impl Solution {
    pub fn min_operations(grid: Vec<Vec<i32>>, x: i32) -> i32 {
        let total_cells = grid.len() * grid[0].len();

        // Get frequency counters for scaled values
        let mut counters_grid = match Self::get_counters_grid(grid, x) {
            Some(counters) => counters,
            None => return -1, // Impossible to make all values equal
        };

        // Compute initial sum of differences
        let mut sum_balance = counters_grid.iter()
            .enumerate()
            .map(|(value, &count)| value * count)
            .sum::<usize>();

        let mut cells_balance = total_cells;
        let mut min_ops = sum_balance;

        // Iterate over the frequency counter and adjust balances
        counters_grid.into_iter()
            .enumerate()
            .map(|(value, count)| {
                sum_balance -= 2 * value * count;
                cells_balance -= 2 * count;
                sum_balance - cells_balance * value
            })
            .min()
            .unwrap() as _
    }

    // Converts a 2D grid into a frequency counter for scaled values.
    // The transformation is impossible when at least two values in the grid have different remainders when divided by x.
    // Returns None if transformation is impossible.
    fn get_counters_grid(grid: Vec<Vec<i32>>, x: i32) -> Option<Vec<usize>> {
        const MAX_INDEX: usize = 10_000; // Upper bound for value indices
        let mut counters_grid = vec![0; MAX_INDEX + 1];

        let mod_base = grid[0][0] % x;
        let (mut min_index, mut max_index) = (MAX_INDEX, 0);

        for row in grid {
            for val in row {
                if val % x != mod_base {
                    return None; // Impossible transformation
                }
                let index = (val / x) as usize;
                max_index = max_index.max(index + 1);
                min_index = min_index.min(index);
                counters_grid[index] += 1;
            }
        }

        // Trim the counters grid to the relevant range
        Some(counters_grid[min_index..max_index].to_vec())
    }
}