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.util.*
import kotlin.collections.ArrayList

data class Node(val p:Int, val n:Int)

fun main() {
    val sc = Scanner(System.`in`)
    val n = sc.nextInt()
    val list = ArrayList<Node>()
    var start = 0
    var end = 0

    for(i in 0 until n) {
        var k = 0
        var minus = 0
        var plus = 0
        val s = sc.next()
        for(c in s) {
            if(c == '(') {
                if(k < 0) {
                    minus += k
                    k = 0
                }
                ++k
            } else if(c==')'){
                --k
            }
        }
        if(k > 0) {
            plus += k
        } else if(k < 0) {
            minus += k
        }

        if(minus == 0 || plus == 0) {
            start += plus
            end += minus
        } else {
            list.add(Node(plus, minus))
        }
    }

    val pq = PriorityQueue<Node>(kotlin.Comparator { o1, o2 ->
        val v1 = o1.n + o1.p
        val v2 = o2.n + o2.p
        return@Comparator v2.compareTo(v1)
    })

    list.sortByDescending { it.n }

    var idx = 0
    var isSuccess = true

    while (isSuccess && idx < list.size) {
        while(idx < list.size && list[idx].n <= start) {
            pq.add(list[idx++])
        }
        while (pq.isNotEmpty()) {
            val node = pq.poll()
            start += node.n
            if(start < 0) {
                isSuccess = false
                break
            }
            start += node.p
        }
    }
    if(isSuccess) {
        val ret = start + end
        isSuccess = ret == 0
    }

    if(isSuccess) {
        print("Yes")
    } else {
        print("No")
    }
}