有n根绳子，你需要把它们剪成k段长度相同的绳子。找出可以获得的碎片的最大长度。

输入数据第一行包含两个数字——n和k（1≤n，k≤10000）。另外，在接下来的 n 行中，每行写一个数字——下一根绳子的长度 ai (1≤ai≤107)。

输出打印一个实数 - 可以获得的碎片的最大长度。如果相对误差或绝对误差不超过 10−6，则答案将被视为正确。

Пример

Входные данные

4 11
802
743
457
539

Выходные данные
200.5

n, k = map(int, input().split())
def bina_(sp,n,k): # поиск целого числа
    i = 0
    r = 10 ** 7 + 1
    while r > i + 1:
        sr = (i + r) // 2
        if proveri_(sr,sp,k) == 1:
            i = sr
        else:
            r = sr
    return i

def bina_s(sp,a,k): # поиск числа после точки
    i = 0
    r = 9999999999
    while r > i + 1:
        sr = (i + r) // 2
        if proveri_s(sp,a,k,sr) == 1:
            i = sr
        else:
            r = sr
    return i
def proveri_s(sp,a,k,sr):
    co_ = 0
    for i in sp:
        co_ += int(i // float(f'{a}.{sr}'))
    if co_ >= k:
        return 1

def proveri_(sr,sp,k):
    co_ = 0
    for i in sp:
        co_ += (i // sr)
    if co_ >= k:
        return 1

sp = []
for i in range(n):
    sp.append(int(input()))
    
a = bina_(sp,n,k)
b = bina_s(sp,a,k)
print(float(f'{a}.{b}'))

简化代码

n, k = map(int, input().split())
def bina_(sp,n,k):
    i = 1
    r = 10 ** 7 + 1
    for _ in range(1000):
        sr = (i + r) / 2
        if proveri_(sr,sp,k) == 1:
            i = sr
        else:
            r = sr
    return i

def proveri_(sr,sp,k):
    co_ = 0
    for i in sp:
        co_ += (i // sr)
    if co_ >= k:
        return 1

sp = []
for i in range(n):
    sp.append(int(input()))

a = bina_(sp,n,k)
print(a)

问题 F：斜坡序列

如果每个元素严格大于或严格小于其邻居，我们将其称为序列锯齿。给定数字n和k，确定由数字1, ..., k组成的长度为n的锯齿序列的数量。

输入格式

该程序接收两个自然数n和k作为输入，1 ≤ n ≤ 4000、1 ≤ k ≤ 4000。

结果格式

需要求出所需序列数除以10 ⁹ +7的余数。

示例

def calculate_zigzag_patterns(length, max_value):
    if length == 1:
        return max_value

    increasing = [0] * (max_value + 1)
    decreasing = [0] * (max_value + 1)

    for index in range(1, max_value + 1):
        increasing[index] = 1
        decreasing[index] = 1

    for current_length in range(2, length + 1):
        new_increasing = [0] * (max_value + 1)
        new_decreasing = [0] * (max_value + 1)

        total_decreasing = 0
        for last_value in range(1, max_value + 1):
            total_decreasing += decreasing[last_value - 1]
            new_increasing[last_value] = total_decreasing

        total_increasing = 0
        for last_value in range(max_value, 0, -1):
            if last_value < max_value:
                total_increasing += increasing[last_value + 1]
            new_decreasing[last_value] = total_increasing

        increasing, new_increasing = new_increasing, increasing
        decreasing, new_decreasing = new_decreasing, decreasing

    final_result = sum(increasing[last_value] + decreasing[last_value] for last_value in range(1, max_value + 1))
    return final_result

length, max_value = map(int, input().split())
result = calculate_zigzag_patterns(length, max_value)
print(result % (10 ** 9 + 7))

通过问题E-蚱蜢和青蛙的解决方案 满分：100 时间限制：2秒 实时限制：5秒 内存限制：256M 问题E：蚱蜢和青蛙 问题条件（pdf）

蚱蜢沿着位于同一条线上且彼此距离相等的柱子跳跃。这些列的序列号为 1 到 N。一开始，蚱蜢坐在编号为 1 的柱子上。他可以向前跳跃 1 到 K 柱的距离，从当前的柱子开始计算。

有些帖子上有青蛙吃蚱蜢（蚱蜢不应该落在这些帖子上！）。确定 Grasshopper 可以通过多少种方式安全到达编号为 N 的列。请记住，Grasshopper 无法向后跳。输入格式 输入字符串包含自然数 N 和 K，以空格分隔。保证1≤N，K≤32。第二行包含青蛙的数量 L (0≤L≤N−2)。第三行包含L个自然数：青蛙所坐的列数（其中没有数字为1和N的列）。

Примеры
Входные данные
6 4
2
2 4
Выходные данные
3

我不明白出了什么问题，并非所有测试都通过

n, k = map(int, input().split())
l = int(input())
s_l = list(map(int, input().split()))
dp = [1] * n
dp_1 = []
for i in range(l):
    dp[s_l[i] - 1] = 0
dp_1 = []
dp_1.append(dp[0])
print(dp)
for i in range(1,n):
    if dp[i] == 0:
        pass
    else:
        if i < k:
            dp_1.append(sum(dp_1[:i]))
        else:
            dp_1.append(sum(dp_1[i - k:i]))
print(dp_1[-1])

关于此任务已经提出了有关优化的问题，但是仍然可以通过使用这部分代码来优化代码而不连接任何库吗？

while j + c - 1 < len(mass):
    if mass[j + c - 1] - mass[j] <= m:
        k += 1
        j = j + c
    else:
        j = j + 1

问题编号 1620。苏博尼克

班上还有人在学习N。班主任接到指示，各派一R组С人去清理。所有参与清理工作的团队都将从事搬运原木的工作。每根原木均由一个团队的所有成员同时搬运。在这种情况下，该大队成员的身高差异越小，携带原木就越方便。

团队的不便数将是该团队中最高和最矮成员的身高差（如果团队中只有一个人，则该差值等于0）。班主任决定组队，尽量将组队带来的不便降到最低。帮帮他吧！

考虑以下示例：

设班上有身高厘米为、、、、、、、、、的人，8需170分成两队，每队三人。205225190260130225160

那么一种选择是这样的：

第一大队：身高225、205、225的人

第二大队：身高160、190、170的人

在这种情况下，第一队的不便次数将等于20，第二队的不便次数将等于30。不便数的最大值将为30，这将是最好的结果。

输入格式

首先输入自然数N，R以及C- 班级人数、小组人数和每队人数（1 ≤ R∙C ≤ N ≤ 100 000）。接下来，N输入整数 - 每个N学生的身高。学生的身高是一个不超过的自然数1 000 000 000。

输出格式

打印一个数字 - 所组成的团队的最大不便次数的最小可能值。

n, r, c = map(int, str(input()).split())
mass = []
for i in range(n):
    mass.append(int(input()))
mass = sorted(mass)
right = mass[len(mass) - 1] - mass[0]
left = 0
while left < right:
    m = (left + right) // 2
    j = 0
    k = 0
    while j + c - 1 < len(mass):
        if mass[j + c - 1] - mass[j] <= m:
            k += 1
            j = j + c
        else:
            j = j + 1
    if k >= r:
        right = m

    else:
        left = m + 1

print(right)

我无法理解它从何而来，T也M无法分别理解循环的下限和上限：

今天早上，评审团决定在奥林匹克版本中添加另一个“非常简单的问题”。组委会执行秘书把条件打印了一份，现在他需要时间 N 在奥运会开始前多印几份。

他有两台复印机可供使用，其中一台可以在 х 几秒钟内复印一张纸，另一台则可以在y.

允许使用一台复印机或同时使用两台复印机。您不仅可以从原件复制，还可以从副本复制。

帮助他算出这需要最少的时间。

输入数据

程序输入接收三个自然数N、x和y，并用空格 ( 1 ≤ N ≤ 2∙108, 1 ≤ x, y ≤ 10) 分隔。

印记

打印一份号码 – 接收N副本所需的最短时间（以秒为单位）。

例子：

输入数据

4 1 1

印记

3

---

输入数据

5 1 2

印记

4

代码：

def min_time(N, x, y):
    if x > y:
        x, y = y, x

    M = y * (N - 1) // (x + y)
    T = x + max(x * M, y * (N - 1 - M))
    for m in range(max(0, M - 1), min(N - 1, M) + 2):
        t = x + max(x * m, y * (N - 1 - m))
        if t < T:
            T = t
    return T

N, x, y = map(int, input().split())
print(min_time(N, x, y))

它无法凭记忆运行，很可能是因为列表太大，但我不知道还有什么办法可以使它更短

from math import *


def binarnui_poisk(a,w,h): # модифицированный левый бинарный поиск
    result= -1
    low = 0
    high = len(a) - 1
    mid = len(a) // 2

    while low <= high:
        if a[mid] // w >= w and a[mid] // h >= h:

            high = mid - 1
            result = a[mid]

        else:
            low = mid + 1


        mid = (low + high) // 2


    return result

w, h, n = map(int, input().split())
s = sqrt((w * h * n)) # нахожу корень от площади, чтобы дальше с ним рабоатать, он будети началом списка
s = ceil(s) # округляю до целого числа
result_ = binarnui_poisk([int(i) for i in range(s, s * w * h + 1) ],w,h)
print(result_)