hdoj 4747 线段树

hdoj 4747

题意：给一个序列，问所有区间[i,j]（i<=j）中，区间中最小的非负整数加和是多少。

思路：

看样例：

1 0 2 0 1

做出以第一个元素1为起点的分别到其他各点的所有区间最小值：

0 2 3 3 3

发现是一个单调递增序列，实际上对于任何一个样例都是这样的结果，因为随着数字的增加，最小值只会增大。

然后我们删掉第一个数字，做第二个元素0的区间最小值：

x 1 1 1 3

因为我们删掉了0之前的1后，在下一个1出现之前，这段区间中就可能拥有一个更小的值1。

而相比于1的区间最小值，0的区间最小值只修改了两个1中间的这段序列，并且是将所有大于1的数字修改为1。

而又因为这是个单调序列，所以修改的这段范围最多有1个（如果没有比删掉的这个值小的数就不用修改）

所以题目就转化成了线段树区间修改区间查询。

先预处理相同数字的位置邻接表，再找出序列中最左端的大于等于删除掉的数Vi的位置L，然后找到下个Vi出现的位置R，如果没有就是序列的最后位置n，最后将这个区间的值修改为Vi。

#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>
using namespace std;

const int M = 200020;
struct Tree{
int l, r, val;
int flag;
long long sum;
}tree[M * 4];
int seq[M], mex[M], Next[M];
bool vis[M];
map<int, int>mp;
int cnt, n;
void buildtree(int rt, int l, int r) {
tree[rt].l = l, tree[rt].r = r, tree[rt].flag = false;
if(l == r) {
tree[rt].val = mex[cnt++];
tree[rt].sum = tree[rt].val;
//    printf("%d %d %d %I64d\n", rt, tree[rt].l, tree[rt].r, tree[rt].sum);
return ;
}
int mid = (l + r) / 2;
buildtree(rt * 2, l, mid);
buildtree(rt * 2 + 1, mid + 1, r);
tree[rt].val = max(tree[rt * 2].val, tree[rt * 2 + 1].val);
tree[rt].sum = tree[rt * 2].sum + tree[rt * 2 + 1].sum;
//   printf("%d %d %d %I64d\n", rt, tree[rt].l, tree[rt].r, tree[rt].sum);
}
void pushdown(int rt){
if(tree[rt].flag) {
tree[rt * 2].val = tree[rt * 2 + 1].val = tree[rt].val;
tree[rt * 2].sum = (long long) (tree[rt * 2].r - tree[rt * 2].l + 1) * tree[rt * 2].val;
tree[rt * 2 + 1].sum = (long long) (tree[rt * 2 + 1].r - tree[rt * 2 + 1].l + 1) * tree[rt * 2 + 1].val;
tree[rt * 2].flag = tree[rt * 2 + 1].flag = true;
tree[rt].flag = false;
}
}
void pullup(int rt) {
tree[rt].sum = tree[rt * 2].sum + tree[rt * 2 + 1].sum;
tree[rt].val = max(tree[rt * 2].val, tree[rt * 2 + 1].val);
}
long long query(int rt, int l, int r) {
if(tree[rt].l == l && tree[rt].r == r) {
return tree[rt].sum;
}
pushdown(rt);
int mid = (tree[rt].l + tree[rt].r) / 2;
if(l > mid) return query(rt * 2 + 1, l, r);
else if(r <= mid) return query(rt * 2, l, r);
else return query(rt * 2, l, mid) + query(rt * 2 + 1, mid + 1, r);
}
void update(int rt, int l, int r, int a) {
if(tree[rt].l == l && r == tree[rt].r) {
tree[rt].val = a;
tree[rt].sum = (long long)(tree[rt].r - tree[rt].l + 1) * a;
tree[rt].flag = true;
return ;
}
pushdown(rt);
int mid = (tree[rt].l + tree[rt].r) / 2;
if(l > mid) update(rt * 2 + 1, l, r, a);
else if(r <= mid) update(rt * 2, l, r, a);
else {
update(rt * 2, l, mid, a);
update(rt * 2 + 1, mid + 1, r, a);
}
pullup(rt);
}
int getLeft(int rt, int val) {
if(tree[rt].l == tree[rt].r) {
if(tree[rt].val >= val) return tree[rt].l;
else return n + 1;
}
pushdown(rt);
if(tree[rt * 2].val >= val) return getLeft(rt * 2, val);
else return getLeft(rt * 2 + 1, val);
}
int main() {
//  freopen("in.txt", "r", stdin);
while(~scanf("%d", &n) && n) {
mp.clear();
for(int i = 1; i <= n; i++) scanf("%d", &seq[i]);
for(int i = 1; i <= n; i++) Next[i] = n;
memset(vis, 0, sizeof vis);
int val = 0;
for(int i = 1; i <= n; i++) {
if(seq[i] < M) vis[seq[i]] = true;
while(vis[val]) val++;
mex[i] = val;
}
for(int i = 1; i <= n; i++) {
if(mp.find(seq[i]) != mp.end()) Next[mp[seq[i]]] = i - 1;
mp[seq[i]] = i;
}
long long ans = 0;
cnt = 1;
buildtree(1, 1, n);
for(int i = 1; i <= n; i++) {
ans += query(1, i, n);
int left = getLeft(1, seq[i]);
//    printf("[%d, %d] = %d\n", left, Next[i], seq[i]);
if(left <= Next[i]) update(1, left, Next[i], seq[i]);
//      printf("%I64d\n", ans);
}
printf("%I64d\n", ans);
}
return 0;
}