Ruudukko

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.System;
import java.math.BigInteger;
import java.util.Arrays;
import java.math.BigInteger;
public class DGrid {
    public static void main(String[] Args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int GridSize = Integer.parseInt(br.readLine());
        int GridSizeSq = GridSize * GridSize;
        int[][] Grid1 = new int[GridSizeSq][2];
        // int[][] SortedGrid = Grid1;
        BigInteger paths = BigInteger.valueOf(0);
        int counter = 0;
        BigInteger[] bigPaths = new BigInteger[GridSizeSq];
        for (int i = 0; i < GridSize; i++) {
            int[] NodeStates = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            for (int j : NodeStates) {
                Grid1[counter] = new int[] { counter, j};
                bigPaths[counter] = BigInteger.ONE;
                counter += 1;
            }
        }
        
        int[][] Grid = Grid1.clone();
        Arrays.sort(Grid1, (a, b) -> Integer.compare(a[1], b[1]));
        // Arrays.sort(SortedGrid, (a,b) ->Integer)
        for (int[] member : Grid1) {
            // CheckDirections(member[0], Grid1, paths, GridSize);
            int position = member[0];
            // int[][] Grid = Grid1;
            int y = (position / GridSize);
            int x = position - y * GridSize;
            BigInteger pathsInMe = bigPaths[position];
            // Check up
            for (int offset = 1; offset < y + 1; offset++) {
                if (Grid[position - GridSize * offset][1] > Grid[position][1]) {
                    bigPaths[position - GridSize * offset]=bigPaths[position - GridSize * offset].add(pathsInMe);
                }
            }
            // Check down
            for (int offset = 1; offset < GridSize - y; offset++) {
                if (Grid[position + GridSize * offset][1] > Grid[position][1]) {
                    bigPaths[position + GridSize * offset]=bigPaths[position + GridSize * offset].add(pathsInMe);
                }
            }
            // Check left
            for (int offset = 1; offset < x + 1; offset++) {
                if (Grid[position - offset][1] > Grid[position][1]) {
                    bigPaths[position - offset]=bigPaths[position - offset].add(pathsInMe);
                }
            }
            // Check right
            for (int offset = 1; offset < GridSize - x; offset++) {
                if (Grid[position + offset][1] > Grid[position][1]) {
                    bigPaths[position + offset]=bigPaths[position + offset].add(pathsInMe);
                }
            }
            
            paths = paths.add(bigPaths[position]);
        }
        
        System.out.println(paths.mod(BigInteger.valueOf(1000000007)));
        //System.out.println(paths);
    }
    // public static void CheckDirections(int position,int[][] Grid,int paths, int
    // GridSize){

    // }

}

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: 2, 3

Verdict: ACCEPTED

Test 5

Group: 2, 3

Verdict: ACCEPTED

Test 6

Group: 2, 3

Verdict: ACCEPTED

Test 7

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 8

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 9

Group: 3

Verdict: TIME LIMIT EXCEEDED