C++ dijkstra函数代码示例

void solve(){
  fscanf(fi,"%ld%ld",&n,&m);
  long i;
  g.s=n;
  for(i=1;i<=n;++i){
    index(g,i).s=0;
  }
  long u,v,c;
  for(i=0;i<m;++i){
    fscanf(fi,"%ld%ld%ld",&u,&v,&c);
    pute(index(g,u),v,c);
    printf("%ld %ld %ld\n",u,v ,c);
  }
  for(i=1;i<=n;++i){
    dijkstra(i);
  }
}

/*主程式*/ 
main()
{

  int Vs = 0;   /*Vs為起始頂點*/
  int Vi, i;
  
  dijkstra(Vs);
  
  for(Vi = 0; Vi < V; Vi++){
 	if (Vi == Vs) continue;
	  printf("V%d到V%d的最短距離為%d,\t路徑為V%d-->",Vs, Vi, distance[Vi], Vi);
      for(i = previous[Vi]; i != Vs ; i = previous[i])
        printf("V%d-->", i);
      printf("V%d\n", Vs);
    }  
  getchar();    
}

int main() 
{
	char i, j , k = 5;
	//char u = 1, v = 2, w = 4;

	store_cpu_rate(16);

	P0_DIR &= ~0x28;
	P0_ALT &= ~0x28;

	serial_init(19200);

	for(n=0;n<6;n++)
	{
		blink_led();
		mdelay(400);
	}

	n = GRAPHSIZE;


	while(1)
	{
		for (i = 0; i < n; i++)
			for (j = 0; j < n; j++)
				dist[i][j] = (k++)%30;
		//n = -1;
		//for (i = 0; i < 6; i++) {
		//fscanf(fin, "%d%d%d", &u, &v, &w);
		//	dist[u][v] = w++;
		//	n = MAX(u, MAX(v+w, n));
		//}
		//fclose(fin);
		for(j=0;j<n;j++)	
			dijkstra(j);

		dij_counter++;

		int_print(dij_counter);
		puts("\r\n");
		
		printD();
	}

	return 0;
}

	pair<cap_t, cost_t> maximum_flow(double source, double sink) {
		cap_t total_flow = 0;
		cost_t total_cost = 0;
		while (dijkstra(source, sink)) {
			cap_t f = mincap[sink];
			total_flow += f;
			for (double p = sink; p != source;) {
				auto &backward = graph[p][from[p]];
				auto &forward = graph[backward.target][backward.rev];
				forward.cap -= f;
				backward.cap += f;
				total_cost += forward.cost * f;
				p = backward.target;
			}
		}
		return make_pair(total_flow, total_cost);
	}

int main() {
	freopen("input.txt", "r", stdin);
	scanf("%d%d%d", &n, &s, &m);
	for (int i = 1; i <= s; i++) {
		int x; scanf("%d", &x);
		w[x] = true;
	}
	for (int i = 1; i <= m; i++) {
		scanf("%d%d%d", &r[i].x, &r[i].y, &r[i].c);
		addedge(r[i].x, r[i].y, r[i].c);
	}
	dijkstra();
	t = 0;
	std::fill(h + 1, h + n + 1, 0);
	std::fill(fa + 1, fa + s + 1, 0);
	for (int i = 1; i <= m; i++) {
		tree[i] = (Road){c[r[i].x], c[r[i].y], d[r[i].x] + d[r[i].y] + r[i].c};
	}
	std::sort(tree + 1, tree + m + 1);
	for (int i = 1; i <= m; i++) {
		int fx = getfa(tree[i].x), fy = getfa(tree[i].y);
		if (fx == fy) continue;
		addedge(tree[i].x, tree[i].y, tree[i].c);
		fa[fx] = fy;
	}
	std::fill(v + 1, v + n + 1, false);
	for (int i = 1; i <= s; i++)
		if (!v[i]) buildtree(i);
	scanf("%d", &q);
	for (int cs = 1; cs <= q; cs++) {
		int x, y, d;
		scanf("%d%d%d", &x, &y, &d);
		x = c[x];
		y = c[y];
		if (getfa(x) != getfa(y)) {
			puts("NIE");
			continue;
		}
		int l = getLca(x, y);
		long long vmax = -INF;
		vmax = std::max(vmax, getValue(x, dep[x] - dep[l]));
		vmax = std::max(vmax, getValue(y, dep[y] - dep[l]));
		printf("%s\n", (vmax <= d) ? "TAK" : "NIE");
	}
	return 0;
}

int main()
{
    scanf("%d %d",&nNodos,&nAristas);
    for(int i = 0; i < nAristas; i++){
        int a,b,v;
        scanf("%d %d %d",&a,&b,&v);
        agregaArista(a,b,v);
    }
    scanf("%d",&inicio);
    dijkstra(inicio);
    for(int i=1;i<=nNodos;i++){
        printf("%d %d\n",i,resultado[i]);
        imprimeTrayecto(i);
        printf("\n");
    }
    return 0;
}

int main()
{
    int G[MAX][MAX],i,j,n,u;
    printf("Enter no. of vertices:");
    scanf("%d",&n);
    printf("\nEnter the adjacency matrix:\n");
    
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            scanf("%d",&G[i][j]);
    
    printf("\nEnter the starting node:");
    scanf("%d",&u);
    dijkstra(G,n,u);
    
    return 0;
}

void* startWorking(void* threadArgs){
 	int k, i;
 	THREADARGS* args = (THREADARGS*)threadArgs;
	int myID = args->id;					/* Current processor No */
	uVertex[myID].iDist=NONE;
	uVertex[myID].iPID=myID;
	uVertex[myID].iNID=NONE;								
	/* Step 2: */
	for (i=myID*(NUM_NODES/PROCESSORS); (i<(myID+1)*(NUM_NODES/PROCESSORS)+(myID+1==PROCESSORS && NUM_NODES%PROCESSORS!=0 ? NUM_NODES%PROCESSORS:0)); i++) {
		rgnNodes[i].iDist =  AdjMatrix[chStart][i];
		rgnNodes[i].iPrev = NONE;
	}
	actuateBarrier(&myBarrier);				/* Actuate the barrier */
	/* Step 3: */
	dijkstra(myID);
	return NULL;
}

int main()
{
            int graph[NODES][NODES] = { 
			{0,  22, 9, 12,  0,  0,  0,  0,  0},
            {22, 0, 35,  0,  0, 36,  0, 34,  0},
            {9,  35, 0,  4,  65, 42, 0,  0,  0},
            {12, 0,  4,  0,  33, 0,  0,  0, 30},
            {0,  0, 65, 33,  0,  18, 23, 0,  0},
            {0,  36, 42, 0,  18, 0,  39, 24, 0},
            {0,  0,  0,  0,  23, 39, 0,  25, 21},
            {0,  34, 0,  0,  0,  24, 25, 0,  19},
            {0,  0,  0,  30, 0,  0,  21, 19, 0} };
 			//Call dijkstra function 
            dijkstra(graph, 0);
            std::cout<<"\n\n";
            return 0;
}

void dijkstra(int n){
    int i;
    int min_now = -1;
    for(i = 1; i < n; i++){
        if(!used[i] && dis1[i] != MAX){
            if(min_now == -1) min_now = i;
            else if (dis1[min_now] > dis1[i]) min_now = i;
        }
    }
    if(min_now == -1)return;
    used[min_now] = 1;
    for(i = 1; i < n; i++){
        if(dis1[min_now] + dis[min_now][i] < dis1[i])
            dis1[i] = dis1[min_now] + dis[min_now][i];
    }
    dijkstra(n);
}

main(int argc, char* argv[]) {
	int i, n, m, maxLen, repCount, retVal, seed;
	int notZero, minTsiz, maxTsiz, avgTsiz;
	edge e; vertex u, v;
	Wdigraph dig, *sptree;

	if (argc != 6 ||
	    sscanf(argv[1],"%d",&n) != 1 ||
	    sscanf(argv[2],"%d",&m) != 1 ||
	    sscanf(argv[3],"%d",&maxLen) != 1 ||
	    sscanf(argv[4],"%d",&repCount) != 1 ||
	    sscanf(argv[5],"%d",&seed) != 1)
		fatal("usage: sptUpdate n m maxLen repCount seed");

	srandom(seed);
	dig.rgraph(n,m); dig.randLength(0,maxLen);

	vertex *p = new int[n+1]; int *d = new int[n+1];
	dijkstra(dig,1,p,d);

	notZero = 0; minTsiz = dig.n(); maxTsiz = 0; avgTsiz = 0;
	for (i = 1; i <= repCount; i++) {
		e = randint(1,dig.m());
		retVal = sptUpdate(dig,p,d,e,randint(1,maxLen));
		if (retVal > 0) {
			notZero++;
			minTsiz = min(retVal,minTsiz);
			avgTsiz += retVal;
			maxTsiz = max(retVal,maxTsiz);
		}
		/* for verification only
		sptree = new Wdigraph(dig.n,dig.n-1);
		for (e = dig.first(); e != 0; e = dig.nextOut(e)) {
			u = dig.tail(e); v = dig.head(e);
			if (p[v] == u) sptree->join(u,v,d[v]);
		}
		check(1,dig,*sptree);
		delete sptree;
		*/
	}

	cout << setw(6) << notZero << " " << setw(2) << minTsiz
	     << " " << (notZero > 0 ? double(avgTsiz)/notZero : 0.0)
	     << " " << setw(4) << maxTsiz;
}

int main()
{
    int i, j, n, v0, v;
    n = 7;
    initCost();
    printf("Input v0(-1 for quit): ");
    scanf("%d", &v0);
    v = v0 - 1;
    while(v != -2)
    {
        for(i = 0; i < n; i++)
            path[i] = -1;
        dijkstra(n, v);
        for(i = 0; i < n; i++)
        {
            if(i != v)
            {
                if(miniDistance[i] < MAXCOST)
                {
                    printf("DIST[%d, %d]=%d\n", v0, i+1, miniDistance[i]);
                    //输出最短路径所经过的顶点
                    printf("    V%d --> ", v0);
                    for(j = 0; path[j] != i; j++)
                    {
                        printf("V%d", path[j]+1);
                        if(path[j+1] != i)
                            printf(" --> ");
                    }
                    if(path[0] == i)
                        printf("V%d", i+1);
                    else
                        printf(" --> V%d", i+1);
                    printf("\n");
                }
                else
                {
                    printf("DIST[%d, %d]=NONE!\n", v0, i+1, miniDistance[i]);
                }
            }
        }
        printf("\nInput v0(-1 for quit): ");
        scanf("%d", &v0);
        v = v0 - 1;
    }
}

int main() {
	int arr[SIZE][SIZE] = {
		0, 0, 0, 0, 0, 0,
		0, INF, 7, 4, 6, 1,
		0, INF, INF, INF, INF, INF,
		0, INF, 2, INF, 5, INF,
		0, INF, 3, INF, INF, INF,
		0, INF, INF, INF, 1, INF
	};
	int touch[SIZE] = { 0 };
	int length[SIZE] = { 0 };
	Edge selectEdge[VERTEX_COUNT] = { 0, 0, 0 };

	dijkstra(arr, touch, length, selectEdge);
	edgePrint(1, length);

	return 0;
}

std::pair
  < typename dijkstra_state_helper<Graph, Params>::type
  , typename distance_visitor_helper_indirect<Graph, Params>::type>
dijkstra_shortest_path_distance(
  const Graph& g, 
  typename boost::graph_traits<Graph>::vertex_descriptor source, 
  DistanceValue target_distance,
  const Params& params)
{
  typedef typename dijkstra_state_helper<Graph, Params>::type state_type;
  typedef typename distance_visitor_helper<state_type>::type visitor_type;
  state_type state = make_dijkstra_state(g, params);
  visitor_type visitor = make_distance_visitor(state, target_distance);
  resumable_dijkstra<state_type> dijkstra(state);
  dijkstra.init_from_source(source, visitor);
  dijkstra.expand(visitor, visitor);
  return std::make_pair(state, visitor);
}

// driver program to test above function
int main()
{
    int i, j;
   /* Let us create the example graph discussed above */
    scanf("%d %d", &x, &y);
    int graph[x][y];
    for (i = 0; i < x; i++) {
        for (j = 0; j < y; j++) {
            graph[i][j] = 1;
        }
    }
    while (scanf("%d %d", &i, &j) != EOF)
        graph[i][j] = 500;

    dijkstra(graph, 0);

    return 0;
}