โปรแกรม C++ เพื่อค้นหาค่าใช้จ่ายทั้งหมดที่จำเป็นสำหรับหุ่นยนต์ในการเดินทางในตาราง

สมมติว่าเราได้รับตารางขนาด h x w แต่ละเซลล์ในตารางมีเลขจำนวนเต็มบวกจำนวนหนึ่ง ขณะนี้มีหุ่นยนต์ค้นหาเส้นทางวางอยู่บนเซลล์ใดเซลล์หนึ่ง (p, q) (โดยที่ p คือหมายเลขแถวและ q คือหมายเลขคอลัมน์ของเซลล์) และสามารถย้ายไปยังเซลล์ได้ (i, j) การดำเนินการย้ายมีค่าใช้จ่ายเฉพาะ ซึ่งเท่ากับ |p - i| + |q - j|. ขณะนี้มีจำนวนทริป q ซึ่งมีคุณสมบัติดังต่อไปนี้

• การเดินทางแต่ละครั้งมีค่าสองค่า (x, y) และมีค่าทั่วไป d.

• หุ่นยนต์ถูกวางบนเซลล์ที่มีค่า x จากนั้นย้ายไปยังเซลล์อื่นที่มีค่า x + d

• จากนั้นจะย้ายไปยังเซลล์อื่นที่มีค่า x + d + d กระบวนการนี้จะดำเนินต่อไปจนกว่าหุ่นยนต์จะไปถึงเซลล์ที่มีค่ามากกว่าหรือเท่ากับ y

• y - x คือผลคูณของ d.

จากการเดินทาง เราต้องหาค่าใช้จ่ายทั้งหมดของแต่ละทริป หากหุ่นยนต์เคลื่อนที่ไม่ได้ ค่าใช้จ่ายในการเดินทางคือ 0

ดังนั้น หากอินพุตเป็น h =3, w =3, d =3, q ​​=1, grid ={{2, 6, 8}, {7, 3, 4}, {5, 1, 9}} , trips ={{3, 9}} แล้วผลลัพธ์จะเป็น 4

3 อยู่ในเซลล์ (2, 2)

6 อยู่ในเซลล์ (1, 2)

9 อยู่ในเซลล์ (3, 3)

ค่าใช้จ่ายทั้งหมด =|(1 - 2) + (2 - 2)| + |(3 - 1) + (3 - 2)| =4.

เพื่อแก้ปัญหานี้ เราจะทำตามขั้นตอนเหล่านี้ -

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)

ให้เราดูการใช้งานต่อไปนี้เพื่อความเข้าใจที่ดีขึ้น -

ตัวอย่าง

#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;
}

อินพุต

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

ผลลัพธ์

4