平面上的地图搜索--Java学习笔记（四）

版权声明：

本文由Faye_Zuo发布于http://www.cnblogs.com/zuofeiyi/, 本文可以被全部的转载或者部分使用，但请注明出处.

这一个月以来，都在学习平面上的地图搜索，主要涉及到深度优先搜索（DFS)和广度优先搜索（BFS）。这两个算法和相关数据结构我整整学习了一个月，中间经历了很多对自己畏难情绪的克服，现在终于搞懂了，不过并没有掌握得很好。要想掌握得很好，需要后期编码来巩固加强了。

先从这道leetcode上面的题目作为引子：

Number of islands(200)

Given a 2d grid map of ‘1’s (land) and ‘0’s (water), count the number of islands.An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically.You may assume all four edges of the grid are all surrounded by water.

开始看到这道题目时，我的内心是崩溃的。因为我完全是连题目都看不懂，什么是islands？

  islands定义

（1）被water包围；

（2）被水平或者垂直lands相连。

（3）一个只包含0和1的二维数组，找到里面不相邻的只包含1的块的个数。

 

然后看到答案，说解决这道题既可以用到DFS，又可以用到BFS。之前对DFS还有一点点接触，然后BFS就非常头大了。只要遍历一遍，碰到一个1，就把他周围相邻的1都标记为非1，这样整个遍历过程中碰到的1的个数就是所求解。 

 

第一部分：DFS(Depth-first search)—深度优先搜索

不理解的东西很多，从“图”的概念开始就不懂，找了很多视频，慢慢学。最后大概花了一周完全理解了

 

第一个大型知识点：图

一. 图的遍历定义

从任意指定的顶点（初始点）出发，按照一定的搜索方法依次访问图中所有顶点，且每个顶点仅被访问一次。

 

二. 回路

图中任意一个顶点都可能和其余顶点相邻接，从图的初始点到其余顶点可能存在多条路径。因此，在访问了某个结点之后，很可能顺着某条回路又回到该顶点。

 

三. 深度优先搜索的基本思想（递归）

(1)首先访问初始出发点，并标记为已访问。

(2)任选一个与Vo相邻且没有被访问的邻接点V1作为新的出发点，访问V1之后，设为已访问。

(3)以V1为新的出发点，访问与V1相邻且没有被访问的任一顶点V2.

(4)重复上述过程，若遇到一个所有邻接点均被访问过的结点，则回到已访问结点序列中最后一个还没有被访问的相邻结点的顶点，再DFS,直到图中所有顶点都被访问过，结束。

 

四 .DFS核心代码

private void dfs(int v, boolean[] visited){                v为初始结点，visited表示是否已访问

 System.out.print(getValue(v));                            getValue(v) 访问该结点

 visited[v]=true;                                          visited[v]=true; 做已访问标记

 int w=getFirstNeighbor(v);                                getFirstNeighbor(v) 取第一个邻接点                            

 while(w!=-1){                                             当邻接点存在时循环        

  if(!=visited[w]){                                        如果没有访问过

   dfs(w,visited);                                         递归遍历

 }

w=getNextNeighbor(v,w);                                    取下一个邻接结点

}

} 

 

 最后花了一周的时间，大概能默写出下面程序：

  static class Solution {
    private int m, n;

    public int numIslands(char[][] grid) {
      m = grid.length;
      if (m == 0) {
        return 0;
      }
      n = grid[0].length;
      if (n == 0) {
        return 0;
      }

      int ans = 0;
      for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
          if (grid[i][j] != '1') {
            continue;

          }

          ans++;
          dfs(grid, i, j);
        }
      }

      return ans;
    }

    public void dfs(char[][] grid, int i, int j) {              \\dfs是一种查找方式，所以没有返回值
      if (i < 0 || i >= m || j < 0 || j >= n) {
        return;
      }

      if (grid[i][j] == '1') {

        grid[i][j] = '2’;                                      \\表示已经访问

     

        dfs(grid, i - 1, j);                                   \\四周相邻的点

        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
      }
    }
  }

}

 

第二部分：BFS(Breadth-first search)—广度优先搜索

更加类似于一个分层搜索的过程，广度优先遍历需要使用一个队列(queue)以保持访问过的结点顺序，以便按这个顺序来访问这些结点的邻接结点。

 

第二个大型知识点：二维数组

对的，二维数组很多基本的知识我并没有掌握，这就是文科生强行学习CS的艰辛，简直想掐死自己有时候。

 

1.定义

（1）静态定义

int[][] arr={{3,1,3},{5,8,2,9},{4,1}}

 

（2）动态定义

int[][] arr=new int[3][2];

 

char[][] grid = new char[][] { { '0', '1', '1', '0' }, { '1', '0', '0', '1' },

        { '1', '0', '0', '1' }, { '1', '1', '0', '0' } };

 

2.打印

（1）打印二维数组

System.out.println(array);

 

（2）打印二维数组中的一维数组

System.out.println(array[0]);

 

（3）打印二维数组中的某个元素

System.out.println(array[0][0]);

 

3.长度

（1）一维数组的个数

array.length

 

（2）每个一维数组的长度

array[1].length

 

4.遍历

for(int x=0;x<array.length;x++)

  {

    for(int y=0;y<array[x].length;y++)

     {

         System.out.println(array[x][y]);

     }

   }

 

 第三个大型知识点：队列

队列一个最大的原理就是：先进先出，后进后出

 

广度优先搜索的原理 

1.首先访问1，将1的邻居放入队列：

 

---

1 2 3   

---

2.根据队列先进先出的原则，1出来。访问队头2的邻居：

 

---

2 3 4 6

---

3.根据队列先进先出的原则，2出来，访问队头3的邻居（3的邻居已经在里面了）

 

---

3 4 6 

---

4.根据队列先进先出的原则，3出来，访问4的邻居（4的邻居已经在里面）

 

---

4 6

---

5.根据队列先进先出的原则，4出来，访问6的邻居

 

---

6 5

---

顺序：1 2 3 4 6 5

 

最后得出结论：

（1）一定是先进先出；

（2）一定是访问队头的邻居

 

第四个大型知识点：集合大家族

1.ArrayList

  动态数组：每一个ArrayList都有一个初始容量，也就是数组的大小。数组的大小随着元素的增加而增加，容量快溢出时，进行扩容操作。

 

2.LinkedList

  双向链表：格外提供get、remove、insert方法在LinkedList的首位部。

 

3.ArrayList和LinkedList的区别

（1）对于随机访问get、set,ArrayList优于LinkedList，因为LinkedList要移动指针。

（2）对于新增和删除，LinkedList占优势，ArrayList要移动数据。 

 

第五个大型知识点：图的邻接矩阵（adjacency matrix)

1.无向图 

5.邻接矩阵的特点：

（1）一个图的邻接矩阵一定是唯一的

（2）对于一个无向图来说，他的邻接矩阵是关于主对角线对称的。

无向图有n个顶点，则邻接矩阵的存储空间为 n(n+1)/2（对称的）；

有向图有n个顶点，则邻接矩阵的存储空间为 n的平方。

（3）借助邻接矩阵可判断两个顶点是否有边，查找边和权都很方便。

（4）利用邻接矩阵很容易计算出图中各顶点的度。

无向图：矩阵中第i行非零元素或者第j行元素的个数就是顶点i的度；

有向图：第i行非零元素的个数是顶点Vi的出度，第i列的非零元素为顶点入度。

 

 

花了整整三个星期，我才理解到这个程序。除了上面的大型知识点，里里外外还有泛型啊，抽象类和接口等等java的基础知识，我都像一头猪。由于程序实在太长了，我自己写出来的程序run不出来，但是我肉眼已经看不出来错误在哪里。于是克服了心里障碍，开始学会一步一步的打印，学会分析计算机的运算过程，从而来理解程序。这是一个很大的突破，我今天下午通过打印功能，终于理解了以下程序染色的过程。我之前的理解的确是错误了。这个方法也能帮助我以后自行查找错误。

 

BFS程序如下： 

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.Queue;

 

public class BFS {

 

  public static void main(String[] args) {

 

 

  }

 

  private Queue<Node> queue;

  static ArrayList<Node> nodes=new ArrayList<Node>();

  static class Node{

    int data;

    boolean visited;

    Node(int data){

      this.data=data;

    }

  }

 

  public BFS(){

    queue=new LinkedList<Node>();

  }

 

  public ArrayList<Node> findNeighbours(int adjacency_matrix[][],Node x){      

    int nodeIndex=-1;

    ArrayList<Node> neighbours=new ArrayList<Node>();

    for(int i=0;i<nodes.size();i++){                                      //第一个for循环用来找element在数组中的index

      if(nodes.get(i).equals(x)){

        nodeIndex=i;

        break;

      }

    }

 

    if(nodeIndex!=-1){                                                   //已经找到index,第二个for循环用来找1，表示相邻

      for(int j=0;j<adjacency_matrix[nodeIndex].length;j++){             //然后返回给neighbour数组

        if(adjacency_matrix[nodeIndex][j]>0){

          neighbours.add(nodes.get(j));

        }

      }

    }

    return neighbours;

 

  }

 

  public void bfs(int adjacency_matrix[][],Node node){                    //bfs的主函数，从这里看起。主函数就是运用队列

    queue.add(node);

    node.visited=true;

    while(!queue.isEmpty()){

      Node element=queue.remove();                                        //注意：队列的remove都是从头开始的

      System.out.println(element.data);                                    //这步打印的是queue的第一个元素

 

      ArrayList<Node> neighbours=findNeighbours(adjacency_matrix,element); //这步开始找邻居

 

      for(int i=0;i<neighbours.size();i++){

        Node n=neighbours.get(i);

        if(n!=null&&!n.visited){

          queue.add(n);

          n.visited=true;

        }

      }

 

    }

  }

 

} 

 

Numbers of Islands的BFS解法完成程序如下：

import java.util.ArrayDeque;
import java.util.Deque;

public class numberOfIslandBFS {

  public static void main(String[] args) {
    char[][] grid = new char[][] {
      { '0', '1', '1', '0' },
      { '1', '0', '0', '1' },
      { '1', '0', '0', '1' },
      { '1', '1', '0', '0' } };
    System.out.println("#islands=" + new Solution().numIslands(grid));

  }

  private static class Point {
    int x;
    int y;

    Point(int x, int y) {
      this.x = x;
      this.y = y;
    }
  }

  public static class Solution {
    public int numIslands(char[][] grid) {
      int res = 0;
      if (grid == null || grid.length == 0 || grid[0].length == 0) {
        return 0;
      }

 

      int row = grid.length;                                      \\row和col主要用来设置for循环的边界

      int col = grid[0].length;

      boolean[][] visited = new boolean[row][col];
      int[][] directions = {
          { 1, 0 },
          { -1, 0 },
          { 0, 1 },
          { 0, -1 } };
      Deque<Point> queue = new ArrayDeque<Point>();

      for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
          if (grid[i][j] == '0' || visited[i][j]) {
            continue;
          }

          queue.add(new Point(i, j));
          res += 1;
          while (!queue.isEmpty()) {

            Point cur = queue.poll();                                     // queue =[ (1,1) ]

            int tpx = cur.x;                                              // 1,用来记录弹出后的x,y

            int tpy = cur.y;                                              // 1

 

            visited[tpx][tpy] = true;                                    //并且标记为已访问

            for (int k = 0; k < 4; k++) {
              int x = tpx + directions[k][0]; // 0
              int y = tpy + directions[k][1]; // 1

              if (x >= 0 && x < row && y >= 0 && y < col && grid[x][y] == '1'
                  && !visited[x][y]) {
                queue.add(new Point(x, y));
              }
            }
          }
        }
      }

      return res;
    }

  }

}