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

相关推荐
weixin_537590451 小时前
《C程序设计语言》练习答案(练习1-7)
linux·c语言·算法
计算机学姐1 小时前
基于SpringBoot的网吧管理系统
java·spring boot·后端·spring·tomcat·intellij-idea·mybatis
Fate_I_C1 小时前
Android现代开发:Kotlin&Jetpack
android·开发语言·kotlin·android jetpack
Boop_wu2 小时前
[Java EE 进阶] SpringBoot 配置文件全解析:properties 与 yml 的使用(1)
java·spring boot·spring·java-ee
!停2 小时前
C++基础入门(缺省参数,函数重载,引用)
开发语言·c++·算法
我不是秋秋2 小时前
软件开发项目各角色关系解析:产品/前后端/测试如何高效协作?
java·算法·面试·职场和发展·哈希算法
Tisfy2 小时前
LeetCode 1886.判断矩阵经轮转后是否一致:模拟
算法·leetcode·矩阵·题解·模拟
青衫客362 小时前
浅谈 Java 后端对象映射:从 JSON → VO → Entity 的原理与实践
java·json
XiaoLeisj3 小时前
Android Kotlin 全链路系统化指南:从基础语法、类型系统与面向对象,到函数式编程、集合操作、协程并发与 Flow 响应式数据流实战
android·开发语言·kotlin·协程