【题解】codeforces 1065G. Fibonacci Suffix 合并技巧+按位贪心

博客解析了codeforces 1065G问题,涉及斐波那契序列的后缀及其第k小的后缀的前m位求解。采用直接按位贪心算法,通过维护前后缀匹配长度和出现次数来解决。使用bitset优化合并过程,复杂度为O(n * m * m/32)。注意检查当前串是否作为后缀出现,避免longlong溢出,每次检查时需正确清空和初始化。

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

题目连接

题意:

给出一个斐波那契序列,F[0] = “0” , F[1] = “1” , F[i] = F[i - 2] + F[i - 1]. 求第k小的后缀的前m位。

题解

直接按位贪心
每次check一个前缀在F[n]中的出现次数。
这个可以维护pre,suf , num表示F[i]和当前串的前后缀匹配长度和当前串出现次数
长度不够默认可以匹配,用bitset优化合并
复杂度O(n * m * m/32)
注意特判当前串是否作为一个后缀出现,因为总是把后面的串作为后缀,暴力跑200位然后判断即可
还有几个坑点:
出现次数可能很大,会爆longlong,要和inf取min
注意每次check的清空和初始化

#include<bits/stdc++.h>
using namespace std;

#define rep(i,l,r) for(register int i = l ; i <= r ; i++)
#define repd(i,r,l) for(register int i = r ; i >= l ; i--)
#define rvc(i,S) for(register int i = 0 ; i < (int)S.size() ; i++)
#define rvcd(i,S) for(register int i = ((int)S.size()) - 1 ; i >= 0 ; i--)
#define fore(i,x)for (register int i = head[x] ; i ; i = e[i].next)
#define forup(i,l,r) for (register int i = l ; i <= r ; i += lowbit(i))
#define fordown(i,id) for (register int i = id ; i ; i -= lowbit(i))
#define pb push_back
#define prev prev_
#define stack stack_
#define mp make_pair
#define fi first
#define se second
#define lowbit(x) (x&(-x))

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int,int> pr;

const ll inf = 1e18;
const int N = 220;
const int maxn = 220;
const ll mod = 1e9 + 7;

struct node{
	ll num,len;
	bitset <N> pre,suf;
	node() { num = len = 0; pre.reset(),suf.reset(); }
	void clear(){
		num = len = 0;
		pre.reset() , suf.reset();
	}
}f[220];
int fail[maxn];
struct node2{
	int len;
	int s[maxn * 10];
	node2(){
		len = 0;
	}
	void init(int x){
		s[++len] = x;
	}
	node2 operator + (const node2 &a){
		node2 res;
		rep(i,1,len) res.s[i] = s[i];
		rep(i,1,a.len) res.s[i + len] = a.s[i];
		res.len = a.len + len;
		return res;
	}
	void getfail(int m,int a[]){
		fail[1] = 0;
		int p = 0;
		rep(i,2,m){
			while ( p && a[p + 1] != a[i] ) p = fail[p];
			if ( a[p + 1] == a[i] ) p++;
			fail[i] = p;
		}
	}
	bool check(int m,int a[]){
	//	getfail(m,a);
	//	int p = 0;
	//	rep(i,1,len){
	//		while ( p && s[i] != a[p + 1] ) p = fail[p];
	//		if ( a[p + 1] == a[i] ) p++;
	//		if ( p == m ) return 1;
	//	}
	//	return 0;
		rep(i,1,m) if ( a[i] != s[len - m + i] ) return 0;
		return 1;
	}
}dt[maxn];

bitset <N> all;
int n,m,ans[maxn],id;
ll k;
int len;

node merge(const node &a,const node &b){
	if ( !a.len ) return b;
	node res;
	res.len = a.len + b.len;
	res.pre = a.pre , res.suf = b.suf; //pre和suf中包含了长度1..n-1的所有信息,所以合并的时候直接&就好
	res.num = a.num + b.num;
	if ( a.len <= len - 2 ) res.pre &= (b.pre >> a.len) | (all << (len - 1 - a.len)); 
	if ( b.len <= len - 2 ) res.suf &= (a.suf << b.len) | (all >> (len - 1 - b.len));
	if ( res.len >= len ){
		bitset<N> tmp = a.suf & b.pre;
		if ( a.len <= len - 2 ) tmp &= all >> (len - 1 - a.len); //如果a的长度不足,则删除高位
		if ( b.len <= len - 2 ) tmp &= all << (len - 1 - b.len); //删除低位
		res.num += tmp.count();
	}
	if ( res.num > inf ) res.num = inf;
	return res;
}
void init(){
	dt[0].init(0) , dt[1].init(1);
	rep(i,2,100){
		dt[i] = dt[i - 2] + dt[i - 1];
		if ( dt[i].len > m ){ id = i; break; }
	}
//	rep(i,1,dt[id].len) printf("%d",dt[id].s[i]);
//	puts("");
}

inline ll calc(int a[]){
	all.reset();
	rep(i,1,len - 1) all.set(i);
	rep(i,0,n) f[i].clear();
	f[0].len = 1 , f[1].len = 1;
	if ( len == 1 ){
		f[0].num = a[1] == 0;
		f[1].num = a[1] == 1;
	}
	else{
		rep(i,1,len){
			f[0].pre[i - 1] = a[i] == 0;
			f[0].suf[i] = a[i] == 0;
			f[1].pre[i - 1] = a[i] == 1;
			f[1].suf[i] = a[i] == 1;
		}
	}
	rep(i,2,n) f[i] = merge(f[i - 2] ,f[i - 1]);
	return f[n].num;
}
void solve(int n,ll k){
	if ( n > m ){ len = n - 1; return; }
	ans[len = n] = 0;
	ll num = calc(ans);
//	cout<<num<<endl;
	if ( num >= k ){
		if ( dt[id].check(n,ans) ) k--;
		if ( !k ){ len = n; return; }
		solve(n + 1,k);
	}
	else{
		k -= num;
		ans[n] = 1;
		if ( dt[id].check(n,ans) ) k--;
		if ( !k ){ len = n; return; }
		solve(n + 1,k);
	}
}
int main(){
	scanf("%d %lld %d",&n,&k,&m);
	init();
	solve(1,k);
	rep(i,1,len) printf("%d",ans[i]);
   puts("");	
}



### Codeforces 1732A Bestie 题目解析 对于给定的整数数组 \(a\) 和查询次数 \(q\),每次查询给出两个索引 \(l, r\),需要计算子数组 \([l,r]\) 的最大公约数(GCD)。如果 GCD 结果为 1,则返回 "YES";否则返回 "NO"[^4]。 #### 解决方案概述 为了高效解决这个问题,可以预先处理数据以便快速响应多个查询。具体方法如下: - **预处理阶段**:构建辅助结构来存储每一对可能区间的 GCD 值。 - **查询阶段**:利用已有的辅助结构,在常量时间内完成每个查询。 然而,考虑到内存限制以及效率问题,直接保存所有区间的结果并不现实。因此采用更优化的方法——稀疏表(Sparse Table),它允许 O(1) 时间内求任意连续子序列的最大值/最小值/GCD等问题,并且支持静态RMQ(Range Minimum Query)/RANGE_GCD等操作。 #### 实现细节 ##### 构建稀疏表 通过动态规划的方式填充二维表格 `st`,其中 `st[i][j]` 表示从置 i 开始长度为 \(2^j\) 的子串的最大公约数值。初始化时只需考虑单元素情况即 j=0 的情形,之后逐步扩展至更大的范围直到覆盖整个输入序列。 ```cpp const int MAXN = 2e5 + 5; int st[MAXN][20]; // Sparse table for storing precomputed results. vector<int> nums; void build_sparse_table() { memset(st,-1,sizeof(st)); // Initialize the base case where interval length is one element only. for(int i = 0 ;i < nums.size(); ++i){ st[i][0]=nums[i]; } // Fill up sparse table using previously computed values. for (int j = 1;(1 << j)<=nums.size();++j){ for (int i = 0;i+(1<<j)-1<nums.size();++i){ if(i==0 || st[i][j-1]!=-1 && st[i+(1<<(j-1))][j-1]!=-1) st[i][j]=__gcd(st[i][j-1],st[i+(1<<(j-1))][j-1]); } } } ``` ##### 处理查询请求 当接收到具体的 l 和 r 参数后,可以通过查找对应的 log₂(r-l+1) 来定合适的跳跃步长 k ,进而组合得到最终答案。 ```cpp string query(int L,int R){ int K=(int)(log2(R-L+1)); return __gcd(st[L][K],st[R-(1<<K)+1][K])==1?"YES":"NO"; } ``` 这种方法能在较短时间内完成大量查询任务的同时保持较低的空间开销,非常适合本题设定下的性能需求。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值