feat: add dijkstra algorithm

Author: plh97

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "python.linting.enabled": true
+}

Search/Dijkstra.png

@@ -0,0 +1,36 @@
+package BFS
+
+// algorithm of graoph
+// BSF
+
+var graph = map[string][]string{
+	"A": []string{"B", "C"},
+	"B": []string{"A", "C", "D"},
+	"C": []string{"A", "B", "D", "E"},
+	"D": []string{"B", "C", "E", "F"},
+	"E": []string{"C", "D"},
+	"F": []string{"D"},
+}
+
+func BSF(graph map[string][]string, s string) []string {
+	res := []string{}
+	queue := []string{}
+	queue = append([]string{s}, queue...) // 队列压入第一个
+	seen := make(map[string]string)       // 可去重的集合映射关系
+	seen[s] = s
+	for len(queue) > 0 {
+		vertex := queue[len(queue)-1] // 队列推出最后一个, 为什么在可选择下一个点的队列中推出最后一个呢, 这就是广度优先了
+		queue = queue[:len(queue)-1]
+		nodes := graph[vertex]
+		for i := range nodes {
+			node := nodes[i]
+			_, ok := seen[node]
+			if !ok {
+				queue = append([]string{node}, queue...) // 插入第一个
+				seen[node] = node
+			}
+		}
+		res = append(res, vertex)
+	}
+	return res
+}

Search/Dijkstra/main.go

@@ -0,0 +1,34 @@
+// # algorithm of graoph
+// # BSF 
+
+graph = {
+  "A": ["B", "C"],
+  "B": ["A", "C", "D"],
+  "C": ["A", "B", "D", "E"],
+  "D": ["B", "C", "E", "F"],
+  "E": ["C", "D"],
+  "F": ["D"],
+}
+
+function BSF(graph, s) {
+  // queue 队列  [a, b, c, d]  移入 [new, a, b, c] , 移除 pop
+  queue = []
+  queue.unshift(s)
+  seen = new Set()
+  seen.add(s)       // 用于记录曾经访问过的节点, 不再访问
+  while (queue.length > 0) {
+    vertex = queue.pop()
+    nodes = graph[vertex]
+    for (let w of nodes) {
+      if (!seen.has(w)) {
+        queue.unshift(w)
+        seen.add(w)
+      }
+    }
+    console.log(vertex)
+  }
+}
+
+
+// A->B->C->D->E->F
+BSF(graph, "A")

Search/Dijkstra/main.js

@@ -0,0 +1,52 @@
+# algorithm of graoph
+# BSF
+import heapq
+import math
+graph = {
+    "A": {"B": 5, "C": 1},
+    "B": {"A": 5, "C": 2, "D": 1},
+    "C": {"A": 1, "B": 2, "D": 4, "E": 8},
+    "D": {"B": 1, "C": 4, "E": 3, "F": 6},
+    "E": {"C": 8, "D": 3},
+    "F": {"D": 8},
+}
+
+
+def init_distance(graph, s):
+    distance = {s: 0}
+    for vertex in graph:
+        if vertex != s:
+            distance[vertex] = math.inf
+    return distance
+
+
+def dijkstra(graph, s):
+    pqueue = []
+    heapq.heappush(pqueue, {0, s})
+    seen = set()
+    parent = {s: None}
+    distance = init_distance(graph, s)
+
+    while (len(pqueue) > 0):
+        pair = heapq.heappop(pqueue)
+        dist = pair[0]
+        vertex = pair[1]
+        seen.add(vertex)
+
+        nodes = graph[vertex].keys()
+        for w in nodes:
+            if w not in seen:
+                if dist + graph[vertex][w] < distance[w]:
+                    heapq.heappush(pqueue, (dist+graph[vertex][w], w))
+                    # pqueue.append(w)
+                    parent[w] = vertex
+                    distance[w] = dist + graph[vertex][w]
+                    # seen.add(w)
+        print(vertex)
+    return parent, distance
+
+
+parent, distance = dijkstra(graph, "A")  # A->B->C->D->E->F
+
+print(parent)
+print(distance)

Search/Dijkstra/main.py

@@ -0,0 +1,42 @@
+package BFS
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type para struct {
+	one map[string][]string
+	two string
+}
+
+type ans struct {
+	one []string
+}
+
+type question struct {
+	p para
+	a ans
+}
+
+func Test_OK(t *testing.T) {
+	ast := assert.New(t)
+
+	qs := []question{
+		question{
+			p: para{
+				one: graph,
+				two: "A",
+			},
+			a: ans{
+				one: []string{"A", "B", "C", "D", "E", "F"},
+			},
+		},
+	}
+
+	for _, q := range qs {
+		a, p := q.a, q.p
+		ast.Equal(a.one, BSF(p.one, p.two), "输入:%v", p)
+	}
+}

Search/Dijkstra/main_test.go

@@ -0,0 +1,40 @@
+# [807. Max Increase to Keep City Skyline](https://leetcode.com/problems/max-increase-to-keep-city-skyline/)
+
+## 2019/06/13
+
+### 题目 💗[easy]
+
+In a 2 dimensional array grid, each value `grid[i][j]` represents the height of a building located there. We are allowed to increase the height of any number of buildings, by any amount (the amounts can be different for different buildings). Height 0 is considered to be a building as well.
+
+At the end, the "skyline" when viewed from all four directions of the grid, i.e. top, bottom, left, and right, must be the same as the skyline of the original grid. A city's skyline is the outer contour of the rectangles formed by all the buildings when viewed from a distance. See the following example.
+
+What is the maximum total sum that the height of the buildings can be increased?
+
+```bash
+Example:
+Input: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
+Output: 35
+
+Explanation:
+The grid is:
+[ [3, 0, 8, 4],
+  [2, 4, 5, 7],
+  [9, 2, 6, 3],
+  [0, 3, 1, 0] ]
+
+The skyline viewed from top or bottom is: [9, 4, 8, 7]
+The skyline viewed from left or right is: [8, 7, 9, 3]
+
+The grid after increasing the height of buildings without affecting skylines is:
+
+gridNew = [ [8, 4, 8, 7],
+            [7, 4, 7, 7],
+            [9, 4, 8, 7],
+            [3, 3, 3, 3] ]
+```
+
+Notes:
+
+1 < grid.length = grid[0].length <= 50.
+All heights grid[i][j] are in the range [0, 100].
+All buildings in grid[i][j] occupy the entire grid cell: that is, they are a 1 x 1 x grid[i][j] rectangular prism.

algorithm/1038.BinarySearchTreetoGreaterSumTree/README.md

@@ -0,0 +1,21 @@
+package bstToGst
+
+import (
+	"github.com/pengliheng/leetcode/Helper"
+)
+
+type TreeNode = Helper.TreeNode
+
+func bstToGst(root *TreeNode) *TreeNode {
+	helper(root, 0)
+	return root
+}
+
+func helper(root *TreeNode, preVal int) int {
+	if root == nil {
+		return preVal
+	}
+	res := helper(root.Right, preVal)
+	root.Val += res
+	return helper(root.Left, root.Val)
+}

algorithm/1038.BinarySearchTreetoGreaterSumTree/main.go

@@ -0,0 +1,26 @@
+package bstToGst
+
+import (
+	"testing"
+
+	"github.com/pengliheng/leetcode/Helper"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var tcs = []struct {
+	N1  *TreeNode
+	ans *TreeNode
+}{
+	{
+		Helper.Ints2TreeNode([]int{4, 1, 6, 0, 2, 5, 7, -1 << 63, -1 << 63, -1 << 63, 3, -1 << 63, -1 << 63, -1 << 63, 8}),
+		Helper.Ints2TreeNode([]int{30, 36, 21, 36, 35, 26, 15, -1 << 63, -1 << 63, -1 << 63, 33, -1 << 63, -1 << 63, -1 << 63, 8}),
+	},
+}
+
+func Test_bitwiseComplement(t *testing.T) {
+	ast := assert.New(t)
+	for _, tc := range tcs {
+		ast.Equal(tc.ans, bstToGst(tc.N1), "输入:%v", tc)
+	}
+}

algorithm/1038.BinarySearchTreetoGreaterSumTree/main_test.go

@@ -15,6 +15,10 @@ var tcs = []struct {
 		Helper.Ints2ListWithCycle([]int{3, 2, 0, -4}, 1),
 		true,
 	},
+	{
+		Helper.Ints2ListWithCycle([]int{3, 2, 0, -4}, -1),
+		false,
+	},
 }
 
 func Test_bitwiseComplement(t *testing.T) {