kk

pom.xml

@@ -20,5 +20,17 @@
             <version>4.4</version>
         </dependency>
     </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>21</source>
+                    <target>21</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
 </project>

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

@@ -0,0 +1,33 @@
+package com.dota.binarySearch._1011;
+
+class Solution {
+	public int shipWithinDays(int[] weights, int days) {
+		int l = weights[0];
+		for (int weight : weights) {
+			l = Math.max(l, weight);
+		}
+		int r = l * weights.length;
+		while (l < r) {
+			int mid = (l + r) / 2;
+			if (df(weights, mid) <= days) {
+				r = mid;
+			} else {
+				l = mid + 1;
+			}
+		}
+
+		return r;
+	}
+	int df(int[] nums, int weight) {
+		int res = 1;
+		int temp = 0;
+		for (int num : nums) {
+			temp += num;
+			if (temp > weight) {
+				res++;
+				temp = num;
+			}
+		}
+		return res;
+	}
+}

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

@@ -0,0 +1,27 @@
+package com.dota.binarySearch._1283;
+
+class Solution {
+	public int smallestDivisor(int[] nums, int threshold) {
+		int l = 1;
+		int r = 1000000;
+		while (l < r) {
+			int mid = l + (r - l) / 2;
+      int t = df(nums, mid);
+			if (t <= threshold) {
+				r = mid;
+			} else {
+				l = mid + 1;
+			}
+		}
+
+		return df(nums, r);
+	}
+
+	int df(int[] nums, int t) {
+		int res =0;
+		for (int num : nums) {
+			res += (num + t - 1) / t;
+		}
+		return res;
+	}
+}

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

@@ -0,0 +1,33 @@
+package com.dota.binarySearch._2187;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    public long minimumTime(int[] time, int totalTrips) {
+        long r = time[0];
+        for (int i : time) {
+            r = Math.min(r, i);
+        }
+        r = r  * totalTrips;
+        long l = 1;
+        while (l < r) {
+            long mid = l + (r - l) / 2;
+            if (df(time, mid) >= totalTrips) {
+                r = mid;
+            } else {
+                l = mid+1;
+            }
+        }
+
+        return r;
+    }
+
+    long df(int[] nums, long t) {
+        long res = 0;
+        for (int num : nums) {
+            res += t/num;
+        }
+        return res;
+    }
+}

src/main/java/com/dota/binarySearch/_3508/Router.java

@@ -0,0 +1,85 @@
+package com.dota.binarySearch._3508;
+
+
+import java.util.*;
+
+record Node(
+		int s,
+		int d,
+		int t) {
+}
+
+class Router {
+	List<Node> list;
+	Set<Node> nodeSet;
+	Map<Integer, List<Integer>> sortMap;
+	int cnt;
+	int limit;
+
+	public Router(int memoryLimit) {
+		list = new ArrayList<>();
+		this.limit = memoryLimit;
+		nodeSet = new HashSet<>();
+		this.cnt = 0;
+		sortMap = new HashMap<>();
+	}
+
+	public boolean addPacket(int source, int destination, int timestamp) {
+		var n = new Node(source, destination, timestamp);
+		if (nodeSet.contains(n)) {
+			return false;
+		}
+
+		cnt++;
+		list.add(n);
+		nodeSet.add(n);
+		sortMap.computeIfAbsent(destination, k -> new ArrayList<>()).add(timestamp);
+		if (cnt > limit) {
+			cnt--;
+			n = list.removeFirst();
+			nodeSet.remove(n);
+			sortMap.get(n.d()).removeFirst();
+		}
+		return true;
+	}
+
+	public int[] forwardPacket() {
+		if (cnt == 0) return new int[]{};
+		cnt--;
+		var n = list.removeFirst();
+		nodeSet.remove(n);
+		sortMap.get(n.d()).removeFirst();
+		return new int[]{n.s(), n.d(), n.t()};
+	}
+
+	public int getCount(int destination, int startTime, int endTime) {
+		var li = sortMap.get(destination);
+		if (li == null) return 0;
+		var r = find(li, endTime + 1);
+		var l = find(li, startTime);
+		return r-l;
+	}
+
+	int find(List<Integer> list, int target) {
+		int l = 0, r = list.size();
+		while (l < r) {
+			int mid = l + (r - l) / 2;
+			if (list.get(mid) >= target) {
+				r = mid;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return r;
+	}
+
+	public static void main(String[] args) {
+		var r = new Router(2);
+		r.addPacket(1,4,1);
+		r.addPacket(5,4,1);
+		r.addPacket(1,4,1);
+		r.getCount(4,1,1);
+		r.forwardPacket();
+		r.getCount(4,1,1);
+	}
+}

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

@@ -0,0 +1,29 @@
+package com.dota.binarySearch._875;
+
+class Solution {
+	public int minEatingSpeed(int[] piles, int h) {
+		int l = 0;
+		int r = piles[0];
+		for (int pile : piles) {
+			r = Math.max(r, pile);
+		}
+
+		while (l < r) {
+			int mid = l + (r - l) / 2;
+			if (df(piles, mid) > h) {
+				l = mid + 1;
+			} else {
+				r = mid;
+			}
+		}
+		return l;
+	}
+
+	int df(int[] piles, int k) {
+		int res = 0;
+		for (int pile : piles) {
+			res += (pile + k - 1) / k;
+		}
+		return res;
+	}
+}