Given an integer N, the task is to print all the unique combinations of putting N pieces in an NxN board.
Note: Print (“*”) for pieces and (“-“) for an empty space.
Example:
Input: N = 2
Output:
* *
– –* –
* –* –
– *– *
* –– *
– *– –
* *
Explanation: The total number of empty spaces are 2*2=4 and the pieces to be set is 2 so there are 4C2 combinations ((4!/(2!*2!))=6) possible which is represented above.Input: N = 1
Output: *
Approach: This problem can be solved by using recursion to generate all possible solutions. Now, follow the steps below to solve this problem:
- Create a function named allCombinations, which will generate all possible solutions.
- It will take an integer piecesPlaced denoting the number of total pieces placed, integer N denoting the number of pieces needed to be placed, two integers row and col denoting the row and column where the current piece is going to be placed and a string ans for storing the matrix where pieces are placed, as arguments.
- Now, the initial call to allCombinations will pass 0 as piecesPlaced, N, 0 and 0 as row and col and an empty string as ans.
- In each call, check for the base case, that is:
- If row becomes N and all pieces are placed, i.e. piecesPlaced=N. Then print the ans and return. Else if piecesPlaced is not N, then just return from this call.
- Now make two calls:
- One to add a ‘*’ at the current position, and one to leave that position and add ‘-‘.
- After this, the recursive calls will print all the possible solutions.
Below is the implementation of the above approach.
// C++ Program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to print all // combinations of setting N // pieces in N x N board void allCombinations( int piecesPlaced, int N, int row,
int col, string ans)
{ // If the total 2d array's space
// is exhausted then backtrack.
if (row == N) {
// If all the pieces are
// placed then print the answer.
if (piecesPlaced == N) {
cout << ans;
}
return ;
}
int nr = 0;
int nc = 0;
// Declare one string
// that will set the piece.
string x = "" ;
// Declare one string that
// will leave the space blank.
string y = "" ;
// If the current column
// is out of bounds then
// increase the row
// and set col to 0.
if (col == N - 1) {
nr = row + 1;
nc = 0;
x = ans + "*\n" ;
y = ans + "-\n" ;
}
// Else increase the col
else {
nr = row;
nc = col + 1;
x = ans + "*\t" ;
y = ans + "-\t" ;
}
// Set the piece in the
// box and move ahead
allCombinations(piecesPlaced + 1, N, nr, nc, x);
// Leave the space blank
// and move forward
allCombinations(piecesPlaced, N, nr, nc, y);
} // Driver Code int main()
{ int N = 2;
allCombinations(0, N, 0, 0, "" );
return 0;
} // This code is contributed by rakeshsahni.
|
// Java Program for the above approach import java.io.*;
import java.util.*;
public class main {
// Function to print all
// combinations of setting N
// pieces in N x N board
public static void allCombinations(
int piecesPlaced,
int N, int row,
int col, String ans)
{
// If the total 2d array's space
// is exhausted then backtrack.
if (row == N) {
// If all the pieces are
// placed then print the answer.
if (piecesPlaced == N) {
System.out.println(ans);
}
return ;
}
int nr = 0 ;
int nc = 0 ;
// Declare one string
// that will set the piece.
String x = "" ;
// Declare one string that
// will leave the space blank.
String y = "" ;
// If the current column
// is out of bounds then
// increase the row
// and set col to 0.
if (col == N - 1 ) {
nr = row + 1 ;
nc = 0 ;
x = ans + "*\n" ;
y = ans + "-\n" ;
}
// Else increase the col
else {
nr = row;
nc = col + 1 ;
x = ans + "*\t" ;
y = ans + "-\t" ;
}
// Set the piece in the
// box and move ahead
allCombinations(
piecesPlaced + 1 , N,
nr, nc, x);
// Leave the space blank
// and move forward
allCombinations(piecesPlaced, N,
nr, nc, y);
}
// Driver Code
public static void main(String[] args)
throws Exception
{
int N = 2 ;
allCombinations( 0 , N, 0 , 0 , "" );
}
} |
# Python Program for the above approach # Function to print all # combinations of setting N # pieces in N x N board def allCombinations(piecesPlaced, N, row, col, ans):
# If the total 2d array's space
# is exhausted then backtrack.
if row = = N:
# If all the pieces are
# placed then print the answer.
if piecesPlaced = = N:
print (ans)
return ;
nr = 0
nc = 0
# Declare one string
# that will set the piece.
x = ""
# Declare one string that
# will leave the space blank.
y = ""
# If the current column
# is out of bounds then
# increase the row
# and set col to 0.
if col = = N - 1 :
nr = row + 1
nc = 0
x = ans + "*\n"
y = ans + "-\n"
# Else increase the col
else :
nr = row
nc = col + 1
x = ans + "* "
y = ans + "- "
# Set the piece in the
# box and move ahead
allCombinations(piecesPlaced + 1 , N, nr, nc, x);
# Leave the space blank
# and move forward
allCombinations(piecesPlaced, N, nr, nc, y);
# Driver Code N = 2
allCombinations( 0 , N, 0 , 0 , "")
# This code is contributed by rdtank. |
// C# Program for the above approach using System;
public class main {
// Function to print all
// combinations of setting N
// pieces in N x N board
public static void allCombinations( int piecesPlaced,
int N, int row,
int col, String ans)
{
// If the total 2d array's space
// is exhausted then backtrack.
if (row == N) {
// If all the pieces are
// placed then print the answer.
if (piecesPlaced == N) {
Console.WriteLine(ans);
}
return ;
}
int nr = 0;
int nc = 0;
// Declare one string
// that will set the piece.
String x = "" ;
// Declare one string that
// will leave the space blank.
String y = "" ;
// If the current column
// is out of bounds then
// increase the row
// and set col to 0.
if (col == N - 1) {
nr = row + 1;
nc = 0;
x = ans + "*\n" ;
y = ans + "-\n" ;
}
// Else increase the col
else {
nr = row;
nc = col + 1;
x = ans + "*\t" ;
y = ans + "-\t" ;
}
// Set the piece in the
// box and move ahead
allCombinations(piecesPlaced + 1, N, nr, nc, x);
// Leave the space blank
// and move forward
allCombinations(piecesPlaced, N, nr, nc, y);
}
// Driver Code
public static void Main( string [] args)
{
int N = 2;
allCombinations(0, N, 0, 0, "" );
}
} // This code is contributed by ukasp. |
// Javascript Program for the above approach // Function to print all // combinations of setting N // pieces in N x N board function allCombinations(piecesPlaced, N, row, col, ans) {
// If the total 2d array's space
// is exhausted then backtrack.
if (row == N) {
// If all the pieces are
// placed then print the answer.
if (piecesPlaced == N) {
document.write(ans);
}
return ;
}
let nr = 0;
let nc = 0;
// Declare one string
// that will set the piece.
let x = "" ;
// Declare one string that
// will leave the space blank.
let y = "" ;
// If the current column
// is out of bounds then
// increase the row
// and set col to 0.
if (col == N - 1) {
nr = row + 1;
nc = 0;
x = ans + "*<br>" ;
y = ans + "-<br>" ;
}
// Else increase the col
else {
nr = row;
nc = col + 1;
x = ans + "* " ;
y = ans + "- " ;
}
// Set the piece in the
// box and move ahead
allCombinations(piecesPlaced + 1, N, nr, nc, x);
// Leave the space blank
// and move forward
allCombinations(piecesPlaced, N, nr, nc, y);
} // Driver Code let N = 2; allCombinations(0, N, 0, 0, "" );
// This code is contributed by Saurabh Jaiswal |
Output:
* * - - * - * - * - - * - * * - - * - * - - * *
Time Complexity: O(2^M), where M=N*N
Auxiliary Space: