CodeForces 87 D.Beautiful Road（并查集）

Description

给出一棵$n$个点的树，每条边的有边权，任两点之间路径上边权最大值的边魅力值加一，问最后魅力值最大的边的魅力值以及这些边的编号

Input

第一行一整数$n$表示节点数，之后以此输入$n-1$条树边的两端点和边权$w$

$(2\le n\le 10^5,1\le w\le 10^9)$

Output

输出最大魅力值、有最大魅力值的边的数量以及编号

Sample Input

6
1 2 1
1 3 5
3 4 2
3 5 3
3 6 4

Sample Output

16 1
2

Solution

按边权从小往大加边，每次加入一个权值的边后，该权值的边必然为当前权值最大的边，进而通过当前森林的状态可以统计每条边的魅力值

假设一条边深度较大端点为$u$，另一个端点为$v$，那么能够增加该边魅力值的路径必然是加入所有该边权的边后，$u$子树中的点到该连通分支中除去$u$子树的其他点的路径，故在加边过程中需要能保证两者之一不变才方便统计，而把等边权的边按深度排序，每次加入深度较大的边，可以保证每次加边后该连通块增加的点都在$u$子树外

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f,maxn=100005;
struct node
{
    int u,v,w,id,dep;
    bool operator<(const node&b)const
    {
        if(w!=b.w)return w<b.w;
        return dep>b.dep;
    }
}edge[maxn];
vector<int>g[maxn];
int n,fa[maxn],num[maxn],dep[maxn],temp[maxn];
ll cnt[maxn];
int find(int x)
{
    if(fa[x]==x)return x;
    return fa[x]=find(fa[x]);
}
void unite(int x,int y)
{
    x=find(x),y=find(y);
    if(x==y)return ;
    fa[x]=y;
    num[y]+=num[x];
}
int dfs(int u,int fa,int depp)
{
    dep[u]=depp;
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i];
        if(v==fa)continue;
        dfs(v,u,depp+1);
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)fa[i]=i,num[i]=1;
    for(int i=1;i<n;i++)
    {
        scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
        g[edge[i].u].push_back(edge[i].v);
        g[edge[i].v].push_back(edge[i].u);
        edge[i].id=i;
    }
    dfs(1,0,0);
    for(int i=1;i<n;i++)
    {
        if(dep[edge[i].u]<dep[edge[i].v])swap(edge[i].u,edge[i].v);
        edge[i].dep=dep[edge[i].u];
    }
    sort(edge+1,edge+n);
    for(int i=1;i<n;)
    {
        int j=i;
        while(j<n&&edge[i].w==edge[j].w)
        {
            temp[j]=num[find(edge[j].u)];
            unite(edge[j].u,edge[j].v);
            j++;
        }
        while(i<j)
        {
            cnt[edge[i].id]=2ll*temp[i]*(num[find(edge[i].u)]-temp[i]);
            i++;    
        }
    }
    ll res=0;
    vector<int>ans;
    for(int i=1;i<n;i++)
        if(cnt[i]==res)ans.push_back(i);
        else if(cnt[i]>res)
        {
            res=cnt[i];
            ans.clear();
            ans.push_back(i);
        }
    printf("%I64d %d\n",res,ans.size());
    for(int i=0;i<ans.size();i++)printf("%d%c",ans[i],i==ans.size()-1?'\n':' ');
    return 0;
}