#!usr/bin/env python3

from collections import defaultdict

from collections import deque

from heapq import heappush, heappop

import sys

import math

import bisect

import random

def LI(): return list(map(int, sys.stdin.readline().split()))

def I(): return int(sys.stdin.readline())

def LS():return list(map(list, sys.stdin.readline().split()))

def S(): return list(sys.stdin.readline())[:-1]

def IR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = I()

    return l

def LIR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = LI()

    return l

def SR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = S()

    return l

def LSR(n):

    l = [None for i in range(n)]

    for i in range(n):l[i] = SR()

    return l

mod = 1000000007



#A

def A():

    return



#B

def B():

    return



#C

def C():

    n = I()

    ans = float("inf")

    for i in range(n+1):

        m = 0

        k = i

        while k > 0:

            m += k%6

            k //= 6

        k = n-i

        while k > 0:

            m += k%9

            k //= 9

        ans = min(ans,m)

    print(ans)

#D

def D():

    n,C = LI()

    f = LIR(C)

    c = LIR(n)

    d = [defaultdict(int) for i in range(3)]

    for i in range(n):

        for j in range(n):

            d[(i+j+2)%3][c[i][j]-1] += 1

    ans = float("inf")

    for i in range(C):

        for j in range(C):

            if i != j:

                for k in range(C):

                    if k != i and k != j:

                        m = 0

                        for a in list(d[0].keys()):

                            m += d[0][a]*f[a][i]

                        for a in list(d[1].keys()):

                            m += d[1][a]*f[a][j]

                        for a in list(d[2].keys()):

                            m += d[2][a]*f[a][k]

                        ans = min(ans,m)

    print(ans)





#E

def E():

    return



#F

def F():

    return



#G

def G():

    return



#H

def H():

    return



#Solve

if __name__ == "__main__":

    D()

#!usr/bin/env python3

from collections import defaultdict, deque

from heapq import heappush, heappop

from itertools import permutations, accumulate

import sys

import math

import bisect

def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]

def I(): return int(sys.stdin.buffer.readline())

def LS():return [list(x) for x in sys.stdin.readline().split()]

def S():

    res = list(sys.stdin.readline())

    if res[-1] == "\n":

        return res[:-1]

    return res

def IR(n):

    return [I() for i in range(n)]

def LIR(n):

    return [LI() for i in range(n)]

def SR(n):

    return [S() for i in range(n)]

def LSR(n):

    return [LS() for i in range(n)]



sys.setrecursionlimit(1000000)

mod = 1000000007



def solve():

    n,C = LI()

    d = LIR(C)

    c = LIR(n)

    ans = 0

    s = [[0]*C for i in range(3)]

    for i in range(n):

        for j in range(n):

            s[(i+j)%3][c[i][j]-1] += 1

    ans = float("inf")

    for x in range(C):

        bx = 1<<x

        for y in range(C):

            if x == y:

                continue

            by = 1<<y

            for z in range(C):

                if z == x or z == y:

                    continue

                cost = 0

                for j in range(C):

                    cost += s[0][j]*d[j][x]

                    cost += s[1][j]*d[j][y]

                    cost += s[2][j]*d[j][z]

                if cost < ans:

                    ans = cost

    print(ans)

    return



#Solve

if __name__ == "__main__":

    solve()

#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random


def LI():
    return list(map(int, sys.stdin.readline().split()))


def I():
    return int(sys.stdin.readline())


def LS():
    return list(map(list, sys.stdin.readline().split()))


def S():
    return list(sys.stdin.readline())[:-1]


def IR(n):
    l = [None for i in range(n)]
    for i in range(n):
        l[i] = I()
    return l


def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):
        l[i] = LI()
    return l


def SR(n):
    l = [None for i in range(n)]
    for i in range(n):
        l[i] = S()
    return l


def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):
        l[i] = SR()
    return l


mod = 1000000007
# A
def A():
    return


# B
def B():
    return


# C
def C():
    n = I()
    ans = float("inf")
    for i in range(n + 1):
        m = 0
        k = i
        while k > 0:
            m += k % 6
            k //= 6
        k = n - i
        while k > 0:
            m += k % 9
            k //= 9
        ans = min(ans, m)
    print(ans)


# D
def D():
    n, C = LI()
    f = LIR(C)
    c = LIR(n)
    d = [defaultdict(int) for i in range(3)]
    for i in range(n):
        for j in range(n):
            d[(i + j + 2) % 3][c[i][j] - 1] += 1
    ans = float("inf")
    for i in range(C):
        for j in range(C):
            if i != j:
                for k in range(C):
                    if k != i and k != j:
                        m = 0
                        for a in list(d[0].keys()):
                            m += d[0][a] * f[a][i]
                        for a in list(d[1].keys()):
                            m += d[1][a] * f[a][j]
                        for a in list(d[2].keys()):
                            m += d[2][a] * f[a][k]
                        ans = min(ans, m)
    print(ans)


# E
def E():
    return


# F
def F():
    return


# G
def G():
    return


# H
def H():
    return


# Solve
if __name__ == "__main__":
    D()

#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect


def LI():
    return [int(x) for x in sys.stdin.buffer.readline().split()]


def I():
    return int(sys.stdin.buffer.readline())


def LS():
    return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    n, C = LI()
    d = LIR(C)
    c = LIR(n)
    ans = 0
    s = [[0] * C for i in range(3)]
    for i in range(n):
        for j in range(n):
            s[(i + j) % 3][c[i][j] - 1] += 1
    ans = float("inf")
    for x in range(C):
        bx = 1 << x
        for y in range(C):
            if x == y:
                continue
            by = 1 << y
            for z in range(C):
                if z == x or z == y:
                    continue
                cost = 0
                for j in range(C):
                    cost += s[0][j] * d[j][x]
                    cost += s[1][j] * d[j][y]
                    cost += s[2][j] * d[j][z]
                if cost < ans:
                    ans = cost
    print(ans)
    return


# Solve
if __name__ == "__main__":
    solve()

-from collections import defaultdict -from collections import deque +from collections import defaultdict, deque +from itertools import permutations, accumulate -import random -    return list(map(int, sys.stdin.readline().split())) +    return [int(x) for x in sys.stdin.buffer.readline().split()] -    return int(sys.stdin.readline()) +    return int(sys.stdin.buffer.readline()) -    return list(map(list, sys.stdin.readline().split())) +    return [list(x) for x in sys.stdin.readline().split()] -    return list(sys.stdin.readline())[:-1] +    res = list(sys.stdin.readline()) +    if res[-1] == "\n": +        return res[:-1] +    return res -    l = [None for i in range(n)] -    for i in range(n): -        l[i] = I() -    return l +    return [I() for i in range(n)] -    l = [None for i in range(n)] -    for i in range(n): -        l[i] = LI() -    return l +    return [LI() for i in range(n)] -    l = [None for i in range(n)] -    for i in range(n): -        l[i] = S() -    return l +    return [S() for i in range(n)] -    l = [None for i in range(n)] -    for i in range(n): -        l[i] = SR() -    return l +    return [LS() for i in range(n)] +sys.setrecursionlimit(1000000) -# A -def A(): -    return -# B -def B(): -    return - - -# C -def C(): -    n = I() -    ans = float("inf") -    for i in range(n + 1): -        m = 0 -        k = i -        while k > 0: -            m += k % 6 -            k //= 6 -        k = n - i -        while k > 0: -            m += k % 9 -            k //= 9 -        ans = min(ans, m) -    print(ans) - - -# D -def D(): +def solve(): -    f = LIR(C) +    d = LIR(C) -    d = [defaultdict(int) for i in range(3)] +    ans = 0 +    s = [[0] * C for i in range(3)] -            d[(i + j + 2) % 3][c[i][j] - 1] += 1 +            s[(i + j) % 3][c[i][j] - 1] += 1 -    for i in range(C): -        for j in range(C): -            if i != j: -                for k in range(C): -                    if k != i and k != j: -                        m = 0 -                        for a in list(d[0].keys()): -                            m += d[0][a] * f[a][i] -                        for a in list(d[1].keys()): -                            m += d[1][a] * f[a][j] -                        for a in list(d[2].keys()): -                            m += d[2][a] * f[a][k] -                        ans = min(ans, m) +    for x in range(C): +        bx = 1 << x +        for y in range(C): +            if x == y: +                continue +            by = 1 << y +            for z in range(C): +                if z == x or z == y: +                    continue +                cost = 0 +                for j in range(C): +                    cost += s[0][j] * d[j][x] +                    cost += s[1][j] * d[j][y] +                    cost += s[2][j] * d[j][z] +                if cost < ans: +                    ans = cost - - -# E -def E(): -    return - - -# F -def F(): -    return - - -# G -def G(): -    return - - -# H -def H(): -    D() +    solve()