Lyft Level 5 Challenge 2018 - Final Round (Open Div. 2)

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(, ) <= f(n, n) ? "White" : "Black");
     }
     return ;
 }

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 << ];
 int ans[N];

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

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 = ; i <= n; ++i) scanf("%d", a + i);
         sort(a + , a +  + n);
         q = ;
         for (int i = , x1, x2, y; i <= m; ++i)
         {
             scanf("%d%d%d", &x1, &x2, &y);
             if (x1 == ) b[++q] = x2;
         }
         sort(b + , b +  + q);
         int res = q;
         int pos = ;
         a[n + ] = (int)1e9;
         for (int i = ; i <= n; ++i)
         {
             while (pos < q && b[pos + ] < a[i + ]) ++pos;
             res = min(res, i + q - pos);
         }
         printf("%d\n", res);
     }
     return ;
 }

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!=-){
             return temp;
         }
     }
     return -;
 }

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

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[], Min[];
         Min[] = Min[] = (int)1e9;
         Max[] = Max[] = -(int)1e9;
         for (int i = ; i <= n; ++i)
         {
             scanf("%d%d", x + i, y + i);
             Max[] = max(Max[], x[i]);
             Min[] = min(Min[], x[i]);
             Max[] = max(Max[], y[i]);
             Min[] = min(Min[], y[i]);
         }
         if (n == )
             printf("%d\n",  * (Max[] + Max[] - Min[] - Min[]));
         else
         {
             int res = ;
             for (int i = ; i <= n; ++i)
                 res = max(res, max(abs(x[i] - Max[]), abs(x[i] - Min[])) + max(abs(y[i] - Max[]), abs(y[i] - Min[])));
             res *= ;
             printf("%d", res);
             for (int i = ; i <= n; ++i)
                 printf(" %d",  * (Max[] + Max[] - Min[] - Min[]));
             puts("");
         }
     }
     return ;
 }

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 = ;
         while (q--)
         {
             scanf("%d%d%d", &t, &l, &r);
             if (t == )
             {
                 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] = ;
                 if (fa.find(r) == fa.end()) fa[r] = r, Xor[r] = ;
                 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 = ;
                     puts("-1");
                     continue;
                 }
                 int fl = find(l), fr = find(r);
                 if (fl != fr)
                 {
                     last = ;
                     puts("-1");
                 }
                 else
                 {
                     last = Xor[l] ^ Xor[r];
                     printf("%d\n", last);
                 }
             }
         }
     }
     return ;
 }