环上取数【动态规划dp】【单调队列优化】

最新推荐文章于 2025-12-02 15:32:05 发布

原创最新推荐文章于 2025-12-02 15:32:05 发布 · 287 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #队列 #算法 #c++ #数据结构

本文探讨了在环形序列中寻找长度不超过K的最大连续子序列和的问题，通过转化为链式序列并应用滑动窗口与单调队列优化，实现O(n)时间复杂度的高效求解。

问题描述

给定一个环，A[1], A[2], A[3], … , A[n]，其中 A[1] 的左边是 A[n]。要求从环上找出一段长度不超过 K 的连续序列，使其和最大。

Input

第一行一个整数 T，表示数据组数，不超过 100。
每组数据第一行给定两个整数 N K。（1 ≤ N ≤ 100000, 1 ≤ K ≤ N）
接下来一行，给出 N 个整数。（-1000 ≤ A[i] ≤ 1000）。

Output

对于每一组数据，输出满足条件的最大连续和以及起始位置和终止位置。如果有多个结果，输出起始位置最小的，如果还是有多组结果，输出长度最短的。

Sample Input

4
6 3
6 -1 2 -6 5 -5
6 4
6 -1 2 -6 5 -5
6 3
-1 2 -6 5 -5 6
6 6
-1 -1 -1 -1 -1 -1

Sample Output

问题分析

问题概括为从一个长度为 n 的环上，找出一段长度不超过 K 的连续序列，使其和最大。
贪心做法去维护前缀和sum，假设我们选了[L,R]，那么ans=sum[R]-sum[L-1]。
i=1到n，遍历一遍，需要记录一个L（L<=i）使得sum[L]是sum数组中最小的。

若用动态规化的思想去解决：

设定状态：
• f[i] 表示以 i 为结尾的最大连续子段和。
• 答案为 max{f[i]}
• 转移方程可列为：
f[i] = sum[i] - min{ sum[j] } (i-k<=j<=i)

此时的时间复杂度为 O(n*m)。
因为减数已经有了位置的限定，不能用一个变量来记录（维护）。
可以采用类似滑动窗口的思路，维护一个最大容量为 m 的单调队列，就能够将每次 m 的遍历优化到常数。
优化后的时间复杂度仍为 O(n)。

对于环，我们可以变环为链去解决。

#include<stdio.h>
#include<deque>
#include<string.h>
using namespace std;
deque<int>q;
int a[100010],sum[200020];
int main(){
	int T,N,K;
	scanf("%d",&T);
	while(T--){
		scanf("%d%d",&N,&K);
		for(int i=1;i<=N;i++)
			scanf("%d",&a[i]);
		int ans=a[1]-1,L,R;
		memset(sum,0,sizeof sum);
		for(int i=1;i<=N;i++)
			sum[i]=sum[i-1]+a[i];
		for(int i=N+1;i<=N+K;i++)
			sum[i]=sum[i-1]+a[i-N];
		q.clear();
		q.push_back(0);
		for(int i=1;i<=N+K;i++){
			if(ans<sum[i]-sum[q.front()]){
				ans=sum[i]-sum[q.front()];
				R=i,L=q.front()+1;
			}
			while(!q.empty() && sum[q.back()]>sum[i])
				q.pop_back();
			q.push_back(i);
			while(i+1-q.front()>K)
				q.pop_front();
		}
		if(R>N)R=R-N;
		printf("%d %d %d\n",ans,L,R);
	} 
	return 0;
}