图论算法

图论算法

广度优先

public static void BFS(){
    int[][] A=new int[][]{{0,1,1,1,0},{1,0,0,1,0},{1,0,0,0,1},{1,1,0,0,0},{0,0,1,0,0}}; 
    int n = A.length;//元素个数
    boolean[] visit=new boolean[n]; //visit[i]标记是否被遍历过,遍历过为true
    int startNode=1;  

    System.out.println("BFS");
    Queue<Integer> queue = new LinkedList<Integer>();                    
    queue.offer(startNode);
    //起始结点装入队列
    visit[startNode]=true;

    while(!queue.isEmpty()){                                            
        int temp=(int)queue.poll(); 
        System.out.print(temp);
        for (int k= 0; k<n; k++) { 
            if (A[temp][k]>0&&visit[k]==false&&temp!=k) { 
                queue.offer(k);                                                     
                visit[k] = true;                                                     
            }
        }
    }
}

深度优先

static int[][] A=new int[][]{{0,1,1,1,0},{1,0,0,1,0},{1,0,0,0,1},{1,1,0,0,0},{0,0,1,0,0}}; 
static int n = A.length;//元素个数
static boolean[] visit=new boolean[n]; 
static int startNode=1;    

public static void getDFSbyRecursive(int i){
        visit[i] = true;
        System.out.print(i);
        for(int j=0;j<n;++j){
            if(visit[j]==false && A[i][j]>0){
                getDFSbyRecursive(j);
            }
        }
    }
/*
 * DFS:深度优先
 */
public static void DFS(){
    //DFS
    System.out.println();
    System.out.println("DFS");

    //递归形式
    for (int i = 0; i < n; i++) { //visit[i]标记是否被遍历过,遍历过为true
        visit[i] = false;
    }
    if(visit[startNode]==false){
        getDFSbyRecursive(startNode);
    }
    //非递归形式
    for (int i = 0; i < n; i++) { //visit[i]标记是否被遍历过,遍历过为true
        visit[i] = false;
    }
    Stack<Integer> stk = new Stack<Integer>();
    if(visit[startNode]==false){
        stk.add(startNode);
        while (!stk.isEmpty()) {
            int temp = stk.pop();
            if(visit[temp]==false){
                visit[temp] = true;
                System.out.print(temp);

                for(int j=0;j<n;++j){
                    if(A[temp][j]>0 && visit[j]==false){
                        stk.add(j);
                    }
                }

            }

        }
    }
}

最短路径

1 Dijktra算法

static int[][] A=new int[][]{{0,1,1,1,0},{1,0,0,1,0},{1,0,0,0,1},{1,1,0,0,0},{0,0,1,0,0}}; 
static int n = A.length;//元素个数
static boolean[] visit=new boolean[n]; 
static int startNode=1;

public static void Dijkstra(){
    int max = 10000;
    int[][] cost = new int[][]{{0,1,max,2},{max,0,1,max},{max,0,0,2},{max,3,max,0}}; 
    int n = cost.length;
    int dist[] = new int[n];
    Arrays.fill(dist, Integer.MAX_VALUE);
    dist[startNode] = 0;
    boolean visited[] = new boolean[n];

    for(int i=0;i<n;++i){
        int best = -1;
        for(int j=0;j<n;++j){
            if(!visited[j] && (best<0 || dist[j]<dist[best])){
                best = j;
            }
        }
        System.out.println(best);
        visited[best] = true;
        for(int j=0;j<n;++j){
            dist[j] = Math.min(dist[j], dist[best]+cost[best][j]);
        }
        System.out.println(Arrays.toString(dist));
    }
    System.out.println([n-1]);
}

2 Floyd

public static void Floyd(){
        int max = 10000;
        int[][] cost = new int[][]{{0,1,max,2},{max,0,1,max},{max,0,0,2},{max,3,max,0}}; 
        int n = cost.length;
        int dist[][] = cost.clone();

        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                for(int mid=0;mid<n;++mid){
                    dist[i][j] = Math.min(dist[i][j], dist[i][mid]+dist[mid][j]);
                }
            }
        }
        System.out.println(dist[startNode][n-1]);
    }

练习

public static void main(String[] args) {
    /**
     * 最短路径问题
     * Dijkstra算法
     * https://www.nowcoder.com/practice/e372b623d0874ce2915c663d881a3ff2?tpId=63&&tqId=29599&rp=1&ru=/activity/oj&qru=/ta/zju-kaoyan/question-ranking
     */
    int inNum = 10000;
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt(); // n * n
    int m = sc.nextInt();
    int dist[][] = new int[n][n];
    int cost[][] = new int[n][n];
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            if(i==j){dist[i][j] = 0;cost[i][j] = 0;}
            else{dist[i][j] = inNum;cost[i][j] = inNum;}
        }
    }
    for(int i=0;i<m;++i){
        int x = sc.nextInt()-1;
        int y = sc.nextInt()-1;
        int d = sc.nextInt();
        int c = sc.nextInt();
        if(d<dist[x][y] || (d==dist[x][y] && c<cost[x][y])){
            dist[x][y] = d;
            dist[y][x] = d;
            cost[x][y] = c;
            cost[y][x] = c;
        }
    }
    int s = sc.nextInt()-1;
    int e = sc.nextInt()-1;
//      Floyd算法-----------------
    int mindist[][] = dist.clone();
    int mincost[][] = cost.clone();
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            for(int mid=0;mid<n;++mid){
                if( (mindist[i][mid]+mindist[mid][j])<mindist[i][j] || 
                    ( (mindist[i][mid]+mindist[mid][j])==mindist[i][j] && mincost[i][mid]+mincost[mid][j]<mincost[i][j]) )
                {
                    mindist[i][j] = mindist[i][mid]+mindist[mid][j];
                    mincost[i][j] = mincost[i][mid]+mincost[mid][j];
                }

            }
        }
    }
    System.out.println(mindist[s][e]+" "+mincost[s][e]);
//      Dijktra算法---------------
//      boolean visit[] = new boolean[n];
//      int mindist[] = new int[n];
//      int mincost[] = new int[n];
//      Arrays.fill(mindist, inNum);
//      Arrays.fill(mincost, 0);
//      
//      mindist[s] = 0;
//      for(int i=0;i<n;++i){
//          int best = -1;
//          for(int j=0;j<n;++j){
//              if(!visit[j] && (best<0 || mindist[j]<mindist[best])){
//                  best = j;
//              }
//          }
            System.out.println(best);
//          visit[best] = true;
//          for(int j=0;j<n;++j){
//              if((mindist[best]+dist[best][j])<mindist[j] ||
//                  ( (mindist[best]+dist[best][j])==mindist[j] && mincost[best]+cost[best][j]<mincost[j]) )
//              {
//                  mindist[j] = mindist[best]+dist[best][j];
//                  mincost[j] = mincost[best]+cost[best][j];
//              }
//          }
            System.out.println(Arrays.toString(mindist));
//          
//      }
//      System.out.println(mindist[e]+" "+mincost[e]);

}

练习题参考

Dijktra+Floyd：牛客网：最短路径问题