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 Haskell (GHC 8.8.3) (judge verdict: Wrong Answer)


module Main where

import           Control.Monad
import           Debug.Trace
import qualified Data.Vector                   as V
import qualified Data.Vector.Mutable           as VM
import qualified Data.Vector.Unboxed           as VU
import qualified Data.Vector.Unboxed.Mutable   as VUM
import           Data.List
import qualified Data.ByteString               as BS
import qualified Data.ByteString.Char8         as BSC8
import           Data.Char
import           Data.Maybe
import           Data.Ord
--import           Data.Vector.Algorithms.Search
import qualified Data.Array                    as A
import qualified Data.Array.Unboxed            as AU
import qualified Data.Array.IO                 as AIO
import qualified Data.Set                      as S
import qualified Data.Map.Strict               as M

main = do
    aN <- getI

    aS <- replicateM aN getLine

    let pLR = map
            (\x -> foldl
                (\acc@(l, r) y -> if r == 0
                    then if y == ')' then (l + 1, 0) else (l, 1)
                    else if y == ')' then (l, r - 1) else (l, r + 1)
                )
                (0, 0)
                x
            )
            aS

    let (p00, pO1) = myFilter (\(l, r) -> l == 0 && r == 0) pLR
    let (pL0, pO2) = myFilter (\(l, r) -> l == 0) pO1
    let (pR0, pO3) = myFilter (\(l, r) -> r == 0) pO2
    let (pSumL, pSumR) = foldr
            (\acc@(accl, accr) (l, r) -> (accl + l, accr + r))
            (0, 0)
            pLR
    let ret = if pO1 == []
            then "Yes"
            else if length pL0 == 0 || length pR0 == 0
                then "No"
                else if pSumL == pSumR then "Yes" else "No"
    putStrLn ret

myFilter :: (a -> Bool) -> [a] -> ([a], [a])
myFilter _pred [] = ([], [])
myFilter pred (x : xs)
    | pred x    = let (l, r) = myFilter pred xs in (x : l, r)
    | otherwise = let (l, r) = myFilter pred xs in (l, x : r)

fromJustInt :: Maybe Int -> Int
fromJustInt (Just x) = x
fromJustInt Nothing  = 0

getVUI :: IO (VU.Vector Int)
getVUI = VU.unfoldr (BSC8.readInt . BSC8.dropWhile isSpace) <$> BSC8.getLine
readI :: BSC8.ByteString -> Int
readI = fst . fromJust . BSC8.readInt
readIL :: BSC8.ByteString -> [Int]
readIL = map readI . BSC8.words
readIT2 :: BSC8.ByteString -> (Int, Int)
readIT2 bs =
    let words = BSC8.words bs in (readI $ head words, readI $ last words)
getI :: IO Int
getI = readI <$> BSC8.getLine
getIL :: IO [Int]
getIL = readIL <$> BSC8.getLine
get2IT :: IO (Int, Int)
get2IT = readIT2 <$> BSC8.getLine

getNIS :: Int -> IO [(Int, BSC8.ByteString)]
getNIS 0 = return []
getNIS n = do
    [aFst, aSnd] <- BSC8.words <$> BSC8.getLine
    next         <- (getNIS (n - 1))
    return ((readI aFst, aSnd) : next)

il2ss :: [Int] -> String
il2ss = unwords . map show

il2sn :: [Int] -> String
il2sn = unlines . map show

--modNum = 10 ^ 9 + 7
modNum = 998244353
newtype Mint = M Int
instance Num Mint where
    (M a) + (M b) = M $ mod (a + b) modNum
    (M a) - (M b) = M (a - b)
    (M a) * (M b) = M $ mod (a * b) modNum
    fromInteger a = M $ mod (fromInteger a) modNum
    abs (M a) = M $ abs a
    signum (M a) = M $ signum a
instance Show Mint where
    show (M a) = show (mod a modNum)

int2MInt :: Int -> Mint
int2MInt a = M (mod a modNum)

fact :: Int -> Int
fact 0         = 1
fact n | n > 0 = n * fact (n - 1)

knappsackMaxVal
    :: AIO.IOArray (Int, Int) Int
    -> VU.Vector Int
    -> VU.Vector Int
    -> Int
    -> IO Int
knappsackMaxVal dp volumeVec valueVec dpSize = do
    mapM_
        (\i -> mapM_
            (\v -> do
                let volume = volumeVec VU.! i
                    value  = valueVec VU.! i
                newdp <- if v < volume
                    then AIO.readArray dp (i, v)
                    else do
                        dpIVm <- AIO.readArray dp (i, v - volume)
                        dpIV  <- AIO.readArray dp (i, v)
                        return (max (dpIVm + value) dpIV)
                AIO.writeArray dp (i + 1, v) newdp
            )
            [0 .. dpSize]
        )
        [0 .. VU.length volumeVec - 1]
    AIO.readArray dp (VU.length volumeVec, dpSize)

knappsackMinVol
    :: AIO.IOArray (Int, Int) Int
    -> VU.Vector Int
    -> VU.Vector Int
    -> Int
    -> Int
    -> IO Int
knappsackMinVol dp volumeVec valueVec dpSize maxVolume = do
    mapM_
        (\i -> mapM_
            (\v -> do
                let volume = volumeVec VU.! i
                    value  = valueVec VU.! i
                newdp <- if (v + value) > dpSize
                    then AIO.readArray dp (i, v)
                    else do
                        dpIVm <- AIO.readArray dp (i, v + value)
                        dpIV  <- AIO.readArray dp (i, v)
                        return (min (dpIVm - volume) dpIV)
                AIO.writeArray dp (i + 1, v) newdp
            )
            (reverse [0 .. dpSize])
        )
        [0 .. VU.length valueVec - 1]

    foldM
        (\acc x -> do
            num <- AIO.readArray dp (VU.length volumeVec, x)
            return $ if num <= maxVolume then x else acc
        )
        0
        [0 .. dpSize]