ACM ICPC, Damascus University Collegiate Programming Contest(2018) Solution

A：Martadella Stikes Again

水。

 #include <bits/stdc++.h>

 using namespace std;

 #define ll long long

 int t;
 ll R, r;

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%lld%lld", &R, &r);
         if (R * R > 2ll * r * r)
             puts("");
         else
             puts("");
     }
     return ;
 }

B：Amer and Graphs

题意：给出n条边，连续选k条边，(1 <= k  <= n) 对于每一个图，有多少个图和它一样

思路：图Hash，枚举起点，再枚举长度，这样每次加边都是一条，时间复杂度O(n ^ 2)

 #include <bits/stdc++.h>
 using namespace std; 

 #define INF 0x3f3f3f3f
 #define INFLL 0x3f3f3f3f3f3f3f3f
 #define ll long long
 #define N 2003

 typedef pair <int, int> pii;

 struct simplehash
 {
     int len;
     ll base, mod;
     vector <ll> P, H;

     inline simplehash() {}
     inline simplehash(const int *ar, int n, ll b, ll m)
     {
         len = n; base = b, mod = m;
         P.resize(len + , ); H.resize(len + , );
         for (int i = ; i <= len; ++i) P[i] = (P[i - ] * base) % mod;
         for (int i = ; i <= len; ++i) H[i] = (H[i - ] + P[ar[i]]) % mod;
     }

     inline ll range_hash(int l, int r)
     {
         ll hashval = (H[r] - H[l - ]) % mod;
         return (hashval <  ? hashval + mod : hashval);
     }
 };

 struct arrayhash
 {
     simplehash sh1, sh2;
     inline arrayhash() {}
     inline arrayhash(const int *ar, int n)
     {
         sh1 = simplehash(ar, n, , );
         sh2 = simplehash(ar, n, , );
     }
     inline ll range_hash(int l, int r)
     {
         return (sh1.range_hash(l, r) << ) ^ (sh2.range_hash(l, r));
     }
 };

 int t, n, pos;
 map <pii, int> mp;
 unordered_map <ll, int> mp2;
 int arr[N];

 inline void Init()
 {
     mp.clear(); pos = ;
     mp2.clear();
 }

 struct Edge
 {
     int u, v, id;
     inline void scan()
     {
         scanf("%d%d", &u, &v);
         if (u > v) swap(u, v);
         if (!mp.count(pii(u, v)))
             mp[pii(u, v)] = mp.size() + ;
         id = mp[pii(u, v)];
     }
 }edge[N];

 inline void Run()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n); Init();
         for (int i = ; i <= n; ++i)
         {
             edge[i].scan();
             arr[i] = edge[i].id;
         }
         ll ans = ;
         arrayhash x = arrayhash(arr, n);
         for (int i = ; i <= n; ++i)
         {
             for (int j = i; j <= n; ++j)
             {
                 ll Hash = x.range_hash(i, j);
                 ans += mp2[Hash]++;
             }
         }
         printf("%lld\n", ans);
     }
 }

 int main()
 {
     #ifdef LOCAL
         freopen("Test.in", "r", stdin);
     #endif

     Run();

     return ;
 }

C：Help Shahhoud

题意：给出A串和B串，每次可以翻转以A串中心点为轴，翻转长度为x，求长度最少使得串A变成串B，如果不行输出-1

思路：很显然要从外往里翻，如果某一段翻转性质相同，那么可以一并翻转，要特别考虑一下四个字符都相同，那么既可以翻转既可以不翻转

 #include<bits/stdc++.h>

 using namespace std;

 #define N 100010

 int t;
 char A[N];
 char B[N];

 int main()
 {
     scanf("%d",&t);
     while(t--)
     {
         scanf("%s", A + );
         scanf("%s", B + );
         int len = strlen(A + );
         int ans = ;
         int flag = ;
         for(int i = ; i <= len / ; ++i)
         {
             int l = i, r = len - i + ;
             if(A[l] == A[r] && A[l] == B[r] && B[l] == B[r]) continue;
             else if(A[l] == B[r] && A[r] == B[l])
             {
                 if(flag == )
                 {
                     ++ans;
                     flag = !flag;
                 }
             }
             else if(A[l] == B[l] && A[r] == B[r])
             {
                 if(flag == )
                 {
                     ++ans;
                     flag = !flag;
                 }
             }
             else
             {
                 ans = -;
                 break;
             }
         }
         if(A[(len + ) / ] != B[(len + ) / ]) ans = -;
         printf("%d\n",ans);
     }
     return ;
 }

D：Simplified 2048

留坑。

E：Floods

题意：给出n个点形成山地（折线图），在下过一段时间的雨后留下的雨量。

思路：显然只有凹下去的点才能做出贡献。所以可以分为以下几种情况。一种是图中一部分，一种是图中二部分。对于一部分即求一个梯形面积，对于第二部分即求一个三角形的相似三角形的面积，累加一下即可。

 #include<bits/stdc++.h>

 using namespace std;

 #define N 100010

 struct node{
     int x,y;
     inline node(){}
     inline node(int x,int y) :x(x),y(y){}
 }a[N];

 int L[N];
 int R[N];
 int n;

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&n);
         for(int i = ; i <= n; ++i)
         {
             scanf("%d %d",&a[i].x,&a[i].y);
         }
         int Max = ;
         for(int i = ; i <= n; ++i)
         {
             Max = max(Max,a[i].y);
             L[i] = Max;
         }
         Max = ;
         for(int i = n; i >= ; --i)
         {
             Max = max(Max, a[i].y);
             R[i] = Max;
         }
         double ans = ;
         for(int i = ; i < n; ++i)
         {
             int top, Max, Min;
             if(a[i].y < a[i + ].y)
             {
                 top = min(L[i], R[i]);
                 Max = a[i + ].y;
                 Min = a[i].y;
             }
             else
             {
                 top = min(L[i + ], R[i + ]);
                 Max = a[i].y;
                 Min = a[i + ].y;
             }
             if(top >= Max)
             {
                 ans += (double)(a[i + ].x - a[i].x) * (top - a[i].y + top - a[i + ].y) * 0.5;
             }
             else if(top > Min)
             {
                 ans += (double)(a[i + ].x - a[i].x) * (top - Min) * (top - Min) / (Max - Min) * 0.5;
             }
         }
         printf("%.8f\n",ans);
     }
     return ;
 }

F：Random Sort

题意：给出n个数，对标号全排列，看有多少种排列里面的数是排好的

思路：如果有相同的数，那么对于这个数它的贡献是fac[x] (fac是阶乘，x是个数)

 #include<bits/stdc++.h>

 using namespace std;

 const int MOD = ;

 #define N 1010

 int inv[N];
 int n;
 int a[N];

 int main()
 {
     inv[] = ;
     for(int i = ; i < N; ++i)
     {
         inv[i] = inv[i - ] * i % MOD;
     }
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&n);
         int ans = ;
         for(int i = ; i <= n; ++i)
         {
             scanf("%d",&a[i]);
         }
         sort(a + , a +  + n);
         int cnt = ;
         for(int i = ;i <= n; ++i)
         {
             if(a[i - ] == a[i])
             {
                 cnt++;
             }
             else
             {
                 ans = ans * inv[cnt] % MOD;
                 cnt = ;
             }
         }
         ans = ans * inv[cnt] % MOD;
         printf("%d\n",ans);
     }
     return ;
 }

G：Weird Requirements

题意：给出n个数，修改最少的数字，使得gcd=x，lcm=y。

思路：显然，一个数的因数不包括gcd和lcm的因数是一定要修改的。统计这些数字的个数。当剩下的数字的因数都满足gcd与lcm的因数的时候，显然最多修改两个数字。那么当必定修改的数的个数大于等于2的时候输出这个数字即可。对于剩下的数字，求出他们的gcd与lcm。那么y/gcd为需要增加的因数，lcm/x为需要减少的因数，但是当增加的因数和减少的因数的gcd！=1时需要修改两个数字。例如gcd=6，lcm=24，五个数分别为12 12 12 12 14

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010

 typedef long long ll;

 int t, n;
 ll arr[N];
 ll x, y;

 inline ll GCD(ll a, ll b)
 {
     return b ==  ? a : GCD(b, a % b);
 }

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         scanf("%lld%lld", &x, &y);
         for (int i = ; i <= n; ++i) scanf("%lld", arr + i);
         if (y % x)
         {
             puts("-1");
             continue;
         }
         if(n ==  && x != y)
         {
             puts("-1");
             continue;
         }
         int ans = ;
         ll gcd = y, lcm = x;
         for (int i = ; i <= n; ++i)
         {
             if(arr[i] % x || y % arr[i]) ++ans;
             else
             {
                 gcd = GCD(gcd, arr[i]);
                 lcm = lcm * arr[i] / GCD(lcm, arr[i]);
             }
         }
         if (ans >= )
             printf("%d\n", ans);
         else if(ans == )
         {
             if(gcd != x && lcm != y && GCD(y / gcd, lcm / x) != )
             {
                 puts("");
             }
             else
             {
                 puts("");
             }
         }
         else
         {
             if(x == gcd && y == lcm)
             {
                 puts("");
             }
             else if(x != gcd && y != lcm && GCD(x / gcd, lcm / y) != )
             {
                 puts("");
             }
             else
             {
                 puts("");
             }
         }
     }
     return ;
 }

H：Shahhoud the Chief Judge

题意：一棵树，每个点有权值，sum = sgm(每个点的权值 * 路径经过它的次数)

思路：设cnt[i] 表示经过第i个点的路径数，如果存在gcd(cnt[i], cnt[j]) == 1 ，那么通过i, j 这两个数，就可以构造出所有的整数

裴蜀定理: ax + by = cgcd(a,b)；  c为任意整数，当gcd(a, b)==1 时   cgcd(a, b) 为任意整数

在这棵二叉树中，必然存在这两个数

考虑深度最深的叶子结点cnt[x] = 2 * n - 1, 那么它的父亲结点的cnt[fa] = 6 * n - 11

gcd(2n - 1, 6n - 11) = gcd(2n - 1, -8) = 1 因为2n - 1 是奇数

 #include <bits/stdc++.h>
 using namespace std; 

 #define INF 0x3f3f3f3f
 #define INFLL 0x3f3f3f3f3f3f3f3f
 #define ll long long
 #define N 100010

 inline ll GCD(ll a, ll b)
 {
     return (ll)b ? GCD(b, a % b) : a;
 }

 struct Edge
 {
     int to, nx;
     inline Edge() {}
     inline Edge(int to, int nx) : to(to), nx(nx) {}
 }edge[N << ];

 int head[N], pos;
 int t, n;
 ll arr[N];
 ll cnt[N];
 ll num[N];
 ll son[N][];
 int fa[N];
 ll sum;

 inline void Init()
 {
     memset(head, -, sizeof head);
     pos = ; fa[] = ; sum = ;
 }

 inline void addedge(int u, int v)
 {
     edge[++pos] = Edge(v, head[u]); head[u] = pos;
     edge[++pos] = Edge(u, head[v]); head[v] = pos;
 }

 inline void DFS(int u)
 {
     cnt[u] = ;
     son[u][] = son[u][] = ;
     for (int it = head[u]; ~it; it = edge[it].nx)
     {
         int v = edge[it].to;
         if (v == fa[u]) continue;
         fa[v] = u; DFS(v);
         cnt[u] += cnt[v];
         if (son[u][])
             son[u][] = cnt[v];
         else
             son[u][] = cnt[v];
     }
     num[u] = (ll)( * n - ) + (ll)(n - cnt[u]) * (cnt[u] - ) *  + (ll)(son[u][] * son[u][] * );
     sum += arr[u] * num[u];
 }

 inline void work()
 {
     if (sum == )
     {
         puts("");
         return;
     }
     int id = ;
     for (int i = ; i <= n; ++i)
     {
         if (sum % num[i] == )
         {
             printf("1\n%d\n", i);
             return;
         }
         if (GCD(num[i], num[fa[i]]) == )
             id = i;
     }
     printf("2\n%d %d\n", fa[id], id);
 }

 inline void Run()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         Init();
         for (int i = ; i <= n; ++i) scanf("%lld", arr + i);
         for (int i = , u, v; i < n; ++i)
         {
             scanf("%d%d", &u, &v);
             addedge(u, v);
         }
         DFS();
         work();
     }
 }

 int main()
 {
     #ifdef LOCAL
         freopen("Test.in", "r", stdin);
     #endif

     Run();

     return ;
 }

I：lldar Yalalov

题意：n堆石子，每一堆有ai个，两个人轮流取，取的操作只有两种

1° 从一堆中取一个

2°每一堆取一个，当且仅当所有堆都至少有一个才能有这个操作

思路：

如果是奇数堆，那么取一个和从所有堆中取一个的操作实际上是一样的，因为取的都是奇数个，不会影响胜负  直接% 2 判断

如果是偶数堆，并且总个数是奇数，那么先手是必胜的，因为如果最小堆里面的石子个数是奇数个，那么只要一直取这里的，如果他取一排，跟着他取

如果总个数是偶数，并且最小堆里面石子个数是偶数，那么是胜利的，因为先手改变命运的次数多一次

 #include <bits/stdc++.h>

 using namespace std;
 #define INF 0x3f3f3f3f
 #define N 110

 int t;
 int n, sum, Min;
 int arr[N];

 inline bool work()
 {
     if (n & )
     {
         return (sum & );
     }
     if (sum & ) return true;
     else
     {
         return (Min & );
     }
 }

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         sum = , Min = INF;
         for (int i = ; i <= n; ++i) scanf("%d", arr + i), sum += arr[i], Min = min(Min, arr[i]);
         puts(work() ? "Yalalov" : "Shin");
     }
     return ;
 }

J：Saeed and Folan

水。

 #include <bits/stdc++.h>

 using namespace std;

 int t, k;
 int L[], R[], p[], D[];

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         for (int i = ; i < ; ++i)
             scanf("%d%d%d%d", &L[i], &R[i], &p[i], &D[i]);
         scanf("%d", &k);
         for (int i = ; i < ; ++i) if (D[i] == )
             D[i] = -;
         int ans = ;
         if (p[] == p[]) ++ans;
         if (p[] == L[]) D[] = ;
         if (p[] == R[]) D[] = -;
         if (p[] == L[]) D[] = ;
         if (p[] == R[]) D[] = -;
         for (int i = ; i <= k; ++i)
         {
             for (int j = ; j < ; ++j)
                 p[j] += D[j];
             if (p[] == p[]) ++ans;
             for (int j = ; j < ; ++j)
             {
                 if (p[j] == R[j]) D[j] = -;
                 if (p[j] == L[j]) D[j] = ;
             }
         }
         printf("%d\n", ans);
     }
     return ;
 }

K：Another Shortest Path Problem

题意：n个点，n条边，没有重边和自环，每次询问给出u, v 询问u -> v的最短路径

思路：这个图是一棵树加一个环，那么我们找出这个环中边权最大的边

那么最短路只有两种状况，经过这条边和不经过这条边 然后找LCA处理一下

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const int DEG = ;
 const int maxn = 1e5 + ;

 struct node{
     int u,v;
     ll w;
     inline node(){}
     inline node(int u,int v,ll w): u(u), v(v), w(w){}
     inline bool operator < (const node &b)
     {
         return w < b.w;
     }
 }G[maxn];

 struct Edge{
     int to,nxt;
     ll w;
     inline Edge(){}
     inline Edge(int to,int nxt, ll w):to(to), nxt(nxt), w(w) {}
 }edge[maxn << ];

 int n,q;
 int head[maxn], tot;
 int father[maxn];
 ll dis[maxn];

 inline int find(int x)
 {
     return father[x] == x ? father[x] : father[x] = find(father[x]);
 }

 inline void mix(int x,int y)
 {
     x = find(x);
     y = find(y);
     if(x != y)
     {
         father[x] = y;
     }
 }

 inline bool same(int x,int y)
 {
     return find(x) == find(y);
 }

 inline void addedge(int u,int v,ll w)
 {
     edge[tot] = Edge(v, head[u],w);
     head[u] = tot++;
 }

 inline void init()
 {
     tot = ;
     memset(head, -, sizeof head);
     for(int i = ; i <= n; ++i) father[i] = i;
 }

 int fa[maxn][DEG];
 int deg[maxn];

 inline void BFS(int root)
 {
     queue<int>q;
     deg[root] = ;
     fa[root][] = root;
     q.push(root);
     while(!q.empty())
     {
         int tmp = q.front();
         q.pop();
         for(int i = ;i < DEG; ++i)
         {
             fa[tmp][i] = fa[fa[tmp][i - ]][i - ];
         }
         for(int i = head[tmp]; ~i; i = edge[i].nxt)
         {
             int v = edge[i].to;
             if(v == fa[tmp][]) continue;
             dis[v] = dis[tmp] + edge[i].w;
             deg[v] = deg[tmp] + ;
             fa[v][] = tmp;
             q.push(v);
         }
     }
 }

 inline int LCA(int u, int v)
 {
     if(deg[u] > deg[v]) swap(u,v);
     int hu = deg[u], hv = deg[v];
     int tu = u,tv = v;
     for(int det = hv - hu, i = ;det; det >>= , ++i)
     {
         if(det & )
         {
             tv = fa[tv][i];
         }
     }
     if(tu == tv) return tu;
     for(int i = DEG - ; i >= ; --i)
     {
         if(fa[tu][i] == fa[tv][i]) continue;
         tu = fa[tu][i];
         tv = fa[tv][i];
     }
     return fa[tu][];
 }

 inline ll query(int u,int v)
 {
     int root = LCA(u,v);
     return dis[u] + dis[v] -  * dis[root];
 }

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d %d",&n,&q);
         init();
         int a,b;
         ll cost;
         for(int i = ; i <= n; ++i)
         {
             scanf("%d %d %lld", &G[i].u, &G[i].v, &G[i].w);
         }
         sort(G + , G +  + n);
         for(int i = ; i <= n; ++i)
         {
             int u = G[i].u;
             int v = G[i].v;
             ll w = G[i].w;
             if(same(u, v))
             {
                 a = u;
                 b = v;
                 cost = w;
             }
             else
             {
                 mix(u,v);
                 addedge(u,v,w);
                 addedge(v,u,w);
             }
         }
         dis[] = ;
         BFS();
         while(q--)
         {
             int u,v;
             scanf("%d %d",&u,&v);
             ll ans = query(u, v);
             ans = min(ans, query(u, a) + query(v, b) + cost);
             ans = min(ans, query(v, a) + query(u, b) + cost);
             printf("%lld\n",ans);
         }
     }
     return ;
 }

L：V--o$\_$o--V

Upsolved.

题意：

$对每一个点i求下标小于i的所有点的LCA的点权和$

思路：

考虑一个点对多个点求分别的$LCA$ 可以树剖对那些点从当前点到根打标记，那么目标点对他们求$LCA就是从当前点走到根看一下打的标记最多的是哪个$

那么此处也可以同样处理，我们需要设计一种标记，使得从该点到根的路径上所有标记点加起来恰好是当前点权值

我们可以这么处理 在这里约定$w[u] 表示点u的点权，x[u] 表示树上的标记, fa[u] 表示点u的父亲$

那么 $x[u] = w[fa[u]] - w[i]$

 #include <bits/stdc++.h>
 using namespace std;

 #define ll long long
 #define N 200010
 int t, n, w[N];
 vector <int> G[N];

 ll dis[N];
 int deep[N], fa[N], sze[N], son[N], top[N], p[N], fp[N], cnt;
 void DFS(int u)
 {
     sze[u] = ;
     for (auto v : G[u])
     {
         deep[v] = deep[u] + ;
         dis[v] = w[v] - w[u];
         DFS(v); sze[u] += sze[v];
         if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
     }
 }

 void getpos(int u, int sp)
 {
     top[u] = sp;
     p[u] = ++cnt;
     fp[cnt] = u;
     if (!son[u]) return;
     getpos(son[u], sp);
     for (auto v : G[u]) if (v != son[u])
         getpos(v, v);
 }

 namespace SEG
 {
     ll sum[N << ], add[N << ], lazy[N << ];
     void build(int id, int l, int r)
     {
         sum[id] = lazy[id] = ;
         if (l == ) sum[id] = dis[];
         if (l == r)
         {
             add[id] = dis[fp[l]];
             return;
         }
         int mid = (l + r) >> ;
         build(id << , l, mid);
         build(id <<  | , mid + , r);
         add[id] = add[id << ] + add[id <<  | ];
     }
     void work(int id, int l, int r, int ql, int qr, ll &res)
     {
         if (l >= ql && r <= qr)
         {
             res += sum[id];
             sum[id] += add[id];
             ++lazy[id];
             return;
         }
         if (lazy[id])
         {
             lazy[id << ] += lazy[id];
             sum[id << ] += lazy[id] * add[id << ];
             lazy[id <<  | ] += lazy[id];
             sum[id <<  | ] += lazy[id] * add[id <<  | ];
             lazy[id] = ;
         }
         int mid = (l + r) >> ;
         if (ql <= mid) work(id << , l, mid, ql, qr, res);
         if (qr > mid) work(id <<  | , mid + , r, ql, qr, res);
         sum[id] = sum[id << ] + sum[id <<  | ];
     }
 }

 ll work(int u, int v)
 {
     ll res = ;
     while (top[u] != top[v])
     {
         if (deep[top[u]] < deep[top[v]]) swap(u, v);
         SEG::work(, , n, p[top[u]], p[u], res);
         u = fa[top[u]];
     }
     if (deep[u] > deep[v]) swap(u, v);
     SEG::work(, , n, p[u], p[v], res);
     return res;
 }

 void init()
 {
     for (int i = ; i <= n; ++i) G[i].clear(), son[i] = ;
     cnt = ;
 }

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n); init();
         for (int i = ; i <= n; ++i) scanf("%d", w + i);
         for (int i = ; i <= n; ++i)
         {
             scanf("%d", fa + i);
             G[fa[i]].push_back(i);
         } dis[] = w[]; DFS(); getpos(, );
         SEG::build(, , n);
         for (int i = ; i <= n; ++i) printf("%lld%c", work(, i), " \n"[i == n]);
     }
     return ;
 }