高斯消元快速入门

高斯消元快速入门

一、基本描述

学习一个算法/技能，首先要知道它是干什么的，那么高斯消元是干啥的呢？

高斯消元主要用来求解线性方程组，也可以求解矩阵的秩，矩阵的逆。在ACM中是一个有力的数学武器.

它的时间复杂度是n^3，主要与方程组的个数，未知数的个数有关。

那么什么是线性方程组呢?
简而言之就是有多个未知数，并且每个未知数的次数均为一次，这样多个未知数组成的方程组为线性方程组。

二、算法过程

其实高斯消元的过程就是手算解方程组的过程，回忆一下小的时候怎么求解方程组：加减消元，消去未知数，如果有多个未知数，就一直消去，直到得到类似kx=b（k和b为常数，x为未知数）的式子，就可以求解出未知数x，然后我们回代，依次求解出各个未知数的值，就解完了方程组。
换句话说，分两步：
1. 加减消元
2. 回代求未知数值

高斯消元就是这样的一个过程。
下面通过一个小例子来具体说明

0.求解方程组

有这样一个三元一次方程组：

⎧⎩⎨2x+y+z=16x+2y+z=−1−2x+2y+z=7①②③ { 2 x + y + z = 1 ① 6 x + 2 y + z = − 1 ② − 2 x + 2 y + z = 7 ③

1.消去x

①×(−3)+② ① × ( − 3 ) + ② 得到
0x−y−2z=−4 0 x − y − 2 z = − 4

①+③ ① + ③ 得到
0x+3y+2z=8 0 x + 3 y + 2 z = 8

从而得到

⎧⎩⎨2x+y+z=10x−y−2z=−40x+3y+2z=8①②③ { 2 x + y + z = 1 ① 0 x − y − 2 z = − 4 ② 0 x + 3 y + 2 z = 8 ③

2.消去y

②×3+③ ② × 3 + ③ 得到
0x+0y−4z=−4 0 x + 0 y − 4 z = − 4

进而得到

⎧⎩⎨2x+y+z=10x−y−2z=−40x+0y−4z=−4①②③ { 2 x + y + z = 1 ① 0 x − y − 2 z = − 4 ② 0 x + 0 y − 4 z = − 4 ③

至此，我们已经求解出来了

z=1 z = 1

下一步我们进行回代过程

3.回代求解y

将 z=1 z = 1 带入 ② ② ，求得

y=2 y = 2

进而得到

⎧⎩⎨2x+y+z=1y=2z=1①②③ { 2 x + y + z = 1 ① y = 2 ② z = 1 ③

4.回代求解x

将 z=1,y=2 z = 1 , y = 2 带入 ① ① ，求得

x=−1 x = − 1

最终得到

⎧⎩⎨x=−1y=2z=1①②③ { x = − 1 ① y = 2 ② z = 1 ③

至此，整个方程组就求解完毕了。

三、再解算法

对于方程组，其系数是具体存在矩阵(数组)里的，下面在给出实际在矩阵中的表示（很熟悉就可以跳过不看啦~）

0.求解方程组

⎡⎣⎢⎢⎢x26−2y122z111val1−17⎤⎦⎥⎥⎥ [ x y z v a l 2 1 1 1 6 2 1 − 1 − 2 2 1 7 ]

1.消去x

⎡⎣⎢⎢⎢x200y1−13z1−22val1−48⎤⎦⎥⎥⎥ [ x y z v a l 2 1 1 1 0 − 1 − 2 − 4 0 3 2 8 ]

2.消去y

⎡⎣⎢⎢⎢x200y1−10z1−2−4val1−4−4⎤⎦⎥⎥⎥ [ x y z v a l 2 1 1 1 0 − 1 − 2 − 4 0 0 − 4 − 4 ]

3.回代求解y

回代的时候，记录各个变量的结果将保存在另外一个数组当中，故保存矩阵的数组值不会发生改变，该矩阵主要进行消元过程。

⎡⎣⎢⎢⎢x200y1−10z1−2−4val1−4−4⎤⎦⎥⎥⎥ [ x y z v a l 2 1 1 1 0 − 1 − 2 − 4 0 0 − 4 − 4 ]

四、再再解算法

说了这么多，其实有一些情况我们还没有说到。
通过上述的消元方法，其实我们比较希望得到的是一个上三角阵(省去了最后的val)

⎡⎣⎢2001−101−2−4⎤⎦⎥ [ 2 1 1 0 − 1 − 2 0 0 − 4 ]

下面问题来了：
Q1：系数不一定是整数啊？
A1：这时候数组就要用到浮点数了！不能是整数！

Q2：什么时候无解啊？
A2：消元完了，发现有一行系数都为0，但是常数项不为0，当然无解啦！比如：

⎡⎣⎢⎢⎢x200y1−10z1−20val1−45⎤⎦⎥⎥⎥ [ x y z v a l 2 1 1 1 0 − 1 − 2 − 4 0 0 0 5 ]

Q3：什么时候多解啊？
A3：消元完了，发现有好几行系数为0，常数项也为0，这样就多解了！有几行为全为0，就有几个自由元，所谓自由元，就是这些变量的值可以随意取，有无数种情况可以满足给出的方程组，比如：

⎡⎣⎢⎢⎢x200y100z100val100⎤⎦⎥⎥⎥ [ x y z v a l 2 1 1 1 0 0 0 0 0 0 0 0 ]

您说这x,y,z不是无数组解嘛！

Q4：那什么时候解是唯一的啊！
A4：您做一下排除法，不满足2和3的，不就是解释唯一的嘛！其实也就是说我们的系数矩阵可以化成上三角阵。

五、代码实现

啰里啰嗦说了一堆，想必算法的流程已经熟悉了，代码如何实现呢？
更多类型的 高斯消元模板

(以下参考kuangbin大牛的模板)

 #include
    #include
    #include
    #include
    #include
    using namespace std;
    const int MAXN=50;
    int a[MAXN][MAXN];//增广矩阵
    int x[MAXN];//解集
    bool free_x[MAXN];//标记是否是不确定的变元
    int gcd(int a,int b){
        if(b == 0) return a; else return gcd(b,a%b);
    }
    inline int lcm(int a,int b){
        return a/gcd(a,b)*b;//先除后乘防溢出
    }
    // 高斯消元法解方程组(Gauss-Jordan elimination).(-2表示有浮点数解，但无整数解，
    //-1表示无解，0表示唯一解，大于0表示无穷解，并返回自由变元的个数)
    //有equ个方程，var个变元。增广矩阵行数为equ,分别为0到equ-1,列数为var+1,分别为0到var.
    int Gauss(int equ,int var){
        int i,j,k;
        int max_r;// 当前这列绝对值最大的行.
        int col;//当前处理的列
        int ta,tb;
        int LCM;
        int temp;
        int free_x_num;
        int free_index;

        for(int i=0;i<=var;i++){
            x[i]=0;
            free_x[i]=true;
        }

        //转换为阶梯阵.
        col=0; // 当前处理的列
        for(k = 0;k < equ && col < var;k++,col++){// 枚举当前处理的行.
        // 找到该col列元素绝对值最大的那行与第k行交换.(为了在除法时减小误差)
            max_r=k;
            for(i=k+1;iif(abs(a[i][col])>abs(a[max_r][col])) max_r=i;
            }
            if(max_r!=k){// 与第k行交换.
                for(j=k;j1;j++) swap(a[k][j],a[max_r][j]);
            }
            if(a[k][col]==0){// 说明该col列第k行以下全是0了，则处理当前行的下一列.
                k--;
                continue;
            }
            for(i=k+1;i// 枚举要删去的行.
                if(a[i][col]!=0){
                    LCM = lcm(abs(a[i][col]),abs(a[k][col]));
                    ta = LCM/abs(a[i][col]);
                    tb = LCM/abs(a[k][col]);
                    if(a[i][col]*a[k][col]<0)tb=-tb;//异号的情况是相加
                    for(j=col;j1;j++){
                        a[i][j] = a[i][j]*ta-a[k][j]*tb;
                    }
                }
            }
        }
        // 1. 无解的情况: 化简的增广阵中存在(0, 0, ..., a)这样的行(a != 0).
        for (i = k; i < equ; i++){ // 对于无穷解来说，如果要判断哪些是自由变元，那么初等行变换中的交换就会影响，则要记录交换.
            if (a[i][col] != 0) return -1;
        }
        // 2. 无穷解的情况: 在var * (var + 1)的增广阵中出现(0, 0, ..., 0)这样的行，即说明没有形成严格的上三角阵.
        // 且出现的行数即为自由变元的个数.
        if (k < var){
            return var - k; // 自由变元有var - k个.
        }
        // 3. 唯一解的情况: 在var * (var + 1)的增广阵中形成严格的上三角阵.
        // 计算出Xn-1, Xn-2 ... X0.
        for (i = var - 1; i >= 0; i--){
            temp = a[i][var];
            for (j = i + 1; j < var; j++){
                if (a[i][j] != 0) temp -= a[i][j] * x[j];
            }
            if (temp % a[i][i] != 0) return -2; // 说明有浮点数解，但无整数解.
            x[i] = temp / a[i][i];
        }
        return 0;
    }
    int main(void){
    //    freopen("in.txt", "r", stdin);
    //    freopen("out.txt","w",stdout);
        int i, j;
        int equ,var;
        while (scanf("%d %d", &equ, &var) != EOF){
            memset(a, 0, sizeof(a));
            for (i = 0; i < equ; i++){
                for (j = 0; j < var + 1; j++){
                    scanf("%d", &a[i][j]);
                }
            }
            int free_num = Gauss(equ,var);
            if (free_num == -1) printf("无解!\n");
            else if (free_num == -2) printf("有浮点数解，无整数解!\n");
            else if (free_num > 0){
                printf("无穷多解! 自由变元个数为%d\n", free_num);
                for (i = 0; i < var; i++){
                    if (free_x[i]) printf("x%d 是不确定的\n", i + 1);
                    else printf("x%d: %d\n", i + 1, x[i]);
                }
            }else{
                for (i = 0; i < var; i++){
                    printf("x%d: %d\n", i + 1, x[i]);
                }
            }
            printf("\n");
        }
        return 0;
    }