牛客直播课-代码实现

每次看牛客上左神的直播都感觉收货满满，讲了网易校招题，挑其中有价值的两个记录一下，都不难。

一、彩色砖块

描述

小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = “ABAB”,那么小易有六种排列的结果:
“AABB”,”ABAB”,”ABBA”,”BAAB”,”BABA”,”BBAA”
其中只有”AABB”和”BBAA”满足最多只有一对不同颜色的相邻砖块。

输入

输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。

样例：
ABAB

输出

输出一个整数,表示小易可以有多少种方式。

样例：
2

我的代码

其实很简单，就是要快速的想到答案：
当不同字母个数=1时，即只有一种颜色，答案为1；
当不同字母个数=2时，即只两种颜色，答案为2（变化的就是两种颜色的前后顺序）；
当不同字母个数>2时，即有多于两种颜色，答案为0（无法只存在一对不同颜色的砖块相邻）；

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

char s[55];

//颜色=1输出1，颜色=2输出2，颜色>3输出0
int main()
{
    while (cin >> s)
    {
        set<char> charater;
        int len = strlen(s);
        for (int i = 0; i < len; i++)
        {
            if (charater.size() >= 3)
                break;
            if (charater.find(s[i]) == charater.cend())
                charater.insert(s[i]);
        }
        int rlt = charater.size();
        if (rlt <= 2) cout << rlt << endl;
        else if (rlt >= 3) cout << "0" << endl;
    }
    return 0;
}

二、操作序列

描述

小易有一个长度为n的整数序列,a_1,…,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。

输入

输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。
第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。

样例：
4
1 2 3 4

输出

在一行中输出操作n次之后的b序列,以空格分割,行末无空格。

样例：
4 2 1 3

我的代码

并不需要真的去逆序,找规律发现:
使用双端队列;
数组长度为偶数时，下标为偶数的放于队尾，下标为奇数的放于队首;
数组长度为奇数时，下标为奇数的放于队尾，下标为偶数的放于队首;

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

char s[200005];

//并不需要逆序,使用双端队列
//数组长度为偶数时，下标为偶数的放于队尾，下标为奇数的放于队首
//数组长度为奇数时，下标为奇数的放于队尾，下标为偶数的放于队首
int main()
{
    int n;
    while (cin >> n)
    {
        deque<int> rlt;
        int _mod = 0;
        if (n % 2 == 0) _mod = 0;
        else _mod = 1;
        for (int i = 0; i < n; i++)
        {
            int num;
            cin >> num;
            if (i % 2 == _mod)
                rlt.emplace_back(num);
            else
                rlt.emplace_front(num);
        }
        int i = 0;
        for (i = 0; i < rlt.size() - 1; i++)
            cout << rlt[i] << " ";
        cout << rlt[i] << endl;
    }
    return 0;
}

三、机器人位移问题

另外纪念一下我终于自己写了个dp！！！！还是手左神的知道大概琢磨到了一点思路。

描述

一排有N个位置，一个机器人在最开始停留在p位置上，如果p==0位置，下一分钟机器人一定向右移动到1位置；如果p==N-1，下一分钟机器人一定向左移动到N-2位置。如果p在0和N-1之间，下一分钟机器人一定会向右或向左移动一个位置。求k分钟的时候，机器人到达T位置有多少种走法。
HDU 2151 Worm杭电上有一样的题。

我的代码

这题使用递归会超时，必须用dp做。
考虑到题目中n和p都是不变量，解空间由k和t构成，可以做一个二维表存储结果。
先写出递归的做法，根据递归中第一个if条件可以首先确定dp第一行的值；然后第二个和第三个if指出了最左边和最右边的列的求法，最左边的列参考右上角点，最右边的列参考左上角点；然后中间的每个点都参考左上角和右上角之和。

#include <iostream>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <deque>
#include <algorithm>
#include <cmath>
using namespace std;

递归,会超时
//int sumPath(int n, int p, int m, int t)
//{
//  if (m == 0 && p == t)
//      return 1;
//  else if (m == 0 && p != t)
//      return 0;
//  if (p == 1) return sumPath(n, 2, m - 1, t);
//  if (p == n) return sumPath(n, n-1, m - 1, t);
//  if (p > 1 && p < n) return sumPath(n, p - 1, m - 1, t) + sumPath(n, p + 1, m - 1, t);
//}

//动规
#define maxn 105
int dp[maxn][maxn];
int sumPath(int n, int p, int m, int t)
{
    dp[0][p] = 1;

    for (int i = 1; i<=m; i++)
    {
        for (int j = 1; j<=n; j++)
        {
            if (j == 1)
                dp[i][j] = dp[i - 1][j + 1];
            else if (j == n)
                dp[i][j] = dp[i - 1][j - 1];
            else
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1];
        }
    }
    return dp[m][t];
}

int main()
{
    int n, p, m, t;
    while (cin >> n >> p >> m >> t)
    {
        memset(dp, 0, (n + 1)*(n + 1)*sizeof(int));
        cout << sumPath(n, p, m, t) << endl;
    }
    return 0;
}

四、排成一排纸牌博弈问题

描述

链接：https://www.nowcoder.com/questionTerminal/7036f62c64ba4104a28deee98a6f53f6
来源：牛客网

有一个整型数组A，代表数值不同的纸牌排成一条线。玩家a和玩家b依次拿走每张纸牌，规定玩家a先拿，玩家B后拿，但是每个玩家每次只能拿走最左或最右的纸牌，玩家a和玩家b都绝顶聪明，他们总会采用最优策略。请返回最后获胜者的分数。
给定纸牌序列A及序列的大小n，请返回最后分数较高者得分数(相同则返回任意一个分数)。保证A中的元素均小于等于1000。且A的大小小于等于300。

输入

样例：
[1,2,100,4],4

输出

样例：
101

我的代码

根据递归改写成dp

#include <iostream>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <deque>
#include <algorithm>
#include <cmath>
using namespace std;

//#define max(a,b) ((a)>(b)?(a):(b))
int f(int arr[], int i, int j);
int s(int arr[], int i, int j);

int max(int a, int b)
{
    return a > b ? a : b;
}
int min(int a, int b)
{
    return a < b ? a : b;
}
//递归
//先拿函数，先拿一定是最好的情况
//int f(int arr[], int i, int j)
//{
//  if (i == j) return arr[i];
//  return max(arr[i] + s(arr, i + 1, j), arr[j] + s(arr, i, j - 1));
//}
后拿函数，后拿因为是对手决断，对手是绝对聪明的，一定会把最差的情况留给你
//int s(int arr[], int i, int j)
//{
//  if (i == j) return 0;
//  return min(f(arr, i + 1, j), f(arr, i, j - 1));
//}
总函数
//int win(int arr[], int n)
//{
//  if (arr == NULL || n == 0) return 0;
//  return max(f(arr, 0, n-1), s(arr, 0, n-1));
//}

//动规
int cardGame(vector<int> A, int n) {
    int **dpf = new int*[n];
    for (int i = 0; i < n; i++)
    {
        dpf[i] = new int[n];
        for (int j = 0; j < n; j++) dpf[i][j] = 0;
    }
    int **dps = new int*[n];
    for (int i = 0; i < n; i++)
    {
        dps[i] = new int[n];
        for (int j = 0; j < n; j++) dps[i][j] = 0;
    }

    if (A.size() == 0 || n == 0) return 0;
    for (int i = 0; i < n; i++)
    {
        dpf[i][i] = A[i];
    }
    for (int dis = 1; dis <= n - 1; dis++)
    {
        for (int i = 0; i < n; i++)
        {
            int j = i + dis;
            if (j > n - 1) break;
            dpf[i][j] = max(A[i] + dps[i + 1][j], A[j] + dps[i][j - 1]);
            dps[i][j] = min(dpf[i + 1][j], dpf[i][j - 1]);
        }
    }
    return max(dpf[0][n - 1], dps[0][n - 1]);
}

int main()
{
    int n;
    while (cin >> n)
    {
        vector<int> arr(n, 0);
        for (int i = 0; i < n; i++) cin >> arr[i];
        cout << cardGame(arr, n) << endl;
    }
    return 0;
}