# Minimize count of unique paths from top left to bottom right of a Matrix by placing K 1s

• Last Updated : 06 May, 2022

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 implement``// the above approach` `#include ``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 implement``// 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 implement``#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``        ``#point to mid point``        ``X ``=` `(N ``-` `1``) ``/``/` `2` `+` `(M ``-` `1``) ``/``/` `2``        ``Y ``=` `(N ``-` `1``) ``/``/` `2``        ``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``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 implement``// 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`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up