Print all unique combinations of setting N pieces on an NxN board

Last Updated : 06 Dec, 2021

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++

// 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

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

Python3

# 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#

// 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

// 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: $O(1)$

My Personal Notes

Related Articles

Table of Contents

Print all unique combinations of setting N pieces on an NxN board

C++

Java

Python3

C#

Javascript

Start Your Coding Journey Now!