# C++ Program to find out the total cost required for a robot to make a trip in a grid

Suppose, we are given a grid of dimensions h x w. Each cell in the grid contains some positive integer number. Now there is a path-finding robot placed on a particular cell (p, q) (where p is the row number and q is the column number of a cell) and it can be moved to cell (i, j). A move operation has a particular cost, which is equal to |p - i| + |q - j|. Now there are q number of trips, which has the following properties.

• Each trip has two values (x, y) and there is a common value d.

• A robot is placed on a cell having value x, then moves to another cell having value x + d.

• Then it moves to another cell having the value x + d + d. This process will continue until the robot reaches a cell that has a value greater than or equal to y.

• y - x is a multiple of d.

Given the trips, we have to find out the total cost of each trip. If the robot can not move, the trip cost is 0.

So, if the input is like h = 3, w = 3, d = 3, q = 1, grid = {{2, 6, 8}, {7, 3, 4}, {5, 1, 9}}, trips = {{3, 9}}, then the output will be 4.

3 is on cell (2, 2)

6 is on cell (1, 2)

9 is on cell (3, 3)

Total cost = |(1 - 2) + (2 - 2)| + |(3 - 1) + (3 - 2)| = 4.

To solve this, we will follow these steps −

Define one map loc
for initialize i := 0, when i < h, update (increase i by 1), do:
for initialize j := 0, when j < w, update (increase j by 1), do:
loc[grid[i, j]] := new pair(i, j)
Define an array dp[d + 1]
for initialize i := 1, when i <= d, update (increase i by 1), do:
j := i
while j < w * h, do:
n := j + d
if j + d > w * h, then:
Come out from the loop
dx := |first value of loc[n] - first value of loc[j]|
dy := |second value of loc[n] - second value of loc[j]|
j := j + d
insert dx + dy at the end of dp[i]
for initialize j := 1, when j < size of dp[i], update (increase j by 1), do:
dp[i, j] := dp[i, j] + dp[i, j - 1]
for initialize i := 0, when i < q, update (increase i by 1), do:
tot := 0
le := first value of trips[i]
ri := second value of trips[i]
if ri mod d is same as 0, then:
f := d
Otherwise,
f := ri mod d
pxl := (le - f) / d
pxr := (ri - f) / d
if le is same as f, then:
if ri is same as f, then:
tot := 0
Otherwise
tot := tot + (dp[f, pxr - 1] - 0)
Otherwise
if ri is same as f, then:
tot := 0
Otherwise
tot := tot + dp[f, pxr - 1] - dp[f, pxl - 1]
print(tot)

Let us see the following implementation to get better understanding −

## Example

#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
void solve(int h, int w, int d, int q, vector<vector<int>> grid,
vector<pair<int, int>> trips) {
map<int, pair<int, int>> loc;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++)
loc[grid[i][j]] = make_pair(i, j);
}
vector<int> dp[d + 1];
for (int i = 1; i <= d; i++) {
int j = i;
while (j < w * h) {
int n = j + d;
if (j + d > w * h)
break;
int dx = abs(loc[n].first - loc[j].first);
int dy = abs(loc[n].second - loc[j].second);
j += d;
dp[i].push_back(dx + dy);
}
for (j = 1; j < dp[i].size(); j++)
dp[i][j] += dp[i][j - 1];
}
for (int i = 0; i < q; i++) {
int tot = 0;
int le, ri;
le = trips[i].first;
ri = trips[i].second;
int f;
if (ri % d == 0)
f = d;
else
f = ri % d;
int pxl, pxr;
pxl = (le - f) / d;
pxr = (ri - f) / d;
if (le == f){
if (ri == f)
tot = 0;
else
tot += (dp[f][pxr - 1] - 0);
} else {
if (ri == f)
tot = 0;
else
tot += dp[f][pxr - 1] - dp[f][pxl - 1];
}
cout<< tot << endl;
}
}
int main() {
int h = 3, w = 3, d = 3, q = 1;
vector<vector<int>> grid = {{2, 6, 8}, {7, 3, 4}, {5, 1, 9}};
vector<pair<int, int>> trips = {{3, 9}};
solve(h, w, d, q, grid, trips);
return 0;
}

## Input

3, 3, 3, 1, {{2, 6, 8}, {7, 3, 4}, {5, 1, 9}}, {{3, 9}}

## Output

4