模板 poj2947 Widget Factory 高斯消元

最新推荐文章于 2020-12-31 17:20:39 发布
最新推荐文章于 2020-12-31 17:20:39 发布
阅读量436 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u013044116/article/details/49764517
本文介绍了一种使用高斯消元法解决线性方程组的方法，包括实现步骤和代码示例。针对特定问题，如装饰物生产天数问题，展示了如何建立方程并求解。

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

转载自kuangbin的模板：

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

const int MAXN=50;



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



/*
void Debug(void)
{
    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] = a[i][j]*ta-a[k][j]*tb;
                }
            }
        }
    }

  //  Debug();

    // 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)
    {
        // 首先，自由变元有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(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]);
            }
        }
//        Debug();
        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;
}



这道题的话，
题目大意：有n 种装饰物，m 个已知条件,每个已知条件的描述如下：
p start end
a1,a2......ap (1<=ai<=n)
第一行表示从星期start 到星期end 一共生产了p 件装饰物(工作的天数为end-start+1+7*x,
加7*x 是因为它可能生产很多周)，第二行表示这p 件装饰物的种类(可能出现相同的种类，
即ai=aj)。规定每件装饰物至少生产3 天，最多生产9 天。问每种装饰物需要生产的天数。
如果没有解，则输出“Inconsistent data.”，如果有多解，则输出“Multiple solutions.”，如果
只有唯一解，则输出每种装饰物需要生产的天数。
解题思路：高斯消元。设每种装饰物需要生产的天数为xi(1<=i<=n)。每一个条件就相当于
给定了一个方程式，假设生产1 类装饰物a1 件、2 类装饰物a2 件、i 类装饰物ai 件所花费
的天数为b，则可以列出下列方程：
a1*x1+a2*x2+...an*xn = b (mod 7)
这样一共可以列出m 个方程式，然后使用高斯消元来解此方程组即可。
除了无解的情况，如果有小数解，一定会有整数解，又由于解的值在3到9之间，整数解一定能化到此区间。 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<ostream>
#include<istream>
#include<algorithm>
#include<queue>
#include<string>
#include<cmath>
#include<set>
#include<map>
#include<stack>
#include<vector>
#define fi first
#define se second
#define ll long long
#define pii pair<int,int>
#define inf (1<<30)
#define eps 1e-8
#define pb push_back
using namespace std;
const int maxn=305;
int n,m;
int a[maxn*2][maxn*2];//增广矩阵
int x[maxn*2];//解集
bool free_x[maxn*2];//标记是否是不确定的变元


char s1[10],s2[10];
int gao(char* s1,char* s2)
{
    int ans=0;
    int a,b;
    if(s1[0]=='M')
        a=0;
    else if(s1[0]=='T'&&s1[1]=='U')
        a=1;
    else if(s1[0]=='W')
        a=2;
    else if(s1[0]=='T' && s1[1]=='H')
        a=3;
    else if(s1[0]=='F')
        a=4;
    else if(s1[0]=='S'&&s1[1]=='A')
        a=5;
    else
        a=6;

    if(s2[0]=='M')
        b=0;
    else if(s2[0]=='T'&&s2[1]=='U')
        b=1;
    else if(s2[0]=='W')
        b=2;
    else if(s2[0]=='T' && s2[1]=='H')
        b=3;
    else if(s2[0]=='F')
        b=4;
    else if(s2[0]=='S'&&s2[1]=='A')
        b=5;
    else
        b=6;
    while(a!=b) {
        a=(a+1)%7;
        ans++;
    }
    return ans+1;
}
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;//先除后乘防溢出
}
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] = ((a[i][j]*ta%7-a[k][j]*tb%7)+7)%7;
                }
            }
        }
    }

  //  Debug();

    // 1. 无解的情况: 化简的增广阵中存在(0, 0, ..., a)这样的行(a != 0).
    for (i = k; i < equ; i++)
    { // 对于无穷解来说，如果要判断哪些是自由变元，那么初等行变换中的交换就会影响，则要记录交换.
        if (a[i][col]%7 != 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; // 说明有浮点数解，但无整数解.
        while(temp%a[i][i]!=0) temp+=7; //一定有值成立
        x[i] = temp / a[i][i];
        if(x[i]<3) while(x[i]<3) x[i]+=7;
        else if(x[i]>9) while(x[i]>9) x[i]-=7;
    }
    return 0;
}
int main()
{
    int tmp;
    while(~scanf("%d%d",&n,&m)) {
        if(n==0&&m==0) break;
        memset(a,0,sizeof(a));
        int k;
        for(int i=0;i<m;i++) {
            scanf("%d%s%s",&k,s1,s2);
            int w=gao(s1,s2);
            while(k--) {
                scanf("%d",&tmp);
                a[i][tmp-1]++;
                if(a[i][tmp-1]>=7)
                    a[i][tmp-1]-=7;
            }
            a[i][n]=w;
        }
        int free_num=Gauss(m,n);
        if(free_num==0) {
            for(int i=0;i<n;i++) {
                if(i==n-1)
                    printf("%d\n",x[i]);
                else
                    printf("%d ",x[i]);
            }
        }
        else if(free_num>0) {
            printf("Multiple solutions.\n");
        }
        else {
            printf("Inconsistent data.\n");
        }
    }
    return 0;
}



高斯消元入门②-异或线性方程组-POJ1222
qq_35577488的博客
12-31 602
题目大意: 给你一个5∗65 * 65∗6大小的二维01矩阵代表灯的开关状态。改变任意一个灯的状态，会导致其上下左右的灯的状态的改变。问一种灯的开关方案使得最终所有灯都关闭. 题目思路: 首先，一个灯只会被按0次或1次。两次等于没按。不同灯按下的效果是叠加起来的. 解释:想象按下某个位置,等效于原矩阵异或上一个新矩阵。 例如按下(2,2)(2,2)(2,2)产生的效果. A2,2=[010111010]A_{2,2} = \left[\begin{array}{lll} 0 & 1 & 0
POJ 1830 开关问题 高斯消元如何求自由变元
Orzage的博客
08-24 912
题目大意：给出n个开关的初始状态以及目标状态，按下一个开关会相应改变其它某些开关的状态（包括自己），问有多少种方案达到目标状态（每个开关最多按一次）。   这道题目是高斯消元求自由变元的模板题。 首先我们可以列出每个开关i的方程，(A1*t1+A2*t2+A3*t3...+An*tn) mod 2=Bi 其中当改变了第j个开关也会改变第i个开关的状态时，Aj=1，否则=0。当第i个开关的初...
POJ2947
severus_vinegar的专栏
08-07 1153
啊，模板都用得那么的纠结～～～要模7什么的最后还是看的别人的代码，一点一点的改的。只是觉得高斯消元还是需要上一下手。。。于是写了这道题～～～ 几乎都是模板。。 上代码： #include #include #include #include using namesp
poj2947
weixinding的专栏
01-22 1599
【大意】 生产一些零件，已知有n种零件，m条记录， 记录只记录了某次生产从周几开始，周几结束，以及生产了哪些产品。 每件商品生产所需天数为3-9天。 求每样产品需要多少天才能完成。 【输入】 多组数据 每组数据第一行n,m 之后m行描述m条记录 其中MON TUE WED THU FRI SAT SUN分别表示周一到周日 每条记录第一个数x表示有x件产品，之后两个日期表示起
poj 2947
ruclion的专栏
07-08 393
题目描述：就是求模7的方程组.然后结果在3到9之间.n~300题解：高斯消元.用公倍数和除以逆元来解.重点：代码：#include <iostream> #include <cstdio> #include <cstring> #include <string> #include <cmath> #include <ctype.h> #include <limits.h> #include <cst
Widget Factory POJ 2947
ZJLORD
08-21 284
Widget Factory 应该是第一个 求整数解的高斯消元吧； 题意： n 种工具，m 个员工，给定每个员工的工作时间（开始工作和被开除的时间），给定该员工加工的工具种类，求出每个工具加工需要的时间。规定每个工具加工时间在3~9 天； 刚开始对模板也不怎么熟，所以搞了好长时间。 事实上题目可以抽象成  n 个变元，m 个方程，在模7 的意义下求整
POJ---3185：The Water Bowls【高斯消元】
KobeDuu
03-06 534
题意： 一排有20个碗，给出每个碗的状态，改变一个碗的状态，其左右两边的碗的状态也随之改变(0 -> 1，1 -> 0)，求全部碗的状态为0时的最少操作数 分析: （1）每个碗的状态只有0或1（所以mod 2），设第i个碗旋转了 xi 次，得到以下方程： 说明：如果转动第j个碗影响第i个碗，aij = 1，否则aij = 0；vi 为第 i 碗的初末状态的异...
高斯消元入门③-异或线性方程,无解,自由元,计数-POJ1830
qq_35577488的博客
12-31 1096
题目大意: 给你n(n≤29)n(n \leq 29)n(n≤29)个开关。每个开关改变状态会跟着改变其他若干个开关的状态。给你一个开始状态，一个结束状态。问你有多少种操作方案.(每个开关至多改变一次状态，且无视操作顺序). 题目思路: 套路与POJ1222几乎一样。将每个开关按或不按设成未知数,列出异或线性方程求解即可。 这里关键对解的存在性进行讨论: 答案是2free2^{free}2free. freefreefree代表自由元的个数. 1.如何求自由元：（自由元的含义是：可以取定义域中的任何值的未知
POJ 2947 高斯消元--判断一解多解无解
Jackyguo1992的专栏
04-23 3736
又是偷来的代码，但是第一道高斯消元，纪念下 知道每条式子的结果取模后的值，求方程组，这不同于一般的高斯消元，而且答案必须为整数并在一定区间内 1.由于是整数要用到gcd； 2.解的判断： 有解的情况都是必须满足row一下全为0 一解：化简后是严格的三角矩阵 多解：自由变量个数较少 无解：row以下有非0的 #include #include #include #inclu
poj 2947 Widget Factory（高斯消元）
街角的花街糖
08-14 1076
Widget Factory Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 4032   Accepted: 1337 Description The widget factory produces several different kinds of wid
POJ - 2947 (Widget Factory)
Joker & Liar的博客
02-21 204
题意：有 n 个零件，每个零件需要 [3,9] 内的其中一天完成，现给出 m 个工人开始开始和结束工作的日期(星期几) 还有它们加工的所有零件种类，求出每一种零件加工需要的时间； 分析：裸的高斯消元解同余线性方程组，套板子就行； 代码： #include<cmath> #include<cstdio> #include<cstring> #i...
POJ2947 DAZE [Gauss]
Rainto的专栏
06-28 1038
题目是要求建立一个方程组： (mat[1][1]*x[1] + mat[1][2]*x[2] + … + mat[1][n]*x[n])%7 =mat[1][n+1] (mat[2][1]*x[1] + mat[2][2]*x[2] + … + mat[2][n]*x[n])%7 =mat[2][n+1] … … (mat[m][1]*x[1] + mat[m][
POJ 2947 线性同余方程组 + 高斯消元
neweryyy的博客
12-20 257
题解 传送门 POJ 2947 Widget Factory 题解 设制作第 iii 类装置需要的时间为 xix_ixi​，对于每条记录，统计在工人工作时间内各类装置制作的数量 aia_iai​，设开始、结束的星期数之差为 bib_ibi​，由于不知道工人开始、结束工作相隔多少周，于是得到一个模数为 777 的线性同余方程 ∑i=0n−1aixi=bimod  7\sum\limits_{i=0}^{n-1}a_ix_i=b_i\mod 7i=0∑n−1​ai​xi​=bi​mod7 共 mmm 条记录，故
poj2947(高斯消元解同模方程组)
weixin_30810239的博客
09-23 216
题目链接：http://poj.org/problem?id=2947 题意：有n 种装饰物，m 个已知条件,每个已知条件的描述如下： p start enda1, a2......ap (1<= ai <= n)第一行表示从星期 start 到星期 end 一共生产了p 件装饰物 (工作的天数为end - start + 1 + 7*x, 加 7*x 是因为它可能生产很多周...
POJ 2947-Widget Factory(高斯消元解同余方程式)
Rocky0429
07-22 2563
题目地址：POJ 2947 题意：N种物品，M条记录，接写来M行，每行有K，Start，End，表述从星期Start到星期End，做了K件物品，接下来的K个数为物品的编号。此题注意最后结果要调整到3-9之间。 思路： 很容易想到高斯消元。但是是带同余方程式的高斯消元，开始建立关系的时候就要MOD 7 解此类方程式时最后求解的过程要用到扩展gcd的思想，举个例子，如果最后得到的矩阵为：
poj2947——Widget Factory(高斯消元求模线性方程)
我在浪里
05-04 311
Widget Factory Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 5977   Accepted: 2082 Description The widget factory produces several different kinds of widge
[poj2947][高斯消元]Widget Factory
Gzb1128的栖息地
03-01 216
传送门： http://poj.org/problem?id=2947 这个代码是错的，我也不是很清楚为啥错了，高消的部分被我拿去交seti那题过了。。可能系数求错了？如果有人看我这个博文发现出了偏差请帮忙指正一下谢谢了。 sol: 题目就是给出了一系列同余方程组，解方程即可。 #include&lt;iostream&gt; #include&lt;algorithm&gt; #inc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值