ioanaalexandru / hw-pa-2 Goto Github PK

            ____   _              _____                      ____  
           |  _ \ / \            |_   _|__ _ __ ___   __ _  |___ \ 
           | |_) / _ \    _____    | |/ _ \ '_ ` _ \ / _` |   __) |
           |  __/ ___ \  |_____|   | |  __/ | | | | | (_| |  / __/ 
           |_| /_/   \_\           |_|\___|_| |_| |_|\__,_| |_____|

    Fiecare problemă moștenește interfața Problem, și deci are același format:
citește datele problemei dintr-un fișier dat ca parametru cu funcția Read(),
calculează rezultatul cu funcția Solve() și scrie rezultatul într-un fișier dat
ca parametru cu funcția Write(). Aceste funcții pot fi apelate de oricâte ori
pentru o instanță de problemă, pentru recitirea datelor, scrierea într-un alt
fișier sau recalcularea rezultatelor. Pentru flexibilitate, datele de intrare
și de ieșire ale fiecărei probleme pot fi accesate, și doar datele de intrare
pot fi modificate în afara funcțiilor definite.
_______________________________________________________________________________
                            TASK 1 - MINLEXBFS
‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
    Pentru acest task, am implementat o parcurgere BFS a unui graf începând de
la nodul 1, singura diferență față de algoritmul clasic fiind că muchiile (sau,
mai exact, nodurile adiacente ale fiecărui nod) sunt stocate în ordine lexico-
grafică - folosind un multiset construit cu un comparator care sortează muchi-
ile întâi crescător în funcție de cost (pentru task-ul 4, nu afectează graful
de aici pentru că nu este cu costuri) și apoi în ordine lexicografică.

    Complexitatea programului (worst-case) este după cum urmează:

→ Citire și inserare muchii: O(M * log(M))  │
→ Parcurgere BFS: O(M + N)                  │=> Total: O(M * log(M))
→ Scriere date: O(1)                        │
_______________________________________________________________________________
                            TASK 2 - DISJCNT
‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
    Pentru acest task, am considerat graful ca fiind orientat (orientarea mu-
chiilor fiind aleasă arbitrar) și am aplicat algoritmul lui Tarjan.
    În mod normal, acest algoritm se folosește pentru grafuri orientate, dar
în cazul unui graf neorientat, acest algoritm îmi dă grupări de noduri care fac
parte dintr-un ciclu (dacă, în graful orientat, există un drum atât de la u la
v, cât și de la v la u, înseamnă că în graful orientat dacă luăm fiecare muchie
într-o anumită direcție - nu în ambele simultan - vor exista două drumuri dis-
tincte între u și v, adică exact cerința problemei). Așadar, pe măsură ce par-
curg graful, când aleg direcția unei muchii, șterg muchia inversă.
    Nu am mai folosit structura de graf utilizată la task-urile 1 și 4, ci am
folosit pur și simplu o matrice de adiacență.

    Complexitatea programului (worst-case) este după cum urmează:

→ Citire și salvare muchii: O(M)                    │
→ Algoritm Tarjan cu eliminare muchii: O(M * M + N) │ => Total: O(M ^ 2)
→ Scriere date: O(1)                                │
_______________________________________________________________________________
                              TASK 3 - RTD
‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
    Pentru acest task, am aplicat o parcurgere BFS recursivă (similară cu Dijk-
stra) pe o matrice de booleans care reprezintă grid-ul, unde dacă un element
este false, înseamnă că acea căsuță este blocată. La fiecare pas din parcurgere,
adaug la costul anterior (memorat printr-un argument) costul corespunzător miș-
cării zarului în direcția respectivă și îl compar cu costul deja calculat pen-
tru căsuța pe care am ajuns. Dacă noul cost este mai mic, continui deplasarea
în toate direcțiile posibile, altfel opresc deplasarea în această direcție. O-
presc deplasarea și dacă costul obținut este mai mare decât costul deja calcu-
lat într-un pas anterior pentru căsuța grid[Fx][Fy], sau dacă am ajuns deja la
căsuța finală.

    Complexitatea programului (worst-case) este după cum urmează:

→ Citire și salvare date: O(K)                     │
→ Parcurgere BFS/Dijkstra pe matrice: O(N ^ 2 + M) │ => Total: O(N ^ 2)
→ Scriere date: O(1)                               │
_______________________________________________________________________________
                            TASK 4 - REVEDGES
‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
    Pentru acest task, am adăugat în graf muchiile inverse ca având costul 1
(muchiile de bază având cost 0) și am implementat algoritmul Floyd-Warshall,
pentru a avea un worst-case complexity bun pentru o rulare cu multe query-uri.

    Complexitatea programului (worst-case) este după cum urmează:

→ Citire și inserare muchii: O(M * log(M))  │
→ Algoritm Floyd_Warshall: O(N ^ 3)         │=> Total: O(N ^ 3)
→ Scriere date: O(1)                        │

=========================== ALEXANDRU Ioana | 324CB ===========================