Floyed算法::
//O(n^3)
const int N = 100;
int nn[N][N];
void floyed(int n)
{
int k,i,j;
for(k=1;k<=n;k++)
{
for(i=1;i<=n;i++)
{
if(i != k)
{
for(j=1;j<=n;j++)
{
if(i!=j && j!=k && nn[i][j]>nn[i][k]+nn[k][j])
nn[i][j] = nn[i][k]+nn[k][j];
}
}
}
}
}
Dijkstra算法::
//O(n^2)
//可堆优化与临阶表优化
const int INF = 0x3f3f3f3f;
const int N = 105;
int nn[N][N];
int dis[N]; //距离
int pre[N]=0; //路径
void dijkstra(int h)
{
memset(dis,0x3f,sizeof(dis));
int i,j;
bool bj[N] = {0};
for(i=1;i<=N;i++)
{
dis[i] = nn[h][i];
if(dis[i] < INF)
pre[i] = h;
}
dis[h] = 0;
bj[h] = 1;
for(i=2;i<=N;i++)
{
int mi = INF;
int no;
for(j=1;j<=N;j++)
{
if(!bj[j] && dis[j]<mi)
{
no = j;
mi = dis[j];
}
}
bj[no] = 1;
for(j=1;j<=N;j++)
{
if(!bj[j] && nn[no][j]<INF && dis[no]+nn[no][j]<dis[j])
{
dis[j] = dis[no]+nn[no][j];
pre[j] = no;
}
}
}
}
Bellman-Ford算法::
//O(ne)
const int INF = 0x3f3f3f3f;
const int N = 105;
int dis[N];
struct edge{
int u,v;
int l; //cost
edge(int _u=0,int _v=0,int _l=0):n(_u),v(_v),l(_l) {};
};
vector<edge> es;
bool bellman_ford(int h)
{
int i,j;
memset(dis,0x3f,sizeof(dis));
dis[h] = 0;
for(i=1;i<N;i++)
{
bool bj=0;
for(j=0;j<es.size();j++)
{
int u,v,l;
u = es[j].u;
v = es[j].v;
l = es[j].l;
if(dis[v] > dis[u]+l)
{
dis[v] = dis[u]+l;
bj = 1;
}
}
if(!bj)
return 1;
}
for(i=0;i<es.size();i++)
{
if(dis[es[j].v] > dis[es[j].u]+es[j].l)
return 0;
}
return 1;
}
SPFA 算法::
//O(KE) K是常数
const int INF = 0x3f3f3f3f;
const int N=1010;
struct node{
int v,w;
node(int _v=0,int _w=0) : v(_v),w(_w) {}
};
vector<node> nn[N];
int dis[N],vis[N];
void SPFA(int u,int v)
{
queue<int> qu;
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
qu.push(u);
dis[u] = 0;
vis[u] = 1;
while(!qu.empty())
{
int no = qu.front();
qu.pop();
vis[no] = 0;
for(i=0;i<nn[no].size();i++)
{
if(dis[no]+nn[no][i].w < dis[nn[no][i].v])
{
dis[nn[no][i].v] = dis[no]+nn[no][i].w;
if(vis[nn[no][i].v] == 0)
{
qu.push(nn[no][i].v);
vis[nn[no][i].v] = 1;
}
}
}
}
}