Given an integer n and an array of positions ‘position[]’ (1 <= position[i] <= 2n), find the number of ways of proper bracket expressions that can be formed of length 2n such that given positions have opening bracket.
**Examples :**

Input : n = 3, position[] = [2} Output : 3 Explanation : The proper bracket sequences of length 6 and opening bracket at position 2 are: [ [ ] ] [ ] [ [ [ ] ] ] [ [ ] [ ] ] Input : n = 2, position[] = {1, 3} Output : 1 Explanation: The only possibility is: [ ] [ ]

**Approach : ** This problem can be solved by **Dynamic programming.**.

Let **DP _{i, j} **be the number of valid ways of filling the first i positions such that there are j more brackets of type ‘[‘ than of type ‘]’. Valid ways would mean that it is the prefix of a matched bracket expression and that the locations at which enforced ‘[‘ brackets are enforced, have been satisfied. It is easy to see that DP

_{2N, 0}is the final answer.

The base case of the DP is, ** DP _{0, 0}=1.** We need to fill the first position with a ‘[‘ bracket, and there is only way to do this.

If the position **has a opening bracket sequence** which can be marked by a hash array, then the recurrence occurs as :

if(j != 0) dp_{i, j = dpi-1, j-1 else dpi, j = 0; }

If the position has **no opening bracket sequence**, then **recurrence** happens as :

if(j != 0) dp_{i, j}= dp_{i - 1, j - 1}+ dp_{i - 1, j + 1}else dp_{i, j}= dp_{i - 1, j + 1}

The answer will be** DP _{2n, 0}**

Given below is the CPP implementation of the above approach :

## C++

`// CPP code to find number of ways of ` `// arranging bracket with proper expressions ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `#define N 1000 ` ` ` `// function to calculate the number ` `// of proper bracket sequence ` `long` `long` `arrangeBraces(` `int` `n, ` `int` `pos[], ` `int` `k) ` `{ ` ` ` ` ` `// hash array to mark the ` ` ` `// positions of opening brackets ` ` ` `bool` `h[N]; ` ` ` ` ` `// dp 2d array ` ` ` `int` `dp[N][N]; ` ` ` ` ` `memset` `(h, 0, ` `sizeof` `h); ` ` ` `memset` `(dp, 0, ` `sizeof` `dp); ` ` ` ` ` `// mark positions in hash array ` ` ` `for` `(` `int` `i = 0; i < k; i++) ` ` ` `h[pos[i]] = 1; ` ` ` ` ` `// first position marked as 1 ` ` ` `dp[0][0] = 1; ` ` ` ` ` `// iterate and formulate the recurrences ` ` ` `for` `(` `int` `i = 1; i <= 2 * n; i++) { ` ` ` `for` `(` `int` `j = 0; j <= 2 * n; j++) { ` ` ` ` ` `// if position has a opening bracket ` ` ` `if` `(h[i]) { ` ` ` `if` `(j != 0) ` ` ` `dp[i][j] = dp[i - 1][j - 1]; ` ` ` `else` ` ` `dp[i][j] = 0; ` ` ` `} ` ` ` `else` `{ ` ` ` `if` `(j != 0) ` ` ` `dp[i][j] = dp[i - 1][j - 1] + ` ` ` `dp[i - 1][j + 1]; ` ` ` `else` ` ` `dp[i][j] = dp[i - 1][j + 1]; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// return answer ` ` ` `return` `dp[2 * n][0]; ` `} ` ` ` `// driver code ` `int` `main() ` `{ ` ` ` `int` `n = 3; ` ` ` ` ` `// positions where opening braces ` ` ` `// will be placed ` ` ` `int` `pos[] = { 2 }; ` ` ` `int` `k = ` `sizeof` `(pos)/` `sizeof` `(pos[0]); ` ` ` ` ` `cout << arrangeBraces(n, pos, k); ` ` ` `return` `0; ` `} ` |

Output :

3

**Time Complexity:** O(n^2)

**Auxiliary Space:** O(n^2)

## Recommended Posts:

- Paytm Interview experience for FTE (On-Campus)
- Balanced expressions such that given positions have opening brackets | Set 2
- Traversal of tree with k jumps allowed between nodes of same height
- Check if it is possible to transform one string to another
- Longest alternating sub-array starting from every index in a Binary Array
- Coin game winner where every player has three choices
- Ways of transforming one string to other by removing 0 or more characters
- Ways to write n as sum of two or more positive integers
- Count All Palindromic Subsequence in a given String
- Ways to arrange Balls such that adjacent balls are of different types
- Partition a set into two subsets such that the difference of subset sums is minimum
- Bitmasking and Dynamic Programming | Set 1 (Count ways to assign unique cap to every person)
- Longest Even Length Substring such that Sum of First and Second Half is same
- Word Wrap Problem | DP-19
- Overlapping Subproblems Property in Dynamic Programming | DP-1

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.