【AHOI2013复仇】从一道题来看DFS及其优化的一般步骤和数组分层问题

RQNOJ187 巧置挡板
———————————————————————————————————————————————————
【背景（神犇不要囧视，3x）】
本沙茶最近开始猛攻搜索、近似、随机等算法，目标是A掉AHOI2012的后3题（在哪跌倒就从哪爬起）。昨天晚上找到这题，发现是搜索，于是开始捉……结果被折腾了一晚上加一上午才A掉，不过，看在这题可以系统性的反映DFS优化的一般步骤，忍了……另外，这题是本沙茶在RQNOJ上通过的第400题……回想起通过第300题的时候已经是近三年半之前了……真颓废啊……
———————————————————————————————————————————————————
普通DFS（不加迭代）的优化方法主要有：
（1）可行性剪枝，如果遇到已经无法产生可行解的情况就剪枝，有时候，可行性剪枝也可以指在搜索过程中对不合法情况的剔除；
（2）最优性剪枝：如果遇到已经无法产生比目前得到的最优解还要优的解的情况就剪枝，这其中包括启发式最优性剪枝（即分支限界），对目前解的进展情况作乐观估计，如果估计值都不能超越目前的最优解，则剪枝；
（3）通过改变搜索顺序，尽早得出较优解，从而为后面的剪枝提供余地；
（4）通过预处理等手段，提前得到启发值或者较优解，为后面的剪枝提供余地；

一般步骤：
（1）预处理，当然是写在最前面，在搜索前得到启发值等东东；
（2）搜索过程中，先写最优性剪枝（包括已经到达搜索终点了，也应该判断一下，提前排除不是最优解的情况）；
（3）再判定搜索终点，如果到了，也不要马上更新解，而是要判定这个解是否符合要求，再更新；
（4）若未到终点，再写可行性剪枝；
（5）最后写搜索过程，包括需要改变搜索顺序的情况。

注意事项： 数组的分层问题。
这是一个很严重的问题，因为分层出错很可能会导致一些很怪的错误出现，难以发现。在 搜索题的调试技巧这一篇中，已经提到了这个问题，本题又涉及到了。
一般来说，搜索过程中使用的数组（包括变量，可以视为零维数组）可以分为以下三类：
（1）在搜索过程中，只会引用其值，不会修改的数组（比如预处理中得到的那些东东），相当于常量；
（2）在搜索过程中，会改变其值，但在搜索完毕后能改回原值的数组；
（3）在搜索过程中，会改变其值，且在搜索完毕后也改不回原值的数组。
对于（1）（2）类数组，不需分层，但对于第（3）类数组一定要分层。这是因为这些数组在多层搜索中都需要修改，而且搜索完了也改不回来，如果不分层，则当后面的搜索完毕以后，要继续搜索前面的，引用的将是后面的值，就会出错。
对于第（3）类数组，有的已经“自然分层”（每层搜索修改的元素都不一样），比如本题代码中的R[][]、C[][]。然而有的并没有自然分层，比如本题的len、pos[]、tmp[]等，因此对于这些数组，需要再加一维，对于不同层使用该维不同的元素即可。

下面是本题的算法：
使用DFS搜索每个位置的挡板是否需要放。搜索时，先搜竖的再搜横的，由于题目要求每个连通块都必须是矩形，因此对于竖的，如果该位置的上方两个相邻位置的横的没有全放（包括只放了一个），则该位置的竖的放不放取决于其上一行对应位置的竖的有没有放（第一行除外），如果两个横的都放了，则这里的竖的既可以放也可以不放（先搜不放的情况）。当然，一行的两个1之间必须至少有一个竖的，这是可行性限制。在搜横的的时候，按照该行所放的竖的，分成若干段，显然每一段要么下面都用横的封上，要么一个都不封上。其中，如果该段所在的连通块里面有1，且下一行对应位置也有1，则必须封上；若该段所在连通块里面没有1，则不能封上（因为不能有一个连通块里一个1都没有），否则可以自由选择封还是不封（当然也是先搜不封的）。这样一直搜到最后一行的竖的后，还要判断最后一行有没有连通块里没1，若没有，则为一个可行解。启发式优化：设D[i]为第i行及以后至少要几个挡板（若某行有K个1，则至少需要(K-1)个竖的；若某列有K个1，则至少需要(K-1)个横的，累加起来即可，显然这是乐观估计），D[i]可以预处理出来，当做启发值。

代码：

#include  < iostream >
#include  < stdio.h >
#include  < stdlib.h >
#include  < string .h >
using   namespace  std;
#define  re(i, n) for (int i=0; i<n; i++)
#define  re1(i, n) for (int i=1; i<=n; i++)
#define  re2(i, l, r) for (int i=l; i<r; i++)
#define  re3(i, l, r) for (int i=l; i<=r; i++)
#define  rre(i, n) for (int i=n-1; i>=0; i--)
#define  rre1(i, n) for (int i=n; i>0; i--)
#define  rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define  rre3(i, r, l) for (int i=r; i>=l; i--)
const   int  MAXN  =   35 , INF  =   ~ 0U   >>   2 ;
int  n, m, D[MAXN], len[MAXN], pos[MAXN][MAXN], tmp[MAXN][MAXN], res  =  INF;
bool  A[MAXN][MAXN], C[MAXN][MAXN], R[MAXN][MAXN], S[MAXN][MAXN][MAXN][MAXN];
void  dfs0( int  No,  int  v,  int  sum,  bool  FF);
void  init()
{
    scanf( " %d%d " ,  & n,  & m);  int  x;
    re(i, n) re(j, m) {scanf( " %d " ,  & x); A[i][j]  =  x;}
}
void  prepare()
{
    re(i, n) re(j, m) {
        S[i][j][i][j]  =  A[i][j];
        re2(k, i + 1 , n) S[i][j][k][j]  =  A[k][j]  ||  S[i][j][k  -   1 ][j];
        re2(k, j + 1 , m) S[i][j][i][k]  =  A[i][k]  ||  S[i][j][i][k  -   1 ];
        re2(k, i + 1 , n) re2(k0, j + 1 , m) S[i][j][k][k0]  =  A[k][k0]  ||  S[i][j][k  -   1 ][k0]  ||  S[i][j][k][k0  -   1 ];
    }
     int  sum;
    re(i, n) {
        D[i]  =   0 ;
        re2(j, i, n) {sum  =   0 ; re(k, m)  if  (A[j][k]) sum ++ ;  if  (sum) D[i]  +=  sum  -   1 ;}
        re(k, m) {sum  =   0 ; re2(j, i, n)  if  (A[j][k]) sum ++ ;  if  (sum) D[i]  +=  sum  -   1 ;}
    }
}
void  dfs1( int  No,  int  v,  int  sum)
{
     if  (sum  +  D[No  +   1 ]  >=  res)  return ;
     if  (v  ==  len[No]  +   1 ) dfs0(No  +   1 ,  0 , sum,  1 );  else   if  (tmp[No][v]  !=   1 ) dfs1(No, v  +   1 , sum);  else  {
         int  l, r, sum0  =  sum;
         if  (v) l  =  pos[No][v  -   1 ]  +   1 ;  else  l  =   0 ;
         if  (v  ==  len[No]) r  =  m  -   1 ;  else  r  =  pos[No][v];
        re3(j, l, r) R[No][j]  =   0 ; dfs1(No, v  +   1 , sum);
        re3(j, l, r) {R[No][j]  =   1 ; sum0 ++ ;} dfs1(No, v  +   1 , sum0);
    }
}
void  dfs0( int  No,  int  v,  int  sum,  bool  FF)
{
     if  (sum  +  D[No  +   1 ]  >=  res)  return ;
     bool  FF0;  if  (A[No][v]) { if  ( ! FF)  return ;  else  FF0  =   0 ;}  else  FF0  =  FF;
     if  (v  ==  m  -   1 ) {
         if  (No  ==  n  -   1 ) {
            len[No]  =   0 ; re(i, m - 1 )  if  (C[No][i]) pos[No][len[No] ++ ]  =  i;
             int  l, r, x;  bool  FFF  =   1 ;
            re3(i,  0 , len[No]) {
                 if  (i) l  =  pos[No][i  -   1 ]  +   1 ;  else  l  =   0 ;
                 if  (i  ==  len[No]) r  =  m  -   1 ;  else  r  =  pos[No][i];
                x  =   0 ; rre(j, No)  if  (R[j][l]) {x  =  j  +   1 ;  break ;}
                 if  ( ! S[x][l][No][r]) {FFF  =   0 ;  break ;}
            }
             if  (FFF) res  =  sum;
             return ;
        }
        len[No]  =   0 ; re(i, m - 1 )  if  (C[No][i]) pos[No][len[No] ++ ]  =  i;
         int  l, r, x, sum0  =  sum;
        re3(i,  0 , len[No]) {
             if  (i) l  =  pos[No][i  -   1 ]  +   1 ;  else  l  =   0 ;
             if  (i  ==  len[No]) r  =  m  -   1 ;  else  r  =  pos[No][i];
            x  =   0 ; rre(j, No)  if  (R[j][l]) {x  =  j  +   1 ;  break ;}
             if  (S[x][l][No][r]  &&  S[No  +   1 ][l][No  +   1 ][r]) {
                tmp[No][i]  =   2 ; re3(j, l, r) {sum0 ++ ; R[No][j]  =   1 ;}
            }  else   if  (S[x][l][No][r]) {
                tmp[No][i]  =   1 ; re3(j, l, r) R[No][j]  =   0 ;
            }  else  {
                tmp[No][i]  =   0 ; re3(j, l, r) R[No][j]  =   0 ;
            }
        }
        dfs1(No,  0 , sum0);
    }  else   if  (No  &&  ( ! R[No  -   1 ][v]  ||   ! R[No  -   1 ][v  +   1 ])) {
         if  (C[No  -   1 ][v]) {C[No][v]  =   1 ; dfs0(No, v  +   1 , sum  +   1 ,  1 );}  else  {C[No][v]  =   0 ; dfs0(No, v  +   1 , sum, FF0);}
    }  else  {
        C[No][v]  =   0 ; dfs0(No, v  +   1 , sum, FF0);
        C[No][v]  =   1 ; dfs0(No, v  +   1 , sum  +   1 ,  1 );
    }
}
void  pri()
{
    printf( " %d\n " , res);
}
int  main()
{
    init();
    prepare();
    dfs0( 0 ,  0 ,  0 ,  1 );
    pri();
     return   0 ;
}