#727711 (Rust) No.569 3 x N グリッドのパスの数

• 問題: No.569 3 x N グリッドのパスの数
• ユーザー: koba-e964
• 提出日時: 2022-01-01 23:25:26
• 言語: Rust (1.77.0 + proconio)
• 結果: AC
• 実行時間: 1,244 ms / 2,000 ms
• コード長: 7,489 bytes
• コンパイル時間: 13,475 ms
• コンパイル使用メモリ: 405,804 KB
• 実行使用メモリ: 5,248 KB
• 最終ジャッジ日時: 2024-10-10 17:20:36
• 合計ジャッジ時間: 52,246 ms
• ジャッジサーバーID （参考情報）: judge4 / judge2

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	52 ms; 5,248 KB
testcase_01	AC	53 ms; 5,248 KB
testcase_02	AC	65 ms; 5,248 KB
testcase_03	AC	65 ms; 5,248 KB
testcase_04	AC	77 ms; 5,248 KB
testcase_05	AC	65 ms; 5,248 KB
testcase_06	AC	77 ms; 5,248 KB
testcase_07	AC	78 ms; 5,248 KB
testcase_08	AC	90 ms; 5,248 KB
testcase_09	AC	78 ms; 5,248 KB
testcase_10	AC	90 ms; 5,248 KB
testcase_11	AC	89 ms; 5,248 KB
testcase_12	AC	102 ms; 5,248 KB
testcase_13	AC	77 ms; 5,248 KB
testcase_14	AC	89 ms; 5,248 KB
testcase_15	AC	90 ms; 5,248 KB
testcase_16	AC	102 ms; 5,248 KB
testcase_17	AC	90 ms; 5,248 KB
testcase_18	AC	103 ms; 5,248 KB
testcase_19	AC	102 ms; 5,248 KB
testcase_20	AC	558 ms; 5,248 KB
testcase_21	AC	547 ms; 5,248 KB
testcase_22	AC	557 ms; 5,248 KB
testcase_23	AC	559 ms; 5,248 KB
testcase_24	AC	570 ms; 5,248 KB
testcase_25	AC	545 ms; 5,248 KB
testcase_26	AC	556 ms; 5,248 KB
testcase_27	AC	559 ms; 5,248 KB
testcase_28	AC	569 ms; 5,248 KB
testcase_29	AC	561 ms; 5,248 KB
testcase_30	AC	569 ms; 5,248 KB
testcase_31	AC	572 ms; 5,248 KB
testcase_32	AC	584 ms; 5,248 KB
testcase_33	AC	546 ms; 5,248 KB
testcase_34	AC	559 ms; 5,248 KB
testcase_35	AC	557 ms; 5,248 KB
testcase_36	AC	571 ms; 5,248 KB
testcase_37	AC	556 ms; 5,248 KB
testcase_38	AC	569 ms; 5,248 KB
testcase_39	AC	572 ms; 5,248 KB
testcase_40	AC	1,054 ms; 5,248 KB
testcase_41	AC	1,059 ms; 5,248 KB
testcase_42	AC	1,043 ms; 5,248 KB
testcase_43	AC	1,244 ms; 5,248 KB
testcase_44	AC	1,239 ms; 5,248 KB
testcase_45	AC	1,239 ms; 5,248 KB
testcase_46	AC	1,231 ms; 5,248 KB
testcase_47	AC	1,232 ms; 5,248 KB
testcase_48	AC	1,221 ms; 5,248 KB
testcase_49	AC	1,237 ms; 5,248 KB
testcase_50	AC	1,210 ms; 5,248 KB
testcase_51	AC	1,234 ms; 5,248 KB
testcase_52	AC	1,227 ms; 5,248 KB
testcase_53	AC	1,221 ms; 5,248 KB
testcase_54	AC	1,209 ms; 5,248 KB
testcase_55	AC	1,220 ms; 5,248 KB
testcase_56	AC	1,211 ms; 5,248 KB
testcase_57	AC	1,215 ms; 5,248 KB
testcase_58	AC	1,196 ms; 5,248 KB
testcase_59	AC	1,233 ms; 5,248 KB

ソースコード

use std::io::Read;

fn get_word() -> String {
    let stdin = std::io::stdin();
    let mut stdin=stdin.lock();
    let mut u8b: [u8; 1] = [0];
    loop {
        let mut buf: Vec<u8> = Vec::with_capacity(16);
        loop {
            let res = stdin.read(&mut u8b);
            if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {
                break;
            } else {
                buf.push(u8b[0]);
            }
        }
        if buf.len() >= 1 {
            let ret = String::from_utf8(buf).unwrap();
            return ret;
        }
    }
}

#[allow(dead_code)]
fn get<T: std::str::FromStr>() -> T { get_word().parse().ok().unwrap() }

fn squmul(a: &[Vec<i64>], b: &[Vec<i64>], mo: i64) -> Vec<Vec<i64>> {
    let n = a.len();
    let mut ret = vec![vec![0; n]; n];
    for i in 0..n {
        for j in 0..n {
            for k in 0..n {
                ret[i][k] += a[i][j] * b[j][k];
                ret[i][k] %= mo;
            }
        }
    }
    ret
}

fn squpow(a: &[Vec<i64>], mut e: i64, mo: i64) -> Vec<Vec<i64>> {
    let n = a.len();
    let mut sum = vec![vec![0; n]; n];
    for i in 0..n { sum[i][i] = 1; }
    let mut cur = a.to_vec();
    while e > 0 {
        if e % 2 == 1 {
            sum = squmul(&sum, &cur, mo);
        }
        cur = squmul(&cur, &cur, mo);
        e /= 2;
    }
    sum
}

// Registry.
#[derive(Clone, Default, Debug)]
struct Reg<T> {
    a: Vec<T>,
    inv: std::collections::HashMap<T, usize>,
}

impl<T: Default> Reg<T> {
    pub fn new() -> Self {
        Self::default()
    }
}

impl<T: std::hash::Hash + Eq + Clone> Reg<T> {
    pub fn get(&mut self, t: &T) -> usize {
        if !self.inv.contains_key(t) {
            let idx = self.a.len();
            self.a.push(t.clone());
            self.inv.insert(t.clone(), idx);
        }
        self.inv[t]
    }
    // init must have distinct elements.
    pub fn init<F>(&mut self, init: &[T], f: F) -> Vec<Vec<i64>>
    where F: Fn(T) -> Vec<T> {
        let mut que = std::collections::VecDeque::new();
        for t in init {
            let idx = self.get(t);
            que.push_back(idx);
        }
        let mut n = self.a.len();
        let mut vis = vec![false; n];
        let mut to = vec![vec![]; n];
        while let Some(v) = que.pop_front() {
            if vis[v] { continue; }
            let ans = f(self.a[v].clone());
            let mut entries = vec![];
            for elem in ans {
                let idx = self.get(&elem);
                entries.push(idx);
                if n <= idx {
                    // A newly created entry.
                    n = self.a.len();
                    vis.resize(n, false);
                    to.resize(n, vec![]);
                    que.push_back(idx);
                }
            }
            vis[v] = true;
            to[v] = entries;
        }
        let mut ans = vec![vec![0; n]; n];
        for i in 0..n {
            for &e in &to[i] {
                ans[i][e] += 1;
            }
        }
        ans
    }
}

#[derive(Clone, Default, Debug, Hash, Eq, PartialEq)]
struct State {
    back: i32,
    me: i32,
    uf: Vec<usize>,
    conn: i32,
    one: i32,
}

// For each component, the root is always the maximum element.
fn uf_naive(uf: &mut [usize], x: usize, y: usize) {
    if uf[x] == uf[y] { return; }
    let n = uf.len();
    let r = std::cmp::max(uf[x], uf[y]);
    let other = r ^ uf[x] ^ uf[y];
    for i in 0..n {
        if uf[i] == other {
            uf[i] = r;
        }
    }
}

fn next(s: State) -> Vec<State> {
    let mut ans = vec![];
    for i in 0..16 {
        let back = i;
        for j in 0..8 {
            let me = j;
            // Find the degree of each vertex
            let mut pre = [0; 4];
            let mut now = [0; 4];
            for k in 0..3 {
                if (me & 1 << k) != 0 {
                    now[k] += 1;
                    now[k + 1] += 1;
                }
                if (s.me & 1 << k) != 0 {
                    pre[k] += 1;
                    pre[k + 1] += 1;
                }
            }
            for k in 0..4 {
                if (back & 1 << k) != 0 {
                    now[k] += 1;
                    pre[k] += 1;
                }
                if (s.back & 1 << k) != 0 {
                    pre[k] += 1;
                }
            }
            if pre.iter().any(|&x| x > 2) {
                continue;
            }
            // Connectedness
            let mut nuf = vec![0; 8];
            for k in 0..4 {
                nuf[k] = s.uf[k];
                nuf[k + 4] = k + 4;
            }
            for k in 0..4 {
                if (back & 1 << k) == 0 { continue; }
                // union-find
                uf_naive(&mut nuf, k, k + 4);
            }
            for k in 0..3 {
                if (me & 1 << k) == 0 { continue; }
                // union-find
                uf_naive(&mut nuf, k + 4, k + 5);
            }
            let mut uf = vec![0; 4];
            let mut conn = s.conn;
            let mut one = s.one;
            for k in 0..4 {
                if pre[k] > 0 && nuf[k] == k {
                    conn += 1;
                }
                if one == 0 && pre[k] != 1 {
                    one += 10;
                }
                if pre[k] == 1 {
                    if k != 0 {
                        one += 10;
                    }
                    one += 1;
                }
                uf[k] = nuf[k + 4] - 4;
            }
            if conn == 0 && one <= 2 {
                ans.push(State {
                    back,
                    me,
                    uf,
                    conn,
                    one,
                });
            }
        }
    }
    ans
}

// https://yukicoder.me/problems/no/569 (4)
// 面倒なことで知られる連結性 DP を、行列累乗に変換する。
// 状態は https://yukicoder.me/problems/no/541 とほとんど同じ。
// それに加えて、次数 1 の頂点が今までに何個あったか持てば良い。また、終点が (3, N) であるという条件は終状態に任せて、始点が (0, 0) であるという条件を満たすために、next の内部で
// 「次数 1 の頂点は頂点 0 のみ」という条件を要請すれば良い。
// -> 頂点 (0, ?) であって次数 1 であるものが (0, 0) より後に出現してしまう場合に対応できない。
// 行列累乗に変換する部分はライブラリを書いた。結局この問題の場合は 158 次行列となる。
// Similar-problems: https://yukicoder.me/problems/no/541
// Tags: connectedness-dp, matrix-exponentiation
fn main() {
    const MOD: i64 = 1_000_000_007;
    let n: i64 = get();
    let mut reg = Reg::<State>::new();
    let mut uf = vec![0; 4];
    for i in 0..4 {
        uf[i] = i;
    }
    let init = State { back: 0, me: 0, uf: uf.clone(), conn: 0, one: 0 };
    let term = State { back: 8, me: 0, uf: uf.clone(), conn: 0, one: 1 };
    let mat = reg.init(&[init.clone()], next);
    let idx2 = reg.get(&term);
    eprintln!("M: {} sq", mat.len());
    let pw = squpow(&mat, n + 2, MOD);
    let mut tot = 0;
    for i in 0..reg.a.len() {
        let s = &reg.a[i];
        if s.back == 0 && s.conn == 0 && s.one == 0 {
            eprintln!("s = {:?}", s);
            for v in next(s.clone()) {
                eprintln!(" => {:?}", v);
            }
            tot = (tot + pw[i][idx2]) % MOD;
        }
    }
    println!("{}", tot);
}