递归递推类似题目总结（费解的开关，飞行员兄弟，翻硬币）

提到递推，最先想到的是斐波那契数列，递推就是通过前面固定的量推出后面的量。

提到递归，一般指的是dfs。

接下来几道题用到了递归/递推的方法。这几道题比较类似，主要都是拨动开关，放在一起总结一下。

1.费解的开关

2.飞行员兄弟

3.翻硬币

费解的开关

你玩过“拉灯”游戏吗？

25 盏灯排成一个 5×5 的方形。

每一个灯都有一个开关，游戏者可以改变它的状态。

每一步，游戏者可以改变某一个灯的状态。

游戏者改变一个灯的状态会产生连锁反应：和这个灯上下左右相邻的灯也要相应地改变其状态。

我们用数字 1 表示一盏开着的灯，用数字 0 表示关着的灯。

下面这种状态

10111
01101
10111
10000
11011

在改变了最左上角的灯的状态后将变成：

01111
11101
10111
10000
11011

再改变它正中间的灯后状态将变成：

01111
11001
11001
10100
11011

给定一些游戏的初始状态，编写程序判断游戏者是否可能在 6 步以内使所有的灯都变亮。

输入格式

第一行输入正整数 n，代表数据中共有 n 个待解决的游戏初始状态。

以下若干行数据分为 n 组，每组数据有 5 行，每行 5 个字符。

每组数据描述了一个游戏的初始状态。

各组数据间用一个空行分隔。

输出格式

一共输出 n 行数据，每行有一个小于等于 6 的整数，它表示对于输入数据中对应的游戏状态最少需要几步才能使所有灯变亮。

对于某一个游戏初始状态，若 6 步以内无法使所有灯变亮，则输出 −1。

数据范围

0<n≤500

输入样例：

3
00111
01011
10001
11010
11100

11101
11101
11110
11111
11111

01111
11111
11111
11111
11111

输出样例：

3
2
-1

 分析及思路

观察题目，我们可以发现

1.按法与顺序无关

2.每个格子最多按 1 次（按 2 次 = 没按，现在需要最少次数）

因此我们可以先把第一行全部按了，枚举第一行所有按法，这行全部按过1次后等于固定了，然后第一行中为0的开关要想变1，只能按这个开关下面这个开关（即第二行），这是唯一确定的，所以我们可以推出一个结论：每一行开关操作由前一行灯的亮暗决定（递推）

难理解部分

这里1<< 5 即第一行所有操作方法有32种,每种表示为10000，00101等等操作，看到0,1表达可以利用二进制。

通过二进制刚好可以表达操作（0为不按，1为按）

比如00010就是按下第一行第2个位置

k >> j & 1 的意思是将 k 右移 j 位并检查是否为1,也可以直接看成把第 j 位移到最后一位上，然后再 &1 （1&1=1，0&1=0），这样可以得到这个位置开关按不按

举例

 00010 >> 1 & 1  是1 所以turn(0, 1) 就是第一行第二个位置

#include <iostream>
#include <cstring>
using namespace std;

const int INF = 100000;//随便找一个达不到的大数
char g[10][10];//存储25盏灯的初始状态
int dx[5]={0,-1,0,1,0}, dy[5]={0,0,1,0,-1};
char backup[10][10];//用来备份这25盏灯

void turn(int x,int y)
{
    for(int i = 0; i < 5; i ++)
    {
        int a = x + dx[i], b = y + dy[i];
        if(a >= 0 && a < 5 && b >= 0 && b < 5)
        {
            g[a][b] ^= 1; //异或,0^1=1,1^1=0
        }
    }
}

int work()
{
    int ans = INF;
    for(int k = 0; k < 1 << 5; k ++)//1<<5=2^5=32，第一行所有操作
    {
        int step = 0;
        memcpy(backup, g, sizeof g);
        
        for(int j = 0; j < 5; j ++)//枚举第一行所有操作
        {
            if(k >> j & 1) //看第j位上是1还是0，1表示按下开关
            {
                step ++;
                turn(0, j);//按下第一行(第0行)第j个开关
            }
        }
        
        for(int i = 0; i < 4; i ++)//最后一行改变不了，只能枚举到第4行
            for(int j = 0; j < 5; j ++)
                if(g[i][j] == '0')
                {
                     step++;
                     turn(i + 1, j);//上一行为0，下一行按下开关
                }
        
        bool is_successful = true;//检查最后一行以及是否成功
        for(int j = 0; j < 5; j ++)
        {
            if(g[4][j] == '0')//检查最后一行
            {
                is_successful = false;
                break;
            }
        }
        
        if(is_successful) ans = min(ans, step);//每一次存一下最小步数
        
        memcpy(g, backup, sizeof g);//恢复现场
                
    }
    if(ans > 6) return -1;
    
    return ans;
}    
int main()
{
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int t;
    cin >> t;
    while(t --)
    {
        for(int i = 0;i < 5;i ++) cin>>g[i];
        cout << work() << endl;
    }
    
}

飞行员兄弟

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

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

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

把手可以表示为一个 4×4 的矩阵，您可以改变任何一个位置 [i,j] 上把手的状态。

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

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

输入格式

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

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

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

输出格式

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

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

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

数据范围

1≤i,j≤4

输入样例：

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

输出样例：

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

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 5;
char a[N][N];
int st[N][N], backup[N][N];//存开关操作 , backup复制st 
int ans = 0x3f;

void turn(int x, int y)
{
    for(int i = 0; i < 4;i ++)
    {
        if(a[x][i] == '+') a[x][i] = '-';
        else a[x][i] = '+';
        
        if(a[i][y] == '+') a[i][y] = '-';
        else a[i][y] = '+';
    }
    //a[x][y]按了2次，要恢复
    if(a[x][y] == '+') a[x][y] = '-';
    else a[x][y] = '+';
    return;
}

void dfs(int u,int step)//执行到了第几个格子,执行的次数
{
    if(u > 16)
    {
        for(int i = 0; i < 4; i ++)
            for(int j = 0; j < 4;j ++)
                if(a[i][j] == '+') return;
                
        if(step < ans)
        {
            ans = step;
            memcpy(backup,st,sizeof backup);
        }
    }
    
    int k = 0;
    for(int i = 0; i < 4; i ++)
    {
        for(int j = 0;j < 4;j ++)
        {
            k ++;
            if(k == u)//当 k 的值等于 u 时，说明找到了当前要处理的格子，其二维坐标为 (i, j)
            {
                turn(i,j);//选
            st[i][j] = 1;
            dfs(u + 1, step + 1);
            
            st[i][j] = 0;//不选
            turn(i,j);
            dfs(u + 1, step);
            
            }
            
        }
    }
    
    
}
int main()
{
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    for(int i = 0; i < 4; i ++)
    {
        for(int j = 0; j < 4;j ++)
        {
            cin >> a[i][j];
        }
    }
    dfs(1, 0);
    cout << ans <<endl;
    
    for(int i = 0;i < 4;i ++)
        for(int j = 0;j < 4;j++)
            if(backup[i][j] == 1)
                cout << i + 1 << ' ' << j + 1 <<endl; 
                
    return 0;
    
}

 翻硬币

小明正在玩一个“翻硬币”的游戏。

桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。

比如，可能情形是：**oo***oooo

如果同时翻转左边的两个硬币，则变为：oooo***oooo

现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？

我们约定：把翻动相邻的两个硬币叫做一步操作。

输入格式

两行等长的字符串，分别表示初始状态和要达到的目标状态。

输出格式

一个整数，表示最小操作步数

数据范围

输入字符串的长度均不超过100。
数据保证答案一定有解。

输入样例1：

**********
o****o****

输出样例1：

5

输入样例2：

*o**o***o***
*o***o**o***

输出样例2：

1

 这题就很简单，直接遍历一遍，找到不同的就翻转一下就行，放在合集里是因为这题也算翻转/开关的题目

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int ans;

int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	string s1,s2;
    cin >> s1 >> s2;
	
	for(int i =0 ;i < s1.size(); i ++)
	{
	    if(s1[i] != s2[i])
	    {
	        ans ++;
	        if(s1[i] == '*') s1[i] = 'o';
	        else s1[i] = '*';
	        if(s1[i + 1] == '*') s1[i + 1] = 'o';
	        else s1[i + 1] = '*';
	    }
	}
	cout << ans <<endl;
	
	return 0;
}