飞行员兄弟

飞行员兄弟

“飞行员兄弟”这个游戏，需要玩家顺利的打开一个拥有 $16$ 个把手的冰箱。

已知每个把手可以处于以下两种状态之一：打开或关闭。

只有当所有把手都打开时，冰箱才会打开。

把手可以表示为一个 $4 \times 4$ 的矩阵，您可以改变任何一个位置 $\left\lbrack {i,j} \right\rbrack$ 上把手的状态。

但是，这也会使得第 $i$ 行和第 $j$ 列上的所有把手的状态也随着改变。

请你求出打开冰箱所需的切换把手的次数最小值是多少。

输入格式

输入一共包含四行，每行包含四个把手的初始状态。

符号 $+$ 表示把手处于闭合状态，而符号 $-$ 表示把手处于打开状态。

至少一个手柄的初始状态是关闭的。

输出格式

第一行输出一个整数 $N$，表示所需的最小切换把手次数。

接下来 $N$ 行描述切换顺序，每行输出两个整数，代表被切换状态的把手的行号和列号，数字之间用空格隔开。

注意：如果存在多种打开冰箱的方式，则按照优先级整体从上到下，同行从左到右打开。

数据范围

$1 \leq i,j \leq 4$

输入样例：

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

输出样例：

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

 

解题思路

　　按照题意，当要改变某个坐标$\left( {x, y} \right)$的状态，第$x$行和第$y$列的状态都要改变。我们发现每个位置最多只能改变一次状态，因为改变两次的话就变成原来的状态，其实就是没有改变过。改变三次的话其实等价于改变一次的状态。所以为了得到最小的改变次数，我们规定每个位置的状态最多只能改变一次。也就是$\left( {x, y} \right)$这个位置最多只能改变一次状态。同时，改变状态位置的顺序是不影响结果的，也就是说对于一组确定的方案（确定改变哪些位置的状态），选择位置的先后改变顺序可以是任意的，得到的结果都是相同的。因为每个位置的状态只与改变这个位置状态的次数有关，所以先后顺序是无所谓的。

　　其实对于所有的开关问题都有两个性质（开关问题指当改变某个位置状态的时，某些位置的状态也会同时改变）：

1. 每个开关最多只按一次。
2. 按开关的顺序可以是任意的。

　　由于数据范围很小，所以可以直接用暴力枚举。

　　下面给出用位运算与状态压缩的做法，时间复杂度是$O\left( {2^{16} \times 16} \right)$。

　　我们把$4 \times 4$的格子压缩成一个$16$位的二进制数（$0 \sim 15$）。如果格子的坐标为$\left( {x, y} \right)$，那么就对应二进制数的第$4 \cdot x + y$位。反过来二进制数的第$i$位，对应格子的坐标为$\left( {i/4,~i\% 4} \right)$。

　　我们每个位置可以选择改变或不改变状态，一共有$4 \times 4 = 16$个位置，共$2^{16}$中选择，所以枚举的区间是$0 \sim 2^{16} - 1$，看一下这些数在二进制下中的每一位，如果某一位为$1$，说明要改变这一个位置的状态。

　　如果某一位是$1$，那么我们怎么快速实现改变某行某列状态的操作呢？这个也可以用位运算来实现。因为我们状态的改变为从$0$改变到$1$，从$1$改变到$0$，所以可以用异或来实现。因为每个格子都对应二进制状态的某一位，所以我们只需要找到要改变的某一行和某一列的所有位置，然后把这些位置对应的二进制位置都异或$1$，就可以实现状态$0, 1$的改变了。

　　因此我们可以进行预处理，找到每个位置要改变状态时，对应要异或的数是多少，存到数组里面。到时候枚举到某个要改变状态的位置时就可以直接查表得到，进行异或，时间复杂度就可以达到$O \left( 1 \right)$了。

　　所以当我们确定一个方案后，把这个方案实现一遍，复杂度是$O \left( 16 \right)$的。一共$2^{16}$种方案，所以时间复杂度就为$O\left( {2^{16} \times 16} \right)$。

　　最后枚举$2^{16}$次就可以了。

　　AC代码如下：

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

typedef pair<int, int> PII;

const int N = 20;

int change[N];

int main() {
    int state = 0;
    for (int i = 0; i < 4; i++) {
        char str[N];
        scanf("%s", str);
        
        for (int j = 0; j < 4; j++) {
            if (str[j] == '+') state += 1 << i * 4 + j; // '+'对应1，'-'对应0
        }
    }
    
    // 预处理出来每个位置改变时要异或的数
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            int idx = i * 4 + j;    // 将格子的坐标转换为对应的二进制位置
            for (int k = 0; k < 4; k++) {
                change[idx] += (1 << i * 4 + k) + (1 << k * 4 + j);
            }
            change[idx] -= 1 << i * 4 + j;  // 容斥原理，(i, j)这个位置被加了两次，所以最后要减一次
        }
    }
    
    vector<PII> ret(N);
    for (int i = 0; i < 1 << 16; i++) {
        int t = state;
        vector<PII> vec;
        for (int j = 0; j < 16; j++) {
            if (i >> j & 1) {
                t ^= change[j]; // 二进制某位为1表示要改变这个格子的状态，直接查表异或
                vec.push_back({j / 4, j % 4});
            }
        }
        
        // t == 0意味着整个二进制数为0，表示所有格子都是'-'
        if (t == 0 && ret.size() > vec.size()) ret = vec;
    }
    
    printf("%d\n", ret.size());
    for (auto &it : ret) {
        printf("%d %d\n", it.first + 1, it.second + 1);
    }
    
    return 0;
}

　　由于每个格子有两种选择，一个是改变状态，另外一个是不改变状态，所以还可以用dfs来做。

　　对应的AC代码如下：

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

typedef pair<int, int> PII;

const int N = 10;

vector<PII> ans(20), ret;
char graph[N][N];

void turn(int x, int y) {
    for (int i = 0; i < 4; i++) {
        graph[x][i] = graph[x][i] == '+' ? '-' : '+';
        graph[i][y] = graph[i][y] == '+' ? '-' : '+';
    }
    graph[x][y] = graph[x][y] == '+' ? '-' : '+';
}

void dfs(int x, int y) {
    if (y == 4) {
        x++, y = 0;
        if (x == 4) {
            for (int i = 0; i < 4; i++) {
                if (strcmp(graph[i], "----")) return;
            }
            if (ans.size() > ret.size()) ans = ret;
            
            return;
        }
    }
    
    turn(x, y);
    ret.push_back({x, y});
    dfs(x, y + 1);
    
    turn(x, y);
    ret.pop_back();
    dfs(x, y + 1);
}

int main() {
    for (int i = 0; i < 4; i++) {
        scanf("%s", graph + i);
    }
    
    dfs(0, 0);
    
    printf("%d\n", ans.size());
    for (auto &it : ans) {
        printf("%d %d\n", it.first + 1, it.second + 1);
    }
    
    return 0;
}

　　bfs也可以做。因为每个位置规定最多改变一次，所以如果发现某个情况之前出现过，这就意味着某个位置被改变了两次状态，那么这个情况就不可以被压入队列。

　　对应的AC代码如下：

#include <cstdio>
#include <string>
#include <queue>
#include <unordered_map>
#include <algorithm>
using namespace std;

typedef pair<int, int> PII;

string ed(16, '-');
unordered_map<string, int> dist;    // 记录变化到某个情况已改变的位置的数量
unordered_map<string, string> pre;  // 记录某个情况是通过哪一个情况变化过来的
unordered_map<string, PII> mp;      // 记录某个情况是通过哪一个位置变化过来的

int bfs(string &str) {
    queue<string> q;
    q.push(str);
    dist[str] = 0;
    mp[str] = {-1, -1};
    
    while (!q.empty()) {
        string s = q.front();
        q.pop();
        
        // 如果发现全部格子都是'-'，退出
        if (s == ed) break;
        
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                string t = s;
                t[i * 4 + j] = t[i * 4 + j] == '+' ? '-' : '+';
                for (int k = i * 4; k < (i + 1) * 4; k++) {
                    t[k] = t[k] == '+' ? '-' : '+';
                }
                for (int k = j; k < j + 24; k += 4) {
                    t[k] = t[k] == '+' ? '-' : '+';
                }
                
                // 如果发现某个情况之前记录过，说明某个位置改变了两次状态，不能压入队列
                if (dist.count(t)) continue;
                dist[t] += dist[s] + 1;
                pre[t] = s;
                mp[t] = {i + 1, j + 1};
                q.push(t);
            }
        }
    }
    
    return dist[ed];
}

void print_path(string &str) {
    if (mp[str].first == -1) return;
    
    print_path(pre[str]);
    printf("%d %d\n", mp[str].first, mp[str].second);
}

int main() {
    string str;
    for (int i = 0; i < 4; i++) {
        char s[5];
        scanf("%s\n", s);
        str += s;
    }
    
    printf("%d\n", bfs(str));
    print_path(ed);
    
    return 0;
}

 

参考资料

　　AcWing 116. 飞行员兄弟：https://www.acwing.com/video/93/