結果

問題 No.1694 ZerOne
ユーザー emakemak
提出日時 2021-10-01 22:07:19
言語 Rust
(1.77.0)
結果
TLE  
実行時間 -
コード長 3,848 bytes
コンパイル時間 3,103 ms
コンパイル使用メモリ 161,036 KB
実行使用メモリ 4,380 KB
最終ジャッジ日時 2023-09-26 17:28:06
合計ジャッジ時間 7,797 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge12
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 0 ms
4,380 KB
testcase_01 AC 1 ms
4,376 KB
testcase_02 AC 1 ms
4,376 KB
testcase_03 TLE -
testcase_04 -- -
testcase_05 -- -
testcase_06 -- -
testcase_07 -- -
testcase_08 -- -
testcase_09 -- -
testcase_10 -- -
testcase_11 -- -
testcase_12 -- -
testcase_13 -- -
testcase_14 -- -
testcase_15 -- -
testcase_16 -- -
testcase_17 -- -
testcase_18 -- -
testcase_19 -- -
testcase_20 -- -
testcase_21 -- -
testcase_22 -- -
testcase_23 -- -
testcase_24 -- -
testcase_25 -- -
testcase_26 -- -
testcase_27 -- -
testcase_28 -- -
testcase_29 -- -
testcase_30 -- -
testcase_31 -- -
testcase_32 -- -
testcase_33 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#![allow(unused_macros, unused_imports)]

use std::collections::{HashMap, HashSet, VecDeque};
macro_rules! dbg {
    ($($xs:expr),+) => {
        if cfg!(debug_assertions) {
            std::dbg!($($xs),+)
        } else {
            ($($xs),+)
        }
    }
}

fn main() {
    input!{
        s: String,
    }

    let n = s.len();
    let s = s.bytes().collect::<Vec<_>>();
    let mut s0 = 0;
    for (i, c) in s.into_iter().enumerate() {
        if c == b'1' {
            s0 += 1<<i;
        }
    }

    let mut hs = HashSet::new();
    hs.insert(s0);
    let mut que = VecDeque::new();
    que.push_back(s0);

    while let Some(x) = que.pop_front() {
        for k in 1..=n/2 {
            for i in 0..=n-2*k {
                let mut mi = 0;
                for p in i..i+k {
                    if x>>p&1 == 1 {
                        mi += 1;
                    }
                }

                for j in i+k..=n-k {
                    let mut mj = 0;
                    for p in j..j+k {
                        if x>>p&1 == 1 {
                            mj += 1;
                        }
                    }

                    dbg!(x, k, i, j, mi, mj);

                    if mi != mj { continue; }
                    
                    let mut y = x;
                    for p in 0..k {
                        if (y>>(i+p)&1) != (y>>(j+p)&1) {
                            y = y ^ ((1<<(i+p)) + (1<<(j+p)));
                        }
                    }

                    if !hs.contains(&y) {
                        hs.insert(y);
                        que.push_back(y);
                    }
                }
            }
        }
    }

    println!("{}", hs.len());
}

pub mod input {
    #[macro_export]
    macro_rules! input{
        (sc=$sc:expr,$($r:tt)*)=>{
            input_inner!{$sc,$($r)*}
        };
        ($($r:tt)*)=>{
            let mut sc=input::Scanner::new(std::io::stdin().lock());
            input_inner!{sc,$($r)*}
        };
    }

    #[macro_export]
    macro_rules! input_inner{
        ($sc:expr)=>{};
        ($sc:expr,)=>{};
        ($sc:expr,$var:ident:$t:tt$($r:tt)*)=>{
            let $var=read_value!($sc,$t);
            input_inner!{$sc $($r)*}
        };
    }

    #[macro_export]
    macro_rules! read_value{
        ($sc:expr,($($t:tt),*))=>{
            ($(read_value!($sc,$t)),*)
        };
        ($sc:expr,[$t:tt;$len:expr])=>{
            (0..$len).map(|_|read_value!($sc,$t)).collect::<Vec<_>>()
        };
        ($sc:expr,[$t:tt])=>{{
            let len = read_value!($sc, usize);
            (0..len).map(|_|read_value!($sc,$t)).collect::<Vec<_>>()
        }};
        ($sc:expr,Chars)=>{read_value!($sc,String).chars().collect::<Vec<char>>()};
        ($sc:expr,Usize1)=>{read_value!($sc,usize)-1};
        ($sc:expr,$t:ty)=>{$sc.next::<$t>()};
    }
    pub struct Scanner {
        s: Box<str>,
        input: std::iter::Peekable<std::str::SplitAsciiWhitespace<'static>>,
    }
    impl Scanner {
        pub fn new<R: std::io::Read>(mut reader: R) -> Self {
            let s = {
                let mut s = String::new();
                reader.read_to_string(&mut s).unwrap();
                s.into_boxed_str()
            };
            let mut sc = Scanner {
                s,
                input: "".split_ascii_whitespace().peekable(),
            };
            use std::mem;
            let s: &'static str = unsafe { mem::transmute(&*sc.s) };
            sc.input = s.split_ascii_whitespace().peekable();
            sc
        }
        #[inline]
        pub fn next<T: std::str::FromStr>(&mut self) -> T
        where
            T::Err: std::fmt::Debug,
        {
            self.input
                .next()
                .unwrap()
                .parse::<T>()
                .expect("Parse error")
        }
    }
}
0