华为 5.20 笔试真题 - 研发岗

import sys
input = sys.stdin.readline

def solve():
    n = int(input())
    tasks = list(map(int, input().split()))
    h = int(input())

    if n > h:
        print(-1)
        return

    total = sum(tasks)
    if total <= h:
        print(1)
        return

    max_t = max(tasks)

    def check(k):
        hours = 0
        for t in tasks:
            hours += (t + k - 1) // k
            if hours > h:
                return False
        return True

    lo, hi = 1, max_t
    while lo < hi:
        mid = (lo + hi) // 2
        if check(mid):
            hi = mid
        else:
            lo = mid + 1

    print(lo)

solve()

import sys
input = sys.stdin.readline

def solve():
    pre_arr = list(map(int, input().split()))
    in_arr = list(map(int, input().split()))
    n = len(pre_arr)

    in_pos = {v: i for i, v in enumerate(in_arr)}

    def build(pl, pr, il, ir):
        if pl > pr:
            return None
        root_val = pre_arr[pl]
        k = in_pos[root_val]
        left_size = k - il
        left = build(pl + 1, pl + left_size, il, k - 1)
        right = build(pl + left_size + 1, pr, k + 1, ir)
        return [root_val, left, right]

    def process(node, path_sum):
        if node is None:
            return None
        cur_sum = path_sum + node[0]
        if cur_sum <= 0:
            return None
        node[1] = process(node[1], cur_sum)
        node[2] = process(node[2], cur_sum)
        # 规则二：单子节点链反复合并
        while (node[1] is None) != (node[2] is None):
            child = node[1] if node[1] is not None else node[2]
            node[0] += child[0]
            node[1] = child[1]
            node[2] = child[2]
        return node

    def postorder(node, result):
        if node is None:
            return
        postorder(node[1], result)
        postorder(node[2], result)
        result.append(str(node[0]))

    root = build(0, n - 1, 0, n - 1)
    root = process(root, 0)
    result = []
    postorder(root, result)
    if not result:
        print("null")
    else:
        print(" ".join(result))

solve()

import sys
input = sys.stdin.readline

def solve():
    data = sys.stdin.read().split()
    idx = 0
    n = int(data[idx]); idx += 1
    T = int(data[idx]); idx += 1

    cost = [0] * (n + 1)
    val = [0] * (n + 1)
    children = [[] for _ in range(n + 1)]

    for _ in range(n):
        sid = int(data[idx]); idx += 1
        t = int(data[idx]); idx += 1
        v = int(data[idx]); idx += 1
        k = int(data[idx]); idx += 1
        cost[sid] = t
        val[sid] = v
        parent = 0
        if k == 1:
            parent = int(data[idx]); idx += 1
        children[parent].append(sid)

    NEG = -1
    f = [[NEG] * (T + 1) for _ in range(n + 1)]

    # 迭代 DFS 避免递归栈溢出
    order = []
    stack = [0]
    while stack:
        u = stack.pop()
        order.append(u)
        for v in children[u]:
            stack.append(v)
    order.reverse()  # 后序

    for u in order:
        if u == 0:
            for j in range(T + 1):
                f[u][j] = 0
        else:
            if cost[u] <= T:
                f[u][cost[u]] = val[u]

        for v in children[u]:
            # best_v[y] = 子树 v 花费 <= y 的最大战斗力（不选 v 记 0）
            best_v = [0] * (T + 1)
            cur = 0
            for y in range(T + 1):
                if f[v][y] > cur:
                    cur = f[v][y]
                best_v[y] = cur

            nf = [NEG] * (T + 1)
            for j in range(T + 1):
                if f[u][j] == NEG:
                    continue
                base = f[u][j]
                limit = T - j
                for y in range(limit + 1):
                    cand = base + best_v[y]
                    if cand > nf[j + y]:
                        nf[j + y] = cand
            f[u] = nf

    ans = 0
    for j in range(T + 1):
        if f[0][j] > ans:
            ans = f[0][j]
    print(ans)

solve()