poj3308

二分图的最小点权覆盖，选定点集，与该点集有关的边覆盖所有顶点，且该点集的点权值和最小。

有类似于匈牙利算法一样的带权匹配算法，但是这里就不介绍了。个人比较推荐，用最大流算法更好理解，写起来更容易。

题意：一个m X n的方阵，方阵格子中有老鼠屎，神枪手一枪能打掉一行或者一列上的所有赃物，让选定某些行和某些列，打掉所有赃物。已知条件： m、n，老鼠屎l粒，在每一行和列上布置神枪手的花费ci、cj，l粒老鼠屎的坐标。总费用为选定的行和列对应的花费值乘积，求最小总费用。

第一步：化积为和，使用幂函数，最后得到结果时再还原！！！

第二步：最大流算法求最小点权覆盖。

先弱弱证明一下该算法。坐标为(i,j)的老鼠屎，第i行和第j列必选之一，点覆盖必选边两个端点之一。假设仅有某一行i上，第a、b、c（可以更多）列上有老鼠屎，选定i行或者选定对应的所有列，也即两者之一必有一个是在最小割中。

• 若（条件1）Α第i行的费用小于所有列，选行i，否则（条件2）选列。
• 若再有某一行ii（ii != i）有a、b、d、e列上有老鼠屎，若上一步（条件1）为真，ii行的费用减去第i行中行与列的差（此差值也进入最小割，当然有可能行ii的费用更小，那样就是ii的费用进入最小割了）否则，对于此行a、b就不考虑，行ii与 d、e列像上一步一样考虑。
• 把i行和ii行看成一行，继续对后面的行进行第二步判定。

此最小点权覆盖就和最小割联系起来了。

只是个博客，写的不是特别学术，希望读者能看懂。

贴个代码，祝好运！

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <queue>
 #include <cmath>
 using namespace std;
 #define maxn 500
 const int maxe = ;
 const double maxf = 1e10;
 #define zero 1e-8
 struct edge{
     int u,v; double c;
     edge(int e1=,int e2=,double e3=){ u=e1,v=e2; c=e3; }
 }e[maxe];
 int ec;
 int head[maxn];
 int next[maxe];
 void addedge(int u,int v,double c){
     e[ec]=edge(u,v,c);
     next[ec]=head[u]; head[u]=ec++;
     //printf("%d --> %d , c = %.5f\n",u,v,c);
     e[ec]=edge(v,u,);
     next[ec]=head[v]; head[v]=ec++;
 }
 //***********************************//
 int source,sink,maxdep;
 int dep[maxn],gap[maxn];
 void setGD(){
      for(int i=;i<=maxdep;i++) dep[i] = maxdep; dep[sink] = ;
      int u,v;
      queue<int> que;
      que.push(sink);
      while(!que.empty()){
            u = que.front(); que.pop();
            for(int i=head[u];i!=-;i=next[i]){
                  v = e[i].v; //if(v > maxdep) continue;
                  if(dep[v] < maxdep) continue; //'被访问过'
                  dep[v] = dep[u]+;
                  que.push(v);
            }
      }
      memset(gap,,sizeof(gap));
      for(int i=;i<=maxdep;i++) gap[dep[i]]++;
 }
 double maxF(){
     setGD();
     int u=source,i;
     int cur[maxn],trace[maxn],top=;
     for(int i=;i<=maxdep;i++) cur[i] = head[i];
     double flow=;
     while(dep[source] <= maxdep){
         if(u == sink){
              double tf = maxf; int ins;
              for(i=;i<top;i++) //找瓶颈边
                 if(tf - e[trace[i]].c > )
                       tf = e[trace[i]].c, ins = i;
              for(i=;i<top;i++){
                 e[trace[i]].c -= tf;
                 e[trace[i]^].c += tf;
              }
              flow += tf;
              u = e[trace[ins]].u, top = ins;
         }
         if(u != sink && gap[dep[u]-]==) break;
         for(i=cur[u];i!=-;i=next[i])
              if(e[i].c > zero && dep[u] == dep[e[i].v] + )
                        break;
         if(i != -) {
              trace[top++] = i;
              cur[u] = i;
              u = e[i].v;
         }
         else {
              int mindep = maxdep;
              for(i=head[u];i!=-;i=next[i]){
                  if(e[i].c > zero && dep[e[i].v] < mindep)
                            mindep = dep[e[i].v], cur[u] = i;
              }
              gap[dep[u]]--;
              dep[u] =  mindep + ;
              gap[dep[u]]++;
              if(u != source)
                 u = e[trace[--top]].u;
         }
     }
     return flow;
 }
 //**********************************//
 void initial(){
      ec = ;
      memset(head,-,sizeof(head));
      //initial source ,sink and maxdep;
 }
 int main()
 {
     int cases; cin>>cases;
     int n,m,l;
     for(int cas=;cas<cases;cas++){
         initial();
         scanf("%d%d%d",&m,&n,&l);
         source=;
         sink=n+m+; maxdep=sink+;
         double tt;
         for(int i=;i<=m;i++)
             scanf("%lf",&tt), addedge(source,i,log10(tt));
         for(int i=;i<=n;i++)
             scanf("%lf",&tt), addedge(i+m,sink,log10(tt));
         int u,v;
         for(int i=;i<=l;i++){
             scanf("%d%d",&u,&v);
             addedge(u,v+m,maxf);
         }
         double ret = maxF();
         printf("%.4f\n",pow(,ret));
     }
     return ;
 }