View source for 2301 - Secv

Se consideră două numerele naturale <code>K</code> și <code>S</code> și un șir de <code>N</code> numere naturale <code>a[1]</code>, <code>a[2]</code>,…, <code>a[N]</code>. O secvenţă de lungime <code>K</code> este un subşir format din <code>K</code> elemente aflate pe poziţii consecutive în şir: <code>a[i]</code>, <code>a[i+1]</code>,.., <code>a[i+k-1]</code>. Parcurgând șirul de la stânga la dreapta, începând cu primul element, se elimină prima secvență de lungime <code>K</code>, cu suma elementelor strict mai mare decât numărul <code>S</code>. În urma ștergerii șirul va avea <code>N-K</code> elemente: <code>a[1]</code>, <code>a[2]</code>,…, <code>a[N-K]</code>. Operația de ștergere continuă după aceleași reguli până când nu mai există secvențe care pot fi eliminate.

= Cerința =
Să se scrie un program care citind numerele <code>N</code>, <code>K</code>, <code>S</code> și cele <code>N</code> elemente din șir rezolvă cerințele:

1) Determină numărul secvențelor care se vor elimina respectând condiția din enunț.

2) Considerând că în șirul citit nu sunt posibile eliminări de secvențe conform condiției din enunț, programul determină numărul de elemente <code>a[i]</code> din șir cu proprietatea următoare: ștergerea lui <code>a[i]</code> conduce la obținerea unui șir în care se mai poate elimina cel puțin o secvență de <code>K</code> elemente cu sumă strict mai mare ca <code>S</code>.

= Date de intrare =
Fișierul de intrare <code>secv.in</code> conține pe prima linie un număr natural <code>P</code>; numărul <code>P</code> poate avea doar valoarea <code>1</code> sau valoarea <code>2</code>. A doua linie conține, în această ordine, separate prin câte un spațiu, numerele <code>N</code>, <code>K</code> și <code>S</code>. A treia linie conține, în ordine elementele șirului, despărțite prin câte un spațiu.

= Date de ieșire =
Dacă valoarea lui <code>P</code> este <code>1</code>, se va rezolva numai '''cerinta 1)'''. În acest caz, fişierul de ieşire <code>secv.out</code> va conține pe prima linie un număr natural reprezentând numărul secvențelor eliminate.

Dacă valoarea lui <code>P</code> este <code>2</code>, se va rezolva numai '''cerinta 2)'''. În acest caz, fişierul de ieşire <code>secv.out</code> va conține pe prima linie un număr natural reprezentând numărul elementelor din șir care au proprietatea că ștergerea fiecăruia în parte ar genera un șir în care se mai pot elimina cel puțin o secvență de <code>K</code> elemente cu sumă strict mai mare ca <code>S</code>.

= Restricții și precizări =

* <code>0 < N ≤ 1 000 000</code> și <code>K ≤ N</code>
* <code>0 < S ≤ 1 000 000 000</code>
* <code>0 ≤ a[1], a[2],...,a[N] ≤ 1.000</code>

= Exemplul 1: =
<code>secv.in</code>
 1
 14 3 7
 1 2 1 3 1 4 5 2 1 4 1 8 2 3
<code>secv.out</code>
 3

== Încărcare soluție ==

=== Lipește codul aici ===
<syntaxhighlight lang="python" line="1">
import sys

MAXN = 1000001
A = [0] * MAXN
B = [0] * MAXN
N = 0
K = 0
S = 0
P = 0
i = 0

def solve1():
    ul = 0
    Nr = 0
    global i
    for i in range(1, N + 1):
        B[ul + 1] = B[ul] + A[i]  # sume partiale
        ul += 1
        if ul >= K and B[ul] - B[ul - K] > S:
            Nr += 1
            ul -= K
    print(Nr)

def solve2():
    ul = 0
    global i
    for i in range(1, N + 1):
        B[ul + 1] = B[ul] + A[i]
        ul += 1
        if ul >= K and B[ul] - B[ul - K] > S:
            print(ul - K + 1, end=' ')
            ul -= K

def solve3():
    pr = 1
    ul = 0
    Nr = 0
    global i
    for i in range(1, N + 1):
        A[i] += A[i - 1]
    for i in range(1, N + 1):
        if i + K <= N:
            while pr <= ul and A[i + K] - A[i - 1] >= A[B[ul] + K] - A[B[ul] - 1]:
                ul -= 1
            B[ul + 1] = i
            ul += 1
        if A[B[pr] + K] - A[B[pr] - 1] - (A[i] - A[i - 1]) > S:
            Nr += 1
        if B[pr] == i - K:
            pr += 1
    print(Nr)

def main():
    sys.stdin = open('secv.in', 'r')
    sys.stdout = open('secv.out', 'w')
    global N, K, S, P, i
    P = int(input())
    N, K, S = map(int, input().split())
    A[1:N+1] = map(int, input().split())
    if P == 1:
        solve1()
    if P == 2:
        solve3()

if __name__ == "__main__":
    main()
</syntaxhighlight>