POJ 1166(Gauss消元 取模)

Problem

|——-| |——-| |——-|
| | | | | | |
|—O | |—O | | O |
| | | | | |
|——-| |——-| |——-|
​ A B C
|——-| |——-| |——-|
| | | | | |
| O | | O | | O |
| | | | | | | | |
|——-| |——-| |——-|
​ D E F
|——-| |——-| |——-|
| | | | | |
| O | | O—| | O |
| | | | | | | |
|——-| |——-| |——-|
​ G H I
(Figure 1)`

Move   Affected clocks



 1         ABDE

 2         ABC

 3         BCEF

 4         ADG

 5         BDEFH

 6         CFI

 7         DEGH

 8         GHI

 9         EFHI    

   (Figure 2)

Input

Your program is to read from standard input. Nine numbers give the start positions of the dials. 0=12 o’clock, 1=3 o’clock, 2=6 o’clock, 3=9 o’clock.

Output

Your program is to write to standard output. Output a shortest sorted sequence of moves (numbers), which returns all the dials to 12 o’clock. You are convinced that the answer is unique.

Sample Input

3 3 0
2 2 2
2 1 2

Sample Output

4 5 8 9

思路

这题只有9个钟 每个钟可以转0~3次 所以$4^9$ 枚举也可行？

但这题是一个解方程组的思路

可以做到$9^3$ 的时间复杂度

先确定初末状态

输入给的是初始状态

对于末状态 我们要使得所有钟表归零

我们要求解的未知数x1~x9代表9种操作所做的次数 范围是0~3 因为做四次等于没做

而对于系数矩阵 行号i代表第i个钟表会被$a_{ij} which \ is \ 1$ 的操作影响

这样增广矩阵的右边列向量 代表对于每个钟需要几次操作（由初末状态求得、套路）

mod4

取模操作很关键

如果用浮点型的高斯消元，显然不能取模（或者说很不方便，①有精度问题 ②这里保证整数解，没必要浮点 ③整数取模方便）

所以采用整数的形式

如何行变换相消去呢？

采用公倍数的形式

对于最后求未知数（ans数组）

可以采用两种方式

1.若矩阵化成的是对角型 则可以直接求解（若取模，则要求逆元；若模数很小，可以直接循环，如本题）

2.若矩阵化成的是上三角型 则回代法求解（若取模，则要求逆元；若模数很小，可以直接循环，如本题）

代码示例(对角，直接求未知数)

//高斯消元 时间复杂度O(n^3) 使用整型计算
//公倍数法 适用于只需要整数解、取模的情况
#include<iostream>
#include<math.h>
#include<set>
#include<cstdio>
#include<stdlib.h>
#include<string.h>
using namespace std;
const int maxn=101;
long long det;//行列式的值
int mod;

//特别适合于行列式求值 取模操作 (除法要求逆元)
//不化成对角而是上三角 因为涉及到取模 要保留一些信息
inline int solve(int a[][maxn],bool l[],int ans[],const int &n,const int &m){
    //a为方程组对应的矩阵
    //l,ans存储解  l[]表示是否为自由变元 1表示不是 0表示是
    //n为未知数的个数 m为方程的个数
    //如果无解返回-1 否则返回自由变元数
    int res=0,r=0;//r为第几行 res为自由变元数
    for(int i=0;i<n;++i) l[i]=false;//开始都是自由变元

    for(int i=0;i<n;++i){//枚举列
        for(int j=r;j<m;++j)//枚举行
            if(a[j][i]){
                //找到当前列下从第r行开始第一个不为零的元素并交换到第r行
                //如果一直为0 则下面会continue res++ 即自由变元+1
                //如果有不为0的 把它调上来（交换行）
                for(int k=i;k<=n;++k)//第j行和第r行交换 因为a[j][i]!=0
                    swap(a[j][k],a[r][k]);
                break;
            }

        //从a[r][i]这一个元素开始 往下的每个元素都是0了 所以这个元素xi是自由变元 i+1跳过即可
        if(a[r][i]==0){
            ++res;
            continue;
        }

        for(int j=0;j<m;++j)//j是行数 从0开始 是对角 不是上三角 这样不要从下往上回代
            if(j!=r&&a[j][i]){
                int ta=a[r][i];
                int tb=a[j][i];
                for(int k=0;k<=n;++k){//公倍数法这里要从0开始
                    a[j][k]=((a[j][k]*ta-a[r][k]*tb)%mod+mod)%mod;
                }
            }
        l[i]=true,++r;
    }

    //输出阶梯型矩阵
//    for(int j=0;j<m;++j){
//        for(int k=0;k<=n;++k){
//            cout<<a[j][k]<<' ';
//        }
//        cout<<endl;
//    }

    det=1;
    for(int i=0;i<n;++i)
        det*=a[i][i];

    //检查是否无解
    for(int i=n-res;i<m;++i){
        if(a[i][n]) return -1;
    }

    for(int i=0;i<n;++i){
        if(l[i]){
            for(int j=0;j<n;++j){
                if(a[j][i]>0){//最后更新的是ans 因为到该数下面全为0了
                    //枚举求值 因为题目要求最短的序列 即x尽量小 所以有满足的直接break就行
                    //这里可能出现多解的情况 一般情况是解同余式ax同余c(mod m)
                    for(ans[i]=0;ans[i]<mod;++ans[i]) if((ans[i]*a[j][i]+mod)%mod==a[j][n]) break;
                }
            }
        }
    }
    return res;//返回自由变元数
}

int b[maxn][maxn]={
    {1, 1, 0, 1 ,0, 0, 0, 0, 0},
    {1, 1, 1, 0, 1, 0, 0, 0, 0},
    {0, 1, 1, 0, 0, 1, 0, 0, 0},
    {1, 0, 0, 1, 1, 0, 1, 0, 0},
    {1, 0, 1, 0, 1, 0, 1, 0, 1},
    {0, 0, 1, 0, 1, 1, 0, 0, 1},
    {0, 0, 0, 1, 0, 0, 1, 1, 0},
    {0, 0, 0, 0, 1, 0, 1, 1, 1},
    {0, 0, 0, 0, 0, 1, 0, 1, 1}
};

int main()
{
//    freopen("read.txt","r",stdin);
//    freopen("out2.txt","w",stdout);
    ios::sync_with_stdio(false);
    bool l[maxn];
    int ans[maxn];
    int a[maxn][maxn];
    int n,m,res;
        for(int i=0;i<9;++i)
            for(int j=0;j<9;++j)
                a[i][j]=b[i][j];
//        cin>>n>>m;
//        for(int j=0;j<m;++j)
//            for(int i=0;i<=n;++i)
//                cin>>a[j][i];
    n=m=9;
    mod=4;
    for(int i=0;i<n;++i){
        cin>>a[i][n];
        a[i][n]=(4-a[i][n])%4;
    }
    res=solve(a,l,ans,n,m);

//    for(int i=0;i<n;++i){
//        if(l[i]&&(ans[i])%4!=0) cout<<'x'<<i+1<<':'<<ans[i]%4<<" ";
//    }
//    cout<<endl;

    multiset<int> ahu;
    for(int i=0;i<n;++i){
        if(l[i]&&ans[i]%4!=0){
            for(int j=0;j<(ans[i])%4;++j){
                ahu.insert(i+1);
            }
        }
    }
    for(multiset<int>::iterator it=ahu.begin();it!=ahu.end();it++) cout<<*(it)<<' ';
    return 0;
}

代码示例(上三角，回代求未知数)

//下面是有区别的代码部分

       //Gauss消元 行相消
for(int j=r+1;j<m;++j)//j是行数 从r+1开始 是上三角 不是对角 这样要从下往上回代
            if(a[j][i]){
                int ta=a[r][i];
                int tb=a[j][i];
                for(int k=0;k<=n;++k){//公倍数法这里要从0开始
                    a[j][k]=((a[j][k]*ta-a[r][k]*tb)%mod+mod)%mod;
                }
            }
        l[i]=true,++r;
    }




    //下面求结果 不考虑自由变元
    for(int i=n-1;i>=0;--i){
        int temp=a[i][n];
        for(int j=i+1;j<n;++j){
            if(a[i][j]){
                temp-=(a[i][j]*ans[j])%mod;
                temp=(temp%mod+mod)%mod;
            }
        }
        //枚举求值 因为题目要求最短的序列 即x尽量小 所以有满足的直接break就行
        //这里可能出现多解的情况 一般情况是解同余式ax同余c(mod m)
        for(ans[i]=0;ans[i]<mod;++ans[i])
            if((ans[i]*a[i][i]+mod)%mod==temp) break;
    }