Added tasks 3324-3327

Author: javadev

src/main/java/g3301_3400/s3324_find_the_sequence_of_strings_appeared_on_the_screen/Solution.java

@@ -0,0 +1,26 @@
+package g3301_3400.s3324_find_the_sequence_of_strings_appeared_on_the_screen;
+
+// #Medium #2024_10_21_Time_6_ms_(100.00%)_Space_55.6_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<String> stringSequence(String t) {
+        List<String> ans = new ArrayList<>();
+        int l = t.length();
+        StringBuilder cur = new StringBuilder();
+        for (int i = 0; i < l; i++) {
+            char tCh = t.charAt(i);
+            cur.append('a');
+            ans.add(cur.toString());
+            while (cur.charAt(i) != tCh) {
+                char lastCh = cur.charAt(i);
+                char nextCh = (char) (lastCh == 'z' ? 'a' : lastCh + 1);
+                cur.setCharAt(i, nextCh);
+                ans.add(cur.toString());
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g3301_3400/s3324_find_the_sequence_of_strings_appeared_on_the_screen/readme.md

@@ -0,0 +1,42 @@
+3324\. Find the Sequence of Strings Appeared on the Screen
+
+Medium
+
+You are given a string `target`.
+
+Alice is going to type `target` on her computer using a special keyboard that has **only two** keys:
+
+*   Key 1 appends the character `"a"` to the string on the screen.
+*   Key 2 changes the **last** character of the string on the screen to its **next** character in the English alphabet. For example, `"c"` changes to `"d"` and `"z"` changes to `"a"`.
+
+**Note** that initially there is an _empty_ string `""` on the screen, so she can **only** press key 1.
+
+Return a list of _all_ strings that appear on the screen as Alice types `target`, in the order they appear, using the **minimum** key presses.
+
+**Example 1:**
+
+**Input:** target = "abc"
+
+**Output:** ["a","aa","ab","aba","abb","abc"]
+
+**Explanation:**
+
+The sequence of key presses done by Alice are:
+
+*   Press key 1, and the string on the screen becomes `"a"`.
+*   Press key 1, and the string on the screen becomes `"aa"`.
+*   Press key 2, and the string on the screen becomes `"ab"`.
+*   Press key 1, and the string on the screen becomes `"aba"`.
+*   Press key 2, and the string on the screen becomes `"abb"`.
+*   Press key 2, and the string on the screen becomes `"abc"`.
+
+**Example 2:**
+
+**Input:** target = "he"
+
+**Output:** ["a","b","c","d","e","f","g","h","ha","hb","hc","hd","he"]
+
+**Constraints:**
+
+*   `1 <= target.length <= 400`
+*   `target` consists only of lowercase English letters.

src/main/java/g3301_3400/s3325_count_substrings_with_k_frequency_characters_i/Solution.java

@@ -0,0 +1,37 @@
+package g3301_3400.s3325_count_substrings_with_k_frequency_characters_i;
+
+// #Medium #2024_10_21_Time_2009_ms_(100.00%)_Space_45.2_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int numberOfSubstrings(String s, int k) {
+        int charCount = 0;
+        HashMap<Character, Integer> map = new HashMap<>();
+        for (int right = 0; right < s.length(); right++) {
+            char curr = s.charAt(right);
+            map.put(curr, map.getOrDefault(curr, 0) + 1);
+            PriorityQueue<Integer> queue = new PriorityQueue<>((a, b) -> b - a);
+            for (char ele : map.keySet()) {
+                queue.offer(map.get(ele));
+            }
+            HashMap<Character, Integer> currMap = new HashMap<>(map);
+            for (int left = 0; left <= right; left++) {
+                int maxEle = queue.peek();
+                if (maxEle < k) {
+                    break;
+                }
+                charCount += 1;
+                char leftChar = s.charAt(left);
+                int leftCharCount = currMap.get(leftChar);
+                currMap.put(leftChar, leftCharCount - 1);
+                queue.remove(leftCharCount);
+                if (leftCharCount > 1) {
+                    queue.offer(leftCharCount - 1);
+                }
+            }
+        }
+        return charCount;
+    }
+}

src/main/java/g3301_3400/s3325_count_substrings_with_k_frequency_characters_i/readme.md

@@ -0,0 +1,36 @@
+3325\. Count Substrings With K-Frequency Characters I
+
+Medium
+
+Given a string `s` and an integer `k`, return the total number of substrings of `s` where **at least one** character appears **at least** `k` times.
+
+**Example 1:**
+
+**Input:** s = "abacb", k = 2
+
+**Output:** 4
+
+**Explanation:**
+
+The valid substrings are:
+
+*   `"aba"` (character `'a'` appears 2 times).
+*   `"abac"` (character `'a'` appears 2 times).
+*   `"abacb"` (character `'a'` appears 2 times).
+*   `"bacb"` (character `'b'` appears 2 times).
+
+**Example 2:**
+
+**Input:** s = "abcde", k = 1
+
+**Output:** 15
+
+**Explanation:**
+
+All substrings are valid because every character appears at least once.
+
+**Constraints:**
+
+*   `1 <= s.length <= 3000`
+*   `1 <= k <= s.length`
+*   `s` consists only of lowercase English letters.

src/main/java/g3301_3400/s3326_minimum_division_operations_to_make_array_non_decreasing/Solution.java

@@ -0,0 +1,43 @@
+package g3301_3400.s3326_minimum_division_operations_to_make_array_non_decreasing;
+
+// #Medium #2024_10_21_Time_19_ms_(100.00%)_Space_69.1_MB_(100.00%)
+
+public class Solution {
+    private static final int MAXI = 1000001;
+    private static final int[] SIEVE = new int[MAXI];
+    private static boolean precompute = false;
+
+    private void compute() {
+        if (precompute) {
+            return;
+        }
+        for (int i = 2; i < MAXI; i++) {
+            if (i * i > MAXI) {
+                break;
+            }
+            for (int j = i * i; j < MAXI; j += i) {
+                SIEVE[j] = Math.max(SIEVE[j], Math.max(i, j / i));
+            }
+        }
+        precompute = true;
+    }
+
+    public int minOperations(int[] nums) {
+        compute();
+        int op = 0;
+        int n = nums.length;
+        for (int i = n - 2; i >= 0; i--) {
+            while (nums[i] > nums[i + 1]) {
+                if (SIEVE[nums[i]] == 0) {
+                    return -1;
+                }
+                nums[i] /= SIEVE[nums[i]];
+                op++;
+            }
+            if (nums[i] > nums[i + 1]) {
+                return -1;
+            }
+        }
+        return op;
+    }
+}

src/main/java/g3301_3400/s3326_minimum_division_operations_to_make_array_non_decreasing/readme.md

@@ -0,0 +1,40 @@
+3326\. Minimum Division Operations to Make Array Non Decreasing
+
+Medium
+
+You are given an integer array `nums`.
+
+Any **positive** divisor of a natural number `x` that is **strictly less** than `x` is called a **proper divisor** of `x`. For example, 2 is a _proper divisor_ of 4, while 6 is not a _proper divisor_ of 6.
+
+You are allowed to perform an **operation** any number of times on `nums`, where in each **operation** you select any _one_ element from `nums` and divide it by its **greatest** **proper divisor**.
+
+Return the **minimum** number of **operations** required to make the array **non-decreasing**.
+
+If it is **not** possible to make the array _non-decreasing_ using any number of operations, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [25,7]
+
+**Output:** 1
+
+**Explanation:**
+
+Using a single operation, 25 gets divided by 5 and `nums` becomes `[5, 7]`.
+
+**Example 2:**
+
+**Input:** nums = [7,7,6]
+
+**Output:** \-1
+
+**Example 3:**
+
+**Input:** nums = [1,1,1,1]
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>

src/main/java/g3301_3400/s3327_check_if_dfs_strings_are_palindromes/Solution.java

@@ -0,0 +1,88 @@
+package g3301_3400.s3327_check_if_dfs_strings_are_palindromes;
+
+// #Hard #2024_10_21_Time_244_ms_(100.00%)_Space_96.3_MB_(100.00%)
+
+import java.util.ArrayList;
+
+public class Solution {
+    private StringBuilder dfsString;
+
+    private int[] fillManacher(String s) {
+        int n = s.length();
+        s = "$" + s + "@";
+        int[] p = new int[n + 2];
+        int center = 0;
+        int right = 0;
+        for (int i = 1; i <= n; i++) {
+            int mirror = 2 * center - i;
+            if (i < right) {
+                p[i] = Math.min(right - i, p[mirror]);
+            }
+            while (s.charAt(i + p[i]) == s.charAt(i - p[i])) {
+                p[i]++;
+            }
+            if (i + p[i] > right) {
+                center = i;
+                right = i + p[i];
+            }
+        }
+        return p;
+    }
+
+    private int[] manacher() {
+        StringBuilder temp = new StringBuilder();
+        for (int i = 0; i < dfsString.length(); i++) {
+            temp.append("#");
+            temp.append(dfsString.charAt(i));
+        }
+        temp.append("#");
+        return fillManacher(String.valueOf(temp));
+        // return Arrays.copyOfRange(arr, 1, arr.length - 1);
+    }
+
+    private void dfs(
+            int node, int parent, ArrayList<ArrayList<Integer>> adj, int[][] range, String s) {
+        int start = dfsString.length();
+
+        for (int neigh : adj.get(node)) {
+            if (neigh == parent) {
+                continue;
+            }
+            dfs(neigh, node, adj, range, s);
+        }
+        dfsString.append(s.charAt(node));
+        int end = dfsString.length() - 1;
+        range[node] = new int[] {start, end};
+    }
+
+    public boolean[] findAnswer(int[] parent, String s) {
+        dfsString = new StringBuilder();
+        int n = parent.length;
+        ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            adj.add(new ArrayList<>());
+        }
+        for (int i = 0; i < n; i++) {
+            if (parent[i] == -1) {
+                continue;
+            }
+            adj.get(parent[i]).add(i);
+        }
+        int[][] range = new int[n][2];
+        dfs(0, -1, adj, range, s);
+        int[] manacherArr = manacher();
+        boolean[] ans = new boolean[n];
+        for (int i = 0; i < n; i++) {
+            int[] currRange = range[i];
+            int length = currRange[1] - currRange[0] + 1;
+            // +2 because the string has $# in the starting and in the end
+            int palindromeStart = 2 * currRange[0] + 2;
+            int palindromeEnd = 2 * currRange[1] + 2;
+            int center = (palindromeStart + palindromeEnd) / 2;
+            // represents the palindrome length having center at center.
+            int palindromeLength = manacherArr[center];
+            ans[i] = palindromeLength >= length;
+        }
+        return ans;
+    }
+}

src/main/java/g3301_3400/s3327_check_if_dfs_strings_are_palindromes/readme.md

@@ -0,0 +1,61 @@
+3327\. Check if DFS Strings Are Palindromes
+
+Hard
+
+You are given a tree rooted at node 0, consisting of `n` nodes numbered from `0` to `n - 1`. The tree is represented by an array `parent` of size `n`, where `parent[i]` is the parent of node `i`. Since node 0 is the root, `parent[0] == -1`.
+
+You are also given a string `s` of length `n`, where `s[i]` is the character assigned to node `i`.
+
+Consider an empty string `dfsStr`, and define a recursive function `dfs(int x)` that takes a node `x` as a parameter and performs the following steps in order:
+
+*   Iterate over each child `y` of `x` **in increasing order of their numbers**, and call `dfs(y)`.
+*   Add the character `s[x]` to the end of the string `dfsStr`.
+
+**Note** that `dfsStr` is shared across all recursive calls of `dfs`.
+
+You need to find a boolean array `answer` of size `n`, where for each index `i` from `0` to `n - 1`, you do the following:
+
+*   Empty the string `dfsStr` and call `dfs(i)`.
+*   If the resulting string `dfsStr` is a **palindrome**, then set `answer[i]` to `true`. Otherwise, set `answer[i]` to `false`.
+
+Return the array `answer`.
+
+A **palindrome** is a string that reads the same forward and backward.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2024/09/01/tree1drawio.png)
+
+**Input:** parent = [-1,0,0,1,1,2], s = "aababa"
+
+**Output:** [true,true,false,true,true,true]
+
+**Explanation:**
+
+*   Calling `dfs(0)` results in the string `dfsStr = "abaaba"`, which is a palindrome.
+*   Calling `dfs(1)` results in the string `dfsStr = "aba"`, which is a palindrome.
+*   Calling `dfs(2)` results in the string `dfsStr = "ab"`, which is **not** a palindrome.
+*   Calling `dfs(3)` results in the string `dfsStr = "a"`, which is a palindrome.
+*   Calling `dfs(4)` results in the string `dfsStr = "b"`, which is a palindrome.
+*   Calling `dfs(5)` results in the string `dfsStr = "a"`, which is a palindrome.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2024/09/01/tree2drawio-1.png)
+
+**Input:** parent = [-1,0,0,0,0], s = "aabcb"
+
+**Output:** [true,true,true,true,true]
+
+**Explanation:**
+
+Every call on `dfs(x)` results in a palindrome string.
+
+**Constraints:**
+
+*   `n == parent.length == s.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `0 <= parent[i] <= n - 1` for all `i >= 1`.
+*   `parent[0] == -1`
+*   `parent` represents a valid tree.
+*   `s` consists only of lowercase English letters.