feat: add solutions to lc problem: No.3078 (doocs#2441)

No.3078.Match Alphanumerical Pattern in Matrix I

Author: yanglbme

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/README.md

@@ -0,0 +1,41 @@
+class Solution {
+public:
+    vector<int> findPattern(vector<vector<int>>& board, vector<string>& pattern) {
+        int m = board.size(), n = board[0].size();
+        int r = pattern.size(), c = pattern[0].size();
+        auto check = [&](int i, int j) {
+            vector<int> d1(26, -1);
+            vector<int> d2(10, -1);
+            for (int a = 0; a < r; ++a) {
+                for (int b = 0; b < c; ++b) {
+                    int x = i + a, y = j + b;
+                    if (isdigit(pattern[a][b])) {
+                        int v = pattern[a][b] - '0';
+                        if (v != board[x][y]) {
+                            return false;
+                        }
+                    } else {
+                        int v = pattern[a][b] - 'a';
+                        if (d1[v] != -1 && d1[v] != board[x][y]) {
+                            return false;
+                        }
+                        if (d2[board[x][y]] != -1 && d2[board[x][y]] != v) {
+                            return false;
+                        }
+                        d1[v] = board[x][y];
+                        d2[board[x][y]] = v;
+                    }
+                }
+            }
+            return true;
+        };
+        for (int i = 0; i < m - r + 1; ++i) {
+            for (int j = 0; j < n - c + 1; ++j) {
+                if (check(i, j)) {
+                    return {i, j};
+                }
+            }
+        }
+        return {-1, -1};
+    }
+};

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/README_EN.md

@@ -0,0 +1,38 @@
+func findPattern(board [][]int, pattern []string) []int {
+	m, n := len(board), len(board[0])
+	r, c := len(pattern), len(pattern[0])
+	check := func(i, j int) bool {
+		d1 := [26]int{}
+		d2 := [10]int{}
+		for a := 0; a < r; a++ {
+			for b := 0; b < c; b++ {
+				x, y := i+a, j+b
+				if pattern[a][b] >= '0' && pattern[a][b] <= '9' {
+					v := int(pattern[a][b] - '0')
+					if v != board[x][y] {
+						return false
+					}
+				} else {
+					v := int(pattern[a][b] - 'a')
+					if d1[v] > 0 && d1[v]-1 != board[x][y] {
+						return false
+					}
+					if d2[board[x][y]] > 0 && d2[board[x][y]]-1 != v {
+						return false
+					}
+					d1[v] = board[x][y] + 1
+					d2[board[x][y]] = v + 1
+				}
+			}
+		}
+		return true
+	}
+	for i := 0; i < m-r+1; i++ {
+		for j := 0; j < n-c+1; j++ {
+			if check(i, j) {
+				return []int{i, j}
+			}
+		}
+	}
+	return []int{-1, -1}
+}

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/Solution.cpp

@@ -0,0 +1,43 @@
+class Solution {
+    public int[] findPattern(int[][] board, String[] pattern) {
+        int m = board.length, n = board[0].length;
+        int r = pattern.length, c = pattern[0].length();
+        for (int i = 0; i < m - r + 1; ++i) {
+            for (int j = 0; j < n - c + 1; ++j) {
+                if (check(board, pattern, i, j)) {
+                    return new int[] {i, j};
+                }
+            }
+        }
+        return new int[] {-1, -1};
+    }
+
+    private boolean check(int[][] board, String[] pattern, int i, int j) {
+        int[] d1 = new int[26];
+        int[] d2 = new int[10];
+        Arrays.fill(d1, -1);
+        Arrays.fill(d2, -1);
+        for (int a = 0; a < pattern.length; ++a) {
+            for (int b = 0; b < pattern[0].length(); ++b) {
+                int x = i + a, y = j + b;
+                if (Character.isDigit(pattern[a].charAt(b))) {
+                    int v = pattern[a].charAt(b) - '0';
+                    if (v != board[x][y]) {
+                        return false;
+                    }
+                } else {
+                    int v = pattern[a].charAt(b) - 'a';
+                    if (d1[v] != -1 && d1[v] != board[x][y]) {
+                        return false;
+                    }
+                    if (d2[board[x][y]] != -1 && d2[board[x][y]] != v) {
+                        return false;
+                    }
+                    d1[v] = board[x][y];
+                    d2[board[x][y]] = v;
+                }
+            }
+        }
+        return true;
+    }
+}

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/Solution.go

@@ -0,0 +1,27 @@
+class Solution:
+    def findPattern(self, board: List[List[int]], pattern: List[str]) -> List[int]:
+        def check(i: int, j: int) -> bool:
+            d1 = {}
+            d2 = {}
+            for a in range(r):
+                for b in range(c):
+                    x, y = i + a, j + b
+                    if pattern[a][b].isdigit():
+                        if int(pattern[a][b]) != board[x][y]:
+                            return False
+                    else:
+                        if pattern[a][b] in d1 and d1[pattern[a][b]] != board[x][y]:
+                            return False
+                        if board[x][y] in d2 and d2[board[x][y]] != pattern[a][b]:
+                            return False
+                        d1[pattern[a][b]] = board[x][y]
+                        d2[board[x][y]] = pattern[a][b]
+            return True
+
+        m, n = len(board), len(board[0])
+        r, c = len(pattern), len(pattern[0])
+        for i in range(m - r + 1):
+            for j in range(n - c + 1):
+                if check(i, j):
+                    return [i, j]
+        return [-1, -1]

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/Solution.java

@@ -0,0 +1,45 @@
+function findPattern(board: number[][], pattern: string[]): number[] {
+    const m: number = board.length;
+    const n: number = board[0].length;
+    const r: number = pattern.length;
+    const c: number = pattern[0].length;
+
+    const check = (i: number, j: number): boolean => {
+        const d1: number[] = Array(26).fill(-1);
+        const d2: number[] = Array(10).fill(-1);
+
+        for (let a = 0; a < r; ++a) {
+            for (let b = 0; b < c; ++b) {
+                const x: number = i + a;
+                const y: number = j + b;
+
+                if (!isNaN(Number(pattern[a][b]))) {
+                    const v: number = Number(pattern[a][b]);
+                    if (v !== board[x][y]) {
+                        return false;
+                    }
+                } else {
+                    const v: number = pattern[a].charCodeAt(b) - 'a'.charCodeAt(0);
+                    if (d1[v] !== -1 && d1[v] !== board[x][y]) {
+                        return false;
+                    }
+                    if (d2[board[x][y]] !== -1 && d2[board[x][y]] !== v) {
+                        return false;
+                    }
+                    d1[v] = board[x][y];
+                    d2[board[x][y]] = v;
+                }
+            }
+        }
+        return true;
+    };
+
+    for (let i = 0; i < m - r + 1; ++i) {
+        for (let j = 0; j < n - c + 1; ++j) {
+            if (check(i, j)) {
+                return [i, j];
+            }
+        }
+    }
+    return [-1, -1];
+}

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/Solution.py

@@ -3088,6 +3088,7 @@
 |  3075  |  [幸福值最大化的选择方案](/solution/3000-3099/3075.Maximize%20Happiness%20of%20Selected%20Children/README.md)  |  `贪心`,`数组`,`排序`  |  中等  |  第 388 场周赛  |
 |  3076  |  [数组中的最短非公共子字符串](/solution/3000-3099/3076.Shortest%20Uncommon%20Substring%20in%20an%20Array/README.md)  |  `字典树`,`数组`,`哈希表`,`字符串`  |  中等  |  第 388 场周赛  |
 |  3077  |  [K 个不相交子数组的最大能量值](/solution/3000-3099/3077.Maximum%20Strength%20of%20K%20Disjoint%20Subarrays/README.md)  |  `数组`,`动态规划`,`前缀和`  |  困难  |  第 388 场周赛  |
+|  3078  |  [Match Alphanumerical Pattern in Matrix I](/solution/3000-3099/3078.Match%20Alphanumerical%20Pattern%20in%20Matrix%20I/README.md)  |    |  中等  |  🔒  |
 
 ## 版权
 

solution/3000-3099/3078.Match Alphanumerical Pattern in Matrix I/Solution.ts

@@ -3086,6 +3086,7 @@ Press <kbd>Control</kbd> + <kbd>F</kbd>(or <kbd>Command</kbd> + <kbd>F</kbd> on
 |  3075  |  [Maximize Happiness of Selected Children](/solution/3000-3099/3075.Maximize%20Happiness%20of%20Selected%20Children/README_EN.md)  |  `Greedy`,`Array`,`Sorting`  |  Medium  |  Weekly Contest 388  |
 |  3076  |  [Shortest Uncommon Substring in an Array](/solution/3000-3099/3076.Shortest%20Uncommon%20Substring%20in%20an%20Array/README_EN.md)  |  `Trie`,`Array`,`Hash Table`,`String`  |  Medium  |  Weekly Contest 388  |
 |  3077  |  [Maximum Strength of K Disjoint Subarrays](/solution/3000-3099/3077.Maximum%20Strength%20of%20K%20Disjoint%20Subarrays/README_EN.md)  |  `Array`,`Dynamic Programming`,`Prefix Sum`  |  Hard  |  Weekly Contest 388  |
+|  3078  |  [Match Alphanumerical Pattern in Matrix I](/solution/3000-3099/3078.Match%20Alphanumerical%20Pattern%20in%20Matrix%20I/README_EN.md)  |    |  Medium  |  🔒  |
 
 ## Copyright