用c语言编写程序，输入整数n（2<=n<=10）、n阶方阵A，计算A的逆矩阵并输出。要求使用指针进行操作，矩阵存储采用动态内存分配，矩阵元素为double类型，最终结果四舍五入保留两位小数输出，矩阵不可逆则输出0。

好的，这是一个比较复杂的问题，需要一步步地实现。首先，我们需要定义一个函数来计算矩阵的逆：

// 计算矩阵的逆，返回逆矩阵的指针
double** matrix_inverse(double** matrix, int n);

接下来，我们需要定义一个函数来打印矩阵：

// 打印矩阵
void print_matrix(double** matrix, int n);

然后，我们需要定义一个函数来释放动态分配的内存：

// 释放矩阵的内存
void free_matrix(double** matrix, int n);

最后，我们需要编写程序的主函数，来读入矩阵并计算逆矩阵：

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

// 计算矩阵的逆，返回逆矩阵的指针
double** matrix_inverse(double** matrix, int n) {
    int i, j, k;
    double temp;

    // 分配存储逆矩阵的空间
    double** inverse = (double**)malloc(n * sizeof(double*));
    for (i = 0; i < n; i++) {
        inverse[i] = (double*)malloc(n * sizeof(double));
    }

    // 将逆矩阵初始化为单位矩阵
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            if (i == j) {
                inverse[i][j] = 1.0;
            } else {
                inverse[i][j] = 0.0;
            }
        }
    }

    // 利用高斯-约旦消元法计算逆矩阵
    for (k = 0; k < n; k++) {
        // 如果主元素为0，则矩阵不可逆，返回0
        if (fabs(matrix[k][k]) < 1e-6) {
            free_matrix(inverse, n);
            return NULL;
        }

        // 将第k行的元素除以主元素
        temp = matrix[k][k];
        for (j = 0; j < n; j++) {
            matrix[k][j] /= temp;
            inverse[k][j] /= temp;
        }

        // 将其余行的元素消成0
        for (i = 0; i < n; i++) {
            if (i != k) {
                temp = matrix[i][k];
                for (j = 0; j < n; j++) {
                    matrix[i][j] -= temp * matrix[k][j];
                    inverse[i][j] -= temp * inverse[k][j];
                }
            }
        }
    }

    return inverse;
}

// 打印矩阵
void print_matrix(double** matrix, int n) {
    int i, j;

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%.2f ", matrix[i][j]);
        }
        printf("\n");
    }
}

// 释放矩阵的内存
void free_matrix(double** matrix, int n) {
    int i;

    for (i = 0; i < n; i++) {
        free(matrix[i]);
    }
    free(matrix);
}

// 主函数
int main() {
    int n, i, j;
    double** matrix;
    double** inverse;

    // 读入矩阵的大小
    scanf("%d", &n);

    // 分配存储矩阵的空间
    matrix = (double**)malloc(n * sizeof(double*));
    for (i = 0; i < n; i++) {
        matrix[i] = (double*)malloc(n * sizeof(double));
    }

    // 读入矩阵的元素
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            scanf("%lf", &matrix[i][j]);
        }
    }

    // 计算矩阵的逆
    inverse = matrix_inverse(matrix, n);

    // 如果矩阵不可逆，则输出0
    if (inverse == NULL) {
        printf("0\n");
    } else {
        // 否则打印逆矩阵
        print_matrix(inverse, n);
        // 释放逆矩阵的内存
        free_matrix(inverse, n);
    }

    // 释放矩阵的内存
    free_matrix(matrix, n);

    return 0;
}

这个程序会读入一个整数n，表示矩阵的大小，然后读入n阶方阵A，计算A的逆矩阵并输出。如果矩阵不可逆，则输出0。矩阵元素为double类型，最终结果四舍五入保留两位小数输出，矩阵存储采用动态内存分配，矩阵操作使用指针。