kk

src/main/java/com/dota/binarySearch/_1818/Solution.java

@@ -0,0 +1,45 @@
+package com.dota.binarySearch._1818;
+
+import java.util.Arrays;
+
+class Solution {
+	public static void main(String[] args) {
+		new Solution().minAbsoluteSumDiff(new int[]{1,10,4,4,2,7}, new int[]{9,3,5,1,7,4});
+	}
+	public int minAbsoluteSumDiff(int[] nums1, int[] nums2) {
+		long sum = 0, max = 0;
+		var sort = nums1.clone();
+		Arrays.sort(sort);
+		for (int i = 0; i < nums1.length; i++) {
+			int diff = Math.abs(nums1[i] - nums2[i]);
+			sum = (sum + diff) % 100_000_0007;
+			int j = search(sort, nums2[i]);
+			if (j < nums1.length) {
+				max = Math.max(max, diff - (sort[j] - nums2[i]));
+			}
+			if (j > 0) {
+				max = Math.max(max, diff - (nums2[i] - sort[j - 1]));
+			}
+
+		}
+
+		return (int) (sum - max + 100_000_0007) % 100_000_0007;
+	}
+
+	int search(int[] sort, int t) {
+		int l = 0, r = sort.length - 1;
+		while (l < r) {
+			if (sort[r] < t) {
+				l = r + 1;
+				break;
+			}
+			int mid = l + (r - l) / 2;
+			if (sort[mid] < t) {
+				l = mid + 1;
+			} else {
+				r = mid;
+			}
+		}
+		return l;
+	}
+}

src/main/java/com/dota/binarySearch/_2070/Solution.java

@@ -0,0 +1,30 @@
+package com.dota.binarySearch._2070;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.TreeMap;
+
+class Solution {
+	public int[] maximumBeauty(int[][] items, int[] queries) {
+		Arrays.sort(items, Comparator.comparingInt(i -> i[0]));
+		var res = new int[queries.length];
+		var tree = new TreeMap<Integer, Integer>();
+		var max = -1;
+		for (int[] item : items) {
+			if (item[1] > max) {
+				max = item[1];
+			}
+			tree.put(item[0], max);
+		}
+		for (int i = 0; i < queries.length; i++) {
+			var e = tree.floorEntry(queries[i]);
+			if (e == null) {
+				res[i] = 0;
+			} else {
+				res[i] = e.getValue();
+			}
+
+		}
+		return res;
+	}
+}

src/main/java/com/dota/binarySearch/_2563/Solution.java

@@ -0,0 +1,29 @@
+package com.dota.binarySearch._2563;
+
+import java.util.Arrays;
+
+class Solution {
+	public long countFairPairs(int[] nums, int lower, int upper) {
+		Arrays.sort(nums);
+		long res = 0;
+		for (int i = 0; i < nums.length; i++) {
+			int a = finda(nums, lower - nums[i], i);
+			int b = finda(nums, upper - nums[i] + 1, i);
+			res += (b - a);
+		}
+		return res;
+	}
+
+	int finda(int[] nums, int num, int start) {
+		int l = -1, r = start;
+		while (l + 1 < r) {
+			int mid = l + (r - l) / 2;
+			if (nums[mid] < num) {
+				l = mid;
+			} else {
+				r = mid;
+			}
+		}
+		return r;
+	}
+}

src/main/java/com/dota/binarySearch/lcp08/Solution.java

@@ -0,0 +1,42 @@
+package com.dota.binarySearch.lcp08;
+
+class Solution {
+	public int[] getTriggerTime(int[][] increase, int[][] requirements) {
+		int n = increase.length;
+		int[] c = new int[n+1];
+		int[] r = new int[n+1];
+		int[] h = new int[n+1];
+		for (int i = 1; i < increase.length+1; i++) {
+			c[i] = increase[i-1][0] + c[i - 1];
+			r[i] = increase[i-1][1] + r[i - 1];
+			h[i] = increase[i-1][2] + h[i - 1];
+		}
+		int m = requirements.length;
+		var res = new int[m];
+		for (int i = 0; i < m; i++) {
+			var req = requirements[i];
+			int ci = find(c, req[0]);
+			int ri = find(r, req[1]);
+			int hi = find(h, req[2]);
+			if(ci==n+1||ri==n+1||hi==n+1) {
+				res[i] = -1;
+			} else {
+				res[i] = Math.max(ci,Math.max(ri,hi));
+			}
+		}
+		return res;
+	}
+
+	int find(int[] nums, int target) {
+		int l = 0, r = nums.length;
+		while (l < r) {
+			int mid = l + (r - l) / 2;
+			if (nums[mid] >= target) {
+				r = mid;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return r;
+	}
+}