Ratsun reitit

import time

start_time = time.time()

n2 = int(input(""))

class cell:

    def __init__(self, x = 0, y = 0, dist = 0):
        self.x = x
        self.y = y
        self.dist = dist

if n2 < 4:
    print("n has to greater than 3")
else:

    # Python3 code to find minimum steps to reach
    # to specific cell in minimum moves by Knight

    # checks whether given position is
    # inside the board
    def isInside(x, y, N):
        if (x >= 1 and x <= N and
            y >= 1 and y <= N):
            return True
        return False

    # Method returns minimum step to reach
    # target position
    def minStepToReachTarget(knightpos,
                             targetpos, N):

        # all possible movments for the knight
        dx = [2, 2, -2, -2, 1, 1, -1, -1]
        dy = [1, -1, 1, -1, 2, -2, 2, -2]

        queue = []

        # push starting position of knight
        # with 0 distance
        queue.append(cell(knightpos[0], knightpos[1], 0))

        # make all cell unvisited
        visited = [[False for i in range(N + 1)]
                          for j in range(N + 1)]

        # visit starting state
        visited[knightpos[0]][knightpos[1]] = True

        # loop untill we have one element in queue
        while(len(queue) > 0):

            t = queue[0]
            queue.pop(0)

            # if current cell is equal to target
            # cell, return its distance
            if(t.x == targetpos[0] and
               t.y == targetpos[1]):
                return t.dist

            # iterate for all reachable states
            for i in range(8):

                x = t.x + dx[i]
                y = t.y + dy[i]

                if(isInside(x, y, N) and not visited[x][y]):
                    visited[x][y] = True
                    queue.append(cell(x, y, t.dist + 1))

    # Driver Code
    def stepsToPoint(targetX, targetY):
        N = n2
        knightpos = [1, n2]
        targetpos = [targetX, targetY]
        return minStepToReachTarget(knightpos, targetpos, N)

    # for (y, row) in enumerate(dp):
    #     for (x, value) in enumerate(row):
    #         dp[y][x] = (stepsToPoint(x+1,n2-y))


    # for y in range(n2):
    #     for x in range(n2):
    #         if x==n2-1:
    #             print(minStepToReachTarget([1, n2], [x+1,n2-y], n2), end="\n")
    #         else:
    #             print(minStepToReachTarget([1, n2], [x+1,n2-y], n2), end=" ")


    # print('\n'.join(' '.join(map(lambda x: str(minStepToReachTarget([1, n2], [x+1, n2-y], n2)), range(n2))) for y in range(n2)))

    print(*[' '.join(map(lambda x: str(minStepToReachTarget([1, n2], [x+1, n2-y], n2)),range(n2))) for y in range(n2)], sep='\n')
    # print(*[minStepToReachTarget([1, n2], [x+1,n2-y], n2) for x in range(n2) for y in range(n2)], sep='\n')

Test 1

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3

Verdict: ACCEPTED

Test 3

Group: 1, 2, 3

Verdict: ACCEPTED

Test 4

Group: 1, 2, 3

Verdict: ACCEPTED

Test 5

Group: 1, 2, 3

Verdict: ACCEPTED

Test 6

Group: 1, 2, 3

Verdict: ACCEPTED

Test 7

Group: 1, 2, 3

Verdict: ACCEPTED

Test 8

Group: 2, 3

Verdict: ACCEPTED

Test 9

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 10

Group: 2, 3

Verdict: TIME LIMIT EXCEEDED

Test 11

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 3

Verdict: TIME LIMIT EXCEEDED