#1157344 (Rust) No.3496 協力カード当て

• 問題: No.3496 協力カード当て
• ユーザー: t33f
• 提出日時: 2026-04-14 23:05:07
• 言語: Rust (1.94.0 + proconio + num + itertools)
• 結果: RE
• 実行時間: -
• コード長: 4,111 bytes
• コンパイル時間: 8,621 ms
• コンパイル使用メモリ: 213,968 KB
• 実行使用メモリ: 611,268 KB
• スコア: 0
• 平均クエリ数: 18.12
• 最終ジャッジ日時: 2026-04-14 23:54:11
• 合計ジャッジ時間: 8,708 ms
• ジャッジサーバーID （参考情報）: judge3_1 / judge2_0

ファイルパターン	結果
other	WA * 1 RE * 13 MLE * 2

コンパイルメッセージ

warning: unused variable: `id`
  --> src/main.rs:45:9
   |
45 |         id: usize,
   |         ^^ help: if this is intentional, prefix it with an underscore: `_id`
   |
   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

ソースコード

#![allow(unused_imports)]
use proconio::{input_interactive, marker::*};
use itertools::*;

fn wait() -> (usize, usize) {
    input_interactive!{ s: Chars, v: usize, k: usize }
    assert_eq!(s, "COUNT".chars().collect_vec());
    (v, k)
}

fn wait_guess(n_hands: usize) {
    input_interactive!{ _: Chars, _: [usize; n_hands] }
}

fn ask(i: usize) -> (usize, usize) {
    println!("ASK {}", i);
    input_interactive!{ s: Chars, v: usize, k: usize }
    assert_eq!(s, "COUNT".chars().collect_vec());
    (v, k)
}

fn enumerate(n_hands: usize, val_min: usize, rem: usize, val_max: usize,
             acc: &mut Vec<usize>, results: &mut Vec<Vec<usize>>) {
    if acc.len() == n_hands {
        results.push(acc.clone());
    } else if val_min <= val_max {
        acc.push(val_min);
        if rem == 1 {
            enumerate(n_hands, val_min + 1, val_min + 1, val_max, acc, results);
        } else {
            enumerate(n_hands, val_min, rem - 1, val_max, acc, results);
        }
        acc.pop();

        for i in val_min + 1..=val_max {
            acc.push(i);
            enumerate(n_hands, i, i - 1, val_max, acc, results);
            acc.pop();
        }
    }
}

fn main() {
    input_interactive!{
        id: usize,
        n_hands: usize,
        val_max: usize,
        ns: [usize; n_hands],
    }

    let mut results = vec![];
    enumerate(n_hands, 1, 1, val_max, &mut vec![], &mut results);
    eprintln!("{}", results.len());
    for (a, b) in results.iter().tuple_windows() {
        assert!(a < b);
    }

    // for r in &results {
    //     eprintln!("{r:?}");
    // }
    // eprintln!("{ns:?}");

    let p = results.binary_search(&ns).unwrap();
    let repr = {
        let mut nums = vec![];
        let mut p = p;
        let mut n = results.len();
        while n > 0 {
            nums.push(p % val_max);
            p /= val_max;
            n /= val_max;
        }
        assert_eq!(p, 0);
        nums
    };

    eprintln!("pos = {p}, repr = {repr:?}");
    let mut other_repr = vec![];
    let mut counts = vec![None; val_max];
    for i in 0..n_hands * 2 {
        input_interactive!{ s: String }
        if s == "WAIT" {
            let (v, k) = wait();
            other_repr.push(v - 1);
            if counts[v - 1].is_none() {
                counts[v - 1] = Some(k);
            } else {
                assert_eq!(counts[v - 1], Some(k));
            }
        } else {
            assert_eq!(s, "TURN");
            let v = repr[i / 2];
            let (_, k) = ask(v + 1);
            if counts[v].is_none() {
                counts[v] = Some(k);
            } else {
                assert_eq!(counts[v], Some(k));
            }
        }
    }

    let other_ns = {
        let mut idx = 0;
        let mut p = 1;
        for a in other_repr {
            idx += p * a;
            p *= val_max;
        }
        results[idx].clone()
    };

    dbg!(other_ns.clone());

    let more_queries = (0..val_max)
        .filter(|&i| counts[i].is_none())
        .map(|i| i + 1)
        .collect_vec();

    dbg!(more_queries.clone());

    for v in more_queries {
        input_interactive!{ s: String }
        eprintln!("got {s}");
        if s == "WAIT" {
            let (v1, k) = wait();
            assert_eq!(v, v1);
            assert!(counts[v - 1].is_none());
            counts[v - 1] = Some(k);
        } else {
            assert_eq!(s, "TURN");
            let (_, k) = ask(v);
            assert!(counts[v - 1].is_none());
            counts[v - 1] = Some(k);
        }
    }

    for v in ns { if let Some(k) = counts[v - 1].as_mut() { *k -= 1 } }
    for v in other_ns { if let Some(k) = counts[v - 1].as_mut() { *k -= 1 } }

    let mut ans = vec![];
    for i in 1..=val_max {
        if let Some(k) = counts[i - 1] {
            ans.extend(std::iter::repeat(i).take(k));
        }
    }

    {
        input_interactive!{ s: String }
        if s == "WAIT" {
            wait_guess(n_hands);
            input_interactive!{ s: String }
            assert_eq!(s, "TURN");
        }
        println!("GUESS {}", ans.iter().join(" "));
    }
}