Problem:
Score : 600 points

Problem Statement

A bracket sequence is a string that is one of the following:

An empty string;

The concatenation of (, A, and ) in this order, for some bracket sequence A ;

The concatenation of A and B in this order, for some non-empty bracket sequences A and B /

Given are N strings S_i. Can a bracket sequence be formed by concatenating all the N strings in some order?

Constraints

1 \leq N \leq 10^6

The total length of the strings S_i is at most 10^6.

S_i is a non-empty string consisting of ( and ).

Input

Input is given from Standard Input in the following format:

N
S_1
:
S_N

Output

If a bracket sequence can be formed by concatenating all the N strings in some order, print Yes; otherwise, print No.

Sample Input 1

2
)
(()

Sample Output 1

Yes

Concatenating (() and ) in this order forms a bracket sequence.

Sample Input 2

2
)(
()

Sample Output 2

No

Sample Input 3

4
((()))
((((((
))))))
()()()

Sample Output 3

Yes

Sample Input 4

3
(((
)
)

Sample Output 4

No

Solution in Kotlin (1.3.71) (judge verdict: Accepted)

import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.util.*
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min

val MOD = 1_000_000_007L

data class Info(var bal: Int, var mn: Int)
data class Entry(val l: Info, val r: Info, val id: Int)

class Solver(stream: InputStream, private val out: java.io.PrintWriter) {
  fun solve() {
    val N = ni()
    val S = Array(N){
      val s = ns().toCharArray()
      var bal = 0
      var mn = 0
      for (c in s) {
        if (c == '(') {
          bal++
        } else {
          bal--
        }
        mn = min(mn, bal)
      }
      val lInfo = infoOf(s)
      val rInfo = infoOf(s.reversed().map{if (it == '(') ')' else '('}.toCharArray())
      Entry(lInfo, rInfo, it)
    }

    if (S.map{it.l.bal}.sum() != 0) {
      out.println("No")
      return
    }

    val lt = mutableListOf<Entry>()
    val rt = mutableListOf<Entry>()

    debug{S.joinToString(" ")}
    for (s in S) {
      if (s.l.bal >= 0) lt.add(s)
      if (s.r.bal >= 0) rt.add(s)
    }
    lt.sortWith(compareBy{-it.l.mn} )
    rt.sortWith(compareBy{-it.r.mn} )

    val used = BooleanArray(N)
    var l = 0
    for (e in lt) {
      if (used[e.id]) continue
      if (-e.l.mn > l) break
      debug{"l: $e"}
      l += e.l.bal
      used[e.id] = true
    }

    var r = 0
    for (e in rt) {
      if (used[e.id]) continue
      if (-e.r.mn > r) break
      debug{"r: $e"}
      r += e.r.bal
      used[e.id] = true
    }

    val ok = used.all { it }
    out.println(if(ok) "Yes" else "No")
  }

  fun infoOf(s: CharArray): Info {
    var bal = 0
    var mn = 0
    for (c in s) {
      if (c == '(') {
        bal++
      } else {
        bal--
      }
      mn = min(mn, bal)
    }
    return Info(bal, mn)
  }













































  private val isDebug = try {
    // なんか本番でエラーでる
    System.getenv("MY_DEBUG") != null
  } catch (t: Throwable) {
    false
  }

  private var tokenizer: StringTokenizer? = null
  private val reader = BufferedReader(InputStreamReader(stream), 32768)
  private fun next(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
      tokenizer = StringTokenizer(reader.readLine())
    }
    return tokenizer!!.nextToken()
  }

  private fun ni() = next().toInt()
  private fun nl() = next().toLong()
  private fun ns() = next()
  private fun na(n: Int, offset: Int = 0): IntArray {
    return map(n) { ni() + offset }
  }
  private fun nal(n: Int, offset: Int = 0): LongArray {
    val res = LongArray(n)
    for (i in 0 until n) {
      res[i] = nl() + offset
    }
    return res
  }

  private fun na2(n: Int, offset: Int = 0): Array<IntArray> {
    val a  = Array(2){IntArray(n)}
    for (i in 0 until n) {
      for (e in a) {
        e[i] = ni() + offset
      }
    }
    return a
  }

  private inline fun map(n: Int, f: (Int) -> Int): IntArray {
    val res = IntArray(n)
    for (i in 0 until n) {
      res[i] = f(i)
    }
    return res
  }

  private inline fun debug(msg: () -> String) {
    if (isDebug) System.err.println(msg())
  }

  private fun debug(a: LongArray) {
    debug { a.joinToString(" ") }
  }

  private fun debug(a: IntArray) {
    debug { a.joinToString(" ") }
  }

  private fun debug(a: BooleanArray) {
    debug { a.map { if (it) 1 else 0 }.joinToString("") }
  }

  private fun debugDim(A: Array<LongArray>) {
    if (isDebug) {
      for (a in A) {
        debug(a)
      }
    }
  }

  /**
   * 勝手にimport消されるのを防ぎたい
   */
  private fun hoge() {
    min(1, 2)
    max(1, 2)
    abs(-10)
  }
}

fun main() {
  val out = java.io.PrintWriter(System.out)
  Solver(System.`in`, out).solve()
  out.flush()
}