Question

给出一个边上具有成本的无向图，找到从给定节点A到B的最短路径。让我们这样说：除了成本和边，我们在时间t = 0开始，对于每个节点给定一个带有某些时间的列表，您有时无法通过这些节点，并且那时候您无法执行任何操作，必须等到“它通过”。如声明所述，您是囚犯，您可以在牢房中进行传送，而传送时间需要花费边缘时间，而那些无能为力的时间就是监护人陪伴在牢房中时，在列表中给出的每个时间戳记所在的单元格中，请找到逃离监狱的最短时间。

我尝试过的事情：

我试图这样修改它：在普通的dijkstra中，您在找到每个节点的最短时间检查它是否是守护者，但它没有用..还有其他想法吗？

int checkGuardian(int min, int ind, List *guardians)
{
    for (List iter = guardians[ind]; iter; iter = iter->next)
        if(min == iter->value.node)
            return min + iter->value.node;

    return 0;
}

void dijkstra(Graph G, int start, int end, List *guardians)
{
    Multiset H = initMultiset();

    int *parent = (int *)malloc(G->V * sizeof(int));

    for (int i = 0; i < G->V; ++i)
    {
        G->distance[i] = INF;
        parent[i] = -1;
    }

    G->distance[start] = 0;

    H = insert(H, make_pair(start, 0));

    while(!isEmptyMultiset(H))
    {
        Pair first = extractMin(H);

        for (List iter = G->adjList[first.node]; iter; iter = iter->next)
            if(G->distance[iter->value.node] > G->distance[first.node] + iter->value.cost 
                                                + checkGuardian(G->distance[first.node] + iter->value.cost, iter->value.node, guardians))
            {
                G->distance[iter->value.node] = G->distance[first.node] + iter->value.cost 
                                                + checkGuardian(G->distance[first.node] + iter->value.cost, iter->value.node, guardians);
                H = insert(H, make_pair(iter->value.node, G->distance[iter->value.node]));
                parent[iter->value.node] = first.node;
            }
    }

    printf("%d\n", G->distance[end]);
    printPath(parent, end);
    printf("%d\n", end);
}

具有以下结构：

typedef struct graph
{
    int V;
    int *distance;
    List *adjList;
} *Graph;

typedef struct list
{
    int size;
    Pair value;
    struct list *tail;
    struct list *next;
    struct list *prev;
} *List;

typedef struct multiset
{
    Pair vector[MAX];
    int size;
    int capacity;
} *Multiset;

typedef struct pair
{
    int node, cost;
} Pair;

作为输入，您将获得节点数，边数和起始节点数。对于下一个数量的边线，您将读取两个边缘之间的边缘，并确定与该边缘相关的成本，然后，对于下一个数量的边线，如果您无法从该单元格中逃脱，则将读取字符“ N”，而“ Y”，如果您可以从该单元格逃脱，则监护人的时间戳数为时间戳数（即时间戳数）。对于此输入：

6 7 1
1 2 5
1 4 3
2 4 1
2 3 8
2 6 4
3 6 2
1 5 10
N 0
N 4 2 3 4 7
Y 0
N 3 3 6 7
N 3 10 11 12
N 3 7 8 9

我希望得到这样的输出：

12
1 4 2 6 3

但我得到以下输出：

10
1 4 2 6 3

在某些条件下修改dijkstra的算法

0 个答案: