Minimum Time To Scan Vivek has two scanners in hi...

Below is a concise O(log (X · min(T1, T2))) solution that uses binary search on time.
At any candidate time t we can compute how many documents each scanner could finish ( ⌊t / T1⌋ and ⌊t / T2⌋ ).
The least t for which the two totals reach X is the answer.

java
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        long X = sc.nextLong();   // number of documents
        long T1 = sc.nextLong();  // time per doc on scanner 1
        long T2 = sc.nextLong();  // time per doc on scanner 2
        sc.close();

        // ensure T1 is the faster (or equal) scanner; makes the search bounds tighter
        if (T1 > T2) {
            long tmp = T1;
            T1 = T2;
            T2 = tmp;
        }

        long low = 0;                // time definitely insufficient
        long high = T1 * X;          // upper bound: slowest‐case, all docs on faster scanner
        while (low < high) {
            long mid = (low + high) >>> 1;        // candidate time
            long done = mid / T1 + mid / T2;      // docs both scanners can finish by 'mid'

            if (done >= X) {          // enough docs ⇒ can try a smaller time
                high = mid;
            } else {                  // not enough ⇒ need more time
                low = mid + 1;
            }
        }

        System.out.println(low);      // minimum time required
    }
}

Why it works

• Feasibility check: In time t, scanner 1 completes ⌊t/T1⌋ docs and scanner 2 completes ⌊t/T2⌋ docs.
• Monotonicity: If a time t is sufficient, all larger times are also sufficient; hence binary search applies.
• Bounds:
  • Lower bound 0 (impossible but safe).
  • Upper bound T1 × X — allocating every document to the faster scanner always finishes by this time, so the answer lies ≤ that.

The algorithm runs in logarithmic time and uses only O(1) additional space.

Below is a self‑contained Java program that reads the start node S and end node E, then prints the number of distinct downward paths in the infinite triangular (“Christmas‑tree”) grid.

java
import java.math.BigInteger;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long S = sc.nextLong();   // start node label
        long E = sc.nextLong();   // end node label
        sc.close();

        // If labels are out of order, a downward path is impossible
        if (S > E) {
            System.out.println(0);
            return;
        }

        // Convert the labels to (row, col) coordinates
        Coord start = toCoord(S);
        Coord end   = toCoord(E);

        // End node must be on or below the start node’s row
        int downSteps = end.row - start.row;
        if (downSteps < 0) {
            System.out.println(0);
            return;
        }

        int rights = end.col - start.col;   // how many right moves are needed
        if (rights < 0 || rights > downSteps) {
            System.out.println(0);
            return;
        }

        // Number of paths equals C(downSteps, rights)
        BigInteger paths = binom(downSteps, rights);
        System.out.println(paths);
    }

    /** Holds 1‑based (row, col) inside the triangular grid. */
    private record Coord(int row, int col) {}

    /**
     * Converts a label x (>=1) to its (row, col).
     * Row r has r labels; first label of row r is 1+ r*(r‑1)/2.
     */
    private static Coord toCoord(long x) {
        // Row can be found from the quadratic formula for triangular numbers
        long r = (long) ((Math.sqrt(8.0 * x + 1) - 1) / 2);
        while (r * (r + 1) / 2 < x) ++r;          // adjust if rounded down
        int row = (int) r;
        int col = (int) (x - r * (r - 1) / 2);    // 1‑based within the row
        return new Coord(row, col);
    }

    /** Returns C(n, k) as a BigInteger (0 ≤ k ≤ n). */
    private static BigInteger binom(int n, int k) {
        if (k < 0 || k > n) return BigInteger.ZERO;
        if (k == 0 || k == n) return BigInteger.ONE;
        k = Math.min(k, n - k);   // exploit symmetry
        BigInteger res = BigInteger.ONE;
        for (int i = 1; i <= k; ++i) {
            res = res.multiply(BigInteger.valueOf(n - k + i))
                     .divide(BigInteger.valueOf(i));
        }
        return res;
    }
}

How the solution works

1. Coordinate mapping

   • Row r starts at label 1 + *r × (r − 1) / 2.
   • Within that row, the column is the offset from that first label.

2. Path characterization

   • Moving down one level keeps the column if you go left or increments it by 1 if you go right.
   • From row r₁ to row r₂ requires t = r₂ − r₁ moves.
   • Exactly k = c₂ − c₁ of those moves must be rights.
   • The number of such sequences is the binomial coefficient C(t, k).

3. Edge cases

   • If the end node is higher than the start, or the required number of rights is impossible (k < 0 or k > t), the answer is 0.
   • If S == E, the algorithm naturally yields 1.

The program uses BigInteger so it works even for very deep rows where the path count exceeds 64‑bit range.