基础线性DP总结

动态规划是一种求解最优解的思想 。通常情况下要分清楚动规和贪心，什么时候用贪心，什么时候用动规。

1.数字三角形问题

动规方程：dp[i][j]=a[i][j]+max{dp[i+1][j],dp[i+1][j+1]}。每次从i,j走有两种选择下dp[i+1][j]和 右下dp[i+1][j+1].全局最优解包含局部最优解。动态规划的核心是状态转移方程。

The Triangle   POJ - 1163 

这是数字三角形的基础题。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=101;
int dp[maxn][maxn];
int  main()
{
  int n;
  while(cin>>n)
  {
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
    {
      for(int j=1;j<=i;j++)
      {
        cin>>dp[i][j];
      }
    }
    for(int i=n-1;i>=1;i--)//从后往前搜索
    {
      for(int j=1;j<=i;j++)
      {
        dp[i][j]=dp[i][j]+max(dp[i+1][j],dp[i+1][j+1]);
      }
    }
   cout<<dp[1][1]<<endl;
  }
  return 0;
}

需要注意边界，我从0开始到n，一直wrong，后来把边界条件改了，就过了，注意是从下往上搜索。动态规划不同于递归，递归会有很多相同子问题，会造成效率很低，动规是从底往上搜索。输出的是最上层dp[1][1]就是所求解。

此题可以用滚动数组进行优化，能降低空间复杂度，滚动数组就是在数据量很大的时候压缩存储。达到节省空间的思想。

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=101;
int dp[maxn][maxn];
int *maxsum;
int  main()
{
  int n;
  while(cin>>n)
  {
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
    {
      for(int j=1;j<=i;j++)
      {
        cin>>dp[i][j];
      }
    }
    maxsum=dp[n];//maxsum指向第n行
    for(int i=n-1;i>=1;i--)//从后往前搜索
    {
      for(int j=1;j<=i;j++)
      {
        maxsum[j]=max(maxsum[j],maxsum[j+1])+dp[i][j];
      }
    }
   cout<<maxsum[1]<<endl;
  }
  return 0;
}

 

G - 免费馅饼

 HDU - 1176

 这道题就是数字三角形的变形，最后要从（0，5）输出。倒推。

#include<iostream>
#include<cstdio>
#include<cstring>
#incl