高斯消元模板

最新推荐文章于 2025-06-07 10:15:57 发布

spring371327

最新推荐文章于 2025-06-07 10:15:57 发布

阅读量599

点赞数

CC 4.0 BY-SA版权

分类专栏：数论文章标签：高斯消元 POJ 1830

本文链接：https://blog.youkuaiyun.com/spring371327/article/details/52712703

数论专栏收录该内容

17 篇文章

订阅专栏

本文介绍了一个经典的开关状态问题，通过构建图模型并使用线性代数方法解决如何通过有限次操作使所有开关达到指定状态的问题。文章详细解释了解题思路与步骤，并提供了完整的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

开关问题

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 7752		Accepted: 3047

Description

有N个相同的开关，每个开关都与某些开关有着联系，每当你打开或者关闭某个开关的时候，其他的与此开关相关联的开关也会相应地发生变化，即这些相联系的开关的状态如果原来为开就变为关，如果为关就变为开。你的目标是经过若干次开关操作后使得最后N个开关达到一个特定的状态。对于任意一个开关，最多只能进行一次开关操作。你的任务是，计算有多少种可以达到指定状态的方法。（不计开关操作的顺序）

Input

输入第一行有一个数K，表示以下有K组测试数据。
每组测试数据的格式如下：
第一行一个数N（0 < N < 29）
第二行 N个0或者1的数，表示开始时N个开关状态。
第三行 N个0或者1的数，表示操作结束后N个开关的状态。
接下来每行两个数I J，表示如果操作第 I 个开关，第J个开关的状态也会变化。每组数据以 0 0 结束。

Output

如果有可行方法，输出总数，否则输出“Oh,it's impossible~!!” 不包括引号

Sample Input

Sample Output

4
Oh,it's impossible~!!

Hint

第一组数据的说明：
一共以下四种方法：
操作开关1
操作开关2
操作开关3
操作开关1、2、3 （不记顺序）

分析：

某些开关的动作可能影响另一些开关的状态,因此以开关为节点，如果存在这种关系就加入一条有向边，这样就构成了一个图，可以用邻接矩阵表示。当某个开关按下时，其自身状态改变，受其影响的开关的状态也改变。

用两个N维向量表示初始状态和结束状态，两者逐个元素异或，就得到了开关状态的变化。

以第一个样例输入为例分析，3个开关，两两相连，初始状态000，最终状态111，开关对应的邻接矩阵为

将对角线的0全部换成1，得矩阵A=

将矩阵每一列想象为一个开关按下后产生的效果（1表示状态翻转，0表示不变），比如，第二列就表示按下第二个开关，则第二个开关的本身状态要改变（这就是把对角线0换成1的原因），受第二个开关影响的开关j状态也要改变，恰好对应邻接矩阵中A[j, 2]=1

把A写成分块矩阵的形式，每一列作为一个子矩阵，则有A=[a₁,a₂, a₃],此处a_i均为列向量，设第i个开关按下次数为x_i，x_i=0或1（开关按两下和没按是等效的，0/1就够了）

记初始状态b0=[0,0,0],最终状态b1=[1,1,1],则状态变化b=b0^b1=[1,1,1],这里b也是列向量。目标就是求x₁a₁ + x₂a₂ +x₃a₃= b的解的个数（此处的加是模2加，也就是异或，下同）

这个方程可以写成

下面就是解这个线性方程组

对增广矩阵[A b]做初等行变换，化成阶梯形（高斯消元法），如果存在[0,0,…,0,1]的行，就是无解；如果存在r行[0,0,…,0,0]，就意味着有r个自由变量，因为这里的变量只取0/1，所以有2^r个解；如果不存在[0,0,…,0,*]，即把最后一行去掉后不存在全0行，则A为满秩矩阵，则方程组有唯一解。

如果不理解这个地方，建议找本线性代数书，看一下线性方程组的解法，解的结构，通解

代码：

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<math.h>
using namespace std;

const int MAXN=50;

const int mod = 2;//可改 
 
int a[MAXN][MAXN];//增广矩阵
int x[MAXN];//解集
bool free_x[MAXN];//标记是否是不确定的变元


/*
void Debug(int equ,int var)
{
    int i, j;
    for (i = 0; i < equ; i++)
    {
        for (j = 0; j < var + 1; j++)
        {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}
*/


inline int gcd(int a,int b)
{
    int t;
    while(b!=0)
    {
        t=b;
        b=a%b;
        a=t;
    }
    return a;
}
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;i<equ;i++)
        {
            if(abs(a[i][col])>abs(a[max_r][col])) max_r=i;
        }
        if(max_r!=k)
        {// 与第k行交换.
            for(j=k;j<var+1;j++) swap(a[k][j],a[max_r][j]);
        }
        if(a[k][col]==0)
        {// 说明该col列第k行以下全是0了，则处理当前行的下一列.
            k--;
            continue;
        }
        for(i=k+1;i<equ;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;j<var+1;j++)
                {
                    a[i][j] = (mod + (a[i][j]%mod)*ta - (a[k][j]%mod)*tb)%mod;
                }
            }
        }
    }

    //Debug(equ,var);

    // 1. 无解的情况: 化简的增广阵中存在(0, 0, ..., a)这样的行(a != 0).
    for (i = k; i < equ; i++)
    { // 对于无穷解来说，如果要判断哪些是自由变元，那么初等行变换中的交换就会影响，则要记录交换.
        if ( (a[i][col]%mod) != 0) return -1;
    }
    // 2. 无穷解的情况: 在var * (var + 1)的增广阵中出现(0, 0, ..., 0)这样的行，即说明没有形成严格的上三角阵.
    // 且出现的行数即为自由变元的个数.
    if (k < var)
    {
        // 首先，自由变元有var - k个，即不确定的变元至少有var - k个.
        for (i = k - 1; i >= 0; i--)
        {
            // 第i行一定不会是(0, 0, ..., 0)的情况，因为这样的行是在第k行到第equ行.
            // 同样，第i行一定不会是(0, 0, ..., a), a != 0的情况，这样的无解的.
            free_x_num = 0; // 用于判断该行中的不确定的变元的个数，如果超过1个，则无法求解，它们仍然为不确定的变元.
            for (j = 0; j < var; j++)
            {
                if (a[i][j] != 0 && free_x[j]) free_x_num++, free_index = j;
            }
            if (free_x_num > 1) continue; // 无法求解出确定的变元.
            // 说明就只有一个不确定的变元free_index，那么可以求解出该变元，且该变元是确定的.
            temp = a[i][var];
            for (j = 0; j < var; j++)
            {
                if (a[i][j] != 0 && j != free_index) temp -= a[i][j] * x[j];
            }
            x[free_index] = temp / a[i][free_index]; // 求出该变元.
            free_x[free_index] = 0; // 该变元是确定的.
        }
        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(){
    
    int T;
    scanf("%d",&T);
    int equ,var;
    int st[50],ed[50];
    int ii,jj;
    while(T--){
    	scanf("%d",&equ);
    	var = equ;
    	for(int i=0; i<equ; i++)
    		scanf("%d",&st[i]);
    	for(int i=0; i<equ; i++)
    		scanf("%d",&ed[i]);
    	memset(a,0,sizeof(a));
    	while(~scanf("%d %d",&ii,&jj) && ii)
    		a[jj-1][ii-1] = 1;
    	for(int i=0; i<equ; i++)
    		a[i][i] = 1;
    	for(int i=0; i<equ; i++)
    		a[i][equ] = (st[i]+ed[i])%mod;
    	int free_sum = Gauss(equ,var);
    	if(free_sum<0)
    		printf("Oh,it's impossible~!!\n");
    	else
    		printf("%d\n",1<<free_sum);
	}
    return 0;
}