BZOJ1070 修车(zkw费用流 or spfa费用流)

1070: [SCOI2007]修车

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 4900  Solved: 2009
[Submit][Status][Discuss]
Description

　　同一时刻有N位车主带着他们的爱车来到了汽车维修中心。维修中心共有M位技术人员，不同的技术人员对不同
的车进行维修所用的时间是不同的。现在需要安排这M位技术人员所维修的车及顺序，使得顾客平均等待的时间最
小。 说明：顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。

Input

　　第一行有两个m,n，表示技术人员数与顾客数。 接下来n行，每行m个整数。第i+1行第j个数表示第j位技术人
员维修第i辆车需要用的时间T。

Output

　　最小平均等待时间，答案精确到小数点后2位。

Sample Input

2 2

3 2

1 4
Sample Output

1.50
HINT

数据范围: (2<=M<=9,1<=N<=60), (1<=T<=1000)

补上，这道题建图确实比较难想，具体怎么做呢，如下：
由于这里的数据不大，可以暴力拆点。
这道题的m个工人对应n辆车，这里求的是顾客的等待时间，那么如果一个人修k(k>1)辆车，
那么此刻修车的时间必定会影响接下来k-1个顾客的等待时间，那么怎么建边呢，由于一个
工人现在正在修的车对已经修过的车的等待时间没有影响，只对后面还没修过的车有影响，
所以我们可以把现在该工人正在修的车设置成该工人倒数第几个修的车，那么该边的费用就
是k*ct[i][j](后面有k-1个人在等待还有此刻正在修的车的顾客的等待时间)，那么就要n*m
条V(i,j)，设置一个超级源结点，与n*m个点相连接，边的容量为1,费用为0。由于每辆车只能
由一个工人修理，所以需要设置n个点与之(n*m个v(i,j))相连接，容量为1,费用为
k*ct[i][j].最后设置一个超级汇点，与n个点(车)相连接，容量为1,费用为0即可。
跑一边zkw费用流或者spfa费用流即可。

zkw费用流:

spfa费用流

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cctype>
#include<cmath>
#include<ctime>
#include<string>
#include<stack>
#include<deque>
#include<queue>
#include<list>
#include<set>
#include<map>
#include<cstdio>
#include<limits.h>
#define MOD 1000000007
#define fir first
#define sec second
#define fin freopen("/home/ostreambaba/文档/input.txt", "r", stdin)
#define fout freopen("/home/ostreambaba/文档/output.txt", "w", stdout)
#define mes(x, m) memset(x, m, sizeof(x))
#define Pii pair<int, int>
#define Pll pair<ll, ll>
#define INF 1e9+7
#define inf 0x3f3f3f3f

#define Pi 4.0*atan(1.0)
#define Sqrt(x) (x)*(x)

#define lowbit(x) (x&(-x))
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

typedef long long ll;
typedef unsigned long long ull;
const double eps = 1e-12;
const int maxn = 3000;
const int maxm = 1500;
using namespace std;
inline int read(){
    int x(0),f(1);
    char ch=getchar();
    while (ch<'0'||ch>'9') {if (ch=='-') f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x*f;
}
struct edge{
    int from,to,cap,rev,cost,next;
};
bool vis[maxm];
int pre[maxm];
int head[maxm];
int tot;
int dis[maxm];
int N,M;
int ct[maxm][maxm];
void init()
{
    tot=0;
    mes(head,-1);
}
edge g[maxn];
void addEdge(int u,int v,int w,int c)
{
    edge &t1=g[tot];
    t1={u,v,w,0,c,head[u]};
    head[u]=tot++;
    edge &t2=g[tot];
    t2={v,u,0,0,-c,head[v]};
    head[v]=tot++;
}
inline int spfa(int s,int t)
{
    queue<int> q;
    for(int i=s;i<=t;++i){
        dis[i]=inf;
        vis[i]=false;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=true;
    q.push(s);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u];~i;i=g[i].next){
            edge &e=g[i];
            if(dis[e.to]>dis[u]+e.cost&&e.cap>e.rev){
                dis[e.to]=dis[u]+e.cost;
                pre[e.to]=i;
                if(!vis[e.to]){
                    vis[e.to]=true;
                    q.push(e.to);
                }
            }
        }
    }
    return pre[t]!=-1;
}
void mcmf(int s,int t,int &flow,int &cost)
{
    flow=0,cost=0;
    while(spfa(s,t)){
        for(int i=pre[t];~i;i=pre[g[i^1].to]){
            g[i].rev+=1;
            g[i^1].rev-=1;
            cost+=g[i].cost;
        }
        flow+=1;
    }
}
inline int getIndex(int x,int y){
    return (x-1)*N+y;
}
int main()
{
   // fin;
    while(~scanf("%d%d",&M,&N)){
        init();
        int st,ed;
        int cost,flow;
        for(int i=1;i<=N;++i){
            for(int j=1;j<=M;++j){
                ct[i][j]=read();
            }
        }
        st=0,ed=N*M+N+1;
        for(int i=1;i<=N*M;++i){
            addEdge(st,i,1,0);
        }
        for(int i=1;i<=N;++i){
            for(int j=1;j<=M;++j){
                for(int k=1;k<=N;++k){
                    addEdge(getIndex(j,k),N*M+i,1,k*ct[i][j]);
                }
            }
        }
        for(int i=1;i<=N;++i){
            addEdge(N*M+i,ed,1,0);
        }
        mcmf(st,ed,flow,cost);
        double re=cost*1.0/N;
        printf("%.2f\n",re);
    }
    return 0;
}