├── README.md ├── Исходники Трухановича Влада ├── Combinatoric │ └── Permutations │ │ ├── Number_to_permutation.cpp │ │ └── Permutation_to_number.cpp ├── Games │ └── Grandi(timus_1540).cpp ├── Mat │ ├── Bin_pow.cpp │ ├── Ewklid+Diophant.cpp │ ├── GCD.cpp │ ├── Gauss.cpp │ ├── diskr_log.CPP │ ├── eiler_function.cpp │ ├── faktoring.CPP │ ├── generator.CPP │ ├── miller-rabin.cpp │ ├── obr_el.cpp │ ├── Решето_Эратосфена.cpp │ └── делители.cpp ├── NP │ ├── Kommivoager.cpp │ ├── Meet_in_the_middle.cpp │ ├── simulated_annealing_queens.cpp │ ├── simulated_annealing_salesman_1.cpp │ └── simulated_annealing_salesman_2.cpp ├── OTHER │ ├── LIS.cpp │ ├── Parket(broken).cpp │ ├── Parket(broken,O(2^n) memory).cpp │ ├── Parket.cpp │ └── fast input and output.cpp ├── Strings │ ├── Aho - Corasic.cpp │ ├── KMP.cpp │ ├── Palindroms.cpp │ ├── Z.cpp │ ├── hash.cpp │ └── suf_aut │ │ ├── 0 - is_substr.cpp │ │ ├── 1 - length_of_substrings.cpp │ │ ├── 2 - count_of_substrings.cpp │ │ ├── 3 - min_lex_shift.cpp │ │ └── 4 - LCS.cpp ├── Геометрия │ ├── Convex_hull.cpp │ ├── line.cpp │ ├── line_intersection.cpp │ └── triangle_area.cpp ├── Графы │ ├── 00 - init.cpp │ ├── 01 - dfs.cpp │ ├── 02 - min_ost.cpp │ ├── 03 - floid.cpp │ ├── 04 - ford - bellman.cpp │ ├── 05 - dejkstr.cpp │ ├── 05.5 - dejkstr_heap.cpp │ ├── 06 - eiler.cpp │ ├── 07 - topolog.cpp │ ├── 08 - max_flow.cpp │ ├── 09 - Strong_Connected_Components.cpp │ ├── 10 - Bridges.cpp │ ├── 11 - Cutpoints.cpp │ ├── 12 - LCA_SPUSK.cpp │ ├── 13 - Dinic.cpp │ ├── 14 - Min_cost_flow.cpp │ └── 15 - hldot(USACO_DEC11_GRASSPLAINTING).cpp └── Структуры данных │ ├── DSU.cpp │ ├── Hash │ ├── Hash_map.cpp │ └── Hash_set.cpp │ ├── SQRT_decomposition.cpp │ ├── Treap │ ├── 1.cpp │ ├── Implicit_treap.cpp │ ├── Implicit_treap_reverse.cpp │ ├── Implict_treap_with_sum_and_coloring_on_the_interval.cpp │ ├── Treap_with_sum_and_add_on_the_interval.cpp │ ├── Treap_with_sum_on_the_interval.cpp │ ├── UPIT(build - O(N)).cpp │ ├── UPIT(build - O(N),fast input).cpp │ ├── UPIT.cpp │ ├── din.txt │ ├── kth.cpp │ ├── pointers │ │ ├── Implict_treap_reverse.cpp │ │ ├── Reverse_2D.cpp │ │ └── Treap_pointers.cpp │ └── treap_my.cpp │ ├── queue_with_min-O(1).cpp │ ├── Деревья_отрезков │ ├── RMQ(ONE).cpp │ ├── RMQ(int).cpp │ ├── RSQ(ONE).cpp │ ├── RSQ(int).cpp │ ├── e-maxx │ │ ├── Interval-modification(e-maxx).cpp │ │ ├── RMQ(e-maxx).cpp │ │ └── RSQ(e-maxx).cpp │ ├── min_value_lower_x.cpp │ └── persistent │ │ ├── COT.cpp │ │ ├── Kth_on_interval.cpp │ │ ├── Kth_on_interval_pointers.cpp │ │ ├── Sum.cpp │ │ └── Sum_pointers.cpp │ └── Деревья_фенвика │ ├── Summator.cpp │ ├── maximator.cpp │ └── maximizator.cpp └── Сборник моих алгоритмов ├── Ввод и вывод через nolock.cpp ├── Геометрия ├── Выпуклая оболочка.cpp ├── Нахождение длины отрезка.cpp ├── Пересечение отрезков.cpp ├── Площадь многоугольника.cpp └── Площадь прямоугольников.cpp ├── Графы ├── BFS.cpp ├── DFS.cpp ├── LCA-offline(алгоритм Тарьяна).cpp ├── LCA.cpp ├── Алгоритм Диница.cpp ├── Дейкстра(через кучу).cpp ├── Задание графа списком рёбер.cpp ├── Краскал.cpp ├── Проверка графа на двудольность.cpp ├── Топологическая сортировка.cpp ├── Форд-Беллман.cpp ├── Эдмондс-Карп с масштабированием.cpp └── Эйлеров путь.cpp ├── ДП(наиболее типичные) ├── ДП по профилю(паркет).cpp ├── Неограниченный рюкзак.cpp └── Рюкзак(с восстановлением ответа).cpp ├── Изученные алгоритмы.txt ├── Самописный ввод и вывод.cpp ├── Скрипты для самотестирования ├── all.bat └── one.bat ├── Строки ├── Hash.cpp ├── Z.cpp ├── Ахо-Корасик.cpp ├── КМП и его применения.cpp ├── ОПН.cpp ├── Рабин-Карп.cpp └── Суффиксный автомат.cpp ├── Структуры ├── DSU.cpp ├── Hash-map.cpp ├── Hash-set.cpp ├── RMQ с присвоением на отрезке.cpp ├── RMQ.cpp ├── RSQ с обновлением на отрезке.cpp ├── RSQ.cpp ├── SQRT-decomposition.cpp ├── Sparse table.cpp ├── Двумерное дерево Фенвика.cpp ├── Двумерное дерево отрезков.cpp ├── Декартово дерево по неявному ключу с множественными операцими на отрезке и реверсом.cpp ├── Декартово дерево(с явным ключом и суммой и обновлением на отрезке).cpp ├── Дерево Фенвика(для суммы).cpp ├── Очередь за O(1).cpp └── Персистентное дерево отрезков(к-ая статистика на отрезке).cpp └── Теория чисел ├── GCD.cpp ├── LCM.cpp ├── Meet-in-the-meedle(составление числа).cpp ├── Meet-in-the-middle(рюкзак).cpp ├── Quicksort.cpp ├── Бинарное возведение в степень.cpp ├── Диофант через Евклида.cpp ├── Дихотомия.cpp ├── Длинная арифметика.cpp ├── Миллер-Рабин.cpp ├── Нахождение n-ого числа Фибоначчи за log N.cpp ├── Нахождение делителей(и их количества) числа за sqrt(N).cpp ├── Перебор битмасками.cpp ├── Перебор всех подмасок данной маски.cpp ├── Перевод между системами счисления(меньше либо равно 10).cpp ├── Решето Эратосфена(не блочное).cpp ├── Тернарный поиск.cpp └── Факторизация.cpp /README.md: -------------------------------------------------------------------------------- 1 | У меня проекта пока что как такого и нет.Я просто решил залить на github все свои и не только свои исходники по спортивному 2 | программированию, чтобы иметь к ним доступ с любой точки Земли(если Интернет есть там=) ).Да и и другим людям тоже может пригодиться. 3 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Combinatoric/Permutations/Number_to_permutation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int n; 4 | long long f[21],k; 5 | int a[21],b[21]; 6 | 7 | void init(){ 8 | f[0]=1; 9 | for (int i=1;i<=20;i++) f[i]=f[i-1]*i; 10 | scanf("%d%I64d",&n,&k);--k; 11 | } 12 | 13 | int main(){ 14 | init(); 15 | for (int i=1;i<=n;i++){ 16 | int q=k/f[n-i]+1; 17 | k%=f[n-i]; 18 | int c=0; 19 | for (int j=1;j<=n;j++){ 20 | if (!b[j]) ++c; 21 | if (c==q){ 22 | b[j]=1; 23 | a[i]=j; 24 | break; 25 | } 26 | } 27 | } 28 | for (int i=1;i<=n;i++) printf("%d ",a[i]); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Combinatoric/Permutations/Permutation_to_number.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int n; 4 | long long f[21],k; 5 | int a[21],b[21]; 6 | 7 | void init(){ 8 | f[0]=1; 9 | for (int i=1;i<=20;i++) f[i]=f[i-1]*i; 10 | scanf("%d",&n); 11 | for (int i=1;i<=n;i++) scanf("%d",&a[i]); 12 | } 13 | 14 | int main(){ 15 | init(); 16 | for (int i=1;i<=n;i++){ 17 | int c=0; 18 | for (int j=1;j 3 | #include 4 | #include 5 | #define N 55 6 | 7 | using namespace std; 8 | 9 | int len[N],g[N][N+N][N+N],a[N][N],t[N],c; 10 | 11 | inline int mex(){ 12 | sort(t,t+c); 13 | if (t[0]!=0) return 0; 14 | for (int i=1;i1) return t[i-1]+1; 15 | return t[c-1]+1; 16 | } 17 | 18 | void calc(int num,int l,int r){ 19 | for (int i=l;i<=r;++i){ 20 | int go=a[num][i],pos; 21 | for (pos=l;a[num][pos]<=go && pos<=r;++pos); 22 | for (int j=pos;j<=r+1;++j) 23 | if (a[num][j]<=go || j==r+1){ 24 | if (pos<=j-1 && g[num][pos][j-1]==-1) calc(num,pos,j-1); 25 | pos=j+1; 26 | } 27 | } 28 | c=0; 29 | for (int i=l;i<=r;++i){ 30 | int go=a[num][i],pos,ans=0; 31 | for (pos=l;a[num][pos]<=go && pos<=r;++pos); 32 | for (int j=pos;j<=r+1;++j) 33 | if (a[num][j]<=go || j==r+1){ 34 | if (pos<=j-1) ans^=g[num][pos][j-1]; 35 | pos=j+1; 36 | } 37 | t[c++]=ans; 38 | } 39 | g[num][l][r]=mex(); 40 | } 41 | 42 | inline bool good(int n,int num,int go){ 43 | int ans=0; 44 | for (int i=1;i<=n;i++) if (i!=num) ans^=g[i][1][len[i]]; 45 | int pos; 46 | for (pos=1;a[num][pos]<=go && pos<=len[num];++pos); 47 | for (int j=pos;j<=len[num]+1;++j) 48 | if (a[num][j]<=go || j==len[num]+1){ 49 | if (pos<=j-1) ans^=g[num][pos][j-1]; 50 | pos=j+1; 51 | } 52 | return ans==0; 53 | } 54 | 55 | int main(){ 56 | // freopen("input.txt","r",stdin); 57 | int n,ans=0; 58 | scanf("%d",&n); 59 | for (int i=1;i<=n;++i){ 60 | scanf("%d",&len[i]); 61 | for (int j=1;j<=len[i];++j) scanf("%d",&a[i][j]); 62 | } 63 | memset(g,255,sizeof(g)); 64 | for (int i=1;i<=n;++i) for (int j=1;j<=len[i];++j) g[i][j][j]=1; 65 | for (int i=1;i<=n;++i) if (len[i]!=1) calc(i,1,len[i]); 66 | for (int i=1;i<=n;++i) ans^=g[i][1][len[i]]; 67 | if (!ans) puts("S"); 68 | else { 69 | puts("G"); 70 | for (int i=1;i<=n;++i) for (int j=1;j<=len[i];++j) 71 | if (good(n,i,a[i][j])){ 72 | printf("%d %d\n",i,j); 73 | return 0; 74 | } 75 | } 76 | return 0; 77 | } 78 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/Bin_pow.cpp: -------------------------------------------------------------------------------- 1 | //O(logY) 2 | #include 3 | using namespace std; 4 | 5 | long long binpow(long long x,long long y){ 6 | long long ans=1; 7 | while (y){ 8 | if (y&1) ans*=x; 9 | x*=x; 10 | y>>=1; 11 | } 12 | return ans; 13 | } 14 | 15 | int main(void){ 16 | long long x,y,ans; 17 | cin>>x>>y; 18 | cout<>ans; 20 | } 21 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/Ewklid+Diophant.cpp: -------------------------------------------------------------------------------- 1 | //O(log) 2 | #include 3 | 4 | using namespace std; 5 | 6 | int gcd (int a, int b, int & x, int & y) { 7 | if (a==0){ 8 | x=0; 9 | y=1; 10 | return b; 11 | } 12 | int x1,y1; 13 | int d=gcd(b%a,a,x1,y1); 14 | x=y1-(b/a)*x1; 15 | y=x1; 16 | return d; 17 | } 18 | 19 | int main(void){ 20 | int A,B,X,Y; 21 | cin>>A>>B; 22 | cout<>Y; 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/GCD.cpp: -------------------------------------------------------------------------------- 1 | //O(log) 2 | #include 3 | 4 | using namespace std; 5 | 6 | long long gcd(long long x,long long y){ 7 | return y?gcd(y,x%y):x; 8 | } 9 | 10 | int main(void){ 11 | long long a,b; 12 | cin>>a>>b; 13 | cout<>a; 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/Gauss.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define forn(I,B) for (int I=1;I<=(B);I++) 5 | 6 | using namespace std; 7 | 8 | const int N=111; 9 | const double eps=1e-9; 10 | 11 | double a[N][N],ans[N]; 12 | int n,m,where[N],k=-1; 13 | 14 | int main(){ 15 | cin>>n>>m; 16 | forn(i,n) forn(j,m) cin>>a[i][j]; 17 | forn(i,m-1) where[i]=-1; 18 | for (int col=1,row=1;colabs(a[sel][col])) sel=i; 22 | if (abs(a[sel][col])eps) k=0; 36 | } 37 | if (k!=0){ 38 | forn(i,m-1) if (where[i]==-1) k=2; 39 | if (k!=2) k=1; 40 | } 41 | cout< 3 | #include 4 | 5 | using namespace std; 6 | 7 | int f(int n){ 8 | int i,res=n,en=sqrt(n); 9 | for (i=2;i<=en;i++) if (n%i==0){ 10 | while (n%i==0) n/=i; 11 | res-=res/i; 12 | } 13 | if (n>1) res-=res/n; 14 | return res; 15 | } 16 | 17 | int main(void){ 18 | int x; 19 | while(cin>>x) cout<>x; 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/faktoring.CPP: -------------------------------------------------------------------------------- 1 | // O(X^0.5) 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | void fact(int n){ 8 | int i,en=sqrt(n); 9 | for (i=2;i<=en;i++) if (n%i==0){ 10 | while (n%i==0) n/=i; 11 | cout<1) cout<>x; 19 | fact(x); 20 | cin>>x; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/generator.CPP: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zamazan4ik/Algorithms/5d91d76aa9235f5da3c198dcbfe4468609955d0c/Исходники Трухановича Влада/Mat/generator.CPP -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/miller-rabin.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define ll long long 5 | 6 | using namespace std; 7 | 8 | inline ll mulmod(ll x,ll y,ll m){ 9 | ll ans=0; 10 | while (y){ 11 | if (y&1) ans=(ans+x)%m; 12 | x=(x+x)%m; 13 | y>>=1; 14 | } 15 | return ans; 16 | } 17 | 18 | inline ll powmod(ll x,ll y,ll m){ 19 | ll ans=1; 20 | while (y){ 21 | if (y&1) ans=mulmod(ans,x,m); 22 | x=mulmod(x,x,m); 23 | y>>=1; 24 | } 25 | return ans; 26 | } 27 | 28 | 29 | inline bool check(int m){ 30 | int s=0,t=m-1,x,a=((rand()*rand())%(m-3))+2; 31 | while (!(t&1)){ 32 | ++s; 33 | t>>=1; 34 | } 35 | x=powmod(a,t,m); 36 | if (x==1 || x==m-1) return true; 37 | while(--s){ 38 | x=mulmod(x,x,m); 39 | if (x==1) return false; 40 | if (x==m-1) return true; 41 | } 42 | return false; 43 | } 44 | 45 | inline bool test(ll x,int r){ 46 | if (x==2 || x==3) return true; 47 | if (x==1 || !(x&1)) return false; 48 | if (x<=100){ 49 | if (x%3==0) return 0; 50 | for (ll i=5;i*i<=x;i+=6){ 51 | if (x%i==0) return 0; 52 | if (x%(i+2)==0) return 0; 53 | } 54 | return 1; 55 | } 56 | bool ok=true; 57 | while (r-- && ok) ok&=check(x); 58 | return ok; 59 | } 60 | 61 | int main(){ 62 | srand(time(NULL)); 63 | ll f; 64 | cin>>f; 65 | cout< 3 | #define maxn 300000 4 | 5 | int n,i,j; 6 | bool b[maxn]; 7 | 8 | int main(void){ 9 | scanf("%d",&n); 10 | freopen("out.out","w",stdout); 11 | b[0]=b[1]=true; 12 | for (i=2;i*i<=n;i++) 13 | if (!b[i]) for (j=i*i;j<=n;j+=i) b[j]=true; 14 | for (i=1;i<=n;i++) if (!b[i]) printf("%d ",i); 15 | return 0; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Mat/делители.cpp: -------------------------------------------------------------------------------- 1 | // O(N^0.5) 2 | #include 3 | 4 | using namespace std; 5 | 6 | int f(int x,int p=0){ 7 | int c=0; 8 | for (int i=2;i*i<=x;i++){ 9 | if (x%i==0){ 10 | if (p) cout<>x) f(x,1); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/NP/Kommivoager.cpp: -------------------------------------------------------------------------------- 1 | #pragma comment(linker, "/STACK:65777216") 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=14; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | int g[N][N],n,f[N][1< 2 | #include 3 | #define N 22 4 | using namespace std; 5 | 6 | int a[N],b[N],c[N],n,s1[1111],s2[1111],m,k,ans=1111111111,sum; 7 | 8 | void init(){ 9 | scanf("%d",&n); 10 | for (int i=1;i<=n;i++){ 11 | scanf("%d",&a[i]); 12 | sum+=a[i]; 13 | } 14 | m=n/2,k=n-n/2; 15 | for (int i=1;i<=m;i++) b[i]=a[i]; 16 | for (int i=1;i<=k;i++) c[i]=a[i+m]; 17 | } 18 | 19 | int main(){ 20 | init(); 21 | for (int i=0;i<(1<sum/2-s1[i] && p) --p; 35 | p=s2[p]; 36 | ans=min(ans,abs(sum-s1[i]-s1[i]-p-p)); 37 | } 38 | printf("%d\n",ans); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/NP/simulated_annealing_queens.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #define memo(A) memset(A,0,sizeof(A)) 7 | #define rep(I,B) for (int I=0;I<(B);I++) 8 | #define N 1111 9 | 10 | using namespace std; 11 | 12 | 13 | int n,a[N],g[N],ba[N],ans,dsum[N],ddif[N]; 14 | 15 | inline double get_rand(){ 16 | return ((rand()*1ll*rand()*rand())%1000000001)/1000000000.0; 17 | } 18 | 19 | inline void get_next(int k) { 20 | int p[N],r[N]; 21 | rep(i,n) p[i]=r[i]=i; 22 | rep(i,k) swap(p[i],p[n-1-rand()%(n-i)]); 23 | for (int i=k-1;i>0;i--) swap(r[i],r[rand()%(i+1)]); 24 | rep(i,n) g[i]=a[i]; 25 | rep(i,k) g[p[i]]=a[p[r[i]]]; 26 | } 27 | 28 | inline int eval(){ 29 | int res=0; 30 | memo(dsum);memo(ddif); 31 | rep(i,n){ 32 | res+=dsum[i+g[i]]; 33 | ++dsum[i+g[i]]; 34 | res+=ddif[i-g[i]+n]; 35 | ++ddif[i-g[i]+n]; 36 | } 37 | return res; 38 | } 39 | 40 | inline double prob(int cur,int nw,double t){ 41 | int delta=nw-cur; 42 | if (delta<0) return 1.0; 43 | else return exp(-delta/t); 44 | } 45 | 46 | int main(){ 47 | srand(time(NULL)); 48 | scanf("%d",&n); 49 | int cure; 50 | rep(i,n) g[i]=i; 51 | random_shuffle(g,g+n); 52 | rep(i,n) a[i]=ba[i]=g[i]; 53 | cure=ans=eval(); 54 | double mxt=20.0; 55 | for (double t=mxt;ans;t*=0.98){ 56 | int k=max(2,(int)(t/mxt*n)); 57 | get_next(k); 58 | int ne=eval(); 59 | if (prob(cure,ne,t)>=get_rand()){ 60 | cure=ne; 61 | rep(i,n) a[i]=g[i]; 62 | } 63 | if (cure 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=222222; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | int n,a[N],ptr,g[N]; 46 | bool b[N]; 47 | ld ans=0,x[N],y[N],t=100.0,minans,t0=100.0; 48 | 49 | inline ld dist(int i,int j){ 50 | return (sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j]))); 51 | } 52 | 53 | void solve_greedy(){ 54 | int cur=0; 55 | b[0]=1;a[ptr++]=0; 56 | rep(steps,n-1){ 57 | int num=-1; 58 | rep(i,n) if (!b[i] && (num==-1 || dist(cur,num)>dist(cur,i))) num=i; 59 | ans+=dist(cur,num); 60 | cur=num; 61 | a[ptr++]=cur; 62 | b[cur]=a; 63 | } 64 | ans+=dist(a[ptr-1],0); 65 | minans=ans; 66 | } 67 | 68 | inline ld get_ans(){ 69 | ld cur=0; 70 | g[n]=0; 71 | rep(i,n) cur+=dist(g[i],g[i+1]); 72 | return cur; 73 | } 74 | 75 | inline void get_next(){ 76 | int k=n*(t/t0); 77 | if (k<2) k=2; 78 | rep(i,n) g[i]=a[i]; 79 | while(k--){ 80 | int num1=rand()%(n-1); 81 | while (g[num1]==0) num1=rand()%(n-1); 82 | swap(g[num1],g[num1+1]); 83 | } 84 | } 85 | 86 | inline ld get_rand(){ 87 | return ((rand()*1ll*rand())%1000001)/1000000.0; 88 | } 89 | 90 | int main(){ 91 | ropen("input.txt"); 92 | wopen("output.txt"); 93 | srand(time(NULL)); 94 | cin>>n; 95 | rep(i,n) cin>>x[i]>>y[i]; 96 | solve_greedy(); 97 | int k=20000; 98 | while (k--){ 99 | get_next(); 100 | ld ff=get_ans(); 101 | if (ff 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=2222; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | int n,a[N],g[N]; 46 | ld x[N],y[N]; 47 | 48 | inline ld get_rand(){ 49 | return ((rand()*1ll*rand()*rand())%1000000001)/1000000000.0; 50 | } 51 | 52 | inline void getRC(int *res,int m){ 53 | rep(i,n) res[i]=i; 54 | rep(i,m){ 55 | int j=n-1; 56 | if (n-i>0) j-=rand()%(n-i); 57 | swap(res[i],res[j]); 58 | } 59 | } 60 | 61 | inline void getRP(int *res,int m){ 62 | rep(i,n) res[i]=i; 63 | for (int i=m-1;i>0;i--){ 64 | int j=rand()%(i+1); 65 | swap(res[i],res[j]); 66 | } 67 | } 68 | 69 | inline void get_next(int changes) { 70 | int p[N],r[N]; 71 | getRC(p,changes); 72 | getRP(r,changes); 73 | rep(i,n) g[i]=a[i]; 74 | rep(i,changes) g[p[i]]=a[p[r[i]]]; 75 | } 76 | 77 | inline ld eval(){ 78 | ld res=0; 79 | g[n]=g[0]; 80 | rep(i,n) res+=sqrt(sqr(x[g[i]]-x[g[i+1]])+sqr(y[g[i]]-y[g[i+1]])); 81 | return res; 82 | } 83 | 84 | inline ld prob(ld cur,ld nw,ld t){ 85 | ld delta=nw-cur; 86 | if (delta<0) return 1.0; 87 | else return exp(-delta/t); 88 | } 89 | 90 | ld solve_greedy(){ 91 | int cur=0,ptr=0; 92 | ld ans=0.0; 93 | bool b[N];memo(b); 94 | b[0]=1;a[ptr++]=0; 95 | rep(steps,n-1){ 96 | int num=-1; 97 | rep(i,n) if (!b[i] && (num==-1 || sqr(x[cur]-x[num])+sqr(y[cur]-y[num])>sqr(x[cur]-x[i])+sqr(y[cur]-y[i]))) num=i; 98 | ans+=sqrt(sqr(x[cur]-x[num])+sqr(y[cur]-y[num])); 99 | cur=num; 100 | a[ptr++]=cur; 101 | b[cur]=1; 102 | } 103 | ans+=sqrt(sqr(x[a[n-1]]-x[0])+sqr(y[a[n-1]]-y[0])); 104 | return ans; 105 | } 106 | 107 | void anneal(){ 108 | ld ans,minans; 109 | ans=minans=solve_greedy(); 110 | ld mxt=100.0; 111 | for (ld curt=mxt;curt>0.01;curt*=0.999){ 112 | int changes=max(2,(int)(curt/mxt*n)); 113 | get_next(changes); 114 | ld nw=eval(); 115 | ld ff=prob(ans,nw,curt); 116 | if (ff>=get_rand()){ 117 | ans=nw; 118 | rep(i,n+1) a[i]=g[i]; 119 | } 120 | if (ans 3 | #define maxn 1111 4 | #define inf 1111111111 5 | 6 | using namespace std; 7 | 8 | int f[maxn],m[maxn],l[maxn],r[maxn],a[maxn],n; 9 | 10 | int prev(int x){ 11 | return (x&(x-1)); 12 | } 13 | 14 | int next(int x){ 15 | return ((x<<1)-prev(x)); 16 | } 17 | 18 | void modify(int pos,int value){ 19 | int p; 20 | for (p=pos;p<=n;p=next(p)) r[p]=max(r[p],value); 21 | m[pos]=max(m[pos],value); 22 | for (p=pos;p>0;p=prev(p)) l[p]=max(l[p],value); 23 | } 24 | 25 | int findmax(int ll, int rr){ 26 | int res,p; 27 | res=-inf; 28 | for (p=ll;next(p)<=rr;p=next(p)) res=max(res,l[p]); 29 | res=max(res,m[p]); 30 | for (p=rr;prev(p)>=ll;p=prev(p)) res=max(res,r[p]); 31 | return res; 32 | } 33 | 34 | void init(void){ 35 | cin>>n; 36 | for (int i=1;i<=n;i++) 37 | cin>>a[i]; 38 | } 39 | 40 | int main(void){ 41 | init(); 42 | for (int i=1;i<=n;i++){ 43 | int mx=findmax(1,a[i]-1); 44 | f[a[i]]=max(f[a[i]],mx+1); 45 | modify(a[i],f[a[i]]); 46 | } 47 | for (int i=1;i<=n;i++) cout<>n; 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/OTHER/Parket(broken).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define N 19 3 | #define rep(I,B) for (int I=0;I<(B);I++) 4 | 5 | int f[N][N][1< 2 | #define N 26 3 | #define rep(I,B) for (int I=0;I<(B);I++) 4 | 5 | int f[2][1< 2 | #define rep(I,B) for (int I=0;I<(B);I++) 3 | #define N 20 4 | using namespace std; 5 | 6 | long long f[N][1<=m) f[x+1][next_mask]+=f[x][mask]; 11 | else { 12 | int cur=1<>n>>m; 23 | int lim=1< 2 | 3 | int res; 4 | char s; 5 | 6 | inline int getInt(){ 7 | res=0; 8 | do{ 9 | s=getchar(); 10 | } while (s<'0' || s>'9'); 11 | do{ 12 | res=res*10+s-'0'; 13 | s=getchar(); 14 | } while (s>='0' && s<='9'); 15 | return res; 16 | } 17 | 18 | void put(int x){ 19 | if (x){ 20 | put(x/10); 21 | putchar(x%10+'0'); 22 | } 23 | } 24 | 25 | inline void putInt(int x){ 26 | if (x) put(x); 27 | else putchar('0'); 28 | putchar('\n'); 29 | } 30 | 31 | int main(){ 32 | int x=getInt(); 33 | putInt(x+1); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Strings/Aho - Corasic.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #define N 111111 6 | #define K 26 7 | using namespace std; 8 | 9 | struct bor{ 10 | int next[K],go[K]; 11 | int link,p; 12 | bool leaf; 13 | char pch; 14 | } t[N]; 15 | int sz; 16 | 17 | void init(){ 18 | sz=1; 19 | memset(t[0].next,255,sizeof(t[0].next)); 20 | memset(t[0].go,255,sizeof(t[0].go)); 21 | t[0].p=t[0].link=-1; 22 | } 23 | 24 | void add(string & s){ 25 | int v=0,q=s.length(); 26 | char c; 27 | for (int i=0;i 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main(){ 7 | string s,t; 8 | cin>>s>>t; 9 | s=t+"$"+s; 10 | int n=s.length(),p[n],i,j=0; 11 | p[0]=0; 12 | for (i=1;i0 && s[i]!=s[j]) j=p[j-1]; 14 | if (s[i]==s[j]) ++j; 15 | p[i]=j; 16 | } 17 | for (i=t.length();i 2 | #include 3 | #define N 222222 4 | using namespace std; 5 | 6 | char s[N]; 7 | int d1[N],d2[N],n,t=INF; 8 | 9 | int main(){ 10 | gets(s); 11 | n=strlen(s); 12 | int l=0,r=-1; 13 | for (int i=0;ir?0:min(d1[l+r-i],r-i))+1; 15 | while (i+k=0 && s[i+k]==s[i-k]) ++k; 16 | d1[i]=--k; 17 | if (i+k>r){ 18 | l=i-k; 19 | r=i+k; 20 | } 21 | } 22 | for (int i=0;ir?0:min(d2[l+r-i+1],r-i+1))+1; 24 | while (i+k-1=0 && s[i+k-1]==s[i-k]) ++k; 25 | d2[i]=--k; 26 | if (i+k-1>r){ 27 | r=i+k-1; 28 | l=i-k; 29 | } 30 | } 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Strings/Z.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define N 111111 4 | using namespace std; 5 | 6 | int z[N],n; 7 | string s; 8 | 9 | int main(){ 10 | cin>>s; 11 | n=s.length(); 12 | for (int i=1,l=0,r=0;ir){ 16 | l=i;r=i+z[i]-1; 17 | } 18 | } 19 | for (int i=0;i 2 | #include 3 | #define P 31 4 | 5 | using namespace std; 6 | 7 | string s; 8 | int i1,i2,len,n; 9 | long long h[1111],p[1111]; 10 | 11 | int main(void){ 12 | cin>>s>>i1>>i2>>len; 13 | n=s.length(); 14 | p[0]=1; 15 | for (int i=1;i>s; 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Strings/suf_aut/0 - is_substr.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | #define N 111111 6 | 7 | struct _SA{ 8 | int link,len; 9 | map next; 10 | } st[N+N]; 11 | 12 | int sz,last; 13 | 14 | void init(){ 15 | last=0; 16 | sz=1; 17 | st[0].link=-1; 18 | st[0].len=0; 19 | } 20 | 21 | void ins(char c){ 22 | int cur=sz++; 23 | st[cur].len=st[last].len+1; 24 | int p; 25 | for (p=last;p!=-1 && !st[p].next.count(c);p=st[p].link) st[p].next[c]=cur; 26 | if (p==-1) st[cur].link=0; 27 | else{ 28 | int q=st[p].next[c]; 29 | if (st[p].len+1==st[q].len) st[cur].link=q; 30 | else{ 31 | int clone=sz++; 32 | st[clone]=st[q]; 33 | st[clone].len=st[p].len+1; 34 | for(;p!=-1 && st[p].next[c]==q;p=st[p].link) st[p].next[c]=clone; 35 | st[q].link=st[cur].link=clone; 36 | } 37 | } 38 | last=cur; 39 | } 40 | 41 | 42 | int main(){ 43 | string s; 44 | cin>>s; 45 | init(); 46 | for (int i=0;i>t; 49 | int cur=0; 50 | for (int i=0;i 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | #define N 111111 7 | 8 | struct _SA{ 9 | int link,len; 10 | map next; 11 | } st[N+N]; 12 | int sz,last,d[N+N],ans[N+N]; 13 | 14 | void init(){ 15 | last=0; 16 | sz=1; 17 | st[0].link=-1; 18 | st[0].len=0; 19 | memset(d,255,sizeof(d)); 20 | memset(ans,255,sizeof(ans)); 21 | } 22 | 23 | void ins(char c){ 24 | int cur=sz++; 25 | st[cur].len=st[last].len+1; 26 | int p; 27 | for (p=last;p!=-1 && !st[p].next.count(c);p=st[p].link) st[p].next[c]=cur; 28 | if (p==-1) st[cur].link=0; 29 | else{ 30 | int q=st[p].next[c]; 31 | if (st[p].len+1==st[q].len) st[cur].link=q; 32 | else{ 33 | int clone=sz++; 34 | st[clone]=st[q]; 35 | st[clone].len=st[p].len+1; 36 | for(;p!=-1 && st[p].next[c]==q;p=st[p].link) st[p].next[c]=clone; 37 | st[q].link=st[cur].link=clone; 38 | } 39 | } 40 | last=cur; 41 | } 42 | 43 | int f(int v){ 44 | if (d[v]!=-1) return d[v]; 45 | int anss=1; 46 | for (map::iterator it=st[v].next.begin();it!=st[v].next.end();it++) anss+=f(it->second); 47 | d[v]=anss; 48 | return anss; 49 | } 50 | 51 | int F(int v){ 52 | if (ans[v]!=-1) return ans[v]; 53 | int anss=0; 54 | for (map::iterator it=st[v].next.begin();it!=st[v].next.end();it++) anss+=F(it->second)+f(it->second); 55 | ans[v]=anss; 56 | return anss; 57 | } 58 | 59 | int main(){ 60 | string s;cin>>s; 61 | init(); 62 | for (int i=0;i 2 | #include 3 | #include 4 | using namespace std; 5 | #define N 111111 6 | 7 | struct _SA{ 8 | int link,len; 9 | map next; 10 | } st[N+N]; 11 | int sz,last,d[N+N]; 12 | 13 | void init(){ 14 | last=0; 15 | sz=1; 16 | st[0].link=-1; 17 | st[0].len=0; 18 | memset(d,255,sizeof(d)); 19 | } 20 | 21 | void ins(char c){ 22 | int cur=sz++; 23 | st[cur].len=st[last].len+1; 24 | int p; 25 | for (p=last;p!=-1 && !st[p].next.count(c);p=st[p].link) st[p].next[c]=cur; 26 | if (p==-1) st[cur].link=0; 27 | else{ 28 | int q=st[p].next[c]; 29 | if (st[p].len+1==st[q].len) st[cur].link=q; 30 | else{ 31 | int clone=sz++; 32 | st[clone]=st[q]; 33 | st[clone].len=st[p].len+1; 34 | for(;p!=-1 && st[p].next[c]==q;p=st[p].link) st[p].next[c]=clone; 35 | st[q].link=st[cur].link=clone; 36 | } 37 | } 38 | last=cur; 39 | } 40 | 41 | int f(int v){ 42 | if (d[v]!=-1) return d[v]; 43 | int ans=1; 44 | for (map::iterator it=st[v].next.begin();it!=st[v].next.end();it++) ans+=f(it->second); 45 | d[v]=ans; 46 | return ans; 47 | } 48 | 49 | int main(){ 50 | string s;cin>>s; 51 | init(); 52 | for (int i=0;i 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | #define N 111111 7 | 8 | struct _SA{ 9 | int link,len; 10 | map next; 11 | } st[N+N]; 12 | int sz,last; 13 | 14 | void init(){ 15 | last=0; 16 | sz=1; 17 | st[0].link=-1; 18 | st[0].len=0; 19 | } 20 | 21 | void ins(char c){ 22 | int cur=sz++; 23 | st[cur].len=st[last].len+1; 24 | int p; 25 | for (p=last;p!=-1 && !st[p].next.count(c);p=st[p].link) st[p].next[c]=cur; 26 | if (p==-1) st[cur].link=0; 27 | else{ 28 | int q=st[p].next[c]; 29 | if (st[p].len+1==st[q].len) st[cur].link=q; 30 | else{ 31 | int clone=sz++; 32 | st[clone]=st[q]; 33 | st[clone].len=st[p].len+1; 34 | for(;p!=-1 && st[p].next[c]==q;p=st[p].link) st[p].next[c]=clone; 35 | st[q].link=st[cur].link=clone; 36 | } 37 | } 38 | last=cur; 39 | } 40 | 41 | int main(){ 42 | string s;cin>>s; 43 | init(); 44 | int cur=0; 45 | for (int i=0;ifirst; 49 | cur=st[cur].next.begin()->second; 50 | } 51 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Strings/suf_aut/4 - LCS.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #define N 222222 6 | using namespace std; 7 | 8 | struct _SA{ 9 | int link,len; 10 | map next; 11 | } st[N]; 12 | 13 | int sz,last,n,bpos,blen; 14 | string s,t; 15 | 16 | void init(){ 17 | cin>>n>>s>>t; 18 | sz=1;last=0; 19 | st[0].len=0; 20 | st[0].link=-1; 21 | } 22 | 23 | void add(char c){ 24 | int cur=sz++,p; 25 | st[cur].len=st[last].len+1; 26 | for (p=last;p!=-1 && !st[p].next.count(c);p=st[p].link) st[p].next[c]=cur; 27 | if (p==-1) st[cur].link=0; 28 | else{ 29 | int q=st[p].next[c]; 30 | if (st[q].len==st[p].len+1) st[cur].link=q; 31 | else{ 32 | int clone=sz++; 33 | st[clone].len=st[p].len+1; 34 | st[clone].next=st[q].next; 35 | st[clone].link=st[q].link; 36 | for(;p!=-1 && st[p].next[c]==q;p=st[p].link) st[p].next[c]=clone; 37 | st[q].link=st[cur].link=clone; 38 | } 39 | } 40 | last=cur; 41 | } 42 | 43 | int main(){ 44 | ios_base::sync_with_stdio(0); 45 | init(); 46 | for (int i=0;iblen){ 59 | blen=l; 60 | bpos=i; 61 | } 62 | } 63 | for (int i=bpos-blen+1;i<=bpos;i++) cout< 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef unsigned long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=5555; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct pt { 46 | int x,y; 47 | bool operator < (const pt & q)const{ 48 | return x 0; 60 | } 61 | 62 | int main(){ 63 | scanf("%d",&n); 64 | rep(i,n) scanf("%d%d",&a[i].x,&a[i].y); 65 | sort(a,a+n); 66 | p1=a[0];p2=a[n-1]; 67 | up[0]=down[0]=p1; 68 | forn(i,n-1){ 69 | if (i==n-1 || cw(p1,a[i],p2)){ 70 | while (c1>=2 && !cw(up[c1-2],up[c1-1],a[i])) --c1; 71 | up[c1++]=a[i]; 72 | } 73 | if (i==n-1 || ccw(p1,a[i],p2)){ 74 | while (c2>=2 && !ccw(down[c2-2],down[c2-1],a[i])) --c2; 75 | down[c2++]=a[i]; 76 | } 77 | } 78 | n=0; 79 | rep(i,c1) a[n++]=up[i]; 80 | for (int i=c2-2;i>0;i--) a[n++]=down[i]; 81 | a[n++]=a[0]; 82 | return 0; 83 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Геометрия/line.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define labs(x) ((x)>0?(x):-(x)) 4 | 5 | int main(){ 6 | double x1,x2,y1,y2,a,b,c,e=1e-9,z; 7 | scanf("%lf %lf %lf %lf",&x1,&y1,&x2,&y2); 8 | a=y1-y2; 9 | b=x2-x1; 10 | c=-a*x1-b*y1; 11 | z=sqrt(a*a+b*b); //norm 12 | a/=z;b/=z;c/=z; //norm 13 | if (a<-e || labs(a) 2 | #include 3 | #define labs(x) ((x)>0?(x):-(x)) 4 | #define eps 1e-5 5 | 6 | bool parallel(double a1, double b1, double c1, double a2, double b2, double c2){ 7 | return labs(a1*b2-a2*b1) 2 | #define labs(x) ((x>0)?(x):-(x)) 3 | 4 | double x1,x2,x3,y1,y2,y3; 5 | 6 | double _area(double x1, double y1, double x2, double y2, double x3, double y3){ 7 | return (x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2))/2.0; 8 | } 9 | 10 | double area(double x1, double y1, double x2, double y2, double x3, double y3){ 11 | return labs(_area(x1,y1,x2,y2,x3,y3)); 12 | } 13 | 14 | bool clockwise(double x1, double y1, double x2, double y2, double x3, double y3){ 15 | return _area(x1,y1,x2,y2,x3,y3)<0.0; 16 | } 17 | 18 | bool counterclockwise(double x1, double y1, double x2, double y2, double x3, double y3){ 19 | return _area(x1,y1,x2,y2,x3,y3)>0.0; 20 | } 21 | 22 | 23 | int main(){ 24 | scanf("%lf %lf %lf %lf %lf %lf",&x1,&y1,&x2,&y2,&x3,&y3); 25 | printf("%lf %d",area(x1,y1,x2,y2,x3,y3),clockwise(x1,y1,x2,y2,x3,y3)); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/00 - init.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define maxn 100 4 | 5 | using namespace std; 6 | 7 | int ef[maxn],es[maxn],ev[maxn],next[maxn],first[maxn],last[maxn],c,m,n; 8 | 9 | void add(int v1, int v2, int v){ 10 | next[++c]=first[v1]; 11 | first[v1]=c; 12 | ef[c]=v1;es[c]=v2;ev[c]=v; 13 | } 14 | 15 | void init(void){ 16 | // freopen("input.txt","r",stdin); 17 | // freopen("output.txt","w",stdout); 18 | cin>>n>>m; 19 | c=0; 20 | int i,x,y,z; 21 | for (i=1;i<=m;i++){ 22 | cin>>x>>y>>z; 23 | add(x,y,z); 24 | } 25 | } 26 | 27 | void sol(void){ 28 | for (int i=1;i<=n;i++){ 29 | for (int h=first[i];h;h=next[h]) cout< 3 | #include 4 | #include 5 | #define maxn 100 6 | 7 | using namespace std; 8 | 9 | int ef[maxn],es[maxn],ev[maxn],next[maxn],first[maxn],c,m,n; 10 | bool b[maxn]; 11 | 12 | void add(int v1, int v2, int v) 13 | { 14 | next[++c]=first[v1]; 15 | first[v1]=c; 16 | ef[c]=v1;es[c]=v2;ev[c]=v; 17 | } 18 | 19 | void init(void) 20 | { 21 | // freopen("input.txt","r",stdin); 22 | // freopen("output.txt","w",stdout); 23 | cin>>n>>m; 24 | int i,x,y,z; 25 | for (i=1;i<=m;i++) 26 | { 27 | cin>>x>>y>>z; 28 | add(x,y,z); 29 | } 30 | } 31 | 32 | void dfs(int v) 33 | { 34 | cout< 2 | #include 3 | #define N 11111 4 | #define M 222222 5 | using namespace std; 6 | 7 | struct tree{ 8 | int x,y,z; 9 | bool operator < (const tree & q) const{ 10 | return z>n>>m; 31 | for (int i=1;i<=n;i++) p[i]=i; 32 | for (int i=1;i<=m;i++) cin>>t[i].x>>t[i].y>>t[i].z; 33 | sort(t+1,t+m+1); 34 | for (int i=1;i<=m;i++) dsu_unite(t[i].x,t[i].y,t[i].z); 35 | return 0; 36 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/03 - floid.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define N 111 5 | #define M 2222 6 | 7 | using namespace std; 8 | 9 | int c,n,m,a[N][N]; 10 | 11 | void init(void){ 12 | // freopen("input.txt","r",stdin); 13 | // freopen("output.txt","w",stdout); 14 | cin>>n>>m; 15 | int i,x,y,z; 16 | memset(a,63,sizeof(a)); 17 | for (i=1;i<=m;i++){ 18 | cin>>x>>y>>z; 19 | a[x][y]=z; 20 | } 21 | for (i=1;i<=n;i++) 22 | a[i][i]=0; 23 | } 24 | 25 | void floid(void){ 26 | int i,j,k; 27 | for (k=1;k<=n;k++) 28 | for (i=1;i<=n;i++) 29 | for (j=1;j<=n;j++) 30 | if (a[i][j]>a[i][k]+a[k][j]) a[i][j]=a[i][k]+a[k][j]; 31 | } 32 | 33 | void sol(void){ 34 | int i,j; 35 | floid(); 36 | for (i=1;i<=n;i++,cout<>n; 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/04 - ford - bellman.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define maxn 111 5 | #define maxm 2222 6 | 7 | using namespace std; 8 | 9 | int ef[maxn],es[maxn],ev[maxn],next[maxn],first[maxn],a[maxn],c,m,n,s; 10 | bool cicle; 11 | 12 | void add(int v1, int v2, int v){ 13 | next[++c]=first[v1];first[v1]=c; 14 | ef[c]=v1;es[c]=v2;ev[c]=v; 15 | } 16 | 17 | void init(void){ 18 | // freopen("input.txt","r",stdin); 19 | // freopen("output.txt","w",stdout); 20 | cin>>n>>m>>s; 21 | int i,x,y,z,j; 22 | for (i=1;i<=m;i++){ 23 | cin>>x>>y>>z; 24 | add(x,y,z); 25 | } 26 | memset(a,63,sizeof(a)); 27 | } 28 | 29 | void ford(int vv){ 30 | int i,j; 31 | a[vv]=0; 32 | for (i=1;i<=n;i++) 33 | for (j=1;j<=m;j++) 34 | if (a[es[j]]>a[ef[j]]+ev[j]) 35 | a[es[j]]=a[ef[j]]+ev[j]; 36 | cicle=false; 37 | for (j=1;j<=m;j++) 38 | if (a[es[j]]>a[ef[j]]+ev[j]){ 39 | cicle=true; 40 | break; 41 | } 42 | } 43 | 44 | void sol(void){ 45 | int i,j; 46 | ford(s); 47 | for (i=1;i<=n;i++)cout<>n; 56 | return 0; 57 | } 58 | 59 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/05 - dejkstr.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define N 111 5 | #define M 11111 6 | #define INF 1111111111 7 | 8 | using namespace std; 9 | 10 | int ef[M],es[M],ev[M],next[M],first[M],d[N],s,c,n,m; 11 | bool b[N]; 12 | 13 | void add(int x,int y, int z){ 14 | next[++c]=first[x];first[x]=c; 15 | ef[c]=x;es[c]=y;ev[c]=z; 16 | } 17 | 18 | void init(void){ 19 | cin>>n>>m>>s; 20 | int i,x,y,z; 21 | for (i=1;i<=m;i++){ 22 | cin>>x>>y>>z; 23 | add(x,y,z); 24 | } 25 | } 26 | 27 | void dist(void){ 28 | int i,u,mind,h,I; 29 | memset(d,63,sizeof(d)); 30 | d[s]=0; 31 | for (I=1;I<=n;I++){ 32 | mind=INF; 33 | for (i=1;i<=n;i++) 34 | if (d[i]>n; 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/05.5 - dejkstr_heap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #define maxn 111 6 | #define maxm 2222 7 | #define INF 1061109567 8 | 9 | using namespace std; 10 | 11 | int first[maxn],ev[maxm],next[maxm],es[maxm],d[maxn],ef[maxm],S,n,m,c; 12 | 13 | void add(int x, int y, int z){ 14 | next[++c]=first[x]; 15 | first[x]=c; 16 | ef[c]=x;es[c]=y;ev[c]=z; 17 | } 18 | 19 | struct pairr{ 20 | int x,y; 21 | bool operator <(const pairr& p) const{ 22 | return y>p.y; 23 | } 24 | }; 25 | 26 | priority_queue q; 27 | 28 | void dist(int s){ 29 | d[s]=0; 30 | pairr t,w; 31 | t.x=s;t.y=0; 32 | q.push(t); 33 | while (!q.empty()){ 34 | t=q.top(); 35 | q.pop(); 36 | if (d[t.x]t.y+ev[h]){ 39 | d[es[h]]=t.y+ev[h]; 40 | w.x=es[h];w.y=d[w.x]; 41 | q.push(w); 42 | } 43 | } 44 | } 45 | 46 | void init(void){ 47 | // freopen("input.txt","r",stdin); 48 | // freopen("output.txt","w",stdout); 49 | cin>>n>>m>>S; 50 | int i,x,y,z,j; 51 | for (i=1;i<=m;i++){ 52 | cin>>x>>y>>z; 53 | add(x,y,z); 54 | } 55 | memset(d,63,sizeof(d)); 56 | } 57 | 58 | void sol(void){ 59 | dist(S); 60 | for (int i=1;i<=n;i++) 61 | cout<>n; 68 | return 0; 69 | } 70 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/06 - eiler.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define maxn 111 4 | #define maxm 2222 5 | 6 | using namespace std; 7 | 8 | int ef[maxm],es[maxm],next[maxm],first[maxn],ei[maxn],c,m,n,ptr; 9 | 10 | 11 | void add(int v1, int v2){ 12 | next[++c]=first[v1];first[v1]=c; 13 | ef[c]=v1;es[c]=v2; 14 | } 15 | 16 | int be(int x){ 17 | if (x&1) return x+1; 18 | else return x-1; 19 | } 20 | 21 | void init(void){ 22 | // freopen("input.txt","r",stdin); 23 | // freopen("output.txt","w",stdout); 24 | cin>>n>>m; 25 | int i,x,y; 26 | for (i=1;i<=m;i++){ 27 | cin>>x>>y; 28 | add(x,y); 29 | add(y,x); 30 | } 31 | m<<=1; 32 | } 33 | 34 | 35 | void eiler(int v){ 36 | for (int h=first[v];h;h=next[h]){ 37 | int e=es[h]; 38 | ef[h]=es[h]=ef[be(h)]=es[be(h)]=0; 39 | eiler(e); 40 | } 41 | if (v!=0)ei[++ptr]=v; 42 | } 43 | 44 | void sol(void){ 45 | eiler(1); 46 | for (int i=ptr;i>=1;i--) 47 | cout<>n; 54 | return 0; 55 | } 56 | 57 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/07 - topolog.cpp: -------------------------------------------------------------------------------- 1 | // O(N+M) 2 | #include 3 | #include 4 | #include 5 | #define maxn 111 6 | #define maxm 2222 7 | 8 | using namespace std; 9 | 10 | int ef[maxm],es[maxm],next[maxm],first[maxn],top[maxn],c,m,n,ptr; 11 | bool b[maxn]; 12 | 13 | void add(int v1, int v2) 14 | { 15 | next[++c]=first[v1]; 16 | first[v1]=c; 17 | ef[c]=v1;es[c]=v2; 18 | } 19 | 20 | void init(void) 21 | { 22 | // freopen("input.txt","r",stdin); 23 | // freopen("output.txt","w",stdout); 24 | cin>>n>>m; 25 | int i,x,y; 26 | for (i=1;i<=m;i++) 27 | { 28 | cin>>x>>y; 29 | add(x,y); 30 | } 31 | } 32 | 33 | 34 | void dfs(int v) 35 | { 36 | b[v]=true; 37 | for (int h=first[v];h;h=next[h]) 38 | if (!b[es[h]]) 39 | dfs(es[h]); 40 | top[++ptr]=v; 41 | } 42 | 43 | void sol(void) 44 | { 45 | int i; 46 | for (i=1;i<=n;i++) 47 | { 48 | if (!b[i]) 49 | dfs(i); 50 | } 51 | for (i=ptr;i>=1;i--) 52 | cout<>n; 60 | return 0; 61 | } 62 | 63 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/08 - max_flow.cpp: -------------------------------------------------------------------------------- 1 | // O(?) 2 | #include 3 | #include 4 | #include 5 | #include 6 | #define maxn 111 7 | #define maxm 2222 8 | #define INF 1061109567 9 | 10 | using namespace std; 11 | 12 | int first[maxn],next[maxm],es[maxm],ev[maxm],ef[maxm],scale,edge[maxn],from[maxn],n,m,c,S,T,ans; 13 | bool b[maxn]; 14 | 15 | void add(int v1, int v2, int v){ 16 | next[++c]=first[v1];first[v1]=c; 17 | ef[c]=v1;es[c]=v2;ev[c]=v; 18 | } 19 | 20 | int be(int x){ 21 | if (x&1) return x+1; 22 | else return x-1; 23 | } 24 | 25 | void init(void){ 26 | // freopen("input.txt","r",stdin); 27 | // freopen("output.txt","w",stdout); 28 | cin>>n>>m>>S>>T; 29 | int i,v1,v2,v; 30 | for (i=1;i<=m;i++){ 31 | cin>>v1>>v2>>v; 32 | add(v1,v2,v); 33 | add(v2,v1,0); 34 | scale=max(scale,v); 35 | } 36 | } 37 | 38 | bool flow(){ 39 | memset(b,0,sizeof(b)); 40 | queue q; 41 | q.push(S); 42 | b[S]=true; 43 | while (!q.empty()){ 44 | int x=q.front();q.pop(); 45 | for (int h=first[x];h;h=next[h]) if (ev[h]>=scale && !b[es[h]]){ 46 | edge[es[h]]=h; 47 | from[es[h]]=x; 48 | q.push(es[h]); 49 | b[es[h]]=true; 50 | if (es[h]==T) return 1; 51 | } 52 | } 53 | return 0; 54 | } 55 | 56 | void sol(void){ 57 | int res=INF; 58 | while (scale){ 59 | while (flow()){ 60 | res=INF; 61 | for (int h=T;h!=S;h=from[h]) res=min(res,ev[edge[h]]); 62 | for (int h=T;h!=S;h=from[h]){ 63 | ev[edge[h]]-=res; 64 | ev[be(edge[h])]+=res; 65 | } 66 | ans+=res; 67 | } 68 | scale>>=1; 69 | } 70 | cout<>n; 77 | return 0; 78 | } 79 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/09 - Strong_Connected_Components.cpp: -------------------------------------------------------------------------------- 1 | //O(N+M) 2 | #include 3 | #include 4 | #include 5 | #define maxn 111 6 | #define maxm 2222 7 | 8 | using namespace std; 9 | 10 | int ef[maxn],es[maxn],next[maxn],first[maxn],Tef[maxn],Tes[maxn],Tnext[maxn],Tfirst[maxn],c,Tc,n,m,k,Tk,order[maxn],comp[maxn]; 11 | bool used[maxn]; 12 | 13 | void add(int x,int y) 14 | { 15 | next[++c]=first[x];first[x]=c; 16 | ef[c]=x;es[c]=y; 17 | } 18 | 19 | void Tadd(int x,int y) 20 | { 21 | Tnext[++Tc]=Tfirst[x];Tfirst[x]=Tc; 22 | Tef[Tc]=x;Tes[Tc]=y; 23 | } 24 | 25 | void dfs(int v) 26 | { 27 | used[v]=true; 28 | for (int h=first[v];h;h=next[h]) 29 | if (!used[es[h]]) 30 | dfs(es[h]); 31 | order[++k]=v; 32 | } 33 | 34 | void Tdfs(int v) 35 | { 36 | used[v]=true; 37 | comp[++Tk]=v; 38 | for (int h=Tfirst[v];h;h=Tnext[h]) 39 | if (!used[Tes[h]]) 40 | Tdfs(Tes[h]); 41 | } 42 | 43 | void init(void) 44 | { 45 | // freopen("input.txt","r",stdin); 46 | // freopen("output.txt","w",stdout); 47 | cin>>n>>m; 48 | for (int i=1;i<=m;i++) 49 | { 50 | int x,y; 51 | cin>>x>>y; 52 | add(x,y); 53 | Tadd(y,x); 54 | } 55 | } 56 | 57 | void sol(void) 58 | { 59 | int i; 60 | memset(used,0,sizeof(used)); 61 | for (i=1;i<=n;i++) 62 | if (!used[i]) 63 | dfs(i); 64 | memset(used,0,sizeof(used)); 65 | for (i=1;i<=n;i++) 66 | { 67 | int v=order[n-i+1]; 68 | if (!used[v]) 69 | Tdfs(v); 70 | for (int j=1;j<=Tk;j++) 71 | cout<>n; 83 | return 0; 84 | } 85 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/10 - Bridges.cpp: -------------------------------------------------------------------------------- 1 | //O(N+M) 2 | #include 3 | #include 4 | #define maxn 111 5 | #define maxm 2222 6 | 7 | using namespace std; 8 | 9 | int ef[maxm],es[maxm],next[maxm],first[maxn],tin[maxm],fup[maxm],timer,c,n,m; 10 | bool used[maxn]; 11 | 12 | void add(int v1,int v2) 13 | { 14 | next[++c]=first[v1]; 15 | first[v1]=c; 16 | ef[c]=v1; 17 | es[c]=v2; 18 | } 19 | 20 | void dfs(int v,int p=-1) 21 | { 22 | used[v]=true; 23 | tin[v]=fup[v]=timer++; 24 | for (int h=first[v];h;h=next[h]) 25 | { 26 | if (es[h]==p) 27 | continue; 28 | if (used[es[h]]) 29 | fup[v]=min(fup[v],tin[es[h]]); 30 | else 31 | { 32 | dfs(es[h],v); 33 | fup[v]=min(fup[v],fup[es[h]]); 34 | if (fup[es[h]]>tin[v]) 35 | cout<>n>>m; 45 | for (int i=1;i<=m;i++) 46 | { 47 | int x,y; 48 | cin>>x>>y; 49 | add(x,y); 50 | add(y,x); 51 | } 52 | m<<=1; 53 | } 54 | 55 | int main(void) 56 | { 57 | init(); 58 | dfs(1); 59 | cin>>n; 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/11 - Cutpoints.cpp: -------------------------------------------------------------------------------- 1 | //O(N+M) 2 | #include 3 | #include 4 | #define maxn 111 5 | #define maxm 2222 6 | 7 | using namespace std; 8 | 9 | int ef[maxm],es[maxm],next[maxm],first[maxn],tin[maxn],fup[maxn],timer,c,n,m; 10 | bool used[maxn]; 11 | 12 | void add(int v1,int v2) 13 | { 14 | next[++c]=first[v1]; 15 | first[v1]=c; 16 | ef[c]=v1; 17 | es[c]=v2; 18 | } 19 | 20 | void dfs(int v,int p=-1) 21 | { 22 | used[v]=true; 23 | tin[v]=fup[v]=timer++; 24 | int children=0; 25 | for (int h=first[v];h;h=next[h]) 26 | { 27 | if (es[h]==p) 28 | continue; 29 | if (used[es[h]]) 30 | fup[v]=min(fup[v],tin[es[h]]); 31 | else 32 | { 33 | dfs(es[h],v); 34 | fup[v]=min(fup[v],fup[es[h]]); 35 | if (fup[es[h]]>=tin[v] && p!=-1) 36 | cout<1) 41 | cout<>n>>m; 49 | for (int i=1;i<=m;i++) 50 | { 51 | int x,y; 52 | cin>>x>>y; 53 | add(x,y); 54 | add(y,x); 55 | } 56 | m<<=1; 57 | } 58 | 59 | int main(void) 60 | { 61 | init(); 62 | dfs(1); 63 | cin>>n; 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Графы/12 - LCA_SPUSK.cpp: -------------------------------------------------------------------------------- 1 | //O(logN)+preproc(NlogN) 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | #define N 11111 8 | 9 | int ef[N],es[N],first[N],next[N],n,k,c,tin[N],tout[N],timer,l=1,up[N][40]; 10 | bool b[N]; 11 | 12 | void add(int x,int y){ 13 | next[++c]=first[x];first[x]=c; 14 | ef[c]=x;es[c]=y; 15 | next[++c]=first[y];first[y]=c; 16 | ef[c]=y;es[c]=x; 17 | } 18 | 19 | void dfs(int v,int p=1){ 20 | b[v]=true; 21 | tin[v]=++timer; 22 | up[v][0]=p; 23 | for (int i=1;i<=l;i++) up[v][i]=up[up[v][i-1]][i-1]; 24 | for (int h=first[v];h;h=next[h]) if (!b[es[h]]) dfs(es[h],v); 25 | tout[v]=++timer; 26 | } 27 | 28 | bool upper (int a, int b){ 29 | return tin[a]<=tin[b] && tout[a]>=tout[b]; 30 | } 31 | 32 | int lca (int a, int b) { 33 | if (upper(a,b)) return a; 34 | if (upper(b,a)) return b; 35 | for (int i=l;i>=0;i--) if (!upper(up[a][i],b)) a=up[a][i]; 36 | return up[a][0]; 37 | } 38 | 39 | void init(void){ 40 | cin>>n>>k; 41 | int x,y; 42 | for (int i=1;i>x>>y; 44 | add(x,y); 45 | } 46 | while ((1<>x>>y; 53 | cout< 2 | #include 3 | #include 4 | #define INF (1<<30) 5 | #define M 222222 6 | #define N 1111 7 | using namespace std; 8 | 9 | int ef[M],es[M],ev[M],next[M],first[N],c,n,m,d[N],s,t,ans,l[N],last[N]; 10 | 11 | void add(int x,int y,int z){ 12 | next[++c]=first[x];first[x]=c; 13 | ef[c]=x;es[c]=y;ev[c]=z; 14 | } 15 | 16 | int be(int x){ 17 | if (x&1) return x+1; 18 | return x-1; 19 | } 20 | 21 | void bfs(void){ 22 | queue q;q.push(s); 23 | memset(l,63,sizeof(l)); 24 | l[s]=0; 25 | while (!q.empty()){ 26 | int v=q.front();q.pop(); 27 | for (int h=first[v];h;h=next[h]) 28 | if (l[es[h]]>l[v]+1 && ev[h]>0){ 29 | l[es[h]]=l[v]+1; 30 | q.push(es[h]); 31 | } 32 | } 33 | } 34 | 35 | int dfs(int v,int f=INF){ 36 | if (v==t) return f; 37 | int res=0; 38 | if (last[v]==-1) last[v]=first[v]; 39 | else last[v]=next[last[v]]; 40 | for (;last[v];last[v]=next[last[v]]){ 41 | int h=last[v]; 42 | if (ev[h]>0 && l[es[h]]==l[v]+1){ 43 | int ans=dfs(es[h],min(ev[h],f)); 44 | ev[h]-=ans; 45 | ev[be(h)]+=ans; 46 | res+=ans; 47 | f-=ans; 48 | if (f==0) break; 49 | } 50 | } 51 | return res; 52 | } 53 | 54 | void init(void){ 55 | cin>>n>>m>>s>>t; 56 | for (int i=1;i<=m;i++){ 57 | int x,y,z; 58 | cin>>x>>y>>z; 59 | add(x,y,z); 60 | add(y,x,0); 61 | } 62 | } 63 | 64 | int main(void){ 65 | init(); 66 | int cur; 67 | do{ 68 | bfs(); 69 | for (int i=1;i<=n;i++) last[i]=-1; 70 | cur=dfs(s); 71 | ans+=cur; 72 | }while (cur); 73 | cout< 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=66; 41 | const int M=22222; 42 | const int INF=111111111; 43 | const double eps=1e-9; 44 | const double pi=3.14159265358979; 45 | 46 | int ef[M],es[M],first[N],next[M],ev[M],ec[M],S=1,T,a[N],b[N],x,y,z,c,n,sum1,sum2,ans,from[N],edge[N],d[N],m,k; 47 | 48 | inline int be(int x){ 49 | return (x&1)?x+1:x-1; 50 | } 51 | 52 | inline void add(int x,int y,int z,int co){ 53 | next[++c]=first[x];first[x]=c; 54 | ef[c]=x;es[c]=y;ev[c]=z;ec[c]=co; 55 | } 56 | 57 | void create_graph(){ 58 | rep(i,m){ 59 | int x,y,z; 60 | scanf("%d%d%d",&x,&y,&z); 61 | ++x;++y; 62 | add(x,y,1,z); 63 | add(y,x,0,-z); 64 | } 65 | T=n; 66 | } 67 | 68 | inline bool find_path(){ 69 | mem(d,63); 70 | d[S]=0; 71 | forn(i,n) forn(j,c){ 72 | if (!ev[j]) continue; 73 | if (d[es[j]]>d[ef[j]]+ec[j] && d[ef[j]]<1000000000){ 74 | d[es[j]]=d[ef[j]]+ec[j]; 75 | from[es[j]]=ef[j]; 76 | edge[es[j]]=j; 77 | } 78 | } 79 | return d[T]<1000000000; 80 | } 81 | 82 | int main(){ 83 | scanf("%d%d%d",&n,&m,&k); 84 | if (n==0 && m==0) return 0; 85 | create_graph(); 86 | while (find_path()){ 87 | int q=INF; 88 | for (int v=T;v!=S;v=from[v]) q=min(q,ev[edge[v]]); 89 | ans+=min(k,q)*d[T]; 90 | k-=min(k,q); 91 | if (k==0) break; 92 | for (int v=T;v!=S;v=from[v]){ 93 | ev[edge[v]]-=q; 94 | ev[be(edge[v])]+=q; 95 | } 96 | } 97 | if (k) puts("Not possible"); 98 | else printf("%d\n",ans); 99 | return 0; 100 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/DSU.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define maxn 11111 4 | 5 | using namespace std; 6 | 7 | int p[maxn],n; 8 | 9 | void init(void){ 10 | for (int i=0;i<=n;i++) p[i]=i; 11 | } 12 | 13 | void makeset (int x){ 14 | p[x]=x; 15 | } 16 | 17 | int findset (int x){ 18 | if (x==p[x]) return x; 19 | return p[x]=findset(p[x]); 20 | } 21 | 22 | void unite(int x,int y){ 23 | x=findset(x); 24 | y=findset(y); 25 | p[x]=y; 26 | } 27 | 28 | int main(void){ 29 | cin>>n; 30 | init(); 31 | unite(1,2); 32 | makeset(8); 33 | for (int i=1;i<=8;i++) cout<>n; 35 | } 36 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Hash/Hash_map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define maxn 1000003 5 | #define MOD 1000003 6 | 7 | using namespace std; 8 | 9 | vector > hash[maxn]; 10 | 11 | void hash_insert(int key,int value) 12 | { 13 | int pos=key%MOD,len=hash[pos].size(),i; 14 | bool b=true; 15 | for (i=0;i>n>>m; 60 | for (int l,r,i=1;i<=n;i++) 61 | { 62 | cin>>l>>r; 63 | hash_insert(l,r); 64 | } 65 | for (int l,i=1;i<=m;i++) 66 | { 67 | cin>>l; 68 | if (hash_in(l)) 69 | cout<>n; 73 | return 0; 74 | } 75 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Hash/Hash_set.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define maxn 1000003 5 | #define MOD 1000003 6 | 7 | using namespace std; 8 | 9 | vector hash[maxn]; 10 | 11 | void hash_insert(int key) 12 | { 13 | int pos=key%MOD,len=hash[pos].size(),i; 14 | bool b=true; 15 | for (i=0;i>n>>m; 51 | for (int l,i=1;i<=n;i++) 52 | { 53 | cin>>l; 54 | hash_insert(l); 55 | } 56 | for (int l,i=1;i<=m;i++) 57 | { 58 | cin>>l; 59 | if (hash_in(l)) 60 | cout<<"YES"<>n; 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/SQRT_decomposition.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define maxn 11111 5 | 6 | using namespace std; 7 | 8 | int a[maxn],b[maxn],n,len; 9 | 10 | void init(void){ 11 | // freopen("input.txt","r",stdin); 12 | // freopen("output.txt","w",stdout); 13 | cin>>n; 14 | len=(int)(sqrt(n)); 15 | for (int i=1;i<=n;i++){ 16 | a[i]=i; 17 | b[(i-1)/len+1]+=a[i]; 18 | } 19 | } 20 | 21 | void modify(int pos,int add){ 22 | a[pos]+=add; 23 | b[(pos-1)/len+1]+=add; 24 | } 25 | 26 | int sum(int l,int r){ 27 | int s=0; 28 | for (int i=l;i<=r;) 29 | if ((i-1)%len==0){ 30 | if (i+len<=r){ 31 | i+=len; 32 | s+=b[i/len]; 33 | }else{ 34 | s+=a[i]; 35 | ++i; 36 | } 37 | }else{ 38 | s+=a[i]; 39 | ++i; 40 | } 41 | return s; 42 | } 43 | 44 | void sol(void){ 45 | int m; 46 | cin>>m; 47 | while (m--){ 48 | int pos,add; 49 | cin>>pos>>add; 50 | modify(pos,add); 51 | } 52 | cin>>m; 53 | while(m--){ 54 | int l,r; 55 | cin>>l>>r; 56 | cout<>n; 68 | return 0; 69 | } 70 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zamazan4ik/Algorithms/5d91d76aa9235f5da3c198dcbfe4468609955d0c/Исходники Трухановича Влада/Структуры данных/Treap/1.cpp -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/Implicit_treap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,y,cost,sz; 9 | } t[N]; 10 | 11 | int a[N],root,n,c; 12 | 13 | inline int szof(int x){ 14 | return x?t[x].sz:0; 15 | } 16 | 17 | inline void recalc(int x){ 18 | if (x) t[x].sz=szof(t[x].ls)+szof(t[x].rs)+1; 19 | } 20 | 21 | void merge(int &x,int l,int r){ 22 | if (!l || !r) x=l?l:r; 23 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 24 | else x=r,merge(t[x].ls,l,t[x].ls); 25 | recalc(x); 26 | } 27 | 28 | void split (int x,int key,int &l,int &r){ 29 | if (!x) l=r=0; 30 | else { 31 | int ck=szof(t[x].ls)+1; 32 | if (ck<=key) l=x,split(t[x].rs,key-ck,t[x].rs,r); 33 | else r=x,split(t[x].ls,key,l,t[x].ls); 34 | recalc(x); 35 | } 36 | } 37 | 38 | void print(int x){ 39 | if (!x) return; 40 | print(t[x].ls); 41 | cout<k) return kth(t[x].ls,k); 65 | } 66 | 67 | int main(){ 68 | cin>>n; 69 | for (int i=0;i>x; 74 | insert(i+1,x); 75 | } 76 | int pos,value; 77 | cin>>pos>>value; 78 | insert(pos,value); 79 | cin>>pos; 80 | erase(pos); 81 | print(root); 82 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/Implicit_treap_reverse.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,y,cost,sz; 9 | bool rev; 10 | } t[N]; 11 | 12 | int a[N],root,n,c; 13 | 14 | inline int szof(int x){ 15 | return x?t[x].sz:0; 16 | } 17 | 18 | inline void recalc(int x){ 19 | if (x) t[x].sz=szof(t[x].ls)+szof(t[x].rs)+1; 20 | } 21 | 22 | inline void push(int x){ 23 | if (x && t[x].rev){ 24 | swap(t[x].ls,t[x].rs); 25 | t[t[x].ls].rev^=1; 26 | t[t[x].rs].rev^=1; 27 | t[x].rev=0; 28 | } 29 | } 30 | 31 | void merge(int &x,int l,int r){ 32 | push(l);push(r); 33 | if (!l || !r) x=l?l:r; 34 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 35 | else x=r,merge(t[x].ls,l,t[x].ls); 36 | recalc(x); 37 | } 38 | 39 | void split (int x,int key,int &l,int &r){ 40 | if (!x) l=r=0; 41 | else { 42 | push(x); 43 | int ck=szof(t[x].ls)+1; 44 | if (ck<=key) l=x,split(t[x].rs,key-ck,t[x].rs,r); 45 | else r=x,split(t[x].ls,key,l,t[x].ls); 46 | recalc(x); 47 | } 48 | } 49 | 50 | void print(int x){ 51 | if (!x) return; 52 | push(x); 53 | print(t[x].ls); 54 | cout<>n; 84 | for (int i=0;i>x; 89 | insert(i+1,x); 90 | } 91 | int l,r; 92 | cin>>l>>r; 93 | reverse(l,r); 94 | print(root); 95 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/Implict_treap_with_sum_and_coloring_on_the_interval.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,y,cost,sz,sum,color; 9 | } t[N]; 10 | 11 | int a[N],root,n,c; 12 | 13 | inline int szof(int x){ 14 | if (x) return t[x].sz; else return 0; 15 | } 16 | 17 | inline int sumof(int x){ 18 | if (x){ 19 | if (t[x].color==-1) return t[x].sum; 20 | else return t[x].color*szof(x); 21 | } else return 0; 22 | } 23 | 24 | inline void recalc(int x){ 25 | if (x){ 26 | t[x].sz=szof(t[x].ls)+szof(t[x].rs)+1; 27 | t[x].sum=sumof(t[x].ls)+sumof(t[x].rs)+t[x].cost; 28 | } 29 | } 30 | 31 | inline void push(int x){ 32 | if (x && t[x].color!=-1){ 33 | t[x].cost=t[x].color; 34 | t[t[x].ls].color=t[x].color; 35 | t[t[x].rs].color=t[x].color; 36 | t[x].color=-1; 37 | } 38 | } 39 | 40 | void merge(int &x,int l,int r){ 41 | push(l);push(r); 42 | if (!l || !r) x=l?l:r; 43 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 44 | else x=r,merge(t[x].ls,l,t[x].ls); 45 | recalc(x); 46 | } 47 | 48 | void split (int x,int key,int &l,int &r){ 49 | if (!x) l=r=0; 50 | else { 51 | push(x); 52 | int ck=szof(t[x].ls)+1; 53 | if (ck<=key) l=x,split(t[x].rs,key-ck,t[x].rs,r); 54 | else r=x,split(t[x].ls,key,l,t[x].ls); 55 | recalc(x); 56 | } 57 | } 58 | 59 | void print(int x){ 60 | if (!x) return; 61 | push(x); 62 | print(t[x].ls); 63 | cout<>n; 103 | for (int i=0;i>x; 108 | insert(i+1,x); 109 | } 110 | int l,r,color; 111 | cin>>l>>r>>color; 112 | coloring(l,r,color); 113 | cin>>l>>r; 114 | cout< 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,x,y,sum,cost,sz,add; 9 | } t[N]; 10 | 11 | int a[N],root,n,c; 12 | 13 | inline int sumof(int x){ 14 | return x?t[x].sum+t[x].sz*t[x].add:0; 15 | } 16 | 17 | inline int szof(int x){ 18 | return x?t[x].sz:0; 19 | } 20 | 21 | inline void recalc(int x){ 22 | if (x){ 23 | t[x].sum=sumof(t[x].ls)+sumof(t[x].rs)+t[x].cost; 24 | t[x].sz=szof(t[x].ls)+szof(t[x].rs)+1; 25 | } 26 | } 27 | 28 | inline void push(int x){ 29 | if (x && t[x].add){ 30 | t[x].cost+=t[x].add; 31 | t[t[x].ls].add+=t[x].add; 32 | t[t[x].rs].add+=t[x].add; 33 | t[x].add=0; 34 | } 35 | } 36 | 37 | void merge(int &x,int l,int r){ 38 | push(l);push(r); 39 | if (!l || !r) x=l?l:r; 40 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 41 | else x=r,merge(t[x].ls,l,t[x].ls); 42 | recalc(x); 43 | } 44 | 45 | void split (int x,int key,int &l,int &r){ 46 | push(x); 47 | if (!x) l=r=0; 48 | else if (t[x].x<=key) l=x,split(t[x].rs,key,t[x].rs,r); 49 | else r=x,split(t[x].ls,key,l,t[x].ls); 50 | recalc(x); 51 | } 52 | 53 | void insert(int & x,int num){ 54 | if (!x) x=num; 55 | else if (t[x].y>n; 88 | for (int i=0;i>t[++c].x>>t[c].cost; 92 | t[c].sum=t[c].cost;t[c].sz=1; 93 | t[c].y=a[i]; 94 | insert(root,c); 95 | } 96 | int l,r,val; 97 | cin>>l>>r>>val; 98 | add(l,r,val); 99 | cin>>l>>r; 100 | cout< 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,x,y,sum,cost; 9 | } t[N]; 10 | 11 | inline int sumof(int x){ 12 | return x?t[x].sum:0; 13 | } 14 | 15 | inline void recalc(int x){ 16 | t[x].sum=sumof(t[x].ls)+sumof(t[x].rs)+t[x].cost; 17 | } 18 | 19 | int a[N],root,n,c; 20 | 21 | void merge(int &x,int l,int r){ 22 | if (!l || !r) x=l?l:r; 23 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 24 | else x=r,merge(t[x].ls,l,t[x].ls); 25 | recalc(x); 26 | } 27 | 28 | void split (int x,int key,int &l,int &r){ 29 | if (!x) l=r=0; 30 | else if (t[x].x<=key) l=x,split(t[x].rs,key,t[x].rs,r); 31 | else r=x,split(t[x].ls,key,l,t[x].ls); 32 | recalc(x); 33 | } 34 | 35 | void insert(int & x,int num){ 36 | if (!x) x=num; 37 | else if (t[x].y>n; 61 | for (int i=0;i>t[++c].x>>t[c].cost; 65 | t[c].sum=t[c].cost; 66 | t[c].y=a[i]; 67 | insert(root,c); 68 | } 69 | int l,r; 70 | cin>>l>>r; 71 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | #define N 111111 9 | struct cell 10 | { 11 | int key,prior; 12 | int ls,rs; 13 | } tree[N]; 14 | 15 | int kv,root; 16 | 17 | void split(int x, int key, int& left_tree, int& right_tree) { 18 | if (!x) 19 | left_tree = right_tree = 0; 20 | else if (key < tree[x].key) 21 | { 22 | split(tree[x].ls, key, left_tree, tree[x].ls); 23 | right_tree = x; 24 | } 25 | else 26 | { 27 | split(tree[x].rs, key, tree[x].rs, right_tree); 28 | left_tree = x; 29 | } 30 | } 31 | 32 | void merge(int& x, int left_tree, int right_tree) 33 | { 34 | if (!left_tree || !right_tree) 35 | { 36 | if (left_tree) x = left_tree; 37 | else x = right_tree; 38 | } 39 | else if (tree[left_tree].prior > tree[right_tree].prior) 40 | { 41 | merge(tree[left_tree].rs, tree[left_tree].rs, right_tree); 42 | x = left_tree; 43 | } 44 | else 45 | { 46 | merge(tree[right_tree].ls, left_tree, tree[right_tree].ls); 47 | x = right_tree; 48 | } 49 | } 50 | 51 | void insert(int& x, int new_item) 52 | { 53 | if (!x) 54 | x = new_item; 55 | else if (tree[new_item].prior > tree[x].prior) 56 | { 57 | split(x, tree[new_item].key, tree[new_item].ls, tree[new_item].rs); 58 | x = new_item; 59 | } 60 | else 61 | { 62 | if (tree[new_item].key < tree[x].key) insert(tree[x].ls, new_item); 63 | else insert(tree[x].rs, new_item); 64 | } 65 | } 66 | 67 | void insert(int x) { 68 | tree[++kv] = (cell) {x, rand(), 0, 0}; 69 | insert(root, kv); 70 | } 71 | 72 | 73 | void erase(int& x, int key) 74 | { 75 | if (!x) int asb=0; 76 | else if (tree[x].key == key) merge(x, tree[x].ls, tree[x].rs); 77 | else 78 | { 79 | if (key < tree[x].key) erase(tree[x].ls, key); 80 | else erase(tree[x].rs, key); 81 | } 82 | } 83 | 84 | vector b; 85 | void print(int x) 86 | { 87 | if (!x) return; 88 | print( tree[x].ls ); 89 | b.push_back(tree[x].key); 90 | print( tree[x].rs ); 91 | } 92 | 93 | int n; 94 | 95 | bool check(int n, int cur_rand) { 96 | vector a(n),c; 97 | for (int i=0;i> n; 117 | int lim = 1 << 12; 118 | for (int i=0;i 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,x,y,sz; 9 | } t[N]; 10 | 11 | inline int szof(int x){ 12 | return x?t[x].sz:0; 13 | } 14 | 15 | inline void recalc(int x){ 16 | t[x].sz=szof(t[x].ls)+szof(t[x].rs)+1; 17 | } 18 | 19 | int a[N],root,n,c; 20 | 21 | void merge(int &x,int l,int r){ 22 | if (!l || !r) x=l?l:r; 23 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 24 | else x=r,merge(t[x].ls,l,t[x].ls); 25 | recalc(x); 26 | } 27 | 28 | void split (int x,int key,int &l,int &r){ 29 | if (!x) l=r=0; 30 | else if (t[x].x<=key) l=x,split(t[x].rs,key,t[x].rs,r); 31 | else r=x,split(t[x].ls,key,l,t[x].ls); 32 | recalc(x); 33 | } 34 | 35 | void insert(int & x,int num){ 36 | if (!x) x=num; 37 | else if (t[x].yk) return kth(t[x].ls,k); 61 | } 62 | 63 | int main(){ 64 | cin>>n; 65 | for (int i=0;i>t[++c].x; 69 | t[c].y=a[i];t[c].sz=1; 70 | insert(root,c); 71 | } 72 | int x; 73 | cin>>x; 74 | cout< 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=222222; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct treap{ 46 | int y,cnt,value; 47 | bool rev; 48 | treap *l,*r; 49 | treap(){} 50 | treap(int x,int y) :value(x),y(y),l(NULL),r(NULL),cnt(1),rev(false){}; 51 | }; 52 | 53 | typedef treap* ptreap; 54 | 55 | ptreap root1,root2; 56 | int a[N],c,n; 57 | 58 | inline int cnt(ptreap t){ 59 | return t?t->cnt:0; 60 | } 61 | 62 | inline void push(ptreap t){ 63 | if (t && t->rev){ 64 | if (t->l) t->l->rev^=1; 65 | if (t->r) t->r->rev^=1; 66 | swap(t->l,t->r); 67 | t->rev=0; 68 | } 69 | } 70 | 71 | inline void recalc(ptreap t){ 72 | if (t) t->cnt=1+cnt(t->l)+cnt(t->r); 73 | } 74 | 75 | void split (ptreap t, int x, ptreap & l, ptreap & r) { 76 | if (!t) return void(l=r=NULL); 77 | push(t); 78 | int cur_key=cnt(t->l)+1; 79 | if (cur_key<=x) split(t->r,x-cur_key,t->r,r),l=t; 80 | else split(t->l,x,l,t->l),r=t; 81 | recalc(t); 82 | } 83 | 84 | void merge (ptreap & t, ptreap l, ptreap r) { 85 | push(l);push(r); 86 | if (!l || !r) t=l?l:r; 87 | else if (l->y>r->y) merge(l->r,l->r, r),t=l; 88 | else merge(r->l,l,r->l),t=r; 89 | recalc(t); 90 | } 91 | 92 | void print(ptreap x){ 93 | if (x==NULL) return; 94 | push(x); 95 | print(x->l); 96 | cout<value<<" "; 97 | print(x->r); 98 | } 99 | 100 | void insert(ptreap &root,int pos,int value){ 101 | ptreap q=new treap(value,a[++c]); 102 | if (!root){ 103 | root=q; 104 | return; 105 | } 106 | ptreap L,M,R; 107 | split(root,pos-1,L,R); 108 | merge(M,L,q); 109 | merge(root,M,R); 110 | } 111 | 112 | void reverse(ptreap & t,int l,int r){ 113 | ptreap t1,t2,t3,t4; 114 | split(t,r,t2,t3); 115 | split(t2,l-1,t1,t4); 116 | t4->rev^=true; 117 | merge(t2,t1,t4); 118 | merge(t,t2,t3); 119 | } 120 | 121 | int main(){ 122 | cin>>n; 123 | forn(i,n+n) a[i]=i; 124 | random_shuffle(a+1,a+n+n+1); 125 | forn(i,n){ 126 | int x; 127 | cin>>x; 128 | insert(root1,i,x); 129 | } 130 | int l,r; 131 | cin>>l>>r; 132 | reverse(root1,l,r); 133 | print(root1); 134 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/pointers/Reverse_2D.cpp: -------------------------------------------------------------------------------- 1 | #pragma comment(linker, "/STACK:65777216") 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=1111; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct treap{ 46 | int y,cnt,value; 47 | bool rev; 48 | treap *l,*r; 49 | treap(){} 50 | treap(int x,int y) :value(x),y(y),l(NULL),r(NULL),cnt(1),rev(false){}; 51 | }; 52 | 53 | typedef treap* ptreap; 54 | 55 | ptreap root[N]; 56 | int a[N*N],c,n; 57 | 58 | inline int cnt(ptreap t){ 59 | return t?t->cnt:0; 60 | } 61 | 62 | inline void push(ptreap t){ 63 | if (t && t->rev){ 64 | if (t->l) t->l->rev^=1; 65 | if (t->r) t->r->rev^=1; 66 | swap(t->l,t->r); 67 | t->rev=0; 68 | } 69 | } 70 | 71 | inline void recalc(ptreap t){ 72 | if (t) t->cnt=1+cnt(t->l)+cnt(t->r); 73 | } 74 | 75 | void split (ptreap t, int x, ptreap & l, ptreap & r) { 76 | if (!t) return void(l=r=NULL); 77 | push(t); 78 | int cur_key=cnt(t->l)+1; 79 | if (cur_key<=x) split(t->r,x-cur_key,t->r,r),l=t; 80 | else split(t->l,x,l,t->l),r=t; 81 | recalc(t); 82 | } 83 | 84 | void merge (ptreap & t, ptreap l, ptreap r) { 85 | push(l);push(r); 86 | if (!l || !r) t=l?l:r; 87 | else if (l->y>r->y) merge(l->r,l->r, r),t=l; 88 | else merge(r->l,l,r->l),t=r; 89 | recalc(t); 90 | } 91 | 92 | void print(ptreap x){ 93 | if (x==NULL) return; 94 | push(x); 95 | print(x->l); 96 | cout<value<<" "; 97 | print(x->r); 98 | } 99 | 100 | void insert(ptreap &root,int pos,int value){ 101 | ptreap q=new treap(value,a[++c]); 102 | if (!root){ 103 | root=q; 104 | return; 105 | } 106 | ptreap L,M,R; 107 | split(root,pos-1,L,R); 108 | merge(M,L,q); 109 | merge(root,M,R); 110 | } 111 | 112 | inline void reverse(ptreap & t,int l,int r){ 113 | ptreap t1,t2,t3,t4; 114 | split(t,r,t2,t3); 115 | split(t2,l-1,t1,t4); 116 | t4->rev^=true; 117 | merge(t2,t1,t4); 118 | merge(t,t2,t3); 119 | } 120 | 121 | inline void swap_r(ptreap & root1, ptreap & root2,int l,int r){ 122 | ptreap L1,L2,R1,R2,M1,M2,LL1,LL2; 123 | split(root1,r,L1,R1); 124 | split(L1,l-1,LL1,M1); 125 | split(root2,r,L2,R2); 126 | split(L2,l-1,LL2,M2); 127 | merge(L1,LL1,M2); 128 | merge(root1,L1,R1); 129 | merge(L2,LL2,M1); 130 | merge(root2,L2,R2); 131 | } 132 | 133 | 134 | int main(){ 135 | int n,m,k; 136 | ropen("input.txt"); 137 | wopen("output.txt"); 138 | scanf("%d%d",&n,&m); 139 | forn(i,n*m) a[i]=i; 140 | random_shuffle(a+1,a+n*m+1); 141 | forn(i,n) forn(j,m){ 142 | int x; 143 | scanf("%d",&x); 144 | insert(root[i],j,x); 145 | } 146 | scanf("%d\n",&k); 147 | forn(i,k){ 148 | char c; 149 | int x1,y1,x2,y2; 150 | scanf("%c %d %d %d %d\n",&c,&x1,&y1,&x2,&y2); 151 | if (c=='H' && y1==y2 || c=='V' && x1==x2) continue; 152 | if (c=='H') for(int i=x1;i<=x2;i++) reverse(root[i],y1,y2); 153 | else while (x2>x1){ 154 | swap_r(root[x1],root[x2],y1,y2); 155 | ++x1; 156 | --x2; 157 | } 158 | } 159 | forn(i,n){ 160 | print(root[i]); 161 | putchar('\n'); 162 | } 163 | return 0; 164 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/pointers/Treap_pointers.cpp: -------------------------------------------------------------------------------- 1 | #pragma comment(linker, "/STACK:65777216") 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=222222; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct treap{ 46 | int x,y; 47 | treap *l,*r; 48 | treap(){} 49 | treap(int x,int y) :x(x),y(y),l(NULL),r(NULL){}; 50 | }; 51 | typedef treap* ptreap; 52 | 53 | ptreap root; 54 | int a[N],c,n; 55 | 56 | void split (ptreap t, int x, ptreap & l, ptreap & r) { 57 | if (!t) l=r=NULL; 58 | else if (xx) split(t->l,x,l,t->l),r=t; 59 | else split(t->r,x,t->r,r),l=t; 60 | } 61 | 62 | void insert (ptreap & t, ptreap it) { 63 | if (!t) t = it; 64 | else if (it->y>t->y) split (t,it->x,it->l,it->r), t=it; 65 | else insert(it->xx?t->l:t->r,it); 66 | } 67 | 68 | void merge (ptreap & t, ptreap l, ptreap r) { 69 | if (!l || !r) t=l?l:r; 70 | else if (l->y>r->y) merge(l->r,l->r, r),t=l; 71 | else merge(r->l,l,r->l),t=r; 72 | } 73 | 74 | void erase (ptreap & t, int x) { 75 | if (t->x==x) merge (t,t->l,t->r); 76 | else erase(xx?t->l:t->r,x); 77 | } 78 | 79 | void print(ptreap x){ 80 | if (x==NULL) return; 81 | print(x->l); 82 | cout<x<<" "; 83 | print(x->r); 84 | } 85 | 86 | int main(){ 87 | cin>>n; 88 | forn(i,n) a[i]=i; 89 | forn(i,n){ 90 | int x; 91 | cin>>x; 92 | ptreap q = new treap(x,a[++c]); 93 | insert(root,q); 94 | } 95 | print(root); 96 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Treap/treap_my.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define N 111111 4 | 5 | using namespace std; 6 | 7 | struct treap{ 8 | int ls,rs,x,y; 9 | } t[N]; 10 | 11 | int a[N],root,n,c; 12 | 13 | void merge(int &x,int l,int r){ 14 | if (!l || !r) x=l?l:r; 15 | else if (t[l].y>t[r].y) x=l,merge(t[x].rs,t[x].rs,r); 16 | else x=r,merge(t[x].ls,l,t[x].ls); 17 | } 18 | 19 | void split (int x,int key,int &l,int &r){ 20 | if (!x) l=r=0; 21 | else if (t[x].x<=key) l=x,split(t[x].rs,key,t[x].rs,r); 22 | else r=x,split(t[x].ls,key,l,t[x].ls); 23 | } 24 | 25 | void insert(int & x,int num){ 26 | if (!x) x=num; 27 | else if (t[x].y>n; 46 | for (int i=0;i>t[++c].x; 50 | t[c].y=a[i]; 51 | insert(root,c); 52 | } 53 | print(root); 54 | cout<>x; 57 | erase(root,x); 58 | print(root); 59 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/queue_with_min-O(1).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | stack > s1,s2; 8 | 9 | void push(int x){ 10 | int minim=s1.empty()?x:min(x,s1.top().second); 11 | s1.push(make_pair(x,minim)); 12 | } 13 | 14 | int getmin(void){ 15 | if (s1.empty() || s2.empty()) return s1.empty()?s2.top().second:s1.top().second; 16 | return min(s1.top().second,s2.top().second); 17 | } 18 | 19 | int pop(void){ 20 | if (s2.empty()) 21 | while (!s1.empty()){ 22 | int x=s1.top().first; 23 | s1.pop(); 24 | int minim=s2.empty()?x:min(x,s2.top().second); 25 | s2.push(make_pair(x,minim)); 26 | } 27 | int x=s2.top().first; 28 | s2.pop(); 29 | return x; 30 | } 31 | 32 | bool empty(void){ 33 | return s1.empty() && s2.empty(); 34 | } 35 | 36 | int main(void){ 37 | int n,m; 38 | cin>>n>>m; 39 | for (int i=1;i<=m;i++){ 40 | int x; 41 | cin>>x; 42 | push(x); 43 | } 44 | for (int i=m+1;i<=n;i++){ 45 | int x; 46 | cin>>x; 47 | cout< 2 | #define N 111111 3 | 4 | using namespace std; 5 | 6 | struct cell{ 7 | int l,r,max; 8 | }; 9 | 10 | cell t[4*N]; 11 | int n,a[N]; 12 | 13 | void build(int v,int l,int r){ 14 | t[v].l=l;t[v].r=r; 15 | if (l==r) t[v].max=a[l]; 16 | else{ 17 | build(v<<1,l,(l+r)>>1); 18 | build((v<<1)+1,((l+r)>>1)+1,r); 19 | t[v].max=max(t[v<<1].max,t[(v<<1)+1].max); 20 | } 21 | } 22 | 23 | void modify(int v,int pos,int val){ 24 | if (t[v].l==t[v].r) t[v].max=val; 25 | else{ 26 | if (pos<=(t[v].l+t[v].r)>>1) modify(v<<1,pos,val); 27 | else modify((v<<1)+1,pos,val); 28 | t[v].max=max(t[v<<1].max,t[(v<<1)+1].max); 29 | } 30 | } 31 | 32 | int get(int v,int l,int r){ 33 | if (l>t[v].r || r>n; 40 | for (int i=1;i<=n;i++) cin>>a[i]; 41 | build(1,1,n); 42 | } 43 | 44 | int main(void){ 45 | init(); 46 | int t,l,r; 47 | while (cin>>t){ 48 | if (t==0) return 0; 49 | cin>>l>>r; 50 | if (t==1) modify(1,l,r); 51 | if (t==2) cout< 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | #define N 111111 7 | struct cell{ 8 | int l,r,max,add; 9 | } a[4*N]; 10 | 11 | void build(int x,int l,int r){ 12 | a[x].l=l;a[x].r=r;a[x].max=a[x].add=0; 13 | if (a[x].l>1); 15 | build(x+x+1,1+((l+r)>>1),r); 16 | } 17 | } 18 | 19 | int get_max(int x,int sumadd=0){ 20 | return a[x].max+a[x].add+sumadd; 21 | } 22 | 23 | void modify(int x,int l,int r,int val){ 24 | if (!x || a[x].r < l || a[x].l > r) return; 25 | if (l<=a[x].l && r>=a[x].r){ 26 | a[x].add+=val; 27 | return; 28 | } 29 | modify(x+x,l,r,val); 30 | modify(x+x+1,l,r,val); 31 | a[x].max=max(get_max(x+x),get_max(x+x+1)); 32 | } 33 | 34 | int findmax(int x,int l,int r,int sumadd){ 35 | if (!x || a[x].r < l || a[x].l > r) return 0; 36 | if (l<=a[x].l && r>=a[x].r) return get_max(x,sumadd); 37 | return max(findmax(x+x,l,r,sumadd+a[x].add),findmax(x+x+1,l,r,sumadd+a[x].add)); 38 | } 39 | 40 | int main(){ 41 | freopen("in","r",stdin); 42 | freopen("out","w",stdout); 43 | 44 | int n,q; 45 | cin>>n>>q; 46 | 47 | build(1,1,n); 48 | while (q--){ 49 | int t,l,r,val; cin >> t; 50 | if (t==1){ 51 | cin>>l>>r>>val; 52 | modify(1,l,r,val); 53 | }else{ 54 | cin>>l>>r; 55 | cout< 2 | #define N 111111 3 | 4 | using namespace std; 5 | 6 | struct cell{ 7 | int l,r,sum; 8 | }; 9 | 10 | cell t[4*N]; 11 | int n,a[N]; 12 | 13 | void build(int v,int l,int r){ 14 | t[v].l=l;t[v].r=r; 15 | if (l==r) t[v].sum=a[l]; 16 | else{ 17 | build(v<<1,l,(l+r)>>1); 18 | build((v<<1)+1,((l+r)>>1)+1,r); 19 | t[v].sum=t[v<<1].sum+t[(v<<1)+1].sum; 20 | } 21 | } 22 | 23 | void modify(int v,int pos,int val){ 24 | if (t[v].l==t[v].r) t[v].sum=val; 25 | else{ 26 | if (pos<=(t[v].l+t[v].r)>>1) modify(v<<1,pos,val); 27 | else modify((v<<1)+1,pos,val); 28 | t[v].sum=t[v<<1].sum+t[(v<<1)+1].sum; 29 | } 30 | } 31 | 32 | int get(int v,int l,int r){ 33 | if (l>t[v].r || r>n; 40 | for (int i=1;i<=n;i++) cin>>a[i]; 41 | build(1,1,n); 42 | } 43 | 44 | int main(void){ 45 | init(); 46 | int t,l,r; 47 | while (cin>>t){ 48 | if (t==0) return 0; 49 | cin>>l>>r; 50 | if (t==1) modify(1,l,r); 51 | if (t==2) cout< 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | #define N 111111 7 | struct cell{ 8 | int l,r,sum,add; 9 | } a[4*N]; 10 | 11 | void build(int x,int l,int r){ 12 | a[x].l=l;a[x].r=r;a[x].sum=a[x].add=0; 13 | if (a[x].l>1); 15 | build(x+x+1,1+((l+r)>>1),r); 16 | } 17 | } 18 | 19 | int get_sum(int x,int sumadd=0){ 20 | return a[x].sum+(a[x].r-a[x].l+1)*(a[x].add+sumadd); 21 | } 22 | 23 | void modify(int x,int l,int r,int val){ 24 | if (!x || a[x].r < l || a[x].l > r) return; 25 | if (l<=a[x].l && r>=a[x].r){ 26 | a[x].add+=val; 27 | return; 28 | } 29 | modify(x+x,l,r,val); 30 | modify(x+x+1,l,r,val); 31 | a[x].sum=get_sum(x+x)+get_sum(x+x+1); 32 | } 33 | 34 | int findsum(int x,int l,int r,int sumadd){ 35 | if (!x || a[x].rr) return 0; 36 | if (l<=a[x].l && r>=a[x].r) return get_sum(x,sumadd); 37 | return findsum(x+x,l,r,sumadd+a[x].add)+findsum(x+x+1,l,r,sumadd+a[x].add); 38 | } 39 | 40 | int main(){ 41 | freopen("in","r",stdin); 42 | freopen("out","w",stdout); 43 | 44 | int n,q; 45 | cin>>n>>q; 46 | 47 | build(1,1,n); 48 | while (q--){ 49 | int t,l,r,val; cin >> t; 50 | if (t==1){ 51 | cin>>l>>r>>val; 52 | modify(1,l,r,val); 53 | }else{ 54 | cin>>l>>r; 55 | cout< 2 | #define maxn 11111 3 | 4 | using namespace std; 5 | 6 | int n,t[maxn],a[maxn]; 7 | 8 | void build(int v,int tl,int tr) 9 | { 10 | if (tl==tr) 11 | t[v]=a[tl]; 12 | else 13 | { 14 | int tm=(tl+tr)>>1; 15 | build(v<<1,tl,tm); 16 | build((v<<1)+1,tm+1,tr); 17 | } 18 | } 19 | 20 | int get(int v,int tl,int tr,int pos) 21 | { 22 | if (tl==tr) return t[v]; 23 | int tm=(tl+tr)>>1; 24 | if (pos<=tm) return t[v]+get(v<<1,tl,tm,pos); 25 | else return t[v]+get((v<<1)+1,tm+1,tr,pos); 26 | } 27 | 28 | void update (int v, int tl, int tr, int l, int r, int add) 29 | { 30 | if (l>r) return; 31 | if (l==tl && r==tr) t[v]+=add; 32 | else 33 | { 34 | int tm=(tl+tr)>>1; 35 | update(v<<1,tl,tm,l,min(r,tm),add); 36 | update ((v<<1)+1,tm+1,tr,max(l,tm+1),r,add); 37 | } 38 | } 39 | 40 | int main(void) 41 | { 42 | cin>>n; 43 | int i; 44 | for (i=1;i<=n;i++) 45 | a[i]=i; 46 | build(1,1,n); 47 | update(1,1,n,5,8,100); 48 | for (i=1;i<=n;i++) 49 | cout<>i; 51 | } 52 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_отрезков/e-maxx/RMQ(e-maxx).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define maxn 11111 3 | 4 | using namespace std; 5 | 6 | int n,t[maxn],a[maxn]; 7 | 8 | void build(int v,int tl,int tr) 9 | { 10 | if (tl==tr) 11 | t[v]=a[tl]; 12 | else 13 | { 14 | int tm=(tl+tr)>>1; 15 | build(v<<1,tl,tm); 16 | build((v<<1)+1,tm+1,tr); 17 | t[v]=max(t[v<<1],t[(v<<1)+1]); 18 | } 19 | } 20 | 21 | int get_max(int v,int tl,int tr,int l,int r) 22 | { 23 | if (l>r) 24 | return 0; 25 | if (l==tl && r==tr) 26 | return t[v]; 27 | int tm=(tl+tr)>>1; 28 | return max(get_max(v<<1,tl,tm,l,min(r,tm)),get_max((v<<1)+1,tm+1,tr,max(l,tm+1),r)); 29 | } 30 | 31 | void update (int v, int tl, int tr, int pos, int new_val) 32 | { 33 | if (tl==tr) 34 | t[v]=new_val; 35 | else 36 | { 37 | int tm=(tl+tr)>>1; 38 | if (pos<=tm) 39 | update(v<<1,tl,tm,pos,new_val); 40 | else update ((v<<1)+1,tm+1,tr,pos,new_val); 41 | t[v]=max(t[v<<1],t[(v<<1)+1]); 42 | } 43 | } 44 | 45 | int main(void) 46 | { 47 | cin>>n; 48 | int i; 49 | for (i=1;i<=n;i++) 50 | a[i]=i; 51 | build(1,1,n); 52 | cout<>n; 56 | return 0; 57 | } 58 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_отрезков/e-maxx/RSQ(e-maxx).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define maxn 11111 3 | 4 | using namespace std; 5 | 6 | int n,t[maxn],a[maxn]; 7 | 8 | void build(int v,int tl,int tr){ 9 | if (tl==tr)t[v]=a[tl]; 10 | else{ 11 | int tm=(tl+tr)>>1; 12 | build(v<<1,tl,tm); 13 | build((v<<1)+1,tm+1,tr); 14 | t[v]=t[v<<1]+t[(v<<1)+1]; 15 | } 16 | } 17 | 18 | int sum(int v,int tl,int tr,int l,int r){ 19 | if (l>r) return 0; 20 | if (l==tl && r==tr) return t[v]; 21 | int tm=(tl+tr)>>1; 22 | return sum(v<<1,tl,tm,l,min(r,tm))+sum((v<<1)+1,tm+1,tr,max(l,tm+1),r); 23 | } 24 | 25 | void update (int v, int tl, int tr, int pos, int new_val){ 26 | if (tl==tr) t[v]=new_val; 27 | else{ 28 | int tm=(tl+tr)>>1; 29 | if (pos<=tm) update(v<<1,tl,tm,pos,new_val); 30 | else update ((v<<1)+1,tm+1,tr,pos,new_val); 31 | t[v] = t[v<<1]+t[(v<<1)+1]; 32 | } 33 | } 34 | 35 | int main(void){ 36 | cin>>n; 37 | int i; 38 | for (i=1;i<=n;i++) a[i]=i; 39 | build(1,1,n); 40 | update(1,1,n,2,100); 41 | cout<>n; 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_отрезков/min_value_lower_x.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #define N 111111 6 | #define INF 1111111111 7 | 8 | using namespace std; 9 | 10 | struct tree{ 11 | int l,r; 12 | vector v; 13 | } t[4*N]; 14 | int n,r,a[N]; 15 | 16 | void build(int v,int l, int r){ 17 | t[v].l=l;t[v].r=r; 18 | if (l==r) t[v].v=vector(1,a[l]); 19 | else{ 20 | build(v+v,l,(l+r)/2); 21 | build(v+v+1,(l+r)/2+1,r); 22 | merge(t[v+v].v.begin(),t[v+v].v.end(),t[v+v+1].v.begin(),t[v+v+1].v.end(),back_inserter(t[v].v)); 23 | } 24 | } 25 | 26 | int ask1(int v,int l,int r,int x){ 27 | if (l>t[v].r || r=l && t[v].r<=r){ 29 | vector::iterator pos=lower_bound(t[v].v.begin(),t[v].v.end(),x); 30 | if (pos!=t[v].v.end()) return *pos; 31 | return INF; 32 | } 33 | return min(ask1(v+v,l,r,x),ask1(v+v+1,l,r,x)); 34 | } 35 | 36 | int ask2(int v,int l,int r,int x){ 37 | if (l>t[v].r || r=l && t[v].r<=r){ 39 | vector::iterator pos=lower_bound(t[v].v.begin(),t[v].v.end(),x); 40 | if (*pos==x) return *pos; 41 | if (pos==t[v].v.begin()) return -INF; 42 | --pos; 43 | return *pos; 44 | } 45 | return max(ask2(v+v,l,r,x),ask2(v+v+1,l,r,x)); 46 | } 47 | 48 | void init(void){ 49 | freopen("input.txt","r",stdin); 50 | freopen("output.txt","w",stdout); 51 | cin>>n>>r; 52 | int i; 53 | for (int i=1;i<=n;i++) cin>>a[i]; 54 | build(1,1,n); 55 | } 56 | 57 | void sol(void){ 58 | while (r--){ 59 | int x,l,r; 60 | int f1,f2; 61 | cin>>l>>r>>x; 62 | f1=ask1(1,l,r,x); 63 | f2=ask2(1,l,r,x); 64 | if (f1==INF) cout< 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=15000000; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct tree{ 46 | int ls,rs,sum; 47 | tree(){} 48 | tree(int value):ls(0),rs(0),sum(value){} 49 | } t[N]; 50 | 51 | int c,n,a[100001],root[100001],k,sorted[100001],m; 52 | 53 | int build(int l,int r){ 54 | int v=++c; 55 | if (l==r) t[v]=tree(0); 56 | else { 57 | t[v].ls=build(l,(l+r)/2); 58 | t[v].rs=build((l+r)/2+1,r); 59 | t[v].sum=t[t[v].ls].sum+t[t[v].rs].sum; 60 | } 61 | return v; 62 | } 63 | 64 | int getsum(int v,int l,int r,int tl,int tr){ 65 | if (tl>r || tr=l && tr<=r) return t[v].sum; 67 | return getsum(t[v].ls,l,r,tl,(tl+tr)/2)+getsum(t[v].rs,l,r,(tl+tr)/2+1,tr); 68 | } 69 | 70 | int modify(int v,int pos,int value,int tl,int tr){ 71 | int nv=++c; 72 | if (tl==tr) t[nv]=tree(value); 73 | else { 74 | int mid=(tl+tr)/2; 75 | if (pos<=mid) t[nv].rs=t[v].rs,t[nv].ls=modify(t[v].ls,pos,value,tl,mid); 76 | else t[nv].ls=t[v].ls,t[nv].rs=modify(t[v].rs,pos,value,mid+1,tr); 77 | t[nv].sum=t[t[nv].ls].sum+t[t[nv].rs].sum; 78 | } 79 | return nv; 80 | } 81 | 82 | int get_k(int p,int q,int k,int tl,int tr){ 83 | if (tl==tr) return tl; 84 | if (t[t[q].ls].sum-t[t[p].ls].sum>=k) return get_k(t[p].ls,t[q].ls,k,tl,(tl+tr)/2); 85 | else return get_k(t[p].rs,t[q].rs,k-t[t[q].ls].sum+t[t[p].ls].sum,(tl+tr)/2+1,tr); 86 | } 87 | 88 | int main(){ 89 | // ropen("input.txt"); 90 | scanf("%d%d",&n,&m); 91 | forn(i,n) scanf("%d",&a[i]); 92 | forn(i,n) sorted[i]=a[i]; 93 | sort(sorted+1,sorted+n+1); 94 | forn(i,n) a[i]=lower_bound(sorted+1,sorted+n+1,a[i])-sorted; 95 | root[k++]=build(1,n); 96 | forn(i,n){ 97 | int val=getsum(root[k-1],a[i],a[i],1,n); 98 | root[k]=modify(root[k-1],a[i],val+1,1,n); 99 | ++k; 100 | } 101 | rep(i,m){ 102 | int l,r,k; 103 | scanf("%d%d%d",&l,&r,&k); 104 | printf("%d\n",sorted[get_k(root[l-1],root[r],k,1,n)]); 105 | } 106 | return 0; 107 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_отрезков/persistent/Kth_on_interval_pointers.cpp: -------------------------------------------------------------------------------- 1 | #pragma comment(linker, "/STACK:65777216") 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=111111; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct tree{ 46 | int sum; 47 | tree *l,*r; 48 | tree(){} 49 | tree(int value):l(NULL),r(NULL),sum(value){} 50 | tree(tree* l, tree *r):l(l),r(r){ 51 | sum=l->sum+r->sum; 52 | } 53 | 54 | } t[N]; 55 | typedef tree* ptree; 56 | 57 | ptree root[N]; 58 | int n,a[N],k,sorted[N],m; 59 | 60 | ptree build(int l,int r){ 61 | if (l==r) return new tree(0); 62 | return new tree(build(l,(l+r)/2),build((l+r)/2+1,r)); 63 | } 64 | 65 | int getsum(ptree t,int l,int r,int tl,int tr){ 66 | if (tl>r || tr=l && tr<=r) return t->sum; 68 | return getsum(t->l,l,r,tl,(tl+tr)/2)+getsum(t->r,l,r,(tl+tr)/2+1,tr); 69 | } 70 | 71 | ptree modify(ptree t,int pos,int value,int tl,int tr){ 72 | if (tl==tr) return new tree(value); 73 | else { 74 | if (pos<=(tl+tr)/2) return new tree(modify(t->l,pos,value,tl,(tl+tr)/2),t->r); 75 | else return new tree(t->l,modify(t->r,pos,value,(tl+tr)/2+1,tr)); 76 | } 77 | } 78 | 79 | int get_k(ptree p, ptree q,int k,int tl,int tr){ 80 | if (tl==tr) return tl; 81 | if (q->l->sum-p->l->sum>=k) return get_k(p->l,q->l,k,tl,(tl+tr)/2); 82 | else return get_k(p->r,q->r,k-q->l->sum+p->l->sum,(tl+tr)/2+1,tr); 83 | } 84 | 85 | int main(){ 86 | // ropen("input.txt"); 87 | scanf("%d%d",&n,&m); 88 | forn(i,n) scanf("%d",&a[i]); 89 | forn(i,n) sorted[i]=a[i]; 90 | sort(sorted+1,sorted+n+1); 91 | forn(i,n) a[i]=lower_bound(sorted+1,sorted+n+1,a[i])-sorted; 92 | root[k++]=build(1,n); 93 | forn(i,n){ 94 | int val=getsum(root[k-1],a[i],a[i],1,n); 95 | root[k]=modify(root[k-1],a[i],val+1,1,n); 96 | ++k; 97 | } 98 | rep(i,m){ 99 | int l,r,k; 100 | scanf("%d%d%d",&l,&r,&k); 101 | printf("%d\n",sorted[get_k(root[l-1],root[r],k,1,n)]); 102 | } 103 | return 0; 104 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_отрезков/persistent/Sum.cpp: -------------------------------------------------------------------------------- 1 | #pragma comment(linker, "/STACK:65777216") 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=1111111; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct tree{ 46 | int ls,rs,sum; 47 | tree(){} 48 | tree(int value):ls(0),rs(0),sum(value){} 49 | } t[N]; 50 | 51 | int c,n,a[N],root[N],k; 52 | 53 | int build(int l,int r){ 54 | int v=++c; 55 | if (l==r) t[v]=tree(a[l]); 56 | else { 57 | t[v].ls=build(l,(l+r)/2); 58 | t[v].rs=build((l+r)/2+1,r); 59 | t[v].sum=t[t[v].ls].sum+t[t[v].rs].sum; 60 | } 61 | return v; 62 | } 63 | 64 | int getsum(int v,int l,int r,int tl,int tr){ 65 | if (tl>r || tr=l && tr<=r) return t[v].sum; 67 | return getsum(t[v].ls,l,r,tl,(tl+tr)/2)+getsum(t[v].rs,l,r,(tl+tr)/2+1,tr); 68 | } 69 | 70 | int modify(int v,int pos,int value,int tl,int tr){ 71 | int nv=++c; 72 | if (tl==tr) t[nv]=tree(value); 73 | else { 74 | int mid=(tl+tr)/2; 75 | if (pos<=mid) t[nv].rs=t[v].rs,t[nv].ls=modify(t[v].ls,pos,value,tl,mid); 76 | else t[nv].ls=t[v].ls,t[nv].rs=modify(t[v].ls,pos,value,mid+1,tr); 77 | t[nv].sum=t[t[nv].ls].sum+t[t[nv].rs].sum; 78 | } 79 | return nv; 80 | } 81 | 82 | int main(){ 83 | ropen("input.txt"); 84 | scanf("%d",&n); 85 | forn(i,n) scanf("%d",&a[i]); 86 | root[k++]=build(1,n); 87 | int l1,r1,l2,r2; 88 | scanf("%d%d%d%d",&l1,&r1,&l2,&r2); 89 | root[k++]=modify(root[0],l1,r1,1,n); 90 | printf("%d %d\n",getsum(root[0],l2,r2,1,n),getsum(root[1],l2,r2,1,n)); 91 | return 0; 92 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_отрезков/persistent/Sum_pointers.cpp: -------------------------------------------------------------------------------- 1 | #pragma comment(linker, "/STACK:65777216") 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #define y1 trololoy1 18 | #define y0 trololoy0 19 | #define mem(A,X) memset(A,X,sizeof(A)) 20 | #define memo(A) memset(A,0,sizeof(A)) 21 | #define forn(I,B) for (int I=1;I<=(B);I++) 22 | #define forg(H,V) for (int H=first[V];h;h=next[H]) 23 | #define rep(I,B) for (int I=0;I<(B);I++) 24 | #define labs(X) (((X)>0)?(X):(-(X))) 25 | #define ropen(X) freopen(X,"r",stdin) 26 | #define wopen(X) freopen(X,"w",stdout) 27 | #define rwopen(X) freopen(X".in","r",stdin);freopen(X".out","w",stdout) 28 | #define pb push_back 29 | #define mp make_pair 30 | #define all(X) (X).begin(),(X).end() 31 | #define sqr(X) ((X)*(X)) 32 | 33 | using namespace std; 34 | 35 | typedef pair pii; 36 | typedef double ld; 37 | typedef long long ll; 38 | typedef pair pll; 39 | typedef vector vi; 40 | const int N=1111111; 41 | const int INF=111111111; 42 | const double eps=1e-9; 43 | const double pi=3.14159265358979; 44 | 45 | struct tree{ 46 | int sum; 47 | tree *l,*r; 48 | tree(){} 49 | tree(int value):l(NULL),r(NULL),sum(value){} 50 | tree(tree* l, tree *r):l(l),r(r){ 51 | sum=l->sum+r->sum; 52 | } 53 | 54 | } t[N]; 55 | typedef tree* ptree; 56 | 57 | ptree root[N]; 58 | int n,a[N],k; 59 | 60 | ptree build(int l,int r){ 61 | if (l==r) return new tree(a[l]); 62 | return new tree(build(l,(l+r)/2),build((l+r)/2+1,r)); 63 | } 64 | 65 | int getsum(ptree t,int l,int r,int tl,int tr){ 66 | if (tl>r || tr=l && tr<=r) return t->sum; 68 | return getsum(t->l,l,r,tl,(tl+tr)/2)+getsum(t->r,l,r,(tl+tr)/2+1,tr); 69 | } 70 | 71 | ptree modify(ptree t,int pos,int value,int tl,int tr){ 72 | if (tl==tr) return new tree(value); 73 | else { 74 | if (pos<=(tl+tr)/2) return new tree(modify(t->l,pos,value,tl,(tl+tr)/2),t->r); 75 | else return new tree(t->l,modify(t->r,pos,value,(tl+tr)/2+1,tr)); 76 | } 77 | } 78 | 79 | int main(){ 80 | ropen("input.txt"); 81 | scanf("%d",&n); 82 | forn(i,n) scanf("%d",&a[i]); 83 | root[k++]=build(1,n); 84 | int l1,r1,l2,r2; 85 | scanf("%d%d%d%d",&l1,&r1,&l2,&r2); 86 | root[k++]=modify(root[0],l1,r1,1,n); 87 | printf("%d %d\n",getsum(root[0],l2,r2,1,n),getsum(root[1],l2,r2,1,n)); 88 | return 0; 89 | } -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_фенвика/Summator.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int s[100],n; 7 | 8 | int prev(int x) 9 | { 10 | return (x&(x-1)); 11 | } 12 | 13 | int next(int x) 14 | { 15 | return ((x<<1) - prev(x)); 16 | } 17 | 18 | void modify(int pos, int value) 19 | { 20 | for (;pos<=n;pos=next(pos)) s[pos]+=value; 21 | } 22 | 23 | int findsum(int l, int r) 24 | { 25 | int res=0,p; 26 | for (p=r;p>0;p=prev(p)) res+=s[p]; 27 | for (p=l-1;p>0;p=prev(p)) res-=s[p]; 28 | return res; 29 | } 30 | 31 | void init(void) 32 | { 33 | // freopen("input.txt","r",stdin); 34 | // freopen("output.txt","w",stdout); 35 | cin>>n; 36 | int i,c; 37 | for (i=1;i<=n;i++) 38 | s[i]=0; 39 | for (i=1;i<=n;i++) 40 | { 41 | cin>>c; 42 | modify(i,c); 43 | } 44 | } 45 | 46 | void sol(void) 47 | { 48 | int i,j; 49 | for (i=1;i<=n;i++,cout<>n; 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_фенвика/maximator.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define maxn 100 4 | #define inf 10000 5 | 6 | using namespace std; 7 | 8 | int m[maxn],n; 9 | 10 | int prev(int x) 11 | { 12 | return (x&(x-1)); 13 | } 14 | 15 | int next(int x) 16 | { 17 | return ((x<<1)-prev(x)); 18 | } 19 | 20 | void modify(int pos, int value) 21 | { 22 | for (int p=pos;p<=n;p=next(p)) m[p]=max(m[p],value); 23 | } 24 | 25 | int findmax(int last) 26 | { 27 | int res=-inf; 28 | for(;last>0;last=prev(last)) res=max(res,m[last]); 29 | return res; 30 | } 31 | 32 | void init(void) 33 | { 34 | // freopen("input.txt","r",stdin); 35 | // freopen("output.txt","w",stdout); 36 | cin>>n; 37 | for (int i=1;i<=n;i++) 38 | m[i]=-inf; 39 | for (int i=1;i<=n;i++) 40 | { 41 | int x; 42 | cin>>x; 43 | modify(i,x); 44 | } 45 | } 46 | 47 | void sol(void) 48 | { 49 | for (int i=1;i<=n;i++) cout<>n; 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Исходники Трухановича Влада/Структуры данных/Деревья_фенвика/maximizator.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define maxn 10000 5 | #define inf 1000000000 6 | 7 | using namespace std; 8 | 9 | int m[maxn],n,l[maxn],r[maxn]; 10 | 11 | int prev(int x) 12 | { 13 | return (x&(x-1)); 14 | } 15 | 16 | int next(int x) 17 | { 18 | return ((x<<1)-prev(x)); 19 | } 20 | 21 | void modify(int pos, int value) 22 | { 23 | int p; 24 | for (p=pos;p<=n;p=next(p)) r[p]=max(r[p],value); 25 | m[pos]=max(m[pos],value); 26 | for (p=pos;p>0;p=prev(p)) l[p]=max(l[p],value); 27 | } 28 | 29 | int findmax(int ll,int rr) 30 | { 31 | int res,p; 32 | res=-inf; 33 | for (p=ll;next(p)<=rr;p=next(p)) res=max(res,l[p]); 34 | res=max(res,m[p]); 35 | for (p=rr;prev(p)>=ll;p=prev(p)) res=max(res,r[p]); 36 | return res; 37 | } 38 | 39 | void init(void) 40 | { 41 | // freopen("input.txt","r",stdin); 42 | // freopen("output.txt","w",stdout); 43 | cin>>n; 44 | int x,i; 45 | for (i=1;i<=n;i++) 46 | m[i]=r[i]=l[i]=-inf; 47 | for (i=1;i<=n;i++) 48 | { 49 | cin>>x; 50 | modify(i,x); 51 | } 52 | } 53 | 54 | void sol(void) 55 | { 56 | int i,j; 57 | for (i=1;i<=n;i++,cout<>n; 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Ввод и вывод через nolock.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | using namespace std; 18 | typedef long long ll; 19 | 20 | ll n, m, i, j, k; 21 | 22 | 23 | #define putcx _putchar_nolock 24 | #define getcx _getchar_nolock 25 | 26 | inline void inp(ll &n) 27 | { 28 | n = 0; 29 | ll ch = getcx(); ll sign = 1; 30 | while (ch < '0' || ch > '9') 31 | { 32 | if (ch == '-') 33 | sign = -1; 34 | ch = getcx(); 35 | } 36 | while (ch >= '0' && ch <= '9') 37 | n = (n << 3) + (n << 1) + ch - '0', ch = getcx(); 38 | n = n*sign; 39 | //(n<<3)+(n<<1) + ch - '0'== n*10 + ch-'0' 40 | } 41 | 42 | inline ll ab(ll &x) 43 | { 44 | return x>0 ? x : -x; 45 | } 46 | 47 | void put(ll x) 48 | { 49 | if(x) 50 | { 51 | put(x/10); 52 | putcx(x%10+'0'); 53 | } 54 | } 55 | 56 | inline void out(ll x) 57 | { 58 | if(x) 59 | { 60 | if(x<0) putcx('-'); 61 | put(ab(x)); 62 | } 63 | else 64 | putcx('0'); 65 | } 66 | 67 | int main() 68 | { 69 | //freopen("input.txt","r",stdin); 70 | n = 10; 71 | ll x; 72 | for (ll i = 0; i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | #define mp make_pair 18 | #define pb push_back 19 | #define x first 20 | #define y second 21 | #define ins insert 22 | using namespace std; 23 | typedef long long ll; 24 | typedef long double ld; 25 | typedef pair pii; 26 | 27 | ll n,m,i,j,k; 28 | vector a; 29 | 30 | void test() 31 | { 32 | cin>>n; 33 | a.resize(n); 34 | for(ll i=0;i>a[i].x>>a[i].y; 36 | sort(a.begin(),a.end()); 37 | ll cur=0,next; 38 | ld dx=-1,dy=0,ans=0,dcos=-2,dlen=0.0; 39 | do 40 | { 41 | for(ll i=0;i= dcos) 47 | { 48 | if(tcos == dcos) 49 | { 50 | if(tlen > dlen) 51 | { 52 | next=i; 53 | dlen=tlen; 54 | } 55 | } 56 | else 57 | { 58 | dcos=tcos; 59 | dlen=tlen; 60 | next=i; 61 | } 62 | } 63 | } 64 | ans+=dlen; 65 | dx=(a[next].x-a[cur].x)/dlen; 66 | dy=(a[next].y-a[cur].y)/dlen; 67 | cur=next; 68 | dcos=-2; 69 | dlen=0; 70 | } 71 | while(cur != 0); 72 | cout.setf(ios_base::fixed); 73 | cout.precision(1); 74 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | 12 | #define x first 13 | #define y second 14 | #define pb push_back 15 | #define mp make_pair 16 | 17 | using namespace std; 18 | typedef long long ll; 19 | typedef long double ld; 20 | typedef pair pii; 21 | 22 | ll n,m,i,j,k,xt,yt; 23 | pair t1,t2,t3,t4; 24 | 25 | bool bounding_box(ll x1,ll x2,ll x3,ll x4) 26 | { 27 | if(x1>x2) swap(x1,x2); 28 | if(x3>x4) swap(x3,x4); 29 | if((x1 <= x4 && x4<=x2) || (x1 <= x3 && x3 <= x2) || (x3<=x1 && x1<=x4) || (x3<=x2 && x2<=x4)) 30 | return true; 31 | else 32 | return false; 33 | } 34 | 35 | bool peresec(pii x1,pii x2,pii x3,pii x4) 36 | { 37 | ll lenx=x1.x-x2.x,leny=x1.y-x2.y; 38 | ll temp1x=x1.x-x3.x,temp1y=x1.y-x3.y; 39 | ll temp2x=x1.x-x4.x,temp2y=x1.y-x4.y; 40 | ll znak1=lenx*temp1y-temp1x*leny,znak2=lenx*temp2y-temp2x*leny; 41 | if(znak1 == 0 || znak2 == 0 || (znak1 < 0 && znak2>0) || (znak1>0 && znak2<0)) 42 | return true; 43 | else 44 | return false; 45 | } 46 | 47 | void test() 48 | { 49 | cin>>t1.x>>t1.y>>t2.x>>t2.y>>t3.x>>t3.y>>t4.x>>t4.y; 50 | if(bounding_box(t1.x,t2.x,t3.x,t4.x) && bounding_box(t1.y,t2.y,t3.y,t4.y)) 51 | { 52 | if(peresec(t1,t2,t3,t4) && peresec(t3,t4,t1,t2)) 53 | cout<<"Yes"; 54 | else 55 | cout<<"No"; 56 | } 57 | else 58 | cout<<"No"; 59 | } 60 | 61 | 62 | int main() 63 | { 64 | ios_base::sync_with_stdio(0); 65 | test(); 66 | return 0; 67 | } 68 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Геометрия/Площадь многоугольника.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define x first 13 | #define y second 14 | #define pb push_back 15 | #define mp make_pair 16 | 17 | using namespace std; 18 | typedef long long ll; 19 | typedef long double ld; 20 | 21 | ll n,m,i,j,k; 22 | vector > a; 23 | ld ans=0.0; 24 | 25 | void test() 26 | { 27 | cin>>n; 28 | for(ll i=0;i>t1>>t2; 32 | a.pb(mp(t1,t2)); 33 | } 34 | a.pb(mp(a[0].x,a[0].y)); 35 | for(ll i=1;i<=n;++i) 36 | { 37 | ld h=a[i].x-a[i-1].x; 38 | ld ax=a[i-1].y,bx=a[i].y; 39 | ans+=(ax+bx)/2*h; 40 | } 41 | if(ans<0.0) 42 | ans=-ans; 43 | cout.setf(ios_base::fixed); 44 | cout.precision(1); 45 | ld b = ll(ans*10 + 0.5)/10.0; 46 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define mp make_pair 19 | #define pb push_back 20 | #define x first 21 | #define y second 22 | #define ins insert 23 | 24 | using namespace std; 25 | typedef long long ll; 26 | typedef long double ld; 27 | typedef pair,pair > points; 28 | 29 | ll n,m,i,j,k,ans=0; 30 | set forx,fory; 31 | vector ax,ay; 32 | vector arr; 33 | 34 | bool check(ll dx,ll dy) 35 | { 36 | for(ll i=0;i=arr[i].x.x && dx=arr[i].x.y && dy>n; 45 | ll temp; 46 | arr.resize(n); 47 | ll dx1,dx2,dy1,dy2; 48 | for(ll i=0;i>dx1>>dy1>>dx2>>dy2; 51 | if(dx1>dx2) swap(dx1,dx2); 52 | if(dy1>dy2) swap(dy1,dy2); 53 | forx.ins(dx1);forx.ins(dx2); 54 | fory.ins(dy1);fory.ins(dy2); 55 | arr[i].x.x=dx1;arr[i].x.y=dy1; 56 | arr[i].y.x=dx2;arr[i].y.y=dy2; 57 | } 58 | for(set::iterator it=forx.begin();it !=forx.end();++it) 59 | ax.pb(*it); 60 | for(set::iterator it=fory.begin();it !=fory.end();++it) 61 | ay.pb(*it); 62 | sort(ax.begin(),ax.end()); 63 | sort(ay.begin(),ay.end()); 64 | for(ll i=0;i 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #define mp make_pair 22 | #define pb push_back 23 | #define x first 24 | #define y second 25 | #define ins insert 26 | 27 | using namespace std; 28 | typedef long long ll; 29 | typedef long double ld; 30 | typedef pair pii; 31 | typedef pair pdd; 32 | typedef vector lnum; 33 | 34 | 35 | const ll maxv=500007,maxe=maxv*2; 36 | ll n, m, i, j, k; 37 | ll es[maxe],ef[maxe],nex[maxe],first[maxv],c=0; 38 | vector sp; 39 | vector > zap(maxv); 40 | vector d(maxv,-1),anc(maxv,-1); 41 | vector used(maxv,false); 42 | 43 | void add(ll v1,ll v2) 44 | { 45 | nex[++c]=first[v1];first[v1]=c; 46 | ef[c]=v1;es[c]=v2; 47 | } 48 | 49 | ll findroot(ll x) 50 | { 51 | return d[x] == x ? x : d[x]=findroot(d[x]); 52 | } 53 | 54 | void union_set(ll v1,ll v2,ll newanc) 55 | { 56 | ll q1=findroot(v1),q2=findroot(v2); 57 | if(q1 != q2) 58 | { 59 | if(rand() & 1) swap(q1,q2); 60 | d[q1]=q2; anc[q2]=newanc; 61 | } 62 | } 63 | 64 | void dfs(ll v) 65 | { 66 | d[v]=v;anc[v]=v;used[v]=true; 67 | for(ll h=first[v];h;h=nex[h]) 68 | { 69 | if(!used[es[h]]) 70 | { 71 | dfs(es[h]); 72 | union_set(v,es[h],v); 73 | } 74 | } 75 | for(ll i=0;i>n; 87 | string s; 88 | ll left,right; 89 | for(ll i=0;i>s>>left>>right; 92 | if(s == "ADD") 93 | { 94 | add(left,right); 95 | add(right,left); 96 | } 97 | else 98 | { 99 | sp.pb(0); 100 | zap[left].pb(mp(right,sp.size()-1)); 101 | zap[right].pb(mp(left,sp.size()-1)); 102 | } 103 | } 104 | dfs(1); 105 | for(ll i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | typedef long long ll; 10 | 11 | const ll maxv = 1000, maxe = 10000, maxk = 15; 12 | ll ef[maxe], es[maxe], nexti[maxe], first[maxe], c = 0; 13 | ll n, m, i, j, k, timer = 0, ptr = 0; 14 | vector tin1(maxv, 0), tin2(maxv, 0), refe(2 * maxv, 0), logn(maxv, 0); 15 | ll t[maxv][maxk]; 16 | 17 | void add(ll v1, ll v2) 18 | { 19 | nexti[++c] = first[v1]; first[v1] = c; 20 | ef[c] = v1; es[c] = v2; 21 | } 22 | 23 | void input() 24 | { 25 | cin >> n >> m; 26 | for (ll i = 0; i> x >> y; 30 | add(x, y); 31 | add(y, x); 32 | } 33 | } 34 | 35 | void dfs(ll v) 36 | { 37 | tin1[v] = ++timer; 38 | tin2[timer] = v; 39 | bool ok = true; 40 | for (ll h = first[v]; h; h = nexti[h]) 41 | { 42 | if (!tin1[es[h]]) 43 | { 44 | dfs(es[h]); 45 | ok = false; 46 | t[++ptr][0] = tin1[v]; 47 | } 48 | } 49 | if (ok) 50 | t[++ptr][0] = tin1[v]; 51 | } 52 | 53 | void calc() 54 | { 55 | for (ll i = 2; i <= ptr; ++i) 56 | logn[i] = logn[i >> 1] + 1; 57 | } 58 | 59 | void sparse() 60 | { 61 | calc(); 62 | for (ll j = 1; j <= logn[ptr]; ++j) 63 | for (ll i = 1; i + (1 << (j - 1)) <= ptr; ++i) 64 | t[i][j] = min(t[i][j - 1], t[i + (1 << (j - 1))][j - 1]); 65 | } 66 | 67 | ll getmin(ll l, ll r) 68 | { 69 | ll k = logn[r - l + 1]; 70 | return min(t[l][k], t[r - (1 << k) + 1][k]); 71 | } 72 | 73 | void lca_build() 74 | { 75 | dfs(1); 76 | for (ll i = 1; i <= ptr; ++i) 77 | if (!refe[t[i][0]]) 78 | refe[t[i][0]] = i; 79 | sparse(); 80 | } 81 | 82 | ll lca_get(ll v1, ll v2) 83 | { 84 | ll l = refe[tin1[v1]], r = refe[tin1[v2]]; 85 | if (l>r) swap(l, r); 86 | return tin2[getmin(l, r)]; 87 | } 88 | 89 | void test() 90 | { 91 | input(); 92 | lca_build(); 93 | ll temp; 94 | cin >> temp; 95 | for (ll i = 0; i> x >> y; 99 | cout << lca_get(x, y) << endl; 100 | } 101 | } 102 | 103 | int main() 104 | { 105 | freopen("input.txt", "r", stdin); 106 | //freopen("output.txt","w",stdout); 107 | //ios_base::sync_with_stdio(0); 108 | test(); 109 | return 0; 110 | } -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Графы/Алгоритм Диница.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | typedef long long ll; 11 | 12 | const ll maxv=10000,maxe=200000; 13 | ll ef[maxe],es[maxe],ev[maxe],nexti[maxe],first[maxv],c=0; 14 | ll n,m,s,t,i,k,j; 15 | vector good; 16 | vector level; 17 | queue q; 18 | 19 | void add(ll v1,ll v2,ll val) 20 | { 21 | nexti[++c]=first[v1];first[v1]=c; 22 | ef[c]=v1;es[c]=v2;ev[c]=val; 23 | } 24 | 25 | void input() 26 | { 27 | cin>>n>>m; 28 | s=1;t=n; 29 | ll x,y,z; 30 | for(ll i=0;i>x>>y>>z; 33 | add(x,y,z); 34 | add(y,x,0); 35 | } 36 | } 37 | 38 | void bfs() 39 | { 40 | level[s]=1; 41 | q.push(s); 42 | while(!q.empty()) 43 | { 44 | ll v=q.front();q.pop(); 45 | for(ll h=first[v];h;h=nexti[h]) 46 | { 47 | if(ev[h]>0 && level[es[h]] == 0) 48 | { 49 | level[es[h]]=level[v]+1; 50 | q.push(es[h]); 51 | } 52 | } 53 | } 54 | } 55 | 56 | ll be(ll x) 57 | { 58 | if(x & 1) return x+1; 59 | else return x-1; 60 | } 61 | 62 | ll dfs(ll v,ll flow) 63 | { 64 | if(v == t) return flow; 65 | ll temp=0,res=0; 66 | for(ll h=first[v];h && flow>0;h=nexti[h]) 67 | { 68 | if(ev[h]>0 && level[es[h]] == level[v]+1 && !good[es[h]]) 69 | { 70 | temp=dfs(es[h],min(flow,ev[h])); 71 | if(temp == 0) 72 | good[es[h]]=true; 73 | res+=temp; 74 | flow-=temp; 75 | ev[h]-=temp; 76 | ev[be(h)]+=temp; 77 | } 78 | } 79 | return res; 80 | } 81 | 82 | int main() 83 | { 84 | //freopen("input.txt","r",stdin); 85 | //freopen("output.txt",W',stdout); 86 | //ios_base::sync_with_stdio(0); 87 | input(); 88 | ll flow=0,ans=0; 89 | do 90 | { 91 | level.clear(); 92 | level.resize(n+3); 93 | good.clear(); 94 | good.resize(m*2+7); 95 | bfs(); 96 | ans=dfs(s,999999999LL); 97 | flow+=ans; 98 | } 99 | while(ans); 100 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | 19 | #define x first 20 | #define y second 21 | #define pb pus_back 22 | #define mp make_pair 23 | #define ins insert 24 | 25 | using namespace std; 26 | typedef long long ll; 27 | typedef long double ld; 28 | typedef pair pii; 29 | typedef pair pdd; 30 | 31 | const ll maxv=1000,maxe=maxv*maxv*2+7; 32 | const ll inf=1e9; 33 | 34 | ll n,m,i,j,k,c=0,s,t,scale=-inf,ans=0; 35 | ll es[maxe],first[maxv],nexti[maxe],from[maxv],edge[maxv],flow[maxe]; 36 | vector used; 37 | 38 | void add(ll v1,ll v2,ll val) 39 | { 40 | nexti[++c]=first[v1];first[v1]=c; 41 | es[c]=v2;flow[c]=val; 42 | } 43 | 44 | ll be(ll x) 45 | { 46 | if(x&1) return x+1; 47 | else return x-1; 48 | } 49 | 50 | void input() 51 | { 52 | cin>>n>>m; 53 | s=1;t=n; 54 | used.resize(n+7); 55 | ll x,y,z; 56 | for(ll i=0;i>x>>y>>z; 59 | add(x,y,z); 60 | add(y,x,0); 61 | scale=max(scale,z); 62 | } 63 | } 64 | 65 | bool path() 66 | { 67 | fill(used.begin(),used.end(),0); 68 | queue q; 69 | q.push(s); 70 | used[s]=true; 71 | while(!q.empty()) 72 | { 73 | ll v=q.front();q.pop(); 74 | for(ll h=first[v];h;h=nexti[h]) 75 | { 76 | if(flow[h]>=scale && !used[es[h]]) 77 | { 78 | used[es[h]]=true; 79 | q.push(es[h]); 80 | from[es[h]]=v; 81 | edge[es[h]]=h; 82 | if(es[h] == t) return true; 83 | } 84 | } 85 | } 86 | return false; 87 | } 88 | 89 | void test() 90 | { 91 | input(); 92 | while(scale) 93 | { 94 | while(path()) 95 | { 96 | ll res=inf; 97 | for(ll x=t;x!=s;x=from[x]) res=min(res,flow[edge[x]]); 98 | for(ll x=t;x!=s;x=from[x]) 99 | { 100 | flow[edge[x]]-=res; 101 | flow[be(edge[x])]+=res; 102 | } 103 | ans+=res; 104 | } 105 | scale>>=1; 106 | } 107 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | typedef long long ll; 11 | 12 | const ll maxv=1000,maxe=10000; 13 | ll ef[maxe],es[maxe],first[maxv],next[maxe],c=0; 14 | ll n,m,i,j,k; 15 | vector step(maxv,0); 16 | stack res; 17 | 18 | void add(ll v1,ll v2) 19 | { 20 | next[++c]=first[v1];first[v1]=c; 21 | ef[c]=v1;es[c]=v2; 22 | } 23 | 24 | void input() 25 | { 26 | cin>>n>>m; 27 | for(ll i=0;i>x>>y; 31 | add(x,y); 32 | //add(y,x); 33 | } 34 | } 35 | 36 | bool check_or(ll &from) 37 | { 38 | ll kf=0,kto=0; 39 | bool ok=true; 40 | for(ll i=1;i<=m;++i) 41 | { 42 | step[ef[i]]++; 43 | step[es[i]]--; 44 | } 45 | for(ll i=1;i<=n;++i) 46 | { 47 | if(step[i] <=-2 || step[i] >=2) 48 | { 49 | ok=false; 50 | break; 51 | } 52 | else if(step[i]==1) 53 | { 54 | from=i; 55 | kf++; 56 | } 57 | else if(step[i] == -1) 58 | { 59 | kto++; 60 | } 61 | } 62 | if(((kf==0 && kto==0)||(kf==1 && kto==1))&&ok) 63 | return true; 64 | else 65 | return false; 66 | } 67 | 68 | bool check_neor(ll &from) 69 | { 70 | ll kn=0; 71 | bool ok=true; 72 | for(ll i=1;i<=2*m;++i) 73 | step[ef[i]]++; 74 | for(ll i=1;i<=n;++i) 75 | { 76 | if(step[i]&1) 77 | { 78 | from=i; 79 | kn++; 80 | } 81 | } 82 | if(kn==0 || kn==2) 83 | return true; 84 | else 85 | return false; 86 | } 87 | 88 | void print() 89 | { 90 | while(!res.empty()) 91 | { 92 | cout< used(maxe,0); 107 | stack q; 108 | q.push(from); 109 | while(!q.empty()) 110 | { 111 | ll v=q.top(); 112 | bool ok=true; 113 | for(ll h=first[v];h;h=next[h]) 114 | { 115 | if(!used[h]) 116 | { 117 | ok=false; 118 | used[h]=true; 119 | //used[be(h)]=true; 120 | q.push(es[h]); 121 | break; 122 | } 123 | } 124 | if(ok) 125 | { 126 | q.pop(); 127 | res.push(v); 128 | } 129 | } 130 | } 131 | 132 | void test() 133 | { 134 | input(); 135 | ll from=1; 136 | if(check_or(from)) 137 | { 138 | eiler(from); 139 | print(); 140 | } 141 | else 142 | cout<<"Impossible"< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | #define x first 20 | #define y second 21 | #define pb push_back 22 | #define mp make_pair 23 | #define ins insert 24 | 25 | using namespace std; 26 | typedef long long ll; 27 | typedef long double ld; 28 | typedef pair pii; 29 | typedef pair pdd; 30 | 31 | ll n, m, i, j, k; 32 | ll f[10][1000000]; 33 | 34 | void calc(ll x,ll y,ll mask,ll next_mask) 35 | { 36 | if(y>=m) f[x+1][next_mask]+=f[x][mask]; 37 | else 38 | { 39 | ll cur=1<>n>>m; 52 | f[0][0]=1; 53 | for(ll i=0;i 2 | #include 3 | 4 | using namespace std; 5 | typedef long long ll; 6 | 7 | const ll size=100; 8 | ll a[size],i,j,p[size],w[size],s,n; 9 | 10 | void input() 11 | { 12 | cin>>n>>s; 13 | for(i=1;i<=s;++i) 14 | { 15 | cin>>p[i]>>w[i]; 16 | } 17 | } 18 | 19 | void sol() 20 | { 21 | a[0]=0; 22 | for(i=1;i<=n;++i) 23 | for(j=1;j<=s;++j) 24 | if(i >= w[j]) 25 | { 26 | a[i]=max(a[i],a[i-w[j]]+p[j]); 27 | } 28 | } 29 | 30 | void pred() 31 | { 32 | while(i>0) 33 | { 34 | for(j=1;j<=s;++j) 35 | { 36 | if(i>=w[j] && a[i-w[j]] == a[i]-p[j]) 37 | { 38 | cout< 2 | #include 3 | 4 | using namespace std; 5 | typedef long long ll; 6 | 7 | const ll size=100; 8 | ll a[size][size],i,j,p[size],w[size],s,n; 9 | 10 | void input() 11 | { 12 | cin>>n>>s; 13 | for(i=1;i<=s;++i) 14 | { 15 | cin>>p[i]>>w[i]; 16 | } 17 | } 18 | 19 | void sol() 20 | { 21 | for(j=1;j<=s;++j) 22 | for(i=1;i<=n;++i) 23 | { 24 | a[i][j]=a[i][j-1]; 25 | if(i>=w[j] && a[i][j] < a[i-w[j]][j-1]+p[j]) 26 | a[i][j] = a[i-w[j]][j-1]+p[j]; 27 | } 28 | } 29 | 30 | void pred(ll i,ll j) 31 | { 32 | if(i > 0 && j > 0) 33 | { 34 | if(j > 0 && i>=w[j] && a[i-w[j]][j-1] == a[i][j]-p[j]) 35 | { 36 | cout< 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | typedef long long ll; 7 | 8 | ll n,m,i,j,k; 9 | 10 | inline ll getInt() 11 | { 12 | ll res=0; 13 | bool ok=false; 14 | char s; 15 | do 16 | { 17 | s=getchar(); 18 | if(s == '-') ok=!ok; 19 | } 20 | while(s<'0' || s>'9'); 21 | do 22 | { 23 | res=res*10+(s-'0'); 24 | s=getchar(); 25 | } 26 | while(s>='0' && s<='9'); 27 | if(ok) res=-res; 28 | return res; 29 | } 30 | 31 | void put(ll x) 32 | { 33 | if(x) 34 | { 35 | put(x/10); 36 | putchar(x%10+'0'); 37 | } 38 | } 39 | 40 | inline void putInt(ll x) 41 | { 42 | if(x) 43 | { 44 | if(x<0) putchar('-'); 45 | put(abs(x)); 46 | } 47 | else putchar('0'); 48 | } 49 | 50 | int main() 51 | { 52 | n=getInt(); 53 | for(ll i=0;ioutput.txt 6 | fc.exe %2.out output.txt >> test.txt -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Строки/Hash.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zamazan4ik/Algorithms/5d91d76aa9235f5da3c198dcbfe4468609955d0c/Сборник моих алгоритмов/Строки/Hash.cpp -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Строки/Z.cpp: -------------------------------------------------------------------------------- 1 | void z(string &s) 2 | { 3 | vector z(s.length()); 4 | for(ll i=1,l=0,r=0;ir) l=i,r=i+z[i]-1; 9 | } 10 | } -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Строки/Ахо-Корасик.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define x first 19 | #define y second 20 | #define pb push_back 21 | #define mp make_pair 22 | #define ins insert 23 | 24 | using namespace std; 25 | 26 | typedef long long ll; 27 | typedef long double ld; 28 | typedef pair pii; 29 | typedef pair pdd; 30 | 31 | const ll maxn=10000; 32 | const ll k=53; 33 | 34 | struct tree 35 | { 36 | ll next[k],go[k],p,link,good; 37 | bool leaf; 38 | char pch; 39 | vector pat; 40 | }; 41 | 42 | ll n,m,i,j,sz=1; 43 | tree t[maxn]; 44 | vector str; 45 | vector used; 46 | string s; 47 | 48 | ll go(ll v,ll c); 49 | ll getlink(ll v); 50 | 51 | void init(ll v) 52 | { 53 | memset(t[v].next,255,sizeof(t[v].next)); 54 | memset(t[v].go,255,sizeof(t[v].go)); 55 | t[v].link=t[v].good=t[v].p=-1; 56 | t[v].leaf=false; 57 | } 58 | 59 | void add_bor(string &s,ll kol) 60 | { 61 | ll v=0; 62 | for(ll i=0;i>n; 141 | str.resize(n); 142 | used.resize(n); 143 | init(0); 144 | t[0].link=t[0].good=t[0].p=0; 145 | for(ll i=0;i>str[i]; 148 | add_bor(str[i],i); 149 | } 150 | cin>>s; 151 | finding(s); 152 | for(ll i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | string s; 10 | int i,size; 11 | vector digit; 12 | vector op; 13 | 14 | bool prav(char op) 15 | { 16 | return op=='^' ? true : false; 17 | } 18 | 19 | bool is_op(char c) 20 | { 21 | return c=='+' || c=='-' || c=='*' || c=='/' || c=='%' || c=='^'; 22 | } 23 | 24 | bool is_unary() 25 | { 26 | return i==0 || is_op(s[i-1]) || s[i-1] == '('; 27 | } 28 | 29 | int priority(char op) 30 | { 31 | if(op<0) 32 | return 4; 33 | else 34 | return op=='+' || op=='-' ? 1 : 35 | op=='*' || op=='/' || op=='%' ? 2 : 36 | op=='^' ? 3 : -1; 37 | } 38 | 39 | void process_op(char op) 40 | { 41 | if(op<0) 42 | { 43 | int l=digit.back(); 44 | digit.pop_back(); 45 | switch(-op) 46 | { 47 | case '+': digit.push_back(l); break; 48 | case '-': digit.push_back(-l); break; 49 | } 50 | } 51 | else 52 | { 53 | int r=digit.back(); 54 | digit.pop_back(); 55 | int l=digit.back(); 56 | digit.pop_back(); 57 | switch(op) 58 | { 59 | case '+':digit.push_back(l+r);break; 60 | case '-':digit.push_back(l-r);break; 61 | case '*':digit.push_back(l*r);break; 62 | case '/':digit.push_back(l/r);break; 63 | case '%':digit.push_back(l%r);break; 64 | case '^':digit.push_back(int(pow(float(l),float(r))));break; 65 | } 66 | } 67 | } 68 | 69 | int calc() 70 | { 71 | size=s.length(); 72 | for(i=0;i= 0 && priority(op.back()) >= priority(curop) || prav(op.back()) && priority(op.back()) > priority(curop) )) 91 | { 92 | process_op(op.back()); 93 | op.pop_back(); 94 | } 95 | op.push_back(curop); 96 | } 97 | else if(isdigit(s[i])) 98 | { 99 | string operand; 100 | while(i>s; 122 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | #define x first 21 | #define y second 22 | #define pb push_back 23 | #define mp make_pair 24 | #define ins insert 25 | 26 | using namespace std; 27 | 28 | typedef long long ll; 29 | typedef long double ld; 30 | typedef pair pii; 31 | typedef pair pdd; 32 | 33 | const ll p=53; 34 | const ll maxn=10000; 35 | 36 | ll n,m,i,j,k; 37 | ll pp[maxn]; 38 | ll h[maxn]; 39 | string s; 40 | 41 | ll get_hash(string &s) 42 | { 43 | ll res=0; 44 | for(ll i=0;i>s; 52 | cin>>n; 53 | pp[0]=1; 54 | for(ll i=1;i>t; 62 | ll h1=get_hash(t); 63 | if(t.length()>s.length()) 64 | { 65 | cout<<"NO"< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define x first 19 | #define y second 20 | #define pb push_back 21 | #define mp make_pair 22 | #define ins insert 23 | 24 | using namespace std; 25 | 26 | typedef long long ll; 27 | typedef long double ld; 28 | typedef pair pii; 29 | typedef pair pdd; 30 | 31 | const ll maxn=10000; 32 | 33 | struct tree 34 | { 35 | ll len,link; 36 | map next; 37 | }; 38 | 39 | ll n,m,i,j,sz=1,cur,last,p; 40 | tree t[2*maxn+7]; 41 | string s; 42 | 43 | void build_aut(string &s) 44 | { 45 | last=0; 46 | for(ll i=0;i>s; 88 | t[0].link=-1;t[0].len=0; 89 | build_aut(s); 90 | ll k; 91 | cin>>k; 92 | for(ll i=0;i>s; 95 | if(check(s)) cout<<"yes"< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | typedef long long ll; 9 | 10 | const ll maxn=100; 11 | vector d(maxn,-1); 12 | 13 | ll findroot(ll v) 14 | { 15 | return d[v]==-1 ? v : d[v]=findroot(d[v]); 16 | } 17 | 18 | void union_set(ll a,ll b) 19 | { 20 | ll q1,q2; 21 | q1=findroot(a); 22 | q2=findroot(b); 23 | if(q1 != q2) 24 | { 25 | r=rand() % 2; 26 | r==0 ? d[q1]=q2 : d[q2]=q1; 27 | } 28 | } 29 | 30 | 31 | 32 | int main() 33 | { 34 | srand(time(0)); 35 | system("pause"); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Структуры/Hash-map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | 21 | #define x first 22 | #define y second 23 | #define pb push_back 24 | #define mp make_pair 25 | #define ins insert 26 | 27 | using namespace std; 28 | 29 | typedef long long ll; 30 | typedef long double ld; 31 | typedef pair pii; 32 | typedef pair pdd; 33 | 34 | const ll mod=1000003; 35 | const ll maxn=mod; 36 | 37 | ll n,m,i,j,k; 38 | 39 | vector h[maxn]; 40 | 41 | void h_ins(ll key,ll zn) 42 | { 43 | ll pos=key%mod; 44 | ll len=h[pos].size(); 45 | bool ok=true; 46 | for(ll i=0;i>n; 97 | ll l,r; 98 | for(ll i=0;i>l>>r; 101 | h_ins(l,r); 102 | } 103 | cin>>m; 104 | for(ll i=0;i>l; 107 | if(h_in(l)) cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | 21 | #define x first 22 | #define y second 23 | #define pb push_back 24 | #define mp make_pair 25 | #define ins insert 26 | 27 | using namespace std; 28 | 29 | typedef long long ll; 30 | typedef long double ld; 31 | typedef pair pii; 32 | typedef pair pdd; 33 | 34 | const ll mod=1000003; 35 | const ll maxn=mod; 36 | 37 | ll n,m,i,j,k; 38 | 39 | 40 | vector h[maxn]; 41 | 42 | void h_ins(ll key) 43 | { 44 | ll pos=key%mod; 45 | ll len=h[pos].size(); 46 | bool ok=true; 47 | for(ll i=0;i>n; 86 | ll t; 87 | for(ll i=0;i>t; 90 | h_ins(t); 91 | } 92 | cin>>m; 93 | for(ll i=0;i>t; 96 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define x first 19 | #define y second 20 | #define pb push_back 21 | #define mp make_pair 22 | #define ins insert 23 | 24 | using namespace std; 25 | 26 | typedef long long ll; 27 | typedef long double ld; 28 | typedef pair pii; 29 | typedef pair pdd; 30 | 31 | const ll maxn=100; 32 | const ll maxi=100000000LL; 33 | struct tree 34 | { 35 | bool color=false; 36 | ll x=-maxi; 37 | }; 38 | 39 | ll n,m,i,j,k; 40 | tree t[4*maxn]; 41 | ll a[maxn]; 42 | 43 | void build(ll v,ll tl,ll tr) 44 | { 45 | if(tl == tr) t[v].x=a[tl]; 46 | else 47 | { 48 | ll tm=(tl+tr)>>1; 49 | build(v<<1,tl,tm); 50 | build((v<<1)+1,tm+1,tr); 51 | t[v].x=max(t[v<<1].x,t[(v<<1)+1].x); 52 | } 53 | } 54 | 55 | void push(ll v) 56 | { 57 | if(t[v].color) 58 | { 59 | t[v].color=false; 60 | t[v<<1].color=t[(v<<1)+1].color=true; 61 | t[v<<1].x=t[(v<<1)+1].x=t[v].x; 62 | } 63 | } 64 | 65 | ll getmax(ll v,ll tl,ll tr,ll l,ll r) 66 | { 67 | if(l>r) return -maxi; 68 | if(tl == l && tr == r) return t[v].x; 69 | push(v); 70 | ll tm=(tl+tr)>>1; 71 | return max(getmax(v<<1,tl,tm,l,min(tm,r)),getmax((v<<1)+1,tm+1,tr,max(l,tm+1),r)); 72 | } 73 | 74 | void update(ll v,ll tl,ll tr,ll l,ll r,ll val) 75 | { 76 | if(l>r)return; 77 | if(tl == l && tr == r) t[v].x=val,t[v].color=true; 78 | else 79 | { 80 | push(v); 81 | ll tm=(tl+tr)>>1; 82 | update(v<<1,tl,tm,l,min(r,tm),val); 83 | update((v<<1)+1,tm+1,tr,max(l,tm+1),r,val); 84 | t[v].x=max(t[v<<1].x,t[(v<<1)+1].x); 85 | } 86 | } 87 | 88 | void test() 89 | { 90 | scanf("%lld",&n); 91 | for(ll i=1;i<=n;++i) 92 | scanf("%lld",&a[i]); 93 | build(1,1,n); 94 | scanf("%lld",&k); 95 | for(ll i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | typedef long long ll; 10 | 11 | struct kor 12 | { 13 | ll sum,add,size; 14 | }; 15 | const ll maxn=10000; 16 | kor t[4*maxn+7]; 17 | ll a[maxn],n,m,i,j,k; 18 | 19 | void init() 20 | { 21 | cin>>n; 22 | for(ll i=1;i<=n;++i) 23 | cin>>a[i]; 24 | } 25 | 26 | void build(ll v,ll tl,ll tr) 27 | { 28 | if(tl == tr) 29 | { 30 | t[v].sum=a[tl]; 31 | t[v].size=1; 32 | } 33 | else 34 | { 35 | ll tm=tl+((tr-tl)>>1); 36 | build(v<<1,tl,tm); 37 | build((v<<1)+1,tm+1,tr); 38 | t[v].sum=t[v<<1].sum+t[(v<<1)+1].sum; 39 | t[v].size=t[v<<1].size+t[(v<<1)+1].size; 40 | } 41 | } 42 | 43 | ll getsum(ll v,ll tl,ll tr,ll l,ll r,ll add) 44 | { 45 | if(l>r) return 0; 46 | if(tl == l && tr == r) 47 | { 48 | return t[v].sum+t[v].size*(add+t[v].add); 49 | } 50 | else 51 | { 52 | ll tm=tl+((tr-tl)>>1); 53 | return getsum(v<<1,tl,tm,l,min(tm,r),add+t[v].add)+getsum((v<<1)+1,tm+1,tr,max(tm+1,l),r,add+t[v].add); 54 | } 55 | } 56 | 57 | void update(ll v,ll tl,ll tr,ll l,ll r,ll val) 58 | { 59 | if(l>r); 60 | else if(tl == l && tr == r) 61 | { 62 | t[v].add+=val; 63 | } 64 | else 65 | { 66 | ll tm=tl+((tr-tl)>>1); 67 | update(v<<1,tl,tm,l,min(tm,r),val); 68 | update((v<<1)+1,tm+1,tr,max(tm+1,l),r,val); 69 | t[v].sum=t[v<<1].sum+t[(v<<1)+1].sum+t[v<<1].size*t[v<<1].add+ 70 | t[(v<<1)+1].size*t[(v<<1)+1].add; 71 | } 72 | } 73 | 74 | ll getnumb(ll v,ll tl,ll tr,ll pos,ll add) 75 | { 76 | if(tl == tr) 77 | { 78 | return t[v].sum+t[v].add+add; 79 | } 80 | else 81 | { 82 | ll tm=tl+((tr-tl)>>1); 83 | if(pos<=tm) 84 | return getnumb(v<<1,tl,tm,pos,t[v].add+add); 85 | else 86 | return getnumb((v<<1)+1,tm+1,tr,pos,t[v].add+add); 87 | } 88 | } 89 | 90 | void test() 91 | { 92 | init(); 93 | build(1,1,n); 94 | ll temp; 95 | cin>>temp; 96 | for(ll i=0;i>x>>y>>z; 100 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | 11 | int arr[11]={0,1,2,3,4,5,6,7,8,9,10},t[4*11+1]; 12 | 13 | void build(int v,int tl,int tr) 14 | { 15 | if(tl==tr) 16 | t[v]=arr[tl]; 17 | else 18 | { 19 | int tm=tl+((tr-tl)>>1); 20 | build(v<<1,tl,tm); 21 | build((v<<1)+1,tm+1,tr); 22 | t[v]=t[v<<1]+t[(v<<1)+1]; 23 | } 24 | } 25 | 26 | void update(int v,int tl,int tr,int pos,int val) 27 | { 28 | if(tl==tr) 29 | t[v]=val; 30 | else 31 | { 32 | int tm=tl+((tr-tl)>>1); 33 | if(pos<=tm) 34 | update(v<<1,tl,tm,pos,val); 35 | else 36 | update((v<<1)+1,tm+1,tr,pos,val); 37 | t[v]=t[v<<1]+t[(v<<1)+1]; 38 | } 39 | } 40 | 41 | int sum(int v,int tl,int tr,int l,int r) 42 | { 43 | if(l>r) 44 | return 0; 45 | if(l==tl&&r==tr) 46 | return t[v]; 47 | int tm=tl+((tr-tl)>>1); 48 | return sum(v<<1,tl,tm,l,min(tm,r)) + sum((v<<1)+1,tm+1,tr,max(l,tm+1),r); 49 | } 50 | 51 | 52 | int main() 53 | { 54 | build(1,1,10); 55 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | 10 | using namespace std; 11 | typedef long long ll; 12 | 13 | const ll maxn=10000; 14 | ll a[maxn],b[maxn],c[maxn]; 15 | ll n,m,i,j,len; 16 | 17 | 18 | void init() 19 | { 20 | ll temp; 21 | cin>>n; 22 | len=sqrt(n); 23 | for(ll i=1;i<=n;++i) 24 | { 25 | cin>>temp; 26 | a[i]=temp; 27 | b[(i-1)/len+1]+=a[i]; 28 | } 29 | } 30 | 31 | void add(ll pos,ll val) 32 | { 33 | a[pos]+=val; 34 | b[(pos-1)/len+1]+=val; 35 | } 36 | 37 | void add_int(ll l,ll r,ll val) 38 | { 39 | for(ll i=l;i<=r;) 40 | { 41 | if(i+len<=r && (i-1)%len==0) 42 | { 43 | c[(i-1)/len+1]+=val; 44 | b[(i-1)/len+1]+=val*len; 45 | i+=len; 46 | } 47 | else 48 | { 49 | a[i]+=val; 50 | b[(i-1)/len+1]+=val; 51 | ++i; 52 | } 53 | } 54 | } 55 | 56 | ll sum(ll l,ll r) 57 | { 58 | ll res=0; 59 | for(ll i=l;i<=r;) 60 | { 61 | if(i+len<=r && (i-1)%len==0) 62 | { 63 | res+=b[(i-1)/len+1]; 64 | i+=len; 65 | } 66 | else 67 | { 68 | res+=a[i]+c[(i-1)/len+1]; 69 | ++i; 70 | } 71 | } 72 | return res; 73 | } 74 | 75 | void test() 76 | { 77 | init(); 78 | for(ll i=0;i<3;++i) 79 | { 80 | ll x,y; 81 | cin>>x>>y; 82 | cout<>x>>y>>z; 89 | add_int(x,y,z); 90 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | typedef long long ll; 9 | 10 | const ll maxn=10000,maxk=14; 11 | ll n,m,i,j,k; 12 | ll t[maxn][maxk],a[maxn],logn[maxn]; 13 | 14 | void calc() 15 | { 16 | for(ll i=2;i<=n;++i) 17 | logn[i]=logn[i>>1]+1; 18 | } 19 | 20 | void build() 21 | { 22 | for(ll i=1;i<=n;++i) 23 | t[i][0]=a[i]; 24 | for(ll j=1;j<=logn[n];++j) 25 | for(ll i=1;i+(1<<(j-1))<=n;++i) 26 | t[i][j]=min(t[i][j-1],t[i+(1<<(j-1))][j-1]); 27 | } 28 | 29 | ll getmin(ll l,ll r) 30 | { 31 | ll k=logn[r-l+1]; 32 | return min(t[l][k],t[r-(1<>n; 38 | for(ll i=1;i<=n;++i) 39 | { 40 | cin>>a[i]; 41 | } 42 | calc(); 43 | build(); 44 | ll temp; 45 | cin>>temp; 46 | for(ll i=0;i>x>>y; 50 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define x first 19 | #define y second 20 | #define pb push_back 21 | #define mp make_pair 22 | #define ins insert 23 | 24 | using namespace std; 25 | 26 | typedef long long ll; 27 | typedef long double ld; 28 | typedef pair pii; 29 | typedef pair pdd; 30 | 31 | const ll maxn=100; 32 | 33 | ll n,m,i,j,k; 34 | ll t[maxn][maxn]; 35 | 36 | ll prev(ll x) 37 | { 38 | return (x&(x+1))-1; 39 | } 40 | 41 | ll next(ll x) 42 | { 43 | return x|(x+1); 44 | } 45 | 46 | ll sum(ll x,ll y) 47 | { 48 | ll res=0; 49 | for(ll i=x;i>0;i=prev(i)) 50 | { 51 | for(ll j=y;j>0;j=prev(j)) 52 | { 53 | res+=t[i][j]; 54 | } 55 | } 56 | return res; 57 | } 58 | 59 | ll getsum(ll xl,ll xr,ll yl,ll yr) 60 | { 61 | return sum(xr,yr)-sum(xr,yl-1)-sum(xl-1,yr)+sum(xl-1,yl-1); 62 | } 63 | 64 | void update(ll x,ll y,ll val) 65 | { 66 | for(ll i=x;i<=n;i=next(i)) 67 | { 68 | for(ll j=y;j<=m;j=next(j)) 69 | { 70 | t[i][j]+=val; 71 | } 72 | } 73 | } 74 | 75 | void test() 76 | { 77 | scanf("%lld%lld",&n,&m); 78 | for(ll i=1;i<=n;++i) 79 | { 80 | for(ll j=1;j<=m;++j) 81 | { 82 | scanf("%lld",&k); 83 | update(i,j,k); 84 | } 85 | } 86 | scanf("%lld",&k); 87 | for(ll i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | #define mp make_pair 21 | #define pb push_back 22 | #define x first 23 | #define y second 24 | #define ins insert 25 | 26 | using namespace std; 27 | typedef int ll; 28 | typedef long double ld; 29 | typedef pair pii; 30 | typedef pair pdd; 31 | typedef vector lnum; 32 | 33 | const ll maxn=1001; 34 | vector > a(maxn,vector(maxn,0)); 35 | vector > t(4*maxn,vector(maxn,0)); 36 | 37 | ll n,m,i,j,k; 38 | 39 | void build_y(ll vx,ll lx,ll rx,ll vy,ll ly,ll ry) 40 | { 41 | if(ly == ry) 42 | { 43 | if(lx == rx) t[vx][vy]=a[lx][ly]; 44 | else t[vx][vy]=t[vx*2][vy]+t[vx*2+1][vy]; 45 | } 46 | else 47 | { 48 | ll my=(ly+ry)>>1; 49 | build_y(vx,lx,rx,vy*2,ly,my); 50 | build_y(vx,lx,rx,vy*2+1,my+1,ry); 51 | t[vx][vy]=t[vx][vy*2]+t[vx][vy*2+1]; 52 | } 53 | } 54 | 55 | void build_x(ll vx,ll lx,ll rx) 56 | { 57 | if(lx != rx) 58 | { 59 | ll mx=(lx+rx)>>1; 60 | build_x(vx*2,lx,mx); 61 | build_x(vx*2+1,mx+1,rx); 62 | } 63 | build_y(vx,lx,rx,1,1,n); 64 | } 65 | 66 | void mod_y(ll vx,ll lx,ll rx,ll vy,ll ly,ll ry,ll x,ll y) 67 | { 68 | if(ly == ry) 69 | { 70 | if(lx == rx) t[vx][vy] = a[x][y]; 71 | else t[vx][vy]=t[vx*2][vy]+t[vx*2+1][vy]; 72 | } 73 | else 74 | { 75 | ll my=(ly+ry)>>1; 76 | if(y <= my) mod_y(vx,lx,rx,vy*2,ly,my,x,y); 77 | else mod_y(vx,lx,rx,vy*2+1,my+1,ry,x,y); 78 | t[vx][vy]=t[vx][vy*2]+t[vx][vy*2+1]; 79 | } 80 | } 81 | 82 | void mod_x(ll vx,ll lx,ll rx,ll x,ll y) 83 | { 84 | if(lx != rx) 85 | { 86 | ll mx=(lx+rx)>>1; 87 | if(x<=mx) mod_x(vx*2,lx,mx,x,y); 88 | else mod_x(vx*2+1,mx+1,rx,x,y); 89 | } 90 | mod_y(vx,lx,rx,1,1,n,x,y); 91 | } 92 | 93 | ll get_y(ll vx,ll vy,ll ly,ll ry,ll yl,ll yr) 94 | { 95 | if(yl>yr) return 0; 96 | if(ly == yl && ry == yr) return t[vx][vy]; 97 | ll my=(ly+ry)>>1; 98 | return get_y(vx,vy*2,ly,my,yl,min(yr,my))+get_y(vx,vy*2+1,my+1,ry,max(yl,my+1),yr); 99 | } 100 | 101 | ll get_x(ll vx,ll lx,ll rx,ll xl,ll xr,ll yl,ll yr) 102 | { 103 | if(xl>xr) return 0; 104 | if(lx == xl && rx == xr) return get_y(vx,1,1,n,yl,yr); 105 | ll mx=(lx+rx)>>1; 106 | return get_x(vx*2,lx,mx,xl,min(xr,mx),yl,yr)+get_x(vx*2+1,mx+1,rx,max(xl,mx+1),xr,yl,yr); 107 | } 108 | 109 | void test() 110 | { 111 | cin>>n>>k; 112 | build_x(1,1,n); 113 | string s; 114 | for(ll i=0;i>s; 117 | if(s == "ADD") 118 | { 119 | ll x,y; 120 | cin>>x>>y; 121 | a[x][y]++; 122 | mod_x(1,1,n,x,y); 123 | } 124 | else 125 | { 126 | ll xl,xr,yl,yr; 127 | cin>>xl>>yl>>xr>>yr; 128 | if(xl>xr) swap(xl,xr); 129 | if(yl>yr) swap(yl,yr); 130 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | typedef long long ll; 13 | 14 | struct kor 15 | { 16 | ll x, prior, ls, rs, size, add, sum; 17 | bool rev; 18 | }; 19 | 20 | const ll maxn = 10000; 21 | kor t[maxn]; 22 | set pr; 23 | queue fr; 24 | ll n, m, i, j, k, root = 0, kol = 0; 25 | 26 | ll sizes(ll x) 27 | { 28 | if (!x) return 0; 29 | else return t[x].size; 30 | } 31 | 32 | ll sum(ll x) 33 | { 34 | if (!x) return 0; 35 | else return t[x].sum + t[x].add*t[x].size; 36 | } 37 | 38 | void recalc(ll x) 39 | { 40 | t[x].size = sizes(t[x].ls) + sizes(t[x].rs) + 1; 41 | t[x].sum = sum(t[x].ls) + sum(t[x].rs) + t[x].x; 42 | } 43 | 44 | void push(ll x) 45 | { 46 | if (x && t[x].rev) 47 | { 48 | t[x].rev = false; 49 | swap(t[x].ls, t[x].rs); 50 | t[t[x].ls].rev ^= true; 51 | t[t[x].rs].rev ^= true; 52 | } 53 | if (x && t[x].add) 54 | { 55 | t[x].x += t[x].add; 56 | t[t[x].ls].add += t[x].add; 57 | t[t[x].rs].add += t[x].add; 58 | t[x].add = 0; 59 | } 60 | 61 | } 62 | 63 | void merge(ll &x, ll left, ll right) 64 | { 65 | push(left); push(right); 66 | if (!left) x = right; 67 | else if (!right) x = left; 68 | else if (t[left].prior > t[right].prior) 69 | { 70 | merge(t[left].rs, t[left].rs, right); 71 | x = left; 72 | } 73 | else 74 | { 75 | merge(t[right].ls, left, t[right].ls); 76 | x = right; 77 | } 78 | recalc(x); 79 | } 80 | 81 | void split(ll x, ll key, ll &left, ll &right) 82 | { 83 | push(x); 84 | if (!x) left = right = 0; 85 | else if (key >= sizes(t[x].ls) + 1) 86 | { 87 | split(t[x].rs, key - sizes(t[x].ls) - 1, t[x].rs, right); 88 | left = x; 89 | } 90 | else 91 | { 92 | split(t[x].ls, key, left, t[x].ls); 93 | right = x; 94 | } 95 | recalc(x); 96 | } 97 | 98 | void erase(ll pos) 99 | { 100 | ll left, mid, temp, right; 101 | split(root, pos - 1, left, temp); 102 | split(temp, 1, mid, right); 103 | merge(root, left, right); 104 | } 105 | 106 | void insert(ll ind, ll pos) 107 | { 108 | ll left, mid, temp, right; 109 | split(root, pos, left, right); 110 | merge(temp, left, ind); 111 | merge(root, temp, right); 112 | } 113 | 114 | void add(ll l, ll r, ll val) 115 | { 116 | ll left, right, temp, mid; 117 | split(root, r, temp, right); 118 | split(temp, l - 1, left, mid); 119 | t[mid].add += val; 120 | merge(temp, left, mid); 121 | merge(root, temp, right); 122 | } 123 | 124 | ll getsum(ll l, ll r) 125 | { 126 | ll left, right, temp, mid, res = 0; 127 | split(root, r, temp, right); 128 | split(temp, l - 1, left, mid); 129 | res = t[mid].sum; 130 | merge(temp, left, mid); 131 | merge(root, temp, right); 132 | return res; 133 | } 134 | 135 | void rever(ll l, ll r) 136 | { 137 | ll left, right, temp, mid; 138 | split(root, r, temp, right); 139 | split(temp, l - 1, left, mid); 140 | t[mid].rev = true; 141 | merge(temp, left, mid); 142 | merge(root, temp, right); 143 | } 144 | 145 | void insert(ll x) 146 | { 147 | ll ind, prior; 148 | if (!fr.empty()) 149 | { 150 | ind = fr.front(); fr.pop(); 151 | } 152 | else 153 | ind = ++kol; 154 | do 155 | { 156 | prior = rand()*rand(); 157 | } while (pr.find(prior) != pr.end()); 158 | pr.insert(prior); 159 | kor temp; 160 | temp = { x, prior, 0, 0, 1, 0, x, false }; 161 | t[ind] = temp; 162 | if (!root) root = ind; 163 | else insert(ind, kol); 164 | } 165 | 166 | void ob(ll x) 167 | { 168 | push(x); recalc(x); 169 | if (t[x].ls) ob(t[x].ls); 170 | cout << t[x].x << endl; 171 | if (t[x].rs) ob(t[x].rs); 172 | 173 | } 174 | 175 | void test() 176 | { 177 | cin >> n; 178 | for (ll i = 0; i> temp; 182 | insert(temp); 183 | } 184 | ob(root); 185 | cout << getsum(1, 4) << endl; 186 | erase(3); 187 | cout << getsum(1, 4) << endl; 188 | add(2, 2, 10); 189 | cout << getsum(1, 2) << endl; 190 | cout << endl; ob(root); cout << endl; 191 | rever(1, 4); 192 | cout << endl; ob(root); cout << endl; 193 | cout << getsum(3, 4) << endl; 194 | 195 | } 196 | 197 | int main() 198 | { 199 | freopen("input.txt", "r", stdin); 200 | srand(time(0)); 201 | test(); 202 | return 0; 203 | } 204 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Структуры/Декартово дерево(с явным ключом и суммой и обновлением на отрезке).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | typedef long long ll; 13 | 14 | struct kor 15 | { 16 | ll key,prior,ls,rs,add,size,sum; 17 | }; 18 | 19 | const ll maxn=10000; 20 | kor t[maxn]; 21 | ll n,m,s,i,j,root=0,kol=0; 22 | queue fr,q,mem; 23 | set pr; 24 | 25 | ll sizes(ll x) 26 | { 27 | if(!x) return 0; 28 | else return t[x].size; 29 | } 30 | 31 | ll summa(ll x) 32 | { 33 | if(!x) return 0; 34 | else return t[x].sum+t[x].size*t[x].add; 35 | } 36 | 37 | void recalc(ll x) 38 | { 39 | t[x].size=sizes(t[x].ls) + sizes(t[x].rs) +1; 40 | t[x].sum=summa(t[x].ls)+summa(t[x].rs)+t[x].key; 41 | } 42 | 43 | void push(ll x) 44 | { 45 | if(x && t[x].add) 46 | { 47 | t[x].key+=t[x].add; 48 | t[t[x].ls].add+=t[x].add; 49 | t[t[x].rs].add+=t[x].add; 50 | t[x].add=0; 51 | } 52 | } 53 | 54 | void merge(ll &x,ll left,ll right) 55 | { 56 | push(left); 57 | push(right); 58 | if(!left) x=right; 59 | else if(!right) x=left; 60 | else if(t[left].prior > t[right].prior) 61 | { 62 | merge(t[left].rs,t[left].rs,right); 63 | x=left; 64 | } 65 | else 66 | { 67 | merge(t[right].ls,left,t[right].ls); 68 | x=right; 69 | } 70 | recalc(x); 71 | } 72 | 73 | void split(ll x, ll key,ll &left,ll &right) 74 | { 75 | push(x); 76 | if(!x) left=right=0; 77 | else if(key < t[x].key) 78 | { 79 | split(t[x].ls,key,left,t[x].ls); 80 | right=x; 81 | } 82 | else 83 | { 84 | split(t[x].rs,key,t[x].rs,right); 85 | left=x; 86 | } 87 | recalc(x); 88 | } 89 | 90 | void erase(ll &x,ll key) 91 | { 92 | if(!x); 93 | else if(t[x].key == key) 94 | { 95 | fr.push(x);pr.erase(t[x].prior); 96 | merge(x,t[x].ls,t[x].rs); 97 | } 98 | else if(key t[x].prior) 108 | { 109 | split(x,t[item].key,t[item].ls,t[item].rs); 110 | x=item; 111 | } 112 | else if(t[item].key < t[x].key) insert(t[x].ls,item); 113 | else insert(t[x].rs,item); 114 | recalc(x); 115 | } 116 | 117 | void insert(ll key) 118 | { 119 | ll ind,prior; 120 | if(!fr.empty()) 121 | { 122 | ind=fr.front();fr.pop(); 123 | } 124 | else 125 | ind=++kol; 126 | do 127 | { 128 | prior=rand()*rand(); 129 | } 130 | while(pr.find(prior) != pr.end()); 131 | pr.insert(prior); 132 | kor temp={key,prior,0,0,0,1,key}; 133 | t[ind]=temp; 134 | if(!root) root=ind; 135 | else insert(root,ind); 136 | } 137 | 138 | ll get_sum(ll l,ll r) 139 | { 140 | ll left,right,mid,temp,res; 141 | split(root,r,temp,right); 142 | split(temp,l-1,left,mid); 143 | res=t[mid].sum; 144 | merge(temp,left,mid); 145 | merge(root,temp,right); 146 | return res; 147 | } 148 | 149 | void add(ll l,ll r,ll val) 150 | { 151 | ll left,right,mid,temp; 152 | split(root,r,temp,right); 153 | split(temp,l-1,left,mid); 154 | t[mid].add+=val; 155 | merge(temp,left,mid); 156 | merge(root,temp,right); 157 | } 158 | 159 | void ob(ll x) 160 | { 161 | if(t[x].add) push(x); 162 | if(t[x].ls) ob(t[x].ls); 163 | q.push(t[x].key); 164 | if(t[x].rs) ob(t[x].rs); 165 | } 166 | 167 | void test() 168 | { 169 | cin>>n; 170 | ll d; 171 | for(ll i=0;i>d; 174 | insert(d); 175 | mem.push(d); 176 | } 177 | while(!mem.empty()) 178 | { 179 | ob(root); 180 | while(!q.empty()) 181 | { 182 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | typedef long long ll; 9 | 10 | const ll maxn=10000; 11 | ll t[maxn],a[maxn]; 12 | ll n,m,i,j,k; 13 | 14 | void input() 15 | { 16 | cin>>n; 17 | for(ll i=1;i<=n;++i) 18 | cin>>a[i]; 19 | } 20 | 21 | ll next(ll x) 22 | { 23 | return x|(x+1); 24 | } 25 | 26 | ll prev(ll x) 27 | { 28 | return x&(x+1); 29 | } 30 | 31 | void add(ll pos,ll val) 32 | { 33 | a[pos]+=val; 34 | while(pos<=n) 35 | { 36 | t[pos]+=val; 37 | pos=next(pos); 38 | } 39 | } 40 | 41 | void build() 42 | { 43 | for(ll i=1;i<=n;++i) 44 | add(i,a[i]); 45 | } 46 | 47 | ll getsum(ll l,ll r) 48 | { 49 | ll res=0; 50 | while(r>=0) 51 | { 52 | res+=t[r]; 53 | r=prev(r)-1; 54 | } 55 | while(l>=0) 56 | { 57 | res-=t[l]; 58 | l=prev(l)-1; 59 | } 60 | return res; 61 | } 62 | 63 | void test() 64 | { 65 | input(); 66 | build(); 67 | ll temp; 68 | cin>>temp; 69 | for(ll i=0;i>x>>y; 73 | cout<>temp; 77 | for(ll i=0;i>x>>y; 81 | cout< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | typedef long long ll; 10 | 11 | ll n,m,i,j,k; 12 | stack > s1,s2; 13 | 14 | void push(ll x) 15 | { 16 | s1.empty() ? s1.push(make_pair(x,x)) : s1.push(make_pair(x,min(x,s1.top().second))); 17 | } 18 | 19 | void copy() 20 | { 21 | while(!s1.empty()) 22 | { 23 | ll x,minim; 24 | x=s1.top().first; 25 | s1.pop(); 26 | minim=s2.empty() ? x : min(x,s2.top().second); 27 | s2.push(make_pair(x,minim)); 28 | } 29 | } 30 | 31 | bool empty() 32 | { 33 | return s1.empty() && s2.empty(); 34 | } 35 | 36 | ll pop() 37 | { 38 | if(s2.empty()) copy(); 39 | if(s2.empty()) cout<<"LOL"<>n; 63 | for(ll i=0;i>temp; 67 | push(temp); 68 | cout< 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #define mp make_pair 22 | #define pb push_back 23 | #define x first 24 | #define y second 25 | #define ins insert 26 | 27 | using namespace std; 28 | typedef long long ll; 29 | typedef long double ld; 30 | typedef pair pii; 31 | typedef pair pdd; 32 | typedef vector lnum; 33 | 34 | const ll maxn = 1000, maxt = 1000000; 35 | 36 | struct tree 37 | { 38 | ll ls = 0, rs = 0, sum = 0; 39 | }; 40 | 41 | ll n, m, i, j, k, c = 0, r = 0; 42 | vector a(maxn), s(maxn), root(maxn); 43 | vector t(maxt); 44 | 45 | ll build(ll tl, ll tr) 46 | { 47 | ll v = ++c; 48 | if (tl == tr); 49 | else 50 | { 51 | ll tm = (tl + tr) >> 1; 52 | t[v].ls = build(tl, tm); 53 | t[v].rs = build(tm + 1, tr); 54 | } 55 | return v; 56 | } 57 | 58 | ll getsum(ll v, ll l, ll r, ll tl, ll tr) 59 | { 60 | if (tl>r || tr= l && tr <= r) return t[v].sum; 62 | ll tm = (tl + tr) >> 1; 63 | return getsum(t[v].ls, l, r, tl, tm) + getsum(t[v].rs, l, r, tm + 1, tr); 64 | } 65 | 66 | ll modify(ll v, ll pos, ll val, ll tl, ll tr) 67 | { 68 | ll nv = ++c; 69 | if (tl == tr) t[nv].sum = val; 70 | else 71 | { 72 | ll tm = (tl + tr) >> 1; 73 | if (pos <= tm) t[nv].rs = t[v].rs, t[nv].ls = modify(t[v].ls, pos, val, tl, tm); 74 | else t[nv].ls = t[v].ls, t[nv].rs = modify(t[v].rs, pos, val, tm + 1, tr); 75 | t[nv].sum = t[t[nv].ls].sum + t[t[nv].rs].sum; 76 | } 77 | return nv; 78 | } 79 | 80 | ll get_k(ll l, ll r, ll k, ll tl, ll tr) 81 | { 82 | if (tl == tr) return tl; 83 | ll tm = (tl + tr) >> 1; 84 | if (t[t[r].ls].sum - t[t[l].ls].sum >= k) return get_k(t[l].ls, t[r].ls, k, tl, tm); 85 | else return get_k(t[l].rs, t[r].rs, k - (t[t[r].ls].sum - t[t[l].ls].sum), tm + 1, tr); 86 | } 87 | 88 | void test() 89 | { 90 | scanf("%lld", &n); 91 | for (ll i = 1; i <= n; ++i) 92 | { 93 | scanf("%lld", &a[i]); 94 | s[i] = a[i]; 95 | } 96 | sort(s.begin() + 1, s.begin() + n + 1); 97 | for (ll i = 1; i <= n; ++i) 98 | { 99 | a[i] = lower_bound(s.begin() + 1, s.begin() + n + 1, a[i]) - s.begin(); 100 | } 101 | root[r++] = build(1, n); 102 | for (ll i = 1; i <= n; ++i) 103 | { 104 | ll val = getsum(root[r - 1], a[i], a[i], 1, n); 105 | root[r] = modify(root[r - 1], a[i], val + 1, 1, n); 106 | ++r; 107 | } 108 | scanf("%lld", &m); 109 | ll left, right, kat; 110 | for (ll i = 1; i <= m; ++i) 111 | { 112 | scanf("%lld%lld%lld", &left, &right, &kat); 113 | printf("%lld\n", s[get_k(root[left - 1], root[right], kat, 1, n)]); 114 | } 115 | } 116 | 117 | 118 | int main() 119 | { 120 | //srand(time(0)); 121 | //ios_base::sync_with_stdio(0); 122 | test(); 123 | return 0; 124 | } 125 | 126 | 127 | 128 | 129 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/GCD.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zamazan4ik/Algorithms/5d91d76aa9235f5da3c198dcbfe4468609955d0c/Сборник моих алгоритмов/Теория чисел/GCD.cpp -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/LCM.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zamazan4ik/Algorithms/5d91d76aa9235f5da3c198dcbfe4468609955d0c/Сборник моих алгоритмов/Теория чисел/LCM.cpp -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/Meet-in-the-meedle(составление числа).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #define x first 22 | #define y second 23 | #define pb push_back 24 | #define mp make_pair 25 | #define ins insert 26 | 27 | using namespace std; 28 | 29 | typedef long long ll; 30 | typedef long double ld; 31 | typedef pair pii; 32 | typedef pair pdd; 33 | 34 | ll n,m,i,j,k,sum; 35 | vector a; 36 | map q; 37 | 38 | void test() 39 | { 40 | cin>>n>>sum; 41 | a.resize(n); 42 | for(ll i=0;i>a[i]; 44 | for(ll i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | 21 | #define x first 22 | #define y second 23 | #define pb push_back 24 | #define mp make_pair 25 | #define ins insert 26 | 27 | using namespace std; 28 | 29 | typedef long long ll; 30 | typedef long double ld; 31 | typedef pair pii; 32 | typedef pair pdd; 33 | 34 | ll n,m,i,j,k,max_w,ans=-1; 35 | vector a,lefti,righti; 36 | vector ml,mr; 37 | 38 | 39 | void test() 40 | { 41 | cin>>n>>max_w; 42 | a.resize(n); 43 | ll temp=n/2; 44 | for(ll i=0;i>a[i].x>>a[i].y; 47 | if(i= ml[i-1].x && ml[i].y<=ml[i-1].y)) 80 | lefti.pb(ml[i]); 81 | for(ll i=0;i=0) 86 | { 87 | ll temp=cur_p+lefti[pos].y; 88 | ans=max(ans,temp); 89 | } 90 | } 91 | cout<>=1; 10 | } 11 | return res; 12 | } 13 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/Диофант через Евклида.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define mp make_pair 19 | #define pb push_back 20 | #define x first 21 | #define y second 22 | #define ins insert 23 | 24 | using namespace std; 25 | typedef long long ll; 26 | typedef long double ld; 27 | typedef pair pii; 28 | 29 | ll gcd(ll a,ll b,ll &x,ll &y) 30 | { 31 | if(a == 0) 32 | { 33 | x=0; 34 | y=1; 35 | return b; 36 | } 37 | ll x1,y1,d; 38 | d=gcd(b%a,a,x1,y1); 39 | y=x1; 40 | x=y1-(b/a)*x1; 41 | return d; 42 | } 43 | 44 | void test() 45 | { 46 | //Diophant's: ax+by=c 47 | ll a,b,c,x,y,nod; 48 | cin>>a>>b>>c; 49 | nod=gcd(a,b,x,y); 50 | if(c%nod == 0) 51 | { 52 | ll mn=c/nod; 53 | cout< key || arr[size-1] < key) 5 | return -1; 6 | while(first < last) 7 | { 8 | mid=first + ((last-first)>>1); 9 | if(arr[mid] == key) 10 | return mid; 11 | else if(arr[mid] < key) 12 | first=mid+1; 13 | else 14 | last=mid-1; 15 | } 16 | if(arr[last] == key) 17 | return last; 18 | else 19 | return -1; 20 | } 21 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/Длинная арифметика.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zamazan4ik/Algorithms/5d91d76aa9235f5da3c198dcbfe4468609955d0c/Сборник моих алгоритмов/Теория чисел/Длинная арифметика.cpp -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/Миллер-Рабин.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | typedef long long ll; 9 | 10 | ll n,s,t,k; 11 | ll p[3]={2,7,61}; 12 | 13 | ll mulmod(ll x,ll y,ll n) 14 | { 15 | ll res=0; 16 | while(y) 17 | { 18 | if(y&1) res=(res+x)%n; 19 | x=(x+x)%n; 20 | y>>=1; 21 | } 22 | return res; 23 | } 24 | 25 | ll powmod(ll x,ll y,ll n) 26 | { 27 | ll res=1; 28 | while(y) 29 | { 30 | if(y&1) res=mulmod(res,x,n); 31 | x=mulmod(x,x,n); 32 | y>>=1; 33 | } 34 | return res; 35 | } 36 | 37 | 38 | bool miller(ll s,ll t,ll a) 39 | { 40 | ll x=powmod(a,t,n); 41 | if(x==1 || x==n-1) return true; 42 | for(ll j=1;j>=1; 70 | } 71 | bool ok=true; 72 | for(ll j=0;j<3 && ok;++j) 73 | ok=miller(s,t,p[j]); 74 | return ok; 75 | } 76 | 77 | 78 | int main() 79 | { 80 | cin>>n; 81 | cout< 2 | 3 | using namespace std; 4 | 5 | int fib(int n) 6 | { 7 | int a=1,b=1, 8 | c=1,d=0, 9 | rc=0,rd=1, 10 | ta,tb,tc,td; 11 | while(n) 12 | { 13 | if(n & 1) 14 | { 15 | tc=rc*a+rd*c; 16 | td=rc*b+rd*d; 17 | rc=tc;rd=td; 18 | } 19 | ta=a*a+b*c; 20 | tb=a*b+b*d; 21 | tc=c*a+d*c; 22 | td=c*b+d*d; 23 | a=ta;b=tb;c=tc;d=td; 24 | n>>=1; 25 | } 26 | return rc; 27 | } 28 | 29 | int main() 30 | { 31 | int n; 32 | cin>>n; 33 | cout< 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | vector v; 8 | 9 | int delit(int n) 10 | { 11 | int j=(int)sqrt((double)n); 12 | for(int i=1;i<=j;++i) 13 | { 14 | if(n%i==0) 15 | { 16 | v.push_back(i); 17 | if(i*i != n) 18 | v.push_back(n/i); 19 | } 20 | } 21 | } 22 | 23 | 24 | 25 | 26 | int main() 27 | { 28 | int n; 29 | cin>>n; 30 | delit(n); 31 | for(int i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | 21 | #define x first 22 | #define y second 23 | #define pb push_back 24 | #define mp make_pair 25 | #define ins insert 26 | 27 | using namespace std; 28 | 29 | typedef long long ll; 30 | typedef long double ld; 31 | typedef pair pii; 32 | typedef pair pdd; 33 | 34 | ll n,m,i,j,k; 35 | 36 | void test() 37 | { 38 | ll kol; 39 | cin>>kol; 40 | vector a(kol); 41 | for(ll i=0;i>a[i]; 43 | ll n=pow(2.0,kol); 44 | for(ll i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | 21 | #define x first 22 | #define y second 23 | #define pb push_back 24 | #define mp make_pair 25 | #define ins insert 26 | 27 | using namespace std; 28 | 29 | typedef long long ll; 30 | typedef long double ld; 31 | typedef pair pii; 32 | typedef pair pdd; 33 | 34 | ll n,m,i,j,k; 35 | 36 | void test() 37 | { 38 | ll kol; 39 | cin>>kol; 40 | vector a(kol); 41 | for(ll i=0;i>a[i]; 43 | ll n=pow(2.0,kol); 44 | for(ll i=0;i 2 | #include 3 | 4 | using namespace std; 5 | typedef long long ll; 6 | 7 | ll n,from,to,i; 8 | 9 | ll from_to_dec(ll digit) 10 | { 11 | ll ans=0; 12 | vector cifr,p; 13 | while(digit) 14 | { 15 | cifr.push_back(digit%10); 16 | digit/=10; 17 | } 18 | 19 | p.push_back(1); 20 | 21 | for(i=1;i ans; 32 | while(1) 33 | { 34 | if(digit=0;--i) 46 | cout<>n>>from>>to; 55 | dec_to_to(from_to_dec(n)); 56 | system("pause"); 57 | return 0; 58 | } 59 | 60 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/Решето Эратосфена(не блочное).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void resheto(bool prime[]) 4 | { 5 | for(i=3;(temp=i*i) <=n;i+=2) 6 | if(prime[i]) 7 | for(j=temp;j<=n;j+=i) 8 | prime[j]=false; 9 | } 10 | 11 | int main() 12 | { 13 | bool *prime=new bool[n+1]; 14 | memset(prime,1,n+1); 15 | prime[0]=prime[1]=false; 16 | resheto(prime); 17 | } 18 | -------------------------------------------------------------------------------- /Сборник моих алгоритмов/Теория чисел/Тернарный поиск.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | #define x first 20 | #define y second 21 | #define pb push_back 22 | #define mp make_pair 23 | #define ins insert 24 | 25 | using namespace std; 26 | 27 | typedef long long ll; 28 | typedef long double ld; 29 | typedef pair pii; 30 | typedef pair pdd; 31 | 32 | ll n,m,i,j,k; 33 | ld eps=1e-7; 34 | 35 | 36 | ld f(ld x) 37 | { 38 | return x*2+4*x+15.0/x; 39 | } 40 | 41 | // search max of function 42 | //ternary search 43 | void test() 44 | { 45 | ld r=1000000000.0,l=-1000000000.0; 46 | while(r-l>eps) 47 | { 48 | ld m1=l+(r-l)/3.0,m2=r-(r-l)/3.0; 49 | if(f(m1) < f(m2)) l=m1; 50 | else r=m2; 51 | } 52 | cout<