Islands

app/main.cpp

@@ -1,6 +1,41 @@
-#include "add.h"
+#include "islands.h"
 #include <iostream>
+#include <time.h>
 
 int main() {
-  std::cout << "2 + 2 = " << add(2, 2) << std::endl;
+  srand(time(NULL));
+  std::vector<std::vector<int>> m(8, std::vector<int>(8, 0));
+
+  std::cout << "Map:" << std::endl;
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      if (rand() % 2 == 0) {
+        m[i][j] = 0;
+      } else {
+        m[i][j] = 1;
+      }
+      std::cout << m[i][j] << ' ';
+    }
+    std::cout << std::endl;
+  }
+  std::cout << std::endl;
+
+  std::cout << "Map after DS method:" << std::endl;
+  std::vector<std::vector<int>> res1 = PercolationForDS(m);
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      std::cout << res1[i][j] << ' ';
+    }
+    std::cout << std::endl;
+  }
+  std::cout << std::endl;
+
+  std::cout << "Map after BFS method:" << std::endl;
+  std::vector<std::vector<int>> res2 = PercolationForBFS(m);
+  for (int i = 0; i < 8; i++) {
+    for (int j = 0; j < 8; j++) {
+      std::cout << res2[i][j] << ' ';
+    }
+    std::cout << std::endl;
+  }
 }

include/islands.h

@@ -0,0 +1,18 @@
+#ifndef INCLUDE_ISLANDS_H_
+#define INCLUDE_ISLANDS_H_
+#include <vector>
+
+struct index {
+  int line;
+  int column;
+};
+
+int find_set(std::vector<int> a, int x);
+void union_sets(std::vector<int> *a, std::vector<int> *b, int x, int y);
+void BFS(std::vector<std::vector<int>> matrix,
+  std::vector<std::vector<int>> *field, struct index y);
+
+std::vector<std::vector<int>> PercolationForDS(std::vector<std::vector<int>> m);
+std::vector<std::vector<int>> PercolationForBFS(std::vector<std::vector<int>> m);
+
+#endif  // INCLUDE_ISLANDS_H_

src/islands.cpp

@@ -0,0 +1,173 @@
+#include <stdlib.h>
+#include <vector>
+#include <queue>
+#include "islands.h"
+#include <limits>
+int inf = std::numeric_limits<int>::infinity();
+
+/* ����� ������ ��� ������ ���������� ��������� */
+int find_set(std::vector<int> a, int x) {
+  int tmp = x;
+  while (a[tmp] != tmp)
+    tmp = a[tmp];
+  return tmp;
+}
+
+/* ����� ����������� ��� ������ ����������� ��������� */
+void union_sets(std::vector<int> *a, std::vector<int> *b, int x, int y) {
+  if ((*b)[find_set(*a, x)] > (*b)[find_set(*a, y)]) {
+    (*a)[find_set(*a, y)] = (*a)[find_set(*a, x)];
+    (*b)[find_set(*a, x)]++;
+  } else {
+    (*a)[find_set(*a, x)] = (*a)[find_set(*a, y)];
+    (*b)[find_set(*a, y)]++;
+  }
+}
+
+/* ���������� ��������, ������������� �� ������ ���������� ��������� */
+std::vector<std::vector<int>> PercolationForDS
+  (std::vector<std::vector<int>> matrix) {
+  int matrix_size = matrix.size();
+  int N = matrix_size * matrix_size + 2;
+  std::vector<int> a(N);
+  std::vector<int> b(N, 1);
+
+  for (int i = 0; i < N; ++i)
+    a[i] = i;
+
+  for (int i = 0; i < matrix_size; ++i)
+    if (matrix[0][i]) union_sets(&a, &b, 0, i + 1);
+
+  for (int i = 0; i < matrix_size - 1; ++i) {
+    for (int j = 0; j < matrix_size - 1; ++j) {
+      if (matrix[i][j] && matrix[i][j + 1]) {
+        union_sets(&a, &b, i * matrix_size + j + 1, i * matrix_size + j + 2);
+      }
+      if (matrix[i][j] && matrix[i + 1][j]) {
+        union_sets(&a, &b, i * matrix_size + j + 1, (i + 1) * matrix_size + j + 1);
+      }
+    }
+    if (matrix[i][matrix_size - 1] && matrix[i + 1][matrix_size - 1]) {
+      union_sets(&a, &b, i * matrix_size + matrix_size, (i + 1) * matrix_size + matrix_size);
+    }
+  }
+
+  for (int i = 0; i < matrix_size - 1; ++i)
+    if (matrix[matrix_size - 1][i] && matrix[matrix_size - 1][i + 1]) {
+      union_sets(&a, &b, (matrix_size - 1) * matrix_size + i + 1,
+        (matrix_size - 1) * matrix_size + i + 2);
+    }
+
+  for (int i = 0; i < matrix_size; ++i)
+    if (matrix[matrix_size - 1][i]) {
+      union_sets(&a, &b, N - 1, (matrix_size - 1) * matrix_size + i + 1);
+    }
+
+  a.push_back(N);
+  a.push_back(N + 1);
+  b.push_back(1);
+  b.push_back(1);
+
+  for (int i = 0; i < matrix_size; ++i)
+    if (matrix[i][0]) {
+      union_sets(&a, &b, N, i * matrix_size + 1);
+    }
+  for (int i = 0; i < matrix_size; ++i)
+    if (matrix[i][matrix_size - 1]) {
+      union_sets(&a, &b, N + 1, i * matrix_size + matrix_size);
+    }
+
+  union_sets(&a, &b, 0, N - 1);
+  union_sets(&a, &b, 0, N);
+  union_sets(&a, &b, 0, N + 1);
+
+  for (int i = 0; i < matrix_size - 1; ++i)
+    for (int j = 0; j < matrix_size - 1; ++j)
+      if (find_set(a, i * matrix_size + j + 1) != find_set(a, 0)) {
+        matrix[i][j] = 0;
+      }
+
+  return matrix;
+}
+
+/* ����� � ������ (breadth-first search) */
+void BFS(std::vector<std::vector<int>> matrix,
+  std::vector<std::vector<int>> *field, struct index Y) {
+  int matrix_size = matrix.size();
+  std::queue<index> q;
+  q.push(Y);
+  (*field)[Y.line][Y.column] = 1;
+  while (!q.empty()) {
+    index point = q.front();
+    q.pop();
+    if (point.column > 0) {
+      if ((matrix[point.line][point.column - 1] == 1) &&
+        ((*field)[point.line][point.column - 1] == inf)) {
+        (*field)[point.line][point.column - 1] = 1;
+        index* temp = new index;
+        temp->line = point.line;
+        temp->column = point.column - 1;
+        q.push(*temp);
+      }
+    }
+    if (point.line > 0) {
+      if ((matrix[point.line - 1][point.column] == 1) &&
+        ((*field)[point.line - 1][point.column] == inf)) {
+        (*field)[point.line - 1][point.column] = 1;
+        index* temp = new index;
+        temp->line = point.line - 1;
+        temp->column = point.column;
+        q.push(*temp);
+      }
+    }
+    if (point.column + 1 < matrix_size) {
+      if ((matrix[point.line][point.column + 1] == 1) &&
+        ((*field)[point.line][point.column + 1] == inf)) {
+        (*field)[point.line][point.column + 1] = 1;
+        index* temp = new index;
+        temp->line = point.line;
+        temp->column = point.column + 1;
+        q.push(*temp);
+      }
+    }
+    if (point.line + 1 < matrix_size) {
+      if ((matrix[point.line + 1][point.column] == 1) &&
+        ((*field)[point.line + 1][point.column] == inf)) {
+        (*field)[point.line + 1][point.column] = 1;
+        index* temp = new index;
+        temp->line = point.line + 1;
+        temp->column = point.column;
+        q.push(*temp);
+      }
+    }
+  }
+}
+
+/* ���������� �������� ����� ����� � ������ (breadth-first search) */
+std::vector<std::vector<int>> PercolationForBFS
+  (std::vector<std::vector<int>> matrix) {
+  int matrix_size = matrix.size();
+  std::vector<std::vector<int>> field(matrix_size, std::vector<int>(matrix_size, inf));
+  index Y;
+  Y.line = 0;
+  for (Y.column = 0; Y.column < matrix_size; ++Y.column) {
+    if (matrix[Y.line][Y.column] == 1) BFS(matrix, &field, Y);
+  }
+  Y.line = matrix_size - 1;
+  for (Y.column = 0; Y.column < matrix_size; ++Y.column) {
+    if (matrix[Y.line][Y.column] == 1) BFS(matrix, &field, Y);
+  }
+  Y.column = 0;
+  for (Y.line = 0; Y.line < matrix_size; ++Y.line) {
+    if (matrix[Y.line][Y.column] == 1) BFS(matrix, &field, Y);
+  }
+  Y.column = matrix_size - 1;
+  for (Y.line = 0; Y.line < matrix_size; ++Y.line) {
+    if (matrix[Y.line][Y.column] == 1) BFS(matrix, &field, Y);
+  }
+
+  for (int i = 1; i < matrix_size - 1; ++i)
+    for (int j = 1; j < matrix_size - 1; ++j)
+      if (field[i][j] == inf) matrix[i][j] = 0;
+  return matrix;
+}

test/test_islands.cpp

@@ -0,0 +1,127 @@
+#include <gtest/gtest.h>
+#include "islands.h"
+
+/*
+00011100
+00010100
+00010100
+00000100
+00100100
+01010100
+00000100
+00010100
+*/
+
+TEST(ISLANDS, the_islands_are_drowning_correctly_DS) {
+  std::vector<std::vector<int>> m(8, std::vector<int>(8, 0));
+  m[0][5] = 1;
+  m[1][5] = 1;
+  m[2][5] = 1;
+  m[3][5] = 1;
+  m[4][5] = 1;
+  m[5][5] = 1;
+  m[6][5] = 1;
+  m[7][5] = 1;
+
+  m[0][3] = 1;
+  m[0][4] = 1;
+  m[1][3] = 1;
+  m[2][3] = 1;
+  m[4][2] = 1;
+  m[4][3] = 1;
+  m[5][1] = 1;
+  m[5][3] = 1;
+  m[7][3] = 1;
+
+  std::vector<std::vector<int>> exp = m;
+  exp[4][2] = 0;
+  exp[4][3] = 0;
+  exp[5][1] = 0;
+  exp[5][3] = 0;
+
+  std::vector<std::vector<int>> res;
+  res = PercolationForDS(m);
+  for (int i = 0; i < 8; ++i)
+    for (int j = 0; j < 8; ++j)
+      EXPECT_EQ(exp[i][j], res[i][j]);
+}
+
+TEST(ISLANDS, the_islands_are_drowning_correctly_BFS) {
+  std::vector<std::vector<int>> m(8, std::vector<int>(8, 0));
+  m[0][5] = 1;
+  m[1][5] = 1;
+  m[2][5] = 1;
+  m[3][5] = 1;
+  m[4][5] = 1;
+  m[5][5] = 1;
+  m[6][5] = 1;
+  m[7][5] = 1;
+
+  m[0][3] = 1;
+  m[0][4] = 1;
+  m[1][3] = 1;
+  m[2][3] = 1;
+  m[4][2] = 1;
+  m[4][3] = 1;
+  m[5][1] = 1;
+  m[5][3] = 1;
+  m[7][3] = 1;
+
+  std::vector<std::vector<int>> exp = m;
+  exp[4][2] = 0;
+  exp[4][3] = 0;
+  exp[5][1] = 0;
+  exp[5][3] = 0;
+
+  std::vector<std::vector<int>> res;
+  res = PercolationForBFS(m);
+  for (int i = 0; i < 8; ++i)
+    for (int j = 0; j < 8; ++j)
+      EXPECT_EQ(exp[i][j], res[i][j]);
+}
+
+TEST(ISLANDS, can_work_in_the_absence_of_islands_DS) {
+  std::vector<std::vector<int>> m(8, std::vector<int>(8, 0));
+  m[0][5] = 1;
+  m[1][5] = 1;
+  m[2][5] = 1;
+  m[3][5] = 1;
+  m[4][5] = 1;
+  m[5][5] = 1;
+  m[6][5] = 1;
+  m[7][5] = 1;
+
+  m[0][3] = 1;
+  m[0][4] = 1;
+  m[1][3] = 1;
+  m[2][3] = 1;
+  m[7][3] = 1;
+
+  std::vector<std::vector<int>> res = PercolationForDS(m);
+  for (int i = 0; i < 8; ++i)
+    for (int j = 0; j < 8; ++j)
+      EXPECT_EQ(m[i][j], res[i][j]);
+}
+
+TEST(ISLANDS, can_work_in_the_absence_of_islands_BFS) {
+  std::vector<std::vector<int>> m(8, std::vector<int>(8, 0));
+  m[0][5] = 1;
+  m[1][5] = 1;
+  m[2][5] = 1;
+  m[3][5] = 1;
+  m[4][5] = 1;
+  m[5][5] = 1;
+  m[6][5] = 1;
+  m[7][5] = 1;
+
+  m[0][3] = 1;
+  m[0][4] = 1;
+  m[1][3] = 1;
+  m[2][3] = 1;
+  m[7][3] = 1;
+
+  std::vector<std::vector<int>> res = PercolationForBFS(m);
+  for (int i = 0; i < 8; ++i)
+    for (int j = 0; j < 8; ++j)
+      EXPECT_EQ(m[i][j], res[i][j]);
+}