Problem:
Escape

頂点に正の値を持つ無向グラフが与えられる。
頂点には 1 から N の番号がついており、i 番目の頂点は w_i の値を持っている。
1 番目の頂点からスタートし、直前に通った辺を通ることができないという制約のもとでグラフ上を移動することができる。
各頂点では，初めて訪れた時に限りその頂点が持つ値の点数を得られる。

取得できる点数の総和の最大値を求めよ。

Constraints

1 ≤ N ≤ 100000

N − 1 ≤ M ≤ 100000

1 ≤ w_i ≤ 1000

1 ≤ u_i, v_i ≤ N

多重辺・自己辺は存在しない

グラフは連結である

Input Format

入力は以下の形式で標準入力から与えられる。

N M
w_1 w_2 ... w_N
u_1 v_1
u_2 v_2
...
u_M v_M

1 行目にはグラフの頂点数 N と辺の数を表す整数 M が入力される。

2 行目には各頂点が持つ値 w_i が入力される。

さらに続けて M 行に、各辺により繋がれる 2 頂点の番号が入力される。

Output Format

答えを1行に出力せよ。

Sample Input 1

6 6
1 2 3 4 5 6
1 2
2 3
3 4
1 4
4 5
5 6

Sample Output 1

21

頂点 1→2→3→4→5→6 と進むことで全ての頂点の点数を集めることができます。

Sample Input 2

7 8
1 3 3 5 2 2 3
1 2
2 3
3 1
1 4
1 7
1 5
1 6
5 6

Sample Output 2

16

頂点 1→2→3→1→5→6→1→4 と進むことで16点を集めることができます。

Solution in Rust (judge verdict: Accepted)

use std::io::Read;

fn run() {
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    let n: usize = it.next().unwrap().parse().unwrap();
    let m: usize = it.next().unwrap().parse().unwrap();
    let w: Vec<u32> = (0..n).map(|_| it.next().unwrap().parse().unwrap()).collect();
    let mut g = vec![vec![]; n];
    let mut d = vec![0; n];
    for _ in 0..m {
        let a = it.next().unwrap().parse::<usize>().unwrap() - 1;
        let b = it.next().unwrap().parse::<usize>().unwrap() - 1;
        g[a].push(b);
        g[b].push(a);
        d[a] += 1;
        d[b] += 1;
    }
    d[0] = 1_000_000;
    let mut dp = vec![0; n];
    let mut q = std::collections::VecDeque::new();
    for i in 0..n {
        if d[i] == 1 {
            d[i] = 1_000_000;
            q.push_back(i);
        }
    }
    let mut used = vec![false; n];
    while let Some(v) = q.pop_front() {
        used[v] = true;
        for &u in &g[v] {
            d[u] -= 1;
            dp[u] = std::cmp::max(dp[u], dp[v] + w[v]);
            if d[u] == 1 {
                d[u] = 1_000_000;
                q.push_back(u);
            }
        }
    }
    let mut ans = 0;
    for i in 0..n {
        if !used[i] {
            ans += w[i];
        }
    }
    ans += *dp.iter().max().unwrap();
    println!("{}", ans);
}

fn main() {
    run();
}