程序设计作业week10 —— 动态规划

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 * (2^p) * (3^q) = m
m/n = (2^p) * (3^q)
首先要满足整除，如果不能整除一定转换不了；
然后不断用2和3除，记录计算次数，如果最后刚好除完等于1，则操作次数就等于计算次数。

完整代码

#include <iostream>
using namespace std;
int n, m, ans;
int main()
{
    cin>>n>>m;
    if(m%n != 0)
	{
        cout<<-1<<endl;
        return 0;
    }
    m /= n;
    while(m%2 == 0)
	{
        ans++;
        m /= 2;
    }
    while(m%3 == 0)
	{
        ans++;
        m /= 3;
    }
    if(m == 1)	cout<<ans<<endl;
    else	cout<<-1<<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 最长上升子序列
状态：定义 fi 表示以 Ai 为结尾的最长上升序列的方程。
初始化：f1 = 1
转移过程：
输出答案：max { f[i], i=1…n }
时间复杂度：O(n^2)

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)

注意：数据范围 用long long

完整代码

#include <iostream>
#include <string.h>
#include <cmath>
#include <algorithm>
using namespace std;
int n, m;
long long int a[5010], b[5010];
long long int f[5010], ff[5010][5010];
int LIS()
{
	long long int mm = -1;
	for(int i=1; i<=n; i++)
	{
		f[i] = 1;
		for(int j=1; j<i; j++)
		{
			if(a[j] < a[i])
			{
				f[i] = max(f[i], f[j]+1);	
				if(f[j] > mm)	mm = f[j];
			}
		}
		if(f[i] > mm)	mm = f[i];
	}
	return mm;
}
int LCS()
{
	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			if(a[i] == b[j])	ff[i][j] = ff[i-1][j-1] + 1;
			else	ff[i][j] = max(ff[i-1][j], ff[i][j-1]);  
	return ff[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;
}

C - 拿数问题 II

题目

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分。

解题思路

这题跟课上讲的略有不同，之前的题目是按数组顺序，所选数的前一个元素和后一个元素不可取，这个题目是按数值顺序，相邻数值大小的数不可取。

解法类似，只要按数值顺序计算就行。因为一个数字有多个时可以重复选，而要使和最大，所以通常选择一个数要乘以这个数的个数，即：sum[i]*i

其他的都差不多，f[i] = max(f[i-1], f[i-2] + sum[i]*i)

完整代码

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
long long n;
long long mi = 1000000, ma = -1;
long long a[100100], sum[100100], f[100100];
int main()
{
	cin>>n;
	memset(sum, 0, sizeof(sum));
	for(int i=1; i<=n; i++)
	{
		cin>>a[i];
		mi = min(mi,a[i]);
		ma = max(ma,a[i]);
		sum[a[i]]++;
	}
	f[mi] = mi * sum[mi];
	for(long long i=mi; i<=ma; i++) 
		f[i] = max(f[i-1], f[i-2] + sum[i]*i);
	cout<<f[ma];
	return 0;
}

总结
代码都很短，但是动态规划问题挺难思考，找到状态转移方程是最关键也是最难的一步，实现起来简单。

设计动态规划法的步骤：

1. 找出最优解的性质，并刻画其结构特征；
2. 递归地定义最优值（写出动态规划方程）；
3. 以自底向上（递推）或带备忘的自顶向下（记忆化搜索）的方式计算出最
   优值；
4. 根据计算最优值时得到的信息，构造一个最优解。