【HDOJ】4400 Mines

  1 /* 4400 */
  2 #include <iostream>
  3 #include <string>
  4 #include <map>
  5 #include <queue>
  6 #include <set>
  7 #include <stack>
  8 #include <vector>
  9 #include <deque>
 10 #include <algorithm>
 11 #include <cstdio>
 12 #include <cmath>
 13 #include <ctime>
 14 #include <cstring>
 15 #include <climits>
 16 #include <cctype>
 17 #include <cassert>
 18 #include <functional>
 19 #include <iterator>
 20 #include <iomanip>
 21 using namespace std;
 22 //#pragma comment(linker,"/STACK:102400000,1024000")
 23 
 24 #define sti                set<int>
 25 #define stpii            set<pair<int, int> >
 26 #define mpii            map<int,int>
 27 #define vi                vector<int>
 28 #define pii                pair<int,int>
 29 #define vpii            vector<pair<int,int> >
 30 #define rep(i, a, n)     for (int i=a;i<n;++i)
 31 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 32 #define clr                clear
 33 #define pb                 push_back
 34 #define mp                 make_pair
 35 #define fir                first
 36 #define sec                second
 37 #define all(x)             (x).begin(),(x).end()
 38 #define SZ(x)             ((int)(x).size())
 39 #define lson            l, mid, rt<<1
 40 #define rson            mid+1, r, rt<<1|1
 41 
 42 typedef struct Point_t {
 43     int x, y, d, id;
 44 
 45     Point_t() {}
 46     Point_t(int x, int y, int d, int id):
 47         x(x), y(y), d(d), id(id) {}
 48 
 49 } Point_t;
 50 
 51 typedef struct node_t{
 52     int axis;
 53     int id;
 54     int l, r;
 55 } node_t;
 56 
 57 const int maxn = 1e5+5;
 58 Point_t P[maxn];
 59 node_t nd[maxn];
 60 bool visit[maxn];
 61 int Q[maxn];
 62 int L, head, tail;
 63 
 64 bool compx(const Point_t& a, const Point_t& b) {
 65     return a.x < b.x;
 66 }
 67 
 68 bool compy(const Point_t& a, const Point_t& b) {
 69     return a.y < b.y;
 70 }
 71 
 72 bool compid(const Point_t& a, const Point_t& b) {
 73     return a.id < b.id;
 74 }
 75 
 76 int newNode() {
 77     ++L;
 78     nd[L].l = nd[L].r = 0;
 79 
 80     return L;
 81 }
 82 
 83 int create(int l, int r, int d) {
 84     if (l > r)    return 0;
 85 
 86     int rt = newNode();
 87     nd[rt].axis = d & 1;
 88     if (l == r) {
 89         nd[rt].id = P[l].id;
 90         return rt;
 91     }
 92 
 93     if (d & 1) {
 94         sort(P+l, P+r+1, compy);
 95     } else {
 96         sort(P+l, P+r+1, compx);
 97     }
 98 
 99     int mid = (l + r) >> 1;
100 
101     nd[rt].id = P[mid].id;
102     nd[rt].l = create(l, mid-1, d+1);
103     nd[rt].r = create(mid+1, r, d+1);
104 
105     return rt;
106 }
107 
108 int Distance(int i, int j) {
109     return abs(P[i].x-P[j].x) + abs(P[i].y-P[j].y);
110 }
111 
112 void search(int rt, int kth) {
113     if (rt == 0)
114         return ;
115 
116     int i, j, k;
117     int id = nd[rt].id;
118     int dis = Distance(id, kth);
119 
120     if (dis <= P[kth].d) {
121         if (!visit[id]) {
122             visit[id] = true;
123             Q[tail++] = id;
124         }
125     }
126 
127     if (nd[rt].axis) {
128         // y
129         if (dis <= P[kth].d) {
130             search(nd[rt].l, kth);
131             search(nd[rt].r, kth);
132         } else {
133             int dy = abs(P[id].y - P[kth].y);
134             if (dy > P[kth].d) {                
135                 if (P[id].y <= P[kth].y)
136                     search(nd[rt].r, kth);
137                 else
138                     search(nd[rt].l, kth);
139             } else {
140                 search(nd[rt].l, kth);
141                 search(nd[rt].r, kth);
142             }
143         }
144 
145     } else {
146 
147         // x
148         if (dis <= P[kth].d) {
149             search(nd[rt].l, kth);
150             search(nd[rt].r, kth);
151         } else {
152             int dx = abs(P[id].x - P[kth].x);
153             if (dx > P[kth].d) {                
154                 if (P[id].x <= P[kth].x)
155                     search(nd[rt].r, kth);
156                 else
157                     search(nd[rt].l, kth);
158             } else {
159                 search(nd[rt].l, kth);
160                 search(nd[rt].r, kth);
161             }
162         }
163     }
164 }
165 
166 void init() {
167     L = 0;
168     memset(visit, false, sizeof(visit));
169 }
170 
171 int solve(int rt, int k) {
172     if (visit[k])
173         return 0;
174 
175     head = tail = 0;
176     visit[k] = true;
177     Q[tail++] = k;
178 
179     while (head < tail) {
180         search(rt, Q[head++]);
181     }
182 
183     return tail;
184 }
185 
186 int main() {
187     ios::sync_with_stdio(false);
188     #ifndef ONLINE_JUDGE
189         freopen("data.in", "r", stdin);
190         freopen("data.out", "w", stdout);
191     #endif
192 
193     int t = 0;
194     int n, q;
195     int kth, ans;
196 
197     while (scanf("%d", &n)!=EOF && n) {
198         rep(i, 0, n) {
199             scanf("%d %d %d", &P[i].x, &P[i].y, &P[i].d);
200             P[i].id = i;
201         }
202         init();
203         int rt = create(0, n-1, 0);
204         sort(P, P+n, compid);
205         scanf("%d", &q);
206         printf("Case #%d:\n", ++t);
207         while (q--) {
208             scanf("%d", &kth);
209             ans = solve(rt, kth-1);
210             printf("%d\n", ans);
211         }
212     }
213 
214 
215     #ifndef ONLINE_JUDGE
216         printf("time = %d.\n", (int)clock());
217     #endif
218 
219     return 0;
220 }

  1 /* 4400 */
  2 #include <iostream>
  3 #include <string>
  4 #include <map>
  5 #include <queue>
  6 #include <set>
  7 #include <stack>
  8 #include <vector>
  9 #include <deque>
 10 #include <algorithm>
 11 #include <cstdio>
 12 #include <cmath>
 13 #include <ctime>
 14 #include <cstring>
 15 #include <climits>
 16 #include <cctype>
 17 #include <cassert>
 18 #include <functional>
 19 #include <iterator>
 20 #include <iomanip>
 21 using namespace std;
 22 //#pragma comment(linker,"/STACK:102400000,1024000")
 23 
 24 #define sti                set<int> 
 25 #define stpii            set<pair<int, int> > 
 26 #define mpii            map<int,int> 
 27 #define vi                vector<int> 
 28 #define pii                pair<int,int> 
 29 #define vpii            vector<pair<int,int> > 
 30 #define rep(i, a, n)     for (int i=a;i<n;++i)
 31 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 32 #define clr                clear
 33 #define pb                 push_back
 34 #define mp                 make_pair
 35 #define fir                first
 36 #define sec                second
 37 #define all(x)             (x).begin(),(x).end()
 38 #define SZ(x)             ((int)(x).size())
 39 #define lson            l, mid, rt<<1
 40 #define rson            mid+1, r, rt<<1|1
 41 
 42 typedef struct node_t {
 43     int x, y, d;
 44     
 45     node_t() {}
 46     node_t(int x, int y, int d):
 47         x(x), y(y), d(d) {}
 48         
 49     friend bool operator< (const node_t& a, const node_t& b) {
 50         return a.y < b.y;
 51     }
 52     
 53 } node_t;
 54 
 55 typedef struct {
 56     int y, id;
 57 } pair_t;
 58 
 59 const int maxn = 1e5+5;
 60 int X[maxn];
 61 bool visit[maxn];
 62 node_t nd[maxn];
 63 vector< pii > vc[maxn];
 64 int n, m;
 65 
 66 bool comp(const node_t& a, const node_t& b) {
 67     return a.y < b.y;
 68 }
 69 
 70 void init() {
 71     memset(visit, false, sizeof(visit));
 72     
 73     rep(i, 0, n) {
 74         X[i] = nd[i].x;
 75         vc[i].clr();
 76     }
 77     
 78     sort(X, X+n);
 79     m = unique(X, X+n) - X;
 80     node_t tmp;
 81     
 82     rep(i, 0, n) {
 83         int id = lower_bound(X, X+m, nd[i].x) - X;
 84         vc[id].pb(mp(nd[i].y, i));
 85     }
 86     
 87     rep(i, 0, m)
 88         sort(all(vc[i]));
 89 }
 90 
 91 int bfs(int kth) {
 92     if (visit[kth])
 93         return 0;
 94     
 95     int ret = 1;
 96     int x, y, dx, dy;
 97     int lx, rx, ly, ry;
 98     int id, xid;
 99     vector< pii >::iterator iter, liter, riter;
100     queue<int> Q;
101     pii p;
102     
103     visit[kth] = true;
104     Q.push(kth);
105     p.sec = -1;
106     
107     while (!Q.empty()) {
108         kth = Q.front();
109         Q.pop();
110         id = lower_bound(X, X+m, nd[kth].x) - X;
111         lx = lower_bound(X, X+m, nd[kth].x - nd[kth].d) - X;
112         rx = upper_bound(X, X+m, nd[kth].x + nd[kth].d) - X;;
113         for (xid=lx; xid<rx; ++xid) {
114             x = X[xid];
115             dx = abs(x - nd[kth].x);
116             dy = nd[kth].d - dx;
117             ly = nd[kth].y - dy;
118             ry = nd[kth].y + dy;
119             
120             // find lower_bound
121             p.fir = ly;
122             p.sec = -1;
123             liter = lower_bound(all(vc[xid]), p);
124             
125             // find upper_bound
126             p.fir = ry;
127             p.sec = maxn;
128             riter = upper_bound(all(vc[xid]), p);
129             
130             for (iter=liter; iter!=riter; ++iter) {
131                 int k = iter->sec;
132                 if (!visit[k]) {
133                     visit[k] = true;
134                     ++ret;
135                     Q.push(k);
136                 }
137             }
138             
139             // vc[xid].erase(liter, riter);
140         }
141     }
142     
143     return ret;
144 }
145 
146 int main() {
147     ios::sync_with_stdio(false);
148     #ifndef ONLINE_JUDGE
149         freopen("data.in", "r", stdin);
150         freopen("data.out", "w", stdout);
151     #endif
152     
153     int q;
154     int t = 0;
155     int ans;
156     
157     while (scanf("%d", &n)!=EOF && n) {
158         rep(i, 0, n)
159             scanf("%d %d %d", &nd[i].x, &nd[i].y, &nd[i].d);
160         init();
161         scanf("%d", &q);
162         printf("Case #%d:\n", ++t);
163         int kth;
164         while (q--) {
165             scanf("%d", &kth);
166             --kth;
167             ans = bfs(kth);
168             printf("%d\n", ans);
169         }
170     }
171     
172     #ifndef ONLINE_JUDGE
173         printf("time = %d.\n", (int)clock());
174     #endif
175     
176     return 0;
177 }