Hej!
Hjälper en kompis med en skoluppgift. Koden är:

/* Dijkstras algorithm to compute the shortest path through a graph. */
#include <stdio.h>
#define MAX_NODES 6		/* maximum number of nodes */
#define INFINITY 1000	/* a number larger than every maximum path */

long n = MAX_NODES;

long dist[MAX_NODES][MAX_NODES] = {
	{0,2,3,1,0,0},
	{2,0,3,2,0,0},
	{5,3,0,3,1,5},
	{1,2,3,0,1,0},
	{0,0,1,1,0,2},
	{0,0,3,0,2,0}};
	
void shortest_path(int s, int t, int path[]) {
	/* the path being worked on */
	struct state {
		int predecessor;                  /* previous node */
		int length;                       /* length from source to this node */
		enum {permanent, tentative} label;/* label state */
	} state[MAX_NODES];
	
	int i, k, min;
	struct state *p;
	
	for (p = &state[0]; p < &state[n]; p++) {
		    /* initialize state */
	        p->predecessor = -1;
	        p->length = INFINITY;
	        p->label = tentative;
	}
	state[t].length = 0; 
	state[t].label = permanent;
	k = t;                                /* k is the initial working node */
	do {                                  /* Is there a better path from k? */
		for (i = 0; i < n; i++)       /* this graph has n nodes */
		if (dist[k][i] != 0 && state[i].label == tentative) {
			if (state[k].length + dist[k][i] < state[i].length) {
				state[i].predecessor = k;
				state[i].length = state[k].length + dist[k][i];
			}
		}
		
		/* Find the tentatively labeled node with the smallest label. */
		k = 0; min = INFINITY;
		for (i = 0; i < n; i++)
			if (state[i].label == tentative && state[i].length < min) {
				min = state[i].length;
				k = i;
			}
		state[k].label = permanent;
	} while (k != s);

   /* Copy the path into the output array. */
   i = 0; k = s;
   do {path[i++] = k; k = state[k].predecessor; } while (k >= 0);
}

int main() {
	int total,a,b,x=0,y=2,c[MAX_NODES]; 
	do	{
		printf("Source node number:");
		fflush(stdin);
		scanf("%d",&x);
		if(x >= MAX_NODES)
			printf("the source number can not.....");
	} while (x >= MAX_NODES);

	for (y = 0; y < MAX_NODES; y++) {
		if (x == y) y++;
		if (y == MAX_NODES) break;
				
		for (a = 0; a < MAX_NODES; a++) {
			c[a] = INFINITY;
		}
		
		shortest_path(x,y,c);
		total = 0;

		printf("nodes in path ");
		for ( a = 0; c[a] != INFINITY; a++) {
			printf("%d ",c[a]);
			total += dist[c[a]][c[a+1]]; // problem här
		}

		total -= dist[c[a-1]][c[a]]; // och här
		printf("\n minimum path from node %d to node %d has cost %d \n",x,y,total);
	}
	return;
}

Jag upplever koden som ganska rörig, åtminstone vid första anblick.

Segmentation faults är i stort sett alltid pekarproblem (det är därför man inte använder gammaldags språk som C, utan C++ istället =) ).

Om vi tittar på ena av raderna kan vi ju se att det finns tre möjligheter för den att krascha:
total += dist[c[a]][c[a+1]];

-c[a] (=addr1)
-c[a+1] (=addr2)
-dist[addr1][addr2]

Så antingen så är elementen i c större än MAX_NODES, eller så är a+1 större än MAX_NODES.
Jag skulle börja med att se till att skriva ut elementen för att kunna debugga det, alternativt använda en riktig debugger. Min spontana gissning är att en lösning på första felet är något i stil med:

for ( a = 0; (c[a] != INFINITY) && (a+1 < MAX_NODES); a++) {
printf("%d ",c[a]);
total += dist[c[a]][c[a+1]];
}

Du har rätt, koden är väldigt rörig. Det som stör mest är att jag fick den att fungera i fjol, men inte nu! Tack för hjälpen, stänger inlägget.