字节跳动春招部分编程题解题思路

欢迎讨论

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。

第一次在牛客网刷这种编程题，真的好难啊-_-!
对字节跳动追求极致的要求真的有了很切身的感受

这是题库链接
下面就是各个题目的解题：

1.万万没想到之聪明的编辑

题目描述：
我叫王大锤，是一家出版社的编辑。我负责校对投稿来的英文稿件，这份工作非常烦人，因为每天都要去修正无数的拼写错误。但是，优秀的人总能在平凡的工作中发现真理。我发现一个发现拼写错误的捷径：

1. 三个同样的字母连在一起，一定是拼写错误，去掉一个的就好啦：比如 helllo -> hello
2. 两对一样的字母（AABB型）连在一起，一定是拼写错误，去掉第二对的一个字母就好啦：比如 helloo -> hello
3. 上面的规则优先“从左到右”匹配，即如果是AABBCC，虽然AABB和BBCC都是错误拼写，应该优先考虑修复AABB，结果为AABCC

我特喵是个天才！我在蓝翔学过挖掘机和程序设计，按照这个原理写了一个自动校对器，工作效率从此起飞。用不了多久，我就会出任CEO，当上董事长，迎娶白富美，走上人生巅峰，想想都有点小激动呢！
……
万万没想到，我被开除了，临走时老板对我说： “做人做事要兢兢业业、勤勤恳恳、本本分分，人要是行，干一行行一行。一行行行行行；要是不行，干一行不行一行，一行不行行行不行。” 我现在整个人红红火火恍恍惚惚的……
$(ps:这是原题目内容，不是我在玩梗，题目好有意思啊)$

请听题：请实现大锤的自动校对程序

题目限制：
数据范围： $1\le n\le 50$ ，每个用例的字符串长度满足 $1\le l\le 1000$
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32M，其他语言64M

输入描述：
第一行包括一个数字N，表示本次用例包括多少个待校验的字符串。
后面跟随N行，每行为一个待校验的字符串。

输出描述：
N行，每行包括一个被修复后的字符串。
示例1

输入例子：
2
helloo
wooooooow
输出例子：
hello
woow

示例2

输入例子：
1
nowcoder
输出例子：
nowcoder

解题思路：

1. 首先读题，题目中只有两种错误，即$AAA\ast 和A\ast ABB\ast$，那么解决方法就分别针对这两个问题；
2. 对于第一种错误AAA*，可以对文本进行过滤，超过2个连续相同字母的就过滤为只剩2个字母，具体方法可以考虑建一个新数组；
3. 对于第二种错误$A\ast ABB\ast$，因为我们已经过滤后只剩下最多两个相同连续字母，所以就可以对AABB对号入座，然后删掉最后一个B就可以了；
4. 因为最近我都在用python，所以用python解题喽，其他编程语言类似~~，代码如下；

def fix_str(err_str):
    stack = [] # 去除第一种错误后的数组
    count = 1

    for i in range(1, len(err_str)):
        if err_str[i] == err_str[i - 1]: # 连续相同字母
            count += 1
        else:
            stack.append(err_str[i - 1] * min(count, 2))
            count = 1

    stack.append(err_str[-1] * min(count, 2))
    final_str = "".join(stack)

    i = 0
    while i < len(final_str) - 3:
        if final_str[i] == final_str[i + 1] and final_str[i + 2] == final_str[i + 3]:
            final_str = final_str[:i + 3] + final_str[i + 4:] # 去掉AABB中后一个B
            i -= 1
        i += 1

    return final_str

N = int(input())
error_str = [input() for _ in range(N)]

for i in range(N):
    fixed_str = fix_str(error_str[i])
    print(fixed_str)

运行结果：通过全部用例 运行时间46ms 占用内存4624KB

2.万万没想到之抓捕孔连顺

这道题让我抓狂，差不多用了半天多时间才完美解决，主要就是因为对时间复杂度的优化上，字节不亏是追求极致啊~

题目描述：
我叫王大锤，是一名特工。我刚刚接到任务：在字节跳动大街进行埋伏，抓捕恐怖分子孔连顺。和我一起行动的还有另外两名特工，我提议

1. 我们在字节跳动大街的 N 个建筑中选定 3 个埋伏地点。
2. 为了相互照应，我们决定相距最远的两名特工间的距离不超过 D 。

我特喵是个天才! 经过精密的计算，我们从X种可行的埋伏方案中选择了一种。这个方案万无一失，颤抖吧，孔连顺！
……
万万没想到，计划还是失败了，孔连顺化妆成小龙女，混在cosplay的队伍中逃出了字节跳动大街。只怪他的伪装太成功了，就是杨过本人来了也发现不了的！

请听题：给定 N（可选作为埋伏点的建筑物数）、 D（相距最远的两名特工间的距离的最大值）以及可选建筑的坐标，计算在这次行动中，大锤的小队有多少种埋伏选择。
注意：

1. 两个特工不能埋伏在同一地点
2. 三个特工是等价的：即同样的位置组合( A , B , C ) 只算一种埋伏方法，不能因“特工之间互换位置”而重复使用

题目限制：
数据范围： $0<n,d\le 10^6$

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 128M，其他语言256M

输入描述：
第一行包含空格分隔的两个数字 N和D(1 ≤ N ≤ 1000000; 1 ≤ D ≤ 1000000)
第二行包含N个建筑物的的位置，每个位置用一个整数（取值区间为[0, 1000000]）表示，从小到大排列（将字节跳动大街看做一条数轴）

输出描述：
一个数字，表示不同埋伏方案的数量。结果可能溢出，请对 99997867 取模
示例1

输入例子：
4 3
1 2 3 4
输出例子：
4
例子说明：
可选方案 (1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)

示例2

输入例子：
1
nowcoder
输出例子：
nowcoder

示例3

输入例子：
2 100
1 102
输出例子：
0
例子说明：
无可选方案

解题思路：

1. 这个题很像中学做过的组合排序问题，但难点在于建筑序列并不是等长的，又因为题目中要求方案是去重的，所以很自然的就会想到暴力算法：三层循环对合适的方案排序后加到集合set()里，然鹅，我试过，时间效率太低了；
2. 然后就想到优化策略：将后两层循环只查找上下相差D的几个数据，查找方法用二分法查找，但是很遗憾还是失败了，耗时还是太久；
3. 然后又想到一种优化策略：将查找的结果存储下来，将代码降为两重循环，这样就可以降低查找次数，然后将代码中不需要更新的列表转换为元组，因为元组的查找速度更高，估计时间复杂度为O(NlogN),然鹅又双叒叕失败了，还是耗时太久；
4. 但已经很接近答案了，在吃饭的时候想到首先确定下来第一个点，然后找出该点之后比它大D的数的区间，假设有m个值，这时候只要$C_m^2$就可以了，时间复杂度约为O(N + m)!
5. 以下为代码实现，优化到这种地步没想到代码还这么简洁

import sys

N, D = map(int, input().split())
pos_list = list(map(int, input().split()))

if N < 3 or D < 1:
    print(0)
    exit(0)

count = 0

back_pos = [0] * N # 保留当前D区间内最大数的下标

for index, pos in enumerate(pos_list):
    target = pos_list[index] # 当前值
    if index > 0:
        back_index = back_pos[index - 1] + 1 # 用上一个值的最大数下标，减少循环
    else:
        back_index = index + 1
    while back_index < N and pos_list[back_index] - target <= D:
        back_index += 1
    back_pos[index] = back_index - 1

back_pos_tuple = tuple(back_pos) # 转换为元组，提升查找效率

for i in range(N - 2):
    length = back_pos_tuple[i] - i
    count += length * (length - 1) // 2

num = (count % 99997867)
print(num)

运行结果：通过全部用例 运行时间242ms 占用内存21664KB

ps:后续的题目还没看，回头更新出来