最短路问题专题

///注意：最短路问题均没有使用递归函数。
/*
Dijkstra  单源最短路问题 用了一个队列
Bellman_Ford 单源最短路  暴搜
Floyd_warshanll  多元最短路问题  dp 直接更新

Dijkstra算法的路径还原*/

Dijkstra算法
Bellman_Floyd算法
Floyd_warshall算法

单源最短路问题  对所有的边进行遍历，更新d的数字
Bellman——floyd 暴力破解
===
const int MAX_E;
const int MAX_V;
const int INF;

struct edge{int from,int to,int cost};
edge G[MAX_E];
int d[MAX_V];
void shortest_path_Bellman_Floyd()
{
    ======
 int i;int v;int start;int finial;
for(int i=0;i<v;++i)
d[i]=INF;
d[start]=0;

while(true)
{
    int flag=0;

    for(int i=0;i<e;++i)
    {
        edge e=G[i];
       if(a [e.from] !=INF&& d[e.from] +e.cost<d[e.to])///这里稍微去一点枝
        {
            d[ e.to ]=d[ e.from ]+e.cost;
            flag=1;
        }
    }
    if(flag==0) break;
}
}

没选过的那些数里面最小的那个就是下一个要去走的
Dijkstra算法
///用重的变量是v 即找到的v的序号以及 v的数量

===
const int MAX_E;
const int MAX_V;
const int INF;

int d[MAX_V];
struct edge{int to,int cost};
vector <edge> G [MAX_V];
int used[MAX_v];
void shortese_path_Dijkstra()

int i;int v;int start;int finial;
for(int i=0;i<v;++i)
d[i]=INF;
d[start]=0;
===将used初始化为0
while(true)
{
     int v1=-1;
    int  min_v=INF;
    ****************
    for(int i=0:i<v;++i)
    {
        if( (!used[i]))
        {
            if(d[i])< min_v {min_v=d[i];v1=i;used[i]=1;} *********别忘记
        }

    }
     *****************
    if(v1==-1)  break;

    for(int i=0;i<G[v1].size;i++)
    {
        int vv=G[v1][i];
        d[vv.to]=min(d[vv.to],d[v1]+vv.cost);
    }

}

Dijkstra算法的第二种实现
使用队列

const int MAX_E;
const int MAX_V;
const int INF;
typedef pair<int int> pa;
///声明成按第一个变量排序的que,从小到大

///(维护d，将新生成的压进去)
///找出来，压进去

void shortest_path_Dijkstra2()
{
    priority_queue<pa,vector<pa>,greater<pa> > que;
    int d[MAX_V];
    int num_v;
    for(int i=0;i<num_v;++i) d[i]=INF; d[start]=0;
    int start;
    int finial;

    que.push(pa(0,start));

    while(!q.empty())
  {
    pa p=que.top();
    que.pop();

    int vertex=p.second;
    for(int i=0;i<v;++i)
    {
        if(d[i]<G[vertex][i]+d[vertex])
         {

             que.push(pa(i,G[vertex][i]+d[vertex]));
              d[i]= G[vertex][i]+d[vertex];
         }
                 ///压进去就好了
    }

  }
}

从数据结构角度
///注意 变量的乱用。。
B: edge d
D: G u d
D2: que  G
///感觉上G与G(edge) 功能一样 不过可能更省空间，但代码复杂点。。。

/*
多源最短路问题 dp的思路
即dp[k][i][j]表示 考虑节点1-k 时从i到j的最短距离

若k是其中一点
dp[k][i][j]=dp[k-1][i][k]+dp[k-1][k][j]
*/
int v;
int e[MAX_V][MAX_V];
for(int i=0;i<v;++i)
    for(int j=0;j<v;++j)
         if(i=j) dp[i][j]=e[i][j];

///不是的话dp[k-1][i][j]
for(int k=0;k<v;++k)
   for(int i=0;i<v;++i)
        for(int j=0;j<v;++j)
               dp[i][j]=min{dp[i][j],dp[i][k]+dp[k][j]};
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ]

]