Overview

This problem involves simulating a ball moving within an interval of length \(M\), repeatedly reflecting at the endpoints. Since the number of shots \(N\) and the movement distances \(A_i\) can be very large, rather than naively tracking each reflection one by one, we need to utilize mathematical properties (the method of images and periodicity) to compute the result of each shot in \(O(1)\).

Analysis

1. Properties of Reflection and the Method of Images

The behavior of a ball reflecting within the range \([0, M]\) becomes easier to understand when we think of the number line being folded back every \(M\) units.

• When coordinate \(x\) satisfies \(0 \le x \le M\): the position is simply \(x\)
• When coordinate \(x\) satisfies \(M < x \le 2M\): it is reflected to \(2M - x\)
• When coordinate \(x\) satisfies \(2M < x \le 3M\): it is reflected again to \(x - 2M\)

In this way, the ball’s movement can be understood as periodic motion with period \(2M\). When moving a distance \(A\) to the right from position \(P\), the final position is determined by the value of \((P + A) \pmod{2M}\).

2. Calculating the Number of Reflections

A reflection occurs each time the ball reaches endpoint \(0\) or \(M\). Consider moving a distance \(A\) to the right from the current position \(P\) (where \(0 \le P < M\)). In this case, the first reflection occurs at point \(M\), and after that, a reflection occurs every \(M\) distance traveled. Therefore, the number of reflections is \(\lfloor (P + A - 1) / M \rfloor\). ※ When \(P+A\) is exactly a multiple of \(M\), we subtract \(-1\) to adjust for whether to include the reflection at that point.

3. Special Reflections (Reflections at the Start)

The problem statement includes the rule: “if the ball is at an endpoint at the start and would move outward, it immediately reflects.” - At position \(0\) with direction L: immediately reflects and starts moving in direction R (reflections +1) - At position \(M\) with direction R: immediately reflects and starts moving in direction L (reflections +1) By handling this at the beginning of each shot, we can uniformly treat all subsequent movement as “movement toward the interior.”

Algorithm

For each shot, the following steps are performed:

1. Check movement distance: If \(A_i = 0\), do nothing.
2. Determine initial reflection:
   • If \(C_i = \text{'R'}\) and current position \(P = M\), increment the reflection count by +1 and set direction to “left.”
   • If \(C_i = \text{'L'}\) and current position \(P = 0\), increment the reflection count by +1 and set direction to “right.”
   • Otherwise, start moving in the specified direction \(C_i\).
3. Calculate position and reflections after movement:
   • When moving to the “left,” it is convenient to invert the coordinate system (\(P' = M - P\)) and compute as if moving to the “right.”
   • Let the virtual coordinate after movement be \(X = P + A\).
   • Add the additional reflection count \(\lfloor (X - 1) / M \rfloor\).
   • Determine the final position \(P\) using \(X \pmod{2M}\):
     • If \(X \pmod{2M} \le M\), then \(P = X \pmod{2M}\)
     • If \(X \pmod{2M} > M\), then \(P = 2M - (X \pmod{2M})\)
4. Restore the coordinate system: If the coordinate system was inverted in step 3, convert the result back to the original coordinate system.

Complexity

• Time complexity: \(O(N)\) Since each shot is computed in constant time \(O(1)\), the total time is linear with respect to the number of shots \(N\).
• Space complexity: \(O(N)\) \(O(N)\) memory is used to store the input (this can be reduced to \(O(1)\) if stream processing is used).

Implementation Notes

• Handling large values: Since \(M\) and \(A_i\) can be as large as \(10^9\), intermediate values like \(2M\) can reach \(2 \times 10^9\). In Python, this is automatically handled as arbitrary-precision integers, but in other languages (such as C++), long long types must be used.

• Unifying direction: The technique of converting leftward movement to rightward movement using the transformation \(P' = M - P\) (utilizing the mirror image) is very effective for reducing conditional branches and preventing bugs.

• Fast I/O: Since \(N\) can be as large as \(2 \times 10^5\), in Python it is advisable to read all input at once using sys.stdin.read().split() to reduce execution time.

  Source Code

import sys

def solve():
    # Fast input reading: read all at once and use an iterator
    input_data = sys.stdin.read().split()
    if not input_data:
        return
    
    it = iter(input_data)
    N = int(next(it))
    M = int(next(it))
    S = int(next(it))
    
    current_P = S
    total_reflections = 0
    
    # Process each of the N shots
    for _ in range(N):
        C = next(it)
        A = int(next(it))
        
        # If distance A is 0, no movement or reflection occurs
        if A == 0:
            continue
        
        # 1. Handle the "start-of-shot" reflection and determine initial direction
        # If at boundary 0 moving Left or boundary M moving Right, reflect immediately
        if C == 'R':
            if current_P == M:
                total_reflections += 1
                direction = -1
            else:
                direction = 1
        else: # C == 'L'
            if current_P == 0:
                total_reflections += 1
                direction = 1
            else:
                direction = -1
        
        # 2. Calculate the number of reflections and the final position for this shot
        # A reflection occurs every time the ball reaches 0 or M with distance remaining.
        # We use mirroring to unify the logic for both directions.
        if direction == 1:
            # Moving towards M from current_P
            # Let X be the distance from 0 in an infinite line model
            X = current_P + A
            # Reflections occur when crossing multiples of M (M, 2M, 3M, ...)
            # Since current_P < M, the first boundary hit is M.
            total_reflections += (X - 1) // M
            
            # Final position calculation within [0, 2M) period
            X_mod = X % (2 * M)
            if X_mod <= M:
                current_P = X_mod
            else:
                current_P = 2 * M - X_mod
        else: # direction == -1
            # Moving towards 0 from current_P
            # Mirror the coordinate system: P' = M - P
            # Moving from P towards 0 is equivalent to moving from P' towards M
            P_prime = M - current_P
            X = P_prime + A
            total_reflections += (X - 1) // M
            
            # Final position calculation on the mirrored table
            X_mod = X % (2 * M)
            if X_mod <= M:
                P_prime_final = X_mod
            else:
                P_prime_final = 2 * M - X_mod
            # Transform back from mirrored coordinate
            current_P = M - P_prime_final
            
    # Output the final position and total reflection count
    sys.stdout.write(f"{current_P} {total_reflections}\n")

if __name__ == '__main__':
    solve()

---

This editorial was generated by gemini-3-flash-thinking.