程序设计思维与实践 Week10 作业 (3/4/数据班)

1、热身题

在一开始他有一个数字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

思路１：首先将ｎ分别乘以２和３的到两个数，再将得到的两个数分别乘以２和３得到四个数．．．．．．一直进行下去直到得到ｍ或得到的数大于ｍ输出－１.这似乎是一个最直观的方法，但实现时却发现对产生的数是指数级增长的，非常不好处理。
　　思路２：这次从ｍ开始，考虑从ｍ变为ｎ：创建一个队列并将ｍ放入，接下来我们进行的操作为：每次从队列中取出一个数，判断这个数是否能被2或3整除并且整除后的结果是否大于n，若都满足的话就将整除后的结果加入队列。重复上述过程直到取到n或队列为空。这种方法更加便于实现与理解。

#include <iostream>
#include <cmath>
#include <queue>
using namespace std;
struct s{
	long long a;
	int i;    //记录是第几次操作
};
const long long inf=1e9;
long long n,m;
queue<s> g;

int main(){
	cin>>n>>m;
	g.push({m,0});
	int i=0,p=1;
	s x;
	while(!g.empty()){
		x=g.front();
		g.pop();
		if(x.a==n){
			cout<<x.i<<endl;
			p=0;
			break;
		}
		if(x.a%2==0&&x.a/2>=n) g.push({x.a/2,x.i+1});
		if(x.a%3==0&&x.a/3>=n) g.push({x.a/3,x.i+1});
	}
	if(p==1) cout<<-1<<endl; 
	return 0;
} 

2、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

ＬＩＳ：
思路：建立数组ａ[n]来储存输入的数据，建立数组lis[n],lis[i]表示1-i的最长lis的长度，这样，初始化lis[1]=1，对于lis[i],遍历所有的lis[x] x<i，选出满足a[i]>a[x]的最大lis[x]并更新lis[i]=lis[x]+1，最后选出最大lis[i]的值即为所需要的结果。
LCS：
思路：建立数组a[n]、ｂ[n]储存数据，建立数组lcs[n][m],lcs[x][y]表示a[1]…a[x]与b[1]…b[y]的最长lcs长度。
初始化lcs[1][0]=lcs[0][1]=lcs[0][0]=0，对于lcs[x][y],若a[x]=b[y]则更新lcs[x][y]=lcs[x-1][y-1]+1,若不相等，则在lcs[x-1][y],lcs[x][y-1]中取较大者，最后取lcs[m][n]即为结果。
在这题中要注意取数的范围超过了int，所以要选用long long

#include <iostream>
#include <algorithm>
using namespace std;
long long a[10000],b[10000];
int n,m,lis[5010],lcs[5100][5100]; 
int LIS(){
	lis[1]=1;
	int Max,M=1;
	for(int i=2;i<=n;i++){
		Max=0;
		for(int l=1;l<i;l++){
			if(a[i]>a[l]) Max=max(Max,lis[l]);
		}
		lis[i]=Max+1;
		M=max(M,lis[i]);
	}
	return M;
}
int LCS(){
	lcs[1][0]=lcs[0][1]=lcs[0][0]=0;
	for(int i=1;i<=n;i++){
		for(int l=1;l<=m;l++){
			if(a[i]==b[l]) lcs[i][l]=lcs[i-1][l-1]+1;
			else{
				lcs[i][l]=max(lcs[i-1][l],lcs[i][l-1]);
			}
		}
	}
	return lcs[n][m];
}
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];
	cout<<LIS()<<" "<<LCS()<<endl;
	return 0;
} 

3、拿数问题

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
思路：我们首先来看原来的拿数问题：
给 n 个数，每一步能拿走一个数，比如拿第 i 个数，Ai = x，得到相应的分数 x，但拿掉这个 Ai 后，Ai+1 和Ai-1 就会变得不可拿。求最大分数。
这题的解决办法为建立数组dp[n]，其中dp[i]表示A[1…i]能拿到的最大分数。
dp[i]的更新规则为dp[i] = max(dp[i-1], dp[i-2]+A[i]) 。
回到这道题目上来，这道问题关键在于ｘ＋１与ｘ－１的分布是不可预知的，所以我们是否能将之转化为原取数问题来解决：
建立一个数组ａ[n]，a[i]表示数据i在数组中出现的次数，此时若取a[i]，则不可取的值变为了a[i-1]与a[i+1]此时似乎与原取数问题差别不大了，同样建立数组dp[i],定义与原问题相同，只不过更新规则变为dp[i]=max(dp[i-1],dp[i-2]+i*a[i])，最后取最大dp[i]即可解决问题。

#include <iostream>
#include <algorithm>
using namespace std;
const int inf=1e5+100;
int n;
long long a[inf],f[inf],Max;

long long ans(){
	f[0]=0;
	f[1]=a[1];
	long long m=f[1];
	for(long long i=2;i<=Max;i++){
		f[i]=max(f[i-1],f[i-2]+i*a[i]);
		m=max(m,f[i]);
	}
	return m;
}
int main(){
	cin>>n;
	long long x;
	fill(a,a+inf,0);
	Max=0;
	for(int i=1;i<=n;i++){
		cin>>x;
		Max=max(Max,x);
		a[x]++;
	}
	cout<<ans()<<endl;
	
	return 0;
}