weekly-239

Signed-off-by: ashKIK <[email protected]>

Author: px100

weekly-239/MinimumAdjacentSwapsToReachTheKthSmallestNumber.java

@@ -0,0 +1,52 @@
+
+// https://leetcode.com/contest/weekly-contest-239/problems/minimum-adjacent-swaps-to-reach-the-kth-smallest-number/
+
+public class MinimumAdjacentSwapsToReachTheKthSmallestNumber {
+
+  public int getMinSwaps(String num, int k) {
+    char[] original = num.toCharArray();
+    char[] nums = original.clone();
+    while (k-- > 0) {
+      nextPermutation(nums);
+    }
+    int ans = 0;
+    for (int i = 0; i < nums.length; i++) {
+      int j = i + 1;
+      while (original[i] != nums[i]) {
+        ans++;
+        swap(nums, i, j++);
+      }
+    }
+    return ans;
+  }
+
+  public void nextPermutation(char[] nums) {
+    if (nums.length <= 1) {
+      return;
+    }
+    int i = nums.length - 2;
+    while (i >= 0 && nums[i] >= nums[i + 1]) {
+      i--;
+    }
+    if (i >= 0) {
+      int j = nums.length - 1;
+      while (j > i && nums[j] <= nums[i]) {
+        j--;
+      }
+      swap(nums, i, j);
+    }
+    reverse(nums, i + 1, nums.length - 1);
+  }
+
+  private void reverse(char[] nums, int left, int right) {
+    while (left < right) {
+      swap(nums, left++, right--);
+    }
+  }
+
+  private void swap(char[] nums, int i, int j) {
+    char temp = nums[j];
+    nums[j] = nums[i];
+    nums[i] = temp;
+  }
+}

weekly-239/MinimumDistanceToTheTargetElement.java

@@ -0,0 +1,15 @@
+
+// https://leetcode.com/contest/weekly-contest-239/problems/minimum-distance-to-the-target-element/
+
+public class MinimumDistanceToTheTargetElement {
+
+  public int getMinDistance(int[] nums, int target, int start) {
+    int min = Integer.MAX_VALUE;
+    for (int i = 0; i < nums.length; i++) {
+      if (nums[i] == target) {
+        min = Math.min(min, Math.abs(i - start));
+      }
+    }
+    return min;
+  }
+}

weekly-239/MinimumIntervalToIncludeEachQuery.java

@@ -0,0 +1,34 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+// https://leetcode.com/contest/weekly-contest-239/problems/minimum-interval-to-include-each-query/
+
+public class MinimumIntervalToIncludeEachQuery {
+
+  public int[] minInterval(int[][] intervals, int[] queries) {
+    Arrays.sort(intervals, (a, b) -> (b[0] - a[0] - (b[1] - a[1])));
+    TreeMap<Integer, List<Integer>> treeMap = new TreeMap<>();
+    for (int i = 0; i < queries.length; i++) {
+      treeMap.computeIfAbsent(queries[i], a -> new ArrayList<>()).add(i);
+    }
+    int[] result = new int[queries.length];
+    Arrays.fill(result, -1);
+    for (int[] interval : intervals) {
+      int left = interval[0];
+      int right = interval[1];
+      Map<Integer, List<Integer>> sub =
+          treeMap.subMap(left, true, right, true);
+      for (List<Integer> list : sub.values()) {
+        for (int i : list) {
+          result[i] = right - left + 1;
+        }
+      }
+      treeMap.keySet().removeAll(Set.copyOf(sub.keySet()));
+    }
+    return result;
+  }
+}

weekly-239/SplittingAStringIntoDescendingConsecutiveValues.java

@@ -0,0 +1,71 @@
+
+// https://leetcode.com/contest/weekly-contest-239/problems/splitting-a-string-into-descending-consecutive-values/
+
+public class SplittingAStringIntoDescendingConsecutiveValues {
+
+  // TC: O(n*log(n))
+  public boolean splitString(String s) {
+    int start = 0;
+    int end = s.length() - 1;
+    while (start < end) {
+      if (binarySearch(s, end, eval(s, start, end) - 1)) {
+        return true;
+      }
+      end--;
+    }
+    return false;
+  }
+
+  private long eval(String s, int start, int end) {
+    long num = 0;
+    for (int i = start; i < end; i++) {
+      num = num * 10 + (long) (s.charAt(i) - '0');
+    }
+    return num;
+  }
+
+  private boolean binarySearch(String s, int index, long target) {
+    if (eval(s, index, s.length()) == target) {
+      return true;
+    }
+    int left = index;
+    int right = s.length();
+    while (left < right) {
+      int mid = right - (right - left) / 2;
+      long num = eval(s, index, mid);
+      if (num == target) {
+        return binarySearch(s, mid, target - 1);
+      }
+      if (num > target) {
+        right = mid - 1;
+      } else {
+        left = mid;
+      }
+    }
+    return false;
+  }
+
+  // TC: O(n^2)
+  public boolean splitString2(String s) {
+    return dfs(s, 0, 0, 0);
+  }
+
+  private boolean dfs(String s, int pos, long curVal, long lastVal) {
+    if (pos == s.length()) {
+      return lastVal != 0;
+    }
+    if (curVal == 0 && lastVal != 0) {
+      return false;
+    }
+    long val = 0;
+    for (int i = pos; i < s.length(); i++) {
+      val = val * 10 + (s.charAt(i) - '0');
+      if (curVal == 0 || curVal == val + 1) {
+        if (dfs(s, i + 1, val, curVal)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}