WEEK(10)作业——动态规划（LIS、LCS）

A-签到题

题目描述

东东在玩游戏“Game23”。

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

Input

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

Output

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

Simple Input 1
120 51840
Simple Output 1
7

Simple Input 2
42 42
Simple Output 2
0

Simple Input 3
48 72
Simple Output 3
-1   

解题思路

刚开始纠结这里递归还是递推，想了一会发现递推貌似不好写，就放弃了。
从n到m，每步两种选择①×2，②×3，像极了似曾相识的深搜，递归边界是x=m或x>m;x=m时次数赋值,x>m直接回溯。times初始设为-1，若无法转换直接输出-1。

代码

#include<iostream>

using namespace std;

int n,m,times=-1;

void dfs(int x,int c) {
	if(x==m) {
		times=c;
		return;
	}
	if(x>m) return;
	dfs(2*x,c+1);
	dfs(3*x,c+1);
}

int main() {
	cin>>n>>m;
	dfs(n,0);
	cout<<times<<endl;
	return 0;
}

B-LIS&LCS

题目描述

东东有两个序列A和B。

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

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

Input

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

Output

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

Simple Input
5 5
1 3 2 5 4
2 4 3 1 5

Simple Output
3 2

解题思路

这是一道很经典的动态规划问题。LIS、LCS是动态规划的经典应用！关键在于转移方程的构造！！！

1. 最长上升子序列

• 状态：定义f[i]表示以A[i]为结尾的最长上升子序列长度
• 初始化f[1]=1
  - 最关键的地方——转移过程：f [ i ] = max { f [ j ] | j < i 且A [ j ] < A [ i ] } + 1
• 输出答案 ：max { f [ i ] , i = 1 ,2 , … }
• 时间复杂度：O ( n ² )

2. 最长公共子序列

• 设计状态：假设 c[ i ] [ j ] 为A[ 1 ],A[ 2 ],A[ 3 ],…,A[ i ]和B[ 1 ],B[ 2 ],B[ 3 ],…,B[ j ]的最长公共子序列（LCS）长度
• 初始化：初始 c[ 1 ][ 0 ]=c[ 0 ][ 1 ]=c[ 0 ][ 0 ]=0
  - 关键部分——转移方程：当A[ i ]=B[ j ]时，c[ i ][ j ]=c[ i-1 ][ j-1 ]+1，否则c[ i ][ j ]=max(c[ i-1 ][ j ],c[ i ][ j-1 ])
• 输出答案：c[ n ][ m ]
• 时间复杂度：O(nm)

代码

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

int n,m,ans1,ans2;
int A[5100],B[5100];
int f[5100],c[5100][5100];

int main() {
	cin>>n>>m;
	for(int i=1;i<=n;++i)
		cin>>A[i];
	for(int i=1;i<=m;++i)
		cin>>B[i];
	
	//LIS
	f[1]=1;
	for(int i=2;i<=n;++i) {
		int maxf=0;
		for(int j=1;j<i;++j) {
			if(A[j]<A[i]) 
				maxf= maxf<f[j]?f[j]:maxf;
		}
		f[i]=maxf+1;
	}
	for(int i=1;i<=n;++i)
		ans1= ans1<f[i]?f[i]:ans1;
		
	//LCS	
	c[1][0]=c[0][1]=c[0][0]=0;
	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]);
		}
	}
	ans2=c[n][m]; 
	
	cout<<ans1<<" "<<ans2<<endl;
	return 0; 
} 

C-拿数问题Ⅱ

题目描述

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

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

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

Input

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

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

Output

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

Example
Input
2
1 2
Output
2

Input
3
1 2 3
Output
4

Input
9
1 2 1 3 2 2 2 2 3
Output
10

Hint

对于第三个样例：先选任何一个值为2的元素，最后数组内剩下4个2。然后4次选择2，最终得到10分。

解题思路

首先要明确此题与课上讲的题的区别，课上是拿了A[ i ]那么A[ i-1 ]和A[ i+1 ]不可拿，这里是拿了x那么x+1和x-1,不可拿，但可拿重复的x,这里我们就可以看到区别，A[ i ]不存在拿多次的情况而x存在拿多次的情况，那么这里的转移方程该怎么写呢呢？

• 首先我们依旧要借鉴——dp[ i ]作为仅考虑A[ 1…i ]时，能拿到的最大分数，运用动态规划的思想。
• 其次令minn=A[ i ]中的最小值，maxn=A[ i ]中的最大值，对所有minn<=x<=maxn的数增加权值，若x在A[ i ]中出现过，则权值为出现的次数cnt[ x ]；若未出现过自然为0。
• 接下来就可以写出转换函数了：dp[ i ]=max(dp[ i-1 ]，dp[ i-2 ]+cnt[ i ]*i)。
• 再对所有x进行枚举，按转换函数计算各自的dp值，时间复杂度O(n)。

注意：1<=A[ i ],n<=10^5，因此dp数组应该开long long，否则会一直wa on test 12（别问我怎么知道的）

说明

原始代码解答：思路相同——三个连续值的取舍。
先将A[ n ]排序sort()，从前向后拿数，dp[ i ]为排序后的序列在截止位置为i下的最大分数，temp为已拿数的最大值，pos为小于temp的最大值的最末位置，因为temp可能会被舍弃，而当前决策与小于temp的数无关，pos所指向位置的dp起决定temp取舍的作用，cnt为当前判定值在原序列中已出现的次数。

代码

更新：

#include<iostream>
#include<algorithm>

using namespace std;

const int maxn=1e5+10;
long long n,minn=maxn,maxx=0;
long long a[maxn],cnt[maxn],dp[maxn];

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++) {
		cin>>a[i];
		minn=min(minn,a[i]);
		maxx=max(maxx,a[i]);
		cnt[a[i]]++;
	}
	dp[minn]=minn*cnt[minn];
	for(long long i=minn;i<=maxx;i++) 
		dp[i]=max(dp[i-1],dp[i-2]+cnt[i]*i);
	cout<<dp[maxx];
	return 0;
}

原始：

#include<iostream>
#include<algorithm>

using namespace std;

const int maxn=1e5+10;
long long n,a[maxn];
long long dp[maxn];

int main() {
	cin>>n;
	for(int i=1;i<=n;++i) 
		cin>>a[i];
	sort(a+1,a+1+n);
	dp[0]=0,dp[1]=a[1];
	int temp=a[1],pos=0,cnt=0;
	for(int i=2;i<=n;++i) {
		if(a[i]==temp) dp[i]=dp[i-1]+a[i];
		else if(a[i]==temp+1) {
			++cnt;
			if(dp[pos]+cnt*a[i]>dp[i-1]) {//可更新
				dp[i]=dp[pos]+cnt*a[i];
				temp=a[i];
				pos=i-cnt;
				cnt=0;
			}else dp[i]=dp[i-1];
		}
		else if(a[i]>temp+1) {
			dp[i]=dp[i-1]+a[i];
			temp=a[i];
			pos=i-1;
			cnt=0;
		}
	}
	cout<<dp[n]<<endl;
	return 0;	
}