All possible paths between two points of a matrix in C++ [closed] - c++

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 5 years ago.
Improve this question
Given a NxM plane, find all the possible paths between two points with three movements: right, down and diagonal(right-down, 315º).
I'm stuck on this problem. I have to resolve it two ways: recursive and iterative. For iterative I have the idea but don't know how to implement it.
The description of my idea is:
(Google Translate). We are faced with a board of N columns of width and M rows of height. We must arrive from a point (x1, y1) to another point (x2, y2), so (xi, yj) can not be greater than N or M respectively. The restrictions for movement are that we can only move to the right (1), diagonal down-right (2) and down (3), with each movement we assign the number in parentheses. Given these movements, we realize that we can not go left or up, so x1 has to be less than x2 and y1 has to be greater than y2.
The algorithm would start from the first point (x1, y1) and try to create three "children", one for each movement:
Right (x1 + 1)
Diagonal (x1 + 1, y1-1)
Down (y1-1)
 
The conditionals for each child to be accepted would be those already said, x1 <= N, y1 <= M, x1 <= x2, y1> = y2.
The iteration would be to try to create 3 more children (one for each movement) from each accepted child.
This iteration would conclude by being (x1, y1) of each child equal to (x2, y2).
Thanks in advance.

Answer 1

Iterative Approach :
This can be solved by memoization, which means you keep track of the no. of ways to reach a certain cell in matrix M.
Initially M[x][y] = 0 , for all x,y. b/w sx, dx and sy,dy respecitevly
Pseudocode:
We first start from source cell (sx,sy), there is only one way to reach it, therefore
sx,sy // source cell
dx,dy // destination cell
M[sx][sy] = 1 ;
for row x between sx, dx :
for column y between sx, dy:
if y-1 >= sy:
M[x][y] += M[x][y-1] // coming to x,y from left cell
if x-1 >= sx:
M[x][y] += M[x][y-1] // coming to x,y from top cell
if x-1 >= sx && y-1 >= sy:
M[x][y] += M[x-1][y-1] // coming from diagonal left cell.
Answer will be M[dx][dy].
Recursive Approach:
Going by the same idea as iterative approach , the same can be implemented recursively as well:
Initially M[x][y] == -1: for all x b/w sx and dx , for all y b/w sy and dy
path( row, col )
if row == dx && col == dy:
return 1
if M[x][y] != -1: return M[x][y] // this means result for this is already calculated
M[x][y] = 0
if col+1 <= dy:
M[row][col] += path(row, col+1) // going right
if row+1 <= dx:
M[row][col] += path (row+1, col) // going down
if row+1 <= dx && col+1 <= dy:
M[row][col] += path(row+1, col+1) // going diagonally right
return M[row][col]
Answer will M[sx][sy]

Answer 2

A simple recursive solution would be to create new childs with each recursion call e.g.
int foundSolutions = 0;
boolean pathExistsBetweenPoints(Point source, Point target, List<Point> previousPoints) {
//Check if we're there yet
if(source.x == target.x && source.y == target.y) {
foundSolutions++;
//Here you can display previousPoints if you want a possible solution
return true;
}
if(source.x > N || source.y > M || source.x > target.x || source.y > target.y) {
return false; //This trail is out of bounds
}
//Add this point to the list of points
List<Point> newPoints = previousPoints.add(source);
//Get the childpoints
Point rightPoint = new Point(source.x, source.y + 1);
Point diagonalPoint = new Point(source.x + 1, source.y + 1);
Point downPoint = new Point(source.x + 1, source.y);
//Check if any of the childs can reach the target
boolean validPath = pathExistsBetweenPoints(rightPoint, target, previousPoints);
validPath = validPath || pathExistsBetweenPoints(diagonalPoint, target, previousPoints);
validPath = validPath || pathExistsBetweenPoints(downPoint, target, previousPoints);
return validPath;
}
I'm not familiar with C++ syntax but this should be fairly translatable