P159 摆动序列 - 技术栈

这道题难度较大，使用了动态规划和前缀和

我们先来说什么是动态规划

动态规划 = 把大问题拆成小问题 + 记住小问题的答案 + 用小答案拼出大答案

举一个简单的例子爬楼梯，一次只能爬2或3层

当你爬楼梯的时候，你站在第一层，当你要迈向第二层楼梯的时候，你只有1种走法

迈向第三层的时候，你可以选择先走到第二层再走到第三层，也可以选择直接走到第三层，这就有2种走法

迈向第四层的时候，你可以选择到第二层到第三层到第四层，也可以选择到第二层到第四层，也可以选择到第三层到第四层，这就有3种走法也就是第二层走法+第三层走法 1+2=3

迈向第五层时：第三层的走法+第四层的走法也就是2+3 = 5层

所以到第N层：第N-2层的走法+第N-1层的走法

我们先看代码：

java 复制代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {
    static final int MOD = 10000;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();

        int[][] up = new int[m + 1][n + 1];
        int[][] down = new int[m + 1][n + 1];

        for (int j = 1; j <= n; j++) {
            up[1][j] = 1;
        }

        for (int i = 2; i <= m; i++) {
            if (i % 2 == 0) {
                // 后缀和
                int[] suffix = new int[n + 2];
                for (int k = n; k >= 1; k--) {
                    suffix[k] = (suffix[k + 1] + up[i - 1][k]) % MOD;
                }
                for (int j = 1; j <= n; j++) {
                    down[i][j] = suffix[j + 1];
                }
            } else {
                // 前缀和
                int[] prefix = new int[n + 2];
                for (int k = 1; k <= n; k++) {
                    prefix[k] = (prefix[k - 1] + down[i - 1][k]) % MOD;
                }
                for (int j = 1; j <= n; j++) {
                    up[i][j] = prefix[j - 1];
                }
            }
        }

        int ans = 0;
        if (m % 2 == 1) {
            for (int j = 1; j <= n; j++) ans = (ans + up[m][j]) % MOD;
        } else {
            for (int j = 1; j <= n; j++) ans = (ans + down[m][j]) % MOD;
        }
        System.out.println(ans);
    }
}

我们分部分解释：

一

这一段代码是算法题（尤其是动态规划、数论类题目）中非常经典的防溢出 + 取模写法。

final表示这是一个常量，防止后面把MOD给改了

static表示MOD是全局通用的一个常量

取模是为了防止整数溢出

二

up是奇数步，down是偶数步

1代表第一步，j表示格子编号

因为第一步可以站在任意格子上，所以无论走到哪个格子上都只有1种走法

三

这是动态规划和后缀和的核心代码

定义后缀和suffix的意义是为了避免第三次for循环，为了避免超时。

举个例子，当k=1的时候，就意味着你要跳到编号是1的格子上，因为是偶数，所以你只能从上往下跳，也就是从2到n的格子上往下跳，所以 down[i][1] = 上一步所有 k>1 格子的走法之和。这时候后缀和就帮你把这些从后往前数的数加起来

suffix[k]：从 k 格到 n 格的所有走法之和

suffix[n] = up[i-1][n]（只有自己）
suffix[n-1] = suffix[n] + up[i-1][n-1]（n-1 + n）
suffix[k] = suffix[k+1] + up[i-1][k]（k 到 n 的总和）

最后取模防止整数溢出

最后一步是将后缀和赋值给down

down[i][j]：第 i 步走到 j 格，且下一步要向下的走法数
suffix[j+1]：从 j+1 格到 n 格的所有走法之和 → 正好是「所有能从 j 上面跳下来的走法」

所以简单来说就是

偶数步向下走时，用后缀和快速算出「所有比 j 大的格子的走法之和」，赋值给 down[i][j]，既高效又避免重复计算。

四

这一部分和上一部分类似，不同的地方是前缀和

因为奇数步的上一步是偶数步，所以计算这一步的前缀和只需要计算上一步的前缀和再加上上一步也就是偶数步的走法就可以

最后一步就是把前缀和赋值给up

向上走，只能走比j小的数，所以前缀和是j-1不是j

五

这一步是输出答案

奇数步的时候就用up up[m][j]：第 m 步（奇数步）走到 j 格的方案数

偶数步就用down down[m][j]：第 m 步（偶数步）走到 j 格的方案数

题目要的是所有可能的终点 ，不管最后站在哪个格子，只要走了 m 步都算，所以要把 j=1 到 j=n 的所有方案数全部加起来。