二分图最小路径覆盖 POJ 1548、1422、2594、3216

POJ 1548

法一：

//

/*题意：在图的给定位置有一些垃圾，现在要让机器人去捡。
机器人总是从左上角出发，到右下角结束。
只能向右或向下走，问至少要用多少个机器人?
算法：最小路径覆盖。在解决最小路径覆盖问题时，
最重要的是要建立一个有向图，所以说，
如何能建立有向图，这因该是思考的方向。
对于这道题来说，对两个垃圾(i,j)和(x,y)，
想想看：它们之间要满足什么样的条件才会连线?
当然是它们可以共用一个机器人！那么什么情况下它们可以共用一个机器人呢？

自然是 i<=x && j<=y !*/

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAX=600;
int map[MAX][MAX];  //map[i][j]=1 表示 排在(按输入顺序)前面的垃圾可以和排在后面的垃圾共用一个机器人。
int vis[MAX];    //访问数组
int match[MAX];  //匹配数组
int count;   //一组测试数据里的垃圾数目



//描述“垃圾”的结构体
typedef struct GARBAGE
{
    int row;  //行坐标
    int col;  //列坐标
}GARBAGE;

GARBAGE garbages[MAX];

bool Dfs(int u)  //深搜求最大匹配
{
    for (int v=1;v<=count;v++)
    {
        if (!vis[v] && map[u][v])
        {
            vis[v]=1;
            if (match[v]==0 || Dfs(match[v]))
            {
                match[v]=u;
                return true;
            }
        }
    }
    return false;
}
int main()
{
    int x,y;
    int i,j;

    while (scanf("%d%d",&x,&y) && x!=-1 && y!=-1)   //注意x和y是第一组数据
    {
        count=1;
        garbages[count].row=x;
        garbages[count].col=y;
        memset(map,0,sizeof(map));
        memset(match,0,sizeof(match));
        //输入“垃圾”的坐标

        while (scanf("%d%d",&x,&y) && x!=0 && y!=0)
        {
            count++;
            garbages[count].row=x;
            garbages[count].col=y;
        }
        //构建有向图

        for (i=1;i<=count;i++)
        {
            for (j=1+i;j<=count;j++)  //之所以可以从i+1开始，是因为后面的 垃圾 不需要和前面的 垃圾 连线：只能向下或向右走，不回去！
            {
                if (garbages[i].col<=garbages[j].col)  //前面垃圾的行号一定大于后面垃圾的行号：就是这样输入的！
                {
                     map[i][j]=1; //前面的垃圾i可以和后面的垃圾j共用一个机器人
                }
            }
        }
        //求最大匹配
        int sum=0;
        for (i=1;i<=count;i++)
        {
            memset(vis,0,sizeof(vis));
            if (Dfs(i))
            {
                sum++;
            }
        }
        printf("%d\n",count-sum);
    }
    return 0;
}

法二:

/*题意：在图的给定位置有一些垃圾，现在要让机器人去捡。机器人总是从左上角出发，到右下角结束。只能向右或向下走，问至少要用多少个机器人?
算法：很纠结的一种做法，不是很明白......算是枚举还算是贪心?
或许概念不是最终要的，关键是对算法思想的理解。
总的来说是先确定第一个垃圾的位置，根据相应的条件，
可以求出能和这个垃圾共用一个机器人的下一个垃圾，
如此循环下去，直到所有的垃圾都被处理完。

网言网语：对于位置(x1,y1)和位置(x2,y2)处的垃圾,
如果满足x1<=x2&&y1<=y2(当然不可能出现两个相同的坐标),
那么这两个位置处的垃圾只需要一个机器人就可以成功处理,
则有Dilworth定理可知,将x坐标升序排序,相等时将y坐标升序排序
(实际上题目就是按照这种形式输入),然后对y序列求解最长递减子序列即为所求.*/

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int map[30][30]; //map[i][j]=1 表示(i,j)处有垃圾。(这和其它地方map数组的定义还是有些区别的)

int main()
{
    int x,y; //临时变量
    int i,j; //临时变量
    int N;  //一组测试数据里垃圾的总数
    int sum; //需要用到的最少机器人的数量
    while (scanf("%d%d",&x,&y) && x!=-1 && y!=-1)
    {
        N=1;
        sum=0;
        memset(map,0,sizeof(map));
        map[x][y]=1;   //别忘了第一组数据
        while (scanf("%d%d",&x,&y) && x!=0 && y!=0)
        {
            map[x][y]=1;
            N++;
        }
        bool result=true;
        while (result)  //当所有的垃圾都被清洁完了，退出循环
        {
            result=false;
            x=y=1;
            for (i=1;i<=24;i++)  //两个for循环是要枚举所有可能的垃圾的数量，当然上界24也可以换成N
            {
                for (j=1;j<=24;j++)
                {
                    if (map[i][j]==1 && x<=i && y<=j)   //前面的垃圾(x,y)可以和后面的垃圾(i,j)共用一个机器人
                    {
                        result=true;
                        map[i][j]=0;
                        x=i;
                        y=j;
                    }
                }
            }
            sum++;   //当没有垃圾时sum也会加1，所以最后输出结果的时候sum要减1
        }
        printf("%d\n",sum-1);   //别忘了sum要减1哦
    }
    return 0;
}

POJ 1422

#include <iostream>
#include <algorithm>
#include <string.h>
#include <vector>
#include <cstdio>
using namespace std;
vector<int> ss[125];
int flag[125],visted[125];
bool dfs(int x){
	for(int i=0;i<ss[x].size();++i){
		if(!visted[ss[x][i]]){
		  visted[ss[x][i]]=1;
		  if(flag[ss[x][i]]==-1||dfs(flag[ss[x][i]])){
		    flag[ss[x][i]]=x;
			return true;
		  }
		}
	}
	return false;
}
int main(){
  int kk;
  scanf("%d",&kk);
  while(kk--){
    int n,m;
	scanf("%d%d",&n,&m);
	memset(ss,0,sizeof(ss));
	memset(flag,-1,sizeof(flag));
	int x,y;
	while(m--){
	  scanf("%d%d",&x,&y);
	  ss[x].push_back(y);
	}
	int sum=0;
	for(int i=1;i<=n;++i){
	  memset(visted,0,sizeof(visted));
	  if(dfs(i))
		  sum++;
	}
	printf("%d\n",n-sum);
  }
  return 0;
}

POJ 2594

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAX=510;
int map[MAX][MAX];  //图
int vis[MAX];    //访问标志
int match[MAX];  //匹配数组
int N,M;    //N：顶点数   M：边数

bool Dfs(int u)  //判断顶点u是否可以找到可匹配的顶点
{
     for (int v=1;v<=N;v++)
     {
          if (!vis[v] && map[u][v])
          {
               vis[v]=1;
               if (match[v]==0 || Dfs(match[v]))
               {
                    match[v]=u;
                    return true;
               }
          }
     }
     return false;
}

void Floyd()   //传递闭包：建新图
{
     for (int k=1;k<=N;k++)
     {
          for (int i=1;i<=N;i++)
          {
               for (int j=1;j<=N;j++)
               {
                    if (map[i][k] && map[k][j])  //顶点i和顶点j可到达
                    {
                         map[i][j]=1;
                    }
                }
           }
      }
}

int main()
{
      int i;
      int x,y;
      while (scanf("%d%d",&N,&M) && (N | M))
      {
            memset(map,0,sizeof(map));
            memset(match,0,sizeof(match));
            //输入边
            for (i=1;i<=M;i++)
            {
                  scanf("%d%d",&x,&y);
                  map[x][y]=1;
            }
            //建新图
            Floyd();
            //求最大匹配
            int sum=0;
            for (i=1;i<=N;i++)
            {
                  memset(vis,0,sizeof(vis));
                  if (Dfs(i))
                  {
                        sum++;
                  }
            }
            printf("%d\n",N-sum);  //输出最小路径覆盖
      }

      return 0;
}

POJ 3216