Indian National Olympiad in Informatics 2014
Due to resurfacing work, all north-south traffic on the highway is being diverted through the town of Siruseri. Siruseri is a modern, planned town and the section of roads used for the diversion forms a rectangular grid where all cars enter at the top-left intersection (north- west) and leave at the bottom-right intersection (south-east). All roads within the grid are one-way, allowing traffic to move north to south (up-down) and west to east (left-right) only.
The town authorities are concerned about highway drivers overspeeding through the town. To slow them down, they have made a rule that no car may travel more than d consecutive road segments in the same direction without turning. (Closed-circuit TV cameras have been installed to enforce this rule.)
Of course, there is also repair work going on within the town, so some intersections are blocked and cars cannot pass through these.
You are given the layout of the rectangular grid of roads within Siruseri and the constraint on how many consecutive road segments you may travel in the same direction. Your task is to compute the total number of paths from the entry (top-left) to the exit (bottom-right).
For instance, suppose there are 3 rows and 4 columns of intersec- tions, numbered from (1,1) at the top-left to (3,4) at the bottom-right, as shown on the right. Intersection (2,1) in the second row, first column is blocked, and no car may travel more than 2 consecutive road seg- ments in the same direction.
Here, (1,1) → (1,2) → (2,2) → (3,2) → (3,3) → (3,4) is a valid path from (1,1) to (3,4), but (1,1) → (1,2) → (1,3) → (1,4) → (2,4) → (3,4) is not, because this involves 3 consecutive road segments from left to right. The path (1, 1) → (2, 1) → (2, 2) → (2, 3) → (3, 3) → (3, 4) is ruled out because it goes through a blocked intersection. In this example, you can check that the total number of valid paths is 5.
-----Input format-----
• Line 1: Three space-separated integers, R, C and d, where R is the number of rows in the grid, C is the number of columns in the grid and d is the maximum number of consecutive segments you can travel in any direction.
• Lines 2 to R+1: Each line contains C integers, each of which is 0 or 1, describing one row of intersections in the grid. An intersection marked 0 is blocked and an intersection marked 1 is available to pass through. The start (top-left) and finish (bottom-right) intersections are always marked 1.
-----Output format-----
A single integer—the number of paths from the top-left intersection to the bottom-right intersection that go only down and right, and obey the d constraint.
Since the final answer may not fit in a variable of type int, report your answer modulo 20011. Be careful to avoid overflows in intermediate computations.
-----Test Data-----
The testdata is grouped into three subtasks. In all subtasks, 1 ≤ R ≤ 300, 1 ≤ C ≤ 300 and 1 ≤ d ≤ 300. In addition, each subtask has the following constraints on the inputs.
• Subtask 1 [20 points]: d = max(R, C) − 1. (In other words, there is no limit on the number of consecutive segments you can travel in one direction.)
• Subtask 2 [30 points]: d=2.
• Subtask 3 [50 points]: No additional constraint on d.
-----Example-----
Here is the sample input and output corresponding to the example above.
-----Sample input-----
3 4 2
1 1 1 1
0 1 1 1
1 1 1 1
-----Sample output-----
5
Note: Your program should not print anything other than what is specified in the output format. Please remove all diagnostic print statements before making your final submission. A program with extraneous output will be treated as incorrect!
class PathNode:

    def __init__(self, row, col, st_x, st_y, p_count=0):
        self.x = row
        self.y = col
        self.pathCount = p_count

    def __str__(self):
        return str(self.x) + " | " + str(self.y) + " | " + str(self.pathCount)


class GraphUtil:
    def __init__(self, mat, R,C, d):
        self.mat = mat
        self.R = R
        self.C = C
        self.d = d
        self.tab = {}

    def isValidMove(self, r, c, blockVal):
        return r < self.R and c < self.C and self.mat[r][c] != blockVal

    def possbilePathUtil(self, r, c, blockVal, step,direction):

        if(not self.isValidMove(r, c, 0)):
            return 0
            
        if (r == self.R - 1 and c == self.C - 1):
            return 1

        if ((r,c,step,direction) in self.tab):
            return self.tab[(r,c,step,direction)]

        result = 0
        
        if direction == 1:
            if step < self.d:
                result = (result + self.possbilePathUtil(r, c + 1, blockVal, step + 1,1)) % 20011
            result = (result +  self.possbilePathUtil(r+1, c, blockVal, 1,2)) % 20011
        else:
            if step < self.d:
                result = (result + self.possbilePathUtil(r + 1, c, blockVal, step + 1, 2)) % 20011
            result = (result + self.possbilePathUtil(r, c + 1, blockVal, 1,1)) % 20011
        
        self.tab[(r,c,step,direction)] = result
        
        return result

    def possbilePath(self):
        if (not self.mat or len(self.mat) < 1):
            return 0

        return self.possbilePathUtil(0, 0, 0,0,2)


numbers = [int(n) for n in input().split()]

mat = [[int(n) for n in input().split()] for r in range(0, numbers[0])]

result = GraphUtil(mat, numbers[0], numbers[1], numbers[2])

print(result.possbilePath())
# print(result.count)
class PathNode:

    def __init__(self, row, col, st_x, st_y, p_count=0):
        self.x = row
        self.y = col
        self.pathCount = p_count

    def __str__(self):
        return str(self.x) + " | " + str(self.y) + " | " + str(self.pathCount)


class GraphUtil:
    def __init__(self, mat, R,C, d):
        self.mat = mat
        self.R = R
        self.C = C
        self.d = d
        self.tab = {}

    def isValidMove(self, r, c, blockVal):
        return r < self.R and c < self.C and self.mat[r][c] != blockVal

    def possbilePathUtil(self, r, c, blockVal, step,direction):

        if(not self.isValidMove(r, c, 0)):
            return 0
            
        if (r == self.R - 1 and c == self.C - 1):
            return 1

        if ((r,c,step,direction) in self.tab):
            return self.tab[(r,c,step,direction)]

        result = 0
        
        if direction == 1:
            if step < self.d:
                result = (result + self.possbilePathUtil(r, c + 1, blockVal, step + 1,1)) % 20011
            result = (result +  self.possbilePathUtil(r+1, c, blockVal, 1,2)) % 20011
        else:
            if step < self.d:
                result = (result + self.possbilePathUtil(r + 1, c, blockVal, step + 1, 2)) % 20011
            result = (result + self.possbilePathUtil(r, c + 1, blockVal, 1,1)) % 20011
        
        self.tab[(r,c,step,direction)] = result
        
        return result

    def possbilePath(self):
        if (not self.mat or len(self.mat) < 1):
            return 0

        return self.possbilePathUtil(0, 0, 0,0,2)


numbers = [int(n) for n in input().split()]

mat = [[int(n) for n in input().split()] for r in range(0, numbers[0])]

result = GraphUtil(mat, numbers[0], numbers[1], numbers[2])

print(result.possbilePath())
# print(result.count)