2020杭电多校第九场 A：Tree

Tree

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Problem Description

You are given a tree consisting of n vertices numbered 1 to n rooted at node 1. The parent of the i-th vertices is pi. You can move from a vertex to any of its children. What's more, you can add one directed edge between any two different vertices, and you can move through this edge too. You need to maximize the number of pairs (x,y) such that x can move to y through the edges after adding the edge. Note that x can also move to x.

 

 

Input

The first line contains one integer T (1≤T≤100000) — the number of test cases.

The first line of each test case contains only one integer n(1≤n≤5×105) — the number of vertices in the tree.

The second line of each test case contains n−1 integers p2,p3,…,pn(1≤pi<i) — the parent of each non-root node.

The sum of n over all test cases does not exceed 106.

 

 

Output

Print T integers — for each test case output the maximum number of pairs (x,y) that vertices x can move to y after adding one edge.

 

 

Sample Input

2

5

1 1 2 2

6

1 2 3 1 3

 

 

Sample Output

17

26

题解

　　从一个点出发可以到达他的所有子节点和他自己，添加一条边使得(x,y)（从x到y）最多，添加的这条边的终点最好的情况就是连一个子节点最多的点，也就是直接连到根节点1是最优的情况，一个点x向根节点连一条边，假设x有sx个子节点，从x可以新增n-sx个新的(x,y)对，假设从他的父亲作为起点新增边可以新增tmp个点对，则从x可以总共新增n-sx+tmp个点对。所以问题可以变为找出一个点使新增的点对最多。

#pragma GCC optimize(3,"Ofast","inline")
#include <map>
#include <set>
#include <time.h>
#include <stack>
#include <queue>
#include <cmath>
#include <vector>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define fi first
#define se second
#define IL inline
#define RG register
#define MP(a,b) make_pair(a,b)
#define PI acos(-1)
#define Mod 998244353
#define EPS 1e-5
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef double DB;
typedef pair<int, int> PR;
const int N = 500009;
const int M = 400009;
int gx[] = {0, 0, 1, -1};
int gy[] = {1, -1, 0, 0};
int n, m, k;
vector<int> g[N];
LL size[N], f[N], sum, ans;
class Init
{
    public:
        IL int mabs(int x)
        {
            return x < 0 ? -x : x;
        }
        IL LL gcd(LL a, LL b)
        {
            return b == 0 ? a : gcd(b, a%b);
        }
        IL LL lcm(int a, int b)
        {
            return a * b / gcd(a, b);
        }
        IL LL ksm(LL a, LL b)
        {
            LL tmp = a, sum = 1;
            while(b)
            {
                if(b & 1)
                    sum = (sum * tmp) % Mod;
                tmp = (tmp * tmp) % Mod;
                b >>= 1;
            }
            return sum % Mod;
        }
        IL LL read()
        {
            LL num = 0; bool flag = 0; char c;
            while((c=getchar())==' ' || c=='\n' || c=='\r');
            if(c == '-') flag = 1; else num = c - '0';
            while(isdigit(c=getchar()))
                num = num * 10LL + c - '0';
            return flag ? -num : num;
        }
        IL void print(LL x)
        {
            if(x < 0) putchar('-'), x = -x;
            if(x > 9) print(x/10);
            putchar(x%10+'0');
        }
    private:

}Init;
void dfs(int x)
{
    size[x] = 1;
    for(int i = 0; i < g[x].size(); i++)
    {
        dfs(g[x][i]);
        size[x] += size[g[x][i]];
    }
}
void geta(int x, int fa)
{
    sum += size[x];
    f[x] = 1LL * n - size[x] + f[fa];
    ans = max(ans, f[x]);
    for(int i = 0; i < g[x].size(); i++)
        geta(g[x][i], x);
}
int main(void)
{
    int T = Init.read();
    while(T--)
    {
        n = Init.read();
        for(int i = 1; i <= n; i++)
            g[i].clear(), f[i] = 0;
        for(int i = 2; i <= n; i++)
        {
            int p = Init.read();
            g[p].push_back(i);
        }
        dfs(1);
        ans = 0; sum = 0;
        geta(1, 0);
        printf("%lld\n", ans+sum);
    }
    return 0;
}