增加岛屿数量深搜go版本

problems/kamacoder/0099.岛屿的数量深搜.md

@@ -326,6 +326,75 @@ if __name__ == '__main__':
 
 ### Go
 
+我们使用一个visited数组，记录下那些位置被遍历过。分为两层遍历。初始化一个visited数组和原始的grid一样大，用来记录哪些陆地被遍历过
+
+第一层遍历遍历整个grid数组的元素，遇到陆地，就在对应的visited数组里标记，并且执行深度搜索，深搜的逻辑是把当前位置的4个方向上的位置，全部判断一遍看是不是陆地，如果是，则在这个位置上再执行深搜，达到递归深搜的效果。所以深搜函数里是递归的。
+
+```go
+package main
+
+import (
+	"fmt"
+)
+
+func visitIsland(grid [][]int) int {
+	row := len(grid)
+	if row == 0 {
+		return 0
+	}
+	visited := make([][]bool, row)
+	//go的这种初始化方式真的丑陋
+	for i := 0; i < row; i++ {
+		visited[i] = make([]bool, len(grid[0]))
+	}
+	ans := 0
+	for i := 0; i < row; i++ {
+		for j := 0; j < len(grid[0]); j++ {
+			if grid[i][j] == 1 && !visited[i][j] {
+				visited[i][j] = true
+				ans++
+				visitGrid(grid, visited, i, j)
+			}
+		}
+	}
+	return ans
+}
+
+func visitGrid(grid [][]int, visited [][]bool, x int, y int) {
+	diff := [4][2]int{{1, 0}, {-1, 0}, {0, 1}, {0, -1}}
+	for _, arr := range diff {
+		nextX := x + arr[0]
+		nextY := y + arr[1]
+		if nextX < 0 || nextX >= len(grid) || nextY < 0 || nextY >= len(grid[0]) {
+			continue
+		}
+		if !visited[nextX][nextY] && grid[nextX][nextY] == 1 {
+			visited[nextX][nextY] = true
+			visitGrid(grid, visited, nextX, nextY)
+		}
+	}
+}
+
+func main() {
+	var row, col int
+	fmt.Scan(&row, &col)
+	if row <=0 || col <=0 {
+		return
+	}
+	grid := make([][]int, row)
+	for i := 0; i < row; i++ {
+		grid[i] = make([]int, col)
+	}
+	for i := 0; i < row; i++ {
+		for j := 0; j < col; j++ {
+			fmt.Scan(&grid[i][j])
+		}
+	}
+	//这里必须要打印，不然报错会显示潜在的数组越界
+	fmt.Println(visitIsland(grid))
+}
+```
+
 ### Rust
 
 ### JavaScript

problems/kamacoder/0104.建造最大岛屿.md

@@ -528,6 +528,104 @@ if __name__ == "__main__":
 
 ### Go
 
+```go
+package main
+
+import "fmt"
+
+func main() {
+    var m, n int
+    fmt.Scan(&m, &n)
+
+    grid := make([][]int, m)
+    for i := range grid {
+        grid[i] = make([]int, n)
+        for j := range grid[i] {
+            fmt.Scan(&grid[i][j])
+        }
+    }
+
+    sum := buildMaxIsland(grid)
+    fmt.Println(sum)
+}
+
+
+func buildMaxIsland(grid [][]int) int {
+	result := 0
+	if grid == nil || len(grid) == 0 {
+		return result
+	}
+	hashMap := make(map[int]int)
+	islandArea := 0
+	gridMark := 2
+	for i := 0; i < len(grid); i++ {
+		for j := 0; j < len(grid[0]); j++ {
+			if grid[i][j] == 1 {
+				islandArea = 0
+				visitGrid4(grid, i, j, &islandArea, gridMark)
+				hashMap[gridMark] = islandArea
+				if islandArea > result {
+					result = islandArea
+				}
+				gridMark++
+			}
+		}
+	}
+
+	for i := 0; i < len(grid); i++ {
+		for j := 0; j < len(grid[0]); j++ {
+			if grid[i][j] == 0 {
+				sum := findNearByIsland(grid, i, j, hashMap)
+				if sum > result {
+					result = sum
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+func visitGrid4(grid [][]int, x int, y int, preValue *int, gridMark int) {
+	if x < 0 || y < 0 || x >= len(grid) || y >= len(grid[0]) {
+		return
+	}
+	//可以省略掉visited的原因是因为grid的每个位置如果被遍历过就会被标记为gridMark，能识别出来是不是被遍历过
+	if grid[x][y] != 1 {
+		return
+	}
+	// visited[x][y] = true
+	grid[x][y] = gridMark
+	*preValue++
+	visitGrid4(grid, x+1, y, preValue, gridMark)
+	visitGrid4(grid, x-1, y, preValue, gridMark)
+	visitGrid4(grid, x, y+1, preValue, gridMark)
+	visitGrid4(grid, x, y-1, preValue, gridMark)
+}
+
+func findNearByIsland(grid [][]int, x, y int, hashMap map[int]int) int {
+	markSet := make(map[int]bool)
+	sum := 1
+	coordinate := [][]int{{x + 1, y}, {x - 1, y}, {x, y + 1}, {x, y - 1}}
+	for _, arr := range coordinate {
+		if arr[0] < 0 || arr[1] < 0 || arr[0] >= len(grid) || arr[1] >= len(grid[0]) {
+			continue
+		}
+		if grid[arr[0]][arr[1]] == 0 {
+			continue
+		}
+		gridMark := grid[arr[0]][arr[1]]
+		if !markSet[gridMark] {
+			markSet[gridMark] = true
+			sum += hashMap[gridMark]
+		}
+	}
+	return sum
+}
+```
+
+
+
 ### Rust
 
 ### JavaScript

problems/kamacoder/0110.字符串接龙.md

@@ -268,6 +268,82 @@ if __name__=='__main__':
 
 ### Go
 
+```go
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func connectWord(words []string, startWord string, endWord string) int {
+	if words == nil || len(words) == 0 {
+		return 0
+	}
+	var allWord = make(map[string]bool)
+	for _, word := range words {
+		allWord[word] = true
+	}
+	visitedWord := make(map[string]bool)
+	queue := make([]string, 0)
+	result := 1
+	queue = append(queue, startWord)
+	queue = append(queue, "")
+	for len(queue) > 0 {
+		word := queue[0]
+		queue = queue[1:]
+		if word == "" {
+			if len(queue) > 0 {
+				result++
+				queue = append(queue, "")
+			}
+            continue
+		}
+		arr := []rune(word)
+		for i := 0; i < len(arr); i++ {
+			old := arr[i]
+			for j := 'a'; j <= 'z'; j++ {
+				arr[i] = j
+				newWord := string(arr)
+				if allWord[newWord] && !visitedWord[newWord] {
+					visitedWord[newWord] = true
+					queue = append(queue, newWord)
+					if newWord == endWord {
+						return result + 1
+					}
+				}
+			}
+			arr[i] = old
+		}
+	}
+	return 0
+}
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	n, _ := strconv.Atoi(scanner.Text())
+	scanner.Scan()
+	input := strings.Split(scanner.Text(), " ")
+	beginStr := input[0]
+	endStr := input[1]
+
+	wordList := []string{beginStr, endStr}
+	for i := 0; i < n; i++ {
+		scanner.Scan()
+		wordList = append(wordList, scanner.Text())
+	}
+	count := connectWord(wordList, beginStr, endStr)
+	fmt.Println(count)
+}
+
+```
+
+
+
 ### Rust
 
 ### JavaScript