2017省夏令营Day7 【快速幂,筛法,矩阵快速幂,线段树】

题解:首先,我们可以得到一个规律:经过2次变换后,a和b的值都分别乘2了,所以只要用快速幂就能过啦,但是,要特判n为0的情况。

代码如下:

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #define Mod 1000000007
 5 using namespace std;
 6 long long a,b,n,ans1,ans2;
 7 long long power(long long x){
 8     long long ret=1,tmp=2;
 9     while(x){
10         if(x&1){ret*=tmp; ret%=Mod;}
11         tmp*=tmp; tmp%=Mod; x/=2;
12     }
13     return ret;
14 }
15 int main()
16 {
17     freopen("apexis.in","r",stdin);
18     freopen("apexis.out","w",stdout);
19     scanf("%lld%lld%lld",&a,&b,&n);
20     if(n==0){
21         printf("%lld %lld",a,b);
22         return 0;
23     }
24     if(a<b) swap(a,b);
25     long long tmp=n>>1;
26     long long t=power(tmp);
27     if(n&1) ans1=t*(a+b)%Mod,ans2=t*(a-b)%Mod;
28     else ans1=t*a%Mod,ans2=t*b%Mod;
29     printf("%lld %lld",ans1,ans2);
30     return 0;
31 }

------------------------------------------------------------华丽的分割线----------------------------------------------------------------------


题解:我们记f[i]表示区间[1,i]内素数个数,我们可以用筛法筛出数据范围内的素数并顺便求f数组,然后我们暴力枚举1-maxn中的数即可。

代码如下:

 1 #include<cstdio>
 2 #include<iostream>
 3 #define Max 200005
 4 using namespace std;
 5 int n,m,ans,cnt,maxn;
 6 int f[Max],num[Max],prime[Max];
 7 void shaifa(){
 8     for(int i=1;i<=Max;i++) f[i]=i;
 9     for(int i=2;i<=Max;i++)
10         if(!prime[i]){
11             f[i]--;
12             for(int j=2*i;j<=Max/2;j+=i){
13                 f[j]=f[j]*(i-1)/i;
14                 prime[j]=1;
15             }
16         }
17 }
18 int main()
19 {
20     freopen("quest.in","r",stdin);
21     freopen("quest.out","w",stdout);
22     shaifa();
23     int T; scanf("%d",&T);
24     while(T--){
25         ans=cnt=maxn=0;
26         scanf("%d%d",&n,&m);
27         for(int i=1;i<=n;i++){
28             int x; scanf("%d",&x);
29             num[x]++; maxn=max(maxn,x);
30         }
31         for(int i=1;i<=maxn;i++){
32             cnt=0;
33             for(int j=i;j<=maxn;j+=i) cnt+=num[j];
34             if(cnt>=m) ans=max(ans,f[i]);
35             num[i]=0;
36         }
37         printf("%d\n",ans);
38     }
39     return 0;
40 }

------------------------------------------------------------华丽的分割线----------------------------------------------------------------------

题解(假):首先,在n、m<=100时,我们可以暴力使枚举l到r,然后用矩阵快速幂求出每个点的答案,最后加起来即可,时间复杂度约为为O(NMlogK)。

代码如下:当做矩阵快速幂的练习吧,最蠢的暴力- -

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #define Max 100001
 5 #define Mod 10007
 6 using namespace std;
 7 int n,m,l,r;
 8 long long K,cnt[Max];
 9 struct mat{long long num[2][2];}a,b,c,ret;
10 mat mult(mat x,mat y){
11     memset(c.num,0,sizeof(c.num));
12     for(int i=0;i<2;i++)
13         for(int j=0;j<2;j++)
14             for(int k=0;k<2;k++)
15                 c.num[i][j]=(c.num[i][j]+x.num[i][k]*y.num[k][j])%Mod;
16     return c;
17 }
18 mat matmod(mat x,long long k){
19     memset(ret.num,0,sizeof(ret.num));
20     for(int i=0;i<2;i++) ret.num[i][i]=1;
21     while(k){
22         if(k&1) ret=mult(ret,x);
23         k>>=1; x=mult(x,x);
24     }
25     return ret;
26 }
27 long long Get(long long k){
28     memset(a.num,0,sizeof(a.num));
29     memset(b.num,0,sizeof(b.num));
30     a.num[0][1]=1; a.num[1][0]=1; a.num[1][1]=1;
31     b.num[0][0]=1; b.num[1][0]=1;
32     a=matmod(a,k-1);
33     a=mult(a,b);
34     return a.num[0][0];
35 }
36 int main()
37 {
38     freopen("rabbit.in","r",stdin);
39     freopen("rabbit.out","w",stdout);
40     scanf("%d%d",&n,&m);
41     for(int i=1;i<=n;i++) cnt[i]=1;
42     for(int i=1;i<=m;i++){
43         long long ans=0;
44         scanf("%d%d%lld",&l,&r,&K);
45         if(K==0){
46             for(int j=l;j<=r;j++)
47                 if(cnt[j]!=0) ans=(ans+Get(cnt[j]))%Mod;
48             printf("%lld\n",ans);
49         }
50         else for(int j=l;j<=r;j++) cnt[j]+=K;
51     }
52     return 0;
53 }

题解:那么,在n、m<=100000时我们该怎么做呢,很明显,我们可以用线段树,但是我还没调出来。。。也许明天会记得填坑吧,大概。

时间: 2024-12-12 04:58:52

2017省夏令营Day7 【快速幂,筛法,矩阵快速幂,线段树】的相关文章

快速乘、快速幂(矩阵快速幂)

当mod一个大数p的时候,还有进行乘法的时候可能会爆long long的时候,就用快速乘或者快速幂. 参考:http://www.cnblogs.com/whywhy/p/5066730.html 先上模板: 快速乘: ll multi(ll a,ll b,ll m) { ll ans=0; while(b) { if(b&1) (ans+=a) %= m; (a=a*2) %= m; b/=2; } return ans; } 快速幂: ll pow_mod(ll a,ll b,ll m) {

算法初步:快速乘,快速幂,矩阵快速幂

原创 by zoe.zhang 在刷题的时候遇到了问题,就是当循环或者递推的次数非常大的情况下获取一定结果,这个时候如果作普通运算,那么很容易就超时了,而且有时候结果也大得超范围了,即使是long long类型的也放不下,然后给了提示说是运用快速幂的思想.所以这里对快速幂做了一点思考和探讨. 1.快速乘,快速幂,矩阵快速幂三者的关系 不管是快速乘,还是快速幂算法,实际上都包含了分解问题的思想在里面,将O(n)的复杂度降到O(lgn).学习的时候,一般学习快速幂算法,再由此推广去解决矩阵快速幂问题

快速幂与矩阵快速幂

快速幂的思路: 仍然是与2 分法有关的算法:(很多O(logN)的算法都是二分法啊...) 但快速幂有个前题,就是数据类型必须满足结合律 对于一般的解法: A^8 = A * A * A * A * A * A * A * A 总共需要7次乘法运算: 将其平均分解: A^8 = (A * A * A * A) * (A * A * A * A) = (A * A * A * A) ^ 2 这样我们就只需要4次乘法运算了: 我们还可以将其再分解: A^6 = [(A * A) * (A * A)]

算法学习 - 快速幂和矩阵快速幂(复杂度Olog(n))C++实现

快速幂 快速幂顾名思义,就是快速算某个数的多少次幂.其时间复杂度为 O(log?N), 与朴素的O(N)相比效率有了极大的提高. 快速幂实现原理 快速幂的原理比较好懂,就是说假如我们求的是3^11,其实比较通用的办法就是 for 1:11 a*=3; 时间复杂度为O(n), 那么我们有没有更快的办法呢? 有的~就是下面要说的快速幂. 快速幂就是把指数进行一次log(N)级别的变换.11 = 2^3+2^1+2^0 那么我只需要算3^1和3^2还有3^8这样复杂度就降下来了.算3^1需要一次记为a

快速幂和矩阵快速幂模板

快速幂模板: ll qmod(ll x,ll n,ll mod) { ll res=1; while(n){ if(n&1) res=(res*x)%mod; x=(x*x)%mod; n/=2; } return res; } 例题:hdu 1097 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<cmath> usin

算法录 之 快速幂快速乘和矩阵快速幂。

1: 问题如下: 求 a^n % m 的值是多少?n是1到10^18次方的一个整数. 求一个数的n次方,朴素的算法就是直接for循环,O(N)的复杂度. 但是对于这个问题n实在是太大了,O(N)也会超时,那么需要更快的算法,快速幂算法. 要求 a^n,如果知道了 a^(n/2) 次方的话,再来个平方就可以了. 那么按照这个思路就能运用分治的思想了. 代码如下: 1 int _pow(int a,long long n,int m) { 2 if(n==0) return 1 % m; 3 4 l

二进制快速幂及矩阵快速幂

二进制快速幂 二进制快速幂虽然不难写,但是无奈总是会忘,所以还是在这里把板子写一下. 二进制快速幂很好理解: 假设我们要求a^b,那么其实b是可以拆成二进制的,该二进制数第i位的权为2^(i-1),例如当b==11时,11的二进制是1011,11 = 23×1 + 22×0 + 21×1 + 2o×1,因此,我们将a11转化为算 a2^0*a2^1*a2^3 int poww(int a, int b) { int ans = 1, base = a; while (b != 0) { if (

关于快速幂、快速乘、矩阵快速幂

一.快速幂 快速幂是用于解决类似$a^b$ $mod$ $p$值类型的问题的.使用普通的方法是从$1$循环至$b$,再逐次累乘,逐次取模.但这种方法对于$b$很大的时候却可能会超时.那么,这时候我们就需要使用快速幂了. 快速幂是基于以下式子: 若$b$ $mod$ $2=1$,则$a^b=a^\frac{b}{2}\times a^\frac{b}{2}\times a$ 若$b$ $mod$ $2=0$,则$a^b=a^\frac{b}{2}\times a^\frac{b}{2}$ 这样,我

uva 1401 Fast Matrix Operations 快速矩阵操作 (线段树 区间修改和查询)

题意:给一个r行c列的全0矩阵,支持以下三种操作: 1 x1 y1 x2 y2 v 子矩阵(x1 y1 x2 y2)的所有元素增加v 2 x1 y1 x2 y2 v 子矩阵(x1 y1 x2 y2)的所有元素设为v 3 x1 y1 x2 y2   查询子矩阵(x1 y1 x2 y2)的元素和.最小值.最大值. 子矩阵(x1 y1 x2 y2)是指满足 x1 <= x <= x2, y1 <= y <= y2的所有元素(x,y). 矩阵不超过20行,矩阵总元素可多达10^6个. 思路