2021-8-2算法学习（算法笔记391-406）

一、Bellman-Ford算法

#include<bits/stdc++.h>
using namespace std;
const int maxv=100;
const int INF=1000000;
struct Node
{
    int v,dis;
};
int n;
vector<Node> Adj[maxv];
int d[maxv];
set<int> prev[maxv];
bool Bellman(int s)
{
    fill(d,d+maxv,INF);
    d[s]=0;

    for(int i=0;i<n-1;i++)
    {
        for(int u=0;u<n;u++)
        {
            for(int j=0;j<Adj[u].size();j++)
            {
                int v=Adj[u][j].v;
                int dis=Adj[u][j].dis;
                if(d[u]+dis<d[v])
                {
                    d[v]=d[u]+dis;
                }
            }
        }
    }
    
    for(int u=0;u<n;u++)
        {
            for(int j=0;j<Adj[u].size();j++)
            {
                int v=Adj[u][j].v;
                int dis=Adj[u][j].dis;
                if(d[u]+dis<d[v])
                {
                    return false;
                }
            }
        }
    return true;
}

二、Floyd算法——解决全源最短路问题

#include<bits/stdc++.h>
using namespace std;

const int INF=1000000;
const int maxv=200;
int n,m;
int dis[maxv][maxv];//初值都赋值为INF 然后输入图中数据  最后得到的结果就是i j两点间的最短路径

void Floyd()
{
    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(dis[i][k]!=INF&&dis[k][j]!=INF&&dis[i][k]+dis[k][j]<dis[i][j])
                {

                }
            }
        }
    }
}

三、最小生成树——prim算法

适合稠密图
O（V^2）

#include<bits/stdc++.h>
using namespace std;
const int maxn=100;
const int INF=100000;
int n,m;
bool vis[maxn]={false};
int G[maxn][maxn];
int d[maxn];


int prim() //默认0号为初始点，且返回最小生成树的边权之和
{
    fill(d,d+maxn,INF);
    d[0]=0;
    int ans=0;
    for(int i=0;i<n;i++)
    {
        int u=-1,min=INF;
        for(int j=0;j<n;j++)
        {
            if(d[j]<min&&vis[j]==false)
            {
                u=j;
                min=d[j];
            }
        }
        if(u==-1) return;
        vis[u]=true;
        ans+=d[u];
        for(int v=0;v<n;v++)
        {
            if(vis[v]==false&&G[u][v]!=INF&&G[u][v]<d[v])
            {
                d[v]=G[u][v];
            }
        }

        return ans;
    }

}