Untitled

#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <utility>
using namespace std;

struct DSU
{
    int cnt, max_sz;
    vector<int> parent, sz;

    DSU(int n)
    {
        parent.resize(n + 1), sz.resize(n + 1);
        for (int i = 1; i <= n; i++)
            parent[i] = i, sz[i] = 1;
        cnt = 0;
        max_sz = 0;
    }

    int find_root(int x);
    void unite(int x, int y);
};


int DSU::find_root(int u)
{
    return (u == parent[u] ? u : parent[u] = find_root(parent[u]));
}

void DSU::unite(int x, int y)
{
    int rx = find_root(x), ry = find_root(y);
    if (rx == ry)
        return;
    cnt--;
    if (sz[rx] < sz[ry])
        swap(rx, ry);
    parent[ry] = rx;
    sz[rx] += sz[ry];
    max_sz = max(max_sz, sz[rx]);
    return;
}

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n, m, k;
    int u, v;
    cin >> n >> m >> k;
    vector<vector<int>> arr(n + 2, vector<int>(m + 2, 0));
    stack<pair<int, int>> op;
    stack<pair<int, int>> ans;

    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= m; ++j)
        {
            cout << m * (i - 1) + j << endl;
            cin >> arr[i][j];
        }
    }

    for (int i = 0; i < k; i++)
    {
        cin >> u >> v;
        arr[u][v] = 0;
        op.push(make_pair(u, v));
    }

    DSU dsu( n * m );

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (arr[i][j])
            {
                dsu.cnt++;

                if (arr[i - 1][j] == 0 && arr[i][j - 1] == 0)
                {
                    dsu.max_sz = 1;
                }
                else if (arr[i][j - 1] == 1 && arr[i - 1][j] == 0)
                {
                    dsu.unite(m * (i - 1) + j - 1, m * (i - 1) + j);
                }
                else if (arr[i - 1][j] == 1 && arr[i][j - 1] == 0)
                {
                    dsu.unite(m * (i - 2) + j, m * (i - 1) + j);
                }
                else if (arr[i - 1][j] == 1 && arr[i][j - 1] == 1)
                {
                    dsu.unite(m * (i - 2) + j, m * (i - 1) + j);
                    dsu.unite(m * (i - 1) + j - 1, m * (i - 1) + j);
                }
            }
        }
    }

    ans.push(make_pair(dsu.max_sz, dsu.cnt));

    for (int i = 0; i < k; i++)
    {
        int u = op.top().first, v = op.top().second;
        op.pop();
        arr[u][v] = 1;
        dsu.cnt++;
        if (dsu.max_sz < 1)
        {
            /* code */
            dsu.max_sz = 1;
        }

        if (arr[u][v - 1])
        {
            dsu.unite(m * (u - 1) + v - 1, m * (u - 1) + v);
        }
        if (arr[u][v + 1])
        {
            dsu.unite(m * (u - 1) + v + 1, m * (u - 1) + v);
        }
        if (arr[u - 1][v])
        {
            dsu.unite(m * (u - 2) + v, m * (u - 1) + v);
        }
        if (arr[u + 1][v])
        {
            dsu.unite(m * u + v, m * (u - 1) + v);
        }
        ans.push(make_pair(dsu.max_sz, dsu.cnt));
    }

    for (int i = 0; i < k + 1; i++)
    {
        cout << ans.top().first << " " << ans.top().second << "\n";
        ans.pop();
    }
    return 0;
}