Hizenberg/Algorithms-snippets
1
0
Fork 0
mirror of https://github.com/Hizenberg469/Algorithms-snippets.git synced 2026-04-19 22:52:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Binomial Coefficient

Browse Source
This commit is contained in:
Hizenberg
2024-04-10 15:36:18 +05:30
parent 6ddf41feb5
commit bc8374182f
21 changed files with 810 additions and 769 deletions
Download Patch File Download Diff File Expand all files Collapse all files

366
Advanced Graph Algorithm/Ford_Fulkerson.cpp
View File

@@ -1,183 +1,183 @@
#include <bits/stdc++.h>
//used for ignoring/removing the assert statement at compile-time.
//#define NDEBUG
using namespace std;
class Edge{
public:
int from, to;
Edge* residual;
long flow;
long capacity;
Edge(int from, int to, long capacity){
this->from = from;
this->to = to;
this->capacity = capacity;
flow = 0;
}
bool isResidual(){
return capacity == 0;
}
long remainingCapacity(){
return capacity - flow;
}
void augment(long bottleNeck){
flow += bottleNeck;
residual->flow -= bottleNeck;
}
string toString(int s ,int t){
string u = (from == s) ? "s" : ((from == t) ? "t" : to_string(from));
string v = (to == s ) ? "s" : ((to == t) ? "t" : to_string(to));
string res = "Edge " + u + " -> " + v + " | " + " flow = " +
to_string(flow) + " | " + " capacity: " + to_string(capacity)
+ " | " + " is residual: " + to_string((int)isResidual()) ;
return res;
}
};
class NetworkFlowSolverBase{
protected :
long INF = INT_MAX/2;
//Input: n = Number of nodes, s = source, t = sink
int n , s, t;
//'visited' and 'visitedToken' are keep track of the
//visited nodes.
protected:
int visitedToken = 1;
int* visited;
bool solved;
long maxFlow;
//Representing the graph.
vector<vector<Edge*>> graph;
public:
NetworkFlowSolverBase(int n, int s,int t){
this->n = n;
this->s = s;
this->t = t;
graph.resize(n);
visited = new int[n];
}
void addEdge(int from ,int to ,long capacity){
assert(capacity > 0);
Edge* e1 = new Edge(from, to , capacity);
Edge* e2 = new Edge(to, from, 0);
e1->residual = e2;
e2->residual = e1;
graph[from].push_back(e1);
graph[to].push_back(e2);
}
vector<vector<Edge*>> getGraph(){
execute();
return graph;
}
long getMaxFlow(){
execute();
return maxFlow;
}
private :
void execute(){
if( solved )return;
solved = true;
solve();
}
public:
virtual void solve(){}
};
class FordFulkersonDfsSolver : public NetworkFlowSolverBase{
public :
FordFulkersonDfsSolver(int n, int s, int t) : NetworkFlowSolverBase(n,s,t){
}
void solve(){
for( long f = dfs(s, INF) ; f != 0 ; f = dfs(s,INF)){
visitedToken++;
maxFlow += f;
}
}
private :
long dfs(int node, long flow){
if( node == t )return flow;
visited[node] = visitedToken;
vector<Edge*> edges = graph[node];
for(Edge* edge : edges){
if( edge->remainingCapacity() > 0 && visited[edge->to] != visitedToken){
long bottleNeck = dfs(edge->to , min(flow,edge->remainingCapacity()));
if( bottleNeck > 0){
edge->augment(bottleNeck);
return bottleNeck;
}
}
}
return 0;
}
};
int main(){
int n = 12;
int s = n - 2;
int t = n - 1;
NetworkFlowSolverBase* solver = new FordFulkersonDfsSolver(n,s,t);
//Edges from Source
solver->addEdge(s, 0, 10);
solver->addEdge(s, 1, 5);
solver->addEdge(s, 2, 10);
//Middle edges
solver->addEdge(0, 3, 10);
solver->addEdge(1, 2, 10);
solver->addEdge(2, 5, 15);
solver->addEdge(3, 1, 2);
solver->addEdge(3, 6, 15);
solver->addEdge(4, 1, 15);
solver->addEdge(4, 3, 3);
solver->addEdge(5, 4, 4);
solver->addEdge(5, 8, 10);
solver->addEdge(6, 7, 10);
solver->addEdge(7, 4, 10);
solver->addEdge(7, 5, 7);
//Edges to sink
solver->addEdge(6, t, 15);
solver->addEdge(8, t, 10);
cout << "Maximum Flow is: " << solver->getMaxFlow() << '\n';
vector<vector<Edge*>> resultGraph = solver->getGraph();
for(vector<Edge*> edges : resultGraph ){
for( Edge* e : edges){
cout << e->toString(s,t) << '\n';
}
}
return 0;
}
#include <bits/stdc++.h>
//used for ignoring/removing the assert statement at compile-time.
//#define NDEBUG
using namespace std;
class Edge{
public:
int from, to;
Edge* residual;
long flow;
long capacity;
Edge(int from, int to, long capacity){
this->from = from;
this->to = to;
this->capacity = capacity;
flow = 0;
}
bool isResidual(){
return capacity == 0;
}
long remainingCapacity(){
return capacity - flow;
}
void augment(long bottleNeck){
flow += bottleNeck;
residual->flow -= bottleNeck;
}
string toString(int s ,int t){
string u = (from == s) ? "s" : ((from == t) ? "t" : to_string(from));
string v = (to == s ) ? "s" : ((to == t) ? "t" : to_string(to));
string res = "Edge " + u + " -> " + v + " | " + " flow = " +
to_string(flow) + " | " + " capacity: " + to_string(capacity)
+ " | " + " is residual: " + to_string((int)isResidual()) ;
return res;
}
};
class NetworkFlowSolverBase{
protected :
long INF = INT_MAX/2;
//Input: n = Number of nodes, s = source, t = sink
int n , s, t;
//'visited' and 'visitedToken' are keep track of the
//visited nodes.
protected:
int visitedToken = 1;
int* visited;
bool solved;
long maxFlow;
//Representing the graph.
vector<vector<Edge*>> graph;
public:
NetworkFlowSolverBase(int n, int s,int t){
this->n = n;
this->s = s;
this->t = t;
graph.resize(n);
visited = new int[n];
}
void addEdge(int from ,int to ,long capacity){
assert(capacity > 0);
Edge* e1 = new Edge(from, to , capacity);
Edge* e2 = new Edge(to, from, 0);
e1->residual = e2;
e2->residual = e1;
graph[from].push_back(e1);
graph[to].push_back(e2);
}
vector<vector<Edge*>> getGraph(){
execute();
return graph;
}
long getMaxFlow(){
execute();
return maxFlow;
}
private :
void execute(){
if( solved )return;
solved = true;
solve();
}
public:
virtual void solve(){}
};
class FordFulkersonDfsSolver : public NetworkFlowSolverBase{
public :
FordFulkersonDfsSolver(int n, int s, int t) : NetworkFlowSolverBase(n,s,t){
}
void solve(){
for( long f = dfs(s, INF) ; f != 0 ; f = dfs(s,INF)){
visitedToken++;
maxFlow += f;
}
}
private :
long dfs(int node, long flow){
if( node == t )return flow;
visited[node] = visitedToken;
vector<Edge*> edges = graph[node];
for(Edge* edge : edges){
if( edge->remainingCapacity() > 0 && visited[edge->to] != visitedToken){
long bottleNeck = dfs(edge->to , min(flow,edge->remainingCapacity()));
if( bottleNeck > 0){
edge->augment(bottleNeck);
return bottleNeck;
}
}
}
return 0;
}
};
int main(){
int n = 12;
int s = n - 2;
int t = n - 1;
NetworkFlowSolverBase* solver = new FordFulkersonDfsSolver(n,s,t);
//Edges from Source
solver->addEdge(s, 0, 10);
solver->addEdge(s, 1, 5);
solver->addEdge(s, 2, 10);
//Middle edges
solver->addEdge(0, 3, 10);
solver->addEdge(1, 2, 10);
solver->addEdge(2, 5, 15);
solver->addEdge(3, 1, 2);
solver->addEdge(3, 6, 15);
solver->addEdge(4, 1, 15);
solver->addEdge(4, 3, 3);
solver->addEdge(5, 4, 4);
solver->addEdge(5, 8, 10);
solver->addEdge(6, 7, 10);
solver->addEdge(7, 4, 10);
solver->addEdge(7, 5, 7);
//Edges to sink
solver->addEdge(6, t, 15);
solver->addEdge(8, t, 10);
cout << "Maximum Flow is: " << solver->getMaxFlow() << '\n';
vector<vector<Edge*>> resultGraph = solver->getGraph();
for(vector<Edge*> edges : resultGraph ){
for( Edge* e : edges){
cout << e->toString(s,t) << '\n';
}
}
return 0;
}

36
Graph Algorithm/Bellmann_Ford.cpp
View File

@@ -1,19 +1,19 @@
vector<int> dist(n+1,(int)-1e17);
dist[1]=0;
for(int i = 1 ; i < n ; i++ ){
for(auto& e : g ){
int a,b,w;
tie(a,b,w)=e;
dist[b]=max(dist[b],dist[a]+w);
}
}
for(auto& e : g ){
int a,b,w;
tie(a,b,w)=e;
if( dist[b] < dist[a] + w ){
cycle[b]=true;
}
vector<int> dist(n+1,(int)-1e17);
dist[1]=0;
for(int i = 1 ; i < n ; i++ ){
for(auto& e : g ){
int a,b,w;
tie(a,b,w)=e;
dist[b]=max(dist[b],dist[a]+w);
}
}
for(auto& e : g ){
int a,b,w;
tie(a,b,w)=e;
if( dist[b] < dist[a] + w ){
cycle[b]=true;
}
}

12
Graph Algorithm/Flloyd_Warshall.cpp
View File

@@ -1,7 +1,7 @@
for(int k = 1 ; k <= n ; k++ ){
for(int i = 1 ; i <= n ; i++ ){
for(int j = 1 ; j <= n ; j++ ){
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
}
}
for(int k = 1 ; k <= n ; k++ ){
for(int i = 1 ; i <= n ; i++ ){
for(int j = 1 ; j <= n ; j++ ){
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
}
}
}

32
Graph Algorithm/dijikstra.cpp
View File

@@ -1,17 +1,17 @@
priority_queue<pii> q;
q.push({0,1});
dist[1]=0;
while(!q.empty()){
pii n=q.top();q.pop();
int weight=n.F,node=n.S;
if( vis[node] )continue;
vis[node]=true;
for(pii& nbr : g[node]){
int n_nbr=nbr.F,n_w=nbr.S;
if( dist[node]+n_w<dist[n_nbr] ){
dist[n_nbr]=dist[node]+n_w;
q.push({-dist[n_nbr],n_nbr});
}
}
priority_queue<pii> q;
q.push({0,1});
dist[1]=0;
while(!q.empty()){
pii n=q.top();q.pop();
int weight=n.F,node=n.S;
if( vis[node] )continue;
vis[node]=true;
for(pii& nbr : g[node]){
int n_nbr=nbr.F,n_w=nbr.S;
if( dist[node]+n_w<dist[n_nbr] ){
dist[n_nbr]=dist[node]+n_w;
q.push({-dist[n_nbr],n_nbr});
}
}
}

41
Number Theory/Dp_nCr.cpp Normal file
View File

@@ -0,0 +1,41 @@
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> nCr;
void binomialCoefficient(int n,int k){
nCr.resize(n+1,vector<int>(k+1,0));
nCr[1][0] = nCr[1][1] = 1;
for(int i = 2 ; i <= n ; i++ ){
for(int j = 0 ; j <= min(i,k) ; j++ ){
if( j == 0 ){
nCr[i][j] = 1;
continue;
}
if( j == 1 || j == 0 ){
nCr[i][j] = i;
continue;
}
nCr[i][j] = nCr[i-1][j]+nCr[i-1][j-1];
}
}
}
int main(int argc,char* argv[]){
binomialCoefficient(5,5);
for(int i = 0 ; i <= 5 ; i++ ){
for(int j = 0 ; j <= 5 ; j++ ){
cout << nCr[i][j] << " ";
}
cout << endl;
}
return 0;
}

38
Number Theory/Fast_Multiply.cpp
View File

@@ -1,19 +1,19 @@
#include <bits/stdc++.h>
using namespace std;
int binary_multiplication(int a , int b,int M=(int)1e9+7){
int res = 0;
while( b ){
if( b&1 ) res += a , res %= M;
a = 2 * a ; a %= M:
b >>= 1;
}
return res;
}
int main(){
return 0;
}
#include <bits/stdc++.h>
using namespace std;
int binary_multiplication(int a , int b,int M=(int)1e9+7){
int res = 0;
while( b ){
if( b&1 ) res += a , res %= M;
a = 2 * a ; a %= M:
b >>= 1;
}
return res;
}
int main(){
return 0;
}

184
Number Theory/Matrix_Exponentiation.cpp
View File

@@ -1,92 +1,92 @@
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
const int M = (int)1e9+7;
struct Mat{
ll m[2][2];
Mat(){
memset(m,0,sizeof(m));
}
void identity(){
for(int idx = 0 ; idx < 2 ; idx++ ){
m[idx][idx] = 1;
}
}
};
Mat operator* (Mat m1,Mat m2){
Mat res;
for(int i = 0 ; i < 2 ; i++ ){
for(int j = 0 ; j < 2 ; j++ ){
for(int k = 0 ; k < 2 ; k++ ){
res.m[i][j] += m1.m[i][k]*m2.m[k][j];
res.m[i][j] %= M;
}
}
}
return res;
}
Mat power(Mat X,ll n){
Mat res;
res.identity();
ll b = n;
while(b){
if( b&1 ) res = res*X;
X = X*X;
b >>= 1;
}
return res;
}
ll fibo(ll n){
if( n < 2 ) return n;
Mat res;
Mat X;
X.m[0][1] = 1 , X.m[1][0] = 1 , X.m[1][1] = 1;
res = power(X,n);
ll fn[2][1];
fn[0][0]=0,fn[1][0]=1;
ll fn1[2][1];
for(int i = 0 ; i < 2 ; i++ ){
for(int j = 0 ; j < 1 ; j++ ){
for(int k = 0 ; k < 2 ; k++ ){
fn1[i][j] = res.m[i][k]*fn[k][j];
fn1[i][j]%=M;
}
}
}
return fn1[0][0];
}
ll modSub(ll a,ll b){
return ((a%M)-(b%M)+M)%M;
}
int main(){
int t;
cin>>t;
while(t--){
ll n,m;
cin>>n>>m;
cout << modSub(fibo(m+2),fibo(n+1)) << '\n';
}
return 0;
}
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
const int M = (int)1e9+7;
struct Mat{
ll m[2][2];
Mat(){
memset(m,0,sizeof(m));
}
void identity(){
for(int idx = 0 ; idx < 2 ; idx++ ){
m[idx][idx] = 1;
}
}
};
Mat operator* (Mat m1,Mat m2){
Mat res;
for(int i = 0 ; i < 2 ; i++ ){
for(int j = 0 ; j < 2 ; j++ ){
for(int k = 0 ; k < 2 ; k++ ){
res.m[i][j] += m1.m[i][k]*m2.m[k][j];
res.m[i][j] %= M;
}
}
}
return res;
}
Mat power(Mat X,ll n){
Mat res;
res.identity();
ll b = n;
while(b){
if( b&1 ) res = res*X;
X = X*X;
b >>= 1;
}
return res;
}
ll fibo(ll n){
if( n < 2 ) return n;
Mat res;
Mat X;
X.m[0][1] = 1 , X.m[1][0] = 1 , X.m[1][1] = 1;
res = power(X,n);
ll fn[2][1];
fn[0][0]=0,fn[1][0]=1;
ll fn1[2][1];
for(int i = 0 ; i < 2 ; i++ ){
for(int j = 0 ; j < 1 ; j++ ){
for(int k = 0 ; k < 2 ; k++ ){
fn1[i][j] = res.m[i][k]*fn[k][j];
fn1[i][j]%=M;
}
}
}
return fn1[0][0];
}
ll modSub(ll a,ll b){
return ((a%M)-(b%M)+M)%M;
}
int main(){
int t;
cin>>t;
while(t--){
ll n,m;
cin>>n>>m;
cout << modSub(fibo(m+2),fibo(n+1)) << '\n';
}
return 0;
}

22
Number Theory/extended_gcd_recursive.cpp
View File

@@ -1,12 +1,12 @@
//Extended gcd -> Recursive
tuple<int,int,int> extended_gcd( int a, int b){
if( b == 0 ){
return {1,0,a};
}
int x,y,g;
tie(x,y,g) = extended_gcd( b , a%b );
return {y , x - (a/b)*y , g};
//Extended gcd -> Recursive
tuple<int,int,int> extended_gcd( int a, int b){
if( b == 0 ){
return {1,0,a};
}
int x,y,g;
tie(x,y,g) = extended_gcd( b , a%b );
return {y , x - (a/b)*y , g};
}

16
Number Theory/inverse_factorial.cpp
View File

@@ -1,9 +1,9 @@
int invFac[MAX_N];
void inverse_factorial(){
invFac[0] = invFac[1] = 1;
for(int i = 2 ; i <= MAX_N ; i++ ){
invFac[i] = (inverse(i)*invFac[i-1])%M;
}
int invFac[MAX_N];
void inverse_factorial(){
invFac[0] = invFac[1] = 1;
for(int i = 2 ; i <= MAX_N ; i++ ){
invFac[i] = (inverse(i)*invFac[i-1])%M;
}
}

46
Number Theory/inverse_modulo_array.cpp
View File

@@ -1,24 +1,24 @@
vector<int> invs( vi& a , int m ){
int n = (int)a.size();
if( n == 0 ) return {};
vector<int> b(n);
int v = 1;
for(int i = 0 ; i < n ; i++ ){
b[i] = v;
v = ((long long)v * a[i] ) % m;
}
int x = power( v , m - 2 , m ) ;
x = (x % m + m ) % m;
for(int i = n - 1 ; i >= 0 ; i-- ){
b[i] = x * b[i] %m;
x = x * a[i] % m;
}
return b;
vector<int> invs( vi& a , int m ){
int n = (int)a.size();
if( n == 0 ) return {};
vector<int> b(n);
int v = 1;
for(int i = 0 ; i < n ; i++ ){
b[i] = v;
v = ((long long)v * a[i] ) % m;
}
int x = power( v , m - 2 , m ) ;
x = (x % m + m ) % m;
for(int i = n - 1 ; i >= 0 ; i-- ){
b[i] = x * b[i] %m;
x = x * a[i] % m;
}
return b;
}

8
Number Theory/modAdd.cpp
View File

@@ -1,4 +1,4 @@
template<typename T>
T modAdd(T a,T b,T M=(T)1e9+7){
return ((M+a%M)%M+(M+b%M)%M)%M;
}
template<typename T>
T modAdd(T a,T b,T M=(T)1e9+7){
return ((M+a%M)%M+(M+b%M)%M)%M;
}

6
Number Theory/modMul.cpp
View File

@@ -1,4 +1,4 @@
template<typename T>
T modMul(T a,T b,T M=(int)1e9+7){
return ((a%M)*(b%M))%M;
template<typename T>
T modMul(T a,T b,T M=(int)1e9+7){
return ((a%M)*(b%M))%M;
}

6
Number Theory/modSub.cpp
View File

@@ -1,4 +1,4 @@
template<typename T>
T modSub(T a,T b,T M=(T)1e9+7){
return (M+((M+a%M)%M-(M+b%M)%M))%M;
template<typename T>
T modSub(T a,T b,T M=(T)1e9+7){
return (M+((M+a%M)%M-(M+b%M)%M))%M;
}

34
Number Theory/prime_sieve.cpp
View File

@@ -1,18 +1,18 @@
#define MAX_N 5000001
bool is_prime[MAX_N];
bool is_sieve_eval = false;
void sieve_erathosis(){
if( is_sieve_eval ) return;
is_sieve_eval = true;
memset(is_prime,0,sizeof(is_prime));
is_prime[0] = true , is_prime[1] = true;
for(int num = 2 ; num*num < MAX_N ; num++ ){
if( !is_prime[num] ){
for(int val = num*num ; val < MAX_N ; val += num ){
is_prime[val] = true;
}
}
}
#define MAX_N 5000001
bool is_prime[MAX_N];
bool is_sieve_eval = false;
void sieve_erathosis(){
if( is_sieve_eval ) return;
is_sieve_eval = true;
memset(is_prime,0,sizeof(is_prime));
is_prime[0] = true , is_prime[1] = true;
for(int num = 2 ; num*num < MAX_N ; num++ ){
if( !is_prime[num] ){
for(int val = num*num ; val < MAX_N ; val += num ){
is_prime[val] = true;
}
}
}
}

20
Number Theory/string_mod_int.cpp
View File

@@ -1,11 +1,11 @@
int operator%(string& a , int b){
int sz = (int)a.size();
int val = 0;
for(int idx = 0 ; idx < sz ; idx++ ){
val = 10*val + (a[idx]-'0');
val %= b;
}
return val;
int operator%(string& a , int b){
int sz = (int)a.size();
int val = 0;
for(int idx = 0 ; idx < sz ; idx++ ){
val = 10*val + (a[idx]-'0');
val %= b;
}
return val;
}

28
Searching/advanced_binary_search.cpp
View File

@@ -1,15 +1,15 @@
//Advanced Binary Seach.
int max_iter;
double low , high , ans;
double err ;
for(int i = 1 ; i <= max_iter ; i++ ){
double mid = low + (high - low)/2;
if( check(mid) ){
ans = mid;
low = mid + err;
}
else{
high = mid - err;
}
//Advanced Binary Seach.
int max_iter;
double low , high , ans;
double err ;
for(int i = 1 ; i <= max_iter ; i++ ){
double mid = low + (high - low)/2;
if( check(mid) ){
ans = mid;
low = mid + err;
}
else{
high = mid - err;
}
}

10
Searching/binary_search_jump.cpp
View File

@@ -1,6 +1,6 @@
//Binary Search Jump.
int ans = n;
for(int b = n/2 ; b >= 1 ; b/=2 ){
while(check(ans - b))ans -= b;
}
//Binary Search Jump.
int ans = n;
for(int b = n/2 ; b >= 1 ; b/=2 ){
while(check(ans - b))ans -= b;
}
cout << ans << endl;

26
Searching/binary_search_normal.cpp
View File

@@ -1,14 +1,14 @@
//Binary Search Normal
int low = 0 , high = n , ans;
while( low <= high ){
int mid = low + ( high - low)/2;
if( check(mid) ){
ans = mid;
low = mid + 1;
}
else{
high = mid - 1;
}
//Binary Search Normal
int low = 0 , high = n , ans;
while( low <= high ){
int mid = low + ( high - low)/2;
if( check(mid) ){
ans = mid;
low = mid + 1;
}
else{
high = mid - 1;
}
}

26
Searching/ternary_search.cpp
View File

@@ -1,14 +1,14 @@
double ternary_search(double l, double r) {
double eps = 1e-9; //set the error limit here
while (r - l > eps) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
double f1 = f(m1); //evaluates the function at m1
double f2 = f(m2); //evaluates the function at m2
if (f1 < f2)
l = m1;
else
r = m2;
}
return f(l); //return the maximum of f(x) in [l, r]
double ternary_search(double l, double r) {
double eps = 1e-9; //set the error limit here
while (r - l > eps) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
double f1 = f(m1); //evaluates the function at m1
double f2 = f(m2); //evaluates the function at m2
if (f1 < f2)
l = m1;
else
r = m2;
}
return f(l); //return the maximum of f(x) in [l, r]
}

272
String Hashing/String_Hashing.cpp
View File

@@ -1,137 +1,137 @@
class String_hash{
public:
vector<int> p = {31,33};
vector<int> prime = { 1000000007, 1000000009 };
int sz;
//For Storing the hash value of the prefix string.
vector<vector<int>> hash;
//For storing the power of p(constant) for polynomial function.
vector<vector<int>> power_p;
//For storing the inverse of the power of p
vector<vector<int>> inv_power_p;
String_hash(string a, int num){
sz = num;
hash.resize(sz);
power_p.resize(sz);
inv_power_p.resize(sz);
string s = a;
int n = (int)s.size();
//Pre-Calculating power.
for(int i = 0 ; i < sz ; i++ ){
power_p[i].resize(n);
power_p[i][0] = 1;
for(int j = 1 ; j < n ; j++ ){
power_p[i][j] = ( power_p[i][j-1] * p[i] ) % prime[i];
}
}
//Pre-Calculating inverse power.
for(int i = 0 ; i < sz ; i++ ){
inv_power_p[i] = invs(power_p[i] , prime[i] );
}
//Calculating prefix-hash of the given string.
for(int i = 0 ; i < sz ; i++ ){
hash[i].resize(n);
for(int j = 0 ; j < n ; j++ ){
hash[i][j] = ( ( s[j] - 'a' + 1LL ) * power_p[i][j] ) % prime[i];
hash[i][j] = ( hash[i][j] + ( j-1 >= 0 ? hash[i][j-1] : 0LL ) ) % prime[i];
}
}
}
vector<int> invs( vi& a , int m ){
int n = (int)a.size();
if( n == 0 ) return {};
vector<int> b(n);
int v = 1;
for(int i = 0 ; i < n ; i++ ){
b[i] = v;
v = ((long long)v * a[i] ) % m;
}
int x = power( v , m - 2 , m ) ;
x = (x % m + m ) % m;
for(int i = n - 1 ; i >= 0 ; i-- ){
b[i] = x * b[i] %m;
x = x * a[i] % m;
}
return b;
}
void add_char_back(char c ){
for(int i = 0 ; i < sz ; i++ ){
//power of p for new character adding at the back.
power_p[i].pb( power_p[i].back() * p[i] );
hash[i].pb( (hash[i].back()) + ( c - 'a' + 1LL ) * (power_p[i].back()) % prime[i]);
}
}
void add_char_front(char c ){
for(int i = 0 ; i < sz ; i++ ){
//power of p for new character adding at the back.
power_p[i].pb( power_p[i].back() * p[i] );
hash[i].pb( (hash[i].back()) * (power_p[i].back()) + ( c - 'a' + 1LL ) % prime[i]);
}
}
vector<int> subStringHash(int l , int r ){ //log 1e9+7
vector<int> new_hash(sz);
for(int i = 0 ; i < sz ; i++ ){
int val1 = ( l-1 >= 0 ? hash[i][l-1] : 0LL );
int val2 = hash[i][r];
new_hash[i] = modMul( modSub( val2 , val1 , prime[i]) , inv_power_p[i][l] , prime[i] ) ;
}
return new_hash;
}
bool compareSubString( int l1 , int r1 , int l2 , int r2 ){
if( l1 > l2 ){
swap(l1,l2);
swap(r1,r2);
}
for(int i = 0 ; i < sz ; i++ ){
int val1 = modSub( hash[i][r1] , ( l1 - 1 >= 0 ? hash[i][l1-1] : 0LL ), prime[i] );
int val2 = modSub( hash[i][r2] , ( l2 - 1 >= 0 ? hash[i][l2-1] : 0LL ), prime[i] );
if( modMul( val1 ,power_p[i][l2-l1] , prime[i] ) != val2 ){
return false;
}
}
return true;
}
class String_hash{
public:
vector<int> p = {31,33};
vector<int> prime = { 1000000007, 1000000009 };
int sz;
//For Storing the hash value of the prefix string.
vector<vector<int>> hash;
//For storing the power of p(constant) for polynomial function.
vector<vector<int>> power_p;
//For storing the inverse of the power of p
vector<vector<int>> inv_power_p;
String_hash(string a, int num){
sz = num;
hash.resize(sz);
power_p.resize(sz);
inv_power_p.resize(sz);
string s = a;
int n = (int)s.size();
//Pre-Calculating power.
for(int i = 0 ; i < sz ; i++ ){
power_p[i].resize(n);
power_p[i][0] = 1;
for(int j = 1 ; j < n ; j++ ){
power_p[i][j] = ( power_p[i][j-1] * p[i] ) % prime[i];
}
}
//Pre-Calculating inverse power.
for(int i = 0 ; i < sz ; i++ ){
inv_power_p[i] = invs(power_p[i] , prime[i] );
}
//Calculating prefix-hash of the given string.
for(int i = 0 ; i < sz ; i++ ){
hash[i].resize(n);
for(int j = 0 ; j < n ; j++ ){
hash[i][j] = ( ( s[j] - 'a' + 1LL ) * power_p[i][j] ) % prime[i];
hash[i][j] = ( hash[i][j] + ( j-1 >= 0 ? hash[i][j-1] : 0LL ) ) % prime[i];
}
}
}
vector<int> invs( vi& a , int m ){
int n = (int)a.size();
if( n == 0 ) return {};
vector<int> b(n);
int v = 1;
for(int i = 0 ; i < n ; i++ ){
b[i] = v;
v = ((long long)v * a[i] ) % m;
}
int x = power( v , m - 2 , m ) ;
x = (x % m + m ) % m;
for(int i = n - 1 ; i >= 0 ; i-- ){
b[i] = x * b[i] %m;
x = x * a[i] % m;
}
return b;
}
void add_char_back(char c ){
for(int i = 0 ; i < sz ; i++ ){
//power of p for new character adding at the back.
power_p[i].pb( power_p[i].back() * p[i] );
hash[i].pb( (hash[i].back()) + ( c - 'a' + 1LL ) * (power_p[i].back()) % prime[i]);
}
}
void add_char_front(char c ){
for(int i = 0 ; i < sz ; i++ ){
//power of p for new character adding at the back.
power_p[i].pb( power_p[i].back() * p[i] );
hash[i].pb( (hash[i].back()) * (power_p[i].back()) + ( c - 'a' + 1LL ) % prime[i]);
}
}
vector<int> subStringHash(int l , int r ){ //log 1e9+7
vector<int> new_hash(sz);
for(int i = 0 ; i < sz ; i++ ){
int val1 = ( l-1 >= 0 ? hash[i][l-1] : 0LL );
int val2 = hash[i][r];
new_hash[i] = modMul( modSub( val2 , val1 , prime[i]) , inv_power_p[i][l] , prime[i] ) ;
}
return new_hash;
}
bool compareSubString( int l1 , int r1 , int l2 , int r2 ){
if( l1 > l2 ){
swap(l1,l2);
swap(r1,r2);
}
for(int i = 0 ; i < sz ; i++ ){
int val1 = modSub( hash[i][r1] , ( l1 - 1 >= 0 ? hash[i][l1-1] : 0LL ), prime[i] );
int val2 = modSub( hash[i][r2] , ( l2 - 1 >= 0 ? hash[i][l2-1] : 0LL ), prime[i] );
if( modMul( val1 ,power_p[i][l2-l1] , prime[i] ) != val2 ){
return false;
}
}
return true;
}
};

350
cpadv.cpp
View File

@@ -1,175 +1,175 @@
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//using namespace __gnu_pbds;
using namespace std;
// template<typename T>
// using indexed_multiset = tree<T , null_type , less_equal<T> , rb_tree_tag ,
// tree_order_statistics_node_update>;
// template<typename T>
// using indexed_set=tree<T,null_type,less<T>,rb_tree_tag,
// tree_order_statistics_node_update>;
#define ld long double
#define ll long long int
#define F first
#define S second
#define pb push_back
#define si set <int>
#define sll set <ll>
#define vi vector <int>
#define vll vector <ll>
#define pii pair <int, int>
#define pll pair <ll,ll>
#define vpi vector <pii>
#define vpl vector <pll>
#define mii map <int, int>
#define mll map <ll,ll>
#define sz(x) ((int) x.size())
#define all(p) p.begin(), p.end()
#define que_max priority_queue <int>
#define que_max_ll priority_queue <ll>
#define que_min priority_queue <int, vi, greater<int>>
#define que_min_ll priority_queue <ll , vll, greater<ll>>
#define bug(...) __f (#__VA_ARGS__, __VA_ARGS__)
#define print(a) for(auto x : a) cout << x << " "; cout << endl
#define print1(a) for(auto x : a) cout << x.F << " " << x.S << endl
#define print2(i,a,x,y) for(auto i = x; i < y; i++) cout<< a[i]<< " "; cout << endl
#define scan(s,e,a) for(auto i = s ; i <= e ; i++ ) cin>>a[i]
#define loop(i,s,e,weight) for(auto i = s ; (weight>=0? i <= e : i >= e ) ; i+=weight )
#define read(n) ll n; cin>>n
#define endl '\n'
#define ALGO_START clock_t z = clock()
#define ALGO_END cout << "RUN TIME : " << fixed << setprecision(6) << ((double)(clock() - z))/CLOCKS_PER_SEC
//endl -> cout << '\n' << flush;//hence,slower.
//for interactive problem.
// cout << flush; //for cin cout
// fflush(stdout); //for scanf printf.
//In Mathematics section of cp course.
template<typename T>
T modMul(T a,T b,T M=(int)1e9+7){
return ((a%M)*(b%M))%M;
}
template<typename T>
inline T power(T a, T b, T M)
{
T x = 1;
while (b)
{
if (b & 1) x = modMul(x,a,M);
a = modMul(a,a,M);
b >>= 1;
}
return x;
}
template <typename T>
inline T pwr(T a, T b)
{
T x = 1;
while (b)
{
if (b & 1) x = x*a;
a = a*a;
b >>= 1;
}
return x;
}
//Square root using advanced binary search.
template <typename T>
ld sq_root(T x){
ld err = 1e-6;
ld ans;
ld low = 1.0 , high = x;
for(int i = 1 ; i <= 40 ; i++ ){
ld mid = low + (high - low)/2.0;
if( mid*mid <= x ){
ans = mid;
low = mid + err;
}
else{
high = mid - err;
}
}
return ans;
}
template <typename Arg1>
void __f (const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << endl; }
template <typename Arg1, typename... Args>
void __f (const char* names, Arg1&& arg1, Args&&... args)
{
const char* comma = strchr (names + 1, ',');
cout.write (names, comma - names) << " : " << arg1 << " "; __f (comma + 1, args...);
}
/*******************************************************************Debugging tools *************************************************/
#define dbg(x...) cerr << #x << " "; _print(x); cerr << endl;
#define debug(x,y...) cerr << #x << " -> "; _print(y); cerr << endl;
#define crndl cerr << "\n";
template <typename T> void _print (T t) { cerr << t; }
void _print() {return;}
template <class T> void _print(T a[], int n) { cerr << "[ "; for(int i = 0; i < n; i++) { _print(a[i]); cerr << " "; } cerr << "]"; }
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.first); cerr << ","; _print(p.second); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(unordered_map <T, V> v) {cerr << "[ "; for (auto &i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto &i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(deque <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(queue <T> q) {cerr << "[ "; while (!q.empty()) {_print(q.front()); cerr << " "; q.pop();} cerr << "]";}
template <class T> void _print(stack <T> s) {cerr << "[ "; stack<T> t; while (!s.empty()) {t.push(s.top()); s.pop();} while (!t.empty()) {_print(t.top()); cerr << " "; t.pop();} cerr << "]";}
template <class T> void _print(priority_queue <T> pq) {cerr << "[ "; while (!pq.empty()) {_print(pq.top()); cerr << " "; pq.pop();} cerr << "]";}
template <class T> void _print(priority_queue<T, vector<T>, greater<T>> pq) {cerr << "[ "; while (!pq.empty()) {_print(pq.top()); cerr << " "; pq.pop();} cerr << "]";}
template <class T, class... V> void _print(T t, V... v) {_print(t); if(sizeof...(v)) {cerr<<", "; _print(v...);}}
// template <class T> void _print(oset<T> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}
/************************************************************************************************************************************/
const int N = 200005;
/**********************Solve Here*********************/
void solve(){
}
/**********************Solve Here*********************/
int32_t main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// clock_t z = clock();
/***********************Test cases********************/
int t = 1;
// cin >> t;
// int i=1;
while (t--){
// cout << "Case#" << i << endl;
solve();
// i++;
}
/***********************Test cases********************/
// cerr << "Run Time : " << ((double)(clock() - z) / CLOCKS_PER_SEC);
//cerr= c error.
return 0;
}
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//using namespace __gnu_pbds;
using namespace std;
// template<typename T>
// using indexed_multiset = tree<T , null_type , less_equal<T> , rb_tree_tag ,
// tree_order_statistics_node_update>;
// template<typename T>
// using indexed_set=tree<T,null_type,less<T>,rb_tree_tag,
// tree_order_statistics_node_update>;
#define ld long double
#define ll long long int
#define F first
#define S second
#define pb push_back
#define si set <int>
#define sll set <ll>
#define vi vector <int>
#define vll vector <ll>
#define pii pair <int, int>
#define pll pair <ll,ll>
#define vpi vector <pii>
#define vpl vector <pll>
#define mii map <int, int>
#define mll map <ll,ll>
#define sz(x) ((int) x.size())
#define all(p) p.begin(), p.end()
#define que_max priority_queue <int>
#define que_max_ll priority_queue <ll>
#define que_min priority_queue <int, vi, greater<int>>
#define que_min_ll priority_queue <ll , vll, greater<ll>>
#define bug(...) __f (#__VA_ARGS__, __VA_ARGS__)
#define print(a) for(auto x : a) cout << x << " "; cout << endl
#define print1(a) for(auto x : a) cout << x.F << " " << x.S << endl
#define print2(i,a,x,y) for(auto i = x; i < y; i++) cout<< a[i]<< " "; cout << endl
#define scan(s,e,a) for(auto i = s ; i <= e ; i++ ) cin>>a[i]
#define loop(i,s,e,weight) for(auto i = s ; (weight>=0? i <= e : i >= e ) ; i+=weight )
#define read(n) ll n; cin>>n
#define endl '\n'
#define ALGO_START clock_t z = clock()
#define ALGO_END cout << "RUN TIME : " << fixed << setprecision(6) << ((double)(clock() - z))/CLOCKS_PER_SEC
//endl -> cout << '\n' << flush;//hence,slower.
//for interactive problem.
// cout << flush; //for cin cout
// fflush(stdout); //for scanf printf.
//In Mathematics section of cp course.
template<typename T>
T modMul(T a,T b,T M=(int)1e9+7){
return ((a%M)*(b%M))%M;
}
template<typename T>
inline T power(T a, T b, T M)
{
T x = 1;
while (b)
{
if (b & 1) x = modMul(x,a,M);
a = modMul(a,a,M);
b >>= 1;
}
return x;
}
template <typename T>
inline T pwr(T a, T b)
{
T x = 1;
while (b)
{
if (b & 1) x = x*a;
a = a*a;
b >>= 1;
}
return x;
}
//Square root using advanced binary search.
template <typename T>
ld sq_root(T x){
ld err = 1e-6;
ld ans;
ld low = 1.0 , high = x;
for(int i = 1 ; i <= 40 ; i++ ){
ld mid = low + (high - low)/2.0;
if( mid*mid <= x ){
ans = mid;
low = mid + err;
}
else{
high = mid - err;
}
}
return ans;
}
template <typename Arg1>
void __f (const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << endl; }
template <typename Arg1, typename... Args>
void __f (const char* names, Arg1&& arg1, Args&&... args)
{
const char* comma = strchr (names + 1, ',');
cout.write (names, comma - names) << " : " << arg1 << " "; __f (comma + 1, args...);
}
/*******************************************************************Debugging tools *************************************************/
#define dbg(x...) cerr << #x << " "; _print(x); cerr << endl;
#define debug(x,y...) cerr << #x << " -> "; _print(y); cerr << endl;
#define crndl cerr << "\n";
template <typename T> void _print (T t) { cerr << t; }
void _print() {return;}
template <class T> void _print(T a[], int n) { cerr << "[ "; for(int i = 0; i < n; i++) { _print(a[i]); cerr << " "; } cerr << "]"; }
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.first); cerr << ","; _print(p.second); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(unordered_map <T, V> v) {cerr << "[ "; for (auto &i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto &i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(deque <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(queue <T> q) {cerr << "[ "; while (!q.empty()) {_print(q.front()); cerr << " "; q.pop();} cerr << "]";}
template <class T> void _print(stack <T> s) {cerr << "[ "; stack<T> t; while (!s.empty()) {t.push(s.top()); s.pop();} while (!t.empty()) {_print(t.top()); cerr << " "; t.pop();} cerr << "]";}
template <class T> void _print(priority_queue <T> pq) {cerr << "[ "; while (!pq.empty()) {_print(pq.top()); cerr << " "; pq.pop();} cerr << "]";}
template <class T> void _print(priority_queue<T, vector<T>, greater<T>> pq) {cerr << "[ "; while (!pq.empty()) {_print(pq.top()); cerr << " "; pq.pop();} cerr << "]";}
template <class T, class... V> void _print(T t, V... v) {_print(t); if(sizeof...(v)) {cerr<<", "; _print(v...);}}
// template <class T> void _print(oset<T> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}
/************************************************************************************************************************************/
const int N = 200005;
/**********************Solve Here*********************/
void solve(){
}
/**********************Solve Here*********************/
int32_t main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// clock_t z = clock();
/***********************Test cases********************/
int t = 1;
// cin >> t;
// int i=1;
while (t--){
// cout << "Case#" << i << endl;
solve();
// i++;
}
/***********************Test cases********************/
// cerr << "Run Time : " << ((double)(clock() - z) / CLOCKS_PER_SEC);
//cerr= c error.
return 0;
}