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: Accepted)

#[allow(unused_imports)]
use proconio::{
    fastout, input,
    marker::{Bytes, Chars, Isize1, Usize1},
};

#[allow(unused_macros)]
macro_rules! echo {
    ($($e:expr),+) => ( { $(println!("{}", $e))+ } );
}

// (() のようなカッコで構成された文字列を受け取って
// (最終的な増減, 一番低いときいくつ下がるか) を返す
fn process(s: &str) -> (isize, isize) {
    let mut sum = 0;
    let mut lowest = 0;
    for c in s.chars() {
        match c {
            '(' => {
                sum += 1;
            }
            _ => {
                sum -= 1;
            }
        }

        lowest = std::cmp::min(lowest, sum);
    }

    (sum, lowest)
}

fn main() {
    input! {
        n: usize,
        s: [String; n],
    }

    let ss = s.iter().map(|s| process(s)).collect::<Vec<_>>();
    let mut positives = ss.iter().filter(|(sum, _)| *sum >= 0).collect::<Vec<_>>();
    let mut r_negatives = ss
        .iter()
        .filter(|(sum, _)| *sum < 0)
        .map(|(sum, pos)| (-sum, -sum + pos))
        .collect::<Vec<_>>();

    positives.sort_by_key(|e| -e.1); // 最下点までの下げ幅の小さい順
    r_negatives.sort_by_key(|e| -e.1); // 最下点までの下げ幅の小さい順

    let mut p_sum = 0;

    for p in positives {
        if p_sum + p.1 < 0 {
            echo!("No");
            return;
        }

        p_sum += p.0;
    }

    let mut n_sum = 0;

    for n in r_negatives {
        if n_sum + n.1 < 0 {
            echo!("No");
            return;
        }

        n_sum += n.0;
    }

    if p_sum != n_sum {
        echo!("No");
        return;
    }

    echo!("Yes");
}