<p>You are given an <code>n x n</code> binary grid <code>board</code>. In each move, you can swap any two rows with each other, or any two columns with each other.</p>

<p>Return <em>the minimum number of moves to transform the board into a <strong>chessboard board</strong></em>. If the task is impossible, return <code>-1</code>.</p>

<p>A <strong>chessboard board</strong> is a board where no <code>0</code>&#39;s and no <code>1</code>&#39;s are 4-directionally adjacent.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/29/chessboard1-grid.jpg" style="width: 500px; height: 145px;" />
<pre>
<strong>Input:</strong> board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]
<strong>Output:</strong> 2
<strong>Explanation:</strong> One potential sequence of moves is shown.
The first move swaps the first and second column.
The second move swaps the second and third row.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/29/chessboard2-grid.jpg" style="width: 164px; height: 165px;" />
<pre>
<strong>Input:</strong> board = [[0,1],[1,0]]
<strong>Output:</strong> 0
<strong>Explanation:</strong> Also note that the board with 0 in the top left corner, is also a valid chessboard.
</pre>

<p><strong class="example">Example 3:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/29/chessboard3-grid.jpg" style="width: 164px; height: 165px;" />
<pre>
<strong>Input:</strong> board = [[1,0],[1,0]]
<strong>Output:</strong> -1
<strong>Explanation:</strong> No matter what sequence of moves you make, you cannot end with a valid chessboard.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == board.length</code></li>
	<li><code>n == board[i].length</code></li>
	<li><code>2 &lt;= n &lt;= 30</code></li>
	<li><code>board[i][j]</code> is either&nbsp;<code>0</code> or <code>1</code>.</li>
</ul>

class Solution {
public:
         int movesToChessboard(vector<vector<int>>& board) {
        int n = board.size();
        int row_counter = 0, col_counter = 0;
        for(int r = 0; r < n; r++){
            row_counter += board[r][0] ? 1 : -1;
            for(int c = 0; c < n; c++){
                if(r == 0) col_counter += board[r][c] ? 1 : -1;
                if((board[r][0] ^ board[0][0]) ^ (board[r][c] ^ board[0][c])) return -1; 
            }
        }
        if(abs(row_counter) > 1 || abs(col_counter) > 1) return -1;
        int row_swap_count = 0, col_swap_count = 0, row_0_count = 0, col_0_count = 0;
        for(int i = 0; i < n; i++){
            if(i & 1){
                row_swap_count += board[i][0];
                col_swap_count += board[0][i];
            }
            row_0_count += board[i][0] == 0, col_0_count += board[0][i] == 0;            
        }
        int odd_position_count = n/2; 
        if(n & 1){ 
            row_swap_count = row_0_count == odd_position_count ? row_swap_count : (odd_position_count - row_swap_count);
            col_swap_count = col_0_count == odd_position_count ? col_swap_count : (odd_position_count - col_swap_count);
        }
        else{
            row_swap_count = min(row_swap_count, odd_position_count - row_swap_count);
            col_swap_count = min(col_swap_count, odd_position_count - col_swap_count);            
        }
        return row_swap_count + col_swap_count;
    } 
};
12800