結果

問題 No.3121 Prime Dance
コンテスト
ユーザー titia
提出日時 2025-05-10 03:30:49
言語 Rust
(1.83.0 + proconio)
結果
WA  
実行時間 -
コード長 3,633 bytes
コンパイル時間 12,715 ms
コンパイル使用メモリ 404,376 KB
実行使用メモリ 458,496 KB
最終ジャッジ日時 2025-05-10 03:31:17
合計ジャッジ時間 27,698 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge1
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2
other AC * 13 WA * 8
権限があれば一括ダウンロードができます

ソースコード

diff # 

use std::collections::VecDeque;
use std::io::{self, BufRead};

fn sieve(x: usize) -> Vec<bool> {
    let mut is_prime = vec![true; x + 1];
    is_prime[0] = false;
    is_prime[1] = false;
    for i in 2..=x {
        if is_prime[i] {
            let mut j = i * 2;
            while j <= x {
                is_prime[j] = false;
                j += i;
            }
        }
    }
    is_prime
}

fn main() {
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines().map(|l| l.unwrap());

    let prime_limit = 200000;
    let primes = sieve(prime_limit);

    let (h, w): (usize, usize) = {
        let v: Vec<usize> = lines
            .next()
            .unwrap()
            .split_whitespace()
            .map(|s| s.parse().unwrap())
            .collect();
        (v[0], v[1])
    };

    let (sx, sy): (usize, usize) = {
        let v: Vec<usize> = lines
            .next()
            .unwrap()
            .split_whitespace()
            .map(|s| s.parse::<usize>().unwrap() - 1)
            .collect();
        (v[0], v[1])
    };

    let (gx, gy): (usize, usize) = {
        let v: Vec<usize> = lines
            .next()
            .unwrap()
            .split_whitespace()
            .map(|s| s.parse::<usize>().unwrap() - 1)
            .collect();
        (v[0], v[1])
    };

    let map: Vec<Vec<char>> = (0..h).map(|_| lines.next().unwrap().chars().collect()).collect();

    const C: usize = 400;
    let mut visited = vec![vec![vec![vec![false; w]; h]; C]; C];
    let mut q = VecDeque::new();
    q.push_back((0usize, 0usize, sx, sy, 0usize)); // (left, down, x, y, steps)
    visited[0][0][sx][sy] = true;

    let mut ans = usize::MAX;

    while let Some((left, down, x, y, steps)) = q.pop_front() {
        if x == gx && y == gy {
            let right = (gx as isize - sx as isize + left as isize) as usize;
            let up = (gy as isize - sy as isize + down as isize) as usize;

            for dd in 0..100{
                for ll in 0..100{

                    if left + ll < primes.len() && down + dd < primes.len() && right + ll < primes.len() && up + dd < primes.len()
                        && primes[left + ll] && primes[down + dd] && primes[right + ll] && primes[up + dd] {
                        ans = ans.min(steps+dd*2+ll*2);
                    }
                }
            }
        }

        for t in 1..100{
            if left + 2*t<C{
                visited[left + 2*t][down][x][y] = true;
            }
            if down+2*t<C{
                visited[left][down+2*t][x][y] = true;
            }
        }

        // Move up
        if x > 0 && left + 1 < C && map[x - 1][y] != '#' && !visited[left + 1][down][x - 1][y] {
            visited[left + 1][down][x - 1][y] = true;
            q.push_back((left + 1, down, x - 1, y, steps + 1));
        }

        // Move left
        if y > 0 && down + 1 < C && map[x][y - 1] != '#' && !visited[left][down + 1][x][y - 1] {
            visited[left][down + 1][x][y - 1] = true;
            q.push_back((left, down + 1, x, y - 1, steps + 1));
        }

        // Move down
        if x + 1 < h && map[x + 1][y] != '#' && !visited[left][down][x + 1][y] {
            visited[left][down][x + 1][y] = true;
            q.push_back((left, down, x + 1, y, steps + 1));
        }

        // Move right
        if y + 1 < w && map[x][y + 1] != '#' && !visited[left][down][x][y + 1] {
            visited[left][down][x][y + 1] = true;
            q.push_back((left, down, x, y + 1, steps + 1));
        }
    }

    if ans == usize::MAX {
        println!("-1");
    } else {
        println!("{}", ans);
    }
}
0