List implementation

CMakeLists.txt

@@ -14,6 +14,12 @@ include(cmake/function.cmake)         # подхватываем функции,
 								      # и для создания исполняемого проекта в отдельные функции
 
 add_subdirectory(lib_easy_example)    # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
+add_subdirectory(lib_DSU)
+add_subdirectory(lib_stack) 
+add_subdirectory(lib_list)
+add_subdirectory(lib_stackL)
+add_subdirectory(lib_queueL)
+add_subdirectory(lib_alg)
 
 add_subdirectory(main)                # подключаем дополнительный CMakeLists.txt из подкаталога с именем main
 

lib_DSU/CMakeLists.txt

@@ -0,0 +1 @@
+create_project_lib(DSU)

lib_DSU/DSU.cpp

@@ -0,0 +1 @@
+#include "DSU.h"

lib_DSU/DSU.h

@@ -0,0 +1,119 @@
+#pragma once
+#include <stdexcept>
+
+class DSU {
+private:
+    int* _parent;
+    int* _rank;
+    int _size;
+
+public:
+    explicit DSU(int n);
+    ~DSU();
+
+    DSU(const DSU&) = delete;
+    DSU& operator=(const DSU&) = delete;
+
+
+    DSU(DSU&& other) noexcept;
+    DSU& operator=(DSU&& other) noexcept;
+
+    int find(int x);
+    void unite(int x, int y);
+    bool same(int x, int y);
+    int size() const;
+    int sets_count() const;
+};
+
+inline DSU::DSU(int n) : _size(n) {
+    if (n <= 0) {
+        throw std::invalid_argument("DSU size must be positive");
+    }
+
+    _parent = new int[n];
+    _rank = new int[n];
+
+    for (int i = 0; i < n; ++i) {
+        _parent[i] = i;
+        _rank[i] = 0;
+    }
+}
+
+inline DSU::~DSU() {
+    delete[] _parent;
+    delete[] _rank;
+}
+
+inline DSU::DSU(DSU&& other) noexcept
+    : _parent(other._parent), _rank(other._rank), _size(other._size) {
+    other._parent = nullptr;
+    other._rank = nullptr;
+    other._size = 0;
+}
+
+inline DSU& DSU::operator=(DSU&& other) noexcept {
+    if (this != &other) {
+        delete[] _parent;
+        delete[] _rank;
+
+        _parent = other._parent;
+        _rank = other._rank;
+        _size = other._size;
+
+        other._parent = nullptr;
+        other._rank = nullptr;
+        other._size = 0;
+    }
+    return *this;
+}
+
+inline int DSU::find(int x) {
+    if (x < 0 || x >= _size) {
+        throw std::out_of_range("DSU index out of range in find");
+    }
+
+    if (_parent[x] != x) {
+        _parent[x] = find(_parent[x]); 
+    }
+    return _parent[x];
+}
+
+inline void DSU::unite(int x, int y) {
+    int rootX = find(x);
+    int rootY = find(y);
+
+    if (rootX == rootY) return; 
+
+
+    if (_rank[rootX] < _rank[rootY]) {
+        _parent[rootX] = rootY;
+    }
+    else if (_rank[rootX] > _rank[rootY]) {
+        _parent[rootY] = rootX;
+    }
+    else {
+        _parent[rootY] = rootX;
+        _rank[rootX]++;
+    }
+}
+
+
+inline bool DSU::same(int x, int y) {
+    return find(x) == find(y);
+}
+
+
+inline int DSU::size() const {
+    return _size;
+}
+
+
+inline int DSU::sets_count() const {
+    int count = 0;
+    for (int i = 0; i < _size; ++i) {
+        if (_parent[i] == i) {
+            count++;
+        }
+    }
+    return count;
+}

lib_alg/CMakeLists.txt

@@ -0,0 +1,3 @@
+create_project_lib(Alg)
+add_depend(Alg DSU ..\\lib_DSU)
+add_depend(Alg Stack ..\\lib_stack)

lib_alg/alg.cpp

@@ -0,0 +1,71 @@
+#include "alg.h"
+
+int countIslands(int** grid, int N) {
+    if (N <= 0) return 0;
+
+    DSU dsu(N * N);
+
+    for (int i = 0; i < N; ++i) {
+        for (int j = 0; j < N; ++j) {
+            if (grid[i][j] == 0) continue;
+
+            int currentIndex = i * N + j;
+
+            if (j + 1 < N && grid[i][j + 1] == 1) {
+                dsu.unite(currentIndex, i * N + (j + 1));
+            }
+
+            if (i + 1 < N && grid[i + 1][j] == 1) {
+                dsu.unite(currentIndex, (i + 1) * N + j);
+            }
+        }
+    }
+
+
+    std::vector<bool> isIslandRoot(N * N, false);
+    int islandCount = 0;
+
+    for (int i = 0; i < N; ++i) {
+        for (int j = 0; j < N; ++j) {
+            if (grid[i][j] == 1) {
+                int root = dsu.find(i * N + j);
+                if (!isIslandRoot[root]) {
+                    isIslandRoot[root] = true;
+                    islandCount++;
+                }
+            }
+        }
+    }
+
+    return islandCount;
+}
+
+bool check_brackets(const std::string& str) {
+    Stack<char> brackets;
+
+    for (char c : str) {
+        if (c == '(' || c == '[' || c == '{') {
+            brackets.push(c);
+        }
+        else if (c == ')') {
+            if (brackets.is_empty() || brackets.top() != '(') {
+                return false;
+            }
+            brackets.pop();
+        }
+        else if (c == ']') {
+            if (brackets.is_empty() || brackets.top() != '[') {
+                return false;
+            }
+            brackets.pop();
+        }
+        else if (c == '}') {
+            if (brackets.is_empty() || brackets.top() != '{') {
+                return false;
+            }
+            brackets.pop();
+        }
+    }
+
+    return brackets.is_empty();
+}

lib_alg/alg.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <functional>
+
+#include "stack.h"
+#include "dsu.h"
+
+int countIslands(int** grid, int N);
+bool check_brackets(const std::string& str);
+
+//int countIslands(int** grid, int N) {
+//    if (N <= 0) return 0;
+//
+//    int** dynamicGrid = new int* [N];
+//    for (int i = 0; i < N; ++i) {
+//        dynamicGrid[i] = new int[N];
+//        for (int j = 0; j < N; ++j) {
+//            dynamicGrid[i][j] = grid[i][j];
+//        }
+//    }
+//
+//    int result = countIslands(dynamicGrid, N);
+//
+//
+//    for (int i = 0; i < N; ++i) {
+//        delete[] dynamicGrid[i];
+//    }
+//    delete[] dynamicGrid;
+//
+//    return result;
+//}
+
+
+//inline int** createGrid(int N, ) {
+//    int** grid = new int* [N];
+//    for (int i = 0; i < N; ++i) {
+//        grid[i] = new int[N];
+//        for (int j = 0; j < N; ++j) {
+//            grid[i][j] = initFunc(i, j);
+//        }
+//    }
+//    return grid;
+//}
+//
+//inline void deleteGrid(int** grid, int N) {
+//    for (int i = 0; i < N; ++i) {
+//        delete[] grid[i];
+//    }
+//    delete[] grid;
+//}
+

lib_list/CMakeLists.txt

@@ -0,0 +1 @@
+create_project_lib(List)

lib_list/list.cpp

@@ -0,0 +1 @@
+#include "list.h"