最短路 Dijkstra

Dijkstra 单源最短路 邻接矩阵形式

/*
*单源最短路径，Dijkstra算法，邻接矩阵形式，复杂度为o(n^2)
*求出源beg到所有点的最短路径，传入图的顶点数和邻接矩阵cost[][]
*返回各点的最短路径lowcost[]，路径pre[]，pre[i]记录beg到i路径上的父节点，pre[beg]=-1；
*可更改路径权类型，但是权值必须为非负，下表0~n-1
*/‘
const int MAXN=1010;
const int INF=0x3f3f3f3f;
bool vis[MAXN];
int pre[MAXN];

void Dijkstra(int cost[][MAXN],int lowcost[],int n,int beg)
{
    for(int i=0;i

Dijkstra单源最短路 邻接矩阵形式 双路径信息

/*
*单源最短路径，dijkstra算法，邻接矩阵形式，复杂度为o(n^2)
*两点间距离存入map[][]，两点间花费存入cost[][]
*求出源st到所有点的最短路径及其对应最小花费
*返回各点的最短路径lowdis[]以及对应的最小花费lowval[]
*可更改路径权类型，但是权值必须为非负，下标1~n
*/
const int MAXN=1010;
const int INF=0x3f3f3f3f;

int n,m;

int lowdis[MAXN];
int lowval[MAXN];
int visit[MAXN];
int map[MAXN][MAXN];
int cost[MAXN][MAXN];

void dijkstra(int st)
{
    int temp=0;
    for(int i=1;i<=n;i++)
    {
        lowdis[i]=map[st][i];
        lowval[i]=cost[st][i];
    }
    memset(visit,0,sizeof(visit));
    visit[st]=1;
    for(int i=1;ilowdis[temp]+map[temp][j])
                {
                    lowdis[j]=lowdis[temp]+map[temp][j];
                    lowval[j]=lowval[temp]+cost[temp][j];
                }
                else if(lowdis[j]==lowdis[temp]+map[temp[j])
                {
                    if(lowval[j]>lowval[temp]+cost[temp][j])
                    {
                        lowval[j]=lowval[temp]+cost[temp][j];
                    }
                }
                    
            }
        }
    }
    return;
        
}

Dijkstra起点Start结点有权值

#define M 505
const int inf=0x3f3f3f3f;
int num[M];    //结点权值
int map[M][M];  //图的临近矩阵
int vis[M];     //结点是否处理过
int ans[M];     //最短路径结点权值和
int dis[M];     //各点最短路径花费
int n,m,Start,End;    //n结点数，m边数，Start起点,End 终点

void Dij(int v)
{
    ans[v]=num[v];
    memset(vis,0,sizeof(vis));
    for(int i=0;imap[u][k]+dis[u])
            {
                dis[k]=map[u][k]+dis[u];
                ans[k]=ans[u]+num[k];
            }
        }
        for(int k=0;kz)
        {
            map[x][y]=z;
            map[y][x]=z;
        }
    }
    Dij(Start);
    return 0;
}