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: # -*- coding: utf-8 -*-
  import bisect
  import heapq
  import math
  import random
  import sys
  from collections import Counter, defaultdict
  from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
  from functools import lru_cache, reduce
  from itertools import combinations, combinations_with_replacement, product, permutations
  
  sys.setrecursionlimit(50000)
  
  
  def read_int():
      return int(input())
  
  
  def read_int_n():
      return list(map(int, input().split()))
  
  
  def read_float():
      return float(input())
  
  
  def read_float_n():
      return list(map(float, input().split()))
  
  
  def read_str():
      return input()
  
  
  def read_str_n():
      return list(map(str, input().split()))
  
  
  def error_print(*args):
      print(*args, file=sys.stderr)
  
  
  def mt(f):
      import time
  
      def wrap(*args, **kwargs):
          s = time.time()
          ret = f(*args, **kwargs)
          e = time.time()
  
          error_print(e - s, "sec")
          return ret
  
      return wrap
  
  
  @mt
  def slv(N, CN, D, C):
      # for d in D:
      #     error_print(d)
      # for c in C:
      #     error_print(c)
  
      T = [[], [], []]
      for i, r in enumerate(C):
          for j, c in enumerate(r):
              T[(i + j) % 3].append((i, j, c))
      TC = [[], [], []]
      for j, t in enumerate(T):
          for i in range(CN):
              s = 0
              for c in t:
                  s += D[c[2] - 1][i - 1]
              TC[j].append(s)
  
      ans = sys.maxsize
      for i, j, k in permutations(range(CN), 3):
          ans = min(ans, sum([TC[0][i], TC[1][j], TC[2][k]]))
  
      return ans
  
  
  def main():
  
      N, CN = read_int_n()
      D = [read_int_n() for _ in range(CN)]
      C = [read_int_n() for _ in range(N)]
      print(slv(N, CN, D, C))
  
  
  if __name__ == "__main__":
      main()
  
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"}]