最近比较忙，又有一段时间没写题目了，终于在前几天把赛码网上，JD的2016秋招和2017实习生招聘剩下的4星难度题目做了，至此所有4星难度题目都解决了，5星难度题目还剩下一个应该是计算几何学的题目，因为这块我不熟悉，后面找时间再处理。
鉴于赛码网的难度分类不是特别准确，接下里我把1-3星难度的题目过一次，如果有价值的就和大家一起分享。
这次的解析包含了4个题目，相对比较简单，但需要考虑全面，否则容易掉坑。
买糖果
<题目来源: 京东2016实习生招聘 原题链接-可在线提交(赛码网)>
问题描述
某糖果公司专门生产儿童糖果，它最受儿童欢迎的糖果有A1、A2两个序列，均采用盒式包装。包装好的A1类糖果体积为一个存储单位，而包装好的A2类糖果体积正好是A1类的两倍。
这两类糖果之所以广受儿童欢迎，是因为糖果中含有公司独家研发的魔幻因子。A1或A2序列中的糖果，看起来包装可能是一样的，但因为其中的魔幻因子含量不同被细分为不同的产品。
临近传统节日，公司的糖果供不应求。作为一个精明的糖果分销商，小东希望能够借此大赚一笔，于是带着现金开着货车来公司提货。货车的容量是确定的，小东希望采购的糖果能够尽可能装满货车，且糖果的魔幻因子总含量最高。只要不超出货车容量，糖果总可以装入货车中。
小东希望你能帮她解决这一问题。
这个题目的描述似乎不是太准确，其实题目就是说有n个糖果，每个糖果有个体积(1或者2)，此外，有个魔幻因子。最后我们需要解决是在体积不超过v的情况下，选择若干糖果并且尽可能的获得最大的魔幻因子总量。
这看起来是个01背包问题*[1]，观察数据规模后发现，n <= 10^5，v <= 10^9这个用于状态转移的枚举量实在太大，而且单就一个v的上限就足以撑爆空间。看来问题似乎不是直接使用01背包的动态规划可以解决的，再观察题目条件，一个比较特别的地方是糖果的体积只有1和2的两种情况，我们从这个比较特殊的条件来解决问题。
a.考虑一种最简单的情况：只有体积为1的糖果。
显然我们只需要对所有的糖果按照魔幻因子从大到小排序，从魔幻因子最大的糖果开始选择，由于体积都是1，那么给定的v一定可以达到。这些选择出来的糖果的魔幻因子的和就是我们的求解目标。
b.再考虑另外一种罪简单的情况，只有体积为2的糖果。
同样我们需要按魔幻因子的大小进行排序，然后从魔幻因子最大的糖果开始选择，但是不同于a，由于是每个糖果的体积是2，那么选出来糖果的体积和不一定可以刚好为v，如果刚好为v则问题已经解决。如果超过v，显然是总体积比v大了1，那么最后选择的这一种糖果就不要了。这时我们选择的糖果的总体积为v-1，尽管浪费了1，但是我们没有任何办法再放入糖果了。
c.考虑题目既有体积1和2的情况。
基于上述两种基本情况的分析，我们仍然需要安排魔幻因子大小进行排序，尽可能选择魔幻因子高的优先选择，再考虑临界情况的处理。需要注意到，对于体积为2的糖果，我们不应该直接按照其魔幻因子的总量进行排序，而是按照单位体积的魔幻因子含量进行排序。这是因为，尽管可能体积为2的糖果魔幻因子可能很高，但是他占用2个体积，如果两个体积为1的糖果魔幻因子没有其高，但是两个加起来就超过了，并且最终占用的体积都是2.
排序之后我们按照从大的开始选择，如果可以刚好取到v，那么问题就得到解决。如果得不到，那么显然当前取的是体积2的糖果，并且是超过1。这个时候，明显我们可以有多种选择，我们既可以在已经选择的糖果中去掉一个体积为1的且魔幻因子最小的糖果，也可以是在还没有选择的糖果中选择一个体积为1的且魔幻因子最大的一个糖果。至于具体选择哪种就看哪种方案可以获得更高的魔幻因子总和了。
那么问题似乎已经解决了，然后我们并没有考虑到选择的和没选择的中都可能不存在体积为1的糖果。
…已选择部分…| 体积为2的糖果| …未选择部分…
^已获得的魔幻因子pm ^体积限制v设已选择的最小的体积为1的糖果的魔幻因子为l
设未选择的最小的体积为1的糖果的魔幻因子为r
当前体积2的糖果魔幻因子为p，体积不超过v获得最大的魔幻因子总和为pm
i.l和r都不存在
- = v
ii.l存在，r不存在 - = max(pm, pm – l + p)
iii.l不存在，r存在
- = pm + r
iv.l和r都存在 - = max(pm + r, pm – l + p)
最后一个需要解决的问题是输出选择糖果的序列问题，这并不难，我们排序后依次记录选择了的糖果即可。pm – l + p的情况，删除记录中的l即可。但是，由于存在多种方案要得失编号尽可能的小，那么对与ii, iv中存在相等的情况时的处理原则时，选择编号较小的即可。
排序时间复杂度为O(nlogn)，由于每个糖果只需要处理一次，计算部分时间复杂度为O(n)，非常理想。
import sys
const_n = 0
const_v = 1
const_p = 2
def main():
while True:
line = map(int, sys.stdin.readline().strip().split())
n, vm = line[0], line[1]
candies = []
for i in range(n):
line = map(int, sys.stdin.readline().strip().split())
if len(line) < 2:
break
candies.append((i + 1, line[0], line[1]))
candies = sorted(candies, key=lambda s: float(s[const_p]) / float(s[const_v]), reverse=True)
# print candies
seq = set([])
v = p = 0
l = r = -1
for i, candy in enumerate(candies):
if v + candy[const_v] >= vm:
if v + candy[const_v] == vm:
seq.add(candy[const_n])
p += candy[const_p]
else:
for j in range(i + 1, n):
if candies[j][const_v] == 1:
r = j
break
if l == -1 and r == -1:
pass
elif l == -1 and r != -1:
p += candies[r][const_p]
seq.append(candies[r][const_n])
elif l != -1 and r == -1:
if candy[const_p] - candies[l][const_p] > 0:
p = p - candies[l][const_p] + candy[const_p]
seq.remove(candies[l][const_n])
seq.add(candy[const_n])
else:
if candy[const_p] - candies[l][const_p] > candies[r][const_p]:
p = p - candies[l][const_p] + candy[const_p]
seq.remove(candies[l][const_n])
seq.add(candy[const_n])
else:
p += candies[r][const_p]
seq.add(candies[r][const_n])
break
seq.add(candy[const_n])
v += candy[const_v]
p += candy[const_p]
if candy[const_v] == 1:
l = i
print p
if p > 0:
seq = sorted(seq)
for s in seq:
print s,
else:
print 'No'
print
if __name__ == '__main__':
main()
终结者C
<题目来源: 京东2017实习生招聘 原题链接-可在线提交(赛码网)>
问题描述
收到情报，有批新造的机器人要运输到前线。小C将去破坏机器人的运输。小C将激光炮放置在公路的一旁，等运输车经过的时候发射（假设激光炮一定可以射穿车辆）。由于能源有限，激光炮只能发射两次。可以认为激光炮放在坐标轴的原点处，并向y轴正方向发射。每辆运输车可以看作是一个矩形，起始的x轴坐标为Xi ,所有的车均位于第一象限，长度为Li,速度为1，朝x轴负方向运动。即经过t时间后，该车车头的x坐标为Xi-t，车尾坐标为Xi-t+Li 。只要打中车的任何一个部分就算击中。
请你算算，他在哪两个时刻发射，才能摧毁最多的运输车。
先简化下题目的意思，由于每个车辆的前进速度是统一的，那么实际上我们就不用考虑车子移动的情况了，只需要在x轴上选择两个点发射激光炮即可。此外，这个题目的数据规模是X、L<= 10^9 而不是109。
需要注意，第2次发射的激光炮不会击毁被第一次发射的激光炮已经击毁的车子。也就是1辆车不能被击毁两次。我们就不能单纯在按某个点上的车辆最多和次多来选择x轴上发射激光炮的位置了。考虑到只能发射两枚激光炮，那么我们只需要枚举这2个位置就可以了。
但是观察X和L 10^9的限时，直接枚举x轴上的两个点显然不可以。
我们考虑两个车有重叠的情况，要判断有没有办法一炮机会这两个车子，实际上我们只需要判断两个位置即可，即某个车头的点是在另外一个车的范围内即可。这是一种对于极限情况的考虑，如果该情况成立，就还会有若干其他的点可能满足，但这部分点就不需要再判断。换句话说，两个车如果有重叠，那么其中有个车的车头一定在另外一个车的车身范围内。
扩展到一般情况，根据上面的讨论，对于所有的车，我们激光炮的发射位置只需要选择每个车车头的位置即可。枚举之后再判断哪些车子被击毁，做上标记。最后记录一个最大的击毁数目即可。由于车辆总数n仅仅200，先两重循环枚举2个车头位置，再用一层循环检查击毁数目，算法的时间复杂度为O(n^3)是可以接受的。
import sys
def calc(f, s, c, n):
destroy = [False for i in range(n)]
res = 0
for i, elem in enumerate(c):
if elem[0] <= f <= elem[1] or elem[0] <= s <= elem[1]:
if not destroy[i]:
res += 1
destroy[i] = True
return res
def main():
n = map(int, sys.stdin.readline().strip().split())[0]
cars = []
segments = []
for i in range(0, n):
line = map(int, sys.stdin.readline().strip().split())
cars.append((line[0], line[0] + line[1]))
segments.append(line[0])
r = 0
for i in range(len(segments)):
for j in range(i):
r = max(r, calc(segments[i], segments[j], cars, n))
print r
if __name__ == '__main__':
main()
幸运数
<题目来源: 京东2017秋招 原题链接-可在线提交(赛码网)>
问题描述
小明同学学习了不同的进制之后，拿起了一些数字做起了游戏。小明同学知道，在日常生活中我们最常用的是十进制数，而在计算机中，二进制数也很常用。现在对于一个数字x，小明同学定义出了两个函数f(x)和g(x)。
f(x)表示把x这个数用十进制写出后各个数位上的数字之和。如f(123)=1+2+3=6。
g(x)表示把x这个数用二进制写出后各个数位上的数字之和。如123的二进制表示为1111011，那么g(123)=1+1+1+1+0+1+1=6。
小明同学发现对于一些正整数x满足f(x)=g(x)，他把这种数字称为幸运数，现在他想知道，小于等于n的幸运数有多少个。
接下来的这两个题目相对比较简单，数据范围也不大，这个题目可以直接按照题目意思模拟即可。
注意以下两点问题：
1.这类题目都要采用离线的计算方式，一次性先把数据规模内的数据全部计算到出来并保存，然后根据输出直接输出结果即可。
2.相对来说这个题目的数据规模较弱，注意到在当次计算时，如果个位没有发生进位的话，结果就是上次计算的结果+1，如果发生了进位再全部计算一次即可。这样可以节约非常大的一个计算量。
提交后我大致看了下运行时间，我使用的python耗时369ms，而其他python和java耗时接近或者超过1000ms，其中一个C++的运行时间为623ms。有时候一个很小的优化带来的性能提升是很显著的。
import sys
const_max_n = 100000 + 1
def _next(bits, last_sum, base):
next_add = 0
bits[0] += 1
last_sum += 1
if bits[0] >= base:
last_sum = 0
for i in range(len(bits)):
bits[i] += next_add
if bits[i] >= base:
bits[i] = 0
next_add = 1
else:
next_add = 0
last_sum += bits[i]
if next_add == 1:
bits.append(1)
last_sum += 1
return last_sum
def main():
r = [0 for i in range(0, const_max_n)]
_dec = [0]
_bin = [0]
last_bin_sum = last_dec_sum = 0
for i in range(1, const_max_n):
last_bin_sum = _next(_dec, last_bin_sum, 2)
last_dec_sum = _next(_bin, last_dec_sum, 10)
r[i] = r[i - 1]
if last_bin_sum == last_dec_sum:
r[i] += 1
t_case = map(int, sys.stdin.readline().strip().split())[0]
for i in range(0, t_case):
n = map(int, sys.stdin.readline().strip().split())[0]
print r[n]
if __name__ == '__main__':
main()三子棋
<题目来源: 京东2016实习生招聘 原题链接-可在线提交(赛码网)>
问题描述
三子棋是一种大家熟知的游戏，几乎所有人都会玩。游戏规则相当简单，两人依次在一个3X3棋盘格上下棋，一个人画叉，另一个人画圈。任何一个人画的三个记号如果形成构成一条水平、垂直或对角的直线则获胜，游戏结束。画叉的人先开始游戏，如果所有的棋盘格都画满了但两人都不能获胜，则游戏平局结束。
游戏在一个3X3的棋盘上进行，每个棋盘格单元处于空白、画叉或画圈状态中的一种，你的任务是确定下一轮由谁下棋:
1：轮到先手下棋；
2：轮到后手下棋；或者是判定游戏的状态：
x：给定的棋局不是合法的棋局；
1 won：先手获胜；
2 won：后手获胜；
Draw：平局；小东对棋类游戏很有研究，这一次三子棋比赛中，她被邀请作为评判，为了提携后进，她请你帮忙判定。
本题看似简单，其实要注意的地方还比较多，包括如何比较优雅的完成代码的编写(这我代码也写不太好)。
注意到本题的条件具有先后顺序。应该是下列顺序：
1.给定的棋局是否合法；
2.是否有获胜方；
3.平局
4.该谁下棋
这类题目建议使用一个方向向量，方向向量可以指示要判断的方向。比如，要判断一个从上到下的对角线情况，我们可以设置一个(1,1)的方向向量，当从(0,0)开始后：
- = (0, 0)
sx = 0, sy = 0
for i <- 0 to 2:
sx += d[0]
sy += d[1]
即可，对于本题，设置一个判断8个方向的起始位置后，再对应设置8个方向向量即可。这样对于我们编写代码十分有利。可以最大限度的减少代码量，便于阅读。
import sys
start = [(2, 0), (1, 0), (0, 0), (0, 0), (0, 0), (0, 1), (0, 2), (2, 0)]
vector = [(0, 1), (0, 1), (0, 1), (1, 1), (1, 0), (1, 0), (1, 0), (-1, 1)]
def main():
while True:
x = o = 0
board = []
for i in range(3):
line = map(str, sys.stdin.readline().strip().split())
if len(line[0]) < 3:
return
for l in line[0]:
if l == 'X':
x += 1
elif l == '0':
o += 1
board.append(list(line[0]))
legal = True
w1 = w2 = False
if 0 <= x - o <= 1:
for i in range(8):
d = {'0': 0, 'X': 0, '.': 0}
dx, dy = start[i][0], start[i][1]
for j in range(3):
t = d.get(board[dx][dy])
d[board[dx][dy]] = t + 1
dx += vector[i][0]
dy += vector[i][1]
if d.get('X') == 3:
w1 = True
if d.get('0') == 3:
w2 = True
if w1 and w2 or x > o and w2 or x == o and w1:
legal = False
else:
legal = False
if legal:
if w1:
print '1 won'
elif w2:
print '2 won'
else:
if x + o == 9:
print 'draw'
elif x == o:
print '1'
else:
print '2'
else:
print 'x'
if name == ‘__main__’:
main()
*[1] 关于01背包问题及其扩展可以参考下列文章:
http://blog.csdn.net/mu399/ar…
http://blog.csdn.net/insistgo…
