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 Scala (judge verdict: Accepted)

import scala.annotation.tailrec
import scala.collection.mutable

object Main extends App {
  import scala.io.StdIn._


  val Array(n, m) = readLine.trim.split(' ').map(_.toInt)
  val weights = readLine.trim.split(' ').map(_.toInt)
  val edges = Array.tabulate(n){_ ⇒ Nil: List[Int]}
  val dimensions = Array.tabulate(n){_ ⇒ 0}
  for (_ ← 0 until m){
    val Array(u, v) = readLine.trim.split(' ').map(_.toInt)
    edges(u - 1) ::= v - 1
    dimensions(u - 1) += 1
    edges(v - 1) ::= u - 1
    dimensions(v - 1) += 1
  }
  val singlePathMemo = Array.tabulate(n){_ ⇒ 0}
  dimensions.indices.tail.filter(i ⇒ dimensions(i) == 1).foreach(i ⇒ singlePathCost(i))
  println(singlePathMemo.max + dimensions.indices.filter(i ⇒ i == 0 || dimensions(i) != 1).map(i ⇒ weights(i)).sum)
  @tailrec
  def singlePathCost(current: Int, prev: Int = -1, result: Int = 0): Unit = {
      if (dimensions(current) != 1 || current == 0) {
        singlePathMemo(current) = math.max(singlePathMemo(current), result)
      }
      else {
        edges(current).filter(i ⇒ i == 0 || dimensions(i) != 1) match {
          case next::Nil ⇒
            dimensions(next) -= 1
            singlePathCost(next, current, math.max(singlePathMemo(current), result) + weights(current))
          case _ ⇒ ???
        }
      }
  }


  case class Cost(any: Int, one: Int)
  implicit class Extension[T](val value :T) extends AnyVal {
    @inline
    def let[A](@inline func: T ⇒ A): A = func(value)
    @inline
    def also(@inline func: T ⇒ Unit): T = {func(value); value}
    @inline
    def takeIf(@inline predicate: T ⇒ Boolean): Option[T] = Some(value).filter(predicate)
  }
}