# Solving Leetcode Interviews in Seconds with AI: Minimum Swaps to Arrange a Binary Grid


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1536" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an n x n binary grid, in one step you can choose two adjacent rows of the grid and swap them. A grid is said to be valid if all the cells above the main diagonal are zeros. Return the minimum number of steps needed to make the grid valid, or -1 if the grid cannot be valid. The main diagonal of a grid is the diagonal that starts at cell (1, 1) and ends at cell (n, n).   Example 1:   Input: grid = [[0,0,1],[1,1,0],[1,0,0]] Output: 3  Example 2:   Input: grid = [[0,1,1,0],[0,1,1,0],[0,1,1,0],[0,1,1,0]] Output: -1 Explanation: All rows are similar, swaps have no effect on the grid.  Example 3:   Input: grid = [[1,0,0],[1,1,0],[1,1,1]] Output: 0    Constraints:  n == grid.length == grid[i].length 1 <= n <= 200 grid[i][j] is either 0 or 1  

	# Explanation
	Here's a breakdown of the approach and the Python code:

*   **Find Trailing Zeros:** For each row, calculate the number of trailing zeros. A row can potentially be moved to row `i` if it has at least `i` trailing zeros.
*   **Greedy Swapping:** Iterate through the rows from top to bottom. For each row `i`, find the first row below it (at or below index `i`) that has at least `i` trailing zeros. If no such row exists, the grid cannot be made valid, so return -1.
*   **Minimize Swaps:** If a suitable row is found, swap it upwards to the `i`-th position, accumulating the number of swaps needed.

*   **Runtime Complexity:** O(n^2). **Storage Complexity:** O(n)

	
	# Code
	```python
	def minSwaps(grid):
    n = len(grid)
    zeros = []
    for row in grid:
        count = 0
        for i in range(n - 1, -1, -1):
            if row[i] == 0:
                count += 1
            else:
                break
        zeros.append(count)

    swaps = 0
    for i in range(n):
        required_zeros = i
        found = False
        for j in range(i, n):
            if zeros[j] >= required_zeros:
                # Move this row to the ith position
                for k in range(j, i, -1):
                    zeros[k], zeros[k - 1] = zeros[k - 1], zeros[k]
                    swaps += 1
                found = True
                break
        if not found:
            return -1

    return swaps
	```