Problem:
Score : 1100 points

Problem Statement

We have a grid with N rows and M columns of squares.
Each integer from 1 to NM is written in this grid once.
The number written in the square at the i-th row from the top and the j-th column from the left is A_{ij}.

You need to rearrange these numbers as follows:

First, for each of the N rows, rearrange the numbers written in it as you like.

Second, for each of the M columns, rearrange the numbers written in it as you like.

Finally, for each of the N rows, rearrange the numbers written in it as you like.

After rearranging the numbers, you want the number written in the square at the i-th row from the top and the j-th column from the left to be M\times (i-1)+j.
Construct one such way to rearrange the numbers. The constraints guarantee that it is always possible to achieve the objective.

Constraints

1 \leq N,M \leq 100

1 \leq A_{ij} \leq NM

A_{ij} are distinct.

Input

Input is given from Standard Input in the following format:

N M
A_{11} A_{12} ... A_{1M}
:
A_{N1} A_{N2} ... A_{NM}

Output

Print one way to rearrange the numbers in the following format:

B_{11} B_{12} ... B_{1M}
:
B_{N1} B_{N2} ... B_{NM}
C_{11} C_{12} ... C_{1M}
:
C_{N1} C_{N2} ... C_{NM}

Here B_{ij} is the number written in the square at the i-th row from the top and the j-th column from the left after Step 1, and C_{ij} is the number written in that square after Step 2.

Sample Input 1

3 2
2 6
4 3
1 5

Sample Output 1

2 6
4 3
5 1
2 1
4 3
5 6

Sample Input 2

3 4
1 4 7 10
2 5 8 11
3 6 9 12

Sample Output 2

1 4 7 10
5 8 11 2
9 12 3 6
1 4 3 2
5 8 7 6
9 12 11 10

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>

using namespace std;

struct mf {
	struct edge {
		int to, flow, back;

		edge(int a, int b, int c) : to(a), flow(b), back(c) {}
	};

	int n, s, t, ans, now;
	vector<vector<edge>> v;
	vector<int> at, ver, dis;
	queue<int> q;

	void init(int a, int b, int c) {
		n = a;
		v = vector<vector<edge>>(n, vector<edge>());
		at = ver = dis = vector<int>(n);
		s = b;
		t = c;
		ans = 0;
		q = queue<int>();
	}

	void bd(int a, int b, int c) {
		// printf("bd %d %d %d\n", a, b, c);
		v[a].emplace_back(b, c, v[b].size());
		v[b].emplace_back(a, 0, v[a].size() - 1);
	}

	void bd(int a, int b) {
		bd(a, b, 1);
	}
	
	int dfs(int a, int b) {
		if (a == t)
			return b;
		for (int &i = at[a]; i < v[a].size(); i++)
			if (ver[v[a][i].to] == now && v[a][i].flow && dis[v[a][i].to] == dis[a] + 1) {
				int re = dfs(v[a][i].to, min(v[a][i].flow, b));
				if (re) {
					b -= re;
					v[a][i].flow -= re;
					v[v[a][i].to][v[a][i].back].flow += re;
					return re;
				}
			}
		return 0;
	}
	
	void bfs() {
		for (now = 1; ; now++) {
			q.push(s);
			ver[s] = now;
			at[s] = 0;
			dis[s] = 0;
			while (!q.empty()) {
				int tmp = q.front();
				q.pop();
				for (int j = 0; j < v[tmp].size(); j++)
					if (v[tmp][j].flow) {
						int to = v[tmp][j].to;
						if (ver[to] != now) {
							ver[to] = now;
							at[to] = 0;
							dis[to] = dis[tmp] + 1;
							q.push(to);
						}
					}
			}
			if (ver[t] != now)
				return;
			while (1) {
				int tmp = dfs(s, INT_MAX);
				if (tmp)
					ans += tmp;
				else
					break;
			}
		}
	}
} mf;

int n, m, x[105][105], y[105];
vector<int> v[105][105];
bool z[105][105];

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++) {
			scanf("%d", x[i] + j);
			v[i][(x[i][j] - 1) / m].push_back(x[i][j]);
		}
	for (int i = 0; i < n; i++) {
		mf.init(n + m + 2, n + m, n + m + 1);
		for (int j = 0; j < n; j++)
			if (!v[i][j].empty()) {
				mf.bd(mf.s, j, v[i][j].size());
				for (int k = 0; k < m; k++)
					if (!z[k][j])
						mf.bd(j, n + k); 
			}
		for (int j = 0; j < m; j++)
			mf.bd(n + j, mf.t);
		mf.bfs();
		// for (int j = 0; j < m; j++) x[i][j] = -1;
		for (int j = 0; j < n; j++)
			if (!v[i][j].empty()) {
				for (int k = 1; k < mf.v[j].size(); k++)
					if (mf.v[j][k].flow == 0) {
						x[i][mf.v[j][k].to - n] = v[i][j].back();
						v[i][j].pop_back();
						z[mf.v[j][k].to - n][j] = 1;
					}
			}
	}
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			printf("%d%c", x[i][j], " \n"[j == m - 1]);
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++)
			y[j] = x[j][i];
		sort(y, y + n);
		for (int j = 0; j < n; j++)
			x[j][i] = y[j];
	}
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			printf("%d%c", x[i][j], " \n"[j == m - 1]);
}