POJ3686：The Windy's——题解

http://poj.org/problem?id=3686

题目大意：

有n个订单m个厂子，第i个订单在第j个厂子所需时间为zij，一个厂子做一个订单时不能做其他的订单。

求订单平均时间最小值。

————————————

这题最开始样例都没推出来让我很绝望，这里解释一下样例。

第一个样例可以1订单做1时间，2订单做2时间（自己1时间+1订单的时间），3订单做3时间，总共6时间/3=2.

接下来考虑建图。

类似二分图+费用流的想法，边的容量为1，费用为时间。

于是这题的关键在于如何让厂子处理多个订单——明显是拆点，怎么拆是关键。

举个例子，假设这个厂子要处理abc三个订单，那么花费总时间就是：

ta+ta+tb+ta+tb+tc=3ta+2tb+1tc。

四个订单就是4ta+3tb+2tc+1td……

我们成功把时间长短变成了订单接的先后顺序。

于是变成：

将厂子拆点成二元组（i，j），其中i为厂子，j为该厂子已经接了（j-1）个订单。

对于k的订单在i厂子花t时间就可以变成：

k连（i，j），容量为1，费用为t*j。

接下来就是板子的活了。

（poj开%f，开%lf会WA……）

#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
#include<algorithm>
#include<cctype>
using namespace std;
typedef long long ll;
const int INF=1e9;
const int N=;
const int M=;
const int P=N+M*N+;
inline int read(){
    int X=,w=;char ch=;
    while(!isdigit(ch)){w|=ch=='-';ch=getchar();}
    while(isdigit(ch))X=(X<<)+(X<<)+(ch^),ch=getchar();
    return w?-X:X;
}
struct node{
    int nxt;
    int to;
    int w;
    int b;
}edge[(N+N*N*M+N*M)*];
int head[P],cnt=-;
void add(int u,int v,int w,int b){
    cnt++;
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].b=b;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
    return;
}
int dis[P];
bool vis[P];
inline bool spfa(int s,int t,int n){
    deque<int>q;
    memset(vis,,sizeof(vis));
    for(int i=;i<=n;i++)dis[i]=INF;
    dis[t]=;q.push_back(t);vis[t]=;
    while(!q.empty()){
    int u=q.front();
    q.pop_front();vis[u]=;
    for(int i=head[u];i!=-;i=edge[i].nxt){
        int v=edge[i].to;
        int b=edge[i].b;
        if(edge[i^].w&&dis[v]>dis[u]-b){
        dis[v]=dis[u]-b;
        if(!vis[v]){
            vis[v]=;
            if(!q.empty()&&dis[v]<dis[q.front()]){
            q.push_front(v);
            }else{
            q.push_back(v);
            }
        }
        }
    }
    }
    return dis[s]<INF;
}
int ans=;
int dfs(int u,int flow,int m){
    if(u==m){
    vis[m]=;
    return flow;
    }
    int res=,delta;
    vis[u]=;
    for(int e=head[u];e!=-;e=edge[e].nxt){
        int v=edge[e].to;
    int b=edge[e].b;
        if(!vis[v]&&edge[e].w&&dis[u]-b==dis[v]){
            delta=dfs(v,min(edge[e].w,flow-res),m);
            if(delta){
                edge[e].w-=delta;
                edge[e^].w+=delta;
                res+=delta;
        ans+=delta*b;
                if(res==flow)break;
            }
        }
    }
    return res;
}
inline int costflow(int S,int T,int n){
    while(spfa(S,T,n)){
    do{
        memset(vis,,sizeof(vis));
        dfs(S,INF,T);
    }while(vis[T]);
    }
    return ans;
}
void restart(){
    memset(head,-,sizeof(head));
    cnt=-;
    ans=;
    return;
}
int main(){
    int t=read();
    while(t--){
    restart();
    int n=read();
    int m=read();
    int S=n+m*n+,T=n+m*n+;
    for(int i=;i<=n;i++){
        add(S,i,,);
        add(i,S,,);
        for(int j=;j<=m;j++){
        int z=read();
        for(int k=;k<=n;k++){
            int p=j*n+k;
            add(i,p,,z*k);
            add(p,i,,-z*k);
        }
        }
    }
    for(int i=n+;i<=n+n*m;i++){
        add(i,T,,);
        add(T,i,,);
    }
    printf("%.6f\n",costflow(S,T,n+m*n+)*1.0/n);
    }
    return ;
}