Editing 1674 - Livada1

Fermierul Quinto are o livadă plină cu pomi fructiferi. Livada are <code>N</code> rânduri, numerotate de la <code>1</code> la <code>N</code>, pe fiecare rând  aflându-se câte <code>M</code> pomi fructiferi, numerotaţi de la <code>1</code> la <code>M</code>. 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 <code>C</code> 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 <code>C</code> de fructe. Astfel, el doreşte să adune fructele din pomi de pe maximum <code>R</code> rânduri diferite, pentru ca <code>N-R</code> 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 <code>C</code> 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 <code>X</code> posibilă astfel încât să se poată culege, în condițiile de mai sus, o cantitate de cel puțin <code>C</code> kg de fructe și orice pom din care se culeg fructe să conțină cel mult <code>X</code> kg de fructe.

= Date de intrare =

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

= Date de ieșire =
Fișierul de ieșire <code>livada1.out</code> 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 =

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

= Exemplu: =
<code>livada1.in</code>
 5 6 18 4
 3 6 5 2 7
 4 1 3 5 1 2
 5 2 6 3
<code>livada1.out</code>
 4

== Încărcare soluție ==

=== Lipește codul aici ===
<syntaxhighlight lang="python" line="1">
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()
</syntaxhighlight>