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();
 const int N = ;

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

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

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

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

     flag=;

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

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

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