Codeforces 980E The Number Games - 贪心 - 树状数组

题目传送门

　　传送点I

　　传送点II

　　传送点III

题目大意

　　给定一颗有$n$个点的树，$i$号点的权值是$2^{i}$要求删去$k$个点，使得剩下的点仍然连通，并且总权值和最大，问删去的所有点的编号。

　　其实这道题和虚树没有太大的关系，我只是提一下而已。

　　因为点的权值很特殊，所以相当于要求剩下序列（从大到小）的字典序最大。

　　然后过程就比较显然了。从大到小枚举点，判断能否保留它（计算加入它后，新的树的点数有没有超过限制）。保留它是指和已经被保留的点连通。

　　这个相当于使得一些关键点连通，然后求出总点数。显然它可以用虚树来做。所以考虑虚树的构造算法，于是我们成功得到了一个时间复杂度为一个天文数字的算法。

　　将一个关键点添加进已有的树（暂时把保留的点形成的树这么称呼吧）中，无非情况有两种：

• 从这个关键点往上跳，直到跳到某个在已有的树中的点，经过点均被加入已有的树中。这种情况出现当且仅当关键点存在于已有的树的根（离原树钦定的根最近的一个点）在原树的子树中。
• 这个关键点到已有的树的根的路径上所有点被加入已有的树。（其他情况）

　　显然，这个过程不能纯暴力做。首先需要计算新添加的点的个数，如果能够保留它，那么暴力修改（因为修改的节点数等于$(n - k)$）。

　　对于情况一，可以通过记录深度数组和倍增数组解决。

　　对于情况二，求完LCA用树上距离公式。

　　总时间复杂度$O(n\log n)$

Code

 /**
  * Codeforces
  * Problem#980E
  * Accepted
  * Time: 1918ms
  * Memory: 172700k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 const int N = 1e6 + , bzmax = ;

 int n, m;
 int cnt;
 vector<int> *g;
 int *in, *out;
 int *dep;
 boolean *vis;
 int bz[N][bzmax];

 inline void init() {
     scanf("%d%d", &n, &m);
     m = n - m;
     g = new vector<int>[(n + )];
     in = new int[(n + )];
     out = new int[(n + )];
     dep = new int[(n + )];
     vis = new boolean[(n + )];
     memset(vis, false, sizeof(boolean) * (n + ));
     for (int i = , u, v; i < n; i++) {
         scanf("%d%d", &u, &v);
         g[u].push_back(v);
         g[v].push_back(u);
     }
 }

 void dfs(int p, int fa) {
     in[p] = ++cnt, dep[p] = dep[fa] + ;
     bz[p][] = fa;
     for (int i = ; i < bzmax; i++)
         bz[p][i] = bz[bz[p][i - ]][i - ];
     for (int i = ; i < (signed)g[p].size(); i++) {
         int e = g[p][i];
         if (e == fa)    continue;
         dfs(e, p);
     }
     out[p] = cnt;
 }

 int lca(int u, int v) {
     if (dep[u] < dep[v])    swap(u, v);
     if (in[u] <= in[v] && out[u] >= out[v])
         return u;
     for (int i = bzmax - , a; ~i; i--) {
         a = bz[u][i];
         if (!(in[a] <= in[v] && out[a] >= out[v]))
             u = a;
     }
     return bz[u][];
 }

 inline void solve() {
     dep[] = , vis[n] = true, m -= , in[] = , out[] = ;
     dfs(, );
     int vr = n;
     for (int i = n - ; i; i--)    {
         if (vis[i])    continue;
         if (in[vr] <= in[i] && out[vr] >= out[i]) {
             int u = i, v;
             for (int j = bzmax - ; ~j; j--) {
                 v = bz[u][j];
                 if (dep[v] >= dep[vr] && !vis[v])
                     u = v;
             }
             if (dep[i] - dep[u] +  > m)    continue;
             for (int j = i; j && !vis[j]; j = bz[j][])
                 vis[j] = true, m--;
         } else {
             int g = lca(vr, i);
 //            cerr << dep[i] + dep[vr] - (dep[g] << 1) << endl;
             if (dep[i] + dep[vr] - (dep[g] << ) > m)    continue;
             for (int j = i; j != bz[g][] && !vis[j]; j = bz[j][])
                 vis[j] = true, m--;
             for (int j = bz[vr][]; !vis[j]; j = bz[j][])
                 vis[j] = true, m--;
             vr = g;
         }
     }
     for (int i = ; i <= n; i++)
         if (!vis[i])
             printf("%d ", i);
 }

 int main() {
     init();
     solve();
     return ;
 }

Multiplication algorithm

　　我们完美解决了这个问题？不。做人要有追求，1.9s真不爽。

　　注意到$n$号点必定存在于已有的树中。那么直接钦定$n$号点作为原树的根。

　　这样直接消灭掉了情况二。对于情况一，也可以稍微改一改。因为原树的根与已有的树的根重合，可以直接树差分加上树状数组计算出距离。

Code

 /**
  * Codeforces
  * Problem#980E
  * Accepted
  * Time: 888ms
  * Memory: 98300k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 typedef class IndexedTree {
     public:
         int *ar;
         int s;

         IndexedTree():ar(NULL) {    }
         IndexedTree(int s):s(s) {
             ar = new int[(s + )];
             memset(ar, , sizeof(int) * (s + ));
         }

         void add(int idx, int val) {
             for ( ; idx <= s; idx += (idx & (-idx)))
                 ar[idx] += val;
         }

         int getSum(int idx) {
             int rt = ;
             for ( ; idx; idx -= (idx & (-idx)))
                 rt += ar[idx];
             return rt;
         }

         void add(int l, int r, int val) {
             add(l, val), add(r + , -val);
         }
 }IndexedTree;

 int n, m;
 int cnt;
 vector<int> *g;
 int *in, *out;
 int *dep, *fas;
 boolean *vis;
 IndexedTree it;

 inline void init() {
     scanf("%d%d", &n, &m);
     m = n - m;
     g = new vector<int>[(n + )];
     in = new int[(n + )];
     out = new int[(n + )];
     dep = new int[(n + )];
     fas = new int[(n + )];
     vis = new boolean[(n + )];
     it = IndexedTree(n);
     memset(vis, false, sizeof(boolean) * (n + ));
     for (int i = , u, v; i < n; i++) {
         scanf("%d%d", &u, &v);
         g[u].push_back(v);
         g[v].push_back(u);
     }
 }

 void dfs(int p, int fa) {
     in[p] = ++cnt, dep[p] = dep[fa] + , fas[p] = fa;
     for (int i = ; i < (signed)g[p].size(); i++) {
         int e = g[p][i];
         if (e == fa)    continue;
         dfs(e, p);
     }
     out[p] = cnt;
 }

 inline void solve() {
     dep[] = ;
     dfs(n, );
     vis[n] = true, it.add(in[n], out[n], ), m--;
     for (int i = n - ; i; i--) {
         if (vis[i])    continue;
         int added = dep[i] - it.getSum(in[i]);
         if (added > m)    continue;
         for (int j = i; !vis[j]; j = fas[j])
             it.add(in[j], out[j], ), vis[j] = true, m--;
     }
     for (int i = ; i <= n; i++)
         if (!vis[i])
             printf("%d ", i);
 }

 int main() {
     init();
     solve();
     return ;
 }