算法设计与分析实验---动态规划

算法设计与分析实验---动态规划_第1张图片

1.石子合并

任务描述

沿着河岸摆放 N 堆石子,现要将石子有次序地合并成一堆,规定每次只能选相邻的 2 堆合并成新的一堆,并将新的一堆的石子数,记为该次合并的得分。 例如:4堆石子4,5,9,4,可以按(((4,5),9),4)合并。

  • 第一次合并得分是9分,合并之后石子堆是9,9,4
  • 第二次合并得分是18分,合并之后石子堆是18,4
  • 第三次合并得分是22分,合并之后石子堆是22
  • 三次合并总得分49

试设计出一个算法,计算出将 N 堆石子合并成 1堆的最小得分和最大得分。

测试说明

输入格式

数据的第 1行是正整数 N,表示有N 堆石子。

2行有 N 个整数,第i 个整数 ai​ 表示第i 堆石子的个数。

输出格式

输出共 2 行,第 1 行为最小得分,第 2行为最大得分。

样例输入

4 4 5 9 4

样例输出

44 54

提示

1≤N≤1000≤ai​≤20

思路:

例如:4堆石子4,5,9,4 

要知道从开头4合并到最后4的最小代价,就需要知道从4合并到9的最小代价再合并最后一个4.....由此知道递推关系:

dpmin[i][j] = min(dpmin[i][j], dpmin[i][k] + dpmin[k + 1][j] + sum*[i->j]);

其中d[i][j]表示把第i到j堆合并成一堆的最小代价,sum*[i->j]表示第i到第j堆的石子数量之和。

由转移方程,可以看出要按照长度j-i进行迭代求解。

算法设计与分析实验---动态规划_第2张图片

 dpmax也是一样,只是把每次找最小值改为每次取最大值。

 注:主函数中数组是从1开始存的不是0!!!

代码:

#include 
#include 
using namespace std;
//在主函数中数组下标是从1开始的
 void dpStone(int a[],int n)
 {
  /**********   Begin   **********/
	
	//补充代码完成功能
    const int INF = 0x3f3f3f3f;
    int dpmin[100][100], sum[100], dpmax[100][100];

    dpmin[n][n] = { {0} };//将数组初始化
	dpmax[n][n] = { {0} };
	sum[n] = { 0 };

	sum[1] = a[1];//设置第一个石子数量
	for (int i = 2; i <= n; i++)
	{
		sum[i] = sum[i - 1] + a[i];//存从1到i的石子数量和
	}

	for (int v = 1; v <= n; v++) // 表示i到j的间距
	{
		for (int i = 1; i <= n - v; i++)//i表示行
		{
			int j = i + v;//j表示列
			int temp = sum[j] - (i > 1 ? sum[i - 1] : 0);
			//i=1的时候,sum取0,temp为从i-1到j的石子数量和
			dpmin[i][j] = INF;//将此处的dp设置为无穷大,便于下面找最小值时使用
			//dpmax不用设置,因为是求最大值,与0相比即可
			for (int k = i; k < j; k++)
			{
				dpmin[i][j] = min(dpmin[i][j], dpmin[i][k] + dpmin[k + 1][j] + temp);
				//比较不同分段方式取最小值
				dpmax[i][j] = max(dpmax[i][j], dpmax[i][k] + dpmax[k + 1][j] + temp);
				//比较不同分段方式取最大值
			}

		}
	}
	printf("%d\n%d", dpmin[1][n], dpmax[1][n]);



  /**********   End   **********/
  
 }
int main()
{
	int n;
	int a[105];
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> a[i];

	dpStone(a, n);
    return 0;

}

可参考博客:http://t.csdn.cn/H0MBg

2.基因检测

任务描述

本关任务:找出两个串的最长公共子串的长度。

用一个字符串表示一段基因,例如:CTATGGGTTT。两段基因的相似度定义为它们所包含的最大公共子串的长度。

例如:CCTTGGTGGGC的最大公共子串为TGG,它的长度为3,则我们称CCTTGGTGGGC的相似度为3。 现给定两段基因,要求计算它们的相似度。

编程要求

在右侧编辑器中有一个函数Similar,它有两个参数str1str2,是两个字符串,长度不超过50

请你在这个函数中,计算并输出这两个字符串的相似度。

输入数据由评测系统读取,并传递给Similar函数。具体见测试说明。

测试说明

平台会对你编写的代码进行测试:

测试输入CCCCC TTTTTGGGGGCC 预期输出: 2

测试输入ACTGGG DDD 预期输出: 0

思路:

dp[i][j]存从主串1-i和子串1-j的最长公共子串的长度

dp[i][j] =dp[i - 1][j - 1] + 1,str1[i]=str2[j]

dp[i][j]=0,str1[i]!=str2[j]

算法设计与分析实验---动态规划_第3张图片

代码: 

#include 
#include 
using namespace std;

void Similar(char *str1,char *str2)
{
	/**********   Begin   **********/
	//补充代码完成任务
    int dp[50][50];//dp[i][j]存从主串1-i和子串1-j的最长公共子串的长度
	int i = 0, j = 0;
	int max = 0, zichuan = 0;
	while (str2[j] != '\0')
	{
		i = 0;
		while (str1[i] != '\0')
		{
			if (str1[i] == str2[j])
			{
				dp[i][j] = (i >= 1 && j >= 1) ? dp[i - 1][j - 1] + 1 : 1;//数组从0开始的,防止数组越界
			}
			else
				dp[i][j] = 0;
		
			if (dp[i][j] > max)//更新最大值
				max = dp[i][j];
			i++;
		}
		j++;
	}
	cout << max << endl;
	return;

	
	/**********   End   **********/
}
int main()
{
    char str1[55],str2[55];
    while(cin >> str1 >> str2)
        Similar(str1,str2);
}

第3关:药剂稀释

任务描述

本关任务:找出一个序列中的最长下降子序列其中的元素个数。

医院里有一种药剂,其可以稀释成不同的浓度供病人使用,并且对于已知浓度的该药剂,使用时只能稀释不能增加浓度。

由于这种药需求量较大,同一瓶药剂只能给某个病人以及排在他后面的若干人使用。不同的病人对药物的浓度要求可能不同。

现在为了最大限度的利用每一瓶药剂(不考虑容量),已知n个病人所需药物浓度的序列,请计算出一瓶药剂能最多使用的人数。

编程要求

在右侧编辑器中有一个函数Cal,它有两个参数arrn

arr中包含n个病人对药物浓度的要求。

请你在这个函数中补充代码,计算并输出一瓶药剂能最多使用的人数。

输入数据由评测系统读取,并传递给Cal函数。具体见测试说明

测试说明

平台会对你编写的代码进行测试:

测试输入6 0.7 0.9 0.6 0.8 0.8 0.4

预期输出4

每组输入有两行,第一行有一个数n,第二行的n个数为数组的内容。

思路:

要知道0.7可用的病人,就要找浓度比0.7小的0.6可用的病人...即找到最后一种浓度0.4能用的病人只能为1后,在向上找0.8...等所能用的病人数

注,一种药剂最少一个人使用,且药剂稀释后不能增加浓度,且只能给后面的病人使用

dp[i]=max(dp[i],dp[j]+1),arr[j]

算法设计与分析实验---动态规划_第4张图片

代码:

#include 
#include 
using namespace std;

void Cal(double arr[],int n)
{
    /**********   Begin   **********/
	
	//补充代码完成任务
    int dp[105];//dp存以该药物为首可用的病人数
	for (int i = 0; i < n; i++)
		dp[i] = 1;
	int dan = 0;
	for (int i = n-2; i >=0; i--)//i为dp数组下标,j为arr下标
	{
		for (int j = n - 1; j > i; j--)
		{
			if (arr[i] >= arr[j])
			{
				dp[i] = max(dp[i], dp[j] + 1);
			}
		}
	}
	for (int i = 0; i < n; i++)
		dan = max(dan, dp[i]);
	cout << dan << endl;

	/**********   End   **********/
}
int main()
{
    double arr[105];
    int n;
    while(cin >> n)
    {
        for(int i=0; i> arr[i];
        Cal(arr,n);
    }
    return 0;
}

第4关:找相似串

任务描述

本关任务:找出最接近的相似串。

一般情况下,度量两个串S1S2的相似性,可以通过从一个串变换成另一个串所需要的最少操作次数来衡量,需要的操作次数越少,则越相似。

假设从一个串变化成另一个串所允许的操作只有两种:插入一个字符或者删除一个字符。无论是插入还是删除一个符号,均算作一次操作。

现给你一个串S,和一个串的集合T,让你找出集合T中与S最相似的串。

编程要求

右侧编辑器中有一个函数Similar,请在这个函数中读取数据完成任务。

输入数据由学员处理。输入的第一行为一个串S,第二行是一个整数n,范围0 < n < 20,表示接下来集合T中的串的个数。接下来n行,每行为一个串。

:所有字符串的长度不超过50

请输出T中与S最相似的串,如果有多个就输出多个串(按照输入时的顺序),每个串占一行。具体见测试说明

测试说明

平台会对你编写的代码进行测试:

测试输入abcd 4 abd abdc abed aebcd

预期输出abd aebcd

提示: 对于第一个串abd,在b后插入一个c就可以变成abcd,操作次数为1次。 第二个串abdc,删除d后面的c,在d前面增加一个c,即可变成abcd,操作次数为2次。 第三个串abed,删除d前面的e,在d前面增加一个c,即可变成abcd,操作次数为2次。 第四个串aebcd,删除a后面的e即可变成abcd,操作次数为1

算法思路

对一个子串来说:

 i = 0时,dp[0][j] = j;

 j = 0时,dp[i][0] = i;

 a[i] == b[j]dp[i][j] = d[i-1][j-1];

 a[i] != b[j]时,有两种操作,要么删除一个串的字符,要么添加一个串的字符,都记为一次操作,dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1

 算法设计与分析实验---动态规划_第5张图片 

代码: 

#include 
#include 
using namespace std;
const int MAX = 50;
void Similar()
{
	/**********   Begin   **********/
	
	//补充代码完成功能
    char s[MAX];
	int n,end;
	cin >> s>>n;//读取主串和子串个数
	int len_s = strlen(s);
	char arr[20][MAX];
	int caozuo[20];//存操作次数
	int dp[MAX][MAX];//用数组dp[i][j]表示,子串从1-i转换到主串的操作数。
	for (int i = 0; i < n; i++)//读取子串
	{
		cin>>arr[i];
	}	
	for (int i = 0; i < len_s; i++)
	{
		dp[0][i] = i;
	}

	for (int k = 0; k < n; k++)//第k个子串
	{
		int len = strlen(arr[k]);//子串长度
		//初始化
		for (int j = 0; j < len; j++)
			dp[j][0] = j;

		for (int i = 1; i < len_s; i++)//i为主串下标
		{
			for (int j = 1; j < len; j++)//j为子串下标
			{
				if (s[i] == arr[k][j])
					dp[i][j] = dp[i - 1][j - 1];
				else
					dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1;
			}
		}
		caozuo[k] = dp[len_s-1][len-1];//存每个子串的最小操作数
	}
	end = caozuo[0];
	for (int i = 1; i < n; i++)
		end = min(end, caozuo[i]);
	for (int i = 0; i < n; i++)
	{
		if (caozuo[i] == end)
			cout << arr[i] << endl;
	}

    

	/**********   End   **********/
}
int main()
{
    Similar();
}

第5关:聪明的寻宝人

任务描述

本关任务:计算寻宝人所能带走的宝物的最大价值。

一个寻宝人在沙漠中发现一处神秘的宝藏,宝藏中共有n个宝物(n不超过20),每个宝物的重量不同,价值也不同,宝物i的重量是wi,其价值为vi

寻宝人所能拿走的宝物的总重量为mm不超过50)。请帮助寻宝人写一个程序,计算寻宝人能够获得的最大总价值。

编程要求

在右侧编辑器中有一个函数MaxValue,它有四个参数valuesweightsnm

valuesweights分别存放了n件宝物的价值重量m为寻宝人所能携带的最大重量。

请在这个函数中补充代码,计算并输出寻宝人所能获得的最大总价值。

输入数据由评测系统读取,并传递给MaxValue函数。具体见测试说明

测试说明

平台会对你编写的代码进行测试:

测试输入3 10 3 4 4 5 5 6

预期输出11

每组输入有多行,第一行有两个数nm,分别为宝石数量寻宝人载重。下面有n行数据,每一行有两个数,分别是宝石重量宝石价值

思路:

是一个0-1背包问题

0-1背包问题参考博客:http://t.csdn.cn/hIcEL

代码:

#include 
using namespace std;


void MaxValue(int values[],int weights[],int n,int m)
{
	/**********   Begin   **********/
	
	//补充代码完成任务
    int dp[30][30];//
    for (int i = 0; i < 30; i++)
    {
        dp[0][i] = 0;
        dp[i][0] = 0;
    }

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (j >= weights[i])
            {
                dp[i][j] = max(dp[i-1][j], dp[i - 1][j - weights[i]] + values[i]);
            }
            else
            {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
    cout << dp[n][m] << endl;
	
	/**********   End   **********/
}
int main()
{
    int vs[30],ws[30],n,m;
    while(cin >> n >> m)
    {
        for(int s =1;s <= n;s++)
            cin >> ws[s] >> vs[s];

        MaxValue(vs,ws,n,m);
    }
}

以上为个人见解,有问题还请指正

你可能感兴趣的:(算法,动态规划)