code

#include <cstdio>
 #include <algorithm>
 #include <cstring>
 //#include<bits/stdc++.h>
 inline void read(int &x) {
     x = 0;
     char c = getchar();
     while(c < '0' || c > '9') {
         c = getchar();
     }
     while(c >= '0' && c <= '9') {
         x = (x << 3) + (x << 1) + c - 48;
         c = getchar();
     }
     return;
 }
 
 const int N = 100010;
 const int dx[4] = {0, 1, 0, -1};
 const int dy[4] = {1, 0, -1, 0};
 
 const int MO = 19260817, B = 998244353;
 struct POS {
     int x, y, h;
     POS(int xx = 0, int yy = 0) {
         x = xx;
         y = yy;
         h = (1ll * x * B + y) % MO;
         if(h < 0) {
             h += MO;
         }
     }
     inline bool operator ==(const POS &d) const {
         return x == d.x && y == d.y;
     }
 };
 struct Node {
     int nex, val;
     POS p;
 }node[N * 30]; int top;
 struct MAP {
     int e[MO];
     inline void insert(const POS &d, const int &a) {
         node[++top].val = a;
         node[top].nex = e[d.h];
         node[top].p = d;
         e[d.h] = top;
         return;
     }
     inline int find(const POS &d) { 
         for(int i = e[d.h]; i; i = node[i].nex) {
             if(node[i].p == d) {
                 return node[i].val;
             }
         }
         return 0;
     }
     inline void clear() {
         memset(e, 0, sizeof(e));
         return;
     }
 }mp, use;
 
 int n, m, c, xi[N], yi[N], tot, num, root;
 int dfn[N * 25], low[N * 25], vis[N * 25];
 bool cut[N * 25], vis_c[N], OK;
 
 inline void np(int x, int y) {
     if(!mp.find(POS(x, y)) && !use.find(POS(x, y))) {
         mp.insert(POS(x, y), ++tot);
     }
     return;
 }
 
 inline int get(int x, int y) {
     return mp.find(POS(x, y));
 }
 
 void tarjan(int s, int x, int y) {
     dfn[s] = low[s] = ++num;
     int temp = 0;
     for(int i = 0; i < 4; i++) {
         int t = get(x + dx[i], y + dy[i]);
         if(!t) {
             continue;
         }
         if(!dfn[t]) {
             tarjan(t, x + dx[i], y + dy[i]);
             low[s] = std::min(low[s], low[t]);
             if(low[t] >= dfn[s]) {
                 temp++;
             }
         }
         else {
             low[s] = std::min(low[s], dfn[t]);
         }
     }
     if(temp >= 2 || (temp == 1 && s != root)) {
         cut[s] = 1;
     }
     return;
 }
 
 void DFS_1(int s, int x, int y, int temp) {
     vis[s] = temp;
     for(int i = 0;i < 4; i++) {
         int t = get(x + dx[i], y + dy[i]);
         if(!t) {
             continue;
         }
         if(!vis[t]) {
             DFS_1(t, x + dx[i], y + dy[i], temp);
         }
     }
     return;
 }
 
 bool fd;
 int number;
 
 bool DFS_2(int s, int x, int y) {
     vis_c[s] = 1;
     for(int i = 0; i < 4; i++) {
         if(use.find(POS(x + dx[i], y + dy[i]))) {
             int ed = use.find(POS(x + dx[i], y + dy[i]));
             if(vis_c[ed]) {
                 continue;
             }
             int t = DFS_2(ed, x + dx[i], y + dy[i]);
             if(!t) {
                 return 0;
             }
         }
         else if(get(x + dx[i], y + dy[i])) {
             if(!fd) {
                 number = vis[get(x + dx[i], y + dy[i])];
                 fd = 1;
             }
             else if(number != vis[get(x + dx[i], y + dy[i])]) {
                 OK = 0;
                 return 0;
             }
         }
     }
     return 1;
 }
 
 inline bool check() {
     OK = 1;
     int temp = 0;
     for(int i = 1; i <= c; i++) {
         for(int x = xi[i] - 2; x <= xi[i] + 2; x++) {
             for(int y = yi[i] - 2; y <= yi[i] + 2; y++) {
                 if(vis_c[i]) {
                     continue;
                 }
                 if(mp.find(POS(x, y)) && !vis[get(x, y)]) {
                     ++temp;
                     DFS_1(get(x, y), x, y, temp);
                     goto f1;
                 }
             }
         }
         f1:
         if(!vis_c[i]) {
             fd = 0;
             DFS_2(i, xi[i], yi[i]);
         }
         if(!OK) {
             break;
         }
     }
     return !OK;
 }
 
 inline int solve() {
     read(n);
     read(m);
     read(c);
     if(!c) {
         if(n == 1 && m == 1) {
             return -1;
         }
         if(n == 1 || m == 1) {
             if(n == 2 || m == 2) {
                 return -1;
             }
             return 1;
         }
         return 2;
     }
     for(int i = 1; i <= c; i++) {
         read(xi[i]);
         read(yi[i]);
         use.insert(POS(xi[i], yi[i]), i);
     }
     if(c + 1 >= 1ll * n * m) {
         return -1;
     }
     for(int i = 1; i <= c; i++) {
         for(int x = xi[i] - 2; x <= xi[i] + 2; x++) {
             for(int y = yi[i] - 2; y <= yi[i] + 2; y++) {
                 if(x > 0 && y > 0 && x <= n && y <= m && (x != xi[i] || y != yi[i])) {
                     np(x, y);
                 }
             }
         }
     }
     if(check()) {
         return 0;
     }
     if(c + 2 == 1ll * n * m) {
         return -1;
     }
     if(m == 1 || n == 1) {
         return 1;
     }
     for(int i = 1; i <= c; i++) {
         for(int x = xi[i] - 2; x <= xi[i] + 2; x++) {
             for(int y = yi[i] - 2; y <= yi[i] + 2; y++) {
                 if(!use.find(POS(x, y))) {
                     root = get(x, y);
                     if(dfn[root]) {
                         continue;
                     }
                     tarjan(root, x, y);
                 }
             }
         }
     }
 
     for(int i = 1; i <= c; i++) {
         for(int x = xi[i] - 1; x <= xi[i] + 1; x++) {
             for(int y = yi[i] - 1; y <= yi[i] + 1; y++) {
                 int s = get(x, y);
                 if(cut[s]) {
                     return 1;
                 }
             }
         }
     }
     return 2;
 }
 
 inline void clear() {
     mp.clear();
     use.clear();
     memset(dfn + 1, 0, tot * sizeof(int));
     memset(low + 1, 0, tot * sizeof(int));
     memset(cut + 1, 0, tot * sizeof(bool));
     memset(vis + 1, 0, tot * sizeof(int));
     memset(vis_c + 1, 0, c * sizeof(bool));
     tot = 0;
     num = 0;
     top = 0;
     return;
 }
 signed main() {
     int T;
     read(T);
     while(T--) {
         printf("%d\n", solve());
         if(T) {
             clear();
         }
     }
     return 0;
 }

认真看，可以发现我和题解不一样！！
记录