算法导论 · 动态规划 · 多段图问题

• 算法说明
  计算开始点到结束点的最短路径长度，从后往前记录最短路径长
  
  COST(4，9) ＝ 4，COST(4，10) ＝ 2，COST(4，11) ＝ 5
  COST(3，6) ＝ min{6 + COST(4，9)，5 + COST(4，10)} ＝ 7
  COST(3，7) ＝ min{4 + COST(4，9)，3 + COST(4，10)} ＝ 5
  COST(3，8) ＝ 7
  COST(2，2) ＝ min{4 + COST(3，6)，2 + COST(3，7)，1 + COST(3，8)}=7
  COST(2，3) ＝ 9
  COST(2，4) ＝ 18
  COST(2，5) ＝ 15
  COST(1，1) ＝ min{9 + COST(2，2)，7 + COST(2，3)，3 + COST(2，4)， 2 + COST(2，5)} ＝ 16
• 源代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <limits.h>
 
#define MAX_VERTEX_NUM 20
#define MAX_VALUE_TYPE INT_MAX
 
typedef struct node{
    int adjvex;
    int weight; //权值
    struct node *next;
}EdgeNode;
 
typedef struct vnode{
    int vertex;  //顶点域
    EdgeNode *firstedge;
}VertexNode;
 
typedef VertexNode AdjList[MAX_VERTEX_NUM];
 
typedef struct{
    AdjList adjlist;
    int n,e;    //顶点数和边数
}ALGraph;

void CreateALGraph(ALGraph *G){//建立有向图的邻接表
    int i,j;
    int k;
    EdgeNode *s;
    scanf("%d%d", &G->n, &G->e);
    for(i=0; i < G->n; i++){
        scanf("%d", &G->adjlist[i].vertex);//G->adjlist[i].vertex = getch();
        G->adjlist[i].firstedge = NULL; //边表设置成空表
    }
    for(k=0; k<G->e; k++){
        scanf("%d%d", &i, &j);
        s = (EdgeNode *)malloc(sizeof(EdgeNode));
        scanf("%d", &s->weight);
        s->adjvex = j;  //邻接点序号为j
        s->next = G->adjlist[i].firstedge;
        G->adjlist[i].firstedge = s;
    }
}
 
int fgraph(ALGraph *G, int route[], int n){
    int i;
    EdgeNode *pnode;
 
    int *path = (int *)malloc(n*sizeof(int)); //记录路径 
    int min_cost, *cost = (int*)malloc(n*sizeof(int));
    
    for(i=0; i<n; i++){
        cost[i] = MAX_VALUE_TYPE; path[i] = -1; route[i] = 0;
    }
    
    cost[n-1] = 0;
    for(i=n-1; i>=0; i--){
        pnode = G->adjlist[i].firstedge;
        while(pnode != NULL){
            if(pnode->weight + cost[pnode->adjvex] < cost[i]){
                cost[i] = pnode->weight + cost[pnode->adjvex];
                path[i] = pnode->adjvex;
            }
            pnode = pnode->next;
        }
    }
    
    i = 0;
    while((route[i] != n-1) && (path[i] != -1)){
        i++;
        route[i] = path[route[i-1]];
    }
    
    min_cost = cost[0];
    free(path); free(cost);
    return min_cost;
}
 
 
void print(ALGraph *G){
    EdgeNode *p;
    int i;
    for(i=0; i<G->n; i++){
        for(p = G->adjlist[i].firstedge; p; p = p->next){
            printf("(%d, %d, %d) ", G->adjlist[i].vertex, p->adjvex, p->weight); 
        }
        putchar('\n');
    }
}
 
int main(){
    freopen("1.multistageGraphProblemInput.txt", "r", stdin);
    int route[MAX_VERTEX_NUM];
    ALGraph G;
    CreateALGraph(&G); //创建图 
//    print(&G);
    printf("%d", fgraph(&G, route, G.n)); //最短路径 
//    for(int i = 0; i < G.n; i++){
//        printf("\t%d", route[i]);
//    }
    return 0;
}

• 输入数据
  
• 输出结果