第309场周赛 NO.2 恰好移动 k 步到达某一位置的方法数目

题目描述：

给你两个 正 整数 startPos 和 endPos 。最初，你站在 无限 数轴上位置 startPos 处。在一步移动中，你可以向左或者向右移动一个位置。

给你一个正整数 k ，返回从 startPos 出发、恰好 移动 k 步并到达 endPos 的 不同 方法数目。由于答案可能会很大，返回对 109 + 7 取余 的结果。

如果所执行移动的顺序不完全相同，则认为两种方法不同。

注意：数轴包含负整数。

Level	AC rate
Medium	26.3%

---

题目解析（递归）：

首先我先说一下我的思路，当终点到我目前所在点的距离大于我剩余的步数时，我肯定不能够达到终点，这时候返回0。当我所剩的步数正好等于距离时，我只有一种走法可以达到终点，这时候返回1。当我所剩步数和距离的奇偶性不同时，我不可能在这个步数情况下到达终点，返回0。然后进行递归，代码如下：

// 递归
class Solution {
    public int numberOfWays(int startPos, int endPos, int k) {
        int ma = Math.abs(endPos-startPos);
        if((k%2)!=ma%2)return 0;
        if(ma==k)return 1;
        if(ma>k)return 0;
        if(k==2)return 2*(ma+1);
        return (numberOfWays(startPos+1,endPos,k-1)+numberOfWays(startPos-1,endPos,k-1))%(int)(1e9+7);
    }
}

但指数暴涨会带来超时的问题。这个时候我们想到我们之前所做的题目中，当递归超时时往往可以通过哈希表的存储查找来解决，代码如下：

// 哈希表存储
class Solution {
    int endPos;
    HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
    public int numberOfWays(int startPos, int end, int k) {
        endPos = end;
        return dg(startPos,k);
    }

    int dg(int sta, int k){
        int ma = Math.abs(endPos-sta);
        if((k%2)!=ma%2||ma>k)return 0;
        if(ma==k)return 1;
        if(map.containsKey(sta*1001+k))return map.get(sta*1001+k);
        else{
            int value = ((dg(sta+1,k-1)+dg(sta-1,k-1))%(int)(1e9+7));
            map.put(sta*1001+k,value);
            return value;
        }
    }
}

执行用时：101 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：83 MB, 在所有 Java 提交中击败了100.00%的用户

题目解析（组合数学问题）：

起点到终点的距离为distance，一共需要走k步，假设我往终点方向走x步，那么我往回需要走k-x步，而x-k+x=distance，则x=(k+distance)/2；这个时候我们只需要返回C(k,x)即可。代码如下：

// // 组合数学
class Solution {
    Map<String,Long> map= new HashMap<String, Long>();
    public int numberOfWays(int startPos, int endPos, int k) {
        int ma = Math.abs(endPos-startPos);
        if((k%2)!=ma%2||ma>k)return 0;
        return (int)comb(k,(ma+k)/2);
    }
    
    long comb(int m,int n){
        String key= m+","+n;
        if(n==0)
            return 1;
        if (n==1) 
            return m;
        if(n>m/2)
            return comb(m,m-n);
        if(n>1){
            if(!map.containsKey(key))
                map.put(key, comb(m-1,n-1)+comb(m-1,n));
            return map.get(key)%(long)(1e9+7);
        }
        return -1;
    }
}

难点在于，java没有计算组合数学的公式，需要自己编写，然后使用递归计算会导致超时的问题，这个时候又通过了哈希表存储来进行解决。

执行用时：234 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：64.9 MB, 在所有 Java 提交中击败了100.00%的用户