結果

問題 No.2977 Kth Xor Pair
ユーザー ikdikd
提出日時 2024-12-01 19:03:22
言語 Rust
(1.77.0 + proconio)
結果
TLE  
実行時間 -
コード長 2,855 bytes
コンパイル時間 15,030 ms
コンパイル使用メモリ 379,760 KB
実行使用メモリ 99,072 KB
最終ジャッジ日時 2024-12-01 19:05:14
合計ジャッジ時間 108,289 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
58,368 KB
testcase_01 AC 1 ms
10,496 KB
testcase_02 AC 36 ms
10,624 KB
testcase_03 AC 37 ms
89,728 KB
testcase_04 AC 37 ms
10,624 KB
testcase_05 AC 36 ms
85,632 KB
testcase_06 AC 36 ms
13,764 KB
testcase_07 TLE -
testcase_08 TLE -
testcase_09 TLE -
testcase_10 TLE -
testcase_11 TLE -
testcase_12 TLE -
testcase_13 TLE -
testcase_14 TLE -
testcase_15 TLE -
testcase_16 TLE -
testcase_17 TLE -
testcase_18 TLE -
testcase_19 TLE -
testcase_20 TLE -
testcase_21 TLE -
testcase_22 TLE -
testcase_23 TLE -
testcase_24 TLE -
testcase_25 TLE -
testcase_26 TLE -
testcase_27 AC 2,458 ms
8,448 KB
testcase_28 AC 2,069 ms
8,576 KB
testcase_29 AC 2,110 ms
8,576 KB
testcase_30 AC 2,303 ms
8,448 KB
testcase_31 AC 2,265 ms
8,576 KB
testcase_32 AC 506 ms
5,248 KB
testcase_33 AC 558 ms
5,248 KB
testcase_34 AC 530 ms
5,248 KB
testcase_35 AC 542 ms
99,072 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

use proconio::input;

fn main() {
    input! {
        n: usize,
        k: usize,
        a: [u32; n],
    };

    // ● xor ▲ ≦ x を満たす組の個数
    let count_leq = |x: u32| -> usize {
        let mut res = 0;
        let mut trie = BinaryTrie::new();
        for &a in &a {
            res += trie.query(a, x);
            trie.add(a);
        }
        res
    };

    if count_leq(0) >= k {
        println!("0");
        return;
    }

    // ● xor ▲ ≦ ok が k 個以上ある
    let mut ng = 0;
    let mut ok = u32::MAX / 2;
    while ok - ng > 1 {
        let mid = (ok + ng) / 2;
        if count_leq(mid) >= k {
            ok = mid;
        } else {
            ng = mid;
        }
    }

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

#[derive(Debug, Clone)]
struct Node {
    size: usize,
    children: [Option<Box<Node>>; 2],
}

impl Node {
    fn new() -> Self {
        Self {
            size: 0,
            children: [None, None],
        }
    }
}

#[derive(Debug)]
struct BinaryTrie {
    root: Node,
}

impl BinaryTrie {
    fn new() -> Self {
        Self { root: Node::new() }
    }

    fn add(&mut self, value: u32) {
        let mut node = &mut self.root;
        node.size += 1;
        for i in (0..u32::BITS).rev() {
            let index = (value >> i & 1) as usize;
            node = node.children[index].get_or_insert_with(|| Box::new(Node::new()));
            node.size += 1;
        }
    }

    fn query(&self, a: u32, x: u32) -> usize {
        fn f(node: &Node, k: u32, a: u32, x: u32) -> usize {
            if k == 0 {
                let a_k = (a >> k & 1) as usize;
                if x >> k & 1 == 0 {
                    match &node.children[a_k] {
                        Some(n) => n.size,
                        None => 0,
                    }
                } else {
                    match &node.children {
                        [Some(n), Some(m)] => n.size + m.size,
                        [Some(n), None] => n.size,
                        [None, Some(n)] => n.size,
                        [None, None] => 0,
                    }
                }
            } else {
                let a_k = (a >> k & 1) as usize;
                if x >> k & 1 == 0 {
                    match &node.children[a_k] {
                        Some(n) => f(n, k - 1, a, x),
                        None => 0,
                    }
                } else {
                    let c = match &node.children[a_k] {
                        Some(n) => n.size,
                        None => 0,
                    };
                    let d = match &node.children[a_k ^ 1] {
                        Some(n) => f(n, k - 1, a, x),
                        None => 0,
                    };
                    c + d
                }
            }
        }

        f(&self.root, u32::BITS - 1, a, x)
    }
}
0