300423

Author: aluferraz

src/leetcode/editor/en/Q2656/MaximumSumWithExactlyKElements.java

@@ -0,0 +1,91 @@
+package leetcode.editor.en.Q2656;
+import java.util.*;
+import javafx.util.Pair;
+
+//You are given a 0-indexed integer array nums and an integer k. Your task is 
+//to perform the following operation exactly k times in order to maximize your 
+//score: 
+//
+// 
+// Select an element m from nums. 
+// Remove the selected element m from the array. 
+// Add a new element with a value of m + 1 to the array. 
+// Increase your score by m. 
+// 
+//
+// Return the maximum score you can achieve after performing the operation 
+//exactly k times. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: nums = [1,2,3,4,5], k = 3
+//Output: 18
+//Explanation: We need to choose exactly 3 elements from nums to maximize the 
+//sum.
+//For the first iteration, we choose 5. Then sum is 5 and nums = [1,2,3,4,6]
+//For the second iteration, we choose 6. Then sum is 5 + 6 and nums = [1,2,3,4,7
+//]
+//For the third iteration, we choose 7. Then sum is 5 + 6 + 7 = 18 and nums = [1
+//,2,3,4,8]
+//So, we will return 18.
+//It can be proven, that 18 is the maximum answer that we can achieve.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: nums = [5,5,5], k = 2
+//Output: 11
+//Explanation: We need to choose exactly 2 elements from nums to maximize the 
+//sum.
+//For the first iteration, we choose 5. Then sum is 5 and nums = [5,5,6]
+//For the second iteration, we choose 6. Then sum is 5 + 6 = 11 and nums = [5,5,
+//7]
+//So, we will return 11.
+//It can be proven, that 11 is the maximum answer that we can achieve.
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= nums.length <= 100 
+// 1 <= nums[i] <= 100 
+// 1 <= k <= 100 
+// 
+//
+// 
+// 
+//
+// 👍 63 👎 3
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int maximizeSum(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
+        for (int num : nums) {
+            pq.add(num);
+        }
+        int sum = 0;
+
+        while (k > 0) {
+            int next = pq.poll();
+            sum += next;
+            pq.add(next + 1);
+            k--;
+        }
+
+        return sum;
+
+    }
+
+
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+
+public class MaximumSumWithExactlyKElements extends Solution {}

src/leetcode/editor/en/Q2657/FindThePrefixCommonArrayOfTwoArrays.java

@@ -0,0 +1,87 @@
+package leetcode.editor.en.Q2657;
+import java.util.*;
+import javafx.util.Pair;
+
+//You are given two 0-indexed integer permutations A and B of length n. 
+//
+// A prefix common array of A and B is an array C such that C[i] is equal to 
+//the count of numbers that are present at or before the index i in both A and B. 
+//
+// Return the prefix common array of A and B. 
+//
+// A sequence of n integers is called a permutation if it contains all integers 
+//from 1 to n exactly once. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: A = [1,3,2,4], B = [3,1,2,4]
+//Output: [0,2,3,4]
+//Explanation: At i = 0: no number is common, so C[0] = 0.
+//At i = 1: 1 and 3 are common in A and B, so C[1] = 2.
+//At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
+//At i = 3: 1, 2, 3, and 4 are common in A and B, so C[3] = 4.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: A = [2,3,1], B = [3,1,2]
+//Output: [0,1,3]
+//Explanation: At i = 0: no number is common, so C[0] = 0.
+//At i = 1: only 3 is common in A and B, so C[1] = 1.
+//At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= A.length == B.length == n <= 50 
+// 1 <= A[i], B[i] <= n 
+// It is guaranteed that A and B are both a permutation of n integers. 
+// 
+//
+// 👍 101 👎 2
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int[] findThePrefixCommonArray(int[] A, int[] B) {
+        int[] ans = new int[A.length];
+
+        HashSet<Integer> pending = new HashSet<>();
+
+        for (int i = 0; i < A.length; i++) {
+            if (i > 0) {
+                ans[i] = ans[i - 1];
+            }
+            while (pending.contains(A[i]) || pending.contains(B[i])) {
+                if (pending.contains(A[i])) {
+                    ans[i]++;
+                    pending.remove(A[i]);
+                }
+                if (pending.contains(B[i])) {
+                    ans[i]++;
+                    pending.remove(B[i]);
+                }
+            }
+
+            if (A[i] != B[i]) {
+                pending.add(A[i]);
+                pending.add(B[i]);
+            } else {
+                ans[i]++;
+            }
+
+
+        }
+        return ans;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+
+public class FindThePrefixCommonArrayOfTwoArrays extends Solution {}

src/leetcode/editor/en/Q2658/MaximumNumberOfFishInAGrid.java

@@ -0,0 +1,144 @@
+package leetcode.editor.en.Q2658;
+import java.util.*;
+import javafx.util.Pair;
+
+//You are given a 0-indexed 2D matrix grid of size m x n, where (r, c) 
+//represents: 
+//
+// 
+// A land cell if grid[r][c] = 0, or 
+// A water cell containing grid[r][c] fish, if grid[r][c] > 0. 
+// 
+//
+// A fisher can start at any water cell (r, c) and can do the following 
+//operations any number of times: 
+//
+// 
+// Catch all the fish at cell (r, c), or 
+// Move to any adjacent water cell. 
+// 
+//
+// Return the maximum number of fish the fisher can catch if he chooses his 
+//starting cell optimally, or 0 if no water cell exists. 
+//
+// An adjacent cell of the cell (r, c), is one of the cells (r, c + 1), (r, c - 
+//1), (r + 1, c) or (r - 1, c) if it exists. 
+//
+// 
+// Example 1: 
+// 
+// 
+//Input: grid = [[0,2,1,0],[4,0,0,3],[1,0,0,4],[0,3,2,0]]
+//Output: 7
+//Explanation: The fisher can start at cell (1,3) and collect 3 fish, then move 
+//to cell (2,3) and collect 4 fish.
+// 
+//
+// Example 2: 
+// 
+// 
+//Input: grid = [[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]
+//Output: 1
+//Explanation: The fisher can start at cells (0,0) or (3,3) and collect a 
+//single fish. 
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// m == grid.length 
+// n == grid[i].length 
+// 1 <= m, n <= 10 
+// 0 <= grid[i][j] <= 10 
+// 
+//
+// 👍 148 👎 12
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+
+    int[][] DIRECTIONS = new int[][]{
+            new int[]{-1, 0},
+            new int[]{1, 0},
+            new int[]{0, -1},
+            new int[]{0, 1}
+    };
+
+    Integer[][] cache;
+    boolean[][] visiting;
+
+    public int findMaxFish(int[][] grid) {
+        Queue<int[]> q = new LinkedList<>();
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[i].length; j++) {
+                if (grid[i][j] != 0) {
+                    q.add(new int[]{i, j});
+                }
+            }
+        }
+
+
+        int ans = 0;
+        if (q.isEmpty()) return ans;
+
+        cache = new Integer[grid.length][grid[0].length];
+        while (!q.isEmpty()) {
+
+            int[] start = q.poll();
+            int row = start[0];
+            int col = start[1];
+            visiting = new boolean[grid.length][grid[0].length];
+
+
+            ans = Math.max(ans, dfs(row, col, grid));
+        }
+
+
+        return ans;
+
+
+    }
+
+    private int dfs(int row, int col, int[][] grid) {
+
+        int best = 0;
+
+        if (cache[row][col] != null) {
+            return cache[row][col];
+        }
+        int cell = grid[row][col];
+        visiting[row][col] = true;
+        grid[row][col] = 0;
+
+        for (int[] dir : DIRECTIONS) {
+            int newRow = row + dir[0];
+            int newCol = col + dir[1];
+            if (isValidIdx(newRow, newCol, grid)) {
+                int fish = grid[newRow][newCol];
+                grid[newRow][newCol] = 0;
+                best += fish + dfs(newRow, newCol, grid);
+                grid[newRow][newCol] = fish;
+            }
+        }
+        best += cell;
+        grid[row][col] = cell;
+        cache[row][col] = best;
+//        visiting[row][col] = false;
+        return best;
+
+    }
+
+    private boolean isValidIdx(int row, int col, int[][] grid) {
+        return row >= 0 && row < grid.length && col >= 0 && col < grid[row].length && grid[row][col] > 0 && !visiting[row][col];
+    }
+
+}
+
+
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+
+public class MaximumNumberOfFishInAGrid extends Solution {}