2020春腾讯实习笔试

2020春腾讯实习笔试

网上看到的2020春腾讯笔试，试一试

第一题

直接贪心算法就可以了。如果收益大于消耗就一定去打这个怪物，但是收益和消耗需要置换到同一维度，显然以血量为单位比较合适，只需要乘法。计算打一个怪物，收益的血量大于消耗的血量，打完之后，金币收益累加，消耗血量累加，最后决定买多少血量即可。

### 获取信息
n,q= [int(i) for i in input().split(' ')]
# input().split(' ') >> ['3', '2']
info = []
for i in range(n):
    info.append([int(i) for i in input().split(' ')])
###
money = 0
blood = 0
for each in info:
    if q*each[1] + blood > each[0]: #打怪
        if blood < each[1]: # 需要用钱换血
            money_one = 1
            while money_one * q + blood < each[0]:
                money_one += 1
            money -= money_one# 换钱
            blood = money_one * q + blood - each[0]# 更新血量
            money += each[1]# 更新钱
        else: # 不需要换钱
            blood = blood - each[0]# 更新血量
            money += each[1] #更新钱
print(money)

# 别人的
from math import ceil

n,q= [int(i) for i in input().split(' ')]
res = 0
b = 0
for i in range(n):
    cost,gain = [int(i) for i in input().split(' ')]
    if gain *q >cost:
        res += gain
        b += cost
print(res - ceil(b/q))

第二题

n = int(input())
info = []
for i in range(n):
    info.append([int(i) for i in input().split(' ')])

for item in info:
    a = item[1]
    b = -2 * item[0]
    c = 2 * item[0] * item[2]
    #判断是否有交点
    delta = b * b - 4 * a * c
    if delta < 0:
        print(0)
    else:
        # 求交点
        x1 = (-b + delta**0.5) / 2*a
        x2 = (-b - delta**0.5) / 2*a
        # 求面积
        area = (x2**3-x1**3)/(6*item[0]) - (x2**2-x1**2)/(2*item[1]) + (x2-x1)*item[2]/item[1]
        print(area)

# 别人的
n = int(input())
for i in range(n):
    A,B,C = [int(i) for i in input().split(' ')]
    delt = 4*A**2/(B**2) - (8*A*C/B)
    if delt <= 0:
        print(0)
    else:
        x1,x2 = ((2*A/B) - delt**0.5)*0.5 , ((2*A/B) + delt**0.5)*0.5
        print ((x1**3 / (6*A) - x1**2 /(2*B) + x1*C/B) - x2**3 / (6*A) + x2**2 / (2*B) - x2*C/B)

第三题

为什么对100003取模？

m, n = [int(i) for i in input().split(' ')]
ans = m**n - m*((m-1)**(n-1))
print(ans)

# 别人的
m,n= [int(i) for i in input().split()]
m = m%10003
print (m*(m**(n-1)-(m-1)**(n-1))%100003)

第四题

# 逐个去计算每个物品是否和之前的是完美配对，据说会超时 O(n^2*k)
n, k = [int(i) for i in input().split(' ')]
info = []
for i in range(n):
    info.append([int(i) for i in input().split(' ')])
ans = 0
for i in range(n):
    for j in range(i+1,n):
        deng = 1 # 表示物品相等的标志
        for m in range(1,k):
            if info[i][0] + info[j][0] != info[i][m] + info[j][m]:
                deng = 0 # 表示物品不相等
                break
        if deng == 1:
            ans += 1
print(ans)

第五题

利用并查集思想，将所有关系构造成树的边
并查集

test = int(input()) # 几组输入数据

### 查找节点node的根节点
def find_root(x, parent):
    if parent[x] == -1: # 该节点没有父节点，表示该节点的根节点就是它本身
        return x
    else:
        return find_root(parent[x], parent)

### 合并有边关系的两个节点，父节点相同的两节点不合并，否则会出现环
def union(x, y, parent, rank):
    # 先找x,y节点的根
    x_root, y_root = find_root(x, parent), find_root(y, parent)
    # 将根相连
    if x_root != y_root:
        # 根据rank判断如何相连才能得到高度最小的树,将高树的根作为低树根的父节点，树的高度不会增加
        if rank[x_root] > rank[y_root]:
            parent[y_root] = x_root
        elif rank[x_root] < rank[y_root]:
            parent[x_root] = y_root
        else: # 两个相等时随便连但是父节点的高度增加
            parent[x_root] = y_root
            rank[y_root] += 1
    


for i in range(test):
    # 接收输入信息
    n = int(input()) #接收有多少组关系
    edges = [] # 保存边关系的列表
    for j in range(n):
        edges.append([int(i) for i in input().split(' ')])
        people_num = max(edges[-1])

    # 父节点列表的初始化
    parent = [-1 for i in range(people_num+1)] #+1是因为数据是从1开始的，从0开始不用加1
    # 节点高度列表初始化
    rank = [0 for i in range(people_num+1)]

    # 将边信息构建成树
    for line in edges:
        x, y = line[0], line[1]
        union(x, y, parent, rank)
        
    # 计算拥有最大节点数的树
    """
    在parent列表中，是-1的都是根节点，-1的个数就是树的个数(实际上-1个数减1才是树的个数，因为多加了parent[0],但是不影响)
    不是-1的找根节点，对应的根节点所在树节点个数+1
    """
    node_num = {}
    # 先将树根存入 key:根 value：树节点个数
    for index, item in enumerate(parent):
        if item == -1:
            node_num[index] = 1
    # 剩下的节点找根，计数
    for i in range(len(parent)):
        if parent[i] != -1:
            i_root = find_root(i, parent)
            node_num[i_root] += 1
    ans = max(node_num.values())
    print(ans)
    

以上程序仅能通过已给的测试用例，由于是网上看到的题，没有大量的测试用例。