图的遍历

深度和广度优先究竟指啥

问题描述

使用深度优先搜索遍历一个图（废话不多说，直接上代码）。

package com.qianwei.chapter5;

import java.util.Scanner;

public class GraphDFS {

    static int[][] e = new int[100][100];
    static int[] book = new int[100];
    static int n, m;
    static int sum = 0;
    
    public static void dfs(int cur) {
        System.out.print(cur + " ");
        sum++;
        if (sum == n) 
            return;
        for (int i = 1; i <= n; i++) {
            if (e[cur][i] == 1 && book[i] == 0) {
                book[i] = 1;
                dfs(i);
            }
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i == j) 
                    e[i][j] = 0;
                else 
                    e[i][j] = 99999999;
            }
        }
        for (int i = 1; i <= m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            e[a][b] = 1;
            e[b][a] = 1;
        }
        book[1] = 1;
        dfs(1);
        sc.close();
    }
}

 

使用广度优先搜索遍历一个图。

package com.qianwei.chapter5;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

public class GraphBFS {

    static int[][] e = new int[100][100];
    static int[] book = new int[100];
    static int n, m;
    static Deque<Integer> queue = new LinkedList<Integer>();

    public static void bfs() {
        while (!queue.isEmpty()) {
            int cur = queue.peek();
            for (int i = 1; i <= n; i++) {
                if (e[cur][i] == 1 && book[i] == 0) {
                    book[i] = 1;
                    queue.offer(i);
                }
            }
            System.out.print(queue.poll() + " ");
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (i == j) {
                    e[i][j] = 0;
                } else {
                    e[i][j] = 99999999;
                }
            }
        }
        for (int i = 1; i <= m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            e[a][b] = 1;
            e[b][a] = 1;
        }
        queue.offer(1);
        book[1] = 1;
        bfs();
        sc.close();
    }
}

 

城市地图——图的深度优先遍历

问题描述

计算有向图中两点的最短路径（废话不多说，直接上代码）。

package com.qianwei.chapter5;

import java.util.Scanner;

public class MapDFS {

    static int min = 99999999;
    static int[][] e = new int[100][100];
    static int[] book = new int[100];
    static int n, m;

    public static void dfs(int cur, int dis) {
        if (dis > min) 
            return;
        if(cur == n) {
            if (dis < min) {
                min = dis;
                return;
            }
        }
        for (int i = 1; i <= n; i++) {
            if (e[cur][i] != 99999999 && book[i] == 0) {
                book[i] = 1;
                dfs(i, dis+e[cur][i]);
                book[i] = 0;
            }
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i == j) 
                    e[i][j] = 0;
                else 
                    e[i][j] = 99999999;
            }
        }
        for (int i = 1; i <= m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            e[a][b] = c;
        }

        book[1] = 1;
        dfs(1, 0);
        System.out.println(min);
        sc.close();
    }
}

 

最少转机——图的广度优先遍历

问题描述

计算图中两点之间经过最少点的路径（废话不多说，直接上代码）。

package com.qianwei.chapter5;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

class NodeMap {
    int x;	//城市编号
    int s;	//转机次数
    NodeMap(int x, int s) {
        this.x = x;
        this.s = s;
    }
}

public class MapBFS {

    static int[][] e = new int[51][51];
    static int[] book = new int[51];
    static int n, m;
    static int start, end;
    static int mark, sum;
    static Deque<NodeMap> queue = new LinkedList<NodeMap>();
    
    public static void bfs() {
        int flag = 0;
        while (!queue.isEmpty()) {
            int cur = queue.peek().x;
            for (int i = 1; i <= n; i++) {
                if(e[cur][i] != 99999999 && book[i] == 0) {
                    mark = i;
                    sum = queue.peek().s + 1;
                    queue.offer(new NodeMap(i, sum));
                    book[i] = 1;
                }
                if(mark == end) {
                    flag = 1;
                    break;
                }
            }
            if(flag == 1) 
                break;
            queue.poll();
        }
    }
    
    public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        start = sc.nextInt();
        end = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i == j) 
                    e[i][j] = 0;
                else 
                    e[i][j] = 99999999;
            }
        }
        for (int i = 1; i <= m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            e[a][b] = 1;
            e[b][a] = 1;
        }

        queue.offer(new NodeMap(start, 0));
        book[1] = start;
        bfs();
        System.out.println(sum);
        sc.close();
    }
}

当然也可以使用深度优先搜索解决，但是这里用广度优先搜索会更快。广度优先搜索更加适合用于所有边的权值相同的情况。