区间DP —— 石子合并

区间DP的经典例题，有三种题型

本篇博客借鉴了了两位大佬的博客。
博客1、博客2

一、任意合并

问题：
N堆石子，现要将石子有序的合并成一堆。每次只能移动任意的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。
思路：
贪心，每次把最小的两堆合并即可，可以使用stl中的优先队列来实现。
代码：

#include<iostream>
#include<queue>
#define ll long long
using namespace std;
int main()
{
    
    
    int t,n,x;
    cin>>t;
    while(t--)
    {
    
    
        ll sum  0;
        cin>>n;
        priority_queue<int,vector<int>,greater<int>>q;
        for(int i=0; i<n; i++)
        {
    
    
            cin >> x;
            q.push(x);
        }
        while(q.size()>1)
        {
    
    
            int t1=q.top();
            q.pop();
            int t2=q.top();
            q.pop();
            sum+=(t1+t2);
            q.push(t1+t2);
        }
        cout << sum << endl;
    }
    return 0;
}

二、相邻合并

问题：
有N堆石子，现要将石子有序的合并成一堆，每次只能移动相邻的2堆石子合并，花费为新合成的一堆石子的数量，求将这N堆石子合并成一堆的总花费最小（或最大）。
思路：
运用区间dp的思想。设dp[i][j]表示第i到第j堆石子合并的最优值，sum[i][j]表示第i到第j堆石子的总数量。那么就有状态转移公式：

代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define Inf 0x7fffffff
#define inf 0x3f3f3f3f
//const int N = 1e6 + 10;
const double PI= acos(-1.0);
const int mod = 1e9 + 7;
//ll a[N],vis[N],num[N],p[N];
const int maxn=301;
int n,a[maxn];
int dp[maxn][maxn];//dp[i][j]表示从第i堆到第j堆合并的代价
int sum[maxn][maxn];//表示石头的数量
int main()
{
    
    
    int n;
    cin>>n;
    for(int i=1; i<=n; i++)
        cin>>a[i];
    memset(sum,0,sizeof(sum));
    fill(dp[0],dp[0]+maxn*maxn,inf);//fill填充量必须是常数
    for(int i=1; i<=n; i++)
        sum[i][i]=a[i],dp[i][i]=0;
    for(int len=1; len<n; len++) //区间长度
    {
    
    
        for(int i=1; i<=n&&i+len<=n; i++) //区间起点
        {
    
    
            int j = i+len;//区间终点
            for(int k=i; k<=j; k++) //用k来表示分割区间
            {
    
    
                sum[i][j] = sum[i][k]+sum[k+1][j];
                dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[i][j]);
            }
        }
    }
    cout << dp[1][n] << endl;
    return 0;
}

三、环形合并

问题：
有N堆石子环形排列，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。
思路：
状态转移方程。

代码：

#include<bits/stdc++.h>
using namespace std;
const int N=500;
#define INF 0x3f3f3f
int mins[N][N],maxs[N][N],sum[N],a[N];
int minval,maxval;
int n;
int getsum(int i,int j)
{
    
    
    if(i+j >= n)
        return getsum(i,n-i-1) + getsum(0,(i+j)%n);
    else
        return sum[i+j] - (i>0 ? sum[i-1]:0);
}
void Work(int a[],int n)
{
    
    
    for(int i=0;i<n;i++)
        mins[i][0] = maxs[i][0] = 0;
    for(int j=1;j<n;j++)
    {
    
    
        for(int i=0;i<n;i++)
        {
    
    
            mins[i][j] = INF;
            maxs[i][j] = 0;
            for(int k=0;k<j;k++)
            {
    
    
                mins[i][j] = min(mins[i][j],mins[i][k] + mins[(i+k+1)%n][j-k-1] + getsum(i,j));
                maxs[i][j] = max(maxs[i][j],maxs[i][k] + maxs[(i+k+1)%n][j-k-1] + getsum(i,j));
            }
        }
    }
    minval = mins[0][n-1];
    maxval = maxs[0][n-1];
    for(int i=0;i<n;i++)
    {
    
    
        minval = min(minval,mins[i][n-1]);
        maxval = max(maxval,maxs[i][n-1]);
    }
}
int main()
{
    
    
    while(scanf("%d",&n)!=EOF)
    {
    
    
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        sum[0] = a[0];
        for(int i=1;i<n;i++)
            sum[i] = sum[i-1] + a[i];
        Work(a,n);
        printf("%d\n%d\n",minval,maxval);
    }
    return 0;
}