【LeetCode】309b：恰好移动 k 步到达某一位置的方法数目

原题链接： 309b：恰好移动 k 步到达某一位置的方法数目

题目大意

给你两个 正 整数 startPos 和 endPos 。最初，你站在 无限 数轴上位置 startPos 处。在一步移动中，你可以向左或者向右移动一个位置。
给你一个正整数 k ，返回从 startPos 出发、恰好 移动 k 步并到达 endPos 的 不同 方法数目。由于答案可能会很大，返回对109 + 7取余 的结果。
如果所执行移动的顺序不完全相同，则认为两种方法不同。
注意：数轴包含负整数。
示例 1：

输入：startPos = 1, endPos = 2, k = 3
输出：3
解释：存在 3 种从 1 到 2 且恰好移动 3 步的方法：
- 1 -> 2 -> 3 -> 2.
- 1 -> 2 -> 1 -> 2.
- 1 -> 0 -> 1 -> 2.
可以证明不存在其他方法，所以返回 3 。

示例 2：

输入：startPos = 2, endPos = 5, k = 10
输出：0
解释：不存在从 2 到 5 且恰好移动 10 步的方法。

数据范围：

1 <= startPos, endPos, k <= 1000

思路

周赛时想到的方法：假设向左移动l次，向右移动r次，那么l+r=k，且r-l=距离绝对差，因此左移和右移的次数都可以计算出，总的方案数相当于l（或r）个元素在k个元素中的排列方法，即$C_k^l$。则DP计算组合数。

代码

class Solution {
public:
    const int MOD = 1e9 + 7;
    typedef long long LL;
    
    int cal(int ll, int rr, int k){
        if(ll == 0) return 1;
        
        LL f[1010][1010];
        //预处理
        for(int i = 0;i <= 1000;i++)
        {
            for(int j = 0;j <= i;j ++)
            {
                if(!j) f[i][j] = 1;
                else f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]) % MOD;
            }
        }
        
        return f[k][ll];
    }
    
    int numberOfWays(int l, int r, int k) {   
        if(l > r) swap(l, r);
        int ll = 0, rr = 0;
        
        int tmp = k + r - l;
        if((tmp) % 2 != 0 || k < r - l) return 0;
        else{
            rr = tmp / 2;
            ll = k - rr;
        }
        return cal(ll, rr, k);
    }
};

思路2

DP，设f[i][j]为第i步到达位置j的方案数。此处由于k与起点终点的数据范围在1~1000，因此其起点不会小于-500，终点不会大于500，因此将起点终点加500，可映射为数组下标，下标范围在0到1500之间，可以开较大的N = 2010的数组区间。
接下来由状态转移方程求解f[k][endPos]即为答案。

代码2

const int N = 2010, MOD = 1e9 + 7;
int f[1010][N]; // 走k步到达位置i的方案数

class Solution {
public:
    int numberOfWays(int startPos, int endPos, int k) {
        startPos += 500, endPos += 500;
        memset(f, 0, sizeof f);
        f[0][startPos] = 1;
        for(int i = 1; i <= k; i ++ ){
            for(int j = 0; j < N; j ++ ){
                if(j) f[i][j] = f[i - 1][j - 1];
                if(j + 1 < N) f[i][j] = (f[i][j] + f[i - 1][j + 1]) % MOD;
            }
        }

        return f[k][endPos];
    }
};