[BZOJ 3829][POI2014] FarmCraft

先贴一波题面...

3829: [Poi2014]FarmCraft

Time Limit: 20 Sec  Memory Limit: 128 MB
Submit: 421  Solved: 197
[Submit][Status][Discuss]

Description

In a village called Byteville, there are   houses connected with N-1 roads. For each pair of houses, there is a unique way to get from one to another. The houses are numbered from 1 to  . The house no. 1 belongs to the village administrator Byteasar. As part of enabling modern technologies for rural areas framework,   computers have been delivered to Byteasar's house. Every house is to be supplied with a computer, and it is Byteasar's task to distribute them. The citizens of Byteville have already agreed to play the most recent version of FarmCraft (the game) as soon as they have their computers.

Byteasar has loaded all the computers on his pickup truck and is about to set out to deliver the goods. He has just the right amount of gasoline to drive each road twice. In each house, Byteasar leaves one computer, and immediately continues on his route. In each house, as soon as house dwellers get their computer, they turn it on and install FarmCraft. The time it takes to install and set up the game very much depends on one's tech savviness, which is fortunately known for each household. After he delivers all the computers, Byteasar will come back to his house and install the game on his computer. The travel time along each road linking two houses is exactly 1 minute, and (due to citizens' eagerness to play) the time to unload a computer is negligible.

Help Byteasar in determining a delivery order that allows all Byteville's citizens (including Byteasar) to start playing together as soon as possible. In other words, find an order that minimizes the time when everyone has FarmCraft installed.

mhy住在一棵有n个点的树的1号结点上，每个结点上都有一个妹子。

mhy从自己家出发，去给每一个妹子都送一台电脑，每个妹子拿到电脑后就会开始安装zhx牌杀毒软件，第i个妹子安装时间为Ci。

树上的每条边mhy能且仅能走两次，每次耗费1单位时间。mhy送完所有电脑后会回自己家里然后开始装zhx牌杀毒软件。

卸货和装电脑是不需要时间的。

求所有妹子和mhy都装好zhx牌杀毒软件的最短时间。

Input

The first line of the standard input contains a single integer N(2<=N<=5 00 000)  that gives the number of houses in Byteville. The second line contains N integers C1,C2…Cn(1<=Ci<=10^9), separated by single spaces; Ci is the installation time (in minutes) for the dwellers of house no. i.

The next N-1  lines specify the roads linking the houses. Each such line contains two positive integers a and b(1<=a<b<=N) , separated by a single space. These indicate that there is a direct road between the houses no. a and b.

Output

The first and only line of the standard output should contain a single integer: the (minimum) number of minutes after which all citizens will be able to play FarmCraft together.

Sample Input

6
1 8 9 6 3 2
1 3
2 3
3 4
4 5
4 6

Sample Output

11

HINT

Explanation: Byteasar should deliver the computers to the houses in the following order: 3, 2, 4, 5, 6, and 1. The game will be installed after 11, 10, 10, 10, 8, and 9 minutes respectively, in the house number order. Thus everyone can play after 11 minutes.

If Byteasar delivered the game in the following order: 3, 4, 5, 6, 2, and 1, then the game would be installed after: 11, 16, 10, 8, 6, and 7 minutes respectively. Hence, everyone could play only after 16 minutes,

手动忽略奇葩翻译

首先从数据范围看这肯定是一道\(O(n)\)左右复杂度可以解决的好题qwq这时可以选择考虑贪心策略. 对于贪心我们可以设置一个权重$k_i$, 代表遍历一遍以结点 \(i\) 为根的子树以后所有子节点完成软件安装还所需的额外时间. 不难发现我们先遍历需要额外时间最多的子树就可以获得最优解. 因为先开始遍历之后安装所需的额外时间可以在遍历其他子树时抵消一部分, 而遍历整个树所需的时间是一定的, 这样的策略可以尽可能多地在固定需要花费的时间里同时消耗这部分额外时间.

然后我们注意到其实根节点的 $k_1$ 与 $c_1$ 二者的较大值加上欧拉遍历用时就是答案. 所以我们考虑如何计算 $k_i$ .

首先我们要 $DFS$ 一遍求对以 \(i\) 为根的欧拉遍历所需时间 \(t_i\) , (其实等价于子树大小的二倍2333) 然后再 $DFS$ 一遍并在回溯过程中计算贪心顺序与 $k_i$ . 由于我们递归处理并且是在回溯过程中计算, 所以在开始计算 $k_i$ 时 $i$ 结点的子树的 $k$ 值一定都已经求出. 然后根据 $k$ 值降序排序 $i$ 的子节点. 然后建立一个临时变量 $tmp$ 储存后续遍历该节点其他子树所需要的时间, 因为后续遍历的过程中所消耗的时间可以抵消一部分前面遍历的子树的 $k$ 值对答案的贡献. 初始化临时变量为 $i$ 的欧拉遍历耗时, 每次遍历到一个子树后将临时变量减去这个子树的欧拉遍历耗时. 然后最终的公式如下:

\[k_i=max\{k_j - tmp-1 , (i,j) \in E\}\]

$tmp$ 和 $k$ 的意义如上文所述.

最后还需要注意的一点是 $k_i$ 可能在后续计算答案抵消的时候会变成负数, 而它对的贡献不可能是负的, 所以最后要判断一下, 如果 $k_i$ 为负则修改为0.

参考代码如下:

GitHub

 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>

 const int MAXV=;

 std::vector<int> E[MAXV];

 int v;
 int c[MAXV];
 int t[MAXV];
 int k[MAXV];

 void Initialize();
 void DFS(int,int);
 void Insert(int,int);
 bool cmp(const int&,const int&);

 int main(){
     Initialize();
     DFS(,);
     printf("%d\n",std::max(k[],c[])+*v-);
     return ;
 }

 void DFS(int root,int prt){
     for(std::vector<int>::iterator i=E[root].begin();i!=E[root].end();i++){
         if(*i==prt)
             continue;
         t[root]++;
         DFS(*i,root);
         t[root]++;
         t[root]+=t[*i];
     }
     if(root!=)
         k[root]=c[root]-t[root];
     std::sort(E[root].begin(),E[root].end(),cmp);
     int tmp=t[root];
     for(std::vector<int>::iterator i=E[root].begin();i!=E[root].end();i++){
         if(*i==prt)
             continue;
         tmp-=+t[*i];
         k[root]=std::max(k[root],k[*i]-tmp-);
     }
     k[root]=std::max(k[root],);
 }

 void Initialize(){
     int a,b;
     scanf("%d",&v);
     for(int i=;i<=v;i++){
         scanf("%d",c+i);
     }
     for(int i=;i<v;i++){
         scanf("%d%d",&a,&b);
         Insert(a,b);
         Insert(b,a);
     }
 }

 inline bool cmp(const int& a,const int& b){
     return k[a]>k[b];
 }

 void Insert(int from,int to){
     E[from].push_back(to);
 }

Backup

补图qwq