链接：

时间限制：C/C++ 2秒，其他语言4秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld

题目描述

a180285非常喜欢滑雪。他来到一座雪山，这里分布着M条供滑行的轨道和N个轨道之间的交点（同时也是景点），而且每个景点都有一编号i（1 ≤
i ≤ N）和一高度Hi。a180285 能从景点i 滑到景点j 当且仅当存在一条i 和j 之间的边，且i 的高度不小于j。
与其他滑雪爱好者不同，a180285喜欢用最短的滑行路径去访问尽量多的景点。如果仅仅访问一条路径上的景点，他会觉得数量太少。于是a180285拿出了他随身携带的时间胶囊。
这是一种很神奇的药物，吃下之后可以立即回到上个经过的景点（不用移动也不被认为是 a180285 滑行的距离）。
请注意，这种神奇的药物是可以连续食用的，即能够回到较长时间 之前到过的景点（比如上上个经过的景点和上上上个经过的景点）。
现在，a180285站在1号景点望着山下的目标，心潮澎湃。他十分想知道在不考虑时间
胶囊消耗的情况下，以最短滑行距离滑到尽量多的景点的方案（即满足经过景点数最大的前 提下使得滑行总距离最小）。你能帮他求出最短距离和景点数吗？

输入描述:

输入的第一行是两个整数N，M。 接下来1行有N个整数Hi，分别表示每个景点的高度。
接下来M行，表示各个景点之间轨道分布的情况。每行3个整数，Ui，Vi，Ki。表示编号为Ui的景点和编号为Vi的景点之间有一条长度为Ki的轨道。

输出描述:

输出一行，表示a180285最多能到达多少个景点，以及此时最短的滑行距离总和。

示例1
输入

3 3 
3 2 1 
1 2 1 
2 3 1 
1 3 10

输出

3 2

题解：

题目中说有了时间胶囊回到之前点，而且可以练习使用。我们再根据样例画出图形，其实就是最小生成树，但是边为有向边（也就是只能从高的地方滑向低的地方，如果一样高可以互相达到）

完美用最小生成树的方法来求
（之前刚写了一个最小生成树的文章链接）
最小生成树的原理：
Kruskal：把最短的集合合并成一个集合
Prim：每次找与现有生成树相连的最短的边
在本题中，我们要找一个边从a到b，可以用Kruskal的方法对点的高低进行排序（从大到小），如果两个点高度相同则对边进行进行排序，然后自高到低一次加入到最小生成树的图中。这样就能保证所有点都是从高到低的方向走。
用Prim的话：点从高到低依次加入，然后每次加入与已有树距离最小的树外点，并不断更新最短距离，这样能保证不重不漏

据说最小树形图还有个专门的算法“朱-刘Edmonds算法”，恕我孤陋寡闻，等学会后更新上

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=100001;


int n,m,head[maxn];
bool vis[maxn];
int q[maxn*20],sum1;
int fa[maxn],h[maxn];

struct edge{
   
	ll u,v,w,h,next;
}a[maxn*20];;
bool cmp(edge a,edge b)
{
   
      if(a.h==b.h)   return a.w<b.w;
      return a.h>b.h;
}
int tot=0;
void add(int u,int v,int w)
{
   
	 a[++tot].next=head[u];
      a[tot].u=u;
      a[tot].v=v;
      a[tot].w=w;
      a[tot].h=h[v];

      head[u]=tot;
}
int find(ll x)
{
   
	if(fa[x]==x)return x;
	else fa[x]=find(fa[x]); 
}
void bfs(int now)
{
   
      int end=1;
  
	  sum1=1;//能经过多少点 （景点数量） 
	  q[now]=1;
      vis[now]=1;
      for(int i=1;i<=end;i++)
      {
   
            int now=q[i];
            for(int j=head[now];j;j=a[j].next)
            {
   
                  if(!vis[a[j].v])
                  {
   
                        vis[a[j].v]=true;
                        sum1++;
                        q[++end]=a[j].v;
                  }
            }
      }
}	

ll kruskal()
{
   
	 ll sum2=0;// 最短的滑行距离总和
      int tot1=0;//统计目前树中边的数量 
      sort(a+1,a+1+tot,cmp);
      
      for(int i=1;i<=n;i++)  fa[i]=i;
      
      for(int i=1;i<=tot;i++)
      {
   
            if(!(vis[a[i].u] && vis[a[i].v]))   continue; 
            
            int f1=find(fa[a[i].u]);
            int f2=find(fa[a[i].v]);
            
            if(f1!=f2)
            {
   
                  fa[f2]=f1;
                  
                  tot1++;
                  sum2+=a[i].w;
            }
            if(tot1==sum1-1)   break;//当组成树即完成任务 
      }
      return sum2;
}
int main()
{
   
	 int u,v,w;
      scanf("%d%d",&n,&m);
      for(int i=1;i<=n;i++)
            scanf("%d",&h[i]);
      for(int i=1;i<=m;i++)
      {
   
           
            cin>>u>>v>>w;
            if(h[u]>=h[v])   add(u,v,w);
            
            if(h[u]<=h[v])   add(v,u,w);
      }
      bfs(1);//从1开始出发 ，看看最多能到多少景点 
      kruskal();
    	cout<<sum1<<" "<<kruskal()<<endl;
      return 0;
}