LeetCode 1575 计数型动态规划（自底向上 + 自顶向下）

题目链接：https://leetcode-cn.com/problems/count-all-possible-routes/

自底向上

• 为什么想到动态规划：最优子结构：到达终点的方案数肯定由到达其他点的,不同油量的方案数求和。
• 如何定义状态：城市肯定在状态里，因为其他城市有不同的剩余油量的状态，且油量为0无法到达，也成为限制之一。所以油量也必须在状态里：$dp(i,f)$表示到达第 $i$个城市，剩余油量为$f$ 的方案数。
• 状态转移：第$i$个城市，可以由除本身外的城市转移过来，只要剩余的油量不小于所用的油量就够了，最后答案是求总共的个数，所以只要方案数相加就行: $dp(i,f-dist)=dp(i,f-dist)+dp(k,f)(f-dist>=0)$
• 枚举顺序：每个城市肯定都要枚举一遍，因为还需要从另一个城市转移过来，所以除本身外的城市肯定还要再枚举一遍。关键是油量的枚举，因为油量肯定是慢慢减少的，可以想到是逆序枚举，而且油量要放在最外层枚举。因为如果先枚举城市$i$，再枚举城市$j$，再枚举油量的话，只是不断更新了$i$城市方案数，而$j$城市不同油量的方案数根本没变化。

#define LL long long
class Solution {
private:
    static constexpr LL MOD = 1e9 + 7;
    int dp[105][205], n; 
    // dp：最优子结构 到达终点的方案数肯定由到达其他点的,不同油量的方案数求和
    // 搜索：反过来 在第 i 个城市到达 fin 的方案数，也可以由其他的点到达 fin 的方案数转移过来， 但是油量有限制，所以油量肯定在状态里
    // 所以城市 和 剩余油量肯定在状态里
    // dp(i, j) 表示到达第 i 个城市，剩余油量为 j 的方案数
    // dp(i, j) = dp(i, j) + dp(k, j - dist)
   
public:
    int countRoutes(vector<int>& loc, int sta, int fin, int fuel) {
        n = loc.size();
        this->loc = loc, this->fin = fin;
        
        memset(dp, 0, sizeof(dp));
        dp[sta][fuel] = 1; // 初始点且燃料满的点方案数为1
        for (int f = fuel; f >= 0; f--){
            for (int i = 0; i < n; i++){
                for (int j = 0; j < n; j++){
                    if (i == j) continue;
                    int leftF = f - abs(loc[i] - loc[j]);
                    if (leftF < 0) continue;
                    dp[i][leftF] = (dp[i][leftF] + dp[j][f]) % MOD;
                }
            }
        }

        int ans = 0;
        for (int i = 0; i <= fuel; i++) 
            ans = (ans + dp[fin][i]) % MOD;

        return ans;
    }
};

自顶向下 （记忆化搜索）

• 每个dfs搜索当前状态为城市i，油量f到达终点的方案数。这样决策的时候就很直观：当前这个状态的方案数，由可去的城市的，且油量为剩余油量的到达终点方案数加起来。
• 初始化：每个状态都初始化为-1。
• 当走到终点时，这个状态的可走到终点的方案数+1。

#define LL long long
class Solution {
private:
    static constexpr LL MOD = 1e9 + 7;
    int dp[105][205], n; 
    // dp：最优子结构 到达终点的方案数肯定由到达其他点的,不同油量的方案数求和
    // 搜索：反过来 在第 i 个城市到达 fin 的方案数，也可以由其他的点到达 fin 的方案数转移过来， 但是油量有限制，所以油量肯定在状态里
    // 所以城市 和 剩余油量肯定在状态里
    // dp(i, j) 表示到达第 i 个城市，剩余油量为 j 的方案数
    // dp(i, j) = dp(i, j) + dp(k, j - dist)
    vector<int> loc;
    int fin;
    // 记忆化搜索
    int dfs(int pos, int rest){
        if (dp[pos][rest] != -1) return dp[pos][rest];
        dp[pos][rest] = 0;
        if (pos == fin) dp[pos][rest] += 1, dp[pos][rest] %= MOD;

        for (int i = 0; i < n; i++){
            if (i == pos) continue;
            int dist = abs(loc[i] - loc[pos]);
            if (dist > rest) continue;
            dp[pos][rest] += dfs(i, rest - dist);
            dp[pos][rest] %= MOD;  
        }

        return dp[pos][rest];
    }
    
public:
    int countRoutes(vector<int>& loc, int sta, int fin, int fuel) {
        n = loc.size();
        this->loc = loc, this->fin = fin;
        memset(dp, -1, sizeof(dp));
        return dfs(sta, fuel);
    }
};