少女NULL中
NULL
inline void read (int &now)
{
register char word = getchar (); int temp = ;
for (now = ; !isdigit (word); word = getchar ()) if (word == '-') temp = ;
for (; isdigit (word); now = now * + word - '', word = getchar ());
if (temp) now = -now;
}
int BUF = ;
char Buf[], *buf = Buf; void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
}
#include <cstdio>
#include <iostream> #define INF 1e9 inline void read (int &now)
{
register char c = getchar (); int temp = ;
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
} using namespace std;
#define Max 2020 int N, M, V, E; double map[Max][Max];
int room[Max], other[Max];
double k[Max];
double dp[Max][Max][]; int Main ()
{
freopen ("classroom.in", "r", stdin);
freopen ("classroom.ans", "w", stdout);
read (N), read (M), read (V), read (E); register int i, j; for (i = ; i <= N; ++ i)
read (room[i]);
for (i = ; i <= N; ++ i)
read (other[i]);
for (i = ; i <= N; ++ i)
scanf ("%lf", &k[i]); int x, y, z; for (i = ; i <= V; ++ i)
for (j = ; j <= V; ++ j)
if (i == j) map[i][i] = ;
else map[i][j] = INF; for (i = ; i <= E; ++ i)
{
read (x), read (y), read (z);
if (x == y) continue;
map[x][y] = min (map[x][y], (double)z);
map[y][x] = map[x][y];
} int pos;
for (pos = ; pos <= V; ++ pos)
for (i = ; i <= V; ++ i)
for (j = ; j <= V; ++ j)
map[i][j] = min (map[i][j], map[i][pos] + map[pos][j]); int L; double res;
for (i = ; i <= N; ++ i)
for (j = ; j <= M; ++ j)
dp[i][j][] = dp[i][j][] = INF;
dp[][][] = , dp[][][] = ; for (i = ; i <= N; ++ i)
{
dp[i][][] = dp[i - ][][] + map[room[i - ]][room[i]];
for (j = , L = min (M, i); j <= L; ++ j)
{
dp[i][j][] = min (dp[i - ][j][] + map[room[i - ]][room[i]], dp[i - ][j][] + map[room[i - ]][room[i]] * (1.0 - k[i - ]) + map[other[i - ]][room[i]] * k[i - ]);
dp[i][j][] = dp[i - ][j - ][] + map[room[i - ]][room[i]] * (1.0 - k[i]) + map[room[i - ]][other[i]] * k[i];
res = dp[i - ][j - ][] + map[room[i - ]][room[i]] * (1.0 - k[i - ]) * (1.0 - k[i]);
res += map[other[i - ]][room[i]] * k[i - ] * (1.0 - k[i]);
res += map[room[i - ]][other[i]] * (1.0 - k[i - ]) * k[i];
res += map[other[i - ]][other[i]] * k[i - ] * k[i];
dp[i][j][] = min (dp[i][j][], res);
}
} double Answer = INF;
for (i = ; i <= M; ++ i)
Answer = min (Answer, min (dp[N][i][], dp[N][i][]));
printf ("%.2lf", Answer); fclose (stdin);
fclose (stdout);
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <iostream>
#include <cstdio> const int BUF = ;
char Buf[BUF], *buf = Buf; void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 2010 int C[Max + ][Max + ];
int sum[Max + ][Max + ]; inline int min (int a, int b)
{
return a < b ? a : b;
}
int data[Max + ]; int Main ()
{
freopen ("problem.in", "r", stdin);
freopen ("problem.ans", "w", stdout);
fread (buf, , BUF, stdin);
int N, M, K;
int T;
read (T), read (K);
C[][] = ;
register int i, j;
int S = ; for (i = ; i <= Max; ++ i)
{
C[i][] = ;
for (j = ; j <= i; j ++)
{
C[i][j] = (C[i - ][j] + C[i - ][j - ]) % K;
if (C[i][j] == ) ++ data[i];
if (i == j) sum[i][j] = sum[i - ][j - ] + data[i];
else sum[i][j] = sum[i - ][j] + data[i];
}
} int x, y;
for (i = ; i <= T; ++ i)
{
read (x), read (y);
printf ("%d\n", sum[x][min (y, x)]);
} return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue> const int BUF = ;
char Buf[BUF], *buf = Buf; #define Inline __attri\
bute__( ( optimize ( "-O2" ) ) ) Inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} std :: priority_queue <int> Heap;
int Tag; Inline void write (int x)
{
if (x > ) write (x / );
putchar (x % + '');
} Inline int Main ()
{
freopen ("earthworm.in", "r", stdin);
freopen ("earthworm.ans", "w", stdout);
fread (buf, , BUF, stdin);
int N, M, Q, U, V, T;
read (N), read (M), read (Q), read (U), read (V), read (T); register int i;
int x;
double k = (double)U / V;
for (i = ; i <= N; ++ i)
{
read (x);
Heap.push (x);
}
register int pos;
for (i = ; i <= M; ++ i)
{
pos = Heap.top () + Tag, Heap.pop ();
if (i % T == ) write (pos), putchar (' ');
x = (int)(k * pos), Heap.push (x - Tag - Q), Heap.push (pos - x - Tag - Q);
Tag += Q;
}
putchar ('\n');
for (i = ; i <= N + M; ++ i)
{
if (i % T == ) write (Heap.top () + Tag), putchar (' ');
Heap.pop ();
}
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include<cstdio>
#include<iostream>
#include<algorithm> #define Max 100010 const int BUF = ;
char Buf[BUF], *buf = Buf; void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} int data[Max]; struct Queue
{
protected : int H, T, c[Max * ]; public :
Queue () { H = ; T = ; }
inline void push (int key) { c[++ T] = key;}
inline void pop () { ++ H; }
inline int front () { return c[H]; }
inline bool empty () { return H > T; }
}; Queue queue[]; int Get_Max ()
{
int now;
for (int i = ; i <= ; ++ i)
{
if (queue[i].empty ()) continue;
if (i != && !queue[].empty () && queue[].front () > queue[i].front ()) continue;
if (i != && !queue[].empty () && queue[].front () > queue[i].front ()) continue;
if (i != && !queue[].empty () && queue[].front () > queue[i].front ()) continue;
now = queue[i].front (), queue[i].pop ();
return now;
}
} int Main ()
{
freopen ("earthworm.in", "r", stdin);
freopen ("earthworm.ans", "w", stdout);
fread (buf, , BUF, stdin);
int N, M, Q, U, V, T;
register int i, pos, Tag = ;
read (N), read (M), read (Q), read (U), read (V), read (T);
for (i = ; i <= N; ++ i)
read (data[i]);
std :: sort (data + , data + N + );
for (i = N; i >= ; -- i)
queue[].push (data[i]);
for (i = ; i <= M; ++ i)
{
pos = Get_Max ();
if (i % T == )
printf ("%d ", pos + Tag);
queue[].push ((long long)(pos + Tag) * U / V - Tag - Q);
queue[].push ((pos + Tag) - (long long)(pos + Tag) * U / V - Tag - Q);
Tag += Q;
}
putchar ('\n');
for (i = ; !queue[].empty () || !queue[].empty () || !queue[].empty(); ++ i)
{
pos = Get_Max ();
if (i % T == )
printf ("%d ", pos + Tag);
}
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath> #define Max 25
#define EPS 1e-8 inline void read (int &now)
{
register char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
}
int T, N, M, Answer; struct Point
{
double x, y;
}; struct Line
{
double a, b, x, y;
}; Point p[Max];
Line b[Max];
int use[Max];
bool visit[Max]; inline double Cal (int pos, int z)
{
return fabs (b[pos].a * p[z].x * p[z].x + b[pos].b * p[z].x - p[z].y);
} void Dfs (int n, int res)
{
if (n > N)
{
if (res < Answer) Answer = res;
return;
}
if (res >= Answer) return;
for (int i = ; i <= res; ++ i)
if (use[i] <= )
{
double X1 = b[i].x, Y1 = b[i].y, X2 = p[n].x, Y2 = p[n].y;
double d = X1 / X2;
if (fabs (X1 * X2 - X1 * X1) <= EPS)
continue;
b[i].a = (Y2 * d - Y1) / (X1 * X2 - X1 * X1);
b[i].b = (Y1 - b[i].a * X1 * X1) / X1;
if (b[i].a >= -EPS)
continue;
++ use[i], Dfs (n + ,res), -- use[i];
}
else if (Cal (i, n) <= EPS)
Dfs (n + , res); b[res + ].x = p[n].x, b[res + ].y = p[n].y;
use[res + ] = , Dfs (n + , res + ), use[res + ] = ;
} int Main ()
{
freopen ("angrybirds.in", "r", stdin);
freopen ("angrybirds.ans", "w", stdout);
read (T);
for (; T; -- T)
{
read (N), read (M);
Answer = ;
memset (p, , sizeof p);
memset (b, , sizeof b);
memset (use, , sizeof use);
for (int i = ; i <= N; ++ i)
scanf ("%lf%lf", &p[i].x, &p[i].y);
Dfs (, );
printf ("%d\n", Answer);
}
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio> #define Max 50
int map[Max][Max]; int Main ()
{
freopen ("magic.in", "r", stdin);
freopen ("magic.ans", "w", stdout); int N, j;
scanf ("%d", &N);
register int i, x = , y = ((N >> ) + ); int L = N * N;
map[x][y] = ;
for (i = ; i <= L; ++ i)
{
if (x == && y != N) x = N, ++ y;
else if (y == N && x != ) -- x, y = ;
else if (x == && y == N) ++ x;
else if (x != && y != N)
{
if (map[x - ][y + ] == ) -- x, ++ y;
else ++ x;
}
map[x][y] = i;
}
for (i = ; i <= N; ++ i)
{
for (j = ; j <= N; ++ j)
printf ("%d ", map[i][j]);
putchar ('\n');
}
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <stack> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
}
#define Max 300000
int N, Answer = 1e9; inline int min (int a, int b)
{
return a < b ? a : b;
} class Tarjan_Type
{
private : int to[Max], _next[Max], C, list[Max];
int scc_number[Max], Scc_C, dfn[Max], low[Max], D_C;
std :: stack <int> Stack; public : Tarjan_Type ()
{
C = , Scc_C = , D_C = ;
}
inline void In (int u, int v)
{
to[++ C] = v, _next[C] = list[u], list[u] = C;
} void Do_Tarjan ()
{
for (int i = ; i <= N; ++ i)
if (!dfn[i]) Dfs (i);
} void Dfs (int now)
{
dfn[now] = low[now] = ++ D_C, Stack.push (now);
for (int i = list[now]; i; i = _next[i])
{
if (!dfn[to[i]])
{
Dfs (to[i]);
low[now] = min (low[to[i]], low[now]);
}
else if (!scc_number[to[i]])
low[now] = min (dfn[to[i]], low[now]);
}
if (dfn[now] == low[now])
{
++ Scc_C; int pos = now + , res = ;
for (; pos != now && !Stack.empty (); Stack.pop ())
pos = Stack.top (), scc_number[pos] = Scc_C, ++ res;
if (res != ) Answer = min (Answer, res);
} }
}; Tarjan_Type Tar; int Main ()
{
freopen ("message.in", "r", stdin);
freopen ("message.ans", "w", stdout);
fread (buf, , BUF, stdin); read (N);
int x;
for (int i = ; i <= N; ++ i)
read (x), Tar.In (i, x);
Tar.Do_Tarjan (); printf ("%d", Answer); return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <iostream>
#include <cstdio>
#include <cstring> #define INF 1e7 const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 30 int T, N, Answer ;
int card[Max], count[Max]; inline int min (int a, int b)
{
return a < b ? a : b;
} void Dfs (int now)
{
if (now > Answer) return;
int res = ; register int i, j; for (i = ; i < ; i ++) count[i] = ;
for (i = ; i <= ; i++) count[card[i]]++; for (; count[]; )
{
-- count[], ++ res;
if (count[] >= ) count[] -= ;
else if (count[] >= ) count[] -= ;
}
for (; count[]; )
{
-- count[], ++ res;
if (count[]) -- count[];
else if (count[]) -- count[];
} if (card[] && card[] && count[] >= ) -- res;
res += count[] + count[], Answer = min (res + now, Answer); for (i = , j; i <= ; ++i)
{
for (j = i; card[j] && j <= ; ++j)
{
-- card[j];
if (j - i + >= ) Dfs (now + );
}
for (; j > i; ) ++ card [--j];
} for (i = , j; i <= ; ++i)
{
for (j = i; card[j] >= && j <= ; ++j)
{
card[j] -= ;
if (j - i + >= ) Dfs (now + );
}
for (; j > i; ) card [--j] += ;
} for (i = , j; i <= ; ++i)
{
for (j = i; card[j] >= && j <= ; ++j)
{
card[j] -= ;
if (j - i + >= ) Dfs (now + );
}
for (; j > i; ) card [--j] += ;
}
}
int Main ()
{
freopen ("landlords.in", "r", stdin);
freopen ("landlords.ans", "w", stdout);
fread (buf, , BUF, stdin);
read (T), read (N);
int x, y; register int i;
for (; T; -- T)
{
memset (card, , sizeof (card));
Answer = INF; for (i = ; i <= N; ++ i)
{
read (x), read (y);
if (x == ) ++ card [y - ];
else if (x == ) ++ card [];
else ++ card[x];
} Dfs (); printf ("%d\n", Answer);
}
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 60000
int N, L, M;
int key[Max]; bool Check (int Thb)
{
int res = , C = , last = ;
for (int i = ; i <= N; ++ i)
{
if (key[i] - last < Thb)
++ C;
else last = key[i];
if (C > M) return false;
}
return true;
} int Main ()
{
freopen ("stone.in", "r", stdin);
freopen ("stone.ans", "w", stdout);
fread (buf, , BUF, stdin); read (L), read (N), read (M); int l = , r = L, Mid; for (int i = ; i <= N; ++ i) read (key[i]);
int Answer;
for (; l <= r; )
{
Mid = l + r >> ;
if (Check (Mid))
{
Answer = Mid;
l = Mid + ;
}
else r = Mid - ;
} printf ("%d", Answer);
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> #define Max 1030 void read (int &now)
{
register char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
} #define Mod 1000000007
int N, M, K;
char A[Max], B[Max];
int dp[Max][Max][Max / * ];
int pos = , next; int data[Max][Max][Max / * ]; int Main ()
{
freopen ("substring.in", "r", stdin);
freopen ("substring.ans", "w", stdout);
dp[][][] = ;
read (N), read (M), read (K);
scanf ("%s%s", A + , B + );
register int i, j, k;
int Answer;
for (i = ; i <= N; ++ i)
{
dp[pos][][] = ;
for (j = ; j <= M; ++ j)
for (k = ; k <= K; ++ k)
{
if (A[i] != B[j])
data[pos][j][k] = ;
else data[pos][j][k] = (data[next][j - ][k] + dp[next][j - ][k - ]) % Mod;
dp[pos][j][k] = (dp[next][j][k] + data[pos][j][k]) % Mod;
}
k = pos, pos = next, next = k;
Answer = next;
} printf ("%d", dp[Answer][M][K]);
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <cstdlib> #define Inline __attri\
bute__( ( optimize ( "-O2" ) ) ) const int BUF = ;
char Buf[BUF], *buf = Buf;
#define INF 1e9 Inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 300050 int N, M;
int t_n[Max]; Inline void swap (int &x, int &y)
{
int now = x; x = y, y = now;
} struct Bit_Tree
{
protected : int sum[Max];
int N;
public : Inline void Prepare (const int &x)
{
this->N = x;
for (register int i = ; i <= N; ++ i)
sum[i] = ;
} Inline int Ask (int l, int r)
{
int res = ;
for (-- l; l; l -= l & (-l)) res -= sum[l];
for (; r; r -= r & (-r)) res += sum[r];
return res;
} Inline void Change (int pos, int to)
{
for (; pos <= N; pos += pos & (-pos))
sum[pos] += to;
}
};
Bit_Tree Bit; inline int min (int a, int b)
{
return a < b ? a : b;
} inline int max (int a, int b)
{
return a > b ? a : b;
} class Tree_Chain_Get
{
private : int to[Max << ], _next[Max << ], dis[Max << ], C, list[Max];
int deep[Max], size[Max], father[Max], chain[Max], son[Max]; int value[Max], key[Max], Count;
public : Inline void In (const int &M)
{
int x, y, z;
for (register int i = ; i <= M; ++ i)
{
read (x), read (y), read (z);
to[++ C] = y, _next[C] = list[x], list[x] = C, value[C] = z;
to[++ C] = x, _next[C] = list[y], list[y] = C, value[C] = z;
}
Bit.Prepare (M + );
Dfs_1 (, ), Count = , Dfs_2 (, );
} void Dfs_1 (int now, int Father)
{
father[now] = Father, size[now] = , deep[now] = deep[Father] + ;
for (int i = list[now]; i; i = _next[i])
if (to[i] != Father)
{
Dfs_1 (to[i], now);
size[now] += size[to[i]];
if (size[son[now]] < size[to[i]])
son[now] = to[i];
}
} void Dfs_2 (int now, int point)
{
chain[now] = point;
for (int i = list[now]; i; i = _next[i])
if (to[i] == father[now])
{
key[now] = value[i];
break;
}
t_n[now] = ++ Count; Bit.Change (Count, key[now]);
if (son[now]) Dfs_2 (son[now], point);
else return ;
for (int i = list[now]; i; i = _next[i])
if (to[i] != son[now] && to[i] != father[now])
Dfs_2 (to[i], to[i]);
} Inline int Q (int x, int y)
{
int res = ;
for (; chain[x] != chain[y]; )
{
if (deep[chain[x]] < deep[chain[y]]) swap (x, y);
res += Bit.Ask (t_n[chain[x]], t_n[x]);
x = father[chain[x]];
}
if (deep[x] > deep[y]) swap (x, y);
if (x != y) res += Bit.Ask (t_n[x] + , t_n[y]);
return res;
}
}; Tree_Chain_Get T;
int q_x[Max], q_y[Max]; Inline int Main ()
{
freopen ("transport.in", "r", stdin);
freopen ("transport.ans", "w", stdout); fread (buf, , BUF, stdin);
read (N), read (M);
T.In (N - );
int x, y; register int i, j;
for (i = ; i <= M; ++ i)
read (q_x[i]), read (q_y[i]);
int Answer = INF, now, res, pos; for (i = ; i <= N; ++ i)
{
pos = t_n[i];
now = Bit.Ask (pos, pos); res = -;
Bit.Change (pos, -now);
for (j = ; j <= M; ++ j)
res = max (res, T.Q (q_x[j], q_y[j]));
Answer = min (Answer, res);
Bit.Change (pos, now);
}
printf ("%d", Answer);
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <cstring> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 300
int c[Max], d[Max];
int map[][]; int Main ()
{
freopen ("rps.in", "r", stdin);
freopen ("rps.ans", "w", stdout);
fread (buf, , BUF, stdin);
int N, A, B;
read (N), read (A), read (B);
register int i, j, k;
for (i = ; i <= A; ++ i)
read (c[i]);
for (i = ; i <= B; ++ i)
read (d[i]);
memset (map, - , sizeof map);
for (i = ; i < ; ++ i) map[i][i] = ;
map[][] = , map[][] = , map[][] = , map[][] = ;
map[][] = , map[][] = , map[][] = ;
map[][] = , map[][] = , map[][] = ;
int Z = , X = ;
for (i = , j = , k = ; i <= N; ++ i, ++ j, ++ k)
{
if (j == A + ) j = ;
if (k == B + ) k = ;
if (map[c[j]][d[k]] == -)
{
if (map[d[k]][c[j]] == ) ++ X;
else if (map[d[k]][c[j]] == ) ++ Z;
continue;
}
if (map[c[j]][d[k]] == ) ++ Z;
else if (map[c[j]][d[k]] == ) ++ X;
}
printf ("%d %d", Z, X);
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 200200 struct E
{
E *n;
int to;
};
E poor[Max << ], *Tail = poor, *list[Max];
int key[Max];
#define Mod 10007 inline void In (int u, int v)
{
++ Tail, Tail->to = v, Tail->n = list[u], list[u] = Tail;
++ Tail, Tail->to = u, Tail->n = list[v], list[v] = Tail;
} int N, father[Max];
int T, Answer = -; inline int max (int a, int b)
{
return a > b ? a : b;
} void Dfs (int now, int Father)
{
father[now] = Father; int Grand = father[Father], res;
if ((res = key[now] * key[Grand]) != )
{
Answer = max (Answer, res);
T = (T + ((res % Mod) << ));
}
for (E *e = list[Father]; e; e = e->n)
if (e->to != now && e->to != Grand)
{
res = key[e->to] * key[now];
Answer = max (Answer, res);
T = (T + res) % Mod;
}
for (E *e = list[now]; e; e = e->n)
if (e->to != Father)
Dfs (e->to, now);
} int Main ()
{
freopen ("link.in", "r", stdin);
freopen ("link.ans", "w", stdout);
fread (buf, , BUF, stdin);
read (N); int x, y;
for (int i = ; i < N; ++ i)
{
read (x), read (y);
In (x, y);
} for (int i = ; i <= N; ++ i)
read (key[i]); Dfs (, );
printf ("%d %d", Answer, T);
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <algorithm> const int BUF = ;
char Buf[BUF], *buf = Buf; #define INF 1e8
inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
}
#define Max 100030 int up[Max], down[Max], N, M, K;
int u[Max], d[Max], Answer = INF, Z; inline int min (int a, int b)
{
return a < b ? a : b;
}
bool flag = false;
void Dfs (int x, int h, int c)
{
if (c > Answer) return ;
if (x > Z) Z = x;
if (x == N)
{
flag = true;
Answer = min (Answer, c);
return ;
}
if (u[x + ] == )
for (int i = ; h + i * up[x] > d[x + ]; ++ i)
{
if (h + i * up[x] >= M)
{
Dfs (x + , M, c + i);
break;
}
else
Dfs (x + , h + i * up[x], c + i);
}
else
for (int i = ; (h + i * up[x]) > d[x + ] && (h + i * up[x] < u[x + ]); ++ i)
Dfs (x + , h + i * up[x], c + i);
if (h - down[x] > d[x + ] && h - down[x] < (u[x + ] == ? INF : u[x + ]))
Dfs (x + , h - down[x], c);
} int Main ()
{
freopen ("bird.in", "r", stdin);
freopen ("bird.ans", "w", stdout);
fread (buf, , BUF, stdin);
register int i;
read (N), read (M), read (K); for (i = ; i < N; ++ i)
read (up[i]), read (down[i]);
int x;
for (i = ; i <= K; ++ i)
read (x), read (d[x]), read (u[x]);
for (i = ; i <= M; ++ i)
Dfs (, i, );
if (flag) printf ("1\n%d", Answer);
else
{
int res = ;
for (i = ; i <= Z; ++ i)
if (u[i]) ++ res;
printf ("0\n%d", res);
}
return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 130
int map[Max][Max];
const int N = Max - ; inline int max (int a, int b)
{
return a > b ? a : b;
}
inline int min (int a, int b)
{
return a < b ? a : b;
}
int Main ()
{
freopen ("wireless.in", "r", stdin);
freopen ("wireless.ans", "w", stdout);
fread (buf, , BUF, stdin); int D, K; read (D), read (K);
register int i, j; int x, y, z;
for (i = ; i <= K; ++ i)
{
read (x), read (y), read (z);
map[x][y] = z;
}
int Answer = -, C = , res;
for (x = ; x < N; ++ x)
for (y = ; y < N; ++ y)
{
res = ;
for (i = -D; i <= D; ++ i)
for (j = -D; j <= D; ++ j)
res += map[min (N - , max (, x - i))][min (N - , max (, y - j))];
if (res == Answer) ++ C;
if (res > Answer) Answer = res, C = ;
} printf ("%d %d", C, Answer); return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <queue>
#include <cstring>
#include <cstdlib> #define Max 220200 const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} struct E
{
E *n;
int to;
};
E *list[Max], poor[Max << ], *Tail = poor;
bool visit[Max]; void F_Bfs (const int &S, const int &T)
{
std :: queue <int> Queue; int now; visit[S] = true;
for (Queue.push (S); !Queue.empty (); Queue.pop ())
{
now = Queue.front ();
for (E *e = list[now]; e; e = e->n)
if (!visit[e->to])
{
visit[e->to] = true;
Queue.push (e->to);
}
}
}
int dis[Max];
void Z_Bfs (const int &S, const int &T)
{
memset (dis, -, sizeof dis); E *e;
std :: queue <int> Queue; int now; dis[S] = ;
for (Queue.push (S); !Queue.empty (); Queue.pop ())
{
now = Queue.front ();
for (e = list[now]; e; e = e->n)
if (!visit[e->to]) goto Continue;
for (e = list[now]; e; e = e->n)
if (dis[e->to] == -)
{
dis[e->to] = dis[now] + ;
Queue.push (e->to);
if (e->to == T)
{
printf ("%d", dis[T]);
exit ();
}
}
Continue : continue;
}
}
int da_x[Max], da_y[Max]; int Main ()
{
freopen ("road.in", "r", stdin);
freopen ("road.ans", "w", stdout);
fread (buf, , BUF, stdin);
int N, M, x, y, z, S, T; read (N), read (M); register int i;
for (i = ; i <= M; ++ i)
{
read (da_x[i]), read (da_y[i]);
++ Tail, Tail->to = da_x[i], Tail->n = list[da_y[i]], list[da_y[i]] = Tail;
}
read (S), read (T);
F_Bfs (T, S);
for (i = ; i <= M; ++ i) list[i] = NULL;
for (i = , Tail = poor; i <= M; ++ i)
++ Tail, Tail->to = da_y[i], Tail->n = list[da_x[i]], list[da_x[i]] = Tail;
Z_Bfs (S, T);
printf ("-1");
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; void read (int &now)
{
int temp = ;
for (now = ; !isdigit (*buf); ++ buf)
if (*buf == '-') temp = ;
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
if (temp) now = -now;
}
#define Max 100
int a[Max];
long long F_P (int x, int p)
{
if (p == ) return ;
long long res = ;
for (; p; p >>= )
{
if (p & ) res *= x;
x *= x;
}
return res;
} int Main ()
{
freopen ("equation.in", "r", stdin);
freopen ("equation.ans", "w", stdout);
fread (buf, , BUF, stdin);
int N, M; register int i;
read (N), read (M); for (i = ; i <= N; ++ i)
read (a[i]);
register int j; int C = ; long long res;
static int Answer[Max];
for (i = ; i <= M; ++ i)
{
res = ;
for (j = ; j <= N; ++ j)
res += a[j] * F_P (i, j);
if (!res) Answer[++ C] = i;
} printf ("%d\n", C);
for (i = ; i <= C; ++ i)
printf ("%d\n", Answer[i]); return ;
} int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (long long &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} long long Q_P (long long x, long long p, long long Mod)
{
long long res = ;
for (; p; p >>= )
{
if (p & ) res = (res * x) % Mod;
x = (x * x) % Mod;
}
return res;
} void write (long long now)
{
if (now > ) write (now / );
putchar (now % + '');
} int Main ()
{
freopen ("circle.in", "r", stdin);
freopen ("circle.ans", "w", stdout); fread (buf, , BUF, stdin); long long N, M, K, X;
read (N), read (M), read (K), read (X); write ((X + M * Q_P (, K, N)) % N);
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <algorithm>
const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define INF 1e9
#define Max 30100 struct E
{
E *n;
int to, key;
};
E *list[Max], poor[Max], *Tail = poor; struct Edge
{
int from, to, key;
bool operator < (const Edge &now) const
{
return this->key > now.key;
}
};
Edge data[Max * ]; struct Unio_Find
{
protected : int data[Max];
public : void Prepare (const int &N)
{
for (register int i = ; i <= N; ++ i)
data[i] = i;
} int Find (int x)
{
return data[x] == x ? x : data[x] = Find (data[x]);
} inline void Unio (int x, int y) { data[x] = y; }
};
Unio_Find Ufs;
inline int min (int a, int b)
{
return a < b ? a : b;
}
int N, M;
struct S_D
{
S_D *Left, *Right;
int key, Mid;
inline void Up ()
{
this->key = min (this->Left->key, this->Right->key);
}
};
int tree_key[Max], in[Max]; inline void swap (int &a, int &b)
{
int now = a; a = b, b = now;
} class Segment_Tree
{
private : S_D _poor[Max], *Tail, *Root; inline S_D *New (int x, int y)
{
++ this->Tail, this->Tail->Mid = x + y >> , this->Tail->key = ;
this->Tail->Left = this->Tail->Right = NULL; return this->Tail;
} void Build (S_D *&now, int l, int r)
{
now = New (l, r);
if (l == r)
{
now->key = tree_key[l];
return ;
}
Build (now->Left, l, now->Mid);
Build (now->Right, now->Mid + , r);
now->Up ();
} int Query (S_D *&now, int L, int R, int l, int r)
{
if (l <= L && R <= r)
return now->key;
int res = INF;
if (l <= now->Mid) res = Query (now->Left, L, now->Mid, l, r);
if (r > now->Mid)
res = min (res, Query (now->Right, now->Mid + , R, l, r));
return res;
} public : Segment_Tree () { this->Tail = _poor;} void Build (int l, int r) { return Build (Root, l, r); }
int Query (int l, int r) { return Query (Root, , N, l, r); }
};
Segment_Tree Seg; class Tree_Chain_Get_Type
{
private : int deep[Max], size[Max], father[Max], chain[Max], son[Max];
int C; void Dfs_1 (int now, int Father)
{
size[now] = , father[now] = Father, deep[now] = deep[Father] + ;
for (E *e = list[now]; e; e = e->n)
if (e->to != Father)
{
Dfs_1 (e->to, now); size[now] += size[e->to];
if (size[son[now]] < size[e->to]) son[now] = e->to;
}
} void Dfs_2 (int now, int point)
{
chain[now] = point; in[now] = ++ C; E *e;
for (e = list[now]; e; e = e->n)
if (e->to == father[now])
tree_key[C] = e->key;
if (son[now]) Dfs_2 (son[now], point);
else return ;
for (e = list[now]; e; e = e->n)
if (e->to != son[now] && e->to != father[now])
Dfs_2 (e->to, e->to);
} public : void Prepare ()
{
C = , Dfs_1 (, ), Dfs_2 (, ); Seg.Build (, N); } int Query (int x, int y)
{
if (Ufs.Find (x) != Ufs.Find (y)) return -;
int res = INF;
for (; chain[x] != chain[y]; )
{
if (deep[chain[x]] < deep[chain[y]]) swap (x, y);
res = min (Seg.Query (in[chain[x]], in[x]), res);
x = father[chain[x]];
}
if (deep[x] > deep[y]) swap (x, y);
if (x != y) res = min (res, Seg.Query (in[x] + , in[y]));
return res;
}
};
Tree_Chain_Get_Type T; int Main ()
{ freopen ("truck.in", "r", stdin);
freopen ("truck.ans", "w", stdout);
fread (buf, , BUF, stdin); read (N), read (M);
int x, y, z;
register int i;
for (i = ; i <= M; ++ i)
{
read (x), read (y), read (z);
data[i].from = x, data[i].to = y, data[i].key = z;
}
std :: sort (data + , data + + M);
int Count = ; Ufs.Prepare (N);
for (i = ; i <= M; ++ i)
{
x = Ufs.Find (data[i].from), y = Ufs.Find (data[i].to);
if (x != y)
{
++ Tail, Tail->to = data[i].to, Tail->key = data[i].key;
Tail->n = list[data[i].from], list[data[i].from] = Tail;
++ Tail, Tail->to = data[i].from, Tail->key = data[i].key;
Tail->n = list[data[i].to], list[data[i].to] = Tail;
++ Count; Ufs.Unio (x, y);
}
if (Count == N - ) break;
}
T.Prepare ();
int Q; read (Q);
for (i = ; i <= Q; ++ i)
read (x), read (y), printf ("%d\n", T.Query (x, y));
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 1221313
int high[Max]; int Main ()
{
freopen ("block.in", "r", stdin);
freopen ("block.ans", "w", stdout);
fread (buf, , BUF, stdin); int N, Answer = , Last = ; read (N); register int i;
for (i = ; i <= N; ++ i) read (high[i]);
for (i = ; i <= N; ++ i)
if (high[i] >= Last)
{
Answer += high[i] - Last;
Last = high[i];
}
else Last = high[i];
printf ("%d", Answer);
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 120000 int Main ()
{
freopen ("flower.in", "r", stdin);
freopen ("flower.ans", "w", stdout); fread (buf, , BUF, stdin);
int N, now, Answer = , res = , Last = ;
read (N); register int i; read (Last);
for (i = ; i <= N; Last = now, ++ i)
{
read (now);
if (res == && now - Last) ++ Answer, res = now - Last;
else if (now - Last != && res > && now < Last)
++ Answer, res = now - Last;
else if (res < && now > Last && now - Last)
++ Answer, res = now - Last;
}
printf ("%d", Answer + );
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue> struct Data
{
int x, y, a, b;
int step;
}Make; #define Max 31 const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} bool visit[Max][Max][Max][Max];
int map[Max][Max];
int N, M ,Q, Answer;
int E_x, E_y, S_x, S_y, T_x, T_y; int move_x[] = {, , -, , };
int move_y[] = {, -, , , }; void Bfs ()
{
std :: queue <Data> Queue;
Data now, pos; int a,b; register int k;
memset (visit, false, sizeof visit);
visit[S_x][S_y][E_x][E_y] = true;
for (Queue.push (Make); !Queue.empty(); Queue.pop ())
{
now = Queue.front();
if (now.a == T_x && now.b == T_y)
{
Answer=now.step;
return ;
}
for (k = ; k <= ; ++ k)
{
pos = now;
a = pos.x + move_x[k];
b = pos.y + move_y[k];
if (a == pos.a && b == pos.b)
pos.a = pos.x, pos.b = pos.y;
if(!map[a][b] || a < || a > N || b < || b > M)
continue ;
pos.x = a, pos.y = b, ++ pos.step;
if (!visit[pos.a][pos.b][pos.x][pos.y])
{
Queue.push (pos);
visit[pos.a][pos.b][pos.x][pos.y] = true;
}
}
}
}
int Main ()
{
freopen ("puzzle.in", "r", stdin);
freopen ("puzzle.ans", "w", stdout);
fread (buf, , BUF, stdin); read (N), read (M), read (Q); register int i, j;
for (i = ; i <= N; ++ i)
for (j = ; j <= M; ++ j)
read (map[i][j]); for (; Q; -- Q)
{
Answer = N * M;
read (E_x), read (E_y), read (S_x), read (S_y);
read (T_x), read (T_y), Make.x = E_x, Make.y = E_y;
Make.a = S_x, Make.b = S_y, Make.step = ;
if (S_x == T_x && S_y == T_y)
{
printf("0\n");
continue ;
}
Bfs ();
if (Answer != N * M)
printf ("%d\n", Answer);
else printf ("-1\n");
}
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
bool temp = false;
for (now = ; !isdigit (*buf); ++ buf)
if (*buf == '-') temp = true;
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
if (temp) now = -now;
} #define Max 100050
double _x[Max], _y[Max];
double i2[Max], _i[Max]; struct S_D
{
S_D *Left, *Right;
double x, x2, y, xy, ss, st, ts, tt;
int l, r, Mid;
bool tag; S_D (int _l, int _r)
{
x = x2 = ss = st = ts = tt = y = xy = ;
Left = Right = NULL;
l = _l, r = _r, Mid = l + r >> ;
tag = false;
} inline void Up ()
{
x = Left->x + Right->x, xy = Left->xy + Right->xy;
y = Left->y + Right->y;
x2 = Left->x2 + Right->x2;
} inline void Down ()
{
S_D *L = Left, *R = Right; double ls = L->r - L->l + , rs = R->r - R->l + ;
if (tag)
{
L->x = ts * ls + _i[L->r] - _i[L->l - ];
L->y = tt * ls + _i[L->r] - _i[L->l - ];
L->xy = ts * tt * ls + (_i[L->r] - _i[L->l - ]) * (ts + tt) + i2[L->r] - i2[L->l - ];
L->x2 = ts * ts * ls + (_i[L->r] - _i[L->l - ]) * ts * 2.0 + i2[L->r] - i2[L->l - ]; R->x = ts * rs + _i[R->r] - _i[R->l - ];
R->y = tt * rs + _i[R->r] - _i[R->l - ];
R->xy = ts * tt * rs + (_i[R->r] - _i[R->l - ]) * (ts + tt) + i2[R->r] - i2[R->l - ];
R->x2 = ts * ts * rs + (_i[R->r] - _i[R->l - ]) * ts * 2.0 + i2[R->r] - i2[R->l - ];
L->ts = R->ts = ts, L->tt = R->tt = tt;
L->ss = R->st = L->st = R->ss = ;
tt = ts = , tag = false;
L->tag = R->tag = true;
}
if (ss || st)
{
L->xy += st * L->x + ss * L->y + ss * st * ls;
L->x2 += ss * L->x + ss * L->x + ss * ss * ls;
R->xy += st * R->x + ss * R->y + ss * st * rs;
R->x2 += ss * R->x + ss * R->x + ss * ss * rs;
L->x += ss * ls, R->x += ss * rs;
L->y += st * ls, L->y += st * rs;
L->ss += ss, R->ss += ss;
L->st += st, R->st += st;
ss = st = ;
}
}
}; struct D
{
double x, y, x2, xy;
D () : x (), y (), x2 (), xy () {}
D (double a, double b, double c, double d) : x (a), y (b), x2 (c), xy (d) {}
}; #define DE printf ("%lf %lf %lf %lf\n", now->x, now->y, now->x2, now->xy);
class Segment_Tree
{
private : S_D *Root; void Build (S_D *&now, int l, int r)
{
now = new S_D (l, r);
if (l == r)
{
now->x = (double)_x[l], now->y = (double)_y[r];
now->x2 = now->x * now->x;
now->xy = now->x * now->y;
return ;
}
Build (now->Left, l, now->Mid);
Build (now->Right, now->Mid + , r);
now->Up ();
} void Change_1 (S_D *&now, int l, int r, double s, double t)
{
if (l <= now->l && now->r <= r)
{
double L = (now->r - now->l + );
now->xy += t * now->x + s * now->y + s * t * L;
now->x2 += s * now->x + s * now->x + s * s * L;
now->x += s * L, now->y += t * L;
now->ss += s, now->st += t;
return ;
}
now->Down ();
if (l <= now->Mid) Change_1 (now->Left, l, r, s, t);
if (r > now->Mid) Change_1 (now->Right, l, r, s, t);
now->Up ();
} void Change_2 (S_D *&now, int l, int r, double s, double t)
{
if (l <= now->l && now->r <= r)
{
double L = (now->r - now->l + );
now->tag = true;
now->ss = now->st = , now->ts = s, now->tt = t;
now->x = L * s + _i[now->r] - _i[now->l - ];
now->y = L * t + _i[now->r] - _i[now->l - ];
now->xy = L * s * t + (s + t) * (_i[now->r] - _i[now->l - ]) + i2[now->r] - i2[now->l - ];
now->x2 = L * s * s + * s * (_i[now->r] - _i[now->l - ]) + i2[now->r] - i2[now->l - ];
return ;
}
now->Down ();
if (l <= now->Mid) Change_2 (now->Left, l, r, s, t);
if (r > now->Mid) Change_2 (now->Right, l, r, s, t);
now->Up ();
} D Query (S_D *&now, int l, int r)
{
if (l <= now->l && now->r <= r)
return D (now->x, now->y, now->x2, now->xy);
now->Down ();
D A, B;
if (l <= now->Mid) A = Query (now->Left, l, r);
if (r > now->Mid) B = Query (now->Right, l, r);
A.x += B.x, A.y += B.y;
A.x2 += B.x2, A.xy += B.xy;
return A;
} public : inline void Build (int l, int r) { return Build (Root, l, r); } inline void Change_1 (int l, int r, double s, double t)
{
return Change_1 (Root, l, r, s, t);
} inline void Change_2 (int l, int r, double s, double t)
{
return Change_2 (Root, l, r, s, t);
} inline void Query (int l, int r)
{
D res = Query (Root, l, r); double s = r - l + ;
double b = res.xy - s * (res.x / s) * (res.y / s);
b /= res.x2 - s * (res.x / s) * (res.x / s);
printf ("%.10lf\n", b);
}
}; Segment_Tree Seg; int Main ()
{
fread (buf, , BUF, stdin);
int N, M; read (N), read (M);
register int i; int x;
for (i = ; i <= N; ++ i)
read (x), _x[i] = (double) x;
for (i = ; i <= N; ++ i)
read (x), _y[i] = (double) x;
int type, y, s, t;
for (i = ; i <= N; ++ i)
_i[i] = _i[i - ] + i;
for (i = ; i <= N; ++ i)
i2[i] = i2[i - ] + i * i;
Seg.Build (, N);
for (i = ; i <= M; ++ i)
{
read (type);
if (type == )
{
read (x), read (y);
Seg.Query (x, y);
}
else if (type == )
{
read (x), read (y), read (s), read (t);
Seg.Change_1 (x, y, (double) s, (double) t);
}
else if (type == )
{
read (x), read (y), read (s), read (t);
Seg.Change_2 (x, y, (double) s, (double) t);
}
} return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <cstring> const int BUF = ;
char Buf[BUF], *buf = Buf; #define Mod 20170408 inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
} #define Max 20000007
#define L 100
struct Matrix
{
int c[L][L];
Matrix () { memset (c, , sizeof c); } Matrix operator * (const Matrix &now) const
{
Matrix res;
for (register int i = , j, k; i < L; ++ i)
for (k = ; k < L; ++ k)
if (this->c[i][k])
for (j = ; j < L; ++ j)
res.c[i][j] = (res.c[i][j] + 1LL * this->c[i][k] * now.c[k][j]) % Mod;
return res;
}
}; int operator ^ (Matrix A, int p)
{
Matrix res; res.c[][] = ;
for (; p; A = A * A, p >>= )
if (p & )
res = res * A;
return res.c[][];
} Matrix A;
int prime[Max];
bool is[Max];
int C; void Euler (const int N)
{
is[] = true;
for (register int i = , j; i <= N; ++ i)
{
if (!is[i]) prime[++ C] = i;
for (j = ; i * prime[j] <= N && j <= C; ++ j)
{
is[i * prime[j]] = true;
if (i % prime[j] == ) break;
}
}
} int data[Max]; int Main ()
{
fread (buf, , BUF, stdin);
int N, M, K; read (N), read (M), read (K);
Euler (Max - ); register int i, j; for (i = ; i <= M; ++ i) ++ data[i % K];
for (i = ; i < K; ++ i)
for (j = ; j < K; ++ j)
A.c[i][(i + j) % K] = data[j] % Mod;
int Answer = A ^ N; memset (A.c, , sizeof A.c);
memset (data, , sizeof data);
for (i = ; i <= M; ++ i)
if (is[i]) ++ data[i % K];
for (i = ; i < K; ++ i)
for (j = ; j < K; ++ j)
A.c[i][(i + j) % K] = data[j] % Mod;
Answer -= A ^ N; printf ("%d", (Answer + Mod) % Mod);
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#include <algorithm> const int BUF = ;
char Buf[BUF], *buf = Buf; inline void read (int &now)
{
bool temp = false;
for (now = ; !isdigit (*buf); ++ buf)
if (*buf == '-') temp = true;
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
if (temp) now = -now;
}
#define Max 800009 int x[Max], y[Max], s[Max];
int rank[Max], father[Max];
int Answer[Max], L, Stack[Max], top;
int list[Max], next[Max];
int N, M; void Dfs (int now)
{
Stack[++ top] = now;
if (now <= M)
for (int i = L; ; ++ i)
if (Stack[top - i] >= now + M)
{
Answer[now] = i;
break;
}
for (int i = list[now]; i; i = next[i])
Dfs (i);
-- top;
} int Main ()
{
freopen ("1.in", "r", stdin);
fread (buf, , BUF, stdin);
read (N), read (M); M = ;
register int i;
for (i = ; i <= N; ++ i)
read (x[i]), read (y[i]), rank[++ M] = x[i], rank[++ M] = y[i];
std :: sort (rank + , rank + + M);
int Size = std :: unique (rank + , rank + + M) - rank - ;
for (i = ; i <= N; ++ i)
{
s[i] = x[i] = std :: lower_bound (rank + , rank + + Size, x[i]) - rank;
y[i] = std :: lower_bound (rank + , rank + + Size, y[i]) - rank;
if (x[i] < y[i])
{
if (father[x[i]] < y[i]) father[x[i]] = y[i];
if (father[x[i] + M] < y[i] + M) father[x[i] + M] = y[i] + M;
}
else
{
if (father[] < y[i]) father[] = y[i];
if (father[x[i]] < y[i] + M) father[x[i]] = y[i] + M;
if (father[x[i] + M] < (M << )) father[x[i] + M] = (M << );
}
}
for (i = ; i <= (M << ); ++ i)
if (father[i] < father[i - ])
father[i] = father[i - ]; for (i = ; i < (M << ); ++ i)
next[i] = list[father[i]], list[father[i]] = i; for (L = -, i = ; i <= M; i = father[i]) ++ L;
for (Dfs (M << ), i = ; i <= N; ++ i)
printf ("%d ", Answer[s[i]]);
return ;
}
int ZlycerQan = Main ();
int main (int argc, char *argv[]) {;}
#include <cstdio>
#include <iostream>
#define Max 1000002
const int Mod = ; typedef long long LL;
inline void read (LL &now)
{
register char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
}
struct MT
{
#define L 2
#define Rg register int
LL c[][];
MT operator * (const MT A) const
{
MT res;
for (Rg i = , j, k; i < L; ++ i)
for (j = ; j < L; ++ j)
{
res.c[i][j] = ;
for (k = ; k < L; ++ k)
res.c[i][j] = (res.c[i][j] + c[i][k] * A.c[k][j]) % Mod;
}
return res;
}
#undef L
};
LL operator ^ (MT A, register LL p)
{
MT res; res.c[][] = res.c[][] = res.c[][] = ; res.c[][] = ;
if (p == || p == ) return ; else if (p == ) return ;
for (p -= ; p; p >>= )
{
if (p & ) res = res * A;
A = A * A;
}
return res.c[][];
}
#undef Rg
LL Gcd (LL a, LL b) { return !b ? a : Gcd (b, a % b); }
MT A; int Main ()
{
freopen ("spfa.in", "r", stdin); freopen ("spfa.out", "w", stdout);
LL N, M, P; read (N), read (M); register int i, j; P = Gcd (N, M);
A.c[][] = A.c[][] = A.c[][] = , A.c[][] = ;
P = A ^ P; std :: cout << P;
return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#include <algorithm>
#define Max 1200202
int c[Max];
inline void read (int &now)
{
register char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', ++ c);
}
int Main ()
{
freopen ("small.in", "r", stdin); freopen ("small.out", "w", stdout);
register int i; int N, T; read (T);
for (i = ; i <= T; ++ i)
{
read (N); for (i = ; i <= N; ++ i) read (c[i]);
std :: sort (c + , c + + N);
int S = std :: unique (c + , c + + N) - c - ;
printf (S == N ? "Happy\n" : "Sad\n%d\n", N - S);
}
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#define Max 1000002
int f[Max][];
#define INF 1e8
int p[] = { , , , , };
inline void min (int &a, int b) { if (b < a) a = b; return ;}
int Dfs (int n, int t)
{
if (n == ) return ; if (f[n][t]) return f[n][t]; f[n][t] = INF;
register int i;
for (i = ; i < ; ++ i)
if (!(n % p[i])) min (f[n][t], Dfs (n / p[i], ) + p[i]);
if (t == ) return f[n][t]; f[n][] = f[n][];
for (i = ; i <= ; ++ i) min (f[n][t], Dfs (n + i, ) + i);
return f[n][t];
}
int Main ()
{
freopen ("huaji.in", "r", stdin); freopen ("huaji.out", "w", stdout);
int N; scanf ("%d", &N); printf ("%d", Dfs (N, )); return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#include <cstdlib>
#define rg register
inline void read (int &now)
{
rg char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
}
#define Max 1000009
int f[Max], N, B, T, x, y;
int Find (int x) { return f[x] == x ? x : f[x] = Find (f[x]); }
int main ()
{
freopen ("dream.in", "r", stdin); freopen ("dream.out", "w", stdout);
int i, j, a, b;
for (read (T); T; -- T)
{
read (N), read (B), read (x), read (y);
for (i = ; i <= N; ++ i) f[i] = i;
for (i = B + ; i <= N; ++ i)
for (j = i * ; j <= N; j += i)
{
a = Find (i), b = Find (j);
if (a != b) f[b] = a;
}
if (Find (x) == Find (y)) printf ("YeS\n");
else printf ("No\n");
}
return ;
}
#include <cstdio>
#include <iostream>
#define rg register
inline void read (int &now)
{
rg char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
}
#define Max 100009
struct E { E *n; int v; } *list[Max], poor[Max << ], *Ta = poor;
int f[Max][Max / + ], s[Max], fa[Max], v[Max], k;
void Yukari (int n, int F)
{
fa[n] = F;
for (E *e = list[n]; e; ++ v[n], e = e->n)
if (e->v != F) Yukari (e->v, n);
}
void Dfs (int n)
{
for (E *e = list[n]; e; e = e->n)
{
int V; f[n][k] += f[V = e->v][k - ];
if (V == fa[n]) continue; Dfs (V);
}
if (k > ) f[n][k] -= f[n][k - ] * (v[n] - );
if (k == ) f[n][k] -= f[n][] * v[n];
s[n] += f[n][k];
}
int Main ()
{
freopen ("young.in", "r", stdin); freopen ("young.out", "w", stdout);
int N, K, R, C, x, y; read (R), read (C), read (N), read (K); rg int i;
for (i = ; i < N; ++ i)
{
read (x), read (y);
++ Ta, Ta->v = y, Ta->n = list[x], list[x] = Ta;
++ Ta, Ta->v = x, Ta->n = list[y], list[y] = Ta;
}
Yukari (, );
for (i = ; i <= N; ++ i) read (s[i]), f[i][] = s[i];
for (i = ; i <= K; ++ i) k = i, Dfs ();
for (i = ; i <= N; ++ i) printf ("%d\n", s[i]);
return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#include <algorithm>
#define rg register
inline void read (int &now)
{
rg char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
}
int Main ()
{
freopen ("moon.in", "r", stdin); freopen ("moon.out", "w", stdout);
int N; read (N); rg int i, j, Answer = ; int x;
for (i = ; i <= N; ++ i) read (x), Answer -= x, read (x), Answer += x;
for (i = ; i <= N; ++ i) read (x), Answer += x, read (x), Answer -= x;
printf ("%d", Answer);
return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#include <algorithm>
#define rg register
inline void read (int &now)
{
rg char c = getchar ();
for (now = ; !isdigit (c); c = getchar ());
for (; isdigit (c); now = now * + c - '', c = getchar ());
}
int Main ()
{
freopen ("moon.in", "r", stdin); freopen ("moon.out", "w", stdout);
int N; read (N); rg int i, j, Answer = ; int x;
for (i = ; i <= N; ++ i) read (x), Answer -= x, read (x), Answer += x;
for (i = ; i <= N; ++ i) read (x), Answer += x, read (x), Answer -= x;
printf ("%d", Answer);
return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#include <string>
#include <cstring>
#define rg register
#define Max 1000
typedef long long LL;
using std :: string;
char l[Max]; int c[Max]; string Answer;
int Main ()
{
freopen ("hwc.in", "r", stdin); freopen ("hwc.out", "w", stdout);
scanf ("%s", l); rg int i, j; int Len = strlen (l);
for (i = Len - ; i >= ; -- i)
{
c[i + ] = l[i] - '' + c[i + ] / , c[i + ] %= ;
if (i == Len - ) ++ c[i + ]; if (i == ) -- c[i + ];
}
bool f = false, p = false, e = false;
for (i = ; i <= Len; ++ i)
{
if (!c[i] && i == ) { f = true; continue; }
else if (!c[i] && i == && f) p = true, Answer.push_back ('');
else Answer.push_back (c[i] + '');
}
if (f && !p) e = true; else -- Len;
for (i = Len; i >= ; -- i)
{
if (!c[i] && i == ) continue;
else if (!c[i] && i == && f) Answer.push_back ('');
else Answer.push_back (c[i] + '');
}
std :: cout << Answer;
return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#include <cstring>
#define rg register
#define EPS 1e-3
#define INF 1e7
typedef double flo; const int BUF = ; char Buf[BUF], *buf = Buf;
inline void read (int &now)
{
for (now = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); now = now * + *buf - '', ++ buf);
}
#define Max 1010
struct E { E *n; int v, d; } *list[Max], poor[Max * ], *Ta = poor;
flo d[Max]; bool is[Max]; int c[Max];
bool Check (int n, flo key)
{
is[n] = true;
for (E *e = list[n]; e; e = e->n)
{
int V; flo r = c[(V = e->v)] - key * e->d;
if (d[V] < d[n] + r)
if (!is[V])
{
d[V] = d[n] + r;
if (Check (V, key)) return true;
}
else return true;
}
return is[n] = false;
}
int Main ()
{
fread (buf, , BUF, stdin);
int N, M, x, y, z; read (N), read (M); rg int i, j; flo Answer;
for (i = ; i <= N; ++ i) read (c[i]);
for (i = ; i <= M; ++ i)
{
read (x), read (y), read (z);
++ Ta, Ta->v = y, Ta->n = list[x], list[x] = Ta, Ta->d = z;
}
for (flo Mid, l = , r = 1000.0; r - l > EPS; )
{
Mid = (l + r) / 2.0;
for (i = ; i <= N; ++ i) d[i] = -INF;
memset (is, false, sizeof is); d[] = 0.0;
if (Check (, Mid)) l = Mid, Answer = Mid; else r = Mid;
}
printf ("%.2lf", Answer);
return ;
}
int ZlycerQan = Main (); int main (int argc, char *argv[]) { return ; }
#include <cstdio>
#include <iostream>
#define rg register
#define INF 1e8
void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 100005
struct SD
{
SD *L, *R; int v, k, Mid, l, r;
void Up () { v = L->v | R->v; }
} poor[Max << ], *null, *Ta = poor; int a[Max], N, M, A, B; class SegmentTree
{
private : SD *Root;
private :
SD *New (int x, int y)
{
++ Ta, Ta->L = Ta->R = null; Ta->v = ;
Ta->Mid = x + y >> ; Ta->l = x, Ta->r = y;
return Ta;
}
void Build (SD *&n, int l, int r)
{
n = New (l, r); if (l == r) { n->v = ; return ; }
Build (n->L, l, n->Mid); Build (n->R, n->Mid + , r);
n->k = ; n->Up ();
}
void C (SD *&n, int p, int k)
{
if (n->l == n->r) { n->v = k; return ; }
if (p <= n->Mid) C (n->L, p, k); else C (n->R, p, k); n->Up ();
if (n->v)
{
if (n->L->v && n->R->v) n->k = ;
else if (n->L->v) n->k = ; else n->k = ; return ;
}
n->k = ;
}
int Q (SD *&n, int l, int r)
{
if (n->v == ) return INF; int s = INF;
if (l <= n->l && n->r <= r)
{
if (n->l == n->r) return n->l;
if (n->k == || n->k == ) { s = Q (n->L, l, r); if (s != INF) return s; }
if (n->k == || n->k == ) { s = Q (n->R, l, r); if (s != INF) return s; }
return s;
}
if (l <= n->Mid && (n->k == || n->k == ))
{ s = Q (n->L, l, r); if (s != INF) return s; }
if (r > n->Mid && (n->k == || n->k == ))
{ s = Q (n->R, l, r); if (s != INF) return s; }
return INF;
} public : inline void Build (int l, int r)
{ Build (Root, l, r); C (a[], ), C (a[], ); }
inline void C (int p, int k) { return C (Root, p, k); }
inline int Q (int l, int r) { return Q (Root, l, r); }
};
SegmentTree Seg;
int main (int argc, char *argv[])
{
freopen ("lunch.in", "r", stdin); freopen ("lunch.out", "w", stdout);
rg int i, j; read (N), read (M), read (A), read (B), read (a[]), read (a[]);
null = Ta; null->L = null->R = null; null->l = null->r = null->v = null->k = null->Mid = ;
Seg.Build (, N - ); int li = , ri = N / , r;
for (i = ; i <= M; ++ i)
{
for (; i - li > ri; Seg.C (a[li ++], ));
a[i] = (1LL * A * a[i - ] + 1LL * B * a[i - ]) % N;
r = Seg.Q (a[i], N - );
if (r != INF) { a[i] = r; Seg.C (a[i], ); }
else { a[i] = Seg.Q (, a[i] - ); Seg.C (a[i], ); }
printf ("%d ", a[i]);
}
fclose (stdin); fclose (stdout); return ;
}
#include <cstdio>
#include <iostream>
#include <cstring>
#define rg register
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 1000005
struct E { E *n; int v; } *list[Max], poor[Max << ], *Ta = poor;
int m[Max], _m[Max], l[Max], Maxn, MaxP, Answer; bool is[Max];
void Dfs (int n, int F)
{
for (E *e = list[n]; e; e = e->n)
if (e->v != F)
l[e->v] = l[n] + , Dfs (e->v, n);
if (l[n] > Maxn) Maxn = l[n], MaxP = n;
}
int pre[Max];
void _Dfs (int n, int F)
{
for (E *e = list[n]; e; e = e->n)
if (e->v != F)
l[e->v] = l[n] + , _Dfs (e->v, n), pre[e->v] = n;
if (l[n] > Maxn) Maxn = l[n], MaxP = n;
}
inline void max (int &a, int b) { if (b > a) a = b; }
void Get (int n)
{
for (E *e = list[n]; e; e = e->n)
if (!is[e->v]) l[e->v] = l[n] + , is[e->v] = true, Get (e->v);
max (Answer, l[n]);
}
int main (int argc, char *argv[])
{
freopen ("tree.in", "r", stdin); freopen ("tree.out", "w", stdout);
rg int i, j; int N, x, y; read (N);
for (i = ; i < N; ++ i)
{
read (x), read (y);
++ Ta, Ta->v = y, Ta->n = list[x], list[x] = Ta;
++ Ta, Ta->v = x, Ta->n = list[y], list[y] = Ta;
}
Dfs (, ); memset (l, , sizeof l);
Maxn = ; int S = MaxP; _Dfs (MaxP, );
for (i = MaxP, is[S] = true; i != S; i = pre[i]) is[i] = true;
memset (l, , sizeof l);
for (i = ; i <= N; ++ i) if (is[i]) Get (i);
printf ("%d", Answer);
fclose (stdin); fclose (stdout); return ;
}
#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#define rg register
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
int N, M, Q;
#define Max 200009
int c[Max], b[Max], key[Max], Answer;
struct Q
{
int id, l, r;
bool operator < (const Q &A) const
{
return b[l] == b[A.l] ? r < A.r : b[l] < b[A.l];
}
} q[Max];
int Zly[Max];
void make (int n, int k, bool t)
{
key[c[n]] += k;
if (t)
{
if (c[n] < Answer && !key[c[n]] && !key[c[n] + ]) Answer = c[n];
if (c[n] - < Answer && !key[c[n] - ] && !key[c[n]] && c[n] - != ) Answer = c[n] - ;
}
else if (c[n] == Answer || c[n] == Answer + ) for (; key[Answer] || key[Answer + ]; ++ Answer);
}
int main (int argc, char *argv[])
{
freopen ("stall.in", "r", stdin); freopen ("stall.out", "w", stdout);
read (N), read (M), read (Q); int K_Size = sqrt (M); rg int i;
for (i = ; i <= M; ++ i) read (c[i]), b[i] = (i + ) / K_Size;
for (i = ; i <= Q; ++ i) q[i].id = i, read (q[i].l), read (q[i].r);
std :: sort (q + , q + + Q); int l = , r = ; Answer = ;
for (i = ; i <= Q; ++ i)
{
for (; l < q[i].l; make (l ++, -, true));
for (; l > q[i].l; make (-- l, , false));
for (; r < q[i].r; make (++ r, , false));
for (; r > q[i].r; make (r --, -, true));
Zly[q[i].id] = Answer; if (Answer > N) Zly[q[i].id] = -;
}
for (i = ; i <= Q; ++ i)
{
if (Zly[i] == -) printf ("-1 -1\n");
else printf ("%d %d\n", Zly[i], Zly[i] + );
}
fclose (stdin); fclose (stdout); return ;
}
#include <iostream>
#include <cstdio>
#include <cstring>
#define rg register
#define Max 10005
int N, M, C, Scc, ind, top, v[Max],w[Max], sv[Max],sw[Max]; bool in_stack[Max];
int dfn[Max],low[Max],belong[Max], stack[Max],f[Max][],in[];
inline int min (int a, int b) { return a < b ? a : b; }
inline int max (int a, int b) { return a > b ? a : b; }
struct E { E *n; int v; } *list1[Max * ], poor[Max * ], *Ta = poor, *list2[Max * ];
inline int read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
void Tarjan (int u)
{
int now = ; E *e;
dfn[u] = low[u] = ++ ind, stack[++ top] = u, in_stack[u] = ;
for (e = list1[u]; e; e = e->n)
{
int v = e->v;
if (!dfn[v]) Tarjan(v), low[u] = min (low[u], low[v]);
else if (in_stack[v]) low[u] = min (low[u], dfn[v]);
}
if (low[u] == dfn[u])
for (++ Scc; now != u; )
{
now = stack[top --]; in_stack[now] = ;
belong[now] = Scc, sw[Scc] += w[now], sv[Scc] += v[now];
}
}
void dp(int x)
{
rg int i, j, k; E *e;
for (e = list2[x]; e; e = e->n)
{
dp (e->v);
for (j = M - sw[x]; j >= ; -- j)
for (k = ; k <= j; ++ k) f[x][j] = max (f[x][j], f[x][k] + f[e->v][j - k]);
}
for (j = M; j >= ; -- j) { if (j >= sw[x]) f[x][j] = f[x][j - sw[x]] + sv[x]; else f[x][j]=; }
}
int main (int argc, char *argv[])
{
freopen ("T1.in", "r", stdin); freopen ("T1.out", "w", stdout);
int x; read (N), read (M); rg int i; E *e;
for (i = ; i <= N; ++ i) read (w[i]);
for (i = ; i <= N; ++ i) read (v[i]);
for (i = ; i <= N; ++ i) { read (x); if (x) ++ Ta, Ta->v = i, Ta->n = list1[x], list1[x] = Ta; }
for (i = ; i <= N; ++ i) if (!dfn[i]) Tarjan (i);
int v;
for (x = ; x <= N; ++ x)
for (e = list1[x]; e; e = e->n)
if (belong[(v = e->v)] != belong[x])
++ Ta, Ta->v = belong[v], Ta->n = list2[belong[x]], list2[belong[x]] = Ta, in[belong[v]] = ;
for (i = ; i <= Scc; ++ i) if(!in[i]) ++ Ta, Ta->v = i, Ta->n = list2[Scc + ], list2[Scc + ] = Ta, in[i] = ;
dp (Scc + ); printf ("%d\n", f[Scc + ][M]); return ;
}
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm> #define Max 400010
#define INF 233333333 int head[Max], nxt[Max], to[Max], tot = , num[Max];
inline int min (int a, int b) { return a < b ? a : b; }
inline int max (int a, int b) { return a > b ? a : b; }
int maxn[Max][],minn[Max][],anc[Max][],ans1[Max][],ans2[Max][], deep[Max];
const int BUF = ; char Buf[BUF], *buf = Buf;
void read (int &n)
{
for (n = ; !isdigit (*buf); ++ buf);
for (; isdigit (*buf); n = n * + *buf - '', ++ buf);
}
inline void cmax (int &a, int b) { if (b > a) a = b; }
inline void cmin (int &a, int b) { if (b < a) a = b; }
class SegmentTree
{
private : struct SD
{
SD *L, *R; int vu, vd, mx, mn, l, r, Mid;
inline void Up ()
{
mx = max (L->mx, R->mx), mn = min (L->mn, R->mn);
vu = R->mx - L->mn, vd = L->mx - R->mn;
}
} *Root, poor_T[Max << ], *TT;
inline SD* New (int x, int y)
{
++ TT, TT->l = x, TT->r = y, TT->Mid = x + y >> ;
TT->mx = TT->mn = TT->vu = TT->vd = ; TT->L = TT->R = NULL; return TT;
}
void Build (SD *&n, int l, int r)
{
n = New (l, r); if (l == r) { n->mx = n->mn = ; return ; }
Build (n->L, l, n->Mid), Build (n->R, n->Mid + , r); n->Up ();
}
int Q (SD *&n, int l, int r, bool t)
{
if (l <= n->l && n->r <= r) { if (t) return n->mx; return n->mn; } int A = ;
if (l <= n->Mid) A = Q (n->L, l, r, t);
if (r > n->Mid) { if (t) cmax (A, Q (n->R, l, r, t)); else cmin (A, Q (n->R, l, r, t)); };
return A;
}
public :
SegmentTree () { TT = poor_T; }
void Build (int l, int r) { return Build (Root, l, r); }
int Q_max (int l, int r) { return Q (Root, l, r, true); }
int Q_min (int l, int r) { return Q (Root, l, r, false); }
};
inline void build (int f, int t) { to[++tot]=t, nxt[tot]=head[f], head[f]=tot; }
void dfs (int u, int fa)
{
if(deep[u]) return ; register int i;
deep[u] = deep[fa]+; minn[u][] = min (num[u], num[fa]);
maxn[u][] = max (num[u], num[fa]); ans1[u][] = max (, num[u] - num[fa]);
ans2[u][] = max (, num[fa] - num[u]); anc[u][] = fa;
for(int i=;anc[u][i - ];i++)
{
anc[u][i] = anc[anc[u][i - ]][i - ];
maxn[u][i] = max (maxn[u][i - ], maxn[anc[u][i - ]][i - ]);
minn[u][i] = min (minn[u][i - ], minn[anc[u][i - ]][i - ]);
ans1[u][i] = max (max (ans1[u][i - ], ans1[anc[u][i - ]][i - ]), maxn[u][i - ] - minn[anc[u][i - ]][i - ]);
ans2[u][i] = max (max (ans2[u][i - ], ans2[anc[u][i - ]][i - ]), maxn[anc[u][i - ]][i - ] - minn[u][i - ]);
}
for (i = head[u]; i; i = nxt[i]) dfs(to[i],u);
}
inline void swap (int &a, int &b) { int c = a; a = b, b = c; }
int asklca (int x, int y)
{
int ans = ; register int i;
if(deep[x]<deep[y]) swap(x,y);
if (deep[x] > deep[y])
{
int dd = deep[x] - deep[y];
for(i = ; i >= ; -- i)
if (dd & ( << i)) x = anc[x][i];
}
if (x != y)
for(i = ; i >= ; -- i)
if(anc[x][i] != anc[y][i]) x = anc[x][i], y = anc[y][i];
if (x == y) return x; else return anc[x][];
}
int ask (int x, int y)
{
int lca = asklca(x,y);
int maxx = -INF, minnn = INF, ans = ;
int dd1 = deep[x] - deep[lca];
if (dd1 > )
for (int i = ; i >= ; -- i)
if (dd1 & ( << i))
{
ans = max (ans, max (ans2[x][i], maxn[x][i] - minnn));
minnn = min (minn[x][i], minnn); x = anc[x][i];
}
int dd2 = deep[y] - deep[lca];
if (dd2 > )
for (int i = ; i >= ; -- i)
if (dd2 & ( << i))
{
ans = max (ans, max (ans1[y][i], maxx - minn[y][i]));
maxx = max (maxn[y][i], maxx); y = anc[y][i];
}
return max (ans, maxx - minnn);
}
int main (int argc, char *argv[])
{
freopen ("T2.in", "r", stdin); freopen ("T2.out", "w", stdout);
register int i, j;
fread (buf, , BUF, stdin); int n; read (n);
for (i = ; i <= n; ++ i) read (num[i]);
for (i = ;i < n; ++ i)
{
int a,b;
read (a), read (b);
build(a,b); build(b,a);
}
dfs(,); int q; read (q);
for (int x, y; q --; )
read (x), read (y), printf("%d\n",ask(x,y));
return ;
}
跪膜myj%%%%%%%
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m,q,p,sx,sy,sz,sd,ex,ey,ez,ed,ans;
bool vis[][][];
inline void in(int &now)
{
char Cget;now=;while((Cget=getchar())>''||Cget<'');
while(Cget>=''&&Cget<='')now=now*+Cget-'',Cget=getchar();
}
void dfs(int x,int y,int z,int d,int step)
{
if(step>=ans) return;
if(x==ex&&ey==y&&ez==z&&d==ed)
{
ans=step;
return;
}
if(step==) return;
if(x==ex&&y==ey&&z==ez) return;
if(abs(ex-x)+abs(ey-y)+abs(ez-z)>(ans-step)*) return;
if(d==)
{
if(z+<=q)
if(!vis[x][y][z+]&&!vis[x][y][z+])
{
vis[x][y][z+]=vis[x][y][z+]=true;
if(y+<=m)
if(!vis[x][y+][z+]&&!vis[x][y+][z+])
{
vis[x][y+][z+]=vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=vis[x][y+][z+]=false;
}
if(y->=)
if(!vis[x][y-][z+]&&!vis[x][y-][z+])
{
vis[x][y-][z+]=vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=vis[x][y-][z+]=false;
}
if(x+<=n)
if(!vis[x+][y][z+]&&!vis[x+][y][z+])
{
vis[x+][y][z+]=vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=vis[x+][y][z+]=false;
}
if(x->=)
if(!vis[x-][y][z+]&&!vis[x-][y][z+])
{
vis[x-][y][z+]=vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=vis[x-][y][z+]=false;
}
vis[x][y][z+]=vis[x][y][z+]=false;
}
if(z->=)
if(!vis[x][y][z-]&&!vis[x][y][z])
{
vis[x][y][z]=vis[x][y][z-]=true;
if(y+<=m)
if(!vis[x][y+][z-]&&!vis[x][y+][z-])
{
vis[x][y+][z-]=vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=vis[x][y+][z-]=false;
}
if(y->=)
if(!vis[x][y-][z-]&&!vis[x][y-][z-])
{
vis[x][y-][z-]=vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=vis[x][y-][z-]=false;
}
if(x+<=n)
if(!vis[x+][y][z-]&&!vis[x+][y][z-])
{
vis[x+][y][z-]=vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=vis[x+][y][z-]=false;
}
if(x->=)
if(!vis[x-][y][z-]&&!vis[x-][y][z-])
{
vis[x-][y][z-]=vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=vis[x-][y][z-]=false;
}
vis[x][y][z]=vis[x][y][z-]=false;
}
if(z+<=q)
if(!vis[x][y][z+]&&!vis[x][y][z+]&&!vis[x][y][z+])
{
vis[x][y][z+]=vis[x][y][z+]=vis[x][y][z+]=true;
if(y+<=m)
if(!vis[x][y+][z+])
{
vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=false;
}
if(y-<=m)
if(!vis[x][y-][z+])
{
vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=false;
}
if(x+<=m)
if(!vis[x+][y][z+])
{
vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=false;
}
if(x-<=m)
if(!vis[x-][y][z+])
{
vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=false;
}
vis[x][y][z+]=vis[x][y][z+]=vis[x][y][z+]=false;
}
if(z->=)
if(!vis[x][y][z]&&!vis[x][y][z-]&&!vis[x][y][z-])
{
vis[x][y][z]=vis[x][y][z-]=vis[x][y][z-]=true;
if(y+<=m)
if(!vis[x][y+][z-])
{
vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=false;
}
if(y-<=m)
if(!vis[x][y-][z-])
{
vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=false;
}
if(x+<=m)
if(!vis[x+][y][z-])
{
vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=false;
}
if(x-<=m)
if(!vis[x-][y][z-])
{
vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=false;
}
vis[x][y][z]=vis[x][y][z-]=vis[x][y][z-]=false;
}
}
if(d==)
{
if(y+<=m)
if(!vis[x][y][z]&&!vis[x][y+][z])
{
vis[x][y][z]=vis[x][y+][z]=true;
if(z+<=q)
if(!vis[x][y+][z+]&&!vis[x][y+][z+])
{
vis[x][y+][z+]=vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=vis[x][y+][z+]=false;
}
if(z->=)
if(!vis[x][y+][z-]&&!vis[x][y+][z-])
{
vis[x][y+][z-]=vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=vis[x][y+][z-]=false;
}
if(x+<=n)
if(!vis[x+][y+][z]&&!vis[x+][y+][z])
{
vis[x+][y+][z]=vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=vis[x+][y+][z]=false;
}
if(x->=)
if(!vis[x-][y+][z]&&!vis[x-][y+][z])
{
vis[x-][y+][z]=vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=vis[x-][y+][z]=false;
}
vis[x][y][z]=vis[x][y+][z]=false;
}
if(y->=)
if(!vis[x][y-][z]&&!vis[x][y-][z])
{
vis[x][y-][z]=vis[x][y-][z]=true;
if(z+<=q)
if(!vis[x][y-][z+]&&!vis[x][y-][z+])
{
vis[x][y-][z+]=vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=vis[x][y-][z+]=false;
}
if(z->=)
if(!vis[x][y-][z-]&&!vis[x][y-][z-])
{
vis[x][y-][z-]=vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=vis[x][y-][z-]=false;
}
if(x+<=n)
if(!vis[x+][y-][z]&&!vis[x+][y-][z])
{
vis[x+][y-][z]=vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=vis[x+][y-][z]=false;
}
if(x->=)
if(!vis[x-][y-][z]&&!vis[x-][y-][z])
{
vis[x-][y-][z]=vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=vis[x-][y-][z]=false;
}
vis[x][y-][z]=vis[x][y-][z]=false;
}
if(y+<=m)
if(!vis[x][y][z]&&!vis[x][y+][z]&&!vis[x][y+][z])
{
vis[x][y][z]=vis[x][y+][z]=vis[x][y+][z]=true;
if(z+<=q)
if(!vis[x][y+][z+])
{
vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=false;
}
if(z->=)
if(!vis[x][y+][z-])
{
vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=false;
}
if(x+<=n)
if(!vis[x+][y+][z])
{
vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=false;
}
if(x->=)
if(!vis[x-][y+][z])
{
vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=false;
}
vis[x][y][z]=vis[x][y+][z]=vis[x][y+][z]=false;
}
if(y->=)
if(!vis[x][y-][z]&&!vis[x][y-][z]&&!vis[x][y-][z])
{
vis[x][y-][z]=vis[x][y-][z]=vis[x][y-][z]=true;
if(z+<=q)
if(!vis[x][y-][z+])
{
vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=false;
}
if(z->=)
if(!vis[x][y-][z-])
{
vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=false;
}
if(x+<=n)
if(!vis[x+][y-][z])
{
vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=false;
}
if(x->=)
if(!vis[x-][y-][z])
{
vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=false;
}
vis[x][y-][z]=vis[x][y-][z]=vis[x][y-][z]=false;
}
}
if(d==)
{
if(x+<=n)
if(!vis[x+][y][z]&&!vis[x+][y][z])
{
vis[x+][y][z]=vis[x+][y][z]=true;
if(z+<=q)
if(!vis[x+][y][z+]&&!vis[x+][y][z+])
{
vis[x+][y][z+]=vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=vis[x+][y][z+]=false;
}
if(z->=)
if(!vis[x+][y][z-]&&!vis[x+][y][z-])
{
vis[x+][y][z-]=vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=vis[x+][y][z-]=false;
}
if(y+<=m)
if(!vis[x+][y+][z]&&!vis[x+][y+][z])
{
vis[x+][y+][z]=vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=vis[x+][y+][z]=false;
}
if(y->=)
if(!vis[x+][y-][z]&&!vis[x+][y-][z])
{
vis[x+][y-][z]=vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=vis[x+][y-][z]=false;
}
vis[x+][y][z]=vis[x+][y][z]=false;
}
if(x->=)
if(!vis[x][y][z]&&!vis[x-][y][z])
{
vis[x][y][z]=vis[x-][y][z]=true;
if(z+<=q)
if(!vis[x-][y][z+]&&!vis[x-][y][z+])
{
vis[x-][y][z+]=vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=vis[x-][y][z+]=false;
}
if(z->=)
if(!vis[x-][y][z-]&&!vis[x-][y][z-])
{
vis[x-][y][z-]=vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=vis[x-][y][z-]=false;
}
if(y+<=m)
if(!vis[x-][y+][z]&&!vis[x-][y+][z])
{
vis[x-][y+][z]=vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=vis[x-][y+][z]=false;
}
if(y->=)
if(!vis[x-][y-][z]&&!vis[x-][y-][z])
{
vis[x-][y-][z]=vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=vis[x-][y-][z]=false;
}
vis[x][y][z]=vis[x-][y][z]=false;
}
if(x+<=n)
if(!vis[x+][y][z]&&!vis[x+][y][z]&&!vis[x+][y][z])
{
vis[x+][y][z]=vis[x+][y][z]=vis[x+][y][z]=true;
if(y+<=m)
if(!vis[x+][y+][z])
{
vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=false;
}
if(y->=)
if(!vis[x+][y-][z])
{
vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=false;
}
if(z+<=q)
if(!vis[x+][y][z+])
{
vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=false;
}
if(z->=)
if(!vis[x+][y][z-])
{
vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=false;
}
vis[x+][y][z]=vis[x+][y][z]=vis[x+][y][z]=false;
}
if(x->=)
if(!vis[x][y][z]&&!vis[x-][y][z]&&!vis[x-][y][z])
{
vis[x][y][z]=vis[x-][y][z]=vis[x-][y][z]=true;
if(y+<=m)
if(!vis[x-][y+][z])
{
vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=false;
}
if(y->=)
if(!vis[x-][y-][z])
{
vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=false;
}
if(z+<=q)
if(!vis[x-][y][z+])
{
vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=false;
}
if(z->=)
if(!vis[x-][y][z-])
{
vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=false;
}
vis[x][y][z]=vis[x-][y][z]=vis[x-][y][z]=false;
}
}
if(d==)
{
if(z+<=q)
if(!vis[x][y][z]&&!vis[x][y][z+])
{
vis[x][y][z]=vis[x][y][z+]=true;
if(y+<=m)
if(!vis[x][y+][z+]&&!vis[x][y+][z+])
{
vis[x][y+][z+]=vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=vis[x][y+][z+]=false;
}
if(y->=)
if(!vis[x][y-][z+]&&!vis[x][y-][z+])
{
vis[x][y-][z+]=vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=vis[x][y-][z+]=false;
}
if(x+<=n)
if(!vis[x+][y][z+]&&!vis[x+][y][z+])
{
vis[x+][y][z+]=vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=vis[x+][y][z+]=false;
}
if(x->=)
if(!vis[x-][y][z+]&&!vis[x-][y][z+])
{
vis[x-][y][z+]=vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=vis[x-][y][z+]=false;
}
vis[x][y][z]=vis[x][y][z+]=false;
}
if(z->=)
if(!vis[x][y][z-]&&!vis[x][y][z-])
{
vis[x][y][z-]=vis[x][y][z-]=true;
if(y+<=m)
if(!vis[x][y+][z-]&&!vis[x][y+][z-])
{
vis[x][y+][z-]=vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=vis[x][y+][z-]=false;
}
if(y->=)
if(!vis[x][y-][z-]&&!vis[x][y-][z-])
{
vis[x][y-][z-]=vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=vis[x][y-][z-]=false;
}
if(x+<=n)
if(!vis[x+][y][z-]&&!vis[x+][y][z-])
{
vis[x+][y][z-]=vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=vis[x+][y][z-]=false;
}
if(x->=)
if(!vis[x-][y][z-]&&!vis[x-][y][z-])
{
vis[x-][y][z-]=vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=vis[x-][y][z-]=false;
}
vis[x][y][z-]=vis[x][y][z-]=false;
}
if(z+<=q)
if(!vis[x][y][z]&&!vis[x][y][z+]&&!vis[x][y][z+])
{
vis[x][y][z+]=vis[x][y][z]=vis[x][y][z+]=true;
if(y+<=m)
if(!vis[x][y+][z+])
{
vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=false;
}
if(y-<=m)
if(!vis[x][y-][z+])
{
vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=false;
}
if(x+<=m)
if(!vis[x+][y][z+])
{
vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=false;
}
if(x-<=m)
if(!vis[x-][y][z+])
{
vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=false;
}
vis[x][y][z+]=vis[x][y][z+]=vis[x][y][z]=false;
}
if(z->=)
if(!vis[x][y][z-]&&!vis[x][y][z-]&&!vis[x][y][z-])
{
vis[x][y][z-]=vis[x][y][z-]=vis[x][y][z-]=true;
if(y+<=m)
if(!vis[x][y+][z-])
{
vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=false;
}
if(y-<=m)
if(!vis[x][y-][z-])
{
vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=false;
}
if(x+<=m)
if(!vis[x+][y][z-])
{
vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=false;
}
if(x-<=m)
if(!vis[x-][y][z-])
{
vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=false;
}
vis[x][y][z-]=vis[x][y][z-]=vis[x][y][z-]=false;
}
}
if(d==)
{
if(y+<=m)
if(!vis[x][y+][z]&&!vis[x][y+][z])
{
vis[x][y+][z]=vis[x][y+][z]=true;
if(z+<=q)
if(!vis[x][y+][z+]&&!vis[x][y+][z+])
{
vis[x][y+][z+]=vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=vis[x][y+][z+]=false;
}
if(z->=)
if(!vis[x][y+][z-]&&!vis[x][y+][z-])
{
vis[x][y+][z-]=vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=vis[x][y+][z-]=false;
}
if(x+<=n)
if(!vis[x+][y+][z]&&!vis[x+][y+][z])
{
vis[x+][y+][z]=vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=vis[x+][y+][z]=false;
}
if(x->=)
if(!vis[x-][y+][z]&&!vis[x-][y+][z])
{
vis[x-][y+][z]=vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=vis[x-][y+][z]=false;
}
vis[x][y+][z]=vis[x][y+][z]=false;
}
if(y->=)
if(!vis[x][y][z]&&!vis[x][y-][z])
{
vis[x][y-][z]=vis[x][y][z]=true;
if(z+<=q)
if(!vis[x][y-][z+]&&!vis[x][y-][z+])
{
vis[x][y-][z+]=vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=vis[x][y-][z+]=false;
}
if(z->=)
if(!vis[x][y-][z-]&&!vis[x][y-][z-])
{
vis[x][y-][z-]=vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=vis[x][y-][z-]=false;
}
if(x+<=n)
if(!vis[x+][y-][z]&&!vis[x+][y-][z])
{
vis[x+][y-][z]=vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=vis[x+][y-][z]=false;
}
if(x->=)
if(!vis[x-][y-][z]&&!vis[x-][y-][z])
{
vis[x-][y-][z]=vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=vis[x-][y-][z]=false;
}
vis[x][y][z]=vis[x][y-][z]=false;
}
if(y+<=m)
if(!vis[x][y+][z]&&!vis[x][y+][z]&&!vis[x][y+][z])
{
vis[x][y+][z]=vis[x][y+][z]=vis[x][y+][z]=true;
if(z+<=q)
if(!vis[x][y+][z+])
{
vis[x][y+][z+]=true;
dfs(x,y+,z+,,step+);
vis[x][y+][z+]=false;
}
if(z->=)
if(!vis[x][y+][z-])
{
vis[x][y+][z-]=true;
dfs(x,y+,z-,,step+);
vis[x][y+][z-]=false;
}
if(x+<=n)
if(!vis[x+][y+][z])
{
vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=false;
}
if(x->=)
if(!vis[x-][y+][z])
{
vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=false;
}
vis[x][y+][z]=vis[x][y+][z]=vis[x][y+][z]=false;
}
if(y->=)
if(!vis[x][y-][z]&&!vis[x][y-][z]&&!vis[x][y][z])
{
vis[x][y-][z]=vis[x][y-][z]=vis[x][y][z]=true;
if(z+<=q)
if(!vis[x][y-][z+])
{
vis[x][y-][z+]=true;
dfs(x,y-,z+,,step+);
vis[x][y-][z+]=false;
}
if(z->=)
if(!vis[x][y-][z-])
{
vis[x][y-][z-]=true;
dfs(x,y-,z-,,step+);
vis[x][y-][z-]=false;
}
if(x+<=n)
if(!vis[x+][y-][z])
{
vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=false;
}
if(x->=)
if(!vis[x-][y-][z])
{
vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=false;
}
vis[x][y-][z]=vis[x][y-][z]=vis[x][y][z]=false;
}
}
if(d==)
{
if(x+<=n)
if(!vis[x][y][z]&&!vis[x+][y][z])
{
vis[x][y][z]=vis[x+][y][z]=true;
if(z+<=q)
if(!vis[x+][y][z+]&&!vis[x+][y][z+])
{
vis[x+][y][z+]=vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=vis[x+][y][z+]=false;
}
if(z->=)
if(!vis[x+][y][z-]&&!vis[x+][y][z-])
{
vis[x+][y][z-]=vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=vis[x+][y][z-]=false;
}
if(y+<=m)
if(!vis[x+][y+][z]&&!vis[x+][y+][z])
{
vis[x+][y+][z]=vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=vis[x+][y+][z]=false;
}
if(y->=)
if(!vis[x+][y-][z]&&!vis[x+][y-][z])
{
vis[x+][y-][z]=vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=vis[x+][y-][z]=false;
}
vis[x+][y][z]=vis[x][y][z]=false;
}
if(x->=)
if(!vis[x-][y][z]&&!vis[x-][y][z])
{
vis[x-][y][z]=vis[x-][y][z]=true;
if(z+<=q)
if(!vis[x-][y][z+]&&!vis[x-][y][z+])
{
vis[x-][y][z+]=vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=vis[x-][y][z+]=false;
}
if(z->=)
if(!vis[x-][y][z-]&&!vis[x-][y][z-])
{
vis[x-][y][z-]=vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=vis[x-][y][z-]=false;
}
if(y+<=m)
if(!vis[x-][y+][z]&&!vis[x-][y+][z])
{
vis[x-][y+][z]=vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=vis[x-][y+][z]=false;
}
if(y->=)
if(!vis[x-][y-][z]&&!vis[x-][y-][z])
{
vis[x-][y-][z]=vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=vis[x-][y-][z]=false;
}
vis[x-][y][z]=vis[x-][y][z]=false;
}
if(x+<=n)
if(!vis[x+][y][z]&&!vis[x+][y][z]&&!vis[x][y][z])
{
vis[x+][y][z]=vis[x+][y][z]=vis[x][y][z]=true;
if(y+<=m)
if(!vis[x+][y+][z])
{
vis[x+][y+][z]=true;
dfs(x+,y+,z,,step+);
vis[x+][y+][z]=false;
}
if(y->=)
if(!vis[x+][y-][z])
{
vis[x+][y-][z]=true;
dfs(x+,y-,z,,step+);
vis[x+][y-][z]=false;
}
if(z+<=q)
if(!vis[x+][y][z+])
{
vis[x+][y][z+]=true;
dfs(x+,y,z+,,step+);
vis[x+][y][z+]=false;
}
if(z->=)
if(!vis[x+][y][z-])
{
vis[x+][y][z-]=true;
dfs(x+,y,z-,,step+);
vis[x+][y][z-]=false;
}
vis[x+][y][z]=vis[x+][y][z]=vis[x][y][z]=false;
}
if(x->=)
if(!vis[x-][y][z]&&!vis[x-][y][z]&&!vis[x-][y][z])
{
vis[x-][y][z]=vis[x-][y][z]=vis[x-][y][z]=true;
if(y+<=m)
if(!vis[x-][y+][z])
{
vis[x-][y+][z]=true;
dfs(x-,y+,z,,step+);
vis[x-][y+][z]=false;
}
if(y->=)
if(!vis[x-][y-][z])
{
vis[x-][y-][z]=true;
dfs(x-,y-,z,,step+);
vis[x-][y-][z]=false;
}
if(z+<=q)
if(!vis[x-][y][z+])
{
vis[x-][y][z+]=true;
dfs(x-,y,z+,,step+);
vis[x-][y][z+]=false;
}
if(z->=)
if(!vis[x-][y][z-])
{
vis[x-][y][z-]=true;
dfs(x-,y,z-,,step+);
vis[x-][y][z-]=false;
}
vis[x-][y][z]=vis[x-][y][z]=vis[x-][y][z]=false;
}
}
}
int main()
{
freopen("blessyou.in","r",stdin);
freopen("blessyou.out","w",stdout);
in(n),in(m),in(q),in(p);
char op[];
in(sx),in(sy),in(sz),scanf("%s",op);
if(op[]=='x')
if(sx==) sd=;
else sd=;
else
if(op[]=='y')
if(sy==) sd=;
else sd=;
else
if(sz==) sd=;
else sd=;
in(ex),in(ey),in(ez),scanf("%s",op);
if(op[]=='x')
if(ex==) ed=;
else ed=;
else
if(op[]=='y')
if(ey==) ed=;
else ed=;
else
if(ez==) ed=;
else ed=;
int tmpx,tmpy,tmpz;
for(int i=;i<=p;i++)
{
in(tmpx),in(tmpy),in(tmpz);
vis[tmpx][tmpy][tmpz]=true;
}
ans=;
dfs(sx,sy,sz,sd,);
if(ans==) cout<<"Dream Battle";
else cout<<ans;
return ;
}
#include <cstdio>
int main (int argc, char *argv[])
{
freopen ("count.in", "r", stdin); freopen ("count.out", "w", stdout);
int N; scanf ("%d", &N); int Answer = N; register int i, j;
for (i = ; i <= N; ++ i) for (j = i; j <= N; j += i) ++ Answer;
printf ("%d", Answer); fclose (stdin); fclose (stdout); return ;
}
#include <cstdio>
#include <iostream>
#define rg register
#define INF 2e9
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 400
int c[Max], s[Max][Max], f[Max][Max];
inline void cmin (int &a, int b) { if (b < a) a = b; }
int main (int argc, char *argv[])
{
freopen ("post.in", "r", stdin); freopen ("post.out", "w", stdout);
int N, M; read (N), read (M); rg int i, j, k;
for (i = ; i <= N; ++ i) read (c[i]);
for (i = ; i <= N; ++ i)
for (j = i + ; j <= N; ++ j) s[i][j] = s[i][j - ] + c[j] - c[(i + j) >> ];
for (i = ; i <= N; ++ i) f[i][] = s[][i];
for (i = ; i <= N; ++ i)
for (j = ; j <= M; ++ j)
for (k = , f[i][j] = INF; k < i; ++ k) cmin (f[i][j], f[k][j - ] + s[k + ][i]);
printf ("%d", f[N][M]); fclose (stdin); fclose (stdout); return ;
}
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#define rg register
#define Max 10001
const int Mod = ;
struct Int
{
int len, data[Max];
void clear() { memset(this, , sizeof(*this)); }
int &operator [] (int k) { return data[k]; }
Int &operator = (int k)
{
clear(), len = ;
for (; k; k >>= ) { ++ len, data[len] = k & Mod; }
if (len == ) ++len;
return *this;
}
Int operator * (Int & A)
{
Int temp; temp.clear (); temp.len = len + A.len - ; rg int i, j;
for (i = ; i <= len; ++ i)
for (j = ; j <= A.len; ++ j)
{
temp[i + j - ] += A[j] * data[i];
temp[i + j] += (temp[i + j - ] >> );
temp[i + j - ] &= Mod;
}
for (; temp[temp.len + ]; ++ temp.len); return temp;
}
void print()
{
for (rg int i = len; i >= ; i--) printf("%X", data[i]);
putchar('\n');
}
} temp, Answer;
std :: map <int, bool> M; bool f[Max * ]; int pnum, p[Max * ];
void Prepare(int M)
{
memset(f, , sizeof(f)); f[] = f[] = false;
p[pnum = ] = ; rg int now, j;
for (now = ; now < M;)
{
for (j = now + now; j <= M; f[j] = false, j += now);
for (++ now; now < M && !f[now]; ++ now);
if (f[now]) p[++pnum] = now;
}
}
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
int Gcd(int a, int b) { return !b ? a : Gcd(b, a % b); }
void work(int num)
{
for (rg int i = ; i <= pnum; i++)
{
if (num % p[i] == )
if (M[p[i]] == )
M[p[i]] = true, temp = p[i], Answer = Answer * temp;
for (; num % p[i] == ; num /= p[i]);
}
if (num != )
if (M[num] == )
M[num] = true, temp = num, Answer = Answer * temp;
}
int main (int argc, char *argv[])
{
freopen ("fraction.in", "r", stdin); freopen ("fraction.out", "w", stdout);
Answer = ; int t, a, b, d; read (t); Prepare ();
for (; t; -- t)
read (a), read (b), d = Gcd(a, b), a /= d, b /= d, work(b);
Answer.print(); fclose (stdin); fclose (stdout); return ;
}
#include <cstdio>
#include <iostream>
#include <queue>
#include <cstring>
std :: string Name = "fireworks", _I = ".in", _O = ".out";
#define rg register
#define flo double
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 201009
struct E { E *n; int v, d; } *list[Max], poor[Max << ], *Ta = poor;
int in[Max], dis[Max], N, M; bool is[Max];
void Spfa ()
{
std :: queue <int> Q; E * e; rg int i, n, v; memset (dis, /, sizeof dis);
for (i = ; i <= N; ++ i)
if (in[i] == ) Q.push (i), is[i] = true, dis[i] = ;
for (; !Q.empty (); Q.pop ())
for (n = Q.front (), is[n] = false, e = list[n]; e; e = e->n)
if (dis[v = e->v] > dis[n] + e->d)
{
dis[v] = dis[n] + e->d;
if (!is[v]) is[v] = true, Q.push (v);
}
}
inline void In (int x, int y, int z) { ++ Ta, Ta->v = y, Ta->n = list[x], list[x] = Ta, Ta->d = z, ++ in[y]; }
inline void cmax (flo &x, flo y) { if (y > x) x = y; }
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
rg int i; flo s; int x, y, z; E *e; read (M), N = M + ;
for (i = ; i <= M; ++ i)
read (x), read (y), read (z), In (x, y, z), In (y, x, z);
for (Spfa (), i = ; i <= N; ++ i)
for (e = list[i]; e; e = e->n)
cmax (s, (dis[i] + dis[e->v] + e->d) / 2.0);
printf ("%0.1lf", s); return ;
}
#include <cstdio>
#include <iostream>
std :: string Name = "stone", _I = ".in", _O = ".out";
#define rg register
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 120
#define INF 1e9
inline void cmax (int &a, int b) { if (b > a) a = b; }
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
int N, M, Mn, Mx, x, p; read (N), read (M); rg int i, j, k;
static int h[Max], s = ;
for (i = ; i <= N; ++ i)
{
for (j = , read (x), Mn = INF; j <= M - x + ; ++ j)
{
for (k = , Mx = ; k <= x; ++ k)
cmax (Mx, h[j + k - ]);
if (Mx < Mn) Mn = Mx, p = j;
}
for (j = ; j <= x; ++ j) h[p + j - ] = Mn + x;
}
for (i = ; i <= N; ++ i) cmax (s, h[i]);
printf ("%d", s); return ;
}
#include <cstdio>
#include <cstring>
#include <iostream>
#define rg register
#define Max 1000005
#define INF 1e9
std :: string Name = "piano", _I = ".in", _O = ".out";
int N, M, a[Max], f[Max], maxn[Max];
inline void read (int &n)
{
rg char c = getchar (); bool temp = false;
for (n = ; !isdigit (c); c = getchar ()) if (c == '-') temp = true;
for (; isdigit (c); n = n * + c - '', c = getchar ());
if (temp) n = -n;
}
inline int max (int a, int b) { return a > b ? a : b; }
inline int cmax (int &a, int b) { if (b > a) a = b; }
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
for (; scanf ("%d%d", &M, &N) != EOF; )
{
rg int i, j; int s = ; memset (f, , sizeof f);
memset (maxn, , sizeof maxn);
for (i = ; i <= N; ++ i) read (a[i]);
for (j = ; j <= M; ++ j)
for (i = j, s = -INF; i <= N; ++ i)
f[i] = max (f[i - ], maxn[i - ]) + a[i], maxn[i-]=s, cmax (s, f[i]);
printf ("%d\n",s);
}
return ;
}
/*
T1
对原矩阵做一遍模k意义下的二维前缀和
求多少子矩阵的和是K的倍数
易知若两个子矩阵和模K的余数相同，那么任取两个相减必定是k的倍数
那么统计一下前缀和中模k相同的数的对数即可
*/
#include <cstdio>
#include <iostream>
std :: string Name = "rally", _I = ".in", _O = ".out";
#define rg register
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 410
typedef long long LL; LL s[Max][Max]; LL _s; int c[], b[];
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
int N, M, K, z; read (N), read (M), read (K); rg int i, j, k;
for (i = ; i <= N; ++ i)
for (j = ; j <= M; ++ j)
read (z), s[i][j] = (s[i - ][j] + s[i][j - ] + z + K - s[i - ][j - ]) % K;
for (i = ; i <= N; ++ i)
for (j = i; j <= N; ++ j)
{
for (k = , c[] = ; k <= M; ++ k)
_s += c[(b[k] = s[j][k] + K - s[i - ][k]) %= K] ++;
for (k = ; k <= M; ++ k) c[b[k]] = ;
}
std :: cout << _s; return ;
}
#include <iostream>
#include <cstdio>
#define rg register
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
#define Max 100005
int N, K, s;
struct E { E *n; int v; } *list[Max], pool[Max << ], *Ta = pool;
inline void In (int u, int v)
{ ++ Ta, Ta->v = v, Ta->n = list[u], list[u] = Ta; }
inline void cmin (int &a, int b) { if (b < a) a = b; }
inline void cmax (int &a, int b) { if (b > a) a = b; }
int Dfs (int n, int F)
{
int mx = -N, mn = N, p; bool f = false; rg E *e; int v;
for (e = list[n]; e; e = e->n)
if ((v = e->v) != F)
f = true, p = Dfs (v, n), cmax (mx, p), cmin (mn, p);
if (!f) return ;
else if (mx + mn < ) return mn + ;
else if (mx >= K) { ++ s; return -K; }
else if (n == && mx >= ) { ++ s; return -K; }
else return mx + ;
}
std :: string Name = "general", _I = ".in", _O = ".out";
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
int T, x, y; read (N), read (K), read (T); rg int i;
if (K == ) return printf ("%d", N), ;
for (i = ; i < N; ++ i) read (x), read (y), In (x, y), In (y, x);
Dfs (, ); if (N <= ) s = ; printf ("%d", s); return ;
}
#include <cstring>
#include <cstdio>
#include <queue>
#include <iostream>
#define Max 40005
#define INF 1e8 namespace Z
{
void read (int &now)
{
now = ;
register char word = getchar ();
while (word < '' || word > '')
word = getchar ();
while (word >= '' && word <= '')
{
now = now * + word - '';
word = getchar ();
}
} inline int min (const int &_Qos_swc, const int &_Cos_ses)
{
return _Qos_swc < _Cos_ses ? _Qos_swc : _Cos_ses;
}
} int S, T = ;
int M, N, K;
int key[Max];
int size[Max], _r[Max];
int Answer;
int Count; int date[Max];
int number[Max]; int cost[Max / ][Max / ]; bool visit[Max];
int dis[Max]; void Bfs (int res)
{
memset (visit, false, sizeof (visit));
std :: queue <int> Queue;
visit[res] = true;
dis[res] = ;
Queue.push (res);
int now;
while (!Queue.empty ())
{
now = Queue.front ();
Queue.pop ();
for (int i = ; i <= M; i++)
{
if (now + size[i] <= N && (!visit[size[i] + now]))
{
visit[size[i] + now] = true;
dis[now + size[i]] = dis[now] + ;
Queue.push (now + size[i]);
}
if (now - size[i] >= && (!visit[now - size[i]]))
{
visit[now - size[i]] = true;
dis[now - size[i]] = dis[now] + ;
Queue.push (now - size[i]);
}
}
}
} class Net_Flow_Type
{
private : struct Edge_Date
{
int from;
int to;
int flow;
int next;
int cost;
}
edge[Max << ]; int Edge_Count;
int edge_list[Max];
int deep[Max];
int pre[Max]; public : void Prepare ()
{
Edge_Count = ;
} inline void AddEdge (int from, int to, int flow, int cost)
{
Edge_Count++;
edge[Edge_Count].from = from;
edge[Edge_Count].to = to;
edge[Edge_Count].flow = flow;
edge[Edge_Count].cost = cost;
edge[Edge_Count].next = edge_list[from];
edge_list[from] = Edge_Count;
Edge_Count++;
edge[Edge_Count].from = to;
edge[Edge_Count].to = from;
edge[Edge_Count].flow = ;
edge[Edge_Count].cost = -cost;
edge[Edge_Count].next = edge_list[to];
edge_list[to] = Edge_Count;
} bool Spfa ()
{
for (int i = ; i <= T; i++)
deep[i] = INF;
std :: queue <int> Queue;
memset (visit, false, sizeof visit);
Queue.push (S);
deep[S] = ;
visit[S] = true;
int now;
while (!Queue.empty ())
{
now = Queue.front ();
Queue.pop ();
for (int i = edge_list[now]; i; i = edge[i].next)
if (edge[i].flow && deep[now] + edge[i].cost < deep[edge[i].to])
{
deep[edge[i].to] = deep[now] + edge[i].cost;
pre[edge[i].to] = i;
if (!visit[edge[i].to])
{
visit[edge[i].to] = true;
Queue.push (edge[i].to);
}
}
visit[now] = false;
}
return deep[T] < INF;
} void Dinic ()
{
while (Spfa ())
{
int res = INF;
for (int i = pre[T]; i; i = pre[edge[i].from])
res = Z :: min (res, edge[i].flow);
for (int i = pre[T]; i; i = pre[edge[i].from])
{
edge[i].flow -= res;
edge[i ^ ].flow += res;
Answer += edge[i].cost * res;
}
}
} void Insert_Edges ()
{
for (int i = ; i <= Count; i++)
{
AddEdge (S, i, , );
AddEdge (i + Count, T, , );
}
for (int i = ; i <= Count; i++)
for (int j = ; j <= Count; j++)
if (i != j && cost[i][j] != INF)
AddEdge (i, j + Count, , cost[i][j]);
} }; Net_Flow_Type Make;
std :: string Name = "starlit", _I = ".in", _O = ".out";
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
Z :: read (N); Z :: read (K); Z :: read (M);
Make.Prepare (); int x;
for (int i = ; i <= K; i++) Z :: read (x), date[x] = true;
for (int i = ; i <= M; i++) Z :: read (size[i]);
for (int i = ; i <= N; i++)
if (date[i] != date[i + ]) number[i] = ++Count;
for (int i = ; i <= N; i++)
if (date[i] != date[i + ])
{
Bfs (i);
for (int j = ; j <= N; j++)
{
if (!number[j])
continue;
if (!visit[j])
cost[number[i]][number[j]] = INF;
else
cost[number[i]][number[j]] = dis[j];
}
}
Make.Insert_Edges ();
Make.Dinic ();
printf ("%d", Answer >> );
return ;
}
#include <iostream>
#include <cstdio>
#define rg register
#define Max 30005
int f[Max], s[Max], d[Max];
#undef Max
#define Max 30000
inline void read (int &n)
{
rg char c = getchar ();
for (n = ; !isdigit (c); c = getchar ());
for (; isdigit (c); n = n * + c - '', c = getchar ());
}
int Find (register int x)
{
for (; x != f[x]; x = f[x]) s[f[x]] = s[x] + ;
return x;
}
std :: string Name = "cube", _I = ".in", _O = ".out";
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
int N, x, y, z; read (N); rg int i; char t[];
for (i = ; i <= Max; ++ i) f[i] = d[i] = i;
for (; N; -- N)
{
scanf ("%s", t), read (x);
if (t[] == 'M')
{
read (y), z = d[y];
x = d[Find (x)], y = Find (y); f[y] = x;
for (; x != f[x]; x = f[x]) d[x] = z;
d[x] = z; Find (z);
}
else printf ("%d\n", s[x]);
}
return ;
}
#include <cstdio>
#include <iostream>
#include <cstring>
#define INF 1e8
#define Max 50010
char l[Max];
#define rg register
int _n[Max], _l[Max], N, S;
int rex[Max], rey[Max], rexn[Max], reyl[Max], t, T;
int Erase (int i)
{
int res = ;
for (int x, c, cl, cr, n, y, r; i != && i != T && (l[_l[i]] == l[i] || l[_n[i]] == l[i]); )
{
c = l[i]; cl = cr = ;
for (x = i; l[x] == c; ++ cl, x = _l[x]); -- cl;
for (y = i; l[y] == c; ++ cr, y = _n[y]); -- cr;
if (cl + cr >= )
{
if (x == ) S = y;
rex[++ t] = x, rey[t] = y, rexn[t] = _n[x], reyl[t] = _l[y], i = x, _n[x] = y, _l[y] = x, res += cl + cr + ;
}
else break;
}
return res;
}
int C, Answer = INF;
void Dfs (int Len, int s)
{
if (s >= Answer) return ;
if (Len <= ) { Answer = s; return ; }
int C0 = , C1 = , x, y, z, rs; rg int i;
for (i = S; i != T; i = _n[i])
{
if (l[i] == l[_n[i]])
{
x = _n[_n[i]], y = _l[_n[_n[i]]]; rs = S;
_n[_n[i]] = ++ C, _l[x] = C, l[C] = l[i]; _l[C] = _n[i], _n[C] = x;
Dfs (Len - Erase (C), s + ); S = rs;
for (; t; -- t) _n[rex[t]] = rexn[t], _l[rey[t]] = reyl[t];
_n[_n[i]] = x, _l[_n[_n[i]]] = y; -- C;
}
}
}
std :: string Name = "zuma", _I = ".in", _O = ".out";
int main (int argc, char *argv[])
{
freopen ((Name + _I).c_str (), "r", stdin);
freopen ((Name + _O).c_str (), "w", stdout);
scanf ("%s", l + ); N = strlen (l + ); rg int i, j; int C1 = , C0 = ;
for (i = ; i <= N; ++ i) _l[i] = i - , _n[i] = i + ; _n[N] = -; S = , T = -; C = N;
Dfs (N, ); printf ("%d", Answer); return ;
}
少女NULL中的更多相关文章
- TypeLoadException: 未能从程序集“ECS.GUI.Define, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中加载类型“ECS.GUI.Define.ArmgAimPos”，因为它在 4 偏移位置处包含一个对象字段，该字段已由一个非对象字段不正确地对齐或重叠
TypeLoadException: 未能从程序集"ECS.GUI.Define, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null ...
- 无法跨越程序集边界使用程序集“DataCheck, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”中的类型“List<ILayer>”，因为该类型有一个为嵌入互操作类型的泛型类型参数
主窗体: FrmDataInspect f2 = new FrmDataInspect(listMapControl1Lyr); f2.Show(); 弹出的窗体: 应该改为: gListMapLyr ...
- 解决Cannot read property 'style' of null中样式问题
<script type="text/javascript"> function updateTime(){ var timeNow = new Date(); var ...
- C# 调用webserver 出现：未能从程序集“jgd3jufm, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null”中加载类型
一般都是 用的动态调用webserver,然后这次用的是固定的 首先 最后 实例化改接口,然后直接传值调用
- oralce中exists not exists in not in对于NULL的处理
1. 先讨论 in 与 not in中存在NULL的情况, sql语句如下: 1 select 1 result1 from dual where 1 not in (2, 3); 2 3 4 s ...
- shell中>/dev/null 2>&1
本文转自http://www.kissyu.org/ 背景 我们经常能在shell脚本中发现>/dev/null 2>&1这样的语句.以前的我并没有去深入地理解这段命令的作用,照搬 ...
- linux下详解shell中>/dev/null 2>&1
前言 相信大家经常能在shell脚本中发现>/dev/null 2>&1这样的语句.以前的我并没有去深入地理解这段命令的作用,照搬照用,直到上周我将这段命令不小心写成了2>& ...
- [转帖]shell 中的>/dev/null 2>&1 是什么鬼？
shell 中的>/dev/null 2>&1 是什么鬼? http://blog.jobbole.com/109355/ 背景 我们经常能在shell脚本中发现>/dev/ ...
- /dev/null脚本中作用
/dev/null设备文件只有一个作用,往它里面写任何数据都直接丢弃. 因此保证了该命令执行时屏幕上没有任何输出. 在shell中常见. command > /dev/null 2> ...
随机推荐
- C#多线程解决程序卡顿问题
描述: 在 C# 中,System.Threading.Thread 类用于线程的工作.它允许创建并访问多线程应用程序中的单个线程.进程中第一个被执行的线程称为主线程. 案例: static void ...
- ASP.NET MVC 允许跨域请求设置
场景:创建一个图片上传的站点,用于其他站点跨域上传附件和图片之类. 上传插件结合百度的 webuploader.js 经常会碰到,跨域的问题,如下, 处理方式呢,是在web.config 中配置允许跨 ...
- jQuery常用方法(五)
一.jQuery中常用方法相关方法参数说明:a.无参,获取值b.参数param,设置值c.参数function(index,oldVal){}回调函数[返回我们所要使用的新值] 回调函数的两个参 ...
- jQuery绑定事件的四种方式：bind、live、delegate、on
1.jQuery操作DOM元素的绑定事件的四种方式 jQuery中提供了四种事件监听方式,分别是bind.live.delegate.on,对应的解除监听的函数分别是unbind.die.undele ...
- 安装部署Spark 1.x Standalone模式集群
Configuration spark-env.sh HADOOP_CONF_DIR=/opt/data02/hadoop-2.6.0-cdh5.4.0/etc/hadoop ...
- Tuple VS ValueTuple
深入理解 c# 元组与值元组(Tuple,ValueTuple) 为什么有此文章 首先要说的是我们公司内部技术框架是用 abp.vnext 框架整合而来的,我们架构师对于 abp 相关的知识都很了然于 ...
- 第一册：lesson 135.
原文:The latest report. question:Is Karen Marsh going to retire,do you think? Are you really going to ...
- MySQL--performance schema学习
启用performance schema 在MySQL 5.6.6版本后,performance schema被默认打开 通常MySQL的二进制版本都默认支持PS, 如果使用编译源码安装,在cmake ...
- mysql字符串截取函数和日期函数
注:mysql下标索引从1开始,并包含开始索引 1.left(str,len) index<=0,返回空 index>0,截取最左边len个字符 select ), ), ), ) 结果 ...
- postgresql9.5编译安装体验
实验环境: centos7.6 pgsql9.5 源码编译安装 实验目的: 体验源码编译安装pgsql 01.download https://ftp.postgresql.org/pub/sourc ...