Count possible moves in the given direction in a grid - GeeksforGeeks

11 Jun, 2021
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 = 4Input: 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++
Java
Python3
C#
PHP
Javascript
// C++ implementation of the above approach#include <bits/stdc++.h>#define int long longusing namespace std; // Function to return the count of// possible steps in a single directionint steps(int cur, int x, int n){     // It can cover infinite 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 stepsint 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 codemain(){    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;}
// Java implementation of the above approachclass GFG{     // Function to return the count of    // possible steps in a single direction    static int steps(int cur, int x, int n)    {         // It can cover infinite steps        if (x == 0)            return Integer.MAX_VALUE;         // We are approaching towards X = N        if (x > 0)            return Math.abs((n - cur) / x);         // We are approaching towards X = 1        else            return Math.abs((cur - 1) / x);    }     // Function to return the count of steps    static int countSteps(int curx, int cury,                             int n, int m,                             int[][] moves)    {        int count = 0;        int k = moves.length;        for (int i = 0; i < k; i++)        {            int x = moves[i][0];            int y = moves[i][1];             // Take the minimum of             // both moves independently            int stepct = Math.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    public static void main(String[] args)    {        int n = 4, m = 5, x = 1, y = 1;        int[][] moves = { { 1, 1 }, { 1, 1 },                          { 0, -2 } };         System.out.print(countSteps(x, y, n, m, moves));    }} // This code is contributed by 29AjayKumar
# Python3 implementation of the approach # Function to return the count of# possible steps in a single directiondef steps(cur, x, n):     # It can cover infinite 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 stepsdef 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 * x        cury += stepct * y         return count # Driver codeif __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
// C# implementation of the above approachusing System; class GFG{     // Function to return the count of    // possible steps in a single direction    static int steps(int cur, int x, int n)    {         // It can cover infinite steps        if (x == 0)            return int.MaxValue;         // We are approaching towards X = N        if (x > 0)            return Math.Abs((n - cur) / x);         // We are approaching towards X = 1        else            return Math.Abs((cur - 1) / x);    }     // Function to return the count of steps    static int countSteps(int curx, int cury,                          int n, int m,                          int[,] moves)    {        int count = 0;        int k = moves.GetLength(0);        for (int i = 0; i < k; i++)        {            int x = moves[i, 0];            int y = moves[i, 1];             // Take the minimum of            // both moves independently            int stepct = Math.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    public static void Main(String[] args)    {        int n = 4, m = 5, x = 1, y = 1;        int[,] moves = { { 1, 1 }, { 1, 1 },                         { 0, -2 } };         Console.Write(countSteps(x, y, n, m, moves));    }} // This code is contributed by Rajput-Ji
<?php// Php implementation of the above approach // Function to return the count of// possible steps in a single directionfunction steps($cur, $x, $n){     // It can cover infinite 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 stepsfunction 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?>
<script> // Javascript 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 infinite steps        if (x == 0)            return Number.MAX_VALUE;         // We are approaching towards X = N        if (x > 0)            return Math.abs((n - cur) / x);         // We are approaching towards X = 1        else            return Math.abs((cur - 1) / x);    }     // Function to return the count of steps    function countSteps(curx, cury, n, m, moves)    {        let count = 0;        let k = moves.length;        for (let i = 0; i < k; i++)        {            let x = moves[i][0];            let y = moves[i][1];             // Take the minimum of             // both moves independently            let stepct = Math.min(steps(curx, x, n),                                  steps(cury, y, m));             // Update count and current positions            count += stepct;            curx += stepct * x;            cury += stepct * y;        }        return Math.floor(count);    } // driver program             let n = 4, m = 5, x = 1, y = 1;        let moves = [[ 1, 1 ], [ 1, 1 ],                          [ 0, -2 ]];         document.write(countSteps(x, y, n, m, moves));   </script>
4
 
Time Complexity: O(N) 
rituraj_jain
ankthon
29AjayKumar
Rajput-Ji
code_hunt
bunnyram19
math
Competitive Programming
Greedy
Mathematical
Matrix
Greedy
Mathematical
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Multistage Graph (Shortest Path)
Breadth First Traversal ( BFS ) on a 2D array
Shortest path in a directed graph by Dijkstra’s algorithm
5 Best Books for Competitive Programming
5 Best Languages for Competitive Programming
Dijkstra's shortest path algorithm | Greedy Algo-7
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Program for array rotation
Write a program to print all permutations of a given string