hdu 2430 优先队列/线段树

1.我自己的想法是用线段树的

考虑从i开头的字串，设sum[i,n] = x,sum[j,n] = y;

要使得x mod p + y mod p <= k ，可以确定y的范围，问题转换为在一个范围内求最值的问题

只要用线段树处理每个y的最小sum，就可以在logN时间内求出i开头的字串中的最大满足条件的值了

一A还是挺爽的，我的线段树做法要考虑一些关于范围的小细节

#include
using namespace std;
typedef long long ll;
const int maxn = 3000000; 
const ll INF  = (ll)1 << 60;
ll ql,qr,p,v;
ll minv[maxn];
int n; 
int tt,nn,pp,kk;
int w[1000010];
ll query(int o,int L,int R){
	ll M = (L + (R - L)/2),ans = INF;
	if (ql <= L && R <= qr) return minv[o];
	if (ql <= M) ans = min(ans,query(o*2,L,M));
	if (M < qr) ans = min(ans,query(o*2 + 1,M + 1,R));
	return ans;
} 

void update(int o,int L,int R){
	int M = L + (R - L)/2;
	if (L == R) {
		if (minv[o] < v) return ;
		else minv[o] = v;
	}
	else{
		if (p <= M) update(o * 2,L, M);
		else update(o * 2 + 1,M + 1,R);
		minv[o] = min(minv[o * 2],minv[o * 2 + 1]);
	}
}

void build(int q)
{
	for(n = 1; n < q; n = n * 2);
	for(int i = 1; i < 2*n; i++)
	    minv[i] = INF;
	p = 0;v = 0;//mod为0的有一个 
	update(1,0,n - 1);
}




int main()
{
	scanf("%d",&tt);
	for(int test = 1; test <= tt; test++){
		scanf("%d %d %d",&nn,&pp,&kk);
		build(pp);
		for(int i = 1; i <= nn; i++){
			scanf("%d",&w[i]);
		}
		ll cur = 0;
		ll curmod = 0;
		ll ans = -1;
		for(int i = nn; i >= 1; i--){
		    cur = cur + w[i];
		    curmod = cur % pp;
		    ql = max(curmod - kk + pp,curmod);
		    qr = pp - 1;
		    //printf("%d %d ",ql,qr);
			if (ql <= qr) {
		    	ll temp = query(1,0,n - 1);
		    	if (temp != INF)
				    ans = max(ans,cur - temp); 
			}
			ql = max(curmod - kk,(ll)0);
			qr = curmod;
			//printf("%d %d",ql,qr);
			if (ql <= qr){
			    ll temp = query(1,0,n - 1);
			    if (temp != INF)
			        ans = max(ans,cur - temp);
			}
			p = curmod; v = cur;
			update(1,0,n - 1);
			//printf(" %d\n",ans);
		}
		if (ans != -1) ans = ans / pp;
		printf("Case %d: %d\n",test,ans);
	}
	return 0;
}

网上的做法是用优先队列，还是挺高级的

试想一个的sum[i,n] mod p = x;

y的模的范围也可以确定，这里可以认为x > y 因为如果x < y 在考虑y的时候会考虑到x，如果是小的减大的会变成负数，是不会取的，所以

可以确定一个y的范围，而这个范围是一个随着x减小左移的滑动窗口，就是要维护滑动窗口中的最小值

用单调队列可以维护，右边的y对于的sum先入队，左边的y的sum如果比右边的小，那么右边的就用不到了，出队，每个元素最多进队一次，出队一次，每次把右边的一部分不满足的出队了，然后加入新的点，又能把右边的一部分出队，队伍里满足若i < j 那么sum[i] < sum[j] 且 pos[i] >pos[j]

优先队列还不是很熟悉啊……