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 <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
// 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);
}
}
} |
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<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
// 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: