poj 3308 Paratroopers 最小割 最小点权覆盖

题目链接：http://poj.org/problem?id=3308

题意：

有一个M*N的图，上面的一些点上有伞兵。

可以设置一些枪在每行或者每列上，通过射击，这行或这列的伞兵就会被消灭。每个枪的设置有一个花费，如果设置多个枪，那么花费是设置每个枪的乘积。

问消灭所有伞兵最少的花费是多少。

思路：

每个点的伞兵至少要用那一列或者那一行设置的枪去消灭，那么就可以应用点覆盖的模型。把伞兵看成是一条边，这条边至少要用一个点来覆盖。

而题目中最终花费是所有花费的乘积，那么可以用对数log(x)+log(y) = log(x*y)来转换。

所以就可以用最小点权覆盖模型来解决。

设置一个超级源点s和超级汇点t。

s向每行连一条边，容量是log(在这些行设置枪的花费)。

每列向t连一条边，容量是log(在这些列设置枪的花费)。

对于每个伞兵所在的位置(x, y)，则x向y连一条边，容量是inf。

然后求最小割。答案就是exp(最大流)。

 

这题要注意一下精度问题，esp开1e-8，因为保留4位小数。用G++时，双精度是%f，用C++时双精度是%lf。

//#include <bits/stdc++.h>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <vector>
using namespace std;
struct Edge
{
    int from, to; double cap, flow;
    Edge(int f, int t, double c, double fl)
    {
        from = f; to = t; cap = c; flow = fl;
    }
};
#define maxn 110
#define inf 100000
#define eps 1e-8
int n, m, s, t;
vector <Edge> edges;
vector <int> G[maxn];
int d[maxn], cur[maxn], vis[maxn];
void AddEdge(int from, int to, double cap)
{
    edges.push_back(Edge(from, to, cap, 0));
    edges.push_back(Edge(to, from, 0, 0));
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}
bool bfs()
{
    memset(vis, 0, sizeof(vis));
    d[s] = 0; vis[s] = 1;
    queue <int> q; q.push(s);
    while(!q.empty())
    {
        int x = q.front(); q.pop();
        for(int i = 0; i < G[x].size(); i++)
        {
            Edge &e = edges[G[x][i]];
            if(!vis[e.to] && e.cap > e.flow)
            {
                d[e.to] = d[x] + 1;
                vis[e.to] = 1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}
double dfs(int x, double a)
{
    if(x == t || fabs(a) < eps) return a;
    double flow = 0, f;
    for(int &i = cur[x]; i < G[x].size(); i++)
    {
        Edge &e = edges[G[x][i]];
        if(d[e.to] == d[x] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(fabs(a) < eps) break;
        }
    }
    return flow;
}
double maxflow()
{
    double flow = 0;
    while(bfs())
    {
        memset(cur, 0, sizeof(cur));
        flow += dfs(s, inf);
    } 
    return flow;
}
int T, M, N, L;
int main() 
{
    //freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d%d",  &M, &N, &L);
        edges.clear();
        s = 0; t = N+M+1; n = N+M+2;
        for(int i = s; i <= t; i++) G[i].clear();
        double val;
        for(int i = 1; i <= M; i++)
        {
            scanf("%lf", &val);
            AddEdge(s, i, log(val));
        }
        for(int i = 1; i <= N; i++)
        {
            scanf("%lf", &val);
            AddEdge(i+M, t, log(val));
        }
        for(int i = 1; i <= L; i++)
        {
            int a, b; scanf("%d%d", &a, &b);
            AddEdge(a, b+M, inf);
        }
        double flow = maxflow();
        printf("%.4lf\n", exp(flow));
    }
    return 0;
}