POJ 1716 Integer Intervals

题意：给出一些区间，求一个集合的长度要求每个区间里都至少有两个集合里的数。

解法：贪心或者差分约束。贪心的思路很简单，只要将区间按右边界排序，如果集合里最后两个元素都不在当前区间内，就把这个区间内的最后两个数加入集合，如果只有一个元素在区间里就加一个，如果两个元素都在区间里就不加。

差分约束系统用来解一个不等式组，只要这个不等式组里的不等式形如x1 - x2 <= c，c为常数就可以用差分约束来解不等式，将每个变量看做点，每个不等式看做边，求一个最短路，那么dis[i]就是不等式的一组解，主要利用的原理就是在最短路问题中：dis[v] <= dis[u] + edge[u][v]，而将x1 - x2 <= c进行移项就可以得到以上形式，由于有负权，所以一般用bellmanford或者spfa……不过我不会写spfa……如果产生负环说明无解。

对于本题来说，将每个区间端点都看做点，sum[i]表示集合中小于等于i的数的个数，则对于一个区间[l, r]来说有不等式sum[r] - sum[l - 1] >= 2，转化成上述形式就是sum[l - 1] - sum[r] <= -2，可以看做是点r到点l-1的一条权值为-2的边。除了题中给出的条件，还有一个隐含条件为0 <= sum[i] - sum[i - 1] <= 1，用以上不等式建图后跑最短路，dis[n] - dis[0]即为答案。

差分约束比较复杂……但是主要想练差分约束才做的这题= =但是数据范围略大……跑bellmanford有点难……最后1000ms擦边过的……

代码：

贪心：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<math.h>
#include<limits.h>
#include<time.h>
#include<stdlib.h>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#include<iomanip>
#define LL long long
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

using namespace std;

struct node
{
    int l, r;
    bool operator < (const node &tmp) const
    {
        if(r == tmp.r) return l < tmp.l;
        return r < tmp.r;
    }
}interval[10005];
int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        for(int i = 0; i < n; i++)
            scanf("%d%d", &interval[i].l, &interval[i].r);
        sort(interval, interval + n);
        int x = -1, y = -1;
        int ans = 0;
        for(int i = 0; i < n; i++)
        {
            if(interval[i].l <= x) continue;
            if(interval[i].l <= y)
            {
                x = y;
                y = interval[i].r;
                ans++;
                continue;
            }
            x = interval[i].r - 1;
            y = interval[i].r;
            ans += 2;
        }
        cout << ans << endl;
    }
    return 0;
}

　　

差分约束系统：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<math.h>
#include<limits.h>
#include<time.h>
#include<stdlib.h>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#include<iomanip>
#define LL long long
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

using namespace std;

struct node
{
    int u, v, value;
    node(int u, int v, int value) : u(u), v(v), value(value) {}
    node() {}
}edge[30005];
int minn = 10000000, maxn, m, cnt;
int dis[10005];
const int inf = 0x3f3f3f3f;
void BellmanFord()//由于不存在无解的数据，不需要判负环
{
    memset(dis, 0, sizeof dis);
    dis[minn] = 0;
    bool flag = true;
    while(flag)//剪枝，如果本次没有进行松弛，则停止松弛
    {
        flag = false;
        for(int j = 0; j < cnt; j++)
            if(dis[edge[j].v] > dis[edge[j].u] + edge[j].value)
            {
                flag = true;
                dis[edge[j].v] = dis[edge[j].u] + edge[j].value;
            }
    }
}
int main()
{
    while(~scanf("%d", &m))
    {
        cnt = 0;
        for(int i = 0; i < m; i++)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            minn = min(minn, min(a, b + 1));//记录最小点
            maxn = max(maxn, max(a, b + 1));//记录最大点
            edge[cnt++] = node(b + 1, a, -2);
        }
        for(int i = minn + 1; i <= maxn; i++)
        {
            edge[cnt++] = node(i - 1, i, 1);
            edge[cnt++] = node(i, i - 1, 0);
        }
        BellmanFord();
        cout << dis[maxn] - dis[minn] << endl;
    }
    return 0;
}