結果
問題 | No.1078 I love Matrix Construction |
ユーザー | koba-e964 |
提出日時 | 2020-06-12 23:08:48 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 249 ms / 2,000 ms |
コード長 | 7,336 bytes |
コンパイル時間 | 16,419 ms |
コンパイル使用メモリ | 401,716 KB |
実行使用メモリ | 62,512 KB |
最終ジャッジ日時 | 2024-06-24 05:51:02 |
合計ジャッジ時間 | 18,311 ms |
ジャッジサーバーID (参考情報) |
judge1 / judge4 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,812 KB |
testcase_01 | AC | 1 ms
6,812 KB |
testcase_02 | AC | 25 ms
10,752 KB |
testcase_03 | AC | 82 ms
24,644 KB |
testcase_04 | AC | 130 ms
33,488 KB |
testcase_05 | AC | 114 ms
28,164 KB |
testcase_06 | AC | 26 ms
10,496 KB |
testcase_07 | AC | 10 ms
6,940 KB |
testcase_08 | AC | 119 ms
28,544 KB |
testcase_09 | AC | 5 ms
6,944 KB |
testcase_10 | AC | 249 ms
62,512 KB |
testcase_11 | AC | 140 ms
35,328 KB |
testcase_12 | AC | 230 ms
51,452 KB |
testcase_13 | AC | 228 ms
57,796 KB |
testcase_14 | AC | 182 ms
40,792 KB |
testcase_15 | AC | 224 ms
54,948 KB |
testcase_16 | AC | 7 ms
6,944 KB |
testcase_17 | AC | 1 ms
6,944 KB |
testcase_18 | AC | 21 ms
8,320 KB |
testcase_19 | AC | 53 ms
16,748 KB |
testcase_20 | AC | 48 ms
16,256 KB |
testcase_21 | AC | 3 ms
6,940 KB |
ソースコード
#[allow(unused_imports)] use std::cmp::*; #[allow(unused_imports)] use std::collections::*; use std::io::{Write, BufWriter}; // https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 macro_rules! input { ($($r:tt)*) => { let stdin = std::io::stdin(); let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock())); let mut next = move || -> String{ bytes .by_ref() .map(|r|r.unwrap() as char) .skip_while(|c|c.is_whitespace()) .take_while(|c|!c.is_whitespace()) .collect() }; 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, [graph1; $len:expr]) => {{ let mut g = vec![vec![]; $len]; let ab = read_value!($next, [(usize1, usize1)]); for (a, b) in ab { g[a].push(b); g[b].push(a); } g }}; ($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, [ $t:tt ]) => {{ let len = read_value!($next, usize); read_value!($next, [$t; len]) }}; ($next:expr, $t:ty) => ($next().parse::<$t>().expect("Parse error")); } #[allow(unused)] macro_rules! debug { ($($format:tt)*) => (write!(std::io::stderr(), $($format)*).unwrap()); } #[allow(unused)] macro_rules! debugln { ($($format:tt)*) => (writeln!(std::io::stderr(), $($format)*).unwrap()); } /** * Strong connected components. * Verified by: yukicoder No.470 (http://yukicoder.me/submissions/145785) */ struct SCC { n: usize, ncc: usize, g: Vec<Vec<usize>>, // graph in adjacent list rg: Vec<Vec<usize>>, // reverse graph cmp: Vec<usize>, // topological order } impl SCC { fn new(n: usize) -> Self { SCC { n: n, ncc: n + 1, g: vec![Vec::new(); n], rg: vec![Vec::new(); n], cmp: vec![0; n], } } fn add_edge(&mut self, from: usize, to: usize) { self.g[from].push(to); self.rg[to].push(from); } fn dfs(&self, v: usize, used: &mut [bool], vs: &mut Vec<usize>) { used[v] = true; for &w in self.g[v].iter() { if !used[w] { self.dfs(w, used, vs); } } vs.push(v); } fn rdfs(&self, v: usize, k: usize, used: &mut [bool], cmp: &mut [usize]) { used[v] = true; cmp[v] = k; for &w in self.rg[v].iter() { if !used[w] { self.rdfs(w, k, used, cmp); } } } fn scc(&mut self) -> usize { let n = self.n; let mut used = vec![false; n]; let mut vs = Vec::new(); let mut cmp = vec![0; n]; for v in 0 .. n { if !used[v] { self.dfs(v, &mut used, &mut vs); } } for u in used.iter_mut() { *u = false; } let mut k = 0; for &t in vs.iter().rev() { if !used[t] { self.rdfs(t, k, &mut used, &mut cmp); k += 1; } } self.ncc = k; self.cmp = cmp; k } #[allow(dead_code)] fn top_order(&self) -> Vec<usize> { assert!(self.ncc <= self.n); self.cmp.clone() } /* * Returns a dag whose vertices are scc's, and whose edges are those of the original graph. */ #[allow(dead_code)] fn dag(&self) -> Vec<Vec<usize>> { assert!(self.ncc <= self.n); let ncc = self.ncc; let mut ret = vec![HashSet::new(); ncc]; let n = self.n; for i in 0 .. n { for &to in self.g[i].iter() { if self.cmp[i] != self.cmp[to] { assert!(self.cmp[i] < self.cmp[to]); ret[self.cmp[i]].insert(self.cmp[to]); } } } ret.into_iter().map(|set| set.into_iter().collect()).collect() } #[allow(dead_code)] fn rdag(&self) -> Vec<Vec<usize>> { assert!(self.ncc <= self.n); let ncc = self.ncc; let mut ret = vec![HashSet::new(); ncc]; let n = self.n; for i in 0 .. n { for &to in self.g[i].iter() { if self.cmp[i] != self.cmp[to] { assert!(self.cmp[i] < self.cmp[to]); ret[self.cmp[to]].insert(self.cmp[i]); } } } ret.into_iter().map(|set| set.into_iter().collect()).collect() } } /** * 2-SAT solver. * n: the number of variables (v_1, ..., v_n) * cons: constraints, given in 2-cnf * i (1 <= i <= n) means v_i, -i (1 <= i <= n) means not v_i. * Returns: None if there's no assignment that satisfies cons. * Otherwise, it returns an assignment that safisfies cons. (true: true, false: false) * Dependencies: SCC.rs * Verified by: Codeforces #400 D * (http://codeforces.com/contest/776/submission/24957215) */ fn two_sat(n: usize, cons: &[(i32, i32)]) -> Option<Vec<bool>> { let mut scc = SCC::new(2 * n); let ni = n as i32; for &(c1, c2) in cons.iter() { let x = if c1 > 0 { c1 - 1 + ni } else { -c1 - 1 } as usize; let y = if c2 > 0 { c2 - 1 } else { -c2 - 1 + ni } as usize; scc.add_edge(x, y); scc.add_edge((y + n) % (2 * n), (x + n) % (2 * n)); } scc.scc(); let mut result = vec![false; n]; let top_ord = scc.top_order(); for i in 0 .. n { if top_ord[i] == top_ord[i + n] { return None; } result[i] = top_ord[i] > top_ord[i + n]; } Some(result) } fn solve() { let out = std::io::stdout(); let mut out = BufWriter::new(out.lock()); macro_rules! puts { ($($format:tt)*) => (let _ = write!(out,$($format)*);); } input! { n: usize, s: [usize1; n], t: [usize1; n], u: [i32; n], } let mut cons = vec![]; for i in 0..n { for j in 0..n { let a = (s[i] * n + j + 1) as i32; let b = (j * n + t[i] + 1) as i32; let a = if (u[i] & 1) != 0 { -a } else { a }; let b = if (u[i] & 2) != 0 { -b } else { b }; cons.push((a, b)); } } if let Some(ans) = two_sat(n * n, &cons) { for i in 0..n { for j in 0..n { puts!("{}{}", if ans[i * n + j] { 1 } else { 0 }, if j + 1 == n { "\n" } else { " " }); } } } else { puts!("-1\n"); } } fn main() { // In order to avoid potential stack overflow, spawn a new thread. let stack_size = 104_857_600; // 100 MB let thd = std::thread::Builder::new().stack_size(stack_size); thd.spawn(|| solve()).unwrap().join().unwrap(); }