Added tasks 2503, 2506, 2507, 2508, 2509

Author: ThanhNIT

src/main/java/g2501_2600/s2503_maximum_number_of_points_from_grid_queries/Solution.java

@@ -0,0 +1,56 @@
+package g2501_2600.s2503_maximum_number_of_points_from_grid_queries;
+
+// #Hard #Array #Sorting #Heap_Priority_Queue #Union_Find #Breadth_First_Search
+// #2023_03_20_Time_47_ms_(96.38%)_Space_59.9_MB_(49.28%)
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class Solution {
+    private final int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
+
+    public int[] maxPoints(int[][] grid, int[] q) {
+        int r = grid.length;
+        int c = grid[0].length;
+        int[] res = new int[q.length];
+        Integer[] index = new Integer[q.length];
+        for (int i = 0; i < q.length; i++) {
+            index[i] = i;
+        }
+        Arrays.sort(index, Comparator.comparingInt(o -> q[o]));
+        Queue<int[]> q1 = new ArrayDeque<>();
+        PriorityQueue<int[]> q2 = new PriorityQueue<>(Comparator.comparingInt(a -> a[2]));
+        q2.offer(new int[] {0, 0, grid[0][0]});
+        boolean[][] visited = new boolean[r][c];
+        int count = 0;
+        visited[0][0] = true;
+        for (int i = 0; i < q.length; i++) {
+            int currLimit = q[index[i]];
+            while (!q2.isEmpty() && q2.peek()[2] < currLimit) {
+                q1.offer(q2.poll());
+            }
+            while (!q1.isEmpty()) {
+                int[] curr = q1.poll();
+                count++;
+                for (int[] dir : dirs) {
+                    int x = dir[0] + curr[0];
+                    int y = dir[1] + curr[1];
+                    if (x < 0 || y < 0 || x >= r || y >= c || visited[x][y]) {
+                        continue;
+                    }
+                    if (!visited[x][y] && grid[x][y] < currLimit) {
+                        q1.offer(new int[] {x, y, grid[x][y]});
+                    } else {
+                        q2.offer(new int[] {x, y, grid[x][y]});
+                    }
+                    visited[x][y] = true;
+                }
+            }
+            res[index[i]] = count;
+        }
+        return res;
+    }
+}

src/main/java/g2501_2600/s2503_maximum_number_of_points_from_grid_queries/readme.md

@@ -0,0 +1,44 @@
+2503\. Maximum Number of Points From Grid Queries
+
+Hard
+
+You are given an `m x n` integer matrix `grid` and an array `queries` of size `k`.
+
+Find an array `answer` of size `k` such that for each integer `queries[i]` you start in the **top left** cell of the matrix and repeat the following process:
+
+*   If `queries[i]` is **strictly** greater than the value of the current cell that you are in, then you get one point if it is your first time visiting this cell, and you can move to any **adjacent** cell in all `4` directions: up, down, left, and right.
+*   Otherwise, you do not get any points, and you end this process.
+
+After the process, `answer[i]` is the **maximum** number of points you can get. **Note** that for each query you are allowed to visit the same cell **multiple** times.
+
+Return _the resulting array_ `answer`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/19/yetgriddrawio.png)
+
+**Input:** grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]
+
+**Output:** [5,8,1]
+
+**Explanation:** The diagrams above show which cells we visit to get points for each query.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/10/20/yetgriddrawio-2.png)
+
+**Input:** grid = [[5,2,1],[1,1,2]], queries = [3]
+
+**Output:** [0]
+
+**Explanation:** We can not get any points because the value of the top left cell is already greater than or equal to 3.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `2 <= m, n <= 1000`
+*   <code>4 <= m * n <= 10<sup>5</sup></code>
+*   `k == queries.length`
+*   <code>1 <= k <= 10<sup>4</sup></code>
+*   <code>1 <= grid[i][j], queries[i] <= 10<sup>6</sup></code>

src/main/java/g2501_2600/s2506_count_pairs_of_similar_strings/Solution.java

@@ -0,0 +1,40 @@
+package g2501_2600.s2506_count_pairs_of_similar_strings;
+
+// #Easy #Array #String #Hash_Table #2023_03_20_Time_6_ms_(85.15%)_Space_42.4_MB_(59.86%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int similarPairs(String[] words) {
+        int len = words.length;
+        if (len == 1) {
+            return 0;
+        }
+        byte[][] alPh = new byte[len][26];
+        Map<String, Integer> map = new HashMap<>();
+        for (int i = 0; i < len; i++) {
+            String word = words[i];
+            for (char c : word.toCharArray()) {
+                int idx = c - 'a';
+                if (alPh[i][idx] == 0) {
+                    alPh[i][idx]++;
+                }
+            }
+            String s = new String(alPh[i]);
+            if (map.containsKey(s)) {
+                map.put(s, map.get(s) + 1);
+            } else {
+                map.put(s, 1);
+            }
+        }
+        int pairs = 0;
+        for (Map.Entry<String, Integer> entry : map.entrySet()) {
+            int freq = entry.getValue();
+            if (freq > 1) {
+                pairs += (freq * (freq - 1)) / 2;
+            }
+        }
+        return pairs;
+    }
+}

src/main/java/g2501_2600/s2506_count_pairs_of_similar_strings/readme.md

@@ -0,0 +1,52 @@
+2506\. Count Pairs Of Similar Strings
+
+Easy
+
+You are given a **0-indexed** string array `words`.
+
+Two strings are **similar** if they consist of the same characters.
+
+*   For example, `"abca"` and `"cba"` are similar since both consist of characters `'a'`, `'b'`, and `'c'`.
+*   However, `"abacba"` and `"bcfd"` are not similar since they do not consist of the same characters.
+
+Return _the number of pairs_ `(i, j)` _such that_ `0 <= i < j <= word.length - 1` _and the two strings_ `words[i]` _and_ `words[j]` _are similar_.
+
+**Example 1:**
+
+**Input:** words = ["aba","aabb","abcd","bac","aabc"]
+
+**Output:** 2
+
+**Explanation:** There are 2 pairs that satisfy the conditions: 
+
+- i = 0 and j = 1 : both words[0] and words[1] only consist of characters 'a' and 'b'. 
+
+- i = 3 and j = 4 : both words[3] and words[4] only consist of characters 'a', 'b', and 'c'.
+
+**Example 2:**
+
+**Input:** words = ["aabb","ab","ba"]
+
+**Output:** 3
+
+**Explanation:** There are 3 pairs that satisfy the conditions: 
+
+- i = 0 and j = 1 : both words[0] and words[1] only consist of characters 'a' and 'b'. 
+
+- i = 0 and j = 2 : both words[0] and words[2] only consist of characters 'a' and 'b'. 
+
+- i = 1 and j = 2 : both words[1] and words[2] only consist of characters 'a' and 'b'.
+
+**Example 3:**
+
+**Input:** words = ["nba","cba","dba"]
+
+**Output:** 0
+
+**Explanation:** Since there does not exist any pair that satisfies the conditions, we return 0.
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 100`
+*   `words[i]` consist of only lowercase English letters.

src/main/java/g2501_2600/s2507_smallest_value_after_replacing_with_sum_of_prime_factors/Solution.java

@@ -0,0 +1,37 @@
+package g2501_2600.s2507_smallest_value_after_replacing_with_sum_of_prime_factors;
+
+// #Medium #Math #Number_Theory #2023_03_20_Time_1_ms_(84.27%)_Space_40_MB_(31.46%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    private final Map<Integer, Integer> memo = new HashMap<>();
+
+    public int smallestValue(int n) {
+        while (get(n) != n) {
+            n = get(n);
+        }
+        return n;
+    }
+
+    private int get(int n) {
+        if (memo.containsKey(n)) {
+            return memo.get(n);
+        }
+        double r = Math.pow(n, 0.5);
+        int r1 = (int) r;
+        if (r - r1 == 0) {
+            return 2 * get(r1);
+        }
+        int res = 0;
+        for (int i = r1; i >= 2; i--) {
+            if (n % i == 0) {
+                res = get(i) + get(n / i);
+            }
+        }
+        res = res == 0 ? n : res;
+        memo.put(n, res);
+        return res;
+    }
+}

src/main/java/g2501_2600/s2507_smallest_value_after_replacing_with_sum_of_prime_factors/readme.md

@@ -0,0 +1,39 @@
+2507\. Smallest Value After Replacing With Sum of Prime Factors
+
+Medium
+
+You are given a positive integer `n`.
+
+Continuously replace `n` with the sum of its **prime factors**.
+
+*   Note that if a prime factor divides `n` multiple times, it should be included in the sum as many times as it divides `n`.
+
+Return _the smallest value_ `n` _will take on._
+
+**Example 1:**
+
+**Input:** n = 15
+
+**Output:** 5
+
+**Explanation:** Initially, n = 15. 
+
+15 = 3 \* 5, so replace n with 3 + 5 = 8. 
+
+8 = 2 \* 2 \* 2, so replace n with 2 + 2 + 2 = 6.
+
+6 = 2 \* 3, so replace n with 2 + 3 = 5.
+
+5 is the smallest value n will take on.
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** Initially, n = 3. 3 is the smallest value n will take on.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>

src/main/java/g2501_2600/s2508_add_edges_to_make_degrees_of_all_nodes_even/Solution.java

@@ -0,0 +1,84 @@
+package g2501_2600.s2508_add_edges_to_make_degrees_of_all_nodes_even;
+
+// #Hard #Hash_Table #Graph #2023_03_20_Time_33_ms_(100.00%)_Space_109.7_MB_(42.70%)
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution {
+    public boolean isPossible(int n, List<List<Integer>> edges) {
+        // first find odd edge nodes
+        int[] degree = new int[n + 1];
+        for (List<Integer> edge : edges) {
+            degree[edge.get(0)]++;
+            degree[edge.get(1)]++;
+        }
+        List<Integer> oddNodes = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            if ((degree[i] & 1) == 1) {
+                oddNodes.add(i);
+            }
+            if (oddNodes.size() > 4) {
+                // cannot be larger than four
+                return false;
+            }
+        }
+        if ((oddNodes.size() & 1) == 1) {
+            // can only have even numbers of odd nodes
+            return false;
+        } else if (oddNodes.isEmpty()) {
+            // zero situation
+            return true;
+        }
+        // find all edges of oddListNode
+        Set[] adjList = new HashSet[oddNodes.size()];
+        for (int i = 0; i < oddNodes.size(); i++) {
+            adjList[i] = new HashSet<>();
+        }
+        for (List<Integer> edge : edges) {
+            for (int i = 0; i < oddNodes.size(); i++) {
+                if ((int) edge.get(0) == oddNodes.get(i)) {
+                    adjList[i].add(edge.get(1));
+                }
+                if ((int) edge.get(1) == oddNodes.get(i)) {
+                    adjList[i].add(edge.get(0));
+                }
+            }
+        }
+        // to see if it is two or four
+        if (oddNodes.size() == 4) {
+            // can only connect each other
+            // have to detect if they have an edge or not
+            return adjList[0].size() < (n - 1)
+                    && adjList[1].size() < (n - 1)
+                    && adjList[2].size() < (n - 1)
+                    && adjList[3].size() < (n - 1)
+                    && ((!adjList[0].contains(oddNodes.get(1))
+                                    && !adjList[1].contains(oddNodes.get(0))
+                                    && !adjList[2].contains(oddNodes.get(3))
+                                    && !adjList[3].contains(oddNodes.get(2)))
+                            || (!adjList[0].contains(oddNodes.get(2))
+                                    && !adjList[2].contains(oddNodes.get(0))
+                                    && !adjList[1].contains(oddNodes.get(3))
+                                    && !adjList[3].contains(oddNodes.get(1)))
+                            || (!adjList[0].contains(oddNodes.get(3))
+                                    && !adjList[1].contains(oddNodes.get(2))
+                                    && !adjList[2].contains(oddNodes.get(1))));
+        } else {
+            // if two dont have an edge, could use it
+            if (adjList[0].contains(oddNodes.get(1))) {
+                // need to find a spare node
+                for (int i = 1; i <= n; i++) {
+                    if (adjList[0].contains(i) || adjList[1].contains(i)) {
+                        continue;
+                    }
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        }
+    }
+}