CSU 1307 City Tour kruskal + dijkstra

http://acm.csu.edu.cn/OnlineJudge/problem.php?id=1307

题意：

　　找一条路径

　　1.这条路径中的最大的边一定要尽可能的小

　　2.满足1的情况下即最大的边相同的时候在找最短路径。

 

坑爹：

　　一开始只用最小生成树做，发现如果给的边的权值都一样的话，那你并查集建图完全就跟你输入的顺序

有关，权值都一样的话，并起来的边未必是你最短路要走的边。

　　找那个最大的边的时候我用递归来找最大的边中间可能有错误，现在还是不知道为什么。

 

解法：

　　不用DFS来找最大的边，因为kruskal中加的边是经过排序的，所以只要加到起点和终点连通的

时候就停止了，并返回那个值，这个值就是满足题意中1的那个最大边（k），然后再用dijkstra来找最短路径，

只要在松弛操作中加一个松弛的边不能超过k的条件就可以了。

 

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

const int maxn = 50000 +10;
const int INF = 0x3fffffff;

struct edge
{
    int start;
    int end;
    int values;
    friend bool operator < (struct edge a,struct edge b)
    {
        return a.values < b.values;
    }
};
struct edge num[maxn];
int map[2010][2010];
int father[maxn];
int Rank[maxn];
int dis[maxn];
bool visit[maxn];
int Max;
int ans;
int ANS;
int N;
int M;
int A;
int B;

void Make_Set(int x)
{
    father[x] = x ;
    Rank[x] = 0 ;
    dis[x] = INF;
}

int find_root(int x)
{  
    if(father[x] == x)
    {
        return x;
    }
    else
    {
        return father[x] = find_root(father[x]);
    }
}

void Union(int a,int b)
{
    int roota;
    int rootb;
    roota = find_root(a) ;
    rootb = find_root(b) ;
    
    if(roota == rootb )
    {
        return;
    }
    
    if(Rank[roota] > Rank[rootb] )
    {
        father[rootb] = roota;
    }
    else if(Rank[roota] < Rank[rootb] )
    {
        father[roota] = rootb;
    }
    else
    {
        father[roota] = rootb;
        Rank[rootb] ++;
    }
}

int kruskal()
{
    int sum=0;
    int count=0;
    int i;
    sort(num,num+M);
    for(i=0; i<M && count<=N-1; i++)
    {
        int a;
        int b;
        a=num[i].start;
        b=num[i].end;
        if(find_root(a)!=find_root(b))
        {
            Union(a,b);
            sum+=num[i].values;
            count++;
            if(find_root(A) == find_root(B))
            {
                return num[i].values;
            }
        }
    }
    return sum;
}


void dijkstra(int begin,int end,int no)
{
    int i;
    dis[begin] = 0;
    for(i=0; i<N; i++)
    {
        int min = INF;
        int min_j = -1;
        int j;
        for(j=1; j<=N; j++)
        {
            if(!visit[j] && min > dis[j])
            {
                min = dis[j];
                min_j = j;
            }
        }
        if(min_j == -1)
        {
            break;
        }
        visit[min_j] = true;
        for(j=1; j<=N; j++)
        {
            if(dis[j] > dis[min_j] + map[min_j][j] && map[min_j][j] <= no)
            {
                dis[j] = dis[min_j] + map[min_j][j];
            }
        }
    }
}

int main()
{
    while(cin>>N>>M>>A>>B)
    {
        int i;
        Max = 0;
        ans = 0;
        ANS = 0;
        memset(visit,0,sizeof(visit));
        int j;
        for(i=0; i<maxn; i++)
        {
            Make_Set(i);
        }
        for(i=0; i<2010; i++)
        {
           for(j=0; j<2010; j++)
           {
               map[i][j] = INF;
           }
        }
        for(i=0; i<M; i++)
        {
            int start;
            int end;
            int values;
            cin>>start>>end>>values;
            num[i].start = start;
            num[i].end = end;
            num[i].values = values;
            if(map[start][end] > values)
            {
                map[start][end] = map[end][start] = values;
            }
        }
        int MAX = kruskal();
        dijkstra(A,B,MAX);
        cout<<dis[B]<<endl;
    }
    return 0;
}

/*

4 4 2 3
1 4 5
1 2 100
2 3 10
1 3 10

3 3 1 2
1 3 20
3 2 20
1 2 20

5 5 1 4
1 2 20
2 3 20
3 4 20
5 4 20
1 5 20
*/