#include<iostream>

#include<cstdio>

#include<cstring>

#include<queue>

using namespace std;

const int N=1e4+;

int n,m,q,hd[N],xnt=,g[N],len[N],cnt,dep[N],f[N][];

int dis[N],ds[N],fa[N],dfn[N],tim;

bool vis[N];

struct Ed{

  int nxt,to,w;bool del;

  Ed(int n=,int t=,int w=):nxt(n),to(t),w(w) {del=;}

}ed[N<<];

int tabs(int k){return k<?-k:k;}

void add(int x,int y,int z)

{

  ed[++xnt]=Ed(hd[x],y,z);hd[x]=xnt;

}

void spfa()

{

  memset(dis,0x3f,sizeof dis);dis[]=;

  queue<int> q;q.push();vis[]=;

  while(q.size())

    {

      int k=q.front();q.pop();vis[k]=;//don't forget visk=0!!

      for(int i=hd[k],v;i;i=ed[i].nxt)

    if(dis[v=ed[i].to]>dis[k]+ed[i].w)

      {

        dis[v]=dis[k]+ed[i].w;

        if(!vis[v])vis[v]=,q.push(v);

      }

    }

}

void circle(int y,int e)

{

  int x=ed[e].to;//!

  len[++cnt]=ed[e].w;g[y]=cnt;

  ed[e].del=ed[e^].del=;//don't forget del!

  add(x,y,);add(y,x,);// edw has no limit--only for bfs the dep

                          // edw is guaranteed by ds[]

  for(e=fa[y];(y=ed[e^].to)!=x;e=fa[y])

    {

      len[cnt]+=ed[e].w;g[y]=cnt;ed[e].del=ed[e^].del=;

      add(x,y,);add(y,x,);

    }

  len[cnt]+=ed[e].w;g[x]=cnt;

}

void dfs(int cr)

{

  dfn[cr]=++tim;

  for(int i=hd[cr],v;i;i=ed[i].nxt)

    if(!dfn[v=ed[i].to])

      {

    fa[v]=i;ds[v]=ds[cr]+ed[i].w;dfs(v);

      }

    else if(i!=(fa[cr]^)&&dfn[v]<dfn[cr])circle(cr,i);//cr!!!

}

void bfs()

{

  queue<int> q;q.push();dep[]=;

  while(q.size())

    {

      int k=q.front();q.pop();

      for(int i=hd[k],v;i;i=ed[i].nxt)

    if(!ed[i].del&&!dep[v=ed[i].to])

      {

        dep[v]=dep[k]+;q.push(v);

        f[v][]=k;

        for(int j=;j<=;j++)//j not i

          {

        f[v][j]=f[f[v][j-]][j-];

          }

      }

    }

}

int lca(int x,int y)

{

  if(dep[x]<dep[y])swap(x,y);

  int p=x,q=y;

  for(int i=;i>=;i--)

    if(dep[f[x][i]]>=dep[y])x=f[x][i];

  if(x==y)return dis[p]-dis[q];

  for(int i=;i>=;i--)

    if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];

  if(g[x]!=g[y]||(!g[x]&&!g[y]))return dis[p]+dis[q]-*dis[f[x][]];//&& !g[x]&&!g[y]!!!

  int k=tabs(ds[x]-ds[y]);

  return dis[p]-dis[x]+dis[q]-dis[y]+min(k,len[g[x]]-k);

  // include p&q in different circle but x&y in the same circle;

  //because the dep of nodes in the same circle are almost the same

}

int main()

{

  scanf("%d%d%d",&n,&m,&q);int x,y,z;

  for(int i=;i<=m;i++)

    {

      scanf("%d%d%d",&x,&y,&z);

      add(x,y,z);add(y,x,z);

    }

  spfa();

  dfs();

  bfs();

  for(int i=;i<=q;i++)

    {

      scanf("%d%d",&x,&y);

      printf("%d\n",lca(x,y));

    }

  return ;

}