用梯形思想编写MPI程序，判断素数,进程0读取输入的n个整数（其中n刚好是进程数的倍数),并将这些整数平均分配到各个进程，最后进程0打印所有素数。

以下是用梯形思想编写的MPI程序，用于判断素数：

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

int is_prime(int n) {
    int i;
    if (n <= 1) {
        return 0;
    }
    for (i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

int main(int argc, char** argv) {
    int rank, size, n, i, j, count = 0, *data, *recv_counts, *displs;

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

    if (rank == 0) {
        printf("Enter the number of integers: ");
        scanf("%d", &n);
        data = (int*) malloc(n * sizeof(int));
        for (i = 0; i < n; i++) {
            scanf("%d", &data[i]);
        }
    }

    MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

    int block_size = n / size;
    int* block_data = (int*) malloc(block_size * sizeof(int));

    MPI_Scatter(data, block_size, MPI_INT, block_data, block_size, MPI_INT, 0, MPI_COMM_WORLD);

    int local_count = 0;
    for (i = 0; i < block_size; i++) {
        if (is_prime(block_data[i])) {
            local_count++;
        }
    }

    MPI_Reduce(&local_count, &count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);

    if (rank == 0) {
        printf("Total number of primes: %d\n", count);

        recv_counts = (int*) malloc(size * sizeof(int));
        displs = (int*) malloc(size * sizeof(int));
        recv_counts[0] = block_size;
        displs[0] = 0;
        for (i = 1; i < size; i++) {
            recv_counts[i] = block_size;
            displs[i] = displs[i - 1] + block_size;
        }

        int* all_data = (int*) malloc(n * sizeof(int));
        MPI_Gatherv(block_data, block_size, MPI_INT, all_data, recv_counts, displs, MPI_INT, 0, MPI_COMM_WORLD);

        printf("All primes: ");
        for (i = 0; i < n; i++) {
            if (is_prime(all_data[i])) {
                printf("%d ", all_data[i]);
            }
        }
        printf("\n");

        free(data);
        free(recv_counts);
        free(displs);
        free(all_data);
    }

    free(block_data);

    MPI_Finalize();
    return 0;
}

程序的运作方式如下：

1. 进程0读取输入的n个整数，并将这些整数平均分配到各个进程。
2. 每个进程计算它分配到的整数中有多少个素数，并将本地计数器的值通过MPI_Reduce函数汇总到进程0的计数器中。
3. 进程0使用MPI_Gatherv函数将各个进程中的整数收集到一个数组中，并打印出所有素数。

在这个程序中，我们使用了以下MPI函数：

- MPI_Init：初始化MPI环境。
- MPI_Comm_rank：获取当前进程的rank。
- MPI_Comm_size：获取MPI_COMM_WORLD通信域中进程的数量。
- MPI_Bcast：将一个值广播到所有进程中。
- MPI_Scatter：将一个数组分发到各个进程中。
- MPI_Reduce：把各个进程的值汇总到一个进程中。
- MPI_Gatherv：把各个进程的数组收集到一个进程中。

对于本程序中使用的MPI函数，可以参考MPI的官方文档进行更深入的了解。