#1016138 (Rust) No.2918 Divide Applicants Fairly

• 問題: No.2918 Divide Applicants Fairly
• ユーザー: ArcAki
• 提出日時: 2024-10-08 13:11:21
• 言語: Rust (1.83.0 + proconio)
• 結果: WA
• 実行時間: -
• コード長: 3,832 bytes
• コンパイル時間: 13,606 ms
• コンパイル使用メモリ: 402,288 KB
• 実行使用メモリ: 10,112 KB
• 最終ジャッジ日時: 2024-10-08 13:11:44
• 合計ジャッジ時間: 19,951 ms
• ジャッジサーバーID （参考情報）: judge5 / judge2

ファイルパターン	結果
sample	AC * 3
other	AC * 43 WA * 18

ソースコード

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#[allow(unused_imports)]
use std::{collections::
          {HashSet, HashMap, BinaryHeap, VecDeque, BTreeSet, BTreeMap},
          mem::{swap},
          cmp::{Reverse, Ordering, PartialOrd, PartialEq},
          fmt::{Debug},
          time::Instant};
//#[allow(unused_imports)]
//use rand::{Rng, thread_rng, seq::{SliceRandom, IndexedRandom}};
use std::io::{Read, BufReader, stdin};
struct InputReader<R: Read> {
    bytes: std::iter::Peekable<std::io::Bytes<BufReader<R>>>,
}
impl<R: Read> InputReader<R> {
    fn new(reader: R) -> Self {
        let reader = BufReader::new(reader);
        let bytes = reader.bytes().peekable();
        Self { bytes }
    }
    fn next_token(&mut self) -> String {
        self.bytes
            .by_ref()
            .map(|r| r.unwrap() as char)
            .take_while(|c| !c.is_whitespace())
            .collect()
    }
}
macro_rules! input {
    ($reader:expr, $($r:tt)*) => {
        let mut next = || $reader.next_token();
        input_inner!{next, $($r)*}
    };
}
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};
    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };
    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };
    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };
    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };
    ($next:expr, usize) => {
        $next().parse::<usize>().expect("Parse error")
    };
    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
fn main() {
    let stdin = stdin();
    let mut reader = InputReader::new(stdin.lock());
    input!{
        reader,
        n: usize,
        r: [i64; n],
    }
    if n > 25{
        println!("0");
        return;
    }
    let h1 = &r[..n/2];
    let h2 = &r[n/2..];
    let mut ans = 1<<60;
    let mut set1 = BTreeSet::new();
    let mut set2 = BTreeSet::new();
    let mut set3 = BTreeSet::new();
    for i in 0..3i64.pow(h1.len() as u32){
        let mut z = 0;
        let mut x = i;
        let (mut f1, mut f2) = (false, false);
        for j in 0..h1.len(){
            if x%3==0{
                f1 = true;
                z += h1[j];
            } else if x%3==1{
                f2 = true;
                z -= h1[j];
            }
            x /= 3;
        }
        if f1 && f2{
            set1.insert(z);
        } else if f1{
            set2.insert(z);
        } else {
            set3.insert(z);
        }
    }
    for i in 0..3i64.pow(h2.len() as u32){
        let mut z = 0;
        let mut x = i;
        let (mut f1, mut f2) = (false, false);
        for j in 0..h2.len(){
            if x%3==0{
                f1 = true;
                z -= h2[j];
            } else if x%3==1{
                f2 = true;
                z += h2[j];
            }
            x /= 3;
        }
        if let Some(&w) = set1.range(z..).next(){
            ans = ans.min(w-z);
        }
        if let Some(&w) = set1.range(..z).next_back(){
            ans = ans.min(z-w);
        }
        if f1{
            if let Some(&w) = set3.range(z..).next(){
                ans = ans.min(w-z);
            }
            if let Some(&w) = set3.range(..z).next_back(){
                ans = ans.min(z-w);
            }
        }
        if f2{
            if let Some(&w) = set2.range(z..).next(){
                ans = ans.min(w-z);
            }
            if let Some(&w) = set2.range(..z).next_back(){
                ans = ans.min(z-w);
            }
        }
    }
    println!("{}", ans);
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX