次短路问题

求最短路和次短路的数量（次短路严格大于最短路）：

dijkstra算法，将状态扩展到二维：用d[u][0]记录节点最短路，d[u][1]记录节点次短路,cnt[u][0]记录节点最短路数量，cnt[u][1]记录节点次短路数量，vis[u][0]记录该点最短路是否确定，vis[u][1]记录该点次短路是否已经确定；

找出新的节点的最短路和次短路（即还没有确定的节点中最小的d[u][0],d[u][1]）；

更新（与u相关的节点的最短路、次短路信息）

1、如果通过u得到的路径小于节点原来的最短路，则更新最短路、次短路信息；

2、如果通过u得到的路径等于节点原来的最短路，则更新最短路方法数；

3、如果通过u得到的路径小于节点原来的次短路，则更新次短路信息；

4、如果通过u得到的路径小于节点原来的次短路，则更新次短路方法数；

注意：这4 个更新顺序是不能条换的，且只要某一个成立就不在往下更新；

循环：循环次数应该为2*n-1（最短路的n-1次循环和此短路的n次循环）

poj3463次短路模板题目（每条边、每个节点只能走一次）；

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<cctype>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<string>
#include<set>
#include<map>
#include<stack>
#define ll long long
#define MAX 1010
#define INF 2000000000
#define eps 1e-8

using namespace std;

struct Edge{
int from, to,dist;
};

vector<int>G[MAX];
vector<Edge>edges;

int n;

void init(){
for (int i=0; i<=n; i++) G[i].clear();
edges.clear();
}

void addEdge(int from, int to, int dist){
edges.push_back((Edge){from,to,dist});
int k = edges.size();
G[from].push_back(k-1);
}

int dijkstra(int s, int t){
int vis[MAX][2],d[MAX][2],cnt[MAX][2];
memset(vis,0,sizeof(vis));
memset(cnt,0,sizeof(cnt));
for (int i=0; i<n; i++){
d[i][0] = d[i][1] = INF;
}
d[s][0] = 0;
cnt[s][0] = 1;
for (int i=0; i<2*n-1; i++){
int minn = INF,flag,k;   //得到新的最短路、此短路，并记下该点信息；
for (int j=0; j<n; j++){
if (!vis[j][0] && d[j][0] < minn){
minn = d[j][0];
flag = 0;
k = j;
}
else if (!vis[j][1] && d[j][1] < minn){
minn = d[j][1];
flag = 1;
k = j;
}
}
if (minn >= INF) break;
vis[k][flag] = 1;
for (int j = 0; j<G[k].size(); j++){      //更新与之相邻的节点信息（最短路，次短路）
Edge e = edges[G[k][j]];
if (d[e.to][0] > minn + e.dist){
d[e.to][1] = d[e.to][0];
cnt[e.to][1] = cnt[e.to][0];
d[e.to][0] = minn + e.dist;
cnt[e.to][0] = cnt[k][flag];
}
else if (d[e.to][0] == minn + e.dist){
cnt[e.to][0] += cnt[k][flag];
}
else if (d[e.to][1] > minn + e.dist){
d[e.to][1] = minn + e.dist;
cnt[e.to][1] = cnt[k][flag];
}
else if (d[e.to][1] == minn + e.dist){
cnt[e.to][1] += cnt[k][flag];
}
}
}
if (d[t][1] == d[t][0] + 1){
cnt[t][0] += cnt[t][1];
}
return cnt[t][0];
}

int main(){
int T,m;
scanf("%d",&T);
while (T--){
init();
scanf("%d%d",&n,&m);
int x,y,z;
for (int i=0; i<m; i++){
scanf("%d%d%d",&x,&y,&z);
x--;
y--;
addEdge(x,y,z);
}
int s,t;
scanf("%d%d",&s,&t);
s--;
t--;
printf("%d\n",dijkstra(s,t));
}
return 0;
}

求此短路的长度（每条边、每个节点可以走多次）：

此短路如果存在，就一定会是最短路上某一条边不走，而走了其它边再回到最短路上；

求解思路：

分别对起点和终点求一次单源最短路ds[i],dt[i]，枚举所有的边（u，v），求出ds[u] + dt[v] + dist[u][v] 大于最短路 中最小的一个值，即为此段路值。

poj3255 求此短路模板题；（此题与上题不同的地方在于每条边、每个节点可以走多次；）

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<cctype>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<stack>
#define ll long long
#define MAX 10000
#define MAXN 1000000
#define INF 100000000
#define eps 1e-8

using namespace std;

struct Edge{
int from ,to, dist;
};

struct Node{
int num,w;
bool operator < (const Node& rhs) const{
return rhs.w < w;
}
};

int first[MAX],next[MAXN];
vector<Edge>edges;

int n;

void init(){
memset(first,-1,sizeof(first));
memset(next,-1,sizeof(next));
edges.clear();
}

void addEdge(int from, int to, int dist){
edges.push_back((Edge){from,to,dist});
int k = edges.size();
next[k-1] = first[from];
first[from] = k-1;
}

int d[MAX][2];

void dijkstra(int s, int t, int flag){
int vis[MAX];
priority_queue<Node>q;
memset(vis,0,sizeof(vis));
for (int i=0; i<n; i++) d[i][flag] = (i == s ? 0 : INF);
q.push((Node){s,0});
while (!q.empty()){
Node temp = q.top();
q.pop();
int u = temp.num;
if (vis[u]) continue;
vis[u] = 1;
for (int i = first[u]; i != -1; i = next[i]){
Edge e = edges[i];
if (!vis[e.to]){
d[e.to][flag] = min(d[e.to][flag], d[u][flag] + e.dist);
q.push((Node){e.to,d[e.to][flag]});
}
}
}
}

int main(){
int m;
while (scanf("%d%d",&n,&m) != EOF){
int x,y,z;
init();
for (int i=0; i<m; i++){
scanf("%d%d%d",&x,&y,&z);
x--;
y--;
addEdge(x,y,z);
addEdge(y,x,z);
}
dijkstra(0,n-1,0);
dijkstra(n-1,0,1);
int ans = INF;
for (int i=0; i<edges.size(); i++){
int u = edges[i].from;
int v = edges[i].to;
if (d[u][0] + d[v][1] + edges[i].dist > d[n-1][0]){
ans = min(ans,d[u][0] + d[v][1] + edges[i].dist);
}
}
printf("%d\n",ans);
}
}