# Generate Binary Strings of length N using Branch and Bound

Last Updated : 01 Mar, 2023

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

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);``        ``}``    ``}``}`

## Python3

 `from` `queue ``import` `Queue` `# Creating a Node class``class` `Node:``    ``def` `__init__(``self``, parent, level, N):``        ``self``.parent ``=` `parent``        ``self``.level ``=` `level``        ``self``.soln ``=` `[``0``]``*``N``        ``self``.child ``=` `[]` `# Queue that maintains the list of live Nodes``Q ``=` `Queue()` `# Utility function to generate binary strings of length n``def` `generate(n):``    ``# If list is full print combination``    ``if` `n.level ``=``=` `N:``        ``print``(''.join(``str``(x) ``for` `x ``in` `n.soln))``    ``else``:``        ``# Create a new list for new combination``        ``n.child ``=` `[]` `        ``l ``=` `n.level` `        ``# iterate while length is not equal to n``        ``for` `i ``in` `range``(``2``):``            ``x ``=` `Node(n, l ``+` `1``, N)``            ``x.soln[:l] ``=` `n.soln[:l]``            ``x.soln[l] ``=` `i``            ``n.child.append(x)``            ``Q.put(x)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``# Initiate Generation``    ``# Create a root Node``    ``N ``=` `3``    ``root ``=` `Node(``None``, ``0``, N)` `    ``# Instantiate the Queue``    ``Q.put(root)` `    ``while` `not` `Q.empty():``        ``E ``=` `Q.get()``        ``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`

## Javascript

 `// Javascript code for the above approach` `// Creating a Node class``class Node {``  ``constructor(parent, level, N) {``    ``this``.parent = parent;``    ``this``.level = level;``    ``this``.soln = ``new` `Array(N).fill(0);``    ``this``.child = [];``  ``}``}` `// Queue that maintains the list of live Nodes``const Q = [];` `// Utility function to generate binary strings of length n``function` `generate(n, N) {``  ``// If list is full print combination``  ``if` `(n.level === N) {``    ``console.log(n.soln.join(``""``));``  ``} ``else` `{``    ``// Create a new list for new combination``    ``n.child = [];` `    ``const l = n.level;` `    ``// iterate while length is not equal to n``    ``for` `(let i = 0; i < 2; i++) {``      ``const x = ``new` `Node(n, l + 1, N);``      ``x.soln = n.soln.slice();``      ``x.soln[l] = i;``      ``n.child.push(x);``      ``Q.push(x);``    ``}``  ``}``}` `// Driver code``(() => {``  ``// Initiate Generation``  ``// Create a root Node``  ``const N = 3;``  ``const root = ``new` `Node(``null``, 0, N);` `  ``// Instantiate the Queue``  ``Q.push(root);` `  ``while` `(Q.length > 0) {``    ``const E = Q.shift();``    ``generate(E, N);``  ``}``})();`  `// This code is contributed by sdeadityasharma`

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

Time Complexity:

Previous
Next