二分图1

以后要争取每天一篇博客，尽管有点难度。

需要用到的一些二分图知识。

二分图构造与网络流息息相关，二者有较强的的联系。

在二分图最大匹配中，每个点（不管是X方点还是Y方点）最多只能和一条匹配边相关联，然而，我们经常遇到这种问题，即二分图匹配中一个点可以和多条匹配边相关联，但有上限，或者说，L_i表示点i最多可以和多少条匹配边相关联。
二分图多重匹配分为二分图多重最大匹配与二分图多重最优匹配两种，分别可以用最大流与最大费用最大流解决。

（1）二分图多重最大匹配：
在原图上建立源点S和汇点T，S向每个X方点连一条容量为该X方点L值的边，每个Y方点向T连一条容量为该Y方点L值的边，原来二分图中各边在新的网络中仍存在，容量为1（若该边可以使用多次则容量大于1），求该网络的最大流，就是该二分图多重最大匹配的值。
（2）二分图多重最优匹配：
在原图上建立源点S和汇点T，S向每个X方点连一条容量为该X方点L值、费用为0的边，每个Y方点向T连一条容量为该Y方点L值、费用为0的边，原来二分图中各边在新的网络中仍存在，容量为1（若该边可以使用多次则容量大于1），费用为该边的权值。求该网络的最大费用最大流，就是该二分图多重最优匹配的值。

【2】POJ2112 Optimal Milking
先预处理求出每两个点（包括挤奶点和牛）间的最短距离，然后将所有挤奶点作为X方点（L值为该挤奶点最多可以容纳多少牛），所有牛作为Y方点（L值为1），X_i和Y_j间边的权值为这两个点之间的最短距离（若这两点间不存在路径则此处无边），然后问题就变成了求一个多重匹配，使得每个Y方点都有匹配点且匹配边中权值的最大值最小。
可以枚举最大边权值S，然后，原图中所有权值大于S的边都要删去。若此时图中存在符合要求的多重匹配，则S合法否则S不合法。由于S的合法性是单调的，所以可以二分枚举S。

先弄上一个匈牙利算法模板。

#include<stdio.h>  
#include<memory.h>  
  
bool g[110][310]; //邻接矩阵，true代表有边相连  
bool flag,visit[310];    //记录V2中的某个点是否被搜索过  
int match[310];   //记录与V2中的点匹配的点的编号  
int p,n;   //二分图中左边、右边集合中顶点的数目   
  
// 匈牙利算法  
bool dfs(int u)  
{  
    for (int i = 1; i <= n; ++i)  
    {  
        if (g[u][i] && !visit[i])   //如果节点i与u相邻并且未被查找过  
        {  
            visit[i] = true;   //标记i为已查找过  
            if (match[i] == -1 || dfs(match[i]))   //如果i未在前一个匹配M中，或者i在匹配M中，但是从与i相邻的节点出发可以有增广路径  
            {  
                match[i] = u;  //记录查找成功记录，更新匹配M（即“取反”）  
                return true;   //返回查找成功  
            }  
        }  
    }  
    return false;  
}  
  
int main(void)  
{  
    int i,j,k,t,v,ans;  
    scanf("%d",&t);  
    while (t--)  
    {  
          scanf("%d %d", &p, &n);  
          for (i = 1; i <= p; i++)  
          {  
              for (j = 1; j <= n; j++)  
                  g[i][j] = false;  
          }  
          for (i = 1; i <= n; i++)  
              match[i] = -1;  
          flag = true;  
          for (i = 1; i <= p; i++)  
          {  
              scanf("%d",&k);  
              if (k == 0)  
                 flag = false;  
              while (k--)  
              {  
                    scanf("%d",&v);  
                    g[i][v]  = true;  
              }  
          }  
          if (flag)  
          {  
               ans = 0;  
               for (i = 1; i <= p; i++)  
               {  
                   memset(visit,false,sizeof(visit));   //清空上次搜索时的标记  
                   if( dfs(i) )    //从节点i尝试扩展  
                       ans++;  
               }  
               if (ans == p)  
                   puts("YES");  
               else  
                   puts("NO");  
          }   
          else  
              puts("NO");  
    }  
      
    return 0;  
}  

km算法模板

/*其实在求最大 最小的时候只要用一个模板就行了,把边的权值去相反数即可得到另外一个.求结果的时候再去相反数即可*/
/*最大最小有一些地方不同。。*/
#include <iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
//赤裸裸的模板啊。。
const int maxn = 101;
const int INF = (1<<31)-1;
int w[maxn][maxn];
int lx[maxn],ly[maxn]; //顶标
int linky[maxn];
int visx[maxn],visy[maxn];
int slack[maxn];
int nx,ny;
bool find(int x)
{
    visx[x] = true;
    for(int y = 0; y < ny; y++)
    {
        if(visy[y])
            continue;
        int t = lx[x] + ly[y] - w[x][y];
        if(t==0)
        {
            visy[y] = true;
            if(linky[y]==-1 || find(linky[y]))
            {
                linky[y] = x;
                return true;        //找到增广轨
            }
        }
        else if(slack[y] > t)
            slack[y] = t;
    }
    return false;                   //没有找到增广轨（说明顶点x没有对应的匹配，与完备匹配(相等子图的完备匹配)不符）
}

int KM()                //返回最优匹配的值
{
    int i,j;

    memset(linky,-1,sizeof(linky));
    memset(ly,0,sizeof(ly));
    for(i = 0; i < nx; i++)
        for(j = 0,lx[i] = -INF; j < ny; j++)
            if(w[i][j] > lx[i])
                lx[i] = w[i][j];
    for(int x = 0; x < nx; x++)
    {
        for(i = 0; i < ny; i++)
            slack[i] = INF;
        while(true)
        {
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            if(find(x))                     //找到增广轨，退出
                break;
            int d = INF;
            for(i = 0; i < ny; i++)          //没找到，对l做调整(这会增加相等子图的边)，重新找
            {
                if(!visy[i] && d > slack[i])
                    d = slack[i];
            }
            for(i = 0; i < nx; i++)
            {
                if(visx[i])
                    lx[i] -= d;
            }
            for(i = 0; i < ny; i++)
            {
                if(visy[i])
                     ly[i] += d;
                else
                     slack[i] -= d;
            }
        }
    }
    int result = 0;
    for(i = 0; i < ny; i++)
    if(linky[i]>-1)
        result += w[linky[i]][i];
    return result;
}

int main()
{
   // freopen("g:/1.txt","r",stdin);
    while(true)
    {
        scanf("%d%d",&nx,&ny);
        int a,b,c;
        while(scanf("%d%d%d",&a,&b,&c),a+b+c)
        {
            w[a][b]=c;
        }
        printf("%d\n",KM());
        break;
    }
    return 0;
}

poj2446

给出一个矩形N*M棋盘，有K个格子是空洞，然后用2*1的矩形，对所有非空洞的格子进行覆盖，如果可以全部覆盖，就puts("YES");

这是一个隐含的二分图匹配，由于每个格子周围都有格子，所以将相邻格子看做一个匹配。

套一下模板就可以了。

LA4043 ants

将给出的黑点与白点连起来，但线不能相交。

这是一个明显的二分图，但在处理线不能相交这个条件时有点困难。

但注意到两条线相交时欧几里得距离会变大，因此求匹配中欧几里得距离和最小的完全匹配即为所求的答案。

还是套用一下KM算法模板就可以了。

还是未完待续……