[动态规划]Exercise Week10 A+B+C

A.[模拟]Game23

题意

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

样例

样例输入：

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

120 51840

样例输出:

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

7

---

思路

1.先判断m能否整除n 即m%n==0 如果不能则肯定不能转化

2.如果能整除 则计算整除的结果 m=m/n 再对n反复除以 3 和 2 直到m变成1

3.如果m能自然跳出循环 则说明可以转化 此时输出次数tnt
否则说明m除了2 3以外还有别的因子 故n是不可能仅凭 *2 *3就转化为m的 故输出-1

---

总结

1.因为2 3是两个素数 没有公因子 故我们可以简单的分别判断 而不是用DP或其他有的没的

2.数据范围告诉我们要开long long

---

代码

#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
long long n,m;
int main()
{
    int tnt=0;
    cin>>n>>m;
    bool ok=1;
    
    if(m%n!=0)  ok=0;//转化不了
    else
    {
        m=m/n;
        while(m!=1)
        {
            if(m%3==0)  {tnt++;m=m/3;continue;}
            if(m%2==0)  {tnt++;m=m/2;continue;}
            ok=0;break;
        }
    }
    
    
    if(ok)  cout<<tnt<<endl;
    else cout<<"-1"<<endl;
    system("pause");
    return 0;
}

B.[DP]LIS & LCS

题意

给出两个数列 a 和 b
求a的LIS大小和ab的LCS大小

样例

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

样例输入：

 6 7
 1 5 2 6 8 7
 2 3 5 6 9 8 4

样例输出：

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

4 3

---

思路

1.对于求一个数列的LIS(最长上升子序列) 我们按照DP的四步走 分别对应如下:
状态:定义dp[i]为 以a[i]为结尾的LIS的长度
初始化: dp[i]=1 (每个a[i]都只以自己为一个序列)
转移过程:dp[i]=max(dp[i],dp[j]+1) j<i且 a[j]<a[i]时
输出答案:max(dp[i])

2.对于求两个序列的LCS 依旧是四步走:
状态:dp[i][j]表示A1 ~ Ai与B1 ~ Bj的LCS长度
初始化:dp[0][0]=dp[1][0]=dp[0][1]=0
转移方程:
当A[i]==B[j]时 dp[i][j]=dp[i-1][j-1]+1
否则 dp[i][j]=max(dp[i-1][j],dp[i][j-1)
输出答案:dp[n][m]

---

总结

比较基本的动态规划类型 需要再熟悉熟悉

---

代码

#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
#define MAXN 5010
using namespace std;
int n,m;
int ans1=0;
int a[MAXN],b[MAXN];
int LCS[MAXN][MAXN];
int LIS[MAXN];
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 dp[]定义为 以a[i]为结尾的LIS长度
    for(int i=1;i<=n;i++)   LIS[i]=1;//初始化时全为1
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<i;j++)    if(a[j]<a[i])   LIS[i]=max(LIS[i],LIS[j]+1);
        ans1=max(ans1,LIS[i]);
    }
    

    //LCS dp[i][j]定义为 A1~Ai 与 B1~Bj 的最长公共子序列
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(a[i]==b[j])  LCS[i][j]=LCS[i-1][j-1]+1;
            else LCS[i][j]=max(LCS[i-1][j],LCS[i][j-1]);
        }
    }
    cout<<ans1<<" "<<LCS[n][m]<<endl;
    system("pause");
    return 0;
}

C.[动态规划]拿数问题

题意

给一个序列，里边有 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)

9 
1 2 1 3 2 2 2 2 3

样例输出:

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

10

---

思路

1.类似于桶排序的思想 数组a[i]表示序列中数字i出现的次数 初始时为0 (由于1<=a<=10⁵ )

2.在DP时 类似于原版拿数的思想 只不过dp时我们是针对原始序列的数据范围进行dp
DP转移方程:
dp[i]=max(dp[i-1],dp[i-2]+a[i]*i);
前者为不取i这个数时 故可以从dp[i-1]转移过来
而后者为取这个数 故不能取dp[i-1] 而需要取dp[i-2]
同时 这样就解决了 取了x后不能取x-1 x+1的问题

---

总结

1.原版拿数的一个变式 注意在dp时需要从1到max(初始序列)

2.由于数据范围 故我们要开long long

---

代码

#include<iostream>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<stdio.h>
#define MAXN 100010
using namespace std;
long long a[MAXN],maxl;
long long dp[MAXN];
int n;
long long x;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&x);
        a[x]++;
        maxl=max(maxl,x);
    }

    //dp[i] 表示仅考虑1~i 这些数时 所能取到的最大总和
    dp[1]=a[1]*1;
    for(long long i=2;i<=maxl;i++)   dp[i]=max(dp[i-1],dp[i-2]+a[i]*i);
    cout<<dp[maxl];
    system("pause");
    return 0;
}