HDU5723 Abandoned country （最小生成树+深搜回溯法）

最新推荐文章于 2020-05-26 15:53:41 发布

dengguan2720

最新推荐文章于 2020-05-26 15:53:41 发布

阅读量137

点赞数

原文链接：http://www.cnblogs.com/aiguona/p/7214707.html

版权

本文探讨了一种算法，用于解决寻找最小生成树及计算任意两点间距离期望的问题。通过Kruskal算法构建最小生成树，并利用深度优先搜索计算所有路径的期望长度。文章详细解释了期望计算的方法，即权值乘以该路径被经过的次数，最终除以总的路径数。

摘要由CSDN通过智能技术生成

Description

　　An abandoned country has

Input

　　The first line contains an integer

Output

　　output the minimum cost and minimum Expectations with two decimal places. They separated by a space.

Sample

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

题意：

　　给定n个定点，m条边，求最小生成树以及任意两点之间距离的期望。

思路：

　　任意两点的期望是（权值）*（这条路被走过的次数）的总和除以总共的路径数。

　　比如从A到B距离为2，从B到C距离为3。那么从A到B走过2一次，从A到C走过2一次，走过3一次，从B到C走过3一次。

　　所以期望为（2*2+3*2）/ 3 = 3.33。

　　这里不能求最短路，超时。

　　应该用深搜回溯，找出这条路被走过过少次。这样就可以求出期望了。

　　这里由于数据量比较大，不能用prim邻接矩阵求最小生成树（vector应该可以），可以用Kruskal求最小生成树。

　　坑点：注意最后求期望的时候总共的路径数量n*(n-1)/2数据量比较大，应该用long long或者double存储。

/*
3
0 0
3 3
1 2 1
2 3 2
1 3 5
4 6
1 2 1
2 3 2
3 4 3
4 1 4
1 3 5
2 4 6
*/
#include<cstdio>
#include<algorithm>
#include<vector>
#include<iostream>
#include<string.h>
using namespace std;
vector<pair<int,int> >  v[100010];

struct Edge
{
    int f,t,q;
};

int m,n;//n为村庄数，m为街道数
Edge s[1000010];//存储图
long long  ans;//存最后的每条路的总和
int pre[100010];//并查集的祖先数组
int vis[100010];//标记数组

bool cmp(Edge a,Edge b )//排序函数
{
    return a.q<b.q;
}

int Find(int x)//找祖先
{
    if(x!=pre[x])
    {
        pre[x]=Find(pre[x]);
    }
    return pre[x];
}

void Merge(int x,int y)//查是否相等
{
    int fx=Find(x);
    int fy=Find(y);
    if(fx!=fy)
        pre[fx]=fy;
}

long long dfs(int x) //dfs递归搜索
{
    vis[x]=1;
    long long now=0,all=1;//now记录当前节点直接连接的节点数量  all记录此节点经过搜索后所有的与此节点连接的节点数
    int h=v[x].size();
    for(int i=0; i<h; i++)
    {
        int b=v[x][i].first;
        if(!vis[b])
        {
            now=dfs(b);
            all+=now;
            ans+=now*(n-now)*v[x][i].second;//ans记录的是权值*经过的次数
        }
    }
    return all;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        memset(vis,0,sizeof(vis));
        scanf("%d%d",&n,&m);
        if(m==0||n==0)
            {printf("0 0.00");continue;}

        for(int i=0;i<=n;i++)
            v[i].clear();
        for(int i=0; i<=n; i++)//并查集的祖先节点的初始化
        {
            pre[i]=i;
        }
        for(int j=0; j<m; j++)//输入
        {
            scanf("%d%d%d",&s[j].f,&s[j].t,&s[j].q);
        }
        sort(s,s+m,cmp);//排序
        long long sum=0;//sum用来记录最小生成树的长度
        for(int j=0; j<m; j++)
        {
            int fx=Find(s[j].f);
            int fy=Find(s[j].t);
            if(fx!=fy)  //如果祖先不相等，那么加入到最小生成树中
            {
                sum=sum+s[j].q;
                Merge(fx,fy);
                //加入到动态数组中准备做期望
                v[s[j].f].push_back(make_pair(s[j].t,s[j].q));
                v[s[j].t].push_back(make_pair(s[j].f,s[j]. q));
            }
        }
        dfs(1);//深搜回溯计算ans的值
        double y=1.0*n*(n-1)/2;
        printf("%lld %.2lf\n",sum,(double)ans/y);
    }
    return 0;
}