HDU 4494 Teamwork（最大流-Dinic+最小费用最大流-mcmf）

关注

原创最新推荐文章于 2026-04-23 22:24:36 发布 1k 阅读 AI 写同款· GEO 优化 ›

网络流模板 —— Dinic算法（弧优化），最小费用最大流 学了几天感觉对网络流算是入门了，稍稍整理一下，同时在学习网络流的过程中看到了三篇别人很不错的blog（如下）感谢 ~~ 网络流相关定义及原理：https://www.cnblogs.com/rmy020718/p/9546071.html Dinic算法+弧优化：https://www.cnblogs.com/SYCstudio/p/7260613.html 网络流常见建模方法：https://... 阅读详情

Description

$m$ 种工人， $n-1$ 个工作，给出第 $i$ 个工作地点的坐标，开始时间，工作完成所需时间以及所需每种工人的数量，两个工作地点之间的距离定义为欧氏距离，工人速度为单位距离每单位时间，工人完成一个工作后如果在到达另一个工作地点时还没到开始时间即可继续工作，问至少要多少名工人才能完成这 $n$ 项工作

Input

第一行一整数 $T$ 表示用例组数，每组用例输入两整数 $n$ 和 $m$ 分别表示工作数量和工人数量，之后输入工人初始坐标，最后 $n-1$ 行每行输入该工作的坐标，开始时间，工作完成所需时间以及所需每种工人的数量 $(T\le 25,n\le 150,m\le 5)$

Output

对于每组用例，输出完成所有工作至少需要的工人数量

Sample Input

2
4 1
0 0
0 1 1 1 3
1 1 3 3 4
1 0 10 1 5
4 1
0 0
0 1 1 1 3
1 1 3 3 4
1 0 3 1 5

Sample Output

5
9

Solution1

可以看出每种工人之间相互独立，所以可以单独分析，考虑完成所有工作所需第 $k$ 种工人的数量，考虑把工人看作费用，把一项工作所需工人看作流量，那么问题转化为一个费用流，由于工人可以做多项工作，把每个工作拆点 $i,i+n-1$ ，建图如下：

1.源点向i连容量为无穷，费用为 $1$ 的边，体现出每个工人是一个费用

2. $i$ 向汇点连容量为 $num[i][k]$ (第 $i$ 项工作所需第 $k$ 种工人的数量)，费用为 $0$ 的边，体现出完成每项工作对工人数量的要求

3.源点向 $i+n-1$ 连容量为 $num[i][k]$ ，费用为 $0$ 的边，表示完成该项工作的工人还可以继续完成其他工作

4. $i+n-1$ 向 $j$ 连容量为 $num[i][k]$ ，费用为 $0$ 的边，如果 $i$ 工作的结束时间加上 $i$ 与 $j$ 的距离还要早于 $j$ 工作的开始时间，说明完成 $i$ 工作的工人可以继续完成 $j$ 工作

跑一边费用流，最小费用即为所需第 $k$ 种工人的最少数量，累加起来即为答案

Code1

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
#define maxn 333
#define maxm 66666
#define INF 0x3f3f3f3f
int head[maxn],d[maxn],s,e,no,vis[maxn],pre[maxn];//s为源点,e为汇点 
struct point
{
    int u,v,flow,next,cost;
    point(){};
    point(int _u,int _v,int _next,int _flow,int _cost)
    {
        u=_u,v=_v,next=_next,flow=_flow,cost=_cost;
    } 
}p[maxm];
void add(int x,int y,int z,int c)//从x到y建一条容量为z,花费为c的边 
{
    p[no]=point(x,y,head[x],z,c);   
    head[x]=no++;
    p[no]=point(y,x,head[y],0,-c);  
    head[y]=no++;
}
void init()//初始化 
{
    memset(head,-1,sizeof(head));
    no=0;
}
bool spfa()
{
    int i,x,y;
    queue<int>q;
    memset(d,0x3f,sizeof(d));
    memset(vis,false,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    d[s]=0;   
    vis[s]=true;  
    q.push(s);
    while(!q.empty())
    {
        x=q.front();  
        q.pop();    
        vis[x]=false;
        for(i=head[x];i!=-1;i=p[i].next)
        {
            if(p[i].flow&&d[y=p[i].v]>d[x]+p[i].cost)
            {
                d[y]=d[x]+p[i].cost;   
                pre[y]=i;
                if(vis[y])  
                    continue;
                vis[y]=true;  
                q.push(y);
            }  
        }  
    }
    return d[e]!=d[e+1];
}
int mcmf()//最小费用最大流 
{
    int mincost=0,maxflow=0,minflow,i;
    while(spfa())
    {
        //if(d[e]>=0)break;//可行流 
        minflow=INF;
        for(i=pre[e];i!=-1;i=pre[p[i].u])
            minflow=min(minflow,p[i].flow);
        for(i=pre[e];i!=-1;i=pre[p[i].u])
        {
            p[i].flow-=minflow;
            p[i^1].flow+=minflow;
        }
        mincost+=d[e]*minflow; 
        maxflow+=minflow;
    }
    return mincost;//最小费用,最大流为maxflow 
}
struct node
{
    double x,y,b,p;
    int num[6];
}a[maxn],o;
double dis(node a,node b)
{
    double x=a.x-b.x,y=a.y-b.y;
    return sqrt(x*x+y*y);
}
int T,n,m;
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        scanf("%lf%lf",&o.x,&o.y);
        for(int i=1;i<n;i++)
        {
            scanf("%lf%lf%lf%lf",&a[i].x,&a[i].y,&a[i].b,&a[i].p);
            for(int j=1;j<=m;j++)scanf("%d",&a[i].num[j]);
        }
        s=0,e=2*n-1;
        int ans=0;
        for(int k=1;k<=m;k++)
        {
            init();
            for(int i=1;i<n;i++)
            {
                add(s,i,INF,1);
                add(i,e,a[i].num[k],0);
                add(s,i+n-1,a[i].num[k],0);
                for(int j=1;j<n;j++)
                    if(i!=j&&a[i].b+a[i].p+dis(a[i],a[j])<=a[j].b)
                        add(i+n-1,j,a[i].num[k],0);
            }
            ans+=mcmf();
        }
        printf("%d\n",ans);
    }
    return 0;
}

Solution2

同样考虑完成所有工作所需第 $k$ 种工人的数量，如果去掉工人可以完成多项工作的条件，那么所需人数应为 $ans=\sum\limits_{i=1}^{n-1}num[i][k]$ ，当工人可以完成多项工作时，我们考虑求出完成某些工作的工人中有多少还可以做其他工作，拿 $ans$ 减掉这些重复工作的工人数量即为所需的最少人数，依旧把第 $i$ 个工作拆点为 $i,i+n-1$ ，建图如下：

1.源点向 $i$ 建容量为 $num[i][k]$ 的边，表示完成第 $i$ 项工作的工人人数

2. $i+n-1$ 向汇点连容量为 $num[i][k]$ 的边，表示完成该项工作的工人中之前做过工作的至多为 $num[i][k]$

3. $i$ 向 $j+n-1$ 连容量为 $num[i][k]$ ，费用为 $0$ 的边，如果 $i$ 工作的结束时间加上 $i$ 与 $j$ 的距离还要早于 $j$ 工作的开始时间，说明完成 $i$ 工作的工人可以继续完成 $j$ 工作

$ans$ 减去最大流即为完成所有工作所需第k种工人的数量，累加即为答案

Code2

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
#define maxn 333
#define maxm 66666
#define INF 0x3f3f3f3f
int head[maxn],cur[maxn],d[maxn],st[maxm],s,e,no;//s为源点,e为汇点,n为点数,no为边数 
struct point
{
    int u,v,flow,next;
    point(){};
    point(int x,int y,int z,int w):u(x),v(y),next(z),flow(w){};
}p[maxm];
void add(int x,int y,int z)//从x到y建容量为z的边 
{
    p[no]=point(x,y,head[x],z);//前向弧,标号为偶 
    head[x]=no++;
    p[no]=point(y,x,head[y],0);//后向弧,标号为奇 
    head[y]=no++;
}
void init()//初始化 
{
    memset(head,-1,sizeof(head));
    no=0;
}
bool bfs()
{
    int i,x,y;
    queue<int>q;
    memset(d,-1,sizeof(d));
    d[s]=0; 
    q.push(s);
    while(!q.empty())
    {
        x=q.front();    
        q.pop();
        for(i=head[x];i!=-1;i=p[i].next)
        {
            if(p[i].flow&& d[y=p[i].v]<0)
            {
                d[y]=d[x]+1;
                if(y==e)    
                    return true;
                q.push(y);
            }
        }
    }
    return false;
}
int dinic()//最大流 
{
    int i,loc,top,x=s,nowflow,maxflow=0;
    while(bfs())
    {
        memcpy(cur,head,sizeof(head));
        top=0;
        while(true)
        {
            if(x==e)
            {
                nowflow=INF;
                for(i=0;i<top;i++)
                {
                    if(nowflow>p[st[i]].flow)
                    {
                        nowflow=p[st[i]].flow;
                        loc=i;
                    }
                }
                for(i=0;i<top;i++)
                {
                    p[st[i]].flow-=nowflow;
                    p[st[i]^1].flow+=nowflow;
                }
                maxflow+=nowflow;
                top=loc;    
                x=p[st[top]].u;
            }
            for(i=cur[x];i!=-1;i=p[i].next)
                if(p[i].flow&&d[p[i].v]==d[x]+1) 
                    break;
            cur[x]=i;
            if(i!=-1)
            {
                st[top++]=i;
                x=p[i].v;
            }
            else 
            {
                if(!top)    
                    break;
                d[x]=-1;
                x=p[st[--top]].u;
            }
        }
    }
    return maxflow;
}
struct node
{
    double x,y,b,p;
    int num[6];
}a[maxn],o;
double dis(node a,node b)
{
    double x=a.x-b.x,y=a.y-b.y;
    return sqrt(x*x+y*y);
}
int T,n,m;
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        scanf("%lf%lf",&o.x,&o.y);
        int ans=0;
        for(int i=1;i<n;i++)
        {
            scanf("%lf%lf%lf%lf",&a[i].x,&a[i].y,&a[i].b,&a[i].p);
            for(int j=1;j<=m;j++)scanf("%d",&a[i].num[j]),ans+=a[i].num[j];
        }
        s=0,e=2*n-1;
        for(int k=1;k<=m;k++)
        {
            init();
            for(int i=1;i<n;i++)
            {
                add(s,i,a[i].num[k]);
                add(i+n-1,e,a[i].num[k]);
                for(int j=1;j<n;j++)
                    if(i!=j&&a[i].b+a[i].p+dis(a[i],a[j])<=a[j].b)
                        add(i,j+n-1,a[i].num[k]);
            }
            ans-=dinic();
        }
        printf("%d\n",ans);
    }
    return 0;
}