結果
問題 | No.1494 LCS on Tree |
ユーザー |
|
提出日時 | 2021-04-30 23:05:19 |
言語 | Rust (1.83.0 + proconio) |
結果 |
WA
|
実行時間 | - |
コード長 | 22,205 bytes |
コンパイル時間 | 28,793 ms |
コンパイル使用メモリ | 378,856 KB |
実行使用メモリ | 33,792 KB |
最終ジャッジ日時 | 2024-07-19 02:53:33 |
合計ジャッジ時間 | 18,215 ms |
ジャッジサーバーID (参考情報) |
judge4 / judge1 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 12 WA * 35 |
ソースコード
// codesnip-guard: mainfn main() {#![allow(unused_imports, unused_macros)]prepare_io!(_in_buf, scanner, _out);macro_rules ! print { ($ ($ arg : tt) *) => (:: std :: write ! (_out , $ ($ arg) *) . expect ("io error")) }macro_rules ! println { ($ ($ arg : tt) *) => (:: std :: writeln ! (_out , $ ($ arg) *) . expect ("io error")) }scan!(scanner, n, mut s: Chars, (g, c): {TreeGraphScanner::<Usize1, char>::new(n)});let k = s.len();let mut ans = 0usize;let mut lcs = vec![vec![0usize; k + 1]; n];for _ in 0..2 {capture!([lcs: &mut Vec<Vec<usize>>, s: &[char], c: &[char], k,],fn dfs(g: &UndirectedSparseGraph, u: usize, p: usize) {for a in g.adjacencies(u) {if a.to != p {let c = c[a.id];let (dp, ndp) = lcs.get_distinct_mut((u, a.to));for i in 0..k {chmax!(ndp[i + 1], dp[i] + (c == s[i]) as usize);chmax!(ndp[i + 1], ndp[i]);}dfs!()(g, a.to, u);}}});dfs(&g, 0, !0);s.reverse();chmax!(ans, lcs.iter().map(|l| l[k]).max().unwrap_or_default());}println!("{}", ans);}#[macro_export]macro_rules! prepare_io {($ in_buf : ident , $ scanner : ident , $ out : ident) => {use std::io::{stdout, BufWriter, Write as _};let $in_buf = read_stdin_all_unchecked();let mut $scanner = Scanner::new(&$in_buf);let $out = stdout();let mut $out = BufWriter::new($out.lock());};}// codesnip-guard: _echopub fn echo<T: std::fmt::Display>(mut writer: impl std::io::Write,iter: impl IntoIterator<Item = T>,sep: impl std::fmt::Display,) -> std::io::Result<()> {let mut iter = iter.into_iter();if let Some(item) = iter.next() {write!(writer, "{}", item)?;}for item in iter {write!(writer, "{}{}", sep, item)?;}writeln!(writer)}// codesnip-guard: scannerpub fn read_stdin_all_unchecked() -> String {use std::io::Read as _;let mut buf = Vec::new();std::io::stdin().read_to_end(&mut buf).expect("io error");unsafe { String::from_utf8_unchecked(buf) }}pub fn read_stdin_line() -> String {let mut s = String::new();std::io::stdin().read_line(&mut s).expect("io error");s}pub trait IterScan: Sized {type Output;fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self::Output>;}pub trait MarkedIterScan: Sized {type Output;fn mscan<'a, I: Iterator<Item = &'a str>>(self, iter: &mut I) -> Option<Self::Output>;}#[derive(Clone, Debug)]pub struct Scanner<'a> {iter: std::str::SplitAsciiWhitespace<'a>,}mod scanner_impls {use super::*;impl<'a> Scanner<'a> {#[inline]pub fn new(s: &'a str) -> Self {let iter = s.split_ascii_whitespace();Self { iter }}#[inline]pub fn scan<T: IterScan>(&mut self) -> <T as IterScan>::Output {<T as IterScan>::scan(&mut self.iter).expect("scan error")}#[inline]pub fn mscan<T: MarkedIterScan>(&mut self, marker: T) -> <T as MarkedIterScan>::Output {marker.mscan(&mut self.iter).expect("scan error")}#[inline]pub fn scan_vec<T: IterScan>(&mut self, size: usize) -> Vec<<T as IterScan>::Output> {(0..size).map(|_| <T as IterScan>::scan(&mut self.iter).expect("scan error")).collect()}#[inline]pub fn iter<'b, T: IterScan>(&'b mut self) -> ScannerIter<'a, 'b, T> {ScannerIter {inner: self,_marker: std::marker::PhantomData,}}}macro_rules ! iter_scan_impls { ($ ($ t : ty) *) => { $ (impl IterScan for $ t { type Output = Self ; # [inline] fn scan <'a , I : Iterator <Item = &'a str >> (iter : & mut I) -> Option < Self > { iter . next () ?. parse ::<$ t > () . ok () } }) * } ; }iter_scan_impls ! (char u8 u16 u32 u64 usize i8 i16 i32 i64 isize f32 f64 u128 i128 String);macro_rules ! iter_scan_tuple_impl { ($ ($ T : ident) *) => { impl <$ ($ T : IterScan) ,*> IterScan for ($ ($ T ,) *) { type Output = ($ (<$ T asIterScan >:: Output ,) *) ; # [inline] fn scan <'a , It : Iterator < Item = &'a str >> (_iter : & mut It) -> Option < Self :: Output > { Some(($ (<$ T as IterScan >:: scan (_iter) ?,) *)) } } } ; }iter_scan_tuple_impl!();iter_scan_tuple_impl!(A);iter_scan_tuple_impl ! (A B);iter_scan_tuple_impl ! (A B C);iter_scan_tuple_impl ! (A B C D);iter_scan_tuple_impl ! (A B C D E);iter_scan_tuple_impl ! (A B C D E F);iter_scan_tuple_impl ! (A B C D E F G);iter_scan_tuple_impl ! (A B C D E F G H);iter_scan_tuple_impl ! (A B C D E F G H I);iter_scan_tuple_impl ! (A B C D E F G H I J);iter_scan_tuple_impl ! (A B C D E F G H I J K);pub struct ScannerIter<'a, 'b, T> {inner: &'b mut Scanner<'a>,_marker: std::marker::PhantomData<fn() -> T>,}impl<'a, 'b, T: IterScan> Iterator for ScannerIter<'a, 'b, T> {type Item = <T as IterScan>::Output;#[inline]fn next(&mut self) -> Option<Self::Item> {<T as IterScan>::scan(&mut self.inner.iter)}}}#[derive(Debug, Copy, Clone)]pub struct Usize1;#[derive(Debug, Copy, Clone)]pub struct CharWithBase(pub char);#[derive(Debug, Copy, Clone)]pub struct Chars;#[derive(Debug, Copy, Clone)]pub struct CharsWithBase(pub char);#[derive(Debug, Copy, Clone)]pub struct Collect<T: IterScan, B: std::iter::FromIterator<<T as IterScan>::Output>> {size: usize,_marker: std::marker::PhantomData<fn() -> (T, B)>,}mod marker_impls {use super::*;use std::{iter::FromIterator, marker::PhantomData};impl IterScan for Usize1 {type Output = usize;#[inline]fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self::Output> {<usize as IterScan>::scan(iter)?.checked_sub(1)}}impl MarkedIterScan for CharWithBase {type Output = usize;#[inline]fn mscan<'a, I: Iterator<Item = &'a str>>(self, iter: &mut I) -> Option<Self::Output> {Some((<char as IterScan>::scan(iter)? as u8 - self.0 as u8) as usize)}}impl IterScan for Chars {type Output = Vec<char>;#[inline]fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self::Output> {Some(iter.next()?.chars().collect())}}impl MarkedIterScan for CharsWithBase {type Output = Vec<usize>;#[inline]fn mscan<'a, I: Iterator<Item = &'a str>>(self, iter: &mut I) -> Option<Self::Output> {Some(iter.next()?.chars().map(|c| (c as u8 - self.0 as u8) as usize).collect(),)}}impl<T: IterScan, B: FromIterator<<T as IterScan>::Output>> Collect<T, B> {pub fn new(size: usize) -> Self {Self {size,_marker: PhantomData,}}}impl<T: IterScan, B: FromIterator<<T as IterScan>::Output>> MarkedIterScan for Collect<T, B> {type Output = B;#[inline]fn mscan<'a, I: Iterator<Item = &'a str>>(self, iter: &mut I) -> Option<Self::Output> {Some((0..self.size).map(|_| <T as IterScan>::scan(iter).expect("scan error")).collect::<B>(),)}}}#[macro_export]macro_rules ! scan_value { ($ scanner : expr , ($ ($ t : tt) ,*)) => { ($ ($ crate :: scan_value ! ($ scanner , $ t)) ,*) } ; ($ scanner : expr , [$t : tt ; $ len : expr]) => { (0 ..$ len) . map (| _ | $ crate :: scan_value ! ($ scanner , $ t)) . collect ::< Vec < _ >> () } ; ($ scanner :expr , [$ t : ty ; $ len : expr]) => { $ scanner . scan_vec ::<$ t > ($ len) } ; ($ scanner : expr , [$ t : ty]) => { $ scanner . iter ::<$ t >() } ; ($ scanner : expr , { $ e : expr }) => { $ scanner . mscan ($ e) } ; ($ scanner : expr , $ t : ty) => { $ scanner . scan ::<$ t > () } ; }#[macro_export]macro_rules ! scan { ($ scanner : expr) => { } ; ($ scanner : expr ,) => { } ; ($ scanner : expr , mut $ var : tt : $ t : tt) => { let mut $ var = $crate :: scan_value ! ($ scanner , $ t) ; } ; ($ scanner : expr , $ var : tt : $ t : tt) => { let $ var = $ crate :: scan_value ! ($ scanner , $t) ; } ; ($ scanner : expr , mut $ var : tt : $ t : tt , $ ($ rest : tt) *) => { let mut $ var = $ crate :: scan_value ! ($ scanner , $ t) ; scan! ($ scanner , $ ($ rest) *) } ; ($ scanner : expr , $ var : tt : $ t : tt , $ ($ rest : tt) *) => { let $ var = $ crate :: scan_value ! ($scanner , $ t) ; scan ! ($ scanner , $ ($ rest) *) } ; ($ scanner : expr , mut $ var : tt) => { let mut $ var = $ crate :: scan_value ! ($scanner , usize) ; } ; ($ scanner : expr , $ var : tt) => { let $ var = $ crate :: scan_value ! ($ scanner , usize) ; } ; ($ scanner : expr , mut$ var : tt , $ ($ rest : tt) *) => { let mut $ var = $ crate :: scan_value ! ($ scanner , usize) ; scan ! ($ scanner , $ ($ rest) *) } ; ($scanner : expr , $ var : tt , $ ($ rest : tt) *) => { let $ var = $ crate :: scan_value ! ($ scanner , usize) ; scan ! ($ scanner , $ ($ rest) *)} ; }// codesnip-guard: SparseGraphpub use sparse_graph::{Adjacency, BidirectionalGraphScanner, BidirectionalSparseGraph, DirectedGraphScanner,DirectedSparseGraph, SparseGraph, TreeGraphScanner, UndirectedGraphScanner,UndirectedSparseGraph,};pub mod sparse_graph {use super::*;use std::{iter, marker::PhantomData, ops, slice};type Marker<T> = PhantomData<fn() -> T>;#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]pub struct DirectedEdge;#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]pub struct UndirectedEdge;#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]pub struct BidirectionalEdge;#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]pub struct Adjacency {pub id: usize,pub to: usize,}impl Adjacency {pub fn new(id: usize, to: usize) -> Adjacency {Adjacency { id, to }}}/// Static Sparse Graph represented as Compressed Sparse Row.#[derive(Debug, Clone)]pub struct SparseGraph<D> {vsize: usize,pub start: Vec<usize>,pub elist: Vec<Adjacency>,pub edges: Vec<(usize, usize)>,_marker: Marker<D>,}impl<D> SparseGraph<D> {/// Return the number of vertices.pub fn vertices_size(&self) -> usize {self.vsize}/// Return the number of edges.pub fn edges_size(&self) -> usize {self.edges.len()}/// Return an iterator over graph vertices.pub fn vertices(&self) -> ops::Range<usize> {0..self.vertices_size()}/// Return a slice of adjacency vertices.pub fn adjacencies(&self, v: usize) -> slice::Iter<'_, Adjacency> {self.elist[self.start[v]..self.start[v + 1]].iter()}}pub trait SparseGraphConstruction: Sized {fn construct_graph(vsize: usize, edges: Vec<(usize, usize)>) -> SparseGraph<Self>;}impl<D: SparseGraphConstruction> SparseGraph<D> {/// Construct graph from edges.pub fn from_edges(vsize: usize, edges: Vec<(usize, usize)>) -> Self {D::construct_graph(vsize, edges)}}impl SparseGraphConstruction for DirectedEdge {fn construct_graph(vsize: usize, edges: Vec<(usize, usize)>) -> SparseGraph<Self> {let mut start: Vec<_> = iter::repeat(0).take(vsize + 1).collect();let mut elist = Vec::with_capacity(edges.len());unsafe { elist.set_len(edges.len()) }for (from, _) in edges.iter().cloned() {start[from] += 1;}for i in 1..=vsize {start[i] += start[i - 1];}for (id, (from, to)) in edges.iter().cloned().enumerate() {start[from] -= 1;elist[start[from]] = Adjacency::new(id, to);}SparseGraph {vsize,start,elist,edges,_marker: PhantomData,}}}impl SparseGraphConstruction for UndirectedEdge {fn construct_graph(vsize: usize, edges: Vec<(usize, usize)>) -> SparseGraph<Self> {let mut start: Vec<_> = iter::repeat(0).take(vsize + 1).collect();let mut elist = Vec::with_capacity(edges.len() * 2);unsafe { elist.set_len(edges.len() * 2) }for (from, to) in edges.iter().cloned() {start[to] += 1;start[from] += 1;}for i in 1..=vsize {start[i] += start[i - 1];}for (id, (from, to)) in edges.iter().cloned().enumerate() {start[from] -= 1;elist[start[from]] = Adjacency::new(id, to);start[to] -= 1;elist[start[to]] = Adjacency::new(id, from);}SparseGraph {vsize,start,elist,edges,_marker: PhantomData,}}}impl SparseGraphConstruction for BidirectionalEdge {fn construct_graph(vsize: usize, edges: Vec<(usize, usize)>) -> SparseGraph<Self> {let mut start: Vec<_> = iter::repeat(0).take(vsize + 1).collect();let mut elist = Vec::with_capacity(edges.len() * 2);unsafe { elist.set_len(edges.len() * 2) }for (from, to) in edges.iter().cloned() {start[to] += 1;start[from] += 1;}for i in 1..=vsize {start[i] += start[i - 1];}for (id, (from, to)) in edges.iter().cloned().enumerate() {start[from] -= 1;elist[start[from]] = Adjacency::new(id * 2, to);start[to] -= 1;elist[start[to]] = Adjacency::new(id * 2 + 1, from);}SparseGraph {vsize,start,elist,edges,_marker: PhantomData,}}}pub type DirectedSparseGraph = SparseGraph<DirectedEdge>;pub type UndirectedSparseGraph = SparseGraph<UndirectedEdge>;pub type BidirectionalSparseGraph = SparseGraph<BidirectionalEdge>;pub struct SparseGraphScanner<U: IterScan<Output = usize>, T: IterScan, D> {vsize: usize,esize: usize,_marker: Marker<(U, T, D)>,}impl<U: IterScan<Output = usize>, T: IterScan, D> SparseGraphScanner<U, T, D> {pub fn new(vsize: usize, esize: usize) -> Self {Self {vsize,esize,_marker: PhantomData,}}}impl<U: IterScan<Output = usize>, T: IterScan, D: SparseGraphConstruction> MarkedIterScanfor SparseGraphScanner<U, T, D>{type Output = (SparseGraph<D>, Vec<<T as IterScan>::Output>);fn mscan<'a, I: Iterator<Item = &'a str>>(self, iter: &mut I) -> Option<Self::Output> {let mut edges = Vec::with_capacity(self.esize);let mut rest = Vec::with_capacity(self.esize);for _ in 0..self.esize {edges.push((U::scan(iter)?, U::scan(iter)?));rest.push(T::scan(iter)?);}let graph = SparseGraph::from_edges(self.vsize, edges);Some((graph, rest))}}pub type DirectedGraphScanner<U, T> = SparseGraphScanner<U, T, DirectedEdge>;pub type UndirectedGraphScanner<U, T> = SparseGraphScanner<U, T, UndirectedEdge>;pub type BidirectionalGraphScanner<U, T> = SparseGraphScanner<U, T, BidirectionalEdge>;pub struct TreeGraphScanner<U: IterScan<Output = usize>, T: IterScan> {vsize: usize,_marker: Marker<(U, T)>,}impl<U: IterScan<Output = usize>, T: IterScan> TreeGraphScanner<U, T> {pub fn new(vsize: usize) -> Self {Self {vsize,_marker: PhantomData,}}}impl<U: IterScan<Output = usize>, T: IterScan> MarkedIterScan for TreeGraphScanner<U, T> {type Output = (UndirectedSparseGraph, Vec<<T as IterScan>::Output>);fn mscan<'a, I: Iterator<Item = &'a str>>(self, iter: &mut I) -> Option<Self::Output> {UndirectedGraphScanner::<U, T>::new(self.vsize, self.vsize - 1).mscan(iter)}}}// codesnip-guard: capture#[macro_export]macro_rules ! capture { ([$ ($ ca : tt) *] , fn $ name : ident ($ ($ arg : tt) *) -> $ ret : ty $ body : block) => { capture ! ({ } [$ ($ ca) *,] fn$ name ($ ($ arg) *) -> $ ret $ body) } ; ([$ ($ ca : tt) *] , fn $ name : ident ($ ($ arg : tt) *) $ body : block) => { capture ! ({ } [$ ($ ca)*,] fn $ name ($ ($ arg) *) -> () $ body) } ; ({ $ (($ g : ident , $ ga : expr , $ gt : ty)) * } [] fn $ name : ident ($ ($ a : ident : $ at : ty) ,*) -> $ ret : ty $ body : block) => { fn $ name ($ ($ g : $ gt ,) * $ ($ a : $ at ,) *) -> $ ret { # [allow (unused_macros)] macro_rules ! $name { () => { |$ ($ a) ,*| $ name ($ ($ g ,) * $ ($ a ,) *) } } $ body } # [allow (unused_mut)] let mut $ name = |$ ($ a) ,*| $ name ($ ($ ga ,)* $ ($ a ,) *) ; } ; ({ $ ($ g : tt) * } [] fn $ name : ident ($ ($ a : ident : $ at : ty) ,*,) $ ($ rest : tt) *) => { capture ! ({ $ ($ g) * }[] fn $ name ($ ($ a : $ at) ,*) $ ($ rest) *) } ; ({ $ ($ done : tt) * } [,] $ ($ rest : tt) *) => { capture ! ({ $ ($ done) * } [] $ ($ rest)*) } ; ({ $ ($ done : tt) * } [$ g : ident : & mut $ gt : ty , $ ($ rest : tt) *] $ ($ info : tt) *) => { capture ! ({ $ ($ done) * ($ g , & mut$ g , & mut $ gt) } [$ ($ rest) *] $ ($ info) *) } ; ({ $ ($ done : tt) * } [$ g : ident : &$ gt : ty , $ ($ rest : tt) *] $ ($ info : tt) *) =>{ capture ! ({ $ ($ done) * ($ g , &$ g , &$ gt) } [$ ($ rest) *] $ ($ info) *) } ; ({ $ ($ done : tt) * } [$ g : ident : $ gt : ty , $ ($ rest :tt) *] $ ($ info : tt) *) => { capture ! ({ $ ($ done) * ($ g , $ g , $ gt) } [$ ($ rest) *] $ ($ info) *) } ; ({ $ ($ done : tt) * } [$ g :ident , $ ($ rest : tt) *] $ ($ info : tt) *) => { capture ! ({ $ ($ done) * ($ g , $ g , usize) } [$ ($ rest) *] $ ($ info) *) } ; }// codesnip-guard: GetDistinctMutpub trait GetDistinctMut<I> {type Output;fn get_distinct_mut(self, index: I) -> Self::Output;}impl<'a, T> GetDistinctMut<(usize, usize)> for &'a mut [T] {type Output = (&'a mut T, &'a mut T);fn get_distinct_mut(self, (i0, i1): (usize, usize)) -> Self::Output {assert_ne!(i0, i1);assert!(i0 < self.len());assert!(i1 < self.len());let ptr = self.as_mut_ptr();unsafe { (&mut *ptr.add(i0), &mut *ptr.add(i1)) }}}impl<'a, T> GetDistinctMut<(usize, usize, usize)> for &'a mut [T] {type Output = (&'a mut T, &'a mut T, &'a mut T);fn get_distinct_mut(self, (i0, i1, i2): (usize, usize, usize)) -> Self::Output {assert_ne!(i0, i1);assert_ne!(i0, i2);assert!(i0 < self.len());assert!(i1 < self.len());assert!(i2 < self.len());let ptr = self.as_mut_ptr();unsafe { (&mut *ptr.add(i0), &mut *ptr.add(i1), &mut *ptr.add(i2)) }}}// codesnip-guard: ord_toolspub trait PartialOrdExt: Sized {fn chmin(&mut self, other: Self);fn chmax(&mut self, other: Self);fn minmax(self, other: Self) -> (Self, Self);}impl<T> PartialOrdExt for TwhereT: PartialOrd,{#[inline]fn chmin(&mut self, other: Self) {if *self > other {*self = other;}}#[inline]fn chmax(&mut self, other: Self) {if *self < other {*self = other;}}#[inline]fn minmax(self, other: Self) -> (Self, Self) {if self < other {(self, other)} else {(other, self)}}}#[macro_export]macro_rules ! min { ($ l : expr) => { $ l } ; ($ l : expr ,) => { $ crate :: min ! ($ l) } ; ($ l : expr , $ r : expr) => { ($ l) . min ($ r) } ; ($l : expr , $ r : expr ,) => { $ crate :: min ! ($ l , $ r) } ; ($ l : expr , $ r : expr , $ ($ t : tt) *) => { $ crate :: min ! ($ crate :: min !($ l , $ r) , $ ($ t) *) } ; }#[macro_export]macro_rules ! chmin { ($ l : expr) => { } ; ($ l : expr ,) => { } ; ($ l : expr , $ r : expr) => { { let r = $ r ; if $ l > r { $ l = r ; } } } ; ($l : expr , $ r : expr ,) => { $ crate :: chmin ! ($ l , $ r) } ; ($ l : expr , $ r : expr , $ ($ t : tt) *) => { $ crate :: chmin ! ($ l , $ r) ;$ crate :: chmin ! ($ l , $ ($ t) *) } ; }#[macro_export]macro_rules ! max { ($ l : expr) => { $ l } ; ($ l : expr ,) => { $ crate :: max ! ($ l) } ; ($ l : expr , $ r : expr) => { ($ l) . max ($ r) } ; ($l : expr , $ r : expr ,) => { $ crate :: max ! ($ l , $ r) } ; ($ l : expr , $ r : expr , $ ($ t : tt) *) => { $ crate :: max ! ($ crate :: max !($ l , $ r) , $ ($ t) *) } ; }#[macro_export]macro_rules ! chmax { ($ l : expr) => { } ; ($ l : expr ,) => { } ; ($ l : expr , $ r : expr) => { { let r = $ r ; if $ l < r { $ l = r ; } } } ; ($l : expr , $ r : expr ,) => { $ crate :: chmax ! ($ l , $ r) } ; ($ l : expr , $ r : expr , $ ($ t : tt) *) => { $ crate :: chmax ! ($ l , $ r) ;$ crate :: chmax ! ($ l , $ ($ t) *) } ; }#[macro_export]macro_rules ! minmax { ($ ($ t : tt) *) => { ($ crate :: min ! ($ ($ t) *) , $ crate :: max ! ($ ($ t) *)) } ; }