Jelly Raid

input/code.cpp: In lambda function:
input/code.cpp:95:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for (int i = 0; i < masters.size(); ++i)
                       ^
input/code.cpp:99:14: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
      if (idx >= m.size())
              ^
input/code.cpp: In function 'int main()':
input/code.cpp:31:35: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%d %d\n", &rows, &columns);
                                   ^
input/code.cpp:34:37: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("(%d %d)\n", &srow, &scolumn);
                                     ^
input/code.cpp:35:37: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result...

#include <iostream>
#include <vector>
#include <cstdio>
#include <queue>

using namespace std;

struct node
{
	int t;
	int row;
	int column;
	
	bool operator<(const node& o) const
	{
		return t > o.t;
	}
};

int main()
{
	const int MAGIC = 120;
		
	std::vector<int> s[60][60];
	for (int i = 0; i < 60; ++i)
	for (int j = 0; j < 60; ++j)
		s[i][j].assign(MAGIC, -1);
	
	int rows, columns;
//	cin >> rows >> cols;
	scanf("%d %d\n", &rows, &columns);
	
	int srow, scolumn, erow, ecolumn;
	scanf("(%d %d)\n", &srow, &scolumn);
	scanf("(%d %d)\n", &erow, &ecolumn);
	
	erow--;
	ecolumn--;
	srow--;
	scolumn--;
	
	char map[60][60];
	
	for (int i = 0 ; i < rows; ++i)
	{
		std::string line;
		cin >> line;
		for (int j = 0; j < columns; ++j)
		{
			map[i][j] = line[j];
		}
	}
	
	int master_count;
	scanf("%d\n", &master_count);
	
	vector<vector<pair<int, int>>> masters(master_count);
	
	for (int i = 0; i < master_count; ++i)
	{
		int steps = 0;
		scanf("%d",&steps);
		scanf(" ");
		masters[i].resize(steps);
		for (int j = 0; j < steps; ++j)
		{
			scanf("(%d %d)", &masters[i][j].first, &masters[i][j].second);
			scanf(" ");
			masters[i][j].first--;
			masters[i][j].second--;
		}
		scanf("\n");
	}
	
	priority_queue<node> q;
	q.push({0, srow, scolumn});
	while (!q.empty())
	{
		node n = q.top();
		q.pop();
		
//		cout << n.row << ", " << n.column << ", " << n.t << " going to " << erow << ", " << ecolumn << endl;
		
		if (n.row == erow && n.column == ecolumn)
		{
			cout << n.t << endl;
			return 0;
		}
		s[n.row][n.column][n.t % MAGIC] = n.t;
		
		auto test = [&rows, &columns, &s, &map, &q, &masters](int row, int column, int t)
		{
			if (row >= 0 && row < rows && column >= 0 && column < columns && s[row][column][t % MAGIC] == -1)
			{
				for (int i = 0; i < masters.size(); ++i)
				{
					auto& m = masters[i];
					int idx = t % (2*m.size()-2);
					if (idx >= m.size())
						idx = m.size()-1-(idx-m.size());
					auto pos = m[idx];
					
					if (row == pos.first)
					{
						int mi = min(column, pos.second);
						int ma = max(column, pos.second);
						bool safe = false;
						for (int c = mi; c <= ma; ++c)
						{
							if (map[row][c] == '#')
							{
								safe = true;
								break;
							}
						}
						if (!safe)
							return;
					}
					if (column == pos.second)
					{
						int mi = min(row, pos.first);
						int ma = max(row, pos.first);
						bool safe = false;
						for (int r = mi; r <= ma; ++r)
						{
							if (map[r][column] == '#')
							{
								safe = true;
								break;
							}
						}
						if (!safe)
							return;
					}
				}
			
			
				if (map[row][column] == '.')
				{
					s[row][column][t % MAGIC] = t;
					q.push({t, row, column});
				}
			}
		};
		
		test(n.row, n.column, n.t+1);
		test(n.row+1, n.column, n.t+1);
		test(n.row, n.column+1, n.t+1);
		test(n.row-1, n.column, n.t+1);
		test(n.row, n.column-1, n.t+1);
	}
	cout << "IMPOSSIBLE" << endl;	
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: WRONG ANSWER

Test 6

Verdict: ACCEPTED

Test 7

Verdict: RUNTIME ERROR