UVA 11134 Fabled Rooks（贪心的妙用+memset误用警示）

题目链接：

https://cn.vjudge.net/problem/UVA-11134

 /*
 问题 输入棋盘的规模和车的数量n（1=<n<=5000）,接着输入n辆车的所能在的矩阵的范围，计算并输出使得每辆车横竖都不能相互攻击
 的摆放方法，能则输出每辆车的坐标，不能则输出"IMPOSSIBLE"。
 解题思路 想想怎么将问题分解成几个小问题，不同行不同列的话，将其分成两个一维问题，采用DFS向下搜索，搜的时候注意每个车的
 行区间和列区间，找到一种则直接返回，输出对应每辆车的行和列即可。但是超时！！！
     使用贪心法，先将所有区间按照右端点的大小进行排序，然后枚举每一个区间，找到一个数k，满足在此区间内，直到所有区间都找到
 一个数输出结果或者其中有一个车在其区间内找不到合适的位置则输出IMPOSSIBLE
 */
 #include<cstdio>
 #include<cstring>
 const int N = ;

 int xl[N],xr[N],yl[N],yr[N];
 int n;
 int row[N],col[N];

 int solve(int ans[],int l[],int r[]);

 int main()
 {
     int i;
     while(scanf("%d",&n), n != ){
         for(i=;i<n;i++){
             scanf("%d%d%d%d",&xl[i],&yl[i],&xr[i],&yr[i]);
         }

         if(solve(row,xl,xr) && solve(col,yl,yr)){
             for(i=;i<n;i++){
                 printf("%d %d\n",row[i],col[i]);
             }
         }
         else
             printf("IMPOSSIBLE\n");
     }
     return ;
 } 

 int solve(int ans[],int l[],int r[])
 {
     int cur,minr;//minr为包含k的区间最小右界（刚开始时初始化为最大，便于寻找最小），cur为放k的最优区间（号）
     memset(ans,-,sizeof(int)*n);
     //memset(ans,-1,sizeof(ans));错误用法，详见分析
     int k,i;
     for(k=;k<=n;k++){
         cur = -,minr = N;//初始化刚开始时初始化为最大，便于寻找最小
         for(i=;i<n;i++){//枚举每个区间
             if(ans[i] <  && l[i] <= k && r[i] < minr){
             //该区间没有被用过且k大于等于该区间的左边界且最小右边界也在该区间内
                 cur = i;//更新 预备将k存放的区间号
                 minr = r[i];//缩小右边界，也是贪心法的体现，总是放在可行区间的最右侧
             }
         }
         //没有区间能够放置k或者k不满足在最优区间内
         if(cur <  || k > minr)    return ;
         //将k放置在cur区间内
         ans[cur]=k;
     }
     return ;
 }

 /*DFS搜索，超时！！！
 #include<cstdio>
 #include<cstring>
 struct REC{
     int xr,yr,xl,yl;
 }rec[5050];

 int row[5050],col[5050],n,flag1,flag2;
 int bkrow[5050],bkcol[5050];

 void dfsrow(int step);
 void dfscol(int step);
 int main()
 {
     int i;

     while(scanf("%d",&n), n != EOF){
         for(i=1;i<=n;i++){
             scanf("%d%d%d%d",&rec[i].xl,&rec[i].yl,&rec[i].xr,&rec[i].yr);
         }

         memset(bkrow,0,sizeof(bkrow));
         memset(bkcol,0,sizeof(bkcol));
         flag1=flag2=0;
         dfsrow(1);
         dfscol(1);

         if(flag1 && flag2){
             for(i=1;i<=n;i++){
                 printf("%d %d\n",row[i],col[i]);
             }
         }
         else
             printf("IMPOSSIBLE\n");

     }
     return 0;
 }

 void dfsrow(int step){
     if(step == n+1){
         flag1=1;
         return;
     }

     int j;
     for(j=rec[step].xl;j<=rec[step].xr;j++){
         if(bkrow[j] == 0){
             bkrow[j]=1;
             row[step]=j;
             dfsrow(step+1);

             if(flag1)
                 return;
             bkrow[j]=0;
         }
     }
 }

 void dfscol(int step){
     if(step == n+1){
         flag2=1;
         return;
     }

     int j;
     for(j=rec[step].yl;j<=rec[step].yr;j++){
         if(bkcol[j] == 0){
             bkcol[j]=1;
             col[step]=j;
             dfscol(step+1);

             if(flag2)
                 return;
             bkcol[j]=0;
         }
     }
 }*/

　　解决这道题的过程还是一波三折的，搜索超时，贪心苦思冥想，最后还栽在了初始化函数memset上，可以看到平时大家使用初始化函数初始化数组时都这样写

1.memset(ans,-1,sizeof(int)*n);

2.memset(ans,-1,sizeof(ans));

意即将ans数组中的内存单元全部初始化为-1，其实只有第一种写法是正确的，这里错误的原因是VC函数传参过程中的指针降级，导致sizeof(a)，返回的是一个something*指针类型大小的的字节数，如果是32位，就是4字节。（详见百度百科https://baike.baidu.com/item/memset/4747579?fr=aladdin#reference-[1]-982208-wrap）

而第二种用法可以出现在初始化结构体中。