Submission #1839613
Source Code Expand
#[allow(unused_macros)]
macro_rules! debug {
($($e:expr), *) => {println!(concat!($(stringify!($e), " = {:?}\n"), *), $($e), *)}
}
fn main() {
let (n, _) = get::tuple::<usize,usize>();
let vlss = {
let mut buf = vec![];
for i in 0 .. n {
let kls = get::list::<usize>();
let ls = kls[1..].iter().map(|&l|l+n).collect::<Vec<_>>();
buf.push((i+1,ls))
}
buf
};
let mut es = vec![];
for (v, ls) in vlss {
for l in ls {
es.push((v,l))
}
}
use std::collections::HashSet;
let g = Graph::new_nonlabeled(n+100000, &es);
let connected = g.dfs(1).into_iter().filter(|&v|v<=n).collect::<HashSet<_>>();
let vs = (1..n+1).collect::<HashSet<usize>>();
let ans = if connected == vs {"YES"} else {"NO"};
println!("{}", ans)
}
struct Graph {
size: usize,
adj: Vec<Vec<(usize, isize)>>
}
impl Clone for Graph {
fn clone(&self) -> Graph {
Graph {
size: self.size,
adj: self.adj.clone()
}
}
}
#[allow(dead_code)]
impl Graph {
fn new_nonlabeled(n: usize, edges: &[(usize, usize)]) -> Graph {
let edges = edges.iter().map(|&(a,b)|(a,b,1)).collect::<Vec<_>>();
Graph::new_labeled(n, &edges)
}
fn new_labeled(n: usize, edges: &[(usize, usize, isize)]) -> Graph {
let mut g: Vec<Vec<(usize, isize)>> = vec![vec![]; n+1];
for &(a, b, c) in edges {
g[a].push((b,c));
g[b].push((a,c)); // delete for digraph
}
Graph {size: n, adj: g}
}
fn edges(&self) -> Vec<(usize, usize, isize)> {
let mut buf = vec![];
for (i, next) in self.adj.iter().enumerate() {
for &(j, x) in next {
buf.push((i, j, x))
}
}
buf
}
fn is_adjacent(&self, u: usize, v: usize) -> bool {
self.adj[u].iter().any(|&(w,_)|w==v) || self.adj[v].iter().any(|&(w,_)|w==u)
}
fn is_connected(&self) -> bool {
self.dfs(1).len() == self.size
}
fn is_hitofude(&self) -> bool {
let deg_odd = self.adj.iter().filter(|vs|vs.len()%2==1).count();
deg_odd == 0 || deg_odd == 2
}
fn bellman_ford(&self, s: usize) -> Vec<isize> {
const INF: isize = std::isize::MAX >> 1;
let edges = self.edges();
let mut bf: Vec<isize> = vec![INF; self.size];
bf[s] = 0;
for _ in 1 .. self.size {
for &(v, w, c) in &edges {
bf[w] = std::cmp::min(bf[w], bf[v]+c)
}
}
bf
}
fn dijkstra(&self, s: usize) -> Vec<isize> {
use std::collections::BinaryHeap;
const INF: isize = std::isize::MAX;
let mut dk: Vec<isize> = vec![INF; self.size];
dk[s] = 0;
let mut pq = BinaryHeap::new();
pq.push((0,s));
while let Some((acc,v)) = pq.pop() {
let acc = -acc;
for &(w,c) in &self.adj[v] {
let cand = acc + c;
if cand < dk[w] {
dk[w] = cand;
pq.push((-cand,w));
}
}
}
dk
}
fn warshall_floyd(&self) -> Vec<Vec<isize>> {
const INF: isize = std::isize::MAX >> 1;
let mut wf: Vec<Vec<isize>> = vec![vec![INF; self.size+1]; self.size+1];
for i in 1 .. self.size+1 {wf[i][i] = 0}
for (next, i) in self.adj.iter().zip(0..) {
for &(j, x) in next {
wf[i][j] = x
}
}
for k in 1 .. self.size+1 {
for i in 1 .. self.size+1 {
for j in 1 .. self.size+1 {
wf[i][j] = std::cmp::min(wf[i][j], wf[i][k] + wf[k][j]);
}
}
}
wf
}
fn coloring2(&self) -> Option<(Vec<usize>, Vec<usize>)> {
fn paint(v: usize, p: bool, g: &Graph, cv: &mut Vec<Option<bool>>) -> bool {
match cv[v] {
None => {
let next = &g.adj[v];
cv[v] = Some(p);
next.iter().all(|&(w,_)|paint(w,!p,g,cv))},
Some(q) => {q == p}
}
}
let mut canvas: Vec<Option<bool>> = vec![None; self.size+1];
let ans = paint(1, false, self, &mut canvas);
let bs = canvas.iter().enumerate().filter(|&(_,&v)|v==Some(false)).map(|(i,_)|i).collect::<Vec<_>>();
let ws = canvas.iter().enumerate().filter(|&(_,&v)|v==Some(true)).map(|(i,_)|i).collect::<Vec<_>>();
if ans {Some((bs,ws))} else {None}
}
fn dfs(&self, s: usize) -> Vec<usize> {
fn go(g: &Graph, current: usize, mut path: &mut Vec<usize>, mut visited: &mut Vec<bool>) {
for &(next, _) in &g.adj[current] {
if visited[next] {
continue
} else {
visited[next] = true;
path.push(next);
go(&g, next, &mut path, &mut visited)
}
}
}
let mut path = vec![s];
let mut visited = vec![false; self.size+1];
visited[s] = true;
go(&self, s, &mut path, &mut visited);
path
}
fn bfs(&self, v: usize) -> Vec<usize> {
use std::collections::VecDeque;
let mut q = VecDeque::new();
let mut buf = vec![];
let mut vd = vec![false; self.size+1];
vd[v] = true;
q.push_back(v);
while let Some(w) = q.pop_front() {
buf.push(w);
for &(next,_) in self.adj[w].iter() {
if !vd[next] {
q.push_back(next);
vd[next] = true
}
}
}
buf
}
fn ultimate(&self, v: usize) -> usize {
use std::collections::VecDeque;
let mut q = VecDeque::new();
let mut dist = 0;
let mut vd = vec![false; self.size+1];
vd[v] = true;
q.push_back((v,dist));
while let Some((w, d)) = q.pop_front() {
dist = std::cmp::max(dist, d);
for &(next,_) in self.adj[w].iter() {
if !vd[next] {
q.push_back((next, d+1));
vd[next] = true
}
}
}
dist
}
fn cut(&mut self, v: usize, w: usize) {
self.adj[v].retain(|&(t,_)| t != w);
self.adj[w].retain(|&(t,_)| t != v);
}
}
#[allow(dead_code)]
mod get {
use std::io::*;
use std::str::*;
pub fn val<T: FromStr>() -> T {
let mut buf = String::new();
let s = stdin();
s.lock().read_line(&mut buf).ok();
buf.trim_right().parse::<T>().ok().unwrap()
}
pub fn vals<T: FromStr>(n: usize) -> Vec<T> {
let mut vec: Vec<T> = vec![];
for _ in 0 .. n {
vec.push(val());
}
vec
}
pub fn tuple<T1: FromStr, T2: FromStr>() -> (T1, T2) {
let mut buf = String::new();
let s = stdin();
s.lock().read_line(&mut buf).ok();
let mut it = buf.trim_right().split_whitespace();
let x = it.next().unwrap().parse::<T1>().ok().unwrap();
let y = it.next().unwrap().parse::<T2>().ok().unwrap();
(x, y)
}
pub fn tuples<T1: FromStr, T2: FromStr>(n: usize) -> Vec<(T1, T2)> {
let mut vec: Vec<(T1, T2)> = vec![];
for _ in 0 .. n {
vec.push(tuple());
}
vec
}
pub fn tuple3<T1: FromStr, T2: FromStr, T3: FromStr>() -> (T1, T2, T3) {
let mut buf = String::new();
let s = stdin();
s.lock().read_line(&mut buf).ok();
let mut it = buf.trim_right().split_whitespace();
let x = it.next().unwrap().parse::<T1>().ok().unwrap();
let y = it.next().unwrap().parse::<T2>().ok().unwrap();
let z = it.next().unwrap().parse::<T3>().ok().unwrap();
(x, y, z)
}
pub fn tuple3s<T1: FromStr, T2: FromStr, T3: FromStr>(n: usize) -> Vec<(T1, T2, T3)> {
let mut vec: Vec<(T1, T2, T3)> = vec![];
for _ in 0 .. n {
vec.push(tuple3());
}
vec
}
pub fn list<T: FromStr>() -> Vec<T> {
let mut buf = String::new();
let s = stdin();
s.lock().read_line(&mut buf).ok();
buf.trim_right().split_whitespace().map(|t| t.parse::<T>().ok().unwrap()).collect()
}
pub fn lists<T: FromStr>(h: usize) -> Vec<Vec<T>> {
let mut mat: Vec<Vec<T>> = vec![];
for _ in 0 .. h {
mat.push(list());
}
mat
}
pub fn chars() -> Vec<char> {
let mut buf = String::new();
let s = stdin();
s.lock().read_line(&mut buf).ok();
buf.trim_right().chars().collect()
}
}
Submission Info
Submission Time |
|
Task |
C - Interpretation |
User |
aimy |
Language |
Rust (1.15.1) |
Score |
400 |
Code Size |
8046 Byte |
Status |
AC |
Exec Time |
70 ms |
Memory |
27884 KB |
Judge Result
Set Name |
sample |
dataset1 |
dataset2 |
Score / Max Score |
0 / 0 |
200 / 200 |
200 / 200 |
Status |
|
|
|
Set Name |
Test Cases |
sample |
sample-01.txt, sample-02.txt |
dataset1 |
sample-01.txt, sample-02.txt, 01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt, 01-09.txt, 01-10.txt |
dataset2 |
sample-01.txt, sample-02.txt, 01-01.txt, 01-02.txt, 01-03.txt, 01-04.txt, 01-05.txt, 01-06.txt, 01-07.txt, 01-08.txt, 01-09.txt, 01-10.txt, 02-01.txt, 02-02.txt, 02-03.txt, 02-04.txt, 02-05.txt, 02-06.txt, 02-07.txt, 02-08.txt, 02-09.txt, 02-10.txt, 02-11.txt, 02-12.txt, 02-13.txt, sample-01.txt, sample-02.txt |
Case Name |
Status |
Exec Time |
Memory |
01-01.txt |
AC |
3 ms |
8444 KB |
01-02.txt |
AC |
4 ms |
8444 KB |
01-03.txt |
AC |
4 ms |
8444 KB |
01-04.txt |
AC |
4 ms |
8444 KB |
01-05.txt |
AC |
4 ms |
8444 KB |
01-06.txt |
AC |
4 ms |
8444 KB |
01-07.txt |
AC |
4 ms |
8444 KB |
01-08.txt |
AC |
4 ms |
8444 KB |
01-09.txt |
AC |
4 ms |
8444 KB |
01-10.txt |
AC |
4 ms |
8444 KB |
02-01.txt |
AC |
26 ms |
20684 KB |
02-02.txt |
AC |
65 ms |
24868 KB |
02-03.txt |
AC |
28 ms |
18672 KB |
02-04.txt |
AC |
56 ms |
22816 KB |
02-05.txt |
AC |
65 ms |
26196 KB |
02-06.txt |
AC |
54 ms |
22808 KB |
02-07.txt |
AC |
70 ms |
24744 KB |
02-08.txt |
AC |
58 ms |
24736 KB |
02-09.txt |
AC |
69 ms |
27884 KB |
02-10.txt |
AC |
45 ms |
24636 KB |
02-11.txt |
AC |
43 ms |
22740 KB |
02-12.txt |
AC |
48 ms |
23152 KB |
02-13.txt |
AC |
44 ms |
24476 KB |
sample-01.txt |
AC |
4 ms |
8444 KB |
sample-02.txt |
AC |
4 ms |
8444 KB |