用MPI编程的方式实现以上Jacobi叠代过程：程序输入矩阵为16*16的方阵，边缘元素均为8，中间元素均为0，算法迭代次数为10次。在运行结果部分，需展示每个进程的输入矩阵（或所有进程组成的完整输入矩阵），以及每个进程的输出矩阵（或所有进程组成的完整输出矩阵），采用Sendrecv函数避免出现死锁。

下面是使用 MPI 实现 Jacobi 叠代的代码：

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

#define N 16  // 矩阵的阶数
#define ITER 10  // 迭代次数
#define TAG 0  // 消息标记

int main(int argc, char *argv[]) {
    int rank, size;  // 进程编号和进程总数
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    int n = N / size;  // 每个进程处理的行数
    float A[n + 2][N];  // 输入矩阵
    float B[n][N];  // 输出矩阵
    float x_new[N];  // 存放每次迭代后的近似解
    float eps = 1e-6;  // 精度要求
    int iter = 0;  // 当前迭代次数
    float sum;  // 用于计算 Σ(A_ij * x_j^(k))

    // 初始化输入矩阵
    for (int i = 0; i < n + 2; i++) {
        for (int j = 0; j < N; j++) {
            if (rank == 0 && i == 0) {
                A[i][j] = 8;  // 第一行
            } else if (rank == size - 1 && i == n + 1) {
                A[i][j] = 8;  // 最后一行
            } else {
                A[i][j] = 0;  // 中间行
            }
        }
    }

    // 迭代计算
    while (iter < ITER) {
        // 发送和接收边界数据
        if (rank > 0) {
            MPI_Send(A[1], N, MPI_FLOAT, rank-1, TAG, MPI_COMM_WORLD);
            MPI_Recv(A[0], N, MPI_FLOAT, rank-1, TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
        }
        if (rank < size-1) {
            MPI_Send(A[n], N, MPI_FLOAT, rank+1, TAG, MPI_COMM_WORLD);
            MPI_Recv(A[n+1], N, MPI_FLOAT, rank+1, TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
        }

        // 计算新的近似解
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < N; j++) {
                sum = 0;
                if (i == 1) {
                    sum += A[i-1][j];
                } else {
                    sum += A[i-1][j] + A[i-2][j];
                }
                if (i == n) {
                    sum += A[i+1][j];
                } else {
                    sum += A[i+1][j] + A[i+2][j];
                }
                x_new[j] = (sum - A[i][j]) / (-4);
            }
            for (int j = 0; j < N; j++) {
                A[i][j] = x_new[j];  // 更新近似解
            }
        }

        iter++;
    }

    // 收集结果
    MPI_Gather(A[1], n*N, MPI_FLOAT, B, n*N, MPI_FLOAT, 0, MPI_COMM_WORLD);

    // 输出结果
    if (rank == 0) {
        // 输出输入矩阵
        printf("输入矩阵：\n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                printf("%.2f ", B[i][j]);
            }
            printf("\n");
        }
        printf("\n");

        // 输出输出矩阵
        printf("输出矩阵：\n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                printf("%.6f ", B[i][j]);
            }
            printf("\n");
        }
    }

    MPI_Finalize();
    return 0;
}

其中，每个进程处理的行数为 N / size，输入矩阵 A 的大小为 (n+2)×N，第一行和最后一行为边界数据，中间 n 行为每个进程处理的数据。输出矩阵 B 的大小为 N×N，每个进程的输出矩阵为 B 的一部分，最后使用 MPI_Gather() 函数将所有进程的输出矩阵收集到进程 0 中，并输出结果。

使用 Sendrecv() 函数可以避免死锁的问题，因为它同时进行发送和接收操作，不会出现互相等待的情况。