Count possible moves in the given direction in a grid
Last Updated :
22 Jun, 2022
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++
#include <bits/stdc++.h>
#define int long long
using namespace std;
int steps( int cur, int x, int n)
{
if (x == 0)
return INT_MAX;
if (x > 0)
return abs ((n - cur) / x);
else
return abs ((cur - 1) / x);
}
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;
int stepct
= min(steps(curx, x, n), steps(cury, y, m));
count += stepct;
curx += stepct * x;
cury += stepct * y;
}
return count;
}
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;
}
|
Java
class GFG
{
static int steps( int cur, int x, int n)
{
if (x == 0 )
return Integer.MAX_VALUE;
if (x > 0 )
return Math.abs((n - cur) / x);
else
return Math.abs((cur - 1 ) / x);
}
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 ];
int stepct = Math.min(steps(curx, x, n),
steps(cury, y, m));
count += stepct;
curx += stepct * x;
cury += stepct * y;
}
return count;
}
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));
}
}
|
Python3
def steps(cur, x, n):
if x = = 0 :
return float ( 'inf' )
elif x > 0 :
return abs ((n - cur) / / x)
else :
return abs ( int ((cur - 1 ) / x))
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 ]
stepct = min (steps(curx, x, n),
steps(cury, y, m))
count + = stepct
curx + = stepct * x
cury + = stepct * y
return count
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))
|
C#
using System;
class GFG
{
static int steps( int cur, int x, int n)
{
if (x == 0)
return int .MaxValue;
if (x > 0)
return Math.Abs((n - cur) / x);
else
return Math.Abs((cur - 1) / x);
}
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];
int stepct = Math.Min(steps(curx, x, n),
steps(cury, y, m));
count += stepct;
curx += stepct * x;
cury += stepct * y;
}
return count;
}
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));
}
}
|
PHP
<?php
function steps( $cur , $x , $n )
{
if ( $x == 0)
return PHP_INT_MAX;
if ( $x > 0)
return floor ( abs (( $n - $cur ) / $x ));
else
return floor ( abs (( $cur - 1) / $x ));
}
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];
$stepct = min(steps( $curx , $x , $n ), steps( $cury , $y , $m ));
$count += $stepct ;
$curx += $stepct * $x ;
$cury += $stepct * $y ;
}
return $count ;
}
$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 );
?>
|
Javascript
<script>
function steps(cur, x, n)
{
if (x == 0)
return Number.MAX_VALUE;
if (x > 0)
return Math.abs((n - cur) / x);
else
return Math.abs((cur - 1) / x);
}
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];
let stepct = Math.min(steps(curx, x, n),
steps(cury, y, m));
count += stepct;
curx += stepct * x;
cury += stepct * y;
}
return Math.floor(count);
}
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>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...