Template :-

ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);

#include <bits/stdc++.h>

#define ll long long

#define vi vector<ll>
#define vii vector<vi>
#define vc vector<char>
#define vcc vector<vc>
#define mi map<int,int>
#define mc map<char,int>
#define sortx(X) sort(X.begin(),X.end());
#define all(X) X.begin(),X.end();
#define ln '\n'

Function :-
memset(BIT, 0, sizeof(BIT)); //intlize arr with 0

int converted = stoi(dec, nullptr, 16);

// compare function -> min is top

struct com {
bool operator()(int &l, int &r){
return l > r;
}
};
priority_queue<int, vi, com> L;

//get random index of array

#include <random>
mt19937 gen(123456789);
uniform_int_distribution<ll> dist(0, points.size() - 1);
ll idx1 = dist(gen);

//rotate matrix
void rotat(vii& X) {
vii tmp(X[0].size(), vi(X.size()));
for (int i = 0; i < X.size(); i++)
for (int j = 0; j < X[i].size(); j++)
tmp[X[i].size() - j - 1][i] = X[i][j];
X = tmp;
}

if (str.find(str1) != string::npos)
transform(str.begin(), str.end(), str.begin(), ::toupper);

// get all sequances of array

string a = "abcd";
do {
cout << a;
} while (next_permutation(a.begin(), a.end()));

1
Bitwise :-
//first digit of number
X & -X
//pow of two just have 1 only
n & (n - 1) && (n != 0) -- > 0

//get the velue of but in number

(x >> indx) & 1

bitset<2000007> Z;
// all point start with one
Z.set();
// get first digit with 1 after b
a = Z._Find_next(b);

int n = 10;

bitset<32> s(n);
00000000000000000000000000001010
s.to_ullong() -- >> to decimal value
s.set(3); // Set bit at position 3 to 1
s.reset(7); // Set bit at position 7 to 0
bool bit3 = s[3]; // Check bit at position 3

bool getBit(ll num, int idx) {

return ((num >> idx) & 1);
}
ll setBit(ll num, int idx, bool val) {
return val ? (num | (1LL << idx)) : (num & ~(1LL << idx));
}

ll flipBit(ll num, int idx) {

return (num ^ (1LL << idx));
}

ll leastBit(ll num) {
return (num & -num);
}

//num%mod, mod is a power of 2

ll Mod(ll num, ll mod) {
return (num & mod - 1);
}

bool isPowerOfTwo(ll num) {

return (num & num - 1) == 0;
}

int turnOnLastZero(int S) {
return S | S + 1;
}

int turnOffLastBit(int S) {
return S & S - 1;
}

int turnOnLastConsecutiveZeroes(int S) {
return S | S - 1;
}

2
int turnOffLastConsecutiveBits(int S) {
return S & S + 1;
}

vector<int> genAllSubmask(int mask) {

vector<int> v;
for (int subMask = mask;; subMask = (subMask - 1) & mask) {
v.push_back(subMask);
if (subMask == 0)
break;
}
return v;
}

math :-
Pi 3.141592653589793238462643383279502884

// seive prime factorization

vi prime(1e7 + 10, 0);
for (int i = 2; i * i < 1e7; ++i) {
if (prime[i]) continue;
for (int j = i; j * j <= 1e7; j+=i)
prime[j] = i;
}

// mode_inverse
ll exp_mod(ll a, ll n) {
ll res = 1;
for (; n > 0; n /= 2) {
if (n % 2) res = res * a % mode;
a = a * a % mode;
}
return res;
}
ll inv_mod(ll a) {
return exp_mod(a, mode - 2);
}

//ax+by=gcd(a,b)
ll gcdExtended(ll a, ll b, ll* x, ll* y)
{
if (a == 0){
*x = 0;
*y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}

ll gcd(ll a, ll b){
if (b == 0)
return a;
return gcd(b, a % b);
}

ll lcm(ll a, ll b){
return (a / gcd(a, b)) * b;
3
}

nCr = fac(n)/fec(r)*fac(n-r)

nCr(n,r) = nCr(n - 1, r - 1) + nCr(n - 1, r)

nPr = fac(n)/fac(n-r)

double log_a_to_base_b(double a, double b) {

return log2(a) / log2(b);
}

(a + b) % c = ((a % c) + (b % c)) % c
(a * b) % c = ((a % c) * (b % c)) % c
(a - b) % c = ((a % c) - (b % c) + c) % c
(a / b) % c = ((a % c) * ((b ^ -1) % c)) % c

ll modfpow(ll x, ll y, ll z){
ll result = 1;
while (y > 0){
if (y % 2 == 1)result = ((result % z) * (x % z)) % z;

x = ((x % z) * (x % z)) % z;
y = y / 2;
}
return result;
}

long long sumOdd(long long num) {

long long res = (num + 1) / 2;
long long finalRes = res * res;
return finalRes;
}
long long sumEven(long long num) {
long long res = (num * (num + 1));
return res;
//summ of numpers divisible by m from 1 to n
ll first_term = m;
ll last_term = (n / m) * m;
ll num_terms = (last_term - first_term) / m + 1;
ll sum = (num_terms * (first_term + last_term)) / 2;

void matrix_multiply(int A[][MAX_SIZE], int B[][MAX_SIZE], int C[][MAX_SIZE], int m, int n, int p) {
// Multiply matrices A and B, storing the result in matrix C
for (int i = 0; i < m; i++) {
for (int j = 0; j < p; j++) {
int sum = 0;
for (int k = 0; k < n; k++) {
sum += A[i][k] * B[k][j];
}
C[i][j] = sum;
}
}
}

phi(a* b) = phi(a) * phi(b)

time = sqrt(n)
ll phi(ll n)
{
ld result = n;
for (int i = 2; i * i <= n; ++i) {
4
 if (n % i == 0){
while (n % i == 0) n /= i;
result *= (1.0 - (1.0 / float(i)));
}
}
if (n > 1)result *= (1.0 - (1.0 / float(n)));
ll jj = result;
return jj;
}

ll catalan(int n){
return (nCr(2 * n, n) * Inv(n + 1)) % MOD;
}

Binary-search-tree :-
//creat node
struct node
{
int key;
struct node* left, * right;
};
struct node* newNode(int item)
{
node* temp = new node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
//insert to node node
node* insert(struct node* node, int key)
{
if (node == NULL)
return newNode(key);

if (key < node->key) node->left = insert(node->left, key);

else node->right = insert(node->right, key);

return node;
}
//delete node
struct node* minValueNode(struct node* node)
{
struct node* current = node;

while (current && current->left != NULL)

current = current->left;

return current;
}
struct node* deleteNode(struct node* root, int key)
{
if (root == NULL) return root;

if (key < root->key) root->left = deleteNode(root->left, key);

else if (key > root->key) root->right = deleteNode(root->right, key);

else {
if (root->left == NULL) {
struct node* temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL) {
struct node* temp = root->left;
free(root);
return temp;
}
struct node* temp = minValueNode(root->right);
root->key = temp->key;
root->right = deleteNode(root->right, temp->key);
}
return root;
}

5
// get element of BST in ordered way
void inorder(struct node* root)
{
if (root != NULL)
{
inorder(root->left);
cout << root->key << " ";
inorder(root->right);
}
}

Fenwick-tree :-
ll rangequery(const vi& Z, ll l, ll r) {
ll summ = 0;

for (int i = r; i > 0; i -= i & -i)

summ += Z[i];

for (int i = l - 1; i > 0; i -= i & -i)

summ -= Z[i];

return summ;
}

void updatepoint(vi& Z, ll n, ll at) {

ll summ = 0;
//sum = rangequery(Z, at, at)

for (int i = at; i < Z.size(); i += i & -i)

Z[i] += n - summ;
}

// To fenwik of 2d array we nested loop it to get summ of squir

for (int x; x > 0; x -= x & -x)
for (int yy = y; yy > 0; yy -= yy & -yy)
sum += BIT[x][yy];

// I can use it to make sorted dynamic array

// to insert update(x,+1) delete update(x,-1)
for ( ; i < BIT.size(); i+= i & -i)
BIT[i]++;

// To get the value of index O(log(n)^2) we use lower pound

while (l < r) {
at = (l + r) / 2;
if (k <= sum(at, BIT)) r = at;
else l = at + 1;
}

// to get all element greater than k in range l , r -> take quary in array and sort in
// I can make fenwick of XoR
// I can binary search for prefix value on it

Segment-tree :-
// it like fenwick but can do more operation like min or max in range
// we first make array of size 2*n -> left and right are 2*i+1 – 2*i+2

int getMid(int s, int e) { return s + (e - s) / 2; }

int getSumUtil(int* st, int ss, int se, int qs, int qe, int si){
if (qs <= ss && qe >= se) return st[si];
if (se < qs || ss > qe) return 0;
int mid = getMid(ss, se);
return getSumUtil(st, ss, mid, qs, qe, 2 * si + 1) +
getSumUtil(st, mid + 1, se, qs, qe, 2 * si + 2);
}
void updateValueUtil(int* st, int ss, int se, int i, int diff, int si){
if (i < ss || i > se)
return;
st[si] = st[si] + diff;
if (se != ss){
int mid = getMid(ss, se);
6
 updateValueUtil(st, ss, mid, i, diff, 2 * si + 1);
updateValueUtil(st, mid + 1, se, i, diff, 2 * si + 2);
}
}
int constructSTUtil(int arr[], int ss, int se, int* st, int si)
{
if (ss == se){
st[si] = arr[ss];
return arr[ss];
}
int mid = getMid(ss, se);
st[si] = constructSTUtil(arr, ss, mid, st, si * 2 + 1) +
constructSTUtil(arr, mid + 1, se, st, si * 2 + 2);
return st[si];
}
int* constructST(int arr[], int n)
{
int x = (int)(ceil(log2(n)));
int max_size = 2 * (int)pow(2, x) - 1;
int* st = new int[max_size];
constructSTUtil(arr, 0, n - 1, st, 0);
return st;
}
// lazy propagation -> add value to range and update it only of needed
// we use another array call lazy to store values
//to get summ or update we first check if there was lazy value
// put this if at the top of get sum and update
if (lazy[si] != 0){
tree [si] += (se - ss + 1) * lazy[si];
if (ss != se)
{
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
}

lazy[si] = 0;
}

// my function
vi Z(1e6 * 3, 0);
ll n;
int getrange(int s, int e, int l, int r, int k) {
if (s > r || e < l) return 0;
if (s >= l && e <= r) return Z[k];
int at = (s + e) / 2;
return getrange(s, at, l, r, k * 2 + 1) + getrange(at + 1, e, l, r, k * 2 + 2);
}
void updates(int s, int e, int k, int index, int val) {
if (s == e) {
Z[k] += val;
return;
}
int at = (s + e) / 2;
if (index >= s && index <= at) updates(s, at, k * 2 + 1, index, val);
else updates(at + 1, e, k * 2 + 2, index, val);
Z[k] += val;
}

void update(int i, ll k) {
updates(0, n - 1, 0, i, k);
}

ll summ(int i) {
return getrange(0, n - 1, 0, i, 0);
7
Trie-tree :-
// to start new node node * X = new node();
struct node {
node* next[2] = { NULL };
int val = 0;
};
node* root, * AT_TRIE, * TRIE = new node[32 * 100100];
void add(node*& X, int n, int k) {
if (!X) *(X = AT_TRIE++) = node();
if (!n) X->val += k;
else add(X->next[n & 1], n >> 1, k);
}
int get(node* X, int n) {
if (!X) return 0;
if (!n) return X->val;
return get(X->next[n & 1], n >> 1);
}

Graph ------------------>>>>>>>>>
// Tree to know every child and it’s parents
struct node
{
int val, pra;
vector<int> c;
};
vii Y;
vector<node> Z;
void build(int k) {
for (int i = 0; i < Y[k].size(); i++) {
if (Y[k][i] == Z[k].pra)continue;
Z[k].c.push_back(Y[k][i]);
Z[Y[k][i]].pra = k;
build(Y[k][i]);
}
}

BFS :-
// to get level of the node or distance
vii Y;
vector<int> lvl(10100, -1);
int nodeLevel(int start)
{
queue<int> Q;
Q.push(start);
lvl[start] = 0;
while (!Q.empty()) {
int re = Q.front();
Q.pop();
for (int i = 0; i < Y[re].size(); i++) {
if (lvl[Y[re][i]] != -1) continue;
lvl[Y[re][i]] = lvl[re] + 1;
Q.push(Y[re][i]);
}
}
8
}

// monomatic stack
ll n; cin >> n;
vi v(n); cin(v);
vector<ll>m(n, -1);
stack<pair<ll, ll>>st;
for (int i = 0; i < n; ++i) {
if (st.empty())
{
st.emplace(v[i], i);
}
else if (v[i] > st.top().first)
{
while (!st.empty() && v[i] > st.top().first)
{
m[st.top().second] = i;
st.pop();
}
st.emplace(v[i], i);
}
else
{
st.emplace(v[i], i);
}
}
ll q; cin >> q;
while (q--)
{
ll x; cin >> x;
if (m[x - 1] == -1)cout << "-1\n";
else cout << m[x - 1] + 1 << "\n";
}

DP :-
ll Longest_Increasing_SubSeq(vi X) {
vi Z;
for (int i = 0; i < X.size(); i++){
ll re = upper_bound(Z.begin(), Z.end(), X[i]) - Z.begin();
if (re == Z.size())Z.push_back(X[i]);
else Z[re] = X[i];
}
return Z.size();
}