Bzoj1070 [SCOI2007]修车

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 5325  Solved: 2217

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)

Source

网络流 费用流

……这题怎么这么像网络流？（悄悄百度）真是网络流啊………

把每个工人拆成n个点，这n个点分别向T连边，容量为1（同一时刻只能修一辆车），第i个点费用为i*(读入的花费）。

　　↑第i个点表示工人倒数第i个修这辆车，对总时间的贡献为等待的人数i*花费时间

跑费用流即可

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int mxn=1010;
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 u,v,nxt,f,w;
}e[mxn*100];
int hd[mxn],mct=1;
void add_edge(int u,int v,int f,int w){
    e[++mct].v=v;
    e[mct].u=u;
    e[mct].nxt=hd[u];
    e[mct].f=f;e[mct].w=w;
    hd[u]=mct;return;
}
void insert(int u,int v,int f,int w){
    add_edge(u,v,f,w); add_edge(v,u,0,-w);return;
}
int S,T;
int dis[mxn],pre[mxn];
int n,m;
queue<int>q;
bool inq[mxn];
void SPFA(int s){
    memset(dis,0x3f,sizeof dis);
    memset(pre,-1,sizeof pre);
    dis[s]=0;q.push(s);inq[s]=1;
    while(!q.empty()){
        int u=q.front();q.pop();inq[u]=0;
        for(int i=hd[u];i;i=e[i].nxt){
            int v=e[i].v;
            if(e[i].f && dis[v]>dis[u]+e[i].w){
                dis[v]=dis[u]+e[i].w;
                pre[v]=i;
                if(!inq[v]){
                    inq[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return;
}
int mxflow(int s,int t){
    SPFA(s);
    int res=0;
    while(pre[t]!=-1){
        int tmp=0x3f3f3f3f;
        for(int i=pre[t];i!=-1;i=pre[e[i].u]){
            tmp=min(tmp,e[i].f);
        }
        res+=dis[t]*tmp;
        for(int i=pre[t];i!=-1;i=pre[e[i].u]){
            e[i].f-=tmp;
            e[i^1].f+=tmp;
        }
        SPFA(s);
    }
    return res;
}
int main(){
    int i,j,w;
    m=read();n=read();
    S=0;T=n+m*n+1;
    for(i=1;i<=n;i++){
        insert(S,i,1,0);
    }
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            w=read();
            for(int k=1;k<=n;k++){
                insert(i,j+n+m*(k-1),1,w*k);
            }
        }
    }
    for(i=1;i<=m;i++)
        for(j=1;j<=n;j++)
            insert(i+n+m*(j-1),T,1,0);
    int ans=mxflow(S,T);
//    printf("!! %d
",ans);
    printf("%.2f
",(double)ans/n);
    return 0;
}

上面那个跑了1000+ms，一看排行榜震惊了，怎么前面全是几十ms跑完的

在黄学长博客看到了神奇的zkw费用流，（看上去像是Dinic和SPFA的结合体），学习一下↓

这样写快了一半。

然而还是不知道几十ms怎么做到的啊

/*by SilverN*/
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<vector>
#include<queue>
using namespace std;
const int mxn=1010;
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 u,v,nxt,f,w;
}e[mxn*100];
int hd[mxn],mct=1;
void add_edge(int u,int v,int f,int w){
    e[++mct].v=v;
    e[mct].u=u;
    e[mct].nxt=hd[u];
    e[mct].f=f;e[mct].w=w;
    hd[u]=mct;return;
}
void insert(int u,int v,int f,int w){
    add_edge(u,v,f,w); add_edge(v,u,0,-w);return;
}
int S,T;
int dis[mxn],pre[mxn];
int n,m;
queue<int>q;
bool inq[mxn];
bool mark[mxn];
bool SPFA(int s){
    memset(inq,0,sizeof inq);
    for(int i=0;i<=T;i++)dis[i]=0x3f3f3f3f;
    dis[T]=0;q.push(T);inq[T]=1;
    while(!q.empty()){
        int u=q.front();q.pop();inq[u]=0;
        for(int i=hd[u];i;i=e[i].nxt){
            int v=e[i].v;
            if(e[i^1].f && dis[v]>dis[u]-e[i].w){
                dis[v]=dis[u]-e[i].w;
//                pre[v]=i;
                if(!inq[v]){
                    inq[v]=1;
                    q.push(v);
                }
            }
        }
    }
    if(dis[S]==0x3f3f3f3f)return 0;
    return 1;
}
int ans=0;
int DFS(int x,int f){
    if(x==T){inq[T]=1;return f;}
    int used=0,w;
    inq[x]=1;
    for(int i=hd[x];i;i=e[i].nxt){
        int v=e[i].v;
        if(!inq[v] && e[i].f && dis[x]-e[i].w==dis[v]){
            w=f-used;
            w=DFS(v,min(e[i].f,w));
            ans+=w*e[i].w;
            e[i].f-=w;    e[i^1].f+=w;
            used+=w;
            if(used==f)return f;
        }
    }
    return used;
}

void mxflow(int s,int t){
    while(SPFA(s)){
        inq[T]=1;
        while(inq[T]){
            memset(inq,0,sizeof inq);
            DFS(S,0x3f3f3f3f);
        }
    }
    return;
}
int main(){
    int i,j,w;
    m=read();n=read();
    S=0;T=n+m*n+1;
    for(i=1;i<=n;i++){
        insert(S,i,1,0);
    }
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            w=read();
            for(int k=1;k<=n;k++){
                insert(i,j+n+m*(k-1),1,w*k);
            }
        }
    }
    for(i=1;i<=m;i++)
        for(j=1;j<=n;j++)
            insert(i+n+m*(j-1),T,1,0);
    mxflow(S,T);
    printf("%.2f
",(double)ans/n);
    return 0;
}