The essence of Gauss elimination is to simplify it into a stepped determinant.
Firstly, the solutions of linear equations are as follows:

• unsolvable
• There are infinite solutions
• Unique solution

The steps of Gaussian elimination are divided into the following four steps:

• Enumerate each row to find the maximum absolute value of the current column under the current row (including the current row).
• Move the line with the largest absolute value to the top
• Change the first number of changes to 1
• Clear the current column of all the following rows to 0

example:

Note: here is the first row and the first column at the beginning. By analogy, it will be reduced to a stepped determinant.

https://www.acwing.com/problem/content/description/885/
The simulated code according to the above steps is as follows:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=110;
const double eps=1e-6;
double a[N][N];
int n;
void print()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n+1;j++)
        cout<<a[i][j]<<" ";
        cout<<endl;
    }
    cout<<endl;
}
int gauss()
{
	int c,r;
	for(c=1,r=1;c<=n;c++)
	{
		int t=r;
		for(int i=r;i<=n;i++)//1 Search 
		{
			if(fabs(a[i][c])>fabs(a[t][c])) t=i;
		}
		
		if(fabs(a[t][c])<eps) continue;
		
		for(int i=c;i<=n+1;i++) swap(a[r][i],a[t][i]);//2 exchange
		
		for(int i=n+1;i>=c;i--) a[r][i]=a[r][i]/a[r][c];//3 simplification 
		
		for(int i=r+1;i<=n;i++)//Clear the column below the row
		{
			if (fabs(a[i][c]) > eps)//If the current column is not 0, you don't need to clear it if it is 0.
			for(int j=n+1;j>=c;j--)
			{
				a[i][j]-=a[i][c]*a[r][j];
			}
		} 
		r++;
	}
	
	if (r <= n)//It means that our lines r to n are all zeros.
    {
        for (int i = r; i <= n; i ++ )//If the constant term is not zero, there will be a contradiction of 0 = 3
            if (fabs(a[i][n+1]) > eps)
                return 2;//unsolvable
        return 1;
    }

    for (int i = n; i >1 0; i -- )//Reverse solution
        for (int j = i + 1; j <= n; j ++ )
            a[i][n+1] -= a[j][n+1] * a[i][j];

    return 0;
}
int main(void)
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n+1;j++)
		cin>>a[i][j];
	}
	int t=gauss();
	if (t == 0)
    {
        for (int i = 1; i <= n; i ++ ) printf("%.2lf\n", a[i][n+1]);
    }
    else if (t == 1) puts("Infinite group solutions");
    else puts("No solution");
	return 0;
}

Here are some common questions you don't understand:

Question 1: why should the operation simplified to 1 and the clearing operation be pushed backwards.


Of course, you can also push forward, but you need to use a variable to record the value of the first element. Just divide the simplification by this value.
But it's a little troublesome.
Then the code is as follows:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=110;
const double eps=1e-6;
double a[N][N];
int n;
void print()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n+1;j++)
        cout<<a[i][j]<<" ";
        cout<<endl;
    }
    cout<<endl;
}
int gauss()
{
	int c,r;
	for(c=1,r=1;c<=n;c++)
	{
		int t=r;
		for(int i=r;i<=n;i++)//1 Search 
		{
			if(fabs(a[i][c])>fabs(a[t][c])) t=i;
		}
		
		if(fabs(a[t][c])<eps) continue;
		
		for(int i=c;i<=n+1;i++) swap(a[r][i],a[t][i]);//2 exchange
		
		double x=a[r][c];
		for(int i=c;i<=n+1;i++) a[r][i]=a[r][i]/x;//3 simplification 
		
		for(int i=r+1;i<=n;i++)
		{
			if (fabs(a[i][c]) > eps)
			{
			    double x=a[i][c];
			    for(int j=c;j<=n+1;j++)
			    {
				    a[i][j]-=x*a[r][j];
		    	}
			}
		} 
		r++;
	}
	
	if (r <= n)
    {
        for (int i = r; i <= n; i ++ )
            if (fabs(a[i][n+1]) > eps)
                return 2;
        return 1;
    }

    for (int i = n; i >= 1; i -- )
        for (int j = i + 1; j <= n; j ++ )
            a[i][n+1] -= a[j][n+1] * a[i][j];

    return 0;
}
int main(void)
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n+1;j++)
		cin>>a[i][j];
	}
	int t=gauss();
	if (t == 0)
    {
        for (int i = 1; i <= n; i ++ ) printf("%.2lf\n", a[i][n+1]);
    }
    else if (t == 1) puts("Infinite group solutions");
    else puts("No solution");
	return 0;
}

Question 2: if (Fabs (a [t] [C]) < EPS) continue; How to understand.

Suppose c represents a column and r represents a row. At this time, we proceed to c = 2 and r = 2
1 0 2 3
0 0 3 2
0 0 2 3
You will find that the maximum absolute value of column c under row r is 0
Explain that column c has been simplified at this time, so we don't need to carry out the following simplification operations,
But at this time, our row r does not need to change. At this time, c plus 1, then we will start from the second row and the third column to find the number with the largest absolute value.
If our r moves backward, then our second line is not simplified at this time, which is obviously wrong.
Taking this as an example, if R moves backward, then r = 3 and C = 3, but at this time, the third number in our second line is 3, which is not the simplest form of 1.

Question 3: how does the inverse solution come from

When there is a unique solution, our final simplification must be this.
The final form of the solution is as follows:

Instead, we simplify each line into the form of only one 1 for each line. Here simulation, the code will understand. I won't repeat it here.

Finally, thank you for watching. See you next time!!!