高斯消元总结

于 2022-11-25 00:02:07 发布
阅读量486 收藏 1
点赞数
分类专栏： c++ 算法 总结 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52621204/article/details/127707757
版权
c++ 同时被 3 个专栏收录
145 篇文章 0 订阅
订阅专栏
算法
142 篇文章 1 订阅
订阅专栏
总结
92 篇文章 0 订阅
订阅专栏

A-Matrix Equation_第 45 届国际大学生程序设计竞赛（ICPC）亚洲区域赛（济南）（重现赛）

         自己写一个2维矩阵或者3维矩阵就可以发现对于每一列来说都是独立的，每一列的n个Cij都是都关系的，这就构成了一个n元一次方程组，其实这就是解一下这个方程组，但是他是问的有多少个矩阵，对于这个方程组构造出的矩阵来说，有多少自由元就说明有多少个Cij是可以任意取值的，也就是有1，2两种选择，不是自由元的就只能有1种；自由元是指系数都是0的未知数，自由元的个数就是高斯消元后0行的个数，所以用高斯消元就可以求出来；

        又因为有运算是模2的，所以也就可以看成是异或型矩阵，那么运算方式就要稍微的发生以下变化，比如

上述图片来自2020icpc-济南站_琅歌的博客-CSDN博客 

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
const int mod=998244353;
const int inf=1e18;
const int N = 2e5+100;
const double eps=1e-8;
int qpow(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int getinv(int a){return qpow(a,mod-2LL);}
int n;
int a[220][220],b[220][220],d[220][220],fac[N];
int gauss()
{
    int newline=1;
    for(int k=1;k<=n;k++)
    {
        int p=newline;
        for(int i=newline+1;i<=n;i++)
        if(d[i][k]>d[p][k]) p=i;
        if(d[p][k]==0) continue;
        swap(d[newline],d[p]);
        for(int i=newline+1;i<=n;i++)
        {
            if(d[i][k]==0) continue;
            for(int j=1;j<=n;j++)
            d[i][j]^=d[newline][j];
        }
        newline++;
    }
    newline--;
    return n-newline;
}
void print()
{
    cout<<"--------------------\n";
        for(int i=1;i<=n;i++)
        {
            for(int k=1;k<=n;k++)
            cout<<d[i][k]<<" ";
            cout<<endl;
        }
        cout<<"--------------------\n";
}
signed main()
{
    //ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n;
    fac[0]=1;
    for(int i=1;i<=100000;i++) fac[i]=fac[i-1]*2LL%mod;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++) cin>>a[i][j],d[i][j]=a[i][j];
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++) cin>>b[i][j];
    int ans=1;
    for(int j=1;j<=n;j++)
    {
        for(int i=1;i<=n;i++) 
        for(int k=1;k<=n;k++) d[i][k]=a[i][k];
        for(int i=1;i<=n;i++)
        d[i][i]=a[i][i]^b[i][j];
        //print();
        int res=gauss();
        //print();
        //cout<<res<<endl;
        ans=ans*fac[res]%mod;
        //cout<<j<<" "<<res<<endl;
        //print();
    }
    cout<<ans<<endl;
    system("pause");
    return 0;
}

借助这个题又回顾了一下高斯消元的东西，高斯消元其实就是大一学的矩阵的行列变换使得矩阵变为行阶梯型，步骤为：

1.设一变量newline代表进行到了第几行，最外层枚举列号k，内层枚举行i，找到最大的a[i][k]让其作为主元，将第i行与第newline行交换，如果最大的a[i][k]==0说明该变量是自由元，跳过去操作下一列；

2.将主元下面的数都消掉，就是行变换

3.操作结束后常数项/主元系数就是该未知数的解

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
const int mod=998244353;
const int inf=1e18;
const int N = 2e5+100;
const double eps=1e-8;
int qpow(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int sgn(double x)
{
    if(fabs(x)<eps) return 0;
    else if(x<0) return -1;
    else return 1;
}
int getinv(int a){return qpow(a,mod-2LL);}
int n;
double a[55][55];
void gauss()
{
    int nl=1;
    for(int k=1;k<=n;k++)
    {
        int p=nl;
        for(int i=nl+1;i<=n;i++)
        if(a[p][k]<a[i][k]) p=i;
        //找一列中最大的数作为主元
        if(sgn(a[p][k])==0) continue;
        //如果最大的数是0那这个变量是一个自由元，跳过
        swap(a[p],a[nl]);
        //将主元所在的行换到上面
        for(int i=1;i<=n;i++)
        {
            if(i==nl) continue;
            double tmp=a[i][k]/a[nl][k];
            for(int j=1;j<=n+1;j++)
            a[i][j]-=tmp*a[nl][j];
            //将该主元所在的列中的非零元素都消去，使得这一列中只有主元一个非零元素
        }
        nl++;
    }
    nl--;
    if(nl<n)
    {
        //如果行数不够n，说明含有自由元
        for(int i=nl+1;i<=n;i++)
        {
            //如果常数项不为0说明是无解的
            if(a[i][n+1]!=0){cout<<"-1\n";return;}
        }
        //如果常数项是0说明是无穷解
        cout<<"0\n";return;
    }
    for(int i=1;i<=n;i++)
    {
        //常数项/主元系数就是未知数的解
        cout<<"x"<<i<<"="<<fixed<<setprecision(2)<<a[i][n+1]/a[i][i]<<endl;
    }
}
signed main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n+1;j++) cin>>a[i][j];
    gauss();
    system("pause");
    return 0;
}

P2962 [USACO09NOV]Lights G - dfs+高斯消元

这题也是异或方程组，可以发现假设每个灯按的次数是xi,那么对于每一个灯来说

xj1^xj2^xj3^...^xi^...^xjm=1,j[1...m]是与i相连的灯，n个灯就构成了n元异或方程组，高斯消元后，如果有自由元的存在就要枚举这个灯开着优还是关掉优，最后取一个最优值即可

题解 P2962 【[USACO09NOV]灯Lights】 - Youngsc_AFO 的博客 - 洛谷博客 (luogu.com.cn)

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
const int mod=998244353;
const int inf=1e18;
const int N = 4e5+100;
const double eps=1e-8;
int qpow(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int sgn(double x)
{
    if(fabs(x)<eps) return 0;
    else if(x<0) return -1;
    else return 1;
}
int getinv(int a){return qpow(a,mod-2LL);}
int a[55][55],n,m;
int vis[55],ans;
void gauss()
{
    int nl=1;
    for(int k=1;k<=n;k++)
    {
        int p=nl;
        for(int i=nl+1;i<=n;i++) if(a[p][k]<a[i][k]) p=i;
        if(a[p][k]==0) continue;
        swap(a[p],a[nl]);
        for(int i=1;i<=n;i++)
        {
            if(i==nl||a[i][k]==0) continue;
            for(int j=1;j<=n+1;j++)
            a[i][j]^=a[nl][j];
        }
        nl++;
    }
    nl--;
}
void dfs(int pos,int res)
{
    if(ans<=res) return;
    if(pos==0)
    {
        ans=res;return;
    }
    int ma=n+1;
    for(int i=pos;i<=n;i++)
    {
        if(a[pos][i]){ma=i;break;}
    }
    if(ma<=n)
    {
        int num=a[pos][n+1];
        for(int i=ma+1;i<=n;i++)
        {
            if(a[pos][i]) num^=vis[i];
        }
        dfs(pos-1,res+num);
    }
    else
    {
        vis[pos]=0;
        dfs(pos-1,res);
        vis[pos]=1;
        dfs(pos-1,res+1);
        vis[pos]=0;
    }
}
void print()
{
    cout<<"-----------------------------\n";
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n+1;j++)
        cout<<a[i][j];
        cout<<endl;
    }
    cout<<"------------------------------\n";
}
signed main()
{
    //ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
        cin>>n>>m;
        for(int i=1;i<=n;i++) a[i][i]=a[i][n+1]=1;
        for(int i=1;i<=m;i++)
        {
            int u,v;cin>>u>>v;
            a[u][v]=a[v][u]=1;
        }
        //print();
        gauss();
        ans=inf;
        //print();
        dfs(n,0);
        cout<<ans<<endl;
    system("pause");
    return 0;
}

P5027 Barracuda - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

根据题意列出方程然后枚举每一个方程是错误的，注意判断不合法的几个细节就可以，然后比较的时候一定要fabs，虽然都是正的，但是不加就是会wa,,,

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
const int mod=998244353;
const int inf=1e18;
const int N = 4e5+100;
const double eps=1e-10;
int qpow(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int sgn(double x)
{
    if(fabs(x)<eps) return 0;
    else if(x<0) return -1;
    else return 1;
}
bool integer(double s)
{
    if(abs(round(s)-s)<eps) return 1;
    return 0;
}
int getinv(int a){return qpow(a,mod-2LL);}
double a[105][105],b[105];
int n;
vector<int>v[105];
int gauss()
{
    int nl=1;
    for(int k=1;k<=n;k++)
    {
        int p=nl;
        for(int i=nl+1;i<=n;i++) if(fabs(a[p][k])<fabs(a[i][k])) p=i;
        //加上fabs才对，不知道为何，明明都是正的呀
        if(sgn(a[p][k])==0) continue;
        swap(a[p],a[nl]);
        for(int i=1;i<=n;i++)
        {
            if(i==nl) continue;
            double tmp=a[i][k]/a[nl][k];
            for(int j=1;j<=n+1;j++)
            a[i][j]-=tmp*a[nl][j];
        }
        nl++;
    }
    nl--;
    if(nl<n) return 0;
    double res=0;
    int ma=n+1;
    for(int i=1;i<=n;i++)
    {
        double tmp=a[i][n+1]/a[i][i];
        if(tmp<0||sgn(a[i][n+1])==0) return 0; 
        int ztmp=tmp;
        if(sgn(tmp-ztmp)!=0) return 0;
        if(res<tmp)
        {
            res=tmp;ma=i;
        }
    }
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        double tmp=a[i][n+1]/a[i][i];
        if(sgn(res-tmp)==0) cnt++;
    }
    if(cnt>1) return 0;
    return ma;
}
void print()
{
    cout<<"-----------------------------\n";
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n+1;j++)
        cout<<a[i][j];
        cout<<endl;
    }
    cout<<"------------------------------\n";
}
signed main()
{
    //ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    cin>>n;
    for(int i=1;i<=n+1;i++)
    {
        int m;cin>>m;
        for(int j=1;j<=m;j++)
        {
            int x;cin>>x;v[i].push_back(x);
        }
        cin>>b[i];
    }
    int ans=-1,mark=0;
    for(int i=1;i<=n+1;i++)
    {
        for(int j=1;j<=n;j++)
        for(int k=1;k<=n+1;k++) a[j][k]=0;
        int cnt=0;
        for(int j=1;j<=n+1;j++)
        {
            if(i==j)continue;
            cnt++;
            for(int k=0;k<v[j].size();k++)
            {
                a[cnt][v[j][k]]=1;
                //cout<<v[j][k]<<" "<<v[j].size()<<" "<<j<<endl;
            }
            a[cnt][n+1]=b[j];
        }
        //print();
        int flag=gauss();
        //print();
        if(flag)
        {
            mark++;
            ans=flag;
            if(mark>1){ans=-1;break;}
        }
    }
    if(ans==-1) cout<<"illegal\n";
    else cout<<ans<<endl;
    system("pause");
    return 0;
}

P2447 [SDOI2010] 外星千足虫 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

一开始就构造成m行n+1列的方程组直接高斯消元，记录最大用到的行就是最小的K，N太大就用bitset优化，有一篇题解是不需要bitset的，但是我不知道他的做法为什么对就没采用，还是老老实实的用bitset吧

题解 P2447 【[SDOI2010]外星千足虫】 - YoungNeal 的博客 - 洛谷博客

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
const int mod=998244353;
const int inf=1e18;
const int N = 4e5+100;
const double eps=1e-10;
int qpow(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int sgn(double x)
{
    if(fabs(x)<eps) return 0;
    else if(x<0) return -1;
    else return 1;
}
bool integer(double s)
{
    if(abs(round(s)-s)<eps) return 1;
    return 0;
}
int getinv(int a){return qpow(a,mod-2LL);}
int n,m,b[2005],ans;
char s[2005][1005];
bitset<1005>a[2005];
bool gauss()
{
    ans=0;
    int nl=1;
    for(int k=1;k<=n;k++)
    {
        int p=nl;
        for(int i=nl;i<=m;i++) if(a[i][k]==1){p=i;break;}
        if(a[p][k]==0) return 0;
        ans=max(ans,p);
        swap(a[p],a[nl]);
        for(int i=1;i<=m;i++)
        {

            if(i==nl||a[i][k]==0) continue;
            // for(int j=k;j<=n+1;j++)
            // a[i][j]^=a[nl][j];
            a[i]^=a[nl];
        }
        nl++;
    }
    nl--;
    return nl>=n;
}
void print()
{
    cout<<"-----------------------------\n";
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n+1;j++)
        cout<<a[i][j];
        cout<<endl;
    }
    cout<<"------------------------------\n";
}
signed main()
{
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>(s[i]+1);
        for(int j=1;j<=n;j++) a[i][j]=(s[i][j]-'0');
        int x;cin>>x;
        a[i][n+1]=x;
    }
    if(gauss())
    {
        cout<<ans<<endl;
        for(int i=1;i<=n;i++)
        {
            if(a[i][n+1]^a[i][i]) cout<<"Earth\n";
            else cout<<"?y7M#\n";
        }
    }
    else cout<<"Cannot Determine\n";
    system("pause");
    return 0;
}

P2973 [USACO10HOL]Driving Out the Piggies G - 高斯消元解方程组，概率

假设期望是经过这个点几次才会爆炸，那么期望其实是和概率在数值上是一样的了，也就是把每走一步的代价看作1，也就相当于在求期望了，f[i]表示经过了多少次i点会爆炸，然后根据题意就可以列出

f[i]=1+sum(f[j]*(1-P)*(1/in[j])) (i==1)

f[i]=sum(f[j]*(1-P)*(1/in[j])) (i!=1)

P是爆炸的概率，in[j]是j的度数，j可以到达i，j一共可以到达in[j]个点，j到达i的概率就是1/in[j],f[i]就可以通过j来转移，当i==1时因为一开始的起点就是1，所以1这个点一开始就经过了一次，所以要加上1

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
const int mod=998244353;
const int inf=1e18;
const int N = 4e5+100;
const double eps=1e-10;
int qpow(int a,int b)
{
    int res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return res;
}
int sgn(double x)
{
    if(fabs(x)<eps) return 0;
    else if(x<0) return -1;
    else return 1;
}
bool integer(double s)
{
    if(abs(round(s)-s)<eps) return 1;
    return 0;
}
int getinv(int a){return qpow(a,mod-2LL);}
int e[305][305],n,m,in[305];
double p,q,a[305][305],P;
void gauss()
{
    int nl=1;
    for(int k=1;k<=n;k++)
    {
        int p=nl;
        for(int i=nl+1;i<=n;i++) if(a[p][k]<a[i][k]) p=i;
        if(sgn(a[p][k])==0) continue;
        swap(a[p],a[nl]);
        for(int i=1;i<=n;i++)
        {
            if(i==nl) continue;
            double tmp=a[i][k]/a[nl][k];
            for(int j=1;j<=n+1;j++)
                a[i][j]-=tmp*a[nl][j];
        }
        nl++;
    }
    for(int i=1;i<=n;i++)
    {
        double tmp=a[i][n+1]/a[i][i]*P;
        cout<<tmp<<endl;
    }
}
signed main()
{
    //ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    //freopen("in.txt","r",stdin);
    cin>>n>>m>>p>>q;
    P=p/q;
    for(int i=1;i<=m;i++)
    {
        int u,v;
        cin>>u>>v;
        in[u]++;in[v]++;
        e[u][v]=e[v][u]=1;
    }
    for(int i=1;i<=n;i++) a[i][i]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(e[i][j]) a[i][j]-=a[j][j]*(1.0-P)/in[j];
        }
    }
    a[1][n+1]=1;
    gauss();
    system("pause");
    return 0;
}

killer_queen4804
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[poj 1830]开关问题 高斯消元+自由变量枚举
一维空间
07-02 1278
开关问题 Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 5407   Accepted: 2015 Description 有N个相同的开关，每个开关都与某些开关有着联系，每当你打开或者关闭某个开关的时候，其他的与此开关相关联的开关也会相应地发生变化，即这些相联系
POJ 1830-开关问题(高斯消元求自由元个数)
Rocky0429
07-21 2011
题目地址：POJ 1830 思路：点击打开链接 利用矩阵思想A*x=b,其中A为n*n的变换矩阵，x,b均为列矩阵; x 表示对n个开关的操作,1表示动它,0表示不动它,显然最后是求解的个数. A[i][j]=1表示若操作开关j会引起i的变化. b 表示若开关i的初始状态和目标状态不同,则b[i]=1,否则b[i]=0.即b表示最终所有开关的变化状态.0为不变,1为变. b[i] =
POJ 1830 开关问题 高斯消元如何求自由变元
Orzage的博客
08-24 843
题目大意：给出n个开关的初始状态以及目标状态，按下一个开关会相应改变其它某些开关的状态（包括自己），问有多少种方案达到目标状态（每个开关最多按一次）。   这道题目是高斯消元求自由变元的模板题。 首先我们可以列出每个开关i的方程，(A1*t1+A2*t2+A3*t3...+An*tn) mod 2=Bi 其中当改变了第j个开关也会改变第i个开关的状态时，Aj=1，否则=0。当第i个开关的初...
线性代数 —— 高斯消元法
热门推荐
Alex_McAvoy的博客
03-29 6万+
【概述】 高斯消元法主要用于求解线性方程组，也可以求矩阵的秩、矩阵的逆等，是一个重要的数学方法。 其时间复杂度主要与方程组个数、方程组未知数个数有关，一般来说，时间复杂度为 O(n^3) 【线性方程组】 线性方程组：有多个未知数，且每个未知数的次数均为一次，这样多个未知数所组成的方程组。 其形式为： 记为矩阵形式，有： 【高斯消元法】 高斯消元法的基本思想是：通过一系列的加减...
高斯消元入门③-异或线性方程,无解,自由元,计数-POJ1830
qq_35577488的博客
12-31 897
题目大意: 给你n(n≤29)n(n \leq 29)n(n≤29)个开关。每个开关改变状态会跟着改变其他若干个开关的状态。给你一个开始状态，一个结束状态。问你有多少种操作方案.(每个开关至多改变一次状态，且无视操作顺序). 题目思路: 套路与POJ1222几乎一样。将每个开关按或不按设成未知数,列出异或线性方程求解即可。 这里关键对解的存在性进行讨论: 答案是2free2^{free}2free. freefreefree代表自由元的个数. 1.如何求自由元：（自由元的含义是：可以取定义域中的任何值的未知
高斯消元处理自由变元的方法
weixin_42465242的博客
02-27 754
在普通的高斯消元中，我们可以直接将矩阵削成对角线矩阵。 void gauss(double sz[1002][1002],int n,double ans[1002]) { for(int i=0;i<n;i++) { int wz=i; for(int j=i+1;j<n;j++) { ...
[USACO3.2.4 Feed Ratios]
shiyuan的专栏
04-22 778
Description 农夫约翰从来只用调配得最好的饲料来喂他的奶牛。饲料用三种原料调配成：大麦，燕麦和小麦。他知道自己的饲料精确的配比，在市场上是买不到这样的饲料的。他只好购买其他三种混合饲料（同样都由三种麦子组成），然后将它们混合，来调配他的完美饲料。  给出三组整数，表示 大麦：燕麦：小麦 的比例，找出用这三种饲料调配 x：y：z 的饲料的方法。  例如，给出目标饲料 3：4：
gauss_seq.c.zip_高斯消元
09-23
此外，高斯-约旦消元（Gauss-Jordan elimination）是高斯消元的一种扩展，它不仅将矩阵转化为上三角形，还能进一步将其化为单位矩阵，从而直接得到解。 总结来说，`gauss_seq.c`是一个用C语言实现的高斯消元法串行...
高斯消元_高斯消元法_线性方程组_
10-04
总结而言，高斯消元法是一种基础且实用的算法，对于求解线性方程组有着广泛的应用。掌握这一方法不仅有助于理解线性代数的基础理论，还能在数据处理、数值计算等领域提供有力的工具。在编程实现时，应注重优化，以...
线性方程组：高斯消元：线性方程组：高斯消元-matlab开发
05-30
下面将详细介绍如何使用MATLAB进行高斯消元求解线性方程组的步骤： 1. **创建系数矩阵与常数向量**： 首先，我们需要构建线性方程组的系数矩阵A和常数向量b。例如，如果我们有以下线性方程组： \[ \begin{align*}...
三种消元法（全主元、Gauss消去法、列主元）
04-23
三种消元法（全主元、Gauss消去法、列主元）三种消元法（全主元、Gauss消去法、列主元）三种消元法（全主元、Gauss消去法、列主元）三种消元法（全主元、Gauss消去法、列主元）
Java单精度高斯消元.doc
06-09
总结来说，Java实现的单精度高斯消元法通过读取用户输入的线性方程组，进行行变换和回代计算，最终得到方程组的解。这个过程涉及到数组操作、条件判断、循环控制等基础编程概念，以及线性代数中的高斯消元法理论。...
3_线性方程组高斯消元详解1
08-03
总结来说，线性方程组的高斯消元法是数值分析中的基础工具，它提供了直接求解线性系统的途径。顺序高斯消去法和列主元高斯消去法是两种常见的实现方式，各有优缺点，适用于不同类型的线性方程组。在编程实现时，要...
第 45 届ICPC济南站 A.Matrix Equation异或高斯消元+求自由元+bitset优化
yang5256的博客
09-23 207
第 45 届ICPC济南站 A.Matrix Equation异或高斯消元+求自由元+bitset优化
高斯消元（自由元，无解）
zyz_bz的博客
03-20 2130
文章目录题目描述：输入：输出：基本思想无解情况自由元情况 题目 描述： 给出一个线性方程组，有n个方程组，m个未知数。解这个线性方程组。 输入： 第1行：2个整数n和m，(n, m <=400，且n不一定等于m) 接下来n行，每行m+1个整数，表示一个方程的m个未知数的系数和常数（数值不超过1000） 输出： 如果无解，输出“No solution”。 如果有唯一解，输出m行，每行一个未知数...
ICPC济南A-Matrix Equation:高斯消元,bitset优化
weixin_50547586的博客
07-10 196
传送门：LINK 前言： 今天和队友打这场，2h过了4道题就开始罚坐了。 因为对内没有人精通高斯消元，更没人会高斯消元+bitset优化，所以这道关键题没人做出来。 所需知识： 1，模2加法等价于异或。 2，高斯消元 3，bitset的运用 AC代码： #include<bits/stdc++.h> using namespace std; #define ll long long const int mod = 998244353; ll ksm(ll a, ll b) {
高斯消元小小结
weixin_30340819的博客
09-20 147
所谓高斯消元，就是一种解线性方程组的算法。 学过线性代数的同学都知道，线性方程组本质就是一个向量X1左乘一个系数矩阵A得到另一个向量X2，我们要求解的就是所有未知数构成的向量X1。 设一个n元一次方程组，我们把所有未知数的系数以及等号右边的常数在保持相对位置不变的情况下组成一个n行n+1列的矩阵， a11 a12 a13 ...... a1n b1a21 a22 a23 ........
高斯消元法小总结和瞎总结
如不如此都如此的博客
05-24 5211
啊 搞到这个算法 ，大概已经在一周前了 ，一周前做去年西安邀请赛的题，其中有一题是要用到高斯消元法求系数，然后再用矩阵快速幂求正解 ，队里ZK命自认要学数学的我 两天搞清楚那个题。。然后我就从高斯消元法入手了，大概看了两天吧，也有一定的了解了？（其实说麻烦挺麻烦，说简单也挺简单的。。主要是我天资愚钝，查阅了好多好多相关博客，模板，题解 ，还是不是很懂。。。）时间大概过了有一周吧，凭借记忆来复述一把...
求关键路径
weixin_52621204的博客
11-24 4250
求关键路径
c语言用高斯消去法求解电路
最新发布
12-12
总结来说，利用高斯消去法可以将电路问题转化为线性方程组的求解问题，通过不断进行消元和回代，最终得到电路中未知量的解。这种方法可以应用于复杂的电路问题，帮助我们分析电路的特性和性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

killer_queen4804

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值