递推题型（一）

1. 翻硬币 - AcWing题库

题目描述

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

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

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

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

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

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

输入格式

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

输出格式

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

数据范围

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

输入样例1：

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

输出样例1：

5

输入样例2：

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

输出样例2：

1

思路

模拟枚举

用两个字符串 a 和 b 来表示当前串和目标串，每次翻转 a 串中的两枚相邻硬币，最终变为 b 串。

从前往后挨个枚举，每次判断该位置的硬币状态是否相同，不同则翻转当前硬币和下一硬币，直到倒数第二个位置为止。

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;

string a, b;

//翻转操作
void turn(int i)
{
    if (a[i] == '*') a[i] = 'o';
    else a[i] = '*';
}

int main()
{
    cin >> a >> b;
    
    int res = 0;
    for (int i = 0; i + 1 < a.size(); i++)
    {
        if (a[i] != b[i])  //判断是否相同
        {
            res++;
            turn(i);      //翻转当前位置和下一位置
            turn(i + 1);
        }
    }
    
    cout << res << endl;
    
    return 0;
}

---

2. 砖块 - AcWing题库

题目描述

$n$ 个砖块排成一排，从左到右编号依次为 $1\sim n$ 。

每个砖块要么是黑色的，要么是白色的。

现在你可以进行以下操作若干次（可以是 0 次）：

选择两个相邻的砖块，反转它们的颜色。（黑变白，白变黑）

你的目标是通过不超过 $3n$ 次操作，将所有砖块的颜色变得一致。

输入格式

第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含一个整数 n。

第二行包含一个长度为 n 的字符串 s。其中的每个字符都是 W 或 B，如果第 $i$ 个字符是 W，则表示第 $i$ 号砖块是白色的，如果第 $i$ 个字符是 B，则表示第 $i$ 个砖块是黑色的。

输出格式

每组数据，如果无解则输出一行 $-1$ 。

否则，首先输出一行 $k$，表示需要的操作次数。

如果 $k>0$，则还需再输出一行 $k$ 个整数，$p_1,p_2,\dots ,p_k$ 。其中 $p_i$ 表示第 $i$ 次操作，选中的砖块为 $p_i$ 和 $p_{i+1}$ 号砖块。

如果方案不唯一，则输出任意合理方案即可。

数据范围

$1\le T\le 10$ ，
$2\le n\le 200$。

输入样例：

4
8
BWWWWWWB
4
BWBB
5
WWWWW
3
BWB

输出样例：

3
6 2 4
-1
0
2
2 1

思路

依次枚举每个砖块，从 1 ~ n-1 ，每次反转当前砖块和下一砖块的颜色，最后判断最后一块砖和第一块砖的颜色是否相同即可。

代码

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

int n;

//反转砖块颜色
void update(char &c)
{
    if (c == 'W') c = 'B';
    else c = 'W';
}

bool check(string s, char ch)
{
    vector<int> res;  //存储每次操作的位置
    
    for (int i = 0; i + 1 < n; i++){
        if (s[i] != ch){
            update(s[i]);
            update(s[i + 1]);
            res.push_back(i);
        }
    }
    
    //如果最后一块砖与第一块砖颜色不同，则说明都变成该颜色不可行
    if (s[n - 1] != s[0]) return false;
    
    cout << res.size() << endl;
    for (auto x : res)
        cout << x << ' ';

    if (res.size()) cout << endl;
    
    return true;
}

void solve()
{
    cin >> n;
    string s;
    cin >> s;
    
    //若既不能都黑，也不能都白，那就无解输出-1
    if (!check(s, 'B') && !check(s, 'W')){
        puts("-1");
        return;
    }
}

int main()
{
    int t;
    cin >> t;
    while (t--){
        solve();
    }
    
    return 0;
}

---

3. 费解的开关 - AcWing题库

题目描述

你玩过“拉灯”游戏吗？

$25$ 盏灯排成一个 $5\times 5$ 的方形。

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

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

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

我们用数字 11 表示一盏开着的灯，用数字 $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\le 500$

输入样例：

3
00111
01011
10001
11010
11100

11101
11101
11110
11111
11111

01111
11111
11111
11111
11111

输出样例：

3
2
-1

思路

每次操作都会改变一个 “十”字范围内灯泡的状态，要使所有灯泡都变亮。

如果从第二行开始枚举，那么第一行灯泡的状态将会变得不可控，即使能将第二行灯泡全部变亮，第一行的灯泡状态仍然是未知的。所以要从第一行开始枚举改变灯泡状态。

由于数据量不大，可以直接枚举灯泡的所有状态，即 $2^5=32$ 种状态。对于每种状态，我们都计算并记录下最后的结果，最后判断最小值即可。

递推思想：

当前行若某一位 (i,j) 为 $0$，那就将其所在列的下一行 (i+1,j) 的灯泡状态改变，使 (i,j) 变为 $1$​ ，即变亮。

如果对 (i,j) 执行 turn 操作，使 (i,j) 变为 $1$，就会破坏上一行的灯的状态。

所以只能从当前一行去改变下一行的灯的状态。

代码

#include <iostream>
#include <cstring>
#include <algorithm>
#define INF 1e8
using namespace std;
const int N = 10;

int n;
char g[N][N], backup[N][N];
int dx[5] = {0, -1, 0, 1, 0}, dy[5] = {0, 0, 1, 0, -1};

//转换灯泡状态
void turn(int x, int y)
{
    for (int i = 0; i < 5; i++)
    {
        int xx = x + dx[i], yy = y + dy[i];
        
        if (xx >= 0 && xx < 5 && yy >= 0 && yy < 5)
        {
            g[xx][yy] ^= 1;  //异或，变成相反数
            
            // if (g[xx][yy] == '1') g[xx][yy] = 0;
            // else g[xx][yy] = 1;
        }
    }
}

int work()
{
    int ans = INF;
    for (int k = 0; k < 1 << 5; k++)  //k表示开关的32种情况,即2^5
    {
        int res = 0;
        memcpy(backup, g, sizeof g);
        
        //对第一行处理
        for (int j = 0; j < 5; j++)
            if (k >> j & 1)
            {
                res++;
                turn(0, j);
            }
        
        //挨个枚举第2~4行
        for (int i = 0; i < 4; i++)
            for (int j = 0; j < 5; j++)
                if (g[i][j] == '0')
                {
                    res++;
                    turn(i + 1, j);  //对下一行处理
                }
                
        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, res);
        
        //枚举完一种情况后还原成初始状态
        memcpy(g, backup, sizeof backup);
    }
    
    if (ans > 6) ans = -1;
    
    return ans;
}

void solve()
{
    for (int i = 0; i < 5; i++) cin >> g[i];
    
    cout << work() << endl;
}

int main()
{
    int t;
    cin >> t;
    while (t--){
        solve();
    }
    
    return 0;
}

---