路由选择算法----JAVA版

import java.io.*;
import java.util.*;
public class RouteDesign {
    final static int maxnum = 100;
    final static int minint = 0;
    final static int maxint = 999999;
    static int dist [] = new int [maxnum];   //当前路径中的最小带宽
    static int mprev[] = new int [maxnum];   //当前节点的前一跳节点
    static int c[][] = new int [maxnum][maxnum]; // 两个节点之间的带宽
    static int hop[] = new int [maxnum]; //当前节点到源节点的跳数
    
    public static void Dijkstra(int n,int v,int b,int dist[],int mprev[],int c[][]){
    	boolean s[] = new boolean[maxnum];
    	
    	for(int i=1;i<=n;i++){
    		dist[i] = c[v][i];                  //这个循环用来说明当前链路到源节点的带宽，寻找源节点可以到达的所有节点
    		s[i]=false;
    		if(dist[i]==minint)
    			mprev[i] = 0;               //当前节点的前一跳节点为0
    		else{
    			mprev[i] = v;               //否则前一跳为源节点             
    			hop[i]=1;                   //重置跳数
    		}
    		
    	}
    	dist[v] = maxint;                           
    	s[v] = true;                                //源节点s[v]为true
    	for(int i=2;i<=n;i++){
    		int tmp = b;                        //tmp为所要求的带宽
    		int u = v;                          //u为源节点
    		for(int j=1;j<=n;j++){                      
    			if(!s[j]&&dist[j]>=tmp){       //s[j]为0并且当前带宽大于要求带宽  
    				u=j;                   //源节点等于当前节点
    				tmp=dist[j];           //保证带宽不会减小
    			}
    		}
    		s[u]=true;
    		for(int j=1;j<=n;j++){
    			int least = dist[u];           //least为u的带宽       
    			if(c[u][j]<dist[u])
    				least=c[u][j]; //最得u到其他节点最小带宽值
    			if((!s[j])&&(least>dist[j])){ //如果当前节点到源点的路径中的带宽过小，更新当前节点最小带宽及路径
    				hop[j]=hop[u]+1;
    				mprev[j]=u;
    				dist[j]=least;
    				
    			}
    			else if(!s[j]&&(least == dist[j])){ //如果相等则比较跳数，跳数小者成为当前节点的路径
    				if(hop[j]>hop[u]+1){
    					hop[j]=hop[u]+1;
    					mprev[j]= u;
    					dist[j]=least;
    				}
    				
    			}
    				
    		}
    	}
    }
    
    	public static void searchPath(int mprev[],int v,int u,String output) throws FileNotFoundException{
    		OutputStream out = new FileOutputStream(output,true);
    		
    		int que[] = new int[maxnum];
    		int tot=1;
    		que[tot]=u;
    		tot++;
    		int tmp = mprev[u];                //tmp为目的节点之前的节点
    		while(tmp!=v){                     //目的节点与源节点v不相等
    			que[tot] =tmp;                             
    			tot++;
    			tmp=mprev[tmp];            //从目的节点回溯 
    		}
    		que[tot]=v;                        //tot的值为回溯的次数                   
    		for(int i = tot;i>=i;i--){
    			if(i!=1){                                                          
    				int num=que[i];
    				try{
    					out.write(String.valueOf(num).getBytes());        //一个字符串转化为一个字节数组
    					out.write(",".getBytes());
    				}catch (IOException e){
    					e.printStackTrace();                           //打印堆栈内容
    				}
    			}
    			else{
    				try{
    					out.write(String.valueOf(que[i]).getBytes());
    					out.write("\r\n".getBytes());
    				}catch(IOException e){
    					e.printStackTrace();
    				}
    			}
    		}
    		try{
    			out.close();
    		}catch(IOException e){
    			e.printStackTrace();
    		}
    		
    	}
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
       String input = args[0];     //而这个main方法有所不同的是：它是所有方法中最先运行的一个，所以没有其他方法给它传递参数，所以需要靠运行时命令行输入参数，所以String args,接收的是命令行的输入
       String output = args[1];  
       BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File(input))) );
       String str = new String ();
       int NodeNum=0;
       int LineNum=0;
       Vector<String>vstr = new Vector<String>();
       Vector<String>dstr = new Vector<String>();   // java 中可以实现自动增长的对象数组
       
       str = in.readLine();                      //读取一个文本行        
       while(true){
    	   str=in.readLine();
    	   if(str.isEmpty()){
    		   break;
    	   }
    	   vstr.add(str);            // 把读入的对象加在vstr中
    	   LineNum++;           
       }    
        in.readLine();
        in.readLine();                 
        while(true){
        	str=in.readLine();
        	if(str==null)
        		break;
        	else if(str.isEmpty())
        		break;
        	dstr.add(str);       //     把目的读入的对象加在dstr中
       }
        
        String LastLine = (String)vstr.lastElement();                                      
        String[] strdata = LastLine.split("\\,");                         
        int firststr = Integer.parseInt(strdata[0]);
        int secondstr = Integer.parseInt(strdata[1]);      //根据，分割录入信息
        if(firststr<secondstr)
        	NodeNum = secondstr;
        else
        	NodeNum = firststr;
        for(int i=1;i<NodeNum;i++){
        	for(int j=1;j<NodeNum;j++){
        		c[i][j]=minint;           //建立整个拓扑
        	}
        	
        }
        
      for(int i=1;i<=LineNum;i++){                       
    	  String Readvstr = (String)vstr.get(i-1);          //get一个数字
    	  String [] vstrdata = Readvstr.split("\\,");          
    	  int firstvstr = Integer.parseInt(vstrdata[0]);      
    	  int secondvstr = Integer.parseInt(vstrdata[1]);         
    	  int thirdvstr = Integer.parseInt(vstrdata[2]);              
    	  if(thirdvstr>c[firstvstr][secondvstr]){
    		  c[firstvstr][secondvstr]=thirdvstr;      //取最小带宽                       
    		  c[secondvstr][firstvstr]=thirdvstr;
    		  
    	  }
      }
      for(int i=1;i<NodeNum;i++){
    	  dist[i]=minint;
    	  hop[i]=minint;                   
    	  
      }
      int src,dst,bdw;
      OutputStream out = new FileOutputStream(output,false);
      out.write("".getBytes());
      out.close();
      for(int i=1;i<=dstr.size();i++){
    	  String Readvstr = (String)dstr.get(i-1);
    	  String sdstr[] =Readvstr.split(",");
    	  src = Integer.parseInt(sdstr[0]);
    	  dst = Integer.parseInt(sdstr[1]);
    	  bdw = Integer.parseInt(sdstr[2]);
    	  Dijkstra(NodeNum,src,bdw,dist,mprev,c);
    	  searchPath(mprev,src,dst,output);
    	  
      }
	}

}