SDU week10作业（A：签到题B：LIS&LCS C：拿数问题II）

最新推荐文章于 2020-06-14 08:52:08 发布

^O^ ? ^O^

最新推荐文章于 2020-06-14 08:52:08 发布

阅读量229

点赞数

分类专栏：学习文章标签：动态规划

本文链接：https://blog.csdn.net/weixin_45736432/article/details/105752474

版权

学习专栏收录该内容

30 篇文章 0 订阅

订阅专栏

A：签到题

题目：

东东在玩游戏“Game23”。

在一开始他有一个数字n，他的目标是把它转换成m，在每一步操作中，他可以将n乘以2或乘以3，他可以进行任意次操作。输出将n转换成m的操作次数，如果转换不了输出-1。

输入：

输入的唯一一行包括两个整数n和m（1<=n<=m<=5*10^8).

输出：

输出从n转换到m的操作次数，否则输出-1.

样例：

样例1：
输入：
120 51840
输出：
7
样例2：
输入：
42 42
输出：
0
样例3：
输入：
48 72
输出：
-1

思路：

这个就是每一步都会产生两种选择，*2 或者 *3，当某一状态两种选择都走过了且还没有到达m，最终就不能到达m,而没有到达的时候，就有两种选择，采取递归解决。
这里产生的一个问题是递归的时候cnt++ 得不到结果而cnt+1 可以，我们可以用深度优先搜索树来看待这种关系，子节点中cnt++的结果会影响的同一层其他子节点上中的cnt，从而导致深度优先搜索不完全。

代码：

#include<stdio.h>
using namespace std;
int m;
bool flag=false;
void solve(int n,int cnt)
{
	if(flag||n>m) return ;
	if(n==m) {	
		printf("%d\n",cnt);
		flag=true;

	}
	solve(2*n,cnt+1);   //cnt++ 和cnt+1  ？ 
	solve(3*n,cnt+1);
}
int main()
{
	int n;
	scanf("%d %d",&n,&m);  
	solve(n,0);
	if(!flag)
		printf("-1\n");	
	return 0;
 }

B：LIS&LCS

题目：

东东有两个序列A和B。

他想要知道序列A的LIS和序列AB的LCS的长度。

注意，LIS为严格递增的，即a1<a2<…<ak(ai<=1,000,000,000)

输入：

第一行两个数n，m（1<=n<=5,000,1<=m<=5,000）
第二行n个数，表示序列A
第三行m个数，表示序列B

输出：

输出一行数据ans1和ans2，分别代表序列A的LIS和序列AB的LCS的长度

样例：

输入：
5 5
1 3 2 5 4
2 4 3 1 5
输出：
32

思路：

LIS：
https://blog.csdn.net/qq_41765114/article/details/88415541
这里面讲解的非常直观。
简单来讲就是每遍历到一个值，就去前面寻找比他小的值，计算长度，代码比较容易，时间复杂度O(n2);
LCS :
设计状态：假设 f[i][j] 为 A1, A2, …, Ai 和 B1, B2, …, Bj 的 LCS 长度
初始化：初始 f[1][0] = f[0][1] = f[0][0] = 0
转移方程：当 Ai == Bj 时，f[i][j] = f[i-1][j-1] + 1
否则 f[i][j] = max(f[i-1][j], f[i][j-1])
输出答案：f[n][m]
时间复杂度：O(nm

代码：

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
long long  a[5010];
long long  b[5010];
long long dp[5010];
long long c[5010][5010];
int main()
{
	int  n,m;
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%lld",&a[i]);
		dp[i]=1;
	}
	for(int i=1;i<=m;i++){
		scanf("%lld",&b[i]);
	} 
	//A序列的LIS
	long long int maxx=1;
	for(int i=2;i<=n;i++){
		for(int j=1;j<i;j++){
			if(a[j]<a[i]){
				dp[i]=max(dp[i],dp[j]+1);
			}
		}
		maxx=max(maxx,dp[i]);//  问题maxx的位置不对 
	} 
	printf("%d ",maxx);
	//AB 的 LCS
	// if a[i]==b[j]   f(i,j)=f(i-1,j-1)+1
	// else  f(i,j)=max(f(i-1,j),f(i,j-1))
	memset(c,0,sizeof(c));
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			if(a[i]==b[j]){
				c[i][j]=c[i-1][j-1]+1;
			}
			else{
				c[i][j]=max(c[i-1][j],c[i][j-1]);    //谨防i-1 
			}
		}
	}
	printf("%d\n",c[n][m]);
	return 0;
}
/*
6 7
1 5 2 6 8 7
2 3 5 6 9 8 4
*/

C：拿数问题II

题目：

YJQ 上完第10周的程序设计思维与实践后，想到一个绝妙的主意，他对拿数问题做了一点小修改，使得这道题变成了拿数问题 II。

给一个序列，里边有 n 个数，每一步能拿走一个数，比如拿第 i 个数， Ai = x，得到相应的分数 x，但拿掉这个 Ai 后，x+1 和 x-1 (如果有 Aj = x+1 或 Aj = x-1 存在) 就会变得不可拿（但是有 Aj = x 的话可以继续拿这个 x）。求最大分数。

本题和课上讲的有些许不一样，但是核心是一样，需要你自己思考。

输入：

第一行包含一个整数 n (1 ≤ n ≤ 105)，表示数字里的元素的个数

第二行包含n个整数a1, a2, …, an (1 ≤ ai ≤ 105)

输出：

输出一个整数：n你能得到最大分值。

样例：

输入：
9
1 2 1 3 2 2 2 2 3
输出：
10

思路：

首先就是读题很重要。上课讲的是当取了i 这个位置的数时，i-1和i+1位置的数都不能取，状态转移方程是：dp[i]=max(dp[i-1],dp[i-2]+a[i]);
而这个题的意思是，当取了i 位置 x 这个数，数值为x-1和x+1的数都不能取，因此这个是基于数值的（读了好几遍…）。
这里就会产生两种思路，第一种基于位置的，显然数据输入后需要排序，然后将相同的合并，假设现在位置i ,数值a[i]，排序合并后，题目的意思就变成了如果a[i]==a[i-1]+1 ，此时不能选取，状态转移方程是：
dp[i]=max(dp[i-1],dp[i-2]+a[i]*sum[a[i]]);
然而若a[i]比a[i-1]大的不只是1 ,就可以继续选取，此时的状态转移方程就是：
dp[i] = max(dp[i-1]+a[i]*sum[a[i]],dp[i-2]+a[i]*sum[a[i]]);
第二种思路是基于数值的：既然原来的这时候就只需要得到输入数据的最小值和最大值，确定范围，状态转移方程和上课讲的就相同
dp[i]=max(dp[i-1],dp[i-2]+i*sum[i]); 方程中的i 就是数值。

需要注意的是方程中均有i-2，因此初始化前两个数，同时ans也可能在前两个数中，

总结：

预想的结果是基于数值的可能会更慢一点，因为当数据量小但是数据范围大的时候就会做大量的无用功，但是结果相反，基于位置的更慢一点，可能的原因是在合并的时候多了一次for循环，这个可以直接在输入的时候t=同时处理sum 和合并，用set 解决，效率可能更高一点。
状态转移非常重要…

代码：

（1）以位置为考量：

#include<stdio.h>
#include<algorithm> 
using namespace std;
long long int a[100010];
long long int b[100010];
long long int dp[100010];
long long int sum[100010];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&b[i]);
		sum[b[i]]++;
	} 
	sort(b,b+n);
	int j=0;
	a[0]=b[0];
	for(int i=1;i<n;i++){
		if(b[i]!=b[i-1]){
			j++;
			a[j]=b[i];
		}
	}
	//初始化
	dp[0]=a[0]*sum[a[0]];
	if(a[1]==a[0]+1){
		dp[1]=max(dp[0],a[1]*sum[a[1]]);	
	} 
	else{
		dp[1]=dp[0]+a[1]*sum[a[1]];
	}
	long long int ans=max(dp[0],dp[1]);
	for(int i=2;i<=j;i++){
		if(a[i]==a[i-1]+1){  //+1不能拿 
			dp[i]=max(dp[i-1],dp[i-2]+a[i]*sum[a[i]]); 
		}
		else{  //其他的可以拿 
			dp[i] = max(dp[i-1]+a[i]*sum[a[i]],dp[i-2]+a[i]*sum[a[i]]);
		} 
		ans=max(ans,dp[i]);
	}
	printf("%lld\n",ans); 
}

（2）以数值为考量

#include<stdio.h>
#include<algorithm>
#include<map> 
using namespace std;
long long int a[100010];
long long int dp[100010];
long long int sum[100010];  //记录重复元素的出现次数 
int main()
{
	int n;
	scanf("%d",&n);
	long long int minn=100010,maxx=0; 
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
		sum[a[i]]++; 
		//确定范围
		minn=min(minn,a[i]);
		maxx=max(maxx,a[i]); 
	}

	dp[minn]=sum[minn]*minn;
	dp[minn+1]=max(dp[minn],(minn+1)*sum[minn+1]);   //初始化 
	long long int ans=max(dp[minn],dp[minn+1]);
	for(int i=minn+2;i<=maxx;i++){   //按照数值考虑 
		dp[i]=max(dp[i-1],dp[i-2]+sum[i]*i); 
		ans=max(ans,dp[i]);
	}
	printf("%lld\n",ans); 
	return 0; 
}
/*
12
1 2 3 2 1 2 1  1 1 2 1 2
*/

^O^ ? ^O^

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SDU week10作业（A：签到题B：LIS&LCS C：拿数问题II）

week10作业A：签到题题目：输入：输出：样例：思路：代码：B：LIS&LCS题目：输入：输出：样例：思路：代码：C：拿数问题II题目：输入：输出：样例：思路：总结：代码：A：签到题题目：东东在玩游戏“Game23”。在一开始他有一个数字n，他的目标是把它转换成m，在每一步操作中，他可以将n乘以2或乘以3，他可以进行任意次操作。输出将n转换成m的操作次数，如果转换不了输出-1。...
复制链接

扫一扫

专栏目录