山东大学计算机科学与技术学院程序设计思维与实践作业 week13-动态规划（3）

山东大学计算机科学与技术学院程序设计思维与实践作业
山大程序设计思维与实践作业
sdu程序设计思维与实践
山东大学程序设计思维实践作业H
山大程序设计思维实践作业H
山东大学程序设计思维与实践
week13-动态规划（3）

相关资料：GitHub

A : 石子合并

题目描述
将 堆石子绕圆形操场排放，现要将石子有序地合并成一堆。规定每次只能选相邻的两堆合并成新的一堆，并将新的一堆的石子数记做该次合并的得分。

请编写一个程序，读入堆数 N 及每堆的石子数，并进行如下计算：

选择一种合并石子的方案，使得做 N−1 次合并得分总和最大。
选择一种合并石子的方案，使得做 N−1 次合并得分总和最小。
输入描述
输入第一行一个整数 N (1≤N≤100)，表示有 N 堆石子。

第二行 N 个整数，表示每堆石子的数量。

输出描述
输出共两行：

第一行为合并得分总和最小值，

第二行为合并得分总和最大值。

测试样例
样例 1
输入:
4
4 5 9 4
输出:
43
54

#include<bits/stdc++.h>
using namespace std;

int f[500][500],a[500],sum[500],g[500][500];//g为代价最大值 
//sum数组为总代价的前缀和，sum[j]-sum[i]=第i到第j堆石子的总重量 

int main(){
	int n;
	int minimum=1e7,maximum=-1e7;
	
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		a[i+n]=a[i];//复制一遍数组 
	}
	sum[0]=0;
	for(int i=1;i<=2*n;i++){
		sum[i]=sum[i-1]+a[i];
	}//算出前缀和 
	
	memset(g,-63,sizeof(g));
	memset(f,+63,sizeof(f));
	for(int i=1;i<=2*n;i++){
		f[i][i]=0;//每堆石头和自己合并的代价都是0 
		g[i][i]=0; 
	}
	//将数组复制一遍，转化为2n长度的链型数组 
	for(int len=2;len<=n;len++){//枚举区间长度 
		for(int l=1;l+len-1<=2*n;l++){//枚举区间起点 
			int r=l+len-1;//区间终点 
			for(int k=l;k<r;k++){//枚举分割点 
				f[l][r]=min(f[l][r],f[l][k]+f[k+1][r]+sum[r]-sum[l-1]);
				g[l][r]=max(g[l][r],g[l][k]+g[k+1][r]+sum[r]-sum[l-1]);
			}
		}
	}
	
	for(int i=1;i<=n;i++){
		minimum=min(minimum,f[i][i+n-1]);//答案可能的区间：f[1,n],f[2,n+1],f[3,n+2]...
		maximum=max(maximum,g[i][i+n-1]);
	}
	cout<<minimum<<endl;
	cout<<maximum;
}

B : 括号序列

题目描述
定义一个合法的括号序列

空序列合法

如果 S 合法，那么(S)和[S]合法

假设 A 和 B 合法，那么 AB 合法

合法序列 - ()，[]，(())，([])，()[]，()[()]

非法序列 - (，[，]，)(， (])，([()，([)]

给定一个序列，求最少添加多少个括号，才能得到一个合法序列。

输入描述
输入仅一行，为一个字符串S,1≤len(S)≤100

输出描述
输出只有一个整数，表示增加的最少字符数。

测试样例
样例 1
输入:
[])
输出:
1

#include <bits/stdc++.h>
using namespace std;
string s = "";
int ans[105][105];

bool duibi(char a,char b){
    return ((a=='(' && b==')') || (a=='[' && b==']'));
}

int computation(int i, int j)
{
    if(i==j)
    {
        ans[i][j]=1;
        return 1;
    }
    if(ans[i][j] != INT_MAX)
    {
        return ans[i][j];
    }
    int res=INT_MAX;
    if(duibi(s[i],s[j]))
    {
        if(i+1==j)
        {
            ans[i][j]=0;
            return 0;
        }
        res=min(res, computation(i + 1, j - 1));
    }
    for(int x=i;x<j;x++)
    {
        res= min(res, computation(i, x) + computation(x + 1, j));
    }
    ans[i][j]=res;
    return res;
}
int main()
{
    cin>>s;
    for(int i=0;i<105;i++)
    {
        for(int j=0;j<105;j++)
        {
            ans[i][j]=INT_MAX;
        }
    }
    int result= computation(0, s.size() - 1);
    cout<<result<<endl;
}

C : 最长回文子序列

题目描述
给定一个字符串 S ，找到其中最长的回文子序列，并返回该序列的长度。

输入描述
输入为一个只包含小写英文字母的字符串 S，最大长度不超过 4000。

输出描述
输出最长回文子序列的长度。

测试样例
样例 1
输入:
abcb
输出:
3

#include <iostream>
using namespace std;
string str;
bool kk[4000][4000];
int fr[4000][4000];
int functn(int i, int j)
{
    if (i == j) return 1;
    if (i > j) return 0;
    if (kk[i][j]) return fr[i][j];
    if (str[i] == str[j])
    {
        kk[i][j] = true;
        fr[i][j] = functn(i + 1, j - 1) + 2;
        return fr[i][j];
    }
    fr[i][j] = std::max(functn(i + 1, j), functn(i, j - 1));
    kk[i][j] = true;
    return fr[i][j];
}

int main()
{
    cin >> str;
    cout << functn(0, str.size() - 1);
    return 0;
}

D : 方格填充

题目描述
将高为 H，宽为 W 的棋盘分割成若干个宽和高分别为 1 和 2 的长方形，有多少种方案。

输入描述
第一行为 H(1≤N≤11)，W(1≤W≤11)。

输出描述
输出方案数。

测试样例
样例 1
输入:
2 2
输出:
2

#include <bits/stdc++.h>
#define lb(x) (x&(-x))

using namespace std;
int h,w;
long long f[12][4097];

// panduan函数判断是否满足连续的0是偶数个
bool panduan(int n){
    int num = 0;
    for(int i = 0; i < w; i++) {
        if(((n >> i) & 1) == 0) num++; // 这一位是0，0的个数++
        else if(num % 2 != 0) return false; // 若为奇数，返回false
        if(w - 1 == i && num % 2 != 0) // 若最后一个数为0，且有奇数个返回false
            return false;
    }
    return true; // 符合条件
}
int main(){
    cin >> h >> w;

    f[0][0] = 1;
    // 遍历每一行
    for(int i = 1; i <= h; ++i){
        // 遍历每种状态
        for(int s1 = 0; s1 < (1 << w); ++s1) {
            //遍历上一行的每一种状态
            for (int s2 = 0; s2 < (1 << w); ++s2) {
                // 每个数字 1 下⽅必须为 0,竖着的 1*2 ⻓⽅形需要补全
                if((s1 & s2) != 0) continue;
                // 判断是否满足连续的0是偶数个
                if(!panduan(s1 | s2)) continue;
                f[i][s1] += f[i - 1][s2];
            }
        }
    }

    cout << f[h][0] << endl;
    return 0;
}