hihoCoder#1120 小Hi小Ho的惊天大作战：扫雷·三

原题地址

看上去非常复杂， 实际上是这一系列最简单的一步，本质上是个搜索过程，相比于前一道题，可以不用策略三，而且题目的数据规模超级小，所以暴力搜索就能过。

把尚未确定的点放在一个unsettled列表里，然后依次枚举每个点的情况：是地雷or不是地雷

优化方案一即：每次枚举后，使用规则一、规则二对列表里剩下的点进行判断，如果能直接判断出是不是地雷的就立即设置了，这样剩下的枚举位就少了。当然回溯的时候记得把这些拓展出来的也要一并回溯。

优化方案二即：周围已知地雷数少的点优先枚举。（这个优化没做）

啰啰嗦嗦写了一大堆代码，WA了一次，原来是判断规则一规则二的时候单纯用8去做判断了，而一个点周围邻居点个数可能不是8。

代码：

 #include <iostream>
 #include <vector>
 #include <cstring>
 #include <cstdlib>

 using namespace std;

 struct point {
   int r;
   int c;
   int v;
   point(int _r, int _c) : r(_r), c(_c) {};
   point(int _r, int _c, int _v) : r(_r), c(_c), v(_v) {};
   bool operator==(const point &o) {return o.r == r && o.c == c;}
   bool operator!=(const point &o) {return o.r != r || o.c != c;}
 };

 #define SIZE 40

 int N, M;
 int field[SIZE][SIZE];
 int ans[SIZE][SIZE];
 int unset[SIZE][SIZE];
 vector<point> unsettled;

 bool valid(point &p) {
   return p.r >=  && p.r < N && p.c >=  && p.c < M;
 }

 vector<point> neighbors(point p) {
   vector<point> res;

   for (int i = -; i < ; i++) {
     for (int j = -; j < ; j++) {
       point q(i + p.r, j + p.c);
       if (valid(q) && q != p)
         res.push_back(q);
     }
   }

   return res;
 }

 void merge(point p) {
   if (ans[p.r][p.c] == - || ans[p.r][p.c] == p.v)
     ans[p.r][p.c] = p.v;
   else
     ans[p.r][p.c] = -;
 }

 int around(point p, int s) {
   vector<point> nbs = neighbors(p);
   int res = ;

   for (auto q : nbs) {
     if (field[q.r][q.c] >=  && s == ) {
       res++;
       continue;
     }
     else
       res += unset[q.r][q.c] == s ?  : ;
   }

   return res;
 }

 bool check(point p) {
   vector<point> nbs = neighbors(p);
   int mine = around(p, );
   int not_mine = around(p, );
   return (mine <= field[p.r][p.c] && field[p.r][p.c] + not_mine <= nbs.size());
 }

 bool check() {
   bool is_ok = true;

   for (auto p : unsettled) {
     if (!is_ok)
       break;
     vector<point> nbs = neighbors(p);
     for (auto q : nbs) {
       if (field[q.r][q.c] >=  && !check(q)) {
         is_ok = false;
         break;
       }
     }
   }

   return is_ok;
 }

 void extend() {
   bool over = false;

   while (!over) {
     over = true;
     for (auto p : unsettled) {
       vector<point> nbs = neighbors(p);
       for (auto q : nbs) {
         if (field[q.r][q.c] < )
           continue;

         vector<point> os = neighbors(q);
         int mine = around(p, );
         int not_mine = around(q, );

         if (field[q.r][q.c] + not_mine == os.size()) {
           for (auto o : os) {
             if (o.v == -) {
               over = false;
               o.v = ;
               unset[o.r][o.c] = ;
             }
           }
         }
         if (mine == field[q.r][q.c]) {
           for (auto o : os) {
             if (o.v == -) {
               over = false;
               o.v = ;
               unset[o.r][o.c] = ;
             }
           }
         }
       }
     }
   }
 }

 void solve(int pos) {
   if (pos >= unsettled.size()) {
     for (auto p : unsettled) {
       merge(p);
     }
     return;
   }

   if (unsettled[pos].v != -) {
     solve(pos + );
     unsettled[pos].v = -;
     unset[unsettled[pos].r][unsettled[pos].c] = -;
     return;
   }

   for (int i = ; i < ; i++) {
     unsettled[pos].v = i;
     unset[unsettled[pos].r][unsettled[pos].c] = i;
     if (!check())
       continue;
     extend();
     solve(pos + );
   }
   unsettled[pos].v = -;
   unset[unsettled[pos].r][unsettled[pos].c] = -;
 }

 int main() {
   int n;

   cin >> n;
   while (n--) {
     cin >> N >> M;
     memset(ans, -, SIZE * SIZE * sizeof(int));
     memset(unset, -, SIZE * SIZE * sizeof(int));
     unsettled.clear();
     for (int i = ; i < N; i++) {
       for (int j = ; j < M; j++) {
         cin >> field[i][j];
         if (field[i][j] < )
           unsettled.push_back(point(i, j, -));
       }
     }

     solve();

     int mine = ;
     int not_mine = ;

     for (auto p : unsettled) {
       mine += (ans[p.r][p.c] ==  ?  : );
       not_mine += (ans[p.r][p.c] ==  ?  : );
     }

     cout << mine << " " << not_mine << endl;

   }

   return ;
 }