Solution Notes (Nathan Pinsker): The first thing we may notice is that we need an efficient way of determining whether a string of parentheses is balanced. Some insight yields the following procedure: Let a '(' represent 1 and a ')' represent -1. A substring of parentheses is clearly balanced only if the sum of its corresponding numbers is 0, but we also have the necessary condition that no prefix of this string has sum less than 0.

Using this insight, we can derive almost the desired solution: we sweep through the array left-to-right. At each step, we record the prefix sum of the parentheses we have seen so far in each of our K arrays. If we have seen the exact same combination of prefix sums before, then we have a possible match -- but we have to make sure that none of the prefix sums in between these two locations are less than those that we are checking.

This problem can be solved individually for each array, and rephrased as "given elements in an array, for each element, find the closest element to its left which is less than it", a fairly well-known problem that can be solved in linear time. Once we have this element (say it's at index i), we know that our balanced parenthesis string cannot extend beyond index i. This allows us to determine whether the balanced parenthesis string we have found is actually valid.

Some care is still required in handling cases where the correct balanced string may comprise multiple sets of balanced parentheses. For example, consider the strings "()(())()" and "()()()()". To handle this, when we find an end parenthesis that corresponds to some number of balanced sets, we simply mark how many sets it ends (the 6th parenthesis in the above string would end 2 sets of balanced parentheses: the strings with indices 2-5 and the strings with indices 0-5). Then, when we process the 8th parenthesis, we will remember this information, and mark the 8th parenthesis as representing 3 sets.

Mark Gordon's concise solution is below. Note his use of the array R and variable lft to solve the problem discussed above.

``````
#include <iostream>
#include <vector>
#include <map>
#include <stdio.h>

using namespace std;

int main() {
freopen("cbs.in", "r", stdin);
freopen("cbs.out", "w", stdout);

int N, M; cin >> N >> M;
vector<string> A(N);
for(int i = 0; i < N; i++) cin >> A[i];

int res = 0;
vector<int> L(N, M);
vector<vector<int> > R(N, vector<int>(2 * M, M));
map<vector<int>, pair<int, int> > mp;
for(int i = 0; i < N; i++) R[i][M] = 0;

mp[L] = make_pair(0, 1);
for(int i = 0; i < M; i++) {
int lft = 0;
for(int j = 0; j < N; j++) {
if(A[j][i] == '(') {
R[j][++L[j]] = i + 1;
} else {
--L[j];
R[j][L[j]] = min(R[j][L[j]], i + 1);
}
lft = max(lft, R[j][L[j]]);
}
if(lft == M) continue;

pair<int, int>& dat = mp[L];
if(dat.first == lft) {
res += dat.second++;
} else {
dat = make_pair(lft, 1);
}
}
cout << res << endl;
}
``````