RobatWalk

 

 /**
     *
     * @param n 总共N个位置 1~n
     * @param index 从index位置开始
     * @param k 走k步
     * @param p 目标
     * @return 从index位置开始走k步到达p的方法数
     */
    public static int getWalkWays(int n,int index,int k,int p){

        if(n<2||index<1||index>n||k<1||p<1||p>n){
            return 0;
        }
        return process(n,index,p,k);

    }
    /**
     *从s位置开始走k步到达p的方法数
     *固定参数：n,p
     *可变参数：cur,rest
     * @param n 总共N个位置 1~n
     * @param cur 当前位置--》
     * @param p 到达P位置
     * @param rest 还剩rest步--》
     * @return
     */
    public static int process(int n,int cur,int p,int rest){
        //base case 没有步可以走了，那你是否在p位置呢，如在则返回1，表示之前做的选择有效
        if(rest==0){
            return cur==p?1:0;
        }

        //开始尝试,在位置1只能往2走
        if(cur==1){
            return process(n,2,p,rest-1);;
        }
        //在位置n,只能往n-1走
        if(cur==n){
            return process(n,n-1,p,rest-1);

        }
        //可以往前往后走
        return process(n,cur-1,p,rest-1)+process(n,cur+1,p,rest-1);;
    }

　　

缓存优化

 public static int getWalkWays2(int n,int index,int k,int p){

        if(n<2||index<1||index>n||k<1||p<1||p>n){
            return 0;
        }
        HashMap<String,Integer> mapCach=new HashMap<>();
        return process(n,index,p,k,mapCach);
    }
    
    /**
     *从s位置开始走k步到达p的方法数
     *固定参数：n,p
     *可变参数：cur,rest
     * @param n 总共N个位置 1~n
     * @param cur 当前位置--》
     * @param p 到达P位置
     * @param rest 还剩rest步--》
     * @return
     */
    public static int process(int n,int cur,int p,int rest,HashMap<String,Integer> mapCache){
        String key=cur+"_"+rest;
        if(mapCache.containsKey(key)){
            return mapCache.get(key);
        }
        Integer ans;

        //base case 没有步可以走了，那你是否在p位置呢，如在则返回1，表示之前做的选择有效
        if(rest==0){
            ans=cur==p?1:0;
            mapCache.put(key,ans);
           return ans;
        }

        //开始尝试,在位置1只能往2走
        if(cur==1){
            ans=process(n,2,p,rest-1,mapCache);
            mapCache.put(key,ans);
            return ans;
        }
        //在位置n,只能往n-1走
        if(cur==n){
            ans=process(n,n-1,p,rest-1,mapCache);
            mapCache.put(key,ans);
            return ans;

        }
        //可以往前往后走
        ans=process(n,cur-1,p,rest-1,mapCache)+process(n,cur+1,p,rest-1,mapCache);
        mapCache.put(key,ans);
        return ans;
    }

　　缓存优化2

   public static int getWalkWays3(int n,int index,int step,int p) {

        if (n < 2 || index < 1 || index > n || step < 1 || p < 1 || p > n) {
            return 0;
        }
        //cur: 1~n,rest
        int[][] dp = new int[n + 1][step + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= step; j++) {
                dp[i][j] = -1;
            }
        }
        return process(n, index, p, step, dp);
    }

    public static int process(int n,int cur,int p,int rest,int[][] dp){
        if(dp[cur][rest]!=-1){
            return dp[cur][rest];
        }

        Integer ans;
        //base case 没有步可以走了，那你是否在p位置呢，如在则返回1，表示之前做的选择有效
        if(rest==0){
            ans=cur==p?1:0;
            dp[cur][rest]=ans;
            return ans;
        }

        //开始尝试,在位置1只能往2走
        if(cur==1){
            ans=process(n,2,p,rest-1,dp);
            dp[cur][rest]=ans;
            return ans;
        }
        //在位置n,只能往n-1走
        if(cur==n){
            ans=process(n,n-1,p,rest-1,dp);
            dp[cur][rest]=ans;
            return ans;

        }
        //可以往前往后走
        ans=process(n,cur-1,p,rest-1,dp)+process(n,cur+1,p,rest-1,dp);
        dp[cur][rest]=ans;
        return ans;
    }

　　

　　动态规划

  public static int process2dp(int n,int start,int end,int step){
        if(n<2|| step<1 || start<1||start>n||end<1||end>n){
            return 0;
        }
        //cur 1--n rest 1--rest
        int[][] dp=new int[n+1][step+1];
        dp[end][0]=1;
      
        for(int j=1;j<=step;j++){
            dp[1][j]=dp[2][j-1];
            dp[n][j]=dp[n-1][j-1];
            for(int i=2;i<=n-1;i++) {
                dp[i][j] = dp[i - 1][j - 1] + dp[i + 1][j - 1];
            }
        }
        return dp[start][step];
    }