Maximize Area of Square Hole in Grid solution and explanation

def dfs_recursive(node, visited=set()):
    if node is None:
        return
    if node not in visited:
        print(node.data)
        visited.add(node)
        for neighbor in node.neighbors:
            dfs_recursive(neighbor, visited)

#include <iostream>
#include <set>
#include <vector>

void dfs_recursive(Node* node, std::set<Node*>& visited) {
    if (!node) return;
    if (visited.find(node) == visited.end()) {
        std::cout << node->data << std::endl;
        visited.insert(node);
        for (Node* neighbor : node->neighbors) {
            dfs_recursive(neighbor, visited);
        }
    }
}

import java.util.*;

void bfs_iterative(Node startNode) {
    Queue<Node> queue = new LinkedList<>();
    Set<Node> visited = new HashSet<>();
    queue.add(startNode);
    visited.add(startNode);

    while (!queue.isEmpty()) {
        Node node = queue.poll();
        System.out.println(node.data);
        for (Node neighbor : node.neighbors) {
            if (!visited.contains(neighbor)) {
                queue.add(neighbor);
                visited.add(neighbor);
            }
        }
    }
}

function bfsIterative(startNode) {
    let queue = [startNode];
    let visited = new Set();
    visited.add(startNode);

    while (queue.length > 0) {
        let node = queue.shift();
        console.log(node.data);
        for (let neighbor of node.neighbors) {
            if (!visited.has(neighbor)) {
                visited.add(neighbor);
                queue.push(neighbor);
            }
        }
    }
}

function maximizeSquareHoleArea(n: number, m: number, hBars: number[], vBars: number[]): number {
    const f = (nums: number[]): number => {
        nums.sort((a, b) => a - b);
        let [ans, cnt] = [1, 1];
        for (let i = 1; i < nums.length; ++i) {
            if (nums[i] === nums[i - 1] + 1) {
                ans = Math.max(ans, ++cnt);
            } else {
                cnt = 1;
            }
        }
        return ans + 1;
    };
    return Math.min(f(hBars), f(vBars)) ** 2;
}

func maximizeSquareHoleArea(n int, m int, hBars []int, vBars []int) int {
	f := func(nums []int) int {
		sort.Ints(nums)
		ans, cnt := 1, 1
		for i, x := range nums[1:] {
			if x == nums[i]+1 {
				cnt++
				ans = max(ans, cnt)
			} else {
				cnt = 1
			}
		}
		return ans + 1
	}
	x := min(f(hBars), f(vBars))
	return x * x
}

impl Solution {
    pub fn maximize_square_hole_area(n: i32, m: i32, h_bars: Vec<i32>, v_bars: Vec<i32>) -> i32 {
        let f = |nums: &mut Vec<i32>| -> i32 {
            let mut ans = 1;
            let mut cnt = 1;
            nums.sort();
            for i in 1..nums.len() {
                if nums[i] == nums[i - 1] + 1 {
                    cnt += 1;
                    ans = ans.max(cnt);
                } else {
                    cnt = 1;
                }
            }
            ans + 1
        };

        let mut h_bars = h_bars;
        let mut v_bars = v_bars;
        let x = f(&mut h_bars).min(f(&mut v_bars));
        x * x
    }
}