OD C卷 - 堆内存申请

堆内存申请 （100）

• 有一个总空间为100字节的堆，从中申请一块内存，内存分配原则为：优先紧接着前一块已使用内存，分配空间足够且最接近申请大小的空闲内存；

输入描述：
第一行输入一个整数，表示要申请的内存大小；
第二行到第n行 输入两个整数，第一个数表示偏移地址，第二个数表示内存块大小
输出描述：
若申请成功，输出内存偏移地址；
若申请失败，则输出-1

若没有足够的空间分配，则申请失败；
堆内存信息区域有重叠或者有非法值（超出[0,100)）都是无效输入；

示例1
输入：
1
0 1
3 2
输出：
1

示例2
输入：
2
3 2
7 3
输出：
5

示例3
输入：
1
3 2
7 3
11 20
输出：
10

思路：

• start、end 区间数值必须在[0, 100) 并且start <= end;
• 区间不能有重叠
• 可以满足空间分配，且剩余的空闲空间最小（最接近申请大小）

# 输入一个整数
n = int(input().strip())

mem = []

# 不定行的输入
i = 0
while True:
    try:
        offset, size = list(map(int, input().strip().split()))
        mem.append([offset, offset + size])
        # i += 1
    except:
        break

mem.sort(key=lambda i:i[0])
length = len(mem)
flag = 0
for i in range(length):
    x = mem[i][0]
    y = mem[i][1]
    # 判断输入是否有效
    if x >= 0 and x < 100 and y >= 0 and y < 100 and x <= y: # 数值有效
        if i == 0:
            continue
        if i > 0 and x >= mem[i - 1][1]: # 区域不重叠
            continue

    flag = 1
    break

# 输入有效
if flag == 0:
    offset = -1

    left_distance = 100
    start = mem[0][0]
    # 处理首位偏移
    if start >= n:
        offset = 0
        left_distance = start - n

    # 从第二个开始
    i = 1
    while i < length:
        current = mem[i][0]
        before = mem[i - 1][1]
        if current - before >= n: # 满足空间分配
            if current - before - n < left_distance: # 满足最近分配大小
                offset = before
                left_distance = current - before - n       
        i += 1

    # 处理结尾分配
    end = mem[length - 1][1]
    if end + n <= 100 and 100 - end - n < left_distance:
        offset = end

    print(offset)

# 输入无效
else:
    print(-1)