Count possible moves in the given direction in a grid

Given a grid N x M size and initial position (X, Y) and a series of K moves.
Each move contains 2 integers Dx and Dy.
A single move consists of the following operation that can also be performed as many times as possible:

X = X + Dx and Y = Y + Dy.

The task is to count the number of moves performed.
Note that at every point of time, the current position must be inside the grid.

Examples:

Input: N = 4, M = 5, X = 1, Y = 1, k[] = {{1, 1}, {1, 1}, {0, -2}}
Output: 4
The values of (X, Y) are as follows:
Steps in Move 1: (1, 1) -> (2, 2) -> (3, 3) -> (4, 4) i.e. 3 moves
Move 2 is not possible as we cannot move to (5, 5) which is out of the bounds of the grid
Steps in Move 3: (4, 4) -> (4, 2) i.e. a single move and (4, 0) will be out of the bound so no further moves possible.
Total moves = 3 + 1 = 4

Input: N = 10, M = 10, X = 3, Y = 3, k[] = {{1, 1}, {-1, -1}}
Output: 16



Approach: It can be observed that we can handle X and Y independently, and merge them as number of steps in current move= minimum of (number of steps with X, number of steps with Y). To find number of moves with X, we can use the sign of Dx to know which end we are approaching and find the distance to that end, with speed being Dx, we can find out the number of steps it would take.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
#include <bits/stdc++.h>
#define int long long
using namespace std;
  
// Function to return the count of
// possible steps in a single direction
int steps(int cur, int x, int n)
{
  
    // It can cover infinte steps
    if (x == 0)
        return INT_MAX;
  
    // We are approaching towards X = N
    if (x > 0)
        return abs((n - cur) / x);
  
    // We are approaching towards X = 1
    else
        return abs((cur - 1) / x);
}
  
// Function to return the count of steps
int countSteps(int curx, int cury, int n, int m,
               vector<pair<int, int> > moves)
{
    int count = 0;
    int k = moves.size();
    for (int i = 0; i < k; i++) {
        int x = moves[i].first;
        int y = moves[i].second;
  
        // Take the minimum of both moves independently
        int stepct
            = min(steps(curx, x, n), steps(cury, y, m));
  
        // Update count and current positions
        count += stepct;
        curx += stepct * x;
        cury += stepct * y;
    }
    return count;
}
  
// Driver code
main()
{
    int n = 4, m = 5, x = 1, y = 1;
    vector<pair<int, int> > moves = { { 1, 1 },
                                      { 1, 1 },
                                      { 0, -2 } };
    int k = moves.size();
    cout << countSteps(x, y, n, m, moves);
    return 0;
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
  
# Function to return the count of 
# possible steps in a single direction 
def steps(cur, x, n): 
  
    # It can cover infinte steps 
    if x == 0:
        return float('inf'
  
    # We are approaching towards X = N 
    elif x > 0:
        return abs((n - cur) // x) 
  
    # We are approaching towards X = 1 
    else:
        return abs(int((cur - 1) / x)) 
  
# Function to return the count of steps 
def countSteps(curx, cury, n, m, moves): 
  
    count = 0
    k = len(moves) 
    for i in range(0, k): 
        x = moves[i][0
        y = moves[i][1]
  
        # Take the minimum of both moves 
        # independently 
        stepct = min(steps(curx, x, n), 
                     steps(cury, y, m)) 
  
        # Update count and current positions 
        count += stepct 
        curx += stepct *
        cury += stepct * y
      
    return count 
  
# Driver code 
if __name__ == "__main__":
  
    n, m, x, y = 4, 5, 1, 1
    moves = [[1, 1], [1, 1], [0, -2]]
      
    print(countSteps(x, y, n, m, moves))
  
# This code is contributed 
# by Rituraj Jain

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// Php implementation of the above approach 
  
// Function to return the count of 
// possible steps in a single direction 
function steps($cur, $x, $n
  
    // It can cover infinte steps 
    if ($x == 0) 
        return PHP_INT_MAX; 
  
    // We are approaching towards X = N 
    if ($x > 0) 
        return floor(abs(($n - $cur) / $x)); 
  
    // We are approaching towards X = 1 
    else
        return floor(abs(($cur - 1) / $x)); 
  
// Function to return the count of steps 
function countSteps($curx, $cury, $n, $m, $moves
    $count = 0; 
    $k = sizeof($moves); 
    for ($i = 0; $i < $k; $i++) 
    
        $x = $moves[$i][0]; 
        $y = $moves[$i][1]; 
  
        // Take the minimum of both moves independently 
        $stepct = min(steps($curx, $x, $n), steps($cury, $y, $m)); 
  
        // Update count and current positions 
        $count += $stepct
        $curx += $stepct * $x
        $cury += $stepct * $y
    
    return $count
  
    // Driver code 
    $n = 4 ;
    $m = 5 ;
    $x = 1 ;
    $y = 1 ; 
    $moves = array( array( 1, 1 ), 
                        array( 1, 1 ), 
                        array( 0, -2 ) ); 
    $k = sizeof($moves);
      
    echo countSteps($x, $y, $n, $m, $moves); 
      
// This code is contributed by Ryuga
?>

chevron_right


Output:

4

Time Complexity: O(N)



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : rituraj_jain, AnkitRai01