HDU 6060 RXD and dividing【斯坦纳树】

最新推荐文章于 2019-11-02 19:30:54 发布

moonlighttlj

最新推荐文章于 2019-11-02 19:30:54 发布

阅读量228

点赞数

分类专栏：【dfs&&bfs】【HDU】文章标签：最小斯坦纳树 dfs

【HDU】同时被 2 个专栏收录

25 篇文章

订阅专栏

【dfs&&bfs】

13 篇文章

订阅专栏

本文探讨了最小斯坦纳树问题的一个具体实例，通过详细解释题目背景和算法实现过程，帮助读者理解如何解决该问题。文章包括问题描述、输入输出样例及官方题解思路。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6060

RXD and dividing

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 524288/524288 K (Java/Others)
Total Submission(s): 1801 Accepted Submission(s): 773

Problem Description
RXD has a tree T, with the size of n. Each edge has a cost.
Define f(S) as the the cost of the minimal Steiner Tree of the set S on tree T.
he wants to divide 2,3,4,5,6,…n into k parts S1,S2,S3,…Sk,
where ⋃Si={2,3,…,n} and for all different i,j , we can conclude that Si⋂Sj=∅.
Then he calulates res=∑ki=1f({1}⋃Si).
He wants to maximize the res.
1≤k≤n≤106
the cost of each edge∈[1,105]
Si might be empty.
f(S) means that you need to choose a couple of edges on the tree to make all the points in S connected, and you need to minimize the sum of the cost of these edges. f(S) is equal to the minimal cost

Input
There are several test cases, please keep reading until EOF.
For each test case, the first line consists of 2 integer n,k, which means the number of the tree nodes , and k means the number of parts.
The next n−1 lines consists of 2 integers, a,b,c, means a tree edge (a,b) with cost c.
It is guaranteed that the edges would form a tree.
There are 4 big test cases and 50 small test cases.
small test case means n≤100.

Output
For each test case, output an integer, which means the answer.

Sample Input
5 4
1 2 3
2 3 4
2 4 5
2 5 6

Sample Output
27

Source
2017 Multi-University Training Contest - Team 3

//题意：
//对于一个节点数为n,每条边都有一个花费值的树
//定义f(S)是这棵树上集合S最小斯坦纳树的花费
//RXD想把编号从2—n的节点划分成k部分，这k部分的并集为⋃Si={2,3,…,n}
//不同的集合交集为空，他想要计算 res=∑ki=1f({1}⋃Si).并使res的值最大
//集合可能为空

官方题解：
这里写图片描述
这段话思考了一下午，对于min(szx,k)还是有点似懂非懂，有必要再看一下最小斯坦纳树。
戳一下了解更多
 斯坦纳树
代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=1000005;
int size[maxn];//存放每个节点的子节点的数目
int w[maxn];//存放权重
struct Edge
{
    int v;//存放编号
    int w;//存放权重
};
Edge temp;
vector<Edge>vec[maxn];//动态数组
void dfs(int u,int pre)
{//dfs递归找到每个节点的子节点数目
    size[u]=1;
    int len=vec[u].size();//u节点的子节点数目
    for(int i=0;i<len;i++)
    {
        int v=vec[u][i].v;
        if(v!=pre)
        {//这部分着重理解一下
            w[v]=vec[u][i].w;//编号为v的节点的权重
            dfs(v,u);
            size[u]+=size[v];//父节点u的经过次数增加
        }
    }
}
int main()
{
    int n,k;
    while(~scanf("%d%d",&n,&k))
    {
        for(int i=0;i<n;i++)
        {
            vec[i].clear();
            size[i]=0;
            w[i]=0;
        }
        for(int i=1;i<=n-1;i++)
        {//双向边，因为两个节点之间的关系是不确定的
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            temp.v=v;
            temp.w=w;
            vec[u].push_back(temp);//u是v的父节点
            temp.v=u;
            vec[v].push_back(temp);//v是u的父节点
        }
        dfs(1,-1);
        long long sum=0;
        for(int i=2;i<=n;i++)
            sum+=(long long)w[i]*min(size[i],k);
        printf("%lld\n",sum);
    }
    return 0;
}