結果

問題 No.763 Noelちゃんと木遊び
ユーザー ngtkanangtkana
提出日時 2024-06-10 16:53:35
言語 Rust
(1.77.0 + proconio)
結果
AC  
実行時間 32 ms / 2,000 ms
コード長 1,948 bytes
コンパイル時間 18,279 ms
コンパイル使用メモリ 386,568 KB
実行使用メモリ 14,848 KB
最終ジャッジ日時 2024-06-10 16:53:56
合計ジャッジ時間 14,271 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 22 ms
14,848 KB
testcase_01 AC 11 ms
6,816 KB
testcase_02 AC 26 ms
12,160 KB
testcase_03 AC 16 ms
8,704 KB
testcase_04 AC 11 ms
6,940 KB
testcase_05 AC 16 ms
8,704 KB
testcase_06 AC 31 ms
14,336 KB
testcase_07 AC 30 ms
13,824 KB
testcase_08 AC 17 ms
9,216 KB
testcase_09 AC 12 ms
6,944 KB
testcase_10 AC 5 ms
6,944 KB
testcase_11 AC 32 ms
14,592 KB
testcase_12 AC 28 ms
13,056 KB
testcase_13 AC 28 ms
12,672 KB
testcase_14 AC 24 ms
11,904 KB
testcase_15 AC 17 ms
8,832 KB
testcase_16 AC 3 ms
6,944 KB
testcase_17 AC 17 ms
8,960 KB
testcase_18 AC 30 ms
14,464 KB
testcase_19 AC 29 ms
13,184 KB
testcase_20 AC 28 ms
13,184 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

use proconio::input;
use proconio::marker::Usize1;

fn main() {
    input! {
        n: usize,
        edges: [(Usize1, Usize1); n - 1],
    }
    let mut g = vec![Vec::new(); n];
    for &(i, j) in &edges {
        g[i].push(j);
        g[j].push(i);
    }
    let mut sorted = Vec::new();
    let mut parent = vec![usize::MAX; n];
    let mut stack = vec![0];
    while let Some(i) = stack.pop() {
        sorted.push(i);
        g[i].retain(|&j| j != parent[i]);
        for &j in &g[i] {
            stack.push(j);
            parent[j] = i;
        }
    }

    let dp = tree_dp(&O {}, &g, &sorted);
    let ans = dp[0].x.max(dp[0].y);
    println!("{ans}");
}

#[derive(Debug, Clone, Copy, PartialEq, Default)]
struct Value {
    x: usize,
    y: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Default)]
struct Acc {
    a: usize,
    b: usize,
}

struct O {}
impl Op for O {
    type Acc = Acc;
    type Value = Value;

    fn f(&self, &value: &Value) -> Acc {
        Acc {
            a: value.x.max(value.y),
            b: value.x,
        }
    }

    fn g(&self, &acc: &Acc) -> Value {
        Value {
            x: acc.a,
            y: 1 + acc.b,
        }
    }

    fn identity() -> Acc {
        Acc { a: 0, b: 0 }
    }

    fn mul(&lhs: &Acc, &rhs: &Acc) -> Acc {
        Acc {
            a: lhs.a + rhs.a,
            b: lhs.b + rhs.b,
        }
    }
}

pub trait Op {
    type Value: Default + Clone;
    type Acc;

    fn f(&self, value: &Self::Value) -> Self::Acc;

    fn g(&self, acc: &Self::Acc) -> Self::Value;

    fn identity() -> Self::Acc;

    fn mul(lhs: &Self::Acc, rhs: &Self::Acc) -> Self::Acc;
}

pub fn tree_dp<O: Op>(o: &O, g: &[Vec<usize>], sorted: &[usize]) -> Vec<O::Value> {
    let mut dp = vec![O::Value::default(); g.len()];
    for &i in sorted.iter().rev() {
        dp[i] = o.g(&g[i]
            .iter()
            .fold(O::identity(), |acc, &j| O::mul(&acc, &o.f(&dp[j]))));
    }
    dp
}
0