OJ图遍历

广度优先遍历

/**
 * Output
 *
 * 输出遍历顺序，用空格隔开
 *
 *
 * Sample Input 1
 *
 * 1
 * 4 a
 * a b c d
 * a 0 1 1 0
 * b 1 0 1 0
 * c 1 1 0 1
 * d 0 0 1 0
 * Sample Output 1
 *
 * a b c d
 */
public class Main {
    static Scanner scanner=new Scanner(System.in);
    static int[][] matrix;
    static List<Character> vs=new ArrayList<>();
    static int n;
    static char startV;
    static List<Character> res=new ArrayList<>();
    static boolean[] visited;
    public static void main(String args[]){
        int T=scanner.nextInt();
        scanner.nextLine();
        while(T-->0){
            String[] line1=scanner.nextLine().split(" ");
            n=Integer.parseInt(line1[0]);
            startV=line1[1].charAt(0);
            String[] line2=scanner.nextLine().split(" ");
            for(int i=0;i<n;i++){
                vs.add(line2[i].charAt(0));
;           }
            matrix=new int[n][n];
            visited =new boolean[n];
            for(int i=0;i<n;i++){
                String[] line3=scanner.nextLine().split(" ");
                for (int j=0;j<n;j++){
                    matrix[i][j]=Integer.parseInt(line3[j+1]);
                }
            }
            visited[vs.indexOf(startV)]=true;
            bfs(startV);
            for(int i=0;i<res.size();i++){
                System.out.print(res.get(i));
                if(i!=res.size()-1) System.out.print(" ");
            }
            System.out.println("");

        }

    }

    /**
     * 广度优先遍历
     * @param v
     */
    private static void bfs(char v) {
        Queue<Character> queue=new LinkedList<>();
        queue.offer(v);//起始结点入栈
        while(!queue.isEmpty()){
            //访问所有节点
            char top=queue.poll();
            res.add(top);

            for(int i=0;i<n;i++){
                if(matrix[vs.indexOf(top)][i]==1&&!visited[i]){
                    visited[i]=true;
                    queue.offer(vs.get(i));
                }
            }

        }
        return;

    }
}

深度优先遍历（遍历所有情况，求最大深度，其实是回溯）

深度优先遍历
Description

按照给定的起始顶点深度优先遍历给定的无向图，尝试所有可能的遍历方式，打印遍历过程中出现的最大深度。

Input

输入第一行是用例个数，后面每个用例使用多行表示，用例的第一行是图中节点的个数n和起始点，用空格隔开，后面n+1行为图的邻接矩阵，其中第一行为节点名称。值之间使用空格隔开。

Output

输出深度优先遍历中遇到的最大深度。

Sample Input 1

1
4 a
a b c d
a 0 1 1 0
b 1 0 1 0
c 1 1 0 1
d 0 0 1 0
Sample Output 1

4

1
4 a
a b c d
a 0 1 0 1
b 1 0 1 0
c 0 1 0 0
d 1 0 0 0

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {
    static Scanner scanner=new Scanner(System.in);
    static int[][] matrix;
    static List<Character> vs=new ArrayList<>();
    static int n;
    static char startV;
    static boolean[] visited;
    static int ans;
    static int temp;
    public static void main(String args[]){
        int T=scanner.nextInt();
        scanner.nextLine();
        while(T-->0){
            vs.clear();
            ans=Integer.MIN_VALUE;
            String[] line1=scanner.nextLine().split(" ");
            n=Integer.parseInt(line1[0]);
            visited=new boolean[n];
            if(n<=0) System.out.println(0);{
                startV=line1[1].charAt(0);
                temp=0;
                String[] line2=scanner.nextLine().split(" ");
                for(int i=0;i<n;i++){
                    vs.add(line2[i].charAt(0));
                           }
                matrix=new int[n][n];
                for(int i=0;i<n;i++){
                    String[] line3=scanner.nextLine().split(" ");
                    for (int j=0;j<n;j++){
                        matrix[i][j]=Integer.parseInt(line3[j+1]);
                    }
                }
                for(int i=0;i<n;i++){
                    for(int j=0;j<n;j++){
                        System.out.print(matrix[i][j]+"\t");
                    }
                    System.out.println("");
                }
                int v=vs.indexOf(startV);
                visited[v]=true;
                dfs(v);
                System.out.println(ans+1);
            }
        }

    }


    /**
     *
     * @param v
     * @return
     */
    static public void dfs(int v){
        for(int i=0;i<n;i++){
            if(matrix[v][i]==1&&!visited[i]){
                visited[i]=true;
                temp++;
                dfs(i);
                temp--;
                visited[i]=false;
            }
        }
        ans=Math.max(ans,temp);
    }