From 40ca6089ccfa874ef1386362c9073597c53869e4 Mon Sep 17 00:00:00 2001 From: marioyc Date: Thu, 28 Aug 2014 18:18:12 +0200 Subject: [PATCH] ZOJ --- ZOJ/3604 - Tunnel Network.cpp | 32 ++++ ZOJ/3605 - Find the Marble.cpp | 58 +++++++ ZOJ/3611 - Ice Valley.cpp | 148 ++++++++++++++++ ZOJ/3620 - Escape Time II.cpp | 81 +++++++++ ZOJ/3623 - Battle Ships.cpp | 37 ++++ ZOJ/3627 - Treasure Hunt II.cpp | 47 +++++ ZOJ/3635 - Cinema in Akiba.cpp | 58 +++++++ ZOJ/3640 - Help Me Escape.cpp | 42 +++++ ZOJ/3644 - Kitty's Game.cpp | 77 +++++++++ ZOJ/3646 - Matrix Transformer.cpp | 70 ++++++++ ZOJ/3647 - Gao the Grid.cpp | 26 +++ ZOJ/3649 - Social Net.cpp | 160 ++++++++++++++++++ ZOJ/3656 - Bit Magic.cpp | 128 ++++++++++++++ ... - The Little Girl who Picks Mushrooms.cpp | 69 ++++++++ ZOJ/3659 - Conquer a New Region.cpp | 77 +++++++++ ZOJ/3662 - Math Magic.cpp | 102 +++++++++++ ZOJ/3665 - Yukari's Birthday.cpp | 78 +++++++++ ZOJ/3668 - Launching the Spacecraft.cpp | 50 ++++++ ZOJ/3686 - A Simple Tree Problem.cpp | 121 +++++++++++++ ZOJ/3690 - Choosing number.cpp | 53 ++++++ ZOJ/3691 - Flower.cpp | 147 ++++++++++++++++ ZOJ/3702 - Gibonacci number.cpp | 41 +++++ ZOJ/3772 - Calculate the Function.cpp | 72 ++++++++ ZOJ/3780 - Paint the Grid Again.cpp | 92 ++++++++++ 24 files changed, 1866 insertions(+) create mode 100644 ZOJ/3604 - Tunnel Network.cpp create mode 100644 ZOJ/3605 - Find the Marble.cpp create mode 100644 ZOJ/3611 - Ice Valley.cpp create mode 100644 ZOJ/3620 - Escape Time II.cpp create mode 100644 ZOJ/3623 - Battle Ships.cpp create mode 100644 ZOJ/3627 - Treasure Hunt II.cpp create mode 100644 ZOJ/3635 - Cinema in Akiba.cpp create mode 100644 ZOJ/3640 - Help Me Escape.cpp create mode 100644 ZOJ/3644 - Kitty's Game.cpp create mode 100644 ZOJ/3646 - Matrix Transformer.cpp create mode 100644 ZOJ/3647 - Gao the Grid.cpp create mode 100644 ZOJ/3649 - Social Net.cpp create mode 100644 ZOJ/3656 - Bit Magic.cpp create mode 100644 ZOJ/3657 - The Little Girl who Picks Mushrooms.cpp create mode 100644 ZOJ/3659 - Conquer a New Region.cpp create mode 100644 ZOJ/3662 - Math Magic.cpp create mode 100644 ZOJ/3665 - Yukari's Birthday.cpp create mode 100644 ZOJ/3668 - Launching the Spacecraft.cpp create mode 100644 ZOJ/3686 - A Simple Tree Problem.cpp create mode 100644 ZOJ/3690 - Choosing number.cpp create mode 100644 ZOJ/3691 - Flower.cpp create mode 100644 ZOJ/3702 - Gibonacci number.cpp create mode 100644 ZOJ/3772 - Calculate the Function.cpp create mode 100644 ZOJ/3780 - Paint the Grid Again.cpp diff --git a/ZOJ/3604 - Tunnel Network.cpp b/ZOJ/3604 - Tunnel Network.cpp new file mode 100644 index 0000000..701cd0e --- /dev/null +++ b/ZOJ/3604 - Tunnel Network.cpp @@ -0,0 +1,32 @@ +#include + +using namespace std; + +#define MOD 1000000007 + +long long mod_pow(long long a, int b){ + long long ret = 1; + + while(b){ + if(b & 1) ret = ret * a % MOD; + a = a * a % MOD; + b >>= 1; + } + + return ret; +} + +int main(){ + int T,N,S; + + scanf("%d",&T); + + while(T--){ + scanf("%d %d",&N,&S); + + if(N == S) printf("1\n"); + else printf("%lld\n",S * mod_pow(N,N - S - 1) % MOD); + } + + return 0; +} diff --git a/ZOJ/3605 - Find the Marble.cpp b/ZOJ/3605 - Find the Marble.cpp new file mode 100644 index 0000000..3447863 --- /dev/null +++ b/ZOJ/3605 - Find the Marble.cpp @@ -0,0 +1,58 @@ +#include +#include + +using namespace std; + +int s,a[50],b[50]; +long long memo[50][51][51]; + +long long solve(int pos, int have, int marble){ + if(have < 0) return 0; + + if(pos == -1){ + if(have > 0 || marble != s) return 0; + return 1; + } + + long long &ret = memo[pos][have][marble]; + + if(ret == -1){ + ret = solve(pos - 1,have,marble); + + if(marble == a[pos]) ret += solve(pos - 1,have - 1,b[pos]); + else if(marble == b[pos]) ret += solve(pos - 1,have - 1,a[pos]); + else ret += solve(pos - 1,have - 1,marble); + } + + return ret; +} + +int main(){ + int T,n,m,k; + + scanf("%d",&T); + + while(T--){ + scanf("%d %d %d %d",&n,&m,&k,&s); + + for(int i = 0;i < m;++i) + scanf("%d %d",&a[i],&b[i]); + + int ans = 1; + long long aux = 0; + memset(memo,-1,sizeof memo); + + for(int i = 1;i <= n;++i){ + long long ret = solve(m - 1,k,i); + + if(ret > aux){ + aux = ret; + ans = i; + } + } + + printf("%d\n",ans); + } + + return 0; +} diff --git a/ZOJ/3611 - Ice Valley.cpp b/ZOJ/3611 - Ice Valley.cpp new file mode 100644 index 0000000..61eac7d --- /dev/null +++ b/ZOJ/3611 - Ice Valley.cpp @@ -0,0 +1,148 @@ +#include +#include +#include + +using namespace std; + +int n,m; +char M[500][501]; +bool in[500][500]; +int er[500][500],ec[500][500],ed[500][500]; + +void dfs(int r, int c){ + if(er[r][c] != -1) return; + if(M[r][c] == '0' || M[r][c] == 'W' || M[r][c] == '$' || M[r][c] == '#'){ + er[r][c] = r; + ec[r][c] = c; + ed[r][c] = 0; + }else{ + int r2,c2; + + if(M[r][c] == 'L'){ + r2 = r; + c2 = c - 1; + }else if(M[r][c] == 'R'){ + r2 = r; + c2 = c + 1; + }else if(M[r][c] == 'D'){ + r2 = r + 1; + c2 = c; + }else{ + r2 = r - 1; + c2 = c; + } + + if(r2 == n || r2 == -1 || c2 == -1 || c2 == m || in[r2][c2]){ + er[r][c] = -2; + ec[r][c] = -2; + }else{ + in[r][c] = true; + dfs(r2,c2); + in[r][c] = false; + er[r][c] = er[r2][c2]; + ec[r][c] = ec[r2][c2]; + ed[r][c] = ed[r2][c2] + 1; + } + } +} + +struct node{ + int r,c,mask,dist; + + node(){} + + node(int _r, int _c, int _mask, int _dist): + r(_r), c(_c), mask(_mask), dist(_dist){} + + bool operator < (node X) const{ + return dist > X.dist; + } +}; + +int x1,y1,x2,y2,id[500][500],id2[110 + 10],dist[110 + 10][1 << 10]; +int dr[] = {-1,1,0,0}; +int dc[] = {0,0,-1,1}; + +int dijkstra(){ + memset(dist,-1,sizeof dist); + priority_queue Q; + Q.push(node(x1,y1,0,0)); + dist[ id[x1][y1] ][0] = 0; + + int best = -1,t = -1; + + while(!Q.empty()){ + node aux = Q.top(); + Q.pop(); + + if(dist[ id[aux.r][aux.c] ][aux.mask] != aux.dist) continue; + if(aux.r == x2 && aux.c == y2){ + int ntreasure = __builtin_popcount(aux.mask); + + if(ntreasure > best || (ntreasure == best && aux.dist < t)){ + best = ntreasure; + t = aux.dist; + } + } + + for(int k = 0;k < 4;++k){ + int r = aux.r + dr[k],c = aux.c + dc[k]; + + if(r >= 0 && r < n && c >= 0 && c < m){ + int d = ed[r][c]; + int r2 = er[r][c],c2 = ec[r][c]; + + if(r2 != -2 && (M[r2][c2] == '0' || M[r2][c2] == '$')){ + int to = id[r2][c2]; + int mask = aux.mask; + + if(M[r2][c2] == '$') mask |= id2[to]; + + if(dist[to][mask] == -1 || aux.dist + 1 + d < dist[to][mask]){ + Q.push(node(r2,c2,mask,aux.dist + 1 + d)); + dist[to][mask] = aux.dist + 1 + d; + } + } + } + } + } + + if(best != -1) t += 2 * best; + return t; +} + +int main(){ + while(scanf("%d %d",&n,&m) == 2){ + for(int i = 0;i < n;++i) + scanf("%s",M[i]); + + memset(in,false,sizeof in); + memset(er,-1,sizeof er); + int cont = 0,cont2 = 0; + memset(id,-1,sizeof id); + memset(id2,0,sizeof id2); + + for(int i = 0;i < n;++i){ + for(int j = 0;j < m;++j){ + dfs(i,j); + + if(M[i][j] == '0' || M[i][j] == '$'){ + if(M[i][j] == '$'){ + id2[cont] = (1 << cont2); + ++cont2; + } + + id[i][j] = cont; + ++cont; + } + } + } + + scanf("%d %d %d %d",&x1,&y1,&x2,&y2); + --x1; --y1; --x2; --y2; + + printf("%d\n",dijkstra()); + } + + return 0; +} diff --git a/ZOJ/3620 - Escape Time II.cpp b/ZOJ/3620 - Escape Time II.cpp new file mode 100644 index 0000000..449b255 --- /dev/null +++ b/ZOJ/3620 - Escape Time II.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include + +using namespace std; + +struct node{ + int cur,mask,t; + + node(){} + + node(int _cur, int _mask, int _t): + cur(_cur),mask(_mask),t(_t){} + + bool operator < (node X)const{ + return t > X.t; + } +}; + +int main(){ + int n,m,t,s,e,j[10],dist[10][1 << 10]; + vector L[10],W[10]; + int val[1 << 10]; + + while(scanf("%d %d %d",&n,&m,&t) == 3){ + scanf("%d %d",&s,&e); + + for(int i = 0;i < n;++i) + scanf("%d",&j[i]); + + val[0] = 0; + + for(int i = 1;i < (1 << n);++i){ + int x = __builtin_ctz(i); + val[i] = j[x] + val[i ^ (1 << x)]; + } + + for(int i = 0;i < n;++i){ + L[i].clear(); + W[i].clear(); + } + + for(int i = 0,a,b,c;i < m;++i){ + scanf("%d %d %d",&a,&b,&c); + L[a].push_back(b); + W[a].push_back(c); + L[b].push_back(a); + W[b].push_back(c); + } + + int ans = 0; + priority_queue Q; + memset(dist,-1,sizeof dist); + + Q.push(node(s,(1 << s),0)); + dist[0][1] = 0; + + while(!Q.empty()){ + node aux = Q.top(); + Q.pop(); + + if(aux.cur == e) ans = max(ans,val[aux.mask]); + + for(int i = L[aux.cur].size() - 1,to,mask,t2;i >= 0;--i){ + to = L[aux.cur][i]; + mask = (aux.mask | (1 << to)); + t2 = aux.t + W[aux.cur][i]; + + if(t2 <= t && (dist[to][mask] == -1 || t2 < dist[to][mask])){ + Q.push(node(to,mask,t2)); + dist[to][mask] = t2; + } + } + } + + printf("%d\n",ans); + } + + return 0; +} diff --git a/ZOJ/3623 - Battle Ships.cpp b/ZOJ/3623 - Battle Ships.cpp new file mode 100644 index 0000000..64b8e9b --- /dev/null +++ b/ZOJ/3623 - Battle Ships.cpp @@ -0,0 +1,37 @@ +#include +#include +#include + +using namespace std; + +int N,L,t[30],l[30]; +int memo[331][331]; + +int solve(int curL, int totall){ + if(totall < 0) return 0; + if(totall >= curL) return 1; + + int &ret = memo[curL][totall]; + + if(ret == -1){ + ret = totall == 0? 660 : (curL + totall - 1) / totall; + + for(int i = 0;i < N;++i) + ret = min(ret,t[i] + solve(curL - totall * t[i],totall + l[i])); + } + + return ret; +} + +int main(){ + while(scanf("%d %d",&N,&L) == 2){ + for(int i = 0;i < N;++i) + scanf("%d %d",&t[i],&l[i]); + + memset(memo,-1,sizeof memo); + + printf("%d\n",solve(L,0)); + } + + return 0; +} diff --git a/ZOJ/3627 - Treasure Hunt II.cpp b/ZOJ/3627 - Treasure Hunt II.cpp new file mode 100644 index 0000000..d5a2dd7 --- /dev/null +++ b/ZOJ/3627 - Treasure Hunt II.cpp @@ -0,0 +1,47 @@ +#include +#include + +using namespace std; + +#define MAXN 100005 + +int main(){ + int n,p,v[MAXN],M,T; + long long sum[MAXN]; + + while(scanf("%d %d",&n,&p) == 2){ + sum[0] = 0; + + for(int i = 0;i < n;++i){ + scanf("%d",&v[i]); + sum[i + 1] = sum[i] +v[i]; + } + + scanf("%d %d",&M,&T); + + long long ans = 0; + + for(int i = 1;i <= p;++i){ + int lo = p - 1,hi = n,mi; + + while(lo < hi){ + mi = (lo + hi + 1) >> 1; + + int z1 = min(mi,min(2 * p - i,i + M)); + int t1 = p - i + mi - z1; + + int z2 = max(i,max(2 * p - mi,mi - M)); + int t2 = mi - p + z2 - i; + + if(min(t1,t2) > T) hi = mi - 1; + else lo = mi; + } + + if(lo >= p) ans = max(ans,sum[lo] - sum[i - 1]); + } + + printf("%lld\n",ans); + } + + return 0; +} diff --git a/ZOJ/3635 - Cinema in Akiba.cpp b/ZOJ/3635 - Cinema in Akiba.cpp new file mode 100644 index 0000000..5271325 --- /dev/null +++ b/ZOJ/3635 - Cinema in Akiba.cpp @@ -0,0 +1,58 @@ +#include +#include + +using namespace std; + +#define MAXN 50000 + +int bit[MAXN + 1]; + +void update(int idx){ + for(int x = idx;x <= MAXN;x += x & -x) + ++bit[x]; +} + +int query(int idx){ + int ret = 0; + + for(int x = idx;x > 0;x -= x & -x) + ret += bit[x]; + + return ret; +} + +int main(){ + int N,Q,lo,hi,mi,ans[MAXN]; + + while(scanf("%d",&N) == 1){ + memset(bit,0,sizeof bit); + + for(int i = 1,a;i <= N;++i){ + scanf("%d",&a); + + lo = 1; hi = N; + + while(lo < hi){ + mi = (lo + hi) >> 1; + + if(mi - query(mi) < a) lo = mi + 1; + else hi = mi; + } + + ans[i] = lo; + update(lo); + } + + scanf("%d",&Q); + + for(int i = 0,x;i < Q;++i){ + scanf("%d",&x); + if(i) putchar(' '); + printf("%d",ans[x]); + } + + printf("\n"); + } + + return 0; +} diff --git a/ZOJ/3640 - Help Me Escape.cpp b/ZOJ/3640 - Help Me Escape.cpp new file mode 100644 index 0000000..9795247 --- /dev/null +++ b/ZOJ/3640 - Help Me Escape.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include + +using namespace std; + +int n,c[100],t[100]; +double memo[10002]; + +double solve(int curf){ + double &ret = memo[curf]; + + if(!(ret == ret)){ + ret = 0; + + for(int i = 0;i < n;++i){ + if(curf > c[i]) ret += t[i]; + else ret += 1 + solve(min(10001,curf + c[i])); + } + + ret /= n; + } + + return ret; +} + +int main(){ + int f; + + while(scanf("%d %d",&n,&f) == 2){ + for(int i = 0;i < n;++i){ + scanf("%d",&c[i]); + t[i] = floor((1 + sqrt(5)) / 2 * c[i] * c[i]); + } + + memset(memo,-1,sizeof memo); + printf("%.3f\n",solve(f)); + } + + return 0; +} diff --git a/ZOJ/3644 - Kitty's Game.cpp b/ZOJ/3644 - Kitty's Game.cpp new file mode 100644 index 0000000..83b18ba --- /dev/null +++ b/ZOJ/3644 - Kitty's Game.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +using namespace std; + +#define MOD 1000000007 +#define MAXN 2005 + +int N,M,K,p[MAXN]; +vector L[MAXN]; +int id[1000001],memo[MAXN][500]; + +int lcm(int a, int b){ + return a / __gcd(a,b) * b; +} + +int solve(int pos, int k){ + if(pos == N){ + if(k == K) return 1; + return 0; + } + + int &ret = memo[pos][ id[k] ]; + + if(ret == -1){ + ret = 0; + + for(int i = L[pos].size() - 1,to;i >= 0;--i){ + to = L[pos][i]; + + if(id[ p[to] ] != -1){ + int aux = lcm(k,p[to]); + + if(aux != k){ + ret += solve(to,aux); + if(ret >= MOD) ret -= MOD; + } + } + } + } + + return ret; +} + +int main(){ + int u,v; + + while(scanf("%d %d %d",&N,&M,&K) == 3){ + for(int i = 1;i <= N;++i) + L[i].clear(); + + for(int i = 0,u,v;i < M;++i){ + scanf("%d %d",&u,&v); + L[u].push_back(v); + } + + for(int i = 1;i <= N;++i) + scanf("%d",&p[i]); + + memset(id,-1,sizeof id); + int cont = 0; + + for(int i = 1;i <= K / i;++i){ + if(K % i == 0){ + id[i] = cont++; + id[K / i] = cont++; + } + } + + memset(memo,-1,sizeof memo); + printf("%d\n",K % p[1] == 0? solve(1,p[1]) : 0); + } + + return 0; +} diff --git a/ZOJ/3646 - Matrix Transformer.cpp b/ZOJ/3646 - Matrix Transformer.cpp new file mode 100644 index 0000000..74ed2c9 --- /dev/null +++ b/ZOJ/3646 - Matrix Transformer.cpp @@ -0,0 +1,70 @@ +#include +#include +#include + +using namespace std; + +vector L[200]; +int l[200],r[200]; +bool visited[200]; + +bool dfs(int cur){ + if(visited[cur]) return false; + visited[cur] = true; + + for(int i = L[cur].size() - 1,to;i >= 0;--i){ + to = L[cur][i]; + + if(l[to] == -1 || dfs(l[to])){ + r[cur] = to; + l[to] = cur; + return true; + } + } + + return false; +} + +bool matching(int V){ + memset(l,-1,sizeof l); + memset(r,-1,sizeof r); + bool found = true; + + while(found){ + memset(visited,false,sizeof visited); + found = false; + + for(int i = 0;i < V;++i) + if(r[i] == -1) + found |= dfs(i); + } + + int cont = 0; + + for(int i = 0;i < V;++i) + if(r[i] != -1) ++cont; + + return cont == V; +} + +int main(){ + int N; + char M[200][201]; + + while(scanf("%d",&N) == 1){ + for(int i = 0;i < N;++i) + scanf("%s",M[i]); + + for(int i = 0;i < N;++i) + L[i].clear(); + + for(int i = 0;i < N;++i) + for(int j = 0;j < N;++j) + if(M[i][j] == 'U') + L[i].push_back(j); + + puts(matching(N)? "YES" : "NO"); + } + + return 0; +} diff --git a/ZOJ/3647 - Gao the Grid.cpp b/ZOJ/3647 - Gao the Grid.cpp new file mode 100644 index 0000000..15ff1b7 --- /dev/null +++ b/ZOJ/3647 - Gao the Grid.cpp @@ -0,0 +1,26 @@ +#include +#include + +using namespace std; + +long long sum[1001][1001]; + +int main(){ + for(int i = 1;i <= 1000;++i) + for(int j = 1;j <= 1000;++j) + sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + __gcd(i,j) - 1; + + for(int i = 1;i <= 1000;++i) + for(int j = 1;j <= 1000;++j) + sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1]; + + int n,m; + long long nm; + + while(scanf("%d %d",&n,&m) == 2){ + nm = (long long)(n + 1) * (m + 1); + printf("%lld\n",nm * ((nm - 1) * (nm - 2) - n * (n - 1) - m * (m - 1)) / 6 - 2 * sum[n][m]); + } + + return 0; +} diff --git a/ZOJ/3649 - Social Net.cpp b/ZOJ/3649 - Social Net.cpp new file mode 100644 index 0000000..58d7883 --- /dev/null +++ b/ZOJ/3649 - Social Net.cpp @@ -0,0 +1,160 @@ +#include +#include +#include + +using namespace std; + +#define MAXN 30005 +#define MAXM 50005 + +struct edge{ + int u,v,a; + + edge(){} + + bool operator < (edge X)const{ + return a > X.a; + } +}e[MAXM]; + +int parent[MAXN]; + +int Find(int x){ + if(parent[x] != x) parent[x] = Find(parent[x]); + return parent[x]; +} + +vector L[MAXN]; +int h[MAXN],p[15][MAXN],mn[15][MAXN],mx[15][MAXN],best[15][MAXN],best2[15][MAXN]; + +void dfs(int cur, int par, int lvl){ + h[cur] = lvl; + p[0][cur] = par; + + for(int i = L[cur].size() - 1,to;i >= 0;--i){ + to = L[cur][i]; + if(to != par) dfs(to,cur,lvl + 1); + } +} + +int lca(int u, int v){ + if(h[v] > h[u]) swap(u,v); + + int diff = h[u] - h[v]; + + for(int i = 14;i >= 0;--i) + if(diff & (1 << i)) + u = p[i][u]; + + for(int i = 14;i >= 0;--i) + if(p[i][u] != p[i][v]){ + u = p[i][u]; + v = p[i][v]; + } + + if(u == v) return u; + return p[0][u]; +} + +int main(){ + int N,M,b[MAXN],Q,X,Y,Z; + + while(scanf("%d",&N) == 1){ + for(int i = 1;i <= N;++i) + scanf("%d",&b[i]); + + scanf("%d",&M); + + for(int i = 0;i < M;++i) + scanf("%d %d %d",&e[i].u,&e[i].v,&e[i].a); + + sort(e,e + M); + + for(int i = 1;i <= N;++i){ + parent[i] = i; + L[i].clear(); + } + + long long sum = 0; + + for(int i = 0,u,v;i < M;++i){ + u = Find(e[i].u); v = Find(e[i].v); + + if(u != v){ + parent[u] = v; + L[ e[i].u ].push_back(e[i].v); + L[ e[i].v ].push_back(e[i].u); + sum += e[i].a; + } + } + + printf("%lld\n",sum); + + dfs(1,0,0); + + for(int i = 1;i <= N;++i){ + mn[0][i] = mx[0][i] = b[i]; + best[0][i] = 0; + } + + for(int i = 1;i <= 14;++i){ + for(int j = 1;j <= N;++j){ + p[i][j] = p[i - 1][ p[i - 1][j] ]; + mn[i][j] = min(mn[i - 1][j],mn[i - 1][ p[i - 1][j] ]); + mx[i][j] = max(mx[i - 1][j],mx[i - 1][ p[i - 1][j] ]); + best[i][j] = max(max(best[i - 1][j],best[i - 1][ p[i - 1][j] ]),mx[i - 1][ p[i - 1][j] ] - mn[i - 1][j]); + best2[i][j] = max(max(best2[i - 1][j],best2[i - 1][ p[i - 1][j] ]),mx[i - 1][j] - mn[i - 1][ p[i - 1][j] ]); + } + } + + scanf("%d",&Q); + + while(Q--){ + scanf("%d %d",&X,&Y); + Z = lca(X,Y); + + vector mn1,mx1,mn2,mx2; + int n1 = 0,n2 = 0,ans = 0; + + int diff = h[X] - h[Z] + 1; + + for(int i = 14;i >= 0;--i){ + if(diff & (1 << i)){ + mn1.push_back(mn[i][X]); + mx1.push_back(mx[i][X]); + ans = max(ans,best[i][X]); + X = p[i][X]; + ++n1; + } + } + + diff = h[Y] - h[Z] + 1; + + for(int i = 14;i >= 0;--i){ + if(diff & (1 << i)){ + mn2.push_back(mn[i][Y]); + mx2.push_back(mx[i][Y]); + ans = max(ans,best2[i][Y]); + Y = p[i][Y]; + ++n2; + } + } + + int x = 100000; + + for(int i = 0;i < n1;++i){ + ans = max(ans,mx1[i] - x); + x = min(x,mn1[i]); + } + + for(int i = n2 - 1;i >= 0;--i){ + ans = max(ans,mx2[i] - x); + x = min(x,mn2[i]); + } + + printf("%d\n",ans); + } + } + + return 0; +} diff --git a/ZOJ/3656 - Bit Magic.cpp b/ZOJ/3656 - Bit Magic.cpp new file mode 100644 index 0000000..0402c5a --- /dev/null +++ b/ZOJ/3656 - Bit Magic.cpp @@ -0,0 +1,128 @@ +#include +#include +#include +#include + +using namespace std; + +#define MAXN 500 + +vector L[2 * MAXN]; +stack S; +int low[2 * MAXN],curh; +bool in_stack[2 * MAXN]; +int cont_scc,id_scc[2 * MAXN]; + +void tarjan(int cur){ + S.push(cur); + in_stack[cur] = true; + low[cur] = ++curh; + + for(int i = L[cur].size() - 1,to;i >= 0;--i){ + to = L[cur][i]; + + if(low[to] == -1){ + tarjan(to); + low[cur] = min(low[cur],low[to]); + }else if(in_stack[to]){ + low[cur] = min(low[cur],low[to]); + } + } + + if(low[cur] == curh){ + int nxt; + + do{ + nxt = S.top(); + S.pop(); + in_stack[nxt] = false; + id_scc[nxt] = cont_scc; + }while(nxt != cur); + + ++cont_scc; + } + + --curh; +} + +void build_scc(int V){ + memset(low,-1,sizeof low); + memset(in_stack,false,sizeof in_stack); + curh = cont_scc = 0; + + for(int i = 0;i < V;++i) + if(low[i] == -1) + tarjan(i); +} + +int main(){ + int N,b[MAXN][MAXN]; + + while(scanf("%d",&N) == 1){ + for(int i = 0;i < N;++i) + for(int j = 0;j < N;++j) + scanf("%d",&b[i][j]); + + bool ok = true; + + for(int i = 0;i < N;++i){ + if(b[i][i] != 0) ok = false; + + for(int j = i + 1;j < N;++j) + if(b[i][j] != b[j][i]) + ok = false; + } + + for(int p = 0;p < 31 && ok;++p){ + for(int i = 0;i < 2 * N;++i) + L[i].clear(); + + for(int i = 0,i2 = 0;i < N;++i,i2 ^= 1){ + for(int j = 0,j2 = 0;j < N;++j,j2 ^= 1){ + int x = ((b[i][j] >> p) & 1); + + if(i == j) ; + else if(i2 == 1 && j2 == 1){ + if(x){ + L[j + N].push_back(i); + L[i + N].push_back(j); + }else{ + L[i].push_back(i + N); + L[j].push_back(j + N); + } + }else if(i2 == 0 && j2 == 0){ + if(x){ + L[i + N].push_back(i); + L[j + N].push_back(j); + }else{ + L[i].push_back(j + N); + L[j].push_back(i + N); + } + }else{ + if(x){ + L[i].push_back(j + N); + L[j].push_back(i + N); + L[i + N].push_back(j); + L[j + N].push_back(i); + }else{ + L[i].push_back(j); + L[j].push_back(i); + L[i + N].push_back(j + N); + L[j + N].push_back(i + N); + } + } + } + } + + build_scc(2 * N); + + for(int i = 0;i < N;++i) + if(id_scc[i] == id_scc[i + N]) + ok = false; + } + + puts(ok? "YES" : "NO"); + } + + return 0; +} diff --git a/ZOJ/3657 - The Little Girl who Picks Mushrooms.cpp b/ZOJ/3657 - The Little Girl who Picks Mushrooms.cpp new file mode 100644 index 0000000..b22c0a9 --- /dev/null +++ b/ZOJ/3657 - The Little Girl who Picks Mushrooms.cpp @@ -0,0 +1,69 @@ +#include +#include + +using namespace std; + +int a[5]; + +int solve4(){ + int ret = 0,total = a[0] + a[1] + a[2] + a[3]; + + for(int i = 0;i < 2;++i) + for(int j = i + 1;j < 3;++j) + for(int k = j + 1;k < 4;++k) + if((a[i] + a[j] + a[k]) % 1024 == 0) + return 1024; + + for(int i = 0;i < 3;++i){ + for(int j = i + 1;j < 4;++j){ + int sum = total - a[i] - a[j]; + + if(sum > 0){ + sum %= 1024; + if(sum == 0) sum = 1024; + ret = max(ret,sum); + } + } + } + + return ret; +} + +int solve5(){ + int ret = 0,total = a[0] + a[1] + a[2] + a[3] + a[4]; + + for(int i = 0;i < 3;++i){ + for(int j = i + 1;j < 4;++j){ + for(int k = j + 1;k < 5;++k){ + int sum = a[i] + a[j] + a[k]; + + if(sum % 1024 == 0){ + sum = total - sum; + + if(sum > 0){ + sum %= 1024; + if(sum == 0) sum = 1024; + ret = max(ret,sum); + } + } + } + } + } + + return ret; +} + +int main(){ + int n; + + while(scanf("%d",&n) == 1){ + for(int i = 0;i < n;++i) + scanf("%d",&a[i]); + + if(n <= 3) printf("1024\n"); + else if(n == 4) printf("%d\n",solve4()); + else printf("%d\n",solve5()); + } + + return 0; +} diff --git a/ZOJ/3659 - Conquer a New Region.cpp b/ZOJ/3659 - Conquer a New Region.cpp new file mode 100644 index 0000000..a0b56c8 --- /dev/null +++ b/ZOJ/3659 - Conquer a New Region.cpp @@ -0,0 +1,77 @@ +#include +#include +#include +#include + +using namespace std; + +#define MAXN 200005 + +struct edge{ + int u,v,w; + + edge(){} + + edge(int _u, int _v, int _w): + u(_u),v(_v),w(_w){} + + bool operator < (edge X)const{ + return w > X.w; + } +}e[MAXN]; + +int parent[MAXN],cont[MAXN]; +long long lazy[MAXN]; + +int Find(int x){ + if(parent[x] != x){ + int r = Find(parent[x]); + if(r != parent[x]) lazy[x] += lazy[ parent[x] ]; + parent[x] = r; + } + + return parent[x]; +} + +void Union(int u, int v, int w){ + u = Find(u); + v = Find(v); + + if(cont[v] > cont[u]) swap(u,v); + + lazy[v] += (long long)(cont[u] - cont[v]) * w - lazy[u]; + lazy[u] += (long long)cont[v] * w; + cont[u] += cont[v]; + parent[v] = u; +} + +int main(){ + int N; + + while(scanf("%d",&N) == 1){ + for(int i = 0;i < N - 1;++i) + scanf("%d %d %d",&e[i].u,&e[i].v,&e[i].w); + + for(int i = 1;i <= N;++i){ + parent[i] = i; + cont[i] = 1; + lazy[i] = 0; + } + + sort(e,e + (N - 1)); + + for(int i = 0;i < N - 1;++i) + Union(e[i].u,e[i].v,e[i].w); + + long long ans = 0; + + for(int i = 1;i <= N;++i){ + Find(i); + ans = max(ans,lazy[i] + (parent[i] == i? 0 : lazy[ parent[i] ])); + } + + printf("%lld\n",ans); + } + + return 0; +} diff --git a/ZOJ/3662 - Math Magic.cpp b/ZOJ/3662 - Math Magic.cpp new file mode 100644 index 0000000..befc434 --- /dev/null +++ b/ZOJ/3662 - Math Magic.cpp @@ -0,0 +1,102 @@ +#include +#include +#include + +using namespace std; + +#define MOD 1000000007 + +vector p,e; +int np; + +int get_mask(int x){ + int ret = 0; + + for(int i = 0;i < np;++i){ + int aux = 0; + + while(x % p[i] == 0){ + x /= p[i]; + ++aux; + } + + if(aux == e[i]) ret |= (1 << i); + } + + return ret; +} + +int memo[100][1001][1 << 5]; +vector div,use; +int ndiv; + +int solve(int pos, int sum, int mask){ + if(sum < 0) return 0; + if(pos == -1){ + if(sum == 0 && mask == (1 << np) - 1) return 1; + return 0; + } + + int &ret = memo[pos][sum][mask]; + + if(ret == -1){ + ret = 0; + + for(int i = 0;i < ndiv;++i){ + ret += solve(pos - 1,sum - div[i],mask | use[i]); + if(ret >= MOD) ret -= MOD; + } + } + + return ret; +} + +int main(){ + int N,M,K; + + while(scanf("%d %d %d",&N,&M,&K) == 3){ + p.clear(); e.clear(); np = 0; + int M2 = M; + + for(int i = 2;i <= M2 / i;++i){ + if(M2 % i == 0){ + p.push_back(i); ++np; + int aux = 0; + + while(M2 % i == 0){ + M2 /= i; + ++aux; + } + + e.push_back(aux); + } + } + + if(M2 != 1){ + p.push_back(M2); + e.push_back(1); + ++np; + } + + div.clear(); use.clear(); ndiv = 0; + + for(int i = 1;i <= M / i;++i){ + if(M % i == 0){ + div.push_back(i); + use.push_back(get_mask(i)); + ++ndiv; + + if(i != M / i){ + div.push_back(M / i); + use.push_back(get_mask(M / i)); + ++ndiv; + } + } + } + + memset(memo,-1,sizeof memo); + printf("%d\n",solve(K - 1,N,0)); + } + + return 0; +} diff --git a/ZOJ/3665 - Yukari's Birthday.cpp b/ZOJ/3665 - Yukari's Birthday.cpp new file mode 100644 index 0000000..603495f --- /dev/null +++ b/ZOJ/3665 - Yukari's Birthday.cpp @@ -0,0 +1,78 @@ +#include +#include +#include + +using namespace std; + +#define MAXVAL 1000000000000LL + +struct sol{ + long long n; + int kr,r; + + sol(){} + + sol(long long _n, int _kr, int _r): + n(_n), kr(_kr), r(_r){} + + bool operator < (sol X)const{ + if(n != X.n) return n < X.n; + if(kr != X.kr) return kr < X.kr; + return r < X.r; + } +}; + +vector v; +int m; + +void solve(long long n, long long &kr, int &r){ + int lo = 0,hi = m - 1,mi; + + while(lo < hi){ + mi = (lo + hi) >> 1; + + if(v[mi].n < n) lo = mi + 1; + else hi = mi; + } + + if(v[lo].n == n){ + kr = v[lo].kr; + r = v[lo].r; + }else{ + kr = n; + r = 1; + } +} + +int main(){ + for(int k = 2;k <= 1000000;++k){ + int r = 1; + long long x = k; + + while(x <= (MAXVAL - k) / k){ + x = k * x + k; + ++r; + v.push_back(sol(x,k * r,r)); + } + } + + sort(v.begin(),v.end()); + m = v.size(); + + long long n,kr1,kr2; + int r1,r2; + + while(scanf("%lld",&n) == 1){ + solve(n,kr1,r1); + solve(n - 1,kr2,r2); + + if(kr2 < kr1 || (kr2 == kr1 && r2 < r1)){ + kr1 = kr2; + r1 = r2; + } + + printf("%d %lld\n",r1,kr1 / r1); + } + + return 0; +} diff --git a/ZOJ/3668 - Launching the Spacecraft.cpp b/ZOJ/3668 - Launching the Spacecraft.cpp new file mode 100644 index 0000000..f4da389 --- /dev/null +++ b/ZOJ/3668 - Launching the Spacecraft.cpp @@ -0,0 +1,50 @@ +#include + +using namespace std; + +int u[22000],v[22000],w[22000],ne; +int dist[1001]; + +int main(){ + int N,M,l,r,a,b; + + while(scanf("%d %d",&N,&M) == 2){ + ne = 0; + + for(int i = 0;i < M;++i){ + scanf("%d %d %d %d",&l,&r,&a,&b); + u[ne] = l - 1; v[ne] = r; w[ne] = b; ++ne; + u[ne] = r; v[ne] = l - 1; w[ne] = -a; ++ne; + } + + for(int i = 1;i <= N;++i){ + u[ne] = i - 1; v[ne] = i; w[ne] = 10000; ++ne; + u[ne] = i; v[ne] = i - 1; w[ne] = 10000; ++ne; + } + + bool found; + dist[0] = 0; + + for(int i = 1;i <= N;++i) + dist[i] = 10000000; + + for(int i = 0;i <= N;++i){ + found = false; + + for(int j = 0;j < ne;++j){ + if(dist[ v[j] ] > dist[ u[j] ] + w[j]){ + dist[ v[j] ] = dist[ u[j] ] + w[j]; + found = true; + } + } + } + + if(found) printf("The spacecraft is broken!\n"); + else{ + for(int i = 0;i < N;++i) + printf("%d%c",dist[i + 1] - dist[i],i == N - 1? '\n':' '); + } + } + + return 0; +} diff --git a/ZOJ/3686 - A Simple Tree Problem.cpp b/ZOJ/3686 - A Simple Tree Problem.cpp new file mode 100644 index 0000000..9b7482a --- /dev/null +++ b/ZOJ/3686 - A Simple Tree Problem.cpp @@ -0,0 +1,121 @@ +#include +#include +#include + +using namespace std; + +#define MAXN 100005 + +vector L[MAXN]; +int pos,s[MAXN],e[MAXN]; +bool flag[8 * MAXN]; + +void dfs(int cur){ + flag[pos] = true; + s[cur] = pos++; + + for(int i = L[cur].size() - 1,to;i >= 0;--i){ + to = L[cur][i]; + dfs(to); + } + + e[cur] = pos++; +} + +int ones[8 * MAXN],zeros[8 * MAXN]; + +void init(int node, int l, int r){ + if(l == r){ + if(flag[l]){ + zeros[node] = 1; + ones[node] = 0; + }else{ + zeros[node] = 0; + ones[node] = 0; + } + }else{ + int mi = (l + r) >> 1; + + init(2 * node + 1,l,mi); + init(2 * node + 2,mi + 1,r); + + ones[node] = ones[2 * node + 1] + ones[2 * node + 2]; + zeros[node] = zeros[2 * node + 1] + zeros[2 * node + 2]; + } +} + +void push(int node, int l, int r){ + if(flag[node]){ + swap(ones[node],zeros[node]); + flag[node] = 0; + + if(l != r){ + flag[2 * node + 1] ^= 1; + flag[2 * node + 2] ^= 1; + } + } +} + +void pull(int node){ + ones[node] = ones[2 * node + 1] + ones[2 * node + 2]; + zeros[node] = zeros[2 * node + 1] + zeros[2 * node + 2]; +} + +int query(int node, int l, int r, int x, int y){ + push(node,l,r); + if(y < l || x > r) return 0; + if(x <= l && r <= y) return ones[node]; + + int mi = (l + r) >> 1; + int ret = query(2 * node + 1,l,mi,x,y) + query(2 * node + 2,mi + 1,r,x,y); + pull(node); + return ret; +} + +void update(int node, int l, int r, int x, int y){ + push(node,l,r); + if(y < l || x > r) return; + if(x <= l && r <= y){ + flag[node] ^= 1; + push(node,l,r); + }else{ + int mi = (l + r) >> 1; + update(2 * node + 1,l,mi,x,y); + update(2 * node + 2,mi + 1,r,x,y); + pull(node); + } +} + +int main(){ + int N,M,v; + char op[2]; + + while(scanf("%d %d",&N,&M) == 2){ + for(int i = 1;i <= N;++i) + L[i].clear(); + + for(int i = 2,p;i <= N;++i){ + scanf("%d",&p); + L[p].push_back(i); + } + + memset(flag,false,sizeof flag); + pos = 0; + dfs(1); + + init(0,0,2 * N - 1); + + memset(flag,false,sizeof flag); + + while(M--){ + scanf("%s %d",op,&v); + + if(op[0] == 'o') update(0,0,2 * N - 1,s[v],e[v]); + else printf("%d\n",query(0,0,2 * N - 1,s[v],e[v])); + } + + printf("\n"); + } + + return 0; +} diff --git a/ZOJ/3690 - Choosing number.cpp b/ZOJ/3690 - Choosing number.cpp new file mode 100644 index 0000000..21499fb --- /dev/null +++ b/ZOJ/3690 - Choosing number.cpp @@ -0,0 +1,53 @@ +#include + +using namespace std; + +#define MOD 1000000007 + +struct Matrix{ + long long a,b,c,d; + + Matrix(){ + a = d = 1; + b = c = 0; + } + + Matrix(long long _a, long long _b, long long _c, long long _d): + a(_a),b(_b),c(_c),d(_d){} + + Matrix operator * (Matrix X){ + return Matrix( + (a * X.a + b * X.c) % MOD, + (a * X.b + b * X.d) % MOD, + (c * X.a + d * X.c) % MOD, + (c * X.b + d * X.d) % MOD); + } + + Matrix pow(int n){ + Matrix ret,a = *this; + + while(n){ + if(n & 1) ret = ret * a; + a = a * a; + n >>= 1; + } + + return ret; + } +}; + +int main(){ + int N,M,K; + Matrix M0; + + while(scanf("%d %d %d",&N,&M,&K) == 3){ + M0.a = M - K; M0.b = M - K; + M0.c = K; M0.d = K - 1; + + M0 = M0.pow(N - 1); + + printf("%lld\n",((M0.a + M0.c) * (M - K) + (M0.b + M0.d) * K) % MOD); + } + + return 0; +} diff --git a/ZOJ/3691 - Flower.cpp b/ZOJ/3691 - Flower.cpp new file mode 100644 index 0000000..a316e71 --- /dev/null +++ b/ZOJ/3691 - Flower.cpp @@ -0,0 +1,147 @@ +#include +#include +#include +#include +#include + +using namespace std; + +#define MAXN 100 + +struct flow_graph{ + static const int MAX_V = 201; + static const int MAX_E = 10200; + + int E,s,t,head,tail; + int cap[2 * MAX_E],to[2 * MAX_E],next[2 * MAX_E],last[MAX_V],dist[MAX_V],q[MAX_V],now[MAX_V]; + + flow_graph(){ + E = 0; + memset(last,-1,sizeof last); + } + + void clear(){ + E = 0; + memset(last,-1,sizeof last); + } + + void add_edge(int u, int v, int uv){ + to[E] = v, cap[E] = uv, next[E] = last[u]; last[u] = E++; + to[E] = u, cap[E] = 0, next[E] = last[v]; last[v] = E++; + } + + bool bfs(){ + memset(dist,-1,sizeof dist); + head = tail = 0; + + q[tail] = t; ++tail; + dist[t] = 0; + + while(head < tail){ + int v = q[head]; ++head; + + for(int e = last[v];e != -1;e = next[e]){ + if(cap[e^1] > 0 && dist[to[e]] == -1){ + q[tail] = to[e]; ++tail; + dist[to[e]] = dist[v]+1; + } + } + } + + return dist[s] != -1; + } + + int dfs(int v, int f){ + if(v == t) return f; + + for(int &e = now[v];e != -1;e = next[e]){ + if(cap[e] > 0 && dist[to[e]] == dist[v]-1){ + int ret = dfs(to[e],min(f,cap[e])); + + if(ret > 0){ + cap[e] -= ret; + cap[e^1] += ret; + return ret; + } + } + } + + return 0; + } + + int max_flow(int source, int sink, int V){ + s = source; t = sink; + int f = 0,df; + + while(bfs()){ + for(int i = 0;i < V;++i) now[i] = last[i]; + + while(true){ + df = dfs(s,INT_MAX); + if(df == 0) break; + f += df; + } + } + + return f; + } +}G; + +int main(){ + int N,x[MAXN],y[MAXN],z[MAXN],f[MAXN],l[MAXN],nd; + int M[MAXN][MAXN],d[MAXN * MAXN],aux; + + while(scanf("%d",&N) == 1){ + bool ok = true; + int totalf = 0; + + for(int i = 0;i < N;++i){ + scanf("%d %d %d %d %d",&x[i],&y[i],&z[i],&f[i],&l[i]); + if(i > 0 && l[i] < f[i]) ok = false; + totalf += f[i]; + } + + if(!ok) printf("-1\n"); + else{ + nd = 0; + d[nd++] = 0; + + for(int i = 0;i < N;++i) + for(int j = i + 1;j < N;++j){ + aux = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) + (z[i] - z[j]) * (z[i] - z[j]); + M[i][j] = M[j][i] = aux; + d[nd++] = aux; + } + + sort(d,d + nd); + + int lo = 0,hi = nd - 1,mi; + + while(lo < hi){ + mi = (lo + hi) >> 1; + int R2 = d[mi]; + + G.clear(); + + for(int i = 0;i < N;++i){ + G.add_edge(0,2 * i + 1,f[i]); + G.add_edge(2 * i + 1,2 * i + 2,l[i]); + } + + for(int i = 0;i < N;++i) + for(int j = i + 1;j < N;++j) + if(M[i][j] <= R2){ + G.add_edge(2 * i + 2,2 * j + 1,1000000000); + G.add_edge(2 * j + 2,2 * i + 1,1000000000); + } + + if(G.max_flow(0,1,2 * N + 1) < totalf) lo = mi + 1; + else hi = mi; + } + + printf("%.7f\n",sqrt(d[lo])); + } + } + + return 0; +} diff --git a/ZOJ/3702 - Gibonacci number.cpp b/ZOJ/3702 - Gibonacci number.cpp new file mode 100644 index 0000000..054d214 --- /dev/null +++ b/ZOJ/3702 - Gibonacci number.cpp @@ -0,0 +1,41 @@ +#include +#include + +using namespace std; + +int main(){ + int T,i,Gi,j,lo,hi,mi; + long long G[21]; + + scanf("%d",&T); + + while(T--){ + scanf("%d %d %d",&i,&Gi,&j); + + G[0] = 1; + + lo = 1; hi = 999999; + + while(lo < hi){ + mi = (lo + hi) >> 1; + + G[1] = mi; + + for(int k = 2;k <= i;++k) + G[k] = min(1000000LL,G[k - 1] + G[k - 2]); + + if(G[i] < Gi) lo = mi + 1; + else hi = mi; + } + + G[1] = lo; + + for(int k = 2;k <= max(i,j);++k) + G[k] = G[k - 1] + G[k - 2]; + + if(G[i] != Gi) printf("-1\n"); + else printf("%lld\n",G[j]); + } + + return 0; +} diff --git a/ZOJ/3772 - Calculate the Function.cpp b/ZOJ/3772 - Calculate the Function.cpp new file mode 100644 index 0000000..06587ad --- /dev/null +++ b/ZOJ/3772 - Calculate the Function.cpp @@ -0,0 +1,72 @@ +#include + +using namespace std; + +#define MOD 1000000007 +#define MAXN 100000 + +struct Matrix{ + long long a,b,c,d; + + Matrix(): + a(1), b(0), c(0), d(1){} + + Matrix(long long _a, long long _b, long long _c, long long _d): + a(_a), b(_b), c(_c), d(_d){} + + Matrix operator * (Matrix X){ + return Matrix( + (a * X.a + b * X.c) % MOD, + (a * X.b + b * X.d) % MOD, + (c * X.a + d * X.c) % MOD, + (c * X.b + d * X.d) % MOD); + } +}; + +int a[MAXN]; +Matrix T[4 * MAXN]; + +void init(int node, int l, int r){ + if(l == r) T[node] = Matrix(0,a[l],1,1); + else{ + int mi = (l + r) >> 1; + init(2 * node + 1,l,mi); + init(2 * node + 2,mi + 1,r); + T[node] = T[2 * node + 1] * T[2 * node + 2]; + } +} + +Matrix query(int node, int l, int r, int x, int y){ + if(r < x || l > y) return Matrix(); + if(x <= l && r <= y) return T[node]; + int mi = (l + r) >> 1; + return query(2 * node + 1,l,mi,x,y) * query(2 * node + 2,mi + 1,r,x,y); +} + +int main(){ + int T,N,M,l,r; + + scanf("%d",&T); + + while(T--){ + scanf("%d %d",&N,&M); + + for(int i = 0;i < N;++i) + scanf("%d",&a[i]); + + init(0,0,N - 1); + + while(M--){ + scanf("%d %d",&l,&r); + --l; --r; + + if(r <= l + 1) printf("%d\n",a[r]); + else{ + Matrix aux = query(0,0,N - 1,l + 2,r); + printf("%lld\n",(aux.b * a[l] + aux.d * a[l + 1]) % MOD); + } + } + } + + return 0; +} diff --git a/ZOJ/3780 - Paint the Grid Again.cpp b/ZOJ/3780 - Paint the Grid Again.cpp new file mode 100644 index 0000000..b69a7d9 --- /dev/null +++ b/ZOJ/3780 - Paint the Grid Again.cpp @@ -0,0 +1,92 @@ +#include +#include +#include +#include + +using namespace std; + +int main(){ + int T,N; + char M[500][501]; + bool checkr[500],checkc[500]; + vector L[1000]; + int in[1000]; + + scanf("%d",&T); + + while(T--){ + scanf("%d",&N); + + for(int i = 0;i < N;++i) + scanf("%s",M[i]); + + memset(checkr,false,sizeof checkr); + memset(checkc,false,sizeof checkc); + memset(in,0,sizeof in); + + for(int i = 0;i < N;++i) + for(int j = 0;j < N;++j) + if(M[i][j] == 'X') + checkr[i] = true; + else + checkc[j] = true; + + int N2 = 0; + + for(int i = 0;i < N;++i){ + if(checkr[i]) ++N2; + if(checkc[i]) ++N2; + } + + for(int i = 0;i < 2 * N;++i) + L[i].clear(); + + for(int i = 0;i < N;++i) + if(checkr[i]) + for(int j = 0;j < N;++j) + if(checkc[j]) + if(M[i][j] == 'X'){ + L[j].push_back(N + i); + ++in[N + i]; + }else{ + L[N + i]. push_back(j); + ++in[j]; + } + + priority_queue Q; + + for(int i = 0;i < N;++i) + if(checkc[i] && in[i] == 0) + Q.push(-i); + + for(int i = 0;i < N;++i) + if(checkr[i] && in[N + i] == 0) + Q.push(-N-i); + + vector ans; + + while(!Q.empty()){ + int aux = -Q.top(); + Q.pop(); + ans.push_back(aux); + + for(int i = L[aux].size() - 1,to;i >= 0;--i){ + to = L[aux][i]; + --in[to]; + + if(in[to] == 0) Q.push(-to); + } + } + + if(ans.size() != N2) printf("No solution\n"); + else{ + for(int i = 0;i < N2;++i){ + printf("%c%d",ans[i] < N? 'C' : 'R',ans[i] < N? ans[i] + 1 : ans[i] - N + 1); + if(i + 1 < N2) printf(" "); + else printf("\n"); + } + } + } + + return 0; +}