HDU_5534_Partial Tree

Partial Tree

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 1659    Accepted Submission(s): 818

Problem Description

In mathematics, and more specifically in graph theory, a tree is an undirected graph in which any two nodes are connected by exactly one path. In other words, any connected graph without simple cycles is a tree.

You find a partial tree on the way home. This tree has n nodes but lacks of n−1 edges. You want to complete this tree by adding n−1 edges. There must be exactly one path between any two nodes after adding. As you know, there are nn−2 ways to complete this tree, and you want to make the completed tree as cool as possible. The coolness of a tree is the sum of coolness of its nodes. The coolness of a node is f(d), where f is a predefined function and d is the degree of this node. What's the maximum coolness of the completed tree?

 

Input

The first line contains an integer T indicating the total number of test cases.
Each test case starts with an integer n in one line,
then one line with n−1 integers f(1),f(2),…,f(n−1).

1≤T≤2015
2≤n≤2015
0≤f(i)≤10000
There are at most 10 test cases with n>100.

 

Output

For each test case, please output the maximum coolness of the completed tree in one line.

 

Sample Input

2
3
2 1
4
5 1 4

 

Sample Output

5
19

 

Source

2015ACM/ICPC亚洲区长春站-重现赛（感谢东北师大）

 

• 给出n个点让建树
• 对于一个度为d的点有函数f(d)的对应数值，使得将所有节点度数对应函数数值加和最大
• 显然不可能一个一个地建树
• 对于二叉树来说对于节点数n，所有可建树的种类与卡特兰数有关，何况这题不限于二叉树
• 测试n在比较小的时候几个例子，不难看出每次随着点数的扩增，都是从(n-1)的每种度数序列中将一个点度数增1，度数为1的点增1
• 那么这里会引发出两种思路，一种是贪心，一种是递推，或者说是dp
• 先说贪心的想法：
• 每次节点数量增1的过程中，贪心地看当前度数序列中哪一个度数增1后节点度数对应函数值增量最大，然后总是挑增量最大的点来增加度数
• 看似很有道理，但是有一个明显的反例，就是说f(n-1)数值远远超过其他数值，贪心的思路不能保证最后可以推到一个点有n-1个度的情况，因为每次贪的是当前的最大增量，在增加点的过程中很有可能对于函数f(d)会有卡在某一度数的情况，例如：a<b<c, f(a)<f(b), f(b)>f(c)。在这种情况下贪心策略可能会让尽可能多的点集中到度数b而计算不到度数在c以后的情况
• 递推想法一：
• 根据节点数递推，用dp[n]推出dp[n+1]
• 看似正确，但是其思路其实和贪心策略一致
• 但是更深层次的考虑的话会发现dp[n]和dp[n+1]没有一致的结构保障，意思是节点数n的结果和节点数n+1的建树结果不能保证除1点外完全相同
• 而如果考虑用dp[1--n]推dp[n+1]也是一样，没有结构一致的保证，也没有保证第n+1棵数是由之前多少棵数组合而成，都是不确定的，没有保障的
• 递推想法二：
• 之前的两种思路都是在点的基础上引发的，我们现在考虑这个题中的重要变量，就是节点的度
• 对于n和节点的树，有n-1个边，2n-2个度，每个节点至少1个度，一条边包含两边节点的2个度
• 我们不妨把度看做半个边，两个度为1条边，对于度做dp
• 这样做的好处在于同一度数序列对应不止一个树的结构，可以进行扩展
• 初始化每个节点1个度，扩展次数为n-2次
• 每次从之前的情况递推，max更新dp[n+1]即可
• dp[i]=max(dp[i],dp[j]+f[i-j+1]-f[1]);(j<i)
• 其中减去的f[1]对应初始赋给每一个点的值，这里的意义在于对于前一种情况j，条一个度数为1的点进行扩展，将(i-j+1)个点组合在一起，形成一个菊花状（好吧，多校的题解里有类似的题，然后就用菊花来形容了），而且可以保证和原始树相连，就达成了扩展的操作

 #include <iostream>
 #include <string>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <climits>
 #include <cmath>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <set>
 #include <map>
 using namespace std;
 typedef long long           LL ;
 typedef unsigned long long ULL ;
 const int    maxn = 1e5 +    ;
 const int    inf  = 0x3f3f3f3f ;
 const int    npos = -         ;
 const int    mod  = 1e9 +     ;
 const int    mxx  =  +     ;
 const double eps  = 1e-       ;
 const double PI   = acos(-1.0) ;

 int T, n;
 LL f[maxn], c[maxn];
 int main(){
     // freopen("in.txt","r",stdin);
     // freopen("out.txt","w",stdout);
     while(~scanf("%d",&T)){
         while(T--){
             scanf("%d",&n);
             for(int i=;i<n;i++)
                 scanf("%lld",&f[i]);
             c[]=n*f[];
             for(int i=;i<=n-;i++){
                 c[i]=0LL;
                 for(int j=;j<i;j++){
                     c[i]=max(c[i],c[j]+f[i-j+]-f[]);
                 }
             }
             printf("%lld\n",c[n-]);
         }
     }
     return ;
 }