int countIslands(int A[][COL], int m, int n)
 {  
     int count = 0; 
     for(int i=0; i<m; i++) 
     {  
          for(int j=0; j<n; j++) 
         {     
             if(A[i][j] == 1) 

0000
0100
0010
0010
0000

0000
0100
0110
0000

0000
0100
0110
0010
0000

#include <stddef.h>
#include <assert.h>
#include <stdbool.h>

int* _map = NULL;
int _width, _height;

int* cell_at(int row, int col);
bool find_one(int* row, int* col);
void zero_cells(int row, int col);

/* меняет содержимое массива */
int count_islands(int map[], int width, int height) {
  int islands_count;
  int row, col;

  /* проверяем входные данные */
  assert(width >= 1);
  assert(height >= 1);

  /* для простоты, сохраняем контекст в глобальные переменные */
  _map = map;
  _width = width;
  _height = height;

  islands_count = 0;
  while (find_one(&row, &col)) {
    islands_count++;
    /* зануляем остров */
    zero_cells(row, col);
  }

  _map = NULL;

  return islands_count;
}

/* индексация двумерного массива */
int* cell_at(int row, int col) {
  assert(_map != NULL);
  assert((0 <= row) && (row < _height));
  assert((0 <= col) && (col < _width));
  /* двумерный массив реализован как одномерный массив длины height * width */
  return &_map[row * _width + col];
}

bool find_one(int* row, int* col) {
  int r, c;

  for (r = 0; r < _height; r++) {
    for (c = 0; c < _width; c++) {
      if (*cell_at(r, c) == 1) {
        *row = r;
        *col = c;
        return true;
      }
    }
  }

  return false;
}

void zero_cells(int row, int col) {
  assert(*cell_at(row, col) == 1);
  *cell_at(row, col) = 0;

  /* зануляем единичных соседей */
  if ((col - 1 >= 0) && (*cell_at(row, col - 1) == 1)) {
    zero_cells(row, col - 1);
  }
  if ((col + 1 < _width) && (*cell_at(row, col + 1) == 1)) {
    zero_cells(row, col + 1);
  }
  if ((row - 1 >= 0) && (*cell_at(row - 1, col) == 1)) {
    zero_cells(row - 1, col);
  }
  if ((row + 1 < _height) && (*cell_at(row + 1, col) == 1)) {
    zero_cells(row + 1, col);
  }
}

int main() {
  int map[] = {
    1,0,0,0,0,0,0,0,0,0,0,
    0,0,0,1,1,1,1,1,0,1,0,
    0,0,1,1,0,0,0,1,0,1,1,
    0,0,1,1,0,1,0,1,1,0,0,
    1,0,0,1,0,0,0,1,1,0,0,
    1,1,0,1,1,1,1,1,1,0,0,
  };
  assert(count_islands(map, /*width:*/11, /*height:*/6) == 5);
  return 0;
}

#define ROWS 10
#define COLS 10

void Check(uint8_t matr[ROWS][COLS],uint32_t row,uint32_t col, uint8_t check[ROWS][COLS])
{
    //check the right side
	if ((col+1) < COLS)
	  if (matr[row][col+1])
		  check[row][col+1] = 1;
	//check the bottom side
	if ((row+1) < ROWS)
		if (matr[row+1][col])
			check[row+1][col] = 1;
}

//typedef struct Point
uint32_t FindIslands(uint8_t matrix[ROWS][COLS], uint32_t rows, uint32_t cols)
{
	uint8_t checked[ROWS][COLS];
	memset(checked, 0, sizeof(checked));

	uint32_t count = 0;
	uint32_t i,j;

	for (i=0; i < ROWS; i++)  
	{
		for (j=0; j < COLS; j++)  
		{
		       //if a cell with value 1 is not visited yet, then new island found
                       if (matrix[i][j] && !checked[i][j])
                      {
        	          //check all cells in this island
        	          Check(matrix, i, j, checked);
        	          ++count;
                      }
		}
	}
	return count;
}