Skip to content

Backtracking-3 Done #1073

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
ManishaRana1195 wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Backtracking-3 Done #1073

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
99 changes: 99 additions & 0 deletions NQueens.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,99 @@
/*
Time Complexity : O(N!. 3N) where N is the size of the board. 3N for validating the placement at each cell
Space Complexity : O(N) on the recursion stack
Did this code successfully run on Leetcode :
Any problem you faced while coding this :
Approach :

We need to place N queens on the board. Need to check if the placement is valid. If yes, add the placement string to
result list. We can create a NXN boolean board, where true represent a queen is placed and false represents otherwise.
We can place one queen row by row, so for a row, we place the queen from 0 to jth column. Once the queen is placed
successfully, we call the recursion on the next row. Once all rows are done, we need to convert the board into list
of strings and add to result.

Before placing a queen, we check its column, its top right and top left diagonals, if a queen is already placed there,
we return false.

Finally, if all queens are placed correctly, we create a string with Q and . from true and false state of the board.

*/
import java.util.ArrayList;
import java.util.List;

public class NQueens {
public List<List<String>> solveNQueens(int n) {
List<List<String>> result = new ArrayList<>();
// Create board to keep the state
boolean[][] board = new boolean[n][n];
placeQueens(board, 0, result);
return result;
}

private void placeQueens(boolean[][] board,int i, List<List<String>> result) {
int rows = board.length;
// If we reach the row size, we have a valid solution and add it to result
if(i == rows){
List<String> solution = convertBoardToString(board);
result.add(solution);
return;
}

for (int j = 0; j < board[0].length; j++) {
if(isValidPlacement(board, i, j)){
board[i][j] = true;
placeQueens(board, i+1, result);
// backtrack
board[i][j] = false;
}

}

}

boolean isValidPlacement(boolean[][] board, int i, int j){
int tempi = i;
int tempj = j;
// check top left diagonal
while(tempi >= 0 && tempj >= 0){
if(board[tempi][tempj]) return false;
tempi--;
tempj--;
}
tempi = i;
tempj = j;

// check all values in the same column
while(tempi >= 0){
if(board[tempi][tempj]) return false;
tempi--;
}

tempi = i;
tempj = j;
// check for queen in the top right diagonal
while(tempi >= 0 && tempj < board[0].length){
if(board[tempi][tempj]) return false;
tempi--;
tempj++;
}

return true;
}

private List<String> convertBoardToString(boolean[][] board) {
List<String> solution = new ArrayList<>();
for (int i = 0; i < board.length; i++) {
StringBuilder temp = new StringBuilder();
for (int j = 0; j < board[0].length; j++) {
// convert board state to list of strings
if(board[i][j]){
temp.append("Q");
}else {
temp.append(".");
}
}
solution.add(temp.toString());
}
return solution;
}
}
56 changes: 56 additions & 0 deletions WordSearch.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,56 @@
/*
Time Complexity : O(M.N.3^L) where M and N are the rows and cols in the board. At each cell, there are 3 neighbors that need
to be explored.
Space Complexity : O(L) in the recursion stack, the entire length of the word
Did this code successfully run on Leetcode : Yes
Any problem you faced while coding this : No
Approach :

We need to perform dfs on each cell that matches the first char of the word. To mark the cell visited, we can change the char
to "#". Once a path is explored we need to back track as that particular character can appear in the word later, so our path need
to visit the character and then un-visit it. So once all the children are explored for a character in the board, will unmark
by restoring its previous value.

*/
public class WordSearch {
int[][] directions = {{0,1}, {1,0}, {-1,0}, {0,-1}};
public boolean exist(char[][] board, String word) {
int rows = board.length;
int cols = board[0].length;

for(int i = 0; i < rows; i++){
for(int j = 0; j < cols; j++){
if(board[i][j] == word.charAt(0)){
if(wordExist(board, i, j, word, 0)){
return true;
}
}
}
}
return false;
}

public boolean wordExist(char[][] board, int i, int j, String word,int index){
int rows = board.length;
int cols = board[0].length;
// If we reach end of the given word, we return true as all the characters in the word are matched
if(index == word.length()) return true;

// If we reach the board boundaries, we return false. We have explored all cells in the direction.
if(i < 0 || j < 0 || i == rows || j == cols) return false;
if(board[i][j] != word.charAt(index)) return false;

char temp = board[i][j];
board[i][j] = '#';
for(int [] dirs: directions){
int newRow = dirs[0] + i;
int newCol = dirs[1] + j;
if(wordExist(board, newRow, newCol, word, index+1)){
return true;
}
}
// backtrack
board[i][j] = temp;
return false;
}
}