算法问题实战策略 TRIANGLEPATH 动态规划入门题

地址 https://algospot.com/judge/problem/read/TRIANGLEPATH （leetcode acwing 均有类似题目可供练习）

我们先从 暴力遍历开始说起

每当你处于一个点 有两个选择 选择下面的数字或者选择右下的数字(x+1   ||  x+1  y+1)

那么每个选择都计算 最后得出sum最大的值就是答案

很明显 这个会TLE

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


using namespace std;

const int MAX_N = 100010;

vector<int> v[MAX_N];
int n, m;
int maxsum = -9999999;

void dfs(int x, int y, int sum) {
    if (x == m+1  && y < x) {
        maxsum = max(maxsum, sum);
        return;
    }
    if (x >= m || y > x)
    {
        return;
    }

    sum += v[x][y];

    dfs(x+1,y,sum);
    dfs(x+1, y + 1, sum);
}

void solve()
{
    int sum = 0;
    dfs(0, 0, sum);

    cout << maxsum << endl;
}

int main()
{
    cin >> n;
    while (n--) {
        cin >> m;
        int len = 1;
        maxsum = -9999999;
        for (int i = 0; i < MAX_N; i++) {
            v[i].clear();
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < len; j++) {
                int t; cin >> t; v[i].push_back(t);
            }
            len++;
        }

        solve();
    }

    return 0;
}

原因在哪里呢？在如下的三角形里 路线有以下几种

1
2 3
4 5 6
7 8 9 10 

1->2->4->7
1->2->4->8
1->2->5->8
1->2->5->9
1->3->5->8
1->3->5->9
1->3->6->9
1->3->6->10

我们可以看到 1->2 1->3的路线重复计算好几次 每次都会去求和

那么我们使用一个表格记录走到2的位置和走到3的位置的最大和 是否就可以避免重复计算

同样其他格子也使用如此思路 

再进行观察

7 8 9 10的记录取决于 他们能够倒推到的 4 5 6格子记录的最大和

4 5 6 的记录取决于 他们能够倒推到的 2  3 格子记录的最大和

2 3的记录取决于 他们能够倒推到的 1 格子记录的最大和

1 的格子是确认的 他的最大和就是他自己

有两种推导公式 如下

/*for (int i = m - 1; i >= 0; i--) {
        for (int j = i; j >= 0; j--) {
            v[i][j] = max(v[i + 1][j], v[i + 1][j + 1]) + v[i][j];
        }
    }
    cout << v[0][0] << endl;*/
    //====================================================================
    /*
    for (int i = 0; i < m; i++) {
        for (int j = 0; j <= i; j++) {
            if (i - 1 >= 0 && j -1 >=0) {
                dp[i][j] = max( dp[i-1][j]+dp[i][j] , dp[i - 1][j-1] + dp[i][j]);
            }
            else if (i - 1 >= 0) {
                dp[i][j] = dp[i - 1][j]+dp[i][j];
            }
        }
    }

    int ret = -999999;
    for (int i = 0; i < m; i++) {
        ret = max(ret, dp[m - 1][i]);
    }
    cout << ret << endl;

全部代码

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


using namespace std;

const int MAX_N = 300;

vector<vector<int>> v(MAX_N,vector<int>(MAX_N));
int n, m;
int maxsum = -9999999;

vector<vector<int>> dp(MAX_N,vector<int>(MAX_N));





void solve()
{
    /*for (int i = m - 1; i >= 0; i--) {
        for (int j = i; j >= 0; j--) {
            v[i][j] = max(v[i + 1][j], v[i + 1][j + 1]) + v[i][j];
        }
    }
    cout << v[0][0] << endl;*/
    //====================================================================
    /*
    for (int i = 0; i < m; i++) {
        for (int j = 0; j <= i; j++) {
            if (i - 1 >= 0 && j -1 >=0) {
                dp[i][j] = max( dp[i-1][j]+dp[i][j] , dp[i - 1][j-1] + dp[i][j]);
            }
            else if (i - 1 >= 0) {
                dp[i][j] = dp[i - 1][j]+dp[i][j];
            }
        }
    }

    int ret = -999999;
    for (int i = 0; i < m; i++) {
        ret = max(ret, dp[m - 1][i]);
    }
    cout << ret << endl;
    */
}

int main()
{
    cin >> n;
    while (n--) {
        cin >> m;
        int len = 1;
        maxsum = -9999999;
        for (int i = 0; i < MAX_N; i++) {
            for (int j = 0; j < MAX_N; j++) {
                v[i][j] = 0;
                //dp[i][j] = 0;
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < len; j++) {
                cin >> v[i][j];
                dp[i][j] = v[i][j];
            }
            len++;
        }

        solve();
    }

    return 0;
}