hihoCoder#1119 小Hi小Ho的惊天大作战：扫雷·二

原题地址

没有复杂算法，就是麻烦，写起来细节比较多，比较考验细心，一次AC好开心。

代码：

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

 using namespace std;

 #define SIZE 400

 int N, M;
 int map[SIZE][SIZE];
 int res[SIZE][SIZE];

 vector<pair<int, int> > unknown_neighbors(int i, int j) {
   vector<pair<int, int> > nbs;

   for (int ii = -; ii < ; ii++)
     for (int jj = -; jj < ; jj++) {
       int r = ii + i;
       int c = jj + j;
       if (r >=  && r < N && c >=  && c < M && (r != i || c != j) && map[r][c] < )
         nbs.push_back(pair<int, int>(r, c));
     }

   return nbs;
 }

 vector<pair<int, int> > known_counterparts(int i, int j) {
   vector<pair<int, int> > cps;

   for (int ii = -; ii < ; ii++) {
     for (int jj = -; jj < ; jj++) {
       int r = ii + i;
       int c = jj + j;
       if (r >=  && r < N && c >=  && c < M && (r != i || c != j) && map[r][c] >= )
         cps.push_back(pair<int, int>(r, c));
     }
   }

   return cps;
 }

 vector<pair<int, int> > differ(vector<pair<int, int> > &a, vector<pair<int, int> > &b) {
   vector<pair<int, int> > diff;
   int count = ;

   for (auto pa : a) {
     bool found = false;
     for (auto pb : b) {
       if (pb == pa) {
         found = true;
         count++;
         break;
       }
     }
     if (!found)
       diff.push_back(pa);
   }

   if (count < b.size())
     diff.clear();

   return diff;
 }

 void merge_pos(int i, int j, int v) {
   if (res[i][j] == - || res[i][j] == v)
     res[i][j] = v;
   else
     res[i][j] = -;
 }

 void solve() {
   for (int i = ; i < N; i++)
     for (int j = ; j < M; j++) {
       if (map[i][j] == ) {
         vector<pair<int, int> > nbs = unknown_neighbors(i, j);
         for (auto p : nbs)
           merge_pos(p.first, p.second, );
       }
       else if (map[i][j] > ) {
         vector<pair<int, int> > nbs = unknown_neighbors(i, j);
         if (nbs.size() == map[i][j]) {
           for (auto p : nbs)
             merge_pos(p.first, p.second, );
           continue;
         }

         vector<pair<int, int> > cps = known_counterparts(i, j);
         for (auto p : cps) {
           vector<pair<int, int> > cp_nbs = unknown_neighbors(p.first, p.second);
           if (nbs.size() <= cp_nbs.size() || map[i][j] <= map[p.first][p.second])
             continue;
           vector<pair<int, int> > diff = differ(nbs, cp_nbs);
           if ((int) (nbs.size() - cp_nbs.size()) == map[i][j] - map[p.first][p.second] && !diff.empty())
             for (auto dp : diff)
               merge_pos(dp.first, dp.second, );
         }
       }
     }
 }

 int main() {
   int n;

   cin >> n;
   while (n--) {
     cin >> N >> M;
     for (int i = ; i < N; i++)
       for (int j = ; j < M; j++)
         cin >> map[i][j];
     memset(res, -, SIZE * SIZE * sizeof(int));

     solve();

     int mine = ;
     int not_mine = ;

     for (int i = ; i < N; i++)
       for (int j = ; j < M; j++) {
         mine += (res[i][j] ==  ?  : );
         not_mine += (res[i][j] ==  ?  : );
       }

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

   return ;
 }