Arbori Indexati Binar

(Categoria Structuri de date, autor Giurgea Mihnea)

Abstract - Problema

AIB-urile sunt o structura de date care implementeaza eficient urmatoarea problema: avem un vector de numere, si vrem sa raspundem la urmatoarele operatii asupra lui:

1. se incremeneaza/ decrementeaza un numar din vector
2. care este suma unei anumite subsecvente a vectorului?
   Pentru un exemplu mai concret, vezi problema datorii.

Sa ne gandim la cateva posibile solutii: am putea sa implementam usor un algoritm naiv de complexitate O(N), sau cu ceva efort sa folosim arborii de intervale pentru o complexitate O(logN). In continuare va vom prezenta structura de date numita AIB, usor de implementat si de aceeasi complexitate ca si arborii de intervale. Mai mult, deoarece acestia au constanta mult mai mica decat arborii de intervale, in practica se vor dovedi mult mai rapizi si vor ocupa si mai putina memorie.

Concret - Cum?

Fie V vectorul de numere care se modifica in timp real. Vom reprezenta AIB-ul folosind un alt vector, pe care il vom denumi, sugestiv, AIB, cu urmatoarea semnificatie:
AIB[x] = suma subsecventei din V cu capetele: [x - 2^k + 1; x], unde k = numarul de 0-uri terminale din reprezentarea binara a lui x.

Detalii implementare

Valoarea x - 2^k + 1, unde k = numarul de 0-uri terminale se poate calcula foarte usor astfel:

#define zeros(x) ( (x ^ (x - 1)) & x )

Aceast define va calcula valoarea 2^k pentru x, unde k = numarul de 0-uri terminale. Pentru a intelege de ce, sa luam cateva exemple:

Folosind acest define, implementarea operatiilor devine foarte simpla.

void Add(int x, int quantity)
{
    int i;

    for (i = x; i <= N; i += zeros(i))
        AIB[i] += quantity;
}

int Compute(int x)
{
    int i, ret = 0;

    for (i = x; i > 0; i -= zeros(i))
        ret += AIB[i];
    return ret;
}

Functia Add(x, quantity) incrementeaza valoarea lui V[x] cu quantity, care poate fi si negativ pentru a decrementa. Functia Compute(x) calculeaza suma V [1] + V [2] + ... + V [x]. Pentru a calcula suma subsecventei V [L...U] folositi Compute(U) - Compute(L-1).

Complexitatea in timp a fiecarei operatii este O(logN), pentru ca, in cazul celei de-a doua operatii, la fiecare pas ultimul bit nenul al lui i devine nul, si deci for-ul va itera de maxim log x ori. Structura ocupa spatiu O(N), doar vectorul AIB.

Aplicatii

Sa presupunem ca problema initiala se restrange la a marca/ demarca o pozitie, si ne propunem sa aflam care este cea de a K-a pozitie marcata.

O prima idee de rezolvare, de complexitate O(log² N), este urmatoarea: cautam binar pozitia, si la fiecare pas, pentru a compara pozitia curenta i cu solutia, calculam in O(logN) functia cnt(i) := suma elementelor de pe pozitiile 1...i; cnt(i) reprezinta de fapt numarul de numere intre 1 si i, pe care il comparam cu K pentru a sti cum facem urmatorul pas.

A doua idee de rezolvare, de complexitate O(logN) se poate realiza optimizand prima idee. Folosim cautarea binara a lui Patrascu si urmatoarea observatie: cnt(8+4) = cnt(8) + AIB[8+4], cnt(16+4) = cnt(16) + AIB[16+4], etc. Daca ne uitam la cum functioneaza functia Compute(int x), putem generaliza astfel: cnt(x) = cnt(x - zeros(x)) + AIB[x]. Implementarea propriu-zisa o lasam ca tema pentru cititor, impreuna cu problema gasirii celui de-al K-lea numar dintr-un AIB oarecare, pornind de la ideea de mai sus.

AIB-urile se pot extinde usor la cazul multidimensional, si lasam aceasta implementare ca tema pentru cititor. De asemenea, incercati sa rezolvati urmatoarele probleme de pe infoarena:
1. Datorii
2. Ben
3. Evantai
4. Schi

Pentru o lectura mai profunda in acest domeniu, va recomand acest articol de pe TopCoder.