【树形DP】【P1351】【NOIP2014D1T2】联合权值

Description

无向连通图 $G$ 有 $n$ 个点， $n-1$ 条边。点从 $1$ 到 $n$ 依次编号,编号为 $i$ 的点的权值为 $W_i$ ，每条边的长度均为 $1$ 。图上两点 $(u, v)$ 的距离定义为 $u$ 点到 $v$ 点的最短距离。对于图 $G$ 上的点对 $(u, v)$ ，若它们的距离为 $2$ ，则它们之间会产生 $W_v \times W_u$ 的联合权值。

Input

第一行包含 $1$ 个整数 $n$ 。

接下来 $n-1$ 行,每行包含 $2$ 个用空格隔开的正整数 $u,v$ ，表示编号为 $u$ 和编号为 $v$ 的点之间有边相连。

最后 $1$ 行,包含 $n$ 个正整数，每两个正整数之间用一个空格隔开，其中第 $i$ 个整数表示图 $G$ 上编号为 $i$ 的点的权值为 $W_i$ 。

Output

输出共 $1$ 行,包含 $2$ 个整数，之间用一个空格隔开,依次为图 $G$ 上联合权值的最大值和所有联合权值之和。由于所有联合权值之和可能很大，输出它时要对 $10007$ 取余。

Sample Input

Sample Output

20 74

Hint

对于100%的数据， $1 \leq n \leq 200000, 0 \leq W_i \leq 10000$ 。

Solution

比较显然的树形递推。

我们考虑对于一棵树，如果能知道根节点的所有以他的儿子为根的子树的答案，可以非常方便的得到以根节点为根的树的答案。这样状态就得以确定了。我们使用$f(i)$来代表以i为根的子树的答案。

对于转移，我们考虑根节点的答案首先是儿子的累加和，其次，根节点对孙子能够构成联合权值，这些都可以在枚举儿子的时候方便的计算出来。最后考虑任意儿子之间会产生联合权值。朴素做法当然是把儿子都存下来然后互相乘起来，这样的复杂度是$O(n^2)$，会被菊花图卡吐血。

因为前面的儿子$\times$后面的儿子显然等于反过来乘，所以我们只需要前面的儿子$\times$后面的，最后把答案乘二即可。考虑对于根节点的第$i$个儿子，它对答案的贡献是【它的权值乘上它前面$i-1$儿子的权值的积】的和，根据乘法结合律，提取该节点的权值，它对答案的贡献就是它的权值乘上【前面儿子的的权值的和】的积这样我们可以直接维护他前面所有儿子的和，然后乘上该节点的权值，加入答案即可。

Code

#include<ctime>

#include<cstdio>

#include<cstdlib>

#define rg register

#define ci const int

#define cl const long long int

typedef long long int ll;

namespace IO {

	char buf[50];

}

template<typename T>

inline void qr(T &x) {

	char ch=getchar(),lst=' ';

	while(ch>'9'||ch<'0') lst=ch,ch=getchar();

	while(ch>='0'&&ch<='9') x=(x<<1)+(x<<3)+(ch^48),ch=getchar();

	if (lst=='-') x=-x;

}

template<typename T>

inline void write(T x,const char aft,const bool pt) {

	if(x<0) {putchar('-');x=-x;}

	int top=0;

	do {

		IO::buf[++top]=x%10+'0';

		x/=10;

	} while(x);

	while(top) putchar(IO::buf[top--]);

	if(pt) putchar(aft);

}

template <typename T>

inline T mmax(const T &a,const T &b) {if(a>b) return a;return b;}

template <typename T>

inline T mmin(const T &a,const T &b) {if(a<b) return a;return b;}

template <typename T>

inline T mabs(const T &a) {if(a<0) return -a;return a;}

template <typename T>

inline void mswap(T &a,T &b) {T temp=a;a=b;b=temp;}

const int maxn = 200010;

const int maxm = 400010;

const int MOD = 10007;

struct Edge {

	int to,nxt;

};

Edge edge[maxm];int hd[maxn],ecnt;

inline void cont(ci from,ci to) {

	Edge &e=edge[++ecnt];

	e.to=to;e.nxt=hd[from];hd[from]=ecnt;

}

int a,b;

int n,ans;

int MU[maxn];

int frog[maxn];

void dfs(ci,ci);

int main() {

	srand(time(NULL));

	qr(n);

	for(rg int i=1;i<n;++i) {

		a=b=0;qr(a);qr(b);

		cont(a,b);cont(b,a);

	}

	for(rg int i=1;i<=n;++i) qr(MU[i]);

	int rt=rand()%n+1;

	dfs(rt,0);

	write(ans,' ',true);

	write((frog[rt]<<1)%MOD,'\n',true);

}

void dfs(ci k,ci fa) {

	int _temp=0,_ans1=0,_ans2=0;

	for(rg int i=hd[k];i;i=edge[i].nxt) {

		int to=edge[i].to;

		if(to==fa) continue;

		frog[k]=(frog[k]+_temp*MU[to])%MOD;

		_temp=(MU[to]+_temp)%MOD;

		if(MU[to]>=_ans1) _ans2=_ans1,_ans1=MU[to];else if(MU[to]>_ans2) _ans2=MU[to];

		ans=mmax(ans,_ans1*_ans2);

		dfs(to,k);

		frog[k]=(frog[k]+frog[to])%MOD;

		for(rg int j=hd[to];j;j=edge[j].nxt) {

			int &tt=edge[j].to;

			if(tt==k) continue;

			int _a=MU[tt]*MU[k];

			frog[k]=(frog[k]+_a)%MOD;

			ans=mmax(ans,_a);

		}

	}

}

Summary

当发现一个小部分因为复杂度超标而不可做的时候，不妨通过一些数学分析将复杂度降低从而获得正确的复杂度