#include<fstream>
#include<cmath>
#include<vector>
#include<algorithm>
#include<cstdlib>
#include<ctime>
#include<limits>
using namespace std;

ifstream fin("sorting.in");
ofstream fout("sorting.out");

const int N=402, INF=numeric_limits<int>::max();

int n, p[N], backup[N], typeP, typeV;
int costP[N][N], costV[N][N];

int getRandom (int i)
{
    return rand()%i;
}

void init()
{
    fin>>n;
    for(int i=1; i<=n; ++i)
    {
        fin>>p[i];
        backup[i]=p[i];
    }

    fin>>typeP;
    for(int i=1; i<=n; ++i)
    {
        for(int j=1; j<=n; ++j)
        {
            fin>>costP[i][j];
        }
    }

    fin>>typeV;
    for(int i=1; i<=n; ++i)
    {
        for(int j=1; j<=n; ++j)
        {
            fin>>costV[i][j];
        }
    }
}

void print(int m[])
{
    for(int i=1; i<=n; ++i)
        fout<<m[i]<<" ";

    fout<<endl;
}

int counter, bestCounter, result, bestResult=INF;
vector<pair<int, int> > answer, bestAnswer;

void restore()
{
    answer.clear();
    for(int i=1; i<=n; ++i)
        p[i]=backup[i];
}

void selectionSortMin()
{
    counter=0, result=0;
    int min_idx;

    for(int i=1; i<n; ++i)
    {
        min_idx=i;

        for(int j=i+1; j<=n; ++j)
            if(p[j]<p[min_idx])
                min_idx = j;

        swap(p[min_idx], p[i]);
        if(min_idx!=i)
        {
            answer.push_back(make_pair(min_idx, i));
            counter++;
            result+=costP[min_idx][i]+costV[p[min_idx]][p[i]];
        }
        //fout<<min_idx<<" "<<i<<" "<<result<<" "<<counter<<endl;
    }

    if(result<bestResult)
    {
        bestResult=result;
        bestCounter=counter;
        bestAnswer=answer;
    }
    //fout<<result<<endl;
    restore();
}

void selectionSortMax()
{
    counter=0, result=0;
    int max_idx;

    for(int i=n; i>1; i--)
    {
        max_idx=i;

        for(int j=i-1; j>=1; j--)
            if(p[j]>p[max_idx])
                max_idx=j;

        swap(p[max_idx], p[i]);
        if(max_idx!=i)
        {
            answer.push_back(make_pair(max_idx, i));
            counter++;
            result+=costP[max_idx][i]+costV[p[max_idx]][p[i]];
        }
        //fout<<max_idx<<" "<<i<<" "<<result<<" "<<counter<<endl;
    }

    if(result<bestResult)
    {
        bestResult=result;
        bestCounter=counter;
        bestAnswer=answer;
    }
    //fout<<result<<endl;
    restore();
}

void selectionSort()
{
    counter=0, result=0;
    int max_idx, min_idx;

    for(int i=1, j=n; i<j; ++i, j--)
    {
        min_idx=i;
        max_idx=j;
        int maxNum=0, minNum=p[i];

        for(int k=i; k<=j; k++)
        {
            if(p[k]>maxNum)
            {
                max_idx=k;
                maxNum=p[k];
            }
            else if(p[k]<minNum)
            {
                min_idx=k;
                minNum=p[k];
            }
        }

        swap(p[min_idx], p[i]);
        if(min_idx!=i)
        {
            answer.push_back(make_pair(min_idx, i));
            counter++;
            result+=costP[min_idx][i]+costV[p[min_idx]][p[i]];
        }

        if (p[min_idx] == maxNum)
            max_idx=min_idx;

        swap(p[j], p[max_idx]);
        if(max_idx!=j)
        {
            answer.push_back(make_pair(max_idx, j));
            counter++;
            result+=costP[max_idx][j]+costV[p[max_idx]][p[j]];
        }

        //fout<<max_idx<<" "<<j<<" "<<result<<" "<<counter<<endl;
        //fout<<min_idx<<" "<<i<<" "<<result<<" "<<counter<<endl;
    }

    if(result<bestResult)
    {
        bestResult=result;
        bestCounter=counter;
        bestAnswer=answer;
    }
    //fout<<result<<endl;
    restore();
}

void algorithm1()
{
    counter=0, result=0;

    int sorted=0;
    while(sorted<n)
    {
        int R, minR=INF, num1, num2;
        for(int i=1; i<=n; ++i)
        {
            if(p[i]==i) continue;
            int j=p[i];
            R=costP[i][j]+costV[p[i]][p[j]];
            if(R<minR)
            {
                minR=R;
                num1=i;
                num2=j;
            }
        }
        if(minR==INF) break;
        swap(p[num1], p[num2]);
        if(num1!=num2)
        {
            answer.push_back(make_pair(num1, num2));
            counter++;
            result+=minR;
            if(p[num1]==num1) sorted++;
            if(p[num2]==num2) sorted++;
        }
    }
    if(result<bestResult)
    {
        bestResult=result;
        bestCounter=counter;
        bestAnswer=answer;
    }
    //fout<<result<<endl;
    restore();
}

void algorithm2()
{
    counter=0, result=0;

    int sorted=0;
    while(sorted<n)
    {
        int R, minR=INF, num1, num2, useThird=false;
        for(int i=1; i<=n; ++i)
        {
            if(p[i]==i) continue;
            int j=p[i];

            R=costP[i][j]+costV[p[i]][p[j]];
            if(R<minR)
            {
                minR=R;
                num1=i;
                num2=j;
            }
        }

        int third;

        for(int i=1; i<=n; ++i)
        {
            if(p[i]==i) continue;
            int j=p[i];

            for(int k=1; k<=n; ++k)
            {
                if(p[k]==k) continue;
                if(k==i || k==j) continue;

                R=costP[i][k]+costV[p[i]][p[k]];
                R+=costP[k][j]+costV[p[i]][p[j]];

                if(R<minR)
                {
                    minR=R;
                    num1=i;
                    num2=j;
                    third=k;
                    useThird=true;
                }
            }
        }

        if(minR==INF) break;
        if(!useThird)
        {
            swap(p[num1], p[num2]);
            if(num1!=num2)
            {
                answer.push_back(make_pair(num1, num2));
                counter++;
                result+=costP[num1][num2]+costV[p[num1]][p[num2]];
                if(p[num1]==num1) sorted++;
                if(p[num2]==num2) sorted++;
            }
        }
        else
        {
            counter+=2;
            result+=minR;

            answer.push_back(make_pair(num1, third));
            answer.push_back(make_pair(third, num2));

            swap(p[num1], p[third]);
            swap(p[third], p[num2]);

            if(p[num1]==num1) sorted++;
            if(p[num2]==num2) sorted++;
            if(p[third]==third) sorted++;
        }
    }
    if(result<bestResult)
    {
        bestResult=result;
        bestCounter=counter;
        bestAnswer=answer;
    }
    //fout<<result<<endl;
    //print(p);
    restore();
}

void algorithm3()
{
    counter=0, result=0;

    int sorted=0;
    while(sorted<n)
    {
        int R, minR=INF, num1, num2, useThird=false, useFourth=false;
        for(int i=1; i<=n; ++i)
        {
            if(p[i]==i) continue;
            int j=p[i];

            R=costP[i][j]+costV[p[i]][p[j]];
            if(R<minR)
            {
                minR=R;
                num1=i;
                num2=j;
            }
        }

        int third;
        for(int i=1; i<=n; ++i)
        {
            if(p[i]==i) continue;
            int j=p[i];

            for(int k=1; k<=n; ++k)
            {
                if(p[k]==k) continue;
                if(k==i || k==j) continue;

                R=costP[i][k]+costV[p[i]][p[k]];
                R+=costP[k][j]+costV[p[i]][p[j]];

                if(R<minR)
                {
                    minR=R;
                    num1=i;
                    num2=j;
                    third=k;
                    useThird=true;
                }
            }
        }

        int fourth;
        for(int i=1; i<=n; ++i)
        {
            if(p[i]==i) continue;
            int j=p[i];

            for(int k=1; k<=n; ++k)
            {
                if(p[k]==k) continue;
                if(k==i || k==j) continue;

                int q=rand()%400+1;
                if(p[q]==q) continue;
                if(q==i || q==j || q==k) continue;

                R=costP[i][k]+costV[p[i]][p[k]];
                R+=costP[k][q]+costV[p[i]][p[q]];
                R+=costP[q][j]+costV[p[i]][p[j]];

                if(R<minR)
                {
                    minR=R;
                    num1=i;
                    num2=j;
                    third=k;
                    fourth=q;
                    useThird=true;
                    useFourth=true;
                }

            }
        }

        if(minR==INF) break;
        if(!useThird)
        {
            swap(p[num1], p[num2]);
            if(num1!=num2)
            {
                answer.push_back(make_pair(num1, num2));
                counter++;
                result+=costP[num1][num2]+costV[p[num1]][p[num2]];
                if(p[num1]==num1) sorted++;
                if(p[num2]==num2) sorted++;
            }
        }
        else if(!useFourth)
        {
            counter+=2;
            result+=minR;

            answer.push_back(make_pair(num1, third));
            answer.push_back(make_pair(third, num2));

            swap(p[num1], p[third]);
            swap(p[third], p[num2]);

            if(p[num1]==num1) sorted++;
            if(p[num2]==num2) sorted++;
            if(p[third]==third) sorted++;
        }
        else
        {
            counter+=3;
            result+=minR;

            answer.push_back(make_pair(num1, third));
            answer.push_back(make_pair(third, fourth));
            answer.push_back(make_pair(fourth, num2));

            swap(p[num1], p[third]);
            swap(p[third], p[fourth]);
            swap(p[fourth], p[num2]);

            if(p[num1]==num1) sorted++;
            if(p[num2]==num2) sorted++;
            if(p[third]==third) sorted++;
            if(p[fourth]==fourth) sorted++;
        }
    }
    if(result<bestResult)
    {
        bestResult=result;
        bestCounter=counter;
        bestAnswer=answer;
    }
    //fout<<result<<endl;
    //print(p);
    restore();
}

int main()
{
    srand ( unsigned ( std::time(0) ) );
    init();

    selectionSort();
    selectionSortMin();
    selectionSortMax();
    algorithm1();
    algorithm2();
    algorithm3();

    fout<<bestCounter<<endl;
    for(int i=0; i<bestCounter; ++i)
        fout<<bestAnswer[i].first<<" "<<bestAnswer[i].second<<endl;

    fin.close();
    fout.close();
    return 0;
}