# Length of Longest Balanced Subsequence

Given a string S, find the length of longest balanced subsequence in it. A balanced string is defined as:-

• A Null string is a balanced string.
• If X and Y are balanced strings, then (X)Y and XY are balanced strings.

Examples :

```Input : S = "()())"
Output : 4

()() is the longest balanced subsequence
of length 4.

Input : s = "()(((((()"
Output : 4
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A brute force approach is to find all subsequence of the given string S and check for all possible subsequence if it form a balanced sequence, if yes, compare it with maximum value.

The better approach is to use Dynamic Programming.

Longest Balananced Subsequence (LBS), can be recursively defined as below.

```LBS of substring str[i..j] :
If str[i] == str[j]
LBS(str, i, j) = LBS(str, i + 1, j - 1) + 2
Else
LBS(str, i, j) = max(LBS(str, i, k) +
LBS(str, k + 1, j))
Where i <= k < j
```

Declare a 2D matrix dp[][], where our state dp[i][j] will denote the length of longest balanced subsequence from index i to j. We will compute this state in order of increasing j – i. For a particular state dp[i][j], we will try to match the jth symbol with kth symbol, that can be done only if S[k] is ‘(‘ and S[j] is ‘)’, we will take the max of 2 + dp[i][k – 1] + dp[k + 1][j – 1] for all such possible k and also max(dp[i + 1][j], dp[i][j – 1]) and put the value in dp[i][j]. In this way we can fill all the dp states. dp[length of string – 1] (considering 0 indexing) will be our answer.

Below is the implementation of this approach:

## C++

 `// C++ program to find length of  ` `// the longest balanced subsequence ` `#include ` `using` `namespace` `std; ` ` `  `int` `maxLength(``char` `s[], ``int` `n) ` `{ ` `    ``int` `dp[n][n]; ` `    ``memset``(dp, 0, ``sizeof``(dp)); ` ` `  `    ``// Considering all balanced  ` `    ``// substrings of length 2 ` `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `        ``if` `(s[i] == ``'('` `&& s[i + 1] == ``')'``) ` `            ``dp[i][i + 1] = 2; ` ` `  `    ``// Considering all other substrings ` `    ``for` `(``int` `l = 2; l < n; l++)  ` `    ``{ ` `        ``for` `(``int` `i = 0, j = l; j < n; i++, j++)  ` `        ``{ ` `            ``if` `(s[i] == ``'('` `&& s[j] == ``')'``) ` `                ``dp[i][j] = 2 + dp[i + 1][j - 1]; ` ` `  `            ``for` `(``int` `k = i; k < j; k++)  ` `                ``dp[i][j] = max(dp[i][j], ` `                              ``dp[i][k] +  ` `                          ``dp[k + 1][j]);          ` `        ``} ` `    ``} ` ` `  `    ``return` `dp[n - 1]; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``char` `s[] = ``"()(((((()"``; ` `    ``int` `n = ``strlen``(s); ` `    ``cout << maxLength(s, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find length of the ` `// longest balanced subsequence. ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `static` `int` `maxLength(String s, ``int` `n) ` `{ ` `    ``int` `dp[][] = ``new` `int``[n][n]; ` `     `  ` `  `    ``// Considering all balanced substrings  ` `    ``// of length 2 ` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) ` `        ``if` `(s.charAt(i) == ``'('` `&&   ` `                ``s.charAt(i + ``1``)    == ``')'``) ` `            ``dp[i][i + ``1``] = ``2``; ` ` `  `    ``// Considering all other substrings ` `    ``for` `(``int` `l = ``2``; l < n; l++)  ` `    ``{ ` `        ``for` `(``int` `i = ``0``, j = l; j < n; i++, j++)  ` `        ``{ ` `            ``if` `(s.charAt(i) == ``'('` `&&  ` `                      ``s.charAt(j) == ``')'``) ` `                ``dp[i][j] = ``2` `+ dp[i + ``1``][j - ``1``]; ` ` `  `            ``for` `(``int` `k = i; k < j; k++)  ` `                ``dp[i][j] = Math.max(dp[i][j], ` `                        ``dp[i][k] + dp[k + ``1``][j]);      ` `                             `  `        ``} ` `    ``} ` ` `  `    ``return` `dp[``0``][n - ``1``]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String s = ``"()(((((()"``; ` `    ``int` `n = s.length() ; ` `    ``System.out.println(maxLength(s, n)); ` `} ` `} ` `// This code is contributed by Prerna Saini `

## Python3

 `# Python3 program to find length of  ` `# the longest balanced subsequence  ` ` `  `def` `maxLength(s, n): ` `     `  `    ``dp ``=` `[[``0` `for` `i ``in` `range``(n)] ` `             ``for` `i ``in` `range``(n)] ` `              `  `    ``# Considering all balanced  ` `    ``# substrings of length 2  ` `    ``for` `i ``in` `range``(n ``-` `1``):  ` `        ``if` `(s[i] ``=``=` `'('` `and` `s[i ``+` `1``] ``=``=` `')'``):  ` `            ``dp[i][i ``+` `1``] ``=` `2` ` `  `    ``# Considering all other substrings  ` `    ``for` `l ``in` `range``(``2``, n): ` `        ``i ``=` `-``1` `        ``for` `j ``in` `range``(l, n): ` `            ``i ``+``=` `1` `            ``if` `(s[i] ``=``=` `'('` `and` `s[j] ``=``=` `')'``):  ` `                ``dp[i][j] ``=` `2` `+` `dp[i ``+` `1``][j ``-` `1``]  ` `            ``for` `k ``in` `range``(i, j):  ` `                ``dp[i][j] ``=` `max``(dp[i][j], dp[i][k] ``+` `                                         ``dp[k ``+` `1``][j]) ` `    ``return` `dp[``0``][n ``-` `1``]  ` ` `  `# Driver Code  ` `s``=` `"()(((((()"` `n ``=` `len``(s) ` `print``(maxLength(s, n))  ` ` `  `# This code is contributed  ` `# by sahishelangia `

## C#

 `// C# program to find length of the ` `// longest balanced subsequence. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `static` `int` `maxLength(String s, ``int` `n) ` `{ ` `    ``int` `[,]dp = ``new` `int``[n, n]; ` `     `  ` `  `    ``// Considering all balanced substrings  ` `    ``// of length 2 ` `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `        ``if` `(s[i] == ``'('` `&& s[i + 1] == ``')'``) ` `            ``dp[i, i + 1] = 2; ` ` `  `    ``// Considering all other substrings ` `    ``for` `(``int` `l = 2; l < n; l++)  ` `    ``{ ` `        ``for` `(``int` `i = 0, j = l; j < n; i++, j++)  ` `        ``{ ` `            ``if` `(s[i] == ``'('` `&& s[j] == ``')'``) ` `                ``dp[i, j] = 2 + dp[i + 1, j - 1]; ` ` `  `            ``for` `(``int` `k = i; k < j; k++)  ` `                ``dp[i, j] = Math.Max(dp[i, j], ` `                        ``dp[i, k] + dp[k + 1, j]);      ` `        ``} ` `    ``} ` ` `  `    ``return` `dp[0, n - 1]; ` `} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``string` `s = ``"()(((((()"``; ` `        ``int` `n = s.Length ; ` `        ``Console.WriteLine(maxLength(s, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output:

```4
```

Time Complexity : O(n2)
Auxiliary Space : O(n2)

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.