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.
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
差分约束系统的题。。。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;
}