程序设计思维与实践 Week10 作业

yyyyyyyyo

于 2020-04-29 23:52:07 发布

阅读量132

点赞数

本文链接：https://blog.csdn.net/yyyyyyyyo/article/details/105773557

版权

文章目录

A 签到题

1.题目大意

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

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

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

样例：

2. 思路历程

要求出 n 乘以几个2或3可以转换成 m，可以先用m / n，再对商分解公因式。

若商不是整数，则肯定无法转换
若商是整数，再循环除以2和3
退出循环后，若商为1，则可以转换，若为0，则不能转换

（具体实现没有什么细节，就不记录辽）

3. 代码

#include <iostream>
using namespace std;

int n, m, res, cnt = 0;

int main()
{
    cin >> n >> m;
    if (m % n == 0)
    {
        res = m / n;
        while (!(res % 2))
        {
            res /= 2;
            cnt++;
        }
        while (!(res % 3))
        {
            res /= 3;
            cnt++;
        }
        if (res == 1) cout << cnt << endl;
        else cout << "-1" << endl;
    }
    else
        cout << "-1" << endl;
    return 0;
}

B LIS & LCS

1.题目大意

东东有两个序列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

3 2

2. 思路历程

引入动态规划的两个经典问题

最长上升子序列 LIS
1）给定n个整数a1, a2, … , an，按从左到右的顺序选出尽量多的整数，组成一个递增的子序列。
2）定义 f[i] 表示以 ai 为结尾的最长上升序列的方程，初始化f[1] = 1
f[i] 取决于 ai 前有多少个比 ai 小的数，因此可得到
3）转移过程：f[i] = max{ fj | j < i && aj < ai} + 1
4）LIS = max{ f[i], i = 1, 2, ..., n}
最长公共子序列 LCS
1）给定两个序列 a 和 b，按从左到右的顺序找到两个序列的公共部分，组成一个子序列。
2）定义 f[i][j] 为a1, a2, …, ai 和b1, b2, …, bj的LCS长度，初始化f[1][0] = f[0][1] = 0
对于公共的元素ai, bj，更新公共序列长度为 + 1，对于非公共元素，取之前的公共序列长度
3）转移过程：当 ai = bi 时，f[i][j] = f[i-1][j-1] + 1，否则f[i][j] = man{f[i-1][j], f[i][j-1]}
4）LCS = f[n][m]

3. 具体实现

数组f1[maxn] 和 f2[maxn][maxn]分别用来表示 LIS 和 LCS 的转移方程
遍历每对i, j(j < i)，当a[j] < a[i]时即可更新f1[i]。
（这里注意要在对某个 i 所有的 j 都考虑完后再更新 LIS 值，我刚开始在考虑每个 j 时都更新是错误的）
遍历每个 a[i] 和 b[j]，按照思路更新f2即可。

4. 代码

#include <iostream>
#include <string.h>
#include <algorithm>
using namespace std;
const int maxn = 5055;

int n, m, ans1 = 0, ans2 = 0;
int A[maxn], B[maxn], f1[maxn], f2[maxn][maxn];

int main()
{
    cin >> n >> m;
    memset(f1, 0, sizeof(f1));
    memset(f2, 0, sizeof(f2));
    
    for (int i = 0; i < n; i++)
    {
        cin >> A[i];
        f1[i] = 1;
    }
    for (int i = 0; i < m; i++) cin >> B[i];
    
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < i; j++)
        {
            if (A[j] < A[i])
                f1[i] = max(f1[i], f1[j] + 1);
        }
        ans1 = max(ans1, f1[i]);
    }
    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (A[i - 1] == B[j - 1])
                f2[i][j] = max(f2[i][j], f2[i - 1][j - 1] + 1);
            else
                f2[i][j] = max(f2[i][j - 1] , f2[i - 1][j]);
        }
    }
    ans2 = f2[n][m];
    
    cout << ans1 << " " << ans2;
    
    return 0;
}

C 拿数问题 II

1.题目大意

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

2. 思路历程

动态规划的另一个经典问题
dp[i] 表示仅考虑 a[1]~a[i] 时可以拿到的总数
对每个数 x 都有拿和不拿两种选择，不拿的话只考虑 dp[i-1] 的值，拿的话考虑dp[i-2] + 所有x的值，因此得出
转移过程：dp[i] = max{dp[i-1], dp[i-2] + i * cnt[i]}

3. 具体实现

记录每个 a[i] 出现的个数，用于拿x的时候更新总数。
遍历时也是根据 a[i] 的值而不是 i 进行遍历，cnt[i] 已经限制了拿的数的大小（若不存在 a[i] = x 那么 cnt[x] = 0），与n个数不是连续的不冲突
（这里刚开始逻辑有点不清晰）

4. 代码

#include <iostream>
#include <algorithm>
#include <string.h>
#include <cmath>
using namespace std;
const int maxn = 100011;

long long n, a[maxn], cnt[maxn], dp[maxn], maxdp;

int main()
{
    cin >> n;
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
        cnt[a[i]]++;
    }
    sort(a, a + n);
    for (long long i = a[0]; i <= a[n - 1]; i++)
    {
        dp[i] = max(dp[i - 1], dp[i - 2] + i * cnt[i]);
        maxdp = max(maxdp, dp[i]);
    }
    cout << maxdp << endl;
    return 0;
}