CCF 202006-4 1246

最新推荐文章于 2024-03-06 21:35:21 发布
最新推荐文章于 2024-03-06 21:35:21 发布
阅读量236 收藏 3
点赞数 3
分类专栏： CCF CSP ACM # 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45919985/article/details/108101627
版权
ACM 同时被 3 个专栏收录
124 篇文章 2 订阅
订阅专栏
CCF CSP
28 篇文章 0 订阅
订阅专栏
动态规划
8 篇文章 0 订阅
订阅专栏

在这里插入图片描述
在这里插入图片描述

通过观察可以发现两位数的组合是有限的,所以两位数可以如同一位数一样写出dp方程:

		dp[i + 1][6] = dp[i][6] + dp[i][4];
		dp[i + 1][4] = dp[i][2] + dp[i][6];
		dp[i + 1][2] = dp[i][1];
		dp[i + 1][1] = dp[i][4];
		dp[i + 1][61] = dp[i][44];
		dp[i + 1][62] = dp[i][41];
		dp[i + 1][64] = dp[i][6] + dp[i][42];
		dp[i + 1][66] = dp[i][46];
		dp[i + 1][41] = dp[i][64];
		dp[i + 1][42] = dp[i][61];
		dp[i + 1][44] = dp[i][62];
		dp[i + 1][46] = dp[i][26] + dp[i][66];
		dp[i + 1][26] = dp[i][16];
		dp[i + 1][16] = dp[i][4];

为了节省内存,我们需要对这14个数进行编号:

id1234567891011121314
val126246166466414244462616

替换之后的dp方程:

		dp[i + 1][6] = dp[i][6] + dp[i][4];
		dp[i + 1][4] = dp[i][2] + dp[i][6];
		dp[i + 1][2] = dp[i][1];
		dp[i + 1][1] = dp[i][4];
		dp[i + 1][5] = dp[i][11];
		dp[i + 1][3] = dp[i][9];
		dp[i + 1][7] = dp[i][6] + dp[i][10];
		dp[i + 1][8] = dp[i][12];
		dp[i + 1][9] = dp[i][7];
		dp[i + 1][10] = dp[i][5];
		dp[i + 1][11] = dp[i][3];
		dp[i + 1][12] = dp[i][13] + dp[i][8];
		dp[i + 1][13] = dp[i][14];
		dp[i + 1][14] = dp[i][4];

然后就有了52分的版本:

#include <iostream>
#include <stdio.h>
#include <map>
#define ll long long
using namespace std;
ll dp[500005][16];
const int mod = 998244353;
map<string, int>mp;
int main() {
    mp["1"] = 1; mp["2"] = 2; mp["4"] = 4; mp["6"] = 6;
    mp["16"] = 14; mp["26"] = 13; mp["41"] = 9; mp["42"] = 10; mp["44"] = 11;
    mp["46"] = 12; mp["61"] = 5; mp["62"] = 3; mp["64"] = 7; mp["66"] = 8;
    int n;
    cin >> n;
    dp[1][2] = 1;
    for (int i = 1; i < n; i++) {
        dp[i + 1][6] = dp[i][6] + dp[i][4];
        dp[i + 1][4] = dp[i][2] + dp[i][6];
        dp[i + 1][2] = dp[i][1];
        dp[i + 1][1] = dp[i][4];
        dp[i + 1][5] = dp[i][11];
        dp[i + 1][3] = dp[i][9];
        dp[i + 1][7] = dp[i][6] + dp[i][10];
        dp[i + 1][8] = dp[i][12];
        dp[i + 1][9] = dp[i][7];
        dp[i + 1][10] = dp[i][5];
        dp[i + 1][11] = dp[i][3];
        dp[i + 1][12] = dp[i][13] + dp[i][8];
        dp[i + 1][13] = dp[i][14];
        dp[i + 1][14] = dp[i][4];
        for (int j = 1; j <= 14; j++)
            dp[i + 1][j] %= mod;
    }
    string s;
    cin >> s;
    int idx = mp[s];
    cout << dp[n][idx] << endl;
}

因为数据量到了1e9,所以需要用到矩阵来进行优化:
(矩阵行为dp[i+1],列为dp[i],可用矩阵乘法自己算一下)
矩阵一定要写对,不然debug时会疯掉!!!

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

之后我们就得到了96分的代码:

#include <cstring>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include <unordered_map>
#define LL long long
using namespace std;
const int mod = 998244353;
unordered_map<string, int>mp;
void mul(LL c[][14], LL a[][14], LL b[][14]) {
	static LL tmp[14][14];
	memset(tmp, 0, sizeof tmp);
	for (int i = 0; i < 14; ++i)
		for (int j = 0; j < 14; ++j)
			for (int k = 0; k < 14; ++k)
				tmp[i][j] = (tmp[i][j] + a[i][k] * b[k][j]) % mod;
	memcpy(c, tmp, sizeof tmp);
}
int qmi(string s, int n) {
	if (n < 0) return 0;
	LL f[14][14] = { 1 };
	LL a[14][14] =
	{
		0,1,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,1,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,1,0,0,0,
		1,0,0,0,0,1,0,0,0,0,0,0,0,1,
		0,0,0,0,0,0,0,0,0,1,0,0,0,0,
		0,0,0,1,0,1,1,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,1,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,1,0,0,
		0,0,1,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,1,0,0,0,0,0,0,0,
		0,0,0,0,1,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,1,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,1,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,1,0
	};
	while (n) {
		if (n & 1)  mul(f, f, a);
		mul(a, a, a);
		n >>= 1;
	}
	return (int)f[0][mp[s]-1];
}
int main() {
	mp["1"] = 1; mp["2"] = 2; mp["4"] = 4; mp["6"] = 6;
	mp["16"] = 14; mp["26"] = 13; mp["41"] = 9; mp["42"] = 10; mp["44"] = 11;
	mp["46"] = 12; mp["61"] = 5; mp["62"] = 3; mp["64"] = 7; mp["66"] = 8;
	int n, ans;
	string s;
	cin >> n >> s;
	if (s.size() == 1 || s.size() == 2) ans = qmi(s, n) % mod;
	cout << ans;
	return 0;
}

由于最后一个测试数据s的取值范围在1e5 ,所以我们进行回溯
任何一段数字最后都能回溯成两位数或一位数
例如 : 6264(n) : 因为初始字段(2,4,16,64)没有以62开头的,所以我们要在前面添上1,变成16264,而16264向上一层回溯的结果为416(n-1),在向上一层回溯结果为24(n-2),变成两位数即可利用上边的思路进行求解.
而464则会有两种回溯策略,一为直接回溯为26(n-1),二为在首位添加6,变成6464,回溯为66(n-1),而最终结果就为<n-1,26>&<n-1,66>两种查找结果之和,所以利用bfs的思路进行求解.

最后,满分代码(本蒟蒻哭了,):

#include <cstring>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include <unordered_map>
#define LL long long
using namespace std;
const int mod = 998244353;
unordered_map<string, int>mp;
#define TLE ios::sync_with_stdio(0),cin.tie(0)
const int INF = 0x3f3f3f3f;
pair<string, int> q[1000005]; int ans = 0;
void mul(LL c[][14], LL a[][14], LL b[][14]) { //矩阵乘法
	static LL tmp[14][14];
	memset(tmp, 0, sizeof tmp);
	for (int i = 0; i < 14; ++i)
		for (int j = 0; j < 14; ++j)
			for (int k = 0; k < 14; ++k)
				tmp[i][j] = (tmp[i][j] + a[i][k] * b[k][j]) % mod;
	memcpy(c, tmp, sizeof tmp);
}
int qmi(string s, int n) {
	if (n < 0) return 0;
	LL f[14][14] = { 1 };
	LL a[14][14] =
	{
		0,1,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,1,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,1,0,0,0,
		1,0,0,0,0,1,0,0,0,0,0,0,0,1,
		0,0,0,0,0,0,0,0,0,1,0,0,0,0,
		0,0,0,1,0,1,1,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,1,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,1,0,0,
		0,0,1,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,1,0,0,0,0,0,0,0,
		0,0,0,0,1,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,1,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,1,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,1,0
	};
	while (n) { //快速幂
		if (n & 1)  mul(f, f, a);
		mul(a, a, a);
		n >>= 1;
	}
	return (int)f[0][mp[s] - 1];
}
string  backtrack(string ch) { //回溯
	string upper = "";
	for (int i = 0; i < ch.size(); ++i) {
		if (ch[i] == '2') upper += '1';
		else if (ch[i] == '1' && (i == ch.size() - 1 || ch[i + 1] == '6')) upper += '4', i++;
		else if (ch[i] == '6' && (i == ch.size() - 1 || ch[i + 1] == '4')) upper += '6', i++;
		else if (ch[i] == '4') upper += '2';
		else return "";
	}
	return upper;
}
void bfs(string start, int n) {
	int step = 0, t = 0;
	q[t] = { start, n };
	while (step <= t) {
		pair<string, int> u = q[step++];
		string s = u.first;
		int depth = u.second;
		if (s == "" || depth < 0) continue;
		if (s.size() == 1 || s.size() == 2) ans = (ans + qmi(s, depth)) % mod;
		else {
			q[++t] = {  backtrack(s),depth - 1 }; // 开头: 1 -> 4 ,6 -> 6, 4 -> 2, 2 -> 1 
			if (s[0] == '4') q[++t] = {  backtrack("6" + s), depth - 1 }; // 开头: 4 -> 6
			else if (s[0] == '6') q[++t] = {  backtrack("1" + s), depth - 1 }; //开头: 6 -> 4
		}
	}
}
int main() {
	TLE;
	mp["1"] = 1; mp["2"] = 2; mp["4"] = 4; mp["6"] = 6;
	mp["16"] = 14; mp["26"] = 13; mp["41"] = 9; mp["42"] = 10; mp["44"] = 11;
	mp["46"] = 12; mp["61"] = 5; mp["62"] = 3; mp["64"] = 7; mp["66"] = 8;
	int n;
	string s;
	cin >> n >> s;
	bfs(s, n);
	cout << ans << endl;
	return 0;
}
Spikeeee-
关注
专栏目录
CCF计算机软件能力认证试题练习：202006-1 线性分类器
WINGREZ‘S BLOG
07-25 9629
线性分类器 来源：CCF 标签： 参考资料： 相似题目： 题目 考虑一个简单的二分类问题——将二维平面上的点分为A 和B 两类。 训练数据包含 n 个点，其中第 i 个点（1 ≤ i ≤ n）可以表示为一个三元组 (xix_{i}xi​, yiy_{i}yi​, typeitype_{i}typei​)，即该点的横坐标、纵坐标和类别。 在二维平面上，任意一条直线可以表示为θ0+θ1x+θ2y=0θ_{0} + θ_{1}x + θ_{2}y = 0θ0​+θ1​x+θ2​y=0的形式，即由 θ0θ_{
CCF 202006-1 线性分类器（C++）
weixin_43597126的博客
08-04 887
202006-1 线性分类器 试题编号： 202006-1 试题名称： 线性分类器 时间限制： 1.0s 内存限制： 512.0MB 问题描述： 解题过程 通过直线方程，将每个点处于直线上方或是下方计算出来（处于直线同侧的点代入直线方程后得到结果同号）。然后对于每条直线，遍历按照位置排序后的每个点，如果处于同侧的点存在不同类型，则中止循环即可。 #include<iostream> #include<algorithm> #include<stdio.h> us
CSP 202006-4 1246
想买很多漂亮衣服但是买不起的博客
02-24 259
28分代码： #include <bits/stdc++.h> using namespace std; int n,s; const int MAX_NUM=10e8; map<int,string> cc; int main() { std::ios::sync_with_stdio(false); cin>>n>>s; stringstream stmp; stmp<<s; string ss=st
CCF 202006-4 1246(digits)
qq_43749262的博客
08-28 958
题记 这道题的关键点在于能看出来长度为1和2的字符串的组合是一定的，一共14种，自己可以推一下，有些是不存在的 #include <iostream> #include <map> #include <string> using namespace std; typedef long long LL; const int Maxn=5e5+10;//int数组一般开到5e5 const int mod=998244353; LL dp[Maxn][15]={0}...
第19次CCF计算机软件能力认证-第4题-202006-4 1246
m0_47879244的博客
10-31 210
代码取自 躺平的hhy写的文章 ![在这里插入图片描述](https://img-blog.csdnimg.cn/c9fc16bc2c0c428cb8e59c0245e3db94.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAY2bogIHmnqrmiYs=,size_20,color_FFFFFF,t_70,g_se,x_16 #include<iostream> #i
202006-4 1246Java
qq_45100518的博客
10-15 144
总结： 1、审题出错了，一直认为输入“9，26”，是在26上进行幂变换9次，其实一直是从1开始变换得。 2、一直纠结于26是数字还是字符串，可见它说是数串就一定是数串，输入时26并不打引号，从这说明不了是整数。 一、暴力法 仅得分32，但用到得一些技巧还是要总结一下。 1、String.valueOf();可以将字符，数字转化成字符串 2、包裹类型.valueOf();可以将字符串，其它数字，转化成包裹类型，精度高的都能转化成精度低的。 3、数字字符转数：可以先转化成字符串在转化成数 如 int a=In
CCF CSP 202006-4 1246 （100分详细题解，矩阵乘法+快速幂）
最新发布
jokerMingge的博客
03-06 617
同时考虑到题目给的s是一个部分数字串，故可能无法直接倒推回s=2，故s在整个序列的情况，可能分为s前面是1，s前面是6，或者s前面不是1或6， 因为4->16 6->64,都会产生两位，所以s的首个数字可能是16中的6，以及64中的6，由于s只是其中的一部分，所以我们要在前面补上1和6。s
CCF 202006-1 线性分类器 CCF 202006-2 稀疏向量
weixin_39096053的博客
01-15 530
CCF 202006-1 线性分类器 思路 代码实现 CCF 202006-2 稀疏向量 思路 代码实现
CCF CSP 202006-4 1246 Python 动态规划
weixin_43758603的博客
06-30 5356
#最后一个子任务还没做,做出来再补充 #官网出题之后再补上原题 简单描述下题目 #1246四个数字 #输入n(),S() #从1开始,对其进行迭代n次,对其每一位数字进行以2为底的幂运算 #比如 "246" -> "41664(4 16 64)"# #求在迭代n次之后,字符串S在长字符串中出现的次数 用例: 输入: 9 26 输出: 5 解释: 迭代第九次: "166416264641626446416166416264264641626446416" ..
CCF-CSP 202006-1 线性分类器 c语言（满分）
Song_yang_yu的博客
02-23 390
CCF-CSP 202006-1 线性分类器 c语言（满分）
202006-4 1246 c++ 96分（矩阵快速幂）
LarsGyonX的博客
03-08 524
在这位大佬的提示下学习了矩阵快速幂，然后写的。CCF_CSP认证2020年6月第四题1246(c++)_black cat@的博客-CSDN博客 矩阵快速幂模板及原理见：矩阵快速幂 原理 模板_LarsGyonX的博客-CSDN博客 O、题目详情 一、分析题目 前24个测试点 |S| 只有1、2位，因此归纳了以下几种经过一次变换可以得到的结果： 1<-4 2<-1 4<-2,6 6<-4,6 16<-4 26<-16 41<-64 42&lt..
【CSP】202006-4 1246 (digits) DP (64‘) 矩阵快速幂 (96‘)
恒治学
04-03 151
#include <iostream> #include <cstdio> #include <map> using namespace std; typedef long long ll; const int state = 14; const int mod = 998244353; //矩阵快速幂 struct mat{ ll m[state+1][state+1]; }unit, a; void init(){ for (int i = 1;
CCF202006-4 1246【矩阵快速幂】（100分题解链接）
海岛Blog
08-24 1402
试题编号： 202006-4 试题名称： 1246 时间限制： 1.0s 内存限制： 512.0MB 问题链接：CCF202006-4 1246 问题简述：（略） 问题分析：参考链接是100分 程序说明：（略） 参考链接： CCF CSP 202006-4 1246 (digits) 题记：（略） 100分的C++语言程序如下： ...
【CCF历年题题解】202006-4 1246【动态规划】
py今天刷题了吗
09-05 846
文章目录暴力法（26分）满分做法，看不懂选择放弃... 暴力法（26分） 参考地址 #include <iostream> #include <cstring> #include <algorithm> using namespace std; const int N = 1010 ,mod = 998244353; int n; string S; string s[N]; int main() { cin >> n >> S
202006-4 CCF CSP认证 1246(digits) 96分 动态规划
qq_41645482的博客
08-06 2871
这个代码并不能通过那个第25号花里胡哨样例，主要针对的是 |s| <= 2的数据。 主要呢我们发现啊，查询的数据可能是啥呢，首先我们考虑1位的（|s| == 1）的 那无非就 1，2，4，6 呗，这简单啊，明显可以dp解决，dp [n] [1-4] 第二维 1-4 分别代表4个数字 1 可以产生 2 2 可以产生4 3 可以产生 1 和 6 4 可以产生 6 和 4 睿智的读者已经心里写出来转移方程，提交，3...
CSP第19次 202006-4 1246 C语言答案
愿天堂没有 Time Limit Exceeded
12-08 574
CSP第24次 202006-4 1246 C语言4分答案 只拿了4分啊哈哈哈哈，对不起我是来搞笑的，等日后再更 #include <stdio.h> #include <string.h> char str[100000010]={0}; char s[1000010]={0}; long long out=0; int main() { long long i,j,n,value=1,len_s; scanf("%lld %s",&n,s);
CCF CSP202006-4 1246(c++动态规划)
计算机科学与技术专业学生的成长之路
07-27 3822
思路分析 算法：动态规划 发现每一次数字是有规律的： 规律式子：str_map[i] = str_map[i - 3] + str_map[i - 1].substr(str_map[i - 4].size()) + str_map[i - 2]; 如上图：用i表示行号; i = 1,str[1] = 2; i = 2,str[2]= 4; i = 3,str[3] = 16; i = 4,str[4] = str[1] + str[3].substr(str[0].size()) + str[2...
第 19 次 CCF CSP 认证 202006-4 1246（digits）
Running Snail
08-26 3444
方法一（暴力法：28分） 思路分析 肯定要先发现数字的规律： 我们以第8行为例，数字由三段构成 第一段绿色：是i-3的数字串 第二段蓝色：是i-1的去除前几位剩余的数字串，去除的位数等于i-4数字串的位数 第三段黄色：是i-2的数字串 str[i] = str[i - 3] + str[i - 1].substr(str[i - 4].size()) + str[i - 2]; 这样出现的限制主要在空间方面，内存不够储存数字串 代码 #include<iostream> #include&
CCF 202009-1 称检测点查询
Spike的秃头之路
10-11 1036
#include<bits/stdc++.h> #define TLE ios::sync_with_stdio(0),cin.tie(0) #define long long ll const int INF = 0x3f3f3f3f; const int maxn = 1005; using namespace std; struct Node{ int d,id; }node[maxn]; bool cmp(Node a,Node b){ if(a.d == b.d) return a
ccf201609-2
08-11
- *2* *3* [CCF-CSP 201609-2火车购票 详细思路及解题过程 满分题解](https://blog.csdn.net/m0_53641110/article/details/122932978)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值