Coin Change | DP-7 - GeeksforGeeks

29 Mar, 2022
Given a value N, if we want to make change for N cents, and we have infinite supply of each of S = { S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins doesn’t matter.For example, for N = 4 and S = {1,2,3}, there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}. So output should be 4. For N = 10 and S = {2, 5, 3, 6}, there are five solutions: {2,2,2,2,2}, {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}. So the output should be 5.
1) Optimal Substructure To count the total number of solutions, we can divide all set solutions into two sets. 1) Solutions that do not contain mth coin (or Sm). 2) Solutions that contain at least one Sm. Let count(S[], m, n) be the function to count the number of solutions, then it can be written as sum of count(S[], m-1, n) and count(S[], m, n-Sm).Therefore, the problem has optimal substructure property as the problem can be solved using solutions to subproblems. 
2) Overlapping Subproblems Following is a simple recursive implementation of the Coin Change problem. The implementation simply follows the recursive structure mentioned above.
3) Approach (Algorithm)
See, here each coin of a given denomination can come an infinite number of times. (Repetition allowed), this is what we call UNBOUNDED KNAPSACK. We have 2 choices for a coin of a particular denomination, either i) to include, or ii) to exclude.  But here, the inclusion process is not for just once; we can include any denomination any number of times until N<0.
Basically, If we are at s[m-1], we can take as many instances of that coin ( unbounded inclusion ) i.e count(S, m, n – S[m-1] ) ; then we move to s[m-2]. After moving to s[m-2], we can’t move back and can’t make choices for s[m-1] i.e count(S, m-1, n ).
Finally, as we have to find the total number of ways, so we will add these 2 possible choices, i.e count(S, m, n – S[m-1] ) + count(S, m-1, n ) ; which will be our required answer.
C++
C
Java
Python3
C#
PHP
Javascript
// Recursive C++ program for// coin change problem.#include <bits/stdc++.h>using namespace std; // Returns the count of ways we can// sum S[0...m-1] coins to get sum nint count(int S[], int m, int n){         // If n is 0 then there is 1 solution    // (do not include any coin)    if (n == 0)        return 1;         // If n is less than 0 then no    // solution exists    if (n < 0)        return 0;     // If there are no coins and n    // is greater than 0, then no    // solution exist    if (m <= 0 && n >= 1)        return 0;     // count is sum of solutions (i)    // including S[m-1] (ii) excluding S[m-1]    return count(S, m - 1, n) +           count(S, m, n - S[m - 1]);} // Driver codeint main(){    int i, j;    int arr[] = { 1, 2, 3 };    int m = sizeof(arr) / sizeof(arr[0]);         cout << " " << count(arr, m, 4);         return 0;} // This code is contributed by shivanisinghss2110
// Recursive C program for// coin change problem.#include<stdio.h> // Returns the count of ways we can// sum S[0...m-1] coins to get sum nint count( int S[], int m, int n ){    // If n is 0 then there is 1 solution    // (do not include any coin)    if (n == 0)        return 1;         // If n is less than 0 then no    // solution exists    if (n < 0)        return 0;     // If there are no coins and n    // is greater than 0, then no    // solution exist    if (m <=0 && n >= 1)        return 0;     // count is sum of solutions (i)    // including S[m-1] (ii) excluding S[m-1]    return count( S, m - 1, n ) + count( S, m, n-S[m-1] );} // Driver program to test above functionint main(){    int i, j;    int arr[] = {1, 2, 3};    int m = sizeof(arr)/sizeof(arr[0]);    printf("%d ", count(arr, m, 4));    getchar();    return 0;}
// Recursive JAVA program for// coin change problem.import java.util.*;class GFG{ // Returns the count of ways we can// sum S[0...m-1] coins to get sum nstatic int count(int S[], int m, int n){         // If n is 0 then there is 1 solution    // (do not include any coin)    if (n == 0)        return 1;         // If n is less than 0 then no    // solution exists    if (n < 0)        return 0;     // If there are no coins and n    // is greater than 0, then no    // solution exist    if (m <= 0 && n >= 1)        return 0;     // count is sum of solutions (i)    // including S[m-1] (ii) excluding S[m-1]    return count(S, m - 1, n) +           count(S, m, n - S[m - 1]);} // Driver codepublic static void  main(String args[]){    int arr[] = { 1, 2, 3 };    int m = arr.length;         System.out.println(count(arr, m, 4));} } // This code is contributed by jyoti369
# Recursive Python3 program for# coin change problem. # Returns the count of ways we can sum# S[0...m-1] coins to get sum ndef count(S, m, n ):     # If n is 0 then there is 1    # solution (do not include any coin)    if (n == 0):        return 1     # If n is less than 0 then no    # solution exists    if (n < 0):        return 0;     # If there are no coins and n    # is greater than 0, then no    # solution exist    if (m <=0 and n >= 1):        return 0     # count is sum of solutions (i)    # including S[m-1] (ii) excluding S[m-1]    return count( S, m - 1, n ) + count( S, m, n-S[m-1] ); # Driver program to test above functionarr = [1, 2, 3]m = len(arr)print(count(arr, m, 4)) # This code is contributed by Smitha Dinesh Semwal
// Recursive C# program for// coin change problem.using System; class GFG{    // Returns the count of ways we can    // sum S[0...m-1] coins to get sum n    static int count( int []S, int m, int n )    {        // If n is 0 then there is 1 solution        // (do not include any coin)        if (n == 0)            return 1;                 // If n is less than 0 then no        // solution exists        if (n < 0)            return 0;             // If there are no coins and n        // is greater than 0, then no        // solution exist        if (m <=0 && n >= 1)            return 0;             // count is sum of solutions (i)        // including S[m-1] (ii) excluding S[m-1]        return count( S, m - 1, n ) +            count( S, m, n - S[m - 1] );    }         // Driver program    public static void Main()    {                 int []arr = {1, 2, 3};        int m = arr.Length;        Console.Write( count(arr, m, 4));                      }}// This code is contributed by Sam007
<?php// Recursive PHP program for// coin change problem. // Returns the count of ways we can// sum S[0...m-1] coins to get sum nfunction coun($S, $m, $n){         // If n is 0 then there is    // 1 solution (do not include    // any coin)    if ($n == 0)        return 1;         // If n is less than 0 then no    // solution exists    if ($n < 0)        return 0;     // If there are no coins and n    // is greater than 0, then no    // solution exist    if ($m <= 0 && $n >= 1)        return 0;     // count is sum of solutions (i)    // including S[m-1] (ii) excluding S[m-1]    return coun($S, $m - 1,$n ) +           coun($S, $m, $n - $S[$m - 1] );}     // Driver Code    $arr = array(1, 2, 3);    $m = count($arr);    echo coun($arr, $m, 4);     // This code is contributed by Sam007?>
<script>// Recursive javascript program for// coin change problem.    // Returns the count of ways we can// sum S[0...m-1] coins to get sum nfunction count(S , m , n ){     // If n is 0 then there is 1 solution    // (do not include any coin)    if (n == 0)        return 1;         // If n is less than 0 then no    // solution exists    if (n < 0)        return 0;     // If there are no coins and n    // is greater than 0, then no    // solution exist    if (m <=0 && n >= 1)        return 0;     // count is sum of solutions (i)    // including S[m-1] (ii) excluding S[m-1]    return count( S, m - 1, n ) +           count( S, m, n - S[m - 1] );} // Driver program to test above functionvar arr = [1, 2, 3];var m = arr.length;document.write( count(arr, m, 4)); // This code is contributed by Amit Katiyar</script>
 4
It should be noted that the above function computes the same subproblems again and again. See the following recursion tree for S = {1, 2, 3} and n = 5. 
The function C({1}, 3) is called two times. If we draw the complete tree, then we can see that there are many subproblems being called more than once.  
C() --> count()
                             C({1,2,3}, 5)                     
                           /             \    
                         /                 \                  
             C({1,2,3}, 2)                 C({1,2}, 5)
            /       \                      /      \         
           /         \                    /         \   
C({1,2,3}, -1)  C({1,2}, 2)        C({1,2}, 3)    C({1}, 5)
               /    \             /     \           /     \
             /       \           /       \         /        \
    C({1,2},0)  C({1},2)   C({1,2},1) C({1},3)    C({1}, 4)  C({}, 5)
                   / \     / \        /\         /     \         
                  /   \   /   \     /   \       /       \  
                .      .  .     .   .     .   C({1}, 3) C({}, 4)
                                               / \ 
                                              /   \   
                                             .      .
Since same subproblems are called again, this problem has Overlapping Subproblems property. So the Coin Change problem has both properties (see this and this) of a dynamic programming problem. Like other typical Dynamic Programming(DP) problems, recomputations of same subproblems can be avoided by constructing a temporary array table[][] in bottom up manner.
Dynamic Programming Solution  
C++
C
Java
Python
C#
PHP
Javascript
// C++ program for coin change problem.#include<bits/stdc++.h> using namespace std; int count( int S[], int m, int n ){    int i, j, x, y;     // We need n+1 rows as the table    // is constructed in bottom up    // manner using the base case 0    // value case (n = 0)    int table[n + 1][m];         // Fill the entries for 0    // value case (n = 0)    for (i = 0; i < m; i++)        table[0][i] = 1;     // Fill rest of the table entries    // in bottom up manner    for (i = 1; i < n + 1; i++)    {        for (j = 0; j < m; j++)        {            // Count of solutions including S[j]            x = (i-S[j] >= 0) ? table[i - S[j]][j] : 0;             // Count of solutions excluding S[j]            y = (j >= 1) ? table[i][j - 1] : 0;             // total count            table[i][j] = x + y;        }    }    return table[n][m - 1];} // Driver Codeint main(){    int arr[] = {1, 2, 3};    int m = sizeof(arr)/sizeof(arr[0]);    int n = 4;    cout << count(arr, m, n);    return 0;} // This code is contributed// by Akanksha Rai(Abby_akku)
// C program for coin change problem.#include<stdio.h> int count( int S[], int m, int n ){    int i, j, x, y;     // We need n+1 rows as the table is constructed    // in bottom up manner using the base case 0    // value case (n = 0)    int table[n+1][m];        // Fill the entries for 0 value case (n = 0)    for (i=0; i<m; i++)        table[0][i] = 1;     // Fill rest of the table entries in bottom    // up manner     for (i = 1; i < n+1; i++)    {        for (j = 0; j < m; j++)        {            // Count of solutions including S[j]            x = (i-S[j] >= 0)? table[i - S[j]][j]: 0;             // Count of solutions excluding S[j]            y = (j >= 1)? table[i][j-1]: 0;             // total count            table[i][j] = x + y;        }    }    return table[n][m-1];} // Driver program to test above functionint main(){    int arr[] = {1, 2, 3};    int m = sizeof(arr)/sizeof(arr[0]);    int n = 4;    printf(" %d ", count(arr, m, n));    return 0;}
/* Dynamic Programming Java implementation of Coin   Change problem */import java.util.Arrays; class CoinChange{    static long countWays(int S[], int m, int n)    {        //Time complexity of this function: O(mn)        //Space Complexity of this function: O(n)         // table[i] will be storing the number of solutions        // for value i. We need n+1 rows as the table is        // constructed in bottom up manner using the base        // case (n = 0)        long[] table = new long[n+1];         // Initialize all table values as 0        Arrays.fill(table, 0);   //O(n)         // Base case (If given value is 0)        table[0] = 1;         // Pick all coins one by one and update the table[]        // values after the index greater than or equal to        // the value of the picked coin        for (int i=0; i<m; i++)            for (int j=S[i]; j<=n; j++)                table[j] += table[j-S[i]];         return table[n];    }     // Driver Function to test above function    public static void main(String args[])    {        int arr[] = {1, 2, 3};        int m = arr.length;        int n = 4;        System.out.println(countWays(arr, m, n));    }}// This code is contributed by Pankaj Kumar
# Dynamic Programming Python implementation of Coin# Change problemdef count(S, m, n):    # We need n+1 rows as the table is constructed    # in bottom up manner using the base case 0 value    # case (n = 0)    table = [[0 for x in range(m)] for x in range(n+1)]     # Fill the entries for 0 value case (n = 0)    for i in range(m):        table[0][i] = 1     # Fill rest of the table entries in bottom up manner    for i in range(1, n+1):        for j in range(m):             # Count of solutions including S[j]            x = table[i - S[j]][j] if i-S[j] >= 0 else 0             # Count of solutions excluding S[j]            y = table[i][j-1] if j >= 1 else 0             # total count            table[i][j] = x + y     return table[n][m-1] # Driver program to test above functionarr = [1, 2, 3]m = len(arr)n = 4print(count(arr, m, n)) # This code is contributed by Bhavya Jain
/* Dynamic Programming C# implementation of CoinChange problem */using System; class GFG{    static long countWays(int []S, int m, int n)    {        //Time complexity of this function: O(mn)        //Space Complexity of this function: O(n)         // table[i] will be storing the number of solutions        // for value i. We need n+1 rows as the table is        // constructed in bottom up manner using the base        // case (n = 0)        int[] table = new int[n+1];         // Initialize all table values as 0        for(int i = 0; i < table.Length; i++)        {            table[i] = 0;        }         // Base case (If given value is 0)        table[0] = 1;         // Pick all coins one by one and update the table[]        // values after the index greater than or equal to        // the value of the picked coin        for (int i = 0; i < m; i++)            for (int j = S[i]; j <= n; j++)                table[j] += table[j - S[i]];         return table[n];    }     // Driver Function    public static void Main()    {        int []arr = {1, 2, 3};        int m = arr.Length;        int n = 4;        Console.Write(countWays(arr, m, n));    }}// This code is contributed by Sam007
<?php// PHP program for// coin change problem. function count1($S, $m, $n){    // We need n+1 rows as    // the table is constructed    // in bottom up manner    // using the base case 0    // value case (n = 0)    $table;    for ($i = 0; $i < $n + 1; $i++)    for ($j = 0; $j < $m; $j++)        $table[$i][$j] = 0;         // Fill the entries for    // 0 value case (n = 0)    for ($i = 0; $i < $m; $i++)        $table[0][$i] = 1;     // Fill rest of the table    // entries in bottom up manner    for ($i = 1; $i < $n + 1; $i++)    {        for ($j = 0; $j < $m; $j++)        {            // Count of solutions            // including S[j]            $x = ($i-$S[$j] >= 0) ?                  $table[$i - $S[$j]][$j] : 0;             // Count of solutions            // excluding S[j]            $y = ($j >= 1) ?                  $table[$i][$j - 1] : 0;             // total count            $table[$i][$j] = $x + $y;        }    }    return $table[$n][$m-1];} // Driver Code$arr = array(1, 2, 3);$m = count($arr);$n = 4;echo count1($arr, $m, $n); // This code is contributed by mits?>
<script> /* Dynamic Programming javascript implementation of Coin   Change problem */ function countWays(S , m , n){    //Time complexity of this function: O(mn)    //Space Complexity of this function: O(n)     // table[i] will be storing the number of solutions    // for value i. We need n+1 rows as the table is    // constructed in bottom up manner using the base    // case (n = 0)    // Initialize all table values as 0    //O(n)    var table = Array(n+1).fill(0);          // Base case (If given value is 0)    table[0] = 1;     // Pick all coins one by one and update the table    // values after the index greater than or equal to    // the value of the picked coin    for (i=0; i<m; i++)        for (j=S[i]; j<=n; j++)            table[j] += table[j-S[i]];     return table[n];} // Driver Function to test above functionvar arr = [1, 2, 3];var m = arr.length;var n = 4;document.write(countWays(arr, m, n)); // This code is contributed by 29AjayKumar </script>
4
Time Complexity: O(mn) Following is a simplified version of method 2. The auxiliary space required here is O(n) only. 
C++
Java
Python
C#
PHP
Javascript
int count( int S[], int m, int n )         {          // table[i] will be storing the number of solutions for          // value i. We need n+1 rows as the table is constructed          // in bottom up manner using the base case (n = 0)          int table[n+1];          // Initialize all table values as 0          memset(table, 0, sizeof(table));          // Base case (If given value is 0)          table[0] = 1;          // Pick all coins one by one and update the table[] values          // after the index greater than or equal to the value of the          // picked coin          for(int i=0; i<m; i++)          for(int j=S[i]; j<=n; j++)          table[j] += table[j-S[i]];          return table[n];         }         
public static int count( int S[], int m, int n ){    // table[i] will be storing the number of solutions for    // value i. We need n+1 rows as the table is constructed    // in bottom up manner using the base case (n = 0)    int table[]=new int[n+1];     // Base case (If given value is 0)    table[0] = 1;     // Pick all coins one by one and update the table[] values    // after the index greater than or equal to the value of the    // picked coin    for(int i=0; i<m; i++)        for(int j=S[i]; j<=n; j++)            table[j] += table[j-S[i]];     return table[n];}
# Dynamic Programming Python implementation of Coin# Change problemdef count(S, m, n):     # table[i] will be storing the number of solutions for    # value i. We need n+1 rows as the table is constructed    # in bottom up manner using the base case (n = 0)    # Initialize all table values as 0    table = [0 for k in range(n+1)]     # Base case (If given value is 0)    table[0] = 1     # Pick all coins one by one and update the table[] values    # after the index greater than or equal to the value of the    # picked coin    for i in range(0,m):        for j in range(S[i],n+1):            table[j] += table[j-S[i]]     return table[n] # Driver program to test above functionarr = [1, 2, 3]m = len(arr)n = 4x = count(arr, m, n)print (x) # This code is contributed by Afzal Ansari
// Dynamic Programming C# implementation// of Coin Change problemusing System; class GFG{static int count(int []S, int m, int n){    // table[i] will be storing the    // number of solutions for value i.    // We need n+1 rows as the table    // is constructed in bottom up manner    // using the base case (n = 0)    int [] table = new int[n + 1];         // Base case (If given value is 0)    table[0] = 1;     // Pick all coins one by one and    // update the table[] values after    // the index greater than or equal    // to the value of the picked coin    for(int i = 0; i < m; i++)        for(int j = S[i]; j <= n; j++)            table[j] += table[j - S[i]];     return table[n];} // Driver Codepublic static void Main(){    int []arr = {1, 2, 3};    int m = arr.Length;    int n = 4;    Console.Write(count(arr, m, n));}} // This code is contributed by Raj
<?phpfunction count_1( &$S, $m, $n ){    // table[i] will be storing the number    // of solutions for value i. We need n+1    // rows as the table is constructed in    // bottom up manner using the base case (n = 0)    $table = array_fill(0, $n + 1, NULl);     // Base case (If given value is 0)    $table[0] = 1;     // Pick all coins one by one and update    // the table[] values after the index    // greater than or equal to the value    // of the picked coin    for($i = 0; $i < $m; $i++)        for($j = $S[$i]; $j <= $n; $j++)            $table[$j] += $table[$j - $S[$i]];     return $table[$n];} // Driver Code$arr = array(1, 2, 3);$m = sizeof($arr);$n = 4;$x = count_1($arr, $m, $n);echo $x; // This code is contributed// by ChitraNayal?>
<script>    // Dynamic Programming Javascript implementation    // of Coin Change problem           function count(S, m, n)    {        // table[i] will be storing the        // number of solutions for value i.        // We need n+1 rows as the table        // is constructed in bottom up manner        // using the base case (n = 0)        let table = new Array(n + 1);        table.fill(0);         // Base case (If given value is 0)        table[0] = 1;         // Pick all coins one by one and        // update the table[] values after        // the index greater than or equal        // to the value of the picked coin        for(let i = 0; i < m; i++)            for(let j = S[i]; j <= n; j++)                table[j] += table[j - S[i]];         return table[n];    }         let arr = [1, 2, 3];    let m = arr.length;    let n = 4;    document.write(count(arr, m, n));</script>
Output: 
4
Thanks to Rohan Laishram for suggesting this space optimized version.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
References: http://www.algorithmist.com/index.php/Coin_Change
Following is another Top Down DP Approach using memoization:
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; int coinchange(vector<int>& a, int v, int n,               vector<vector<int> >& dp){    if (v == 0)        return dp[n][v] = 1;    if (n == 0)        return 0;    if (dp[n][v] != -1)        return dp[n][v];    if (a[n - 1] <= v) {        // Either Pick this coin or not        return dp[n][v] = coinchange(a, v - a[n - 1], n, dp)                          + coinchange(a, v, n - 1, dp);    }    else // We have no option but to leave this coin        return dp[n][v] = coinchange(a, v, n - 1, dp);}int32_t main(){    int tc = 1;    // cin >> tc;    while (tc--) {        int n, v;        n = 3, v = 4;        vector<int> a = { 1, 2, 3 };        vector<vector<int> > dp(n + 1,                                vector<int>(v + 1, -1));        int res = coinchange(a, v, n, dp);        cout << res << endl;    }}// This Code is Contributed by// Harshit Agrawal NITT
// Java program for the above approachimport java.util.*; class GFG {     static int coinchange(int[] a, int v, int n, int[][] dp)    {        if (v == 0)            return dp[n][v] = 1;        if (n == 0)            return 0;        if (dp[n][v] != -1)            return dp[n][v];        if (a[n - 1] <= v)        {                       // Either Pick this coin or not            return dp[n][v]                = coinchange(a, v - a[n - 1], n, dp)                  + coinchange(a, v, n - 1, dp);        }        else // We have no option but to leave this coin            return dp[n][v] = coinchange(a, v, n - 1, dp);    }   // Driver code    public static void main(String[] args)    {        int tc = 1;        while (tc != 0) {            int n, v;            n = 3;            v = 4;            int[] a = { 1, 2, 3 };            int[][] dp = new int[n + 1][v + 1];            for (int[] row : dp)                Arrays.fill(row, -1);            int res = coinchange(a, v, n, dp);            System.out.println(res);            tc--;        }    }} // This code is contributed by rajsanghavi9.
# Python program for the above approachdef coinchange(a, v, n, dp):    if (v == 0):        dp[n][v] = 1;        return dp[n][v];    if (n == 0):        return 0;    if (dp[n][v] != -1):        return dp[n][v];    if (a[n - 1] <= v):         # Either Pick this coin or not        dp[n][v] = coinchange(a, v - a[n - 1], n, dp) + coinchange(a, v, n - 1, dp);        return dp[n][v];    else: # We have no option but to leave this coin        dp[n][v] = coinchange(a, v, n - 1, dp);        return dp[n][v]; # Driver codeif __name__ == '__main__':    tc = 1;    while (tc != 0):        n = 3;        v = 4;        a = [ 1, 2, 3 ];        dp = [[-1 for i in range(v+1)] for j in range(n+1)]        res = coinchange(a, v, n, dp);        print(res);        tc -= 1;     # This code is contributed by Rajput-Ji
// C# program for the above approachusing System;public class GFG {     static int coinchange(int[] a, int v, int n, int[, ] dp)    {        if (v == 0)            return dp[n, v] = 1;        if (n == 0)            return 0;        if (dp[n, v] != -1)            return dp[n, v];        if (a[n - 1] <= v) {             // Either Pick this coin or not            return dp[n, v]                = coinchange(a, v - a[n - 1], n, dp)                  + coinchange(a, v, n - 1, dp);        }        else // We have no option but to leave this coin            return dp[n, v] = coinchange(a, v, n - 1, dp);    }     // Driver code    public static void Main(String[] args)    {        int tc = 1;        while (tc != 0) {            int n, v;            n = 3;            v = 4;            int[] a = { 1, 2, 3 };            int[, ] dp = new int[n + 1, v + 1];            for (int j = 0; j < n + 1; j++) {                for (int l = 0; l < v + 1; l++)                    dp[j, l] = -1;            }            int res = coinchange(a, v, n, dp);            Console.WriteLine(res);            tc--;        }    }} // This code is contributed by umadevi9616
<script>// javascript program for the above approach     function coinchange(a , v , n,  dp) {        if (v == 0)            return dp[n][v] = 1;        if (n == 0)            return 0;        if (dp[n][v] != -1)            return dp[n][v];        if (a[n - 1] <= v) {             // Either Pick this coin or not            return dp[n][v] = coinchange(a, v - a[n - 1], n, dp) + coinchange(a, v, n - 1, dp);        } else // We have no option but to leave this coin            return dp[n][v] = coinchange(a, v, n - 1, dp);    }     // Driver code             var tc = 1;        while (tc != 0) {            var n, v;            n = 3;            v = 4;            var a = [ 1, 2, 3 ];            var dp = Array(n+1).fill().map(() => Array(v+1).fill(-1));                         var res = coinchange(a, v, n, dp);            document.write(res);            tc--;        } // This code contributed by umadevi9616</script>
4
Time Complexity: O(M*N)Auxiliary Space: O(M*N)
Contributed by: Mayukh Sinha 
Sam007
khyatigrover
Mithun Kumar
nicklodeon10
R_Raj
Akanksha_Rai
ukasp
PLACEMENT__CHAHIYE
piyush25pv
amit143katiyar
29AjayKumar
decode2207
mayukh99
sagartomar9927
shivanisinghss2110
HarshitAgrawal8
akshaysingh98088
rajsanghavi9
roynilarghya
jyoti369
umadevi9616
Rajput-Ji
imcoder
Accolite
Microsoft
Morgan Stanley
Paytm
Samsung
Snapdeal
Dynamic Programming
Greedy
Mathematical
Paytm
Morgan Stanley
Accolite
Microsoft
Samsung
Snapdeal
Dynamic Programming
Greedy
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Largest Sum Contiguous Subarray
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Subset Sum Problem | DP-25
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Program for array rotation
Program for Shortest Job First (or SJF) CPU Scheduling | Set 1 (Non- preemptive)
Fractional Knapsack Problem
Difference between Prim's and Kruskal's algorithm for MST
Program for Least Recently Used (LRU) Page Replacement algorithm