单源最短路径 Bellman_ford 和 dijkstra

首先两个算法都是常用于 求单源最短路径

关键部分就在于松弛操作 实际上就是dp的感觉

if (dist[e.to] > dist[v] + e.cost)

{

　　dist[e.to] = dist[v] + e.cost;　　

　　...

}

bellman_ford O(E*V) 但是配合队列可以 有spfa 可以达到O(kE) 

http://www.360doc.com/content/13/1208/22/14357424_335569176.shtml

并且bellman_ford还适用于负边 并且可以利用最多循环V-1次的性质 判断是否存在负圈(如果循环超过V-1次 说明有负圈 因为没重复走着负圈一次 都伴随着更新)

并且因为松弛操作是针对于每条边的遍历也可以用向前星存

#include <iostream>
#include <stdio.h>
#include <fstream>
#include <string.h>
#define MAXV 10007
#define MAXE 1007
#define INF 0x3f3f3f3f
using namespace std;

int V, E;

struct Edge
{
    int from, to, cost;
}edge[MAXE];




int bellman_ford(int s, int d)//求单源最短路径
{
    int dist[MAXV];
    fill (dist, dist+V+10, INF);
    dist[s] = 0;
    while (true)//直至update不在更新
    {
        bool update = false;
        for (int i = 0; i < E; i++)
        {
            if (dist[edge[i].from] != INF && dist[edge[i].to] > dist[edge[i].from] + edge[i].cost)
            {
                dist[edge[i].to] = dist[edge[i].from] + edge[i].cost;
                update = true;
            }
        }
        if (!update) break;
    }
    return dist[d];
}
//while(true) 循环中最多循环V-1次 复杂度是O(V*E)
//如果存在 从s可达的负圈 那么在第V次循环时也会更新 可以用这个性质来检查负圈
//如果一开始把dist都初始化为0  那么可以检查出所有的负圈
//检查负边 是负边 返回true
//P.S 圈表示基本回路
bool isNegtive()
{
    int dist[MAXV];
    memset(dist, 0, sizeof(dist));//单纯查负圈
    for (int i = 0; i < V; i++)
    {
        for (int i = 0; i < E; i++)
        {
            Edge e = edge[i];
            if (dist[e.to] < dist[e.from] + e.cost )
            {
                dist[e.to] = dist[e.from] + e.cost;
                if (i == V-1)//如果第V次还更新 那么就有负圈
                    return true;
            }
        }
    }
    return false;
}
int main()
{
    ifstream cin ("in.txt");
    cin >> V >> E;
    for (int i = 0; i < E; i++)
    {
        cin >> edge[i].from >> edge[i].to >> edge[i].cost;
    }
    cout << bellman_ford(1, 7) << endl;
}

dijkstra 普通写法O(V^2)

但是 dijkstra的特点 --->>是针对每一个点 通过它所对应的边更新 e.to的节点 

每次取出的是离原点sorce 最近的点 所以就可以使用优先队列 那么就变成O(V*logV)

并且因为“是针对每一个点 通过它所对应的边更新 e.to的节点 ” 那么也很好试用向前星

#include <iostream>
#include <string.h>
#include <fstream>
#include <stdio.h>
#include <queue>
#define MAXV 10007
#define MAXE 1007
#define INF 0x3f3f3f3f
using namespace std;

int V, E;
//迪杰特斯拉好像不是很好用向前星
//这个算法是针对每一个点更新 而向前星存储的是边的信息 要查找点就比较复杂

//用邻接矩阵存储 O(V^2)的算法

int cost[MAXV][MAXV];
int dijkstra(int s, int d)
{
    int dist[MAXV];
    bool use[MAXV];
    fill(dist, dist+MAXV, INF);
    memset(use, false, sizeof(use));
    dist[s] = 0;
    while (true)
    {
        int v = -1;
        for (int i = 1; i <= V; i++)//找一个最近的 未使用过的点
        {
            if (!use[i] && (v == -1 || dist[i] < dist[v])) v = i;
        }
        if (v == -1) break;
        use[v] = true;
        for (int i = 1; i <= V; i++)
        {
            dist[i] = min(dist[i], dist[v] + cost[v][i]);
        }
    }
    return dist[d];
}

//使用优先队列(也就是heap优化)O(E*logV)
//针对边来dp 这里可以用向前星存储了
struct Edge
{
    int to, n, next;
}edge[MAXE];
int num = 0;
int head[MAXV];
void Add(int from, int to, int c)
{
    edge[num].n = c;
    edge[num].to = to;
    edge[num].next = head[from];//从头插入
    head[from] = num++;
}
void init()//初始化
{
    ifstream cin("in.txt");
    memset(edge, -1, sizeof(edge));
    memset(head, -1, sizeof(head));
    cin >> V >> E;
    for (int j = 0; j < E; j++)
    {
        int from , to , c;
        cin >> from >> to >> c;
        Add(from, to, c);
    }
}

typedef pair<int, int> P;//first 表示与s的距离, second表示点的编号
int pre[MAXV];//记录前驱节点 在每次dist[j] = dist[k] + cost[k][j]更新时记录在到j的最短路径上的前驱节点就是k
int fast_dijkstra(int s, int d)
{
    int dist[MAXV];
    priority_queue<P, vector<P>, greater<P> > que;//用优先队列存储点的信息 每次弹出距离最短的点O(logV)
    fill(dist, dist+MAXV, INF);
    dist[s] = 0;
    que.push(P(0, s));
    while (!que.empty())
    {
        P p = que.top();
        que.pop();
        if (dist[p.second] < p.first) continue;
        int t = head[p.second];
        while (t != -1)
        {
            Edge e = edge[t];
            if (dist[e.to] > dist[p.second] + e.n)
            {
                dist[e.to] = dist[p.second] + e.n;
                pre[e.to] = p.second;
                que.push( P(dist[e.to], e.to) );
            }
            t = e.next;
        }
    }
    return dist[d];
}

int main()
{
    /*
    ifstream cin("in.txt");
    cin >> V >> E;
    for (int i = 1; i <= V; i++)
        for (int j = 1; j <= V; j++)
            cost[i][j] = INF;//不存在时 cost为INF
    for (int j = 0; j < E; j++)
    {
        int from , to , c;
        cin >> from >> to >> c;
        cost[from][to] = c;
    }
    int ans = dijkstra(1, 7);
    */
    init();
    int ans = fast_dijkstra(1,7);
    cout << ans << endl;
    //这样路径即还原了
    int t = pre[7];
    cout << 7 << " ";
    while(t != 1)
    {
        cout << t << " ";
        t = pre[t];
    }
    cout << 1 <<endl;
}