poj 3680 Intervals (离散化+费用流)_n条线段,选择若干个不相交的线段,权值最大-CSDN博客

n条线段，带有权值。

选择其中若干条，使得权值最大且每个端点覆盖次数都不超过K次。

建图：

1、将输入的顶点离散化。设总共不同的顶点个数为n。

2、将顶点i到i+1连一条容量为K，费用为0的边。

3、新建源点0和汇点n+1，顶点0到1、顶点n到n+1分别连容量为K，费用为0的边。

4、对于每个区间的两个端点，连一条容量为1，费用为-w的边。

5、求最小费用最大流，得到的费用即为所求的最大权值的相反数。

说明：

1、输入中区间顶点的编号范围为1e5，而边的数量不过200，即实际上顶点数量最多只有400个，因此可以离散化处理顶点编号，方便建图。

2、对于任意两个区间，若二者不重复，则从顶点0到n+1的流量必然可以经过二者对应的边，即在同一条增广路中。若重复则二者对应的边分别处于两条不同的增广路中。而这两条不同的增广路交点为编号为n的顶点，其到顶点n+1的流量为K，即最终求出来的增广路数量不会超过K，即重叠的区间个数不会超过K，也即重叠的顶点数不会超过K。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uI;
typedef double db;
#define inf 0x3f3f3f3f
#define maxn 405
#define maxq 8000
#define maxm 1205
struct Edge{
    int to,next,cap,cost;
}edge[maxm];

int n,m,head[maxn],cnt,Q[maxq],qhead,qtail;
int cur[maxn],f[maxn],mcmf_cost,mcmf_flow;

inline void add(int u,int v,int cap,int cost)
{
    edge[cnt].to=v;
    edge[cnt].cap=cap;
    edge[cnt].cost=cost;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].to=u;
    edge[cnt].cap=0;
    edge[cnt].cost=-cost;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

int d[maxn];
bool vis[maxn];

inline bool spfa(int s,int e)
{
    int i;
    qhead=qtail=0;
    memset(d,inf,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s]=0;
    Q[qtail++]=s;
    cur[s]=-1;
    f[s]=inf;
    vis[s]=1;
    while(qtail>qhead)
    {
        int u=Q[qhead++];
        vis[u]=0;
        for(i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>0&&d[v]>d[u]+edge[i].cost)
            {
                d[v]=d[u]+edge[i].cost;
                f[v]=min(f[u],edge[i].cap);
                cur[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    Q[qtail++]=v;
                }
            }
        }
    }
    if(d[e]==inf) return 0;
    mcmf_flow+=f[e];
    for(i=cur[e];~i;i=cur[edge[i^1].to])
    {
        edge[i].cap-=f[e];
        edge[i^1].cap+=f[e];
        mcmf_cost+=f[e]*edge[i].cost;
    }
    return 1;
}

int e[201][3],num[100001];
int main()
{
    int T,K,i;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&m,&K);
        cnt=0;
        memset(head,-1,sizeof(head));
        memset(num,0,sizeof(num));
        mcmf_cost=mcmf_flow=0;
        int Min=20000000,Max=-1;
        for(i=1;i<=m;++i)
        {
            scanf("%d%d%d",&e[i][0],&e[i][1],&e[i][2]);
            num[e[i][0]]=num[e[i][1]]=1;
            Min=min(e[i][0],min(e[i][1],Min));
            Max=max(e[i][0],max(e[i][1],Max));
        }
        n=0;
        for(i=Min;i<=Max;++i) if(num[i]) num[i]=++n;
        for(i=1;i<=m;++i) add(num[e[i][0]],num[e[i][1]],1,-e[i][2]);
        for(i=0;i<=n;++i) add(i,i+1,K,0);
        while(spfa(0,n+1));
        printf("%d\n",-mcmf_cost);
    }
    return 0;
}