bzoj 4569: [Scoi2016]萌萌哒

最新推荐文章于 2019-03-26 14:12:34 发布
最新推荐文章于 2019-03-26 14:12:34 发布
阅读量978 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heheda_is_an_oier/article/details/51372726
版权
一种会T的做法：
发现并查集加边只会发生n-1次，所以只要一个较小的复杂度完成这n-1次加边即可
启发式合并维护并查集，每次暴力修改所有属于小区间的fa值，用vector记录每个连通块内的数，暴力在线段树内修改hash值，复杂度logn,需要进行nlogn次
线段树上hash把所有的fa hash起来，然后二分找位置，每次寻找log^2,需要进行On次 
    
    

     
     

      
      #include<cstdio>
     
     

     
     

      
      #include<cstdlib>
     
     

     
     

      
      #include<cstring>
     
     

     
     

      
      #include<algorithm>
     
     

     
     

      
      #include<vector> 
     
     

     
     

      
      #define ll long long
     
     

     
     

      
      #define unl unsigned long long
     
     

     
     

      
      #define inf 1e9
     
     

     
     

      
      #define eps 1e-8
     
     

     
     

      
      #define md 1000000007
     
     

     
     

      
      #define N 100010
     
     

     
     

      
      using namespace std;
     
     

     
     

      
      unl tmp[4*N],mi[N],ha[4*N];
     
     

     
     

      
      int fa[N];
     
     

     
     

      
      int lx[4*N],rx[4*N];
     
     

     
     

      
      vector<int> vec[N];
     
     

     
     

      
      const unl cheng=23333333;
     
     

     
     

      
      void build(int i,int l,int r)
     
     

     
     

      
      {
     
     

     
     

      
      	tmp[i]=mi[r-l+1]; lx[i]=l; rx[i]=r;
     
     

     
     

      
      	if (l==r) { ha[i]=fa[l]; return;}
     
     

     
     

      
      	int mid=(l+r)>>1;
     
     

     
     

      
      	build(i<<1,l,mid); build(i<<1|1,mid+1,r);
     
     

     
     

      
      	ha[i]=ha[i<<1]*tmp[i<<1]+ha[i<<1|1];
     
     

     
     

      
      }
     
     

     
     

      
       
     
     

     
     

      
      void modify(int i,int x)
     
     

     
     

      
      {
     
     

     
     

      
      	if (lx[i]==rx[i]) { ha[i]=fa[x]; return;}
     
     

     
     

      
      	int mid=(lx[i]+rx[i])>>1;
     
     

     
     

      
      	if (x<=mid) modify(i<<1,x); else modify(i<<1|1,x);
     
     

     
     

      
      	ha[i]=ha[i<<1]*tmp[i<<1]+ha[i<<1|1];
     
     

     
     

      
      }
     
     

     
     

      
       
     
     

     
     

      
      unl query(int i,int ql,int qr)
     
     

     
     

      
      {
     
     

     
     

      
      	if (ql<=lx[i]&&rx[i]<=qr) return ha[i];
     
     

     
     

      
      	int mid=(lx[i]+rx[i])>>1;
     
     

     
     

      
      	if (qr<=mid) return query(i<<1,ql,qr);
     
     

     
     

      
      	if (mid+1<=ql) return query(i<<1|1,ql,qr);
     
     

     
     

      
      	return query(i<<1,ql,mid)*mi[mid-ql+1]+query(i<<1|1,mid+1,qr);
     
     

     
     

      
      }
     
     

     
     

      
       
     
     

     
     

      
      int main()
     
     

     
     

      
      {
     
     

     
     

      
      	int n,m;
     
     

     
     

      
      	scanf("%d%d",&n,&m);
     
     

     
     

      
      	for (int i=1;i<=n;i++) { fa[i]=i; vec[i].push_back(i);}
     
     

     
     

      
      	mi[0]=1; for (int i=1;i<=n;i++) mi[i]=mi[i-1]*cheng;
     
     

     
     

      
      	build(1,1,n);
     
     

     
     

      
      	for (int i=1;i<=m;i++)
     
     

     
     

      
      	{
     
     

     
     

      
      		int l1,r1,l2,r2;
     
     

     
     

      
      		scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
     
     

     
     

      
      		while (query(1,l1,r1)!=query(1,l2,r2))
     
     

     
     

      
      		{
     
     

     
     

      
      			int L=0,R=r1-l1;
     
     

     
     

      
      			while (L!=R)
     
     

     
     

      
      			{
     
     

     
     

      
      				int mid=(L+R)>>1;
     
     

     
     

      
      				if (query(1,l1,l1+mid)!=query(1,l2,l2+mid)) R=mid; else L=mid+1;
     
     

     
     

      
      			}
     
     

     
     

      
      			int f1=fa[l1+L],f2=fa[l2+L];
     
     

     
     

      
      			if (vec[f1].size()<vec[f2].size()) swap(f1,f2);
     
     

     
     

      
      			for (int j=vec[f2].size()-1;j>=0;j--)
     
     

     
     

      
      			{
     
     

     
     

      
      				int x=vec[f2][j];
     
     

     
     

      
      				fa[x]=f1; modify(1,x);
     
     

     
     

      
      				vec[f1].push_back(x);
     
     

     
     

      
      			}
     
     

     
     

      
      			vec[f2].clear();
     
     

     
     

      
      		}
     
     

     
     

      
      	}
     
     

     
     

      
      	int k=0;
     
     

     
     

      
      	for (int i=1;i<=n;i++) if (fa[i]==i) k++;
     
     

     
     

      
      	ll ans=9;
     
     

     
     

      
      	for (int i=2;i<=k;i++) ans=ans*10%md;
     
     

     
     

      
      	printf("%lld\n",ans);
     
     

     
     

      
      	return 0;
     
     

     
     

      
      }
正解:
又是ST表。用ST表记录每一层的并查集 fa[j][i]的含义是 从i开始的2^j个字符分别和从fa[j][i]开始的2^j个字符对应相等。
每次并查集合并fa[j][x],fa[j][y]的时候，要把fa[j-1][x],fa[j-1][y] 以及 fa[j-1][x+(1<<j-1)] fa[j-1][y+(1<<(j-1)] 合并
总共发生nlogn次合并，复杂度nlogn
%能想出来的人 
    
    

     
     

      
      #include<cstdio>
     
     

     
     

      
      #include<cstdlib>
     
     

     
     

      
      #include<cstring>
     
     

     
     

      
      #include<algorithm>
     
     

     
     

      
      #include<cmath>
     
     

     
     

      
      #define ll long long
     
     

     
     

      
      #define unl unsigned long long
     
     

     
     

      
      #define inf 1e9
     
     

     
     

      
      #define eps 1e-8
     
     

     
     

      
      #define md 1000000007
     
     

     
     

      
      #define N 100010
     
     

     
     

      
      using namespace std;
     
     

     
     

      
      int fa[20][N];
     
     

     
     

      
      int find(int j,int i) { return fa[j][i]==i?i:fa[j][i]=find(j,fa[j][i]);}
     
     

     
     

      
       
     
     

     
     

      
      void merge(int j,int x,int y)
     
     

     
     

      
      {
     
     

     
     

      
      	int f1=find(j,x),f2=find(j,y);
     
     

     
     

      
      	if (f1==f2) return;
     
     

     
     

      
      	fa[j][f2]=f1;
     
     

     
     

      
      	if (!j) return;
     
     

     
     

      
      	merge(j-1,x,y); merge(j-1,x+(1<<(j-1)),y+(1<<(j-1)));
     
     

     
     

      
      }
     
     

     
     

      
       
     
     

     
     

      
      int main()
     
     

     
     

      
      {
     
     

     
     

      
      	int n,m;
     
     

     
     

      
      	scanf("%d%d",&n,&m);
     
     

     
     

      
      	if (n==1) { printf("10\n"); return 0;}
     
     

     
     

      
      	for (int j=0;j<18;j++)
     
     

     
     

      
      	  for (int i=1;i<=n;i++)
     
     

     
     

      
      		fa[j][i]=i;
     
     

     
     

      
      	for (int i=1;i<=m;i++)
     
     

     
     

      
      	{
     
     

     
     

      
      		int l1,r1,l2,r2;
     
     

     
     

      
      		scanf("%d%d%d%d",&l1,&r1,&l2,&r2);
     
     

     
     

      
      		if (l1>l2) { swap(l1,l2); swap(r1,r2);}
     
     

     
     

      
      		int j=log2(r1-l1+1+eps);
     
     

     
     

      
      		merge(j,l1,l2); merge(j,r1-(1<<j)+1,r2-(1<<j)+1);
     
     

     
     

      
      	}
     
     

     
     

      
      	int ans=0;
     
     

     
     

      
      	for (int i=1;i<=n;i++)
     
     

     
     

      
      		if (find(0,i)==i) ans++;
     
     

     
     

      
      	ll ret=9;
     
     

     
     

      
      	for (int i=2;i<=ans;i++) ret=ret*10%md;
     
     

     
     

      
      	printf("%lld\n",ret);
     
     

     
     

      
      	return 0;
     
     

     
     

      
      }

heheda_is_an_OIer
关注
【BZOJ4569】【SCOI2016】萌萌哒
cz_xuyixuan的博客
07-06 374
【题目链接】 点击打开链接 【思路要点】 很强的脑洞题。 显然有一个O(NM)O(NM)O(NM)的暴力，每次暴力用并查集合并区间的对应位置。 考虑加速这个过程，我们新建O(LogN)O(LogN)O(LogN)层点，第iii层的两个点pi,xpi,xp_{i,x}和pi,ypi,yp_{i,y}被用并查集合并，表示xxx起的2i2i2^i个元素和yy...
bzoj4569【SCOI2016】萌萌哒
AaronPolaris
06-30 2341
并查集+ST表，思路好
BZOJ 4569 [Scoi2016]萌萌哒
Faxth
09-11 496
一个长度为n的大数，用S1S2S3…Sn表示，其中Si表示数的第i位,S1是数的最高位，告诉你一些限制条件，每个条件表示为四个数，l1，r1，l2，r2，即两个长度相同的区间，表示子串Sl1Sl1+1Sl1+2…Sr1与Sl2Sl2+1Sl2+2…Sr2完全相同。比如n=6时，某限制条件l1=1，r1=3，l2=4，r2=6，那么123123，351351均满足条件，但是12012，131141不满足条件，前者数的长
BZOJ 4569: [Scoi2016]萌萌哒
cgh_Andy's Blog
10-18 338
...
bzoj4569: [Scoi2016]萌萌哒 并查集+倍增
maxtir的博客
05-30 214
bzoj4569: [Scoi2016]萌萌哒 Description 一个长度为n的大数，用S1S2S3…Sn表示，其中Si表示数的第i位,S1是数的最高位，告诉你一些限制条件，每个条 件表示为四个数，l1，r1，l2，r2，即两个长度相同的区间，表示子串Sl1Sl1+1Sl1+2…Sr1与Sl2Sl2+1Sl2+2…S r2完全相同。比如n=6时，某限制条件l1=1，r1=3，l2...
BZOJ 4569: [Scoi2016]萌萌哒 倍增思维并查集
Monica
10-09 434
Time Limit: 10 Sec Memory Limit: 256 MB Submit: 1110 Solved: 528Description一个长度为n的大数，用S1S2S3…Sn表示，其中Si表示数的第i位,S1是数的最高位，告诉你一些限制条件，每个条 件表示为四个数，l1，r1，l2，r2，即两个长度相同的区间，表示子串Sl1Sl1+1Sl1+2…Sr1与Sl2Sl2+1Sl2
bzoj4569 [Scoi2016]萌萌哒（并查集+倍增）
Icefox的博客
04-27 338
考虑暴力做法，就是每次把对应位置都用并查集合并了。最后答案就是9*10^（连通块个数-1）。然而这样太暴力了，怎么优化呢？ 我们考虑倍增的思想，用id[j][i]这个点表示j…j+(1< < i)-1这一段。我们每次合并两个对应区间时，变成合并logn个对应区间。 最后再从上往下推到i=0.即如果id[x][i]和id[y][i]联通,则id[x][i-1],id[y][i-1]也联通，id[x
bzoj4569[Scoi2016]萌萌哒
时光真疯狂, 我一路执迷于匆忙.
05-20 1647
Description给出一个有n位的无前导0正整数，再给出m个限制，每个限制形如l1…r1,l2..r2表示这个数的l1~r1位和第l2~r2位是相等的。求这样的数的个数。 n,m<=10^5Solution我们可以先来考虑一下暴力。 对于这一个区间，我们暴力把它们用并查集并起来。 那么100%呢？ 我们可以用f[i][j]表示[i~i+2^j-1]这一段区间属于哪一个集合。 若没有则等
bzoj 4569 [Scoi2016]萌萌哒
aln1541的博客
10-20 100
4569: [Scoi2016]萌萌哒 Time Limit:10 SecMemory Limit:256 MB[Submit][Status][Discuss] Description 一个长度为n的大数，用S1S2S3...Sn表示，其中Si表示数的第i位,S1是数的最高位，告诉你一些限制条件，每个条 件表示为四个数，l1，r1，l2，r2，即两个长度相同的区...
BZOJ1855: [Scoi2010]股票交易（洛谷P2569）
forezxl的博客
11-02 295
单调队列 DP BZOJ题目传送门 洛谷题目传送门 设f[i][j]f[i][j]f[i][j]表示前iii天还剩jjj股的最多钱数。有四种转移方式。 1.之前没有股票，直接从这一天开始买，f[i][j]=−j∗APi(j∈[0,ASi])f[i][j]=-j*AP_i\quad(j\in[0,AS_i])f[i][j]=−j∗APi​(j∈[0,ASi​]) 2.这一天啥也不干，f[i][j]=...
BZOJ1088: [SCOI2005]扫雷Mine（洛谷P2327）
forezxl的博客
02-09 297
技巧题 BZOJ题目传送门 洛谷题目传送门 使劲划水 对于两列的扫雷，有个十分显然的性质：只要确定了前两个的情况，其他的就都确定了。 而当第一个数是0或2时，前两个都是确定的，直接算就好了。 当第一个数是1时，计算第一个是雷、第二个不是雷和第一个不是雷、第二个是雷的情况即可。 其实答案只可能是0、1、2。。。 代码： #include&lt;cctype&gt; #include...
bzoj4444: [Scoi2015]国旗计划
Hanks_o的博客
04-22 306
题目传送门 好题 解法： 因为区间互不包含。 那么左端点在区间内最右边的的区间一定是当前区间能扩展到最远的区间。 这句话有点绕。举个例子。 假设当前区间为1~5。 那么我们往右扩展。 找到左端点最右且小于等于5的区间。 这个区间一定是最优解。 因为区间互不包含啊。如果这个区间不是最优解的话那么就被别的包含了。。 因为题目是环。需要转化成链。 所以把环复制一份放在后面就变成了...
bzoj1079: [SCOI2008]着色方案 题解
Unlimited的博客
01-04 417
1079: [SCOI2008]着色方案 Description 　　有n个木块排成一行，从左到右依次编号为1~n。你有k种颜色的油漆，其中第i种颜色的油漆足够涂ci个木块。 所有油漆刚好足够涂满所有木块，即c1+c2+…+ck=n。相邻两个木块涂相同色显得很难看，所以你希望统计任意两 个相邻木块颜色不同的着色方案。 Input 　　第一行为一个正整数k，第二行包...
bzoj4447: [Scoi2015]小凸解密码（线段树）
苟为蒟蒻又何妨
03-26 168
传送门 题意简述：咕咕咕 思路：考虑预处理出bbb数组，然后每次改动aaa都只会对第iii和i+1i+1i+1这两个位置产生影响，于是可以用线段树来维护bbb数组。 现在求答案的方法是断环为链，倍增整个数组，然后就可用线段树维护000段的一些信息。 代码： #include<bits/stdc++.h> #define ri register int using namespace ...
电子设计论文鱼缸水循环自动控制器电子设计论文鱼缸水循环自动控制器
09-21
电子设计论文鱼缸水循环自动控制器电子设计论文鱼缸水循环自动控制器
AP9569GH-HF-VB一款P-Channel沟道TO252的MOSFET晶体管参数介绍与应用说明
09-21
-40V;-65A;RDS(ON)=10mΩ@VGS=10V;VGS=20V;Vth=-1.6V
电子设计论文用555电路组成的DC-AC变换器
09-21
电子设计论文用555电路组成的DC-AC变换器
基于深度学习的看图作诗模型.zip
最新发布
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
洛谷 P1640 BZOJ 1854 [SCOI2010]连续攻击游戏
05-14
这道题目需要进行博弈论的思考。我们可以使用动态规划来解决这道题目。 首先，我们可以定义 $f_{i,j}$ 表示当前剩下 $i$ 到 $j$ 这些数时，当前玩家最多能获得的分数。我们可以发现，在这个状态中，当前玩家只能从 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值