單源最短路徑問題

是指從一個指定頂點s到其他所有頂點i之間的距離，因為是單一頂點到其他頂點的距離，所以稱為單源。
       設圖G<V,E>是一個有向加權網路，其中V和E分別為頂點集合和邊集合，其邊權鄰接矩陣為W，邊上權值w(i,j)>0,i,j∈V，V={0,1,…,N-1}。
       設dist(i)為最短的路徑長度，即距離，其中s∈V且i≠s。這裡我是學習的Dijkstra演算法，並將其並行化。

最短路徑序列演算法

       Dijkstra演算法是單源最短路徑問題的經典解法之一，還有很多單源最短路徑的演算法，比如Bellman-ford、spfa，下面說說Dijkstra演算法的基本思想：
　　假定有一個待搜尋的頂點表VL

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<math.h>

using namespace std;
const int maxn = 10000;
int dist[maxn];
int mp[maxn][maxn];
bool
 
 vis[maxn];
int n,m;
const int oo = INT_MAX;
void Dijkstra(int s)
{
    for(int i=1; i<=n; i++)
    {
        dist[i] = mp[s][i];
        vis[i]=false;
    }
    dist[s] = 0;
    vis[s] = true;
    int u;
    for(int i=2; i<=n; i++)
    {
        int minn = oo;
        for(int j=1; j<=n; j++)
            if
 
(!vis[j]&&minn>dist[j])
            {
                minn = dist[j];
                u=j;
            }
        vis[u]=true;
        for(int j=1; j<=n; j++)
            if(!vis[j]&&mp[u][j]<oo)
            {
                if(dist[u]+mp[u][j]<dist[j])
                    dist[j]=dist[u]+mp[u][j];
            }
    }
}
int main()
{
    for(int i=0; i<maxn; i++)
        for(int j=0; j<maxn; j++)
        {
            if(i!=j)mp[i][j]=oo;
            else mp[i][j]=0;
        }
    scanf("%d%d",&n,&m);
    for(int i=0; i<m; i++)
    {
        int s,t,len;
        scanf("%d%d%d",&s,&t,&len);
        mp[s][t]=len;
    }
    int st;
    scanf("%d",&st);
    Dijkstra(st);
    for(int i=1; i<=n; i++)
        printf("%d ",dist[i]);
    puts("");
    return 0;
}

以下這段程式碼我們可以進行並行化，每個處理器分派n = N/p（注意這裡的n跟我程式中寫的n不是一個n）個節點進行初始化

    for(int i=1; i<=n; i++)
    {
        dist[i] = mp[s][i];
        vis[i]=false;
    }
    dist[s] = 0;

下面這段程式碼可以並行化為：首先每個處理器分派n個節點分別求區域性最小值，然後再p個處理器合作求全域性最小值，最後再將這一最小值廣播出去。p個處理器合作方法如下：當p為偶數時，後p/2個處理器將自己的區域性最小值分別傳送到對應的前p/2個處理器中，由前p/2個處理器比較出2個區域性最小值中相對較小者並保留。當p為奇數時，設p=2h+1，則後h個處理器的值分別傳送到前h個處理器中，比較並保留當前最小值。一次這樣的迴圈過後，p個最小值減少了一半，兩次後變為1/4，如此一層一層的比較，logp次迴圈後，就可以得出唯一的全域性最小值。

for(int j=1; j<=n; j++)
            if(!vis[j]&&minn>dist[j])
            {
                minn = dist[j];
                u=j;
            }

下面的這段程式碼，可以每個處理器分配n個頂點，然後獨立進行更新dist的操作。

        for(int j=1; j<=n; j++)
            if(!vis[j]&&mp[u][j]<oo)
            {
                if(dist[u]+mp[u][j]<dist[j])
                    dist[j]=dist[u]+mp[u][j];
            }

根據以上思路，最短路徑的並行演算法就很明瞭了，使用了p個處理器，那麼時間複雜度就是O(N^2/p+Nlogp)。
我們能夠進行並行的方法就比較多了，可以用openmp或者mpi等等。最近在學習mpi並行程式設計，學的還不是很6，具體並行的程式就不貼啦。