#include <stdio.h>
#define SQR_LEN(x, y) ((x)*(x))+((y)*(y))

float SQRT(float val)
{
    float total = 1;
    for(int i = 0; i< 8; i++)
    {
        total = (total+(val/total))/2;
    }

    return total;
}

int main()
{
    int num_case;
    float total_length[50];


    //준비 과정
    scanf("%d", &num_case);
    for(int i = 0; i < num_case; i++) //테스트 케이스(50번 이하) 루프
    {
        int num_build, num_cable_installed;
        int p_build[500][2]; //건물의 좌표
        int temp[3];
        char graph_build[500][500] = { 0, };
        //0: nonconnected c: connected a: already connected
        bool connected_build[500] = { 0, };


        //첫 줄은 건물 개수(500개 이하)와 설치된 케이블 개수(2000개 이하)
        scanf("%d %d", &num_build, &num_cable_installed);

        //건물들의 x좌표
        for(int j = 0; j < num_build; j++)
        {
            scanf("%d ", &p_build[j][0]);
        }
        //건물들의 y좌표(좌표는 전부 1000이하)
        for(int j = 0; j < num_build; j++)
        {
            scanf("%d ", &p_build[j][1]);
        }
        //설치된 케이블 하나당 연결된 건물...
        for(int j = 0; j < num_cable_installed; j++)
        {
            scanf("%d %d", &temp[0], &temp[1]);
            graph_build[temp[0]][temp[1]] = graph_build[temp[1]][temp[0]] = 'a';
        }

        //해결 과정
            //프림 알고리즘 응용
            //출발점 하나를 지정한다.
            //만약 지금 이어진 노드가 이미 이어진 케이블이 있으면 그 노드도 연결시킨다.
            //기본적으론 지나간 점들에 이어진 에지 중 최솟값을 다음 이어진 노드로 정한다.

            //출발점은 건물 0번
            //가장 큰 루프는 전체 건물이 케이블로 이어져 있을 때 탈출

                //연결된 노드가 새로 생기면 루프는 지금 노드에서 이미 설치된 케이블이 있는지 확인한다.
                    //있으면 자동으로 트리에 연결한다.
                //루프는 지금 지나간 모든 노드에서 가장 최소 에지를 찾는다
                    //단 시작노드와 끝노드가 전부 지나간 노드인 경우는 제외한다.(트리에 속해있으므로)
                //새로 이어질 최소 에지는 총 설치해야할 케이블 길이에 추가한다.

        connected_build[0] = true; //출발점 지정
        total_length[i] = 0;
        while(true)
        {
            //연결된 노드 중 이미 설치된 케이블이 있는지 확인하는 루프
            while(true)
            {
                bool is_end = true;
                for(int j = 0; j < num_build; j++)
                {
                    for(int k = j; k < num_build; k++)
                    {
                        if((connected_build[j] || connected_build[k]) && graph_build[j][k] == 'a')
                        {
                            graph_build[j][k] = 'c';
                            connected_build[k] = connected_build[j] = true;
                            is_end = false;
                            break;
                        } 
                    }
                }

                if(is_end)
                    break;
            }

            //모든 건물이 연결되어 있는가
            bool is_all_connect = true;

            for(int j = 0; j < num_build; j++)
            {
                if(!connected_build[j])
                {
                    is_all_connect = false;
                    break;
                }
            }

            if(is_all_connect)
                break;  //해결 루프 탈출
            else
            {
                //최소 에지 찾기

                temp[2] = 0; 
                //temp: [0] = 최소 에지의 시작노드, [1] = 최소 에지의 끝노드, [2] = 최소 에지의 길이의 제곱

                for(int j = 0; j < num_build; j++)
                {//이어진 노드 찾기
                    for(int k = j; k < num_build; k++)
                    {
                        if(connected_build[j] || connected_build[k])
                        {
                            if(connected_build[j] && connected_build[k])   //이미 연결된 노드는 제외
                                continue;

                            if(!temp[2])//temp값 초기화
                            {
                                temp[0] = j;
                                temp[1] = k;
                                temp[2] = SQR_LEN(p_build[k][0] - p_build[j][0], p_build[k][1] - p_build[j][1]);
                                continue;
                            }

                            if(temp[2] > SQR_LEN(p_build[k][0] - p_build[j][0], p_build[k][1] - p_build[j][1]))
                            {
                                temp[0] = j;
                                temp[1] = k;
                                temp[2] = SQR_LEN(p_build[k][0] - p_build[j][0], p_build[k][1] - p_build[j][1]);
                            }
                        }
                    }
                }

                //최소 에지에 케이블 연결
                graph_build[temp[0]][temp[1]] = 'c';
                connected_build[temp[0]] = connected_build[temp[1]] = true;
                total_length[i] += SQRT((float)temp[2]);
            }
        }

        //해결 과정 end

    }

    //출력: 각 케이스 당 설치할 케이블들의 최소 합
    for(int i = 0; i < num_case; i++)
    {
        printf("%.12f\n", total_length[i]);
    }

    return 0;
}