【HDOJ】3832 Earth Hour

其实就是bfs，不过也可以写成最短路，因为权重为1，可以用Spira解。

 /* 3832 */
 #include <iostream>
 #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 = ;
 const int maxe = maxn*maxn*;
 const int INF = 1e7;
 int X[maxn], Y[maxn], R[maxn];
 int dis[maxn], D[][maxn];
 bool inS[maxn];
 int V[maxe], nxt[maxe];
 int head[maxn], head_[maxn], n, m;

 void addEdge(int u, int v) {
     V[m] = v;
     nxt[m] = head[u];
     head[u] = m++;

     V[m] = u;
     nxt[m] = head[v];
     head[v] = m++;
 }

 typedef struct node_t {
     int u, v, w;

     node_t() {}

     node_t(int u_, int v_, int w_):
         u(u_), v(v_), w(w_) {}

     friend bool operator< (const node_t& a, const node_t& b) {
         return a.w > b.w;
     }
 } node_t;

 void forward(priority_queue<node_t>& Q, int u) {
     int& k = head_[u];

     if (k != -) {
         Q.push(node_t(u, V[k], dis[u]+));
         k = nxt[k];
     }
 }

 void Spira(int s) {
     priority_queue<node_t> Q;
     node_t nd;
     int cnt = ;

     memset(inS, false, sizeof(inS));
     rep(i, , n+)    dis[i] = INF;
     dis[s] = ;
     inS[s] = true;
     forward(Q, s);

     while (!Q.empty()) {
         nd = Q.top();
         Q.pop();
         forward(Q, nd.u);
         if (!inS[nd.v]) {
             inS[nd.v] = true;
             dis[nd.v] = nd.w;
             if (++cnt == n)
                 break;
             forward(Q, nd.v);
         }
     }
 }

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

     int t;
     int mn, ans;

     scanf("%d", &t);
     while (t--) {
         scanf("%d", &n);
         rep(i, , n+)
             scanf("%d %d %d", &X[i], &Y[i], &R[i]);
         memset(head, -, sizeof(head));
         m = ;
         rep(i, , n+) {
             rep(j, , i) {
                 if ((X[i]-X[j])*(X[i]-X[j])+(Y[i]-Y[j])*(Y[i]-Y[j]) <= (R[i]+R[j])*(R[i]+R[j])) {
                     addEdge(i, j);
                 }
             }
         }

         memcpy(head_, head, sizeof(head));
         Spira();
         memcpy(D[], dis, sizeof(dis));

         memcpy(head_, head, sizeof(head));
         Spira();
         memcpy(D[], dis, sizeof(dis));

         memcpy(head_, head, sizeof(head));
         Spira();
         memcpy(D[], dis, sizeof(dis));

         mn = INF;
         rep(i, , n+)
             mn = min(mn, D[][i]+D[][i]+D[][i]);

         ans = (mn==INF) ? -:n-mn-;
         printf("%d\n", ans);
     }

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

     return ;
 }