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=1j=n 的所有方案数全部加起来

相关推荐
Chester_19997 小时前
CSP202203C.计算资源调度器
开发语言·数据结构·c++·蓝桥杯
裕晟资质规划8 小时前
武器装备科研生产单位保密资质申请方法论:条件模型与流程拆解
人工智能·算法
EXI-小洲8 小时前
Java 操作 Word:字符串替换、图片插入、动态生成表格与API接口下载
java·开发语言·spring boot·word
会周易的程序员9 小时前
给 PLC 写一个字节码虚拟机:STVM 虚拟机架构设计
开发语言·c++·虚拟机·软plc·iec61131·stvm
机器视觉知识推荐、就业指导9 小时前
为什么老说“纯 Qt 没啥就业市场”?
开发语言·qt
telepan9 小时前
Qt 开发避坑与性能指南:如何优雅、安全地定义全局常量字符串?
开发语言·qt
m0_695251499 小时前
Qt MaintenanceTool 使用国内镜像加速下载(超详细教程)
开发语言·qt
2601_961901709 小时前
SpringBoot使用Nacos进行application.yml配置管理
java·spring boot·spring
en.en..10 小时前
C语言 标准输入 / 输出缓冲区
算法
何以解忧,唯有..10 小时前
LangChain 工具调用(Tool Calling)实战指南
java·前端·langchain