并行算法计算矩阵相乘，随机生成两个矩阵相乘，用（x-1）*3+y计算进程号，每个进程负责一个答案矩阵的元素，用c++编程最后输出答案矩阵

以下是使用 MPI 编写的并行矩阵乘法程序：

#include <iostream>
#include <mpi.h>
#include <cstdlib>
#include <ctime>

using namespace std;

#define ROW_A 1000
#define COL_A 1000
#define ROW_B 1000
#define COL_B 1000

int main(int argc, char **argv)
{
    int size, rank, tag = 0;
    int a[ROW_A][COL_A], b[ROW_B][COL_B], c[ROW_A][COL_B];

    MPI_Status status;

    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    srand((unsigned)time(NULL));

    if (rank == 0) {
        // 生成随机矩阵
        for (int i = 0; i < ROW_A; i++) {
            for (int j = 0; j < COL_A; j++) {
                a[i][j] = rand() % 100;
            }
        }
        for (int i = 0; i < ROW_B; i++) {
            for (int j = 0; j < COL_B; j++) {
                b[i][j] = rand() % 100;
            }
        }

        // 将矩阵 B 广播给其他进程
        for (int i = 1; i < size; i++) {
            MPI_Send(&b, ROW_B * COL_B, MPI_INT, i, tag, MPI_COMM_WORLD);
        }

        // 计算矩阵乘法
        int start_row, end_row;
        for (int i = 1; i < size; i++) {
            start_row = (i - 1) * 3;
            end_row = start_row + 2;
            MPI_Send(&start_row, 1, MPI_INT, i, tag, MPI_COMM_WORLD);
            MPI_Send(&end_row, 1, MPI_INT, i, tag, MPI_COMM_WORLD);
            MPI_Send(&a[start_row][0], (end_row - start_row + 1) * COL_A, MPI_INT, i, tag, MPI_COMM_WORLD);
        }

        start_row = (size - 1) * 3;
        end_row = ROW_A - 1;
        for (int i = start_row; i <= end_row; i++) {
            for (int j = 0; j < COL_B; j++) {
                c[i][j] = 0;
                for (int k = 0; k < ROW_B; k++) {
                    c[i][j] += a[i][k] * b[k][j];
                }
            }
        }

        int temp_c[COL_B];
        for (int i = 1; i < size; i++) {
            MPI_Recv(&temp_c, COL_B, MPI_INT, i, tag, MPI_COMM_WORLD, &status);
            start_row = (i - 1) * 3;
            end_row = start_row + 2;
            for (int j = start_row; j <= end_row; j++) {
                for (int k = 0; k < COL_B; k++) {
                    c[j][k] = temp_c[k];
                }
            }
        }

        // 输出结果
        for (int i = 0; i < ROW_A; i++) {
            for (int j = 0; j < COL_B; j++) {
                cout << c[i][j] << " ";
            }
            cout << endl;
        }
    } else {
        // 接收矩阵 B
        MPI_Recv(&b, ROW_B * COL_B, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);

        // 接收计算范围和矩阵 A 的部分数据
        int start_row, end_row;
        MPI_Recv(&start_row, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
        MPI_Recv(&end_row, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
        int a_part[(end_row - start_row + 1) * COL_A];
        MPI_Recv(&a_part, (end_row - start_row + 1) * COL_A, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);

        // 计算矩阵乘法的一部分
        int temp_c[COL_B];
        for (int i = start_row; i <= end_row; i++) {
            for (int j = 0; j < COL_B; j++) {
                temp_c[j] = 0;
                for (int k = 0; k < ROW_B; k++) {
                    temp_c[j] += a_part[(i - start_row) * COL_A + k] * b[k][j];
                }
            }
            MPI_Send(&temp_c, COL_B, MPI_INT, 0, tag, MPI_COMM_WORLD);
        }
    }

    MPI_Finalize();

    return 0;
}

该程序使用了 MPI 并行计算框架，通过广播将矩阵 B 发送给其他进程，然后将矩阵 A 的不同部分分别发送给不同的进程进行计算，最后将每个进程计算的结果发送回主进程。主进程负责输出最终结果。