Added tasks 1074, 1078, 1079.

Author: javadev

src/main/java/g1001_1100/s1074_number_of_submatrices_that_sum_to_target/Solution.java

@@ -0,0 +1,34 @@
+package g1001_1100.s1074_number_of_submatrices_that_sum_to_target;
+
+// #Hard #Array #Hash_Table #Matrix #Prefix_Sum
+// #2022_02_26_Time_171_ms_(68.35%)_Space_117.8_MB_(5.54%)
+
+import java.util.HashMap;
+
+public class Solution {
+    public int numSubmatrixSumTarget(int[][] matrix, int target) {
+        int rows = matrix.length;
+        int columns = matrix[0].length;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 1; j < columns; j++) {
+                matrix[i][j] += matrix[i][j - 1];
+            }
+        }
+        HashMap<Integer, Integer> sumMap = new HashMap<>();
+        int cur;
+        int res = 0;
+        for (int i = 0; i < columns; i++) {
+            for (int j = i; j < columns; j++) {
+                sumMap.clear();
+                sumMap.put(0, 1);
+                cur = 0;
+                for (int[] ints : matrix) {
+                    cur += ints[j] - (i > 0 ? ints[i - 1] : 0);
+                    res += sumMap.getOrDefault(cur - target, 0);
+                    sumMap.put(cur, sumMap.getOrDefault(cur, 0) + 1);
+                }
+            }
+        }
+        return res;
+    }
+}

src/main/java/g1001_1100/s1074_number_of_submatrices_that_sum_to_target/readme.md

@@ -0,0 +1,40 @@
+1074\. Number of Submatrices That Sum to Target
+
+Hard
+
+Given a `matrix` and a `target`, return the number of non-empty submatrices that sum to target.
+
+A submatrix `x1, y1, x2, y2` is the set of all cells `matrix[x][y]` with `x1 <= x <= x2` and `y1 <= y <= y2`.
+
+Two submatrices `(x1, y1, x2, y2)` and `(x1', y1', x2', y2')` are different if they have some coordinate that is different: for example, if `x1 != x1'`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/02/mate1.jpg)
+
+**Input:** matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0
+
+**Output:** 4
+
+**Explanation:** The four 1x1 submatrices that only contain 0.
+
+**Example 2:**
+
+**Input:** matrix = [[1,-1],[-1,1]], target = 0
+
+**Output:** 5
+
+**Explanation:** The two 1x2 submatrices, plus the two 2x1 submatrices, plus the 2x2 submatrix.
+
+**Example 3:**
+
+**Input:** matrix = [[904]], target = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= matrix.length <= 100`
+*   `1 <= matrix[0].length <= 100`
+*   `-1000 <= matrix[i] <= 1000`
+*   `-10^8 <= target <= 10^8`

src/main/java/g1001_1100/s1078_occurrences_after_bigram/Solution.java

@@ -0,0 +1,24 @@
+package g1001_1100.s1078_occurrences_after_bigram;
+
+// #Easy #String #2022_02_26_Time_0_ms_(100.00%)_Space_40.4_MB_(48.38%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public String[] findOcurrences(String text, String first, String second) {
+        List<String> list = new ArrayList<>();
+        String[] str = text.split(" ");
+        for (int i = 0; i < str.length; i++) {
+            if (str[i].equals(first) && str.length - 1 >= i + 2 && str[i + 1].equals(second)) {
+                list.add(str[i + 2]);
+            }
+        }
+        String[] s = new String[list.size()];
+        int j = 0;
+        for (String ele : list) {
+            s[j++] = ele;
+        }
+        return s;
+    }
+}

src/main/java/g1001_1100/s1078_occurrences_after_bigram/readme.md

@@ -0,0 +1,27 @@
+1078\. Occurrences After Bigram
+
+Easy
+
+Given two strings `first` and `second`, consider occurrences in some text of the form `"first second third"`, where `second` comes immediately after `first`, and `third` comes immediately after `second`.
+
+Return _an array of all the words_ `third` _for each occurrence of_ `"first second third"`.
+
+**Example 1:**
+
+**Input:** text = "alice is a good girl she is a good student", first = "a", second = "good"
+
+**Output:** ["girl","student"]
+
+**Example 2:**
+
+**Input:** text = "we will we will rock you", first = "we", second = "will"
+
+**Output:** ["we","rock"]
+
+**Constraints:**
+
+*   `1 <= text.length <= 1000`
+*   `text` consists of lowercase English letters and spaces.
+*   All the words in `text` a separated by **a single space**.
+*   `1 <= first.length, second.length <= 10`
+*   `first` and `second` consist of lowercase English letters.

src/main/java/g1001_1100/s1079_letter_tile_possibilities/Solution.java

@@ -0,0 +1,33 @@
+package g1001_1100.s1079_letter_tile_possibilities;
+
+// #Medium #String #Backtracking #2022_02_26_Time_3_ms_(86.86%)_Space_42.3_MB_(51.05%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int count;
+
+    public int numTilePossibilities(String tiles) {
+        count = 0;
+        char[] chars = tiles.toCharArray();
+        Arrays.sort(chars);
+        boolean[] visited = new boolean[chars.length];
+        dfs(chars, 0, visited);
+        return count;
+    }
+
+    private void dfs(char[] chars, int length, boolean[] visited) {
+        if (length == chars.length) {
+            return;
+        }
+        for (int i = 0; i < chars.length; i++) {
+            if (visited[i] || i - 1 >= 0 && chars[i] == chars[i - 1] && !visited[i - 1]) {
+                continue;
+            }
+            count++;
+            visited[i] = true;
+            dfs(chars, length + 1, visited);
+            visited[i] = false;
+        }
+    }
+}

src/main/java/g1001_1100/s1079_letter_tile_possibilities/readme.md

@@ -0,0 +1,32 @@
+1079\. Letter Tile Possibilities
+
+Medium
+
+You have `n` `tiles`, where each tile has one letter `tiles[i]` printed on it.
+
+Return _the number of possible non-empty sequences of letters_ you can make using the letters printed on those `tiles`.
+
+**Example 1:**
+
+**Input:** tiles = "AAB"
+
+**Output:** 8
+
+**Explanation:** The possible sequences are "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA".
+
+**Example 2:**
+
+**Input:** tiles = "AAABBC"
+
+**Output:** 188
+
+**Example 3:**
+
+**Input:** tiles = "V"
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= tiles.length <= 7`
+*   `tiles` consists of uppercase English letters.

src/test/java/g1001_1100/s1074_number_of_submatrices_that_sum_to_target/SolutionTest.java

@@ -0,0 +1,23 @@
+package g1001_1100.s1074_number_of_submatrices_that_sum_to_target;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numSubmatrixSumTarget() {
+        assertThat(
+                new Solution()
+                        .numSubmatrixSumTarget(new int[][] {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}}, 0),
+                equalTo(4));
+    }
+
+    @Test
+    void numSubmatrixSumTarget2() {
+        assertThat(
+                new Solution().numSubmatrixSumTarget(new int[][] {{1, -1}, {-1, 1}}, 0),
+                equalTo(5));
+    }
+}

src/test/java/g1001_1100/s1078_occurrences_after_bigram/SolutionTest.java

@@ -0,0 +1,23 @@
+package g1001_1100.s1078_occurrences_after_bigram;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findOcurrences() {
+        assertThat(
+                new Solution()
+                        .findOcurrences("alice is a good girl she is a good student", "a", "good"),
+                equalTo(new String[] {"girl", "student"}));
+    }
+
+    @Test
+    void findOcurrences2() {
+        assertThat(
+                new Solution().findOcurrences("we will we will rock you", "we", "will"),
+                equalTo(new String[] {"we", "rock"}));
+    }
+}

src/test/java/g1001_1100/s1079_letter_tile_possibilities/SolutionTest.java

@@ -0,0 +1,23 @@
+package g1001_1100.s1079_letter_tile_possibilities;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numTilePossibilities() {
+        assertThat(new Solution().numTilePossibilities("AAB"), equalTo(8));
+    }
+
+    @Test
+    void numTilePossibilities2() {
+        assertThat(new Solution().numTilePossibilities("AAABBC"), equalTo(188));
+    }
+
+    @Test
+    void numTilePossibilities3() {
+        assertThat(new Solution().numTilePossibilities("V"), equalTo(1));
+    }
+}