[原]最短路专题【基础篇】（updating...）

hud1548 a strange lift  最短路/bfs  题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1548

题意：一个奇怪的电梯，每层楼的按键 只能上达 i + k[i] 层，下至 i- k[i] 层。不能到达超过n楼， 也不能小于 1楼。问最少按键数。以单个0结束输入。

思路：bfs, 从起点出发，每个楼层只会访问一次，在不出界的情况下访问能够到达的楼层。

总结：布吉岛神马原因，只有用G++交才过，导致我纠结了好多天，【摔】！

AC代码：

 //AC
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<limits.h>
 using namespace std;
 #define maxn 2000
 #define INF INT_MAX
 int n, a, b;
 int arr[maxn];
 bool inq[maxn];
 int dis[maxn];

 void bfs(int st){
    queue<int> q;
    q.push(st);
    int x;
    dis[st] = ;
    if(a < ||a > n||b < ||b > n) return;
    while(!q.empty()){
      x = q.front();
      q.pop();
      if(x < ||x > n||x == b) break;
      if(x+arr[x] >= &&x+arr[x] <= n&&!inq[x+arr[x]]) { q.push(x+arr[x]); inq[x+arr[x]] = ; dis[x+arr[x]] = dis[x] + ; }
      if(x-arr[x] >= &&x-arr[x] <= n&&!inq[x-arr[x]]) { q.push(x-arr[x]); inq[x-arr[x]] = ; dis[x-arr[x]] = dis[x] + ; }
      //if(x+arr[x]>n&&x-arr[x]<1) break;
    }
 }
 int main(){
    while(~scanf("%d",&n) ,n){
     scanf("%d%d", &a, &b);
       for(int i = ; i <= n; i++)
         scanf("%d",&arr[i]);
       memset(inq, , sizeof(inq));
       for(int i = ; i <= maxn; i++){
         dis[i] = INF;
       }
       bfs(a);
       printf("%d\n", (dis[b] == INF)?-:dis[b]);
    }
 }

hdu2544    最短路题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544

题意：正如题目所说，是最短路，可以说是单源最短路入门题。

思路：可以用dijkstra做，这里我用spfa，不知道写的规不规范，总之思路和bellman-ford很像的，相当于Bellman-Ford的队列优化，也相当于做一趟bfs，具体是从当前节点出发，访问所有节点，如果能够到达，且被访问节点到起点的值比当前节点到起点的值加上当前节点到该节点大，则更新被访问的节点到起点的值，如果节点不在队列中，则入队，复杂度最坏是O（mn）。

总结：写完交wa了N+1次，最后才发现是INF的值没设好，Σ(っ °Д °;)っ设小了可能比更新后的距离小了，设大了，比如INT_MAX又溢出了。。。所以后来设成 节点数X单条路径最大距离  再大一点点就过了~~T^T

AC代码如下：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<limits.h>
 #include<queue>
 using namespace std;
 #define maxn 109
 #define INF 1000011
 int n, m, w[maxn][maxn];
 void spfa()
 {
   int d[maxn], k;
   bool inq[maxn];
   for(int i = ; i <= n; i++) {d[i] = INF; inq[i] = false;}
   d[] = ;
   //inq[1] = true;
   queue<int> q;
   q.push();
   while(!q.empty()){
      k = q.front(); q.pop();
      inq[k] = false;
      for(int j = ; j <= n; j++){
        int t = d[k] + w[k][j];
        if(d[j] > t){
           d[j] = t;
           if(!inq[j]){
              q.push(j);
              inq[j] = true;
           }
        }
      }
   }
   printf("%d\n",d[n]);
 }

 int main()
 {
   while(scanf("%d%d", &n, &m)&&n&&m){
     for(int i = ; i <= n; i++)
      for(int j = ; j <= n; j++)
         w[i][j] = (i == j)?:INF;

     for(int i = ; i < m; i++){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        w[a][b] = w[b][a] =c;
     }
     spfa();
   }
   return ;
 }

hdu 3790 最短路径问题 基础最短路★

思路：基础最短路，先考虑路径再考虑费用

总结：WA原因， 输入时没考虑 a, b 之间存在多条路径

AC代码:

spfa版

 //spfa版

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<limits.h>
 #include<queue>
 using namespace std;
 #define maxn 2000
 #define INF INT_MAX-100001
 int n, m, a, b, d, p, s, t;
 int w[maxn][maxn], cost[maxn][maxn];
 struct node{
   int dis, cos;
 };

 void test(node* x){
   for(int i = ; i <= n; i++)
   {
      cout<<x[i].dis<<" "<<x[i].cos<<endl;
   }
 }

 void spfa(int s, int t)
 {
   node d[maxn]; bool inq[maxn]; memset(inq, , sizeof(inq));
   int k;
   for(int i = ; i < maxn; i++)
    d[i].dis = d[i].cos = INF;

   d[s].dis = d[s].cos = ; inq[s] = true;
   queue<int> q;
   q.push(s);
   while(!q.empty()){
      k = q.front(); q.pop();
      inq[k] = false;
      for(int i = ; i <= n; i++){
        if(i != k){
          int t1 = d[k].dis + w[k][i];  int t2 = d[k].cos + cost[k][i];
          if(t1 < d[i].dis){
            d[i].dis = t1;
            d[i].cos = t2;
            if(!inq[i]) { q.push(i); inq[i] = true; }
          }
          if(t1 == d[i].dis&&t1 != INF){
            if(t2 < d[i].cos) {
             d[i].cos = t2;
            }
            if(!inq[i]){ q.push(i); inq[i] = true; }
          }
        }
      }
   }
   //test(d);
   printf("%d %d\n", d[t].dis, d[t].cos);

 }
 void init()
 {
   for(int i = ; i <= n; i++)
     for(int j = ; j <= n; j++){
        w[i][j] = cost[i][j] = (i == j)?:INF;
     }
 }
 int main()
 {
   while(scanf("%d%d", &n, &m),n,m){
     init();
     for(int i = ; i < m; i++){
       scanf("%d%d%d%d", &a, &b, &d, &p);
       if(d < w[a][b]){
       w[a][b] = w[b][a] = d;
       cost[a][b] = cost[b][a] = p;
       }
     }
     scanf("%d%d", &s, &t);

     spfa(s, t);
   }
   return ;
 }

dijkstra版

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<stack>
 #include<string>
 #include<cmath>
 #define maxn 1024
 #define INF 0x3fffffff
 using namespace std;
 int n, m;
 int d[maxn];
 struct node{
    int dis, cos;
 };
 node arr[maxn][maxn];

 void test(int* c, int*d){
   for(int i = ; i <= n; i++){
    cout<<i<<" dis "<< c[i]<<" cost "<<d[i]<<endl;
   }
 }

 void dijkstra(int s, int t)
 {
   int d[maxn], cost[maxn];
   bool vis[maxn];
   memset(vis, false, sizeof(vis));
   for(int i = ; i < maxn; i++)
    d[i] = cost[i] = INF;
   d[s] = cost[s] = ;

   for(int i = ; i <= n; i++){
     int k, mm = INF;

     for(int j = ; j <= n; j++) if(!vis[j] && d[j] < mm) { mm = d[j]; k = j; }
     vis[k] = true;

     for(int j = ; j <= n; j++){
       if(d[j] > d[k] + arr[k][j].dis){
         d[j] = d[k] + arr[k][j].dis;
         cost[j] = cost[k] + arr[k][j].cos;
       }
       else if(d[j] < INF && d[j] == d[k] + arr[k][j].dis && cost[j] > cost[k] + arr[k][j].cos){
         cost[j] = cost[k] + arr[k][j].cos;
       }
     }
   }
 //test(d, cost);
   printf("%d %d\n", d[t], cost[t]);
 }

 int main(){
   while(scanf("%d%d", &n, &m) ==  &&(n||m)){
     for(int i = ; i <= n; i++){
       for(int j = ; j <= n; j++)
       {
         arr[i][j].dis = arr[i][j].cos = (i == j)?:INF;
       }
     }
     for(int i = ; i < m; i++){
       int a, b, c, d;
       scanf("%d%d%d%d", &a, &b, &c, &d);
       if(c < arr[a][b].dis){
         arr[a][b].dis = arr[b][a].dis = c;
         arr[a][b].cos = arr[b][a].cos = d;
       }
     }
     int s, t;
     scanf("%d%d", &s, &t);
     dijkstra(s, t);
   }
   return ;
 }

hdu 2066 一个人的旅行  【多源多汇，基础最短路】

思路：邻接表存图。 多源多汇，所以考虑建立【超级原点】，通常为0点，该点到所有起点的距离都为0，然后就是裸的最短路了。

总结：不知道为什么在自己电脑上init()之后s就被莫名其妙地改变成和t一个值了。。。。但是无改动用C++交上去过了，= =||，如果谁知道为神马请告诉我一声，涩涩~~~

AC代码如下：

 //AC
 #include<iostream>
 #include<cstdio>
 #include<queue>
 #include<vector>
 #include<limits.h>
 #include<cstring>
 using namespace std;
 #define maxn 1010
 #define INF INT_MAX-1000
 struct node{
    int v, wei;
 };
 vector<node> gra[maxn];
 int t, s, d;  int dis[maxn];

 void init()
 {
     int i;
     for(i = ; i <= maxn; i++)
         gra[i].clear();
 }

 void input()
 {
    for(int i = ; i < t; i++){
        node re;
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        re.v = v; re.wei = w;
        gra[u].push_back(re);
        re.v = u;
        gra[v].push_back(re);
    }
    for(int i = ; i < s; i++){
        node re; re.wei = ;
        scanf("%d", &re.v);
        gra[].push_back(re);
        int t = re.v; re.v = ;
        gra[t].push_back(re);
    }
 }

 void output()
 {
    int ans = INF;
    for(int i = ; i < d; i++){
      int fina;
      scanf("%d", &fina);
      if(dis[fina] < ans) ans = dis[fina];
    }
    printf("%d\n", ans);
 }

 void spfa()
 {
    bool inq[maxn];  memset(inq, , sizeof(inq));
    for(int i = ; i < maxn; i++)
      dis[i] = INF;

    queue<int> q;
    q.push();
    inq[] = true; dis[] = ;
    while(!q.empty()){
       int u = q.front(); q.pop();
       inq[u] = false;
       for(int i = ; i < gra[u].size(); i++){
         int t = dis[u] + gra[u][i].wei;
         int v = gra[u][i].v;
         if(dis[v] > t){
           dis[v] = t;
           if(!inq[v]){
             q.push(v);
             inq[v] = true;
           }
         }
       }
    }
 }

 int main()
 {
    while(scanf("%d%d%d", &t, &s, &d) != EOF){
      init();
      input();
      spfa();
      output();
    }
    return ;
 }

同类型基础题如下：

1869 六度分离 Floyd最短路(water)

作者：u011652573 发表于2014-4-22 8:12:45 原文链接

阅读：82 评论：0 查看评论