CodeForces 816C 思维

On the way to school, Karen became fixated on the puzzle game on her phone!

The game is played as follows. In each level, you have a grid with n rows and m columns. Each cell originally contains the number 0.

One move consists of choosing one row or column, and adding 1 to all of the cells in that row or column.

To win the level, after all the moves, the number in the cell at the i-th row and j-th column should be equal to g_i, j.

Karen is stuck on one level, and wants to know a way to beat this level using the minimum number of moves. Please, help her with this task!

Input

The first line of input contains two integers, n and m (1 ≤ n, m ≤ 100), the number of rows and the number of columns in the grid, respectively.

The next n lines each contain m integers. In particular, the j-th integer in the i-th of these rows contains g_i, j (0 ≤ g_i, j ≤ 500).

Output

If there is an error and it is actually not possible to beat the level, output a single integer -1.

Otherwise, on the first line, output a single integer k, the minimum number of moves necessary to beat the level.

The next k lines should each contain one of the following, describing the moves in the order they must be done:

• rowx, (1 ≤ x ≤ n) describing a move of the form "choose the x-th row".
• colx, (1 ≤ x ≤ m) describing a move of the form "choose the x-th column".

If there are multiple optimal solutions, output any one of them.

Sample Input

Input

3 5
2 2 2 3 2
0 0 0 1 0
1 1 1 2 1

Output

4
row 1
row 1
col 4
row 3

Input

3 3
0 0 0
0 1 0
0 0 0

Output

-1

Input

3 3
1 1 1
1 1 1
1 1 1

Output

3
row 1
row 2
row 3

Hint

In the first test case, Karen has a grid with 3 rows and 5 columns. She can perform the following 4 moves to beat the level:

In the second test case, Karen has a grid with 3 rows and 3 columns. It is clear that it is impossible to beat the level; performing any move will create three 1s on the grid, but it is required to only have one 1 in the center.

In the third test case, Karen has a grid with 3 rows and 3 columns. She can perform the following 3 moves to beat the level:

Note that this is not the only solution; another solution, among others, is col 1, col 2, col 3.

　　分析这种棋盘的特性，要加加一行，要加加一列，且不能减，且棋盘初始都为零。所以如果同一行上出现了不同的数，则数大的一列必然有该列的加，行同理。

所以可以先处理列，把所有列加过的都还原回去，所以只剩下了由个别的行改变所导致的棋盘，再用同样的方法将行还原回去，最后如果棋盘仍然不为零的话，说明所有的行都进行过相同次数的

加（这里要注意！！！如果最后棋盘不为零的话，既有可能是所有的行进行了操作，也有可能是所有的列进行了操作，因为题目让求最少的操作次数，所以应判断行和列谁小操作的谁）。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<map>
#include<iostream>
using namespace std;
typedef long long  LL;
const double pi=acos(-1.0);
const double e=exp(1);
const int N = 100009;

LL con[110][110];
LL check[110][110];
LL col[110],row[110];

int main()
{
    LL i,p,j,m,n;
    LL flag=0;
    scanf("%lld%lld",&m,&n);
    LL head=10000000,tail=10000000,mid;

    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            scanf("%lld",&con[i][j]);
            if(con[1][j]<head)
                head=con[1][j];
            if(con[i][1]<tail)
                tail=con[i][1];
        }
    }

    if(m<=n)
    {
        for(i=1; i<=n; i++)
        {
            if(con[1][i]>head)
                col[i]+=con[1][i]-head;
        }
        mid=tail-col[1];
        for(i=1; i<=m; i++)
        {
            if(con[i][1]>tail)
                row[i]+=con[i][1]-tail;
            row[i]+=mid;
        }
    }
    else
    {
        for(i=1; i<=m; i++)
        {
            if(con[i][1]>tail)
                row[i]+=con[i][1]-tail;
        }
        mid=head-row[1];
        for(i=1; i<=n; i++)
        {
            if(con[1][i]>head)
                col[i]+=con[1][i]-head;
            col[i]+=mid;
        }
    }

    flag=0;

    for(i=1; i<=n; i++)
    {
        if(col[i])
        {
            flag+=col[i];
            for(j=1; j<=m; j++)
                check[j][i]+=col[i];
        }
    }
    for(i=1; i<=m; i++)
    {
        if(row[i])
        {
            flag+=row[i];
            for(j=1; j<=n; j++)
                check[i][j]+=row[i];
        }
    }

    for(i=1; i<=m; i++)
    {
        for(j=1; j<=n; j++)
        {
            if(con[i][j]!=check[i][j])
                break;
        }
        if(j<=n)
        {
            flag=-1;
            break;
        }
    }



    if(flag==-1)
        printf("-1
");
    else
    {
        printf("%lld
",flag);
        for(i=1; i<=n; i++)
        {
            while(col[i])
            {
                col[i]--;
                printf("col %lld
",i);
            }
        }
        for(i=1; i<=m; i++)
        {
            while(row[i])
            {
                row[i]--;
                printf("row %lld
",i);
            }
        }
    }
    return 0;
}