1.DFS (depth first search) and BFS (breadth first search) collection.

2. The main difference between the two is that the former maintains a stack data structure, so the recursive method can usually be used; The latter maintains the data structure of a queue, usually using the method of circular iteration.

3. At the same time, if the former is implemented by recursion, only the form of recursion and the conditions for ending recursion need to be considered. The computer maintains the stack itself, which is more convenient and easy to understand. The latter needs to write its own iteration to maintain the queue, which is relatively complex to start

4. If you are familiar with backtracking and recursion, DFS is easy to use, and there will be little explanation below

#### Color fill (simple)

- Idea: DFS, pay attention to boundary conditions and special cases, and then search (fill color) in four directions up, down, left and right

var floodFill = function(image, sr, sc, newColor) { let begin = image[sr][sc] // Special attention if (begin === newColor) return image let srlen = image.length - 1, sclen = image[0].length - 1 let dfs = (image, sr, sc, newColor) => { // Focus on boundary conditions if (sr < 0 || sc < 0 || sr > srlen || sc > sclen) return if (image[sr][sc] === begin) { image[sr][sc] = newColor } else { return } dfs(image, sr - 1, sc, newColor) // lower dfs(image, sr + 1, sc, newColor) // upper dfs(image, sr, sc - 1, newColor) // Left dfs(image, sr, sc + 1, newColor) // right } dfs(image, sr, sc, newColor) return image };

### Number of islands (medium)

- Idea: cycle through the grid array. As long as the current value is 1, add one to the count, and then perform DFS search in four directions up, down, left and right until it meets zero, and the place it passes each time should become zero to prevent repeated search from falling into an endless loop (such as searching from left to right, and from right to left, and so on)

var numIslands = function(grid) { if (!grid.length) return 0 let nr = grid.length let nc = grid[0].length let sum = 0 let dfs = (grid, r, c) => { if (r < 0 || c < 0 || r >= nr || c >= nc || grid[r][c] === '0') return grid[r][c] = '0' // The searched place is assigned to zero dfs(grid, r - 1, c) // lower dfs(grid, r + 1, c) // upper dfs(grid, r, c - 1) // Left dfs(grid, r, c + 1) // right } // Traversal array for (let i = 0; i < nr; i++) { for (let j = 0; j < nc; j++) { if (grid[i][j] === '1') { sum++ dfs(grid, i, j) } } } return sum };

### Water area size (medium)

- Idea: compared with the previous question, it has four more search directions - diagonal, but there is no essential difference. It can be done as long as you search several more directions

var pondSizes = function(land) { if (!land.length) return [] let res = [], size = 0 let nr = land.length let nc = land[0].length let dfs = (land, r, c) => { if (r < 0 || c < 0 || r >= nr || c >= nc || land[r][c] !== 0) return land[r][c] = -1 size++ // Search in eight directions dfs(land, r - 1, c) dfs(land, r - 1, c - 1) dfs(land, r - 1, c + 1) dfs(land, r, c - 1) dfs(land, r, c + 1) dfs(land, r + 1, c) dfs(land, r + 1, c - 1) dfs(land, r + 1, c + 1) return size } for (let i = 0; i < nr; i++) { for (let j = 0; j < nc; j++) { if (land[i][j] === 0) { size = 0 dfs(land, i, j) if (size !== 0) res.push(size) } } } return res.sort() };

### Open keyboard lock (medium)

- thinking
- BFS. The code and ideas are complex. Look at the form of the topic, you can think of using a queue, because the operation is carried out in sequence, and the next rotation can only be carried out after one rotation. The difficulty of this problem is that it is easy to fall into a dead end - thinking about using code to write rotation operation and iteration together, and the two are carried out at the same time. If you think about it carefully, you will find that it is very hybrid, or almost impossible to achieve, because there are many situations after one rotation. So we need to turn the rotation operation into a function, and return the value to the array with various conditions. We can call the function in every iteration and traverse the result.
- The rotation function and can directly see the code comments. Here we mainly talk about the idea of iteration. Maintain a queue, first store the initial state of 0000, then enter the total cycle (once for each total cycle, the number of steps plus one), then traverse and take out the states in the queue, and rotate each state. The results are stored in the array, and then the results in the rotating array are stored in the queue according to the sequence (at the same time, judge whether they meet the requirements, store them in the queue if they do not meet the requirements, and return the results if they meet the requirements), and then iterate over each result when entering the total cycle

var openLock = function(deadends, target) { if (target === '0000') return 0 if (deadends.includes('0000')) return -1 // The result of enumeration rotation is a string, which requires additional processing const go = (x) => { // Forward rotation return x === '9' ? '0' : (parseInt(x) + 1) + '' } const back = (x) => { // reversal return x === '0' ? '9' : (parseInt(x) - 1) + '' } const get = (status) => { const res = [] const arr = Array.from(status) // Only four digits for (let i = 0; i < 4; i++) { const num = arr[i] // Save current traversal number arr[i] = go(num) res.push(arr.join('')) // Deposit forward transfer result arr[i] = back(num) res.push(arr.join('')) // Save reversal result arr[i] = num // Restore current traversal number } return res // Returns all results of one rotation } // BFS let step = 0 let dead = new Set(deadends) const queue = [] queue.push('0000') let seed = new Set() seed.add('0000') while (queue.length) { step++ const len = queue.length for (let i = 0; i < len; i++) { // Take out multiple results after the last rotation in sequence let status = queue.shift() // Traverse the various cases of rotation once for (let next of get(status)) { // Judge whether it meets the requirements, store it in the queue if it does not meet the requirements, and return the results if it meets the requirements if (!seed.has(next) && !dead.has(next)) { if (next === target) { return step } else { queue.push(next) seed.add(next) } } } } } return -1 };

### Word search (medium)

- Idea: DFS, the efficiency after submission is extremely low and outrageous. Traverse each element of the array, and then search up, down, left and right. General, not much explanation

var exist = function(board, word) { let len = word.length let nr = board.length let nc = board[0].length let isTrue = false let dfs = (board, r, c, sub) => { if (r < 0|| c < 0 || r >= nr || c >= nc || sub.length > len || board[r][c] === '1') return sub += board[r][c] if (sub === word) isTrue = true let str = board[r][c] board[r][c] = '1' dfs(board, r - 1, c, sub) dfs(board, r + 1, c, sub) dfs(board, r, c - 1, sub) dfs(board, r, c + 1, sub) board[r][c] = str } for (let i = 0; i < nr; i++) { for (let j = 0; j < nc; j++) { if (board[i][j] === word[0]) { dfs(board, i, j, '') } } } return isTrue };

### Curriculum (medium)

- Idea: BFS, the efficiency after submission is extremely low and outrageous. This problem involves topological sorting. If you understand topological sorting, you will understand it very well

var canFinish = function(numCourses, prerequisites) { let pic = new Array(numCourses) let len = prerequisites.length let queue = [], sum = 0 for (let i = 0; i < numCourses; i++) { pic[i] = [] } // Store the corresponding relationship of course order to form a topology for (let i = 0; i < len; i++) { let [back, pre] = prerequisites[i] pic[back].push(pre) } // First, the nodes with zero penetration are stored in the queue for (let i = 0; i < numCourses; i++) { if (pic[i].length === 0) queue.push(i) } // Check whether there is a ring in the topology. If there is no ring, it returns true while (queue.length) { let mid = queue.shift() for (let i = 0; i < numCourses; i++) { let cur = pic[i] let index = cur.indexOf(mid) if (index === -1) continue cur.splice(index, 1) if (cur.length === 0) queue.push(i) } sum++ } return sum === numCourses };

If you think it's helpful to you, give it a compliment~

Anyway, posting doesn't make money. Make friends~

If you need to reprint, please indicate the source foolBirdd