字节跳动冬令营网络赛 Solution

A：Aloha

Unsolved.

B：Origami

Unsolved.

题意：

初始的时候有一张纸，可以从左边往右边折叠，或者从右边往左边折叠

每次折叠的长度不能超过现有宽度，最后折叠到长度为1

从上往下看会有一个$1-n的排列$，现在给出这个排列

问这个排列是否是合法折叠出来的

C：Continued Story

Unsolved.

题意：

有一个有根树，根为1，两个人轮流操作，每一次操作时选择一条边将其边权减一

如果某一次操作后对应的边的边权变为0，那么这条边会被移除

此时树会被分成两块，没有根的那块会被移除（根为1）

D：The Easiest One

Unsolved.

题意：

定义两种操作：

$x = x - 1$

$x = x - 2^i (当x AND 2^i != 0 时可以用)$

定义$f(x, y) 为 x 变成y 所需的最少操作数 此处(y <= x)$

求$\sum_{0 <= y <= x <= n} f(x, y)$

E：Set

Unsolved.

题意：

有n个集合，每个集合的大小都为m， 并且要满足$|S_i - S_{(i - 1 + n) mod n} | >= l_i$

现在要使得所有集合的并的元素个数最小，求最小的数量

F：Old Problem

Unsolved.

在$n x m 的矩形里 有 (n - 1) (m - 1) 个点，有有多少个三点能够组成直角三角形$

G：Periodic Palindrome

Unsolved.

H：Accel World

Unsolved.

I：Hello, Hello and Hello

Unsolved.

题意：

有一个字符串，当开始是 $000....111...222 这样的$

每一次可以选择其中一个子串把它放到后面，求最小的操作次数使得任意相邻的字符都不相同

无法做到输出-1

J：Sortable Path on Tree

Upsolved.

题意：

有一棵树，求存在多少个$pair(u, v) 使得u ->v 的简单路径上所有点按顺序组成的点权序列$

使得存在一个起点，使得从这个起点开始往后是一个非递减序列，（可以看作一个环此时）

思路：

点分治

我们将一个序列用大于号和小于号串起来

$这样对于某种符号数>=2的，直接视为2$

$那么只有9种状态来表示一个点$

$在对每棵子树分治的时候我们只需要考虑如何拼接形态即可$

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

 #define ll long long
 #define N 100010
 int t, n;
 int w[N];
 vector <int> G[N];
 ll res;

 struct BIT
 {
     int a[N];
     void init() { memset(a, , sizeof a); }
     void update(int x, int val)
     {
         for (; x <= ; x += x & -x)
             a[x] += val;
     }
     int query(int x)
     {
         int res = ;
         for (; x > ; x -= x & -x)
             res += a[x];
         return res;
     }
     int query(int l, int r) { if (r < l) return ; return query(r) - query(l - ); }
 }bit[][]; 

 int vis[N];
 int root, sum, sze[N], f[N];
 void getroot(int u, int fa)
 {
     sze[u] = , f[u] = ;
     for (auto v : G[u]) if (v != fa && !vis[v])
     {
         getroot(v, u);
         sze[u] += sze[v];
         f[u] = max(f[u], sze[v]);
     }
     f[u] = max(f[u], sum - sze[u]);
     if (f[u] < f[root]) root = u;
 }

 int big[N], small[N];
 void getdeep(int u, int fa)
 {
     if (big[u] > ) big[u] = ;
     if (small[u] > ) small[u] = ;
     int x = big[u], y = small[u];
     for (int i = ; i <= ; ++i)
         for (int j = ; j <= ; ++j)
         {
             int nx = x + i;
             int ny = y + j;
             if (nx >=  && ny >= ) continue;
             if (!nx || !ny || (nx ==  && ny == )) res += bit[i][j].query();
             else if (nx == ) res += bit[i][j].query(, w[u]);
             else if (ny == ) res += bit[i][j].query(w[u], );
         }
     for (auto v : G[u]) if (v != fa && !vis[v])
     {
         big[v] = big[u] + (w[v] > w[u]);
         small[v] = small[u] + (w[v] < w[u]);
         getdeep(v, u);
     }
 }

 void add(int u, int fa, int flag)
 {
     bit[small[u]][big[u]].update(w[u], flag);
     for (auto v : G[u]) if (v != fa && !vis[v])
         add(v, u, flag);
 }

 void solve(int u)
 {
     vis[u] = ;
     bit[][].update(w[u], );
     for (auto v : G[u]) if (!vis[v])
     {
         big[v] = (w[v] > w[u]);
         small[v] = (w[v] < w[u]);
         getdeep(v, u);
         add(v, u, );
     }
     for (auto v : G[u]) if (!vis[v]) add(v, u, -);
     bit[][].update(w[u], -);
     for (auto v : G[u]) if (!vis[v])
     {
         sum = f[] = sze[v]; root = ;
         getroot(v, );
         solve(root);
     }
 }

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         for (int i = ; i <= n; ++i) G[i].clear(), vis[i] = ;
         for (int i = ; i <= n; ++i) scanf("%d", w + i);
         for (int i = , u, v; i < n; ++i)
         {
             scanf("%d%d", &u, &v);
             G[u].push_back(v);
             G[v].push_back(u);
         }
         res = ;
         sum = f[] = n; root = ;
         getroot(, );
         solve(root);
         printf("%lld\n", res + n);
     }
     return ;
 }