YTU4069隐匿深处的弱点

样例输入 #1 

5
13
11 8
12 7 26
6 14 15 8
12 7 13 24 11

样例输出 #1

49 

提示

13->8->7->14->7

对于 100% 的数据，保证 1≤n≤100。金字塔中的数字不会超过 1000。

思路：这是一道典型的动态规划的题，动态规划就是给定一个问题把它拆解成子问题，直到子问题可以解决。然后把子问题的答案保存起来，以减少重复计算，再根据子问题答案反推，得出原问题解的一种方法。 

学习顺序可以按dfs->记忆化搜索->倒序->正序->空间优化 来学习

第一种方法：dfs (缺点会TLE)

#include <iostream>
#include <vector>
#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int g[N][N];
int n;
int dfs(int x1,int y1)
{
    if(x1>n||y1>n) return 0;
    //求最优子问题  min
    else
    {    
    
          return min(dfs(x1+1,y1),dfs(x1+1,y1+1))+g[x1][y1];
    
        
    }
}
int main() {
    
        cin>>n;
        for (int i = 1; i <= n; ++i) {
            for(int j=1;j<=i;j++)
            {
                    cin>>g[i][j];
            }
        
        }
        int res=dfs(1,1);    
        
    cout<<res<<endl;
    
//dfs->记忆化搜索-倒序递推->正序递推->空间优化
    return 0;
}

如果我们画递归搜索树的话，可以看到有很多子树分支是重复的，这时候我们可以采用第二种方法记忆化搜索  如果这个点已经计算过就直接返回（ if(mem[x1][y1]) return mem[x1][y1];）

#include <iostream>
#include <vector>
#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int g[N][N];
int mem[N][N];
int n;
int dfs(int x1,int y1)//
{
    int sum=0;
    if(mem[x1][y1]) return mem[x1][y1];
    if(x1>n||y1>n) sum=0;
    //求最优子问题  max
    else
              sum= min(dfs(x1+1,y1),dfs(x1+1,y1+1))+g[x1][y1];
              mem[x1][y1]=sum;

return sum;
    
}
int main() {
    
        cin>>n;
        for (int i = 1; i <= n; ++i) {
            for(int j=1;j<=i;j++)
            {
                    cin>>g[i][j];
            }
        
        }
        int res=dfs(1,1);    
        
    cout<<res<<endl;
    
//dfs->记忆化搜索-倒序递推->正序递推->空间优化
    return 0;
}

 dp的状态转移方程其实就是从前两个办法中提取的递归方式

第三种方法  倒序dp

递推正着推，递归就要倒着回来 （i从n到1）

倒序  最后的终点只能是最上面的 （唯一）

#include <iostream>
#include <vector>
#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int g[N][N];
int f[N][N];
int mem[N][N];
int n;
//dfs->记忆化搜索-倒序递推->正序递推->空间优化
int main() {
    
        cin>>n;
        for (int i = 1; i <= n; ++i) {
            for(int j=1;j<=i;j++)
            {
                    cin>>g[i][j];
            }
        
        }
            for (int i = n; i >=1; --i) {
            for(int j=1;j<=i;j++)
            {
                f[i][j]=min(f[i+1][j],f[i+1][j+1])+g[i][j];
            }
        
        }
    cout<<f[1][1]<<endl;
    return 0;

第四种方法 正序

我们需要先把f数组初始化为最大，因为我们求的是最小的结果，如果i-1越界且未初始化为最大，就会导致答案错误，可以手动画图理解·一下。

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

const int N = 1010;
int g[N][N];
int f[N][N]; // 这里需要初始化f数组

int main() {
	int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= i; j++) {
            cin >> g[i][j];
           
        }
    }
     for (int i = 0; i <= n; ++i) {
        for (int j = 0; j <= i+1; j++) {
          
           f[i][j]=INT_MAX;
        }
    }
    f[1][1]=g[1][1];
    for (int i = 2; i <= n; ++i) {
        for (int j = 1; j <= i; j++) {
            f[i][j] = min(f[i-1][j-1], f[i-1][j]) + g[i][j];
        }
    }
    int res = INT_MAX;
    for (int i = 1; i <= n; ++i) {
        res = min(f[n][i], res);
    }
    cout << res << endl;
    return 0;
}

参考：B站一只会code的小金鱼