Dijstra--讲解

这个算法只能计算单源最短路,而且不能计算负权值,这个算法是贪心的思想。

Dijkstra是按路径长度递增的顺序构造最短路径,每次都是从dist数组中选择最小的,然后加入已经确定出最短路的顶点的集合中,然后去更新,没有加入到已经确定出最短路的顶点的集合中,Dijkstra 每次循环都可以确定一个顶点的最短路径,故程序需要循环 n-1 次。

Dijkstra O(n^2) 单源最短路算法(计算从一个点到其他各点的最短路径),我们实际使用的dij使用优先队列优化的Dij时间复杂度为O(mlogn)。任何题目中都要注意的有四点事项:图是有向图还是无向图、是否有负权边,是否有重边,顶点到自身的可达性。

Dijstra--讲解_第1张图片

Dijstra--讲解_第2张图片

dist[i]表示源点到i点的最短路径.

以为源点

    1         2          3       4      5        6

dis  0         1          12      inf     inf       inf(一开始初始化dis源点,自己到自己0,不能直接到达的为inf,当然也可以,像下面一样初始化)

1         2          3       4      5        6

dis  0         inf         inf      inf     inf       inf

S存放已经找到的最短路径的节点,U存放没找到的

S={1},一开始只有源点

以第一种初始化方法为例:

从dist里面选一个最小的 是1,将其节点加入S,S={1,2},更新dist;

1         2          3       4      5        6

dis  0         1          10      4    inf       inf

 

从dist里面选一个最小的 是4,将其节点加入S,S={1,2,4},更新dist;

1         2          3       4      5        6

dis  0         1          8      4      17       19

 

从dist里面选一个最小的 是8,将其节点加入S,S={1,2,4,3},更新dist;

1         2          3       4      5        6

dis  0         1          8      4      13      19

 

从dist里面选一个最小的 是13,将其节点加入S,S={1,2,4,3,5},更新dist;

1         2          3       4      5        6

dis  0         1          8      4      13        17

void Dijkstra(int s)
{
    int vis[LEN] = {0};
    for(int i=1; i<=n; i++)
        dis[i] = INF;
    dis[s] = 0;
    for(int i=0; i

 

/* 
使用优先队列Dijkstra算法 
复杂度O(ElogE) 
注意对vector E[MAXN]进行初始化后加边
*/  
using namespace std;  
const int INF=0x3f3f3f3f;  
const int MAXN=1000010;  
struct qnode  
{  
    int v;  
    int c;  
    qnode(int _v=0,int _c=0):v(_v),c(_c){}  
    bool operator <(const qnode &r)const  
    {  
        return c>r.c;  
    }  
};  
struct Edge  
{  
    int v,cost;  
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}  
};  
  
vector E[MAXN];  
bool vis[MAXN];  
int dist[MAXN];  
void Dijkstra(int n,int start)//点的编号从1开始  
{  
    memset(vis,false,sizeof(vis));  
    for(int i=1;i<=n;i++) dist[i]=INF;  
    priority_queue que;  
    while(!que.empty()) que.pop();  
    dist[start]=0;  
    que.push(qnode(start,0));  
    qnode tmp;  
    while(!que.empty())  
    {  
        tmp=que.top();  
        que.pop();  
        int u=tmp.v;  
        if(vis[u]) continue;  
        vis[u]=true;  
        for(int i=0;idist[u]+cost)  
            {  
                dist[v]=dist[u]+cost;  
                que.push(qnode(v,dist[v]));  
            }  
        }  
    }  
}  
void addedge(int u,int v,int w)  
{  
    E[u].push_back(Edge(v,w));  
}  
int main()  
{  
    for(int i=0;i<=MAXN;i++)  
        if(!E[i].empty())  
            E[i].clear();  
   // freopen("in.txt","r",stdin);  
    int n;  
    cin>>n;  
    int e;  
    cin>>e;  
    int u,v,w;  
    for(int i=1;i<=e;i++)  
    {  
        cin>>u>>v>>w;  
        addedge(u,v,w);  
    }  
    Dijkstra(n,1);  
    for(int i=1;i<=n;i++)  
        cout<

 

你可能感兴趣的:(图论,比赛)