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 Java (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.*;

public class Main {
    private static boolean isValidParenthesis(String[] str, int n) {
        int totalLen = 0;
        for (int i = 0; i < n; i++) {
            totalLen += str[i].length();
        }

        if (totalLen % 2 > 0) {
            return false;
        }

        String[] str1 = new String[n];
        for (int i = 0; i < n; i++) {
            str1[i] = validateString(str[i]);
        }

        return buildAndValidateStrings(str1, 0, n, "", new HashSet<>());
    }

    private static boolean buildAndValidateStrings(String[] str, int index, int n, String s, Set<Integer> visited) {
        if (visited.size() == n) {
            return isValid(s);
        }

        for (int i = 0; i < n; i++) {
            if (!visited.contains(i)) {
                visited.add(i);
                if (buildAndValidateStrings(str, i + 1, n, s + str[i], visited)) {
                    return true;
                }
                visited.remove(i);
            }
        }

        return false;
    }

    private static boolean isValid(String s) {
        if (s.length() == 0) {
            return false;
        }
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(') {
                stack.push(ch);
            } else {
                if (stack.isEmpty() || stack.peek() != '(') {
                    return false;
                }
                stack.pop();
            }
        }

        return stack.isEmpty();
    }

    private static String validateString(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == ')' && !stack.isEmpty() && stack.peek() == '(') {
                stack.pop();
            } else {
                stack.push(ch);
            }
        }

        StringBuilder sb = new StringBuilder();
        while (!stack.isEmpty()) {
            sb.insert(0, stack.pop());
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int count = N, i = 0;
        String[] str = new String[N];
        sc.nextLine();
        
        while (count-- > 0) {
            str[i++] = sc.nextLine();
        }
        
        System.out.println(isValidParenthesis(str, N) ? "Yes" : "No");

        sc.close();
    }
}