Merge branch 'master' of ssh://111.230.181.241:1111/ikachan/leetcode-go

hard/10.regular-expression-matching.go

@@ -0,0 +1,24 @@
+func isMatch(s string, p string) bool {
+	m, n := len(s), len(p)
+	dp := make([][]bool, m+1)
+	for i := range dp {
+		dp[i] = make([]bool, n+1)
+	}
+	dp[0][0] = true
+	// dp[i][0] = false, if i > 0
+	for i := 1; i <= n; i++ {
+		dp[0][i] = 1 < i && p[i-1] == '*' && dp[0][i-2]
+	}
+	// dp[i][j] = if p[j-1] == '*', dp[i][j-2] || ((p[j-2] == '.' || s[i-1] == p[j-2]) && dp[i-1][j])
+	//            else, (p[j-2] == '.' || s[i-1] == p[j-1]) && dp[i-1][j-1]
+	for i := 1; i <= m; i++ {
+		for j := 1; j <= n; j++ {
+			if p[j-1] == '*' {
+				dp[i][j] = dp[i][j-2] || ((p[j-2] == '.' || s[i-1] == p[j-2]) && dp[i-1][j])
+			} else {
+				dp[i][j] = (p[j-1] == '.' || s[i-1] == p[j-1]) && dp[i-1][j-1]
+			}
+		}
+	}
+	return dp[m][n]
+}

hard/10.regular-expression-matching.java

@@ -0,0 +1,20 @@
+class Solution {
+    public boolean isMatch(String s, String p) {
+        char[] str = s.toCharArray(), pat = p.toCharArray();
+        boolean[][] dp = new boolean[str.length + 1][pat.length + 1];
+        dp[0][0] = true;
+        // dp[i][0] = false, 0 < i
+        for (int i = 1; i <= pat.length; i++)
+            dp[0][i] = 1 < i && pat[i - 1] == '*' && dp[0][i - 2];
+        for (int i = 1; i <= str.length; i++) {
+            for (int j = 1; j <= pat.length; j++) {
+                if (pat[j - 1] == '*') {
+                    dp[i][j] = dp[i][j - 2] || ((pat[j - 2] == '.' || str[i - 1] == pat[j - 2]) && dp[i - 1][j]);
+                } else {
+                    dp[i][j] = (pat[j - 1] == '.' || str[i - 1] == pat[j - 1]) && dp[i - 1][j - 1];
+                }
+            }
+        }
+        return dp[str.length][pat.length];
+    }
+}

oj/algorithms/graph/bellman-ford.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() {
+	var n, m, src int
+	fmt.Scan(&n, &m, &src)
+	adj := make([][]int, n)
+	length := make([][]int, n)
+	for i := range length {
+		length[i] = make([]int, n)
+	}
+	for i := 0; i < m; i++ {
+		var u, v, l int
+		fmt.Scan(&u, &v, &l)
+		adj[u] = append(adj[u], v)
+		length[u][v] = l
+	}
+	dist, prev := bellmanFord(adj, length, src)
+	fmt.Println(dist)
+	fmt.Println(prev)
+}
+
+func bellmanFord(adj [][]int, length [][]int, src int) ([]int, []int) {
+	n := len(adj)
+	dist := make([]int, n)
+	prev := make([]int, n)
+	for i := 0; i < n; i++ {
+		dist[i] = math.MaxInt32
+		prev[i] = -1
+	}
+	dist[src] = 0
+	for updated := true; updated; updated = false {
+		for u := range adj {
+			for _, v := range adj[u] {
+				if alt := dist[u] + length[u][v]; alt < dist[v] {
+					dist[v] = alt
+					prev[v] = u
+					updated = true
+				}
+			}
+		}
+	}
+	return dist, prev
+}

oj/algorithms/graph/floyd.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+func main() {
+	var n, m, src int
+	fmt.Scan(&n, &m, &src)
+	adj := make([][]int, n)
+	length := make([][]int, n)
+	for i := range length {
+		length[i] = make([]int, n)
+	}
+	for i := 0; i < m; i++ {
+		var u, v, l int
+		fmt.Scan(&u, &v, &l)
+		adj[u] = append(adj[u], v)
+		length[u][v] = l
+	}
+	fmt.Println(floyd(adj, length))
+}
+
+func floyd(adj [][]int, length [][]int) [][]int {
+	n := len(adj)
+	dist := make([][]int, n)
+	for i := range dist {
+		dist[i] = make([]int, n)
+		for j := range dist[i] {
+			dist[i][j] = math.MaxInt32
+		}
+	}
+	for u := range adj {
+		for _, v := range adj[u] {
+			dist[u][v] = length[u][v]
+		}
+	}
+	for k := 0; k < n; k++ {
+		for i := 0; i < n; i++ {
+			for j := 0; j < n; j++ {
+				if alt := dist[i][k] + dist[k][j]; alt < dist[i][j] {
+					dist[i][j] = alt
+				}
+			}
+		}
+	}
+	return dist
+}