POJ - 2253（变相最短路，SPFA）

最新推荐文章于 2021-04-01 18:48:34 发布

原创最新推荐文章于 2021-04-01 18:48:34 发布 · 306 阅读

0 ·

CC 4.0 BY-SA版权

acm水题专栏收录该内容

126 篇文章

订阅专栏

本文通过一次反复调试的经历，总结了最短路径算法实现过程中的关键注意事项，包括数据结构的清理及严格按照题目要求输出结果的重要性。

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

反思：1.最短路水题。但是为什么WA了11遍，因为，没有在新一组输入的时候把所有原来的数据结构清空。

for (int i = 1; i <= n; i++) {
            G[i].clear();
        }

一定不能忘。
2.这道题还告诉我，一定要注意题中要求的输出格式，空行什么的不能忘，忘了就gg了。

#include <iostream>
#include <queue>
#include <cstdio>
#include <map>
#include <cstring>
#include <stack>
#include <string>
#include <vector>
#include <cmath>

using namespace std;

const int INF = 1 << 30;

struct node
{
    int x, y;
};

struct CNode
{
    int v;
    double w;
    CNode(){}
    CNode(int vv, double ww)
    {
        v = vv;
        w = ww;
    }
};

int n;
vector<vector<CNode> > G;
node Node[300];
double dis[300];
int vis[300];

double max(double a,double b)
{
    return a>b?a:b;
}

double Distance(node a, node b)
{
    return sqrt(double(a.x - b.x) * (a.x - b.x) + double(a.y - b.y) * (a.y - b.y));
}

void SPFA()
{
    for (int i = 1; i <= n; i++) {
        dis[i] = double(INF);
    }
    memset(vis, 0, sizeof(vis));
    queue<int> q;
    q.push(1);
    dis[1] = 0;
    vis[1] = 1;
    while (!q.empty()) {
        int t = q.front();
        vis[t] = 0;
        q.pop();
        for (int i = 0; i < G[t].size(); i++) {
            CNode tmp = G[t][i];
            double md = max(dis[t], tmp.w);
            if (dis[tmp.v] > md) {
                dis[tmp.v] = md;
                if (vis[tmp.v] == 0) {
                    q.push(tmp.v);
                    vis[tmp.v] = 1;
                }
            }
        }
    }
    printf ("Frog Distance = %.3lf\n\n", dis[2]);
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    #endif // ONLINE_JUDGE
    int kase = 1;
    while (scanf("%d", &n) !=EOF) {
        if (n == 0) break;
        printf("Scenario #%d\n", kase++);
        memset(Node, 0, sizeof(Node));
        for (int i = 1; i <= n; i++) {
            scanf("%d%d", &Node[i].x, &Node[i].y);
        }
        G.resize(n + 1);
        for (int i = 1; i <= n; i++) {
            G[i].clear();
        }
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j++) {
                double d = Distance (Node[i], Node[j]);
                G[i].push_back(CNode(j, d));
                G[j].push_back(CNode(i, d));
            }
        }
        SPFA ();
    }
    return 0;
}