Hypyt

input/code.cpp: In function 'void getNums(std::string, int**, uint)':
input/code.cpp:22:41: warning: comparison of integer expressions of different signedness: 'uint' {aka 'unsigned int'} and 'int' [-Wsign-compare]
   22 |   while (getline(iss, s, ' ') && vcount != ccount) {
      |                                  ~~~~~~~^~~~~~~~~

#include <algorithm>
#include <cstdint>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <sys/types.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#define MONS 65535
#define UNIN 65534
#define uin uint8_t
 
void getNums(const std::string in, int **values, uint vcount) {
  int ccount = 0;
  std::istringstream iss(in);
  std::string s;
  while (getline(iss, s, ' ') && vcount != ccount) {
    *values[ccount] = std::stoi(s);
    ccount++;
  }
}
 
struct ivec2 {
  uin x, y = 0;
  ivec2(int x, int y) : x(x), y(y) {}
  ivec2() {}
  ivec2 operator+(const ivec2 &other) const {
    return ivec2(x + other.x, y + other.y);
  }
  ivec2 operator*(const int &value) const {
    return ivec2(x * value, y * value);
  }
  ivec2 operator/(const int &value) const {
    return ivec2(x / value, y / value);
  }
  friend std::ostream &operator<<(std::ostream &os, const ivec2 &v) {
    return os << "(" << v.x << ", " << v.y << ")";
  }
 
  bool operator<(const ivec2 &other) const {
    return (x < other.x) || (x == other.x && y < other.y);
  }
  bool operator>(const ivec2 &other) const {
    return (x > other.x) || (x == other.x && y > other.y);
  }
  bool operator<=(const ivec2 &other) const {
    return *this < other || *this == other;
  }
  bool operator>=(const ivec2 &other) const {
    return *this > other || *this == other;
  }
  bool operator==(const ivec2 &other) const {
    return (x == other.x && y == other.y) ? true : false;
  }
};
 
struct Grid {
  std::vector<std::vector<uint8_t>> xopt, yopt;
  std::unordered_map<uint32_t, int16_t> cache;
  uint8_t w, h;
  inline uint16_t getIndex(uint16_t x, uint16_t y) { return y * w + x; }
  inline ivec2 getCoords(uint16_t index) { return ivec2(index % w, index / w); }
  inline uint32_t packCoords(uin sx, uin sy, uin dx, uin dy) {
    return ((uint32_t)sx << 24) | ((uint32_t)sy << 16) | ((uint32_t)dx << 8) |
           (uint32_t)dy;
  }
 
  int solveslow(uin sx, uin sy, uin dx, uin dy) {
    std::vector<uint8_t> vx,
        vy; /// this isn't going to be any faster than the prev one, is it?
 
    std::vector<uint16_t> nindices; // step and pos
    std::vector<uint16_t> cindices;
    nindices.push_back(getIndex(dx, dy));
    int step = 1;

#define COUNT(x,y) std::count(x.begin(), x.end(), y)
    
    while (!nindices.empty()) {
      cindices = std::move(nindices);
 
      for (auto po : cindices) {
        int found = -1;
        ivec2 p = getCoords(po);
        for (auto xpos : xopt[p.y]) {
          if (std::count(vx.begin(), vx.end(), xpos))
            continue;
          if (true) {
            if (COUNT(yopt[xpos], sy))
              return step + 2;
 
            if (found == -1) {
 
              for (auto yposs : yopt[xpos]) {
                if (COUNT(xopt[yposs], sx))
                  found = step + 3;
              }
            }
          }
          nindices.push_back(getIndex(xpos, p.y));
        }
        // xopt.erase(p.y);
 
        for (auto ypos : yopt[p.x]) {
          if (COUNT(vy, ypos))
            continue;
          if (true) {
            if (COUNT(xopt[ypos], sx))
              return step + 2;
 
            if (found == -1) {
              for (auto xposs : xopt[ypos]) {
                if (COUNT(yopt[xposs], sy)) {
                  found = step + 3;
                }
              }
            }
          }
          nindices.push_back(getIndex(p.x, ypos));
        }
        if (found != -1)
          return found;
 
        // yopt.erase(p.x);
        vx.push_back(p.x);
        vy.push_back(p.y);
      }
      cindices.clear();
      step++;
    }
 
    return -1;
  }
 
  int solve(uin sx, uin sy, uin dx,
            uin dy) { // idk why i'm doing it like this smh. pwease work
 
    if (dx == sx && dy == sy)
      return 0;
    else if (dx == sx || dy == sy)
      return 1;
 
    if (xopt[sy].size() == 1 && yopt[sx].size() == 1)
      return -1;
    if (yopt[dx].size() == 1 && xopt[dy].size() == 1)
      return -1;
 
    if (COUNT(xopt[sy], dx))
      return 2;
    if (COUNT(yopt[sx], dy))
      return 2;
    /*
    for (auto xpos : xopt[sy]) {
      if (COUNT(yopt[xpos],dy)) {
        return 3;
      }
    } 
    for (auto ypos : yopt[sx]) {
      if (COUNT(xopt[ypos],dx))
        return 3;
    }*/
 
    uint32_t mcoords = packCoords(sx, sy, dx, dy);
    if (auto sc = cache.find(mcoords); sc != cache.end())
      return sc->second;
    mcoords = packCoords(dx, dy, sx, sy);
    if (auto sc = cache.find(mcoords); sc != cache.end())
      return sc->second;
 
    int16_t steps = solveslow(sx, sy, dx, dy);
    cache[mcoords]=steps;
    return steps;
  }
};
 
int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
 
  int w, h, c, z;
  int **vals;
  vals = new int *[4];
  vals[0] = &h;
  vals[1] = &w;
  vals[2] = &c;
  vals[3] = &z;
 
  std::string line;
 
  std::getline(std::cin, line);
  getNums(line, vals, 3);
 
  Grid grid;
  grid.cache.reserve(200000);
  grid.xopt.resize(250);
  grid.yopt.resize(250);
  grid.w = w;
  grid.h = h;
 
  for (int i = 0; i < h && std::getline(std::cin, line); i++) {
    if (line.size() == 0)
      continue;
    for (int x = 0; x < w; x++) {
      if (line[x] == 46) {
        grid.yopt[x].push_back(i);
        grid.xopt[i].push_back(x);
      }
    }
  }
  for (int i = 0; std::getline(std::cin, line); i++) {
    getNums(line, vals, 4);
    std::cout <<  grid.solve(w - 1, h - 1, z - 1, c - 1) << "\n";
  }
 
  // grid.print();
}

Test 1 (public)

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 2

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 3

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 4

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 5

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 6

Group: 2, 5

Verdict: ACCEPTED

Test 7

Group: 2, 5

Verdict: ACCEPTED

Test 8

Group: 2, 5

Verdict: ACCEPTED

Test 9

Group: 3, 4, 5

Verdict: ACCEPTED

Test 10

Group: 3, 4, 5

Verdict: ACCEPTED

Test 11

Group: 3, 4, 5

Verdict: ACCEPTED

Test 12

Group: 4, 5

Verdict: ACCEPTED

Test 13

Group: 4, 5

Verdict: ACCEPTED

Test 14

Group: 4, 5

Verdict: ACCEPTED

Test 15

Group: 5

Verdict: ACCEPTED

Test 16

Group: 5

Verdict: ACCEPTED

Test 17

Group: 5

Verdict: ACCEPTED

Test 18

Group: 5

Verdict: ACCEPTED

Test 19

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 21

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 22

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 23

Group: 1, 2, 3, 4, 5

Verdict: ACCEPTED

Test 24

Group: 5

Verdict: ACCEPTED

Test 25

Group: 5

Verdict: ACCEPTED

Test 26

Group: 5

Verdict: ACCEPTED

Test 27

Group: 5

Verdict: ACCEPTED