动归||爬楼梯及变阶

一、基础版

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

class Solution {
    public int climbStairs(int n) {
     if (n <= 2) return n;
     int f1 = 1, f2 = 2, f3 = 3;
     for (int i = 2; i < n; i++) {
        f3 = f1 + f2;
        f1 = f2;
        f2 = f3;
     }
     return f3;
    }
}

二、扩展版

2.1 假设每次爬楼梯可以选择上 1 阶、2 阶或者 4 阶，求到达第 n 阶楼梯有多少种不同的方法。

class Solution {
    public int climbStairs(int n) {
     if (n <= 4） return n;
     int f1 = 1, f2 = 2, f3 = 3, f4 = 4;
     for (int i = 3; i < n; i++) {
        f4 = f1 + f2 + f3;
        f1 = f2;
        f2 = f3;
        f3 = f4;
     }
     return f4;
    }
}

//dp[i] = dp[i - 1] + dp[i -2] + dp[i - 4]

2.2 爬楼梯时，每上一阶需要消耗一定的体力值，不同的台阶消耗的体力值不同。已知每个台阶的体力消耗值数组 cost，每次只能爬1阶或2阶，求到达第 n 阶楼梯的最小体力消耗。

public int minCostClimbingStairs(int[] cost) {
    int n = cost.length;
    int[] dp = new int[n + 1];
    dp[0] = 0;
    dp[1] = cost[0];
    for (int i = 2; i <= n; i++) {
        dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
    }
    return dp[n];
}

2.3 爬楼梯有时间限制，每上一阶需要花费一定的时间，且在某些特定的台阶会有额外的时间奖励。给定每个台阶的时间花费数组 time 和奖励时间数组 bonus，每次只能爬1阶或2阶，求在规定时间内到达第 n 阶楼梯的最优方案。

public int findOptimalPath(int[] time, int[] bonus, int n, int maxTime) {
        int[] dp = new int[n + 1];  
      // dp[i] 表示到达第 i 阶楼梯的最优时间
        for (int i = 1; i <= n; i++) {
            dp[i] = Integer.MAX_VALUE;  // 初始化最大值，方便后续更新最小值
            for (int j = 1; j <= i; j++) {  // 遍历从第 1 阶到第 i 阶的所有可能上一步位置
                int prevTime = dp[j];  // 从第 j 阶到达第 i 阶的前一阶段时间
                if (prevTime!= Integer.MAX_VALUE && prevTime + time[j] <= maxTime) {  
                   // 如果前一阶段时间不为无穷大且加上当前时间不超过最大时间限制
                    int currentTime = prevTime + time[j] - bonus[j];  
                   // 当前时间为前一阶段时间加上当前台阶时间减去奖励时间
                    if (j > 1) {
                        currentTime -= bonus[j - 1];  
               // 如果不是从第 1 阶上来的，再减去前一阶的奖励时间（因为不能重复获得）
                    }
                    dp[i] = Math.min(dp[i], currentTime);  
          // 更新到达第 i 阶的最优时间
                }
            }
        }
        return dp[n]!= Integer.MAX_VALUE? dp[n] : -1;  
    // 如果最终到达第 n 阶的时间不是无穷大，则返回该时间，否则返回 -1 表示无法在规定时间内到达
    }

2.4 爬楼梯时，每上一阶有一定的概率滑倒并回到起点。已知每个台阶的滑倒概率数组 probability，每次只能爬1阶或2阶，求成功到达第 n 阶楼梯的概率。

   public static double climbStairsWithSlipProb(double[] probability, int n) {
        double[] dp = new double[n + 1];
        dp[0] = 1;

        for (int i = 1; i <= n; i++) {
            double slipProb = i < probability.length? probability[i] : 0;
            double successProb = 1 - slipProb;
            if (i == 1) {
                dp[i] = successProb * dp[i - 1];
            } else {
                dp[i] = successProb * (dp[i - 1] + dp[i - 2]);
            }
        }

        return dp[n];
    }

2.5 楼梯是环形的，即从第 n 阶可以直接到达第 1 阶，每次可以上 1 阶或 2 阶，求从第 1 阶出发经过 m 次上楼梯后回到第 1 阶的方法数。

  public static int countWays(int n, int m) {
        if (n <= 0 || m <= 0) {
            return 0;
        }

        int[] dp = new int[n];
        dp[0] = 1;

        for (int i = 1; i < n; i++) {
            dp[i] = dp[(i - 1 + n) % n] + dp[(i - 2 + n) % n];
        }

        int result = 0;
        for (int i = 0; i < n; i++) {
            if (i == 0) {
                if (m % n == 0) {
                    result += 1;
                }
            } else {
                int times = m / n + (m % n >= i? 1 : 0);
                result += dp[i] * times;
            }
        }

        return result;
    }