add graph

Author: drinks5

01-matrix/main.go

@@ -0,0 +1,69 @@
+package main
+
+var (
+	Dirs = [4][2]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}
+)
+
+func maxAreaOfIsland(grid [][]int) int {
+	area := 0
+	rows := len(grid)
+	if rows == 0 {
+		return 0
+	}
+	cols := len(grid[0])
+	visited := make([][]bool, rows)
+	for v := range visited {
+		visited[v] = make([]bool, cols)
+	}
+	for i := 0; i < rows; i++ {
+		for j := 0; j < cols; j++ {
+			if (grid[i][j] == 1) && !visited[i][j] {
+				if a := getAreaDFS(grid, visited, i, j, rows, cols); a > area {
+					area = a
+				}
+			}
+		}
+	}
+	return area
+}
+
+func getArea(grid [][]int, visited [][]bool, i, j, rows, cols int) int {
+	var pos [2]int
+	stack := [][2]int{{i, j}}
+	visited[i][j] = true
+	area := 0
+	for {
+		if len(stack) == 0 {
+			break
+		}
+		area++
+		pos, stack = stack[0], stack[1:]
+		for _, d := range Dirs {
+			r := pos[0] + d[0]
+			c := pos[1] + d[1]
+			if 0 <= r && r < rows && 0 <= c &&
+				c < cols && grid[r][c] == 1 &&
+				!visited[r][c] {
+				stack = append(stack, [2]int{r, c})
+				visited[r][c] = true
+			}
+		}
+	}
+	return area
+}
+
+func getAreaDFS(grid [][]int, visited [][]bool, i, j, rows, cols int) int {
+	var area int
+	if 0 <= i && i < rows && 0 <= j &&
+		j < cols && grid[i][j] == 1 &&
+		!visited[i][j] {
+		area = 1
+	} else {
+		return 0
+	}
+	visited[i][j] = true
+	for _, d := range Dirs {
+		area += getAreaDFS(grid, visited, i+d[0], j+d[1], rows, cols)
+	}
+	return area
+}

01-matrix/main.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+import unittest
+from typing import List, Tuple
+
+
+"""
+https://leetcode.com/problems/01-matrix/
+给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。
+
+两个相邻元素间的距离为 1 。
+
+示例 1：
+
+输入：mat = [[0,0,0],[0,1,0],[0,0,0]]
+输出：[[0,0,0],[0,1,0],[0,0,0]]
+示例 2：
+
+输入：mat = [[0,0,0],[0,1,0],[1,1,1]]
+输出：[[0,0,0],[0,1,0],[1,2,1]]
+"""
+Dirs = ((-1, 0), (1, 0), (0, -1), (0, 1))
+
+class Solution:
+    def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:
+        rows = len(mat)
+        if not rows:
+            return []
+        cols = len(mat[0])
+        dists = [[0] * cols for _ in range(rows)]
+        stack: List[Tuple[int, int]] = []
+        for i in range(rows):
+            for j in range(cols):
+                if mat[i][j] == 0:
+                    dists[i][j] = 0
+                    stack.append((i, j))
+                else:
+                    dists[i][j] = -1
+        while stack:
+            i, j= stack.pop()
+            dist = dists[i][j]
+            for d in Dirs:
+                r = i+
+        return []
+
+
+cases = [
+    {
+        "input": [[[0, 0, 0], [0, 1, 0], [0, 0, 0]]],
+        "output": [[0, 0, 0], [0, 1, 0], [0, 0, 0]],
+    },
+    {
+        "input": [[[0, 0, 0], [0, 1, 0], [1, 1, 1]]],
+        "output": [[0, 0, 0], [0, 1, 0], [1, 2, 1]],
+    },
+]
+
+
+class SolutionTestCase(unittest.TestCase):
+    def test(self):
+        for t in cases:
+            print(f"input: {t['input']}\noutput: {t['output']}\n")
+            ret = Solution().updateMatrix(*t["input"])
+            self.assertListEqual(ret, t["output"])
+
+
+if __name__ == "__main__":
+    unittest.main()

01-matrix/main_test.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+func Test_maxAreaOfIsland(t *testing.T) {
+	type args struct {
+		grid [][]int
+	}
+	tests := []struct {
+		args args
+		want int
+	}{
+		{args{[][]int{{0, 0, 0, 0, 0, 0, 0, 0}}}, 0},
+		{args{[][]int{
+			{0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
+			{0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0},
+			{0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+			{0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0},
+			{0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0},
+			{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
+			{0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0},
+			{0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0},
+		}}, 6},
+	}
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+			if got := maxAreaOfIsland(tt.args.grid); !assert.Equal(t, tt.want, got) {
+				t.Errorf("main() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

alien-dictionary/main.go

@@ -0,0 +1,26 @@
+package main
+
+import "math/rand"
+
+func findKthLargest(arr []int, k int) int {
+	pivot := arr[rand.Int()%(len(arr)-1)]
+	var larger []int
+	var equal []int
+	var less []int
+	for _, x := range arr {
+		if x > arr[pivot] {
+			larger = append(larger, x)
+		} else if x == arr[pivot] {
+			equal = append(equal, x)
+		} else {
+			less = append(less, x)
+		}
+	}
+	if len(larger) >= k {
+		return findKthLargest(larger, k)
+	} else if len(larger)+len(equal) >= k {
+		return arr[pivot]
+	} else {
+		return findKthLargest(append(equal, less...), k-len(larger))
+	}
+}

alien-dictionary/main.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+import unittest
+from typing import List, Dict
+import random
+
+
+"""
+https://leetcode-cn.com/problems/alien-dictionary/
+现有一种使用英语字母的外星文语言，这门语言的字母顺序与英语顺序不同。
+
+给定一个字符串列表 words ，作为这门语言的词典，words 中的字符串已经 按这门新语言的字母顺序进行了排序 。
+
+请你根据该词典还原出此语言中已知的字母顺序，并 按字母递增顺序 排列。若不存在合法字母顺序，返回 "" 。若存在多种可能的合法字母顺序，返回其中 任意一种 顺序即可。
+
+字符串 s 字典顺序小于 字符串 t 有两种情况：
+
+在第一个不同字母处，如果 s 中的字母在这门外星语言的字母顺序中位于 t 中字母之前，那么 s 的字典顺序小于 t 。
+如果前面 min(s.length, t.length) 字母都相同，那么 s.length < t.length 时，s 的字典顺序也小于 t 。
+ 
+示例 1：
+
+输入：words = ["wrt","wrf","er","ett","rftt"]
+输出："wertf"
+示例 2：
+
+输入：words = ["z","x"]
+输出："zx"
+示例 3：
+
+输入：words = ["z","x","z"]
+输出：""
+解释：不存在合法字母顺序，因此返回 "" 。
+"""
+
+
+class Solution:
+    def alienOrder(self, words: List[str]) -> str:
+        indegrees: Dict[str, int] = {}
+        graph: Dict[int, List[int]] = {}
+        queue = []
+        path = []
+        for word in words:
+            for s in word:
+
+        return ""
+
+
+cases = [
+    {
+        "input": [["wrt", "wrf", "er", "ett", "rftt"]],
+        "output": "werft",
+    },
+    {
+        "input": [["z", "x"]],
+        "output": "zx",
+    },
+    {
+        "input": [["z", "x", "z"]],
+        "output": "",
+    },
+]
+
+
+class SolutionTestCase(unittest.TestCase):
+    def test(self):
+        for t in cases:
+            print(f"input: {t['input']}\noutput: {t['output']}\n")
+            ret = Solution().alienOrder(*t["input"])
+            self.assertEqual(ret, t["output"])
+
+
+if __name__ == "__main__":
+    unittest.main()

alien-dictionary/main_test.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+func Test_findKthLargest(t *testing.T) {
+	type args struct {
+		arr []int
+		k   int
+	}
+	tests := []struct {
+		args args
+		want int
+	}{
+		{args{[]int{3, 2, 1, 5, 6, 4}, 2}, 5},
+		{args{[]int{3, 2, 3, 1, 2, 4, 5, 5, 6}, 4}, 4},
+	}
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+			if got := findKthLargest(tt.args.arr, tt.args.k); !assert.Equal(t, tt.want, got) {
+				t.Errorf("singleNonDuplicate() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

combination-sum/main.go

@@ -0,0 +1,26 @@
+package main
+
+import "math/rand"
+
+func findKthLargest(arr []int, k int) int {
+	pivot := arr[rand.Int()%(len(arr)-1)]
+	var larger []int
+	var equal []int
+	var less []int
+	for _, x := range arr {
+		if x > arr[pivot] {
+			larger = append(larger, x)
+		} else if x == arr[pivot] {
+			equal = append(equal, x)
+		} else {
+			less = append(less, x)
+		}
+	}
+	if len(larger) >= k {
+		return findKthLargest(larger, k)
+	} else if len(larger)+len(equal) >= k {
+		return arr[pivot]
+	} else {
+		return findKthLargest(append(equal, less...), k-len(larger))
+	}
+}

combination-sum/main.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+import unittest
+from typing import List
+
+
+"""
+https://leetcode.com/problems/combination-sum/
+给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 
+的唯一组合。
+
+candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。 
+
+对于给定的输入，保证和为 target 的唯一组合数少于 150 个。
+
+示例 1：
+
+输入: candidates = [2,3,6,7], target = 7
+输出: [[7],[2,2,3]]
+示例 2：
+
+输入: candidates = [2,3,5], target = 8
+输出: [[2,2,2,2],[2,3,3],[3,5]]
+示例 3：
+
+输入: candidates = [2], target = 1
+输出: []
+示例 4：
+
+输入: candidates = [1], target = 1
+输出: [[1]]
+示例 5：
+
+输入: candidates = [1], target = 2
+输出: [[1,1]]
+"""
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        return [[7], [2, 2, 3]]
+
+
+cases = [
+    {
+        "input": [[2, 3, 6, 7], 7],
+        "output": [[7], [2, 2, 3]],
+    },
+]
+
+
+class SolutionTestCase(unittest.TestCase):
+    def test(self):
+        for t in cases:
+            print(f"input: {t['input']}\noutput: {t['output']}\n")
+            ret = Solution().combinationSum(*t["input"])
+            self.assertListEqual(ret, t["output"])
+
+
+if __name__ == "__main__":
+    unittest.main()