dijkstra、heap+dijkstra、扩展应用

heap+dijkstra
堆优化的dij，就是在更新最短路时，将更新最短距离的点的编号和当前最短距离压入优先队列，下一次再取点的时候不需要遍历了。注意当取出的点的最短距离大于更新之后的最短距离时，就弃之不用。
时间复杂度O(|E|log(|V|)。
板子：

public class Main {
	static int maxn=220,n,INF=Integer.MAX_VALUE/2;
	static int dist[]=new int[maxn];
	static Vector<Edge> G[]=new Vector[maxn];
	static class Edge{
	//自己看情况写吧
	}
	static class Hpnd implements Comparable<Hpnd>{
		int v,w;
		public Hpnd(int v,int w) {
			this.v=v;
			this.w=w;
		}
		@Override
		public int compareTo(Hpnd o) {
			// TODO Auto-generated method stub
			return this.w-o.w;
		}
	}
	static void dij(int s) {
		for(int i=0;i<=n;i++) {
			dist[i]=INF;
			path[i]=-1;
		}
		dist[s]=0;
		count[s]=1;
		PriorityQueue<Hpnd> q=new PriorityQueue<Main.Hpnd>();
		Hpnd nd;
		q.add(new Hpnd(s,0));
		//vis[s]=true;
		Edge e;
		while(!q.isEmpty()) {
			nd=q.poll();
			if(nd.w>dist[nd.v]) continue;
			int u=nd.v;
			for(int i=0;i<G[u].size();i++) {
				e=G[u].get(i);
				if(dist[e.v]>dist[u]+e.w) {
						dist[e.v]=dist[u]+e.w;
						q.add(new Hpnd(e.v,dist[e.v]));
				}
			}
		}
	}
}

扩展应用
1.图中点与路均有权值,且存在多条最短路,要求输出最短路条数、点权和最小的最短路路径及其点权和。

1）如何求最短路数量？
数据结构：开一个
count[]数组，记录到某点的最短路条数。
代码：在dij算法中的“更新各点最短路d[i]”的部分，除了判断体①d[u]>d[v]+cost[v][u]，还要新增判断体②d[u]==d[v]+cost[v][u]；在前者，更新count[u]=count[v],在后者更新count[u]+=count[v].
初始化：count[s]=0,其余为0

2）如何找到最短路中的最大点权和？
数据结构：开sum[]数组记录到点i的最短路径中点权和最大的路径的点权和（好绕= =）。开val[]存每个点的和，这个是固定的。
代码：在判断体①中，写sum[u]=sum[v]+val[u];在②中,if(sum[u]<sum[v]+val[u]),更新sum[u]=sum[v]+val[u]；
初始化：sum[s]=val[s];其余为0

3)如何将2)中的那条路记录下来?
path[]数组反向记录即可.即path[i]=j表示点i的最短路是由j点转来的.如果正向,由于一个点可能通向多个点,且均为到这些点的最短路,那么会产生覆盖.

天梯赛 L2-001 紧急救援 ac代码

public class Main {
	static int INF=0xffffff;
	static int dist[]=new int[550],cost[][]=new int[550][550],
			path[]=new int[550],sum[]=new int[550],val[]=new int[550],count[]=new int[550];
	static boolean used[]=new boolean[550];
	static void dij(int s,int n) {
		int res=0;
		for(int i=0;i<n;i++) {
			dist[i]=INF;
			used[i]=false;
			path[i]=-1;
			sum[i]=0;
			count[i]=0;
		}
		count[s]=1;
		sum[s]=val[s];
		//used[s]=true;
		dist[s]=0;
		int v;
		while(true) {
			v=-1;
			for(int u=0;u<n;u++) {
				if(!used[u]&&(v==-1||dist[u]<dist[v])) {
					v=u;
				}
			}
			if(v==-1) {
				break;
			}
			used[v]=true;
			for(int u=0;u<n;u++) {
				if(dist[u]>dist[v]+cost[v][u]) {
					count[u]=count[v];
					dist[u]=dist[v]+cost[v][u];
					path[u]=v;
					sum[u]=sum[v]+val[u];
				}else if(dist[u]==dist[v]+cost[v][u]) {
					count[u]+=count[v];
					if(sum[u]<sum[v]+val[u]) {
						sum[u]=sum[v]+val[u];
						path[u]=v;
					}
				}
			}	
		}
	}
	
    public static void main(String args[]) throws IOException {
        //System.out.println(Integer.parseInt("-5"));
        PrintWriter out=new PrintWriter(System.out);
        InputReader sc=new InputReader(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int s=sc.nextInt();
        int d=sc.nextInt();
        for(int i=0;i<n;i++) {
        	val[i]=sc.nextInt();
        }
        for(int i=0;i<n;i++) {
        	for(int j=i;j<n;j++) {
        		cost[i][j]=INF;
        		cost[j][i]=INF;
        	}
        }
        int u,v,c;
        for(int i=0;i<m;i++) {
        	u=sc.nextInt();
        	v=sc.nextInt();
        	c=sc.nextInt();
        	cost[u][v]=c;
        	cost[v][u]=c;
        }
        dij(s,n);
        out.println(count[d]+" "+sum[d]);
        int cur=d;
        ArrayList<Integer> list=new ArrayList<Integer>();
        list.add(d);
        while(path[cur]!=-1) {
        	list.add(path[cur]);
        	cur=path[cur];
        }
        for(int i=list.size()-1;i>=0;i--) {
        	out.print(list.get(i));
        	if(i!=0) {
        		out.print(" ");
        	}
        }
        out.flush();
        out.close();
    }
}