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 >= 0 && p.r < N && p.c >= 0 && p.c < M;
}

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

  for (int i = -1; i < 2; i++) {
    for (int j = -1; j < 2; 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] == -1 || ans[p.r][p.c] == p.v)
    ans[p.r][p.c] = p.v;
  else
    ans[p.r][p.c] = -2;
}

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

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

  return res;
}

bool check(point p) {
  vector<point> nbs = neighbors(p);
  int mine = around(p, 1);
  int not_mine = around(p, 0);
  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] >= 0 && !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] < 0)
          continue;

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

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

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

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

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

int main() {
  int n;

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

    solve(0);

    int mine = 0;
    int not_mine = 0;

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

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

  }

  return 0;
}