2023牛客暑假多校第四场（补题向题解：J）

已于 2023-09-11 19:32:30 修改
阅读量163 收藏
点赞数 1
分类专栏： 牛客寒假暑假训练营题解 动态规划 文章标签： c++ 算法
于 2023-09-10 20:12:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TT6899911/article/details/132794847
版权

终于有时间来慢慢补补题了

J Qu’est-ce Que C’est?

作为队内的dp手，赛时想了好久，等学弟学妹都出了还是不会，羞愧，还好最终队友做出来了。
链接J Qu’est-ce Que C’est?

题意

长度为 n n n 的数组 a a a，每个数的取值范围 a i = [ − m , m ] a_i = [-m, m] ai​=[−m,m]，问所有满足长度 > 1 >1 >1 的子段的和为非负数的数组可能的数量。 1 ≤ n , m ≤ 5000 1\leq n,m\leq 5000 1≤n,m≤5000。

以下题解，仅参考懵哥的状态定义，具体解题过程优化和代码都是博主自己琢磨的。

法一思路

dp状态定义 f [ i ] [ j ] : f[i][j]: f[i][j]: 前 i i i 个数，最小后缀和为 j j j 的方案数 j = [ − 5000 , 5000 ] j = [-5000, 5000] j=[−5000,5000]。因为是最小后缀和，那么如果有后缀 < − 5000 <-5000 <−5000 的说明至少是两个数以上的和为负数，与题意不符是不合法的方案，所以数组大小开到 [ 0 , 10000 ] [0,10000] [0,10000] 即可（离散化后）。

我们先不管时间复杂度，根据dp定义先敲个状态转移出来，代码如下：

#include <bits/stdc++.h>
using namespace std;

#define ll long long

const int N = 5010, mod = 998244353;

int f[N][N * 2]; // 前i个数，最小后缀和为j的方案数 j = [-5000, 5000]

void add(int& a, int b){
    a = (a + b) % mod;
}
int main(){
    int n, m;
    cin >> n >> m;

    f[0][2 * m] = 1;
    for(int i = 1; i <= n; i ++){
        for(int j = -m; j <= m; j ++){ // 枚举最小后缀
            for(int k = m; k >= -m; k --){ // 枚举当前a_i选哪个数
                if(j + k < 0) break;
                add(f[i][min(j + k, k) + m], f[i - 1][j + m]);
            }
        }
        
    }
    
    int ans = 0;
    for(int i = -m; i <= m; i ++){
        add(ans, f[n][i + m]);
    }
    cout << ans;
    return 0;
}

时间复杂度为 O ( n 3 ) O(n^3) O(n3)，我们观察一下代码如何优化，发现会有大量连续的 k k k， f [ i ] [ min ⁡ ( j + k , k ) ] f[i][\min(j + k, k)] f[i][min(j+k,k)] 加的是同一个状态 f [ i − 1 ] [ j ] f[i - 1][j] f[i−1][j]。那么经典优化方案不就来了吗，差分前缀和优化。

以下分情况讨论：
因为是 min ⁡ ( j + k , k ) \min(j + k, k) min(j+k,k)

  1. j j j 是非正数
    无论当前 k k k 选什么， j + k ≤ k j + k \leq k j+k≤k，所以状态一定是转移到 j + k j + k j+k，所以对于一个非正数的 j j j 可转移的范围就是 0 ∼ j + m 0 \sim j + m 0∼j+m。
// 区间 [l, r] + val  f_l + val  f_{r + 1} + val
for(int j = -m; j <= 0; j ++){
    f[i][m] = (f[i][m] + f[i - 1][j + m]) % mod;// 差分 +
    f[i][m + j + m + 1] = (f[i][m + j + m + 1] + mod - f[i - 1][j + m]) % mod;// 差分 -
}
  1. j j j 是正数
    同理无论当前 k k k 选什么， k ≤ j + k k \leq j + k k≤j+k，所以状态一定是转移到 k k k，所以对于一个正数 j j j，可以转移的范围就是 − j ∼ m -j\sim m −j∼m。
for(int j = 1; j <= m; j ++){
    f[i][-j + m] = (f[i][-j + m] + f[i - 1][j + m]) % mod;
    f[i][m + m + 1] = (f[i][m + m + 1] + mod - f[i - 1][j + m]) % mod;
}

法一完整代码

#include <bits/stdc++.h>
using namespace std;

#define ll long long

const int N = 5010, mod = 998244353;

int f[N][N * 2]; // 前i个数，最小后缀和为j的方案数 j = [-5000, 5000]

void add(int& a, int b){
    a = (a + b) % mod;
}
int main(){
    int n, m;
    cin >> n >> m;

    f[0][2 * m] = 1;
    for(int i = 1; i <= n; i ++){
        /*
        for(int j = -m; j <= m; j ++){
            for(int k = m; k >= -m; k --){
                if(j + k < 0) break;
                add(f[i][min(j + k, k) + m], f[i - 1][j + m]);
            }
        }
        */
        
        // 考虑差分前缀和优化
        // j 是 负数 k 是正数 f[i][j + k + m] 从0 ~ m + j
        // j 是 正数 k 是负数/正数 f[i][k + m] 从-j ~ m

        for(int j = -m; j <= 0; j ++){
            f[i][m] = (f[i][m] + f[i - 1][j + m]) % mod; // 差分 +
            f[i][m + j + m + 1] = (f[i][m + j + m + 1] + mod - f[i - 1][j + m]) % mod; // 差分 -
        }
        for(int j = 1; j <= m; j ++){
            f[i][-j + m] = (f[i][-j + m] + f[i - 1][j + m]) % mod;
            f[i][m + m + 1] = (f[i][m + m + 1] + mod - f[i - 1][j + m]) % mod;
        }
        for(int j = -m + 1; j <= m; j ++){ // 前缀和
            f[i][j + m] = (f[i][j + m] + f[i][j + m - 1]) % mod;
        }
    }

    int ans = 0;
    for(int i = -m; i <= m; i ++){
        add(ans, f[n][i + m]);
    }
    cout << ans;
    return 0;
}

法二思路

首先先说说博主自己解题时卡在什么地方，我当时认为dp必须维护 a i − 1 a_{i-1} ai−1​ 和 a i − 2 a_{i-2} ai−2​ 位置上的数是什么，才能确定当前选择的 a i a_i ai​ 的选择是否合法，这样的时空复杂度都达到了 n 3 n^3 n3，而且也没有能发现优化的点。而不得不说这个思路也很妙，仅仅一个点就将时空都缩减了一维，可以不用维护 a i − 2 a_{i-2} ai−2​ 的情况。

你可能会和我一样疑惑，如果不维护 a i − 2 a_{i-2} ai−2​ 若 a i − 2 + a i − 1 + a i < 0 a_{i-2}+a_{i-1}+a_i < 0 ai−2​+ai−1​+ai​<0 的情况如何排除，我们考虑一下合法序列的情况：对于一个合法序列，肯定不会出现两个连续的负数，即一个负数的后继肯定是正数。 所以dp方程的第二维维护的就是当前节点的数值大小，因为负数是和正数绑定的，我们将一个负数和其后继的正数当做一个数来记录，转移时直接从 d p i − 1 dp_{i-1} dpi−1​ 转移到 d p i + 1 dp_{i+1} dpi+1​。

f [ i ] [ j ] ： f[i][j]： f[i][j]： 前 i i i 个数，第 i i i 个数大小为 j j j 的合法方案数。

老样子，我们不考虑优化先写个暴力转移出来

#include <bits/stdc++.h>
using namespace std;

const int N = 5010, mod = 998244353;

int f[N][N * 2], pre[N * 2];

void add(int& a, int b){
    a = (a + b) % mod;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);

    int n, m;
    cin >> n >> m;
    f[0][m] = 1; // 初始化一个最大的数作为第0个数
    
    int ans = 0;
	
    // 暴力转移
    for(int i = 1; i <= n; i ++){
        
        // 枚举前一个数的值j，因为但凡出现负数我们就会将其与一个正数合并为非负数一起维护，所以不需要离散化和枚举负数
        for(int j = 0; j <= m; j ++){ 
            for(int k = -j; k <= 0; k ++){ // 枚举当前选负数
            	if(i == n) add(ans, f[i - 1][j]); // 最后一个数不用和正数绑定，单独计算
                else{
                    for(int p = -k; p <= m; p ++){ // 枚举与负数绑定一起选的正数
                        add(f[i + 1][k + p], f[i - 1][j]);
                    }
                }
            }
            for(int k = 1; k <= m; k ++){ // 枚举当前选的正数
                add(f[i][k], f[i - 1][j]);
            }   
        }
    }
    for(int i = 0; i <= m; i ++){
        add(ans, f[n][i]);
    }
    cout << ans << "\n"; 
    return 0;
}

先从简单的开始优化，看当前选的数 k k k 为正数的情况，我们发现dp定义中，将所有负数和正数绑定在一起，所以dp状态中所有数都是正数。也就是所有的 j j j 都可以转移到 k k k，我们直接记录一下前缀和，枚举 k k k 全部加上即可，代码如下：

for(int i = 1; i <= n; i ++){
    pre[1] = f[i - 1][0];
    for(int j = 1; j <= m; j ++){ // 前缀和
        pre[j + 1] = (pre[j] + f[i - 1][j]) % mod;
    }
    for(int k = 1; k <= m; k ++){ // 枚举当前选的正数
        f[i][k] = (f[i][k] + pre[m + 1]) % mod; // 正数之间任意转移直接将前缀和全部加上
    }
}

再考虑当前 k k k 为负数需要和正数绑定的情况。若当前选负数，那么该负数与 前一个正数，后一个正数的和都不能为负，所以直接枚举当前选哪个负数。若当前选的负数为 k k k，前一个正数 j ≥ − k j \geq -k j≥−k 且 后一个正数 p ≥ − k p \geq -k p≥−k，也就是说 j = [ − k , m ] j = [-k, m] j=[−k,m] 可以转移到 p = [ − k , m ] p = [-k, m] p=[−k,m]。即：

f [ i + 1 ] [ 0 ∼ k + m ] + ∑ j = − k m f [ i − 1 ] [ j ] f[i+1][0\sim k+m] + \sum_{j = -k}^{m}f[i-1][j] f[i+1][0∼k+m]+∑j=−km​f[i−1][j]。

f [ i − 1 ] f[i-1] f[i−1] 已经用前缀和维护好了，而 f [ i + 1 ] f[i+1] f[i+1] 这种经典的连续一段加同一个数的转移是否能想到优化方法，没错就是差分前缀和，具体见代码。

法二完整代码

#include <bits/stdc++.h>
using namespace std;

const int N = 5010, mod = 998244353;

int f[N][N * 2], pre[N * 2];

void add(int& a, int b){
    a = (a + b) % mod;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);

    int n, m;
    cin >> n >> m;
    f[0][m] = 1; // 初始化一个最大的数作为第0个数
    
    int ans = 0;
    // 优化
    for(int i = 1; i <= n; i ++){
        
        pre[1] = f[i - 1][0];
        for(int j = 1; j <= m; j ++){ // 前缀和
            pre[j + 1] = (pre[j] + f[i - 1][j]) % mod;
        }

        // 考虑到若当前选负数，那么该负数和 前一个正数 和 后一个正数的和都不能为负，所以直接枚举当前选哪个负数
        for(int k = -m; k <= 0; k ++){
            int sum = (pre[m + 1] + mod - pre[-k]) % mod; // f[i - 1] 能转移的前缀和

            if(i < n){ // 前一个数和后一个数都至少要 >= -k, 转移范围为[i - 1][-k, m](前缀和) -> [i + 1][0, k + m](差分前缀和)
                f[i + 1][0] = (f[i + 1][0] + sum) % mod; // 差分 +
                f[i + 1][k + m + 1] = (f[i + 1][k + m + 1] + mod - sum) % mod; // 差分 -
            }
            else{// 最后一个数可以直接选负数
                ans = (ans + sum) % mod; // 转移范围为 f[i - 1][-k ~ m] -> f[i][k] 直接加在ans上
            }
        }

        for(int j = 1; j <= m; j ++){// 前缀和维护差分
            f[i + 1][j] = (f[i + 1][j] + f[i + 1][j - 1]) % mod; 
        }

        for(int k = 1; k <= m; k ++){ // 枚举当前选的正数
            f[i][k] = (f[i][k] + pre[m + 1]) % mod; // 正数之间任意转移直接将前缀和全部加上
        }
    }


    for(int i = 0; i <= m; i ++){
        add(ans, f[n][i]);
    }
    cout << ans << "\n"; 
    return 0;
}
CCSU_梅子酒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
这篇内容主要涵盖了一些计算机科学和算法竞赛中的关键知识点，包括后缀数组、无限树、二次型、矩阵求逆、有向图的生成树计数、无穷字符串比较、快速幂运算以及最小费用流。 1. 后缀数组(B-Suffix Array): 后缀数组...
2018牛客暑期多校第二场题解
09-28
### 2018牛客暑期多校第二场题解 #### 题目一：健身计划（laofudasuan） **题目大意** 白云正在制定一个健身计划，每秒可以选择步行1米或者跑步k米（k为常数），但不能连续两秒都跑步。当白云累计行走的距离在[L,R...
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 145
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++笔记5•内存管理•
qq_64446190的博客
08-12 1087
内存管理
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 201
C++ | Leetcode C++题解之第337题打家劫舍III
ubuntu22.04 安装 ros1
qq_35547879的博客
08-14 210
原先只知道ros1 noetic 只支持到ubuntu20.04。现在系统必须升级到ubuntu22.04。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 912
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++笔记4•类和对象3•
qq_64446190的博客
08-12 663
类和对象3
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 914
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
1 基本概念
m0_62280492的博客
08-13 561
C语言基本概念
typdef 与 struct
ligreenjian的博客
08-14 83
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。
C语言常用关键字
Fearlessness的博客
08-14 465
C语言中常用的关键字
【CPP】CPP的STL(前篇)
2302_79981653的博客
08-12 787
简单来说:CPP在有了模板之后,很多重复性质的代码就不需要自己手撕很多遍了,甚至说有前人做了一个库,把常见的算法,数据结构啥的放进库里面,这些数据结构,算法啥的全都采用了模板类和模板函数的形式,使得这个库里的代码复用率极高,况且写这个库的人都是大佬级别的大佬,效率也很不错,所以在CPP实际开发中,就不需要自己再造轮子了,调用这个库里的玩意就行STL目前有两个需要去学习的版本,一个是微软家的PJ版,一个是GCC(Linux)的SGI版,这俩调用的效果都是一样的,只是底层不一样,需要了解一下。
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 515
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
【嵌入式系统】第10章 LES 硬件介绍（6）模数转换ADC，模拟比较器,功能说明，模块控制，采样电路（东南大学）
最新发布
persona5joker的博客
08-15 510
【嵌入式系统】第17章 LES 硬件介绍（6）模拟比较器,结构框图，信号描述，功能说明，模块控制，采样电路（东南大学）
【C++】C++的内存处理 --- 智能指针
JLX_1的博客
08-12 1104
本文探讨了C++智能指针的原理与应用，分析了传统异常机制中内存泄漏问题，并提出智能指针的解决方案。文章详细介绍了RAII技术、shared_ptr、unique_ptr和weak_ptr的使用，并演示了如何通过自定义删除器来适配不同的资源释放需求。同时，文章还提及了多线程环境下智能指针的安全性和内存泄漏问题，强调智能指针在预防内存泄漏中的重要作用，为C++开发者提供了实用的内存管理指南。
牛客暑期多校第二场题解：动态规划与环形DP应用
本资源是2018年牛客暑期多校第二场的ACM题解文档，主要涉及三个编程问题的解题思路和方法。 第一个问题是关于动态规划（Dynamic Programming，简称DP）的应用。题目名为"laofudasuan"，背景是白云健身的模拟。问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值