Hypyt

input/code.cpp: In function 'void getNums(std::string, int**, uint)':
input/code.cpp:16:41: warning: comparison of integer expressions of different signedness: 'uint' {aka 'unsigned int'} and 'int' [-Wsign-compare]
   16 |   while (getline(iss, s, ' ') && vcount != ccount) {
      |                                  ~~~~~~~^~~~~~~~~
input/code.cpp: In member function 'void Grid::drawco(uint, uint16_t)':
input/code.cpp:60:23: warning: comparison of integer expressions of different signedness: 'int' and 'uint' {aka 'unsigned int'} [-Wsign-compare]
   60 |     for (int i = 0; i < h; i++) {
      |                     ~~^~~
input/code.cpp: In member function 'void Grid::drawro(uint, uint16_t)':
input/code.cpp:67:23: warning: comparison of integer expressions of different signedness: 'int' and 'uint' {aka 'unsigned int'} [-Wsign-compare]
   67 |     for (int i = 0; i < w; i++) {
      |                     ~~^~~
input/code.cpp: In member function 'void Grid::print()':
input/code.cpp:73:23: w...

#include <cstdint>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <sys/types.h>
#include <unordered_set>

#define MONS 65535
#define UNIN 65534

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 {
  int 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);
  }
};

struct Grid {
  uint16_t *cgrid;
  uint w, h;

  uint16_t monster = MONS; // holy hell

  Grid(uint iw, uint ih) {
    w = iw;
    h = ih;
    cgrid = new uint16_t[w * h];
    // std::memset(cgrid, 0, w * h * sizeof(uint));
  };
  inline uint16_t &getc(uint x, uint y) {
    if (x >= w || x < 0 || y >= h || y < 0) {
      return monster;
      std::cout << "rejected: " << x << y << " \n";
    }

    return cgrid[y * w + x];
  }

  void setc(uint x, uint y, uint16_t c) { getc(x, y) = c; }
  void drawco(uint x, uint16_t c) {
    for (int i = 0; i < h; i++) {
      setc(x, i, c);
    }
  }
  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); }
  void drawro(uint y, uint16_t c) {
    for (int i = 0; i < w; i++) {
      setc(i, y, c);
    }
  }

  void print() {
    for (int y = 0; y < h; y++) {
      int charLen = 0;
      std::cout << "|";
      for (int x = 0; x < w; x++) {
        std::cout << getc(x, y);
        int numLen = std::to_string(getc(x, y)).size();
        std::cout << std::string(5 - numLen, ' ');
        std::cout << "|";
        charLen += 6;
      }
      std::cout << "\n";
      for (int x = 0; x < charLen; x++) {
        std::cout << "-";
      }
      std::cout << "\n";
    }
    std::cout << "\n";
  }

  int solve(uint16_t sx, uint16_t sy, uint16_t dx, uint16_t dy) { // idk what is going on in here. its so tupid
    std::unordered_set<uint16_t> visited;
    std::unordered_set<uint16_t> options;

    options.insert(getIndex(dx, dy));
    visited.insert(getIndex(dx, dy));

    int step = 0;

    if (dx == sx && dy == sy)
      return 0;
    else if (dx == sx || dy == sy)
      return 1;
    
    while (options.size() != 0) {
      step++;
      //std::cout << "step: " << step << "\n";
      std::unordered_set<uint16_t> indices = std::move(options);

      for (auto index : indices) {
        ivec2 cpos = getCoords(index);
        //std::cout << "pos: " << cpos.x << " " << cpos.y << " " << index << "\n";
        for (int x = 0; x < w; x++) { // add row into road
          if (!indices.count(getIndex(x, cpos.y)) && getc(x, cpos.y) == UNIN &&
              !visited.count(getIndex(x, cpos.y))) {

            if (x == sx || cpos.y == sy) { // can we move into road?
              return step + 1;
            }

            options.insert(getIndex(x, cpos.y));
            visited.insert(getIndex(x, cpos.y));
          }
        }
        for (int y = 0; y < w; y++) { // add row into road
          if (!indices.count(getIndex(cpos.x, y)) && getc(cpos.x, y) == UNIN &&
              !visited.count(getIndex(cpos.x, y))) {

            if (cpos.x == sx || y == sy) { // can we move into road?
              return step+1;
            }

            options.insert(getIndex(cpos.x, y));
            visited.insert(getIndex(cpos.x, y));
          }
        }
      }

      // nothing :(
    }
    return -1;
  }
};

int main() {
  int w, h, c, z;
  int **vals;
  vals = new int *[4];
  vals[0] = &h;
  vals[1] = &w;
  vals[2] = &c;
  vals[3] = &z;

  uint qcount = c;

  std::string line;

  std::getline(std::cin, line);
  getNums(line, vals, 3);

  Grid grid(w, 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++) {
      grid.setc(x, i, line[x] == 46 ? UNIN : MONS);
    }
    // std::copy(line.data(), line.data() + w, grid.cgrid + i * w);
  }

  for (int i = 0; std::getline(std::cin, line); i++) { ///// I != 1 111111111
    // if (i != 2)
    //   continue;
    getNums(line, vals, 4);

    std::cout << 
              grid.solve(w - 1, h - 1, z - 1, c - 1) << "\n";
    // std::cout << line << ": "<< h << " " << w << " " << c << " " << z<<"\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: TIME LIMIT EXCEEDED

Test 10

Group: 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 11

Group: 3, 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 12

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 13

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 14

Group: 4, 5

Verdict: TIME LIMIT EXCEEDED

Test 15

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 17

Group: 5

Verdict: TIME LIMIT EXCEEDED

Test 18

Group: 5

Verdict: TIME LIMIT EXCEEDED

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: TIME LIMIT EXCEEDED

Test 27

Group: 5

Verdict: ACCEPTED