动态规划 之 机器人到达指定位置的方法数

题目描述
  假设有排成一行的N个位置，记为1~N，开始时机器人在M位置，机器人可以往左或者往右走，如果机器人在1位置，那么下一步机器人只能走到2位置，如果机器人在N位置，那么下一步机器人只能走到N-1位置。规定机器人只能走k步，最终能来到P位置的方法有多少种。由于方案数可能比较大，所以答案需要对1e9+7取模。

输入描述:

输入包括一行四个正整数N（2<=N<=5000）、M(1<=M<=N)、K(1<=K<=5000)、P(1<=P<=N)。

输出描述:

输出一个整数，代表最终走到P的方法数对10^9+7取模后的值。

示例1

输入
5 2 3 3
输出
3
说明
1).2->1,1->2,2->3
2).2->3,3->2,2->3
3).2->3,3->4,4->3

示例2

输入
1000 1 1000 1
输出
591137401

下面由浅入深，从暴力破解到动态规划，推出动态规划问题的解题思路。

暴力破解

  对于机器人有三种走法：

1. 在1位置，只能向 2 位置移动
2. 在 N 位置，只能向N-1 位置移动
3. 在 i 位置，可以移动至 i-1 ，也可以移动至 i+1 位置

class Solution{
public:
	int getWays(int N, int start, int end, int K){
		// 检查输入参数
		if (N < 1 || start < 1 || start > N || end < 1 || end > N || K < 1){
			return 0;
		}
		
		// 暴力破解
		return process(N, start, end, K);
	}

private:
	const int mod = 1e9 + 7;
	int process(int N, int start, int end, int K){
		if (K == 0){
			return start == end ? 1 : 0;
		}

		if (start == 1){
			return process(N, 2, end, K-1) % mod;
		}
		if (start == N){
			return process(N, N-1, end, K-1) % mod;
		}

		return (process(N, start-1, end, K-1) 
			+  process(N, start+1, end, K-1)) % mod;
	}
};

HashMap 存储中间结果

第一种优化方式是暴力破解法会重复计算产生无效解，使用HashMap 存储中间过程结果。

class SolutionHashMap{
public:
    int getWays(int N, int start, int K, int end){
        if (N < 1 || start < 1 || start > N || end < 1 || end > N || K < 1){
            return 0;
        }

        unordered_map<string, int> mem;
        process(N, start, K, end, mem);

        string key = to_string(start) + "_" + to_string(K);
        return mem[key];
    }

private:
    int process(int N, int start, int rest, int end, unordered_map<string, int>& mem){
        string key = to_string(start) + "_" + to_string(rest);
        if (mem.find(key) != mem.end()){
            return mem[key];
        }

        int ans = 0;
        if (rest == 0){
            ans = ((start == end) ? 1 : 0);
            mem.insert({key, ans});
            return ans;
        }

        if (start == 1){
            ans = process(N, 2, rest - 1, end, mem) % mod;
            mem.insert({key, ans});
            return ans;
        }

        if (start == N){
            ans = process(N, N-1, rest - 1, end, mem) % mod;
            mem.insert({key, ans});
            return ans;
        }

        ans = (process(N, start-1, rest - 1, end, mem)
                + process(N, start+1, rest - 1, end, mem)) % mod;
        mem.insert({key, ans});
        return ans;
    }
};

数组记录

使用二维数组作为备忘录，记录中间结果

class SolutionVec{
public:
    int getWays(int N, int start, int K, int end){
        if (N < 1 || start < 1 || start > N || end < 1 || end > N || K < 1){
            return 0;
        }

        vector<vector<int>> cache(N+1, vector<int>(K+1, -1));

        int res = process(N, start, K, end, cache);
        return res;
    }

private:
    const int mod = 1e9 + 7;
    int process(int N, int cur, int rest, int end, vector<vector<int>>& cache){
        if (cache[cur][rest] != -1){
            return cache[cur][rest] ;
        }

        if (rest == 0){
            cache[cur][rest] = cur == end ? 1 : 0;
            return cache[cur][rest];
        }

        if (cur == 1){
            cache[cur][rest] = process(N, 2, rest - 1, end, cache) % mod;
            return cache[cur][rest];
        }

        if (cur == N){
            cache[cur][rest] = process(N, N - 1, rest - 1, end, cache) % mod;
            return cache[cur][rest];
        }

        cache[cur][rest] = (process(N, cur + 1, rest - 1, end, cache)
                           + process(N, cur - 1, rest - 1, end, cache)) % mod;

        return cache[cur][rest];
    }
};

动态规划

class SolutionDP{
public:
    int getWays(int N, int start, int K, int end){
        if (N < 1 || start < 1 || start > N || end < 1 || end > N || K < 1){
            return 0;
        }

        const int mod = 1e9 + 7;
        vector<vector<int>> dp(N+1, vector<int>(K+1, 0));
        dp[end][0] = 1;
        for (int rest = 1; rest < K + 1; rest++){
            for (int cur = 1; cur < N + 1; cur++){
                if (cur == 1){
                    dp[cur][rest] = dp[2][rest-1] % mod;
                }
                else if (cur == N){
                    dp[cur][rest] = dp[N-1][rest-1] % mod;
                }
                else{
                    dp[cur][rest] = (dp[cur-1][rest-1] + dp[cur+1][rest-1]) % mod;
                }
            }
        }

        return dp[start][K];
    }
};

动态规划一般解题步骤：

1. 使用暴力破解递归求解，确定固定参数 和 可变参数
2. 对于可变参数，将其作为 N 维数组作为 dp 备忘录
3. 给定具体参数，画出表格
4. 写出 base case ，将其他位置也计算得出
5. 分析位置依赖（暴力递归的依赖相同）

点关注，不迷路。一键三连是对我最大的支持，欢迎关注编程小镇，每天涨一点新姿势😄。