uva 11134 fabled rooks （贪心）——yhx

We would like to place n rooks, 1 n 5000, on a n n
board subject to the following restrictions
• The i-th rook can only be placed within the rectan-
gle given by its left-upper corner (xli; yli) and its right-
lower corner (xri; yri), where 1 i n, 1 xli
xri n, 1 yli yri n.
• No two rooks can attack each other, that is no two rooks
can occupy the same column or the same row.
Input
The input consists of several test cases. The rst line of each
of them contains one integer number, n, the side of the board. n lines follow giving the rectangles
where the rooks can be placed as described above. The i-th line among them gives xli, yli, xri, and
yri. The input le is terminated with the integer `0' on a line by itself.
Output
Your task is to nd such a placing of rooks that the above conditions are satised and then output n
lines each giving the position of a rook in order in which their rectangles appeared in the input. If there
are multiple solutions, any one will do. Output `IMPOSSIBLE' if there is no such placing of the rooks.

---

因为行和列并没有什么关系，所以只要把问题分成两个，如果都能满足，再进行配对即可。

那么问题就变成了在[1,n]上有n个区间，把n个整数恰好不重不漏地分配到每个区间。

很明显用贪心。

 #include<cstdio>
 #include<cstring>
 struct qj
 {
     int l,r,num;
 }q1,q2;
 qj a1[],a2[];
 int p1[],p2[],n;
 bool xy(qj a,qj b)
 {
     return a.l<b.l||(a.l==b.l&&a.r<b.r);
 }
 void st1(int l,int r)
 {
     int i,j,k;
     qj mid=a1[(l+r)/];
     i=l;
     j=r;
     do
     {
         while (xy(a1[i],mid)) i++;
         while (xy(mid,a1[j])) j--;
         if (i<=j)
         {
             p1[a1[i].num]=j;
             p1[a1[j].num]=i;
             q1=a1[i];
             a1[i]=a1[j];
             a1[j]=q1;
             i++;
             j--;
         }
     }
     while (i<=j);
     if (l<j) st1(l,j);
     if (i<r) st1(i,r);
 }
 void st2(int l,int r)
 {
     int i,j,k;
     qj mid=a2[(l+r)/];
     i=l;
     j=r;
     do
     {
         while (xy(a2[i],mid)) i++;
         while (xy(mid,a2[j])) j--;
         if (i<=j)
         {
             p2[a2[i].num]=j;
             p2[a2[j].num]=i;
             q2=a2[i];
             a2[i]=a2[j];
             a2[j]=q2;
             i++;
             j--;
         }
     }
     while (i<=j);
     if (l<j) st2(l,j);
     if (i<r) st2(i,r);
 }
 int main()
 {
     int i,j,k,m,p,q,x,y,z;
     bool ok;
     while (scanf("%d",&n)&&n)
     {
         for (i=;i<=n;i++)
         {
             scanf("%d%d%d%d",&q1.l,&q2.l,&q1.r,&q2.r);
             p1[i]=p2[i]=q1.num=q2.num=i;
             a1[i]=q1;
             a2[i]=q2;
         }
         st1(,n);
         st2(,n);
         ok=;
         for (i=;i<=n;i++)
           if (a1[i].l>i||a1[i].r<i||a2[i].l>i||a2[i].r<i)
           {
               ok=;
               break;
           }
         if (ok)
           for (i=;i<=n;i++)
             printf("%d %d\n",p1[i],p2[i]);
         else
           printf("IMPOSSIBLE\n");
     }
 }

以上是经典的错误答案。（反正我开始就是这么错的）

把区间按左端点排序，第i个区间放整数i。

反例：[1,1],[1,3],[2,2]。照这个贪心思路找不到解。

 #include<cstdio>
 #include<cstring>
 #define MS(a) memset(a,0,sizeof(a))
 int l1[],r1[],l2[],r2[],p1[],p2[];
 int main()
 {
     int i,j,k,m,n,p,q1,q2,x,y,z,min1,min2;
     bool ok;
     while (scanf("%d",&n)&&n)
     {
         MS(p1);
         MS(p2);
         for (i=;i<=n;i++)
           scanf("%d%d%d%d",&l1[i],&l2[i],&r1[i],&r2[i]);
         ok=;
         for (i=;i<=n;i++)
         {
             q1=q2=-;
             min1=min2=;
             for (j=;j<=n;j++)
             {
                 if (p1[j]==&&l1[j]<=i&&r1[j]>=i&&r1[j]<min1)
                 {
                     q1=j;
                     min1=r1[j];
                 }
                 if (p2[j]==&&l2[j]<=i&&r2[j]>=i&&r2[j]<min2)
                 {
                     q2=j;
                     min2=r2[j];
                 }
             }
             if (q1==-||q2==-)
             {
                 ok=;
                 break;
             }
             p1[q1]=i;
             p2[q2]=i;
         }
         if (ok)
           for (i=;i<=n;i++)
             printf("%d %d\n",p1[i],p2[i]);
         else
           printf("IMPOSSIBLE\n");
     }
 }

正解：把按顺序枚举区间变成按顺序枚举点。对于每个点，找到它能放的、右端点最小的区间。

若不取这个区间而取另一个右端点更大的区间，会让之后的点选择变少。