EOJ1810 稀疏矩阵三元组转化

稀疏矩阵定义：

稀疏矩阵的原理是将矩阵中的非零元素用一个三元组来表示，然后保存在数组中，而那些零元素就不保存，从而达到压缩的目的。三元组(i, j, k)表示第i行第j列的值是k。所以一个矩阵就可以用一个数组来表示了，数组的每一个元素就是一个三元组，并且排列的顺序是，行号递增，如果行号相等，则列号递增。

如何实现稀疏矩阵的转置：

矩阵的转置就是将i行j列的元素放到j行i列。对于三元组我们要将(i, j, k)转变成(j, i, k)。有三种方法可以实现转置。

假如一个m行n列的矩阵，转化成三元组存储以后有k个三元组。

第一种：复杂度k+klogk。将稀疏矩阵的每一个三元组(i, j, x)变成(j, i, x)，然后再按照行号递增，如果行号相等，则列号递增的顺序qsort一次。

int cmp(const void*a, const void*b)
{
    int *aa = (int*)a, *bb = (int*)b;
    if (aa[0] != bb[0])
        return aa[0] - bb[0];
    return aa[1] - bb[1];
}

void mat_transpose(int a[][3])//将原稀疏矩阵转置
{
    for (int i=0; i<k; i++)
        swap(a[i][0], a[i][1]);
    qsort(a, k, sizeof(a[0]), cmp);
}

第二种：复杂度n*k。将原来的稀疏矩阵三元组扫描一遍，找出所有列号为1的（在转置之后的矩阵中行号为1），放到转置之后的矩阵里面，第二次再扫描一遍，找出所有列号2的（转置之后行号是2），放到转置之后的矩阵里面。重复n遍就行了。

void mat_transpose(int a[][3], int b[][3])//将a转置放在b中
{
    int len = 0;
    for (int r=0; r<n; r++)
    {
        for (int i=0; i<k; i++)
        {
            if (a[i][1] == r)
            {
                b[len][0] = a[i][1];
                b[len][1] = a[i][0];
                b[len++][2] = a[i][2];
            }
        }
    }
}

第三种：复杂度n+k。首先计算出转置之后的矩阵每一行有多少个元素（其实也就是计算转置前每一列有多少个元素）。然后再根据这个结果我们就可以得到，转置之后在稀疏矩阵三元组数组中第i行的开始位置。假如我们现在知道了转置之后矩阵第一行有2个元素，第二行有3个元素，第3行有四个元素。那么我们就可以知道，第一行开始的位置是1，第二行开始的位置是3，第三行开始的位置是6，第四行开始的位置是10。然后我们开始扫描转置前的三元组数组，假如现在扫描到了一个三元组(3, 2 ,1), 因为他的列号是2，所以转置之后在第二行，根据我们刚才计算的答案，它在数组中的位置应该是3，所以就把(2, 3, 1)放到三的位置，同时一定要记得把第二行开始的位置加1，因为刚才的位置已经被放上东西了。这样一来就构造完成了。

void fast_mat_transpose(int a[][3], int b[][3])//将a转置放在b中
{
    int x[1005], y[1005];//x[i]表示转置之后的矩阵第i行有多少元素，y[i]表示转置之后第i行的开始位置  
    memset(x, 0, sizeof(x));
    for (int i=0; i<k; i++)
        x[a[i][1]]++;
    y[0] = 0;
    for (int i=1; i<n; i++)
        y[i] = y[i - 1] + x[i - 1];
    for (int i=0; i<k; i++)
    {
        int &j = y[a[i][1]];
        b[j][0] = a[i][1];
        b[j][1] = a[i][0];
        b[j][2] = a[i][2];
        j++;
    }
}