Code is Added

Author: anjha1

1235.maximum-profit-in-job-scheduling/MaximumProfitInJobScheduling.java

@@ -0,0 +1,30 @@
+import java.util.Arrays;
+
+class MaximumProfitInJobScheduling {
+    private int binarySearch(int[][] jobs, int right, int target) {
+        int left = 0;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (jobs[mid][1] > target) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
+        int n = startTime.length;
+        int[][] jobs = new int[n][];
+        for (int i = 0; i < n; i++)
+            jobs[i] = new int[]{startTime[i], endTime[i], profit[i]};
+        Arrays.sort(jobs, (a, b) -> a[1] - b[1]);
+        int[] dp = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            int k = binarySearch(jobs, i - 1, jobs[i - 1][0]);
+            dp[i] = Math.max(dp[i - 1], dp[k] + jobs[i - 1][2]);
+        }
+        return dp[n];
+    }
+}

1235.maximum-profit-in-job-scheduling/README.md

@@ -0,0 +1,8 @@
+# [1235. Maximum Profit in Job Scheduling](https://leetcode.com/problems/maximum-profit-in-job-scheduling/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\log^n)$. Sort is $O(n\log^n)$ and iteration + binary search is also $O(n\log^n)$. Thus, the total time complexity is $O(n\log^n)$.
+- Space Complexity: $O(n)$. We use $O(n)$ space to save dp.

1239.maximum-length-of-a-concatenated-string-with-unique-characters/MaximumLengthOfAConcatenatedStringWithUniqueCharacters.java

@@ -0,0 +1,29 @@
+import java.util.List;
+
+class MaximumLengthOfAConcatenatedStringWithUniqueCharacters {
+    private int max = 0;
+
+    private boolean isValid(String currentStr, String newStr) {
+        int[] array = new int[26];
+        for (int i = 0; i < newStr.length(); i++) {
+            if (++array[newStr.charAt(i) - 'a'] == 2) return false;
+            if (currentStr.contains(newStr.charAt(i) + ""))
+                return false;
+        }
+        return true;
+    }
+
+    private void backtrack(List<String> arr, String current, int start) {
+        if (max < current.length())
+            max = current.length();
+        for (int i = start; i < arr.size(); i++) {
+            if (!isValid(current, arr.get(i))) continue;
+            backtrack(arr, current + arr.get(i), i + 1);
+        }
+    }
+
+    public int maxLength(List<String> arr) {
+        backtrack(arr, "", 0);
+        return max;
+    }
+}

1239.maximum-length-of-a-concatenated-string-with-unique-characters/README.md

@@ -0,0 +1,2 @@
+# [1239. Maximum Length of a Concatenated String with Unique Characters](https://leetcode.com/problems/maximum-length-of-a-concatenated-string-with-unique-characters/)
+

1254.number-of-closed-islands/NumberOfClosedIslands.java

@@ -0,0 +1,34 @@
+class NumberOfClosedIslands {
+    private int m, n;
+    private int res = 0;
+    private final int[] dx = {-1, 0, 1, 0};
+    private final int[] dy = {0, 1, 0, -1};
+
+    public int closedIsland(int[][] grid) {
+        m = grid.length;
+        n = grid[0].length;
+        if (m <= 2 || n <= 2) return 0;
+        for (int i = 1; i < m - 1; i++) {
+            for (int j = 1; j < n - 1; j++) {
+                if (grid[i][j] == 0)
+                    if (dfs(grid, i, j)) res++;
+            }
+        }
+
+        return res;
+    }
+
+    private boolean dfs(int[][] grid, int x, int y) {
+        if ((x == 0 || x == m - 1 || y == 0 || y == n - 1) && grid[x][y] == 0) {
+            return false;
+        }
+        boolean f = true;
+        grid[x][y] = 1;
+        for (int i = 0; i < 4; i++) {
+            int x1 = x + dx[i], y1 = y + dy[i];
+            if (x1 < 0 || x1 >= m || y1 < 0 || y1 >= n || grid[x1][y1] == 1) continue;
+            f = f & dfs(grid, x1, y1);
+        }
+        return f;
+    }
+}

1254.number-of-closed-islands/README.md

@@ -0,0 +1,8 @@
+# [1254. Number of Closed Islands](https://leetcode.com/problems/number-of-closed-islands/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(m \times n)$.
+- Space Complexity: $O(m \times n)$.

1293.shortest-path-in-a-grid-with-obstacles-elimination/README.md

@@ -0,0 +1,2 @@
+# [1293. Shortest Path in a Grid with Obstacles Elimination](https://leetcode.com/problems/shortest-path-in-a-grid-with-obstacles-elimination/)
+

1293.shortest-path-in-a-grid-with-obstacles-elimination/ShortestPathInAGridWithObstaclesElimination.java

@@ -0,0 +1,37 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+class ShortestPathInAGridWithObstaclesElimination {
+    private static final int[][] directions = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
+
+    public int shortestPath(int[][] grid, int k) {
+        int m = grid.length, n = grid[0].length;
+        boolean[][][] visited = new boolean[m][n][k + 1];
+
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0, k});
+
+        int dist = 0;
+
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+
+            while (size-- > 0) {
+                int[] curr = queue.remove();
+                int x = curr[0];
+                int y = curr[1];
+                int obs = curr[2];
+                if (x == m - 1 && y == n - 1 && obs >= 0) return dist;
+
+                if (obs < 0 || visited[x][y][obs]) continue;
+                visited[x][y][obs] = true;
+                if (x - 1 >= 0) queue.add(new int[]{x - 1, y, obs - grid[x - 1][y]});
+                if (x + 1 < m) queue.add(new int[]{x + 1, y, obs - grid[x + 1][y]});
+                if (y - 1 >= 0) queue.add(new int[]{x, y - 1, obs - grid[x][y - 1]});
+                if (y + 1 < n) queue.add(new int[]{x, y + 1, obs - grid[x][y + 1]});
+            }
+            dist++;
+        }
+        return -1;
+    }
+}

1319.number-of-operations-to-make-network-connected/NumberOfOperationsToMakeNetworkConnected.java

@@ -0,0 +1,42 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class NumberOfOperationsToMakeNetworkConnected {
+    List<Integer>[] edges;
+    boolean[] visited;
+
+    public int makeConnected(int n, int[][] connections) {
+        if (connections.length < n - 1) {
+            return -1;
+        }
+
+        edges = new List[n];
+        for (int i = 0; i < n; i++) {
+            edges[i] = new ArrayList<>();
+        }
+        for (int[] connection : connections) {
+            edges[connection[0]].add(connection[1]);
+            edges[connection[1]].add(connection[0]);
+        }
+
+        visited = new boolean[n];
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                dfs(i);
+                res++;
+            }
+        }
+
+        return res - 1;
+    }
+
+    private void dfs(int n) {
+        visited[n] = true;
+        for (int v : edges[n]) {
+            if (!visited[v]) {
+                dfs(v);
+            }
+        }
+    }
+}

1319.number-of-operations-to-make-network-connected/README.md

@@ -0,0 +1,8 @@
+# [1319. Number of Operations to Make Network Connected](https://leetcode.com/problems/number-of-operations-to-make-network-connected/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n+m)$. $m$ is the length of `connections`.
+- Space Complexity: $O(n+m)$. It costs $O(m)$ to save all edges and costs $O(n)$ for DFS stack.

1323.maximum-69-number/Maximum69Number.java

@@ -0,0 +1,16 @@
+class Maximum69Number {
+    public int maximum69Number (int num) {
+        int numCopy = num;
+        int indexSix = -1;
+        int currDigit = 0;
+
+        while (numCopy > 0) {
+            if (numCopy % 10 == 6)
+                indexSix = currDigit;
+            numCopy /= 10;
+            currDigit++;
+        }
+
+        return indexSix == -1 ? num : num + 3 * (int) Math.pow(10, indexSix);
+    }
+}

1323.maximum-69-number/README.md

@@ -0,0 +1,2 @@
+# [1323. Maximum 69 Number](https://leetcode.com/problems/maximum-69-number/)
+

1328.break-a-palindrome/BreakAPalindrome.java

@@ -0,0 +1,17 @@
+class BreakAPalindrome {
+    public String breakPalindrome(String palindrome) {
+        if (palindrome.length() <= 1) return "";
+        char[] chars = palindrome.toCharArray();
+        int len = palindrome.length();
+        for (int i = 0; i < len; i++) {
+            if (i == len - 1) {
+                chars[i] = 'b';
+            }
+            if (palindrome.charAt(i) != 'a' && i != (len / 2)) {
+                chars[i] = 'a';
+                break;
+            }
+        }
+        return String.valueOf(chars);
+    }
+}

1328.break-a-palindrome/README.md

@@ -0,0 +1,2 @@
+# [1328. Break a Palindrome](https://leetcode.com/problems/break-a-palindrome/)
+

1329.sort-the-matrix-diagonally/README.md

@@ -0,0 +1,2 @@
+# [1329. Sort the Matrix Diagonally](https://leetcode.com/problems/sort-the-matrix-diagonally/)
+

1329.sort-the-matrix-diagonally/SortTheMatrixDiagonally.java

@@ -0,0 +1,30 @@
+class SortTheMatrixDiagonally {
+    private void pass(int[][] a, int row, int col, int n, int m) {
+        int[] arr = new int[101];
+        int i = row, j = col;
+        while (row < n && col < m) {
+            arr[a[row++][col++]]++;
+        }
+        for (int k = 0; k < 101; k++) {
+            if (arr[k] > 0) {
+                while (arr[k] != 0) {
+                    a[i++][j++] = k;
+                    arr[k]--;
+                }
+            }
+        }
+    }
+
+    public int[][] diagonalSort(int[][] mat) {
+        int row = mat.length;
+        int col = mat[0].length;
+        int count = 0, i = 0, k = 0;
+        while (count < row + col) {
+            if (i == row - 1 && k < col) k++;
+            if (i != row - 1) i++;
+            pass(mat, row - 1 - i, k, row, col);
+            count++;
+        }
+        return mat;
+    }
+}

1335.minimum-difficulty-of-a-job-schedule/MinimumDifficultyOfAJobSchedule.java

@@ -0,0 +1,20 @@
+class MinimumDifficultyOfAJobSchedule {
+    public int minDifficulty(int[] jobDifficulty, int d) {
+        int n = jobDifficulty.length;
+        if (d > n) return -1;
+        int[][] dp = new int[d + 1][n + 1];
+        for (int i = 1; i <= n; i++)
+            dp[1][i] = Math.max(dp[1][i - 1], jobDifficulty[i - 1]);
+        for (int i = 2; i <= d; i++) {
+            for (int j = i; j <= n; j++) {
+                dp[i][j] = Integer.MAX_VALUE;
+                int currMax = 0;
+                for (int k = j; k >= i; k--) {
+                    currMax = Math.max(currMax, jobDifficulty[k - 1]);
+                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][k - 1] + currMax);
+                }
+            }
+        }
+        return dp[d][n];
+    }
+}

1335.minimum-difficulty-of-a-job-schedule/README.md

@@ -0,0 +1,2 @@
+# [1335. Minimum Difficulty of a Job Schedule](https://leetcode.com/problems/minimum-difficulty-of-a-job-schedule/)
+

1338.reduce-array-size-to-the-half/README.md

@@ -0,0 +1,2 @@
+# [1338. Reduce Array Size to The Half](https://leetcode.com/problems/reduce-array-size-to-the-half/)
+

1338.reduce-array-size-to-the-half/ReduceArraySizeToTheHalf.java

@@ -0,0 +1,23 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+class ReduceArraySizeToTheHalf {
+    public int minSetSize(int[] arr) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i : arr) {
+            map.put(i, map.getOrDefault(i, 0) + 1);
+        }
+        ArrayList<Integer> arrayList = new ArrayList<>(map.values());
+        arrayList.sort(Collections.reverseOrder());
+
+        int currentSize = 0, minimumSet = 0;
+        while (currentSize < arr.length / 2) {
+            currentSize += arrayList.remove(0);
+            minimumSet++;
+        }
+
+        return minimumSet;
+    }
+}