bellman_ford+spfa

bellman_ford

有边数限制的最短路径

它的存边方式就比较随意了，可以随便存，只要能遍历到所有的边就行，也就是可以用结构体直接进行存储
如果有负权回路的话，最短路不一定存在，比如如果负权回路虽然存在，但是，这个负权回路无法到达终点，这种情况最短路还是存在的, 但是如果在最短路上的话，这个最短路就是不存在的
spfa要求图中不能有负环

思路就是两个循环，先循环要走过多少个边（最多就是n-1个，因为最短路最多就是n-1个），再循环所有的边，就是每次都看一下每边能更新什么就更新什么，但是都要是用上一条边更新之后的结果，所以要出现一个backup数组

#include 
using namespace std;

#define int long long

const int N = 510;

int backup[N],dist[N];
struct node
{
    int a, b, w;
    
}r[10010];
int n, m, k;


void bellman_ford()
{
    dist[1] = 0;
    for(int i=1; i<=k; i++)
    {
        memcpy(backup, dist, sizeof dist);
        for(int j=1; j<=m; j++)
        {
            int a = r[j].a;
            int b = r[j].b;
            int w = r[j].w;
            
            // cout << a << b << w<
            
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
    // if(dist[n] > 0x3f3f3f3f3f3f3f3f / 2) return -1;
    // return dist[n];
}

signed main()
{
    memset(dist, 0x3f, sizeof dist);
    
    cin>>n>>m>>k;
    // cout << n << m << k<
    int a, b, c;
    for (int i = 1; i <= m; i ++ )
    {
        cin>>a>>b>>c;
        // cout << a << b << c<
        r[i]= {a, b, c};
    }
    
    bellman_ford();
    
    if(dist[n] > 0x3f3f3f3f3f3f3f3f / 2) cout << "impossible" << endl;
    else cout << dist[n] << endl;
    return 0;
}

spfa

最短路

spfa求最短路

spfa算法中，存储更新了的点的数据结构，可以是队列，可以说堆，可以是优先队列，这都可以
spfa虽然会被卡成nm，但是很常用，卡了再换嘛

感觉spfa的思想就是，我直接存边，然后开始从第一个点开始循环，先更新跟起始点联通的点，然后就继续，把更新过的点放进队列，如果队列不空，就用这些更新过的点，再更新其他点

原理大概就是，看一下BF算法，它dist[b] = min(dist[b], backup[a] + w);里面只有dist[a]被更新过，dist[b]才会被更新

#include 
using namespace std;

#define int long long
#define PII pair
#define x first
#define y second
#define endl '\n'
const int N = 1e5 + 10;
vector<PII> v[N];
int dist[N], st[N];
int n, m, k, a, b, c;
void spfa()  // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
{
    
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    st[1] = 1;
    
    while(!q.empty())
    {
        int num = q.front();
        q.pop();
        st[num] = 0;
        for(auto i : v[num])
        {
            if(dist[i.x] > dist[num] + i.y)
            {
                dist[i.x] = dist[num] + i.y;
                if(!st[i.x])
                {
                    q.push(i.x);
                    st[i.x] = 1;
                }
                
            }
        }
    }
   
}

signed main()
{
    cin >> n >> m;
    
    for(int i=1; i<=m; i++)
    {
        cin >> a >> b >> c;
        v[a].push_back({b, c});
    }
    spfa();
    
    if (dist[n] == 0x3f3f3f3f3f3f3f3f) puts("impossible");
    else cout << dist[n] << endl;;
    
    return 0;
}

判负环

spafa判负环

思路大概就是用spfa求最短路，用cnt数组记录一下，从起点到终点最短路上经过的边数，如果有n个边，就需要有n+1个点，然后根据抽屉原理，一定有一个点相同。就形成了一个环。

但是这里跟spfa又不太一样，这里的dist数组不需要初始化，因为判断的是负环，所以0作为初始值，也可以进行更新

#include 
#include 
#include 
#include 
#include 

using namespace std;

#define int long long
#define x first
#define y second

const int N = 2010, M = 1e4 + 10;
int n, m, a, b, c;
bool st[N];
#define PII pair
vector<PII> v[N];
int dist[N], cnt[N];
bool spfa()  // 如果存在负环，则返回true，否则返回false。
{

    queue<int> q;
     
    for (int i = 1; i <= n; i ++ ) q.push(i), st[i] = true;
    
    while (!q.empty())
    {
       int t = q.front();
       q.pop();
       
       st[t] = false;
       
       for (auto i : v[t])
       {
           if(dist[i.x] > dist[t] + i.y)
           {
               dist[i.x] = dist[t] + i.y;
               cnt[i.x] = cnt[t] + 1;
               if(cnt[i.x] >= n) return 1;
               
               if(!st[i.x])
               {
                   q.push(i.x);
                   st[i.x];
               }
           }
       }
    }
    
    return false;
}


signed main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i ++ )
    {
        cin >> a >> b >> c;
        
        v[a].push_back({b, c});
    }
    
    if(spfa()) cout << "Yes" << endl;
    else cout << "No" << endl;
    return 0; 
}