Skip to content

Backtracking - 3 - Completed #1061

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
PrasiddhShah wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Backtracking - 3 - Completed #1061

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
87 changes: 87 additions & 0 deletions problem1.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,87 @@
// Time Complexity :O(n!)
// Space Complexity :O(1)
// Did this code successfully run on Leetcode :yes

/*
* Approach
*
* There are 3 main components to solve this problem
*
* if is to check if the placed queen on each row is safe of not
* we do that by check 3 component, left diagonal, right diagonal, and the straight column
*
* if the check fails continue of the for loop else mark that portion in the board
* increase the row+1 and do the recursive call on that row
*
* when r == board.length
* we create new list and store the board value using a stringbuilder to make true as Q and false as .
*
*/

class Solution {
public List<List<String>> solveNQueens(int n) {
List<List<String>> result = new ArrayList<>();
boolean[][] board = new boolean[n][n];
backtrack(board, 0, result);
return result;
}

private void backtrack(boolean[][] board, int r, List<List<String>> result) {
if (r == board.length) {
List<String> li = new ArrayList<>();
// convert the board into stirg
for (int i = 0; i < board.length; i++) {
StringBuilder sb = new StringBuilder();
for (int j = 0; j < board.length; j++) {
if (board[i][j] == true) {
sb.append('Q');
} else {
sb.append('.');
}
}
li.add(sb.toString());
}
result.add(li);
}
//
for (int c = 0; c < board.length; c++) {
if (isSafe(board, r, c)) {
board[r][c] = true;

backtrack(board, r + 1, result);

board[r][c] = false;
}
}
}

private boolean isSafe(boolean[][] board, int r, int c) {
// same col check
for (int i = r - 1; i >= 0; i--) {
if (board[i][c] == true) {
return false;
}
}
// left diagolan
int i = r;
int j = c;
while (i >= 0 && j >= 0) {
if (board[i][j] == true) {
return false;
}
i--;
j--;
}
// right diagolan
i = r;
j = c;
while (i >= 0 && j < board.length) {
if (board[i][j] == true) {
return false;
}
i--;
j++;
}
return true;
}
}
64 changes: 64 additions & 0 deletions problem2.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,64 @@
// Time Complexity :O(mn3^L)
// Space Complexity :O(1)
// Did this code successfully run on Leetcode :yes

/*
* Approach
* here are are using DFS and backtracking to solve the problem
*
* we will first find the starting letter in of the word on the board
* after the word is found we start the dfs
*
* where will will use the dirs array to find the next char of the word
* if not found then return false,come back one step and change the board to its previous state
* if found, make that node visited and start the search for there again
*
*
*/

class Solution {
int[][] dirs;

public boolean exist(char[][] board, String word) {
int m = board.length;
int n = board[0].length;
this.dirs = new int[][] { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] == word.charAt(0)) {
if (backtrack(board, word, i, j, 0))
return true;
}
}
}
return false;
}

private boolean backtrack(char[][] board, String word, int r, int c, int idx) {
// base
if (idx == word.length()) {
return true;
}
if (r < 0 || c < 0 || r == board.length || c == board[0].length || board[r][c] == '#') {
return false;
}

// logic
if (board[r][c] == word.charAt(idx)) {
// action
board[r][c] = '#';

// recurse
for (int[] dir : dirs) {
int nr = r + dir[0];
int nc = c + dir[1];
if (backtrack(board, word, nr, nc, idx + 1)) {
return true;
}
}
// backtrack
board[r][c] = word.charAt(idx);
}
return false;
}
}