POJ 1753 Flip Game(高斯消元法，枚举自由变元)

最新推荐文章于 2020-02-27 22:15:00 发布
最新推荐文章于 2020-02-27 22:15:00 发布
阅读量1.4k 收藏
点赞数
分类专栏： ACM 文章标签： acm 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013840081/article/details/48009767
版权

题目：

Flip Game
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 34731 Accepted: 15207

Description

Flip game is played on a rectangular 4x4 field with two-sided pieces placed on each of its 16 squares. One side of each piece is white and the other one is black and each piece is lying either it's black or white side up. Each round you flip 3 to 5 pieces, thus changing the color of their upper side from black to white and vice versa. The pieces to be flipped are chosen every round according to the following rules:
  1. Choose any one of the 16 pieces.
  2. Flip the chosen piece and also all adjacent pieces to the left, to the right, to the top, and to the bottom of the chosen piece (if there are any).

Consider the following position as an example:

bwbw
wwww
bbwb
bwwb
Here "b" denotes pieces lying their black side up and "w" denotes pieces lying their white side up. If we choose to flip the 1st piece from the 3rd row (this choice is shown at the picture), then the field will become:

bwbw
bwww
wwwb
wwwb
The goal of the game is to flip either all pieces white side up or all pieces black side up. You are to write a program that will search for the minimum number of rounds needed to achieve this goal.

Input

The input consists of 4 lines with 4 characters "w" or "b" each that denote game field position.

Output

Write to the output file a single integer number - the minimum number of rounds needed to achieve the goal of the game from the given position. If the goal is initially achieved, then write 0. If it's impossible to achieve the goal, then write the word "Impossible" (without quotes).

Sample Input

bwwb
bbwb
bwwb
bwww

Sample Output

4

Source

Northeastern Europe 2000

题意：有一个4*4的棋盘，上面放有黑白棋子，问最少翻转多少次可以使棋盘上的棋子都为黑色或都为白色。

思路：数据很小，可以暴力，但这里用高斯消元法求解，这题的难点在于要求最少次数，所以要枚举自由变元。假设有k个自由变元，那么所有的情况就有1<<k种，在高斯消元法求解的时候先记录下自由变元，然后对所有情况进行枚举，对非自由变元求解的时候方程有equ-k个。

代码： 
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include<climits>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>
using namespace std;

#define PB push_back
#define MP make_pair

#define REP(i,x,n) for(int i=x;i<(n);++i)
#define FOR(i,l,h) for(int i=(l);i<=(h);++i)
#define FORD(i,h,l) for(int i=(h);i>=(l);--i)
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define RI(X) scanf("%d", &(X))
#define RII(X, Y) scanf("%d%d", &(X), &(Y))
#define RIII(X, Y, Z) scanf("%d%d%d", &(X), &(Y), &(Z))
#define DRI(X) int (X); scanf("%d", &X)
#define DRII(X, Y) int X, Y; scanf("%d%d", &X, &Y)
#define DRIII(X, Y, Z) int X, Y, Z; scanf("%d%d%d", &X, &Y, &Z)
#define OI(X) printf("%d",X);
#define RS(X) scanf("%s", (X))
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
#define Swap(a, b) (a ^= b, b ^= a, a ^= b)
#define Dpoint  strcut node{int x,y}
#define cmpd int cmp(const int &a,const int &b){return a>b;}

 /*#ifdef HOME
    freopen("in.txt","r",stdin);
    #endif*/
const int MOD = 1e9+7;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<double> VD;
typedef long long LL;
typedef pair<int,int> PII;
//#define HOME

int Scan()
{
	int res = 0, ch, flag = 0;

	if((ch = getchar()) == '-')				//判断正负
		flag = 1;

	else if(ch >= '0' && ch <= '9')			//得到完整的数
		res = ch - '0';
	while((ch = getchar()) >= '0' && ch <= '9' )
		res = res * 10 + ch - '0';

	return flag ? -res : res;
}
/*----------------PLEASE-----DO-----NOT-----HACK-----ME--------------------*/

const int MAXN=50;



int a[MAXN][MAXN];//增广矩阵
int x[MAXN];//解集
int 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]=0;

    }
    free_x_num=0;
    //转换为阶梯阵.
    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--;
            free_x[free_x_num++]=col;
            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]^a[k][j];
                }
            }
        }
    }

  //Debug(equ,var);

    // 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个.
      // Debug(equ,var);
        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;*/
}

char mp[4][4];
int main()
{//freopen("out.txt","w",stdout);
for(int i=0;i<4;i++)
    {for(int j=0;j<4;j++)
    scanf("%c",&mp[i][j]);
    //printf("%c",mp[i][j]);}
   // printf("\n");
    getchar();
    }
MS0(a);
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
{
    int k=i*4+j;
    if(mp[i][j]=='b')
        a[k][16]=0;
    else
        a[k][16]=1;
}
for(int i=0;i<4;i++)
    for(int j=0;j<4;j++)
{
    int t=i*4+j;
    a[t][t]=1;
    if(i!=0)
    a[(i-1)*4+j][t]=1;
    if(i!=3)
    a[(i+1)*4+j][t]=1;
    if(j!=0)
    a[i*4+(j-1)][t]=1;
    if(j%4!=3)
    a[i*4+j+1][t]=1;

}
int ans=Gauss(16,16);
if(ans==-1||ans==-2)
    ans=INT_MAX;
else
{   /*if(ans==0)
    {for(int i=0;i<16;i++)
        ans+=x[i];}*/
   // else
   // {
        int t=ans;
        ans=INT_MAX;
        int tot=(1<<t);

        for(int i=0;i<tot;i++)
            {   int cnt=0;
               int index=i;
                for(int j=0;j<t;j++)
            {
               x[free_x[j]]=(index&1);
               if(x[free_x[j]])
                cnt++;
               index>>=1;
            }

            for(int j=16-t-1;j>=0;j--)
            {
                int temp = a[j][16];
                //int tt=0;
                //while(a[j][tt]==0)
                   // tt++;
        for (int k = j+1; k < 16; k++)
        {
            if (a[j][k] != 0) temp ^=  x[k];
        }
       // if (temp % a[j][j] != 0) return -2; // 说明有浮点数解，但无整数解.
        x[j] = temp/a[j][j] ;
        cnt+=x[j];
            }
            ans=min(ans,cnt);
            }

   // }


}
MS0(a);
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
{
    int k=i*4+j;
    if(mp[i][j]=='b')
        a[k][16]=1;
    else
        a[k][16]=0;
}
for(int i=0;i<4;i++)
    for(int j=0;j<4;j++)
{
    int t=i*4+j;
    a[t][t]=1;
    if(i!=0)
    a[(i-1)*4+j][t]=1;
    if(i!=3)
    a[(i+1)*4+j][t]=1;
    if(j!=0)
    a[i*4+(j-1)][t]=1;
    if(j%4!=3)
    a[i*4+j+1][t]=1;

}
int ans2=Gauss(16,16);
if(ans2==-1||ans2==-2)
    ans2=INT_MAX;
else
{
    /*if(ans2==0)
    {for(int i=0;i<16;i++)
        ans2+=x[i];}
    else
    {*/
        int t=ans2;
        ans2=INT_MAX;
        int tot=(1<<t);

        for(int i=0;i<tot;i++)
            {   int cnt=0;
                 int index=i;
                for(int j=0;j<t;j++)
            {

                    x[free_x[j]]=index&1;
                    if( x[free_x[j]])
                    cnt++;
                    index>>=1;
                }


            for(int j=16-t-1;j>=0;j--)
            {
                int temp = a[j][16];
              //  int tt=0;

               // while(a[j][tt]==0)
                 //   tt++;
        for (int k = j+1; k < 16; k++)
        {
            if (a[j][k] != 0) temp ^=  x[k];
        }
       // if (temp % a[j][j] != 0) return -2; // 说明有浮点数解，但无整数解.
        x[j] = temp/a[j][j] ;
        cnt+=x[j];
            }
            ans2=min(ans2,cnt);
            }

    //}

}
int res=min(ans,ans2);
if(res==INT_MAX)
{
    printf("Impossible\n");
}
else
    printf("%d\n",res);


        return 0;
}



hexiecs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
poj--1753 Flip Game(二维反转)（高斯消元）
further~
04-07 716
给定4乘4的01矩阵，反转成全零或者全1
poj1753 Flip Game 【dfs + 暴力枚举】
OOOak
03-13 422
题意： 给你一个只有黑白棋的4*4的棋盘 你有一种操作 你可以对其中某一个位置的棋子进行翻转 使其变换颜色，而且该棋子上下左右都会进行翻转 请问最少进行几次操作可以使得棋盘颜色一致 如没有就打印“Impossible” 题解： 因为该棋盘只有16个格子， 且每个格子无论翻转多少次，都只有两种状态，而且你对每个位置只有操作和不操作两种选择， 所以 一共会有 2^16 种方案， 所以我...
(麻烦)Flip Game (CD1488)
jiangjiashi的博客
05-08 1209
太麻烦了,刚开始自己还想歪了.后来也是各种细节出错.值得高兴的是做出来了,黑黑 最近又做了一遍，发现自己的思路更清析了，不过还是WA了好几盘。因为在flip的时候应该是flip下一个坐标的 #include #include using namespace std; #define inf 10000 char s[15][15]; int go[16][16]; int
POJ1753 Flip Game【高斯消元法】
程序员充电站（itcharge）
09-15 769
题目大意： 有一个 4*4 的棋盘，棋盘上有黑色和白色的格子，每一次你可以翻其中的一个格子，这 个格子（x，y）如果被翻，那么对应位置为(x-1，y)、(x+1，y)、(x，y-1)、(x，y+1) 格子的颜色会变成相对的颜色，现在求将棋盘全部翻为白色格子或者是黑色格子用的最 少的步数是多少？如果无法把所有格子都翻为白色或者是黑色，那么输出 "Impossible"。 解题思路： 和 POJ1222 一样，一个格子变化最多改变 5 个格子，其中格子改变为 1，格子不改变 为 0，则每个位
HDOJ Lanterns 3364【高斯消元求自由变元】
豫帝哥哥
08-10 1508
Lanterns Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1268    Accepted Submission(s): 497 Problem Description Alice has received
POJ-1753 Flip Game 高斯消元
weixin_33699914的博客
07-26 65
这题我们可以参考开关那题，只不过这里是求最少的操作次数，那么我们需要对变元进行枚举，算出所有的情况下，最少需要改变的次数。 代码如下： #include &lt;cstdlib&gt; #include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt; #define TO(x, y) (x-1)*...
poj1753Flip Game【刷题计划】
loving coding
11-04 447
Flip Game Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 47766   Accepted: 20383 Description Flip game is played on a rectangular 4x4 field wi
POJ1753-Flip Game
07-29
两个解决方案的代码文件“POJ1753-Flip Game(BFS+bit).cpp”和“POJ1753-Flip Game(DFS+enum).cpp”分别实现了BFS和DFS策略。阅读这些代码可以帮助理解如何将理论转换为实际的程序实现。 五、文档说明 “POJ1753-...
poj 1753 Flip Game(枚举,bfs)(简单)
天道酬勤
04-25 4108
poj 1753 Flip Game题目http://poj.org/problem?id=1753 给你一个4*4的棋盘，每个棋子非黑即白，翻一个棋子会带动它上下左右的棋子也翻过来，问至少多少次可以使棋盘全黑或者全白。思路只有16个棋子，所以用2进制状态压缩，用^=进行翻棋子的操作，当然要判断一下在不在棋盘内，接着就是枚举每个状态16个棋子翻的状态，进行判断，如果超了16步就是不可能了，因为
poj 1753 Flip Game（高斯消元）
梦幻的蔷薇色
11-05 283
和 poj 1681 Painter’s Problem 完全一样，http://blog.csdn.net/gyhguoge01234/article/details/78428118#include <stdio.h> #include <string.h> #include <algorithm> using namespace std; //对2取模的01方程组 const int MAXN
POJ.1753 Flip Game (高斯消元 枚举自由元)
Pengwill's Blog
08-16 560
POJ.1753 Flip Game (高斯消元 枚举自由元)标签（空格分隔）： 高斯消元题意分析基本方法是和解决异或方程组是一样的。严格来讲，遇到有多个自由元的时候，不能统一将自由元当做0处理。 自由元在前几篇题解中已经提及他的概念了，包括一些详细的解释。所谓自由元指的是在有无穷解的情况下，随意取值的自变量。举个栗子例子：{u+x+2y+z=30y+z=20 \begin{cases} u+x
POJ3185 高斯消元 +枚举自由变元
缺氧
11-11 511
给20个碗，每次可以翻转连续的某一个以及它两边的，问最少的步数把全部翻转成0 先按照全部翻转成0列方程，用高斯消元解 最后如果有很多个自由变元。 则去枚举自由变元 由于变量只有0或1 则2^num 次枚举变元的值， 然后根据最后这些自由边缘对应的方程应该是上三角矩阵的最下面num行 因此则需要从 n-num-1行到第1行依次回带，得到其余的变量 然后最小的步数便是答案 复
POJ.1753 Flip Game(高斯消元+枚举自由元 两次)
八百标兵奔北坡的博客
07-11 210
题意：给你一个4*4的矩阵，每个位置对应着一个状态（开或者关），然后如果你按动某一个位置，那么上下左右位置都会被影响二改变状态，问最少经过几次达到全开或者全馆的状态。 分析:其实对于每一个位置都可以列一个线性方程，构成一个方程组，a[i][j]就是表示按动j位置时对i位置有影响，然后对于方程组用高斯消元求解，然后对于存在自由元的情况需要枚举判断符合的个数，最后取最小值。 #include <...
POJ 1222 高斯消元法
_rabbit的专栏
03-07 818
EXTENDED LIGHTS OUT Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 6119   Accepted: 4015 Description In an extended version of the game Lights Out, is a puzzl
Flip Game--高斯消元
bless295的博客
12-26 352
Flip Game Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 42090   Accepted: 18169 Description Flip game is played on a rectangular 4x4 field with two-sided
【高斯消元】 HDOJ 5257 翻转游戏
yysys
06-05 667
如果第一行的状态确定了，那么矩阵的所有状态也会随之确定。。。那么我们就将第一行写成变量，这样能够推出矩阵的m个方程。。。然后对于k，可以写出k个限制方程。。因此我们总共列出m+k个方程，高斯消元，bitset优化即可。。。 #include #include #include #include #include #include #include #include #includ
高斯消元（poj1753)
fengsigaoju的博客
03-12 498
参考了kuangbin的博客,注意自由变元那边 #include #include #include #include #include using namespace std; const int MAXN=30; const int INF=0x3fffffff; int a[MAXN][MAXN];//增广矩阵 int x[MAXN]; int free_x[MAXN]; char
高斯消元处理自由变元的方法
weixin_42465242的博客
02-27 782
在普通的高斯消元中，我们可以直接将矩阵削成对角线矩阵。 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++) { ...
poj 1753 Flip Game 高斯消元
JayYe的专栏
06-04 988
这题也是高斯消元的模板题，要枚举自由变元求得最优解。也可以直接暴力枚举，不过有技巧的是，只需要第一行枚举下，每行得到使得该行以上可以的状态，然后继续往下枚举。 我是感觉直接高斯消元还简单明了点~ #include #include #include using namespace std; int a[22][22] , x[22], xx[22], n = 4 ,var, equ
poj1753解题过程
最新发布
03-26
POJ1753题目为"Flip Game"，题目给出了一个4x4的棋盘，每个格子有黑色或白色，每次翻转一个格子会同时翻转它上下左右四个格子的颜色，目标是把整个棋盘都变为同一种颜色，求把棋盘变成同种颜色的最小步数。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值