Sorting Slides（二分图匹配——确定唯一匹配边）

题目描述：

Professor Clumsey is going to give an important talk this afternoon. Unfortunately, he is not a very tidy person and has put all his transparencies on one big heap. Before giving the talk, he has to sort the slides. Being a kind of minimalist, he wants to do this with the minimum amount of work possible.

The situation is like this. The slides all have numbers written on them according to their order in the talk. Since the slides lie on each other and are transparent, one cannot see on which slide each number is written.

Well, one cannot see on which slide a number is written, but one may deduce which numbers are written on which slides. If we label the slides which characters A, B, C, ... as in the figure above, it is obvious that D has number 3, B has number 1, C number 2 and A number 4.

Your task, should you choose to accept it, is to write a program that automates this process.

Input

The input consists of several heap
descriptions. Each heap descriptions starts with a line containing a
single integer n, the number of slides in the heap. The following n
lines contain four integers xmin, xmax, ymin and ymax, each, the
bounding coordinates of the slides. The slides will be labeled as A, B,
C, ... in the order of the input.

This is followed by n lines
containing two integers each, the x- and y-coordinates of the n numbers
printed on the slides. The first coordinate pair will be for number 1,
the next pair for 2, etc. No number will lie on a slide boundary.

The input is terminated by a heap description starting with n = 0, which should not be processed.

Output

For each heap description in the
input first output its number. Then print a series of all the slides
whose numbers can be uniquely determined from the input. Order the pairs
by their letter identifier.

If no matchings can be determined from the input, just print the word none on a line by itself.

Output a blank line after each test case.

Sample Input

4
6 22 10 20
4 18 6 16
8 20 2 18
10 24 4 8
9 15
19 17
11 7
21 11
2
0 2 0 2
0 2 0 2
1 1
1 1
0

Sample Output

Heap 1
(A,4) (B,1) (C,2) (D,3)

Heap 2
none

 /*
 题意描述：输入幻灯片的坐标位置，页码的坐标位置，将能唯一确定页码的幻灯片按照顺序输出，
 如果没有一张能够唯一确定则输出none
 */
 /*
 解题思路：基本思路是将幻灯片和页码进行匹配，按照二分图匹配的思路求最大匹配，如果某一条边
 是唯一边，则将这条边去掉以后，该二分图的最大匹配数将<n,输出该匹配边。
 */
 #include<stdio.h>
 #include<string.h>
 const int N=;
 struct Slide{
     int xmin,xmax,ymin,ymax;
 }slide[N];
 struct Num{
     int x,y;
 }num[N];
 int n,e[N][N],cx[N],cy[N],bk[N];
 int maxmatch();
 int path(int u);

 int main()
 {
     int i,j,t=;
     while(scanf("%d",&n), n != )
     {
         for(i=;i<n;i++)
             scanf("%d%d%d%d",&slide[i].xmin,&slide[i].xmax,&slide[i].ymin,&slide[i].ymax);
         for(i=;i<n;i++)
             scanf("%d%d",&num[i].x,&num[i].y);

         memset(e,,sizeof(e));
         for(i=;i<n;i++){
             for(j=;j<n;j++){
                 if(num[i].x>slide[j].xmin && num[i].x<slide[j].xmax
                 && num[i].y>slide[j].ymin && num[i].y<slide[j].ymax)
                 e[j][i]=;//点i在j张里，按照输出顺序，先输出字母，再输出数字
             }
         }    

         printf("Heap %d\n",++t);
         int flag=;
         for(i=;i<n;i++){
             for(j=;j<n;j++){
                 if(e[i][j])
                 {
                     e[i][j]=;
                     if(maxmatch() < n)
                     {
                         if(flag)
                         printf(" (%c,%d)",'A'+i,j+);
                         else
                         printf("(%c,%d)",'A'+i,j+);
                         flag=;
                     }
                     e[i][j]=;
                 }
             }
         }

         if(flag)
         printf("\n\n");
         else
         printf("none\n\n");
     }
     return ;
 }

 int maxmatch()
 {
     int i;
     memset(cx,-,sizeof(cx));
     memset(cy,-,sizeof(cy));
     int ans=;
     for(i=;i<n;i++)
     {
         if(cy[i]==-)
         {
             memset(bk,,sizeof(bk));
             ans += path(i);
         }
     }
     return ans;
 }
 int path(int u)
 {
     int i;
     for(i=;i<n;i++)
     {
         if(e[u][i] && !bk[i])
         {
             bk[i]=;
             if(cx[i]==- || path(cx[i]))
             {
                 cx[i]=u;
                 cy[u]=i;
                 return ;
             }
         }
     }
     return ;
 }
 /*易错分析：按照输出顺序，先幻灯片再页码，所以输入边的时候j在前，i在后*/