Mail.Ru Cup 2018 Round 2 Solution

A. Metro

Solved.

题意：

有两条铁轨，都是单向的，一条是从左往右，一条是从右往左，Bob要从第一条轨道的第一个位置出发,Alice的位置处于第s个位置，有火车会行驶在铁轨上，一共有n个站点，1表示火车会在该站点停下，0表示不会，求Bob能否到达地s个位置（到达任意一边即可）

思路：

如果第一条铁轨的第一个位置为0，或者第s个位置的两条铁轨都不停，那么答案显然是$"No"$

再考虑第一条铁轨上所有为1的位置都可以到达

再考虑两条轨道是否有同一个站点都都会停下的，那么就可以到达第二条轨道，并且该站点的左边的会停下的站点都可以到达

再判断一下s站点有没有被标记即可。

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

 #define N 1010
 int n, s, a[N], b[N];
 int vis[N];

 bool solve()
 {
     if (a[] == ) return false;
     if (a[s] ==  && b[s] == ) return false;
     for (int i = ; i <= n; ++i) if (a[i]) vis[i] = ;
     bool flag = false;
     for (int i = n; i >= ; --i)
     {
         if (a[i] && b[i]) flag = ;
         if (flag && b[i]) vis[i] = ;
     }
     return vis[s];
 }

 int main()
 {
     while (scanf("%d%d", &n, &s) != EOF)
     {
         memset(vis, , sizeof vis);
         for (int i = ; i <= n; ++i) scanf("%d", a + i);
         for (int i = ; i <= n; ++i) scanf("%d", b + i);
         puts(solve() ? "YES" : "NO");
     }
     return ;
 }

B. Alice and Hairdresser

Solved,

题意：

Alice有$n根头发，只有长度 > l 的头发才需要减，并且有相邻多根头发的长度都 > l，那么这几根可以一刀剪掉$

现在有两种操作，第一种是询问Alice如果要剪头发，最少需要减几刀，第二种是第$p$根头发增加了$d$的长度。

思路：

头发增加时，如果这根头发已经$ > l 了$ 那么不需要操作

反之，则判断一下，左右两边的头发长度

如果左右两边头发长度都$> l$ 那么下剪刀的次数 - 1  因为左右两边本来是两个连通块，现在连成一个。

如果有一边$ > l$ 有一边不是，那么下剪刀次数不变

如果两边都$ < l$ 那么下剪刀次数+1

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

 #define ll long long
 #define N 100010
 int n, m, res;
 ll l, a[N];

 int main()
 {
     while (scanf("%d%d%lld", &n, &m, &l) != EOF)
     {
         res = ;
         for (int i = ; i <= n; ++i)
         {
             scanf("%lld", a + i);
             if (a[i] > l && a[i - ] <= l) ++res;
         }
         for (int i = , t, p, d; i <= m; ++i)
         {
             scanf("%d", &t);
             if (t == ) printf("%d\n", res);
             else
             {
                 scanf("%d%d", &p, &d);
                 if (a[p] <= l && a[p] + d > l)
                 {
                     if (a[p - ] > l && a[p + ] > l) --res;
                     else if (a[p - ] > l || a[p + ] > l);
                     else ++res;
                 }
                 a[p] += d;
             }
         }
     }
     return ;
 }

C. Lucky Days

Upsolved.

题意：

定义一个三元组$<l, r, t>$ 表示一个周期为$t$，第$[l, r]$天里面是幸运天，现在给出$Alice 和 Bob$的两个三元组，求两人最长的连续相同的幸运天数。

思路：

考虑两个人的起点之差是 $gcd(ta, tb)$ 用一个人的起点去逼近另一个人的起点，然后求一下答案。

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

 #define ll long long
 ll la, lb, ra, rb, ta, tb;

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

 ll calc(ll la, ll ra, ll lb, ll rb)
 {
     return max(0ll, min(ra, rb) - max(la, lb) + );
 }

 int main()
 {
     while (scanf("%lld%lld%lld", &la, &ra, &ta) != EOF)
     {
         scanf("%lld%lld%lld", &lb, &rb, &tb);
         if (la > lb)
         {
             swap(la, lb);
             swap(ra, rb);
             swap(ta, tb);
         }
         ll g = gcd(ta, tb);
         ll gap = ra - la;
         la += ((lb - la) / g) * g;
         ra = la + gap;
         printf("%lld\n", max(calc(la, ra, lb, rb), calc(la + g, ra + g, lb, rb)));
     }
     return ;
 }

D. Refactoring

Unsolved.

E. Segments on the Line

Unsolved.

F. Tree and XOR

Upsolved.

题意：

在一棵树种，一共有$n^2$个任意两点间的简单路径异或和，求第k大。

思路：

显然，路上任意两点路径异或和就是两个点到根的异或和再异或

再考虑求第k大，可以二分，然后去找到有多少个比这个数小的数，如果$<= k 那么这个数就可能可以作为答案$

但这样的过程是$O(n{log^n}^2)$，显然不行

但是其实可以直接一位一位考虑，从高位到低位逐位确定，枚举当前为是否为1，如果为1，那么异或后当前为为0的都是比当前数小的数，逐步确定下去即可。

但是注意到，这个过程可以用$01Trie 完成，但是完整的01Trie空间开不下$

又考虑我们每一次确定的时候，只会用到上一层和当前层的状态，所有用滚动数组即可。

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

 #define ll long long
 #define N 1000010
 int n, rt[N], prt[N], ch[N][], num[N], cnt;
 ll w[N], k;

 void init()
 {
     memset(num, , sizeof num);
     memset(ch, , sizeof ch);
 }

 int main()
 {
     while (scanf("%d%lld", &n, &k) != EOF)
     {
         init();
         for (int i = , p; i <= n; ++i)
         {
             scanf("%d%lld", &p, w + i);
             w[i] ^= w[p];
         }
         ll res = ;
         for (int i = ; i <= n; ++i) rt[i] = prt[i] = ; cnt = ;
         for (int s = ; s >= ; --s)
         {
             for (int i = ; i <= cnt; ++i) ch[i][] = ch[i][] = num[i] = ; cnt = ;
             for (int i = ; i <= n; ++i)
             {
                 int id = (w[i] >> s) & ;
                 if (!ch[rt[i]][id]) ch[rt[i]][id] = ++cnt;
                 rt[i] = ch[rt[i]][id];
                 ++num[rt[i]];
             }
             ll sum = ;
             for (int i = ; i <= n; ++i)
             {
                 int id = (w[i] >> s) & ;
                 sum += num[ch[prt[i]][id]];
             }
             if (sum < k)
             {
                 res |= 1ll << s;
                 k -= sum;
                 for (int i = ; i <= n; ++i)
                 {
                     int id = (w[i] >> s) & ;
                     prt[i] = ch[prt[i]][id ^ ];
                 }
             }
             else
             {
                 for (int i = ; i <= n; ++i)
                 {
                     int id = (w[i] >> s) & ;
                     prt[i] = ch[prt[i]][id];
                 }
             }
         }
         printf("%lld\n", res);
     }
     return ;
 }

G. Jellyfish Nightmare

Unsolved.