solved leetcode sudoko problem using Hashmap

`

1. class Solution {
   1. public void solveSudoku(char[][] board) {
   2. HashMap> rows = new HashMap<>();
   3. HashMap> cols = new HashMap<>();
   4. HashMap> boxes = new HashMap<>();

Here three hashmap used that is row,cols,and boxes Now
it will efficiently keep track of which numbers are already used in each row, column, and 3x3 sub-box of the Sudoku board.

Each entry in these hashmaps is a HashSet to store characters representing numbers.

2. // Initialize hashmaps
3. for (int i = 0; i < 9; i++) {
4. rows.put(i, new HashSet<>());
5. cols.put(i, new HashSet<>());
6. boxes.put(i, new HashSet<>());
7. }
9. // Fill the hashmaps with the existing numbers on the board
10. for (int r = 0; r < 9; r++) {
11. for (int c = 0; c < 9; c++) {
12. char num = board[r][c];
13. if (num != '.') {
14. rows.get(r).add(num);
15. cols.get(c).add(num);
16. int boxIndex = (r / 3) * 3 + c / 3;
17. boxes.get(boxIndex).add(num);
18. }
19. }
20. }
22. // Start solving the puzzle using backtracking
23. solve(board, rows, cols, boxes, 0, 0);
24. }
26. private boolean solve(char[][] board, HashMap> rows, HashMap> cols, HashMap> boxes, int r, int c) {
27. if (r == 9) return true; // Puzzle solved
28. if (c == 9) return solve(board, rows, cols, boxes, r + 1, 0);
29. if (board[r][c] != '.') return solve(board, rows, cols, boxes, r, c + 1);
31. int boxIndex = (r / 3) * 3 + c / 3;
33. // Try placing numbers from 1 to 9
34. for (char num = '1'; num <= '9'; num++) {
35. if (!rows.get(r).contains(num) && !cols.get(c).contains(num) && !boxes.get(boxIndex).contains(num)) {
36. // Place the number
37. board[r][c] = num;
38. rows.get(r).add(num);
39. cols.get(c).add(num);
40. boxes.get(boxIndex).add(num);
42. // Continue solving with the next empty cell
43. if (solve(board, rows, cols, boxes, r, c + 1)) return true;
45. // Backtrack
46. board[r][c] = '.';
47. rows.get(r).remove(num);
48. cols.get(c).remove(num);
49. boxes.get(boxIndex).remove(num);
50. }
51. }
53. return false; // No valid solution found, backtrack
54. }
56. } When backtracking, removing a number from the hashmaps is straightforward and ensures that all constraints are maintained.