Patterns

Binary search over the answer values themselves; check feasibility at mid

When to useCapacity-style problems: find min/max value such that feasibility check passes

iterative

INITIALIZE

lo, hi = bounds of possible answers

let lo = Math.max(...times);
let hi = times.reduce((a, b) => a + b, 0);

let lo = Math.max(...weights);
let hi = weights.reduce((a, b) => a + b, 0);

let lo = 0;
let hi = Math.max(...areas);

let lo = Math.min(...onions);
let hi = Math.max(...onions);

let lo = 1;
let hi = Math.max(...minCals);

if (n === 0) return 0;
let lo = 1; let hi = n; let res = -1;

let lo = 1; let hi = k;

let lo = 1; let hi = k;

let lo = Math.max(...nums); let hi = nums.reduce((a, b) => a + b, 0);

let lo = 1n; let hi = 2n * 10n ** 18n;

—

TRAVERSE

while (lo < hi)

while (lo < hi) {

while (lo < hi) {

for (let i = 0; i < 100; i++) {

while (lo < hi) {

while (lo < hi) {

while (lo <= hi) {

while (lo < hi) {

while (lo < hi) {

while (lo < hi) {

while (lo < hi) {

—

mid

mid = candidate answer

  const mid = Math.floor((lo + hi) / 2);

  const mid = Math.floor((lo + hi) / 2);

  const mid = (lo + hi) / 2;

  const mid = Math.floor((lo + hi) / 2);

  const mid = Math.floor((lo + hi) / 2);

  const mid = Math.floor((lo + hi) / 2);

  const mid = Math.floor((lo + hi) / 2);

  const mid = Math.floor((lo + hi) / 2);

  const mid = Math.floor((lo + hi) / 2);

  const mid = (lo + hi) / 2n;

—

[FEASIBILITY]

if feasible(mid) hi = mid; else lo = mid + 1

  if (canSplit(mid)) hi = mid;
  else lo = mid + 1;

  if (canShip(mid)) hi = mid;
  else lo = mid + 1;

  if (canServe(mid)) lo = mid;
  else hi = mid;

  if (canMake(mid)) hi = mid;
  else lo = mid + 1;

  if (canFinish(mid)) hi = mid;
  else lo = mid + 1;

  if (mid * mid === n) return mid;
  else if (mid * mid > n) { res = mid; hi = mid - 1; }
  else lo = mid + 1;

  if (isReachable(mid)) hi = mid;
  else lo = mid + 1;

  if (canArrive(mid)) hi = mid;
  else lo = mid + 1;

  if (canSplit(mid)) hi = mid;
  else lo = mid + 1;

  if (count(mid) < BigInt(n)) lo = mid + 1n;
  else hi = mid;

—

RETURN

return lo (smallest feasible)

return lo;

return lo;

return Math.round(lo * 10000) / 10000;

return lo;

return lo;

return res - 1;

return lo;

return canArrive(lo) ? lo : -1;

return lo;

return Number(lo % MOD);

—