graph — Модификация реализации Prim для записи веса кратчайшего пути Переполнение стека

У меня возникли проблемы с получением этой реализации Prim для отслеживания общего веса кратчайшего пути, который он находит. Путь кажется правильным, но я не могу понять, где суммировать веса, когда они добавляются в массив, в котором хранятся пути (так как он был записан только для хранения используемых путей).

Я попытался суммировать pCrawl-> weight, когда каждая вершина добавляется в MST, но это, кажется, сумма всех весов на графике. То же самое с ключом значений [].

Мой вопрос заключается в том, что можно суммировать при каждом добавлении пути к MST, чтобы отразить общий вес MST, когда были добавлены все кратчайшие пути.

Вот код, который я использую: http://pastebin.com/TFLGCE0L

Список Смежности, который я сделал: http://pastebin.com/SvgGjEPj

И карта, использованная для его создания: карта

Функция Prim выглядит следующим образом:

// The main function that constructs Minimum Spanning Tree (MST)
// using Prim's algorithm
void PrimMST(struct Graph* graph)
{
int V = graph->V;// Get the number of vertices in graph
int parent[V];   // Array to store constructed MST
int key[V];      // Key values used to pick minimum weight edge in cut

// minHeap represents set E
struct MinHeap* minHeap = createMinHeap(V);

// Initialize min heap with all vertices. Key value of
// all vertices (except 0th vertex) is initially infinite
for (int v = 1; v < V; ++v)
{
parent[v] = -1;
key[v] = INT_MAX;
minHeap->array[v] = newMinHeapNode(v, key[v]);
minHeap->pos[v] = v;
}

// Make key value of 0th vertex as 0 so that it
// is extracted first
key[0] = 0;
minHeap->array[0] = newMinHeapNode(0, key[0]);
minHeap->pos[0]   = 0;

// Initially size of min heap is equal to V
minHeap->size = V;

// In the followin loop, min heap contains all nodes
// not yet added to MST.
while (!isEmpty(minHeap))
{
// Extract the vertex with minimum key value
struct MinHeapNode* minHeapNode = extractMin(minHeap);
int u = minHeapNode->v; // Store the extracted vertex number

// Traverse through all adjacent vertices of u (the extracted
// vertex) and update their key values
struct AdjListNode* pCrawl = graph->array[u].head;
while (pCrawl != NULL)
{
int v = pCrawl->dest;

// If v is not yet included in MST and weight of u-v is
// less than key value of v, then update key value and
// parent of v
if (isInMinHeap(minHeap, v) && pCrawl->weight < key[v])
{
key[v] = pCrawl->weight;
parent[v] = u;
decreaseKey(minHeap, v, key[v]);
}
pCrawl = pCrawl->next;
}
}

Используемые структуры выглядят так:

// A structure to represent a node in adjacency list
struct AdjListNode
{
int dest;
int weight;
struct AdjListNode* next;
};

// A structure to represent an adjacency liat
struct AdjList
{
struct AdjListNode *head;  // pointer to head node of list
};

// A structure to represent a graph. A graph is an array of adjacency lists.
// Size of array will be V (number of vertices in graph)
struct Graph
{
int V;
struct AdjList* array;
};
// Structure to represent a min heap node
struct MinHeapNode
{
int  v;
int key;
};

// Structure to represent a min heap
struct MinHeap
{
int size;      // Number of heap nodes present currently
int capacity;  // Capacity of min heap
int *pos;     // This is needed for decreaseKey()
struct MinHeapNode **array;
};

Я чувствую, что нахожусь в курсе этого курса по структурам данных, поэтому пытаюсь использовать код из Интернета для решения этой небольшой части задания без полного понимания: /

Спасибо,

Майкл