1 #include <stdio.h>
 2 #include <algorithm>
 3 #include <queue>
 4 #include <vector>
 5
 6 using namespace std;
 7
 8 const int INF = 1e9;
 9 const int _N = 2100;
10
11 struct edge {
12     int v, w;
13     edge(int v = 0, int w = 0):
14         v(v), w(w) { }
15 };
16
17 vector<edge> G[_N];
18 queue<int> Q;
19 int dis[_N];
20 bool mk[_N];
21
22 void Ins(int t1, int t2, int t3) { G[t1].push_back(edge(t2, t3)); return; }
23
24 void SPFA(int beg)
25 {
26     int i;
27     for (i = 0; i <= 2011; ++i)
28         dis[i] = -INF, mk[i] = false;
29     while (!Q.empty()) Q.pop();
30     dis[beg] = 0, Q.push(beg), mk[beg] = true;
31     while (!Q.empty()) {
32         int p = Q.front();
33         Q.pop(); mk[p] = false;
34         for (i = G[p].size()-1; i >= 0; --i) {
35             edge v = G[p][i];
36             if (dis[v.v] < dis[p] + v.w) {
37                 dis[v.v] = dis[p] + v.w;
38                 if (!mk[v.v]) Q.push(v.v), mk[v.v] = true;
39             }
40         }
41     }
42     return;
43 }
44
45 int main()
46 {
47     int N, i;
48     scanf("%d", &N);
49     for (i = 1; i <= N; ++i) {
50         int t1, t2;
51         scanf("%d%d", &t1, &t2);
52         if (t1 > t2) swap(t1, t2);
53         Ins(t1, t2+1, t2+1-t1);
54     }
55     for (i = 1; i <= 2010; ++i) Ins(i, i+1, 0), Ins(0, i, 0);
56     SPFA(0);
57     int ans = 0;
58     for (i = 1; i <= 2011; ++i) ans = max(ans, dis[i]);
59     printf("%d\n", ans);
60     return 0;
61 }

 1 #include <stdio.h>
 2 #include <algorithm>
 3 #include <string.h>
 4
 5 using namespace std;
 6
 7 const int _N = 51000;
 8 const int INF = 1e9;
 9
10 struct data {
11     int val, x;
12     bool operator < (const data &tmp) const
13     {
14         return x < tmp.x;
15     }
16 } A[_N];
17
18 int L[_N*2], R[_N*2];
19
20 int main()
21 {
22     int i, sum, mx_sum, mn_sum, ans, N;
23     scanf("%d", &N);
24     for (i = 1; i <= N; ++i) {
25         scanf("%d%d", &A[i].val, &A[i].x);
26         if (!A[i].val) A[i].val = -1;
27     }
28     sort(A+1, A+1+N);
29
30     memset(L, -1, sizeof L), memset(R, -1, sizeof R);
31     sum = mx_sum = mn_sum = 0;
32     L[sum+_N] = R[sum+_N] = 0;
33
34     for (i = 1; i <= N; ++i) {
35         mx_sum = max(mx_sum, sum += A[i].val);
36         mn_sum = min(mn_sum, sum);
37         if (L[sum+_N] == -1) L[sum+_N] = i;
38         R[sum+_N] = i;
39     }
40     ans = 0;
41     for (i = mn_sum; i <= mx_sum; ++i)
42         if (L[i+_N] != -1 && L[i+_N] < R[i+_N])
43             ans = max(ans, A[R[i+_N]].x-A[L[i+_N]+1].x);
44     printf("%d\n", ans);
45     return 0;
46 }

 1 #include <stdio.h>
 2 #include <algorithm>
 3 #include <vector>
 4 #include <math.h>
 5
 6 using namespace std;
 7
 8 const int _N = 200105;
 9
10 vector<int> G[_N], P[_N];
11 int mxd, lg_mxd;
12 int depth[_N], X[_N], Clr[_N], dad[_N][20];
13
14 void DFS(int node, int d)
15 {
16     mxd = max(mxd, depth[node] = d);
17     if (!X[Clr[node]] || depth[X[Clr[node]]] < depth[node])
18         X[Clr[node]] = node;
19     for (int i = G[node].size()-1; i >= 0; --i)
20         DFS(G[node][i], d+1);
21     return;
22 }
23
24 int LCA(int x, int y)
25 {
26     if (depth[x] < depth[y]) swap(x, y);
27     int t = depth[x]-depth[y], i;
28     for (i = lg_mxd; i >= 0; --i)
29         if ((t>>i) & 1) x = dad[x][i];
30     if (x == y) return x;
31     for (i = lg_mxd; i >= 0; --i)
32         if (dad[x][i] != dad[y][i])
33             x = dad[x][i], y = dad[y][i];
34     return dad[x][0];
35 }
36
37 int main()
38 {
39     int N, M, i, c, j, root;
40     scanf("%d%d", &N, &M);
41     for (i = 1; i <= N; ++i) {
42         scanf("%d%d", &Clr[i], &dad[i][0]);
43         P[Clr[i]].push_back(i);
44         if (!dad[i][0]) root = i;
45         else G[dad[i][0]].push_back(i);
46     }
47     DFS(root, 1);
48     lg_mxd = log2(mxd+0.5)+1;
49     for (j = 1; j <= lg_mxd; ++j)
50         for (i = 1; i <= N; ++i)
51             dad[i][j] = dad[dad[i][j-1]][j-1];
52     for (c = 1; c <= M; ++c) {
53         int ans = -1;
54         for (i = P[c].size()-1; i >= 0; --i)
55             if (P[c][i] != X[c])
56                 ans = max(ans, depth[X[c]]+depth[P[c][i]]-2-(depth[LCA(X[c], P[c][i])]-1)*2);
57         printf("%d\n", ans);
58     }
59     return 0;
60 }

 1 #include <stdio.h>
 2 #include <algorithm>
 3 #include <string.h>
 4
 5 using namespace std;
 6
 7 const int _N = 101005;
 8
 9 struct data {
10     int val, id;
11 } A[_N];
12
13 int cnt;
14 int B[_N], C[_N], L[_N], R[_N];
15
16 bool val_first(data t1, data t2) { return t1.val < t2.val; }
17
18 inline int lbt(int v) { return v & (-v); }
19
20 int GetSum(int k)
21 {
22     int tmp = 0;
23     for (int i = k; i; i ^= lbt(i)) tmp += C[i];
24     return tmp;
25 }
26
27 void Modify(int k, int d)
28 {
29     for (int i = k; i <= cnt; i += lbt(i)) C[i] += d;
30     return;
31 }
32
33 int main()
34 {
35     int N, i;
36     scanf("%d", &N);
37     for (i = 1; i <= N; ++i)
38         scanf("%d", &A[i].val), A[i].id = i;
39     sort(A+1, A+1+N, val_first);
40
41     B[A[1].id] = cnt = 1;
42     for (i = 2; i <= N; ++i)
43         B[A[i].id] = A[i].val == A[i-1].val ? B[A[i-1].id] : (++cnt);
44     for (i = 1; i <= N; ++i)
45         L[i] = GetSum(cnt)-GetSum(B[i]), Modify(B[i], 1);
46     memset(C, 0, sizeof C);
47     for (i = N; i >= 1; --i)
48         R[i] = GetSum(cnt)-GetSum(B[i]), Modify(B[i], 1);
49     int ans = 0;
50     for (i = 1; i <= N; ++i)
51         if (max(L[i], R[i]) > 2*min(L[i], R[i])) ++ans;
52     printf("%d\n", ans);
53     return 0;
54 }