Lyft Level 5 Challenge 2018

A. The King's Race

签.

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

#define ll long long
ll n, x, y;

ll f(ll a, ll b)
{
    return max(abs(a - x), abs(b - y));
}

int main()
{
    while (scanf("%lld%lld%lld", &n, &x, &y) != EOF)
    {
        puts(f(1, 1) <= f(n, n) ? "White" : "Black");
    }
    return 0;
}

B. Taxi drivers and Lyft

签.

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

#define N 100010
int n, m;
struct node
{
    int x, t, id, small, big, small_pos, big_pos; 
}a[N << 1]; 
int ans[N];

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        memset(ans, 0, sizeof ans);
        for (int i = 1, x; i <= n + m; ++i)
        {
            scanf("%d", &x);
            a[i].x = x; 
        }
        for (int i = 1, tmp = 0, t; i <= n + m; ++i)
        {
            scanf("%d", &t);
            a[i].t = t;
            if (t == 1)
                a[i].id = ++tmp;
        }
        int Max = -((int)1e9 + 1), pos = -1; 
        for (int i = 1; i <= n + m; ++i)
        {
            if (a[i].t == 1) 
            {
                Max = a[i].x;
                pos = a[i].id;
            }
            else
            {
                a[i].small = Max;
                a[i].small_pos = pos;
            }
        }
        int Min = (int)2e9 + 1; pos = -1;
        for (int i = n + m; i >= 1; --i)
        {
            if (a[i].t == 1)
            {
                Min = a[i].x;
                pos = a[i].id;
            }
            else
            {
                a[i].big = Min;
                a[i].big_pos = pos;
            }
        }
        for (int i = 1; i <= n + m; ++i) if (a[i].t == 0)
        {
            int A = abs(a[i].x - a[i].small), B = abs(a[i].x - a[i].big);
            if (A <= B) ++ans[a[i].small_pos];
            else ++ans[a[i].big_pos];
        }
        for (int i = 1; i <= m; ++i) 
            printf("%d%c", ans[i], " 
"[i == m]);
    }
    return 0;
}

C. The Tower is Going Home

Solved.

题意：

要从$(1, 1) 走到(1e9, *)$

$有一些横着和竖着的栏杆挡着，每次只能移动到曼哈顿距离为1的格子$

$求最小的需要去掉的栏杆的数量，使得可以到达目的地$

思路：

考虑横着的栏杆，$如果左端点不是1，那么该栏杆没有用$

$那么考虑从左到右扫一遍，竖着的栏杆按顺序去掉后$

$右端点没有超过该竖着栏杆的横栏杆，该横栏杆也没有用$

更新答案即可

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

#define N 100010
int n, m, q;
int a[N], b[N];


int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        sort(a + 1, a + 1 + n);
        q = 0;
        for (int i = 1, x1, x2, y; i <= m; ++i)
        {
            scanf("%d%d%d", &x1, &x2, &y);
            if (x1 == 1) b[++q] = x2;
        }
        sort(b + 1, b + 1 + q);
        int res = q;  
        int pos = 0;
        a[n + 1] = (int)1e9; 
        for (int i = 0; i <= n; ++i)
        {
            while (pos < q && b[pos + 1] < a[i + 1]) ++pos;
            res = min(res, i + q - pos);
        }
        printf("%d
", res);
    }
    return 0;
}

D. Intersecting Subtrees

Upsolved.

题意：

有一棵树，$A选了一棵子树，B选了一棵子树$

$但是B对树的标号和A对树的标号不同$

$现在告诉你以A标号的树的形态$

$以及A, B各自选择的子树的标号$

$有5次询问机会，每次可以询问$

$A ; x;; 返回B对应的标号$

$B ; y ;; 返回A对应的标号$

最后给出答案，$A， B选择的子树是否有交，有的话输出其中一个交点，否则输出-1$

思路：

随便选一个$B中的点，得到A中的点，如果刚好是A子树内的，直接输出$

$否则以这个点去找一个最近的点，再询问一次，如果是就输出，否则就是-1$

$因为找到的是最近的属于A选择子树内的点，说明这条路径上没有交，如果这个点不是交$

$那么说明那个点那头也不会有交$ 

$如果有交的话，这个点就会把B选择的子树分成两部分，就不是连通的，和题意想违背$

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

#define N 1010
int t, n, k, st;
int visa[N], visb[N];
vector <int> G[N];

int fa[N];
void BFS(int S) 
{
    queue <int> q; q.push(S); fa[st] = S;
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        if (visa[u]) 
        {
            st = u;
            return; 
        }
        for (auto v : G[u]) if (v != fa[u])
        {
            fa[v] = u;
            q.push(v);
        }
    }
}

int dfs(int num,int fa){
    if(visa[num]){
        return num;
    }
    for (auto v : G[num]) if (v != fa) 
    {
        int temp=dfs(v,num);
        if(temp!=-1){
            return temp;
        }
    }
    return -1;
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) G[i].clear();
        memset(visa, 0, sizeof visa);
        memset(visb, 0, sizeof visb);
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        scanf("%d", &k);
        for (int i = 1, x; i <= k; ++i)
        {
            scanf("%d", &x);
            visa[x] = 1;
        }    
        scanf("%d", &k);
        for (int i = 1, x; i <= k; ++i)
        {
            scanf("%d", &x);
            visb[x] = 1;
            st = x;
        }
        printf("B %d
", st);
        fflush(stdout);
        st = -1;
        scanf("%d", &st); 
        if (visa[st])
        {
            printf("C %d
", st);
            fflush(stdout);
            continue;
        }
        BFS(st);
        //st = dfs(st, st);
        int ed;
        printf("A %d
", st);
        fflush(stdout);
        scanf("%d", &ed);
        if (visa[st] && visb[ed])
            printf("C %d
", st);
        else 
            puts("C -1");
        fflush(stdout);
    }
    return 0;
}

E. Optimal Polygon Perimeter

Upsolved.

题意：

给出一个凸包，两点之间的距离为曼哈顿距离

定义$f(x) 为选择x个点构成一个凸包的最大周长$

输出$f(3), f(4) cdots f(n)$

思路：

对于$n >= 4的答案，就是选择最大上界，最大下界，最大左界，最大右界，构成的矩形的周长$

$再考虑n == 3的时候$

$因为是一个三角形，那么肯定是某两个最构成的两个点，再加上一个点，那个点枚举求解即可$

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

#define N 300010
int n;
int x[N], y[N];

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        int Max[2], Min[2];
        Min[0] = Min[1] = (int)1e9;
        Max[0] = Max[1] = -(int)1e9;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d%d", x + i, y + i);
            Max[0] = max(Max[0], x[i]);
            Min[0] = min(Min[0], x[i]);
            Max[1] = max(Max[1], y[i]);
            Min[1] = min(Min[1], y[i]);
        }
        if (n == 3)
            printf("%d
", 2 * (Max[0] + Max[1] - Min[0] - Min[1]));
        else
        {
            int res = 0;
            for (int i = 1; i <= n; ++i)
                res = max(res, max(abs(x[i] - Max[0]), abs(x[i] - Min[0])) + max(abs(y[i] - Max[1]), abs(y[i] - Min[1])));
            res *= 2;
            printf("%d", res);    
            for (int i = 4; i <= n; ++i) 
                printf(" %d", 2 * (Max[0] + Max[1] - Min[0] - Min[1]));
            puts("");
        }
    }
    return 0;
}

F. Deduction Queries

Upsolved.

题意：

两种操作

$1;l;r;x 告知你[l, r]的异或和$

$2;l;r 询问[l,r]的异或和，如果不知道就输出-1$

思路：

我们考虑异或的性质，就是异或两次就相当于删除

对于每次给出的$l, r我们可以把l, r并在一起$

$这样对于每个连通块中的节点，我们维护的是当前点到根的异或和$

$这样连通块中任意两点都可以询问，答案就是两个到根的异或和再异或一下$

$我们再考虑合并$

$我们令a, b为给出的异或和, fa[a], fa[b]为其所在连通块的根$

$我们发现这两个连通块有这样一条路径$

$fa[a] -> a -> b -> fa[b]$

$我们期望将fa[a] -> fa[b] 连一条边$

$根据前面定义的性质 fa[a]要维护的权值就是[fa[a], fa[b]]的异或和$ 

$那么这个权值就是 [fa[a], a] oplus [a, b] oplus [b, fa[b]]$

为了方便操作，我们将右界$+1$

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

#define N 200010
int q, t, l, r, x, last;
map <int, int> fa, Xor, Rank;

int find(int x)
{
    if (fa[x] == x) return x;
    int root = find(fa[x]);
    Xor[x] ^= Xor[fa[x]];
    return fa[x] = root;
}

int main()
{
    while (scanf("%d", &q) != EOF)
    {
        fa.clear(); Xor.clear(); Rank.clear(); last = 0;
        while (q--)
        {
            scanf("%d%d%d", &t, &l, &r);
            if (t == 1)
            {
                scanf("%d", &x);
                l ^= last;
                r ^= last;
                x ^= last;
                if (l > r) swap(l, r);
                ++r;
                if (fa.find(l) == fa.end()) fa[l] = l, Xor[l] = 0;
                if (fa.find(r) == fa.end()) fa[r] = r, Xor[r] = 0;
                int fl = find(l), fr = find(r);
                if (fl != fr)
                {
                    if (Rank[fr] <= Rank[fl])
                    {
                        fa[fr] = fl;
                        Xor[fr] = Xor[l] ^ Xor[r] ^ x;    
                        if (Rank[fl] == Rank[fr]) ++Rank[fl];
                    }
                    else
                    {
                        fa[fl] = fr;
                        Xor[fl] = Xor[l] ^ Xor[r] ^ x;
                    }
                }
            }
            else
            {
                l ^= last;
                r ^= last;
                if (l > r) swap(l, r); ++r;
                if (fa.find(l) == fa.end() || fa.find(r) == fa.end())
                {
                    last = 1;
                    puts("-1");
                    continue;
                }
                int fl = find(l), fr = find(r);
                if (fl != fr)
                {
                    last = 1;
                    puts("-1");
                }
                else
                {
                    last = Xor[l] ^ Xor[r];
                    printf("%d
", last);
                }
            }
        }
    }
    return 0;
}