HDU 5045 费用流求最大权

点击打开链接

题意：有n个人和m到题目，每个人做对的概率以矩阵形式给出，问如何分配才可以使做对的概率最大，有一个限制条件是做到目前为止每两个人的做题数量差距不能超过1，也就是前n道题目，必须一人做一个

思路：网上都是dp多一点，用网络流也可以，不过麻烦很多，可是本弱是一点dp都不会的选手啊，只能用网络流了，对于那个限制条件，我们可以以前n道题建一次图，然后再来n个，不过就直接建完就可以了，然后我们要求的是什么呢，很明显是最大权，而最大费用最大流刚好可以解决，这里面的费用流有两种方法，用spfa找最短路或者用dijkstra找最短路，用spfa会方便很多，因为它可以处理带负的权值边，dijkstra不可以，这道题就是要讲权值变负，求最小费用最大流，然后将结果取负就可以了，本弱喜欢用dijkstra，处理的很麻烦，有兴趣的可以看看，建议用spfa

#include <queue>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
const double inf=1000.0;
const int maxn=1050;
typedef pair<double,int> P;
struct edge{
    int to,cap,rev;
    double cost;
    edge();
    edge(int a,int b,double c,int d){to=a,cap=b,cost=c,rev=d;};
};
vector<edge>G[maxn];
double h[maxn],dis[maxn];
int prevv[maxn],preve[maxn];
void addedge(int st,int en,int cap,double cost){
    G[st].push_back(edge(en,cap,cost,G[en].size()));
    G[en].push_back(edge(st,0,-cost,G[st].size()-1));
}
double min_cost_flow(int st,int en,int f){
    double ans=0;
    memset(h,0,sizeof(h));
    while(f>0){
        priority_queue<P,vector<P>,greater<P> >que;
        for(int i=0;i<maxn;i++) dis[i]=inf;
        dis[st]=0;que.push(P(0,st));
        while(!que.empty()){
            P p=que.top();que.pop();
            int v=p.second;
            if(dis[v]<p.first) continue;
            for(unsigned int i=0;i<G[v].size();i++){
                edge &e=G[v][i];
                if(e.cap>0&&dis[e.to]>dis[v]+e.cost+h[v]-h[e.to]){
                    dis[e.to]=dis[v]+e.cost+h[v]-h[e.to];
                    prevv[e.to]=v;
                    preve[e.to]=i;
                    que.push(P(dis[e.to],e.to));
                }
            }
        }
        if(dis[en]==inf) return -1;
        for(int i=0;i<maxn;i++) h[i]+=dis[i];
        int d=f;
        for(int i=en;i!=st;i=prevv[i]){
            d=min(d,G[prevv[i]][preve[i]].cap);
        }
        f-=d;
        ans+=d*h[en];
        for(int i=en;i!=st;i=prevv[i]){
            edge &e=G[prevv[i]][preve[i]];
            e.cap-=d;
            G[i][e.rev].cap+=d;
        }
    }
    return ans;
}
double A[15][1010];
int main(){
    int T,n,m,T1=1;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++) scanf("%lf",&A[i][j]);
        }
        double ans=0,max1=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(A[i][j]>max1) max1=A[i][j];
                A[i][j]*=-1;
            }
        }
        max1+=1;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++) A[i][j]+=max1;
        int t=1;
        while(t<=m){
            for(int i=0;i<maxn;i++) G[i].clear();
            int kk=1,tt=t,ttt=t;
            for(;tt<=m&&kk<=n;tt++,kk++) addedge(tt+n,n+m+1,1,0);
            for(int i=1;i<=n;i++) addedge(0,i,1,0);
            for(int i=1;i<=n;i++){
                int k=1;
                for(int j=t;j<=m&&k<=n;j++,k++){
                    addedge(i,n+j,1,A[i][j]);
                }
            }
            t+=n;
            int ff;
            if(t<=m) ff=n;
            else ff=m-ttt+1;
            ans+=min_cost_flow(0,n+m+1,ff);
        }
        max1=max1*m;
        double ans1=(ans-max1)*(-1);
        printf("Case #%d: %.5lf\n",T1++,ans1);
    }
    return 0;
}