結果

問題 No.1323 うしらずSwap
ユーザー akakimidoriakakimidori
提出日時 2020-12-20 01:00:51
言語 Rust
(1.77.0 + proconio)
結果
AC  
実行時間 325 ms / 3,000 ms
コード長 5,163 bytes
コンパイル時間 13,088 ms
コンパイル使用メモリ 389,120 KB
実行使用メモリ 172,288 KB
最終ジャッジ日時 2024-11-15 09:33:25
合計ジャッジ時間 24,153 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
5,248 KB
testcase_01 AC 1 ms
5,248 KB
testcase_02 AC 1 ms
5,248 KB
testcase_03 AC 1 ms
5,248 KB
testcase_04 AC 1 ms
5,248 KB
testcase_05 AC 1 ms
5,248 KB
testcase_06 AC 1 ms
5,248 KB
testcase_07 AC 1 ms
5,248 KB
testcase_08 AC 1 ms
5,248 KB
testcase_09 AC 1 ms
5,248 KB
testcase_10 AC 1 ms
5,248 KB
testcase_11 AC 1 ms
5,248 KB
testcase_12 AC 1 ms
5,248 KB
testcase_13 AC 1 ms
5,248 KB
testcase_14 AC 1 ms
5,248 KB
testcase_15 AC 1 ms
5,248 KB
testcase_16 AC 179 ms
171,776 KB
testcase_17 AC 302 ms
171,520 KB
testcase_18 AC 178 ms
171,904 KB
testcase_19 AC 315 ms
171,520 KB
testcase_20 AC 179 ms
171,520 KB
testcase_21 AC 179 ms
171,520 KB
testcase_22 AC 306 ms
171,904 KB
testcase_23 AC 180 ms
171,520 KB
testcase_24 AC 325 ms
171,648 KB
testcase_25 AC 180 ms
171,520 KB
testcase_26 AC 176 ms
171,904 KB
testcase_27 AC 177 ms
171,904 KB
testcase_28 AC 191 ms
171,648 KB
testcase_29 AC 163 ms
171,904 KB
testcase_30 AC 223 ms
171,776 KB
testcase_31 AC 163 ms
171,520 KB
testcase_32 AC 255 ms
171,904 KB
testcase_33 AC 267 ms
115,456 KB
testcase_34 AC 254 ms
115,840 KB
testcase_35 AC 251 ms
116,096 KB
testcase_36 AC 240 ms
116,352 KB
testcase_37 AC 240 ms
116,096 KB
testcase_38 AC 243 ms
115,456 KB
testcase_39 AC 245 ms
115,840 KB
testcase_40 AC 249 ms
116,096 KB
testcase_41 AC 249 ms
116,352 KB
testcase_42 AC 242 ms
116,096 KB
testcase_43 AC 162 ms
171,648 KB
testcase_44 AC 192 ms
171,264 KB
testcase_45 AC 186 ms
172,288 KB
testcase_46 AC 197 ms
171,264 KB
testcase_47 AC 170 ms
171,648 KB
testcase_48 AC 178 ms
171,776 KB
testcase_49 AC 228 ms
171,264 KB
testcase_50 AC 189 ms
171,520 KB
testcase_51 AC 140 ms
171,648 KB
testcase_52 AC 159 ms
171,392 KB
testcase_53 AC 234 ms
171,648 KB
testcase_54 AC 160 ms
171,520 KB
testcase_55 AC 226 ms
171,392 KB
testcase_56 AC 145 ms
171,904 KB
testcase_57 AC 253 ms
171,904 KB
testcase_58 AC 2 ms
5,248 KB
testcase_59 AC 2 ms
5,248 KB
testcase_60 AC 2 ms
5,248 KB
testcase_61 AC 1 ms
5,248 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

// ---------- begin input macro ----------
// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
// ---------- end input macro ----------

// 最短経路が2以上あるなら2*dが答え
// 到達不可能なら-1
// 最短経路が1つのみの時
// 脇道があったりすれば2*d+2
// 無い時
// 迂回路を探さねばならん
// これもBFSでいい...?
// ダメ
// #####
// #ST.#
// ##.##
// #####
// とか、6手で交換できるけど迂回路がなくて検知できない
// #######################
// #ST...................#
// ####################.##
// #######################
// みたいなのとかもできる
//
// ###################
// #S................#
// #T###############.#
// #.................#
// ###################
// 迂回させるパターンはこれ
//
// 交換不可能は
// 連結でないorグラフがパスである時
// それ以外はできるはず
// 最小コストはどうするのか
// 最短路が2つ以上あるなら明らか
// 1つの時
// 迂回させるパターンか、どこかで入れ替えさせるパターン
// 迂回させるパターンは頑張ってBFS
// 入れ替えさせるパターン
// 到達可能な三叉路を全部試せばいい？
// WA
// 何がダメか

const INF: usize = 1_000_000_000;

fn bfs(src: (usize, usize), s: &[Vec<u8>]) -> Vec<Vec<(usize, usize, usize, usize)>> {
    let h = s.len();
    let w = s[0].len();
    let mut dp = vec![vec![(INF, 0, 0, 0); w]; h];
    dp[src.0][src.1] = (0, 1, 0, 0);
    let mut q = std::collections::VecDeque::new();
    q.push_back(src);
    while let Some((x, y)) = q.pop_front() {
        let (d, way, _, _) = dp[x][y];
        let d = d + 1;
        for &(nx, ny) in [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)].iter() {
            if s[nx][ny] == b'#' {
                continue;
            }
            if dp[nx][ny].0 > d {
                dp[nx][ny] = (d, way, x, y);
                q.push_back((nx, ny));
            } else if dp[nx][ny].0 == d {
                dp[nx][ny].1 = 2;
            }
        }
    }
    dp
}

fn run() {
    input! {
        h: usize,
        w: usize,
        src: (usize1, usize1),
        dst: (usize1, usize1),
        s: [bytes; h],
    }
    let dp_src = bfs(src, &s);
    let dp_dst = bfs(dst, &s);
    let (dis, way, _, _) = dp_src[dst.0][dst.1];
    if dis >= INF {
        println!("-1");
        return;
    } else if way == 2 {
        println!("{}", 2 * dis);
        return;
    }
    let mut ans = INF;
    for i in 0..h {
        for j in 0..w {
            if dp_src[i][j].0 < INF {
                let mut cnt = 0;
                for p in [(i - 1, j), (i + 1, j), (i, j - 1), (i, j + 1)].iter() {
                    if s[p.0][p.1] == b'.' {
                        cnt += 1;
                    }
                }
                if cnt > 2 {
                    ans = ans.min(2 * dp_src[i][j].0 + 2 * dp_dst[i][j].0 + 4);
                }
            }
        }
    }
    let mut s = s;
    let mut pos = dst;
    while pos != src {
        s[pos.0][pos.1] = b'#';
        let p = dp_src[pos.0][pos.1];
        pos = (p.2, p.3);
    }
    let mut pos = dst;
    while pos != src {
        if pos != dst {
            let (i, j) = pos;
            for &p in [(i - 1, j), (i + 1, j), (i, j - 1), (i, j + 1)].iter() {
                if s[p.0][p.1] == b'.' && p != src {
                    ans = ans.min(2 * dis + 2);
                }
            }
        }
        let p = dp_src[pos.0][pos.1];
        pos = (p.2, p.3);
    }
    let dp = bfs(src, &s);
    for &p in [(dst.0 - 1, dst.1), (dst.0 + 1, dst.1), (dst.0, dst.1 - 1), (dst.0, dst.1 + 1)].iter() {
        if p != src {
            ans = ans.min(1 + dp[p.0][p.1].0 + dis);
        }
    }
    if ans >= INF {
        println!("-1");
    } else {
        println!("{}", ans);
    }
}

fn main() {
    run();
}
0