HDU_5045_Contest(状态压缩or最小费用最大流)

题型：动态规划OR网络流

题意：

n个队员做m道题，第i个小时做第i个题目。Pij表示第i个队员能做出第j个题目的概率。

在任意时刻，任意两个队员的编程时间之差不允许超过1个小时。

问能做出最多题目的期望。

分析：

题目，最多10个人做1000道题。

根据题目的限制条件，可以发现，可行方案的队员序列必须是每n个题目由n个不同的队员做，即队员的全排列。

例如3个人做5道题，12312就是合法的，122321是不合法的。

这样就可以讲问题缩小了，只需要对每n个题目进行求解最优解，如果暴力枚举全排列，复杂度10！。

方法一：

采用状态压缩，复杂度2^10，妥妥的A了。

对于m%n != 0，需要对剩余的部分处理一下。我懒得处理了，于是直接后面用0补全，变成整整的n/m+1部分，简单粗暴效果好。

方法二：

采用费用流。

由于每n个题由n个不同的人做，所以很容易看出是二分图最大权匹配问题。可以采用KM算法，我用的是费用流，源点到队员流量为1，费用为0；队员到各个题目的流量为1，费用为对应概率取负；题目到汇点流量为1，费用为0.

跑n/m+1边费用流。

注意数组开的稍微大一点，我数组开的感觉差不多，却多次TLE和RE，不知为毛。开大一点就A了。

代码：

状态压缩：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>

#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;

int n,m;
double p[16][1024];

double dp[1<<10];

void init(){
    for(int i=0;i<10;i++){
        for(int j=0;j<1024;j++){
            p[i][j] = 0.00;
        }
    }
}

int ONE(int x){
    int num = 0;
    while(x){
        if(x&1) num ++;
        x >>= 1;
    }
    return num;
}

int main(){
    int _;
    int Cas = 0;
    scanf("%d",&_);
    while(_--){
        scanf("%d%d",&n,&m);
        init();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                scanf("%lf",&p[i][j]);
            }
        }
        printf("Case #%d: ",++Cas);

        int part = m/n;
        if(m%n!=0){
            part++;
        }

//        printf("part = %d\n",part);

        double ans = 0.0;
        int all = (1<<n);

        for(int op=0;op<part;op++){
//                cout<<"*****************"<<endl;
            int s = op * n;//每一部分第一个位置
            mt(dp,0);
            for(int i=0;i<all;i++){
                int yi = ONE(i);
                if(yi>=n) continue;
                for(int j=0;j<n;j++){
                    if((i>>j)&1) continue;
                    //如果这一位是0
                    int next = i|(1<<j);
                    dp[next] = max(dp[next],dp[i]+p[j][yi+s]);
                }
            }
            ans += dp[all-1];
        }

        printf("%.5f\n",ans);

    }
    return 0;
}

费用流：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<stack>

#define inf 0x3f3f3f3f
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;

int n,m;
double p[16][1024];

class MaxFlowMinCost { ///最小费用最大流 o(ME)
    typedef int typef;///流量的类型
    typedef double typec;///费用的类型
    static const int ME=1010;///边的个数
    static const int MV=100;///点的个数
    queue<int> q;
    int cur[MV],pre[MV];
    bool used[MV],sign[MV];
    typef flow;
    typec cost,dist[MV];
    bool spfa(int s,int t) {
        mt(used,0);
        mt(sign,0);
        mt(dist,0);
        used[s]=sign[s]=true;
        while(!q.empty()) q.pop();
        q.push(s);
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            used[u]=false;
            for(int i=g.head[u]; ~i; i=g.e[i].next) {
                if(g.e[i].flow<1) continue;
                int v=g.e[i].v;
                typec c=g.e[i].cost;
                if(!sign[v]||dist[v]>dist[u]+c) {
                    dist[v]=dist[u]+c;
                    sign[v]=true;
                    pre[v]=u;
                    cur[v]=i;
                    if(used[v]) continue;
                    used[v]=true;
                    q.push(v);
                }
            }
        }
        return sign[t];
    }
    struct G {
        struct E {
            int v,next;
            typef flow;
            typec cost;
        } e[ME];
        int le,head[MV];
        void init() {
            le=0;
            mt(head,-1);
        }
        void add(int u,int v,typef flow,typec cost) {
            e[le].v=v;
            e[le].flow=flow;
            e[le].cost=cost;
            e[le].next=head[u];
            head[u]=le++;
        }
    } g;
public:
    void init() {
        g.init();
    }
    void add(int u,int v,typef flow,typec cost) {
        g.add(u,v,flow,cost);
        g.add(v,u,0,-cost);
    }
    void solve(int s,int t) {
        flow=cost=0;
        while(spfa(s,t)) {
            int temp=t;
            typef now=inf;
            while(temp!=s) {
                now=min(now,g.e[cur[temp]].flow);
                temp=pre[temp];
            }
            flow+=now;
            temp=t;
            while(temp!=s) {
                int id=cur[temp];
                cost+=now*g.e[id].cost;
                g.e[id].flow-=now;
                g.e[id^1].flow+=now;
                temp=pre[temp];
            }
        }
    }
    typef getflow() {
        return flow;
    }
    typec getcost() {
        return cost;
    }
} gx;

int main() {
    int _;
    int Cas = 0;
    scanf("%d",&_);
    while(_--) {
        scanf("%d%d",&n,&m);
        mt(p,0);

//        for(int i=0;i<n;i++){
//            for(int j=0;j<m+10;j++){
//                p[i][j] = 0.0;
//            }
//        }

        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                scanf("%lf",&p[i][j]);
            }
        }

//        cout<<"*************"<<endl;
//        for(int i=0; i<n; i++) {
//            for(int j=0; j<m; j++) {
//                printf("%.2f ",p[i][j]);
//            }
//            puts("");
//        }
//        cout<<"*************"<<endl;

        printf("Case #%d: ",++Cas);

        int part = m/n;
        if(m%n!=0) part++;

        double ans = 0.0;

        for(int op=0; op<part; op++) {
            gx.init();
            int S = 2*n+1;
            int T = 2*n+2;
            int st = op * n;
            for(int i=0; i<n; i++) {
                for(int j=0; j<n; j++) {
                    gx.add(i,j+n,1,-p[i][j+st]);
                }
            }
            for(int i=0; i<n; i++) {
                gx.add(S,i,1,0);
            }
            for(int i=0; i<n; i++) {
                gx.add(i+n,T,1,0);
            }
            gx.solve(S,T);
            ans -= gx.getcost();
        }

        printf("%.5f\n",ans);

    }
    return 0;
}