图论-最短路

单源最短路：

单元最短路问题是固定一个起点，求它到其他所有点的最短路的问题。终点固定的问题也叫单源最短路。

算法1：Bellman-Ford算法

记从起点s出发到顶点i的最短路为d[i],则:

d[i]=min(d[i],d[j]+G[j][i])(G[j][i]表示顶点j到i的距离)

初始化d[s]=0,其他均为inf,枚举每一条边，不断通过刚才的式子进行更新，更新数组d,就可以得到起点s到每一个顶点的最短路。

算法限制:必须保证图中不存在负圈.

算法原理:枚举每一条边，通过刚才的式子进行更新d，如果没有更新的值，则退出

时间复杂度:O(V*E)

代码如下:

const inf=0x3f3f3f3f;
const int maxn=1e3+100;
struct ege{
    int from,to,cost//起点，终点，权值
};
ege es[maxn];
int d[maxn];
int V,E;

void Bellman_Ford(int s)
{
    for (int i=0;id[e.from]+e.cost) {
                //保证可以到达from，然后使用这条边使得更短的距离到to
                d[e.to]=d[e.from]+e.cost;
                update=true;
            }
        }
        if (!update) break;
    }
}

ps:如果图中不存在从s可达的负圈，那么同一个最短路不会经过同一个顶点俩次（也就是说，最多通过V-1条边),用此可以检查图是否带有负圈

代码如下:

bool find_negative_loop()
{
    memset (d,0,sizeof (d));
    for (int i=0;id[e.from]+e.cost) {
                d[e.to]=d[e.from]+e.cost;
                if (i==V-1) return true;
            }
        }
    }
    return false;
}

算法2：Dijkstra算法

在没有负边的情况下，在BEllman-Ford算法中，如果d[j]还不是最短距离时，那么即d[i]=min(d[i],d[j]+G[j][i])(G[j][i]表示顶点j到i的距离)，进行更新，d[i]也不会变成最短距离。而且d[j]没有变化是，每一次都要检查一遍，很浪费时间，对算法进行修改:

1:找到最短距离已经确定的顶点，从它出发更新相邻的顶点的最短距离

2:已经确定的最短距离的顶点不需要更改

算法限制:图中不允许有负边

时间复杂度:o(V*V)

代码如下:

const inf=0x3f3f3f3f;
const int maxn=1e3+100;
int G[maxn][maxn];
bool vis[maxn];//标记那些顶点已经被遍历
int d[maxn];
int V,E;

void dijkstra(int s)
{
    memset (vis,false,sizeof (vis));
    for (int i=1;i<=n+m;i++) {
        dis[i]=inf;//预处理
    }
    dis[s]=0;
    while (true) {
        int v=-1;
        for (int i=1;i<=V;i++) {
            if (vis[i]==false&&(v==-1||(dis[i]

算法3：Dijlstra的优化

我们每一次都要枚举所有的顶点来查找下一个使用的顶点，因此很浪费时间，需要考虑新的数据结构来降低时间复杂度。

需要优化的数值更新和取最小值的情况，可以使用堆来优化，堆结构满足要求,把每个顶点当前的最短距离用维护，更新最短距离时，把对应元素往根方向移动，而取最小值就是堆顶，也可以使用STL中的priority_queue来实现

算法限制:图中不允许有负边

时间复杂度:O(E*log(V)）

代码如下:

typedef pair P;//first 最短距离 second 顶点
const inf=0x3f3f3f3f;
const int maxn=1e3+100;
struct ege{
    int from,to,cost//起点，终点，权值
};
vector G[maxn];
int d[maxn];
int V;

void dijkstra(int s)
{
    priority_queue,greater
 > que;
    for (int i=0;id[e.from]+e.cost) {
                d[e.to]=d[e.from]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
        
    }
}

任意俩点间的最短路

求解所有俩点间的最短路的问题叫做任意俩点间的最短路问题。

1：Floyd-Warshall算法

算法原理：非常简单，G[i][j]表示顶点i到顶点j的最短距离，我们运用dp的思想，枚举其它的每一条边G[i][k]与G[k][j]来更新G[i[j]

G[i][j]=min(G[i][j],G[i][k]+G[k][j])

不存在的边为inf

时间复杂度:O(V^3)

代码如下:

const inf=0x3f3f3f3f;
const int maxn=1e3+100;
int dp[maxn][maxn];//存图
int V;

void Floyd()
{
    for (int i=0;i