Before we start solving this problem, let’s do some math first. The problem statement clearly states that we have N pairs of parentheses to work with. That means for a string to be considered as part of the solution, it must be of size 2N.

Once we have generated a string of size 2N, for it to actually be a part of the solution, we will have to check if there is a balance in the opening and closing parentheses. If these conditions are met, the string is a part of the solution.

How many strings can be generated? At every index in the string we have 2 options, i.e. either a ( or a ) and we have to make this selection 2N times, that gives us a total of 2^2N strings.

For example, with N = 3, the length of the string should be 6 and there will be 2x2x2x2x2x2 or 2^6 strings that can be generated. Once a string has been generated, it will take us O(N) time to scan the string and validate it.

This crude algorithm will give us a time complexity of O(Nx2^2N) where N comes from scanning and 2^2N comes from generating. The space complexity can be limited to O(2^2N) for holding all the generated strings.

To make this solution more efficient, we should come up with a way that allows us to check if it’s okay to add a ( or a ) and this can be done by keeping count. We know for a fact that at any given point the number of ( has to be less than or equal to N and for the string to be balanced, the number of ) has to be less than or equal to (. This is the crucial part. I messed up my initial implementation of the code by assuming that ) also has to be less than or equal to N and as a result I started generated unbalanced strings.

This is a classic backtracking problem and can be solved using recursion. The code to do this looks something like:

``````func generateParenthesis(_ n: Int) -> [String] {
var result = [String]()
var s: String = ""

func backtrack(numOpen:Int = 0, numClose: Int = 0) {
if s.count == 2 * n {
result.append(s)
return
}

if numOpen < n {
s.append("(")
backtrack(numOpen: numOpen + 1, numClose: numClose)
s.removeLast()
}

if numClose < numOpen {
s.append(")")
backtrack(numOpen: numOpen, numClose: numClose + 1)
s.removeLast()
}
}

backtrack()
return result
}
``````

Time and Space Complexity: We have only generated only those strings that will be a part of the valid solution which is essentially a subset of the 2^2N elements. It turns out this is the Nth Catalan number which is basically the kind of math I am unfamiliar with! Leetcode has a not so detailed instruction on this.

Code hosted on Github.