Editing 2453 - Rosii Mici

Dan este un mare pasionat al fructelor, printre preferatele sale fiind strugurii şi pepenii. Însă recent şi-a descoperit și pasiunea pentru legume, în special pentru roşii, dar mai ales roşiile mici. Spre norocul lui, grădina bunicului este plină de roşii. Grădina are forma unei matrice cu <code>N</code> linii și <code>M</code> coloane cu elemente numere naturale, nu neapărat distincte, unde fiecare element din matrice reprezintă dimensiunea unei roşii. Matricea are proprietatea că oricare coloană are valorile ordonate crescător de sus în jos, adică de la prima spre ultima linie. Bunicul său îi cere să rezolve <code>Q</code> sarcini. Pentru fiecare sarcină, Dan primeşte un număr natural <code>x</code> şi trebuie să găsească o submatrice de arie maximă care începe de pe linia <code>1</code> a matricei care reprezintă grădina şi are toate elementele mai mici sau egale decât <code>x</code>. Pentru determinarea submatricei cerute, Dan are voie să mute toate valorile unei coloane în fața oricărei alte coloane. De asemenea, îi este permis să facă oricâte mutări de tipul acesta.

= Cerința =
Să se calculeze aria maximă a unei submatrice care respectă specificațiile din enunț, pentru fiecare din cele <code>Q</code> sarcini date de către bunic.

= Date de intrare =
Fișierul de intrare <code>input.txt</code> conține pe prima linie trei numere naturale <code>N</code>, <code>M</code> și <code>Q</code> separate printr-un spaţiu, având semnificația din enunț. Pe fiecare dintre următoarele <code>N</code> linii se află câte <code>M</code> numere naturale despărțite prin câte un spațiu, reprezentând valorile matricei. Pe următoarele <code>Q</code> linii se află câte un număr natural <code>x</code>, reprezentând dimensiunea unei roşii.

= Date de ieșire =
Fișierul de ieșire <code>output.txt</code> va conține pe primele <code>Q</code> linii câte un număr natural, reprezentând aria maximă cerută

pentru fiecare sarcină, în ordinea în care acestea apar în fișierul de intrare.

= Restricții și precizări =

* <code>1 ≤ N, M ≤ 1000</code>
* <code>1 ≤ Q ≤ 100 000</code>
* <code>1 ≤ A[i][j] ≤ N * M</code>, <code>1 ≤ i ≤ N</code>, <code>1 ≤ j ≤ M</code>

== Exemplul 1 ==
input.txt:

3 4 3

1 9 6 2

1 10 10 4

7 15 10 6

6

10

9

output.txt:

4

9

6

Explicație:

Pentru rezolvarea primei sarcini Dan mută prima coloană în fața celei de a patra obținând matricea:

<code>9 6 1 2</code>

<code>10 10 1 4</code>

<code>15 10 7 6</code>

Alege apoi submatricea cu colțul stânga sus în <code>(1,3)</code> și colțul dreapta jos în <code>(2,4)</code>. Aria acesteia este <code>4</code>.

Pentru rezolvarea celei de a doua sarcini, Dan mută prima coloană în fața celei de a treia obținând matricea:

<code>9 1 6 2</code>

<code>10 1 10 4</code>

<code>15 7 10 6</code>

Soluția este submatricea cu colțul stânga sus în <code>(1,2)</code> și colțul dreapta jos în <code>(3,4)</code>. Aria acesteia este <code>9</code>.

Pentru rezolvarea celei de a treia sarcini, Dan mută ultima coloană în fața primei coloane, obținând matricea:

<code>2 1 9 6</code>

<code>4 1 10 10</code>

<code>6 7 15 10</code>

Soluția este submatricea cu colțul stânga sus în <code>(1,1)</code> și colțul dreapta jos în <code>(3,2)</code>. Aria acesteia este <code>6</code>.

== Exemplul 2 ==
input.txt:

9999999 4 3

1 9 6 2

1 10 10 4

7 15 10 6

6

10

9

Output:

ValueError: Error: 1 <= n <= 1000

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verify_constraints(n, m, q):
    if not (1 <= n <= 1000):
        raise ValueError("Error: 1 <= n <= 1000")
    if not (1 <= m <= 1000):
        raise ValueError("Error: 1 <= m <= 1000")
    if not (1 <= q <= 100000):
        raise ValueError("Error: 1 <= q <= 100000")

def main():
    def read_int():
        return int(fin.readline().strip())

    with open("input.txt", "r") as fin, open("output.txt", "w") as fout:
        n, m, q = map(int, fin.readline().split())
        verify_constraints(n, m, q)

        positions = [[] for _ in range(n * m + 5)]
        minn = [0] * m
        height = [0] * (m + 1)
        sum_ = [0] * (n + 1)
        ans = [0] * (n * m + 5)
        sol = 0

        for i in range(n):
            row = list(map(int, fin.readline().split()))
            for j in range(m):
                x = row[j]
                if not (minn[j] <= x):
                    raise ValueError("Error: minn[j] <= x")
                minn[j] = x
                positions[x].append(j)

        for val in range(1, n * m + 1):
            for j in positions[val]:
                height[j] += 1
                sum_[height[j]] += 1
                sol = max(sol, sum_[height[j]] * height[j])
            ans[val] = sol

        for i in range(1, n * m + 1):
            ans[i] = max(ans[i - 1], ans[i])

        for _ in range(q):
            x = read_int()
            fout.write(str(ans[x]) + "\n")

if __name__ == "__main__":
    main()

</syntaxhighlight>