POJ 1502 MPI Maelstrom （简单最短路，多种算法均可）

最新推荐文章于 2022-03-13 18:41:37 发布

原创最新推荐文章于 2022-03-13 18:41:37 发布 · 812 阅读

0 ·

CC 4.0 BY-SA版权

Graph Theroy 同时被 2 个专栏收录

15 篇文章

订阅专栏

Shortest Path

7 篇文章

订阅专栏

本文详细介绍了如何使用SPFA算法解决POJ在线评测平台上的问题ID为1502的任务，即在给定的邻接矩阵中找出到结点1的最长路径。通过实例代码展示了解题过程，并解释了算法的实现细节。

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

传送门：http://poj.org/problem?id=1502

题目大意：给定一个邻接矩阵，求出到结点1的最长的点的距离。

解题思路：简单题，n比较小，各种最短路算法均可，下面为SPFA。

Code：

/*   W          w           w        mm          mm             222222222       7777777777777    */
/*    W        w w         w        m  m        m  m          222        22              7777    */
/*    w        w w         w        m  m        m  m                     22              777     */
/*     w      w   w       w        m    m      m    m                    22              77      */
/*     w      w    w      w        m    m      m    m                 222                77      */
/*      w    w      w    w        m      m    m      m              222                  77      */
/*      w    w      w    w        m      m    m      m            222                    77      */
/*       w  w        w  w        m        m  m        m         222                      77      */
/*       w  w        w  w        m        m  m        m      222                         77      */
/*        ww          ww        m          mm          m     222222222222222             77      */

//#pragma comment(linker, "/STACK:102400000,102400000")
//C++
//int size = 256 << 20; // 256MB
//char *p = (char*)malloc(size) + size;
//__asm__("movl %0, %%esp\n" :: "r"(p));
//G++
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<ctime>
#include<deque>
#include<cmath>
#include<vector>
#include<string>
#include<cctype>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<sstream>
#include<iostream>
#include<algorithm>
#define REP(i,s,t) for(int i=(s);i<=(t);i++)
#define REP2(i,t,s) for(int i=(t);i>=s;i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned long ul;

int n;
const int MAXN=105;
const int INF=0x3f3f3f3f;
struct Edge
{
    int v;
    int cost;
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost) {}
};
vector<Edge>E[MAXN];
void addedge(int u,int v,int w)
{
    E[u].push_back(Edge(v,w));
}
bool vis[MAXN];//在队列标志
int cnt[MAXN];//每个点的入队列次数
int dist[MAXN];
bool SPFA(int start,int n)
{
    memset(vis,false,sizeof(vis));
    for(int i=1; i<=n; i++)dist[i]=INF;
    vis[start]=true;
    dist[start]=0;
    queue<int>que;
    while(!que.empty())que.pop();
    que.push(start);
    memset(cnt,0,sizeof(cnt));
    cnt[start]=1;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        vis[u]=false;
        for(int i=0; i<E[u].size(); i++)
        {
            int v=E[u][i].v;
            if(dist[v]>dist[u]+E[u][i].cost)
            {
                dist[v]=dist[u]+E[u][i].cost;
                if(!vis[v])
                {
                    vis[v]=true;
                    que.push(v);
                    if(++cnt[v]>n)return false;//cnt[i]为入队列次数,用来判定是否存在负环回路
                }
            }
        }
    }
    return true;
}
char s[20];
int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("test.in","r",stdin);
#endif
    while(~scanf("%d",&n))
    {
        REP(i,1,n)
        {
            E[i].clear();
        }
        REP(i,2,n)
        {
            REP(j,1,i-1)
            {
                scanf("%s",s);
                if(s[0]=='x')
                {
                    continue;
                }
                else
                {
                    int w;
                    sscanf(s,"%d",&w);
                    addedge(i,j,w);
                    addedge(j,i,w);
                }
            }
        }
        SPFA(1,n);
        int ans=-1;
        REP(i,2,n)
        {
            //printf("dist[%d]=%d\n",i,dist[i]);
            if(dist[i]==INF)
            {
                continue;
            }
            ans=max(ans,dist[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}