1674 - Livada1

Fermierul Quinto are o livadă plină cu pomi fructiferi. Livada are N rânduri, numerotate de la 1 la N, pe fiecare rând aflându-se câte M pomi fructiferi, numerotaţi de la 1 la M. Livada lui Quinto este una specială, aşa că pentru unii pomi se cunoaşte cantitatea de fructe (exprimată în kg) care poate fi culeasă, iar pentru alţii aceasta poate fi determinată pe baza unei formule. Quinto şi-a propus să recolteze C kg de fructe din pomii aflaţi în livada lui. Acesta foloseşte un utilaj modern pentru culesul fructelor. Utilajul poate fi folosit pe oricare din rândurile livezii, dar poate aduna doar fructele dintr-un şir consecutiv de pomi, începând cu primul pom de pe rândul respectiv, neavând posibilitatea de a culege parţial fructele dintr-un pom. Preocupat de frumuseţea livezii sale, Quinto s-a gândit la restricţii suplimentare pentru recoltarea cantităţii C de fructe. Astfel, el doreşte să adune fructele din pomi de pe maximum R rânduri diferite, pentru ca N-R rânduri să rămână complete. De asemenea, el doreşte să culeagă cu prioritate pomii care au o cantitate cât mai mică de fructe, pentru ca în livadă să rămână cei mai roditori pomi. Quinto şi-a dat seama că este dificil să culeagă fix C kg de fructe, prin urmare este mulţumit şi cu o cantitate mai mare, care respectă celelalte condiţii impuse de el.

Cerința

Determinaţi cea mai mică valoare X posibilă astfel încât să se poată culege, în condițiile de mai sus, o cantitate de cel puțin C kg de fructe și orice pom din care se culeg fructe să conțină cel mult X kg de fructe.

Date de intrare

• Pe prima linie a fişierului livada1.in se află 4 numere naturale N M C R cu semnificaţia din enunţ.
• Pe a doua linie din fişierul de intrare se află 5 numere naturale x y z w u, separate printr-un spaţiu.
• Dacă notăm cu A[i][j] cantitatea de fructe (exprimată în kg) din cel de-al j-lea pom de pe linia i, atunci:
  • Linia a treia din fişierul de intrare conţine M valori A[1][i], 1≤i≤M, separate printr-un spaţiu
  • Linia a patra din fişierul de intrare conţine N-1 valori A[i][1], 2≤i≤N, separate printr-un spaţiu
  • Celelalte valori A[i][j], 2≤i≤N, 2≤j≤M, se calculează conform formulei: A[i][j] = (x*A[i-1][j] + y*A[i][j-1] + z*A[i-1][j-1] + w) % u.

Date de ieșire

Fișierul de ieșire livada1.out va conține o singură valoare scrisă pe prima linie, care reprezintă cea mai mică valoare a cantităţii de fructe (exprimată în kg) dintr-un pom cules, astfel încât să fie respectate toate restricţiile problemei.

Restricții și precizări

• 1 ≤ R ≤ N ≤ 100
• 1 ≤ M ≤ 25000
• 0 ≤ x,y,z,w,u ≤ 10^9
• 0 ≤ A[i][j] ≤ 10^9
• Atenție la determinarea fiecărei valori A[i][j] pentru că în formulă sunt produse care pot să furnizeze valori mai mari decât 2^32-1.
• 1 ≤ C ≤ 10^18
• Se garantează că pentru toate testele problema are soluție
• Pentru 30% din teste se garantează faptul că 1 ≤ M ≤ 100 şi 1 ≤ A[i][j] ≤ 100
• Pentru 70% din teste se garantează faptul că 1 ≤ M ≤ 4000

Exemplu:

livada1.in

5 6 18 4
3 6 5 2 7
4 1 3 5 1 2
5 2 6 3

livada1.out

4

Încărcare soluție

Lipește codul aici

import numpy as np

NMax = 100
MMax = 25000
A = np.zeros((NMax+5, MMax+5), dtype=int)
Max = np.zeros((NMax+5, MMax+5), dtype=int)
Sum = np.zeros((NMax+5, MMax+5), dtype=int)
N = 0
M = 0
R = 0
Sol = 0
C = 0

def Read():
    global N, M, C, R
    global A
    x = 0
    y = 0
    z = 0
    w = 0
    u = 0
    with open("livada1.in", "r") as fin:
        lines = fin.readlines()
        N, M, C, R = map(int, lines[0].split())
        x, y, z, w, u = map(int, lines[1].split())
        A[1, :] = list(map(int, lines[2].split()))
        for i in range(2, N+1):
            A[i, 1] = int(lines[i+1])
            for j in range(2, M+1):
                A[i, j] = (x * A[i - 1, j] + y * A[i, j - 1] + z * A[i - 1, j - 1] + w) % u

def Precalculate():
    global N, M
    global A, Max, Sum
    for i in range(1, N+1):
        for j in range(1, M+1):
            Sum[i, j] = A[i, j] + Sum[i, j-1]
            Max[i, j] = max(Max[i, j-1], A[i, j])

def Find(i, Value):
    global M
    global A, Sum, Max
    Crop = 0
    Left = 1
    Right = M
    while Left <= Right:
        Mid = (Left+Right) // 2
        if Max[i, Mid] <= Value:
            Crop = Sum[i, Mid]
            Left = Mid + 1
        else:
            Right = Mid - 1
    return Crop

def Check(Value):
    global N, R, C
    V = np.zeros(NMax, dtype=int)
    k = 0
    for i in range(1, N+1):
        V[k] = Find(i, Value)
        k += 1
    V = np.sort(V[:k])[::-1]
    Total = 0
    for i in range(1, R+1):
        if i <= k:
            Total += V[i-1]
    return Total >= C

def Solve():
    global Sol
    Left = 1
    Right = 1000000000
    while Left <= Right:
        Mid = (Left + Right) // 2
        if Check(Mid):
            Sol = Mid
            Right = Mid - 1
        else:
            Left = Mid + 1

def Print():
    global Sol
    with open("livada1.out", "w") as fout:
        fout.write(str(Sol) + "\n")

if __name__ == '__main__":
Read()
Precalculate()
Solve()
Print()