Find cells in Matrix that are not visited by Robot for given movements

// Java implementation to find the
// unvisited cells of the matrix
import java.util.*;
import java.awt.Point;

class pair{  
 int x;
 String y;
} 

public class Main
{
    // Dimension
    // of the board
    static int n;
  
    // Current location
    // of the robot
    static int curr_i = 0, curr_j = 0;
    static int duration;
      
    // nXn matrix to store the
    // visited state of positions
    static Vector<Vector<Boolean>> visited = new Vector<Vector<Boolean>>();
  
    // Function to move the robot
    static void moveRobot(int n, int i, int j, int dx, int dy)
    {
  
        // if the robot tends to move
        // out of the board
        // or tends to visit an
        // already visited position
        // or the wind direction is changed
        if (i < 0 || i >= n || j < 0 || j >= n
            || visited.get(i).get(j) == true
            || duration == 0) {
  
            // the robot can't move further
            // under the influence of
            // current wind direction
            return;
        }
  
        // Change the current location
        // and mark the current
        // position as visited
        curr_i = i;
        curr_j = j;
        visited.get(i).set(j, true);
  
        // One second passed
        // visiting this position
        duration--;
  
        moveRobot(n, i + dx, j + dy, dx, dy);
    }
  
    // Function to find the unvisited
    // cells of the matrix after movement
    static void findUnvisited(int p, Vector<pair> periods)
    {
        // map to store the wind directions
        int[] array = new int[]{-1, 0};
        Vector<Integer> l = new Vector<Integer>();
        l.add(-1);
        l.add(0);
        HashMap<String, Vector<Integer>> mp = new HashMap<String, Vector<Integer>>();
        mp.put("N", l);
        l.clear();
        l.add(1);
        l.add(0);
        mp.put("S", l);
        l.clear();
        l.add(0);
        l.add(1);
        mp.put("E", l);
        l.clear();
        l.add(0);
        l.add(-1);
        mp.put("W", l);
        l.clear();
        l.add(-1);
        l.add(1);
        mp.put("NE", l);
        l.clear();
        l.add(-1);
        l.add(-1);
        mp.put("NW", l);
        l.clear();
        l.add(1);
        l.add(1);
        mp.put("SE", l);
        l.clear();
        l.add(1);
        l.add(-1);
        mp.put("SW", l);
  
        // Initially all of the
        // positions are unvisited
        for (int i = 0; i < n; i++) {
            visited.add(new Vector<Boolean>());
            for (int j = 0; j < n; j++) {
                visited.get(i).add(false);
            }
        }
  
        for (int i = 0; i < p; i++) {
            String dir = periods.get(i).y;
            int dx = mp.get(dir).get(0);
            int dy = mp.get(dir).get(1);
  
            // duration for the which the
            // current direction of wind exists
            int duration;
  
            if (i < p - 1) 
            {
              
                // difference of the start time
                // of current wind direction
                // and start time of the
                // upcoming wind direction
                duration
                    = periods.get(i + 1).x
                      - periods.get(i).x;
            }
            else {
                // the maximum time for which
                // a robot can move is
                // equal to the diagonal
                // length of the square board
                duration = (int)Math.sqrt(2) * n;
            }
  
            // If its possible to move
            // the robot once in the
            // direction of wind, then
            // move it once and call the
            // recursive function for
            // further movements
            int next_i = curr_i + dx;
            int next_j = curr_j + dy;
  
            if (next_i >= 0
                && next_i < n
                && next_j >= 0
                && next_j < n
                && visited.get(next_i).get(next_j) == false
                && duration > 0) {
                moveRobot(n, next_i, next_j, dx, dy);
            }
        }
  
        // Variable to store the
        // number of unvisited positions
        int not_visited = 0;
  
        // traverse over the matrix and
        // keep counting the unvisited positions
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (visited.get(i).get(j) == false) {
                    not_visited++;
                }
            }
        }
  
        System.out.print(not_visited/2+1);
    }
    
    public static void main(String[] args) {
        // Dimension of the board
        n = 5;
      
        // number of periods
        int p = 6;
      
        // vector of pairs
        Vector<pair> periods = new Vector<pair>();
        pair p1 = new pair();
        p1.x = 0;
        p1.y = "SE";
        periods.add(p1);
        p1 = new pair();
        p1.x = 1;
        p1.y = "NE";
        periods.add(p1);
        p1 = new pair();
        p1.x = 2;
        p1.y = "E";
        periods.add(p1);
        p1 = new pair();
        p1.x = 6;
        p1.y = "SW";
        periods.add(p1);
        p1 = new pair();
        p1.x = 15;
        p1.y = "N";
        periods.add(p1);
        p1 = new pair();
        p1.x = 1;
        p1.y = "NE";
        periods.add(p1);
        p1 = new pair();
        p1.x = 20;
        p1.y = "W";
        periods.add(p1);
      
        // Function Call
        findUnvisited(p, periods);
    }
}

// This code is contributed by rameshtravel07.