蓝桥杯倒计时 | 倒计时16天

让机器理解语言か

已于 2023-03-24 00:05:18 修改

分类专栏：【蓝桥杯Python】考前冲刺文章标签：算法蓝桥杯

于 2023-03-23 22:45:14 首次发布

本文链接：https://blog.csdn.net/m0_69478345/article/details/129739268

版权

【蓝桥杯Python】考前冲刺专栏收录该内容

10 篇文章 9 订阅

订阅专栏

作者🕵️‍♂️：让机器理解语言か

专栏🎇：蓝桥杯倒计时冲刺

描述🎨：蓝桥杯冲刺阶段，一定要沉住气，一步一个脚印，胜利就在前方！

寄语💓：🐾没有白走的路，每一步都算数！🐾

问题一：开心的金明

题目描述

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间他自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过 N 元钱就行”。今天一早金明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的 N 元。于是，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是整数元）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第j件物品的价格为 v[j]，重要度为 w[j]，共选中了 k 件物品，编号依次为 j1，j2，⋯，jk，则所求的总和为：

v[j1]×w[j1]+v[j2]×w[j2]+⋯+v[jk]×w[jk]。

请你帮助金明设计一个满足要求的购物单。

输入描述

输入的第一行包含两个整数 N,m，（其中 N（<30000）表示总钱数，m（<25）为希望购买物品的个数）。从第 2 行到第 m+1 行，第 j 行给出了编号为 j−1 的物品的基本数据，每行有 2 个非负整数 v，p，（其中 v 表示该物品的价格(v≤ $10^4$ )，p 表示该物品的重要度( 1 ~ 5 )）

输出描述

输出一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（< $10^8$ ）。

输入输出样例

示例 1

输入
1000 5
800 2
400 5
300 5
400 3
200 2
输出
3900

【思路】

一道0/1背包的模板题，对这个知识点不是很熟悉的同学可以看一下我这篇文章：算法第十四期——动态规划（DP）初入门

【代码】

不滚动

N, m = map(int, input().split())
dp = [[0] * (N + 1) for _ in range(m + 1)]

v = [0] * (m + 1); p = [0] * (m + 1)
for i in range(1, m + 1):
    v[i], p[i] = map(int, input().split())
for i in range(1, m + 1):
    for j in range(0, N + 1):
        if j < v[i]:
            dp[i][j] = dp[i - 1][j]
        else:
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + v[i] * p[i])
print(dp[m][N])

交替滚动

N, m = map(int, input().split())
dp = [[0] * (N + 1) for _ in range(2)]

v = [0] * (m + 1); p = [0] * (m + 1)
for i in range(1, m + 1):
    v[i], p[i] = map(int, input().split())

now, old = 0, 1
for i in range(1, m + 1):
    now, old = old, now
    for j in range(0, N + 1):
        if j < v[i]:
            dp[now][j] = dp[old][j]
        else:
            dp[now][j] = max(dp[old][j], dp[old][j - v[i]] + v[i] * p[i])
print(dp[now][N])

自我滚动

N, m = map(int, input().split())
dp = [0] * (N + 1)

v = [0] * (m + 1); p = [0] * (m + 1)
for i in range(1, m + 1):
    v[i], p[i] = map(int, input().split())

for i in range(1, m + 1):
    for j in range(N, v[i] - 1, -1):
            dp[j] = max(dp[j], dp[j - v[i]] + v[i] * p[i])
print(dp[N])

题目二：积木画

问题描述

小明最近迷上了积木画, 有这么两种类型的积木, 分别为 I 型（大小为 2 个单位面积) 和 L 型 (大小为 3 个单位面积):

同时, 小明有一块面积大小为 2×N 的画布, 画布由 2×N 个 1×1 区域构成。小明需要用以上两种积木将画布拼满, 他想知道总共有多少种不同的方式? 积木可以任意旋转, 且画布的方向固定。

输入格式

输入一个整数 N，表示画布大小。

输出格式

输出一个整数表示答案。由于答案可能很大，所以输出其对 1000000007 取模后的值。

样例输入
3
样例输出
5
样例说明

五种情况如下图所示，颜色只是为了标识不同的积木：

评测用例规模与约定

对于所有测试用例，1≤N≤10000000.

【思路】

dp[i][j]：前i-1个位置铺满的情况下，第i个位置的第j个状态的情况数

在位置i的4个状态下，铺满位置i，位置i+1的可能出现的状态如下：

从第i列到第i+1列的转移表：

【代码】

Python3（非滚动数组实现）(TLE)

n = int(input())
MOD = int(1e9) + 7
g = [[1, 1, 1, 1], [0, 0, 1, 1], [0, 1, 0, 1], [1, 0, 0, 0]]
dp = [[0] * 4 for _ in range(n + 10)]

dp[1][0] = 1
for i in range(1, n + 1):
    for j in range(4):        # 第i列的状态j
        for k in range(4):    # 第j列的状态k
            if g[j][k] == 1:  # 第i列的状态j可以转移第j列的状态k
                dp[i + 1][k] = (dp[i + 1][k] + dp[i][j]) % MOD
print(dp[n + 1][0])

C++ (滚动数组实现) (AC)

#include <iostream>
#include <string.h>
using namespace std;
const int N = 1e7 + 10, MOD = 1e9 + 7;
int dp[2][4];
int g[4][4] = {{1, 1, 1, 1}, {0, 0, 1, 1}, {0, 1, 0, 1}, {1, 0, 0, 0}};
int main()
{
    int n; cin >> n;
    int old = 0, now = 1;
    dp[now][0] = 1;
    for (int i = 1; i <= n; i++) {
        swap(now, old);
        memset(dp[now], 0 ,sizeof(dp[now]));
        for (int j = 0; j < 4; j++) {
            for (int k = 0; k < 4; k++ ) {
                dp[now][k] = (dp[now][k] + dp[old][j] * g[j][k]) % MOD;
            }
        }
    }
    cout << dp[now][0];
    return 0;
}