Problem 144: Investigating Multiple Reflections of a Laser Beam

Mathematical Foundation

Theorem 1. For the ellipse $4x^2 + y^2 = 100$, the outward unit normal at a point $(x_0, y_0)$ on the ellipse is proportional to $(4x_0, y_0)$.

Proof. The ellipse is the level set $F(x,y) = 4x^2 + y^2 - 100 = 0$. The gradient $\nabla F = (8x, 2y)$ is perpendicular to the level curve and points outward. Simplifying by the common factor of 2:

This is outward-pointing because for a point on the ellipse with $x_0 > 0$, the $x$-component is positive (pointing away from the center). $\square$

Theorem 2 (Reflection Formula). Given an incoming direction $\mathbf{d}$ and surface normal $\mathbf{n}$, the reflected direction is:

Proof. Decompose $\mathbf{d} = \mathbf{d}_\parallel + \mathbf{d}_\perp$ where $\mathbf{d}_\parallel = \frac{\mathbf{d} \cdot \mathbf{n}}{|\mathbf{n}|^2}\mathbf{n}$ is the component along $\mathbf{n}$ and $\mathbf{d}_\perp = \mathbf{d} - \mathbf{d}_\parallel$ is tangential. The law of reflection reverses the normal component while preserving the tangential component:

$\square$

Theorem 3 (Ray—Ellipse Intersection). A ray from $(x_0, y_0)$ on the ellipse in direction $(d_x, d_y)$ intersects the ellipse again at parameter:

Proof. Substitute $(x, y) = (x_0 + td_x, y_0 + td_y)$ into $4x^2 + y^2 = 100$:

Expanding and using $4x_0^2 + y_0^2 = 100$:

The solution $t = 0$ corresponds to the starting point. The other solution is:

$\square$

Lemma 1. The parameter $t$ in Theorem 3 is always nonzero (unless the ray is tangent to the ellipse at the starting point), so the ray always hits the ellipse again.

Proof. The numerator $2(4x_0 d_x + y_0 d_y) = 2(\mathbf{n} \cdot \mathbf{d})$ vanishes only when $\mathbf{d}$ is tangent to the ellipse at $(x_0, y_0)$. After reflection, $\mathbf{d}'$ has a nonzero normal component (since the incoming ray was not tangent), so the numerator is nonzero. $\square$

Editorial

Simulate laser reflections inside the ellipse 4x^2 + y^2 = 100. Entry at (0, 10.1), first hit at (1.4, -9.6). Exit when |x| <= 0.01 at the top (y > 0). We repeat. We then reflect. Finally, next intersection.

Pseudocode

INPUT: Ellipse 4x^2 + y^2 = 100, entry (0, 10.1), first hit (1.4, -9.6)
OUTPUT: Number of internal reflections before exit
repeat
Reflect
Next intersection
Check exit

Complexity Analysis

• Time: $O(R)$ where $R$ is the number of reflections. Each reflection requires $O(1)$ arithmetic operations (dot product, reflection, quadratic solve). Here $R = 354$.
• Space: $O(1)$ — only the current position, direction, and normal need to be stored.

Answer

#include <bits/stdc++.h>
using namespace std;

int main() {
    // Problem 144: Laser reflections in ellipse 4x^2 + y^2 = 100
    // Entry: (0, 10.1) -> first hit: (1.4, -9.6)
    // Exit: |x| <= 0.01 at top (y > 0)

    double x0 = 0.0, y0 = 10.1;
    double x1 = 1.4, y1 = -9.6;

    int count = 0;

    while (true) {
        // Direction of incoming beam
        double dx = x1 - x0;
        double dy = y1 - y0;

        // Normal at (x1, y1): proportional to (4*x1, y1)
        double nx = 4.0 * x1;
        double ny = y1;

        // Reflect: d' = d - 2*(d.n)/(n.n) * n
        double dn = dx * nx + dy * ny;
        double nn = nx * nx + ny * ny;
        double rx = dx - 2.0 * dn / nn * nx;
        double ry = dy - 2.0 * dn / nn * ny;

        // Find next intersection with 4x^2 + y^2 = 100
        // Ray: (x1 + t*rx, y1 + t*ry)
        // 4(x1+t*rx)^2 + (y1+t*ry)^2 = 100
        // t * (4*rx^2 + ry^2) + 2*(4*x1*rx + y1*ry) = 0  (dividing out t=0)
        double denom = 4.0 * rx * rx + ry * ry;
        double t = -2.0 * (4.0 * x1 * rx + y1 * ry) / denom;

        double x2 = x1 + t * rx;
        double y2 = y1 + t * ry;

        count++;

        // Check exit condition
        if (fabs(x2) <= 0.01 && y2 > 0) {
            break;
        }

        x0 = x1; y0 = y1;
        x1 = x2; y1 = y2;
    }

    cout << count << endl;
    return 0;
}

"""
Problem 144: Investigating Multiple Reflections of a Laser Beam

Simulate laser reflections inside the ellipse 4x^2 + y^2 = 100.
Entry at (0, 10.1), first hit at (1.4, -9.6).
Exit when |x| <= 0.01 at the top (y > 0).
"""

def solve():
    x0, y0 = 0.0, 10.1
    x1, y1 = 1.4, -9.6

    count = 0
    points = [(x0, y0), (x1, y1)]

    while True:
        # Incoming direction
        dx = x1 - x0
        dy = y1 - y0

        # Normal at (x1, y1) on ellipse 4x^2 + y^2 = 100
        nx = 4.0 * x1
        ny = y1

        # Reflect: d' = d - 2(d.n)/(n.n) * n
        dn = dx * nx + dy * ny
        nn = nx * nx + ny * ny
        rx = dx - 2.0 * dn / nn * nx
        ry = dy - 2.0 * dn / nn * ny

        # Next intersection parameter
        denom = 4.0 * rx * rx + ry * ry
        t = -2.0 * (4.0 * x1 * rx + y1 * ry) / denom

        x2 = x1 + t * rx
        y2 = y1 + t * ry

        count += 1
        points.append((x2, y2))

        # Exit check
        if abs(x2) <= 0.01 and y2 > 0:
            break

        x0, y0 = x1, y1
        x1, y1 = x2, y2

    print(count)