图连通（Kruaskal和prim）

Kruaskal

#include<bits/stdc++.h>
using namespace std ;
#define MAX_N 110

struct edge{
    int from,to;
    long long cost;
}E[MAX_N * MAX_N];

bool cmp(edge a,edge b){
    return a.cost < b.cost;
}

int father[MAX_N];
int N,M;

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

int Find(int x){
    if(x!=father[x]) return father[x] = Find(father[x]);
    return x;
}

bool Same(int x,int y){
    return Find(x)==Find(y);
}

void join(int x,int y){
    int p=Find(x),q=Find(y);
    if(p==q) return;
    father[p]=q;
}

long long Kruskal(){
    long long res = 0;
    sort(E+1,E+1+M,cmp);
    for(int i=1;i<=M;i++){
        if(Same(E[i].from,E[i].to)) continue ;
        join(E[i].from,E[i].to);
        res+=E[i].cost;
    }
    return res ;
}

int main(){

    while(scanf("%d%d",&M,&N) == 2){
        if(M==0) break;
        init();
        for(int i=1;i<=M;i++)
            scanf("%d%d%lld",&E[i].from,&E[i].to,&E[i].cost);
        long long res = Kruskal();
        for(int i=1;i<=N;i++)
            if(!Same(i,1))
                res = -1 ;
        if(res==-1)
            printf("?\n");
        else
            printf("%lld\n",res);
    }
    return 0;
}

Prim

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define MAX_N 110


struct edge{
    int to;
    ll cost;
    bool operator< (const edge &a) const{
        return a.cost < cost;
    }
    edge(int tt,ll cc):to(tt),cost(cc){}
    edge(){}
};


priority_queue<edge> que;
vector<edge>    G[MAX_N];
int N,M;
bool flag[MAX_N];


ll prim(){
    ll res = 0 ;
    flag[1]=1;
    for(int i=0;i<G[1].size();i++)
            que.push(G[1][i]);
    while(!que.empty()){
        edge e = que.top();
        que.pop();
        if(flag[e.to])  continue;
        flag[e.to]=1;
        res += e.cost;
        for(int i=0;i<G[e.to].size();i++)
            que.push(G[e.to][i]);
    }
    return res ;
}


int main(){
    while(scanf("%d%d",&M,&N)==2){
        if(M==0) break ;
        memset(flag,0,sizeof(flag));
        for(int i=0;i<=M;i++)
            G[i].clear();
        while(!que.empty()) que.pop();
        int u,v;
        ll cost;
        for(int i=1;i<=M;i++){
            scanf("%d%d%lld",&u,&v,&cost);
            G[u].push_back(edge(v,cost));
            G[v].push_back(edge(u,cost));
        }
        ll res = prim();
        for(int i=1;i<=N;i++)
            if(!flag[i])
                res = -1;
        if(res == -1 )
            printf("?\n");
        else
            printf("%lld\n",res);
    }
    return 0;
}

dijkstra

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
#define ll long long
const int maxn = 1000+10;
const int INF = 100000000;

struct edge{
    int to;
    int cost;
    edge(){}
    edge(int tt,int cc):to(tt),cost(cc){}
    bool operator< (const edge &a) const{
        if(a.cost == cost)
            return a.to > to ;
        return a.cost < cost;
    }
};
int dis[maxn];
vector<edge> G[maxn];
bool vis[maxn];
int dijkstra(int s,int e){
    priority_queue<edge> Q;
    Q.push(edge(s,0));
    dis[s] = 0;
    while(Q.size()){
        edge t = Q.top();
        Q.pop();
        int v = t.to;
        if(vis[v]) continue;
        vis[v] = true ;
        for(int i=0;i < G[v].size();i++){
            int v2 = G[v][i].to;
            int len = G[v][i].cost;
            if(dis[v2]>dis[v]+len){
                dis[v2] = dis[v]+len;
                Q.push(edge(v2,dis[v2]));
            }
        }
    }
    return dis[e];
}
void init(){
    for(int i=0;i<maxn;i++){
        dis[i] = INF;
        G[i].clear();
        vis[i] = false ;
    }
}
int main(){
    int N,M,S,T;
    while(scanf("%d%d",&N,&M)==2&&N&&M){
        init();
        int f,t,c;
        for(int i=0;i<M;i++){
            scanf("%d%d%d",&f,&t,&c);
            G[f].push_back(edge(t,c));
            G[t].push_back(edge(f,c));
        }
        int ans = dijkstra(1,N);
        if(ans == INF)
            printf("-1\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}