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
Next

Ways of transforming one string to other by removing 0 or more characters
Recommended Articles
Page :
Balanced expressions such that given positions have opening brackets | Set 2
13, Sep 18
Number of balanced bracket expressions that can be formed from a string
06, Dec 18
Printing brackets in Matrix Chain Multiplication Problem
12, Feb 17
Ways to fill N positions using M colors such that there are exactly K pairs of adjacent different colors
24, Dec 18
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
15, Jan 21
Numbers with a Fibonacci difference between Sum of digits at even and odd positions in a given range
09, Apr 20
Color N boxes using M colors such that K boxes have different color from the box on its left
21, Jan 19
Maximum length subsequence such that adjacent elements in the subsequence have a common factor
11, Feb 19
Longest subsequence such that adjacent elements have at least one common digit
25, Feb 19
Maximum size of square such that all submatrices of that size have sum less than K
08, Apr 20
Maximum subset sum such that no two elements in set have same digit in them
04, Jun 19
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Minimize cost of painting N houses such that adjacent houses have different colors
15, Feb 21
Count of Numbers in a Range divisible by m and having digit d in even positions
29, Dec 18
Count Numbers in Range with difference between Sum of digits at even and odd positions as Prime
22, Feb 19
Number of ways to partition a string into two balanced subsequences
15, Nov 18
Maximum possible balanced binary substring splits with at most cost K
18, Nov 21
Count Balanced Binary Trees of Height h
17, Jun 17
Length of Longest Balanced Subsequence
19, Oct 17
Count of numbers in range which are divisible by M and have digit D at odd places
10, Apr 20
Count N-digit numbers whose adjacent digits have equal GCD
21, Jul 21
Find the number of distinct pairs of vertices which have a distance of exactly k in a tree
15, Feb 19
Count numbers from 1 to n that have 4 as a digit
29, Jun 15
Minimize elements to be added to a given array such that it contains another given array as its subsequence
10, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!