[题解] CodeM美团点评编程竞赛资格赛题

最近看到牛课网美团一个编程竞赛，想着做做看，结果一写就是两天。。真是写不动了啊。话不多说，下面开始我的题解。

题目大致还是比较考察思维和代码能力（因为自己代码能力较弱，才会觉得比较考察代码能力吧= =！），难度由简到难变化也比较适中，有签到题、有算法实现，当然也有稍稍一点代码量的题。感谢美团点评，提供一套合适的题目~

音乐研究

题目描述

美团外卖的品牌代言人袋鼠先生最近正在进行音乐研究。他有两段音频，每段音频是一个表示音高的序列。现在袋鼠先生想要在第二段音频中找出与第一段音频最相近的部分。
具体地说，就是在第二段音频中找到一个长度和第一段音频相等且是连续的子序列，使得它们的 difference 最小。两段等长音频的 difference 定义为：
difference = SUM(a[i] - b[i])2 (1 ≤ i ≤ n),其中SUM()表示求和 
其中 n 表示序列长度，a[i], b[i]分别表示两段音频的音高。现在袋鼠先生想要知道，difference的最小值是多少？数据保证第一段音频的长度小于等于第二段音频的长度。

输入描述:

第一行一个整数n(1 ≤ n ≤ 1000)，表示第一段音频的长度。
第二行n个整数表示第一段音频的音高（0 ≤ 音高 ≤ 1000）。
第三行一个整数m(1 ≤ n ≤ m ≤ 1000)，表示第二段音频的长度。
第四行m个整数表示第二段音频的音高（0 ≤ 音高 ≤ 1000）。

输出描述:

输出difference的最小值

输入例子:

2
1 2
4
3 1 2 4

输出例子:

0

题解：

签到题，n*m<1e6，直接暴力枚举第二个数组的起点即可，复杂度O(n*m)。

#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <cstring>

using namespace std;

const int kMaxN = 1000 + 5;
int n, m, a1[kMaxN], a2[kMaxN];

int main(){
    //freopen("in.txt","r",stdin);
    cin >> n;
    for (int i = 1; i <= n; i ++)
        cin >> a1[i];
    cin >> m;
    for (int i = 1; i <= m; i ++)
        cin >> a2[i];
    int ans = 1e9;
    for (int i = 0; i <= m - n; i ++) {
        int sum = 0;
        for (int j = 1; j <= n; j ++)
            sum += (a1[j] - a2[i + j]) * (a1[j] - a2[i + j]);
        ans = min(ans, sum);
    }
    cout << ans << endl;
    return 0;
}

 

　　

 

锦标赛

题目描述

组委会正在为美团点评CodeM大赛的决赛设计新赛制。
比赛有 n 个人参加（其中 n 为2的幂），每个参赛者根据资格赛和预赛、复赛的成绩，会有不同的积分。比赛采取锦标赛赛制，分轮次进行，设某一轮有 m 个人参加，那么参赛者会被分为 m/2 组，每组恰好 2 人，m/2 组的人分别厮杀。我们假定积分高的人肯定获胜，若积分一样，则随机产生获胜者。获胜者获得参加下一轮的资格，输的人被淘汰。重复这个过程，直至决出冠军。
现在请问，参赛者小美最多可以活到第几轮（初始为第0轮）？

输入描述:

第一行一个整数 n (1≤n≤ 2^20)，表示参加比赛的总人数。
接下来 n 个数字（数字范围：-1000000…1000000），表示每个参赛者的积分。
小美是第一个参赛者。

输出描述:

小美最多参赛的轮次。

输入例子:

4
4 1 2 3

输出例子:

2

 题解：

这个也比较好容易想到，很容易可以想到当小美被淘汰时，所有其他人的分数都是严格大于小美的分数的。所以直接将小美安排和所有与她分数低的人比赛即可，因为分数高的一定赢，因此可以认为她淘汰的人和被他淘汰的人淘汰的人，这些人分数都小于等于小美。

因此答案就是log2(count(score <= score[0])) score[0]是小美的分数。

#include <iostream>
#include <cstdio>
#include <cmath>

using namespace std;

int main(){
    //freopen("1.in","r",stdin);
    int n,ans = 0,x0, x;
    cin >> n;
    for(int i = 0; i < n; i++){
        scanf("%d",&x);
        if(i == 0) x0 = x;
        ans += x <= x0;
    }
    cout << ((int)(log(ans * 1.0) / log(2.0))) << endl;
    return 0;
}

 

　

 

 优惠券

美团点评上有很多餐馆优惠券，用户可以在美团点评App上购买。每种优惠券有一个唯一的正整数编号。每个人可以拥有多张优惠券，但每种优惠券只能同时拥有至多一张。每种优惠券可以在使用之后继续购买。

当用户在相应餐馆就餐时，可以在餐馆使用优惠券进行消费。某人优惠券的购买和使用按照时间顺序逐行记录在一个日志文件中，运营人员会定期抽查日志文件看业务是否正确。业务正确的定义为：一个优惠券必须先被购买，然后才能被使用。

某次抽查时，发现有硬盘故障，历史日志中有部分行损坏，这些行的存在是已知的，但是行的内容读不出来。假设损坏的行可以是任意的优惠券的购买或者使用。

现在给一个日志文件，问这个日志文件是否正确。若有错，输出最早出现错误的那一行，即求出最大s，使得记录1到s-1满足要求；若没有错误，输出-1。

输入描述:

输入包含多组数据
m 分别表示 m (0 ≤ m ≤ 5 * 10^5) 条记录。
下面有m行，格式为：
I x （I为Input的缩写，表示购买优惠券x）；
O x（O为Output的缩写，表示使用优惠券x）；
? （表示这条记录不知道）。
这里x为正整数，且x ≤ 10^5 。

输出描述:

-1 或 x(1 ≤ x ≤ m) 其中x为使得1到x-1这些记录合法的最大行号。

输入例子:

0
1
O 1
2
?
O 1
3
I 1
?
O 1
2
I 2
O 1

输出例子:

-1
1
-1
-1
2

 题解：

刚开始看到这题，就理所应当的认为只需要记录未知记录的个数，和每个优惠券的状态即可，如果在购买时发现还存在这种优惠券，就用未知记录代替，位置记录条数减一（消费同理）。

这样做的确是把不合理的购买或者消费记录给清除了，但是这样做法的一个最大问题就在于，它没有考虑购买的时机，即认为未知记录是万能的。但是例如连续两次买进同一种优惠券（中间没有未知记录），这样也是不合法的。因此，我们需要分情况讨论：

购买优惠券x时：

　　1.若之前没有交易过优惠券x或之前最后一次操作x已经将其卖出：  直接购买

 　  2.前一次操作是买入优惠券x：

　　　　1）两次买进之间没有未知记录： 这条记录是不合法的

　　　　2）两次买进之间有多次(>=1)条未知记录： 取最早的一条未知记录充当x的使用记录。

使用优惠券x时：

　　1.之前对x的操作最后一次是买入优惠券x： 直接使用

 　  2.前一次对x的操作是对x的使用(或没有对x的操作记录)：  

　　　　1）找出这两次使用操作的最早的一条未知记录，充当买入操作

　　　　2）若没有未知记录，这条记录不合法

上面为什么一定要取多天未知记录的最早的一条，读者自己可以思考下。下面我的代码用yhq变量保存最近的上一次操作优惠券x的位置，使用set集合来存放所有未知记录出现的位置（可以很方便的使用lower_bound函数）。

#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <cstring>

using namespace std;

char c;
int n, x;
map<int, int> yhq;
set<int> unknown;

int main(){
    //freopen("in.txt","r",stdin);
    while(~scanf("%d%*c", &n)) {
        yhq.clear();
        unknown.clear();
        int has_error = -1;
        for (int i = 1; i <= n; i ++) {
            scanf("%c%*c", &c);
            if(c == '?') {
                unknown.insert(i);
                continue;
            }
            scanf("%d%*c", &x);
            if(has_error >= 0) { // has find ans
                continue;
            }
            if(c == 'I') {
                if(yhq[x] > 0) {
                    set<int>::iterator it = unknown.lower_bound(yhq[x]);
                    if(it == unknown.end()) has_error = i;
                    else unknown.erase(it);
                }
                yhq[x] = i;
            }
            else {
                if(yhq[x] <= 0) {
                    set<int>::iterator it = unknown.lower_bound(-yhq[x]);
                    if(it == unknown.end()) has_error = i;
                    else unknown.erase(it);
                }
                yhq[x] = -i;
            }
        }
        printf("%d\n", has_error);
    }
    return 0;
}

 

　　

 送外卖

题目描述

n 个小区排成一列，编号为从 0 到 n-1 。一开始，美团外卖员在第0号小区，目标为位于第 n-1 个小区的配送站。
给定两个整数数列 a[0]~a[n-1] 和 b[0]~b[n-1] ，在每个小区 i 里你有两种选择：
1) 选择a：向前 a[i] 个小区。
2) 选择b：向前 b[i] 个小区。

把每步的选择写成一个关于字符 ‘a’ 和 ‘b’ 的字符串。求到达小区n-1的方案中，字典序最小的字符串。如果做出某个选择时，你跳出了这n个小区的范围，则这个选择不合法。 
• 当没有合法的选择序列时，输出 “No solution!”。
• 当字典序最小的字符串无限长时，输出 “Infinity!”。
• 否则，输出这个选择字符串。

字典序定义如下：串s和串t，如果串 s 字典序比串 t 小，则
• 存在整数 i ≥ -1，使得∀j，0 ≤ j ≤ i，满足s[j] = t[j] 且 s[i+1] < t[i+1]。
• 其中，空字符 < ‘a’ < ‘b’。

输入描述:

输入有 3 行。
第一行输入一个整数 n (1 ≤ n ≤ 10^5)。
第二行输入 n 个整数，分别表示 a[i] 。
第三行输入 n 个整数，分别表示 b[i] 。
−n ≤ a[i], b[i] ≤ n

输出描述:

输出一行字符串表示答案。

输入例子:

7
5 -3 6 5 -5 -1 6
-6 1 4 -2 0 -2 0

输出例子:

abbbb

 题解：

 终于通过所有数据了。

#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <cstring>

using namespace std;

const int kMaxN = 1e5 + 5;
int n, a[kMaxN], b[kMaxN];
int vis[kMaxN], ans_flag;
char str_ans[kMaxN];

int dfs(char * ans, int step, int cur_node, bool flag)
{
    if(cur_node < 1 || cur_node > n || vis[cur_node] > 1)
        return 0;
    if(vis[cur_node]) return 1;
    if(cur_node == n) {
        ans[step] = 0;
        ans_flag = flag;
        if(!flag) puts(ans);
        return 2;
    }
    vis[cur_node] = 1;
    ans[step] = 'a';
    int ret = dfs(ans, step + 1, cur_node + a[cur_node], flag);
    if(ret == 2) return 2;

    ans[step] = 'b';
    if(dfs(ans, step + 1, cur_node + b[cur_node], flag || ret==1) == 2)
        return 2;

    vis[cur_node] = 2;
    return 0;
}

int main(){
    //freopen("in.txt","r",stdin);
    cin >> n;
    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    for (int i = 1; i <= n; i ++)
        scanf("%d", &b[i]);
    memset(vis, 0, sizeof(vis));
    if(dfs(str_ans, 0, 1, 0) != 2)
        puts("No solution!");
    else if(ans_flag){
        puts("Infinity!");
    }
    return 0;
}

 

 

 

 

数码

时间限制：1秒
空间限制：32768K

题目描述

给定两个整数 l 和 r ，对于所有满足1 ≤ l ≤ x ≤ r ≤ 10^9 的 x ，把 x 的所有约数全部写下来。对于每个写下来的数，只保留最高位的那个数码。求1～9每个数码出现的次数。

输入描述:

一行，两个整数 l 和 r (1 ≤ l ≤ r ≤ 10^9)。

输出描述:

输出9行。

第 i 行，输出数码 i 出现的次数。

输入例子:

1 4

输出例子:

4
2
1
1
0
0
0
0
0

题解：

首先，使用find_ans(n)计算1~n所有数的答案，那么最后的答案就是find_ans(r) - find_ans(l - 1)。

其次，要计算最高位为i的约数出现的次数。例如i=2，那么另cnt(x)为n以内约数包含x的数的个数，有：

　　　　　　ans[2] = cnt(2) + cnt(20) + cnt(21) + .... cnt(29) + cnt(200) + cnt(201) + ... 其中(x<=n)

所以我们分位数讨论

　　　　　　1位[i, i+1)，2位[i*10, (i+1)*10), 3位[i*100, (i+1)*100)... ... 　　　　其中i取1~9。

我们知道，n以内包含约数x的自然数的个数为 n / x，即cnt(x) = n / x, 我们令ans[i]表示首位为i的答案，那么有：

　　　　　　ans[i] = sum{ sum{ n / x | i * 10^j <= x <= (i + 1) * 10^j} | 0 <= j <= 9}

 上述步骤中可以看到对于每一个j， 即对于最高位为i且位数为（j+1）位的所有数x是连续的。 所以关键在于写一个函数，用于计算：

　　　　　　sigle_sum = (n / low) + (n / (low + 1)) + ... + (n / high)   其中   low = i * 10^j,  high = (i + 1) * 10^j

可以看到上述计算单个答案sigle_sum 时，复杂度为O(10^j), 这对于一个位数较大（如j>=7）情况来说，枚举量依然非常巨大。

但是我们可以看到当j>=5时，low = i * 10^5, 有 n/low <= 10^4,所以我们可以枚举上述每一个式子的商（如商=x)，再计算[low,high]区间中商为x的数有多少个，最后答案+ x * num(low, high, n, x)，其中num(low, high, n, x)表示n/low, n/(low+1),,,n/(high)这些值中结果为x的个数，这个我们可以O(1)的计算出来。

最后计算sigle_sum总复杂度小于O(1e5)。

最后计算总答案复杂度：O(9 * 10 * 1e5)，终于可以通过了~

#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <cstring>

using namespace std;

typedef long long LL;
LL l, r;
LL a[10], b[10];

// calc (n / low) + (n / (low + 1)) + ... + (n / high)
LL find_ans(LL low, LL high, LL n)
{
    if(high < low) return 0;
    LL result = 0;
    if(high - low < 1e5) for (int i = low; i <= high; i ++) {
        result += n / i;
    }
    else {
        LL l = n / high, r = n / low;
        for (int i = l; i <= r; i ++) {
            LL lb = max(n / (i + 1), low), rb = min(n / i, high);
            if(n / rb == n / lb) rb ++;
            result += (rb - lb) * i;
        }
    }
    return result;
}

void find_ans(LL n, LL * ans)
{
    memset(ans, 0, sizeof(LL) * 10);
    if(!n) return ;
    for (int i = 1; i <= 9; i ++) {
        LL mul_num = 1;
        for (int j = 0; j <= 9 && mul_num <= n; j ++) {
            ans[i] += find_ans(i * mul_num, min((i + 1) * mul_num - 1, n), n);
            mul_num *= 10;
        }
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    cin >> l >> r;
    find_ans(l - 1, a);
    find_ans(r, b);
    for (int i = 1; i <= 9; i ++)
        cout << (b[i] - a[i]) << endl;
    return 0;
}

 

 

 围棋

题目描述

围棋是起源于中国有悠久历史的策略性棋类游戏。它的规则如下：
1. 棋盘19*19。
2. 棋子分黑白两色，双方各执一色。
3. 下法：每次黑或白着一子于棋盘的空点上。棋子下定后，不再向其他点移动。
4. 棋子的气：一个棋子在棋盘上，与它相邻的空点是这个棋子的“气”（这里相邻是指两个点有公共边）。 相邻的点上如果有同色棋子存在，这些棋子就相互连接成一个不可分割的整体，气合并计算。
相邻的点上如果有异色棋子存在，此处的气便不存在。
如果棋子所在的连通块失去所有的气，即为无气之子，不能在棋盘上存在。
5. 提子：把无气之子清理出棋盘的手段叫“提子”。提子有二种：
1) 着子后，对方棋子无气，应立即提取对方无气之子。
2) 着子后，双方棋子都呈无气状态，应立即提取对方无气之子。
6. 禁着点：棋盘上的任何一空点，如果某方在此下子，会使该子立即呈无气状态，同时又不能提取对方的棋子，这个点叫做“禁着点”，该方不能在此下子。
7. 禁止全局同形：无论哪一方，在成功进行了着子、提子操作后，棋盘局面不能和任何之前的局面相同。

你要做的是：输入一些操作，从空棋盘开始模拟这些操作。
对于每一步，若结果不正确，则输出对应的miss并且忽略这个操作，并在最后输出棋盘的局面。

输入描述:

第一行，测试数据组数≤100
第二行，每组测试数据，执行的步数 n ≤ 2000 
然后 n 行 
B x y 
W x y 
(1 ≤ x ≤ 19,1 ≤ y ≤ 19)
其中，二元组 x,y 表示围棋棋盘上第 x 行第 y 列对应的点。
输入数据保证是黑白轮流下的。

输出描述:

多行
对于miss的情况，输出是哪一种错误格式，其中：
miss 1 表示下的位置已经有棋了
miss 2 表示违反规则6
miss 3 表示违反规则7
对于正常的操作，不用输出。
最后输出最终盘面。“B表示黑子，W表示白子，如果是空点的话，就输出'.'字符。”

输入例子:

1
12
B 1 3
W 1 2
B 2 4
W 2 1
B 1 1
W 2 3
B 3 3
W 3 2
B 1 1
W 2 3
B 2 2
W 2 3

对应的棋形是这样的：

输出例子:

miss 2
miss 2
miss 1
miss 3
.WB................
WB.B...............
.WB................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................
...................

 题解：

 这个比较纯粹，模拟每一次操作，然后判断是否合法，没太多可讲之处，纯粹是考察代码实现能力。当然我也只是完成了这道题而已啦，代码风格和可读性还比较低。

#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <cstring>
#include <vector>
#include <queue>

using namespace std;

const int kModNum = 1e9 + 7;
const int kBorderSize = 19;
const int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

struct Board {
    int arr[20][20];
    int hash_val;
    bool operator == (const Board & another) const {
        for (int i = 0; i < kBorderSize; i ++) {
            for (int j = 0; j < kBorderSize; j ++) {
                if(arr[i][j] != another.arr[i][j]) return false;
            }
        }
        return true;
    }
    bool operator < (const Board & another) const {
        return hash_val < another.hash_val;
    }
};

int T, n, x, y;
char op;
Board board, tmp;
map< int, set<Board> > mps;
int vis[kBorderSize][kBorderSize];


void Reset()
{
    memset(board.arr, 0, sizeof(board.arr));
    mps.clear();
}

int MyHash(const Board & board)
{
    int hash_num = 0;
    for (int i = 0; i < kBorderSize; i ++) {
        for (int j = 0; j < kBorderSize; j ++) {
            hash_num = ((hash_num << 1) % kModNum + hash_num) % kModNum;
            hash_num = (hash_num + board.arr[i][j]) % kModNum;
        }
    }
    return hash_num;
}

bool OutBound(int nx, int ny)
{
    return nx < 0 || nx >= kBorderSize || ny < 0 || ny >= kBorderSize;
}

bool ExistBoard(const Board board)
{
    return mps.count(board.hash_val) && mps[board.hash_val].count(board);
}

bool IsDeadPiece(int x, int y, int piece_type)
{
    memset(vis, false, sizeof(vis));
    queue<int> que;
    que.push(x * kBorderSize + y);
    vis[x][y] = true;
    while(!que.empty()) {
        int fr = que.front();
        que.pop();
        x = fr / kBorderSize;
        y = fr % kBorderSize;
        for (int i = 0; i < 4; i ++) {
            int nx = x + dir[i][0], ny = y + dir[i][1];
            if(OutBound(nx, ny) || vis[nx][ny]) continue;
            if(!board.arr[nx][ny]) {
                return false;
            }
            if(board.arr[nx][ny] == piece_type) {
                que.push(nx * kBorderSize + ny);
                vis[nx][ny] = true;
            }
        }
    }
    return true;
}

void RemoveDeadPiece()
{
    for (int i = 0; i < kBorderSize; i ++) {
        for (int j = 0; j < kBorderSize; j ++) {
            if(vis[i][j]) board.arr[i][j] = 0;
        }
    }
}

bool MovePiece()
{
    int put_val = op == 'B' ? 1 : 2;
    // 放下这颗棋子
    board.arr[x][y] = put_val;
    // 找是否能移除对手的棋子
    bool can_remove = false;
    for (int i = 0; i < 4; i ++) {
        int nx = x + dir[i][0], ny = y + dir[i][1];
        if(OutBound(nx, ny) || board.arr[nx][ny] != 3 - put_val)
            continue;
        if(IsDeadPiece(nx, ny, board.arr[nx][ny])) {
            can_remove = true;
        }
    }
    // 不能移走对手的棋子，自己又是死棋，不能下在这
    if(!can_remove && IsDeadPiece(x, y, put_val))
        return false;
    // 吧对手的死棋移除
    for (int i = 0; i < 4; i ++) {
        int nx = x + dir[i][0], ny = y + dir[i][1];
        if(OutBound(nx, ny) || board.arr[nx][ny] != 3 - put_val)
            continue;
        if(IsDeadPiece(nx, ny, board.arr[nx][ny])) {
            RemoveDeadPiece();
        }
    }
    board.hash_val = MyHash(board);
    return true;
}

void PrintBoard(Board board)
{
    for (int i = 0; i < kBorderSize; i ++) {
        for (int j = 0; j < kBorderSize; j ++) {
            if(!board.arr[i][j]) putchar('.');
            else if(board.arr[i][j] & 1) putchar('B');
            else putchar('W');
        }
        puts("");
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    cin >> T;
    while(T--) {
        Reset();
        scanf("%d%*c", &n);
        while(n --) {
            scanf("%c %d %d%*c", &op, &x, &y);
            x --; y --;
            // 第一种错误， 位置已经存在棋子
            if(board.arr[x][y]) {
                puts("miss 1");
                continue;
            }
            tmp = board;
            if(!MovePiece()) {
                puts("miss 2");
                board = tmp;
                continue;
            }
            if(ExistBoard(board)) {
                puts("miss 3");
                board = tmp;
                continue;
            }
            mps[MyHash(board)].insert(board);
        }
        PrintBoard(board);
    }
    return 0;
}