結果

問題 No.1323 うしらずSwap
ユーザー akakimidoriakakimidori
提出日時 2020-12-20 00:42:25
言語 Rust
(1.77.0 + proconio)
結果
WA  
実行時間 -
コード長 4,720 bytes
コンパイル時間 14,009 ms
コンパイル使用メモリ 393,092 KB
実行使用メモリ 172,160 KB
最終ジャッジ日時 2024-09-21 11:03:08
合計ジャッジ時間 25,486 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
5,248 KB
testcase_01 AC 1 ms
5,376 KB
testcase_02 AC 1 ms
5,376 KB
testcase_03 WA -
testcase_04 AC 1 ms
5,376 KB
testcase_05 WA -
testcase_06 WA -
testcase_07 AC 1 ms
5,376 KB
testcase_08 WA -
testcase_09 WA -
testcase_10 AC 1 ms
5,376 KB
testcase_11 WA -
testcase_12 WA -
testcase_13 AC 1 ms
5,376 KB
testcase_14 AC 1 ms
5,376 KB
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 WA -
testcase_19 WA -
testcase_20 WA -
testcase_21 WA -
testcase_22 WA -
testcase_23 WA -
testcase_24 WA -
testcase_25 WA -
testcase_26 AC 177 ms
171,776 KB
testcase_27 AC 176 ms
172,032 KB
testcase_28 WA -
testcase_29 AC 168 ms
171,776 KB
testcase_30 AC 224 ms
171,776 KB
testcase_31 AC 169 ms
171,648 KB
testcase_32 WA -
testcase_33 AC 264 ms
115,456 KB
testcase_34 AC 252 ms
115,712 KB
testcase_35 AC 249 ms
116,096 KB
testcase_36 AC 239 ms
116,352 KB
testcase_37 AC 239 ms
115,968 KB
testcase_38 AC 241 ms
115,584 KB
testcase_39 AC 244 ms
115,840 KB
testcase_40 AC 251 ms
116,096 KB
testcase_41 AC 245 ms
116,352 KB
testcase_42 AC 283 ms
116,096 KB
testcase_43 WA -
testcase_44 WA -
testcase_45 WA -
testcase_46 WA -
testcase_47 WA -
testcase_48 WA -
testcase_49 WA -
testcase_50 WA -
testcase_51 WA -
testcase_52 WA -
testcase_53 WA -
testcase_54 WA -
testcase_55 WA -
testcase_56 WA -
testcase_57 WA -
testcase_58 WA -
testcase_59 WA -
testcase_60 WA -
testcase_61 AC 2 ms
5,376 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
// 入れ替えさせるパターン
// 到達可能な三叉路を全部試せばいい？

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 1..(h - 1) {
        for j in 1..(w - 1) {
            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 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() {
        ans = ans.min(1 + dp[p.0][p.1].0 + dis);
    }
    if ans >= INF {
        println!("-1");
    } else {
        println!("{}", ans);
    }
}

fn main() {
    run();
}
0