Codeforces Round #777 C. Madoka and Childish Pranks

C. Madoka and Childish Pranks

time limit per test

1 second

memory limit per test

256 megabytes

Madoka as a child was an extremely capricious girl, and one of her favorite pranks was drawing on her wall. According to Madoka’s memories, the wall was a table of n rows and m columns, consisting only of zeroes and ones. The coordinate of the cell in the$ i-th$ row and the j-th column $(1 \le i \le n, 1 \le j \le m) $is (i, j).

One day she saw a picture “Mahou Shoujo Madoka Magica” and decided to draw it on her wall. Initially, the Madoka’s table is a table of size n \times m filled with zeroes. Then she applies the following operation any number of times:

Madoka selects any rectangular subtable of the table and paints it in a chess coloring (the upper left corner of the subtable always has the color 0). Note that some cells may be colored several times. In this case, the final color of the cell is equal to the color obtained during the last repainting.

White color means 0, black means 1. So, for example, the table in the first picture is painted in a chess coloring, and the others are not.

For better understanding of the statement, we recommend you to read the explanation of the first test.

Help Madoka and find some sequence of no more than $n\cdot m$ operations that allows you to obtain the picture she wants, or determine that this is impossible.

Input

Each test contains multiple test cases. The first line contains a single integer t ($1\le t\le 10$) — the number of test cases. Description of the test cases follows.

The first line of each test case contains two integers n and m $(1\le n,m\le 100)$ — the size of the table. Each of the following n lines contains a string of length m consisting only of 1 and 0 — description of the picture that Madoka wants to obtain.

Output

If it is impossible to obtain the given picture, print -1.

Otherwise, print in the first line a single integer $q$ ($0\le q\le n\cdot m$) — the number of operations you need to obtain the picture. Note that you do not need to minimize the number of operations.

Then for each operation (in the order of execution) print a single line containing four numbers — the coordinates of the upper-left corner and the lower-right corner of the rectangle.

Example

input

Copy

4
4 5
01000
10100
01010
00110
2 3
001
010
3 3
110
101
000
1 1
0

output

Copy

4
1 1 3 3
3 3 4 4
4 3 4 4
4 2 4 3
1
1 2 2 3
-1
0

Note

The description of the first test case is below.

In the third test case, it is impossible to paint the desired picture.

In the fourth test case, the initial table is already the desired picture.

这题的意思有点难懂，大概题意是，原本有$n\ast m$的网格，然后每次操作只能按棋盘图案操作，就是只能画一个类似棋盘的图案，比如样例1，第一步，画了一个$3\ast 3$的正方形，按照棋盘的规则（黑白相间，第一个为白），第二步也是画了个棋盘不过是$2*2的。最后她给出画的样子，要你用这个方法画出来。

分析，分析这个需要从小着手，比如我们涂一个1*2的长方形，那么就只有三种情况:

1.2.3.

显然第三种不能画，第一种可以画，第二种不用动。所以我们看到第一行第一个为黑就可以NO了。而且，很关键的是，他不需要你求最小步数，只要画出来就成功。所以我们试着每次只涂两个，从后面涂到前面，其实发现，只要第一个不是黑色，全部都能涂，只不过是用最多次数来涂，遍历所需数组，遇到1就涂（前一格和这一格（两格）），如果在第一列，就涂这一格和上面一格(第一行第一列除外)。

#include<iostream>
#include<cstring>
#include<vector>
#include<array>
using namespace std;
int a[101][101];
vector<array<int ,4> >ans;//二维答案数组
int main()
{
    int n;
    cin>>n;
    int x,y;
    while(n--){
        cin>>x>>y;
        char c;
        for(int i=1;i<=x;i++){
            for(int j = 1; j<= y; j++){
               cin>>c;
               a[i][j]=c-'0'; 
            }
        }
        ans.clear();
        if(a[1][1]==1){cout<<-1<<endl;
        continue;}
        for(int i=x; i >=1; i--){
            for(int j=y; j>=1 ;j--){
                if(a[i][j]==1){
                    if(j>1){
                        ans.push_back({i,j-1,i,j});
                        //cout<<i<<' '<<j-1<<' '<<i<<' '<<j<<endl;
                    }
                    else {
                        ans.push_back({i-1,j,i,j});
                        //cout<<i-1<<' '<<j<<' '<<i<<' '<<j<<endl;
                    }
                }
            }
        }
        cout<<ans.size()<<endl;//因为要先输入步数才输出坐标，所以要存
        for(auto i: ans){
            cout<< i[0]<<' '<< i[1] << ' '<< i[2]<< ' '<< i[3]<< endl;
        }
    }
}