hdu 1598 find the most comfortable road

https://vjudge.net/problem/HDU-1598

思路：
一开始想了很久才想通，先把边进行排序，然后枚举边的起点和终点，但是这样就是三重循环，t了。
之后的改进，大概就是，只用枚举起点，当循环到两点联通的时候，就可以break了，这样就改进成了二重循环。
一开始就是卡在，如何判断两点联通，这里用到的主要是克鲁斯卡尔算法的思想。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int par[205];

struct node
{
    int a,b;
    int d;
} r[1005];

void init(int n)
{
    for (int i = 1;i <= n;i++)
        par[i] = i;
}

int fin(int x)
{
    if (x == par[x]) return x;
    else return par[x] = fin(par[x]);
}

void unit(int x,int y)
{
    x = fin(x);
    y = fin(y);

    if (x != y) par[x] = y;
}

bool cmp(node p,node q)
{
    return p.d < q.d;
}

int main()
{
    int n,m;

    while (scanf("%d%d",&n,&m) != EOF)
    {
        for (int i = 0;i < m;i++)
        {
            scanf("%d%d%d",&r[i].a,&r[i].b,&r[i].d);
        }

        sort(r,r+m,cmp);

        int q;

        scanf("%d",&q);

        for (int i = 0;i < q;i++)
        {
            int st,en;

            int minn = 100000000;

            scanf("%d%d",&st,&en);

            for (int j = 0;j < m;j++)
            {
                init(n);
                bool f = 0;
                for (int k = j;k < m;k++)
                {
                    bool ff = 0;

                    unit(r[k].a,r[k].b);

                    if (fin(st) == fin(en)) ff = 1;

                    if (ff && r[k].d - r[j].d < minn)
                    {
                        minn = r[k].d - r[j].d;
                        f = 1;
                    }

                    if (f) break;
                }
            }


            if (minn == 100000000) printf("-1\n");
            else printf("%d\n",minn);
        }
    }


    return 0;
}