枚举 | POJ2965.The Pilots Brothers' refrigerator

枚举 | POJ2965.The Pilots Brothers’ refrigerator

Link：The Pilots Brothers’ refrigerator

Description
The game “The Pilots Brothers: following the stripy elephant” has a quest where a player needs to open a refrigerator.There are 16 handles on the refrigerator door. Every handle can be in one of two states: open or closed. The refrigerator is open only when all handles are open. The handles are represented as a matrix 4х4. You can change the state of a handle in any location [i, j] (1 ≤ i, j ≤ 4). However, this also changes states of all handles in row i and all handles in column j.The task is to determine the minimum number of handle switching necessary to open the refrigerator.

Input
The input contains four lines. Each of the four lines contains four characters describing the initial state of appropriate handles. A symbol “+” means that the handle is in closed state, whereas the symbol “−” means “open”. At least one of the handles is initially closed.

Output
The first line of the input contains N – the minimum number of switching. The rest N lines describe switching sequence. Each of the lines contains a row number and a column number of the matrix separated by one or more spaces. If there are several solutions, you may give any one of them.

Sample Input

-+--
----
----
-+--

Sample Output

6
1 1
1 3
1 4
4 1
4 3
4 4

Source
Northeastern Europe 2004, Western Subregion

题意
冰箱门上有4X4共16个门把手，每个门把手有打开和关闭两种状态，每次可更改第[i,j]个门把手的状态，但同时也会更改与之同行同列的所有门把手的状态，问最少更改几次门把手的状态，使所有门把手状态为开，打开冰箱门

思路
和枚举 | POJ1753.Flip Game类似 采用DFS进行枚举，并且使用辅助数组对进行路径记录。代码从枚举 | POJ1753.Flip Game中复制过来进行简单修改即可

参考代码

#include <iostream>
using namespace std;

bool chess[5][5] = {false}; 
int anx[16] = {0};
int any[16] = {0};

int deep, step;
int row, col;
bool flag = false;

//判断是否为同一种颜色
bool isOver()
{
    int i, j;
    for( i = 1; i <= 4; i++ )
        for( j = 1; j <= 4; j++ )
        {
           if( !chess[i][j] )
                return false;
        }
    return true;
}

//翻转
void flip( int row, int col )
{
    int i;
    for( i = 1; i < 5; i++ )
    {
        chess[i][col] = !chess[i][col];
        chess[row][i] = !chess[row][i];
    }
    chess[row][col] = !chess[row][col];
}

//使用DFS的方法遍历从16个棋子中找出step个棋子进行翻转的所有方法
void DFS( int row, int col, int deep )
{
    anx[deep] = row;
    any[deep] = col;
    
    //递归出口: 翻转棋子个数deep自增到step
    //或者 已经找到全部翻转为白色的路径 或者 所有棋子全部已经翻转
    if( deep == step )
    {
        flag = isOver();
        if( flag )
        {
            cout << step << endl;
            for( int i = 0; i < step; i++ )
                cout << anx[i] << " " << any[i] << endl;
        }
        return;
    }

    if( flag || row == 5 )
        return;

    //翻转当前(row,col)位置
    flip( row, col );

    //逐行进行递归
    if( col < 4 )
        DFS( row, col+1, deep+1 );
    else
        DFS( row+1, 1, deep+1 );

    //还原当前位置
    flip( row, col );

    //当前层递归下一个棋子，此时深度不变
    if( col < 4 )
        DFS( row, col+1, deep );
    else
        DFS( row+1, 1, deep );
}

int main()
{
    //input
    int i, j;
    char c;
    for( i = 1; i < 5; i++ )
        for( j = 1; j < 5; j++ )
        {
            cin >> c;
            if( c == '+' )
                chess[i][j] = false;
            else
                chess[i][j] = true;
        }
    //翻转0, 1, 2, 3... 15, 16个棋子
    for( step = 0; step <= 16; step++ )
    {
        DFS( 1, 1, 0 );
        if( flag )
            break;
    }
    return 0;
}