#![allow(unused_imports)] use std::io::{ self, Write }; use std::str::FromStr; use std::cmp::{ min, max }; use std::collections::{ BinaryHeap, VecDeque }; #[allow(unused_macros)] macro_rules! trace { ($var:expr) => ({ let _ = writeln!(&mut std::io::stderr(), ">>> {} = {:?}", stringify!($var), $var); }) } #[allow(unused_macros)] macro_rules! swap { ($a:expr, $b:expr) => ({ let t = $b; $b = $a; $a = t; }) } #[derive(Debug)] struct Topological(Vec); impl Topological { fn visit(u: usize, mut used: &mut Vec, rd: &Vec>, mut ord: &mut Vec) { if used[u] { return } used[u] = true; for &v in rd[u].iter() { Self::visit(v, &mut used, &rd, &mut ord); } ord.push(u); } fn new(neigh: &Vec>) -> Self { let n = neigh.len(); let mut rd = vec![vec![]; n]; for u in 0..n { for &v in neigh[u].iter() { rd[v].push(u); } } // sort let mut used = vec![false; n]; let mut ord = vec![]; for u in 0..n { Self::visit(u, &mut used, &rd, &mut ord); } Topological(ord) } } struct Hako(i32, i32, i32); fn can_include(a: &Hako, b: &Hako) -> bool { let Hako(x1, y1, z1) = *a; let Hako(x2, y2, z2) = *b; if x1 > x2 && y1 > y2 && z1 > z2 { return true } if x1 > x2 && y1 > z2 && z1 > y2 { return true } if x1 > y2 && y1 > x2 && z1 > z2 { return true } if x1 > y2 && y1 > z2 && z1 > x2 { return true } if x1 > z2 && y1 > x2 && z1 > y2 { return true } if x1 > z2 && y1 > y2 && z1 > x2 { return true } false } fn main() { let mut sc = Scanner::new(); let n: usize = sc.cin(); let mut hakos = vec![]; for _ in 0..n { let x: i32 = sc.cin(); let y: i32 = sc.cin(); let z: i32 = sc.cin(); hakos.push(Hako(x, y, z)); } let mut neigh = vec![vec![]; n]; let mut dmat = vec![vec![false; n]; n]; for i in 0..n { for j in 0..n { if can_include(&hakos[i], &hakos[j]) { neigh[i].push(j); dmat[i][j] = true; } } } let Topological(ord) = Topological::new(&neigh); let mut memo = vec![1; n]; for i in 0..n { for j in (i + 1)..n { if dmat[ord[i]][ord[j]] { memo[j] = max(memo[j], memo[i] + 1); } } } let mut maxlen = 0; for i in 0..n { maxlen = max(maxlen, memo[i]); } println!("{}", maxlen); } #[allow(dead_code)] struct Scanner { stdin: io::Stdin, buffer: VecDeque, } #[allow(dead_code)] impl Scanner { fn new() -> Scanner { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } } fn reserve(&mut self) { while self.buffer.len() == 0 { let mut line = String::new(); let _ = self.stdin.read_line(&mut line); for w in line.split_whitespace() { self.buffer.push_back(String::from(w)); } } } fn cin(&mut self) -> T { self.reserve(); match self.buffer.pop_front().unwrap().parse::() { Ok(a) => a, Err(_) => panic!("parse err") } } fn get_char(&mut self) -> char { self.reserve(); let head = self.buffer[0].chars().nth(0).unwrap(); let tail = String::from( &self.buffer[0][1..] ); if tail.len()>0 { self.buffer[0]=tail } else { self.buffer.pop_front(); } head } }