#119div2 D

//本题大意:在一个城市图中.有N个车子.每个车对于该图的边的值不一样.在每次询问中.询问从A->B最多替换K次车的最短路
//         替换可以在任何城市进行.
//解题思路:最开始想的是dp[i][j][k][l] = min(dp[i-1][1->carnum][k][s] + car[s][l]).i是第几次替换.j是使用第
//         j个车进行替换.k是起点.l是终点.这样的复杂度是k(1000)*n(60)^5.很大.
//         后来发现没必要去记录在第i次对第j个车进行替换..只需要记录第i次进行替换的时候k->l的最短路即可.
//         因为每一次进行替换.不需要去记录在k->l过程中并不是最有替换选择的那些车.只需要选择一个车可以使得
//         k->l的路径是最优的就可以了..
//         那么动态转移方程就是dp[i][k][l] = min(dp[i][k][l] , dp[i-1][k][s] + car[s][l]).枚举每个中间点就可以了.
//         最后.k是1000. 但是因为城市(点)只有60个.所以.并不需要在k>60的时候把每个k都枚举一遍..
//         因为对于60个点的图中.不论是寻找哪两个点的最短路.一定这条路的边最多不会超过点的数目..
//         所以k>60以后的结果和k=60的结果是一样的.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<math.h>
#include<vector>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
const int mn = 66;
int map[mn][mn],city,m,r,d[mn],cas[mn][mn],dp[mn][mn][mn];
bool vis[mn];
int main()
{
    while(scanf("%d%d%d",&city,&m,&r) != EOF)
    {
        memset(cas,0x3f3f3f3f,sizeof(cas));
        for(int i = 1 ; i <= city ; i++)cas[i][i] = 0;
        for(int i = 1 ; i <= m ; i++)
        {
            for(int j = 1 ; j <= city ; j++)
            {
                for(int k = 1 ; k <= city ; k++)
                    scanf("%d",&map[j][k]);
            }
            for(int j = 1 ; j <= city ; j++)
            {
                memset(vis,0,sizeof(vis));
                memset(d,0x3f3f3f3f,sizeof(d));
                vis[j] = 1;
                d[j] = 0;
                int t = j;
                for(int s = 1 ; s < city ; s++)
                {
                    for(int k = 1 ; k <= city ; k++)
                      if(!vis[k] && d[t] + map[t][k] < d[k])
                        d[k] = map[t][k] + d[t];
                    int ps = 0x3f3f3f3f;
                    for(int k = 1 ; k <= city ; k++)
                    if(ps > d[k] && !vis[k])
                    {
                        ps = d[k];
                        t = k;
                    }
                    if(ps == 0x3f3f3f3f)break;
                    vis[t] = 1;
                    cas[j][t] = min(cas[j][t] , ps);
                }
            }
        }//printf("%d\n",cas[1][4]);
        memset(dp,0x3f3f3f3f,sizeof(dp));
        for(int i = 1 ; i <= city ; i++)
        {
            for(int j = 1 ; j <= city ; j++)
            {
                for(int k = 1 ; k <= city ; k++)
                {
                    if(i == 1)
                    {
                        dp[i][j][k] = cas[j][k];
                    }
                    else
                    {
                        for(int l = 1 ; l <= city ; l++)
                          dp[i][j][k] = min(dp[i-1][j][l] + cas[l][k],dp[i][j][k]);
                    }
                }
            }
        }
        for(int i = 1 ; i <= r ; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(c <= city - 1)
            printf("%d\n",dp[c+1][a][b]);
            else printf("%d\n",dp[city][a][b]);
        }
    }
}