ACM-ICPC 2018 焦作赛区网络预赛 Solution

A. Magic Mirror

水。

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

 int t;
 char s[];

 inline bool work()
 {
     int len = strlen(s);
     if (len != ) return false;
     if (s[] != 'j' && s[] != 'J') return false;
     if (s[] != 'e' && s[] != 'E') return false;
     if (s[] != 's' && s[] != 'S') return false;
     if (s[] != 's' && s[] != 'S') return false;
     if (s[] != 'i' && s[] != 'I') return false;
     if (s[] != 'e' && s[] != 'E') return false;
     return true;
 }

 inline void Run()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%s", s);
         puts(work() ? "Good guy!" : "Dare you say that again?");
     }
 }

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

     Run();
     return ;
 }  

B. Mathematical Curse

题意：有n个房间,m个诅咒，每个房间有一个数值，刚开始有一个初始值，每次进入一个房间可以选择消除诅咒或者不消除，消除诅咒只能顺序消除，消除诅咒就是拿初始值和房间的数值做运算，求最后最大的数是多少

思路：$Max[i][j]$ 表示 第i个房间 第j个操作的最大值, $Min[i][j]$ 表示第i个房间第j个操作的最小值

因为乘法 负负相乘可能变得很大

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

 #define N 1010
 #define ll long long
 #define INFLL 0x3f3f3f3f3f3f3f3f

 int t, n, m;
 int arr[N];
 char f[];
 ll Max[N][], Min[N][];
 ll k, ans;

 inline void Run()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d%lld", &n, &m, &k);
         for (int i = ; i <= n; ++i) scanf("%d", arr + i);
         scanf("%s", f + );
         memset(Max, -0x3f, sizeof Max);
         memset(Min, 0x3f, sizeof Min);
         Max[][] = Min[][] = k; ans = -INFLL;
         for (int i = ; i <= n; ++i)
         {
             Max[i][] = k, Min[i][] = k;
             for (int j = ; j <= min(m, i); ++j)
             {
                 Max[i][j] = Max[i - ][j], Min[i][j] = Min[i - ][j];
                 ll a = Max[i - ][j - ], c = Min[i - ][j - ], b = (ll)arr[i];
                 if (f[j] == '+')
                 {
                     a += b, c += b;
                 }
                 else if (f[j] == '-')
                 {
                     a -= b, c -= b;
                 }
                 else if (f[j] == '*')
                 {
                     a *= b, c *= b;
                 }
                 else if (f[j] == '/')
                 {
                     a /= b, c /= b;
                 }
                 if (a < c) swap(a, c);
                 Max[i][j] = max(Max[i][j], a);
                 Min[i][j] = min(Min[i][j], c);
                 //printf("%d %d %lld %lld\n", i, j, Max[i][j], Min[i][j]);
             }
             ans = max(ans, Max[i][m]);
         }
         printf("%lld\n", ans);
     }
 }

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

     Run();
     return ;
 }  

C. Password

留坑。

D. Sequence

留坑。

E. Jiu Yuan Wants to Eat

题意：四种操作。

思路：将取反看成加法和乘法   例如：Not(1000) = 1111 - 1000

然后树链剖分维护 + 线段树

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

 #define N 100010
 #define ull unsigned long long

 const ull D = ;

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

 int n, q;
 int head[N], pos;
 int top[N], fa[N], deep[N], num[N], p[N], fp[N], son[N], tot;

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

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

 inline void DFS(int u)
 {
     num[u] = ;
     for (int it = head[u]; ~it; it = edge[it].nx)
     {
         int v = edge[it].to;
         if (v == fa[u]) continue;
         fa[v] = u; deep[v] = deep[u] + ;
         DFS(v); num[u] += num[v];
         if (son[u] == - || num[v] > num[son[u]]) son[u] = v;
     }
 }

 inline void getpos(int u, int sp)
 {
     top[u] = sp;
     p[u] = ++tot;
     fp[tot] = u;
     if (son[u] == -) return;
     getpos(son[u], sp);
     for (int it = head[u]; ~it; it = edge[it].nx)
     {
         int v = edge[it].to;
         if (v != son[u] && v != fa[u])
             getpos(v, v);
     }
 }

 struct node
 {
     int l, r;
     ull sum, lazy[];
     inline node() {}
     inline node(int _l, int _r)
     {
         l = _l, r = _r;
         sum = ;
         lazy[] = , lazy[] = ;
     }
 }tree[N << ];

 inline void pushup(int id)
 {
     tree[id].sum = tree[id << ].sum + tree[id <<  | ].sum;
 }

 inline void work0(node &r, ull lazy)
 {

     r.sum = r.sum + lazy * (r.r - r.l + );
     r.lazy[] = r.lazy[] + lazy;
 }

 inline void work1(node &r, ull lazy)
 {
     r.sum = r.sum * lazy;
     r.lazy[] = r.lazy[] * lazy;
     r.lazy[] *= lazy;
 }

 inline void pushdown(int id)
 {
     if (tree[id].l >= tree[id].r) return;
     if (tree[id].lazy[] != )
     {
         ull lazy = tree[id].lazy[]; tree[id].lazy[] = ;
         work1(tree[id << ], lazy);
         work1(tree[id <<  | ], lazy);
     }
     if (tree[id].lazy[])
     {
         ull lazy = tree[id].lazy[]; tree[id].lazy[] = ;
         work0(tree[id << ], lazy);
         work0(tree[id <<  | ], lazy);
     }
 }

 inline void build(int id, int l, int r)
 {
     tree[id] = node(l, r);
     if (l == r) return;
     int mid = (l + r) >> ;
     build(id << , l, mid);
     build(id <<  | , mid + , r);
 }

 inline void update(int id, int l, int r, int vis, ull val)
 {
     if (tree[id].l >= l && tree[id].r <= r)
     {
         if (vis == )
             work1(tree[id], val);
         else
             work0(tree[id], val);
         return;
     }
     pushdown(id);
     int mid = (tree[id].l + tree[id].r) >> ;
     if (l <= mid) update(id << , l, r, vis, val);
     if (r > mid) update(id <<  | , l, r, vis, val);
     pushup(id);
 }

 ull anssum;

 inline void query(int id, int l, int r)
 {
     if (tree[id].l >= l && tree[id].r <= r)
     {
         anssum += tree[id].sum;
         return;
     }
     pushdown(id);
     int mid = (tree[id].l + tree[id].r) >> ;
     if (l <= mid) query(id << , l, r);
     if (r > mid) query(id <<  | , l, r);
     pushup(id);
 }

 inline void change(int u, int v, int vis, ull val)
 {
     int fu = top[u], fv = top[v];
     while (fu != fv)
     {
         if (deep[fu] < deep[fv])
         {
             swap(fu, fv);
             swap(u, v);
         }
         update(, p[fu], p[u], vis, val);
         u = fa[fu]; fu = top[u];
     }
     if (deep[u] > deep[v]) swap(u, v);
     update(, p[u], p[v], vis, val);
 }

 inline void sum(int u, int v)
 {
     int fu = top[u], fv = top[v];
     anssum = ;
     while (fu != fv)
     {
         if (deep[fu] < deep[fv])
         {
             swap(fu, fv);
             swap(u, v);
         }
         query(, p[fu], p[u]);
         u = fa[fu], fu = top[u];
     }
     if (deep[u] > deep[v]) swap(u, v);
     query(, p[u], p[v]);
 }

 inline void Run()
 {
     while (scanf("%d", &n) != EOF)
     {
         Init();
         for (int i = , u; i <= n; ++i)
         {
             scanf("%d", &u);
             addedge(u, i);
         }
         DFS(); getpos(, ); build(, , n);
         scanf("%d", &q);
         int op, u, v; ull val;
         for (int i = ; i <= q; ++i)
         {
             scanf("%d%d%d", &op, &u, &v);
             if (op <= )
             {
                 scanf("%llu", &val);
                 change(u, v, op - , val);
             }
             else if (op == )
             {
                 change(u, v, , -);
                 change(u, v, , D);
             }
             else
             {
                 sum(u, v);
                 printf("%llu\n", anssum);
             }
         }
     }
 }

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

     Run();
     return ;
 }  

F. Modular Production Line

留坑。

G. Give Candies

题意：有n颗糖，有n个人，按顺序出列，每次随机给那个人一些糖（至少一颗），分完为止，求有多少方案

思路：规律是$2^{n - 1}$ 根据费马小定理  $a^{p - 1} = 1 \pmod p$ 那么 只要 先用 $(n - 1)  mod (MOD - 1)$ 再快速幂

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<cstring>
 #include<map>

 using namespace std;

 typedef long long ll;

 const int MOD = (int)1e9 + ;
 const int INF = 0x3f3f3f3f;
 const int maxn = (int)1e5 + ;

 inline ll qpow(ll n, ll x)
 {
     ll res = ;
     while (n)
     {
         if (n & ) res = (res * x) % MOD;
         x = (x*x) % MOD;
         n >>= ;
     }
     return res;
 }

 int t;
 char str[maxn];

 inline void RUN()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%s", str);
         ll n = ;
         int len = strlen(str);
         for (int i = ; i < len; ++i)
         {
             n = n *  + str[i] - '';
             n %= (MOD - );
         }
         n = (n -  + (MOD - )) % (MOD - );
         //cout << n << endl;
         ll ans = qpow(n, );
         printf("%lld\n", ans);
     }
 }

 int main()
 {
 #ifdef LOCAL_JUDGE
     freopen("Text.txt", "r", stdin);
 #endif // LOCAL_JUDGE

     RUN();

 #ifdef LOCAL_JUDGE
     fclose(stdin);
 #endif // LOCAL_JUDGE

 }

H. String and Times

题意：求出有多少子串的出现次数在[A, B] 之间

思路：后缀自动机，出现次数至少为A 的减去 出现次数知道为B + 1

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

 #define ll long long
 #define N 200010

 char s[N];

 struct SAM {
     int p, q, np, nq, cnt, lst, a[N][], l[N], f[N], tot;
     int Tr(char c) { return c - 'A'; }
     int val(int c) { return l[c] - l[f[c]]; }
     SAM() { cnt = ; lst = ++cnt; }
     void Initialize() {
         memset(l, , sizeof(int)*(cnt + ));
         memset(f, , sizeof(int)*(cnt + ));
         for (int i = ; i <= cnt; i++)for (int j = ; j<; j++)a[i][j] = ;
         cnt = ; lst = ++cnt;
     }
     void extend(int c) {
         p = lst; np = lst = ++cnt; l[np] = l[p] + ;
         while (!a[p][c] && p)a[p][c] = np, p = f[p];
         if (!p) { f[np] = ; }
         else {
             q = a[p][c];
             if (l[p] +  == l[q])f[np] = q;
             else {
                 nq = ++cnt; l[nq] = l[p] + ;
                 memcpy(a[nq], a[q], sizeof(a[q]));
                 f[nq] = f[q]; f[np] = f[q] = nq;
                 while (a[p][c] == q)a[p][c] = nq, p = f[p];
             }
         }
     }
     int b[N], x[N], r[N];
     void build() {
         int len = strlen(s + );
         for (int i = ; i <= len; i++)extend(Tr(s[i]));
         memset(r, , sizeof(int)*(cnt + ));
         memset(b, , sizeof(int)*(cnt + ));
         for (int i = ; i <= cnt; i++)b[l[i]]++;
         for (int i = ; i <= len; i++)b[i] += b[i - ];
         for (int i = ; i <= cnt; i++)x[b[l[i]]--] = i;
         for (int i = p = ; i <= len; i++) { p = a[p][Tr(s[i])]; r[p]++; }
         for (int i = cnt; i; i--)r[f[x[i]]] += r[x[i]];
     }
     void solve() {
         ll ans = ;
         int A, B;
         build();
         scanf("%d %d", &A, &B);
         // cnt 为不同子串个数   r[x[i]] 为第i个不同子串 出现的次数
         for (int i = ; i <= cnt; i++)if (r[x[i]] >= A) ans += val(x[i]);
         for (int i = ; i <= cnt; i++)if (r[x[i]] >= B + ) ans -= val(x[i]);
         printf("%lld\n", ans);
     }
 }sam;

 inline void Run()
 {
     while (scanf("%s", s + ) != EOF)
     {
         sam.Initialize();
         sam.solve();
     }
 }

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

     Run();
     return ;
 }  

I. Save the Room

水。

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<cstring>
 #include<map>

 using namespace std;

 typedef long long ll;

 const int MOD = (int)1e9 + ;
 const int INF = 0x3f3f3f3f;
 const int maxn = (int)1e5 + ;

 int a, b, c;

 inline void RUN()
 {
     while (~scanf("%d %d %d", &a, &b, &c))
     {
         if (a %  ==  || b %  ==  || c %  == )
         {
             puts("Yes");
         }
         else
         {
             puts("No");
         }
     }
 }

 int main()
 {
 #ifdef LOCAL_JUDGE
     freopen("Text.txt", "r", stdin);
 #endif // LOCAL_JUDGE

     RUN();

 #ifdef LOCAL_JUDGE
     fclose(stdin);
 #endif // LOCAL_JUDGE

 }

J. Participate in E-sports

题意：判断$\frac {(n - 1)(n)}{2}$ 和 $n$ 是不是平方数

思路：二分开方法

 import java.math.BigInteger;
 import java.util.Scanner;

 public class Main
 {
     public static BigInteger check(BigInteger n,BigInteger x) {
         BigInteger ans=BigInteger.valueOf(1);
         BigInteger a=BigInteger.valueOf(1);
         for(BigInteger i=BigInteger.ZERO;i.compareTo(n)<0;i=i.add(a)) {
             ans=ans.multiply(x);
         }
         return ans;
     }
     static BigInteger Get(BigInteger m) {
         BigInteger l=BigInteger.ZERO;
         BigInteger a=BigInteger.valueOf(2);
         BigInteger b=BigInteger.valueOf(1);
         BigInteger r=BigInteger.valueOf(1);
         BigInteger mid=BigInteger.ZERO;
         while(check(BigInteger.valueOf(2),r).compareTo(m)<=0) {
             l=r;
             r=r.multiply(a);
         }
         while(l.compareTo(r)<=0) {
             mid=l.add(r).divide(a);
             if(check(BigInteger.valueOf(2),mid).compareTo(m)<=0) l=mid.add(b);
             else r=mid.subtract(b);
         }
         return r;   //返回的是开方后的值
     }

     public static boolean ok(BigInteger n)
     {
         BigInteger x = Get(n);
         if (x.multiply(x).compareTo(n) == 0) return true;
         return false;
     }

     public static void main(String[] args)
     {
         Scanner in = new Scanner(System.in);
         int t = in.nextInt();
         for (int kase = 1; kase <= t; ++kase)
         {
 //            System.out.println("bug");
             BigInteger n = in.nextBigInteger();
             BigInteger nn = n.multiply(n.subtract(BigInteger.ONE)).divide(BigInteger.valueOf(2));
             boolean flag[] = new boolean[2];
             flag[0] = ok(n); flag[1] = ok(nn);
             if (flag[0] && flag[1]) System.out.println("Arena of Valor");
             else if (flag[0]) System.out.println("Hearth Stone");
             else if (flag[1]) System.out.println("Clash Royale");
             else System.out.println("League of Legends");
         }
         in.close();
     }
 }

K. Transport Ship

题意： 有n种船，每种船有$v[i]$容量，每种船有$2^{c[i]} - 1$ 个，每次询问s，求能把s刚好装下的船的分配方案有多少

思路：多重背包+记录方案数

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

 #define N 10010
 #define ll long long
 #define INF 0x3f3f3f3f

 const ll MOD = (ll)1e9 + ; 

 int Bit[];

 inline void Init()
 {
     Bit[] = ;
     for (int i = ; i <= ; ++i) Bit[i] = (Bit[i - ] << );
     for (int i = ; i <= ; ++i) --Bit[i];
 }

 int t, n, q;
 int v[], c[];
 ll dp[N];
 ll f[N];

 inline void Run()
 {
     Init();
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d", &n, &q);
         for (int i = ; i <= n; ++i)
         {
             scanf("%d%d", v + i, c + i);
             c[i] = Bit[c[i]];
         }
         memset(f, , sizeof f);
         dp[] = ; f[] = ;
         int m = ;
         for (int i = ; i <= m; ++i) dp[i] = -INF;
         for (int i = ; i <= n; ++i)
         {
             if (v[i] * c[i] >= m)
             {
                 for (int j = v[i]; j <= m; ++j)
                 {
                     dp[j] = max(dp[j], dp[j - v[i]] + v[i]);
                     if (dp[j] == dp[j - v[i]] + v[i])
                         f[j] = (f[j] + f[j - v[i]]) % MOD;
                 }
             }
             else
             {
                 int tmp = c[i];
                 for (int k = ; k < tmp; tmp -= k, k <<= )
                 {
                     for (int j = m; j >= k * v[i]; --j)
                     {
                         int w = k * v[i];
                         dp[j] = max(dp[j], dp[j - w] + w);
                         if (dp[j] == dp[j - w] + w)
                             f[j] = (f[j] + f[j - w]) % MOD;
                     }
                 }
                 for (int j = m; j >= tmp * v[i]; --j)
                 {
                     int w = tmp * v[i];
                     dp[j] = max(dp[j], dp[j - w] + w);
                     if (dp[j] == dp[j - w] + w)
                         f[j] = (f[j] + f[j - w]) % MOD;
                 }
             }
         }
         for (int i = , id; i <= q; ++i)
         {
             scanf("%d", &id);
             printf("%lld\n", f[id]);
         }
     }
 }

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

     Run();
     return ;
 }  

L. Poor God Water

线性递推

 #include<bits/stdc++.h>
 using namespace std;
 #define mst(a,b) memset((a),(b),sizeof(a))

 typedef long long ll;
 const int maxn = ;
 const ll mod = 1e9 + ;
 const int INF = 0x3f3f3f3f;
 const double eps = 1e-;

 ll fast_mod(ll a, ll n, ll Mod)
 {
     ll ans = ;
     a %= Mod;
     while (n)
     {
         if (n & ) ans = (ans*a) % Mod;
         a = (a*a) % Mod;
         n >>= ;
     }
     return ans;
 }

 namespace Dup4
 {
     ll res[maxn], base[maxn], num[maxn], md[maxn];
     vector<int>vec;
     void mul(ll *a, ll *b, int k)
     {
         for (int i = ; i <  * k; i++) num[i] = ;
         for (int i = ; i < k; i++)
         {
             if (a[i])
             {
                 for (int j = ; j < k; j++)
                 {
                     num[i + j] = (num[i + j] + a[i] * b[j]) % mod;
                 }
             }
         }
         for (int i =  * k - ; i >= k; i--)
         {
             if (num[i])
             {
                 for (int j = ; j < vec.size(); j++)
                 {
                     num[i - k + vec[j]] = (num[i - k + vec[j]] - num[i] * md[vec[j]]) % mod;
                 }
             }
         }
         for (int i = ; i < k; i++) a[i] = num[i];
     }
     ll solve(ll n, vector<int> a, vector<int> b)
     {
         ll ans = , cnt = ;
         int k = a.size();
         assert(a.size() == b.size());
         for (int i = ; i < k; i++) md[k -  - i] = -a[i];
         md[k] = ;
         vec.clear();
         for (int i = ; i < k; i++) if (md[i]) vec.push_back(i);
         for (int i = ; i < k; i++) res[i] = base[i] = ;
         res[] = ;
         while ((1LL << cnt) <= n) cnt++;
         for (int p = cnt; p >= ; p--)
         {
             mul(res, res, k);
             if ((n >> p) & )
             {
                 for (int i = k - ; i >= ; i--) res[i + ] = res[i];
                 res[] = ;
                 for (int j = ; j < vec.size(); j++)
                 {
                     res[vec[j]] = (res[vec[j]] - res[k] * md[vec[j]]) % mod;
                 }
             }
         }
         for (int i = ; i < k; i++) ans = (ans + res[i] * b[i]) % mod;
         if (ans < ) ans += mod;
         return ans;
     }
     vector<int> BM(vector<int> s)
     {
         vector<int> B(, ), C(, );
         int L = , m = , b = ;
         for (int i = ; i < s.size(); i++)
         {
             ll d = ;
             for (int j = ; j < L + ; j++) d = (d + (ll)C[j] * s[i - j]) % mod;
             if (d == ) m++;
             else if ( * L <= i)
             {
                 vector<int> T = C;
                 ll c = mod - d * fast_mod(b, mod - , mod) % mod;
                 while (C.size() < B.size() + m) C.push_back();
                 for (int j = ; j < B.size(); j++) C[j + m] = (C[j + m] + c * B[j]) % mod;
                 L = i +  - L, B = T, b = d, m = ;
             }
             else
             {
                 ll c = mod - d * fast_mod(b, mod - , mod) % mod;
                 while (C.size() < B.size() + m) C.push_back();
                 for (int j = ; j < B.size(); j++) C[j + m] = (C[j + m] + c * B[j]) % mod;
                 m++;
             }
         }
         return C;
     }
     int gao(vector<int> a, ll n)
     {
         vector<int> c = BM(a);
         c.erase(c.begin());
         for (int i = ; i < c.size(); i++) c[i] = (mod - c[i]) % mod;
         return solve(n, c, vector<int>(a.begin(), a.begin() + c.size()));
     }
 }

 void RUN()
 {
     ll n;
     int t;
     scanf("%d", &t);
     while(t--)
     {
         scanf("%lld", &n);
         ++n;
         printf("%d\n", Dup4::gao(vector<int>{,,,,,,,,,}, n - ));
     }
 }

 int main()
 {
 #ifdef LOCAL_JUDGE
     freopen("Text.txt", "r", stdin);
 #endif // LOCAL_JUDGE

     RUN();

 #ifdef LOCAL_JUDGE
     fclose(stdin);
 #endif // LOCAL_JUDGE

     return ;
 }