poj 1201 interval 差分约束/贪心+线段树区间更新

Intervals

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 22337		Accepted: 8423

Description

You are given n closed, integer intervals [ai, bi] and n integers c1, ..., cn. 

Write a program that: 

reads the number of intervals, their end points and integers c1, ..., cn from the standard input, 

computes the minimal size of a set Z of integers which has at least ci common elements with interval [ai, bi], for each i=1,2,...,n, 

writes the answer to the standard output. 

Input

The first line of the input contains an integer n (1 <= n <= 50000) -- the number of intervals. The following n lines describe the intervals. The (i+1)-th line of the input contains three integers ai, bi and ci separated by single spaces and such that 0 <=
ai <= bi <= 50000 and 1 <= ci <= bi - ai+1.
Output

The output contains exactly one integer equal to the minimal size of set Z sharing at least ci elements with interval [ai, bi], for each i=1,2,...,n.
Sample Input

5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1

Sample Output

6

Source

Southwestern Europe 2002

差分约束系统的题。。。wa了很多次因为没注意清楚约束条件和隐藏条件

题目要求的是区间 [ai,bi]中至少有ci个数，一开始直接转化为 Sbi-Sai >= ci 个数，Sn代表前n个数中包含多少个，但其实Sbi-Sai包含的是(ai,bi],所以应该用区间Sbi-S(ai-1)。

但是ai有可能为0，所以统一都+1区间变为S(bi+1)-Sai>=ci

根据这个问题，加进去之间的点还必须满足一些隐藏条件： 

        1.对于a<=b, Sa <= Sb。

        2.同时一个区间[a,b]内最多也只能包含b-a+1个， 所以还有 Sb+1-Sa >= b-a+1 (这里区间是上面说的+1后)

        确定三个条件后，建立图论模型求最长路径 SaI+ci <= Sbi，从ai到bi连接一条权为ci的边

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;

#define maxn 50005
#define inf 0x3f3f3f3f

struct edge
{
edge(){}
edge(int v_, int w_, int n) { v=v_; w=w_; next=n;}
int v;
int w;
int next;
};

edge g[4*maxn];
int first[maxn], top;

void add(int u, int v, int w)
{
g[top] = edge(v, w, first[u]);
first[u] = top++;
}

int d[maxn];
int in[maxn];

void spfa(int s)  //因为图是连通的，所以可以用spfa
{
memset(d, -inf, sizeof(d));
memset(in, 0, sizeof(in));
queue<int> que;
que.push(s);
d[s] = 0;

while(!que.empty()){
int u = que.front(); que.pop();
in[u] = 0;

for(int i = first[u]; i != -1; i = g[i].next){
int v = g[i].v, w= g[i].w;
if(d[u]+w > d[v]){      //求最长路径
d[v] = d[u]+w;
if(!in[v]){
in[v] = 1;
que.push(v);
}
}
}
}
}

int h[maxn]; //记录用到的点
int arr[maxn]; //用到的点从小到大存储

int main()
{
int n;
while(~scanf("%d", &n)){
memset(h, 0, sizeof(h));
memset(first, -1, sizeof(first));

int s, e;
int a, b, w;
for(int i = 0; i < n; i++){
scanf("%d%d%d", &a, &b, &w);
add(a,b+1,w);
h[a]=h[b+1]=1;
}

int cnt = 0;
for(int i = 0; i < maxn; i++)
if(h[i])
arr[cnt++] = i;             //arr中存储点，从小到大

for(int i = 1; i < cnt; i++){
add(arr[i-1], arr[i], 0);       //相邻两个点满足Sa+0 <= Sb,从a到b一条边边权为0
add(arr[i], arr[i-1], -(arr[i]-arr[i-1]));  //满足最多不超过b-a+1,  Sb+1-Sa<= b-a+1( Sb-(b-a+1)<=Sa)
}                                              //从b到a连接边权-(b-a+1)

spfa(arr[0]);
printf("%d\n", d[arr[cnt-1]]);
}
return 0;
}

还有另外一种做法就是贪心+线段树，按每个区间的末端点从小到大排序。从第一个区间开始，每个区间检查有多少个数，小于c个，则从区间末端一直往前增加直到满足c个为止，这是O(n^2)。用线段树优化就可以达到O(nlogn)，在进行区间更新时，优先选择先更新靠右的区间，同时返回增加了多少个数，然后再继续更新左边的区间，具体写在注释里了。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

#define maxn 50005

int n;

struct node     //线段树节点
{
node() {}
node(int ll, int rr) { l = ll; r = rr;}
int l, r;
int sum;        //sum表示该节点区间上一共有多少个数了
int inc;
};

node tr[4*maxn];

void build(int rt, int l, int r)
{
tr[rt] = node(l, r);
tr[rt].inc = tr[rt].sum = 0;

if(l == r)
return;

int m = l+(r-l)/2;
build(2*rt, l, m);
build(2*rt+1, m+1, r);
}

int query(int rt, int ll, int rr)
{
int l = tr[rt].l, r = tr[rt].r;
int &sum = tr[rt].sum;
int &inc = tr[rt].inc;
int lc = 2*rt, rc = 2*rt+1;

if(l == ll && r == rr)
return sum;
else{
if(inc){
tr[lc].inc = 1;
tr[rc].inc = 1;
tr[lc].sum = tr[lc].r-tr[lc].l+1;
tr[rc].sum = tr[rc].r-tr[rc].l+1;
inc = 0;
}
}

int m = l+(r-l)/2;
if(rr <= m)
return query(lc, ll, rr);
else if(ll > m)
return query(rc, ll, rr);
else
return query(lc, ll, m)+query(rc, m+1, rr);
}

int seg_modify(int rt, int ll, int rr, int v)  //v表示需要增加的个数
{
int l = tr[rt].l, r = tr[rt].r;
int &sum = tr[rt].sum;
int &inc = tr[rt].inc;
int lc = 2*rt, rc = 2*rt+1;
if(sum == r-l+1) return 0;

int ret;

if(l == ll && r == rr && sum+v>=r-l+1){   //如果需要刚好对应节点区间，且增加的个数使得该区间满了，则直接更新该节点整个区间
ret = (r-l+1)-sum; //返回增加的个数
sum = (r-l+1);
inc = 1;
return ret;
}
else{
if(inc){
tr[lc].inc = 1;
tr[rc].inc = 1;
tr[lc].sum = tr[lc].r-tr[lc].l+1;
tr[rc].sum = tr[rc].r-tr[rc].l+1;
inc = 0;
}
}

int m = l+(r-l)/2;
if(rr <= m)
seg_modify(lc, ll, rr, v);
else if(ll > m)
seg_modify(rc, ll, rr, v);
else{

int left = v-seg_modify(rc, m+1, rr, v); //优先更新靠右边的区间，然后计算还要增加的个数
if(left)
seg_modify(lc, ll, m, left);
}

ret = tr[lc].sum+tr[rc].sum - tr[rt].sum;
tr[rt].sum += ret;
return ret;
}

struct range    //保存输入区间的节点
{
int l, r;
int c;
bool operator <(const range& t) const
{
return r < t.r;
}
};

range a[maxn];

int main()
{
while(~scanf("%d", &n)){
for(int i = 0; i < n; i++)
scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].c);
sort(a, a+n);

int ub = a[n-1].r;
build(1, 0, ub);
for(int i = 0; i < n; i++){
int cnt = query(1, a[i].l, a[i].r);
if(cnt < a[i].c)
seg_modify(1, a[i].l, a[i].r, a[i].c-cnt);
}

printf("%d\n", query(1, 0, ub));
}
return 0;
}