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: x = input().split()
  n = int(x[0])
  c = int(x[1])
  dlist = [0] * (c * c)
  clist = [0] * (n * n)
  cost1 = []
  cost2 = []
  cost3 = []
  x = 0
  for i in range(c):
      a = input().split()
      for i in a:
          dlist[x] = i
          x = x + 1
  x = 0
  for i in range(n):
      a = input().split()
      for i in a:
          clist[x] = i
          x += 1
  x = 0
  list1 = []
  list2 = []
  list3 = []
  y = 0
  yy = 0
  while y < n:
      while yy < n:
          if (y + yy) % 3 == 0:
              list1.append(clist[y * n + yy])
          elif (y + yy) % 3 == 1:
              list2.append(clist[y * n + yy])
          elif (y + yy) % 3 == 2:
              list3.append(clist[y * n + yy])
          yy = yy + 1
      y = y + 1
      yy = 0
  
  y = 1
  y2 = 1
  y3 = 1
  mini = 99999999999999999999
  while y <= c:
      cost = 0
      for i in list1:
          if i != y:
              cost = cost + dlist[(i - 1) * c + y - 1]
      cost1.append(cost)
      y = y + 1
  while y2 <= c:
      cost = 0
      for i in list2:
          if i != y2:
              cost = cost + dlist[(i - 1) * c + y2 - 1]
      cost2.append(cost)
      y2 = y2 + 1
  while y3 <= c:
      cost = 0
      for i in list3:
          if i != y3:
              cost = cost + dlist[(i - 1) * c + y3 - 1]
      cost3.append(cost)
      y3 = y3 + 1
  x = 1
  x2 = 2
  x3 = 3
  while x <= c:
      while x2 <= c:
          if x2 == x:
              x2 += 1
          if x2 > c:
              break
          while x3 <= c:
              if x3 == x or x3 == x2:
                  x3 += 1
              if x3 == x or x3 == x2:
                  x3 += 1
              if x3 > c:
                  break
  
              mini = min(mini, cost1[x - 1] + cost2[x2 - 1] + cost3[x3 - 1])
              x3 += 1
          x2 += 1
          x3 = 1
      x += 1
      x2 = 1
      x3 = 1
  
  print(mini)
  
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"}]