Longest route

input/code.cpp: In function 'int rec(int, std::vector<std::vector<int> >&, std::vector<int>&, std::vector<bool>&, std::vector<int>&)':
input/code.cpp:66:13: warning: variable 'prec' set but not used [-Wunused-but-set-variable]
   66 |         int prec = -2;
      |             ^~~~

#include <algorithm>
#include <vector>
#include <iostream>

using namespace std;

// Debug printing
#ifdef DEBUG
#define deb(fmt, args...) printf("DEBUG: %d: " fmt, __LINE__, ##args)
#else
#define deb(fmt, args...)
#endif

void print_array(vector<int> in, const string title = "Vector")
{
	cout << title << " [\n";
	for (const auto &el : in) {
		cout << el << " ";
	}
	cout << "\n] END\n";
}

void print_matrix(vector<vector<int> > in, const string title = "Matrix")
{
	cout << title << "[\n";
	for (unsigned int i = 0; i < in.size(); i++) {
		cout << "row " << i << ": ";
		for (unsigned int j = 0; j < in[i].size(); j++) {
			cout << in[i][j] << " ";
		}
		cout << "\n";
	}
	cout << "] END\n";
}

vector<int> top_sort;
bool impossible = false;

void top_dfs(int s, vector<int> &status, vector<vector<int> > adj)
{
	if (impossible)
		return;
	if (status[s] == 1) {
		impossible = true;
	}
	if (status[s] == 2) {
		return;
	};
	status[s] = 1;
	for (auto u : adj[s]) {
		top_dfs(u, status, adj);
	}
	status[s] = 2;
	top_sort.push_back(s);
}

int rec(int a, vector<vector<int> > &adj, vector<int> &path, vector<bool> &h,
	vector<int> &distances)
{
	if (a == 1)
		return 0;
	if (h[a])
		return distances[a];
	h[a] = true;
	int maximum = -2;
	int prec = -2;
	for (auto b : adj[a]) {
		int res = rec(b, adj, path, h, distances);
		// maximum = max(maximum, res);
		// maximum = max(maximum, distances[b].first);
		if (res > maximum) {
			maximum = res;
			prec = b;
			// maximum = distances[b].first;
		}
	}
	// distances[a] = {maximum, prec};
	// path.push_back(prec);
    distances[a] = maximum + 1;
	return maximum + 1;
}

int main(int argc, char *argv[])
{
	int n, m;
	cin >> n >> m;
	int tmp1, tmp2;
	vector<vector<int> > adj(n + 1);
	vector<vector<int> > adjrev(n + 1);
	for (int i = 0; i < m; i++) {
		cin >> tmp1 >> tmp2;
		adj[tmp1].push_back(tmp2);
		adjrev[tmp2].push_back(tmp1);
	}

	// print_matrix(adj);

	vector<int> status(n + 1, 0);
	for (int i = 1; i < n + 1; i++) {
		if (status[i] == 0)
			top_dfs(i, status, adj);
	}
	if (impossible) {
		cout << "IMPOSSIBLE\n";
	}
    vector<int> distance(n + 1, -2);
    distance[1] = 0;
    vector<int> prec(n + 1);
    reverse(top_sort.begin(), top_sort.end());
    // print_array(top_sort, "sort");
    for (auto u : top_sort) {
        for (auto v : adj[u]) {
            if (distance[u] + 1 > distance[v]) {
                distance[v] = distance[u] + 1;
                prec[v] = u;
            }
        }
    }
    // print_array(distance, "dist");

    if (distance[n] < 0) {
        cout << "IMPOSSIBLE\n";
        return 0;
    }

    vector<int> path;
    int next = n;
    while (next != 1 && next != 0) {
        path.push_back(next);
        next = prec[next];
        // deb("next: %d\n", next);
    }
    path.push_back(1);

	// // deb("top sort tehty\n");
	// // print_array(top_sort, "sort");
	// // print_matrix(adjrev, "rev");
	// // reverse(top_sort.begin(), top_sort.end());
	// vector<int> distances(n + 1, -1);
 //    distances[1] = 0;
	// // for (auto vert : top_sort) {
	// //     rec(vert, adjrev, distances);
	// // }
	// // for (auto p : distances) {
	// //     deb("{ %d, %d }\n", p.first, p.second);
	// // }
	// vector<int> path;
	// vector<bool> h(n + 1, false);
	// rec(n, adjrev, path, h, distances);
 //    if (distances[n] == -1) {
 //        cout << "IMPOSSIBLE\n";
 //        return 0;
 //    }
 //    // print_array(distances, "dist");
 //    int v = n;
 //    int ma = 0;
 //    while (v != 1) {
 //        ma = -1;
 //        // deb("%d, ma: %d\n", v, ma);
 //        for (auto u : adjrev[v]) {
 //            if (distances[u] > ma) {
 //                ma = distances[u];
 //                v = u;
 //            }
 //        }
 //        if (ma == -1) {
 //            cout << "IMPOSSIBLE\n";
 //            return 0;
 //        }
 //        path.push_back(v);
 //    }
	// // print_array(path, "path");
    // reverse(path.begin(), path.end());
	cout << path.size() << "\n";
	for (int i = path.size() - 1; i >= 0; i--) {
		cout << path[i] << " ";
	}
	cout << "\n";
	// print_array(path);

	//handle top sorted stuff

	return 0;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: WRONG ANSWER

Test 5

Verdict: ACCEPTED

Test 6

Verdict: TIME LIMIT EXCEEDED

Test 7

Verdict: TIME LIMIT EXCEEDED

Test 8

Verdict: TIME LIMIT EXCEEDED

Test 9

Verdict: TIME LIMIT EXCEEDED

Test 10

Verdict: TIME LIMIT EXCEEDED

Test 11

Verdict: TIME LIMIT EXCEEDED

Test 12

Verdict: RUNTIME ERROR

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: RUNTIME ERROR

Test 16

Verdict: ACCEPTED

Test 17

Verdict: RUNTIME ERROR

Test 18

Verdict: RUNTIME ERROR

Test 19

Verdict: ACCEPTED

Test 20

Verdict: RUNTIME ERROR

Test 21

Verdict: ACCEPTED