POJ 3680 Intervals 费用流+离散化

最新推荐文章于 2019-03-01 15:38:31 发布

aosakixuan

最新推荐文章于 2019-03-01 15:38:31 发布

阅读量416

点赞数

CC 4.0 BY-SA版权

分类专栏：图论-网络流

本文链接：https://blog.youkuaiyun.com/aosakixuan/article/details/47659579

图论-网络流专栏收录该内容

5 篇文章

订阅专栏

本文探讨了在给定的区间集合中，如何选择部分区间以最大化总权重，同时确保任意点的覆盖次数不超过给定阈值的问题。通过构建特定类型的图并应用增广路径算法，实现了解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Intervals

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 6930		Accepted: 2884

Description

You are given N weighted open intervals. The ith interval covers (a_i, b_i) and weighs w_i. Your task is to pick some of the intervals to maximize the total weights under the limit that no point in the real axis is covered more than k times.

Input

The first line of input is the number of test case.
The first line of each test case contains two integers, N and K (1 ≤ K ≤ N ≤ 200).
The next N line each contain three integers a_i, b_i, w_i(1 ≤ a_i < b_i ≤ 100,000, 1 ≤ w_i ≤ 100,000) describing the intervals.
There is a blank line before each test case.

Output

For each test case output the maximum total weights in a separate line.

Sample Input

4

3 1
1 2 2
2 3 4
3 4 8

3 1
1 3 2
2 3 4
3 4 8

3 1
1 100000 100000
1 2 3
100 200 300

3 2
1 100000 100000
1 150 301
100 200 300

Sample Output

Source

POJ Founder Monthly Contest – 2008.07.27, windy7926778

引用一个题解

有N个整数区间，每个区间有一个权值，从中取一些区间，使得任意整数点的重叠数不大于K，并且这些区间的总权值最大。

http://blog.youkuaiyun.com/waitfor_/article/details/7380406 引用这个题解

建图从0->1,1->2,~~~~~n->n+1每条边容量为k，费用为0，

对于每条线段，他的两个端点连边容量为1，费用-w

算法正确性证明：

如果两个区间没有交集，那么代表它们的边可以出现在同一增广路上，这一点显然。否则，它们就在不同的增广路上。每一个区间对应的边的容量都是1，这样，最后的流量就是被选出的两两有交集的区间的数量。受到(0,1,k,0)这条边的容量限制，这个值刚好不大于k.区间的权都是正的，因此选取的区间多多益善，所以流量必然最大。

（对于每次选取的增广路中总存在一个区间，在每次增广所得区间都与这个区间有交集）

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <functional>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <list>
#include <stack>
#define ALL(v) (v).begin(),(v).end()
#define foreach(i,v) for (__typeof((v).begin())i=(v).begin();i!=(v).end();i++)
#define SIZE(v) ((int)(v).size())
#define mem(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define lp(k,a) for(int k=1;k<=a;k++)
#define lp0(k,a) for(int k=0;k<a;k++)
#define lpn(k,n,a) for(int k=n;k<=a;k++)
#define lpd(k,n,a) for(int k=n;k>=a;k--)
#define sc(a) scanf("%d",&a)
#define sc2(a,b) scanf("%d %d",&a,&b)
#define lowbit(x) (x&(-x))
#define ll int
#define pi pair<int,int>
#define vi vector<int>
#define PI acos(-1.0)
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define TT cout<<"*****"<<endl;
#define TTT cout<<"********"<<endl;

using namespace std;
#define inf 0x3f3f3f3f
#define Inf 0x3FFFFFFFFFFFFFFFLL
#define N 5000
#define M 5000

struct Edge
{
    ll to,cap,cost,nex;
    Edge() {}
    Edge(ll to,ll cap,ll cost,ll next):to(to),cap(cap),cost(cost),nex(next) {}
} edge[M];

struct{
    int a,b,w;
}line[210];

ll head[N],top;
ll D[N],A[N],P[N],li[N];
bool inq[N];

void add(ll from,ll to,ll cap,ll cost)
{
    edge[top]=Edge(to,cap,cost,head[from]);
    head[from]=top++;
    edge[top]=Edge(from,0,-cost,head[to]);
    head[to]=top++;
}

bool spfa(ll s,ll t,ll &flow,ll &cost)
{
    for(ll i=0;i<=t;i++) D[i]=inf;
    mem(inq);
    queue<ll>q;
    q.push(s);
    D[s]=0;
    A[s]=inf;
    while(!q.empty())
    {
        ll u=q.front();
        q.pop();
        inq[u]=0;
        for(ll i=head[u];~i;i=edge[i].nex)
        {
            Edge &e=edge[i];
            if(e.cap && D[e.to]>D[u]+e.cost)
            {
                D[e.to]=D[u]+e.cost;
                P[e.to]=i;
                A[e.to]=min(A[u],e.cap);
                if(!inq[e.to])
                {
                    inq[e.to]=1;
                    q.push(e.to);
                }
            }
        }
    }
    if(D[t]==inf) return false;
    cost+=D[t]*A[t];
    flow+=A[t];
    ll u=t;
    while(u!=s)
    {
        edge[P[u]].cap-=A[t];
        edge[P[u]^1].cap+=A[t];
        u=edge[P[u]^1].to;
    }
    return true;
}

ll mcmf(ll s,ll t)
{
    ll flow=0, cost=0;
    while(spfa(s,t,flow,cost));
    return cost;
}


int a[N],S,T,n,m,k,u,v,w,cnt;
void init()
{
    mem1(head);
    cnt=0;
    top=0;
    lp(i,m)
    {
        sc2(u,v); sc(w);
        li[cnt++]=u;
        li[cnt++]=v;
        line[i].a=u;
        line[i].b=v;
        line[i].w=w;
    }

    sort(li,li+cnt);
    n=unique(li,li+cnt)-li;
    S=0;
    T=n+1;
    lp(i,n+1)
        add(i-1,i,k,0);

    lp(i,m)
    {
        int x=lower_bound(li,li+n,line[i].a)-li+1;
        int y=lower_bound(li,li+n,line[i].b)-li+1;
        add(x,y,1,-line[i].w);
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    int t;
    sc(t);
    while(t--)
    {
        scanf("%d%d",&m,&k);
        init();
        int cost=mcmf(S,T);
        printf("%d\n",-cost);
    }
    return 0;
}