Zoj 3201 Tree of Tree

树树

时间限制: 1秒      内存限制: 32768 KB

你给一个树的每个节点的权重,你需要找到这棵树的指定大小的最大子树。

树定义

树是其中不包含任何周期的连通图。

输入

有在输入多个测试用例。

每种情况下的第一行是两个整数N(1 <= N <= 100),K(1 <= K <= N),其中N是该树的节点的数量,K是子树的大小,其次通过与N的非负整数,其中第k个整数表示第k个节点的权重的行。接下来的N - 1行描述了树,每行有两个整数这意味着在这两个节点之间的边缘。以上所有的指标都是零基础,这是保证树的描述是正确的。

产量

一行与对于每种情况,这是最大的子树的总权重的单个整数。

样例输入

3 1

10 20 30

0 1

0 2

3 2

10 20 30

0 1

0 2

样例输出

30

40

树型DP+背包问题!

f[i][j]表示以i为根结点有j个结点子树的最大权值。

以下代码仅供参考!

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
#define MAX 105
vector<int> adj[MAX];
int f[MAX][MAX],tot[MAX],weight[MAX];
int ans,K;
int max(int a,int b)
{
	return a>b?a:b;
}
int DFS(int u,int father)
{
	tot[u]=1;
	int i,j,k,v;
	for(i=0;i<adj[u].size();i++)
	{
		v=adj[u][i];
		if(v==father)    // 如果又回到了父节点的情况
			continue;
		tot[u]+=DFS(v,u);
	}
	f[u][1]=weight[u];
	for(i=0;i<adj[u].size();i++)
	{
		v=adj[u][i];
		if(v==father)
			continue;
		for(j=tot[u];j>=1;j--)
		{
			for(k=0;k<j&&k<=tot[v];k++)
			{
				f[u][j]=max(f[u][j],f[u][j-k]+f[v][k]);
			}
		}
	}
	if(tot[u]>=K)
		ans=max(ans,f[u][K]);
	return tot[u];
}
int main()
{
	int N,i,u,v;
	while(~scanf("%d%d",&N,&K))
	{
		for(i=0;i<N;i++)
		{
			scanf("%d",&weight[i]);
			adj[i].clear();
		}
		for(i=1;i<N;i++)
		{
			scanf("%d%d",&u,&v);
			adj[u].push_back(v);
			adj[v].push_back(u);
		}
		memset(f,0,sizeof(f));
		ans=0;
		DFS(1,-1);
		printf("%d\n",ans);
	}
	return 0;
}

Zoj 3201 Tree of Tree,布布扣,bubuko.com

时间: 2025-01-02 05:15:03

Zoj 3201 Tree of Tree的相关文章

ZOJ 3201

Tree of Tree Time Limit: 1000MS   Memory Limit: 32768KB   64bit IO Format: %lld & %llu Description You're given a tree with weights of each node, you need to find the maximum subtree of specified size of this tree. Tree Definition A tree is a connect

[Leetcode][Tree][Binary Tree Postorder Traversal]

二叉树的后续遍历 1.递归版本 /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: void dfsPostorderTraversal(TreeNode *now, vec

LeetCode OJ - Symmetric Tree &amp;&amp; Same Tree

这两道题,大同小异. 我都是用BFS,在遍历的过程,判断结构是否相同/对称,值是否相同. 下面是AC代码: 1 /** 2 * Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center). 3 * @param root 4 * @return 5 */ 6 public boolean isSymmetricRecursively(TreeNode root){ 7

leetcode -day24 Maximum Depth of Binary Tree &amp; Binary Tree Zigzag Level Order Traversal

1.Maximum Depth of Binary Tree Given a binary tree, find its maximum depth. The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node. class Solution { public: int maxDepth(TreeNode *root) { inM

poj 2985 The k-th Largest Group 求第K大数 Treap, Binary Index Tree, Segment Tree

题目链接:点击打开链接 题意:有两种操作,合并集合,查询第K大集合的元素个数.(总操作次数为2*10^5) 解法: 1.Treap 2.树状数组 |-二分找第K大数 |-二进制思想,逼近第K大数 3.线段树 4.... Treap模板(静态数组) #include <math.h> #include <time.h> #include <stdio.h> #include <limits.h> #include <stdlib.h> const

[Leetcode][Tree][Binary Tree Preorder Traversal]

二叉树的前序遍历:root点先被访问,然后是left和right子节点.迭代的版本也相对好写. 1.递归版本:时间复杂度O(N),空间复杂度O(N) 1 /** 2 * Definition for binary tree 3 * struct TreeNode { 4 * int val; 5 * TreeNode *left; 6 * TreeNode *right; 7 * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 * }

LeetCode[Tree]: Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root). 这个简单的问题可以这样解决:利用LeetCode[Tree]: Binary Tree Level Order Traversal相同的方法得到自顶向下的层序遍历结果之后,将结果翻转即可.也可以插入的时候不从

[Leetcode][Tree][Binary Tree Inorder Traversal]

二叉树的中序遍历 1.递归版本 /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: void dfsInorderTraversal(TreeNode *root, vect

B-tree/B+tree/B*tree [转]

(原文出处:http://blog.csdn.net/hbhhww/article/details/8206846) B~树 1.前言: 动态查找树主要有:二叉查找树(Binary Search Tree),平衡二叉查找树(Balanced Binary Search Tree),红黑树 (Red-Black Tree ),B-tree/B+-tree/ B*-tree (B~Tree).前三者是典型的二叉查找树结构,其查找的时间复杂度O(log2N)与 树的深度相关,那么降低树的深度自然对查找