Skip to content
Related Articles

Related Articles

Balanced expressions such that given positions have opening brackets

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 28 May, 2021
View Discussion
Improve Article
Save Article

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 DPi, 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 DP2N, 0 is the final answer.
The base case of the DP is, DP0, 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) dpi, j = dpi-1, j-1
else  dpi, j =  0; 

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

if(j != 0) dpi, j = dpi - 1, j - 1 + dpi - 1, j + 1
 else  dpi, j = dpi - 1, j + 1

The answer will be DP2n, 0
Given below is the 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;
}

Java




// Java code to find number of ways of
// arranging bracket with proper expressions
 
public class GFG {
 
    static final int N = 1000;
 
// function to calculate the number
// of proper bracket sequence
    static long arrangeBraces(int n, int pos[], int k) {
 
        // hash array to mark the
        // positions of opening brackets
        boolean h[] = new boolean[N];
 
        // dp 2d array
        int dp[][] = new int[N][N];
 
        // mark positions in hash array
        for (int i = 0; i < k; i++) {
            h[pos[i]] = true;
        }
 
        // 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
 
    public static void main(String[] args) {
        int n = 3;
 
        // positions where opening braces
        // will be placed
        int pos[] = {2};
        int k = pos.length;
        System.out.print(arrangeBraces(n, pos, k));
    }
}
// This code is contributed by 29AjayKumar

Python3




# Python 3 code to find number of ways of
# arranging bracket with proper expressions
N = 1000
 
# function to calculate the number
# of proper bracket sequence
def arrangeBraces(n, pos, k):
     
    # hash array to mark the
    # positions of opening brackets
    h = [False for i in range(N)]
 
    # dp 2d array
    dp = [[0 for i in range(N)]
             for i in range(N)]
 
    # mark positions in hash array
    for i in range(k):
        h[pos[i]] = 1
 
    # first position marked as 1
    dp[0][0] = 1
 
    # iterate and formulate the recurrences
    for i in range(1, 2 * n + 1):
        for j in range(2 * n + 1):
             
            # 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
n = 3
 
# positions where opening braces
# will be placed
pos = [ 2 ,];
k = len(pos)
print(arrangeBraces(n, pos, k))
 
# This code is contributed
# by sahishelangia

C#




// C# code to find number of ways of
// arranging bracket with proper expressions
using System;
   
class GFG
{
    static int N = 1000;
   
    // function to calculate the number
    // of proper bracket sequence
    public static long arrangeBraces(int n, int[] pos, int k)
    {
       
        // hash array to mark the
        // positions of opening brackets
        bool[] h = new bool[N];
       
        // dp 2d array
        int[,] dp = new int[N,N];
       
        for(int i = 0; i < N; i++)
            h[i] = false;
         
        for(int i = 0; i < N; i++)
            for(int j = 0; j < N; j++)
                dp[i,j] = 0;
       
        // mark positions in hash array
        for (int i = 0; i < k; i++)
            h[pos[i]] = true;
       
        // 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
    static void Main()
    {
        int n = 3;
         
        // positions where opening braces
        // will be placed
        int[] pos = new int[]{ 2 };
        int k = pos.Length;
       
        Console.Write(arrangeBraces(n, pos, k));
    }
    //This code is contributed by DrRoot_
}

Javascript




<script>
    // Javascript code to find number of ways of
    // arranging bracket with proper expressions
     
    let N = 1000;
   
    // function to calculate the number
    // of proper bracket sequence
    function arrangeBraces(n, pos, k) {
   
        // hash array to mark the
        // positions of opening brackets
        let h = new Array(N);
        h.fill(false);
   
        // dp 2d array
        let dp = new Array(N);
        for (let i = 0; i < N; i++)
        {
            dp[i] = new Array(N);
            for (let j = 0; j < N; j++)
            {
                dp[i][j] = 0;
            }
        }
   
        // mark positions in hash array
        for (let i = 0; i < k; i++) {
            h[pos[i]] = true;
        }
   
        // first position marked as 1
        dp[0][0] = 1;
   
        // iterate and formulate the recurrences
        for (let i = 1; i <= 2 * n; i++) {
            for (let 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];
    }
     
    let n = 3;
   
    // positions where opening braces
    // will be placed
    let pos = [2];
    let k = pos.length;
    document.write(arrangeBraces(n, pos, k));
     
</script>

Output : 
 

3

Time Complexity: O(n^2) 
Auxiliary Space: O(n^2)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!