区间型动态规划

题目来源于codevs

---

石子归并

题目描述 Description
有n堆石子排成一列，每堆石子有一个重量w[i], 每次合并可以合并相邻的两堆石子，一次合并的代价为两堆石子的重量和w[i]+w[i+1]。问安排怎样的合并顺序，能够使得总合并代价达到最小。

输入描述 Input Description
第一行一个整数n（n<=100）

第二行n个整数w1,w2…wn (wi <= 100)

输出描述 Output Description
一个整数表示最小合并代价

样例输入 Sample Input
4
4 1 1 4

样例输出 Sample Output
18

分析：
动态规划题
首先我们可以处理出从各段的和。
然后对于f[i][j] 表示 从 i 到 j 合并得到的最小值（代价）
于是f[i][j] = min(f[i][k]+f[k+1][j]+a[i][j],f[i][j]);

#include<cstdio>
#include<iostream>
using namespace std;
int f[105][105],w[105],a[105][105];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        cin>>w[i];

    for(int i=1;i<=n;i++)
        {a[i][i]=w[i];f[i][i]=0;}

    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)
            a[i][j]=a[i][j-1]+w[j];

    for(int len=2;len<=n;len++)
        for(int i=1;i<=n;i++)
        {
            int j=i+len-1;
            if(j>n) continue;
            f[i][j]=0x7ffffff;
            for(int k=i;k<j;k++)
            {
            f[i][j]=min(f[i][k]+f[k+1][j]+a[i][j],f[i][j]);
            }
        }
    cout<<f[1][n]<<endl;
    return 0;
}

能量项链

题目描述 Description
在Mars星球上，每个Mars人都随身佩带着一串能量项链。在项链上有N颗能量珠。能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样，通过吸盘（吸盘是Mars人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为m，尾标记为r，后一颗能量珠的头标记为r，尾标记为n，则聚合后释放的能量为m*r*n（Mars单位），新产生的珠子的头标记为m，尾标记为n。

需要时，Mars人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。

例如：设N=4，4颗珠子的头标记与尾标记依次为(2，3) (3，5) (5，10) (10，2)。我们用记号⊕表示两颗珠子的聚合操作，(j⊕k)表示第j，k两颗珠子聚合后所释放的能量。则第4、1两颗珠子聚合后释放的能量为：

(4⊕1)=10*2*3=60。

这一串项链可以得到最优值的一个聚合顺序所释放的总能量为

((4⊕1)⊕2)⊕3）=10*2*3+10*3*5+10*5*10=710。

输入描述 Input Description
第一行是一个正整数N（4≤N≤100），表示项链上珠子的个数。第二行是N个用空格隔开的正整数，所有的数均不超过1000。第i个数为第i颗珠子的头标记（1≤i≤N），当i < N时，第i颗珠子的尾标记应该等于第i+1颗珠子的头标记。第N颗珠子的尾标记应该等于第1颗珠子的头标记。

至于珠子的顺序，你可以这样确定：将项链放到桌面上，不要出现交叉，随意指定第一颗珠子，然后按顺时针方向确定其他珠子的顺序。

输出描述 Output Description
只有一行，是一个正整数E（E≤2.1*109），为一个最优聚合顺序所释放的总能量。

样例输入 Sample Input
4
2 3 5 10

样例输出 Sample Output
710
分析：
个人觉得就是石子合并的加强版，变成一个环了。用一个取模或者把数组加倍来解决。
然后定义f[i][j] 表示从 i 到 j 的最大能量
f[i][j]=max(f[i][r] , f[i][k-1]+f[k][j]+s[i]*s[k]*b[r]);

#include <cstdio>
#include <iostream>
using namespace std;
int f[102][102],n;

// 直接解决 环状  省得开两倍 
int mod(int x){
    return (x-1)%n+1;
}

int main()
{
    int s[102],r;
    int b[102];//存储 
    int Maxn=-1;
    //Readdata();
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&s[i]);
        b[i-1]=s[i];
       }
    //dp
    b[n]=s[1]; 
    for(int j=2; j<=n; j++){
        for(int i=1; i<=n; i++){
            r=mod(i+j-1);
            for(int k=i+1;k<=j+i-1;k++){
                f[i][r]=max(f[i][r],f[i][mod(k-1)]+f[mod(k)][r]+s[i]*s[mod(k)]*b[r]);
          }}}    
    for(int i=1;i<=n;i++)
    {
    if(f[i][mod(i+n-1)]>Maxn)Maxn=f[i][mod(i+n-1)];
     }
    printf("%d",Maxn);
    return 0;
}

矩阵取数游戏

题目描述 Description
【问题描述】
帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的n*m 的矩阵，矩阵中的每个元素aij均
为非负整数。游戏规则如下：
1. 每次取数时须从每行各取走一个元素，共n个。m次后取完矩阵所有元素；
2. 每次取走的各个元素只能是该元素所在行的行首或行尾；
3. 每次取数都有一个得分值，为每行取数的得分之和，每行取数的得分= 被取走的元素值*2i，
其中i 表示第i 次取数（从1 开始编号）；
4. 游戏结束总得分为m次取数得分之和。
帅帅想请你帮忙写一个程序，对于任意矩阵，可以求出取数后的最大得分。

输入描述 Input Description
第1行为两个用空格隔开的整数n和m。
第2~n+1 行为n*m矩阵，其中每行有m个用单个空格隔开的非负整数。

输出描述 Output Description
输出 仅包含1 行，为一个整数，即输入矩阵取数后的最大得分。

样例输入 Sample Input
2 3
1 2 3
3 4 2

样例输出 Sample Output
82

数据范围及提示 Data Size & Hint
样例解释
第 1 次：第1 行取行首元素，第2 行取行尾元素，本次得分为1*21+2*21=6
第2 次：两行均取行首元素，本次得分为2*22+3*22=20
第3 次：得分为3*23+4*23=56。总得分为6+20+56=82
【限制】
60%的数据满足：1<=n, m<=30, 答案不超过1016
100%的数据满足：1<=n, m<=80, 0<=aij<=1000

分析：
由于每一排之间是相对独立的，也即是找到每一排所能得到的最大值求和。
满足动态规划要求。
f[i,j]=max{f[i-1,j]+data[i-1]*2^k,f[i,j+1]+data[j+1]*2^k}
则每一行的最大得分为max(f[i][i-1])

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;

const int MAXN = 1005;

struct bign
{
    int len, s[MAXN];
    bign ()
    {
        memset(s, 0, sizeof(s));
        len = 1;
    }
    bign (int num) { *this = num; }
    bign (const char *num) { *this = num; }
    bign operator = (const int num)
    {
        char s[MAXN];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    bign operator = (const char *num)
    {
        for(int i = 0; num[i] == '0'; num++) ;  //去前导0
        len = strlen(num);
        for(int i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
        return *this;
    }
    bign operator + (const bign &b) const 
    {
        bign c;
        c.len = 0;
        for(int i = 0, g = 0; g || i < max(len, b.len); i++)
        {
            int x = g;
            if(i < len) x += s[i];
            if(i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }
    bign operator += (const bign &b)
    {
        *this = *this + b;
        return *this;
    }
    void clean()
    {
        while(len > 1 && !s[len-1]) len--;
    }
    bign operator * (const bign &b) //*
    {
        bign c;
        c.len = len + b.len;
        for(int i = 0; i < len; i++)
        {
            for(int j = 0; j < b.len; j++)
            {
                c.s[i+j] += s[i] * b.s[j];
            }
        }
        for(int i = 0; i < c.len; i++)
        {
            c.s[i+1] += c.s[i]/10;
            c.s[i] %= 10;
        }
        c.clean();
        return c;
    }
    bign operator *= (const bign &b)
    {
        *this = *this * b;
        return *this;
    }


    bool operator < (const bign &b)
    {
        if(len != b.len) return len < b.len;
        for(int i = len-1; i >= 0; i--)
        {
            if(s[i] != b.s[i]) return s[i] < b.s[i];
        }
        return false;
    }
    bool operator > (const bign &b)
    {
        if(len != b.len) return len > b.len;
        for(int i = len-1; i >= 0; i--)
        {
            if(s[i] != b.s[i]) return s[i] > b.s[i];
        }
        return false;
    }
    bool operator == (const bign &b)
    {
        return !(*this > b) && !(*this < b);
    }
    bool operator != (const bign &b)
    {
        return !(*this == b);
    }
    bool operator <= (const bign &b)
    {
        return *this < b || *this == b;
    }
    bool operator >= (const bign &b)
    {
        return *this > b || *this == b;
    }
    string str() const
    {
        string res = "";
        for(int i = 0; i < len; i++) res = char(s[i]+'0') + res;
        return res;
    }
};
//输入输出 
istream& operator >> (istream &in, bign &x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign &x)
{
    out << x.str();
    return out;
}
bign f[90][90],pow[90],ans;
int main()
{   Readdata();
    int n,m,a[100];
    scanf("%d%d",&n,&m);
    pow[0]=1;
    //get pow ; 
    for(int i=1;i<=m;i++)
    pow[i]=pow[i-1]*2;
    //对每一排考虑 实际上 每一排跟下一排没得关系找到当前最大 
    for(int r=1;r<=n;r++)
        {
            for(int c=1;c<=m;c++)
                scanf("%d",&a[c]);

            for(int i=1;i<=m;i++)
                f[i][i]=pow[m]*a[i];

            for(int i=m-1;i>=1;i--)
                for(int j=i+1;j<=m;j++)
                    {if(f[i+1][j]+pow[m-j+i]*a[i] > f[i][j-1]+pow[m-j+i]*a[j])
                      f[i][j]=f[i+1][j]+pow[m-j+i]*a[i];
                      else f[i][j] = f[i][j-1]+pow[m-j+i]*a[j];
                    }
            ans=ans+f[1][m];
        }
    cout<<ans;
    return 0;
}