Олимпиадная задача про лазеры, 10 класс

class Laser:
    def __init__(self, x, y, direction):
        self.x = x
        self.y = y
        self.direction = direction  # 1 = Up, 2 = Right, 3 = Down, 4 = Left
        self.reflections = []  # Stores mirrors it has reflected off
 
    def move(self):
        if self.direction == 1:
            self.y += 1
        elif self.direction == 2:
            self.x += 1
        elif self.direction == 3:
            self.y -= 1
        elif self.direction == 4:
            self.x -= 1
 
    def reflect(self, mirror):
        """ Reflect the laser off the mirror """
        self.reflections.append(mirror)
        if mirror[0] == mirror[2]:  # Vertical mirror
            if self.direction in [1, 3]:
                self.direction = 2 if self.direction == 1 else 4
            else:
                self.direction = 3 if self.direction == 2 else 1
        else:  # Horizontal mirror
            if self.direction in [1, 3]:
                self.direction = 4 if self.direction == 1 else 2
            else:
                self.direction = 1 if self.direction == 4 else 3
 
 
def do_intersect(laser1, laser2):
    # simple checking based on coordinates for now; assuming lasers are simple lines
    return (laser1.x == laser2.x) and (laser1.y == laser2.y)
 
 
def main(laser1_start, laser2_start, mirrors):
    laser1 = Laser(*laser1_start)
    laser2 = Laser(*laser2_start)
 
    mirrors = [((x1, y1), (x2, y2)) for (x1, y1, x2, y2) in mirrors]
 
    reflections1_count = 0
    reflections2_count = 0
 
    while True:
        laser1.move()
        laser2.move()
        
        # Check intersection between lasers
        if do_intersect(laser1, laser2):
            # First remove from Laser 1's reflections
            if reflections1_count < len(laser1.reflections):
                laser1.reflections.pop(reflections1_count)
                reflections1_count += 1
            else:
                # then remove from Laser 2's reflections
                if reflections2_count < len(laser2.reflections):
                    laser2.reflections.pop(-1)  # Last mirror
                    reflections2_count += 1
                else:
                    break
        else:
            break
 
    return reflections1_count, reflections2_count
 
 
if __name__ == "__main__":
    # Input
    laser1_start = list(map(int, input().strip().split()))
    laser2_start = list(map(int, input().strip().split()))
    n = int(input().strip())
    mirrors = [tuple(map(int, input().strip().split())) for _ in range(n)]
 
    results = main(
        (laser1_start[0], laser1_start[1], laser1_start[2]),
        (laser2_start[0], laser2_start[1], laser2_start[2]),
        mirrors
    )
 
    print(*results)

def solve():
    x1, y1, d1 = map(int, input().split())
    x2, y2, d2 = map(int, input().split())
    n = int(input())
    mirrors = []
    for _ in range(n):
        mirrors.append(list(map(int, input().split())))
 
    def trace_ray(x, y, d, removed_mirrors):
        path = [(x, y)]
 
        while True:
            if d == 1:  # Up
                ny = y + 1
                nx = x
            elif d == 2:  # Down
                ny = y - 1
                nx = x
            elif d == 3:  # Left
                nx = x - 1
                ny = y
            elif d == 4:  # Right
                nx = x + 1
                ny = y
 
            hit_mirror = -1
            for i, mirror in enumerate(mirrors):
                if i not in removed_mirrors:
                    if (mirror[0] == mirror[2] and mirror[1] <= y <= mirror[3] and min(mirror[0], nx) <= x <= max(
                            mirror[0], nx)) or \
                            (mirror[1] == mirror[3] and mirror[0] <= x <= mirror[2] and min(mirror[1], ny) <= y <= max(
                                mirror[1], ny)):
                        hit_mirror = i
                        break
 
            if hit_mirror != -1:
 
                if mirrors[hit_mirror][0] == mirrors[hit_mirror][2]:  # Vertical mirror
                    if d == 1 or d == 2:
                        d = 4 if x < mirrors[hit_mirror][0] else 3
                else:  # Horizontal mirror
                    if d == 3 or d == 4:
                        d = 2 if y < mirrors[hit_mirror][1] else 1
                path.append((nx, ny))
                x, y = nx, ny
 
            else:
                path.append((nx, ny))
                break
        return path
 
    def check_intersection(path1, path2):
        for p1 in path1:
            for p2 in path2:
                if p1 == p2:
                    return True
        return False
 
    min_removed1 = float('inf')
    min_removed2 = float('inf')
 
    for i in range(1 << (2 * n)):
        removed_mirrors1 = []
        removed_mirrors2 = []
        count1 = 0
        count2 = 0
 
        temp = bin(i)[2:].zfill(2 * n)
 
        for j in range(n):
            if int(temp[j]) == 1:
                removed_mirrors1.append(j)
                count1 += 1
            if int(temp[j + n]) == 1:
                removed_mirrors2.append(j)
                count2 += 1
 
        path1 = trace_ray(x1, y1, d1, removed_mirrors1)
        path2 = trace_ray(x2, y2, d2, removed_mirrors2)
 
        if not check_intersection(path1, path2):
            if count1 + count2 < min_removed1 + min_removed2:
                min_removed1 = count1
                min_removed2 = count2
 
    print(min_removed1, min_removed2)
 
 
solve()