feat: add solutions to lc problem: No.44

solution/0000-0099/0044.Wildcard Matching/Solution.cpp

@@ -2,22 +2,25 @@ class Solution {
 public:
     bool isMatch(string s, string p) {
         int m = s.size(), n = p.size();
-        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
-        dp[0][0] = true;
-        for (int j = 1; j <= n; ++j) {
-            if (p[j - 1] == '*') {
-                dp[0][j] = dp[0][j - 1];
+        int f[m + 1][n + 1];
+        memset(f, -1, sizeof(f));
+        function<bool(int, int)> dfs = [&](int i, int j) {
+            if (i >= m) {
+                return j >= n || (p[j] == '*' && dfs(i, j + 1));
             }
-        }
-        for (int i = 1; i <= m; ++i) {
-            for (int j = 1; j <= n; ++j) {
-                if (s[i - 1] == p[j - 1] || p[j - 1] == '?') {
-                    dp[i][j] = dp[i - 1][j - 1];
-                } else if (p[j - 1] == '*') {
-                    dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
-                }
+            if (j >= n) {
+                return false;
             }
-        }
-        return dp[m][n];
+            if (f[i][j] != -1) {
+                return f[i][j] == 1;
+            }
+            if (p[j] == '*') {
+                f[i][j] = dfs(i + 1, j) || dfs(i, j + 1) ? 1 : 0;
+            } else {
+                f[i][j] = (p[j] == '?' || s[i] == p[j]) && dfs(i + 1, j + 1) ? 1 : 0;
+            }
+            return f[i][j] == 1;
+        };
+        return dfs(0, 0);
     }
 };

solution/0000-0099/0044.Wildcard Matching/Solution.cs

@@ -1,43 +1,34 @@
-using System.Linq;
-
 public class Solution {
+    private bool?[,] f;
+    private char[] s;
+    private char[] p;
+    private int m;
+    private int n;
+
     public bool IsMatch(string s, string p) {
-        if (p.Count(ch => ch != '*') > s.Length)
-        {
+        this.s = s.ToCharArray();
+        this.p = p.ToCharArray();
+        m = s.Length;
+        n = p.Length;
+        f = new bool?[m, n];
+        return Dfs(0, 0);
+    }
+
+    private bool Dfs(int i, int j) {
+        if (i >= m) {
+            return j >= n || (p[j] == '*' && Dfs(i, j + 1));
+        }
+        if (j >= n) {
             return false;
         }
-
-        bool[,] f = new bool[s.Length + 1, p.Length + 1];
-        bool[] d = new bool[s.Length + 1]; // d[i] means f[0, j] || f[1, j] || ... || f[i, j]
-        for (var j = 0; j <= p.Length; ++j)
-        {
-            d[0] = j == 0 ? true : d[0] && p[j - 1] == '*';
-            for (var i = 0; i <= s.Length; ++i)
-            {
-                if (j == 0)
-                {
-                    f[i, j] = i == 0;
-                    continue;
-                }
-
-                if (p[j - 1] == '*')
-                {
-                    if (i > 0)
-                    {
-                        d[i] = f[i, j - 1] || d[i - 1];
-                    }
-                    f[i, j] = d[i];
-                }
-                else if (p[j - 1] == '?')
-                {
-                    f[i, j] = i > 0 && f[i - 1, j - 1];
-                }
-                else
-                {
-                    f[i, j] = i > 0 && f[i - 1, j - 1] && s[i - 1] == p[j - 1];
-                }
-            }
+        if (f[i, j] != null) {
+            return f[i, j].Value;
+        }
+        if (p[j] == '*') {
+            f[i, j] = Dfs(i + 1, j) || Dfs(i + 1, j + 1) || Dfs(i, j + 1);
+        } else {
+            f[i, j] = (p[j] == '?' || s[i] == p[j]) && Dfs(i + 1, j + 1);
         }
-        return f[s.Length, p.Length];
+        return f[i, j].Value;
     }
-}
+}

solution/0000-0099/0044.Wildcard Matching/Solution.go

@@ -1,23 +1,31 @@
 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)
+	f := make([][]int, m+1)
+	for i := range f {
+		f[i] = make([]int, n+1)
 	}
-	dp[0][0] = true
-	for j := 1; j <= n; j++ {
-		if p[j-1] == '*' {
-			dp[0][j] = dp[0][j-1]
+	var dfs func(i, j int) bool
+	dfs = func(i, j int) bool {
+		if i >= m {
+			return j >= n || p[j] == '*' && dfs(i, j+1)
 		}
-	}
-	for i := 1; i <= m; i++ {
-		for j := 1; j <= n; j++ {
-			if s[i-1] == p[j-1] || p[j-1] == '?' {
-				dp[i][j] = dp[i-1][j-1]
-			} else if p[j-1] == '*' {
-				dp[i][j] = dp[i-1][j] || dp[i][j-1]
-			}
+		if j >= n {
+			return false
+		}
+		if f[i][j] != 0 {
+			return f[i][j] == 1
+		}
+		f[i][j] = 2
+		ok := false
+		if p[j] == '*' {
+			ok = dfs(i+1, j) || dfs(i+1, j+1) || dfs(i, j+1)
+		} else {
+			ok = (p[j] == '?' || s[i] == p[j]) && dfs(i+1, j+1)
+		}
+		if ok {
+			f[i][j] = 1
 		}
+		return ok
 	}
-	return dp[m][n]
+	return dfs(0, 0)
 }

solution/0000-0099/0044.Wildcard Matching/Solution.java

@@ -1,22 +1,34 @@
 class Solution {
+    private Boolean[][] f;
+    private char[] s;
+    private char[] p;
+    private int m;
+    private int n;
+
     public boolean isMatch(String s, String p) {
-        int m = s.length(), n = p.length();
-        boolean[][] dp = new boolean[m + 1][n + 1];
-        dp[0][0] = true;
-        for (int j = 1; j <= n; ++j) {
-            if (p.charAt(j - 1) == '*') {
-                dp[0][j] = dp[0][j - 1];
-            }
+        this.s = s.toCharArray();
+        this.p = p.toCharArray();
+        m = s.length();
+        n = p.length();
+        f = new Boolean[m][n];
+        return dfs(0, 0);
+    }
+
+    private boolean dfs(int i, int j) {
+        if (i >= m) {
+            return j >= n || (p[j] == '*' && dfs(i, j + 1));
+        }
+        if (j >= n) {
+            return false;
+        }
+        if (f[i][j] != null) {
+            return f[i][j];
         }
-        for (int i = 1; i <= m; ++i) {
-            for (int j = 1; j <= n; ++j) {
-                if (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '?') {
-                    dp[i][j] = dp[i - 1][j - 1];
-                } else if (p.charAt(j - 1) == '*') {
-                    dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
-                }
-            }
+        if (p[j] == '*') {
+            f[i][j] = dfs(i + 1, j) || dfs(i + 1, j + 1) || dfs(i, j + 1);
+        } else {
+            f[i][j] = (p[j] == '?' || s[i] == p[j]) && dfs(i + 1, j + 1);
         }
-        return dp[m][n];
+        return f[i][j];
     }
 }

solution/0000-0099/0044.Wildcard Matching/Solution.py

@@ -1,15 +1,13 @@
 class Solution:
     def isMatch(self, s: str, p: str) -> bool:
-        m, n = len(s), len(p)
-        dp = [[False] * (n + 1) for _ in range(m + 1)]
-        dp[0][0] = True
-        for j in range(1, n + 1):
-            if p[j - 1] == '*':
-                dp[0][j] = dp[0][j - 1]
-        for i in range(1, m + 1):
-            for j in range(1, n + 1):
-                if s[i - 1] == p[j - 1] or p[j - 1] == '?':
-                    dp[i][j] = dp[i - 1][j - 1]
-                elif p[j - 1] == '*':
-                    dp[i][j] = dp[i - 1][j] or dp[i][j - 1]
-        return dp[m][n]
+        @cache
+        def dfs(i: int, j: int) -> bool:
+            if i >= len(s):
+                return j >= len(p) or (p[j] == "*" and dfs(i, j + 1))
+            if j >= len(p):
+                return False
+            if p[j] == "*":
+                return dfs(i + 1, j) or dfs(i + 1, j + 1) or dfs(i, j + 1)
+            return (p[j] == "?" or s[i] == p[j]) and dfs(i + 1, j + 1)
+
+        return dfs(0, 0)

solution/0000-0099/0044.Wildcard Matching/Solution.ts

@@ -0,0 +1,25 @@
+function isMatch(s: string, p: string): boolean {
+    const m = s.length;
+    const n = p.length;
+    const f: number[][] = Array.from({ length: m + 1 }, () =>
+        Array.from({ length: n + 1 }, () => -1),
+    );
+    const dfs = (i: number, j: number): boolean => {
+        if (i >= m) {
+            return j >= n || (p[j] === '*' && dfs(i, j + 1));
+        }
+        if (j >= n) {
+            return false;
+        }
+        if (f[i][j] !== -1) {
+            return f[i][j] === 1;
+        }
+        if (p[j] === '*') {
+            f[i][j] = dfs(i + 1, j) || dfs(i, j + 1) ? 1 : 0;
+        } else {
+            f[i][j] = (p[j] === '?' || s[i] === p[j]) && dfs(i + 1, j + 1) ? 1 : 0;
+        }
+        return f[i][j] === 1;
+    };
+    return dfs(0, 0);
+}

solution/0000-0099/0044.Wildcard Matching/Solution2.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    bool isMatch(string s, string p) {
+        int m = s.length(), n = p.length();
+        bool f[m + 1][n + 1];
+        memset(f, false, sizeof(f));
+        f[0][0] = true;
+        for (int j = 1; j <= n; ++j) {
+            if (p[j - 1] == '*') {
+                f[0][j] = f[0][j - 1];
+            }
+        }
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                if (p[j - 1] == '*') {
+                    f[i][j] = f[i - 1][j] || f[i][j - 1] || f[i - 1][j - 1];
+                } else {
+                    f[i][j] = f[i - 1][j - 1] && (p[j - 1] == '?' || s[i - 1] == p[j - 1]);
+                }
+            }
+        }
+        return f[m][n];
+    }
+};

solution/0000-0099/0044.Wildcard Matching/Solution2.go

@@ -0,0 +1,23 @@
+func isMatch(s string, p string) bool {
+	m, n := len(s), len(p)
+	f := make([][]bool, m+1)
+	for i := range f {
+		f[i] = make([]bool, n+1)
+	}
+	f[0][0] = true
+	for j := 1; j <= n; j++ {
+		if p[j-1] == '*' {
+			f[0][j] = f[0][j-1]
+		}
+	}
+	for i := 1; i <= m; i++ {
+		for j := 1; j <= n; j++ {
+			if p[j-1] == '*' {
+				f[i][j] = f[i-1][j] || f[i][j-1] || f[i-1][j-1]
+			} else {
+				f[i][j] = f[i-1][j-1] && (p[j-1] == '?' || s[i-1] == p[j-1])
+			}
+		}
+	}
+	return f[m][n]
+}

solution/0000-0099/0044.Wildcard Matching/Solution2.java

@@ -0,0 +1,23 @@
+class Solution {
+    public boolean isMatch(String s, String p) {
+        int m = s.length(), n = p.length();
+        boolean[][] f = new boolean[m + 1][n + 1];
+        f[0][0] = true;
+        for (int j = 1; j <= n; ++j) {
+            if (p.charAt(j - 1) == '*') {
+                f[0][j] = f[0][j - 1];
+            }
+        }
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                if (p.charAt(j - 1) == '*') {
+                    f[i][j] = f[i - 1][j] || f[i][j - 1] || f[i - 1][j - 1];
+                } else {
+                    f[i][j] = f[i - 1][j - 1]
+                        && (p.charAt(j - 1) == '?' || s.charAt(i - 1) == p.charAt(j - 1));
+                }
+            }
+        }
+        return f[m][n];
+    }
+}

solution/0000-0099/0044.Wildcard Matching/Solution2.py

@@ -0,0 +1,17 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        m, n = len(s), len(p)
+        f = [[False] * (n + 1) for _ in range(m + 1)]
+        f[0][0] = True
+        for j in range(1, n + 1):
+            if p[j - 1] == "*":
+                f[0][j] = f[0][j - 1]
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if p[j - 1] == "*":
+                    f[i][j] = f[i - 1][j] or f[i][j - 1] or f[i - 1][j - 1]
+                else:
+                    f[i][j] = f[i - 1][j - 1] and (
+                        p[j - 1] == "?" or s[i - 1] == p[j - 1]
+                    )
+        return f[m][n]

solution/0000-0099/0044.Wildcard Matching/Solution2.ts

@@ -0,0 +1,23 @@
+function isMatch(s: string, p: string): boolean {
+    const m: number = s.length;
+    const n: number = p.length;
+    const f: boolean[][] = Array.from({ length: m + 1 }, () =>
+        Array.from({ length: n + 1 }, () => false),
+    );
+    f[0][0] = true;
+    for (let j = 1; j <= n; ++j) {
+        if (p.charAt(j - 1) === '*') {
+            f[0][j] = f[0][j - 1];
+        }
+    }
+    for (let i = 1; i <= m; ++i) {
+        for (let j = 1; j <= n; ++j) {
+            if (p[j - 1] === '*') {
+                f[i][j] = f[i - 1][j] || f[i][j - 1] || f[i - 1][j - 1];
+            } else {
+                f[i][j] = f[i - 1][j - 1] && (p[j - 1] === '?' || s[i - 1] === p[j - 1]);
+            }
+        }
+    }
+    return f[m][n];
+}