Simple dynamic programming exercise [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 8 years ago.
Improve this question
Let's have a field (of given dimensions) of little squares with a value on each square. From each square, one can move only to the square directly below, or the one diagonally to the left or right. The task is to find the maximum combined value of a journey through the field.
For example for the input
1
6 5
3 1 7 4 2
2 1 3 1 1
1 2 2 1 8
2 2 1 5 3
2 1 4 4 4
5 2 7 5 1
the output should be 32, but my code outputs 20.
My approach was to exhaustively try all the possible routes through the field in the following manner:
y == last_row return value[x,y]
f(x,y)
y != last_row return value[x,y] + max(f(x-1,y+1),f(x,y+1),f(x+1,y+1))
Is there an error in my approach, in my code, or both?
The code is here:
#include <iostream>
#include <vector>
#include <limits>
using namespace std;
typedef int T;
T max(T x, T y, T z) {
if(x < y) {
if(y < z) return z;
else return y;
}
else {
if(y > z) return x;
else {
if(x > z) return x;
else return z;
}
}
}
//Finds the maximum amount of stones possibly gathered by following coordinates x,y
//The topmost left is (0,0), bottom right is (columns-1,rows-1)
T max_stones_found_following(T x, T y, vector< vector<T> > A) {
//Reached the last row?
if(y == A.size()-1) return A[x][y];
else {
T went_left, went_right, went_down;
if(x-1 >= 0) went_left = max_stones_found_following(x-1, y+1, A);
else went_left = numeric_limits<T>::min();
if(x+1 <= A[x].size()-1) went_right = max_stones_found_following(x+1, y+1, A);
else went_right = numeric_limits<T>::min();
went_down = max_stones_found_following(x, y+1, A);
return A[x][y] + max(went_left, went_right, went_down);
}
}
int main() {
//Initialization
T test_cases, rows, columns, stones_found, max_stones;
vector< vector<T> > A;
cin >> test_cases;
while(test_cases--) {
//Field input
cin >> rows >> columns;
for(int i = 0; i < rows; i++) {
vector<T> row;
for(int j = 0; j < columns; j++) {
T in;
cin >> in;
row.push_back(in);
}
A.push_back(row);
}
max_stones = 0;
stones_found = 0;
//Try starting at different positions in the first row
for(int i = 0; i < columns; i++) {
stones_found = max_stones_found_following(i, 0, A);
if(stones_found > max_stones) max_stones = stones_found;
}
//Output
cout << max_stones << endl;
}
return 0;
}

Answer 1

Some of your problems:
Method max is more complex that needed. You are making to many comparison to find the max. See bellow.
Your principal problem is using i and j inverted, according to the calling site i means the column where to start in the row 0 and in the method max_stones_found_following you are using as the row of the matrix of values.
Fixed Code (by the way it's a really slow solutions for big input data, and not dynamic programming):
#include <iostream>
#include <vector>
#include <limits>
using namespace std;
typedef int T;
T max(T x, T y, T z) {
return std::max(x, std::max(y, z));
}
// Finds the maximum amount of stones possibly gathered by following coordinates
// x,y
// The topmost left is (0,0), bottom right is (columns-1,rows-1)
T max_stones_found_following(T x, T y, vector<vector<T>> A) {
// Reached the last row?
if (y == A.size() - 1)
return A[y][x];
else {
T went_left, went_right, went_down;
if (x - 1 >= 0)
went_left = max_stones_found_following(x - 1, y + 1, A);
else
went_left = numeric_limits<T>::min();
if (x + 1 <= A[y].size() - 1)
went_right = max_stones_found_following(x + 1, y + 1, A);
else
went_right = numeric_limits<T>::min();
went_down = max_stones_found_following(x, y + 1, A);
return A[y][x] + max(went_left, went_right, went_down);
}
}
int main() {
// Initialization
T test_cases, rows, columns, stones_found, max_stones;
vector<vector<T>> A;
cin >> test_cases;
while (test_cases--) {
// Field input
cin >> rows >> columns;
for (int i = 0; i < rows; i++) {
vector<T> row;
for (int j = 0; j < columns; j++) {
T in;
cin >> in;
row.push_back(in);
}
A.push_back(row);
}
max_stones = 0;
stones_found = 0;
// Try starting at different positions in the first row
for (int i = 0; i < columns; i++) {
stones_found = max_stones_found_following(i, 0, A);
if (stones_found > max_stones)
max_stones = stones_found;
}
// Output
cout << max_stones << endl;
}
return 0;
}
See definition of dynamic programming. It's applicable to solve problems that:
Can be break into sub-problems.
And this sub-problems overlaps some how.
Ex: this problem can be divided into sub-problems as, what is the best path from row 0 -> row i. With this in mind the problem of the best path to row i, only depend of the best paths to row i-1 and the values of the matrix for the ith row. Using this you extend the solution to row i until reach last row.
In the last row would be the best path until every column of that row, search the max of this.
Source Code (Dynamic Programming):
#include <algorithm>
#include <iostream>
#include <vector>
typedef std::vector<int> row_t;
typedef std::vector<row_t> matrix_t;
int main() {
// Initialization
int test_cases, rows, columns;
matrix_t A;
std::cin >> test_cases;
while (test_cases--) {
std::cin >> rows >> columns;
for (int i = 0; i < rows; i++) {
row_t row(columns);
int in;
for (int j = 0; j < columns; j++) {
std::cin >> in;
row[j] = in;
}
A.push_back(row);
}
// Dynamic Programming Here
// For storage the best path until each cell
matrix_t best_A (rows, row_t(columns, 0));
std::copy(A[0].cbegin(), A[0].cend(), best_A[0].begin());
for (int i = 1; i < rows; i++) {
for (int j = 0; j < columns; j++) {
// right down
if (j > 0 && best_A[i - 1][j - 1] + A[i][j] > best_A[i][j]) {
best_A[i][j] = best_A[i - 1][j - 1] + A[i][j];
}
// left down
if (j < columns - 1 && best_A[i - 1][j + 1] + A[i][j] > best_A[i][j]) {
best_A[i][j] = best_A[i - 1][j + 1] + A[i][j];
}
// down
if (best_A[i - 1][j] + A[i][j] > best_A[i][j]) {
best_A[i][j] = best_A[i - 1][j] + A[i][j];
}
}
}
// End Dynamic Programming
auto it = std::max_element(best_A[best_A.size() - 1].cbegin(), best_A[best_A.size() - 1].cend());
// Output
std::cout << *it << std::endl;
}
return 0;
}
As commented previously you can calculate the best path to row i reading only the first i rows, you could do it on the fly (when reading, read first rows, calculate best starting positions, read second row, calculate best path until every column of second row, and so on), this is very good if the input is really, really big. You also don't need to save the best path until rows 1..i, you only need to have the last row calculated and the best paths of the actual row calculating.

Answer 2

Dynamic programming is a great way to approach this problem. But like anonymous commented, you aren't using it, or at least not in a clear fashion.
If you have C columns, then you have C possible starting locations, and C second locations, but there are 3*C - 2 pairs of (first, second). The way to leverage dynamic programming is to note the Markov nature, and for each cell in the second row, of all paths ending in that cell, keep only the one with the best score.
Then for each additional row, you again evaluate 3*C - 2 paths, keeping only C of them.
Repeat until you reach the bottom.
Implementation-wise, you should have a vector of C "best" paths to the current row, and build the vector of C best paths to the next row. Then the next row becomes the current row (use vector::swap). Each "path" must store at minimum the accumulated value, but storing the history of locations visited might also be nice.
In fact, you never even need to store the entire grid in memory. You can perform all processing for each row as you read it.
NOTE: Use of dynamic programming here makes the complexity R*C instead of C * 3^R
It was actually a lot of fun coming up with a real solution. Warning: pointers ahead!
#include <iostream>
#include <sstream>
#include <vector>
void solve_one_case();
int main(int argc, char** argv)
{
/* driver */
const std::string input = "6 5\n"
"3 1 7 4 2\n"
"2 1 3 1 1\n"
"1 2 2 1 8\n"
"2 2 1 5 3\n"
"2 1 4 4 4\n"
"5 2 7 5 1";
std::stringbuf inputstream(input, std::ios_base::in);
auto const oldbuf = std::cin.rdbuf();
std::cin.rdbuf(&inputstream);
solve_one_case();
std::cin.rdbuf(oldbuf);
return 0;
}
void solve_one_case()
{
/* get board size from input */
int rows = 1, columns = 1;
std::cin >> rows >> columns;
std::vector<char> route(rows * columns, '|');
/* get first row from input */
std::vector<int> current_row, prev_row;
current_row.resize(columns);
for( int& start_score : current_row )
std::cin >> start_score;
/* get all cells from input, solving */
char* pRoute = &route[columns];
for( int row = 1; row < rows; ++row ) {
prev_row = current_row;
int cell = 0;;
for( int column = 0; column < columns; ++column )
{
std::cin >> cell;
if (column > 0 && prev_row[column-1] > current_row[column]) {
current_row[column] = prev_row[column-1];
*pRoute = '\\';
}
if (column + 1 < columns && prev_row[column+1] > current_row[column]) {
current_row[column] = prev_row[column+1];
*pRoute = '/';
}
current_row[column] += cell;
++pRoute;
}
}
/* find best value in final row */
int best_score = current_row[0], best_end = 0;
for( int i = 1; i < columns; ++i ) {
if (best_score < current_row[i]) {
best_score = current_row[i];
best_end = i;
}
}
std::cout << "Best score is " << best_score << "\n";
/* backtrack along route */
int route_column = best_end;
for( int row = 0; row < rows; ++row ) {
char breadcrumb = '*';
pRoute -= columns;
std::swap(pRoute[route_column], breadcrumb);
switch (breadcrumb) {
case '/': ++route_column; break;
case '\\': --route_column; break;
}
}
/* print routes */
pRoute = &route[0];
for( int row = 0; row < rows; ++row ) {
std::cout.write(pRoute, columns);
pRoute += columns;
std::cout << '\n';
}
std::cout << std::flush;
}
Output:
Best score is 32
||*||
|/|*\
//|\*
/||*|
||*|\
|/*||