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 C# (.NET Core 3.1.201) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;
using static System.Math;
using System.Numerics;

namespace AtCoder
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
            Solve();
            //Out.Flush();
            Read();
        }

        static void Solve()
        {
            var N = Sarray()[0];
            var lrs = new (long l, long r)[N];
            for (var i = 0; i < N; ++i)
            {
                var S = ReadLine();
                var l = 0L;
                var r = 0L;
                foreach (var s in S)
                {
                    if (s == '(') ++l;
                    else
                    {
                        if (l == 0) ++r;
                        else --l;
                    }
                }
                lrs[i] = (l, r);
            }
            //(だけで最長のものを作る
            var ln = 0L;
            foreach (var lr in lrs.Where(lr => 0 < lr.l - lr.r).OrderBy(lr => lr.r))
            {
                if (lr.r <= ln) ln += lr.l - lr.r;
                else
                {
                    WriteLine("No");
                    return;
                }
            }
            //)だけで最長のものを作る
            var rn = 0L;
            foreach (var lr in lrs.Where(lr => lr.l - lr.r < 0).OrderBy(lr => lr.l))
            {
                if (lr.l <= rn) rn += lr.r - lr.l;
                else
                {
                    WriteLine("No");
                    return;
                }
            }
            var eqM = 0L;
            var eqMs = lrs.Where(lr => lr.l == lr.r);
            if (eqMs.Any()) eqM = eqMs.Max(lr => lr.l);

            if (rn == ln && eqM <= rn) WriteLine("Yes");
            else WriteLine("No");
        }

        static long Mod = (long)1e9 + 7;
        static public long[] Sarray() { return ReadLine().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }
        static public (T1 a, T2 b) Slice<T1, T2>()
        {
            var t = ReadLine().Split();
            return (
            (T1)Convert.ChangeType(t[0], typeof(T1)),
            (T2)Convert.ChangeType(t[1], typeof(T2)));
        }
        static public (T a, T b) Slice2<T>()
        {
            var t = ReadLine().Split();
            return (
            (T)Convert.ChangeType(t[0], typeof(T)),
            (T)Convert.ChangeType(t[1], typeof(T)));
        }
        static public (T a, T b, T c) Slice3<T>()
        {
            var t = ReadLine().Split();
            return (
            (T)Convert.ChangeType(t[0], typeof(T)),
            (T)Convert.ChangeType(t[1], typeof(T)),
            (T)Convert.ChangeType(t[2], typeof(T)));
        }
    }
}