CSP-WEEK13基础题好玩的思维题和线性DP-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43942251/article/details/106181978

本文介绍了CSP-Week13的三道题目，包括分割数问题、寻找无法被整除的数以及线性DP的捡猫咪游戏。通过动态规划方法解决，讲解了思路和实现代码，涉及SPJ、线性搜索和滚动数组优化等概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

CSP-Week13 思维计算题和线性DP

T1 分割数

这一天，TT 遇到了一个神秘人。
神秘人给了两个数字，分别表示 n 和 k，并要求 TT 给出 k 个奇偶性相同的正整数，使得其和等于 n。
例如 n = 10，k = 3，答案可以为 [4 2 4]。
TT 觉得这个任务太简单了，不愿意做，你能帮他完成吗？

本题是SPJ

INPUT和输入样例

第一行一个整数 T，表示数据组数，不超过 1000。
之后 T 行，每一行给出两个正整数，分别表示 n（1 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 100）。

输入样例：

8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9

OUTPUT和输出样例

如果存在这样 k 个数字，则第一行输出 “YES”，第二行输出 k 个数字。
如果不存在，则输出 “NO”。

YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120

思路概述

看到SPJ松了口气，因为是SPJ的缘故所以并不需要做什么复杂的算法操作，找出唯一的一种不合法情况就可以轻松完成求解：使用偶数个数字拼成一个奇数不可能实现

实现代码

#include<iostream>
#include<stdio.h>

using namespace std;

int data_group=0;
long long adder=0;
int part_num=0;

int main()
{
    scanf("%d",&data_group);
    for(int i=0;i<data_group;i++)
    {
    	adder=0;
    	part_num=0;
        scanf("%lld %d",&adder,&part_num);
        if(adder<part_num)
        {
            printf("NO\n");
        }
        else
        {
            if(adder%2==1)//要拆的数是奇数
            {
                if(part_num%2==1)//拆成奇数个
                {
                    printf("YES\n");
                    for(int i=0;i<part_num-1;i++)
                    {
                        printf("1 ");
                        adder--;
                    }
                    printf("%d\n",adder);
                }
                else//拆成偶数个
                {
                    printf("NO\n");
                }
            }
            else//要拆的数是偶数
            {
            	
                if(part_num%2==1)//拆成奇数个
                {
                	if(adder<part_num*2)
                	{
                		printf("NO\n");
					}
					else
					{
						printf("YES\n");
	                    for(int i=0;i<part_num-1;i++)
	                    {
	                        printf("2 ");
	                        adder-=2;
	                    }
	                    printf("%d\n",adder);
					}
                }
                else//拆成偶数个
                {
                    printf("YES\n");
                    for(int i=0;i<part_num-1;i++)
                    {
                        printf("1 ");
                        adder--;
                    }
                    printf("%d\n",adder);
                }
            }
        }
    }
    return 0;
}

T2 有趣的计算题

在你们的帮助下，TT 轻松地完成了上一个神秘任务。
但是令人没有想到的是，几天后，TT 再次遇到了那个神秘人。
而这一次，神秘人决定加大难度，并许诺 TT，如果能够完成便给他一个奖励。
任务依旧只给了两个数字，分别表示 n 和 k，不过这一次是要求 TT 给出无法被 n 整除的第 k 大的正整数。

例如 n = 3，k = 7，则前 7 个无法被 n 整除的正整数为 [1 2 4 5 7 8 10]，答案为 10。

INPUT和输入样例

第一行一个整数 T，表示数据组数，不超过 1000。
之后 T 行，每一行给出两个正整数，分别表示 n（2 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 1e9）。

输入样例：

6
3 7
4 12
2 1000000000
7 97
1000000000 1000000000
2 1

OUTPUT和输出样例

对于每一组数据，输出无法被 n 整除的第 k 大的正整数。

输出样例：

思路概述

赌的思路
一开始没有想太多，直接O（n）复杂度的算法，遍历直到找出目标值。结果果然TLE了，虽然说我有赌的成分，但是要注意的是，比赛中很多简单题会在思维习惯上挖坑，让你走入思维的误区导致丢分。
冷静思考了一会发现，这道题目其实是一道手推公式题，因为给定固定的数字之后，数字整数倍的位置其实是固定的—一定是那些数可以被整除。
由此可以列出表达式：
无法被整除第k大的正整数M=M之前能够被整除的数 j 个+M之前不能被整除的数 k 个
如果使用 n 表示题目中的数字n，则公式如下：
M=M/n（整除）+k
公式经过化简推导，注意整除的余数和商的关系，就可以求得正解

实现代码

#include<iostream>
#include<stdio.h>
using namespace std;

int data_group=0;
long long diviser=0;
long long num=0;


int main()
{
    scanf("%d",&data_group);
    for(int i=0;i<data_group;i++)
    {
        scanf("%d %lld",&diviser,&num);
        long long apart=(diviser*num)%(diviser-1);
    	if(apart==0)
		num=(diviser*num-diviser+1)/(diviser-1);
		else 
		num=(diviser*num-apart)/(diviser-1);
		printf("%lld\n",num);	
    }
    return 0;
}

T3-线性DP

在大家不辞辛劳的帮助下，TT 顺利地完成了所有的神秘任务。
神秘人很高兴，决定给 TT 一个奖励，即白日做梦之捡猫咪游戏。
捡猫咪游戏是这样的，猫咪从天上往下掉，且只会掉在 [0, 10] 范围内。
TT 初始站在位置五上，且每秒只能在移动不超过一米的范围内接住掉落的猫咪，如果没有接住，猫咪就会跑掉。例如，在刚开始的一秒内，TT 只能接到四、五、六这三个位置其中一个位置的猫咪。
喜爱猫咪的 TT 想要接住尽可能多的猫咪，你能帮帮他吗？

INPUT及输入样例

多组样例。每组样例输入一个 m (0 < m < 100000)，表示有 m 只猫咪。
在接下来的 m 行中，每行有两个整数 a b (0 < b < 100000)，表示在第 b 秒的时候有一只猫咪掉落在 a 点上。
注意，同一个点上同一秒可能掉落多只猫咪。m = 0 时输入结束。
输出样例：

OUTPUT 及输出样例

输出一个整数 x，表示 TT 可能接住的最多的猫咪数。

思路概述

题目是一道典型的DP题目，要注意到的是，某个位置一个时间点可能会有多个得分，且这些得分均有效，因此在进行输入时，可以使用一个二维数组A[i][j],在 i 秒 j 位置上的得分。
预处理了上面的情况，题目基本可以理解为一个线性DP，使用dp[i][j],表示在 i 位置上，到 j 时间为止的最大得分。
则可以写出状态转移方程：
i=0时，dp[i][j]=max(dp[i][j-1],dp[i+1][j-1])+a[i][j]
i=10时, dp[i][j]=max(dp[i][j-1],dp[i-1][j-1])+a[i][j]
0<i<10时, dp[i][j]=max(dp[i][j-1],dp[i-1][j-1],dp[i+1][j-1])+a[i][j]
最终结果即为max{dp[i][t]}
但是这种设计显然并非最优，可以看到的是，在进行更新时，更新第 j 维的操作使用的数据均为 j-1 维，因此可以使用滚动数组进行优化，将dp数组变为一维，达到最优的空间复杂度。

题目代码

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int M = 1e5 + 5;
int a[M][11];
int dp[11][2];
int cat_num = 0;
int time_max = 0;
int cat_time;
int cat_pos;
int last = 0;
int know = 0;
int ans1 = 0;

int main()
{
	scanf("%d", &cat_num);
	while (cat_num != 0)
	{
		for (int i = 0; i < M; i++)
			for (int j = 0; j <= 10; j++)
				a[i][j] = 0;
		time_max=0;
		ans1=0;
		for (int i = 0; i < cat_num; i++)
		{
			scanf("%d %d", &cat_pos, &cat_time);
			time_max = max(time_max, cat_time);
			a[cat_time][cat_pos]++;
		}
		for (int i = 0; i <= 10; i++)
			for (int j = 0; j <= 1; j++)
				dp[i][j] = 0;
		last = 0;
		know = 1;
		int ans = 0;
		for (int i = 0; i <= time_max; i++)
		{
			if (i < 5)
			{
				for (int j = 5 - i; j <= 5 + i; j++)
				{
					ans1= max(dp[j][last], dp[j - 1][last]);
					dp[j][know] = max(ans1, dp[j + 1][last]) + a[i][j];
					ans=max(ans,dp[j][know]);
				}
			}
			else
			{
				for (int j = 0; j <= 10; j++)
				{
					if (j == 0)
					{
						dp[j][know] = max(dp[j][last], dp[j + 1][last]) + a[i][j];
					}
					else if (j == 10)
					{
						dp[j][know] = max(dp[j][last], dp[j - 1][last]) + a[i][j];
					}
					else
					{
						ans1 = max(dp[j][last], dp[j - 1][last]);
						dp[j][know] = max(ans1, dp[j + 1][last]) + a[i][j];
					}
					ans=max(ans,dp[j][know]);
				}
			}
			last = 1 - last;
			know = 1 - know;
		}
		printf("%d\n", ans);
		scanf("%d", &cat_num);
	}
	return 0;
}