2018 Multi-University Training Contest 4 Solution

A - Problem A. Integers Exhibition

留坑。

B - Problem B. Harvest of Apples

题意：计算$\sum_{i = 0}^{i = m}C(n, i)$

思路：由$sum_{i = 0}^{i = m}C(n,i)$可以得到$sum_{i = 0}^{i = m + 1}C(n,i)$以及$sum_{i = 0}^{i = m}C(n + 1,i)$然后用莫对算法求解

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const ll MOD = 1e9 + ;
 const int maxn = 1e5 + ;

 int unit;
 ll inv[maxn];
 ll invfac[maxn];
 ll fac[maxn];
 ll ans[maxn];
 int n, m;

 struct node{
     int l, r, id;
     inline node(){}
     inline node(int l, int r, int id) :l(l), r(r), id(id){}
     inline bool operator < (const node &b) const
     {
         if(l / unit != b.l / unit)    return l / unit < b.l / unit;
         else return r < b.r;
     }
 }arr[maxn];

 inline void Init()
 {
     fac[] = invfac[] = ;
     fac[] = inv[] = invfac[] = ;
     for(int i = ; i < maxn; ++i)
     {
         fac[i] = fac[i - ] * i % MOD;
         inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
         invfac[i] = invfac[i - ] * inv[i] % MOD;
     }
 }

 inline ll cal(int a, int b)
 {
     ll res = fac[a] * invfac[b] % MOD * invfac[a - b] % MOD;
     return res;
 }

 inline void work()
 {
     ll tmp = ;
     for(int i = ; i <= arr[].r; ++i)
     {
         tmp = (tmp + cal(arr[].l, i)) % MOD;
     }
     ans[arr[].id] = tmp;
     int L = arr[].l, R = arr[].r;
     for(int i = ; i <= n; ++i)
     {
         while(L < arr[i].l)
         {
             tmp = (tmp *  % MOD- cal(L++, R) + MOD) % MOD;
         }
         while(L > arr[i].l)
         {
             tmp = (tmp + cal(--L, R) + MOD) % MOD * inv[] % MOD;
         }
         while(R < arr[i].r)
         {
             tmp = (tmp + cal(L, ++R)) % MOD;
         }
         while(R > arr[i].r)
         {
             tmp = (tmp - cal(L, R--) + MOD) % MOD;
         }
         ans[arr[i].id] = tmp;
     }
 }

 int main()
 {
     Init();
     scanf("%d", &n);
     for(int i = ; i <= n; ++i)
     {
         scanf("%d %d", &arr[i].l, &arr[i].r);
         arr[i].id = i;
     }
     unit = (int)sqrt(n);
     sort(arr + , arr +  + n);
     work();
     for(int i = ; i <= n; ++i)
     {
         printf("%lld\n", ans[i]);
     }
     return ;
 }

C - Problem C. Problems on a Tree

留坑。

D - Problem D. Nothing is Impossible

题意：给出n道题目，每道题目有$a_i种正确选择，b_i种错误选择$ 一共有m个人，所有人都要选择一个题目集合去做，相当于去试答案，问最多能试出多少道题目答案

思路：排序，前缀积。

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

 #define N 110
 #define ll long long

 struct node
 {
     int a, b, sum;
     inline void scan()
     {
         scanf("%d%d", &a, &b);
         sum = a + b;
     }
     inline bool operator < (const node &r) const
     {
         return sum < r.sum;
     }
 }arr[N];

 int t, n, m;
 ll sum;

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d%d", &n, &m);
         for (int i = ; i <= n; ++i) arr[i].scan();
         sort(arr + , arr +  + n);
         int ans = ; sum = ;
         for (int i = ; i <= n; ++i)
         {
             sum *= arr[i].sum;
             if (sum > m) break;
             ans = i;
         }
         printf("%d\n", ans);
     }
     return ;
 }

E - Problem E. Matrix from Arrays

题意：给出一种构造二维数组的构造方式，然后给出一个左上角，一个右下角，求这个矩形内的数和

思路：打表找规律发现，大矩阵是由若干个$2L \cdot 2L$个小矩阵构成的，那么把给出的矩阵分成四块，整块整块的处理，边边角角的处理

 #include<bits/stdc++.h>

 using namespace std;

 #define N 110

 typedef long long ll;

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

 inline ll cal(int x,int y)
 {
     if(x <  || y < ) return 0ll;
     ll res = G[n - ][n - ] * (x / n) * (y / n) + G[n - ][y % n] * (x / n) + G[x % n][n - ] * (y / n) + G[x % n][y % n];
     return res;
 }

 int main()
 {
     int t;
     scanf("%d", &t);
     while(t--)
     {
         scanf("%d", &n);
         for(int i = ; i < n; ++i)
         {
             scanf("%lld", arr + i);
         }
         for(int i = , cnt = ; i < (n << ); ++i)
         {
             for(int j = ; j <= i; ++j)
             {
                 G[j][i - j] = arr[cnt];
                 cnt = (cnt + ) % n;
             }
         }
         n <<= ;
         for(int i = ; i < n; ++i)
         {
             for(int j = ; j < n; ++j)
             {
                 G[i][j] += (i ? G[i - ][j] : );
                 G[i][j] += (j ? G[i][j - ] : );
                 G[i][j] -= ((i && j) ? G[i - ][j - ] : );
             }
         }
         int q;
         scanf("%d", &q);
         while(q--)
         {
             scanf("%d %d %d %d", &x[], &y[], &x[], &y[]);
             ll ans = cal(x[], y[]) - cal(x[] - , y[]) - cal(x[], y[] - ) + cal(x[] - , y[] - );
             printf("%lld\n", ans);
         }
     }
     return ;
 }

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

 #define N 1100
 #define ll long long

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

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         for (int i = ; i <= n; ++i) scanf("%lld", arr + i);
         memset(G, , sizeof G);
         for (int i = , cnt = ; i <= (n << ); ++i)
         {
             for (int j = ; j <= i; ++j)
             {
                 G[j][i - j] = arr[cnt + ];
                 cnt = (cnt + ) % n;
             }
         }
         n <<= ;
         ll base = ;
         for (int i = ; i < n; ++i) for (int j = ; j < n; ++j) base += G[i][j];
         scanf("%d", &q);
         while (q--)
         {
             scanf("%d%d%d%d", &x[], &y[], &x[], &y[]);
             ll ans = , tmp;
             //compute Big
             ll xl = (x[] - x[] + ) / n, yl = (y[] - y[] + ) / n; ans += (base * xl * yl);
             //compute lower_left corner
             tmp = ;
             for (int i = x[] + xl * n; i <= x[]; ++i)
             {
                 for (int j = y[], cnt = ; cnt <= n; ++cnt, ++j)
                     tmp += G[i % n][j % n];
             }
             //compute upper_right corner
             ans += tmp * yl; tmp = ;
             for (int i = x[], cnt = ; cnt <= n; ++cnt, ++i)
             {
                 for (int j = y[] + yl * n; j <= y[]; ++j)
                     tmp += G[i % n][j % n];
             }
             //compute lower_right corner
             ans += tmp * xl; tmp = ;
             for (int i = x[] + xl * n; i <= x[]; ++i)
             {
                 for (int j = y[] + yl * n; j <= y[]; ++j)
                     ans += G[i % n][j % n];
             }
             printf("%lld\n", ans);
         }
     }
     return ;
 }

F - Problem F. Travel Through Time

留坑。

G - Problem G. Depth-First Search

留坑。

H - Problem H. Eat Cards, Have Fun

留坑。

I - Problem I. Delightful Formulas

留坑。

J - Problem J. Let Sudoku Rotate

题意：给出一个16 * 16 的数独， 有一些4 * 4 的矩阵被逆时针旋转过，然后求恢复最少需要旋转多少次

思路：爆搜，两条剪枝，一个是判断是否有冲突，一个是判断当前步数是否比已有答案大

 #include<bits/stdc++.h>

 using namespace std;

 const int maxn = 1e2 + ;

 int ans;
 bool vis[];
 char s[];
 int G[maxn][maxn];

 inline bool judge(int x,int y)
 {
     for(int i = x *  - ; i <= x * ; ++i)
     {
         memset(vis, false, sizeof vis);
         for(int j = ; j <= y * ; ++j)
         {
             if(vis[G[i][j]]) return false;
             vis[G[i][j]] = true;
         }
     }
     for(int i = y *  - ; i <= y * ; ++i)
     {
         memset(vis, false, sizeof vis);
         for(int j = ;  j <= x * ; ++j)
         {
             if(vis[G[j][i]]) return false;
             vis[G[j][i]] = true;
         }
     }
     return true;
 }

 inline void fun(int x, int y)
 {
     int tmp[][];
     for(int i = ; i <= ; ++i)
     {
         for(int j = ; j <= ; ++j)
         {
             tmp[j][ - i + ] = G[(x - ) *  + i][(y - ) *  + j];
         }
     }
     for(int i = ; i <= ; ++i)
     {
         for(int j = ; j <= ; ++j)
         {
             G[(x - ) *  + i][(y - ) *  + j] = tmp[i][j];
         }
     }
 }
 inline void DFS(int x,int y,int res)
 {
     if(res >= ans) return ;
     if(y > )
     {
         DFS(x + , , res);
         return ;
     }
     if(x == )
     {
         ans = min(ans, res);
         return ;
     }
     for(int i = ; i < ; ++i)
     {
         if(i)
         {
             fun(x, y);
 /*            if(x == 3 && y == 1 && i == 1)
             {
                 for(int i = x * 4 - 3; i <= x * 4; ++i)
                 {
                     for(int j = y * 4 - 3; j <= y * 4; ++j)
                     {
                         printf("%d%c", G[i][j], " \n"[j == y * 4]);
                     }
                 }
             }*/
         }
         if(judge(x, y))
         {
             DFS(x, y + , res + i);
         }
     }
     fun(x, y);
 }

 int main()
 {
     int t;
     scanf("%d", &t);
     while(t--)
     {
         ans =  << ;
         for(int i = ; i <= ; ++i)
         {
             scanf("%s", s + );
             for(int j = ; j <= ; ++j)
             {
                 if(s[j] >= '' && s[j] <= '')
                 {
                     G[i][j] = s[j] - '';
                 }
                 else if(s[j] >= 'A' && s[j] <= 'F')
                 {
                     G[i][j] = (s[j] - 'A') + ;
                 }
             }
         }
     //    fun(1, 1);
         DFS(, , );
         printf("%d\n", ans);
     }
     return ;
 }

K - Problem K. Expression in Memories

按题意模拟即可

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

 #define N 100010

 int t;
 char s[N];

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%s", s);
         bool flag = true;
         int len = strlen(s);
         for(int i = ; i < len; ++i)
         {
             if(s[i] == '*' || s[i] == '+')
             {
                 if(i ==  || i == len - )
                 {
                     flag = false;
                     break;
                 }
                 else if(s[i + ] == '*' || s[i + ] == '+')
                 {
                     flag = false;
                     break;
                 }
             }
             else if(s[i] == '')
             {
                 if(i ==  || s[i - ] == '*' || s[i - ] == '+')
                 {
                     if(i +  < len && s[i + ] >= '' && s[i + ] <= '')
                     {
                         flag = false;
                         break;
                     }
                     else if(s[i + ] == '?') s[i + ] = '+';
                 }
             }
             else if(s[i] == '?')
             {
                 s[i] = '';
             }
         }
         if(flag)
         {
             printf("%s\n", s);
         }
         else
         {
             printf("IMPOSSIBLE\n");
         }
     }
     return ;
 }

L - Problem L. Graph Theory Homework

水。

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

 #define N 100010

 int t, n;
 int arr[N];

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         for (int i = ; i <= n; ++i) scanf("%d", arr + i);
         int ans = (int)floor(sqrt(abs(arr[] - arr[n])));
         printf("%d\n", ans);
     }
     return ;
 }