c++求：对两个以三元组形式存储的同阶稀疏矩阵A、B，设计算法 求C=A+B。

稀疏矩阵乘法可以采用三元组存储方式进行优化，具体算法如下：

1. 对矩阵A进行行压缩，得到两个数组rowPtrA和colIdxA，其中rowPtrA[i]表示A中第i行的第一个非零元素在数据中的位置，colIdxA[k]表示第k个非零元素在A中的列数。

2. 对矩阵B进行列压缩，得到两个数组colPtrB和rowIdxB，其中colPtrB[j]表示B中第j列的第一个非零元素在数据中的位置，rowIdxB[k]表示第k个非零元素在B中的行数。

3. 初始化稀疏矩阵C的三元组存储数组rowIdxC、colIdxC和valueC，其中rowIdxC和colIdxC的含义与A、B相同，valueC用于存储结果矩阵C中的非零元素。

4. 对于A中的每一行i，遍历该行的所有非零元素A[i][k]，并在B中找到所有列j满足B[k][j]非零，将对应的乘积累加到C[i][j]中。具体实现可以利用rowPtrA、colIdxA、colPtrB和rowIdxB数组，以及两个指针k和j进行遍历和查找。

5. 返回稀疏矩阵C的三元组存储数组。

下面是Python代码实现：

def sparse_matrix_multiplication(A, B):
    # Step 1: row compression for matrix A
    rowPtrA, colIdxA = [], []
    for i in range(len(A)):
        rowPtrA.append(len(colIdxA))
        for j in range(len(A[0])):
            if A[i][j] != 0:
                colIdxA.append(j)
    rowPtrA.append(len(colIdxA))

    # Step 2: column compression for matrix B
    colPtrB, rowIdxB = [], []
    for j in range(len(B[0])):
        colPtrB.append(len(rowIdxB))
        for i in range(len(B)):
            if B[i][j] != 0:
                rowIdxB.append(i)
    colPtrB.append(len(rowIdxB))

    # Step 3: initialize sparse matrix C
    rowIdxC, colIdxC, valueC = [], [], []

    # Step 4: matrix multiplication
    for i in range(len(A)):
        for k in range(rowPtrA[i], rowPtrA[i+1]):
            colA = colIdxA[k]
            for l in range(colPtrB[colA], colPtrB[colA+1]):
                j = rowIdxB[l]
                valueCIndex = len(valueC) - 1
                while valueCIndex >= 0 and rowIdxC[valueCIndex] > i:
                    valueCIndex -= 1
                if valueCIndex < 0 or rowIdxC[valueCIndex] < i or colIdxC[valueCIndex] < j:
                    rowIdxC.insert(valueCIndex+1, i)
                    colIdxC.insert(valueCIndex+1, j)
                    valueC.insert(valueCIndex+1, 0)
                valueC[valueCIndex+1] += A[i][colA] * B[colA][j]

    return rowIdxC, colIdxC, valueC

该算法采用了稀疏矩阵乘法的优化方式，在稀疏矩阵A、B的情况下可以大幅提升计算效率。