結果

問題 No.5005 3-SAT
ユーザー terry_u16terry_u16
提出日時 2022-04-29 17:18:45
言語 Rust
(1.77.0 + proconio)
結果
AC  
実行時間 1,982 ms / 2,000 ms
コード長 11,073 bytes
コンパイル時間 1,716 ms
実行使用メモリ 6,952 KB
スコア 83,953
最終ジャッジ日時 2022-04-29 17:22:13
合計ジャッジ時間 206,913 ms
ジャッジサーバーID
（参考情報） 		judge11 / judge15
純コード判定しない問題か言語
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1,982 ms
3,116 KB
testcase_01 AC 1,982 ms
3,116 KB
testcase_02 AC 1,982 ms
5,160 KB
testcase_03 AC 1,982 ms
4,904 KB
testcase_04 AC 1,980 ms
4,904 KB
testcase_05 AC 1,981 ms
4,904 KB
testcase_06 AC 1,982 ms
4,904 KB
testcase_07 AC 1,982 ms
5,164 KB
testcase_08 AC 1,982 ms
4,904 KB
testcase_09 AC 1,981 ms
4,904 KB
testcase_10 AC 1,982 ms
4,904 KB
testcase_11 AC 1,982 ms
4,900 KB
testcase_12 AC 1,982 ms
4,900 KB
testcase_13 AC 1,982 ms
4,900 KB
testcase_14 AC 1,982 ms
4,900 KB
testcase_15 AC 1,980 ms
4,900 KB
testcase_16 AC 1,982 ms
5,156 KB
testcase_17 AC 1,982 ms
4,900 KB
testcase_18 AC 1,981 ms
4,904 KB
testcase_19 AC 1,982 ms
4,904 KB
testcase_20 AC 1,981 ms
5,160 KB
testcase_21 AC 1,982 ms
5,164 KB
testcase_22 AC 1,982 ms
4,904 KB
testcase_23 AC 1,981 ms
4,908 KB
testcase_24 AC 1,981 ms
2,988 KB
testcase_25 AC 1,981 ms
4,904 KB
testcase_26 AC 1,982 ms
5,164 KB
testcase_27 AC 1,982 ms
5,160 KB
testcase_28 AC 1,982 ms
4,908 KB
testcase_29 AC 1,982 ms
4,900 KB
testcase_30 AC 1,980 ms
2,964 KB
testcase_31 AC 1,982 ms
4,900 KB
testcase_32 AC 1,982 ms
4,904 KB
testcase_33 AC 1,982 ms
4,900 KB
testcase_34 AC 1,982 ms
4,900 KB
testcase_35 AC 1,981 ms
4,904 KB
testcase_36 AC 1,981 ms
4,900 KB
testcase_37 AC 1,982 ms
5,160 KB
testcase_38 AC 1,982 ms
4,900 KB
testcase_39 AC 1,982 ms
3,116 KB
testcase_40 AC 1,981 ms
5,156 KB
testcase_41 AC 1,981 ms
4,900 KB
testcase_42 AC 1,981 ms
4,900 KB
testcase_43 AC 1,982 ms
4,904 KB
testcase_44 AC 1,982 ms
5,160 KB
testcase_45 AC 1,982 ms
4,900 KB
testcase_46 AC 1,981 ms
5,160 KB
testcase_47 AC 1,982 ms
4,904 KB
testcase_48 AC 1,981 ms
5,160 KB
testcase_49 AC 1,982 ms
4,904 KB
testcase_50 AC 1,982 ms
4,900 KB
testcase_51 AC 1,981 ms
4,900 KB
testcase_52 AC 1,982 ms
5,156 KB
testcase_53 AC 1,982 ms
4,900 KB
testcase_54 AC 1,981 ms
4,904 KB
testcase_55 AC 1,982 ms
4,904 KB
testcase_56 AC 1,981 ms
4,904 KB
testcase_57 AC 1,982 ms
4,900 KB
testcase_58 AC 1,982 ms
5,160 KB
testcase_59 AC 1,982 ms
4,900 KB
testcase_60 AC 1,981 ms
4,904 KB
testcase_61 AC 1,981 ms
5,160 KB
testcase_62 AC 1,982 ms
4,904 KB
testcase_63 AC 1,982 ms
5,156 KB
testcase_64 AC 1,982 ms
4,904 KB
testcase_65 AC 1,982 ms
5,160 KB
testcase_66 AC 1,981 ms
4,900 KB
testcase_67 AC 1,982 ms
4,904 KB
testcase_68 AC 1,982 ms
6,948 KB
testcase_69 AC 1,981 ms
4,904 KB
testcase_70 AC 1,982 ms
4,900 KB
testcase_71 AC 1,982 ms
4,904 KB
testcase_72 AC 1,981 ms
6,948 KB
testcase_73 AC 1,981 ms
4,900 KB
testcase_74 AC 1,982 ms
4,904 KB
testcase_75 AC 1,982 ms
4,904 KB
testcase_76 AC 1,982 ms
6,948 KB
testcase_77 AC 1,981 ms
4,904 KB
testcase_78 AC 1,981 ms
4,900 KB
testcase_79 AC 1,982 ms
4,904 KB
testcase_80 AC 1,982 ms
4,900 KB
testcase_81 AC 1,982 ms
4,904 KB
testcase_82 AC 1,980 ms
4,900 KB
testcase_83 AC 1,982 ms
4,904 KB
testcase_84 AC 1,981 ms
6,952 KB
testcase_85 AC 1,982 ms
6,948 KB
testcase_86 AC 1,982 ms
6,952 KB
testcase_87 AC 1,981 ms
4,908 KB
testcase_88 AC 1,981 ms
4,900 KB
testcase_89 AC 1,982 ms
4,908 KB
testcase_90 AC 1,981 ms
4,900 KB
testcase_91 AC 1,982 ms
4,900 KB
testcase_92 AC 1,980 ms
4,904 KB
testcase_93 AC 1,981 ms
6,948 KB
testcase_94 AC 1,982 ms
4,904 KB
testcase_95 AC 1,982 ms
6,948 KB
testcase_96 AC 1,981 ms
6,952 KB
testcase_97 AC 1,981 ms
6,952 KB
testcase_98 AC 1,982 ms
4,908 KB
testcase_99 AC 1,982 ms
4,900 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
warning: field is never read: `since`
   --> Main.rs:116:5
    |
116 |     since: Instant,
    |     ^^^^^^^^^^^^^^
    |
    = note: `#[warn(dead_code)]` on by default

warning: 1 warning emitted

ソースコード

diff # 

use std::time::Instant;

macro_rules! get {
      ($t:ty) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.trim().parse::<$t>().unwrap()
          }
      };
      ($($t:ty),*) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              let mut iter = line.split_whitespace();
              (
                  $(iter.next().unwrap().parse::<$t>().unwrap(),)*
              )
          }
      };
      ($t:ty; $n:expr) => {
          (0..$n).map(|_|
              get!($t)
          ).collect::<Vec<_>>()
      };
      ($($t:ty),*; $n:expr) => {
          (0..$n).map(|_|
              get!($($t),*)
          ).collect::<Vec<_>>()
      };
      ($t:ty ;;) => {
          {
              let mut line: String = String::new();
              std::io::stdin().read_line(&mut line).unwrap();
              line.split_whitespace()
                  .map(|t| t.parse::<$t>().unwrap())
                  .collect::<Vec<_>>()
          }
      };
      ($t:ty ;; $n:expr) => {
          (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()
      };
}

#[allow(unused_macros)]
macro_rules! chmin {
    ($base:expr, $($cmps:expr),+ $(,)*) => {{
        let cmp_min = min!($($cmps),+);
        if $base > cmp_min {
            $base = cmp_min;
            true
        } else {
            false
        }
    }};
}

#[allow(unused_macros)]
macro_rules! chmax {
    ($base:expr, $($cmps:expr),+ $(,)*) => {{
        let cmp_max = max!($($cmps),+);
        if $base < cmp_max {
            $base = cmp_max;
            true
        } else {
            false
        }
    }};
}

#[allow(unused_macros)]
macro_rules! min {
    ($a:expr $(,)*) => {{
        $a
    }};
    ($a:expr, $b:expr $(,)*) => {{
        std::cmp::min($a, $b)
    }};
    ($a:expr, $($rest:expr),+ $(,)*) => {{
        std::cmp::min($a, min!($($rest),+))
    }};
}

#[allow(unused_macros)]
macro_rules! max {
    ($a:expr $(,)*) => {{
        $a
    }};
    ($a:expr, $b:expr $(,)*) => {{
        std::cmp::max($a, $b)
    }};
    ($a:expr, $($rest:expr),+ $(,)*) => {{
        std::cmp::max($a, max!($($rest),+))
    }};
}

#[allow(unused_macros)]
macro_rules! mat {
    ($e:expr; $d:expr) => { vec![$e; $d] };
    ($e:expr; $d:expr $(; $ds:expr)+) => { vec![mat![$e $(; $ds)*]; $d] };
}

#[derive(Debug, Clone, Copy)]
struct Requirement {
    digit: usize,
    value: usize,
}

#[derive(Debug, Clone)]
struct Choice {
    requirements: [Requirement; 3],
}

#[derive(Debug, Clone)]
struct Input {
    since: Instant,
    choices: Vec<Choice>,
}

const CHOICES_COUNT: usize = 2048;
const DIGIT_LEN: usize = 256;
const TIME_LIMIT: f64 = 1.98;

fn main() {
    let input = read_input();
    let solution = solve(&input);
    write_output(&solution);
}

fn read_input() -> Input {
    let mut choices = vec![];
    let mut counts = vec![0; DIGIT_LEN];

    for _ in 0..CHOICES_COUNT {
        let (a, b, c, p, q, r) = get!(usize, usize, usize, usize, usize, usize);

        counts[a] += 1;
        counts[b] += 1;
        counts[c] += 1;

        let requirements = [
            Requirement { digit: a, value: p },
            Requirement { digit: b, value: q },
            Requirement { digit: c, value: r },
        ];
        let choice = Choice { requirements };

        choices.push(choice);
    }

    // TODO: 重なるケースとか真面目に見た方がいいかも
    for choice in choices.iter_mut() {
        choice
            .requirements
            .sort_unstable_by(|r0, r1| counts[r0.digit].cmp(&counts[r1.digit]));
    }

    let since = Instant::now();
    let input = Input { since, choices };
    input
}

fn solve(input: &Input) -> Vec<usize> {
    let init_solution = vec![0; CHOICES_COUNT];
    let solution = annealing(input, init_solution, TIME_LIMIT);
    to_answer(input, &solution)
}

fn annealing(input: &Input, initial_solution: Vec<usize>, duration: f64) -> Vec<usize> {
    let mut solution = initial_solution;
    let mut best_solution = solution.clone();
    let mut current_score = calc_score(input, &solution);
    let mut best_score = current_score;

    let mut all_iter = 0;
    let mut valid_iter = 0;
    let mut accepted_count = 0;
    let mut update_count = 0;
    let mut rng = Xorshift::with_seed(42);

    let duration_inv = 1.0 / duration;
    let since = std::time::Instant::now();
    let mut time = 0.0;

    let temp0 = 1e1;
    let temp1 = 1e-1;
    let mut inv_temp = 1.0 / temp0;

    while time < 1.0 {
        all_iter += 1;
        if (all_iter & ((1 << 4) - 1)) == 0 {
            time = (std::time::Instant::now() - since).as_secs_f64() * duration_inv;
            let temp = f64::powf(temp0, 1.0 - time) * f64::powf(temp1, time);
            inv_temp = 1.0 / temp;
        }

        if rng.rand(10) != 0 {
            // 変形
            let index = if (current_score as usize) < CHOICES_COUNT && rng.rand(20) == 0 {
                current_score as usize
            } else {
                rng.rand((best_score as usize + 50).min(CHOICES_COUNT))
            };

            let add = rng.rand(2) + 1;
            solution[index] = (solution[index] + add) % 3;

            // スコア計算
            let new_score = calc_score(input, &solution);
            let score_diff = new_score - current_score;

            if score_diff >= 0 || rng.randf() < f64::exp(score_diff as f64 * inv_temp) {
                // 解の更新
                current_score = new_score;
                accepted_count += 1;

                if chmax!(best_score, current_score) {
                    best_solution = solution.clone();
                    update_count += 1;
                }
            } else {
                // ロールバック
                solution[index] = (solution[index] + 3 - add) % 3;
            }
        } else {
            let mut stack = vec![];

            let index = current_score as usize;
            let add = rng.rand(2) + 1;
            let new_choice = (solution[index] + add) % 3;
            solution[index] = new_choice;
            stack.push((index, add));
            let base_req = &input.choices[index].requirements[new_choice];

            let mut used = [false; DIGIT_LEN];
            let mut values = [0; DIGIT_LEN];

            for (sol, choice) in solution[..(index + 1)].iter().zip(input.choices.iter()) {
                let req = &choice.requirements[*sol];

                if !used[req.digit] {
                    used[req.digit] = true;
                    values[req.digit] = req.value;
                }
            }

            let mut candidates = vec![];

            for index in 0..(current_score as usize) {
                let reqs = &input.choices[index].requirements;
                let req = &reqs[solution[index]];

                if req.digit == base_req.digit && req.value != base_req.value {
                    candidates.clear();

                    for (i, req) in reqs.iter().enumerate() {
                        if req.digit == base_req.digit && req.value != base_req.value {
                            candidates.push(i);
                        } else {
                            candidates.push(i);
                            candidates.push(i);
                        }
                    }

                    let new_choice = candidates[rng.rand(candidates.len())];
                    let add = (new_choice + 3 - solution[index]) % 3;
                    solution[index] = new_choice;
                    stack.push((index, add));
                }
            }

            // スコア計算
            let new_score = calc_score(input, &solution);
            let score_diff = new_score - current_score;

            if score_diff >= 0 || rng.randf() < f64::exp(score_diff as f64 * inv_temp) {
                // 解の更新
                current_score = new_score;
                accepted_count += 1;

                if chmax!(best_score, current_score) {
                    best_solution = solution.clone();
                    update_count += 1;
                }
            } else {
                // ロールバック
                while let Some((i, add)) = stack.pop() {
                    solution[i] = (solution[i] + 3 - add) % 3;
                }
            }
        }

        valid_iter += 1;
    }

    eprintln!("===== annealing =====");
    eprintln!("score      : {}", best_score);
    eprintln!("all iter   : {}", all_iter);
    eprintln!("valid iter : {}", valid_iter);
    eprintln!("accepted   : {}", accepted_count);
    eprintln!("updated    : {}", update_count);
    eprintln!("");
    eprintln!("score: {}", best_score);

    best_solution
}

fn calc_score(input: &Input, solution: &[usize]) -> i32 {
    let mut used = [false; DIGIT_LEN];
    let mut values = [0; DIGIT_LEN];

    for (i, (solution, choice)) in solution.iter().zip(input.choices.iter()).enumerate() {
        let req = choice.requirements[*solution];
        if used[req.digit] && values[req.digit] != req.value {
            return i as i32;
        }

        used[req.digit] = true;
        values[req.digit] = req.value;
    }

    CHOICES_COUNT as i32
}

fn to_answer(input: &Input, solution: &[usize]) -> Vec<usize> {
    let mut used = [false; DIGIT_LEN];
    let mut values = vec![0; DIGIT_LEN];

    for (solution, choice) in solution.iter().zip(input.choices.iter()) {
        let req = choice.requirements[*solution];
        if used[req.digit] && values[req.digit] != req.value {
            return values;
        }

        used[req.digit] = true;
        values[req.digit] = req.value;
    }

    values
}

fn write_output(solution: &[usize]) {
    let mut result = String::new();

    for v in solution.iter().rev() {
        if *v == 0 {
            result.push('0');
        } else {
            result.push('1');
        }
    }

    println!("{}", result);
}

#[derive(Debug)]
#[allow(dead_code)]
pub struct Xorshift {
    seed: usize,
}
impl Xorshift {
    #[allow(dead_code)]
    pub fn new() -> Xorshift {
        Xorshift {
            seed: 0xf0fb588ca2196dac,
        }
    }
    #[allow(dead_code)]
    pub fn with_seed(seed: usize) -> Xorshift {
        Xorshift { seed: seed }
    }
    #[inline]
    #[allow(dead_code)]
    pub fn next(&mut self) -> usize {
        self.seed = self.seed ^ (self.seed << 13);
        self.seed = self.seed ^ (self.seed >> 7);
        self.seed = self.seed ^ (self.seed << 17);
        self.seed
    }
    #[inline]
    #[allow(dead_code)]
    pub fn rand(&mut self, m: usize) -> usize {
        self.next() % m
    }
    #[inline]
    #[allow(dead_code)]
    // 0.0 ~ 1.0
    pub fn randf(&mut self) -> f64 {
        use std::mem;
        const UPPER_MASK: usize = 0x3FF0000000000000;
        const LOWER_MASK: usize = 0xFFFFFFFFFFFFF;
        let tmp = UPPER_MASK | (self.next() & LOWER_MASK);
        let result: f64 = unsafe { mem::transmute(tmp) };
        result - 1.0
    }
}
0