提出 #27966757

---

ソースコード 拡げる

import sys
import fileinput

lines = []
for l in sys.stdin:
    lines.append(l.rstrip('\r\n'))



class Mass:
    def __init__(self, i, j, wall_top = False, wall_right = False, wall_bottom = False, wall_left = False):
        self.i = i
        self.j = j
        self.wall_top = wall_top
        self.wall_right = wall_right
        self.wall_bottom = wall_bottom
        self.wall_left = wall_left
        self.is_cleared = False

    def clear(self):
        self.is_cleared = True


def init_floor_info(N, h, v, floor):
    for i in range(N):
        for j in range(N):
            mass = floor[i][j]
            if j < N-1:
                right_mass = floor[i][j+1]
            if i < N-1:
                bottom_mass = floor[i+1][j]
            # 外壁
            if i == 0:
                mass.wall_top = True
            if i == N-1:
                mass.wall_bottom = True
            if j == 0:
                mass.wall_left = True
            if i == N-1:
                mass.wall_right = True

            # その他の壁
            if j < N-1 and h[i][j] == "1":
                mass.wall_right = True
                right_mass.wall_left =True
            if i < N-1 and v[i][j] == "1":
                mass.wall_bottom = True
                bottom_mass.wall_top = True


class Robot:
    def __init__(self, i, j):
        self.i = i
        self.j = j
        # 0, 1, 2, 3 で上右下左
        self.direction = 0
        self.root = []
        self.count_turn = 0
        # self.clearned = []

    def turn_reft(self):
        d = self.direction
        if d == 0:
            d = 3
        else:
            d -= 1
        self.count_turn +=1
        self.root.append("L")

    def turn_reft_if_wall(self):
        d = self.direction
        if d == 0:
            d = 3
        else:
            d -= 1
        self.count_turn +=1
        self.root.append("l")

    def turn_right(self):
        d = self.direction
        if d == 3:
            d = 0
        else:
            d += 1
        self.count_turn +=1
        self.root.append("R")

    def turn_right_if_wall(self):
        d = self.direction
        if d == 3:
            d = 0
        else:
            d += 1
        self.count_turn +=1
        self.root.append("r")

    def go_forward(self):
        self.root.append("F")

    def move_top(self):
        self.j -= 1
        self.go_forward()

    def move_right(self):
        self.i += 1
        self.go_forward()

    def move_bottom(self):
        self.j += 1
        self.go_forward()

    def move_left(self):
        self.i -= 1
        self.go_forward()

# def FunctionName(args):
    

def main(lines):
    N = 20
    h = lines[1:N+1]
    v = lines[N+1:]
    s_i, s_j = int(lines[0].split()[0]), int(lines[0].split()[1])
    floor = [[Mass(i, j) for j in range(N)] for i in range(N)]
    init_floor_info(N, h, v, floor)

    rob = Robot(s_i, s_j)
    while i < 5000:
      	i += 1
        curr_mass = floor(rob.i, rob.j)
        direction = rob.direction
        constraint = True
        if rob.count_turn == 4:
            rob.count_turn = 0
            constraint = False
        if constraint:
            if direction == 0:
                top_mass = floor[rob.i-1][rob.j]
                if not curr_mass.wall_top and not top_mass.is_cleared:
                    rob.move_top()
                    top_mass.clear()
                else:
                    rob.turn_right_if_wall()
                continue

            if direction == 1:
                right_mass = floor[rob.i][rob.j+1]
                if not curr_mass.wall_right and not right_mass.is_cleared:
                    rob.move_right()
                else:
                    rob.turn_right_if_wall()
                continue

            if direction == 2:
                bottom_mass = floor[rob.i+1][rob.j]
                if not curr_mass.wall_bottom and not bottom_mass.is_cleared:
                    rob.move_bottom()
                else:
                    rob.turn_right_if_wall()
                continue

            if direction == 3:
                left_mass = floor[rob.i][rob.j-1]
                if not curr_mass.wall_left and not left_mass.is_cleared:
                    rob.move_left()
                else:
                    rob.turn_right_if_wall()
                continue
        else:
            if direction == 0:
                top_mass = floor[rob.i-1][rob.j]
                if not curr_mass.wall_top:
                    rob.move_top()
                    top_mass.clear()
                else:
                    rob.turn_right_if_wall()
                continue

            if direction == 1:
                right_mass = floor[rob.i][rob.j+1]
                if not curr_mass.wall_right:
                    rob.move_right()
                else:
                    rob.turn_right_if_wall()
                continue

            if direction == 2:
                bottom_mass = floor[rob.i+1][rob.j]
                if not curr_mass.wall_bottom:
                    rob.move_bottom()
                else:
                    rob.turn_right_if_wall()
                continue

            if direction == 3:
                left_mass = floor[rob.i][rob.j-1]
                if not curr_mass.wall_left:
                    rob.move_left()
                else:
                    rob.turn_right_if_wall()
                continue


    print("".join(rob.root))

main(lines)

提出情報

ジャッジ結果