Jzoj3895 数字对

给你一个序列s,求出所有最长的区间[l,r]使得存在一个k∈[l,r]且对于任何i∈[l,r]都有s[k]|s[i]

显然如果这个k存在,那么s[k]一定是s[l]~s[r]的最小值

现在问题就成了,求一个最长的区间使得s[l]~s[r]的最小值=s[l]~s[r]的gcd

那么我们可以二分答案,而求一个区间最小和gcd都可以用ST表完成,所以整体复杂度nlg^2n

(虽然说这是solution的方法但是不是最快的方法,最快的方法是枚举k,让后向两边暴力扫描法,复杂度是n^2的但是跑起来非常快!)

正解:313ms

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;
inline int Min(int a,int b){ return a<b?a:b; }
inline int gcd(int a,int b){
	for(int c;b;a=b,b=c) c=a%b;
	return a;
}
int preLog[500010],n,w[500010];
vector<int> A;
struct ST_list{
	int (*f)(int,int) ;
	int g[20][500010];
	void init(int* s,int (*f1)(int,int) ){
		f=f1;
		memcpy(g[0]+1,s+1,n<<2);
		for(int i=n;i;--i)
			for(int j=1;i+(1<<j)-1<=n;++j)
				g[j][i]=f(g[j-1][i],g[j-1][i+(1<<j-1)]);
	}
	int query(int l,int r){
		int k=preLog[r-l+1];
		return f(g[k][l],g[k][r-(1<<k)+1]);
	}
} s1,s2;
bool ok(int len){
	int M=n-len;
	for(int i=1;i<=M;++i)
		if(s1.query(i,i+len)==s2.query(i,i+len)) return 1;
	return 0;
}
int main(){
	preLog[1]=0;
	for(int i=2,j=0;i<=500010;++i){
		if(i==(1<<j+1)) ++j;
		preLog[i]=j;
	}
	scanf("%d",&n);
	for(int i=1;i<=n;++i) scanf("%d",w+i);
	s1.init(w,Min); s2.init(w,gcd);
	int l=0,r=n-1;
	for(int m;l<r;){
		m=l+r+1>>1;
		if(ok(m)) l=m;
		else r=m-1; 
	}
	n-=l;
	for(int i=1;i<=n;++i)
		if(s1.query(i,i+l)==s2.query(i,i+l)) A.push_back(i);
	printf("%d %d\n",A.size(),l);
	for(int i=0,z=A.size();i<z;++i) printf("%d ",A[i]);
}
暴力:76ms

#include<iostream>
#include<cstdio>
#include<cstdlib>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define N 500010
using namespace std;
int a[N],ans[N];
int main()
{
    int n,num=0,val=0;
    cin>>n;
    fo(i,1,n)
    {
             scanf("%d",&a[i]);
             if(a[i]==1)
             {
                        cout<<1<<' '<<n-1<<endl<<1;
                        return 0;
             }
    }
    fo(k,1,n)
    {
             if(a[k]==0) continue;
             int l=k,r=k;
             while(a[l-1]%a[k]==0 && l>1) l--;
             while(a[r+1]%a[k]==0 && r<n) r++;
             if(r-l==val && l!=ans[num]) ans[++num]=l;
             if(r-l>val)
             {
                        fo(i,1,num) ans[i]=0;
                        val=r-l,ans[num=1]=l;
             }
    }
    cout<<num<<' '<<val<<endl;
    fo(i,1,num) printf("%d ",ans[i]);
}

### 解题思路 题目要求解决的是一个与图相关的最小覆盖问题,通常在特定条件下可以通过状态压缩动态规划(State Compression Dynamic Programming, SCDP)来高效求解。由于状态压缩的适用条件是状态维度较小(例如K≤10),因此可以利用二进制示状态集合,从而优化计算过程。 #### 1. 状态示 - 使用一个整数 `mask` 示当前选择的点集,其中第 `i` 位为 `1` 示第 `i` 个节点被选中。 - 定义 `dp[mask]` 示在选中 `mask` 所代的点集后,能够覆盖的节点集合。 - 可以通过预处理每个点的邻域信息(包括自身和所有直接连接的点),快速更新状态。 #### 2. 预处理邻域 对于每个节点 `u`,预先计算其邻域范围 `neighbor[u]`,即从该节点出发一步能到达的所有节点集合。这样,在后续的状态转移过程中,可以直接使用这些信息进行合并操作。 #### 3. 状态转移 - 初始化:对每个单独节点 `u`,设置初始状态 `dp[1 << u] = neighbor[u]`。 - 转移规则:对于任意两个状态 `mask1` 和 `mask2`,如果它们没有交集,则可以通过合并这两个状态得到新的状态 `mask = mask1 | mask2`,并更新对应的覆盖范围为 `dp[mask1] ∪ dp[mask2]`。 - 在所有状态生成之后,检查是否某个状态的覆盖范围等于全集(即覆盖了所有节点)。如果是,则记录此时使用的最少节点数量。 #### 4. 最优解提取 遍历所有可能的状态,找出能够覆盖整个图的最小节点数目。 --- ### 时间复杂度分析 - 状态总数为 $ O(2^K) $,其中 `K` 是关键点的数量。 - 每次状态转移需要枚举所有可能的子集组合,复杂度为 $ O(2^K \cdot K^2) $。 - 整体时间复杂度控制在可接受范围内,适用于 `K ≤ 10~20` 的情况。 --- ### 代码实现(状态压缩 DP) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 25; int neighbor[MAXN]; // 每个节点的邻域 int dp[1 << 20]; // dp[mask] 示选中的点集合为 mask 时所能覆盖的点集合 int min_nodes; // 最小覆盖点数 void solve(int n, vector<vector<int>>& graph) { // 预处理每个节点的邻域 for (int i = 0; i < n; ++i) { neighbor[i] = (1 << i); // 包括自己 for (int j : graph[i]) { neighbor[i] |= (1 << j); } } // 初始化 dp 数组 memset(dp, 0x3f, sizeof(dp)); for (int i = 0; i < n; ++i) { dp[1 << i] = neighbor[i]; } // 状态转移 for (int mask = 1; mask < (1 << n); ++mask) { if (__builtin_popcount(mask) >= min_nodes) continue; // 剪枝 for (int sub = mask & (mask - 1); sub; sub = (sub - 1) & mask) { int comp = mask ^ sub; if (comp == 0) continue; int new_mask = mask; int covered = dp[sub] | dp[comp]; if (covered == (1 << n) - 1) { min_nodes = min(min_nodes, __builtin_popcount(new_mask)); } dp[new_mask] = min(dp[new_mask], covered); } } } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); // 无向图 } min_nodes = n; solve(n, graph); cout << "Minimum nodes required: " << min_nodes << endl; return 0; } ``` --- ### 优化策略 - **剪枝**:当当前状态所用节点数已经超过已知最优解时,跳过后续计算。 - **提前终止**:一旦发现某个状态覆盖了全部节点,并且节点数达到理论下限,即可提前结束程序。 - **空间优化**:可以仅保存当前轮次的状态,减少内存占用。 --- ### 总结 本题通过状态压缩动态规划的方法,将原本指数级复杂度的问题压缩到可接受范围内。结合位运算技巧和预处理机制,能够高效地完成状态转移和覆盖判断操作。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值