Connect them(最小生成树+输出路径)

Connect them

---

Time Limit: 1 Second       Memory Limit: 32768 KB

---

You have n computers numbered from 1 to n and you want to connect them to make a small local area network (LAN). All connections are two-way (that is connecting computers iand j is the same as connecting computers j and i). The cost of connecting computer i and computer j is c_ij. You cannot connect some pairs of computers due to some particular reasons. You want to connect them so that every computer connects to any other one directly or indirectly and you also want to pay as little as possible.

Given n and each c_ij , find the cheapest way to connect computers.

Input

There are multiple test cases. The first line of input contains an integer T (T <= 100), indicating the number of test cases. Then T test cases follow.

The first line of each test case contains an integer n (1 < n <= 100). Then n lines follow, each of which contains n integers separated by a space. The j-th integer of the i-th line in these n lines is c_ij, indicating the cost of connecting computers i and j (c_ij = 0 means that you cannot connect them). 0 <= c_ij <= 60000, c_ij = c_ji, c_ii = 0, 1 <= i, j <= n.

Output

For each test case, if you can connect the computers together, output the method in in the following fomat:

i₁ j₁ i₁ j₁ ......

where i_k i_k (k >= 1) are the identification numbers of the two computers to be connected. All the integers must be separated by a space and there must be no extra space at the end of the line. If there are multiple solutions, output the lexicographically smallest one (see hints for the definition of "lexicography small") If you cannot connect them, just output "-1" in the line.

Sample Input
2
3
0 2 3
2 0 5
3 5 0
2
0 0
0 0


Sample Output
1 2 1 3
-1

Hints:
A solution  A is a line of  p integers:  a₁,  a₂, ... a_p.
Another solution  B different from  A is a line of  q integers:  b₁,  b₂, ... b_q.
A is  lexicographically smaller than  B if and only if:
(1) there exists a positive integer  r ( r <=  p,  r <=  q) such that  a_i =  b_i for all 0 <  i <  r and  a_r <  b_r 
OR

(2) p < q and a_i = b_i for all 0 < i <= p

题意：有n台电脑，给一个n*n的矩阵，矩阵的值描述连接第i台电脑与第j台电脑的花费（i，j分别代表行与列），其中若值为0则认为两台电脑无法直接连接，求最少花费使得n台电脑都能连接（其实就是求最小生成树）。按照最小字典序输出连接路径。

分析：要输出路径所以用kursual求最小生成树，顺便记录路径，在对边的权值排序时要注意，若边权值相同，要选编号小的点的边。

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
struct node
{
    int x,y,wei;
}e[105*105];

struct no
{
    int a,b;
}l[105*105];

int t,n,m,sum;
int pre[105*105];

int cmp(node a,node b)
{
    if(a.wei!=b.wei)
        return a.wei<b.wei;
    else if(a.x!=b.x)//权值相同选编号小的边
        return a.x<b.x;
    else
        return a.y<b.y;
}

int cmp1(no x,no y)//最后对记录的路径排序，求字典序最小的。
{
    if(x.a!=y.a)
        return x.a<y.a;
    return x.b<y.b;
}

int find(int x)
{
    return pre[x]==x?x:pre[x]=find(pre[x]);
}

int Merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);

    if(fx!=fy)
    {
        pre[fx]=fy;
        return 1;
    }

    return 0;
}

int main()
{
    int i,j,t,cou;
    int sum=0,k=0;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);

        cou=0;
        sum=0;

        for(i=0;i<105*105;i++)
            pre[i]=i;

        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                int w;
                scanf("%d",&w);
                if(j<=i)//j<=i的情况前面已经存过了
                    continue;
                if(w==0)//w==0代表无法直接连接，即没有这条边。
                    continue;

                e[cou].x=i;
                e[cou].y=j;
                e[cou].wei=w;
                cou++;
            }
        }

        sort(e,e+cou,cmp);

        for(i=0;i<cou;i++)
        {
            if(Merge(e[i].x,e[i].y))
            {
                l[sum].a=e[i].x;//记录路径
                l[sum].b=e[i].y;
                sum++;
            }
        }

        if(sum!=n-1)
        {
            printf("-1\n");
            continue;
        }
        else
        {
            sort(l,l+sum,cmp1);//按最小字典序输出。

            for(i=0;i<sum-1;i++)
                printf("%d %d ",l[i].a,l[i].b);

            printf("%d %d\n",l[sum-1].a,l[sum-1].b);
        }
    }
    return 0;
}