02_递推

费解的开关

你玩过“拉灯”游戏吗？
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 <bits/stdc++.h>

using namespace std;

const int N = 6;

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

//十字操作
void turn(int x, int y)
{
    for(int i = 0; i < 5; i++)
    {
        int a = x + dx[i];
        int b = y + dy[i];
        if(a > 5 || a < 0 || b > 5 || b < 0)
            continue;
        //异或运算:0^1=1,1^1=0
        st[a][b] ^= 1;
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        for(int i = 0; i < 5; i++)
            scanf("%s", st[i]);
        
        //最大步数为6，answer初值大于6    
        int answer = 10;
        //备份
        memcpy(backup, st, sizeof st);
        
        //第一行5个开关，总共2^5种按法
        //遍历所有按法，1代表按，0代表不按
        for(int op = 0; op < 32; op++)
        {
            int step = 0;
            for(int i = 0; i < 5; i++)
            {
                //op的第i位是否为1
                //第i位按不按
                if(op >> i & 1)
                {
                    turn(0,i);
                    step++;
                }
            }
            
            //第一行确定，剩下的具有唯一性
            for(int i = 0; i < 4; i++)
            {
                for(int j = 0; j < 5; j++)
                {
                    if(st[i][j] == '0')
                    {
                        turn(i+1, j);
                        step++;
                    }
                }
            }
            
            //判断最后一行还有没有暗的
            bool dark = false;
            for(int i = 0; i < 5; i++)
            {
                if(st[4][i] != '1')
                {
                    dark = true;
                    break;
                }
            }
            
            if(!dark)
                answer = min(answer, step);
            
            memcpy(st, backup, sizeof st);
        }
        if(answer > 6)
            cout<< -1 <<endl;
        else
            cout<< answer <<endl;
    }
    return 0;
}

翻硬币

小明正在玩一个“翻硬币”的游戏。
桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
比如，可能情形是：**oo***oooo
如果同时翻转左边的两个硬币，则变为：oooo***oooo
现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？

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

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

输出格式
一个整数，表示最小操作步数

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

输入样例1：
**********
o****o****
输出样例1：
5

输入样例2：
*o**o***o***
*o***o**o***
输出样例2：
1

#include <bits/stdc++.h>

using namespace std;

const int N = 110;

char st[N], aim[N];
int step;

void turn(int x)
{
    if(st[x] == '*')
        st[x] = 'o';
    else
        st[x] = '*';
}

int main()
{
    scanf("%s %s", st, aim);
    int len = strlen(st);
    for(int i = 0; i < len; i++)
    {
        if(st[i] != aim[i])
        {
            step++;
            turn(i + 1);
        }
    }
    printf("%d\n", step);
    return 0;
}

数的范围

给定一个按照升序排列的长度为 n 的整数数组，以及 q 个查询。
对于每个查询，返回一个元素 k 的起始位置和终止位置（位置从 0 开始计数）。
如果数组中不存在该元素，则返回 -1 -1。

输入格式
第一行包含整数 n 和 q，表示数组长度和询问个数。
第二行包含 n 个整数（均在 1∼10000 范围内），表示完整数组。
接下来 q 行，每行包含一个整数 k，表示一个询问元素。

输出格式
共 q 行，每行包含两个整数，表示所求元素的起始位置和终止位置。
如果数组中不存在该元素，则返回 -1 -1。

数据范围
1≤n≤100000
1≤q≤10000
1≤k≤10000

输入样例：
6 3
1 2 2 3 3 4
3
4
5
输出样例：
3 4
5 5
-1 -1

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

int n, m;
int q[N];

int main()
{
    int x, l, r, mid;
    scanf("%d %d", &n, &m);
    
    for(int i = 0; i < n; i++)
        scanf("%d", &q[i]);
        
    while(m--)
    {
        scanf("%d", &x);
        l = 0;
        r = n-1;
        while(l < r)
        {
            mid = l + r >> 1;
            if(q[mid] >= x)
                r = mid;
            else
                l = mid+1;
        }
        
        if(q[r] == x)
        {
            cout << r <<" ";
            l = r;
            r = n-1;
            while(l < r)
            {
                mid = l + r + 1>> 1;
                if(q[mid] <= x)
                    l = mid;
                else
                    r = mid-1;
            }
            cout << l << endl;
        }
        else
            cout << "-1 -1\n";
    }
    return 0;
}