UESTC Training for Graph Theory——N、滑雪与时间胶囊(Large Input)

滑雪与时间胶囊(Large Input)

Time Limit: 20000 ms Memory Limit: 131072 kB Solved: 49 Tried: 408

Description

a180285 非常喜欢滑雪。他来到一座雪山,这里分布着 M 条供滑行的轨道和 N 个轨道之间的交点(同时也是景点),而且每个景点都有一编号 i(1<=i<=N)和一高度 Hi。a180285能从景点 i 滑到景点 j 当且仅当存在一条 i 和 j 之间的边,且 i 的高度不小于 j。

与其他滑雪爱好者不同,a180285 喜欢用最短的滑行路径去访问尽量多的景点。如果仅仅访问一条路径上的景点,他会觉得数量太少。于是 a180285 拿出了他随身携带的时间胶囊。这是一种很神奇的药物,吃下之后可以立即回到上个经过的景点(不用移动也不被认为是a180285 滑行的距离)

请注意,这种神奇的药物是可以连续食用的,即能够回到较长时间之前到过的景点(比如上上个经过的景点和上上上个经过的景点)。

现在,a180285 站在 1 号景点望着山下的目标,心潮澎湃。他十分想知道在不考虑时间胶囊消耗的情况下, 以最短滑行距离滑到尽量多的景点的方案(即满足经过景点数最大的前提下使得滑行总距离最小)

你能帮他求出最短距离和景点数吗?

Input

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

Output

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

Sample Input

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

Sample Output

3 2

Source

SCOI2012

/*算法思想：
  给一个有向图，每个要求遍历尽可能多的点，然后再是遍历通过的路径长度最小
  由于起始点就在 1 ，已经确定了，所以我们可以这样做：
  先BFS一遍，确定哪些点是可以到达的，这就是能遍历的最大的点的数量。
  然后在对这些能到达的点构成的图求一个最小生成树，由于可以使用时间胶囊，回到上一次访问的点，
  在这时，边就可以看做是无向的了，我们同kruskal求一次最小生成树就是遍历完这些点通过的最小路径
*/

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#define N 200005
using namespace std;
struct data
{
    int st,en,next;
    long long val;
} edge[2000005];
int head[N],tot,n,m,fa[N],weight[N];
bool fg[N];
void make_set()
{
    for(int i=0;i<=n;i++)
        fa[i]=i;
}
int find_set(int x)
{
    if(fa[x]!=x) fa[x]=find_set(fa[x]);
    return fa[x];
}
void merge_set(int x,int y)
{
    fa[y]=x;
}
void add_edge(int st,int en,long long val)
{
    edge[tot].st=st;
    edge[tot].en=en;
    edge[tot].val=val;
    edge[tot].next=head[st];
    head[st]=tot++;
}
int bfs()  //bfs找哪些点能够遍历到
{
    int ans=1;
    queue<int>q;
    memset(fg,0,sizeof(fg));
    q.push(1); fg[1]=true;
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        for(int pos=head[now];pos!=-1;pos=edge[pos].next)
            if(!fg[edge[pos].en])
            {
                q.push(edge[pos].en);
                fg[edge[pos].en]=true;
                ans++;
            }
    }
    return ans;
}
bool cmp(data a,data b)
{
    if(weight[a.en]==weight[b.en]) return a.val<b.val;
    else return weight[a.en]>weight[b.en];
}
long long kruskal()  //kruskal求最小生成树
{
    long long ans=0;
    for(int i=1;i<=tot;i++)
    if(fg[edge[i].st] && fg[edge[i].en])
    {
        int f1=find_set(edge[i].st);
        int f2=find_set(edge[i].en);
        if(f1!=f2)
        {
            ans+=edge[i].val;
            merge_set(f1,f2);
        }
    }
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(long long i=1;i<=n;i++)
        scanf("%d",&weight[i]);
    memset(head,-1,sizeof(head));
    memset(edge,0,sizeof(edge));
    tot=1;
    for(int i=1;i<=m;i++)
    {
        int a,b; long long c;
        scanf("%d%d%lld",&a,&b,&c);
        if(weight[a]<weight[b])
            add_edge(b,a,c);
        else if(weight[a]>weight[b])
            add_edge(a,b,c);
        else
        {
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
    }
    printf("%d ",bfs());
    sort(edge+1,edge+tot+1,cmp);
    make_set();
    printf("%lld\n",kruskal());
    return 0;
}