Recursive path finding until result of division is 1 - c++

Question

I am trying to solve an exercise in recursion that goes like this.
Say you have a matrix of nxm with integers like this(just an example):
1 1 1 5 2
2 3 5 2 1
3 1 1 1 5
1 1 5 1 1
I want to find a path (starting from anywhere) that, given a number n, every step n changes by n/(number_at_that_position) and the path stops when n = 1.
I am not looking for all paths, I am just looking for a path.
So if you use symbols to map the path, you would end up with a matrix
> > V - *
- - V > ^
- - V ^ -
- - > ^ -
Where '>' means a step right, '<' means a step left, '^' is a step up and 'V 'is a step down. Once n becomes 1, we insert '*' to say the path ended.
Most important: The path has to be continuous and you cannot visit a place you have visited before.
Even more important: The function that finds the path MUST be recursive.
If no path is found, the code exits with a message saying that no path was found.
Up to now I've come up with the following code for the path finding. I've used ideas from different places, but one of them is this one Recursively finding a path through a maze c++
bool path_print(vector<vector<int> > &P, size_t line, size_t col, vector<vector<char> > &A, int n) {
if (line < 0 || line > P.size() || col < 0 || col > P[0].size()) {
return false;
}
if (A[line][col] != '-') {
return false;
}
if (n == 1) {
A[line][col] = '*';
return false;
}
printf("n = %d, line = %zu, col = %zu\n", n, line, col);
n = n/P[line][col];
if (path_print(P, line, col+1, A, n) == true){
A[line][col] = '>';
return true;
} else if (path_print(P, line-1, col, A, n) == true) {
A[line][col] = '^';
return true;
} else if (path_print(P, line+1, col, A, n) == true){
A[line][col] = 'V';
return true;
} else if (path_print(P, line, col-1, A, n) == true){
A[line][col] = '<';
return true;
}
return true;
}
P is the vector containing the values
A is the char vector that stores the path
n is the actual number you are probing
I've been working on this for a while and I am stuck. This code does not work properly. Any suggestions or help would be greatly appreciated.
Thank you in advance

Answer 1

In your code :
if (line < 0 || line > P.size() || col < 0 || col > P[0].size())
is wrong because :
that allows to use the indexes P.size() and P[0].size(), in the original code of the link the comparisons are made with size - 1
line is a size_t so to do line < 0 has no sense, same for col
can be :
bool path_print(vector<vector<int> > &P, int line, int col, vector<vector<char> > &A, int n) {
if (line < 0 || line >= (int) P.size() || col < 0 || col >= (int) P[0].size())
or to check col and line before to do + 1 or -1 on them in a recursive call to avoid any problem including overflow.
But this is not enough to solve your problem, because your other changes from the code of the link are wrong :
you modify A cell after the recursive calls rather than before
you do not reset A cell to '-' after
when you find the exit (in your case n is 1) you return false rather than true, so you continue to search, and you check the value of n too late after an other move
at the end of the function you return true rather than false
Note that is is useless to continue to search while n is 0 after the division
To write if (f() == true) is redundant, if (f()) is enough
A solution modifying your code is :
#include <iostream>
#include <vector>
using namespace std;
bool searchPath(const vector<vector<int> > & P,
size_t line, size_t col,
vector<vector<char> > &A,
int n) {
if (A[line][col] != '-') {
return false;
}
n = n/P[line][col];
if (n == 1) {
A[line][col] = '*';
return true;
}
if (n == 0)
return false;
A[line][col] = '>';
if ((col != (P[0].size() - 1)) && searchPath(P, line, col+1, A, n)) {
return true;
}
A[line][col] = '^';
if ((line != 0) && searchPath(P, line-1, col, A, n)) {
return true;
}
A[line][col] = 'V';
if ((line != (P.size() - 1)) && searchPath(P, line+1, col, A, n)){
return true;
}
A[line][col] = '<';
if ((col != 0) && searchPath(P, line, col-1, A, n)){
return true;
}
A[line][col] = '-';
return false;
}
int main(int argc, char ** argv)
{
vector<vector<int> > P;
vector<vector<char> > A;
// fill vectors
int lines, columns;
cout << "number of lines and columns : ";
if (!((cin >> lines) && (cin >> columns) && (lines > 0) && (columns > 0))) {
cout << "invalid sizes" << endl;
return -1;
}
P.resize(lines);
A.resize(lines);
cout << "enter maze" << endl;
for (int i = 0; i != lines; ++i) {
P[i].resize(columns);
A[i].resize(columns);
for (int j = 0; j != columns; ++j) {
int v;
if (!(cin >> v) || (v < 1)) {
cout << "invalid input : " << v << endl;
return -1;
}
P[i][j] = v;
A[i][j] = '-';
}
}
int n;
cout << "enter n : ";
if (!(cin >> n) || (n <= 0)) {
cout << "invalid value of n" << endl;
return -1;
}
// search a way from all cells
for (size_t l = 0; l != (size_t) lines; ++l) {
for (size_t c = 0; c != (size_t) columns; ++c) {
if (searchPath(P, l, c, A, n)) {
// found
cout << "found from cell line " << l << " column " << c << endl;
for (l = 0; l != (size_t) lines; ++l) {
for (c = 0; c != (size_t) columns; ++c) {
cout << A[l][c] << ' ';
}
cout << endl;
}
return 0;
}
}
}
cout << "no solution" << endl;
return 0;
}
Examples :
number of lines and columns : 4 5
enter maze
1 1 1 5 2
2 3 5 2 1
3 1 1 1 5
1 1 5 1 1
enter n : 200
found from cell line 0 column 0
> > > > V
- * - - V
- ^ < < V
- - - ^ <
number of lines and columns : 4 5
enter maze
1 1 1 5 2
2 3 5 2 1
3 1 1 1 5
1 1 5 1 1
enter n : 999999
no solution