POJ 3680 Intervals

POJ_3680

    一开始想的是将区间放到一边，然后点放到另一边，区间和覆盖的点连边做费用流，但这样很明显是错误的，因为在最大流时源点流入区间的边不一定是满流的，也就是说线段选择性地覆盖了若干个点，这显然是不科学的。

    在参考了别人的思路之后，发现保证每个点被覆盖K次，不仅可以每个点都连一条容量为K边到汇点，还可以每个点只连一条容量为K的边到后一个点，相当于把这些点串联起来，这样也可以保证每个点至多被覆盖K次。至于如何描述选择了一个区间(a,b)，可以连一条a到b的容量为1费用为w的边，这样只要再额外限定从源点出发的或者是流到汇点的容量为K，那么对于任何一个小区间就最多只会有K条流流过，这样就保证了每个点至多被覆盖K次。最后做最大费用最大流即可，因为原图没有环，所以可以不必考虑有正圈的情况。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAXD 410
#define MAXM 1210
#define INF 0x3f3f3f3f
#define NINF 0xc3c3c3c3
const int Q = 405;
int N, M, K, first[MAXD], e, next[MAXM], v[MAXM], flow[MAXM], cost[MAXM];
int S, T, tx[MAXD], q[MAXD], inq[MAXD], dis[MAXD], pre[MAXD];
struct Seg
{
    int x, y, w;
}seg[MAXD];
void init()
{
    int i;
    scanf("%d%d", &N, &K);
    for(i = 0; i < N; i ++)
    {
        scanf("%d%d%d", &seg[i].x, &seg[i].y, &seg[i].w);
        tx[i << 1] = seg[i].x, tx[i << 1 | 1] = seg[i].y;
    }
    std::sort(tx, tx + N * 2);
    for(i = M = 1; i < N * 2; i ++) if(tx[i] != tx[i - 1]) tx[M ++] = tx[i];
    tx[M] = INF;
}
int BS(int x)
{
    int mid, min = 0, max = M;
    for(;;)
    {
        mid = min + max >> 1;
        if(mid == min) break;
        if(tx[mid] <= x) min = mid;
        else max = mid;
    }
    return mid;
}
void add(int x, int y, int f, int c)
{
    v[e] = y, flow[e] = f, cost[e] = c;
    next[e] = first[x], first[x] = e ++;
}
void build()
{
    int i, x, y;
    S = 0, T = M;
    memset(first, -1, sizeof(first[0]) * (T + 1)), e = 0;
    for(i = 0; i < M; i ++)
        add(i, i + 1, K, 0), add(i + 1, i, 0, 0);
    for(i = 0; i < N; i ++)
    {
        x = BS(seg[i].x), y = BS(seg[i].y);
        add(x, y, 1, seg[i].w), add(y, x, 0, -seg[i].w);
    }
}
int bfs()
{
    int i, x, front = 0, rear = 0;
    memset(dis, 0xc3, sizeof(dis[0]) * (T + 1));
    dis[S] = 0, pre[S] = -1, q[rear ++] = S;
    memset(inq, 0, sizeof(inq[0]) * (T + 1));
    while(front != rear)
    {
        x = q[front ++], inq[x] = 0;
        front > Q ? front = 0 : 0;
        for(i = first[x]; i != -1; i = next[i])
            if(flow[i] && dis[v[i]] < dis[x] + cost[i])
            {
                dis[v[i]] = dis[x] + cost[i], pre[v[i]] = i;
                if(!inq[v[i]])
                {
                    q[rear ++] = v[i], inq[v[i]] = 1;
                    rear > Q ? rear = 0 : 0;
                }
            }
    }
    return dis[T] != NINF;
}
void solve()
{
    int i, c = 0, a;
    build();
    while(bfs())
    {
        for(i = pre[T], a = INF; i != -1; i = pre[v[i ^ 1]]) a = std::min(a, flow[i]);
        for(i = pre[T]; i != -1; i = pre[v[i ^ 1]])
            flow[i] -= a, flow[i ^ 1] += a;
        c += a * dis[T];
    }
    printf("%d\n", c);
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t --)
    {
        init();
        solve();
    }
    return 0;
}