hdu5700

首先把每个区间的两点（不用分是左端还是右端我们只看位置,但是要打上标记是左端还是右端)都加入到数列中，然后对序列进行排序，然后分左端点和右端点进行求最值，具体方法是:

1.你要注意一个性质就是选出来的答案的区间左端至少有k个左端点。然后我们就是不断的移动:

举个栗子:

11 3  4

1 2 3 4 5 6 7 8 9 10 11

1 8

2 7

3 6

4 5

排序:

1 2 3 4 5 6 7 8

1 2 3 4 都是左端点进栈

然后到5的时候开始询问:

由于1的左端区间数小于k，1出栈，同理2也是

现在是3，所以询问的答案就是3到5的和就是：12

但是这样求出来的答案明显是错的，因为5是和4对应的。然后怎么办？

显然先让4出栈，（用打标记的办法让他出去具体见代码)

然后现在是6，又开始询问

答案是3到6的值，现在答案对了，弥补了以前错误的答案。

现在应该知道原因了吧:

就算先开始我们计算了错误答案，但是算了错误答案后后面一定会有正确的答案把它覆盖掉所以不用担心。

至于为什么。。。讲不明白。。。

用我上面提到的性质加分类讨论仔细想想吧.

重要性质:你要注意一个性质就是选出来的答案的区间左端至少有k个左端点,而且这k个左端点对应的右端点你都没询问过！！！

易错点:

1.考虑区间各端点重合的情况

2.ans没有的时候输出0，题意没讲明白

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
int n, m, k;
ll sum[100020];
int tot;
int stackk[100020];
int l = 0;
int r = -1;
bool isinstack[100020];
ll  ans = -100000000000000000;
int allamount;
struct nodee
{
	int kind;
	int real, num;
};
struct pairr
{
	int l, r;
};
nodee node[200020];
pairr p[100010];
bool com(nodee a, nodee b)
{
	if (a.real == b.real)
	{
		if (a.kind == b.kind&&a.kind == 0)
			return p[a.num].r < p[b.num].r;
		return a.kind < b.kind;
	}
	return a.real < b.real;
}
void getin(int num)
{
	stackk[++r] = num;
	isinstack[node[num].num] = 1;
}
int gettop()
{
	while (l <=r && (isinstack[node[stackk[l]].num] == 0 || allamount < k - 1))
		allamount += isinstack[node[stackk[l]].num],
		l++;
	if (l <= r)
		return node[stackk[l]].real;
	else
		return -1;
}
void getout(int i,int num)
{
	if (p[i].l < node[stackk[l]].real || l>r)
		allamount--;
	else
	{
		if (p[i].l == node[stackk[l]].real&&i != node[stackk[l]].num)
		{
			allamount--;
		}
		else
			isinstack[i] = 0;
	}
}
int main()
{
	while (scanf("%d%d%d", &n, &k, &m) != EOF)
	{
		ans = 0; tot = 0; l = 0; r = -1;
		allamount = 0;
		for (int i = 0; i <= n; i++)
			isinstack[i] = 0;
		for (int i = 1; i <= n; i++)
			scanf("%lld", &sum[i]),
			sum[i] += sum[i - 1];
		for (int i = 0; i < m; i++)
		{
			int a, b;
			scanf("%d%d", &a, &b);
			p[i].l = a; p[i].r = b;
			node[tot].kind = 0; node[tot].real = a, node[tot++].num = i;
			node[tot].kind = 1; node[tot].real = b, node[tot++].num = i;
		}
		sort(node, node + tot, com);
		for (int i = 0; i < tot; i++)
		{
			if (node[i].kind == 1)
			{
				int left = gettop();
				if (left != -1)
					ans = max(ans, sum[node[i].real] - sum[left - 1]);
				getout(node[i].num,i);
			}
			else
			{
				getin(i);
			}
		}
		printf("%lld\n", ans);
	}
	return 0;
}