C++博客-ACM___________________________-随笔分类-ACM ( 最短路 )

HDOJ 1548 HDU 1548 A strange lift ACM 1548 IN HDU

MiYu — Sun, 15 Aug 2010 08:19:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1548
题目描述:

A strange lift
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2641 Accepted Submission(s): 944

Problem Description
There is a strange lift.The lift can stop can at every floor as you want, and there is a number Ki(0 <= Ki <= N) on every floor.The lift have just two buttons: up and down.When you at floor i,if you press the button "UP" , you will go up Ki floor,i.e,you will go to the i+Ki th floor,as the same, if you press the button "DOWN" , you will go down Ki floor,i.e,you will go to the i-Ki th floor. Of course, the lift can't go up high than N,and can't go down lower than 1. For example, there is a buliding with 5 floors, and k1 = 3, k2 = 3,k3 = 1,k4 = 2, k5 = 5.Begining from the 1 st floor,you can press the button "UP", and you'll go up to the 4 th floor,and if you press the button "DOWN", the lift can't do it, because it can't go down to the -2 th floor,as you know ,the -2 th floor isn't exist.
Here comes the problem: when you is on floor A,and you want to go to floor B,how many times at least he havt to press the button "UP" or "DOWN"?

Input
The input consists of several test cases.,Each test case contains two lines.
The first line contains three integers N ,A,B( 1 <= N,A,B <= 200) which describe above,The second line consist N integers k1,k2,.kn.
A single 0 indicate the end of the input.

Output
For each case of the input output a interger, the least times you have to press the button when you on floor A,and you want to go to floor B.If you can't reach floor B,printf "-1".

Sample Input
5 1 5
3 3 1 2 5
0

Sample Output
3

题目分析:

        这题又是一个标准的 Dijkstra 算法的题目 ( 最短路 ). 要说难度吗? 对我而言吧, 就是图的生成.
刚开始做的时候自己想复杂了, 以为从不同的楼层开始, 就有不同的走法, 所以开始的时候写循环没写对,
就写成了递归.   结果很杯具的 STACK_OVERFLOW........   在 AMB 神牛的指点发现, 原来是自己想复杂了,
只需要计算出每一个楼层的上楼和下楼就可以了, 当然, 要注意是否越界. 图生成后, 当然就是 DIJKSTRA了.

闲来无事, 又复制一遍 :
            Dijkstra算法的基本思路是：

         假设每个点都有一对标号 (dj, pj)，其中dj是从起源点s到点j的最短路径的长度 (从顶点到其本身的最短路径是零路(没有弧的路)，其长度等于零)；

pj则是从s到j的最短路径中j点的前一点。求解从起源点s到点j的最短路径算法的基本过程如下：

　　1) 初始化。起源点设置为：① ds=0, ps为空;② 所有其他点: di=∞, pi=?;③ 标记起源点s，记k=s,其他所有点设为未标记的。

　　2) 检验从所有已标记的点k到其直接连接的未标记的点j的距离，并设置：

dj=min［dj, dk+lkj］

式中，lkj是从点k到j的直接连接距离。

　　3) 选取下一个点。从所有未标记的结点中，选取dj 中最小的一个i：

di=min［dj, 所有未标记的点j］

点i就被选为最短路径中的一点，并设为已标记的。

　　4) 找到点i的前一点。从已标记的点中找到直接连接到点i的点j*，作为前一点,设置：i=j*

　　5) 标记点i。如果所有点已标记，则算法完全推出，否则，记k=i，转到2) 再继续。

代码如下:

#include <iostream>
using namespace std;
const int MAX = 200;
const int INF = 0x7FFFFFF;
int N,A,B;
int g[MAX+1][MAX+1];
int hash[MAX+1];
int path[MAX+1];
int K[MAX+1];
int Dijkstra ( int beg , int end )
{
    path[beg] = 0;
    hash[beg] = false;
    while ( beg != end )
    {
            int m = INF, temp;
            for ( int i = 1; i <= N; ++ i )
            {
                  if ( g[beg][i] != INF )
                       path[i] = min ( path[i], path[beg] + g[beg][i] );
                  if ( m > path[i] && hash[i] )
                  {
                       m = path[i];
                       temp = i;
                  }
            }
            beg = temp;
            if ( m == INF )
                 break;
            hash[beg] = false;
    }
    if ( path[end] == INF )
         return -1;
    return path[end];
}

int main ()
{
    while ( scanf ( "%d%d%d", &N, &A, &B ) , N )
    {
            for ( int i = 0; i <= MAX; ++ i )
            {
                  hash[i] = true;
                  path[i] = INF;
                  for ( int j = 0; j <= MAX; ++ j )
                  {
                        g[i][j] = INF;
                  }
            }
            for ( int i = 1; i <= N; ++ i )
            {
                  scanf ( "%d",&K[i] );
            }
            for ( int i = 1; i <= N; ++ i )
            {
                  if ( i + K[i] <= N )
                       g[ i ][ i + K[i] ] = 1;
                  if ( i - K[i] >= 1 )
                       g[ i ][ i - K[i] ] = 1;
            }
            cout << Dijkstra ( A, B ) << endl;
    }
    return 0;
}

SO 代码:

#include <iostream>
using namespace std;
const int MAX = 200;
const int INF = 0x7FFFFFF;
bool UP = true;
bool DOWN = false;
int N,A,B;
int g[MAX+1][MAX+1];
int hash[MAX+1];
int path[MAX+1];
int K[MAX+1];

int Dijkstra ( int beg , int end )
{
    path[beg] = 0;
    hash[beg] = false;
    while ( beg != end )
    {
            int m = INF, temp;
            for ( int i = 1; i <= N; ++ i )
            {
                  if ( g[beg][i] != INF )
                       path[i] = min ( path[i], path[beg] + g[beg][i] );
                  if ( m > path[i] && hash[i] )
                  {
                       m = path[i];
                       temp = i;
                  }
            }
            beg = temp;
            if ( m == INF )
                 break;
            hash[beg] = false;
    }
    if ( path[end] == INF )
         return -1;
    return path[end];
}

bool setGraph ( int n, bool flag )
{
     if ( flag )
     {
          if ( n + K[n] <= N )
          {
               g[ n ][ n + K[n] ] = 1;
               setGraph ( n + K[n], UP );
               setGraph ( n + K[n], DOWN );
          }
     }
     else
     {
          if ( n - K[n] >= 1 )
          {
               g[ n  ][ n - K[n] ] = 1;
               setGraph ( n - K[n], UP );
               setGraph ( n - K[n], DOWN );
          }
     }
     return true;
}
int main ()
{
    while ( scanf ( "%d%d%d", &N, &A, &B ) , N )
    {
            for ( int i = 0; i <= MAX; ++ i )
            {
                  hash[i] = true;
                  path[i] = INF;
                  for ( int j = 0; j <= MAX; ++ j )
                  {
                        g[i][j] = INF;
                  }
            }
            for ( int i = 1; i <= N; ++ i )
            {
                  scanf ( "%d",&K[i] );
            }
            for ( int i = 1; i <= N; ++ i )
            {
                  setGraph ( i, UP );
                  setGraph ( i, DOWN );
            }
            cout << Dijkstra ( A, B ) << endl;
    }
    return 0;
}

MiYu 2010-08-15 16:19 发表评论

HDOJ 1874 HDU 1874 畅通工程续 ACM 1874 IN HDU

MiYu — Sun, 15 Aug 2010 05:15:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=1874
题目描述:

畅通工程续
Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5528 Accepted Submission(s): 1686

Problem Description
某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。

现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

Input
本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

Output
对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

Sample Input
3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2

Sample Output
2
-1

题目分析:

最短路的入门题目.

Dijkstra算法的基本思路是：

假设每个点都有一对标号 (dj, pj)，其中dj是从起源点s到点j的最短路径的长度 (从顶点到其本身的最短路径是零路(没有弧的路)，其长度等于零)；

pj则是从s到j的最短路径中j点的前一点。求解从起源点s到点j的最短路径算法的基本过程如下：

　　1) 初始化。起源点设置为：① ds=0, ps为空;② 所有其他点: di=∞, pi=?;③ 标记起源点s，记k=s,其他所有点设为未标记的。

　　2) 检验从所有已标记的点k到其直接连接的未标记的点j的距离，并设置：

dj=min［dj, dk+lkj］

式中，lkj是从点k到j的直接连接距离。

　　3) 选取下一个点。从所有未标记的结点中，选取dj 中最小的一个i：

di=min［dj, 所有未标记的点j］

点i就被选为最短路径中的一点，并设为已标记的。

　　4) 找到点i的前一点。从已标记的点中找到直接连接到点i的点j*，作为前一点,设置：i=j*

　　5) 标记点i。如果所有点已标记，则算法完全推出，否则，记k=i，转到2) 再继续。

代码如下:

#include <iostream>
using namespace std;
const int MAX = 201;
const int INF = 0x7FFFFFF;
int graph[MAX][MAX];
bool hash[MAX];
int path[MAX];
int N,M;
int Dijkstra ( int beg , int end )
{
    path[beg] = 0;
    hash[beg] = false;
    while ( beg != end )
    {
            int m = INF, temp;
            for ( int i = 0; i != N; ++ i )
            {
                  if ( graph[beg][i] != INF )
                       path[i] = min ( path[i], path[beg] + graph[beg][i] );
                  if ( m > path[i] && hash[i] )
                  {
                       m = path[i];
                       temp = i;
                  }
            }
            beg = temp;
            if ( m == INF )
                 break;
            hash[beg] = false;
    }
    if ( path[end] == INF )
         return -1;
    return path[end];
}
int main ()
{
    while ( scanf ( "%d%d", &N, &M ) != EOF )
    {
            for ( int i = 0; i != MAX; ++ i )
            {
                  hash[i] = true;
                  path[i] = INF;
                  for ( int j = 0; j != MAX; ++ j )
                  {
                        graph[i][j] = INF;
                  }
            }
            for ( int i = 0; i != M; ++ i )
            {
                  int c1,c2,cost;
                  scanf ( "%d%d%d",&c1, &c2, &cost );
                  if ( cost < graph[c1][c2] )
                       graph[c1][c2] = graph[c2][c1] = cost;
            }
            int beg,end;
            scanf ( "%d%d",&beg, &end );
            cout << Dijkstra ( beg,end ) << endl;
    }
    return 0;
}

MiYu 2010-08-15 13:15 发表评论

HDOJ 2066 HDU 2066 一个人的旅行 ACM 2066 IN HDU

MiYu — Sun, 15 Aug 2010 03:31:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2066
题目描述:

一个人的旅行
Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4077 Accepted Submission(s): 1348

Problem Description
虽然草儿是个路痴（就是在杭电待了一年多，居然还会在校园里迷路的人，汗~),但是草儿仍然很喜欢旅行，因为在旅途中会遇见很多人（白马王子，^0^），很多事，还能丰富自己的阅历，还可以看美丽的风景……草儿想去很多地方，她想要去东京铁塔看夜景，去威尼斯看电影，去阳明山上看海芋，去纽约纯粹看雪景，去巴黎喝咖啡写信，去北京探望孟姜女……眼看寒假就快到了，这么一大段时间，可不能浪费啊，一定要给自己好好的放个假，可是也不能荒废了训练啊，所以草儿决定在要在最短的时间去一个自己想去的地方！因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。

Input
输入数据有多组，每组的第一行是三个整数T，S和D，表示有T条路，和草儿家相邻的城市的有S个，草儿想去的地方有D个；
接着有T行，每行有三个整数a，b，time,表示a,b城市之间的车程是time小时；(1=<(a,b)<=1000;a,b 之间可能有多条路)
接着的第T+1行有S个数，表示和草儿家相连的城市；
接着的第T+2行有D个数，表示草儿想去地方。

Output
输出草儿能去某个喜欢的城市的最短时间。

Sample Input
6 2 3
1 3 5
1 4 7
2 8 12
3 8 4
4 9 12
9 10 2
1 2
8 9 10

Sample Output
9

题目分析:

        刚开始做的时候也没做分析, 直接就是枚举每个起点到每个终点的最短距离, 然后取最短的路, 很显然, TLE.................
还是自己没有把DIJKSTRA 算法理解好.... 再次看了一遍算法的描述和数据结构书上的 sample后发现, 其实算法执行过程中
已经把起点到其他点的最短距离全部算出来了, 所以只需要枚举每个起点就可以了, 兴奋之下, 马上修改了代码, Submit! ......
很杯具, 还是tle ...... 不明白为什么.....看网上其他人写的解题报告 , 原来很多人也是这做的, 枚举起始点, 但是他们的却可以AC.
虽然时间一般是 100MS左右. 这里我一直很纠结, 不明白同样的算法为什么我的会TLE.
         在 AMB 大牛的提示下, 不需要全部枚举, 只要把所有起点的距离都设置成0就可以了, 但是不知道为什么, 还是一直TLE.

最后的办法是:   设置一个起点指向所有起点, 之间的距离设置为 1, 同样设置一个终点指向所有终点, 距离同样设置为1, 最后
使用 DIJKSTRA 算法求出起点到终点的最短距离 - 2 就行了.

代码如下:

#include <iostream>
using namespace std;
const int INF = 0x7FFFFFFF;
int T,S,D,L;
const int MAXN=1005;    //点个数
int graph[MAXN][MAXN];
int s[MAXN];
int d[MAXN];
int Dijkstra ( int beg, int end )
{
    bool hash[MAXN];
    int path[MAXN];
    for ( int i = 0; i <= L; ++ i )
    {
          hash[i] = true;
          path[i] = INF;
    }
    hash[beg] = false;
    path[beg] = 0;
    while ( beg != end )
    {
           for ( int i = 0; i <= L; ++ i )
           {
                 if ( graph[beg][i] != 0 )
                 {
                      if ( path[i] > path[beg] + graph[beg][i] )
                           path[i] = path[beg] + graph[beg][i];
                 }
           }
           int min = INF;
           for ( int i = 0; i <= L; ++ i )
           {
                 if ( min > path[i] && hash[i] )
                 {
                      min = path[i];
                      beg = i;
                 }
           }
           hash[beg] = false;
    }
    return path[end];
}

int main ()
{
    while ( scanf ( "%d%d%d",&T,&S,&D ) != EOF )
    {
          memset ( graph , 0 , sizeof ( graph ) );
          L = 0;
          for ( int i = 1; i <= T; ++ i )
          {
                int r,c,cost;
                scanf ( "%d%d%d",&r,&c,&cost );
                if ( graph[r][c] == 0 )
                     graph[r][c] = graph[c][r] = cost ;
                else
                {
                     if ( cost < graph[r][c] )
                          graph[r][c] = graph[c][r] = cost ;
                }
                if ( L < max ( r,c ) )
                     L = max ( r,c );
          }
          for ( int i = 0; i != S; ++ i )
          {
               scanf ( "%d",&s[i] );
               graph[0][ s[i] ] = 1;
               graph[ s[i] ][0] = 1;
          }
          L ++;
          for ( int i = 0; i != D; ++ i )
          {
               scanf ( "%d",&d[i] );
               graph[ d[i] ][ L ] = 1;
               graph[ L ][ d[i] ] = 1;
          }

          cout << Dijkstra ( 0,L ) - 2 << endl;
    }
    return 0;
}

顺便 0rz 下大牛代码:

#include <iostream>
#define MAX 1005
#define INF 0x7FFF
#define CMP(A,B) (A.d < B.d)
using namespace std;
int d[MAX][MAX];
class HNode {
      public:
              int v;
              int d;
};
class Heap {
public:
        HNode h[MAX * 2];
        int n, p, c;
        Heap() {
                n = 0;
        }
        void inline ins(HNode e) {
                for (p = ++n; p > 1 && CMP(e,h[p>>1]); h[p] = h[p>>1], p >>= 1)
                        ;
                h[p] = e;
        }
        int inline pop(HNode &e) {
                if (!n)
                        return 0;
                for (e = h[p = 1], c = 2; c < n
                                && CMP(h[c += (CMP(h[c + 1],h[c]) && c < n - 1)], h[n]);
                                h[p] = h[c], p = c, c <<= 1)
                        ;
                h[p] = h[n--];
                return 1;
        }
};
int Dijkstra(int A, int B, int N) {
        int dist[MAX];
        int mask[MAX];
        int Tmp;
        Heap h;
        HNode e, ne;

        for (int i = 0; i < N; i++) {
                dist[i] = INF;
                mask[i] = 0;
        }
        dist[e.v = A] = (e.d = 0);
        h.ins(e);
        while (h.pop(e)) {
                if (!mask[e.v]) {
                        mask[e.v] = 1;
                        for (int i = 0; i < N; i++) {
                                if (!mask[i] && (Tmp = e.d + d[e.v][i])
                                                < dist[i]) {
                                        dist[ne.v = i] = (ne.d = Tmp);
                                        h.ins(ne);
                                }
                        }
                }
        }
        return dist[B];
}
int main() {
        int T, S, D, M;
        int st, en, tm;
        while (scanf("%d %d %d", &T, &S, &D)!=EOF) {
                M = 0;
                for (int i = 0; i < MAX; i++)
                        for (int j = 0; j < MAX; j++)
                                d[i][j] = INF;
                for (int i = 0; i < T; i++) {
                        scanf("%d %d %d", &st, &en, &tm);
                        if (tm < d[st][en]) {
                                d[st][en] = d[en][st] = tm;
                        }

                        M = st> M ? st : M;
                        M = en> M ? en : M;
                }
                M = M + 1;
                for (int i = 0; i < S; i++) {
                        scanf("%d", &st);
                        d[0][st] = 1;
                        d[st][0] = 1;
                }

                for (int i = 0; i < D; i++) {
                        scanf("%d", &en);
                        d[M][en] = 1;
                        d[en][M] = 1;
                }
                cout<<Dijkstra(0, M, M+1)-2<<endl;
        }
        return 0;
}

MiYu 2010-08-15 11:31 发表评论

HDOJ 2544 HDU 2544 最短路 ACM 2544 IN HDU

MiYu — Sat, 14 Aug 2010 10:28:00 GMT

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
http://acm.hdu.edu.cn/showproblem.php?pid=2544
题目描述:

最短路
Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3844 Accepted Submission(s): 1628

Problem Description
在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input
输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

Output
对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output
3
2

题目分析:

最短路的入门题目, 我也是刚刚接触, 开始一直没看明白到底怎么回事, 睡了一觉醒来, 把数据结构书翻出来复习了一次 Dijkstra 终于明白了.

Dijkstra算法的基本思路是：
假设每个点都有一对标号 (dj, pj)，其中dj是从起源点s到点j的最短路径的长度 (从顶点到其本身的最短路径是零路(没有弧的路)，其长度等于零)；

pj则是从s到j的最短路径中j点的前一点。求解从起源点s到点j的最短路径算法的基本过程如下：

　　1) 初始化。起源点设置为：① ds=0, ps为空;② 所有其他点: di=∞, pi=?;③ 标记起源点s，记k=s,其他所有点设为未标记的。

　　2) 检验从所有已标记的点k到其直接连接的未标记的点j的距离，并设置：

dj=min［dj, dk+lkj］

式中，lkj是从点k到j的直接连接距离。

　　3) 选取下一个点。从所有未标记的结点中，选取dj 中最小的一个i：

di=min［dj, 所有未标记的点j］

点i就被选为最短路径中的一点，并设为已标记的。

　　4) 找到点i的前一点。从已标记的点中找到直接连接到点i的点j*，作为前一点,设置：i=j*

　　5) 标记点i。如果所有点已标记，则算法完全推出，否则，记k=i，转到2) 再继续。

代码如下:

#include <iostream>
using namespace std;
const int INF = 0x7FFFFFFF;
const int MAX = 105;
int graph[MAX][MAX];
int N,M;
int Dijkstra ( int beg, int end )
{
    bool hash[N+1];
    int path[N+1];
    for ( int i = 0; i <= N; ++ i )
    {
          hash[i] = true;
          path[i] = INF;
    }
    hash[beg] = false;
    path[beg] = 0;
    while ( beg != end )
    {
           for ( int i = 1; i <= N; ++ i )
           {
                 if ( graph[beg][i] )
                 {
                      if ( path[i] > path[beg] + graph[beg][i] )
                           path[i] = path[beg] + graph[beg][i];
                 }
           }
           int min = INF;
           for ( int i = 1; i <= N; ++ i )
           {
                 if ( min > path[i] && hash[i] )
                 {
                      min = path[i];
                      beg = i;
                 }
           }
           hash[beg] = false;
    }
    return path[end];
}

int main ()
{
    while ( scanf ( "%d%d",&N,&M ) , N + M )
    {
          memset ( graph , 0 , sizeof ( graph ) );
          for ( int i = 1; i <= M; ++ i )
          {
                int r,c,cost;
                scanf ( "%d%d%d",&r,&c,&cost );
                if ( graph[r][c] == 0 )
                     graph[r][c] = graph[c][r] = cost ;
                else
                {
                     if ( cost < graph[r][c] )
                          graph[r][c] = graph[c][r] = cost ;
                }
          }
          cout << Dijkstra ( 1,N ) << endl;;
    }
    return 0;
}

MiYu 2010-08-14 18:28 发表评论