poj 3680(最小费用最大流)

题目链接：http://poj.org/problem?id=3680

思路：因为N<=200,而区间范围为【1，100000】，因此需要离散化，去重，然后就是建图了相连两点连边，容量为k,费用为0，然后就是对区间端点进行连边，容量为1，费用为权值，最后就是跑费用流了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define MAXN 444
#define MAXM 444444
#define inf 1<<30

struct Edge{
int v,cap,cost,next;
}edge[MAXM];

int vs,vt,NE,n,m;
int head[MAXN];

void Insert(int u,int v,int cap,int cost)
{
edge[NE].v=v;
edge[NE].cap=cap;
edge[NE].cost=cost;
edge[NE].next=head[u];
head[u]=NE++;

edge[NE].v=u;
edge[NE].cap=0;
edge[NE].cost=-cost;
edge[NE].next=head[v];
head[v]=NE++;
}

int pre[MAXN],cur[MAXN];
int dist[MAXN];
bool mark[MAXN];
bool spfa(int vs,int vt)
{
memset(mark,false,sizeof(mark));
fill(dist,dist+vt+1,-inf);
dist[vs]=0;
queue<int>que;
que.push(vs);
while(!que.empty()){
int u=que.front();
que.pop();
mark[u]=false;
for(int i=head[u];i!=-1;i=edge[i].next){
int v=edge[i].v;
if(edge[i].cap>0&&dist[u]+edge[i].cost>dist[v]){
dist[v]=dist[u]+edge[i].cost;
pre[v]=u;
cur[v]=i;
if(!mark[v]){
mark[v]=true;
que.push(v);
}
}
}
}
return dist[vt]!=-inf;
}

int MinCostFlow(int vs,int vt)
{
int flow=0,cost=0;
while(spfa(vs,vt)){
int aug=inf;
for(int u=vt;u!=vs;u=pre[u]){
aug=min(aug,edge[cur[u]].cap);
}
flow+=aug,cost+=dist[vt]*aug;
for(int u=vt;u!=vs;u=pre[u]){
edge[cur[u]].cap-=aug;
edge[cur[u]^1].cap+=aug;
}
}
return cost;
}

struct Line{
int u,v,w;
}line[MAXN];

int num[MAXN];

int main()
{
//   freopen("1.txt","r",stdin);
int _case,cnt=0;
scanf("%d",&_case);
while(_case--){
scanf("%d%d",&n,&m);
cnt=NE=0;
memset(head,-1,sizeof(head));
for(int i=1;i<=n;i++){
scanf("%d%d%d",&line[i].u,&line[i].v,&line[i].w);
num[cnt++]=line[i].u;
num[cnt++]=line[i].v;
}
sort(num,num+cnt);
cnt=unique(num,num+cnt)-num;
for(int i=1;i<=cnt;i++){
Insert(i-1,i,m,0);
}
for(int i=1;i<=n;i++){
int a=lower_bound(num,num+cnt,line[i].u)-num+1;
int b=lower_bound(num,num+cnt,line[i].v)-num+1;
Insert(a,b,1,line[i].w);
}
printf("%d\n",MinCostFlow(0,cnt));
}
return 0;
}

View Code