程序设计思维与实践 Week12 CSP模测

A 瑞神的序列

1.题目大意

瑞神的数学一向是最好的，连强大的咕咕东都要拜倒在瑞神的数学水平之下，虽然咕咕东很苦 恼，但是咕咕东拿瑞神一点办法都没有。

5.1期间大家都出去玩了，只有瑞神还在孜孜不倦的学习，瑞神想到了一个序列，这个序列长度为 n ，也就是一共有 n 个数，瑞神给自己出了一个问题：数列有几段?

段的定义是连续的相同的最长整数序列

输入：
输入第一行一个整数n，表示数的个数 接下来一行n个空格隔开的整数，表示不同的数字

输出：
输出一行，这个序列有多少段

12
2 3 3 6 6 6 1 1 4 5 1 4

8

2. 思路历程

• 思路很简单，遍历数组，每当遇到与前一个不同的数后就将段数加1，注意一个小细节初始段数为1而不为0。

3. 反思

• （做对啦，反思的话就希望以后也保持清醒，秒杀简单题吧

4. 代码

#include <iostream>
using namespace std;
const int maxn = 1011;
int n, a[maxn], cnt = 1;

int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    
    for (int i = 1; i < n; i++)
    {
        if (a[i] != a[i - 1])
            cnt++;
    }
    cout << cnt;
    return 0;
}

B 消消乐大师

1.题目大意

Q 老师是个很老实的老师，最近在积极准备考研。Q 老师平时只喜欢用Linux系统，所以Q老师的电脑上没什么娱乐的游戏，所以Q老师平时除了玩 Linux 上的赛车游戏 SuperTuxKart 之外，就是喜欢消消乐了。

游戏在一个包含有 n 行 m 列的棋盘上进行，棋盘的每个格子都有一种颜色的棋子。当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。
一个棋子可能在某一行和某一列同时被消除。

由于这个游戏是闯关制，而且有时间限制，当 Q 老师打开下一关时，Q 老师的好哥们叫 Q 老师去爬泰山去了，Q老师不想输在这一关，所以它来求助你了！！

输入：
输入第一行包含两个整数 n , m ，表示行数和列数
接下来 n 行 m 列，每行中数字用空格隔开，每个数字代表这个位置的棋子的颜色。数字都大于0

输出：
输出 n 行 m 列，每行中数字用空格隔开，输出消除之后的棋盘。（如果一个方格中的棋子被消除， 则对应的方格输出0，否则输出棋子的颜色编号。）

样例：

4 5
2 2 3 1 2
3 4 5 1 4
2 3 2 1 3
2 2 2 4 4

2 2 3 0 2
3 4 5 0 4
2 3 2 0 3
0 0 0 4 4

2. 思路历程

• 由于一个棋子可能在某一行和某一列同时被消除，因此不能在考虑了一行或者一列之后就把棋子消除，考虑把棋子的颜色数字和是否被消除分开表示，封装成类来表示。
• 从行和列两个方向对棋子进行遍历，每次比较当前棋子和前两个/上两个棋子的大小，若可消除则把标记为置为true，最后输出时遇到标记为true的直接输出0。

3. 反思

• 关于声明结构体后创建对象的方式要记录一个小细节：如果结构体内已经有了需要参数的构造函数，直接创建对象时一定要再加一个空的构造函数，否则会导致无类型匹配的错误。
• 这道题做对应该算是我运气比较好，因为刚开始不知道怎么找出连续所有相同的棋子，甚至想过新增一个变量记录前一个棋子，每个棋子与之比较。后来先写了只有连续三个棋子颜色相同的情况后，突然发现这样遍历一遍就已经比较了所有棋子的大小，可以找全颜色相同的棋子了。
• 其实我经常在这种显而易见的问题上转不过弯来，还是要多多锻炼自己的逻辑思维能力。

4. 代码

#include <iostream>
#include <string.h>
using namespace std;
const int maxn = 33;

struct Chess
{
    int digit;
    bool flag;
    Chess() {}
    Chess(int dig)
    {
        digit = dig;
        flag = false;
    }
}a[maxn][maxn];

int n, m, temp;

int main()
{
    memset(a, 0, sizeof(a));
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cin >> temp;
            a[i][j] = Chess(temp);
        }
    }
    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m - 2; j++)
        {
            if (a[i][j].digit == a[i][j + 1].digit && a[i][j + 1].digit == a[i][j + 2].digit)
            {
                a[i][j].flag = true;
                a[i][j + 1].flag = true;
                a[i][j + 2].flag = true;
            }
        }
    }
    for (int j = 1; j <= m; j++)
    {
        for (int i = 1; i <= n; i++)
        {
            if (a[i][j].digit == a[i + 1][j].digit && a[i + 1][j].digit == a[i + 2][j].digit)
            {
                a[i][j].flag = true;
                a[i + 1][j].flag = true;
                a[i + 2][j].flag = true;
            }
        }
    }
    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (j == 1)
            {
                if (a[i][j].flag == true) cout << "0";
                else cout << a[i][j].digit;
            }
            else
            {
                if (a[i][j].flag == true) cout << " 0";
                else cout << " " << a[i][j].digit;
            }
        }
        cout << endl;
    }
    return 0;
}

C 咕咕东学英语

1.题目大意

咕咕东很聪明，但他最近不幸被来自宇宙的宇宙射线击中，遭到了降智打击，他的英语水平被归零了！这一切的始作俑者宇宙狗却毫不知情！

此时咕咕东碰到了一个好心人—— TT，TT 在吸猫之余教咕咕东学英语。今天 TT 打算教咕咕东字母 A 和字母 B ，TT给了咕咕东一个只有大写A、B组成的序列，让咕咕东分辨这些字母。
但是咕咕东的其他学科水平都还在，敏锐的咕咕东想出一个问题考考TT：咕咕东问TT这个字符串有多少个子串是 Delicious 的。
TT虽然会做这个问题，但是他吸完猫发现辉夜大小姐更新了，不想回答这个问题，并抛给了你，你能帮他解决这个问题吗?
Delicious 定义：对于一个字符串，我们认为它是 Delicious 的当且仅当它的每一个字符都属于一个大于 1 的回文子串中。

输入：
输入第一行一个正整数 n ，表示字符串长度接下来一行，一个长度为 n 只由大写字母A、B构成的字符串。

输出：
输出仅一行，表示符合题目要求的子串的个数。

样例：

5
AAABB

6

2. 思路历程

• 这道题就是我觉得读不懂的题，所以一点一点读：题目要求找到符合某些条件的子串， 因此答案肯定是在n * (n - 1) / 2个子串里选一些。（根据样例的解释感觉这里应该用大于1的子串更准确一点）
• 子串要符合的条件：其每一个字符都属于一个大于 1 的回文子串中。简单考虑回文串的特性：所有字符都相同，两个字符交替出现且长度为奇数，两种字符分别占前半部分和后半部分且长度为偶数。因此初步判断Delicious的子串大于非Delicious的子串。
• 因此考虑计算非Delicious的子串。对于（从0开始）第 i 个字符，以此为右边界往前有 i 个大于1的子串，以此为左边界往后有 n - 1 - i 个大于1的子串。因此遍历字符串，对字符串中每个字符再进行两次遍历。
• 关于条件的判断，当且仅当其他字符全部相同只有边界字符单独不同时，字符串是非Delicious的。

3. 反思

• 我也不知道为什么，模测的时候string是用cin >> s[i]来输入的，华丽丽地TE了，求我自己不要把string和char数组搞混。
• 关于long long型变量，要时刻注意，有时候题目给的n的数据范围远没有达到长整型，但是不保证题目里用到了n²，在敲代码的时候多留意一下。

4. 代码

#include <iostream>
using namespace std;

long long n, ans = 0;
string s;

int main()
{
    cin >> n;
    cin >> s;
    
    for (long long i = 0; i < n; i++)
    {
        if (s[i] == 'B')
        {
            for (long long j = i - 1; j >= 0; j--)
            {
                if (s[j] == 'A') ans++;
                else break;
            }
            for (long long j = i + 1; j < n; j++)
            {
                if (s[j] == 'A') ans++;
                else break;
            }
        }
        if (s[i] == 'A')
        {
            for (long long j = i - 1; j >= 0; j--)
            {
                if (s[j] == 'B') ans++;
                else break;
            }
            for (long long j = i + 1; j < n; j++)
            {
                if (s[j] == 'B') ans++;
                else break;
            }
        }
    }
    
    for (long long i = 1; i < n; i++)
    {
        if (s[i] != s[i - 1]) ans--;
    }
    cout << n * (n - 1) / 2 - ans;
    return 0;
}