output_description: If the minimum possible sum of the wrongness of all the squares is x, print x.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N C
      D_{1,1} ... D_{1,C}
      :
      D_{C,1} ... D_{C,C}
      c_{1,1} ... c_{1,N}
      :
      c_{N,1} ... c_{N,N}
attempt: from itertools import permutations
  
  
  def solve(p, query):
      # the cost of group's all color change to i
      group_a = [0] * (color + 1)
      group_b = [0] * (color + 1)
      group_c = [0] * (color + 1)
  
      for c_a, c_b, c_c in zip(mod_1, mod_2, mod_0):
          for i in range(1, color + 1):
              group_a[i] += d[c_a][i]
              group_b[i] += d[c_b][i]
              group_c[i] += d[c_c][i]
  
      top_3_group_a = sorted(
          list(zip(list(range(color + 1)), group_a[1:]))[:3], key=lambda x: x[1]
      )
      top_3_group_b = sorted(
          list(zip(list(range(color + 1)), group_b[1:]))[:3], key=lambda x: x[1]
      )
      top_3_group_c = sorted(
          list(zip(list(range(color + 1)), group_c[1:]))[:3], key=lambda x: x[1]
      )
      ans = float("inf")
      for i in top_3_group_a:
          for j in top_3_group_b:
              if i[0] != j[0]:
                  for k in top_3_group_c:
                      if i[0] != k[0] and j[0] != k[0]:
                          ans = min(ans, i[1] + j[1] + k[1])
      return ans
  
  
  if __name__ == "__main__":
      n, color = map(int, input().split())
      c, d = [], []
      d.append([0] * (color + 1))
  
      for _ in range(color):
          d.append([0] + list(map(int, input().split())))
  
      _c = []
      for _ in range(n):
          _c.append(list(map(int, input().split())))
  
      mod_1, mod_2, mod_0 = [], [], []
  
      for i in range(n):
          for j in range(n):
              if (i + j) % 3 == 1:
                  mod_1.append(_c[i][j])
              elif (i + j) % 3 == 2:
                  mod_2.append(_c[i][j])
              else:
                  mod_0.append(_c[i][j])
  
      if n % 3 == 1:
          mod_1.append(0)
          mod_2.append(0)
      if n % 3 == 2:
          mod_0.append(0)
          mod_2.append(0)
  
      print(solve(c, d))
  
problem_description: Statement
  
  There is a grid with N rows and N columns of squares. Let (i,j) be the square
  at the i-th row from the top and the j-th column from the left.
  
  These squares have to be painted in one of the C colors from Color 1 to Color
  C. Initially, (i,j) is painted in Color c_{i,j}.
  
  We say the grid is a _good_ grid when the following condition is met for all
  i,j,x,y satisfying 1 \leq i,j,x,y \leq N:
  
    * If (i+j) \% 3=(x+y) \% 3, the color of (i,j) and the color of (x,y) are the same.
    * If (i+j) \% 3 \neq (x+y) \% 3, the color of (i,j) and the color of (x,y) are different.
  
  Here, X \% Y represents X modulo Y.
  
  We will repaint zero or more squares so that the grid will be a good grid.
  
  For a square, the _wrongness_ when the color of the square is X before
  repainting and Y after repainting, is D_{X,Y}.
  
  Find the minimum possible sum of the wrongness of all the squares.
samples: [{"input": "2 3\n    0 1 1\n    1 0 1\n    1 4 0\n    1 2\n    3 3", "output": "3\n    \n\n  * Repaint (1,1) to Color 2. The wrongness of (1,1) becomes D_{1,2}=1.\n  * Repaint (1,2) to Color 3. The wrongness of (1,2) becomes D_{2,3}=1.\n  * Repaint (2,2) to Color 1. The wrongness of (2,2) becomes D_{3,1}=1.\n\nIn this case, the sum of the wrongness of all the squares is 3.\n\nNote that D_{i,j} \\neq D_{j,i} is possible.\n\n* * *"}, {"input": "4 3\n    0 12 71\n    81 0 53\n    14 92 0\n    1 1 2 1\n    2 1 1 2\n    2 2 1 3\n    1 1 2 2", "output": "428"}]