【HDOJ】4775 Infinite Go

其实是一道模拟题，并查集用来优化。还可以的一道题目。

 /* 4775 */
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <vector>
 #include <deque>
 #include <algorithm>
 #include <cstdio>
 #include <cmath>
 #include <ctime>
 #include <cstring>
 #include <climits>
 #include <cctype>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <iomanip>
 using namespace std;
 //#pragma comment(linker,"/STACK:102400000,1024000")

 #define sti                set<int>
 #define stpii            set<pair<int, int> >
 #define mpii            map<int,int>
 #define vi                vector<int>
 #define pii                pair<int,int>
 #define vpii            vector<pair<int,int> >
 #define rep(i, a, n)     for (int i=a;i<n;++i)
 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 #define clr                clear
 #define pb                 push_back
 #define mp                 make_pair
 #define fir                first
 #define sec                second
 #define all(x)             (x).begin(),(x).end()
 #define SZ(x)             ((int)(x).size())
 #define lson            l, mid, rt<<1
 #define rson            mid+1, r, rt<<1|1

 const int maxn = ;
 map<pii, int> id;
 map<pii, bool> visit;
 map<pii, int>::iterator iter;
 int X[maxn], Y[maxn];
 int sz[maxn], fa[maxn];
 int dir[][] = {
     -,, ,, ,-, ,
 };
 int n;

 int find(int x) {
     if (x == fa[x])
         return x;

     return fa[x] = find(fa[x]);
 }

 bool judge(int x, int y) {
     return x<= || y<=;
 }

 void remove(int bx, int by, int uid) {
     queue<pii> Q;
     int x, y;
     pii p(bx, by), pp;

     visit.clr();
     Q.push(p);
     visit[p] = true;

     while (!Q.empty()) {
         p = Q.front();
         Q.pop();

         // remove from the id
         iter = id.find(p);
         fa[iter->sec] = iter->sec;
         sz[iter->sec] = ;
         id.erase(iter);

         rep(j, , ) {
             x = p.fir + dir[j][];
             y = p.sec + dir[j][];
             if (judge(x, y))
                 continue;

             pp.fir = x;
             pp.sec = y;
             if (visit[pp])
                 continue;

             iter = id.find(pp);
             if (iter == id.end())
                 continue;

             if ((iter->sec&) ^ uid) {
                 int f = find(iter->sec);
                 ++sz[f];
             } else {
                 visit[pp] = true;
                 Q.push(pp);
             }
         }
     }
 }

 void solve() {
     rep(i, , n+)
         fa[i] = i;
     memset(sz, , sizeof(sz));
     id.clr();

     int vac, x, y;
     int xx, yy;
     pii p;

     rep(i, , n+) {
         p.fir = x = X[i];
         p.sec = y = Y[i];
         id[p] = i;
         vac = ;
         rep(j, , ) {
             xx = x + dir[j][];
             yy = y + dir[j][];
             if (judge(xx, yy))
                 continue;

             iter = id.find(mp(xx, yy));
             if (iter == id.end()) {
                 ++vac;
             } else {
                 int f = find(iter->sec);
                 --sz[f];
             }
         }
         sz[i] = vac;
         rep(j, , ) {
             xx = x + dir[j][];
             yy = y + dir[j][];
             if (judge(xx, yy))
                 continue;

             iter = id.find(mp(xx, yy));
             if (iter == id.end())
                 continue;

             if ((iter->sec & ) ^ (i & )) {
                 // delete enemy
                 int fx = find(iter->sec);
                 if (sz[fx] == ) {
                     remove(xx, yy, iter->sec&);
                 }

             } else {
                 // link self
                 int fx = find(iter->sec);
                 int fy = find(i);
                 if (fx != fy) {
                     fa[fx] = fy;
                     sz[fy] += sz[fx];
                 }
             }
         }

         int f = find(i);
         if (sz[f] == ) {
             remove(x, y, i&);
         }
     }

     int ansa, ansb;

     ansa = ansb = ;
     visit.clr();
     per(i, , n+) {
         p.fir = X[i];
         p.sec = Y[i];
         iter = id.find(p);
         if (iter==id.end() || visit[p])
             continue;

         visit[p] = true;
         if (iter->sec & )
             ++ansa;
         else
             ++ansb;
     }

     printf("%d %d\n", ansa, ansb);
 }

 int main() {
     ios::sync_with_stdio(false);
     #ifndef ONLINE_JUDGE
         freopen("data.in", "r", stdin);
         freopen("data.out", "w", stdout);
     #endif

     int t;

     scanf("%d", &t);
     while (t--) {
         scanf("%d", &n);
         rep(i, , n+)
             scanf("%d %d", &X[i], &Y[i]);
         solve();
     }

     #ifndef ONLINE_JUDGE
         printf("time = %d.\n", (int)clock());
     #endif

     return ;
 }

数据发生器。

 from random import randint, shuffle
 import shutil
 import string

 def GenDataIn():
     with open("data.in", "w") as fout:
         t = 10
         fout.write("%d\n" % t)
         bound = 10**2
         for tt in xrange(t):
             n = randint(1000, 5000)
             fout.write("%d\n" % n)
             d = dict()
             for i in xrange(n):
                 while True:
                     x = randint(1, bound)
                     y = randint(1, bound)
                     tpl = (x, y)
                     if tpl not in d:
                         d[tpl] = True
                         break
                 fout.write("%d %d\n" % (x, y))

 def MovDataIn():
     desFileName = "F:\eclipse_prj\workspace\hdoj\data.in"
     shutil.copyfile("data.in", desFileName)

 if __name__ == "__main__":
     GenDataIn()
     MovDataIn()