POJ 3308--Paratroopers

题意：给定一m*n矩阵，火星伞兵可能降落到矩阵中的l个点，地球人有一种武器可以摧毁一行或一列的伞兵，每行每列的武器花费各有不同，问各次武器发射花费乘积最小的花费是多少？

题解：类似于POJ 3041最小顶点覆盖，此题更为复杂，因为每行每列有加权分量，权值不是1，且最优值为权值之积。

1. 最小权值之积可以通过取对数化为权值之和，构造超级源点以及超级汇点，从源点到行的每点的容量为行的花费，从行点到列点（若有伞兵存在）的花费为INF，从列点到超级汇点的容量为列的花费，其它容量为0。
2. 由1构造的网络流的最大流就是最优值的对数值。

• 证明：根据最大流最小切割定理知最大流是流网络的最小割的容量。一个切割是图的点集（S，V-S）的一个划分，切割的容量就是所有从S中的点流向V-S中的点的容量之和。易知由1的构图，行和列中的点容量无穷大，不可能为切割的两边，所以切割只能划分源点到行点以及列点到汇点，所以使割容量最小也即使总花费最小。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
#define maxN 105
#define INF 1e8

class solve
{
private:
    int N,M,L;
    int dest;
    double maxFlow;
    double capacity[maxN][maxN];
    int height[maxN];
public:
    solve(int m,int n,int l):N(n),M(m),L(l)
    {
        maxFlow = 0;
        memset(capacity,0,sizeof(capacity));
        dest = N+M+1;
        processIn();
        Dinic();
        printf("%.4lf\n",exp(maxFlow));
    }
    void processIn();
    void Dinic();
    bool BFS();
    double DFS(int u,double minCapacity);
};

double solve::DFS(int u,double minCapacity)
{
    if(u == dest)
    {
        return minCapacity;
    }
    double totalFlow = 0;
    double tmpCapacity;
    for(int v = 1;v <= dest;v++)
    {
        if(height[v] == height[u]+1&&capacity[u][v] > 0)
        {
            if(minCapacity > totalFlow)     //从u前面流入的流量还能继续往下流
            {
                tmpCapacity = DFS(v,min(minCapacity-totalFlow,capacity[u][v]));
                if(tmpCapacity)
                {
                    totalFlow += tmpCapacity;
                    capacity[u][v] -= tmpCapacity;
                    capacity[v][u] += tmpCapacity;
                }
                else
                {
                    height[v] = 0;      //v往下已无流量则封闭v点
                }
            }
            else
            {
                return totalFlow;
            }
        }
    }
    return totalFlow;
}

bool solve::BFS()
{
    int now,next;
    queue<int> q;
    memset(height,0,sizeof(height));
    q.push(0);
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        for(next = 1;next <= dest;next++)
        {
            if(!height[next]&&capacity[now][next] > 0)
            {
                height[next] = height[now]+1;
                q.push(next);
            }
        }
    }
    if(!height[dest])
        return 0;
    return 1;
}

void solve::Dinic()
{
    while(BFS())
    {
        maxFlow += DFS(0,INF);
    }
}

void solve::processIn()
{
    int i,j;
    for(i = 1;i <= M;i++)
    {
        scanf("%lf",&capacity[0][i]);
        capacity[0][i] = log(capacity[0][i]);
    }
    for(i = 1;i <= N;i++)
    {
        scanf("%lf",&capacity[M+i][dest]);
        capacity[M+i][dest] = log(capacity[M+i][dest]);
    }
    while(L--)
    {
        scanf("%d%d",&i,&j);
        capacity[i][M+j] = INF;
    }
    return ;
}

int main()
{
    int T,m,n,l;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&m,&n,&l);
        solve poj_3308(m,n,l);
    }
    return 0;
}