Number of cells a queen can move with obstacles on the chessboard

14 Jun, 2022
Consider a N X N chessboard with a Queen and K obstacles. The Queen cannot pass through obstacles. Given the position (x, y) of Queen, the task is to find the number of cells the queen can move.
Examples: 
Input : N = 8, x = 4, y = 4, 
        K = 0
Output : 27
Input : N = 8, x = 4, y = 4, 
        K = 1, kx1 = 3, ky1 = 5
Output : 24
Method 1: The idea is to iterate over the cells the queen can attack and stop until there is an obstacle or end of the board. To do that, we need to iterate horizontally, vertically and diagonally. The moves from position (x, y) can be: (x+1, y): one step horizontal move to the right. (x-1, y): one step horizontal move to the left. (x+1, y+1): one step diagonal move up-right. (x-1, y-1): one step diagonal move down-left. (x-1, y+1): one step diagonal move left-up. (x+1, y-1): one step diagonal move right-down. (x, y+1): one step downward. (x, y-1): one step upward.
Below is C++ implementation of this approach:  
C++
Java
Python3
C#
Javascript
// C++ program to find number of cells a queen can move// with obstacles on the chessboard#include<bits/stdc++.h>using namespace std; // Return if position is valid on chessboardint range(int n, int x, int y){  return (x <= n && x > 0 && y <= n && y > 0);} // Return the number of moves with a given directionint check(int n, int x, int y, int xx, int yy,                  map <pair<int, int>, int> mp){  int ans = 0;     // Checking valid move of Queen in a direction.  while (range(n, x, y) && ! mp[{x, y}])  {    x += xx;    y += yy;    ans++;  }     return ans;} // Return the number of position a Queen can move.int numberofPosition(int n, int k, int x, int y,                  int obstPosx[], int obstPosy[]){  int x1, y1, ans = 0;  map <pair<int, int>, int> mp;     // Mapping each obstacle's position  while(k--)  {    x1 = obstPosx[k];    y1 = obstPosy[k];         mp[{x1, y1}] = 1;  }     // Fetching number of position a queen can  // move in each direction.  ans += check(n, x + 1, y, 1, 0, mp);  ans += check(n, x-1, y, -1, 0, mp);  ans += check(n, x, y + 1, 0, 1, mp);  ans += check(n, x, y-1, 0, -1, mp);  ans += check(n, x + 1, y + 1, 1, 1, mp);  ans += check(n, x + 1, y-1, 1, -1, mp);  ans += check(n, x-1, y + 1, -1, 1, mp);  ans += check(n, x-1, y-1, -1, -1, mp);     return ans;} // Driven Programint main(){  int n = 8;  // Chessboard size  int k = 1;  // Number of obstacles  int Qposx = 4; // Queen x position  int Qposy = 4; // Queen y position  int obstPosx[] = { 3 };  // x position of obstacles  int obstPosy[] = { 5 };  // y position of obstacles     cout << numberofPosition(n, k, Qposx, Qposy,                   obstPosx, obstPosy) << endl;  return 0;}
// Java program to find number of cells a queen can move// with obstacles on the chessboard import java.util.*; class GFG{  static class pair  {    int first, second;    public pair(int first, int second)     {      this.first = first;      this.second = second;    }     }  // Return if position is valid on chessboard  static boolean range(int n, int x, int y)  {    return (x <= n && x > 0 && y <= n && y > 0);  }   // Return the number of moves with a given direction  static int check(int n, int x, int y, int xx, int yy,                   HashMap <pair, Integer> mp)  {    int ans = 0;     // Checking valid move of Queen in a direction.    while (range(n, x, y) && ! mp.containsKey(new pair(x, y)))    {      x += xx;      y += yy;      ans++;    }     return ans;  }   // Return the number of position a Queen can move.  static int numberofPosition(int n, int k, int x, int y,                              int obstPosx[], int obstPosy[])  {    int x1, y1, ans = 0;    HashMap <pair, Integer> mp = new HashMap<>();     // Mapping each obstacle's position    while(k>0)    {      k--;      x1 = obstPosx[k];      y1 = obstPosy[k];       mp.put(new pair(x1, y1), 1);    }     // Fetching number of position a queen can    // move in each direction.    ans += check(n, x + 1, y, 1, 0, mp);    ans += check(n, x-1, y, -1, 0, mp);    ans += check(n, x, y + 1, 0, 1, mp);    ans += check(n, x, y-1, 0, -1, mp);    ans += check(n, x + 1, y + 1, 1, 1, mp);    ans += check(n, x + 1, y-1, 1, -1, mp);    ans += check(n, x-1, y + 1, -1, 1, mp);     return ans;  }   // Driven Program  public static void main(String[] args)  {    int n = 8;  // Chessboard size    int k = 1;  // Number of obstacles    int Qposx = 4; // Queen x position    int Qposy = 4; // Queen y position    int obstPosx[] = { 3 };  // x position of obstacles    int obstPosy[] = { 5 };  // y position of obstacles     System.out.print(numberofPosition(n, k, Qposx, Qposy,                                      obstPosx, obstPosy) +"\n");  }} // This code contributed by Rajput-Ji
# Python program to find number of cells a queen can move# with obstacles on the chessboardclass pair :             def __init__(self, first, second):        self.first = first        self.second = second # Return if position is valid on chessboarddef range(n , x , y):    return (x <= n and x > 0 and y <= n and y > 0) # Return the number of moves with a given directiondef check(n , x , y , xx , yy, mp):    ans = 0     # Checking valid move of Queen in a direction.    while range(n, x, y) and pair(x, y) not in mp :        x += xx        y += yy        ans = ans+1     return ans # Return the number of position a Queen can move.def numberofPosition(n , k , x , y , obstPosx , obstPosy):    ans = 0    mp = {}     # Mapping each obstacle's position    while (k > 0):        k -= 1        x1 = obstPosx[k]        y1 = obstPosy[k]         mp[pair(x1, y1)] = 1         # Fetching number of position a queen can        # move in each direction.        ans += check(n, x + 1, y, 1, 0, mp)        ans += check(n, x - 1, y, -1, 0, mp)        ans += check(n, x, y + 1, 0, 1, mp)        ans += check(n, x, y - 1, 0, -1, mp)        ans += check(n, x + 1, y + 1, 1, 1, mp)        ans += check(n, x + 1, y - 1, 1, -1, mp)        ans += check(n, x - 1, y + 1, -1, 1, mp)     return ans # Driven Program n = 8 # Chessboard sizek = 1 # Number of obstaclesQposx = 4 # Queen x positionQposy = 4 # Queen y positionobstPosx = [ 3 ] # x position of obstaclesobstPosy = [ 5 ] # y position of obstacles print(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy)) # This code is contributed by shinjanpatra
// C# program to find number of cells a queen can move// with obstacles on the chessboardusing System;using System.Collections.Generic; public class GFG{ public  class pair  {   public  int first, second;    public pair(int first, int second)     {      this.first = first;      this.second = second;    }     }     // Return if position is valid on chessboard  static bool range(int n, int x, int y)  {    return (x <= n && x > 0 && y <= n && y > 0);  }   // Return the number of moves with a given direction  static int check(int n, int x, int y, int xx, int yy,                   Dictionary <pair, int> mp)  {    int ans = 0;     // Checking valid move of Queen in a direction.    while (range(n, x, y) && ! mp.ContainsKey(new pair(x, y)))    {      x += xx;      y += yy;      ans++;    }     return ans;  }   // Return the number of position a Queen can move.  static int numberofPosition(int n, int k, int x, int y,                              int []obstPosx, int []obstPosy)  {    int x1, y1, ans = 0;    Dictionary <pair, int> mp = new Dictionary<pair, int>();     // Mapping each obstacle's position    while(k>0)    {      k--;      x1 = obstPosx[k];      y1 = obstPosy[k];       mp.Add(new pair(x1, y1), 1);    }     // Fetching number of position a queen can    // move in each direction.    ans += check(n, x + 1, y, 1, 0, mp);    ans += check(n, x-1, y, -1, 0, mp);    ans += check(n, x, y + 1, 0, 1, mp);    ans += check(n, x, y-1, 0, -1, mp);    ans += check(n, x + 1, y + 1, 1, 1, mp);    ans += check(n, x + 1, y-1, 1, -1, mp);    ans += check(n, x-1, y + 1, -1, 1, mp);     return ans;  }   // Driven Program  public static void Main(String[] args)  {    int n = 8;  // Chessboard size    int k = 1;  // Number of obstacles    int Qposx = 4; // Queen x position    int Qposy = 4; // Queen y position    int []obstPosx = { 3 };  // x position of obstacles    int []obstPosy = { 5 };  // y position of obstacles     Console.Write(numberofPosition(n, k, Qposx, Qposy,                                      obstPosx, obstPosy) +"\n");  }} // This code is contributed by Rajput-Ji
<script>// javascript program to find number of cells a queen can move// with obstacles on the chessboard      class pair {                  constructor(first , second) {            this.first = first;            this.second = second;        }    }     // Return if position is valid on chessboard    function range(n , x , y) {        return (x <= n && x > 0 && y <= n && y > 0);    }     // Return the number of moves with a given direction    function check(n , x , y , xx , yy, mp) {        var ans = 0;         // Checking valid move of Queen in a direction.        while (range(n, x, y) && !mp.has(new pair(x, y))) {            x += xx;            y += yy;            ans++;        }         return ans;    }     // Return the number of position a Queen can move.    function numberofPosition(n , k , x , y , obstPosx , obstPosy) {        var x1, y1, ans = 0;        var mp = new Map();         // Mapping each obstacle's position        while (k > 0) {            k--;            x1 = obstPosx[k];            y1 = obstPosy[k];             mp.set(new pair(x1, y1), 1);        }         // Fetching number of position a queen can        // move in each direction.        ans += check(n, x + 1, y, 1, 0, mp);        ans += check(n, x - 1, y, -1, 0, mp);        ans += check(n, x, y + 1, 0, 1, mp);        ans += check(n, x, y - 1, 0, -1, mp);        ans += check(n, x + 1, y + 1, 1, 1, mp);        ans += check(n, x + 1, y - 1, 1, -1, mp);        ans += check(n, x - 1, y + 1, -1, 1, mp);         return ans;    }     // Driven Program             var n = 8; // Chessboard size        var k = 1; // Number of obstacles        var Qposx = 4; // Queen x position        var Qposy = 4; // Queen y position        var obstPosx = [ 3 ]; // x position of obstacles        var obstPosy = [ 5 ]; // y position of obstacles         document.write(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy) + "\n"); // This code is contributed by Rajput-Ji</script>
Output: 
24
Time Complexity: O(n2)Auxiliary Space: O(n)
 Method 2: The idea is to iterate over the obstacles and for those who are in the queen’s path, we calculate the free cells upto that obstacle. If there is no obstacle in the path we have to calculate the number of free cells upto end of board in that direction. 
For any (x1, y1) and (x2, y2): 
If they are horizontally at same level: abs(x1 – x2 – 1)
If they are vertically at same level: abs(y1 – y2 – 1) is the number of free cells between.
If they are diagonal: both abs(x1 – x2 – 1) or abs(y1 – y2 – 1) is the number of free cells between.
Below is the implementation of this approach:  
C++
Java
Python3
C#
Javascript
// C++ program to find number of cells a queen can move// with obstacles on the chessboard#include<bits/stdc++.h>using namespace std; // Return if position is valid on chessboardint range(int n, int x, int y){  return (x <= n && x > 0 && y <= n && y > 0);} // Return the number of moves with a given directionint check(int n, int x, int y, int xx, int yy,                  map <pair<int, int>, int> mp){  int ans = 0;     // Checking valid move of Queen in a direction.  while (range(n, x, y) && ! mp[{x, y}])  {    x += xx;    y += yy;    ans++;  }     return ans;} // Return the number of position a Queen can move.int numberofPosition(int n, int k, int x, int y,                  int obstPosx[], int obstPosy[]){  int x1, y1, ans = 0;  map <pair<int, int>, int> mp;     // Mapping each obstacle's position  while(k--)  {    x1 = obstPosx[k];    y1 = obstPosy[k];         mp[{x1, y1}] = 1;  }     // Fetching number of position a queen can  // move in each direction.  ans += check(n, x + 1, y, 1, 0, mp);  ans += check(n, x-1, y, -1, 0, mp);  ans += check(n, x, y + 1, 0, 1, mp);  ans += check(n, x, y-1, 0, -1, mp);  ans += check(n, x + 1, y + 1, 1, 1, mp);  ans += check(n, x + 1, y-1, 1, -1, mp);  ans += check(n, x-1, y + 1, -1, 1, mp);  ans += check(n, x-1, y-1, -1, -1, mp);     return ans;} // Driven Programint main(){  int n = 8;  // Chessboard size  int k = 1;  // Number of obstacles  int Qposx = 4; // Queen x position  int Qposy = 4; // Queen y position  int obstPosx[] = { 3 };  // x position of obstacles  int obstPosy[] = { 5 };  // y position of obstacles     cout << numberofPosition(n, k, Qposx, Qposy,                   obstPosx, obstPosy) << endl;  return 0;}
// Java program to find number of cells a queen can move// with obstacles on the chessboard import java.util.*; class GFG{  static class pair  {    int first, second;    public pair(int first, int second)     {      this.first = first;      this.second = second;    }     }  // Return if position is valid on chessboard  static boolean range(int n, int x, int y)  {    return (x <= n && x > 0 && y <= n && y > 0);  }   // Return the number of moves with a given direction  static int check(int n, int x, int y, int xx, int yy,                   HashMap <pair, Integer> mp)  {    int ans = 0;     // Checking valid move of Queen in a direction.    while (range(n, x, y) && ! mp.containsKey(new pair(x, y)))    {      x += xx;      y += yy;      ans++;    }     return ans;  }   // Return the number of position a Queen can move.  static int numberofPosition(int n, int k, int x, int y,                              int obstPosx[], int obstPosy[])  {    int x1, y1, ans = 0;    HashMap <pair, Integer> mp = new HashMap<>();     // Mapping each obstacle's position    while(k>0)    {      k--;      x1 = obstPosx[k];      y1 = obstPosy[k];       mp.put(new pair(x1, y1), 1);    }     // Fetching number of position a queen can    // move in each direction.    ans += check(n, x + 1, y, 1, 0, mp);    ans += check(n, x-1, y, -1, 0, mp);    ans += check(n, x, y + 1, 0, 1, mp);    ans += check(n, x, y-1, 0, -1, mp);    ans += check(n, x + 1, y + 1, 1, 1, mp);    ans += check(n, x + 1, y-1, 1, -1, mp);    ans += check(n, x-1, y + 1, -1, 1, mp);     return ans;  }   // Driven Program  public static void main(String[] args)  {    int n = 8;  // Chessboard size    int k = 1;  // Number of obstacles    int Qposx = 4; // Queen x position    int Qposy = 4; // Queen y position    int obstPosx[] = { 3 };  // x position of obstacles    int obstPosy[] = { 5 };  // y position of obstacles     System.out.print(numberofPosition(n, k, Qposx, Qposy,                                      obstPosx, obstPosy) +"\n");  }} // This code contributed by Rajput-Ji
# Python program to find number of cells a queen can move# with obstacles on the chessboardclass pair :             def __init__(self, first, second):        self.first = first        self.second = second # Return if position is valid on chessboarddef range(n , x , y):    return (x <= n and x > 0 and y <= n and y > 0) # Return the number of moves with a given directiondef check(n , x , y , xx , yy, mp):    ans = 0     # Checking valid move of Queen in a direction.    while range(n, x, y) and pair(x, y) not in mp :        x += xx        y += yy        ans = ans+1     return ans # Return the number of position a Queen can move.def numberofPosition(n , k , x , y , obstPosx , obstPosy):    ans = 0    mp = {}     # Mapping each obstacle's position    while (k > 0):        k -= 1        x1 = obstPosx[k]        y1 = obstPosy[k]         mp[pair(x1, y1)] = 1         # Fetching number of position a queen can        # move in each direction.        ans += check(n, x + 1, y, 1, 0, mp)        ans += check(n, x - 1, y, -1, 0, mp)        ans += check(n, x, y + 1, 0, 1, mp)        ans += check(n, x, y - 1, 0, -1, mp)        ans += check(n, x + 1, y + 1, 1, 1, mp)        ans += check(n, x + 1, y - 1, 1, -1, mp)        ans += check(n, x - 1, y + 1, -1, 1, mp)     return ans # Driven Program n = 8 # Chessboard sizek = 1 # Number of obstaclesQposx = 4 # Queen x positionQposy = 4 # Queen y positionobstPosx = [ 3 ] # x position of obstaclesobstPosy = [ 5 ] # y position of obstacles print(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy)) # This code is contributed by shinjanpatra
// C# program to find number of cells a queen can move// with obstacles on the chessboardusing System;using System.Collections.Generic; public class GFG{ public  class pair  {   public  int first, second;    public pair(int first, int second)     {      this.first = first;      this.second = second;    }     }     // Return if position is valid on chessboard  static bool range(int n, int x, int y)  {    return (x <= n && x > 0 && y <= n && y > 0);  }   // Return the number of moves with a given direction  static int check(int n, int x, int y, int xx, int yy,                   Dictionary <pair, int> mp)  {    int ans = 0;     // Checking valid move of Queen in a direction.    while (range(n, x, y) && ! mp.ContainsKey(new pair(x, y)))    {      x += xx;      y += yy;      ans++;    }     return ans;  }   // Return the number of position a Queen can move.  static int numberofPosition(int n, int k, int x, int y,                              int []obstPosx, int []obstPosy)  {    int x1, y1, ans = 0;    Dictionary <pair, int> mp = new Dictionary<pair, int>();     // Mapping each obstacle's position    while(k>0)    {      k--;      x1 = obstPosx[k];      y1 = obstPosy[k];       mp.Add(new pair(x1, y1), 1);    }     // Fetching number of position a queen can    // move in each direction.    ans += check(n, x + 1, y, 1, 0, mp);    ans += check(n, x-1, y, -1, 0, mp);    ans += check(n, x, y + 1, 0, 1, mp);    ans += check(n, x, y-1, 0, -1, mp);    ans += check(n, x + 1, y + 1, 1, 1, mp);    ans += check(n, x + 1, y-1, 1, -1, mp);    ans += check(n, x-1, y + 1, -1, 1, mp);     return ans;  }   // Driven Program  public static void Main(String[] args)  {    int n = 8;  // Chessboard size    int k = 1;  // Number of obstacles    int Qposx = 4; // Queen x position    int Qposy = 4; // Queen y position    int []obstPosx = { 3 };  // x position of obstacles    int []obstPosy = { 5 };  // y position of obstacles     Console.Write(numberofPosition(n, k, Qposx, Qposy,                                      obstPosx, obstPosy) +"\n");  }} // This code is contributed by Rajput-Ji
<script>// javascript program to find number of cells a queen can move// with obstacles on the chessboard      class pair {                  constructor(first , second) {            this.first = first;            this.second = second;        }    }     // Return if position is valid on chessboard    function range(n , x , y) {        return (x <= n && x > 0 && y <= n && y > 0);    }     // Return the number of moves with a given direction    function check(n , x , y , xx , yy, mp) {        var ans = 0;         // Checking valid move of Queen in a direction.        while (range(n, x, y) && !mp.has(new pair(x, y))) {            x += xx;            y += yy;            ans++;        }         return ans;    }     // Return the number of position a Queen can move.    function numberofPosition(n , k , x , y , obstPosx , obstPosy) {        var x1, y1, ans = 0;        var mp = new Map();         // Mapping each obstacle's position        while (k > 0) {            k--;            x1 = obstPosx[k];            y1 = obstPosy[k];             mp.set(new pair(x1, y1), 1);        }         // Fetching number of position a queen can        // move in each direction.        ans += check(n, x + 1, y, 1, 0, mp);        ans += check(n, x - 1, y, -1, 0, mp);        ans += check(n, x, y + 1, 0, 1, mp);        ans += check(n, x, y - 1, 0, -1, mp);        ans += check(n, x + 1, y + 1, 1, 1, mp);        ans += check(n, x + 1, y - 1, 1, -1, mp);        ans += check(n, x - 1, y + 1, -1, 1, mp);         return ans;    }     // Driven Program             var n = 8; // Chessboard size        var k = 1; // Number of obstacles        var Qposx = 4; // Queen x position        var Qposy = 4; // Queen y position        var obstPosx = [ 3 ]; // x position of obstacles        var obstPosy = [ 5 ]; // y position of obstacles         document.write(numberofPosition(n, k, Qposx, Qposy, obstPosx, obstPosy) + "\n"); // This code is contributed by Rajput-Ji</script>
Time Complexity: O(n2)Auxiliary Space: O(n)
This article is contributed by Aarti Rathi and Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
vt_m
jit_t
jana_sayantan
johnolwamba
rajeev0719singh
Rajput-Ji
shinjanpatra
as5853535
adi1212
chessboard-problems
Matrix
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Unique paths in a Grid with Obstacles
Maximum size rectangle binary sub-matrix with all 1s
Printing all solutions in N-Queen Problem
Real-time application of Data Structures
Python program to multiply two matrices
Gold Mine Problem
Traverse a given Matrix using Recursion
Program to find transpose of a matrix
Rotate Matrix Elements
Sparse Matrix and its representations | Set 1 (Using Arrays and Linked Lists)