0618图的整理

Posted 2020-07-26 神犇(shenben)

第五章  图

5.1      医院设置

codevs 2577：http://codevs.cn/problem/2577/

源程序名            hospital.???（pas, c, cpp） 可执行文件名        hospital.exe 输入文件名          hospital.in 输出文件名          hospital.out

【问题描述】

       设有一棵二叉树，如图5-1：

                                                                                                    131

                                                                          /   \

                                                                        24  123

                                                                                /  \

                                                                           420 405

    其中，圈中的数字表示结点中居民的人口。圈边上数字表示结点编号，现在要求在某个结点上建立一个医院，使所有居民所走的路程之和为最小，同时约定，相邻接点之间的距离为l。如上图中，若医院建在：

【输入】

    第一行一个整数n，表示树的结点数。(n≤100)

    接下来的n行每行描述了一个结点的状况，包含三个整数，整数之间用空格(一个或多个)分隔，其中：第一个数为居民人口数；第二个数为左链接，为0表示无链接；第三个数为右链接。

【输出】

       一个整数，表示最小距离和。

【样例】

       hospital.in                          hospital.out

       5                                        81

       13 2 3

       4 0 0

       12 4 5

       20 0 0

       40 0 0

【知识准备】

       图的遍历和最短路径。

【算法分析】

       本题的求解任务十分明了：求一个最小路径之和。

       根据题意，对n个结点，共有n个路径之和：用记号Si表示通向结点i的路径之和，则，其中Wj为结点j的居民数，g(i,j)为结点j到结点i的最短路径长度。下面表中反映的是样例的各项数据：

j g(i,j) i	1	2	3	4	5	Si
1	0	1	1	2	2	0×13+1×4+1×12+2×20+2×40=136
2	1	0	2	3	3	1×13+0×4+2×12+3×20+3×40=217
3	1	2	0	1	1	1×13+2×4+0×12+1×20+1×40=81
4	2	3	1	0	2	2×13+3×4+1×12+0×20+2×40=130
5	2	3	1	2	0	2×13+3×4+1×12+2×20+0×40=90

 

       从表中可知S3=81最小，医院应建在3号居民点，使得所有居民走的路径之和为最小。

       由此可知，本题的关键是求g[i,j]，即图中任意两点间的最短路径长度。

       求任意两点间的最短路径采用下面的弗洛伊德（Floyd）算法。

       （1）数据结构：

       w:array[1..100]of longing;         描述个居民点人口数

       g:array[1..100, 1..100]of longint       初值为图的邻接矩阵，最终为最短路径长度

       （2）数据的读入：

       本题数据结构的原形为二叉树，数据提供为孩子标识法，分支长度为1，建立带权图的邻接矩阵，分下面两步：

       ①g[i,j]←Max        {Max为一较大数，表示结点i与j之间无直接相连边}

       ②读入n个结点信息：

       for i:=1 to n do

         begin

              g[i,j]:=0;

              readln(w[i],l,r);

              if l>0 then begin

                               g[i,l]:=l;            g[l,i]:=l

                             end;

              if r>0 then begin

                               g[i,r]:=l;           g[r,i]:=l

                             end;

       （3）弗洛伊德算法求任意两点间的最短路径长度

       for k:=1 to n do

         for i:=1 to n do

              if i<>k then for j:=1 to n do

                             if (i<>j)and(k<>j)and(g[i,k]+g[k,j]<g[i,j])  then g[i,j]:=g[i,k]+g[k,j];

       （4）求最小的路程和min

       min:=max longint;

       for i:=1 to n do

         begin

              sum:=0;

              for j:=1 to n do sum:=sum+w[i]*g[i,j];

              if sum<min then min:=sum;

         end;

       （5）输出

       writeln(min);

 

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
#define N 105
int w[N],g[N][N],n;
int main(){
    memset(g,127/3,sizeof g);
    scanf("%d",&n);
    for(int i=1,x,y;i<=n;i++){
        scanf("%d%d%d",w+i,&x,&y);
        g[i][x]=g[x][i]=g[i][y]=g[y][i]=1;
    }
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i!=j&&i!=k&&j!=k&&g[i][j]>g[i][k]+g[k][j]){
                    g[i][j]=g[i][k]+g[k][j];
                }
            }
        }
    }
    int ans=0x3f3f3f3f;
    for(int i=1;i<=n;i++){
        int s=0;
        for(int j=1;j<i;j++){
            s+=g[i][j]*w[j];
        }
        for(int j=i+1;j<=n;j++){
            s+=g[i][j]*w[j];
        }
        ans=min(s,ans);
    }
    printf("%d\n",ans);
    return 0;
}

 

5.2      工程规划

源程序名            work.???（pas, c, cpp） 可执行文件名        work.exe 输入文件名          work.in 输出文件名          work.out

【问题描述】

    造一幢大楼是一项艰巨的工程，它是由n个子任务构成的，给它们分别编号1，2，…，n(5≤n≤1000)。由于对一些任务的起始条件有着严格的限制，所以每个任务的起始时间T1，T2，…，Tn并不是很容易确定的(但这些起始时间都是非负整数，因为它们必须在整个工程开始后启动)。例如：挖掘完成后，紧接着就要打地基；但是混凝土浇筑完成后，却要等待一段时间再去掉模板。

    这种要求就可以用M(5≤m≤5000)个不等式表示，不等式形如Ti-Tj≤b代表i和j的起始时间必须满足的条件。每个不等式的右边都是一个常数b，这些常数可能不相同，但是它们都在区间(-100，100)内。

    你的任务就是写一个程序，给定像上面那样的不等式，找出一种可能的起始时间序列T1，T2，…，Tn，或者判断问题无解。对于有解的情况，要使最早进行的那个任务和整个工程的起始时间相同，也就是说，T1，T2，…，Tn中至少有一个为0。

【输入】

    第一行是用空格隔开的两个正整数n和m，下面的m行每行有三个用空格隔开的整数i，j，b对应着不等式Ti-Tj≤b。

【输出】

       如果有可行的方案，那么输出N行，每行都有一个非负整数且至少有一个为0，按顺序表示每个任务的起始时间。如果没有可行的方案，就输出信息“NO SOLUTION”。

【样例1】

       work.in                               work.out

       5 8                                     0

       1 2 0                                  2

       1 5 –1                                5

       2 5 1                                  4

       3 1 5                                  1

       4 1 4

       4 3 –1

       5 3 –1

       5 4 –3

【样例2】

       work.in                               work.out

       5 5                                     NO SOLUTION

       1 2 –3

       1 5 –1

       2 5 –1

       5 1 –5

       4 1 4

【算法分析】

       本题是一类称为约束满足问题的典型问题，问题描述成n个子任务的起始时间Ti及它们之间在取值上的约束，求一种满足所有约束的取值方法。

       将工程的n个子任务1，2，…，n作为一有向图G的n个顶点，顶点V_i（i＝1，…，n）的关键值为子任务i的起始时间T_i，我们并不需要关心顶点之间的弧及其弧长，而是要确定顶点的关键值T_i的取值，满足所有的约束条件。本题的约束条件由m个不等式T_i-T_j≤b给出，这样的有向图称为约束图。

    为了确定每一个T_i的值，先假设某一个子任务的起始时间为零，如设T_j＝0，则其余子任务的起始时间T_i相对于T₁可设置其起始时间为一区间[-maxt，maxt]。

    下面分析不等式T_i-T_j≤b。此不等式可变形为如下两种形式：

    （1）T_i≤T_j+b意味T_i的最大值为T_j+b；

    （2）T_j≥T_i-b意味T_j的最大值为T_i-b；

    因此，根据题中给出的m个不等式，逐步调整各个T_i的最小值和最大值。

    设high[i]为T_i当前的最大值，low[i]为T_i当前的最小值。

    high[j]为T_j当前的最大值，low[j]为T_j当前的最小值。

    若high[i]-high[j]>b，则high[i]=high[j]+b(根据T_i≤T_j+b)，

    若low[i]-low[j]<b，则low[j]＝low[i]-b(根据T_i≥T_i-b)。

    以上的调整终止视下列两种情况而定：

    （1）对所有的不等式T_i-T_j≤b，不再有high[i]或low[j]的调整；

    （2）若存在high[i]<low[i]或high[j]<low[j]则表示不存在T₁，T₂，…，T_n能满足所有m个不等式T_i-T_j≤b，即问题无解。

    根据以上思路，先建立约束图，每个结点代表一个起始时间值，并记录其可能的取值范围：

    数组high，low:array[1..maxn]of longint；{n个子任务起始时间的取值范围}

       high[1]=0;   low[1]=0;   {设置n个起始时间的初值，其中T_i=0}

    for  i:=2 to n do begin

                                   high[i]:=maxt;              {T_i的上界}

                                   low[i]:=-maxt;              {Tj的下界}

                             end;

       约束条件（m个不等式）用记录数组表示：

       type                            {不等式结构}

         Tinequ=record

              i,j,b:longint;

         end;

       var

         arrinequ:array[1..maxm]of Tinequ;       {存放m个不等式}

       利用约束条件，逐一调整每一个起始时间的取值范围，直到无法调整为止。

       主要算法如下：   

flag:=true;      {调整状态标记} noans:=false;    {解的有无标记} while (flag) do   {进行约束传递，根据不等式调整各个起始时间值}   begin     flag:=false;     for k:=1 to m do       with arrinequ[k] do       begin         if (high[i]-high[j]>b) then begin high[i]:=high[j]+b;  flag:=true;  end;  {调整Ti的上界}         if (low[i]-low[j]>b) then begin low[j]:=low[i]-b;   flag:=true;  end;  {调整Tj的下界}         if (low[i]>high[i]) or (low[j]>high[j])          then begin          {无法满足当前不等式，则调整终止}                noans:=true;   {问题无解noans=true}                flag:=false;                break;              end;       end;   end;

       下面以样例说明：

【样例1】

       8个不等式如下

序号	1	2	3	4	5	6	7	8
i	1	1	2	3	4	4	5	5
j	2	5	5	1	1	3	3	4
b	0	-1	1	5	4	-1	-3	-3

       顶点的关键值Ti的调整记录：

	初值	第1轮调整	第2轮调整	第3轮调整
high[1]	0	0	0	0
low[1]	0	0	0	0
high[2]	100000	100000	2	2
low[2]	-10000	2	2	2
high[3]	100000	5	5	5
low[3]	-10000	4	5	5
high[4]	100000	4	4	4
low[4]	-10000	4	4	4
high[5]	100000	1	1	1
low[5]	-10000	1	1	1
调整状态		有变化	有变化	无变化

【样例2】

       5个不等式如下

编号	1	2	3	4	5
i	1	1	2	5	4
j	2	5	5	1	1
b	-3	-1	-1	-5	4

       顶点关键值T_i的调整记录：      

		初值	第一轮调整	第二轮调整
1	high	0	0
	low	0	0
2	high	100000	99999
	low	-10000	3
3	high	100000	10000
	low	-10000	-10000
4	high	100000	4
	low	-10000	-10000
5	high	100000	-5
	low	-10000	1
调整情况			high[5]<low[5]终止

       经第一轮调整，调整过程终止，即问题无解。

       从样例2所给不等式也可看出，因为：

       T₁-T₂≤-3，→T₂>T₁

       T₂-T₅≤-1，→T₅>T₂

       T₅-T₁≤-5，→T₁>T₅

       这三个不等式不能同时成立，因此问题无解。

/*
  <1>根据题意，假设一个开始任务，开始时间为0，其余的各项任务均
  维护一个时间范围，即low[i]-high[i]。 
  由 Ti-Tj<=b 得:① Ti<=Tj+b,即 high[i]=high[j]+b;
                 ② Tj>=Ti-b,即 low[j]=low[i]-b;
  <2>当high[i]-high[j]<=b 或者 low[i]-low[j]<=b 时，成立；
  反之，则用以上①②式更新。
  <3>当high[]<low[]时，没有可行方案，
  <4>当数据不再更新时，得出可行方案（满足数据非负，且至少有一个0)。 
*/
#include<cstdio>
#include<iostream>
#include<cstring>
#define M 1010
#define N 5010
#define INF 10000
using namespace std;
int high[M],low[M];
struct node
{
    int x,y,v;
}a[N];
int main()
{
    int n,m,x,y,v;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].v);
    }
    for(int i=2;i<=n;i++){
        high[i]=INF;
        low[i]=-INF;
    }
    int flag=1,ff=0;
    while(flag){
        flag=0;
        for(int i=1;i<=m;i++){
            int x=a[i].x,y=a[i].y,b=a[i].v;
            if(high[x]-high[y]>b){
                high[x]=high[y]+b;
                flag=1;
            }
            if(low[x]-low[y]>b){
                low[y]=low[x]-b;
                flag=1;
            }
            if(high[x]<low[x]||high[y]<low[y]){
                ff=1;
                flag=0;
            }
        }
    }
    if(ff)printf("NO SOLUTION\n");
    else{
        int minn=INF;
        for(int i=1;i<=n;i++)
            minn=min(high[i],minn);
        for(int i=1;i<=n;i++)
            printf("%d\n",high[i]-minn);
    }
    return 0;
}

 

5.3      服务器储存信息问题

源程序名            servers.???（pas, c, cpp） 可执行文件名        servers.exe 输入文件名          servers.in 输出文件名          servers.out

【问题描述】

           Byteland王国准备在各服务器间建立大型网络并提供多种服务。

    网络由n台服务器组成，用双向的线连接。两台服务器之间最多只能有一条线直接连接，同时，每台服务器最多只能和10台服务器直接连接，但是任意两台服务器间必然存在一条路径将它们连接在一起。每条传输线都有一个固定传输的速度。δ(V, W)表示服务器V和W之间的最短路径长度，且对任意的V有δ(V, V)＝0。

    有些服务器比别的服务器提供更多的服务，它们的重要程度要高一些。我们用r(V)表示服务器V的重要程度(rank)。rank越高的服务器越重要。

    每台服务器都会存储它附近的服务器的信息。当然，不是所有服务器的信息都存，只有感兴趣的服务器信息才会被存储。服务器V对服务器W感兴趣是指，不存在服务器U满足，r(U)>r(W)且δ(V, U)<δ(V, W)。

    举个例子来说，所有具有最高rank的服务器都会被别的服务器感兴趣。如果V是一台具有最高rank的服务器，由于δ(V, V)＝0，所以V只对具有最高rank的服务器感兴趣。我们定义B(V)为V感兴趣的服务器的集合。

    我们希望计算所有服务器储存的信息量，即所有服务器的|B(V)|之和。Byteland王国并不希望存储大量的数据，所以所有服务器存储的数据量(|B(V)|之和)不会超过30n。

    你的任务是写一个程序，读入Byteland王国的网络分布，计算所有服务器存储的数据量。

【输入】

    第一行两个整数n和m，(1≤n≤30000，1≤m≤5n)。n表示服务器的数量，m表示传输线的数量。

    接下来n行，每行一个整数，第i行的整数为r(i)(1≤r(i)≤10)，表示第i台服务器的rank。

    接下来m行，每行表示各条传输线的信息，包含三个整数a，b，t(1≤t≤1000，1≤a，b≤n，a≠b)。a和b是传榆线所连接的两台服务器的编号，t是传输线的长度。

【输出】

       一个整数，表示所有服务器存储的数据总量，即|B(V)|之和。

【样例】

       servers.in                                         servers.out

       4 3                                            9

       2

       3

       1

       1

       1 4 30

       2 3 20

       3 4 20

注：B(1)={1，2}，B(2)={2}，B(3)={2，3}，B(4)={1，2，3，4}。

【知识准备】

       Dijkstra算法，及其O((n+e)log₂n)或O(nlog₂n+e)的实现。

【算法分析】

    本题的难点在于问题的规模。如果问题的规模在100左右，那么这将是一道非常容易的题目。因为O(n³)的算法是很容易想到的：

    （1）求出任意两点间的最短路径，时间复杂度为O(n³)；

    （2）枚举任意两点，根据定义判断一个节点是否对另一个节点感兴趣，时间复杂度为O(n³)。

    当然，对于30000规模的本题来说，O(n³)的算法是绝对不可行的，即便降到O(n²)也不行，只有O(nlog₂n)或O(n)是可以接受的。

    既然现在可以得到的算法与要求相去甚远，要想一鼓作气得到一个可行的算法似乎就不是那么容易了。我们不妨先来看看我们可以做些什么。

    判断一个节点V是否对节点W感兴趣，就是要判断是否存在一个rank大于r(W)的节点U，δ(V, U)<δ(V, W)。所以，节点V到某个特定的rank的节点（集合）的最短距离是一个非常重要的值。如果我们可以在O(nlog₂n)时间内求出所有节点到特定rank的节点（集合）的最短距离，我们就成功地完成了算法的一个重要环节。

    用Dijkstva算法反过来求特定rank的节点（集合）到所有点的最短距离——以所有特定rank的节点为起点（rank=1, 2, 3, …或10)，求这一点集到所有点的最短距离。由于图中与每个点关联的边最多只有10条，所以图中的边数最多为5n。用Priority Queue（Heap, Winner Tree或Fibonacci Heap等）来实现Dijkstra算法，时间复杂度为O((n+e)log₂n)（用Fibonacci Heap实现，更确切的时间复杂度是O(nlog₂n+e))。这里，e＝5n，因而求一遍最短路径的时间复杂度为O(nlog₂n)。由于1≤rank≤10，每个rank都要求一遍最短路径，所以求出每个节点到所有rank的最短路径长度的时间复杂度为O(10*(5+1)nlog₂n)，即O(nlog₂n)。

    求出所有点到特定rank的节点(集合)的最短距离，就完成了判断任意节点V对W是否感兴趣的一半工作。另一半是求任意节点V到W的最短距离。前面求节点到rank的最短距离时，利用的是rank范围之小——只有10种，以10个rank集合作起点，用Dijkstra算法求10次最短路径。但是，如果是求任意两点的最短路径，就不可能只求很少次数的最短路径了。一般来说，求任意两点最短路径是Ω(n²)的（这只是一个很松的下界），这样的规模已经远远超出了可承受的范围。但是，要判断V对W是否感兴趣，δ(V, W)又是必须求的，所以n次Dijkstra算法求最短路径肯定是逃不掉的（或者也可以用一次Floyd算法代替，但是时间复杂度一样，可认为等价)。那么，我们又能从哪里来降这个时间复杂度呢？

    题目中提到：所有服务器储存的数据量（|B(V)|之和）不会超过30n。这就是说，最多只存在30n对(V, W)满足V对W感兴趣。所以，就本题来说，我们需要处理的点对最少可能只有30n个，求最短距离的下界也就变成Ω(30n)=Ω(n)了（当然，这也只是很松的下界）。虽说下界是Ω(n)，其实我们只需要有O(nlog₂n)的算法就可以满足要求了。

    从前面估算下界的过程中我们也看到，计算在下界中的代价都是感兴趣的点对（一个节点对另一个节点感兴趣），其余部分为不感兴趣的点对。我们如果想降低时间复杂度，就要避免不必要的计算，即避免计算不感兴趣的点对的最短路径。

    我们来看当V对W不感兴趣时的情况。根据定义，δ(V, W)>δ(V, r(W)+1)。如果是以W为起点，用Dijkstra算法求最短路径的话。当扩展到V时，发现V对W不感兴趣，即δ(V, W)>δ(V, r(W)+1)。那么，如果再由V扩展求得到U的最短路径，则：

    δ(U, W)=δ(V, W)+δ(U, V)，

    δ(U, r(W)+1)=δ(V, r(W)+1)+δ(U, V)，

    由于δ(V, W)>δ(V, r(W)+1)，

    所以δ(V, W)+δ(U, V)>δ(V, r(W)+1)+δ(U, V)，即δ(U, W)>δ(U, r(W)+1)

    所以，U对W也不感兴趣。因此，如果以W为起点，求其他点到W的最短路径，以判断其他点是否对W感兴趣，当扩展到对W不感兴趣的节点时，就可以不继续扩展下去了（只扩展对W感兴趣的节点）。

    我们知道，所有感兴趣的点对不超过30n。因此，以所有点作起点，用Dijkstra算法求最短路径的时间复杂度可由平摊分析得为O(30(n+e)log₂n)=O(30(n+5n)log₂n)=O(nlog₂n)。

    由此，我们看到判断一节点是否对另一节点感兴趣，两个关键的步骤都可以在O(nlog₂n)时间内完成。当然算法的系数是很大的，不过由于n不大，这个时间复杂度还是完全可以承受的。下面就总结一下前面得到的算法：

    （1）分别以rank=1, 2, …, 10的节点（集合）作为起点，求该节点（集合）到所有点的最短距离（其实也就是所有点到该节点（集合）的最短距离）；

    （2）以每个点作为起点，求该点到所有点的最短距离。当求得某节点的最短距离的同时根据求得的最短距离和该节点到rank大于起点的节点（集合）的最短距离，判断该节点是否对起点感兴趣。如果感兴趣，则找到一对感兴趣的点对，否则，停止扩展该节点，因为该节点不可能扩展出对起点感兴趣的节点。

    总结解题的过程，可以发现解决本题的关键有三点：一是稀疏图，正因为图中边比较稀疏所以我们可以用Dijkstra+Priority Queue的方法将求最短路径的时间复杂度降为O(nlog₂n)；二是rank的范围很小，rank的范围只有10，所以我们只用了10次Dijkstra算法就求得了所有点到特定rank的最短距离；三是感兴趣的点对只有很少，由于感兴趣的点对只有30n，我们通过只计算感兴趣点对的最短路径，将求点与点间最短路径的时间复杂度降到了O(nlog₂n)。这三点，只要有一点没有抓住。本题就不可能得到解决。

 

 

5.4      间谍网络(AGE)

codevs 4093：http://codevs.cn/problem/4093/

 

源程序名            age.???（pas, c, cpp） 可执行文件名        age.exe 输入文件名          age.in 输出文件名          age.out

【问题描述】

           由于外国间谍的大量渗入，国家安全正处于高度的危机之中。如果A间谍手中掌握着关于B间谍的犯罪证据，则称A可以揭发B。有些间谍收受贿赂，只要给他们一定数量的美元，他们就愿意交出手中掌握的全部情报。所以，如果我们能够收买一些间谍的话，我们就可能控制间谍网中的每一分子。因为一旦我们逮捕了一个间谍，他手中掌握的情报都将归我们所有，这样就有可能逮捕新的间谍，掌握新的情报。

    我们的反间谍机关提供了一份资料，色括所有已知的受贿的间谍，以及他们愿意收受的具体数额。同时我们还知道哪些间谍手中具体掌握了哪些间谍的资料。假设总共有n个间谍(n不超过3000)，每个间谍分别用1到3000的整数来标识。

    请根据这份资料，判断我们是否有可能控制全部的间谍，如果可以，求出我们所需要支付的最少资金。否则，输出不能被控制的一个间谍。

【输入】

    输入文件age.in第一行只有一个整数n。

    第二行是整数p。表示愿意被收买的人数，1≤p≤n。

    接下来的p行，每行有两个整数，第一个数是一个愿意被收买的间谍的编号，第二个数表示他将会被收买的数额。这个数额不超过20000。

    紧跟着一行只有一个整数r，1≤r≤8000。然后r行，每行两个正整数，表示数对(A, B)，A间谍掌握B间谍的证据。

【输出】

    答案输出到age.out。

    如果可以控制所有间谍，第一行输出YES，并在第二行输出所需要支付的贿金最小值。否则输出NO，并在第二行输出不能控制的间谍中，编号最小的间谍编号。

【样例1】

       age.in                                 age.out

       3                                        YES

       2                                        110

       1 10

       2 100

       2

       1 3

       2 3

【样例2】

       age.in                                 age.out

       4                                        NO

       2                                        3

       1 100

       4 200

       2

       1 2

       3 4

【算法分析】

    根据题中给出的间谍的相互控制关系，建立有向图。找出有向图中的所有强连通分量，用每个强连通分量中最便宜的点（需支付最少贿金的间谍）来代替这些强连通分量，将强连通分量收缩为单个节点。收缩强连通分量后的图中，入度为0的节点即代表需要贿赂的间谍。

5.5      宫廷守卫

源程序名            guards.???（pas, c, cpp） 可执行文件名        guards.exe 输入文件名          guards.in 输出文件名          guards.out

【问题描述】

           从前有一个王国，这个王国的城堡是一个矩形，被分为M×N个方格。一些方格是墙，而另一些是空地。这个王国的国王在城堡里设了一些陷阱，每个陷阱占据一块空地。

    一天，国王决定在城堡里布置守卫，他希望安排尽量多的守卫。守卫们都是经过严格训练的，所以一旦他们发现同行或同列中有人的话，他们立即向那人射击。因此，国王希望能够合理地布置守卫，使他们互相之间不能看见，这样他们就不可能互相射击了。守卫们只能被布置在空地上，不能被布置在陷阱或墙上，且一块空地只能布置一个守卫。如果两个守卫在同一行或同一列，并且他们之间没有墙的话，他们就能互相看见。(守卫就像象棋里的车一样)

    你的任务是写一个程序，根据给定的城堡，计算最多可布置多少个守卫，并设计出布置的方案。

【输入】

       第一行两个整数M和N(1≤M，N≤200)，表示城堡的规模。

       接下来M行N列的整数，描述的是城堡的地形。第i行j列的数用a_i,j表示。

       a_i,j=0，表示方格[i,j]是一块空地；

       a_i,j=1，表示方格[i,j]是一个陷阱；

       a_i,j=2，表示方格[i,j]是墙。

【输出】

       第一行一个整数K，表示最多可布置K个守卫。

       此后K行，每行两个整数xi和yi，描述一个守卫的位置。

【样例】

       guards.in                                          guards.out

       3 4                                            2

2 0 0 0                                      1 2

       2 2 2 1                                      3 3

       0 1 0 2

       样例数据如图5-2（黑色方格为墙，白色方格为空地，圆圈为陷阱，G表示守卫）

			○
	○

	G
			○
	○	G

 

【算法分析】

    本题的关键在构图。

    城堡其实就是一个棋盘。我们把棋盘上横向和纵向连续的极长段（不含墙）都分离出来。显然，每一段上最多只能放一个guard，而且guard总是放在一个纵向段和一个横向段的交界处，所以一个guard和一个纵向段和一个横向段有关。

    我们把纵向段和横向段都抽象成图中的节点，如果一个纵向段和一个横向段相交的话，就在两点之间连一条边。这样，guard就成为了图中的边。前面得出的性质抽象成图的语言就是，每个点只能和一条边相连，每条边只能连接一个纵向边的点和一个横向边的点。因此，这样的图是二分图，我们所求的正是二分图的匹配。而要布置最多的guards，就是匹配数