飞行员兄弟(y总数组解法)解析

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/160005/
来源：AcWing

#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

#define x first//定义first=x
#define y second//定义second=y

using namespace std;

typedef pair<int, int> PII;//PII就是pair<int,int>

const int N = 5;

char g[N][N], backup[N][N];

int get(int x, int y)
{
    return x * 4 + y;//这一步其实是转换成二级制
}

void turn_one(int x, int y)
{
    if (g[x][y] == '+') g[x][y] = '-';//开关开始变
    else g[x][y] = '+';
}

void turn_all(int x, int y)
{
    for (int i = 0; i < 4; i ++ )
    {
        turn_one(x, i);
        turn_one(i, y);
    }

    turn_one(x, y);//上面两次中心的变了两次所以在动一次
}

int main()
{
    for (int i = 0; i < 4; i ++ ) cin >> g[i];

    vector<PII> res;
    for (int op = 0; op < 1 << 16; op ++ )
    {
        vector<PII> temp;
        memcpy(backup, g, sizeof g);        // 备份

        // 进行操作
        for (int i = 0; i < 4; i ++ )
            for (int j = 0; j < 4; j ++ )
                if (op >> get(i, j) & 1)
                {
                    temp.push_back({i, j});//输出那个操作的哪一个
                    turn_all(i, j);//转换
                }

        // 判断所有灯泡是否全亮
        bool has_closed = false;
        for (int i = 0; i < 4; i ++ )
            for (int j = 0; j < 4; j ++ )
                if (g[i][j] == '+')
                    has_closed = true;

        if (has_closed == false)
        {
            if (res.empty() || res.size() > temp.size()) res = temp;//遍历找到最小的哪个替换
        }

        memcpy(g, backup, sizeof g);        // 还原
    }

    cout << res.size() << endl;
    for (auto op : res) cout << op.x + 1 << ' ' << op.y + 1 << endl;

    return 0;
}

我自己听的时候一头雾水，后来看了别的帖子自己慢慢的理解总算是理解出来了，以下是我的个人的见解。

for (int i = 0; i < 4; i ++ )
            for (int j = 0; j < 4; j ++ )
                if (op >> get(i, j) & 1)
                {
                    temp.push_back({i, j});//输出那个操作的哪一个
                    turn_all(i, j);//转换
                }

我一开始是不太理解这里，其实这里就是一个全部遍历一遍的过程，我全部枚举一遍肯定有能成功的，数组备份的原因是要还原，我找到了一个，把它复原，然后接着往下找，然后

 if (has_closed == false)
    {
        if (res.empty() || res.size() > temp.size()) res = temp;
        //遍历找到最小的哪个替换
     }

找到一个，先替换，然后接着遍历找比它还要短就能成功的次数，最后输出。