На сколько кусков распадется часть листа, если из него вырезать некоторые клетки? Есть алгоритм.

#include <iostream>
#include <ctime>
#include <vector>
using namespace std;
 
 
 
/*
The function finds random position of cells in the sheet, be aware that k is not a number of cells, but it is a number of tries*/
void  Random(vector<vector<int>>& del,int tries, int m, int n) 
{
    srand(time(NULL));
    for (int i = 0; i < tries; i++)
    {
        del.push_back(vector<int>(2, 0));
        del[i][0] = rand() % m;
        del[i][1] = rand() % n;
    }
}
 
/*
The function deletes cells from sheet . 'del' is array with coordinates of cells that must to be delete
*/
void Delete(vector<vector<int>>& sheet, vector<vector<int>>& del)
{
    for (int i = 0; i < del.size(); i++)
    {
        sheet[del[i][0]][del[i][1]] = -1;
    }
}
 
/*
The function (recursion) paints a cell in sheet[i][j] with colour ,and continues to paint until there is no adjacent cells
*/
void Paint(vector<vector<int>>& sheet,int i,int j, int colour)
{
    sheet[i][j] = colour;
    if ((i - 1) >= 0 && sheet[i-1][j] == 0) Paint(sheet, i - 1, j, colour);
    if ((i + 1)<sheet.size() && sheet[i+1][j] == 0) Paint(sheet, i + 1, j, colour);
    if ((j - 1) >= 0 && sheet[i][j-1] == 0) Paint(sheet, i, j-1, colour);
    if ((j + 1)<sheet[0].size() && sheet[i][j+1] == 0) Paint(sheet, i, j+1, colour);
}
 
/*
Finds a number of shapes
*/
int Find(vector<vector<int>>& sheet)
{
    int colour = 0;
    for (int i = 0; i < sheet.size(); i++)
    {
        for (int j = 0; j < sheet[0].size(); j++)
        {
            if (sheet[i][j] == 0)
            {
                colour++;
                Paint(sheet, i, j, colour);
                
            }
        }
    }
    return colour;
}
void Chess_Table(vector<vector<int>>& sheet)
{
    int f = 0, d = 0;
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            f = i * 8 + j;
            if (f%2 == d) sheet[i][j] = -1;
        }
        d = (d == 0) ? 1 : 0;
    }
}
int main()
{
    
    vector<vector<int>> sheet(8, vector<int>(8, 0));
    //_X_
    //XXX
    //_X_
    vector<vector<int>> sheet1 = { { -1, 0, -1 }, { 0, 0, 0 }, { -1, 0, - 1 } };
    //XXX
    //_X_
    //X_X   
    //XXX                                                                               
    vector<vector<int>> sheet2 = { { 0, 0, 0 }, { -1, 0, -1 }, { 0, -1, 0 }, { 0, 0, 0 } };         
    //X_X_X
    //X_X_X
    //X_X_X
    //X_X_X
    //X_X_X
    vector<vector<int>> sheet3 = { { 0, -1, 0, -1, 0 }, { 0, -1, 0, -1, 0 },
    { 0, -1, 0, -1, 0 }, { 0, -1, 0, -1, 0 }, { 0, -1, 0, -1, 0 } };
    
    Chess_Table(sheet);
    cout << Find(sheet1) << endl << Find(sheet2) << endl << Find(sheet3) << endl << Find(sheet)<<endl;
 
 
    
    
    
    system("pause");
}

#include <iostream> // std::cout and so on.
#include <vector> // for std::vector.
#include <utility> // for std::pair.
 
// 0 - cell enable;
// -1 - cell empty;
// 1.. - number of variant.
 
class Desk
{
public:
    // Init desk.
    Desk(int len, int hei)
        : length(len), height(hei)
    {
        board = new int*[height];
        for (int i = 0; i < height; ++i)
        {
            board[i] = new int[length];
 
            for (int j = 0; j < length; ++j)
            {
                board[i][j] = 0;
            }
        }
    }
 
    // Free resources.
    ~Desk()
    {
        for (int i = 0; i < height; ++i)
        {
            delete board[i];
        }
        delete board;
    }
 
public:
    // Handle desk.
    void handle()
    {
        count = 1;
 
        for (int i = 0; i < height; ++i)
        {
            for (int j = 0; j < length; ++j)
            {
                if (board[i][j] == 0)
                {
                    std::vector<std::pair<int, int> > co;
 
                    check(i,j, co); // write coordinates to storage.
                    confirm(co, count); // save coordinates.
                    ++count;
                }
            }
        }
    }
 
    void showDesk()
    {
        for (int i = 0; i < height; ++i)
        {
            for (int j = 0; j < length; ++j)
            {
                std::cout.width(3);
                std::cout << board[i][j];
            }
            std::cout << "\n";
        }
        std::cout << "\n" << std::endl;
    }
 
    void removeCell(int y, int x)
    {
        board[y][x] = -1;
    }
 
    int countResult() const
    {
        return count;
    }
 
private:
    // Check cell.
    void check(const int y, const int x, std::vector<std::pair<int, int> >& coordinates)
    {
        if (x == length || x == -1 || y == height || y == -1)
        {
            return;
        }
        else if (board[y][x] == -1) // if cell empty..
        {
            return;
        }
 
        // Finding equals coordinates.
        for (size_t i = 0; i < coordinates.size(); ++i)
        {
            if (coordinates[i].first == y && coordinates[i].second == x) // if fined - return.
            {
                return;
            }
        }
 
        std::pair<int, int> p(y, x);
        coordinates.push_back(p); // save current location.
 
        check(y, x+1, coordinates); // move forward.
        check(y, x-1, coordinates); // move backward.
        check(y-1, x, coordinates); // move up.
        check(y+1, x, coordinates); // move down.
    }
 
    void confirm(const std::vector<std::pair<int, int> >& coordinates, int value)
    {
        for (size_t i = 0; i < coordinates.size(); ++i)
        {
            board[coordinates[i].first][coordinates[i].second] = value;
        }
    }
 
private:
    const int length;
    const int height;
    int count;
    int** board;
};
 
int main()
{
    Desk desk(8, 8);
    desk.showDesk();
 
    desk.removeCell(0, 1);
    desk.removeCell(1, 0);
 
    desk.removeCell(0, 6);
    desk.removeCell(1, 7);
 
    desk.removeCell(6, 0);
    desk.removeCell(7, 1);
 
    desk.removeCell(6, 7);
    desk.removeCell(7, 6);
 
    desk.removeCell(4, 3);
    desk.removeCell(3, 2);
    desk.removeCell(2, 3);
    desk.removeCell(2, 4);
    desk.removeCell(3, 5);
    desk.removeCell(4, 4);
 
    desk.handle();
 
    desk.showDesk();
}

sport.cpp
 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <utility>
#include <algorithm>
#include <queue>
#include <vector>
 
 
 
using namespace std;
 
bool arr[101][101];
long long m,n,k,temp_i,temp_j,i,ans=0,j;
queue<pair<long long,long long> > q;
 
void input()
{
    scanf("%I64d%I64d%I64d",&m,&n,&k);
    for(i=0;i<k;++i)
    {
        scanf("%I64d%I64d",&temp_i,&temp_j);
        arr[temp_i][temp_j]=true;
    }
}
 
void process()
{
    do
    {
        long long i1=q.front().first,j1=q.front().second;
        arr[i1][j1]=true;
        if(i1+1<=m && arr[i1+1][j1]==false)
        {
            q.push(make_pair(i1+1,j1));
            arr[i1+1][j1]=true;
        }
        if(i1-1>=1 && arr[i1-1][j1]==false)
        {
            q.push(make_pair(i1-1,j1));
            arr[i1-1][j1]=true;
        }
        if(j1+1<=n && arr[i1][j1+1]==false)
        {
            q.push(make_pair(i1,j1+1));
            arr[i1][j1+1]=true;
        }
        if(j1-1>=1 && arr[i1][j1-1]==false)
        {
            q.push(make_pair(i1,j1-1));
            arr[i1][j1-1]=true;
        }
        q.pop();
    }
    while(!q.empty());
}
 
void answer()
{
    for(i=1;i<=m;++i)
        for(j=1;j<=n;++j)
        {
            if(!arr[i][j])
            {
                q.push(make_pair(i,j));
                process();
                ++ans;
            }
        }
}
 
 
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    input();
    answer();
    printf("%I64d",ans);
}