poj 3308 Paratroopers(网络流 最小割 dinic模板)

题意：火星人要和地球人PK，地球人间谍搞到了一份情报：火星人要搞伞兵，登陆在地球一个row*col的地图上，而且知道伞兵的数量和每个伞兵要降落的格子。为了消灭敌人，可以在某一行或者某一列安置激光枪。每个激光枪可以瞬间消灭这一行（或者列）的敌人。

安装消灭第i行的激光枪消费是ri。

安装消灭第j行的激光枪消费是ci。

现在总部要你花费最小的费用，安装好足够的激光枪去消灭所有的火星人，问最小的花费是多少。

这里花费的定义有点不同：是每个激光器消费的乘积。

思路：最小割_最大流，EK超时，用dinic模板做，不是一般的快。把伞兵看成边，行列看成节点，转化为了带权二分图最小点覆盖。加入超级源点和超级汇点，源点和所有行节点相连(权值ri)，所有列节点和汇点相连(权值ci)，如果a行b列有敌人，则把节点a和节点b相连。则问题又可以转化求最小割。

因为对任一敌人<a,b>，必然有source-->a-->b-->sink，故路径上的三条边<source,a>,<a,b>, <b,sink>中至少有一条边在割中,我们把<a,b>的权值设置为无限大，则其不可能被选中。于是割边集中必然有<source,a>和<b,sink>中的至少一条，也即对应选择了相应的行或列，我们把这些边的权值设置为花费，则最小割即是总花费的最小方案。

 

最小割：对于图中的两个点(一般为源点和汇点)来说，如果把图中的一些边去掉，如果它们之间无法连通的话，则这些边组成的集合就叫为割了。如果这些边有权值，最小割就是指权值之和最小的一个割。

最大流最小割：应用于网络中，指总流量不超过链路可承载的最大值，且在每条子路径上取尽可能少的流量。对任意一个只有一个源点一个汇点的图来说，从源点到汇点的最大流等于最小割。

参考资料：http://www.cnblogs.com/zsboy/archive/2013/01/27/2878810.html

                  https://comzyh.com/blog/archives/568/

                  http://blog.sina.com.cn/s/blog_6635898a0100ps4m.html

                  http://blog.sina.com.cn/s/blog_68629c7701010r91.html 

代码1：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=150;//点数的最大值
const int MAXM=20500;//边数的最大值

struct Node
{
    int from,to,next;
    double cap;
} edge[MAXM];
int tol;

int dep[MAXN];//dep为点的层次
int head[MAXN];

int n;
void init()
{
    tol=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,double w)//第一条变下标必须为偶数
{
    edge[tol].from=u;
    edge[tol].to=v;
    edge[tol].cap=w;
    edge[tol].next=head[u];
    head[u]=tol++;
    edge[tol].from=v;
    edge[tol].to=u;
    edge[tol].cap=0;
    edge[tol].next=head[v];
    head[v]=tol++;
}

int BFS(int start,int end)
{
    int que[MAXN];
    int front,rear;
    front=rear=0;
    memset(dep,-1,sizeof(dep));
    que[rear++]=start;
    dep[start]=0;
    while(front!=rear)
    {
        int u=que[front++];
        if(front==MAXN)front=0;
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>0&&dep[v]==-1)
            {
                dep[v]=dep[u]+1;
                que[rear++]=v;
                if(rear>=MAXN)rear=0;
                if(v==end)return 1;
            }
        }
    }
    return 0;
}
double dinic(int start,int end)
{
    double res=0;
    int top;
    int stack[MAXN];//stack为栈，存储当前增广路
    int cur[MAXN];//存储当前点的后继
    while(BFS(start,end))
    {
        memcpy(cur,head,sizeof(head));
        int u=start;
        top=0;
        while(1)
        {
            if(u==end)
            {
                double min=INF;
                int loc;
                for(int i=0; i<top; i++)
                    if(min>edge[stack[i]].cap)
                    {
                        min=edge[stack[i]].cap;
                        loc=i;
                    }
                for(int i=0; i<top; i++)
                {
                    edge[stack[i]].cap-=min;
                    edge[stack[i]^1].cap+=min;
                }
                res+=min;
                top=loc;
                u=edge[stack[top]].from;
            }
            for(int i=cur[u]; i!=-1; cur[u]=i=edge[i].next)
                if(edge[i].cap!=0&&dep[u]+1==dep[edge[i].to])
                    break;
            if(cur[u]!=-1)
            {
                stack[top++]=cur[u];
                u=edge[cur[u]].to;
            }
            else
            {
                if(top==0)break;
                dep[u]=-1;
                u=edge[stack[--top]].from;
            }
        }
    }
    return res;
}

int main()//多源多汇点，在前面加个源点，后面加个汇点，转成单源单汇点
{
    int start,end,t;
    int row,col,par;
    double val;
    int i,j;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&row,&col,&par);
        n=row+col+1;
        init();
        for(i = 1; i <= row; i ++)
        {
            scanf("%lf", &val);
            addedge(0, i, log(val));
        }
        for(i = 1; i <= col; i ++)
        {
            scanf("%lf", &val);
            addedge(row + i, n, log(val));
        }
        while(par --)
        {
            scanf("%d%d", &i, &j);
            addedge(i, row + j, INF);
        }

        double ans=dinic(0,n);
        printf("%.4f\n",exp(ans));
    }
    return 0;
}

代码2：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<cmath>
using namespace std;
const int nMax = 105;
const int eMax = 1450;
const double inf = 999999;

struct{
    int u, v, next;
    double c;
}bf[2*eMax];
int ne, head[nMax];
int cur[nMax], ps[nMax], dep[nMax];

void addEdge(int u, int v, double c){    // dinic的加边，还是有点不同的。
    bf[ne].u = u;
    bf[ne].v = v;
    bf[ne].c = c;
    bf[ne].next = head[u];
    head[u] = ne ++;
    bf[ne].u = v;
    bf[ne].v = u;
    bf[ne].c = 0;
    bf[ne].next = head[v];
    head[v] = ne ++;
}

double dinic(int s, int t){     // dinic模板：源点为s，汇点为t(这里可以不用知道n的大小)。
    double tr, res = 0;
    int i, j, k, f, r, top;
    while(1){
        memset(dep, -1, sizeof(dep));
        for(f = dep[ps[0]=s] = 0, r = 1; f != r;)
            for(i = ps[f ++], j = head[i]; j; j = bf[j].next)
                if(bf[j].c && dep[k=bf[j].v] == -1){
                    dep[k] = dep[i] + 1;
                    ps[r ++] = k;
                    if(k == t){
                        f = r; break;
                    }
                }
        if(dep[t] == -1) break;
        memcpy(cur, head, sizeof(cur));
        i = s, top = 0;
        while(1){
            if(i == t){
                for(tr = inf, k = 0; k < top; k ++)
                    if(bf[ps[k]].c < tr)
                        tr = bf[ps[f=k]].c;
                for(k = 0; k < top; k ++){
                    bf[ps[k]].c -= tr;
                    bf[ps[k]^1].c += tr;
                }
                i = bf[ps[top=f]].u;
                res += tr;          // 当前的最大流，每次累积上去。
            }
            for(j = cur[i]; cur[i]; j = cur[i] = bf[cur[i]].next)
                if(bf[j].c && dep[i]+1 == dep[bf[j].v]) break;
            if(cur[i]){
                ps[top ++] = cur[i];
                i = bf[cur[i]].v;   // i=bf[cur[i]].v 绝不能写为 bf[cur[i]].v=i，脑残了一次。
            }else{
                if(top == 0) break;
                dep[i] = -1;
                i = bf[ps[-- top]].u;
            }
        }
    }
    return res;
}

int main(){
    int t, row, col, par, n, i, j;
    double val;
    scanf("%d", &t);
    while(t --){
        ne = 2;
        memset(head, 0, sizeof(head));
        scanf("%d%d%d", &row, &col, &par);
        n = row + col + 1;
        for(i = 1; i <= row; i ++){
            scanf("%lf", &val);
            addEdge(0, i, log(val));
        }
        for(i = 1; i <= col; i ++){
            scanf("%lf", &val);
            addEdge(row + i, n, log(val));
        }
        while(par --){
            scanf("%d%d", &i, &j);
            addEdge(i, row + j, inf);
        }
        double ans = dinic(0, n);
        printf("%.4f\n", exp(ans));
    }
    return 0;
}