Leetcode题型总结之计算路径数

题型介绍：

给定一个目标值，计算能够实现该目标的所有组合数目或者方法数目。如给定目标值target和数组(不含重复值), 计算和为target的子数组数目；这类题目需要将序列位置i和目标值target作为状态，dp[i][target]=sum{dp[i−1][k]},k=可通过选择l到达target的状态,l=0,1.....，众所周知dp的递推关系是已知状态->所有选择->当前状态(待求)。一般情况下第一维只与上一状态有关可以省略；

如果不好想出dp的定义可以先通过dfs解决，然后将记忆数组作为dp数组。因为dfs中每条路径表示一个解或者序列，因此在计算所有序列数目时，只有在合法的路径的叶子节点返回1，不合法的返回0.向上过程计算所有返回值的和作为合法序列的数目。

def dfs(n, target):
    if n==0 :
        return 1 if target == 0 else 0
    if(memo[n][target]!= -1) 
        return memo[n][target]
    ret = 0
    for path in 所有选择:
        ret += dfs(n-1, target-path);
    return memo[n][target] = ret

例子：

题目1:

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：

输入：nums = [1], target = 1
输出：1

代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum=0;
    int len=nums.size();
    for(int i=0;i<len;i++){
        sum+=nums[i];
    }
    if(target>sum||target<0-sum)return 0;
    vector<vector<int>> v(len+1, vector<int>(2*sum+1,0));
    v[0][sum]=1;
    for(int i=1;i<=len;i++){
        for(int j=0;j<2*sum+1;j++){
            if(v[i-1][j]!=0){
                v[i][j+nums[i-1]]+=v[i-1][j];
                v[i][j-nums[i-1]]+=v[i-1][j];
            }
        }
    }
    return v[len][target+sum];
    }
};

思路：

 使用动态规划的思路，把target和最后一个加的数都看做是状态中的一部分；需要考虑可能是负数的情况，所以vector的长度是2*sum+1；

题目2——1155: 掷骰子的N种方法

这里有 d 个一样的骰子，每个骰子上都有 f 个面，分别标号为 1, 2, ..., f。

我们约定：掷骰子的得到总点数为各骰子面朝上的数字的总和。

如果需要掷出的总点数为 target，请你计算出有多少种不同的组合情况（所有的组合情况总共有 f^d 种），模 10^9 + 7 后返回。

示例 1：

输入：d = 1, f = 6, target = 3
输出：1
示例 2：

输入：d = 2, f = 6, target = 7
输出：6
示例 3：

输入：d = 2, f = 5, target = 10
输出：1
示例 4：

输入：d = 1, f = 2, target = 3
输出：0
示例 5：

输入：d = 30, f = 30, target = 500
输出：222616187

提示：

1 <= d, f <= 30
1 <= target <= 1000

代码：

class Solution {
public:
    int numRollsToTarget(int d, int f, int target) {
         vector<vector<int>> v(d,vector<int>(max(d*f+1,target+1),0));
    int mod=pow(10,9)+7;
    for(int i=0;i<f;i++){
        v[0][i+1]=1;
    }
    for(int i=1;i<d;i++){
        for(int j=0;j<d*f+1;j++){
            if(v[i-1][j]!=0){
                for(int k=1;k<=f;k++){
                    v[i][j+k]=(v[i][j+k]+v[i-1][j])%mod;
                }
            }
        }
    }
    return v[d-1][target];
    }
};

想法：

确定动态规划递推公式是关键，这里v[i][j]表示，第i+1次掷骰子，和为j的所有可能情况数是多少；

题目3——1223: 掷骰子模拟

有一个骰子模拟器会每次投掷的时候生成一个 1 到 6 的随机数。

不过我们在使用它时有个约束，就是使得投掷骰子时，连续 掷出数字 i 的次数不能超过 rollMax[i]（i 从 1 开始编号）。

现在，给你一个整数数组 rollMax 和一个整数 n，请你来计算掷 n 次骰子可得到的不同点数序列的数量。

假如两个序列中至少存在一个元素不同，就认为这两个序列是不同的。由于答案可能很大，所以请返回 模 10^9 + 7 之后的结果。 

示例 1：

输入：n = 2, rollMax = [1,1,2,2,2,3]
输出：34
解释：我们掷 2 次骰子，如果没有约束的话，共有 6 * 6 = 36 种可能的组合。但是根据 rollMax 数组，数字 1 和 2 最多连续出现一次，所以不会出现序列 (1,1) 和 (2,2)。因此，最终答案是 36-2 = 34。
示例 2：

输入：n = 2, rollMax = [1,1,1,1,1,1]
输出：30
示例 3：

输入：n = 3, rollMax = [1,1,1,2,2,3]
输出：181

提示：

1 <= n <= 5000
rollMax.length == 6
1 <= rollMax[i] <= 15

代码：

class Solution {
public:
    const int MOD = 1e9 + 7;
    int dieSimulator(int n, vector<int>& rollMax) {
        long dp[6][16], tmp[6];
        memset(dp, 0, sizeof(dp));
        memset(tmp, 0, sizeof(tmp));

        for (int j = 0; j < 6; j++) {
            dp[j][1] = 1;
            dp[j][0] = 5;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < 6; j++) {
                for (int k = min(rollMax[j], i + 1); k >= 1; k--) {
                    dp[j][k] = dp[j][k - 1];
                    tmp[j] = (tmp[j] + dp[j][k]) % MOD;
                }
            }
            for(int j=0;j<6;j++){
                long t= 0;
                for(int k=0;k<6;k++){
                    if(k==j) continue;
                    t = (t + tmp[k]) % MOD;
                }
                dp[j][0] = t;
            }
            memset(tmp, 0, sizeof(tmp));
        }
        long ans = 0;
        for (int j = 0; j < 16; j++) {
            ans = (ans + dp[0][j]) % MOD;
        }

        return ans;
    }
};

想法：

维持一个二维数组，遍历N次，N表示掷骰子的数目；首先初始化这个二维数组，然后每次更新这个二维数组；dp[i][j]表示，i+1出现j次的种类数；每次遍历，首先遍历1-6，更新dp[i][j]，然后统计每一个字母j 对应的tmp的个数；然后再遍历一个1-6，更新dp[j][0]；

全部遍历结束以后，输出数目总和；