solution is Added

Author: anjha1

1354.construct-target-array-with-multiple-sums/ConstructTargetArrayWithMultipleSums.java

@@ -0,0 +1,25 @@
+import java.util.PriorityQueue;
+
+class ConstructTargetArrayWithMultipleSums {
+    public boolean isPossible(int[] target) {
+        long sum = 0;
+        PriorityQueue<Integer> pq = new PriorityQueue<Integer>((a, b) -> b - a);
+        for (int i = 0; i < target.length; i++) {
+            sum += target[i];
+            pq.offer(target[i]);
+        }
+
+        while (pq.peek() != 1) {
+            int value = pq.poll();
+            long diff = sum - value;
+            if (diff == 1) return true;
+            if (diff > value || diff == 0 || value % diff == 0) return false;
+
+            value %= diff;
+            sum = diff + value;
+            pq.offer(value);
+        }
+
+        return true;
+    }
+}

1354.construct-target-array-with-multiple-sums/README.md

@@ -0,0 +1,2 @@
+# [1354. Construct Target Array With Multiple Sums](https://leetcode.com/problems/construct-target-array-with-multiple-sums/)
+

1372.longest-zigzag-path-in-a-binary-tree/LongestZigzagPathInABinaryTree.java

@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class LongestZigzagPathInABinaryTree {
+    int maxRes;
+
+    public int longestZigZag(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        maxRes = 0;
+        dfs(root, true, 0);
+        return maxRes;
+    }
+
+    private void dfs(TreeNode node, boolean dir, int len) {
+        maxRes = Math.max(maxRes, len);
+        if (!dir) {
+            if (node.left != null) {
+                dfs(node.left, true, len + 1);
+            }
+            if (node.right != null) {
+                dfs(node.right, false, 1);
+            }
+        } else {
+            if (node.left != null) {
+                dfs(node.left, true, 1);
+            }
+            if (node.right != null) {
+                dfs(node.right, false, len + 1);
+            }
+        }
+    }
+}

1372.longest-zigzag-path-in-a-binary-tree/README.md

@@ -0,0 +1,7 @@
+# [1372. Longest ZigZag Path in a Binary Tree](https://leetcode.com/problems/longest-zigzag-path-in-a-binary-tree/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the amount of root nodes.
+- Space Complexity: $O(1)$.

1383.maximum-performance-of-a-team/MaximumPerformanceOfATeam.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+class MaximumPerformanceOfATeam {
+    private final int modulo = (int) (Math.pow(10, 9) + 7);
+
+    public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
+        int[][] order = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            order[i] = new int[]{efficiency[i], speed[i]};
+        }
+        Arrays.sort(order, (a, b) -> Integer.compare(b[0], a[0]));
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        long totalSpeed = 0, best = 0;
+        for (int[] pair : order) {
+            int spd = pair[1];
+            pq.add(spd);
+            if (pq.size() <= k) totalSpeed += spd;
+            else totalSpeed += spd - pq.poll();
+            best = Math.max(best, totalSpeed * pair[0]);
+        }
+        return (int) (best % modulo);
+    }
+}

1383.maximum-performance-of-a-team/README.md

@@ -0,0 +1,2 @@
+# [1383. Maximum Performance of a Team](https://leetcode.com/problems/maximum-performance-of-a-team/)
+

1402.reducing-dishes/README.md

@@ -0,0 +1,7 @@
+# [1402. Reducing Dishes](https://leetcode.com/problems/reducing-dishes/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\log n)$. The time complexity of Sort in java is $O(n\log n)$.
+- Space Complexity: $O(\log n)$. The space complexity of sort is $O(\log n)$.

1402.reducing-dishes/ReducingDishes.java

@@ -0,0 +1,17 @@
+import java.util.Arrays;
+
+class ReducingDishes {
+    public int maxSatisfaction(int[] satisfaction) {
+        Arrays.sort(satisfaction);
+        int preSum = 0, res = 0;
+        for (int i = satisfaction.length - 1; i >= 0; i--) {
+            if (preSum + satisfaction[i] > 0) {
+                preSum += satisfaction[i];
+                res += preSum;
+            } else {
+                break;
+            }
+        }
+        return res;
+    }
+}

1423.maximum-points-you-can-obtain-from-cards/MaximumPointsYouCanObtainFromCards.java

@@ -0,0 +1,20 @@
+class MaximumPointsYouCanObtainFromCards {
+    public int maxScore(int[] cardPoints, int k) {
+        int l = 0, r = cardPoints.length - k;
+        int sum = 0;
+        for (int i = r; i < cardPoints.length; i++) {
+            sum += cardPoints[i];
+        }
+        if (cardPoints.length == k) {
+            return sum;
+        }
+        int max = sum;
+        while (r < cardPoints.length) {
+            sum += (cardPoints[l] - cardPoints[r]);
+            max = Math.max(max, sum);
+            l++;
+            r++;
+        }
+        return max;
+    }
+}

1423.maximum-points-you-can-obtain-from-cards/README.md

@@ -0,0 +1,2 @@
+# [1423. Maximum Points You Can Obtain from Cards](https://leetcode.com/problems/maximum-points-you-can-obtain-from-cards/)
+

1431.kids-with-the-greatest-number-of-candies/KidsWithTheGreatestNumberOfCandies.java

@@ -0,0 +1,22 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class KidsWithTheGreatestNumberOfCandies {
+    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
+        int greatestCandies = 0;
+        for (int candy: candies) {
+            if (candy > greatestCandies) {
+                greatestCandies = candy;
+            }
+        }
+        List<Boolean> res = new ArrayList<>();
+        for (int candy: candies) {
+            if (candy + extraCandies >= greatestCandies) {
+                res.add(true);
+            } else {
+                res.add(false);
+            }
+        }
+        return res;
+    }
+}

1431.kids-with-the-greatest-number-of-candies/README.md

@@ -0,0 +1,7 @@
+# [1431. Kids With the Greatest Number of Candies](https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `candies`.
+- Space Complexity: $O(1)$.

1444.number-of-ways-of-cutting-a-pizza/NumberOfWaysOfCuttingAPizza.java

@@ -0,0 +1,34 @@
+class NumberOfWaysOfCuttingAPizza {
+    private final int modulo = (int) (Math.pow(10, 9) + 7);
+
+    private int dfs(int m, int n, int k, int r, int c, Integer[][][] dp, int[][] preSum) {
+        if (preSum[r][c] == 0) return 0;
+        if (k == 0) return 1;
+        if (dp[k][r][c] != null) return dp[k][r][c];
+        int res = 0;
+        for (int nr = r + 1; nr < m; nr++) {
+            if (preSum[r][c] - preSum[nr][c] > 0) {
+                res = (res + dfs(m, n, k - 1, nr, c, dp, preSum)) % modulo;
+            }
+        }
+        for (int nc = c + 1; nc < n; nc++) {
+            if (preSum[r][c] - preSum[r][nc] > 0) {
+                res = (res + dfs(m, n, k - 1, r, nc, dp, preSum)) % modulo;
+            }
+        }
+        dp[k][r][c] = res;
+        return dp[k][r][c];
+    }
+
+    public int ways(String[] pizza, int k) {
+        int m = pizza.length, n = pizza[0].length();
+        Integer[][][] dp = new Integer[k][m][n];
+        int[][] preSum = new int[m + 1][n + 1];
+        for (int r = m - 1; r >= 0; r--) {
+            for (int c = n - 1; c >= 0; c--) {
+                preSum[r][c] = preSum[r][c + 1] + preSum[r + 1][c] - preSum[r + 1][c + 1] + (pizza[r].charAt(c) == 'A' ? 1 : 0);
+            }
+        }
+        return dfs(m, n, k - 1, 0, 0, dp, preSum);
+    }
+}

1444.number-of-ways-of-cutting-a-pizza/README.md

@@ -0,0 +1,2 @@
+# [1444. Number of Ways of Cutting a Pizza](https://leetcode.com/problems/number-of-ways-of-cutting-a-pizza/)
+