图论-最短路各个模板详解(Dijkstra,bellman-ford,spfa,Floyd)

Dijkstra算法(边权为正数)(朴素板)

void djstl()
{
	dist[1] = 0;
	for (int i = 1; i <= n; i++)
	{
		int t = -1;
		for (int j = 1; j <= n; j++)
		{
			if ((t == -1 || dist[j] < dist[t]) && !st[j])
			{
				t = j;
			}
		}

		st[t] = 1;
		for (int j = h[t]; j != -1; j = ne[j])
		{
			int k = e[j];
			dist[k] = min(dist[k], dist[t] + w[j]);
		}
	}
}

Dijkstra算法(堆优化版)

注意点:
1. 开st数组,用来记录一个点是否已经被更新
2. 当一个点发现可以被更新时,就放到heap中,这样的话,就算heap中有很多相同的点,也只会拿出里面的最 短距离的点
3. 记得dist和h初始化

void djstl2()
{
    memset(dist, 0x3f, sizeof(dist));
  
    priority_queue < PII, vector<PII>, greater<PII> > heap;
    heap.push({ 0,1 });
    dist[1] = 0;

    while (heap.size())
    {
        PII t = heap.top();
        heap.pop();

        if (st[t.second])continue;

        st[t.second] = 1;

        for (int i = h[t.second]; i != -1; i = ne[i])
        {
            int y = e[i];
            if (dist[t.second] + w[i] < dist[y])
            {
                dist[y] = dist[t.second] + w[i];
                heap.push({ dist[y],y });

            }
        }


    }

}

bellman-ford算法(有边(步)数限制的最短路算法)(正权负权都行)

本质是k次松弛操作(要求k步之内走到目的地)
不一定是从1走到n,任意两个点之间都可以,把起点dist设成0,k次松弛之后,如果终点dist还是无穷,就不可达
一般用结构体存边即可

struct BIAN
{
	int a, b, c;

}bian[N];

int bellmanford()
{
	memset(dist, 0x3f, sizeof(dist));
	dist[1] = 0;
	for (int i = 1; i <= k; i++)
	{
	    memcpy(back,dist,sizeof(dist));
	
		for (int j = 1; j <= m; j++)
		{
				auto t = bian[j];
			dist[t.b] = min( back[t.a]+t.c, dist[t.b]);
		}
	}
	return dist[n];
}

spfa算法求最短路(负权)

一般用于求最短路以及判断负权回路是否存在
算法思想:是bellmanford算法的优化,只有当这个点的dist被更新,才会接着放到队列中接着用来其他点
==st数组代表当前点是否在队列中(因为某一个点可能反复被更新而导致重复放到队列里)

void spfa()
{
  deque<int> q;
  q.push_back(1);
  dist[1] =0;
  st[1] = 1;
  while(q.size())
  {
      int t  = q.front();
      q.pop_front();
      st[t] = 0;
      for(int i = h[t];i !=-1;i = ne[i])
      {
          int k = e[i];
         
          if(dist[t]+w[i]<dist[k])
          {
              dist[k]  = dist[t]+w[i];
              if(st[k]==0)
              {
              q.push_back(k);
              st[k] =1;
              }
          }
      }
  }
  
}

spfa判断负环

算法核心点:

1. 用虚拟原点来理解spfa算法,假设出一个虚拟点,距离所有点的距离是0,dist[i]就是虚拟点到这个点的距离
2. 用cnt[i]数组记录虚拟点到这个点的最短路径中有几条边,如果大于等于n就说明有负环
3. 一开始要把所有的点都加入到队列中去,因为可能一开始图不连通

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 2010, M = 10010;

int n, m;
int h[N], w[M], e[M], ne[M], idx;
int dist[N], cnt[N];
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

bool spfa()
{
    queue<int> q;

    for (int i = 1; i <= n; i ++ )
    {
        st[i] = true;
        q.push(i);
    }

    while (q.size())
    {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;

                if (cnt[j] >= n) return true;
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    if (spfa()) puts("Yes");
    else puts("No");

    return 0;
}