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 Rust (1.42.0) (judge verdict: Wrong Answer)

use proconio::marker::Bytes;
use proconio::{fastout, input};
use std::cmp::Ordering;

struct MyStr {
    pub min: i32,
    pub sum: i32,
    pub rmin: i32,
}
impl MyStr {
    fn make(s: Vec<u8>) -> MyStr {
        let mut sum: i32 = 0;
        let mut min: i32 = 0;
        let mut rsum: i32 = 0;
        let mut rmin: i32 = 0;
        for i in 0..s.len() {
            let c = s[i];
            if c == '(' as u8 {
                sum += 1;
            } else {
                sum -= 1;
            }
            min = min.min(sum);
        }
        for i in 0..s.len() {
            let c = s[s.len() - 1 - i];
            if c == ')' as u8 {
                rsum += 1;
            } else {
                rsum -= 1;
            }
            rmin = rmin.min(rsum);
        }

        MyStr { min, sum, rmin }
    }
}

#[fastout]
fn main() {
    input! {
        n: usize,
        s: [Bytes; n],
    }
    let mut obj: Vec<MyStr> = s.into_iter().map(|a| MyStr::make(a)).collect();
    let obj = &mut obj[..];
    obj.sort_unstable_by(|a, b| {
        if a.sum >= 0 && b.sum >= 0 {
            a.min.cmp(&b.rmin).reverse()
        } else {
            a.rmin.cmp(&b.rmin)
        }
    });

    let mut now: i32 = 0;
    let mut min: i32 = 0;

    for x in obj {
        min = min.min(now + x.min);
        now += x.sum;
    }
    if now == 0 && min >= 0 {
        println!("Yes");
    } else {
        println!("No");
    }
}