递归与动态规划

矩阵的最小路径和

给一个矩阵，从左上角走到右下角，只能向右或向下走，求和最小的路径。

#include <bits/stdc++.h>
using namespace std;

// 普通的动态规划,空间复杂度和时间复杂度均为O(N*M)
int minSumPath(vector<vector<int> > a) {
    if (a.size() == 0 || a[0].size() == 0)
        return 0;
    int row = a.size(), col = a[0].size();
    vector<vector<int> > dp(row, vector<int>(col));
    dp[0][0] = a[0][0];
    for (int i = 1; i < row; ++i) {
        dp[i][0] = dp[i-1][0] + a[i][0];
    }
    for (int j = 1; j < col; ++j) {
        dp[0][j] = dp[0][j-1] + a[0][j];
    }
    for (int i = 1; i < row; ++i) {
        for (int j = 1; j < col; ++j) {
            dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + a[i][j];
        }
    }
    return dp[row-1][col-1];
}

// 只维护一个数组，每遍历一层的时候更新数组.时间复杂度为O(N*M),空间复杂度为O(min{N,M})
int minSumPath2(vector<vector<int> > a) {
    if (a.size() == 0 || a[0].size() == 0)
        return 0;
    int row = a.size(), col = a[0].size();
    int more = max(row, col), less = min(row, col);
    vector<int> dp(less);
    dp[0] = a[0][0];
    for (int i = 1; i < less; i++)
        dp[i] = dp[i-1] + (row > col ? a[0][i] : a[i][0]);
    for (int i = 1; i < more; i++) {
        dp[0] = dp[0] + (row > col ? a[i][0] : a[0][i]);
        for (int j = 1; j < col; j++) {
            dp[j] = min(dp[j-1],dp[j]) + (row > col ? a[i][j] : a[j][i]);
        }
    }
    return dp[less-1];
}

int main(int argc, char const *argv[]) {
    vector<vector<int> > a {
  {
  1,3,5,9}, {
  8,1,3,4},{
  5,0,6,1},{
  8,8,4,0}};
    cout << minSumPath(a) << endl;
    cout << minSumPath2(a) << endl;
    return 0;
}

换钱的最少货币数

问题一：给定数组arr中所有的值都代表一种面值的货币，每种面值的货币可以使用任意张。 再给定一个整数aim代表要找的钱，求组成aim的最少货币数

问题二：给定数组arr中所有的值都代表一种面值的货币，每种面值的货币只可以使用一次。再给定一个整数aim代表要找的钱，求组成aim的最少货币数

#include <bits/stdc++.h>
using namespace std;

/*
      给定数组arr中所有的值都代表一种面值的货币，每种面值的货币可以使用任意张。
      再给定一个整数aim代表要找的钱，求组成aim的最少货币数
*/

// 时间复杂度和空间复杂度均为O(N*aim),N为数组长度
int minCoins(vector<int> a, int aim) {
    if (a.size() == 0 || aim < 0) return 0;
    int n = a.size();
    // dp[i][j]的含义：在可以任意使用a[0..i]货币的情况下，组成j所需的最小张数
    vector<vector<int> > dp(n, vector<int>(aim+1));
    for (int j = 1; j <= aim; ++j) {
        dp[0][j] = INT_MAX;  // 表示只用第一种货币，组成j所需的最小张数，不能组成设置为最大值MAX
        if (j - a[0] >= 0 && dp[0][j-a[0]] != INT_MAX) // 避免j-a[0]<0，作为数组下标会溢出
            dp[0][j] = dp[0][j-a[0]]+