# Generate Binary Strings of length N using Branch and Bound

• Difficulty Level : Expert
• Last Updated : 17 Jan, 2020

The task is to generate a binary string of length N using branch and bound technique

Examples:

Input: N = 3
Output:
000
001
010
011
100
101
110
111
Explanation:
Numbers with 3 binary digits are
0, 1, 2, 3, 4, 5, 6, 7

Input: N = 2
Output:
00
01
10
11

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

Approach:

Generate Combinations using Branch and Bound :

• It starts with an empty solution vector.
• While Queue is not empty remove partial vector from queue.
• If it is a final vector print the combination else,
• For the next component of partial vector create k child vectors by fixing all possible states for the next component insert vectors into the queue.

Below is the implementation of the above approach

## C++

 `// CPP Program to generate ` `// Binary Strings using Branch and Bound ` `#include ` `using` `namespace` `std; ` ` `  `// Creating a Node class ` `class` `Node ` `{ ` `public``: ` `    ``int` `*soln; ` `    ``int` `level; ` `    ``vector child; ` `    ``Node *parent; ` ` `  `    ``Node(Node *parent, ``int` `level, ``int` `N) ` `    ``{ ` `        ``this``->parent = parent; ` `        ``this``->level = level; ` `        ``this``->soln = ``new` `int``[N]; ` `    ``} ` `}; ` ` `  `// Utility function to generate binary strings of length n ` `void` `generate(Node *n, ``int` `&N, queue &Q) ` `{ ` `    ``// If list is full print combination ` `    ``if` `(n->level == N) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < N; i++) ` `            ``cout << n->soln[i]; ` `        ``cout << endl; ` `    ``} ` `    ``else` `    ``{ ` `        ``int` `l = n->level; ` ` `  `        ``// iterate while length is not equal to n ` `        ``for` `(``int` `i = 0; i <= 1; i++) ` `        ``{ ` `            ``Node *x = ``new` `Node(n, l + 1, N); ` `            ``for` `(``int` `k = 0; k < l; k++) ` `                ``x->soln[k] = n->soln[k]; ` `            ``x->soln[l] = i; ` `            ``n->child.push_back(x); ` `            ``Q.push(x); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Initiate Generation ` `    ``// Create a root Node ` `    ``int` `N = 3; ` `    ``Node *root; ` `    ``root = ``new` `Node(NULL, 0, N); ` ` `  `    ``// Queue that maintains the list of live Nodes ` `    ``queue Q; ` `     `  `    ``// Instantiate the Queue ` `    ``Q.push(root); ` ` `  `    ``while` `(!Q.empty()) ` `    ``{ ` `        ``Node *E = Q.front(); ` `        ``Q.pop(); ` `        ``generate(E, N, Q); ` `    ``} ` ` `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Java

 `// Java Program to generate ` `// Binary Strings using Branch and Bound ` ` `  `import` `java.io.*; ` `import` `java.util.*; ` ` `  `// Creating a Node class ` `class` `Node { ` ` `  `    ``int` `soln[]; ` `    ``int` `level; ` `    ``ArrayList child; ` `    ``Node parent; ` ` `  `    ``Node(Node parent, ``int` `level, ``int` `N) ` `    ``{ ` `        ``this``.parent = parent; ` `        ``this``.level = level; ` `        ``this``.soln = ``new` `int``[N]; ` `    ``} ` `} ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `N; ` ` `  `    ``// Queue that maintains the list of live Nodes ` `    ``public` `static` `Queue Q; ` ` `  `    ``// Utility function to generate binary strings of length n ` `    ``public` `static` `void` `generate(Node n) ` `    ``{ ` `        ``// If list is full print combination ` `        ``if` `(n.level == N) { ` `            ``for` `(``int` `i = ``0``; i <= N - ``1``; i++) { ` `                ``System.out.print(n.soln[i]); ` `            ``} ` `            ``System.out.println(); ` `        ``} ` `        ``else` `{ ` ` `  `            ``// Create a new vector for new combination ` `            ``n.child = ``new` `ArrayList(); ` ` `  `            ``int` `l = n.level; ` ` `  `            ``// iterate while length is not equal to n ` `            ``for` `(``int` `i = ``0``; i <= ``1``; i++) { ` `                ``Node x = ``new` `Node(n, l + ``1``, N); ` `                ``for` `(``int` `k = ``0``; k < l; k++) { ` `                    ``x.soln[k] = n.soln[k]; ` `                ``} ` `                ``x.soln[l] = i; ` `                ``n.child.add(x); ` `                ``Q.add(x); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``// Initiate Generation ` `        ``// Create a root Node ` `        ``N = ``3``; ` `        ``Node root = ``new` `Node(``null``, ``0``, N); ` ` `  `        ``// Instantiate the Queue ` `        ``Q = ``new` `LinkedList(); ` `        ``Q.add(root); ` ` `  `        ``while` `(Q.size() != ``0``) { ` `            ``Node E = Q.poll(); ` `            ``generate(E); ` `        ``} ` `    ``} ` `} `

## C#

 `// C# Program to generate ` `// Binary Strings using Branch and Bound ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `// Creating a Node class ` `public` `class` `Node  ` `{ ` `    ``public` `int` `[]soln; ` `    ``public` `int` `level; ` `    ``public` `List child; ` `    ``public` `Node parent; ` ` `  `    ``public` `Node(Node parent,  ` `                ``int` `level, ``int` `N) ` `    ``{ ` `        ``this``.parent = parent; ` `        ``this``.level = level; ` `        ``this``.soln = ``new` `int``[N]; ` `    ``} ` `} ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `N; ` ` `  `    ``// Queue that maintains the list of live Nodes ` `    ``public` `static` `Queue Q; ` ` `  `    ``// Utility function to generate  ` `    ``// binary strings of length n ` `    ``public` `static` `void` `generate(Node n) ` `    ``{ ` `        ``// If list is full print combination ` `        ``if` `(n.level == N) ` `        ``{ ` `            ``for` `(``int` `i = 0; i <= N - 1; i++) ` `            ``{ ` `                ``Console.Write(n.soln[i]); ` `            ``} ` `            ``Console.WriteLine(); ` `        ``} ` `        ``else` `        ``{ ` ` `  `            ``// Create a new vector for new combination ` `            ``n.child = ``new` `List(); ` ` `  `            ``int` `l = n.level; ` ` `  `            ``// iterate while length is not equal to n ` `            ``for` `(``int` `i = 0; i <= 1; i++)  ` `            ``{ ` `                ``Node x = ``new` `Node(n, l + 1, N); ` `                ``for` `(``int` `k = 0; k < l; k++)  ` `                ``{ ` `                    ``x.soln[k] = n.soln[k]; ` `                ``} ` `                ``x.soln[l] = i; ` `                ``n.child.Add(x); ` `                ``Q.Enqueue(x); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{ ` `        ``// Initiate Generation ` `        ``// Create a root Node ` `        ``N = 3; ` `        ``Node root = ``new` `Node(``null``, 0, N); ` ` `  `        ``// Instantiate the Queue ` `        ``Q = ``new` `Queue(); ` `        ``Q.Enqueue(root); ` ` `  `        ``while` `(Q.Count != 0) ` `        ``{ ` `            ``Node E = Q.Dequeue(); ` `            ``generate(E); ` `        ``} ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```000
001
010
011
100
101
110
111
```

Time Complexity:

My Personal Notes arrow_drop_up
Recommended Articles
Page :