石子合并（区间DP）+滑雪（记忆化搜索）

石子合并

 

设有 N 堆石子排成一排，其编号为 1,2,3,…,N。

每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

例如有 4 堆石子分别为 1 3 5 2， 我们可以先合并 1、2 堆，代价为 4，得到 4 5 2， 又合并 1、2 堆，代价为 9，得到 9 2 ，再合并得到 11，总代价为 4+9+11=24；

如果第二步是先合并 2、3 堆，则代价为 7，得到 4 7，最后一次合并代价为 11，总代价为 4+7+11=22。

问题是：找出一种合理的方法，使总的代价最小，输出最小代价。

输入格式

第一行一个数 N 表示石子的堆数 N。

第二行 N 个数，表示每堆石子的质量(均不超过 1000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤N≤300

输入样例：

4
1 3 5 2

输出样例：

22

思路：

        因为合并的时候只能相邻区间之间进行合并，因此，到最后肯定就是俩个合并成一个完成要求吗，那么这个时候只要使得俩个区域分别最小，以此类推，左边一个也是有俩个更小的区域合并而来，一次类推，大问题拆成小问题，从而达成要求。

用到闫氏DP法分析就会得到

        状态： dp[i][j]表示将 i到 j这一段石子合并成一堆的方案的集合

        属性：min

        状态转移方程：dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+arr[j]-arr[i-1]);

#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<stack>
#include<string>
#include<algorithm>
#include<unordered_map>
#include<map>
#include<cstring>
#include <unordered_set>
//#include<priority_queue>
#include<queue>
#include<set>
#include<stdlib.h>
#define dbug cout<<"hear!"<<endl;
#define rep(a,b,c) for(ll a=b;a<=c;a++)
#define per(a,b,c) for(ll a=b;a>=c;a--)
#define no cout<<"NO"<<endl;
#define yes cout<<"YES"<<endl;
#define endl "\n"
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//priority_queue<int,vector<int>,greater<int> >q;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> PII;
typedef pair<long double,long double> PDD;
 ll  INF = 0x3f3f3f3f;
//const ll LINF=LLONG_MAX;
// int get_len(int x1,int y1,int x2,int y2)
// {
//   return (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1);
// }
const ll N = 1e6+ 10;
const ll mod1 =998244353;
const ll mod2 =1e9+7;
const ll hash_num = 3e9+9;
ll n,m,ca, k, p,ans;
ll arr[N],brr[N],crr[N];
 ll h[N],ne[N],e[N],w[N],book[N],idx;
ll hh[N];
//ll book[N];

ll dp[500][500];

void solve()
{
   cin >> n;
   rep(i,1,n)
   {
    cin >> arr[i];
    arr[i]+=arr[i-1];//前缀和
   }
    memset(dp,INF,sizeof(dp));
   for(int len = 1;len <= n;len ++)//len表示分割的长度
   {
        for(int i = 1;i+len-1 <= n;i++)//i是左端点
        {
            int j= i+len-1;
            if(len==1)
            {
                dp[i][j]=0;//当长度为1 时候是不需要合并代价的
                continue;
            }
            for(int k=i;k<=j-1;k++)//枚举分割点
            {
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+arr[j]-arr[i-1]);
            }
        }
   }
   cout <<dp[1][n];
}




int main()
{
   IOS;
   ll _;
    _=1;
    //scanf("%lld",&_);
    //cin>>_;
    ca=1;
    while(_--)
    {
      solve(); 
      ca++;
    }    
    return 0;
}

知识点：

        常用区间DP板子：

        

for (int len = 1; len <= n; len++) {         // 区间长度
    for (int i = 1; i + len - 1 <= n; i++) { // 枚举起点
        int j = i + len - 1;                 // 区间终点
        if (len == 1) {
            dp[i][j] = 初始值
            continue;
        }

        for (int k = i; k < j; k++) {        // 枚举分割点，构造状态转移方程
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);
        }
    }
}

  

滑雪

给定一个 R 行 C 列的矩阵，表示一个矩形网格滑雪场。

矩阵中第 i 行第 j 列的点表示滑雪场的第 i 行第 j 列区域的高度。

一个人从滑雪场中的某个区域内出发，每次可以向上下左右任意一个方向滑动一个单位距离。

当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。

下面给出一个矩阵作为例子：

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

在给定矩阵中，一条可行的滑行轨迹为 24−17−2−1。

在给定矩阵中，最长的滑行轨迹为 25−24−23−…−3−2−1，沿途共经过 25 个区域。

现在给定你一个二维矩阵表示滑雪场各区域的高度，请你找出在该滑雪场中能够完成的最长滑雪轨迹，并输出其长度(可经过最大区域数)。

输入格式

第一行包含两个整数 R 和 C。

接下来 R 行，每行包含 C 个整数，表示完整的二维矩阵。

输出格式

输出一个整数，表示可完成的最长滑雪长度。

数据范围

1≤R,C≤300,
0≤矩阵中整数≤10000

输入样例：

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

输出样例：

25

 思路：

        题意很容易就能够理解

样例25就是这么跑出来的

这题其实不能用bfs，因为肯定超时

这个时候我们就开始分析：

        状态表示： 集合 ：从i，j开始的路径

                             属性：max

        状态转移方程：从上面划过来 ：dp[i-1][j]+1

                                   从下面划过来：dp[i+1][j]+1

                                   从左面划过来：dp[i][j-1]+1

                                   从右面划过来：dp[i][j+1]+1

这个时候就可以用到递归（记忆化搜索）

#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<stack>
#include<string>
#include<algorithm>
#include<unordered_map>
#include<map>
#include<cstring>
#include <unordered_set>
//#include<priority_queue>
#include<queue>
#include<set>
#include<stdlib.h>
#define dbug cout<<"hear!"<<endl;
#define rep(a,b,c) for(ll a=b;a<=c;a++)
#define per(a,b,c) for(ll a=b;a>=c;a--)
#define no cout<<"NO"<<endl;
#define yes cout<<"YES"<<endl;
#define endl "\n"
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//priority_queue<int,vector<int>,greater<int> >q;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> PII;
typedef pair<long double,long double> PDD;
 ll  INF = 0x3f3f3f3f;
//const ll LINF=LLONG_MAX;
// int get_len(int x1,int y1,int x2,int y2)
// {
//   return (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1);
// }
const ll N = 1e6+ 10;
const ll mod1 =998244353;
const ll mod2 =1e9+7;
const ll hash_num = 3e9+9;
ll n,m,ca, k, p,ans;
ll arr[N],brr[N],crr[N];
 //ll h[N],ne[N],e[N],w[N],book[N],idx;

ll h[500][500];
ll dp[500][500];
ll dx[]={0,1,0,-1},dy[]={1,0,-1,0};
ll get_max(ll x,ll y)
{
    ll &v=dp[x][y];//小技巧，等于把f[x][y]简化成了v，如果v发生变化，f[x][y]也会随之变化
    if(v!=-1)return v;//如果已经计算过了，就可以直接返回答案
    v=1;//一定要算上自身的1
    rep(i,0,3)
    {
        ll a=x+dx[i],b=y+dy[i];
        if(a>0 && b>0 && a<=n && b<=m && h[a][b]<h[x][y])
        {
            v=max(v,get_max(a,b)+1);//更新
        }
    }
    return v;
}

void solve()
{
   cin >> n >> m;
   memset(dp,-1,sizeof(dp));
    rep(i,1,n)
    {
        rep(j,1,m)
        {
            cin >> h[i][j];
        }
    }
    ll res=0;
    rep(i,1,n)
    {
        rep(j,1,m)
        {
            res=max(res,get_max(i,j));
        }
    }
    cout << res<<endl;
}




int main()
{
   IOS;
   ll _;
    _=1;
    //scanf("%lld",&_);
    //cin>>_;
    ca=1;
    while(_--)
    {
      solve(); 
      ca++;
    }    
    return 0;
}