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[1] == 0) return false;
    if (a[s] == 0 && b[s] == 0) return false;
    for (int i = 1; i <= n; ++i) if (a[i]) vis[i] = 1;
    bool flag = false;
    for (int i = n; i >= 1; --i)
    {
        if (a[i] && b[i]) flag = 1;
        if (flag && b[i]) vis[i] = 1; 
    }
    return vis[s];
}

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

 

 

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 = 0;
        for (int i = 1; i <= n; ++i) 
        {
            scanf("%lld", a + i);
            if (a[i] > l && a[i - 1] <= l) ++res; 
        }
        for (int i = 1, t, p, d; i <= m; ++i)
        {
            scanf("%d", &t);
            if (t == 0) printf("%d\n", res);
            else 
            {
                scanf("%d%d", &p, &d);
                if (a[p] <= l && a[p] + d > l)  
                {
                    if (a[p - 1] > l && a[p + 1] > l) --res;
                    else if (a[p - 1] > l || a[p + 1] > l);
                    else ++res;                    
                }
                a[p] += d;  
            }
        }
    }
    return 0;
}

 

 

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) + 1);  
}
    
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 0;
}

 

 

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][2], num[N], cnt;  
ll w[N], k;

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

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

 

G. Jellyfish Nightmare

Unsolved.