最短路入门合辑（附模板代码及水题）

于 2019-08-28 18:03:38 发布
阅读量258 收藏
点赞数
文章标签： 最短路 差分约束 入门 水题 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43408978/article/details/99690151
版权

最短路

大致题意：求一个点到另一个点的最短距离
解法：Floyd、Dijkstra、Bellman-ford、Spfa
关键名词：
1、源：

可以理解为图的起点，很好理解，就像是一条流水线的源头。

2、有向和无向

有向就是这个图的方向是固定的，只能从这边到那边，那边过不来，无向就是方向不固定。

3、权值、负权值、负圈：

权值：边的距离， 负权值：边权是负的，负圈：图中的一个环，边权全部为负边权。

4、重边

相同的边，就比如 1->2 权值为3，数据中又出现 1->2 权值为4。

5、松弛：

先给出一张无向图
一张无向图
城市1到城市2有一条路长为10
城市1到城市3有一条路长为2
城市2到城市3有一条路长为3
现在要问城市1到城市2的最短距离是多少？
显然…答案是5，肉眼可以轻易看出来，但如果图一复杂，这种问题还是交给代码解决来的高效。
专业术语解这题 ：
源是1，用dis[i]表示源到各点的最短距离，ma[i][j]表示城市i到城市j的距离。
初始时：dis[1] = 0; dis[2] = 10; dis[3] = 2；
ma[1][2] = ma[2][1] = 10; ma[1][3] = ma[3][1] = 2;
ma[2][3] = ma[3][2] = 3;
我们的目标是更新这个dis数组，让它成为真正的最短路径。暴力枚举后会找到一个式子dis[2] > dis[3] + ma[3][2]，则更改dis[2] = dis[3] + ma[3][2],这一步，就是松弛。

在下列算法中宏定义V为点的数量，E为边的数量。
Floyd算法：多源、可以负边权、无负圈，时间复杂度V3 ，时间复杂度V2

这个算法就是直接把ma这个数组里的数据作为最短路径去松弛。
以hdu2544为例

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define pii pair<int, int>
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 103;
const int INF = 0x3f3f3f3f; //相当于正无穷
int ma[N][N];  //i->j最短路径
int n, m;   //点数、边数
int main() {
  int u, v, w; // u - v 权值为w
  while(scanf("%d%d", &n, &m), n+m) {
    memset(ma, INF, sizeof(ma));
    while(m--) {
      read(u); read(v); read(w);
      if(w < ma[u][v])  //防止有重边
        ma[u][v] = ma[v][u] = w;
    }
    //开始暴力枚举，这里复杂度极高，后续算法大多是对这里进行优化
    for(int k = 1; k <= n; ++k) {
      for(int i = 1; i <= n; ++i) {
        if(ma[i][k] == INF) continue; //剪枝
        for(int j = 1; j <= n; ++j) {
          if(ma[i][j] > ma[i][k] + ma[k][j]) {  //松弛
            ma[i][j] = ma[i][k] + ma[k][j];
          }
          //ma[i][j] = min(ma[i][j], ma[i][k] + ma[k][j]);
        }
      }
    }
    printf("%d\n", ma[1][n]);
  }
	return 0;
}

这个算法的优越性在于，它是多源的，并且可以处理无向图的最小环问题，大概就是在一个无向图中找出最小环的价值这样，对于松弛过的点，如果还能进行松弛就表示有环，运用这个特点，找最小环 。
以hdu1599为例

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define pii pair<int, int>
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 110;
const int INF = 2e6; //因为爆精疯狂WA,调小一点
int mincycle, sum, n, m, dis[N][N], ma[N][N];
/* 
mincycle表示最小环的价值，sum表示最小环的数量（跟这题没啥关系），n表示点数，m表示边数，
dis[i][j]表示i->j的最短路，ma存图
*/
void floyd() {
  mincycle = INF;
  for(int k = 1; k <= n; ++k) {
    for(int i = 1; i < k; ++i)   //更新最小环，以及更新最小环数量
      for(int j = i+1; j < k; ++j) {
        if(mincycle > dis[i][j] + ma[i][k] + ma[k][j])
          { mincycle = dis[i][j] + ma[i][k] + ma[k][j]; sum = 1; }
        else if(mincycle == dis[i][j] + ma[i][k] + ma[k][j]) sum++;
      }
    for(int i = 1; i <= n; ++i)   //路径还是要松弛的嘛
      for(int j = 1; j <= n; ++j)
        dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
  }
}
int main() {
  int u, v, w;
  while(~scanf("%d%d", &n, &m)) {
    for(int i = 1; i <= n; ++i)  //初始化
      for(int j = 1; j <= n; ++j)
        ma[i][j] = dis[i][j] = INF;
    while(m--) {
      read(u); read(v); read(w);
      if(w < ma[u][v])   //防止重边
        ma[u][v] = ma[v][u] = dis[u][v] = dis[v][u] = w;
    }
    floyd();
    if(mincycle < INF) printf("%d\n", mincycle);
    else puts("It's impossible.");
  }
	return 0;
}
dijkstra算法：单源，无负边权，时间复杂度是V2及以下，空间的话看具体优化。

这个算法需要用到dis数组，这个算法相对于上一个算法的优化就是，暴力枚举的时候每次选取dis值最小的点，而不是暴力枚举k，这样可以将其降到V2。
邻接矩阵（针对边多点少的情况）实现：以hdu2544为例

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define pii pair<int, int>
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 1e3;
const int INF = 0x3f3f3f3f;
int ma[N][N], n;
int dis[N], vis[N];
//dis表示从起点到各个点的最短路，dis[i]表示s->i的最短路
//vis记录该点是否已经被松弛
void dij() {
	int m = INF, mi;
	for(int i = 1; i <= n; i++) {   //先初始化dis数组
		dis[i] = ma[1][i]; vis[i] = 0;    //把dis中的值赋值为起点练得所有边的权值
	}
	dis[1] = 0; vis[1] = 1;
	for(int j = 1; j <= n; j++) {  //表示每个点都需要被松弛
		m = INF;   //初始化最小值
		for(int i = 1; i <= n; i++) {
			if(!vis[i] && dis[i] < m) {
			//如果这个点没有被松弛，且这个点是以s为起点最小的
				m = dis[i];  //就把找到的最小值的路径长赋值为该点
				mi = i;   //记录下该点是哪个点
			}
		}
		vis[mi] = 1;  //表示该点已经被松弛
		for(int i = 1; i <= n; i++) {
			if(!vis[i] && m + ma[mi][i] < dis[i]) { //若这个点没有松弛过且可以松弛
			//如果最小值+以该最小值点为起点的路径长是不是小于以s为起点的路径长
				dis[i] = m + ma[mi][i];
			//更新dis数组
			}
		}
	}
}
int main() {
    int m, u, v, w;
    while(scanf("%d%d", &n, &m), (n + m)) {
    memset(ma, INF, sizeof(ma));
    while(m--) {
      read(u); read(v); read(w);
      if(w < ma[u][v])  //防止有重边
        ma[u][v] = ma[v][u] = w; //无向边
    }
    dij();
    printf("%d\n", dis[n]);
	}
	return 0;
}

优先队列+结构体（针对点多边少的情况）实现：以hdu2544为例

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define pii pair<int, int>  //dis, i
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 103;
const int INF = 0x3f3f3f3f;
int n, m;
struct xx {
  int to, cost; 
};
int dis[N], vis[N];
vector<xx> v[N];   
// v[i].to与v[i].cost分别表示 i -> to 这个点有一条边，花费为cost;
void dij() {
  priority_queue< pii, vector<pii>, greater<pii> > q;  //按照first升序排序
  while(!q.empty()) q.pop();
  dis[1] = 0; q.push(pii{0, 1});
  //初始化列表方法把起始点放进优先队列
  while(!q.empty()) {
  //用一个优先队列存{dis[i], i} == s->i的距离  与  i
    pii pp = q.top(); q.pop();
    int vv = pp.second;  //pp.second 表示当前需要松弛的点
    if(vis[vv]) continue;  //如果该点已被松弛， 循环继续
    vis[vv] = 1;  //松弛前把该点 标记为已被松弛
    for(int i = 0; i < v[vv].size(); i++) {        // 松弛过程
      dis[v[vv][i].to] = min(dis[v[vv][i].to], v[vv][i].cost + dis[vv]);
      q.push(pii{dis[v[vv][i].to], v[vv][i].to});
    }
  }
}
int main() {
  int a, b, c;
  while(scanf("%d%d", &n, &m), n+m) {
    for(int i = 1; i <= n; ++i) {    //跟邻接矩阵第一步相同，初始化dis数组
      v[i].clear(); dis[i] = INF; vis[i] = 0;
    }
    while(m--) {
      read(a); read(b); read(c);
      v[a].push_back({b, c});
      v[b].push_back({a, c});
    }
    dij();
    printf("%d\n", dis[n]);
  }
  return 0;
}

优先队列+链式前向星优化：这个做法比较常用，是一个较优的算法，首先，前向星存图的方法，贴一个比较好理解一点的博客：链式前向星存图，以hdu2544为例

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define pii pair<int, int>
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int M = 1e4+4;
const int N = 103;
const int INF = 0x3f3f3f3f;
int n, m, s, t, cnt;
struct xx {
  int next, to, w;
}edge[M];
//前向星存边的结构体
int vis[N], dis[N], head[N];
// vis常规记录该点是否已经松弛，dis常规记录源点到其他各点的距离，head是前向星存图的核心
priority_queue<pii, vector<pii>, greater<pii> > pq;
//优先队列优化
pii cur;
//松弛时简化代码使用
void add(int u, int v, int w) {
  edge[cnt].w = w;
  edge[cnt].to = v;
  edge[cnt].next = head[u];
  head[u] = cnt++;
}
//前向星加边
void dij() {
  for(int i = 1; i <= n; ++i) { dis[i] = INF; vis[i] = 0; }
  dis[1] = 0;
  while(!pq.empty()) pq.pop();
  pq.push(pii(dis[1], 1));
  //常规初始化
  while(!pq.empty()) {
    cur = pq.top();
    pq.pop();
    if(vis[cur.second]) continue; //如果已经松弛过，跳过
    vis[cur.second] = 1;
    for(int i = head[cur.second]; i; i = edge[i].next) {  //前向星访问边的基本形式
      if(dis[edge[i].to] > cur.first + edge[i].w) {  //松弛
        dis[edge[i].to] = cur.first + edge[i].w;
        pq.push(pii (dis[edge[i].to], edge[i].to));  //入队
      }
    }
  }
}
int main() {
  int u, v, w;
  while(scanf("%d%d", &n, &m), n + m) {
    cnt = 1;
    memset(head, 0, sizeof(head));
    for(int i = 1; i <= m; ++i) {
      read(u); read(v); read(w);
      add(u, v, w); add(v, u, w); //无向图存边形式
    }
    dij();
    printf("%d\n", dis[n]);
  }
	return 0;
}
Bellman-Ford算法：单源，可以判断负环，时间复杂度VE。

这里实现一下打印路径，用一个pre数组保存当前节点的上一个节点，最后打印的时候用一个栈维护，比较好理解，代码量也很少。以hdu1224为例，嗯…然后我为了体现这个算法的突出之处，把板子总结了一下，所以这当中有个判断负环的步骤对这题是没用的。

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 103;
const int INF = 0x3f3f3f3f;
struct xx {
  int u, v, w;
}edge[N*N];
//结构体存边的形式实现，当然也可以用链式前向星实现...后续会提到
int n, m, a[N], dis[N], pre[N];
//点数，边数，a数组存每个城市的满足点，dis还是常规源点到各点的最短路，pre记录了当前节点的上一个节点。
int cnt, t;
//这个是为了题目要求的格式化..因为这个还P了一发
bool bellman_ford() {
  bool f; int ok;
  //f为了判断负环使用，ok是剪枝使用
  for(int i = 1; i <= n + 1; ++i) dis[i] = -INF, pre[i] = 0;
  dis[1] = 0; pre[1] = 1;
  //常规初始化，让起点的pre值为自己
  for(int i = 1; i <= n; ++i) { //每个点都要松弛一次
    ok = 1;
    for(int j = 1; j <= m; ++j) {  //遍历边的形式
      if(dis[edge[j].v] < dis[edge[j].u] + edge[j].w) { //松弛
        dis[edge[j].v] = dis[edge[j].u] + edge[j].w;
        pre[edge[j].v] = edge[j].u;
        ok = 0;
      }
    }
    if(ok) break; //如果当前没有边可以让点松弛，剪枝
  }
  f = 1;  //这里在判断负环，跟floyd方法类似
  for(int i = 1; i <= m; ++i) {
    if(dis[edge[i].v] < dis[edge[i].u] + edge[i].w) {
      f = 0; break;
    }
  }
  return f;
}
//打印路径
void Print(int root) {
  printf("CASE %d#\n", ++cnt);
  printf("points : %d\n", dis[n+1]);
  printf("circuit : ");
  if(root == 2) printf("1\n");
  else {
    stack<int> sk; //用栈维护
    while(!sk.empty()) sk.pop();
    while(root != pre[root]) {
      sk.push(root);
      root = pre[root];
    }
    if(root == pre[root]) sk.push(root);
    while(sk.size() > 1) { printf("%d->", sk.top() == n + 1 ? 1 : sk.top()); sk.pop(); }
    if(sk.size() == 1) printf("%d\n", sk.top() == n + 1 ? 1 : sk.top());
    if(cnt < t) puts(""); //控制格式
  }
}
int main() {
  read(t);
  int u, v;
  for(int k = 1; k <= t; ++k) {
    read(n);
    for(int i = 1; i <= n; ++i) {
      read(a[i]);
    }
    a[n+1] = 0;
    read(m);
    for(int i = 1; i <= m; ++i) {
      read(u); read(v);
      if(u > v) swap(u, v);  //这里指定了只能从小节点城市向大节点城市旅游
      if(u == v) continue;
      edge[i].u = u; edge[i].v = v; edge[i].w = a[v];
    }
    bellman_ford();
    Print(n+1);
  }
  return 0;
}
spfa：单源，可以检测负圈，是Bellman-Ford的队列优化，不稳定，时间复杂度kE （k << V），不过最坏的情况还是会到达VE，只是大大优化了Bellman-Ford的复杂度

这个！我见过的最多！其次就是Dijsktra！
这里实现我用了前向星优化，以hdu2544为例

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 103;
const int INF = 0x3f3f3f3f;
struct Node {     //前向星结构体
  int to, next, w;
  //to 表示v， next里面跟u相同的边有关，w是u，v的距离
}edge[N*N];
int vis[N], outqueue[N], head[N], dis[N];
//outqueue关键是用来检测有没有负环出现，vis是常规操作，防止重复推进队列，标记..，head[i]是前向星中u = i这个点存在的最后一条边
int n, m, cnt;
void add(int u, int v, int w) {   //前向星关键
  edge[cnt].w = w;
  edge[cnt].to = v;
  edge[cnt].next = head[u];
  head[u] = cnt++;
}
bool spfa() {
  for(int i = 1; i <= n; ++i) {
    dis[i] = INF; vis[i] = 0;
  }
  dis[1] = 0; vis[1] = 1;
  queue <int> q;
  q.push(1);
  int cur;
  while(!q.empty()) {
    cur = q.front();
    q.pop();
    vis[cur] = 0; outqueue[cur]++;
    if(outqueue[cur] > n) return false; // 负环出现
    for(int i = head[cur]; i; i = edge[i].next) {  //前向星的循环方式
      if(dis[edge[i].to] > dis[cur] + edge[i].w) {  //松弛
        dis[edge[i].to] = dis[cur] + edge[i].w;
        if(!vis[edge[i].to]) {
          vis[edge[i].to] = 1; q.push(edge[i].to);
        }
      }
    }
  }
  return true;
}
int main() {
  int u, v, w;
  while(scanf("%d%d", &n, &m), n + m) {
    memset(head, -1, sizeof(head));
    memset(outqueue, 0, sizeof(outqueue));
    cnt = 1;
    while(m--) {
      read(u); read(v); read(w);
      add(u, v, w);
      add(v, u, w); //无向图
    }
    if(spfa()) {
      printf("%d\n", dis[n]);
    } else printf("have negative circle\n"); //有负环，跟这题没有这种情况
  }
	return 0;
}

啊，终于填完了这个坑，但是！没有差分约束的最短路是不完整的，但是如果了解了最短路，差分约束很好理解。

差分约束

大致题意：给出几个不等式条件，要得到某个不等式条件

描述：有这样一组不等式
{ x 1 − x 2 ≤ y 1 x 2 − x 3 ≤ y 2 x 3 − x 4 ≤ y 3 ⋯ x i − x j ≤ y k \begin{cases} x_1-x_2\leq y_1\\ x_2-x_3\leq y_2 \\ x_3-x_4\leq y_3 \\ \cdots \\ x_i-x_j\leq y_k \end{cases} ⎩⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎧​x1​−x2​≤y1​x2​−x3​≤y2​x3​−x4​≤y3​⋯xi​−xj​≤yk​​
要根据这些关系计算出 x n − x 1 ≤ ? x_n-x1\leq ? xn​−x1≤?
这样的问题可以转化为最短路方法解决，看到这些不等式，有没有想起来最短路里面的松弛，最简单的差分约束，就是一个三角形了，两边之和一定大于第三边，可以转化为上述的等式。目前制作过差分约束的水题，只要找到不等式，建边求最短路或者最长路就可以完成这道题了。
一般有两种形式，一种是像上面的<=，还有一种是>=。
<= ：建边方式 x2->x1建立一条边权为y1的边，x3->x2建立一条边权为y2的边…xj->xi建立一条边权为yk的边，然后用这些边去求x1->xn的最短路。
>= ：建边方式 x2->x1建立一条边权为y1的边，x3->x2建立一条边权为y2的边…xj->xi建立一条边权为yk的边，然后用这些边去求x1->xn的最长路。
以及有时候会出现既有>=号又有<=号的情况，看问题是要求啥，可以进行相应的转换，例如 4-3>=1 可以转化为 3-4<=-1，所以大部分差分约束问题都是用spfa解决的，因为可能包含负边权。
以hdu1384为例
这题就可以转化为差分约束来求解

#include<bits/stdc++.h>
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define pii pair<int, int>
using namespace std;
typedef long long ll;
template<class T>
void read(T &res) {
  int f = 1; res = 0;
  char c = getchar();
  while(c < '0' || c > '9') { if(c == '-') f = -1; c = getchar(); }
  while(c >= '0' && c <= '9') { res = res * 10 + c - '0'; c = getchar(); }
  res *= f;
}
const int N = 2e5+5;
const int INF = 0x3f3f3f3f;
struct xx {
  int next, to, w;
}edge[N];
int n, cnt;
int vis[N], dis[N], head[N];
void add(int u, int v, int w) {
  edge[cnt].w = w;
  edge[cnt].to = v;
  edge[cnt].next = head[u];
  head[u] = cnt++;
}
//spfa方法求最短路
void spfa(int start, int ed) {
  memset(dis, -INF, sizeof(dis));
  memset(vis, 0, sizeof(vis));
  queue<int> pq;
  int cur;
  dis[start] = 0; vis[start] = 1;
  pq.push(start);
  while(!pq.empty()) {
    cur = pq.front();
    pq.pop();
    vis[cur] = 0;
    for(int i = head[cur]; ~i; i = edge[i].next) {
      if(dis[edge[i].to] < dis[cur] + edge[i].w) {
        dis[edge[i].to] = dis[cur] + edge[i].w;
        if(!vis[edge[i].to]) {
          vis[edge[i].to] = 1;
          pq.push(edge[i].to);
        }
      }
    }
  }
}
int main() {
  int u, v, w, mx, mi;
  while(~scanf("%d", &n)) {
    cnt = 1; mx = 0; mi = INF;
    memset(head, -1, sizeof(head));
    for(int i = 1; i <= n; ++i) {
      read(u); read(v); read(w);
      add(u, v+1, w);
      //列出不等式加边
      mx = max(mx, v+1); mi = min(mi, u);
    }
    for(int i = mi; i < mx; ++i) {
      add(i, i+1, 0); add(i+1, i, -1); 
      //这里是隐含条件，好好想想噢
    }
    spfa(mi, mx);
    printf("%d\n", dis[mx]);
  }
  return 0;
}
真·水题！都是hdu的 0.0

基础最短路系列：

  • 2544 最短路
  • 1548 A strange lift
  • 3790 最短路径问题
  • 2066 一个人的旅行
  • 2112 HDU Today
  • 1874 畅通工程续
  • 1217 Arbitrage
  • 1869 六度分离
  • 1690 Bus System
  • 2722 Here We Go(relians) Again
  • 1599 find the mincost route （floyd找最小环）
  • 1224 free DIY Tour（输出路径）

差分约束系列：

  • 1384 Intervals
  • 1531 King
  • 3440 House Man
  • 3592 World Exhibition

终于填完了这个坑，马上要开学了，内心是拒绝的，就不能让我多躺两天 ，还要继续努力鸭~

cornivores
关注
代码 基于最短路dijkstra算法离散优化问题代码
06-04
代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法离散优化问题代码代码 基于最短路dijkstra算法...
【最短路入门专题1】H - Frogger poj2253【dijkstra】
weixin_30745553的博客
08-07 118
Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on another stone. He plans to visit her, but since the water is dirty and full of tourists'...
最短路入门-- hd 2544【floyed+dijsktra】
thoughtspark的博客
08-20 207
最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 69975    Accepted Submission(s): 30571 Problem Description 在每年的校赛里，所有进入决赛的同学都
图论：HDU2544-最短路（最全、最经典的最短路入门及小结）
weixin_30732825的博客
07-18 159
最短路 Time Limit: 5000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 45288Accepted Submission(s): 19993 Problem Description 在每年的校赛...
最短路入门
pigesama的博客
03-11 162
今天早上看了一上午，总算是明白了一点最短路，大概思路应该是这样，我拿一道板子题来说：Bessie is out in the field and wants to get back to the barn to get as much sleep as possible before Farmer John wakes her for the morning milking. Bessie nee...
HDU 2544 最短路(最短路入门)
herongwei 的 BLOG
01-22 1342
HDU 2544 最短路(最短路入门)
最短路matlab代码.zip
07-11
在给定的标题"最短路matlab代码.zip"和描述中，我们可以推断这是一个使用MATLAB编写的解决最短路径问题的程序。MATLAB是一种强大的数学计算和编程环境，广泛用于科学研究和工程应用。 最短路问题通常出现在图论中，...
算法合集之《最短路算法及其应用》
02-26
总的来说，《最短路算法及其应用》文档将提供对这些算法的理论介绍、代码实现以及实例解析，帮助读者理解并掌握如何在MATLAB中应用这些工具来解决实际问题。通过学习，读者不仅能提升算法理解能力，还能增强编程实践...
最短路问题及MATLAB代码
08-06
最短路问题是一种在图论中的经典问题，广泛应用于网络优化、交通规划、通信网络设计等领域。它旨在寻找网络中的最短路径，使得从源节点到目标节点的总权重（通常表示距离、时间或成本）最小。在数学建模中，解决最...
算法文档无代码最短路算法及其应用
最新发布
04-15
关于无代码最短路算法及其应用的研究在计算机科学中是一个重要的领域，它涉及到图论、网络分析和算法优化等多个方面。最短路算法是图论中用于找出两个顶点之间距离最短路径的算法，它在诸如地图导航、通信网络、交通...
最短路（三种基础算法）
weixin_30697239的博客
05-10 130
蒟蒻最近在不断AK最短路 这篇博客就发一下最基础的三种做法（以后会发一篇升级版的） 1.大名鼎鼎的Floyd 2.Dijkstra 3.Bellman-Ford 就以这道题为例吧 （这道题数据苛（hen）刻（shui）,不过代码已用大数据测过，不要怀疑算法的准确性） 注：三种算法我写在了一起 #include<bits/stdc++.h> using nam...
图的最短路入门
Bell的博客
08-17 404
图的最短路入门 讲到图论，不得不提及信息学竞赛中最常考的最短路算法，最短路算法已经成为几乎每位选手都必会的算法了，本文将介绍3种最短路算法：Floyd,Dijkstra,SPFA 最短路 定义： 对在权图G=(V,E),从一个源点s到汇点t有很多路径，其中路径上权和最少的路径，称从s到t的最短路径。 比如给出这样一幅图G： v2v_2v2​到v5v_5v5​的最短路径就是v2⇒v4⇒v1⇒...
HDU 2544：最短路（ 最短路径入门 &&Dijkstra && floyd ）
TOKHE的专栏
07-26 895
最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 30972    Accepted Submission(s): 13345 Problem Description 在每年的校赛里，所有进入决赛的同学都会获
图论之最短路入门
Everything can be done!
09-04 486
最短路有很多算法： 现在我就对  Dijkstra  和 floyd 这两种算法讲一下； 这两种方法输出最短路径的时候都是利用pre数组，倒查的方法。 Dijkstra 是可以知道各个点到源点的最短距离的，是一个 dist [ ]数组记录的，时间复杂度为O(n^2)； 具体实现如下： 将图中所有的顶点V分成两个集合Va,Vb,如果源点到u的最短路径已经确定，则点u属于集合
最短路入门练习 解题报告
努力奋斗才能梦想成真
07-31 1528
题目链接 A - Frogger     给你若干个点，要求第一个点到第二个点的所有路径中最大边的最小值。        这种题目在以后会经常碰到，最大的最小，或是最小的最大，首先可以想到的方法是二分，但是这道题也有不用二分的方法，我这里就把两种都介绍下吧。        解法1：                假设你规定距离小于等于X的点之间才能通行，那么此时如果你还能从1走到2，说明
最短路水题大合集
Minacor-Mynarco
11-06 1030
题目一： Silver Cow Party 题意： 有N个农场 ， 每个农场一头牛 ， 现在他们要走到第X个农场去参加派对 ， 然后返回各自的农场。 然后有M条单向路 ， 每条路从A到B花费T 然后每头牛都会选择最短的路来走一个来回 求的是每头牛走的路中的最大值 思路： 图论水题 ， 很裸的最短路算法。 算法采用spfa ， 构造正反两个图 ， 我们知道如果从x点
最短路：从入门到劝退
DJ的博客
12-24 488
最短路：从入门到女装
解决最短路问题的算法解析与代码实现
在提供的代码片段中，可以看到一个Java程序的框架，它包含了可能用于实现最短路算法的数据结构和变量，如队列`q`用于优先级队列（在Dijkstra算法中常见），数组`d`存储每个顶点到起点的最短距离，以及邻接链表表示的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值