图论基本概念

图,分为有向图和无向图

一,表示方法

1,邻接矩阵

        通过使用n*n的二维数组来表示一个图 1表示相连，0表示不相连

2,邻接表

        通过一个数组表示各个顶点 然后各个数组的元素下指向一个链表， 链表中的各个元素就是该数组元素所直连的顶点

二,遍历方法

1,深度优先

        采用栈来实现 首先任意选取一个图中的元素入栈，标记其为访问过 然后获取当前栈顶元素的其他相连的顶点 任选一个入栈，将该顶点标为访问过 继续上面步骤 知道栈顶元素没有未访问过的顶点 于是将栈顶元素弹栈， 继续获取新栈顶元素是否还有未访问过的顶点 有就继续入栈，重复上面的操作， 直到所有的元素都弹栈，此时就遍历完了图的所有顶点

2,广度优先

        采用队列实现 任选图中一个顶点入队 标记其为已访问过 接着从队列中获取队头顶点，获取其直连的没有访问过的元素依次入队并标记为 已访问过，重复以上步骤，直至所有元素都出队完，即可完成图的所有顶点的遍历

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = 5;
        int m = 4;
        int[][] data = new int[n][m];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                data[i][j] = scanner.nextInt();
            }
        }
        int dx =  scanner.nextInt();
        int dy =  scanner.nextInt();
        int x = scanner.nextInt();
        int y =scanner.nextInt();
        boolean[][] mark = new boolean[n][m];
        Graph graph = new Graph(n,m,mark,data);
        graph.dfs(x,y,dx,dy,1);
        System.out.println(graph.minStep);
        //graph.bfs(x,y,dx,dy);

    }
    public static class Point{
        public int x;
        public int y;
    }
    public static class Graph{
        int n;
        int m;
        boolean[][] mark;
        int[][] data;
        int[][] next = {{0,1},{1,0},{0,-1},{-1,0}};
        int minStep= Integer.MAX_VALUE;
        public Graph(int n,int m,boolean[][] mark,int[][] data){
            this.n = n;
            this.m = m;
            this.mark = mark;
            this.data =data;
        }

        public void dfs(int x,int y,int dx,int dy,int step){
            if(x == dx && y == dy ){
                if(minStep> step){
                    minStep = step;
                }
                return ;
            }
            for(int i=0;i<next.length;i++){
                int nextX = x+next[i][0];
                int nextY = y+next[i][1];
                if(nextX<0 || nextX>=n || nextY<0 || nextY>=m){
                    continue;
                }
                if(!mark[nextX][nextY] && data[nextX][nextY]==0){
                    mark[nextX][nextY] = true;
                    dfs(nextX,nextY,dx,dy,step +1);
                    mark[nextX][nextY] =  false;
                }
            }
        }


        public void bfs(int x,int y,int dx,int dy){
            Queue<Point> queue = new LinkedList<>();
            Point first =  new Point();
            first.x= x;
            first.y =  y;
            queue.offer(first);
            while(!queue.isEmpty()){
                Point point = queue.poll();
                mark[point.x][point.y] =  true;
                if(point.x ==  dx && point.y ==  dy){
                    System.out.println("找到了");
                    return;
                }
                for(int i = 0;i<next.length;i++){
                    Point nextPoint = new Point();
                    nextPoint.x = point.x + next[i][0];
                    nextPoint.y =  point.y + next[i][1];
                    if(nextPoint.x<0 || nextPoint.x>=n || nextPoint.y<0 || nextPoint.y>=m){
                        continue;
                    }
                    if(data[nextPoint.x][nextPoint.y]==0 && !mark[nextPoint.x][nextPoint.y]){
                        queue.offer(nextPoint);
                    }

                }
            }
            System.out.println("找不到");
        }
    }