蒟蒻之省选复习——————连载中

1.筛法

 1 var
 2     n,m,i,x,tot,j                                 :longint;
 3     prime                                         :array[0..10000050] of boolean;
 4     p                                             :array[0..10000050] of longint;
 5 begin
 6     read(n,m);
 7     for i:=2 to n do
 8     begin
 9         if not prime[i] then
10         begin
11             inc(tot);
12             p[tot]:=i;
13         end;
14         for j:=1 to tot do
15         begin
16             if (i*p[j]>n) then break;
17             prime[i*p[j]]:=true;
18             if i mod p[j]=0 then break;
19         end;
20     end;
21     //for i:=1 to tot do prime[p[i]]:=true;
22     for i:=1 to m do
23     begin
24         read(x);
25         if x=1 then writeln(‘No‘) else
26         if (prime[x]) then writeln(‘No‘) else writeln(‘Yes‘);
27     end;
28 end.//prime
 1 var
 2     n,i,j,tot                                   :longint;
 3     nprime                                     :array[0..1000050] of boolean;
 4     p,phi                                    :array[0..1000050] of longint;
 5 begin
 6     read(n);
 7     phi[1]:=1;
 8     for i:=2 to n do
 9     begin
10         if not nprime[i] then
11         begin
12             phi[i]:=i-1;
13             inc(tot);
14             p[tot]:=i;
15         end;
16         for j:=1 to tot do
17         begin
18             if (i*p[j]>n) then break;
19             nprime[i*p[j]]:=true;
20             if (i mod p[j]=0) then
21             begin
22                 phi[i*p[j]]:=phi[i]*p[j];
23                 break;
24             end else phi[i*p[j]]:=phi[i]*(p[j]-1);
25         end;
26     end;
27     for i:=1 to n do write(phi[i],‘ ‘);
28 end.//phi
 1 var
 2     n,i,j,tot                                 :longint;
 3     nprime                                     :array[0..1000050] of boolean;
 4     p,miu                                     :array[0..1000050] of longint;
 5 begin
 6     read(n);
 7     miu[1]:=1;
 8     for i:=2 to n do
 9     begin
10         if not nprime[i] then
11         begin
12             miu[i]:=-1;
13             inc(tot);
14             p[tot]:=i;
15         end;
16         for j:=1 to tot do
17         begin
18             if i*p[j]>n then break;
19             nprime[i*p[j]]:=true;
20             if (i mod p[j]=0) then
21             begin
22                 miu[i*p[j]]:=0;
23                 break;
24             end else miu[i*p[j]]:=-miu[i];
25         end;
26     end;
27     for i:=1 to n do write(miu[i],‘ ‘);
28 end.//miu

2.平衡树——sbt

  1 var
  2     N,i,opt,x,t,tot                                 :longint;
  3     left,right,size,key                             :Array[0..100050] of longint;
  4
  5 procedure lrot(var t:longint);
  6 var
  7     k                                                 :longint;
  8 begin
  9     k:=right[t];
 10     right[t]:=left[k];
 11     left[k]:=t;
 12     size[k]:=size[t];
 13     size[t]:=size[left[t]]+size[right[t]]+1;
 14     t:=k;
 15 end;
 16
 17 procedure rrot(var t:longint);
 18 var
 19     k                                                 :longint;
 20 begin
 21     k:=left[t];
 22     left[t]:=right[k];
 23     right[k]:=t;
 24     size[k]:=size[t];
 25     size[t]:=size[left[t]]+size[right[t]]+1;
 26     t:=k;
 27 end;
 28
 29 procedure maintain(var t:longint; flag:boolean);
 30 begin
 31     if not flag then
 32     begin
 33         if size[left[left[t]]]>size[right[t]] then rrot(t) else
 34         if size[right[left[t]]]>size[right[t]] then
 35         begin
 36             lrot(left[t]);
 37             rrot(t);
 38         end else exit;
 39     end else
 40     begin
 41         if size[right[right[t]]]>size[left[t]] then lrot(t) else
 42         if size[left[right[t]]]>size[left[t]] then
 43         begin
 44             rrot(right[t]);
 45             lrot(t);
 46         end else exit;
 47     end;
 48     maintain(left[t],false);
 49     maintain(right[t],true);
 50     maintain(t,false);
 51     maintain(t,true);
 52 end;
 53
 54 procedure insert(var t:longint; v:longint);
 55 begin
 56     if t=0 then
 57     begin
 58         inc(tot);
 59         t:=tot;
 60         left[t]:=0;
 61         right[t]:=0;
 62         size[t]:=1;
 63         key[t]:=v;
 64         exit;
 65     end;
 66     inc(size[t]);
 67     if v<key[t] then insert(left[t],v) else insert(right[t],v);
 68     maintain(t,v>=key[t]);
 69 end;
 70
 71 function delete(var t:longint; v:longint):longint;
 72 begin
 73     dec(size[t]);
 74     if (v=key[t]) or ((v<key[t]) and (left[t]=0)) or ((v>key[t]) and (right[t]=0)) then
 75     begin
 76         delete:=key[t];
 77         if (left[t]=0) or (right[t]=0) then t:=left[t]+right[t] else key[t]:=delete(left[t],v+1);
 78     end else
 79     if v<key[t] then exit(delete(left[t],v)) else exit(delete(right[t],v));
 80 end;
 81
 82 function rank(var t:longint; v:longint):longint;
 83 begin
 84     if t=0 then exit(1);
 85     if v<=key[t] then exit(rank(left[t],v));
 86     exit(rank(right[t],v)+size[left[t]]+1);
 87 end;
 88
 89 function select(var t:longint; v:longint):longint;
 90 begin
 91     if v=size[left[t]]+1 then exit(key[t]);
 92     if v<size[left[t]]+1 then exit(select(left[t],v));
 93     exit(select(right[t],v-size[left[t]]-1));
 94 end;
 95
 96 function pred(var t:longint; v:longint):longint;
 97 begin
 98     if t=0 then exit(-1);
 99     if v<=key[t] then exit(pred(left[t],v));
100     pred:=pred(right[t],v);
101     if pred=-1 then exit(key[t]);
102 end;
103
104 function succ(var t:longint; v:longint):longint;
105 begin
106     if t=0 then exit(-1);
107     if v>=key[t] then exit(succ(right[t],v));
108     succ:=succ(left[t],v);
109     if succ=-1 then exit(key[t]);
110 end;
111
112 begin
113     read(N);
114     for i:=1 to N do
115     begin
116         read(opt,x);
117         if (opt=1) then insert(t,x) else
118         if (opt=2) then x:=delete(t,x) else
119         if (opt=3) then writeln(rank(t,x)) else
120         if (opt=4) then writeln(select(t,x)) else
121         if (opt=5) then writeln(pred(t,x)) else
122         if (opt=6) then writeln(succ(t,x));
123     end;
124 end.

3.线段树——加法和乘法标签

  1 type
  2     rec                                         =record
  3         l,r                                     :longint;
  4         sum,lz,tg                                 :int64;
  5     end;
  6
  7 var
  8     t                                             :array[0..300050] of rec;
  9     a                                             :array[0..100050] of int64;
 10     N,M,mo,i,opt,x,y                             :longint;
 11     z                                             :int64;
 12
 13 procedure build(x,l,r:longint);
 14 var
 15     mid                                         :longint;
 16 begin
 17     t[x].l:=l; t[x].r:=r; t[x].tg:=1;
 18     if (t[x].l=t[x].r) then
 19     begin
 20         t[x].sum:=a[l] mod mo;
 21         exit;
 22     end;
 23     mid:=(t[x].l+t[x].r)>>1;
 24     build(x*2,l,mid);
 25     build(x*2+1,mid+1,r);
 26     t[x].sum:=(t[x*2].sum+t[x*2+1].sum) mod mo;
 27 end;
 28
 29 procedure update(x:longint);
 30 begin
 31     t[x].sum:=(t[x].sum*t[x].tg+t[x].lz*(t[x].r-t[x].l+1)) mod mo;
 32     if (t[x].l=t[x].r) then
 33     begin
 34         t[x].tg:=1;
 35         t[x].lz:=0;
 36         exit;
 37     end;
 38     t[x*2].tg:=(t[x*2].tg*t[x].tg) mod mo;
 39     t[x*2+1].tg:=(t[x*2+1].tg*t[x].tg) mod mo;
 40     t[x*2].lz:=(t[x*2].lz*t[x].tg+t[x].lz) mod mo;
 41     t[x*2+1].lz:=(t[x*2+1].lz*t[x].tg+t[x].lz) mod mo;
 42     t[x].tg:=1;
 43     t[x].lz:=0;
 44 end;
 45
 46 procedure c_tg(x,l,r:longint; y:int64);
 47 var
 48     mid                                         :longint;
 49 begin
 50     if (t[x].lz<>0) or (t[x].tg<>1) then update(x);
 51     if (t[x].l=l) and (t[x].r=r) then
 52     begin
 53         t[x].tg:=(t[x].tg*y) mod mo;
 54         exit;
 55     end;
 56     mid:=(t[x].l+t[x].r)>>1;
 57     if l>mid then c_tg(x*2+1,l,r,y) else
 58     if r<=mid then c_tg(x*2,l,r,y) else
 59     begin
 60         c_tg(x*2,l,mid,y);
 61         c_tg(x*2+1,mid+1,r,y);
 62     end;
 63     t[x].sum:=(t[x*2].sum*t[x*2].tg+t[x*2].lz*(t[x*2].r-t[x*2].l+1)+
 64         t[x*2+1].sum*t[x*2+1].tg+t[x*2+1].lz*(t[x*2+1].r-t[x*2+1].l+1)) mod mo;
 65 end;
 66
 67 procedure c_lz(x,l,r:longint; y:int64);
 68 var
 69     mid                                         :longint;
 70 begin
 71     if (t[x].lz<>0) or (t[x].tg<>1) then update(x);
 72     if (t[x].l=l) and (t[x].r=r) then
 73     begin
 74         t[x].lz:=(t[x].lz+y) mod mo;
 75         exit;
 76     end;
 77     mid:=(t[x].l+t[x].r)>>1;
 78     if l>mid then c_lz(x*2+1,l,r,y) else
 79     if r<=mid then c_lz(x*2,l,r,y) else
 80     begin
 81         c_lz(x*2,l,mid,y);
 82         c_lz(x*2+1,mid+1,r,y);
 83     end;
 84     t[x].sum:=(t[x*2].sum*t[x*2].tg+t[x*2].lz*(t[x*2].r-t[x*2].l+1)+
 85         t[x*2+1].sum*t[x*2+1].tg+t[x*2+1].lz*(t[x*2+1].r-t[x*2+1].l+1)) mod mo;
 86 end;
 87
 88 function find(x,l,r:longint):int64;
 89 var
 90     mid                                         :longint;
 91 begin
 92     if (t[x].lz<>0) or (t[x].tg<>1) then update(x);
 93     if (t[x].l=l) and (t[x].r=r) then exit(t[x].sum mod mo);
 94     mid:=(t[x].l+t[x].r)>>1;
 95     if l>mid then exit(find(x*2+1,l,r)) else
 96     if r<=mid then exit(find(x*2,l,r)) else
 97         exit((find(x*2,l,mid)+find(x*2+1,mid+1,r)) mod mo);
 98 end;
 99
100 begin
101     read(N,M,mo);
102     for i:=1 to N do read(a[i]);
103     build(1,1,N);
104     for i:=1 to M do
105     begin
106         read(opt);
107         if opt=1 then
108         begin
109             read(x,y,z);
110             c_tg(1,x,y,z);
111         end else
112         if opt=2 then
113         begin
114             read(x,y,z);
115             c_lz(1,x,y,z);
116         end else
117         begin
118             read(x,y);
119             writeln(find(1,x,y));
120         end;
121     end;
122 end.
时间: 2024-10-09 23:47:49

蒟蒻之省选复习——————连载中的相关文章

蒟蒻的省选复习————连载中

1.筛法 1 var 2 n,m,i,x,tot,j :longint; 3 prime :array[0..10000050] of boolean; 4 p :array[0..10000050] of longint; 5 begin 6 read(n,m); 7 for i:=2 to n do 8 begin 9 if not prime[i] then 10 begin 11 inc(tot); 12 p[tot]:=i; 13 end; 14 for j:=1 to tot do

蒟蒻林荫的小复习——主席树

主席树也就是指可持久化线段树,大致思想也就是每次利用之前的重复信息,只为被更新的一部分开辟新点.而且所谓可持久化线段树实际上是指可持久化权值线段树,线段树中每个端点存的是这个端点所代表的树的出现次数. 而在主席树的维护当中对于每个历史版本如果都开一颗新树,那么M将是最终的结局.正确解法则是为每一个改变的点分配编号而未改变的点直接链接到新树上. 下面就来从主席树的两个经典问题来考虑 1:区间第K小问题 传送门 首先分析问题,给出一个序列,每次给定一个封闭区间,求这个封闭区间以内的最小值. 上面我们

蒟蒻林荫小复习——关于有限制区间元素查询的一些解法

如题:本文主要说明对于区间有限制查询的一些解法(其实就两种) 问题1:给定一个数列,要求查询区间L—R中所有大于等于Va小于等于Vb的元素和 解法: 1.线段树套权值线段树 第一维维护区间,第二维作为权值线段树,维护值域在A—B之间的元素之和 每次查询就从第一维拉到对应区间,然后用Va和Vb确定在权值线段树中的查询范围即可 2.分块 分块数组记为a,对每一个a块都开一个数组b,b数组将a块中元素拷贝后排序,新建c,对于每一个b都求前缀和 这样对于整块而言,用二分确定Va和Vb在b数组中的位置Ia

[蒟蒻实验室]Ep.1背包退火!

[蒟蒻实验室]Ep.1背包退火! · FBI Warning · 新算法:背包退火! · 本文所包含的思路来自于NCC79601巨佬的启迪Orz ·算法剖析 简单来讲,背包退火就是用模拟退火的思路解决某些类型的背包问题,继承了模拟退火的玄学复杂度,也继承了它的不稳定性,所以能够有效地解决大背包问题的TLE问题.这个算法能够把数十行的代码优化部分转移为 洗把脸 调参的问题. 例题 :LuoGuP1049[装箱问题] 有一个箱子容量为V,同时有n个物品,每个物品有一个体积vi.要求n个物品中,任取若

关于如何食用Xcode——用mac的小蒟蒻

前言QwQ 对于一只用Mac的小蒟蒻,没有Dev_c++简直太难受了,用在线IDE写代码又没法保存,那么我们怎么办呢? 好在App Store里有这个好东西 所以我们今天来介绍一下 “如何使用Xcode” 0x00 新建文件 Step 1 :打开Xcode 会看到这样的一个界面->  Step 2 :选择中间的"Create a new Xcode project" Step 3 :一定要选macOS下的Command Line Tool (我就是因为没看到找了半天) Step

dp专场的蒟蒻题解

前言:一直想练练dp,正好衣神弄了个训练赛..上次看cgold大佬的题解心血来潮所以自己试着写了第一次题解..可惜本蒟蒻的能力太差有两道题做不太出,只好搬运学习其它大佬的题解了.. a题 https://vjudge.net/contest/355951#problem/A 这题做题的过程十分痛苦 我又双叒叕看错题意了.. 以为是必须在对角线上 其实是随便n*n的都行.. 大概思路是从一个角开始更新,统计左边和上边相同的长度 #include <iostream> #include <c

蒟蒻ACMer回忆录 &#183; 一段弱校ACM的奋斗史

三年半的ACM生涯终于迎来了终点,退役之时,感慨万分,故写此文以纪念逝去的时光,那些为ACM拼搏的日子,那段弱校ACM的奋斗史. 三年半的ACM生涯,窝见证了CUMT从打铁到铜牌的突破,又见证了从铜牌到银牌的突破:见证了集训队员从3人发展到10余人,又见证了ACM实验室的落实. 三年半的ACM生涯,窝经历了太多,有Accepted时的欢笑,有Wrong Answer时的沮丧,有Time Limit Exceeded时的无奈,有Runtime Error时的尴尬,有打铁的失落,有拿牌的惊喜. 13

算法描述》LCA两三事(蒟蒻向)

LCA是图论中常用的解决树形结构子问题的工具,这一问题一般需要用一个简短的子函数直接解决,但是这对于广大蒟蒻们仍然是一个不小的问题. LCA是指在树形结构中两点的最近公共祖先,对于这个问题,直接向上找事最直接的方法,但同时时间复杂度和数据给出的生成树的层数有关,最优情况是logN级别的,但是如果数据给出的是一条链就GG了,所以要用更优的方法写,一般来说,用的是log2N的操作,最糟糕的复杂度也是logN级别的,那如何实现这一过程捏,我这里有两种方法,和大家分享 第一种:树上倍增 具体方法是对于已

bzoj 4636: 蒟蒻的数列

4636: 蒟蒻的数列 Description 蒟蒻DCrusher不仅喜欢玩扑克,还喜欢研究数列 题目描述 DCrusher有一个数列,初始值均为0,他进行N次操作,每次将数列[a,b)这个区间中所有比k小的数改为k,他想知 道N次操作后数列中所有元素的和.他还要玩其他游戏,所以这个问题留给你解决. Input 第一行一个整数N,然后有N行,每行三个正整数a.b.k. N<=40000 , a.b.k<=10^9 Output 一个数,数列中所有元素的和 Sample Input 4 2 5