金币阵列问题

写在前面：仅为个人代码/总结，未必标准，仅供参考！如有错误，还望指出交流，共同进步！

金币阵列问题

【算法思想】
枚举初始状态每列变换为目标状态第1列的情况，在枚举过程中寻找变换次数的情况。
①首先判断目标矩阵中每一行的0的个数是否与原矩阵对应行的0或1的个数相等，若不相等则目标矩阵不能由原矩阵变换而来，直接输出-1。
②首先将每一列运用列交换为第1列
③然后对每一行进行判断，如果元素与目标元素不相等，则进行行翻转处理
④最后向后判断后面列是否相同
②~④步可具体步骤如下：
（1）将矩阵中的每一列作为第1列，并利用第一个规则将第1列中的相关元素与目标矩阵中第1列的元素进行配对，如果不相同，则利用第1个规则进行翻转；
（2）从第2列开始，将处理后的列与目标列进行比较，如果相同，则转下一列；如果不相同，看是否可以通过列的交换完成，如果不可以，则无法做到，如果可以，则继续扫描，直至所有的列描述完成为止。

注意：在判断后面列是否相同的过程中若相同列号的列不相同，则需要在目标矩阵中往后寻找与原矩阵相应列相同的列，将该列与找到的列进行交换，同时需要尽量的减少交换次数，其过程如以下例子：（文章中所给代码是在课本参考代码的基础上修改优化后的代码，其体现如以下例子）
以下测试样例，课本参考代码不能得到正确的结果：
1 8
1 1 1 1 0 0 0 0
0 1 0 1 0 1 0 1
当第1列与第6列做变换时：
课本所给参考代码：
① 1 1 0 1 0 0 0 1（trans2(1,6)）
② 1 1 1 0 0 0 0 1（same(3,4);trans2(3,4)）
③ 1 1 1 1 0 0 0 0（trans2(4,8)）
共3步
修改后代码：
① 1 1 0 1 0 0 0 1（trans2(1,6)）
② 1 1 1 1 0 0 0 0（trans2(3,8)）
（发现原矩阵与目标矩阵的第4列相同，不交换，往后寻找与原矩阵第3列相同的列，发现第8列符合条件且原矩阵与目标矩阵的第8列不相同，交换）
共2步，更优化，符合题目要求。

【my code】

#include <bits/stdc++.h>
using namespace std;
int k,n,m,Count,best;
int M0[101][101],M1[101][101],M[101][101];
bool flag;
void trans1(int x)//行翻转
{
    for(int i=1;i<=m;i++)
    {
        M1[x][i]=M1[x][i]^1;
    }
    Count++;
}
void trans2(int x,int y)//列交换
{
    for(int i=1;i<=n;i++)
    {
        swap(M1[i][x],M1[i][y]);
    }
    if(x!=y)
        Count++;
}
bool same(int x,int y)//判断两个矩阵的同一列是否相等
{
    for(int i=1;i<=n;i++)
    {
        if(M0[i][x]!=M1[i][y])
            return false;
    }
    return true;
}
void acpy(int a[101][101],int b[101][101])//拷贝矩阵数据
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            a[i][j]=b[i][j];
}
bool judge()//判断两个矩阵是否能够相互变换
{
    bool flag0=true;
    for(int i=1;i<=n;i++)
    {
        int n0=0,n1=0,n2=0;
        for(int j=1;j<=m;j++)
        {
            if(M0[i][j]==0) {n0++;}
            else {n1++;}
            if(M1[i][j]==0) {n2++;}
        }
        if(n2!=n0&&n2!=n1)
        {
            flag0=false;
            break;
        }
    }
    return flag0;
}
int main()
{
    cin>>k;
    for(int i=1;i<=k;i++)
    {
        cin>>n>>m;//n行m列
        for(int x=1;x<=n;x++)
        {
            for(int y=1;y<=m;y++)
            {
                cin>>M0[x][y];
            }
        }
        for(int x=1;x<=n;x++)
        {
            for(int y=1;y<=m;y++)
            {
                cin>>M1[x][y];
            }
        }
        flag=judge();
        if(flag==false) {cout<<-1<<endl;continue;}
        acpy(M,M1);//复制M1矩阵给M
        best=m+n+1;
        for(int j=1;j<=m;j++)
        {
            acpy(M1,M);
            Count=0;
            trans2(1,j);//M1矩阵第1列和第j列交换
            for(int p=1;p<=n;p++)
            {
                if(M0[p][1]!=M1[p][1])//如果某行第一个元素不相等，则将变换矩阵按行取反
                    trans1(p);
            }
            //进行按列比较，是否相同，否则对换，从目标数组转换成初始数组
            for(int p=1;p<=m;p++)
            {
                flag=false;
                int w=0,v=0;
                for(int q=p;q<=m;q++)
                {
                    if(same(p,q))
                    {
                        w=p;
                        v=q;
                        if(!same(q,q)||p==q)
                        {
                           flag=true;
                           break;
                        }
                        else//如果要交换的两列中另一列与原矩阵的同序号列相同，则继续找下一个可交换的列，减少变换次数
                        {
                           flag=true;
                           continue;
                        }
                        //trans2(p,q);
                        //flag=true;
                        //break;
                    }
                }
                if(flag) {trans2(w,v);}
                else {break;}
                //if(!flag) {break;}
            }
            if(flag&&Count<best)
                best=Count;
        }
        if(best<m+n+1)
        {
            cout<<best<<endl;
        }
        else
            cout<<-1<<endl
    }
    return 0;
}
/*
input_1:
2
4 3
1 0 1
0 0 0
1 1 0
1 0 1
1 0 1
1 1 1
0 1 1
1 0 1
4 3
1 0 1
0 0 0
1 0 0
1 1 1
1 1 0
1 1 1
0 1 1
1 0 1
output_1:
2
-1

input_2:
2
1 8
1 1 1 1 0 0 0 0
0 1 0 1 0 1 0 1
1 8
1 1 1 1 0 0 0 0
0 0 0 0 1 1 1 1
output_2:
2
1

input_3:
2
3 4
0 0 1 1
0 1 1 1
0 0 0 0
0 1 1 0
0 1 1 1
0 0 0 0
3 5
0 0 0 1 1
0 1 0 1 1
0 0 1 0 0
0 1 1 0 0
0 1 1 0 1
0 0 0 1 0
output_3:
1
2

input_4:
3
1 1
0
1
1 1
0
0
4 4
0 0 1 1
1 0 0 0
1 1 0 0
1 0 0 1
1 1 0 0
1 1 1 0
0 0 1 1
0 1 0 1
output_4:
1
0
4
*/