Question

我有一个算法任务，它会在图表中找到最长的路径。我将在输入中输入两个数字(N,M)，表示矩阵的大小和N*M个数字。它们表示每个顶点的值。我必须找到从第一个顶点到最后一个的最长路径，我只能向下或向右移动。所以输入例如：

输出

最长路径包括这些顶点的顺序：1,3,2,4,3,2,2,2

我使用过Bellman-Ford算法，因为我已将每个顶点的值更改为负值。但是这个算法对于大量的数据（1000x1000）来说太慢了。是否有任何选项可以更改此算法以仅在两个顶点（第一个和最后一个）之间找到最大的方式，而不是在第一个顶点和每个其他顶点之间找到？这是我的代码：

# include <stdio.h>
# include <stdlib.h>


typedef struct {
    int source;
    int dest;
    int weight;
} Edge;

void BellmanFord(Edge edges[], int edgecount, int nodecount, int source)
{
    int *distance = malloc(nodecount * sizeof *distance);
    int i, j;

    distance[source] = -1;

    for (i=0; i < nodecount; ++i) {
        for (j=0; j < edgecount; ++j) {
            if (distance[edges[j].source] < 0) {
                int new_distance = distance[edges[j].source] + edges[j].weight;
                if (new_distance < distance[edges[j].dest])
                  distance[edges[j].dest] = new_distance;
            }
        }
    }
    printf("%d\n",-distance[nodecount-1]-1);
    free(distance);
    return;
}

int main(void)
{
    Edge *edges;
    edges = malloc(2000000*sizeof(Edge));
    int n,m,i,k,chodbapomoc,q = 0,p = 0,pamat;
    scanf("%d %d",&n,&m);
    for(i = 0; i < n*m;i++){    //this is transformation of input to edges 
       if(i != n*m-1)           //list, so i can go only down or right 
           scanf("%d",&chodbapomoc);
       if(p%m != m-1 && p != 0){
          edges[q].source = p;
          edges[q].dest = p+1;
          edges[q++].weight = -chodbapomoc;
       }
       else if(i == 0){
          k = chodbapomoc;
          scanf("%d",&chodbapomoc);
          edges[q].source = p;
          edges[q].dest = p+1;
          edges[q++].weight = -chodbapomoc-k;
       }
       if(p > m-1 && p != m){
          edges[q].source = p-m;
          edges[q].dest = p;
          edges[q++].weight = -pamat;
       }
       else if(i == m-1){
          edges[q].source = 0;
          edges[q].dest = m;
          edges[q++].weight = -chodbapomoc-k;
       }
       pamat = chodbapomoc;
       p++;
    }
    BellmanFord(edges, q, n*m, 0);
    return 0;
}

或者还有其他选择，比这更快，找到DAG中最长的路径？并且，有什么方法可以记住最大路径中的哪些验证？

感谢您的回复

Answer 1

可以进行算法改进：在您的情况下，复杂度可以是O(N)，其中N是图像上的点数。

Bellman-Ford algorithm旨在处理任何weighted digraph。在最坏的情况下，其复杂性为O(mn)，其中n是节点数，m是边数。

请注意，您的有向图是acyclic：图表中没有定向循环。从任何一点来看，都有＆＃34;未来的观点＆＃34; （您将来访问它们）和过去的点数＆＃34; （你可能来自那里）。 Kahn算法使用此属性来执行topological sorting。最后，这种有向图中的最短路径算法依赖于拓扑排序，总复杂度为O(n+m)！

由于您正在处理数组，并且由于只允许top-＆gt; bottom和left-＆gt;右移动，因此很容易找到拓扑排序。只需从左到右依次访问这些线路，并在途中更新最大距离！在程序结束时，图像填充距离源的最大距离。有四种不同的情况：

i==0 && j==0：这是源点。它的最大距离等于它的重量。
i==0 && j!=0：这是第一行中的一点。到达那里的唯一方法是向左走。因此，它的最大距离是从行首开始的权重之和。
i!=0 && j==0：这是第一栏中的一点。到达那里的唯一方法是下降。因此，它的最大距离是来自列的开始的权重之和。
i!=0 && j!=0：一般情况。请注意，点(i-1,j)和(i,j-1)已经存在距离源的最大距离。距离(i,j)的最大距离是这两个距离中最大的一个加上点(i,j)的权重。

最终数组存储距离源的最大距离。另一个数组存储路径信息（最大值来自哪里？）。

第一行：

1 3 8 9 11    s l l l l

第二行：

1 3 8 9  11    s l l l  l
4 6 9 11 12    u l u lu lu

第三行：

1 3  8  9  11    s l l l  l
4 6  9  11 12    u l u lu lu
5 10 13 15 16    u u l l  l

最后一行：

1 3  8  9  11    s l l l  l
4 6  9  11 12    u l u lu lu
5 10 13 15 16    u u l l  l
8 11 15 17 19    u u u lu l

由于右侧的阵列，可以轻松地检索2条最长的路径。该阵列只读一次：这个技巧应该将你的计算时间缩短几个数量级，它仍然为你提供了精确的解决方案！

如果它仍然太慢并且近似解决方案足够，请查看simulated annealing。要探索的空间是DDRRRDR n-1 D（向下）和m-1 R（右）等路径。能量将是-distance(DDRRRDR)，一个小修改将交换一个D和一个R。

以下是由gcc main.c -o main -Wall编译的精确解（不退火）的示例代码。编辑：它现在也打印出一条最大长度的路径。

# include <stdio.h>
# include <stdlib.h>



typedef enum {S,L,U,LU} Direction;


int main(void)
{
    FILE * pFile;
    int n=1,m=1,i,j;
    int* image;
    pFile = fopen ("image.txt","r");
    if (pFile!=NULL)
    {
        if(fscanf(pFile,"%d%d",&n,&m)!=2){printf("read failed\n");exit(1);}
        image=malloc(n*m*sizeof(int));
        if(image==NULL){printf("malloc failed\n");exit(1);}
        for(i=0;i<n*m;i++){
            if(fscanf(pFile,"%d",&image[i])!=1){printf("read failed %d\n",i);exit(1);}
        }
        fclose (pFile);
    }else{printf("file open failed\n");exit(1);}

    Direction* directions=malloc(n*m*sizeof(Direction));

    for(i=0;i<n;i++){
        for(j=0;j<m;j++){
            //getting the direction of max
            if(i==0 && j==0){
                directions[i*m+j]=S;
            }
            if(j==0 && i>0){
                directions[i*m+j]=U;
            }
            if(j>0 && i==0){
                directions[i*m+j]=L;
            }
            if(j>0 && i>0){
                if(image[i*m+(j-1)]>image[(i-1)*m+j]){
                    directions[i*m+j]=L;
                }else{
                    if(image[i*m+(j-1)]<image[(i-1)*m+j]){
                        directions[i*m+j]=U;
                    }else{
                        directions[i*m+j]=LU;
                    }
                }
            }
            //setting the new value of image[i*m+j]
            if(directions[i*m+j]==L){
                image[i*m+j]+=image[i*m+j-1];
            }else{
                if(directions[i*m+j]==U || directions[i*m+j]==LU){
                    image[i*m+j]+=image[(i-1)*m+j];
                }
            }

        }
    }

    printf("max distance is %d\n",image[n*m-1]);

            printf("A path from the end is\n");
    char path[n+m-1];
    path[n+m-2]='\0';
    int cnt=n+m-3;
    i=n-1;
    j=m-1;
    printf("(%d %d)\n",i,j);
    while(i!=0 || j!=0){
        if(directions[i*m+j]==LU){printf("many possible max path. going left\n");}
        if(directions[i*m+j]==U){
            printf("D ");
            path[cnt]='D';
            i--;
        }else{
            printf("R ");
            path[cnt]='R';
            j--;
        }
        cnt--;
        printf("(%d %d)\n",i,j);
    }

    printf("A max path is %s\n",path);
    free(directions);
    free(image);


    return 0;
}

图像在文件image.txt中提供，如下所示：

一个。 B.汗，Topological sorting of large networks ACM的通讯第19卷，第11期，1962年11月第558-562页：10.1145 / 368996.369025

一个顶点的Bellman-ford算法

1 个答案: