C 所有点之间的最短路径问题，floyd warshall

罗文先生计划徒步旅行 巴黎的。但是,因为他是一个 有点懒，他想坐飞机 穿越所有道路的最短路径 他想去的地方。他计划 坐公共汽车去第一个地方 又一个从上一个地方回来的， 所以他可以自由选择出发点 还有终点。你能帮助他吗

输入

输入的第一行包含 参观的地点数量（n）。那么， 在下面的n行中，您可以找到 每个参观地点的坐标。 以下是一个例子：

三,

132 73

49 86

72 111

输出

对于每个测试用例，您的程序 应输出一行，其中包含 Rowan先生必须的最小距离 步行去参观所有的地方 从一个地方到另一个地方的步行距离 另一个是欧几里得距离。这个 算法应在中输出一个数字 精确为3的定点表示法 小数点右边的数字 点和无引导空间。有 最多可参观12个地方。范例

输入示例：

三,

132 73

49 86

72 111

示例输出：

104.992

我一直在写这个代码，作为我的家庭作业，但我不能让它工作，我开始怀疑这是否是最好的方法

问题是floyd warshall函数对float**路径结构没有任何作用。。不知道为什么。。floydwarshall前后的路径相同（路径，n，下一个）

#包括
#包括
#包括
#包括
#包括
/*实施http://en.wikipedia.org/wiki/Floyd–WARU算法*/
结构点{
浮动x；
浮动y；
};
浮动成本（结构点*a，结构点*b）{
返回sqrt（pow（（*a.x-（*b.x，2）+pow（（*a.y-（*b.y，2））；
}
浮点**f2dmalloc（整数n，整数m）{
int i；
浮动**ptr；
ptr=malloc（n*sizeof（float*））；
对于（i=0；i

Floyd Warshall解决了这个问题：对于每一对点，找到连接它们的最短路径。（它需要连接这两个点。它不需要做任何其他事情。它只会访问其他点，如果这会产生较短的路径。）

在本例中，由于您始终可以直接从任何点到任何其他点，因此最短路径始终是直接路径：从A到B（这就是为什么调用

floydwarshall

不会改变任何事情。）

但你试图解决的问题似乎是旅行推销员的问题：找到一条能够访问你所有的点并且尽可能短的路径

---

这些是完全不同的问题，您需要做一些完全不同的事情来解决您被要求解决的问题。

文本有点混乱，但我认为它必须是到每个点的最短距离动态规划问题。或者老师在和孩子们玩。我需要尽可能短的路径，但不要回到起点。。我见过旅行推销员的问题，但在每一个描述中，它都是一个计算闭合回路的问题。你能发布更多的问题陈述吗？如果我们有更多的背景知识，也许更容易完全确定你被要求做什么。例如，是否有“给定这些点，这里是一个正确答案”形式的示例？还有关于你应该使用哪种算法的建议吗？Rowan先生？比如威廉·罗恩·汉密尔顿？汉密尔顿的难题？因为他的问题不要求旅行在开始的地方结束，所以它不要求循环，所以它不是TSP。此外，弗洛伊德·沃雷德不会访问所有的积分；它将只访问所有poi

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <float.h>

/*Implementing of http://en.wikipedia.org/wiki/Floyd–Warshall_algorithm*/


struct point {
    float x;
    float y;
};


float cost(struct point* a, struct point* b) {

    return sqrt(pow((*a).x - (*b).x, 2) + pow((*a).y - (*b).y, 2));

}


float** f2dmalloc(int n, int m){

    int i;
    float **ptr;

    ptr = malloc(n * sizeof(float *));
    for (i = 0; i < n; i++) {
        ptr[i] = calloc(m, sizeof(float));
    }

    return ptr;

}



void floydwarshall(float **path, int n, float ** next){
    int i, j, k;
    float a, b;
    for (k = 0; k < n; k++) {
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                a = path[i][j];
                b = path[i][k] + path[k][j];
                path[i][j] = ((a) < (b) ? a : b);
                next[i][j] = k;

            }
        }
    }

}

int main (int argc, const char* argv[])
{



    int i;
    int j;
    int n;

    float temp;
    float mininum;

    scanf("%d", &n);

    /*
    A 2-dimensional matrix. At each step in the algorithm, path[i][j] is the shortest path
    from i to j using intermediate vertices (1..k−1).  Each path[i][j] is initialized to
    cost(i,j).
    */
    float ** path;
    float ** next;
    struct point* points;

    path = f2dmalloc(n, n);
    next = f2dmalloc(n, n);

    points = malloc(n * sizeof(struct point));

    for (i = 0; i < n; i++){
        scanf("%f %f", &(points[i].x), &(points[i].y));
    }


    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            path[i][j] = cost(&points[i], &points[j]);
        }
    }


    temp = 0;
    for (i = 0; i < n; i++) {
        mininum = FLT_MAX;
        for (j = 0; j < n; j++) {
            printf("%.3f\t", path[i][j]);
            if (path[i][j] < mininum && path[i][j] != 0){
                mininum = path[i][j];
            }

        }
        printf("\tminimum - %.3f\n", mininum);
        temp += mininum;
    }

    floydwarshall(path, n, next);


    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%.3f\t", next[i][j]);

        }
        printf("\n");
    }

    /*
    temp = 0;
    for (i = 0; i < n; i++) {
        mininum = FLT_MAX;
        for (j = 0; j < n; j++) {
            printf("%.3f\t", path[i][j]);
            if (path[i][j] < mininum && path[i][j] != 0){
                mininum = path[i][j];
            }

        }
            printf("\tminimum - %.3f\n", mininum);
        temp += mininum;
    }

    printf("%.3f\n", temp);

     */

    return 0;
}