LeetCode 1632. Rank Transform of a Matrix

struct Node
{
	int value;
	int x;
	int y;
	Node() {}
	Node(int x, int y, int value)
	{
		this->x = x;
		this->y = y;
		this->value = value;
	}
}a[250005],b[505];

int compare(Node a, Node b)
{
	return a.value < b.value;
}
class Solution {
public:
    int n, m;
    int rrank[505][505];
    int nrank[505][505];
    int mrank[505][505];
    int f[250005];
    int v[250005];
    int rn[505];
    int rm[505];
    int tag[505][505];

    int find(int x)
    {
        if (f[x] != x)
            f[x] = find(f[x]);
        return f[x];
    }
    void join(int x, int y)
    {
        int fx = find(x);
        int fy = find(y);
        f[fy] = fx;
    }

    vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {
                    n = matrix.size();
        m = matrix[0].size();

        int pos = 0;
        int pos2 = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                a[pos++] = Node(i, j, matrix[i][j]);
            }
        }

        sort(a, a + pos, compare);

        for (int i = 0; i < pos; i++)
        {
            tag[a[i].x][a[i].y] = i;
            f[i] = i;
        }

        for (int i = 0; i < n; i++)
        {
            pos2 = 0;
            for (int j = 0; j < m; j++)
            {
                b[pos2++] = Node(i, j, matrix[i][j]);
            }

            sort(b, b + pos2, compare);

            for (int j = 1; j < pos2; j++)
            {
                if (b[j].value != b[j - 1].value)
                {
                    continue;
                }
                else
                {
                    int fx = find(tag[i][b[j - 1].y]);
                    int fy = find(tag[i][b[j].y]);

                    f[fx] = fy;
                }
            }
        }

        for (int i = 0; i < m; i++)
        {
            pos2 = 0;
            for (int j = 0; j < n; j++)
            {
                b[pos2++] = Node(j, i, matrix[j][i]);
            }

            sort(b, b + pos2, compare);

            for (int j = 1; j < pos2; j++)
            {
                if (b[j].value != b[j - 1].value)
                {
                    continue;
                }
                else
                {
                    int fx = find(tag[b[j-1].x][i]);
                    int fy = find(tag[b[j].x][i]);

                    f[fx] = fy;
                }
            }
        }

        int start = 0;
        for (int i = 0; i < pos; i++)
        {

            int ran = max(rn[a[i].x], rm[a[i].y]) +1;
            int ff = find(i);
            if (v[ff] < ran)
            {
                v[ff] = ran;
            }

            if (i== pos-1 ||a[i + 1].value != a[i].value)
            {
                for (int j = start; j <= i; j++)
                {
                    int xx = v[find(j)];
                    rrank[a[j].x][a[j].y] = xx;
                    rn[a[j].x] = xx;
                    rm[a[j].y] = xx;
                }

                start = i + 1;
            }
        }

        vector<vector<int>> ans;
        for (int i = 0; i < n; i++)
        {
            vector<int> res;
            for (int j = 0; j < m; j++)
            {
                res.push_back(rrank[i][j]);
            }
            ans.push_back(res);
        }

        return ans;

    }
};