2020秋招拼多多客户端开发笔试题目
- 数组升序
题目描述：
给定两个数组A和B。其中数组A是几乎严格升序排列的，几乎的定义是只需改变其中一个数，即可满足完全升序排列。这里严格升序排列指的是不允许相邻两个为相同的数。请找出数组B中满足要求的最大数，并输出最终的有序数组，如果找不到，输出”NO”。
输入描述：
共两行，第一行是数组A，第二行为数组B，输入之间用空格分割，且len(A),len(B)<100。
输出描述：
最终有序数组，不存在则输出NO
示例：
输入：
1 3 5 7 4 10
2 1 5 8 9
输出：
1 3 7 9 10
#include#include #include #include using namespace std; int main(){ vector A; vector B; int tmp; int idx=-1,i=-1; while(scanf("%d",&tmp)!=EOF){ if(tmp!=' ') { A.push_back(tmp); ++i; } if(i>0 && A[i]<=A[i-1]){ idx=i; } if(tmp=='\n') break; } while(scanf("%d",&tmp)!=EOF){ if(tmp!=' ') B.push_back(tmp); } if(idx==-1) { for (int k = 0; k < A.size(); ++k) { if (k > 0) cout << " "; cout << A[k]; } cout << endl; }else{ sort(B.begin(),B.end()); int pos=-1; vector ::iterator it; if(idx 测试输出
2.字符串成环
题目描述：
给定一个字符串数组（字符串长度和数组的长度均大于1且小于1024），所有字符串均为大写字母，给定的字符串数组能否通过更换数组中元素顺序，从而首尾成环，环上相邻字符串首尾衔接的字符相同。
输入描述：
一行字符串，空格分割
输出描述：
true or false
示例：
输入：
CAT TIGER RPC
输出：
true
import sys
if __name__ == "__main__":
n = sys.stdin.readline().strip()
N = list(n.split())
head,end = N[0][0], N[0][-1]
N.pop(0)#第一个元素已经得到记录，删除它
while N!=[]:
for s in N:
ind = [id for id,i in enumerate(N) if i[0]==end]#找到开头与end相同的所有字符串的下标
if ind ==[]:#如果没有找到，则说明不能成环
print('false')
exit()
choose = ind[0]#如果能找到，则先取第一个
for i in ind:
if N[i][0] == N[i][-1]:#如果找到的字符串中，首位是相同的,比如BCVHSGB，那么就取这个字符串,因为取了这个字符串，end不变，比如head,end=A,B，现有BCVHSGB和BCVHSGM可取，则优先取BCVHSGB，这样head,end还是A,B
choose = i
end = N[choose][-1]#将end更新为取的字符串的末尾字符
N.pop(choose)#将取的这个字符pop()出来
if head != end:#等到所有字符串都处理完，如果头不等于尾，则不能成环
print('false')
exit()
print('true')#否则，能成环3.任务依赖
题目描述：
一共有N个执行的任务，每个任务需要PiPi的时间完成执行。同时，任务之间可能会有一些依赖关系。比如任务1可能依赖任务2和任务3，那么任务1必须在任务2和任务3都执行完成后才能执行。
同时只能执行一个任务，并且在任务完成之前不能暂停切换去执行其他任务。为了提升平台用户的使用体验，希望最小化任务的平均返回时长。一个任务的返回时长定义为任务执行完成时刻减去平台接收到该任务的时刻。在零时刻，所有N个任务都已经被平台接收。
安排一下任务执行顺序，使得平均返回时长最小。
输入描述：
第一行包含2个正整数N、M，分别表示任务数量以及M个任务依赖关系。
第二行包含N个正整数，第i（1 <= i <= N）个数表示第i个任务的处理时间Pi。
接下来的M行，每行表示一个任务依赖关系。每行包含2个整数Ai（1 <= Ai <= N）、Bi（1 <= Bi <= N）。表示第Bi个任务依赖于第Ai个任务。数据保证不会出现循环依赖的情况。
数据范围：
1 <= N <= 1000
1 <= M <= 50000
1 <= Pi <= 10000
输出描述：
输出一行，包含N个整数（两两之间用一个空格符分隔），其中第i（1 <= i <= N）个整数表示多多鸡执行的第i个任务的编号。若有多种可行方案，则输出字典序最小（优先执行编号较小的任务）的方案。
示例：
输入：
5 6
1 2 1 1 1
1 2
1 3
1 4
2 5
3 5
4 5
输出：
1 3 4 2 5
import os
def TaskSequence(n,degree,depend,cost):
res=[]#保存每个结点用时
queue=[]
for i in range(1,n+1):
if degree[i]==0:#先把不依赖于其他结点的的结点入队
queue.append([i,cost[i-1]])#队列记录的是结点标号以及开销
degree[i]=-1#懒惰删除
while queue:#当没有结点存入优先队列，说明所有结点都已经执行完毕
queue.sort(key=lambda x:(x[1],x[0]))#按照执行时间-标号排序
node=queue.pop(0)
res.append(node[0])
if node[0] not in depend:#该节点没有被任何结点依赖，无须进一步计算，继续取下一个结点
continue
for ref in depend[node[0]]:#该节点执行完毕，所有依赖于该节点的其他结点，依赖数目要减一
degree[ref]-=1
for i in range(1,n+1):#查看下是否有结点已经获得自由
if degree[i]==0:
queue.append([i,cost[i-1]])#将自由结点入队，连同编号和开销
degree[i]=-1
return res
if __name__ == "__main__":
n,m=map(int,input().split())
cost=list(map(int,input().split()))#将输入序列中的每一个元素转换成int,再形成list返回
degree={}
for i in range(1,n+1):
degree[i]=0#初始化时，每个节点不依赖于任何其他结点
depend={}
for _ in range(m):
ref=list(map(int,input().split()))
depend.setdefault(ref[0],[]).append(ref[1])
degree[ref[1]]+=1#该节点依赖于其他结点，+1
res=TaskSequence(n,degree,depend,cost)
print(" ".join(map(str,res)))
4.最高金字塔
题目描述：
有N个长方体积木，每个积木的高都是1，长宽都为Li，重量为Wi。
现在要用这些积木搭一个高高的金字塔。他打算金字塔的每一层是由且仅由一块积木组成。同时每一层的积木边长都严格比在其下方的积木小。
每块积木只能承受自身重量的7倍重量，若超过7倍自重，搭建的金字塔会因此变得不稳定。具体来说即：对于每一块积木，在其上方的积木重量之和必须小于等于其自重的7倍。
计算一下最高可以搭一个多高的金字塔？
数据范围：
1 <= N <= 100
1 <= Li <= 1000
1 <= Wi <= 1000
输入描述：
第一行包含1个正整数N，表示积木的数量。
第二行包含N个正整数，第i个数表示第i个积木的长度Li。
第三行包含N个正整数，第i个数表示第i个积木的重量Wi。
输出描述：
输出占一行，仅包含一个整数，表示可以搭出的金字塔的最高高度。
示例：
输入：
10
1 2 3 4 5 6 7 8 9 10
1 1 1 1 1 1 1 1 1 10
输出：
9
其实我觉得是暴力解法
if __name__ == "__main__":
N = int(input())
L = list(map(int, input().split()))
W = list(map(int, input().split()))
Pair = []
for i in range(N):
Pair.append([L[i], W[i]])
Pair.sort(key=lambda x:x[0])
Pair.insert(0, [0, 0])
# dp[i][j]表示第i个积木为底时，构造高度为j时所用的积木的最小重量
dp = [[float("inf") for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0] = 0
ans = 0
for i in range(1, N + 1):
# 以第i块积木为底时
for k in range(i):
if Pair[k][0] < Pair[i][0]: # 长度满足条件
for j in range(k+1):
# 重量满足条件
if dp[k][j] != float("inf") and dp[k][j] <= Pair[i][1]*7:
dp[i][j+1] = min(dp[i][j+1], dp[k][j]+Pair[i][1])
ans = max(ans, j+1)
print(ans)