rearanjat, și împărțit pe limbaje, redenumit

cpp/coadaBirint/labirint3.cpp

@@ -0,0 +1,177 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+
+struct nodInCoada {
+    int x, y;
+};
+
+struct coadaCirculara {
+    nodInCoada* coada;
+    int fata;
+    int spate;
+    int marime;
+    
+    coadaCirculara(int m) {
+        marime = m;
+        coada = new nodInCoada[marime];
+        fata = -1;
+        spate = -1;
+    }
+    
+    void adauga(int x, int y) {
+        if (fata == -1) {
+            fata = 0;
+        }
+        spate = (spate + 1) % marime;
+        coada[spate].x = x;
+        coada[spate].y = y;
+    }
+    
+    nodInCoada scoate() {
+        nodInCoada value = coada[fata];
+        if (fata == spate) {
+            fata = -1;
+            spate = -1;
+        } else {
+            fata = (fata + 1) % marime;
+        }
+        return value;
+    }
+    
+    bool eGol() {
+        return fata == -1;
+    }
+};
+
+void citesteLabirint(std::string numeLabirint,
+                            int**& labirint, int& n, int& m) {
+    std::ifstream fisier(numeLabirint);
+    fisier >> n >> m;
+    labirint = new int*[n];
+    for (int i = 0; i < n; i++) {
+        labirint[i] = new int[m];
+    }
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            fisier >> labirint[i][j];
+        }
+    }
+}
+
+bool** creazaIstoric(int n, int m) {
+    bool** aFost = new bool*[n];
+    for (int i = 0; i < n; i++) {
+        aFost[i] = new bool[m];
+        for (int j = 0; j < m; j++) {
+            aFost[i][j] = false;
+        }
+    }
+    return aFost;
+}
+//scrie o matrice cu FALSE pentru a tine minte unde
+//a mai fost soarecele
+
+void stergeIstoric(bool** istoric, int n) {
+    for (int i = 0; i < n; i++) {
+        delete[] istoric[i];
+    }
+    delete[] istoric;
+}
+//dealoca memorie matrice bool
+
+void stergeMatriceInt(int** matrice, int n) {
+    for (int i = 0; i < n; i++) {
+        delete[] matrice[i];
+    }
+    delete[] matrice;
+}
+//dealoca memorie matrice int
+
+void laBFSirint(int** labirint, int xPlecare, int yPlecare, 
+                                int xBranza, int yBranza,
+                                int n, int m) {
+    coadaCirculara q(n * m);
+    bool** trecut = creazaIstoric(n, m);
+    
+    int** xAnterior = new int*[n];
+    int** yAnterior = new int*[n];
+    for (int i = 0; i < n; i++) {
+        xAnterior[i] = new int[m];
+        yAnterior[i] = new int[m];
+        for (int j = 0; j < m; j++) {
+            xAnterior[i][j] = -1;
+            yAnterior[i][j] = -1;
+        }
+    }
+
+    int dx[] = {-1, 1, 0, 0};
+    int dy[] = {0, 0, -1, 1};
+    //direcții de mișcare sus, jos, stânga, dreapta în 2 vectori.
+
+    //Algoritm de cautare in latime.
+    q.adauga(xPlecare, yPlecare);
+    trecut[xPlecare][yPlecare] = true;
+
+    while (!q.eGol()) {
+        nodInCoada curent = q.scoate();
+        int x = curent.x;
+        int y = curent.y;
+
+        if (x == xBranza && y == yBranza) {
+            std::cout << "Soarecu a pus gheara pe branza!\n";
+            std::cout << "Inainte sa ajunga la branza el a fost prin: ";
+            int xCurent = xBranza, yCurent = yBranza;
+            while (xCurent != -1 && yCurent != -1) {
+                std::cout << "(" << xCurent << "," << yCurent << ") ";
+                int xParinte = xAnterior[xCurent][yCurent];
+                int yParinte = yAnterior[xCurent][yCurent];
+                xCurent = xParinte;
+                yCurent = yParinte;
+            }
+            std::cout << "\n";
+            return;
+        } //Soarecu se opreste cand da de branza
+
+        //Daca nu a gasit branza cauta in pozitiile vecine
+        for (int i = 0; i < 4; i++) {
+            int xVecin = x + dx[i];
+            int yVecin = y + dy[i];
+            
+            if (xVecin >= 0 && xVecin < n && yVecin >= 0 && yVecin < m &&
+                !trecut[xVecin][yVecin] && labirint[xVecin][yVecin] != -1) {
+                
+                q.adauga(xVecin, yVecin);
+                trecut[xVecin][yVecin] = true;
+                xAnterior[xVecin][yVecin] = x;
+                yAnterior[xVecin][yVecin] = y;
+            }
+        }
+    }
+    
+    std::cout << "Branza este o minciuna! Soarecele este inchis :( \n";
+
+    //Goleste memorie!
+    stergeIstoric(trecut, n);
+    for (int i = 0; i < n; i++) {
+        delete[] xAnterior[i];
+        delete[] yAnterior[i];
+    }
+    delete[] xAnterior;
+    delete[] yAnterior;
+    delete[] q.coada;
+}
+
+int main() {
+    int** labirint;
+    int n, m;
+    std::string harta;
+    std::cout << "Selectați labirintul (scrie numele fisierului): ";
+    getline(std::cin, harta);
+    citesteLabirint(harta, labirint, n, m);
+    laBFSirint(labirint, 0, 0, n-1, m-1, n, m);
+    //am ales conltul diametral opus punctului de plecare,
+    //dar ambele pot fi arbitrare
+    stergeMatriceInt(labirint, n);
+    return 0;
+}