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: #include <iostream>
  #include <vector>
  #include <algorithm>
  #include <utility>
  #include <string>
  #include <queue>
  #include <stack>
  
  using namespace std;
  
  typedef long long int ll;
  typedef pair<int, int> Pii;
  
  const ll mod = 1000000007;
  
  int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
  
    int n, c;
    cin >> n >> c;
    vector<vector<int> > d(c, vector<int>(c));
    for (auto &x: d) {
      for (auto &y: x) cin >> y;
    }
    vector<vector<int> > a(n, vector<int>(n));
    for (auto &x: a) {
      for (auto &y: x) {
        cin >> y;
        y--;
      }
    }
  
    vector<int> c0Count(c), c1Count(c), c2Count(c);
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        if ((i + j) % 3 == 0) c0Count[a[i][j]]++;
        else if ((i + j) % 3 == 1) c1Count[a[i][j]]++;
        else if ((i + j) % 3 == 2) c2Count[a[i][j]]++;
      }
    }
  
    int ans = 1000000007;
    for (int c0 = 0; c0 < c; c0++) {
      for (int c1 = 0; c1 < c; c1++) {
        if (c0 == c1) continue;
        for (int c2 = 0; c2 < c; c2++) {
          if (c0 == c2 || c1 == c2) continue;
          int cost = 0;
          for (int i = 0; i < c; i++) {
            cost += d[i][c0] * c0Count[i];
            cost += d[i][c1] * c1Count[i];
            cost += d[i][c2] * c2Count[i];
          }
          if (cost < ans) ans = cost;
        }
      }
    }
  
    cout << ans << endl;
  
    return 0;
  }
  
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"}]