POJ 1847 Tram Floyd或者spfa 最短路

最新推荐文章于 2019-08-25 17:54:03 发布

原创最新推荐文章于 2019-08-25 17:54:03 发布 · 242 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#poj #最短路 #pku #floyd #spfa

POJ 同时被 2 个专栏收录

16 篇文章

订阅专栏

最短路

14 篇文章

订阅专栏

本文介绍了一个火车路径选择问题，通过构建图模型并采用SPFA算法或Floyd算法来寻找从起点到终点所需的最少操作次数。该问题涉及图论中的最短路径算法应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：火车行驶过程有n条岔路（每次只能走一条），默认是第一条路..如果需要改路的话需要操作一次，问从a到b最少需要操作多少次....n个点 a,b是起点和终点，然后n行，第i行有k个点，代表第i个点可以走到这k个点，初始默认方向是第一个点的方向...其他的改道一次需要操作一次...按照操作次数当做边权求最短路即可..

输入：

3 2 1 //有3个开关点，计算从第二个到第一个最少需要旋转几次

2 2 3//第1个开关可以通向2 和3 ，通向2不需要旋转，通向3需要旋转1次

2 3 1//第2个开关可以通向3 和1，通向3不需要旋转，通向1需要旋转1次

#include <stdio.h>  
  
#define maxN 110  
#define  inf 1000000000  
  
int mat[maxN][maxN];  
bool flag[maxN][maxN];  
bool vis[maxN];  
int dis[maxN];  
int queue[10 * maxN];  
  
int n,a,b;  
  
  
void Init()//初始化  
{  
    for (int i = 1; i <= n; ++ i)  
    {  
        for (int j = 1; j <= n; ++ j)  
        {  
            if (i == j)  
            {  
                mat[i][j] = 0;  
            }  
            else  
                mat[i][j] = inf;  
            flag[i][j] = false;  
        }  
        vis[i] = false;  
        dis[i] = inf;  
    }  
}  
  
void spfa() //  spfa算法  
{  
    int head = 0, tail = 1;  
    queue[head] = a;  
    dis[a] = 0;  
    while (head < tail)  
    {  
        int u = queue[head];  
        vis[u] = true;  
        for (int i = 1; i <= n; ++ i)  
        {  
            if (flag[u][i] && dis[i] > dis[u] + mat[u][i])  
            {  
                dis[i] = dis[u] + mat[u][i];  
                if (!vis[i])  
                {  
                    vis[i] = true;  
                    queue[tail] = i;  
                    tail ++;  
                }  
            }  
        }  
        vis[u] = false;  
        head ++;  
    }  
    if (dis[b] >= inf)  
    {  
        printf("-1\n");  
    }  
    else  
        printf("%d\n", dis[b]);  
}  
  
void floyd()    //floyd 算法  
{  
    for (int i = 1; i <= n; ++ i)  
    {  
        for (int j = 1; j <= n; ++ j)  
        {  
            for (int k = 1; k <= n; ++ k)  
            {  
                if (mat[j][k] > mat[j][i] + mat[i][k])  
                {  
                    mat[j][k] = mat[j][i] + mat[i][k];  
                }  
            }  
        }  
    }  
    if (mat[a][b] >= inf)  
    {  
        printf("-1\n");  
    }  
    else  
        printf("%d\n", mat[a][b]);  
}  
int main()  
{  
    while (scanf("%d%d%d", &n, &a, &b) != EOF)  
    {  
        //scanf("%d%d%d", &n, &a, &b);  
        Init();  
        for (int i = 1; i <= n; ++ i)  
        {  
            int m,v;  
            scanf("%d", &m);  
            for (int j = 0; j < m; ++ j)  
            {  
                scanf("%d", &v);  
                if (j == 0)  
                {  
                    mat[i][v] = 0;  
                }  
                else  
                    mat[i][v] = 1;  
                //mat[i][v] = !(j == 0);  
                flag[i][v] = true;  
            }  
        }  
        spfa();//两种方法，可以调用spfa也可以调用floyd算法，两个都行，由于数据比较小，时间上没有差别。如果要调用floyd只需要将本行屏蔽，打开下一行即可  
        //floyd();  
    }  
    return 0;  
}