The 2017 China Collegiate Programming Contest, Hangzhou Site Solution

A: Super_palindrome

题面：给出一个字符串，求改变最少的字符个数使得这个串所有长度为奇数的子串都是回文串

思路：显然，这个字符串肯定要改成所有奇数位相同并且所有偶数位相同

那统计一下奇数位上哪个字符出现的个数最多，偶数位上哪个字符出现的个数最多

答案就是 n 减去它们

 #include <bits/stdc++.h>

 using namespace std;

 #define N 110
 #define INF 0x3f3f3f3f

 int t;
 char s[N];

 int odd[];
 int even[];

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%s", s);
         memset(odd, , sizeof odd);
         memset(even, , sizeof even);
         int len = strlen(s);
         int Maxodd = , Maxeven = ;
         for (int i = ; i < len; ++i)
         {
             if (i & )
                 odd[s[i]]++, Maxodd = max(Maxodd, odd[s[i]]);
             else
                 even[s[i]]++, Maxeven = max(Maxeven, even[s[i]]);
         }
         printf("%d\n", len - Maxodd - Maxeven);
     }
     return ;
 }

B: Master of Phi

题意：给定一个n，接下来n行输入p和q代表数字num有q个p因子，计算题中式子

思路:根据题中数字提取出公因数n，然后每个式子只是每个数的质因子乘上（1-1/p）。对于所有要求的式子，对于每个质因子p仅可能0-q中可能，所以所求式子就变成了∏((1-1/pi)*qi+1)所得值。

 #include<bits/stdc++.h>

 using namespace std;

 #define N 110

 typedef long long ll;

 const int MOD = ;

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

 int m;
 ll p[N],q[N];
 ll tmp[N];

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&m);
         ll ans = ;
         for(int i = ;i <= m; ++i)
         {
             scanf("%lld %lld",&p[i], &q[i]);
             p[i] %= MOD;
             ans = (ans * qpow(p[i], q[i])) % MOD;
             p[i] = (p[i] - ) * qpow(p[i], MOD - ) % MOD;
             tmp[i] = p[i] * q[i] % MOD;
         }
         for(int i = ; i <= m; ++i)
         {
             ans = (ans * (tmp[i] + ) % MOD) % MOD;
         }
         printf("%lld\n",ans);
     }
     return ;
 }

C: Hakase and Nano

题面：有n堆石子，两个人轮流取，Hakase 一轮必须取两次，另一个人一轮取一次，最后取光的人胜利，给出先后手顺序，判断哪个人必胜

思路：通过两个人的简单模拟，可以发现Hakase的优势很大，它的必败情况很少。

以下四种为必败情况

H先手，并且所有石子堆都是1，并且石子堆数%3==0

H后手，并且所有石子堆都是1，并且石子堆数%3==1

H后手，并且有一个石子堆的个数不是1，其它全是1，并且石子堆数%3==0 || %3 == 1

 #include<bits/stdc++.h>

 using namespace std;

 #define N 1000010

 int n, d;
 int arr[N];

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d %d",&n,&d);
         int num = ;
         for(int i = ; i <= n; ++i)
         {
             scanf("%d",&arr[i]);
             if(arr[i] > ) num++;
         }
         if(num >= )
         {
             puts("Yes");
             continue;
         }
         if(d == )
         {
             if(num ==  && n %  == ) puts("No");
             else puts("Yes");
         }
         else if(d == )
         {
             if(num ==  && n %  == ) puts("No");
             else if(num ==  && (n %  ==  || n %  == )) puts("No");
             else puts("Yes");
         }
     }
     return ;
 }

D:Master of Random

题意：给出一棵树，每个节点都有一个权值，对于第i个节点，它的father是random(0, i-1)，求任意一颗子树的权值期望。

题意：对于一颗子树，它的权值为自身权值加上除自己以外的权值期望。对于节点i，那么i+1是节点i的子节点的概率为1/(1 + i)，对于第i+2个节点是节点i的子节点的概率为1/(i+2)+1/(i+1)*1/(i+2)=1/(i+1)，从而发现后面每个节点是i的子节点的概率都为1/(i+1)。那么第i个节点的权值期望就为ai+1/(i+1)*∑aj(j from i+1 to n-1)

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const int MOD = ;

 #define N 100010

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

 int n;
 ll a[N];
 ll sum[N];

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&n);
         for(int i = ;i < n; ++i)
         {
             scanf("%lld",&a[i]);
         }
         memset(sum, , sizeof sum);
         for(int i = n - ; i >= ; --i)
         {
             sum[i] = (sum[i + ] + a[i]) % MOD;
         }
         ll ans = ;
         for(int i = ;i < n; ++i)
         {
             ans = (ans + (a[i] + sum[i + ] * qpow(i + , MOD - ) % MOD) % MOD) % MOD;
         }
         ans = (ans * qpow(n, MOD - )) % MOD;
         printf("%lld\n", ans);
     }
     return ;
 }

E:Master of Subgraph

留坑。

F:Hearthock

留坑。

G:Marriage

留坑。

H:Master of Connexted Component

留坑。

I:Master of Matrix

留坑

J:Master of GCD

题意：有n个数刚开始都是1，然后每次操作使得(l, r)区间的所有数都乘上x，x == 2 || x ==3 求所有数的最大公约数

思路：显然，我们找出乘2最少的次数n，以及乘3最少的次数m 答案就是2^n * 3*m

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;
 const int INF = 0x3f3f3f3f;
 const int p = ;
 #define N 100010

 int n, m;

 ll sum_2[N], sum_3[N];

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

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
         memset(sum_2, , sizeof sum_2);
         memset(sum_3, , sizeof sum_3);
         scanf("%d %d",&n,&m);
         for(int i = ; i < m; ++i)
         {
             int l,r,x;
             scanf("%d %d %d",&l ,&r ,&x);
             if(x == )
             {
                 sum_2[l]++;
                 sum_2[r + ]--;
             }
             else
             {
                 sum_3[l]++;
                 sum_3[r + ]--;
             }
         }
         ll Min_2 = INF;
         ll Min_3 = INF;
         ll op_2 = , op_3 = ;
         for(int i = ; i <= n; ++i)
         {
             op_2 += sum_2[i];
             Min_2 = min(Min_2, op_2);
             op_3 += sum_3[i];
             Min_3 = min(Min_3, op_3);
         }
         ll ans = ;
         ans = (ans * qpow(, Min_2)) % p;
         ans = (ans * qpow(, Min_3)) % p;
         printf("%lld\n",ans);
     }
     return ;
 }

K:Master of Sequence

题意：两组序列，三种操作。

思路：ai很小，我们可以考虑对ai作文章。可以把那个式子拆开看成 floor(t / ai) - (bi / ai)

然后预处理出bi / ai 的整数部分和余数部分 并且将所有整数部分相加得到sum

然后查询的时候二分枚举t，查询的时候用去考虑对于同一个ai, 如果t/ai 的余数小于  bi/ai 的余数 那就需要多减一 然后加上整数部分

然后前缀和处理一下，二分的时间复杂度为logn * 1000

修改的时间复杂度为O(1000)

 #include <bits/stdc++.h>

 using namespace std;

 #define N 100010

 #define M 1010

 #define ll long long

 #define INFLL (ll)1e12

 int arr[N], brr[N];

 int a[M][M];

 ll sum;

 int n, m;

 inline bool check(ll mid, ll k)
 {
     ll tot = -sum;
     for (int i = ; i <= ; ++i)
     {
         ll tmp = mid / i;
         ll MOD = mid % i;
         tot += tmp * a[i][];
         tot -= a[i][MOD + ];
     }
     return tot >= k;
 }

 int main()
 {
     int t; scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d", &n, &m);
         for (int i = ; i <= n; ++i)
             scanf("%d", arr + i);
         for (int i = ; i <= n; ++i)
             scanf("%d", brr + i);
         memset(a, , sizeof a);
         sum = ;
         for (int i = ; i <= n; ++i)
         {
             a[arr[i]][brr[i] % arr[i]]++;
             sum += brr[i] / arr[i];
         }
         for (int i = ; i <= ; ++i)
         {
             for (int j = ; j >= ; --j)
             {
                 a[i][j] += a[i][j + ];
             }
         }
         int op, x, y, k;
         while (m--)
         {
             scanf("%d", &op);
             if (op == )
             {
                 scanf("%d%d", &x, &y);
                 int tmp = arr[x]; arr[x] = y;
                 for (int i = ; i <= brr[x] % tmp; ++i)
                     a[tmp][i]--;
                 sum -= brr[x] / tmp;
                 sum += brr[x] / arr[x];
                 for (int i = ; i <= brr[x] % arr[x]; ++i)
                     a[arr[x]][i]++;
             }
             else if (op == )
             {
                 scanf("%d%d", &x, &y);
                 int tmp = brr[x]; brr[x] = y;
                 for (int i = ; i <= tmp % arr[x]; ++i)
                     a[arr[x]][i]--;
                 sum -= tmp / arr[x];
                 sum += brr[x] / arr[x];
                 for (int i = ; i <= brr[x] % arr[x]; ++i)
                     a[arr[x]][i]++;
             }
             else if (op == )
             {
                 scanf("%d", &k);
                 ll l = , r = INFLL, ans = -;
                 while (r - l >= )
                 {
                     ll mid = (l + r) >> ;
                     if (check(mid, (ll)k))
                     {
                         ans = mid;
                         r = mid - ;
                     }
                     else
                     {
                         l = mid + ;
                     }
                 }
                 printf("%lld\n", ans);
             }
         }
     }
     return ;
 }

L:Mod, Xor and Everything

留坑。