虽然这只是个暴力,正解并不会写。。。但是这个暴力也让我长见识了。。。
题目大意:
给定一棵树,每个节点有一个权值,求所有的联通块中权值为第k大的权值和。
思路:
遇到不会做的题目一定要有梦想!!!说不定暴力就A了呢??我们对于每一个点单独来考虑对答案的贡献,即统计包含这个点的联通块且这个点为联通块中权值第k大的个数。那么就可以把每个点作为根来考虑一次,大于根节点的权值设为1,其他的全部都是0,现在我们要求的就是一个树形依赖背包容积为k-1的方案数。之前打树形背包都是打的
nk2
n
k
2
,发现现在要统计n遍,那不是炸成
n2k2
n
2
k
2
了。于是找了好久,找到了一个优化树形背包成
O(nk)
O
(
n
k
)
的方法,即换一种DP方式。
对于每一个点,我们强制选择从根到它的路径上的所有节点,
dp[u][j]
d
p
[
u
]
[
j
]
即表示从根选到u以及这条路径的左边和他子树的dp值,每一个点首先要强制从父亲转移过来,对于每一个父亲,可以从它的儿子转移过来,即它的每一个儿子有选和不选两种方案,而这里只要加上DP数组就可了(具体的看下面的代码一定会更好理解)。
但是仅仅是这样还是不够的,时间复杂度达到了
O(n2k)
O
(
n
2
k
)
,发现一个优化,即我们只对从小到大排序后排名<=k的数进行DP,最后因为数据太水的缘故,
O((n−k)∗nk)
O
(
(
n
−
k
)
∗
n
k
)
的算法轻松跑过。
/*=====================
* Author : Ylsoi
* Problem : coat
* Algorithm : DP
* Time : 2018.4.13
* ==================*/
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
void File(){
freopen("coat.in","r",stdin);
freopen("coat.out","w",stdout);
}
#define REP(i,a,b) for(register int i=a;i<=b;++i)
#define DREP(i,a,b) for(register int i=a;i>=b;--i)
#define MREP(i,x) for(register int i=beg[x];i;i=E[i].last)
#define ll long long
#define inf (0x3f3f3f3f)
#define mod (64123)
const int maxn=1666+10;
int n,k,w,d[maxn],beg[maxn],cnt,ans;
int dp[maxn][maxn],a[maxn];
struct edge{
int to;
int last;
}E[maxn*2];
void add(int u,int v){
++cnt;
E[cnt].to=v;
E[cnt].last=beg[u];
beg[u]=cnt;
}
bool judge(int x,int y){return d[x]!=d[y] ? d[x]>d[y] : x<y;}
void dfs(int rt,int u,int f){
if(f){//首先强制选择这个点并从父亲转移过来
if(judge(u,rt))REP(i,1,k-1)dp[u][i]=dp[f][i-1];
else REP(i,0,k-1)dp[u][i]=dp[f][i];
}
MREP(i,u){
int v=E[i].to;
if(v==f)continue;
dfs(rt,v,u);
}//从子树的状态转移到父亲
REP(i,0,k-1)dp[f][i]=(dp[f][i]+dp[u][i])%mod;
}
void work(){
REP(i,k,n){
memset(dp,0,sizeof(dp));
dp[a[i]][0]=1;
dfs(a[i],a[i],0);
ans=(ans+d[a[i]]*dp[a[i]][k-1])%mod;
}
}
int main(){
//File();
scanf("%d%d%d",&n,&k,&w);
REP(i,1,n)scanf("%d",&d[i]);
REP(i,1,n-1){
int u,v;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
REP(i,1,n)a[i]=i;
sort(a+1,a+n+1,judge);
work();
printf("%d\n",ans);
return 0;
}