思路：
快速转置算法的基本思想是预先计算出转置后的三元组在新数组中的位置，然后直接将元素放到对应的位置上。这样做的好处是只需要遍历一次原数组，就可以完成转置操作。
步骤如下：
1. 初始化一个新的三元组数组，用于存储转置后的矩阵。
2. 初始化一个数组，用于存储原矩阵每列的非零元素个数。
3. 遍历原矩阵的三元组，统计每列的非零元素个数。
4. 根据每列的非零元素个数，计算出转置后的三元组在新数组中的位置。
5. 遍历原矩阵的三元组，将每个元素放到新数组的对应位置上。
伪代码：
```
function fastTranspose(M, T):
初始化数组 numCols 和 position
for i in range(1, M.cols+1):
numCols[i] = 0
for i in range(1, M.t+1):
numCols[M.data[i].j] += 1
position[1] = 1
for i in range(2, M.cols+1):
position[i] = position[i-1] + numCols[i-1]
for i in range(1, M.t+1):
j = position[M.data[i].j]
T.data[j].i = M.data[i].j
T.data[j].j = M.data[i].i
T.data[j].e = M.data[i].e
position[M.data[i].j] += 1
```
C++代码：
#include <iostream>
#include <vector>
using namespace std;
struct Triple {
int i, j, e;
};
void fastTranspose(vector<Triple>& M, vector<Triple>& T, int n, int m, int k) {
vector<int> numCols(m+1, 0), position(m+1, 0);
T.resize(k+1);
for (int t = 1; t <= k; ++t)
++numCols[M[t].j];
position[1] = 1;
for (int col = 2; col <= m; ++col)
position[col] = position[col-1] + numCols[col-1];
for (int t = 1; t <= k; ++t) {
int j = position[M[t].j];
T[j].i = M[t].j;
T[j].j = M[t].i;
T[j].e = M[t].e;
++position[M[t].j];
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<Triple> M(k+1), T;
for (int t = 1; t <= k; ++t)
cin >> M[t].i >> M[t].j >> M[t].e;
fastTranspose(M, T, n, m, k);
for (int t = 1; t <= k; ++t)
cout << T[t].i << " " << T[t].j << " " << T[t].e << "\n";
return 0;
}
这段代码首先定义了一个结构体 Triple，用于存储三元组的行号、列号和值。然后定义了一个函数 fastTranspose，用于进行快速转置。最后在 main 函数中，读取输入的矩阵，调用 fastTranspose 函数进行转置，并输出转置后的矩阵。
