杭电oj h1874 畅通工程续 java版

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class h1874 {
    
    //求dp数组的最小值的下标，要保证次下标没有松弛过，这里用了一个HashSet来保证唯一
    //如果都松弛一遍或者无法松弛那么返回-1
	public static int min(int dp[],Set<Integer> s) {
		int min=10001;
		int j=-1;
		for(int i=0;i<dp.length;i++) {
    		if(dp[i]>0&&dp[i]<10000) {
    			if(!s.contains(i)&&dp[i]<min) {
    				min=dp[i];
    			    j=i;
    			}
    		}
    	}
		s.add(j);
		return j;
		
	}
    public static int dj(int arr[][],int q,int z,int dp[]) {
    	Set<Integer> s=new HashSet<Integer> ();
    	while(true) {
    		int j=min(dp,s);
            //如果松弛到了目的点或者个点都进行松弛那么跳出循环
    		if(j==z||j==-1) {
    			break;
    		}
            //松弛
    		for(int i=0;i<arr[j].length;i++) {
    			if(arr[j][i]+dp[j]<dp[i]) {
    				dp[i]=arr[j][i]+dp[j];
    			}
    		}
    	}
    	if(dp[z]!=10000) {
    		return dp[z];
    	}else {
		return -1;
    	}
    	
    }
	public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            while(sc.hasNext()) {
            	int a=sc.nextInt();
            	int b=sc.nextInt();
            	int arr[][]=new int[a][a];
            	for(int i=0;i<arr.length;i++) {
            		for(int j=0;j<arr[i].length;j++) {
            			arr[i][j]=10000;
            		}
            	}
            	for(int i=0;i<arr.length;i++) {
            		arr[i][i]=0;
            	}
            	for(int i=0;i<b;i++) {
            		int x=sc.nextInt();
            		int y=sc.nextInt();
            		int c=sc.nextInt();
            		if(arr[x][y]>c) {
            		arr[x][y]=c;
            		arr[y][x]=c;
            		}
            	}
            	int q=sc.nextInt();
            	int z=sc.nextInt();
  
            	int dp[]=new int[a];
               for(int i=0;i<arr[q].length;i++) {
            	   dp[i]=arr[q][i];
               }
              
            System.out.println(dj(arr,q,z,dp));
            
            }
	}

}

思路总结：

 这里输入的话有可能在相邻2点的权值有多个，这里要保证最小权值

我用的是迪杰斯特拉算法 稍微改了下 没有把该点到全部点的最短路径求出来，如果dp 数组 进行松弛的时候，松弛的点是目的点 就可以不要进行松弛了，直接进行判断dp[ 目的点]如果 还是无穷大那么就输出-1反之输出 值，