Skip to content
Related Articles

Related Articles

Minimize count of unique paths from top left to bottom right of a Matrix by placing K 1s
  • Last Updated : 08 Sep, 2020

Given two integers N and M where M and N denote a matrix of dimensions N * M consisting of 0‘s only. The task is to minimize the count of unique paths from the top left (0, 0) to bottom right (N – 1, M – 1) of the matrix across cells consisting of 0’s only by placing exactly K 1s in the matrix.

Note: Neither the bottom right nor the top-left cell can be modified to a 0. 

Examples: 

Input: N = 3, M = 3, K = 1
Output: 2
Explanation: 
Placing K(= 1) 1s in the matrix to generate the matrix [[0, 0, 0], [0, 1, 0], [0, 0, 0]] leaves only two possible paths from top-left to bottom-right cells. 
The paths are[(0, 0) → (0, 1) → (0, 2) → (1, 2) → (2, 2)] and [(0, 0) → (1, 0) → (2, 0) → (2, 1) → (2, 2)]

Input: N = 3, M = 3, K = 3
Output: 0
Explanation:
Placing K(= 3) 1s to generate a matrix [[0, 1, 1], [1, 0, 0], [0, 0, 0]] leaves no possible path from top-left to bottom-right.



Approach: The problem can be solved by considering the following possible cases. 

  1. If K ≥ 2: The count of possible paths can be reduced to 0 by placing two 1s in (0, 1) and (1, 0) cells of the matrix.
  2. If K = 0: The count remains C(N+M-2, N-1).
  3. If K = 1: Place a 1 at the Centre of the matrix, ((N-1)/2, (M-1)/2) to minimize the path count. Therefore, the count of possible paths for this case is as follows:

Result = Total number of ways to reach the bottom right from the top left – ( Number of paths to midpoint from the top left * Number of ways to reach the endpoint from the midpoint) 
where

  • Total number of ways to reach the bottom right from the top left = C(N + M – 2, N – 1)
  • Number of paths to midpoint from the top left = C((N – 1) / 2 + (M – 1) / 2, (N – 1) / 2)
  • Number of ways to reach the endpoint from the midpoint=C(((N – 1) – (N – 1 ) / 2) + ((M – 1) – (M – 1) / 2), ((N – 1) – (N – 1) / 2))

Below is the implementation of the above approach:

C++




// C++ Program to implememnt
// the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the value of
// Binomial Coefficient C(n, k)
int ncr(int n, int k)
{
    int res = 1;
  
    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;
  
    // Calculate the value of
    // [n * (n-1) *---* (n-k+1)] /
    // [k * (k-1) *----* 1]
    for (int i = 0; i < k; ++i) {
        res *= (n - i);
        res /= (i + 1);
    }
  
    return res;
}
  
// Function to find the minimum
// count of paths from top
// left to bottom right by
// placing K 1s in the matrix
int countPath(int N, int M, int K)
{
    int answer;
    if (K >= 2)
        answer = 0;
    else if (K == 0)
        answer = ncr(N + M - 2, N - 1);
    else {
  
        // Count of ways without 1s
        answer = ncr(N + M - 2, N - 1);
  
        // Count of paths from starting
        // point to mid point
        int X = (N - 1) / 2 + (M - 1) / 2;
        int Y = (N - 1) / 2;
        int midCount = ncr(X, Y);
  
        // Count of paths from mid
        // point to end point
        X = ((N - 1) - (N - 1) / 2)
            + ((M - 1) - (M - 1) / 2);
  
        Y = ((N - 1) - (N - 1) / 2);
        midCount *= ncr(X, Y);
        answer -= midCount;
    }
    return answer;
}
  
// Driver Code
int main()
{
    int N = 3;
    int M = 3;
    int K = 1;
  
    cout << countPath(N, M, K);
  
    return 0;
}

Java




// Java Program to implememnt
// the above approach
import java.util.*;
class GFG{
  
// Function to return the value of
// Binomial Coefficient C(n, k)
static int ncr(int n, int k)
{
    int res = 1;
  
    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;
  
    // Calculate the value of
    // [n * (n-1) *---* (n-k+1)] /
    // [k * (k-1) *----* 1]
    for (int i = 0; i < k; ++i) 
    {
        res *= (n - i);
        res /= (i + 1);
    }
    return res;
}
  
// Function to find the minimum
// count of paths from top
// left to bottom right by
// placing K 1s in the matrix
static int countPath(int N, int M, int K)
{
    int answer;
    if (K >= 2)
        answer = 0;
    else if (K == 0)
        answer = ncr(N + M - 2, N - 1);
    else 
    {
        // Count of ways without 1s
        answer = ncr(N + M - 2, N - 1);
  
        // Count of paths from starting
        // point to mid point
        int X = (N - 1) / 2 + (M - 1) / 2;
        int Y = (N - 1) / 2;
        int midCount = ncr(X, Y);
  
        // Count of paths from mid
        // point to end point
        X = ((N - 1) - (N - 1) / 2) + 
            ((M - 1) - (M - 1) / 2);
        Y = ((N - 1) - (N - 1) / 2);
        midCount *= ncr(X, Y);
        answer -= midCount;
    }
    return answer;
}
  
// Driver Code
public static void main(String[] args)
{
    int N = 3;
    int M = 3;
    int K = 1;
    System.out.print(countPath(N, M, K));
}
}
  
// This code is contributed by shikhasingrajput

Python3




#Python3 Program to implememnt
#the above approach
#Function to return the value of
#Binomial Coefficient C(n, k)
def ncr(n, k):
    res = 1
  
    #Since C(n, k) = C(n, n-k)
    if (k > n - k):
        k = n - k
  
    #Calculate the value of
    #[n * (n-1) *---* (n-k+1)] /
    #[k * (k-1) *----* 1]
    for i in range(k):
        res *= (n - i)
        res //= (i + 1)
  
    return res
  
#Function to find the minimum
#count of paths from top
#left to bottom right by
#placing K 1s in the matrix
def countPath(N, M, K):
    answer = 0
    if (K >= 2):
        answer = 0
    elif (K == 0):
        answer = ncr(N + M - 2, N - 1)
    else:
  
        #Count of ways without 1s
        answer = ncr(N + M - 2, N - 1)
  
        #Count of paths from starting
        #poto mid point
        X = (N - 1) // 2 + (M - 1) // 2
        Y = (N - 1) // 2
        midCount = ncr(X, Y)
  
        #Count of paths from mid
        #poto end point
        X = ((N - 1) - (N - 1) // 2)+ 
            ((M - 1) - (M - 1) // 2)
  
        Y = ((N - 1) - (N - 1) // 2)
        midCount *= ncr(X, Y)
        answer -= midCount
  
    return answer
  
#Driver Code
if __name__ == '__main__':
    N = 3
    M = 3
    K = 1
    print(countPath(N, M, K))
  
# This code is contributed by Mohit Kumar 29

C#




// C# program to implememnt
// the above approach
using System;
  
class GFG{
  
// Function to return the value of
// Binomial Coefficient C(n, k)
static int ncr(int n, int k)
{
    int res = 1;
  
    // Since C(n, k) = C(n, n-k)
    if (k > n - k)
        k = n - k;
  
    // Calculate the value of
    // [n * (n-1) *---* (n-k+1)] /
    // [k * (k-1) *----* 1]
    for(int i = 0; i < k; ++i) 
    {
        res *= (n - i);
        res /= (i + 1);
    }
    return res;
}
  
// Function to find the minimum
// count of paths from top
// left to bottom right by
// placing K 1s in the matrix
static int countPath(int N, int M, int K)
{
    int answer;
      
    if (K >= 2)
        answer = 0;
    else if (K == 0)
        answer = ncr(N + M - 2, N - 1);
    else
    {
          
        // Count of ways without 1s
        answer = ncr(N + M - 2, N - 1);
  
        // Count of paths from starting
        // point to mid point
        int X = (N - 1) / 2 + (M - 1) / 2;
        int Y = (N - 1) / 2;
        int midCount = ncr(X, Y);
  
        // Count of paths from mid
        // point to end point
        X = ((N - 1) - (N - 1) / 2) + 
            ((M - 1) - (M - 1) / 2);
        Y = ((N - 1) - (N - 1) / 2);
          
        midCount *= ncr(X, Y);
        answer -= midCount;
    }
    return answer;
}
  
// Driver Code
public static void Main(String[] args)
{
    int N = 3;
    int M = 3;
    int K = 1;
      
    Console.Write(countPath(N, M, K));
}
}
  
// This code is contributed by Amit Katiyar
Output: 
2

Time Complexity: O(N+M)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :