POJ 3185 The Water Bowls（高斯消元法，输出0最多的解）

The Water Bowls

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 7860		Accepted: 3094

Description

The cows have a line of 20 water bowls from which they drink. The bowls can be either right-side-up (properly oriented to serve refreshing cool water) or upside-down (a position which holds no water). They want all 20 water bowls to be right-side-up and thus use their wide snouts to flip bowls. 

Their snouts, though, are so wide that they flip not only one bowl but also the bowls on either side of that bowl (a total of three or -- in the case of either end bowl -- two bowls). 

Given the initial state of the bowls (1=undrinkable, 0=drinkable -- it even looks like a bowl), what is the minimum number of bowl flips necessary to turn all the bowls right-side-up?

Input

Line 1: A single line with 20 space-separated integers

Output

Line 1: The minimum number of bowl flips necessary to flip all the bowls right-side-up (i.e., to 0). For the inputs given, it will always be possible to find some combination of flips that will manipulate the bowls to 20 0's.

Sample Input

0 0 1 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0

Sample Output

3

Hint

Explanation of the sample: 

Flip bowls 4, 9, and 11 to make them all drinkable: 
0 0 1 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 [initial state] 
0 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 [after flipping bowl 4] 
0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 [after flipping bowl 9] 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 [after flipping bowl 11]

题意：

给你20个灯排成一列1表示关0表示开，每次可以翻转一个灯和其相邻两边的（如果存在）灯，求最少的步数翻转灯使得所有灯都打开。数据保证有解。

思路：

网上有直接枚举的解法，但是这也确实是一道高斯消元开关灯问题的经典问题。

a[i][j]=1或0 表示灯i是否受灯j影响。所有运算均为异或运算。

对于无穷解的情况，因为我们要尽量使翻转的灯最少（解中的1最少），所以我们把自由变元存起来，利用二进制枚举其为0或1，然后再计算其他未知量的解，取一个1最少的解即可。

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<iomanip>
#include<vector>
#include<queue>
#include<set>
#include<algorithm>
#define max(a,b)   (a>b?a:b)
#define min(a,b)   (a<b?a:b)
#define swap(a,b)  (a=a+b,b=a-b,a=a-b)
//#define memset(a,v)  memset(a,v,sizeof(a))
#define X (sqrt(5)+1)/2.0  //Wythoff
#define Pi acos(-1)
#define e  2.718281828459045
#define eps 1.0e-8
using namespace std;
typedef long long int LL;
typedef pair<int,int>pa;
const int MAXL(1e5);
const int INF(0x3f3f3f3f);
const int mod(1e9+7);
int dir[4][2]= {{-1,0},{1,0},{0,1},{0,-1}};
const int MAXN=50;
int a[MAXN][MAXN];//增广矩阵
int x[MAXN];//解集
int free_x[MAXN];//标记是否是不确定的变元
int gcd(int a,int b)
{
    if(b == 0)
        return a;
    else
        return gcd(b,a%b);
}
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;
    free_x_num=0;
    for(int i=0; i<=var; i++)
    {
        x[i]=0;
        free_x[i]=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]*ta-a[k][j]*tb;
                    a[i][j]^=a[k][j];
                }
            }
        }
    }
    // 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)
    {
        return var - k; // 自由变元有var - k个.
    }*/
    // 3. 唯一解的情况: 在var * (var + 1)的增广阵中形成严格的上三角阵.
    // 计算出Xn-1, Xn-2 ... X0.
    int sta=1<<(var-k);
    int res=INF;
    for(int i=0;i<sta;i++)
    {
        int cnt=0;
        int idx=i;
        for(int j=0;j<var-k;j++)
        {
            x[free_x[j]]=(idx&1);
            if(x[free_x[j]]) cnt++;
            idx>>=1;
        }
        for (int j=k-1;j>=0;j--)
        {
            int tmp=a[j][var];
            for (int l=j+1;l<var;l++)
            {
                if (a[j][l]) tmp^=a[j][l]*x[l];
            }
            x[j]=tmp;
            if(x[j]) cnt++;
        }
        res=min(res,cnt);
    }
    return res;
}
int b[MAXN];
int main(void)
{
    int T,cas=1;
    int i, j;
    int equ,var;
    {
        equ=var=20;
        memset(a, 0, sizeof(a));
        for (i = 0; i < equ; i++) scanf("%d",&a[i][var]);
        for (i = 0; i < equ; i++)
        {
            if(i) a[i-1][i]=1;
            if(i+1<var) a[i+1][i]=1;
            a[i][i]=1;
        }
        int ans = Gauss(equ,var);
        printf("%d\n",ans);
    }
    return 0;
}