Overview

This problem asks us to find the total travel time when a security guard makes \(M\) round-trip patrols from the waiting station (checkpoint \(N\)) to checkpoint \(1\).

Analysis

Consider the time for one round trip

First, let’s think about how much movement occurs in one patrol.

• Outbound: Travel from checkpoint \(N\) to checkpoint \(1\)

  • Travel distance: \(N - 1\) (passing between adjacent checkpoints \(N-1\) times)
  • Travel time: \(N - 1\) seconds

• Return: Travel from checkpoint \(1\) to checkpoint \(N\)

  • Travel distance: \(N - 1\)
  • Travel time: \(N - 1\) seconds

Therefore, the time for one round trip is \((N - 1) \times 2\) seconds.

Verification with a concrete example

Let’s consider the case where \(N = 5\), \(M = 3\).

Checkpoints: 1 --- 2 --- 3 --- 4 --- 5 (waiting station)

• One round trip: \(5 \to 1 \to 5\) takes \((5-1) \times 2 = 8\) seconds
• Three round trips: \(8 \times 3 = 24\) seconds

Why simple calculation is sufficient

In this problem, each round trip is independent and follows the same route every time. Therefore, there’s no need to simulate movement second by second—the answer can be obtained through simple multiplication.

If we were to simulate second by second, since \(N, M\) can be up to \(10^9\), we would need up to \(2 \times 10^{18}\) operations, resulting in TLE (Time Limit Exceeded).

Algorithm

1. Calculate the time for one round trip: \((N - 1) \times 2\)
2. Since we make \(M\) round trips, the total time is \((N - 1) \times 2 \times M\)
3. Output the result

This can be solved using only simple arithmetic operations.

Complexity

• Time complexity: \(O(1)\) (only a constant number of operations)
• Space complexity: \(O(1)\) (only using a few variables)

Implementation Notes

Watch out for overflow

Since \(N\) and \(M\) can each be up to \(10^9\), the answer can be at most approximately \((10^9 - 1) \times 2 \times 10^9 \approx 2 \times 10^{18}\).

• Python: No integer overflow, so no special handling needed
• C++/Java: You need to use 64-bit integer types (long long or long)

Calculation order

The calculation order of \((N - 1) \times 2 \times M\) produces the same result regardless of order, but for readability, it’s clearer to write it as “time for one round trip × number of trips”.

Source Code

N, M = map(int, input().split())
# One round trip takes (N-1) * 2 seconds
# Since we make M round trips, the total is (N-1) * 2 * M seconds
print((N - 1) * 2 * M)

---

This editorial was generated by claude4.5opus.