Generate Binary Strings of length N using Branch and Bound
Last Updated :
01 Mar, 2023
Improve
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
// CPP Program to generate
// Binary Strings using Branch and Bound
#include <bits/stdc++.h>
using namespace std;
// Creating a Node class
class Node
{
public:
int *soln;
int level;
vector<Node *> 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<Node *> &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<Node *> 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 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<Node> 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<Node> 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<Node>();
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<Node>();
Q.add(root);
while (Q.size() != 0) {
Node E = Q.poll();
generate(E);
}
}
}
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# 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<Node> 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<Node> 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<Node>();
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<Node>();
Q.Enqueue(root);
while (Q.Count != 0)
{
Node E = Q.Dequeue();
generate(E);
}
}
}
// This code is contributed by Rajput-Ji
// 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:
