最少转机——图的遍历

原创

---

小明和小刚一同坐飞机去旅游，他们现在位于1号城市，目标是5号城市，可是1号城市并没有到5号城市的直航。

不过小明已经收集了很多航班的信息，现在小明希望找到一种乘坐方式，使得转机的次数最少。

输入

　　第一行有4个整数v、e、n、m，分别表示顶点数、边数、出发点、目的地；

　　接下来e行，每行输出两个整数，分别代表哪两个城市有直航；

输出

　　最少转机次数

BFS——一旦找到目的地，转机次数即最少，因为BFS枚举了在N步之内所有能到达的顶点

import java.util.*;

//BFS一旦找到，即是最少转机次数
public class 最少转机 {
    
    static int v;
    static int e;
    static int start;
    static int end;
    static int matrix[][];
    static int que[];
    static int que_step[];
    static int book[];
    static int flag=0;    //标记

    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        v=reader.nextInt();
        e=reader.nextInt();
        start=reader.nextInt();
        end=reader.nextInt();
        matrix=new int[v+1][v+1];
        que=new int[v+1];
        que_step=new int[v+1];
        book=new int[v+1];
        //矩阵初始化
        for(int i=1;i<=v;i++) {
            book[i]=0;
            for(int j=1;j<=v;j++) {
                if(i==j) {
                    matrix[i][j]=0;
                }
                else {
                    matrix[i][j]=99999;
                }
            }
        }
        //读入边
        for(int i=1;i<=e;i++) {
            int one_City=reader.nextInt();
            int two_City=reader.nextInt();
            //无向图
            matrix[one_City][two_City]=1;
            matrix[two_City][one_City]=1;
        }
        int head=1;
        int tail=1;
        //初始位置入队列
        que[tail]=start;
        que_step[tail]=0;
        book[start]=1;
        tail++;
        while(head<tail) {
            for(int i=que[head];i<=v;i++) {
                if(matrix[ que[head] ][i]>0 && matrix[ que[head] ][i]<99999 && book[i]==0) {
                    //入队列
                    que[tail]=i;
                    que_step[tail]=que_step[head]+1;
                    book[i]=1;
                    tail++;
                    //目的地判断
                    if(i==end) {
                        flag=1;
                        break;
                    }
                }
            }
            if(flag==1) {
                break;
            }
            head++;
        }
        System.out.println(que_step[tail-1]);
    }

}

DFS——回溯比较

import java.util.*;

public class 最少转机DFS {
    
    static int v;
    static int e;
    static int start;
    static int end;
    static int matrix[][];
    static int book[];
    static int min=99999;
    
    static void dfs(int cur,int dis) {
        if(dis>min) {
            return;
        }
        if(cur==end) {
            if(dis<min) {
                min=dis;
            }
            return;
        }
        for(int i=1;i<=v;i++) {
            if(matrix[cur][i]>0 && matrix[cur][i]<99999 && book[i]==0) {
                book[i]=1;
                dfs(i,dis+1);
                book[i]=0;
            }
        }
    }

    public static void main(String[] args) {
        Scanner reader=new Scanner(System.in);
        v=reader.nextInt();
        e=reader.nextInt();
        start=reader.nextInt();
        end=reader.nextInt();
        matrix=new int[v+1][v+1];    //编号从1开始
        book=new int[v+1];
        //矩阵初始化
        for(int i=1;i<=v;i++) {
            book[i]=0;
            for(int j=1;j<=v;j++) {
                if(i==j) {
                    matrix[i][j]=0;
                }
                else {
                    matrix[i][j]=99999;
                }
            }
        }
        //读入边
        for(int i=1;i<=e;i++) {
            int one_City=reader.nextInt();
            int two_City=reader.nextInt();
            matrix[one_City][two_City]=1;
            matrix[two_City][one_City]=1;
        }
        book[start]=1;
        dfs(1,0);
        System.out.println(min);
    }

}

测试用例：

输入：

5 7 1 5
1 2
1 3
2 3
2 4
3 4
3 5
4 5

输出：

2

14:38:13

2018-07-24