feat: add solutions to lc problem: No.0087

No.0087.Scramble String

Author: yanglbme

solution/0000-0099/0087.Scramble String/README.md

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    bool isScramble(string s1, string s2) {
+        int n = s1.size();
+        int f[n][n][n + 1];
+        memset(f, -1, sizeof(f));
+        function<bool(int, int, int)> dfs = [&](int i, int j, int k) -> int {
+            if (f[i][j][k] != -1) {
+                return f[i][j][k] == 1;
+            }
+            if (k == 1) {
+                return s1[i] == s2[j];
+            }
+            for (int h = 1; h < k; ++h) {
+                if (dfs(i, j, h) && dfs(i + h, j + h, k - h)) {
+                    return f[i][j][k] = true;
+                }
+                if (dfs(i + h, j, k - h) && dfs(i, j + k - h, h)) {
+                    return f[i][j][k] = true;
+                }
+            }
+            return f[i][j][k] = false;
+        };
+        return dfs(0, 0, n);
+    }
+};

solution/0000-0099/0087.Scramble String/README_EN.md

@@ -1,35 +1,34 @@
 public class Solution {
+    private string s1;
+    private string s2;
+    private int[,,] f;
+
     public bool IsScramble(string s1, string s2) {
-        if (s1.Length != s2.Length) return false;
-        var length = s1.Length;
-        if (length == 0) return true;
-        var f = new bool[length + 1, length, length];
-        for (var i = 0; i < length; ++i)
-        {
-            for (var j = 0; j < length; ++j)
-            {
-                f[1, i, j] = s1[i] == s2[j];
-            }
+        int n = s1.Length;
+        this.s1 = s1;
+        this.s2 = s2;
+        f = new int[n, n, n + 1];
+        return dfs(0, 0, n);
+    }
+
+    private bool dfs(int i, int j, int k) {
+        if (f[i, j, k] != 0) {
+            return f[i, j, k] == 1;
         }
-        for (var i = 2; i <= length; ++i)
-        {
-            for (var j = 0; j <= length - i; ++j)
-            {
-                for (var k = 0; k <= length - i; ++k)
-                {
-                    for (var l = 1; l < i; ++l)
-                    {
-                        if (f[l, j, k] && f[i - l, j + l, k + l]
-                            || f[l, j, k + i - l] && f[i - l, j + l, k])
-                        {
-                            f[i, j, k] = true;
-                            break;
-                        }
-                    }
-                }
+        if (k == 1) {
+            return s1[i] == s2[j];
+        }
+        for (int h = 1; h < k; ++h) {
+            if (dfs(i, j, h) && dfs(i + h, j + h, k - h)) {
+                f[i, j, k] = 1;
+                return true;
+            }
+            if (dfs(i, j + k - h, h) && dfs(i + h, j, k - h)) {
+                f[i, j, k] = 1;
+                return true;
             }
         }
-
-        return f[length, 0, 0];
+        f[i, j, k] = -1;
+        return false;
     }
 }

solution/0000-0099/0087.Scramble String/Solution.cpp

@@ -1,32 +1,28 @@
 func isScramble(s1 string, s2 string) bool {
 	n := len(s1)
-	dp := make([][][]bool, n+1)
-	for i := range dp {
-		dp[i] = make([][]bool, n)
-		for j := range dp[i] {
-			dp[i][j] = make([]bool, n+1)
+	f := make([][][]int, n)
+	for i := range f {
+		f[i] = make([][]int, n)
+		for j := range f[i] {
+			f[i][j] = make([]int, n+1)
 		}
 	}
-	for i := 0; i < n; i++ {
-		for j := 0; j < n; j++ {
-			dp[i][j][1] = s1[i] == s2[j]
+	var dfs func(i, j, k int) bool
+	dfs = func(i, j, k int) bool {
+		if k == 1 {
+			return s1[i] == s2[j]
 		}
-	}
-	for l := 2; l < n+1; l++ {
-		for i1 := 0; i1 < n-l+1; i1++ {
-			for i2 := 0; i2 < n-l+1; i2++ {
-				for i := 1; i < l; i++ {
-					if dp[i1][i2][i] && dp[i1+i][i2+i][l-i] {
-						dp[i1][i2][l] = true
-						break
-					}
-					if dp[i1][i2+l-i][i] && dp[i1+i][i2][l-i] {
-						dp[i1][i2][l] = true
-						break
-					}
-				}
+		if f[i][j][k] != 0 {
+			return f[i][j][k] == 1
+		}
+		f[i][j][k] = 2
+		for h := 1; h < k; h++ {
+			if (dfs(i, j, h) && dfs(i+h, j+h, k-h)) || (dfs(i+h, j, k-h) && dfs(i, j+k-h, h)) {
+				f[i][j][k] = 1
+				return true
 			}
 		}
+		return false
 	}
-	return dp[0][0][n]
-}
+	return dfs(0, 0, n)
+}

solution/0000-0099/0087.Scramble String/Solution.cs

@@ -1,28 +1,31 @@
 class Solution {
+    private Boolean[][][] f;
+    private String s1;
+    private String s2;
+
     public boolean isScramble(String s1, String s2) {
         int n = s1.length();
-        boolean[][][] dp = new boolean[n][n][n + 1];
-        for (int i = 0; i < n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                dp[i][j][1] = s1.charAt(i) == s2.charAt(j);
-            }
+        this.s1 = s1;
+        this.s2 = s2;
+        f = new Boolean[n][n][n + 1];
+        return dfs(0, 0, n);
+    }
+
+    private boolean dfs(int i, int j, int k) {
+        if (f[i][j][k] != null) {
+            return f[i][j][k];
         }
-        for (int len = 2; len <= n; ++len) {
-            for (int i1 = 0; i1 <= n - len; ++i1) {
-                for (int i2 = 0; i2 <= n - len; ++i2) {
-                    for (int i = 1; i < len; ++i) {
-                        if (dp[i1][i2][i] && dp[i1 + i][i2 + i][len - i]) {
-                            dp[i1][i2][len] = true;
-                            break;
-                        }
-                        if (dp[i1][i2 + len - i][i] && dp[i1 + i][i2][len - i]) {
-                            dp[i1][i2][len] = true;
-                            break;
-                        }
-                    }
-                }
+        if (k == 1) {
+            return s1.charAt(i) == s2.charAt(j);
+        }
+        for (int h = 1; h < k; ++h) {
+            if (dfs(i, j, h) && dfs(i + h, j + h, k - h)) {
+                return f[i][j][k] = true;
+            }
+            if (dfs(i + h, j, k - h) && dfs(i, j + k - h, h)) {
+                return f[i][j][k] = true;
             }
         }
-        return dp[0][0][n];
+        return f[i][j][k] = false;
     }
 }

solution/0000-0099/0087.Scramble String/Solution.go

@@ -1,18 +1,14 @@
 class Solution:
     def isScramble(self, s1: str, s2: str) -> bool:
-        n = len(s1)
-        dp = [[[False] * (n + 1) for _ in range(n)] for _ in range(n)]
-        for i in range(n):
-            for j in range(n):
-                dp[i][j][1] = s1[i] == s2[j]
-        for l in range(2, n + 1):
-            for i1 in range(n - l + 1):
-                for i2 in range(n - l + 1):
-                    for i in range(1, l):
-                        if dp[i1][i2][i] and dp[i1 + i][i2 + i][l - i]:
-                            dp[i1][i2][l] = True
-                            break
-                        if dp[i1][i2 + l - i][i] and dp[i1 + i][i2][l - i]:
-                            dp[i1][i2][l] = True
-                            break
-        return dp[0][0][n]
+        @cache
+        def dfs(i: int, j: int, k: int) -> bool:
+            if k == 1:
+                return s1[i] == s2[j]
+            for h in range(1, k):
+                if dfs(i, j, h) and dfs(i + h, j + h, k - h):
+                    return True
+                if dfs(i + h, j, k - h) and dfs(i, j + k - h, h):
+                    return True
+            return False
+
+        return dfs(0, 0, len(s1))

solution/0000-0099/0087.Scramble String/Solution.java

@@ -0,0 +1,24 @@
+function isScramble(s1: string, s2: string): boolean {
+    const n = s1.length;
+    const f = new Array(n)
+        .fill(0)
+        .map(() => new Array(n).fill(0).map(() => new Array(n + 1).fill(-1)));
+    const dfs = (i: number, j: number, k: number): boolean => {
+        if (f[i][j][k] !== -1) {
+            return f[i][j][k] === 1;
+        }
+        if (k === 1) {
+            return s1[i] === s2[j];
+        }
+        for (let h = 1; h < k; ++h) {
+            if (dfs(i, j, h) && dfs(i + h, j + h, k - h)) {
+                return Boolean((f[i][j][k] = 1));
+            }
+            if (dfs(i + h, j, k - h) && dfs(i, j + k - h, h)) {
+                return Boolean((f[i][j][k] = 1));
+            }
+        }
+        return Boolean((f[i][j][k] = 0));
+    };
+    return dfs(0, 0, n);
+}