HDU 2544 最短路【Bellman_Ford 】

题意：给出n个节点，m条边，问从起点到终点的最短距离

用bellman_ford，注意是无向图

初学bellman_ford= =一点点理解

因为dijkstra是每次用集合里面的点去更新它们所连接的点的距离 假设集合s={A},

如果B能够被A“带”入集合的话，说明AB一定是最短的距离了，因为后来不管怎么样，边权都是正的，不会使得AB变得更小

所以，dijkstra只能处理正权图

然后Bellman_Ford可以处理负权，反复用已有的边来更新最短距离

从起点1到终点n的最短距离最多经过n-2个点，即为最多松弛n-1次

如果第n次还能够松弛成功，说明含有负权回路

大概先理解了这些，优化再好好学= =证明也再好好看

#include<iostream>  
#include<cstdio>  
#include<cstring> 
#include <cmath> 
#include<stack>
#include<vector>
#include<map> 
#include<set>
#include<queue> 
#include<algorithm>  
#define mod=1e9+7;
using namespace std;

typedef long long LL;
const int INF = 0x3f3f3f3f ;
const int maxn=10005;
int d[maxn];

struct edge{
    int u,v,w;
} e[maxn];

int flag=1,nodenum,edgenum,st;

void bellman_ford(){
    int i,j,k;
    for(i=1;i<=nodenum;i++)
    d[i] = (i == st ? 0 : INF);
    
    for(i=1;i<nodenum;i++){
        for(j=1;j<=2*edgenum;j++){
            if(d[e[j].v]>d[e[j].u]+e[j].w) d[e[j].v]=d[e[j].u]+e[j].w;//松弛 
        }
    }  
}

int main(){
    int i,j,k,u,v,w;
    while(scanf("%d %d",&nodenum,&edgenum)!=EOF&&nodenum&&edgenum){
        for(i=1;i<=2*edgenum;i++){
            scanf("%d %d %d",&u,&v,&w);//无向图 
            e[i].u=u;e[i].v=v;e[i].w=w;
            i++;
            e[i].u=v;e[i].v=u;e[i].w=w;
        }
        
        st=1;
        
        bellman_ford();
        printf("%d
",d[nodenum]);
    }
    return 0;
}

加油 go---go--go