算法竞赛——递推详解

二、递推

1、简单斐波那契数列
以下数列 0 1 1 2 3 5 8 13 21 … 被称为斐波纳契数列。
这个数列从第 3 项开始，每一项都等于前两项之和。
输入一个整数 N，请你输出这个序列的前 N 项。
输入格式
一个整数 N。
输出格式
在一行中输出斐波那契数列的前 N 项，数字之间用空格隔开。
数据范围
0<N<46
输入样例：
5
输出样例：
0 1 1 2 3
题解：
当i=1时，a[1]=0,当i=2时，a[2]=1,然后就可以进行递推 a[i]=a[i-1]+a[i-1]

#include<iostream>
using namespace std;
const int N=47;
int a[N];
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        if(i==1) a[i]=0;
        if(i==2) a[i]=1;
        else a[i]=a[i-1]+a[i-2];
        cout<<a[i]<<" ";
    }
    return 0;
}

2、费解的开关
你玩过“拉灯”游戏吗？
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

题解：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=6;
char g[N][N],backup[N][N];
int dx[5]={-1, 0, 1, 0, 0},dy[5]={0, 1, 0, -1, 0};
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) continue;   // 在边界外，直接忽略即可
        g[a][b] ^= 1;
    }
}
int main(){
	int T;
	cin>>T;
	while(T--){
		for(int i=0;i<5;i++) cin>>g[i];
		int res=10;
		for(int op=0;op<32;op++){
			memcpy(backup, g, sizeof g);
            int step = 0;
            for(int i=0;i<5;i++){
            	if(op >> i &1){
            		step++;
            		turn(0,i);
				}
			}
			for(int j=0;j<4;j++){
				for(int k=0;k<5;k++){
					if(g[j][k]=='0'){
						step++;
						turn(j+1,k);
					}
				}
			}
			bool dark=false;
			for (int i = 0; i < 5; i ++ )
                if (g[4][i] == '0')
                {
                    dark = true;
                    break;
                }
			 if (!dark) res = min(res, step);
			 memcpy(g, backup, sizeof g);
		}
		if (res > 6) res = -1;
		cout << res << endl;
		
	}
	
	return 0;
}

3、飞行员兄弟
“飞行员兄弟”这个游戏，需要玩家顺利的打开一个拥有 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<cstdio>
#include<algorithm>
#include<vector>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N=5;
char g[N][N],backup[N][N];
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 get(int x,int y){
    return 4*x+y;
}
int main(){
	for(int i=0;i<4;i++) {
		cin>>g[i];
	}
	 vector<PII> res;
	for(int op=0;op<65536;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 swither=false;
			for(int j=0;j<4;j++){
				for(int k=0;k<4;k++){
					if(g[j][k]=='+') swither=true;
				}		
			}
			if(!swither) {
				 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;
}

4、翻硬币
小明正在玩一个“翻硬币”的游戏。
桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
比如，可能情形是：oo*oooo
如果同时翻转左边的两个硬币，则变为：oooo***oooo
现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？
我们约定：把翻动相邻的两个硬币叫做一步操作。
输入格式
两行等长的字符串，分别表示初始状态和要达到的目标状态。
输出格式
一个整数，表示最小操作步数
数据范围
输入字符串的长度均不超过100。
数据保证答案一定有解。
输入样例1：

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

输出样例1：

5

输入样例2：

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

输出样例2：

1

题解：只需要考虑每一个硬币与对应的硬币是否相同，若不相同，直接翻转第二个硬币即可；

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=110;
char a[N],b[N];
void turn(int i){
    if(a[i]=='o') a[i]='*';
    else a[i]='o';
}
int main(){
    int res=0;
    cin>>a;
    cin>>b;
    int lena=strlen(a);
    for(int i=0;i<lena;i++){
        if(a[i]!=b[i]){
            turn(i+1);
            res++;
        }
    }
    cout<<res;
    return 0;
}