用Jacobi 迭代法解如下方程组 输出方程组的解，及矩阵 L和U 的C语言代码

方程组如下：

3x + 2y + z = 1
2x + 5y + 2z = -4
x + y + 3z = 2

使用 Jacobi 迭代法解该方程组的步骤如下：

1. 将方程组转化为矩阵形式：`Ax = b`，其中 A 为系数矩阵，x 和 b 分别为未知数矩阵和常数向量。

| 3  2  1 |   | x |   | 1 |
| 2  5  2 | x | y | = |-4 |
| 1  1  3 |   | z |   | 2 |

2. 将矩阵 A 分解为下三角矩阵 L 和上三角矩阵 U，即 A = LU。

| 1   0   0 |   | 3  2  1 |   | 1  0  0 |
| L_21  1  0 | x | 0  1  2 | = | 0  1  0 |
| L_31 L_32 1 |   | 0  0  2 |   | 0  0  1 |

L = | 1   0   0 |
    | L_21  1  0 |
    | L_31 L_32 1 |

U = | 3  2  1 |
    | 0  1  2 |
    | 0  0  2 |

3. 将方程组转化为迭代格式：`x(k+1) = D^-1(b - (L+U)x(k))`，其中 D 为对角矩阵，含 A 的对角线元素。

x(k+1)_1 = (1/3)(1 - 2x(k)_2 - x(k)_3)
x(k+1)_2 = (-4 - 2x(k)_1 - 2x(k)_3)/5
x(k+1)_3 = (2 - x(k)_1 - x(k)_2)/3

4. 初始化迭代过程，设初值 `x(0) = [0, 0, 0]^T`。

5. 迭代计算，直到收敛。

根据 Jacobi 迭代法的收敛条件，当系数矩阵 A 对角线元素绝对值之和大于非对角线元素绝对值之和时，迭代法才能保证收敛。对于本题的系数矩阵 A，满足该条件，所以迭代法一定能够收敛。

迭代过程中，每次更新的解向量为 `x(k+1)`，直到满足收敛条件为止。最终的解向量为方程组的解。

以下是求解该方程组的 C 语言代码实现：

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

#define N 3
#define MAX_ITER 1000
#define EPSILON 1e-6

void print_matrix(double a[][N], int n) {
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%10.5f ", a[i][j]);
        }
        printf("\n");
    }
}

void print_vector(double x[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%10.5f ", x[i]);
    }
    printf("\n");
}

void jacobi(double a[][N], double b[], double x[], int n) {
    int i, j, k;
    double sum;

    double d[N]; // 对角线元素
    double l[N][N], u[N][N]; // L 和 U 矩阵

    // 分解 A 为 L 和 U
    for (i = 0; i < n; i++) {
        d[i] = a[i][i];
        for (j = 0; j < n; j++) {
            if (i < j) {
                u[i][j] = a[i][j];
                l[i][j] = 0.0;
            } else if (i > j) {
                l[i][j] = a[i][j];
                u[i][j] = 0.0;
            } else {
                l[i][j] = 0.0;
                u[i][j] = 0.0;
            }
        }
    }

    // 初始化迭代
    k = 0;

    // 开始迭代
    while (k < MAX_ITER) {
        double x_new[N];
        for (i = 0; i < n; i++) {
            sum = 0.0;
            for (j = 0; j < n; j++) {
                if (i != j) {
                    sum += a[i][j] * x[j];
                }
            }
            x_new[i] = (b[i] - sum) / d[i];
        }

        // 判断是否收敛
        double err = 0.0;
        for (i = 0; i < n; i++) {
            err += fabs(x_new[i] - x[i]);
        }
        if (err < EPSILON) {
            break;
        }

        // 更新迭代
        for (i = 0; i < n; i++) {
            x[i] = x_new[i];
        }
        k++;
    }

    // 输出结果
    printf("Matrix A:\n");
    print_matrix(a, n);
    printf("Matrix L:\n");
    print_matrix(l, n);
    printf("Matrix U:\n");
    print_matrix(u, n);
    printf("Vector b:\n");
    print_vector(b, n);
    printf("Solution x:\n");
    print_vector(x, n);
}

int main() {
    double a[N][N] = {{3, 2, 1}, {2, 5, 2}, {1, 1, 3}};
    double b[N] = {1, -4, 2};
    double x[N] = {0};
    jacobi(a, b, x, N);
    return 0;
}