当前位置： 首页 > news >正文

【矩阵快速幂】P3702 [SDOI2017] 序列计数|省选-

news 来源：原创 2025/5/20 23:50:01

本文涉及知识点

【矩阵快速幂】封装类及测试用例及样例

P3702 [SDOI2017] 序列计数

题目描述

Alice 想要得到一个长度为 n n n 的序列，序列中的数都是不超过 m m m 的正整数，而且这 n n n 个数的和是 p p p 的倍数。

Alice 还希望，这 n n n 个数中，至少有一个数是质数。

Alice 想知道，有多少个序列满足她的要求。

输入格式

一行三个数， n , m , p n,m,p n,m,p。

输出格式

一行一个数，满足 Alice 的要求的序列数量，答案对 20170408 20170408 20170408 取模。

输入输出样例 #1

输入 #1

3 5 3

输出 #1

33

说明/提示

对 20 % 20\% 20% 的数据， 1 ≤ n , m ≤ 100 1\leq n,m\leq100 1≤n,m≤100。

对 50 % 50\% 50% 的数据， 1 ≤ m ≤ 100 1\leq m \leq 100 1≤m≤100。

对 80 % 80\% 80% 的数据， 1 ≤ m ≤ 1 0 6 1\leq m\leq 10^6 1≤m≤106。

对 100 % 100\% 100% 的数据， 1 ≤ n ≤ 1 0 9 , 1 ≤ m ≤ 2 × 1 0 7 , 1 ≤ p ≤ 100 1\leq n \leq 10^9,1\leq m \leq 2\times 10^7,1\leq p\leq 100 1≤n≤109,1≤m≤2×107,1≤p≤100。

P3702 矩阵指数幂

用静态变量记录[1,2e7]中所有元素是否是质数。注意：细节不好，可能超时。
通过i枚举1到M，如果i是质数cnt[i%P][1]++，如果不是质数cnt[i%p][0]++。

dp[n][p][j] 记录长度为n，和%P为p的方案数，j表示是否包括质数。
k= Pj+p ，dp降维为dp[n][k]。
pre=dp[n],cur=dp[n+1] ,pre × \times × mat=cur,求mat
第一层枚举k=0 to P 第二层枚举 k1 = 0 to P
k2 = (k+k1)%P
dp[k][k2] += cnt[k1][0]
dp[k][k2+P] += cnt[k1][1]
dp[k+P][k2+P] += cnt[k1][0] + cnt[k1][1]
初始化：pre[0]=1，其它全为0。
ans = prematn
ans[P…2P-1]之和便答案。
时间复杂度：O(ppplogn) 很可能超时。
解决方法：至少一个质数的方案=所有方案-不包括质数的方案。
所有方案的矩阵为mat1,包括质数的方案矩阵为mat2:
第一层枚举k=0 to P 第二层枚举 k1 = 0 to P
mat1[k][(k+k1)%P] += cnt[k1][0] +cnt[k1][1]
mat2[k][(k+k1)%P] += cnt[k1][0]

代码

核心代码

#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>
#include<list>
#include <array>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t);
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	scanf("%d", &n);
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<int N = 1'000'000>
class COutBuff
{
public:
	COutBuff() {
		m_p = puffer;
	}
	template<class T>
	void write(T x) {
		int num[28], sp = 0;
		if (x < 0)
			*m_p++ = '-', x = -x;

		if (!x)
			*m_p++ = 48;

		while (x)
			num[++sp] = x % 10, x /= 10;

		while (sp)
			*m_p++ = num[sp--] + 48;
		AuotToFile();
	}
	void writestr(const char* sz) {
		strcpy(m_p, sz);
		m_p += strlen(sz);
		AuotToFile();
	}
	inline void write(char ch)
	{
		*m_p++ = ch;
		AuotToFile();
	}
	inline void ToFile() {
		fwrite(puffer, 1, m_p - puffer, stdout);
		m_p = puffer;
	}
	~COutBuff() {
		ToFile();
	}
private:
	inline void AuotToFile() {
		if (m_p - puffer > N - 100) {
			ToFile();
		}
	}
	char  puffer[N], * m_p;
};

template<int N = 1'000'000>
class CInBuff
{
public:
	inline CInBuff() {}
	inline CInBuff<N>& operator>>(char& ch) {
		FileToBuf();
		ch = *S++;
		return *this;
	}
	inline CInBuff<N>& operator>>(int& val) {
		FileToBuf();
		int x(0), f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行		
		return *this;
	}
	inline CInBuff& operator>>(long long& val) {
		FileToBuf();
		long long x(0); int f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		val = f ? -x : x; S++;//忽略空格换行
		return *this;
	}
	template<class T1, class T2>
	inline CInBuff& operator>>(pair<T1, T2>& val) {
		*this >> val.first >> val.second;
		return *this;
	}
	template<class T1, class T2, class T3>
	inline CInBuff& operator>>(tuple<T1, T2, T3>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val);
		return *this;
	}
	template<class T1, class T2, class T3, class T4>
	inline CInBuff& operator>>(tuple<T1, T2, T3, T4>& val) {
		*this >> get<0>(val) >> get<1>(val) >> get<2>(val) >> get<3>(val);
		return *this;
	}
	template<class T = int>
	inline CInBuff& operator>>(vector<T>& val) {
		int n;
		*this >> n;
		val.resize(n);
		for (int i = 0; i < n; i++) {
			*this >> val[i];
		}
		return *this;
	}
	template<class T = int>
	vector<T> Read(int n) {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) {
			*this >> ret[i];
		}
		return ret;
	}
	template<class T = int>
	vector<T> Read() {
		vector<T> ret;
		*this >> ret;
		return ret;
	}
private:
	inline void FileToBuf() {
		const int canRead = m_iWritePos - (S - buffer);
		if (canRead >= 100) { return; }
		if (m_bFinish) { return; }
		for (int i = 0; i < canRead; i++)
		{
			buffer[i] = S[i];//memcpy出错			
		}
		m_iWritePos = canRead;
		buffer[m_iWritePos] = 0;
		S = buffer;
		int readCnt = fread(buffer + m_iWritePos, 1, N - m_iWritePos, stdin);
		if (readCnt <= 0) { m_bFinish = true; return; }
		m_iWritePos += readCnt;
		buffer[m_iWritePos] = 0;
		S = buffer;
	}
	int m_iWritePos = 0; bool m_bFinish = false;
	char buffer[N + 10], * S = buffer;
};


template<class T = long long>
class CMatMul
{
public:
	CMatMul(T llMod = 1e9 + 7) :m_llMod(llMod) {}
	// 矩阵乘法
	vector<vector<T>> multiply(const vector<vector<T>>& a, const vector<vector<T>>& b) {
		const int r = a.size(), c = b.front().size(), iK = a.front().size();
		assert(iK == b.size());
		vector<vector<T>> ret(r, vector<T>(c));
		for (int i = 0; i < r; i++)
		{
			for (int j = 0; j < c; j++)
			{
				for (int k = 0; k < iK; k++)
				{
					ret[i][j] = (ret[i][j] + a[i][k] * b[k][j]) % m_llMod;
				}
			}
		}
		return ret;
	}

	// 矩阵快速幂
	vector<vector<T>> pow(const vector<vector<T>>& a, vector<vector<T>> b, T n) {
		vector<vector<T>> res = a;
		for (; n; n /= 2) {
			if (n % 2) {
				res = multiply(res, b);
			}
			b = multiply(b, b);
		}
		return res;
	}
	vector<vector<T>> pow(vector<vector<T>> pre, vector<vector<T>> mat, const string& str)
	{
		for (int i = str.length() - 1; i >= 0; i--) {
			const int t = str[i] - '0';
			pre = pow(pre, mat, t);
			mat = pow(mat, mat, 9);
		}
		return pre;
	}
	vector<vector<T>> TotalRow(const vector<vector<T>>& a)
	{
		vector<vector<T>> b(a.front().size(), vector<T>(1, 1));
		return multiply(a, b);
	}
protected:
	const  T m_llMod;
};

class CCreatePrime {
public:
	CCreatePrime(int iMax) :m_isPrime(iMax + 1, true)
	{
		m_isPrime[0] = m_isPrime[1] = false;
		for (int i = 2; i <= iMax; i++)
		{
			if (m_isPrime[i])
			{
				m_vPrime.emplace_back(i);
			}
			for (const auto& n : m_vPrime)
			{
				if ((long long)n * i > iMax) { break; }
				m_isPrime[n * i] = false;
				if (0 == i % n) { break; }
			}
		}
	}
	vector<int> m_vPrime;
	vector<bool> m_isPrime;
};

class Solution {
public:
	int Ans(int n, int m, int p) {
		static const auto v = CCreatePrime(2e7).m_isPrime;
		vector<vector<int>> cnt(2, vector<int>(p));
		for (int i = 1; i <= m; i++) {
			cnt[0][i % p]++;
			if (!v[i]) { cnt[1][i % p]++; }
		}
		vector<vector<long long>> mat1(p, vector<long long>(p));
		auto mat2 = mat1;
		for (int k = 0; k < p; k++) {
			for (int k1 = 0; k1 < p; k1++) {
				const int k2 = (k + k1) % p;
				mat1[k][k2] += cnt[0][k1];
				mat2[k][k2] += cnt[1][k1];
			}
		}
		const int MOD = 20170408;
		CMatMul<> matMul(MOD);
		vector<vector<long long>> pre(1, vector<long long>(p));
		pre[0][0] = 1;
		auto ans1 = matMul.pow(pre, mat1, n);
		auto ans2 = matMul.pow(pre, mat2, n);
		auto ans = (MOD + ans1[0][0] - ans2[0][0]) % MOD;
		return ans;
	}
};

int main() {
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG	
	ios::sync_with_stdio(0);
	int n,m,p;
	cin >> n >> m >> p ;
		auto res = Solution().Ans(n,m,p);
		cout <<res << "\n";
		
#ifdef _DEBUG		
	//printf("start=%d,end=%d,T=%d", start,end,T);
	//Out(edge, "edge=");
	//Out(fish, ",fish=");
	/*Out(edge, "edge=");
	Out(que, "que=");*/
#endif // DEBUG	
	
	return 0;
}

单元测试

TEST_METHOD(TestMethod1)
		{
			auto res = Solution().Ans(3,5,3);
			AssertEx(33, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771
如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

相关文章：

  • C++ 新特性 | C++ 11 | 移动语义
  • 【huggingface 数据下载】ssh / https 不同的下载流程，hf 镜像下载注意事项
  • ⼆、Kafka客户端消息流转流程
  • Ubuntu环境安装
  • 【网安面经合集】42 道高频 Web 安全面试题全解析（附原理+防御+思路）
  • Java基础-25-继承-方法重写-子类构造器的特点-构造器this的调用
  • 基于langchain实现GraphRAG：基于图结构的检索增强生成系统
  • Linux（24）——系统调优
  • MySQL数据库和表的操作之数据库表操作
  • Day3 蓝桥杯省赛冲刺精炼刷题 —— 排序算法与贪心思维
  • 静态路由与BFD联动实验配置
  • TCP、HTTP、HTTPS、DNS的原理
  • 科技潮流出行新体验 方程豹全新车型钛3正式开启预售
  • linux服务器专题1------redis的安装及简单配置
  • 【跑步计划，日期推算】
  • 我的世界模组进阶开发教程——地形生成（2）
  • C语言基础数据类型
  • RAG 调优指南：Spring AI Alibaba 模块化 RAG 原理与使用
  • Linux进程间通信：【目的】【管道】【匿名管道】【命名管道】【System V 共享内存】
  • 自动驾驶浪潮下，HMI 设计如何保障安全与便捷？
  • 短剧植入，撬不动96.4%直男的钱包 | 调研报告
  • 可显著提高公交出行率，山东、浙江多县常态化实施城区公交免费
  • 新四军老战士、苏州市文联原副主席张景坤逝世
  • 住建部：我国超9.4亿人生活在城镇
  • 澎湃读报丨多家央媒刊文关注拧紧纪律的螺丝：强化监督推动过紧日子要求落到实处
  • 世卫大会中国代表团：中国深入参与全球卫生治理，为构建人类卫生健康共同体贡献中国力量