Algoritmi fundamentali

#include <bits/stdc++.h> // hashuri

#define MOD 666013

using namespace std;

ifstream f("hashuri.in");
ofstream g("hashuri.out");

int n;
vector <int> Hash[MOD]; HASH

void op1(int x){

int p = x % MOD;
for (int i = 0; i < Hash[p].size(); i++){
if (Hash[p][i] == x){
return;
}
}
Hash[p].push_back(x);
}

void op2 (int x){

int p = x % MOD;
for (int i = 0; i < Hash[p].size(); i++){
if (Hash[p][i] == x){
Hash[p].erase(Hash[p].begin() + i);
}
}
}

void op3 (int x){

int p = x % MOD;
for (int i = 0; i < Hash[p].size(); i++){
if (Hash[p][i] == x){
g << "1\n";
return;
}
}
g << "0\n";
return;
}

void dostuff(){
f >> n;
for (;n--;){
int op, val;
f >> op >> val;
if (op == 1){
op1(val);
} else {
if (op == 2){
op2(val);
} else {
op3(val);
}
}
 }
}

int main()
{
ios_base::sync_with_stdio(false);
dostuff();
return 0;
}

#include <bits/stdc++.h> //ridicare la putere in timp logaritmic

#define MOD 1999999973

using namespace std;

long long x,n; POWER

ifstream f("lgput.in");
ofstream g("lgput.out");

void dostuff(){
f >> x >> n; //x^n
}

long long mypow (long long x, long long n){

if (n == 1){
return x;
}
if (n == 0){
return 1;
}
if (n%2){
return (x*mypow(x*x%MOD, (n-1)/2))%MOD;
} else {
return (mypow(x*x%MOD, n/2))%MOD;
}
}

int main()
{
dostuff();
g << mypow (x, n);
return 0;
}

//dijkstra
#include <bits/stdc++.h>
#define INF 99999999
#define MAX 51000

using namespace std; DIJKSTRA

ifstream f("dijkstra.in");
ofstream g("dijkstra.out");

vector < pair <int, int> > G[MAX];

int n, m;
int D[MAX];

void dijkstra(){
priority_queue<pair <int, int>, vector < pair < int, int > >, greater < pair <
int,int > > > pq;
pq.push({0,1});
while (!pq.empty()){
int node = pq.top().second;
int value = pq.top().first;
pq.pop();

if (D[node] != value) continue;

for (int i = 0; i < G[node].size(); i++){
if (value + G[node][i].second < D[G[node][i].first]){
D[G[node][i].first] = value + G[node][i].second;
pq.push({D[G[node][i].first], G[node][i].first});
}
}
}
}

void dostuff(){
f >> n >> m;
for (int i = 1; i <= m; i++){
int x, y, d;
f >> x >> y >> d;
G[x].push_back({y, d});
}
}

void domorestuff(){
for (int i = 2; i <= n; i++){
D[i] = INF;
}
dijkstra();
for (int i = 2; i <= n; i++){
if (D[i] == INF){
g << "0 ";
} else {
g << D[i] << ' ';
}
}
}

int main()
{
dostuff();
domorestuff();
return 0;
}

//bellman ford
#include <bits/stdc++.h>
#define MAX 50100
#define INF 1e9
using namespace std; BELLMAN-FORD

ifstream f("bellmanford.in");
ofstream g("bellmanford.out");

vector < pair <int, int> > G[MAX];

int n, m;
int d[MAX], s[MAX], cnt[MAX];
queue <int> q;

void dostuff(){
f >> n >> m;
for (int i = 1; i <= m; i++){
int x, y, c;
f >> x >> y >> c;
G[x].push_back({y,c});
}
}

int bf(){
int nod, nxt, cst;
for (int i = 2; i <= n; i++){
d[i] = INF;
}
q.push(1);
s[1] = 1;
while(!q.empty()){
nod = q.front();
s[nod] = 0;
q.pop();
for(int i = 0; i < G[nod].size(); i++)
{
nxt = G[nod][i].first;
cst = G[nod][i].second;
if(cst + d[nod] < d[nxt]){
d[nxt] = d[nod] + cst;
if(s[nxt] == 0){
q.push(nxt);
s[nxt] = 1;
}
if(++cnt[nxt] > n){
return 0;
}
}
}
}
return 1;
}

int main()
{
dostuff();
if (bf()){
for (int i = 2; i <= n; i++){
g << d[i] << ' ';
}
} else {
g << "Ciclu negativ!";
 }
return 0;
}

//lca
#include <bits/stdc++.h>
#define MAX 100100

using namespace std;

ifstream f("lca.in");
ofstream g("lca.out");

int n, m, t[MAX], lvl[MAX];

void facemlca (int a, int b){

while (t[a] != t[b]){
if (lvl[a] > lvl[b]){
a = t[a];
} else {
b = t[b];
}
}
while (a != b){
if (lvl[a] > lvl[b]){
a = t[a];
} else {
b = t[b];
}
}
g << a << '\n';
}

int main()
{
ios_base::sync_with_stdio(false);
f >> n >> m;
lvl[1] = 1;
for (int i = 1; i <= n-1; i++){
int x;
f >> x;
t[i+1] = x;
lvl[i+1] = lvl[x] + 1;
}

while (m--){
int a, b;
f >> a >> b;
facemlca (a,b);
}
return 0;
}

//roy floyd
#include <bits/stdc++.h>
#define MAX 110

using namespace std;

ifstream f("royfloyd.in");
ofstream g("royfloyd.out");

int n, a[MAX][MAX];

void royfloyd (){

for (int k = 1; k <= n; k++){
for (int i = 1; i <= n; i++){
for (int j = 1; j <= n; j++){
if (a[i][k] && a[k][j] && i != j){
if (a[i][j] > a[i][k] + a[k][j] || !a[i][j]){
a[i][j] = a[i][k] + a[k][j];
}
}
}
}
}
}

int main()
{
f >> n;
for (int i = 1; i <= n; i++){
for (int j = 1; j <= n; j++){
f >> a[i][j];
}
}
royfloyd();
for (int i = 1; i <= n; i++){
for (int j = 1; j <= n; j++){
g << a[i][j] << ' ';
}
g << '\n';
}
return 0;
}

//aib
#include <bits/stdc++.h>
#define MAX 15015

using namespace std;

ifstream f("datorii.in");
ofstream g("datorii.out");

int n, m, v[MAX], aib[MAX];

int suma(int x){

int s = 0;
while (x){
s += aib[x];
x &= x - 1;
 }
return s;
}

void adauga (int x, int val){

do{
aib[x] += val;
x += x & (-x);
} while (x <= n + 1);
}

int main()
{
f >> n >> m;
for (int i = 1; i <= n; i++){
f >> v[i];
}
for (int i = 1; i <= n; i++){
adauga (i, v[i]);
}
for (;m--;){
int op, left, right;
f >> op >> left >> right;
if (op == 0){
adauga(left, -right);
} else {
g << suma(right) - suma(left - 1) << '\n';
}
}
return 0;
}

//rmq
"Care este elementul minim din intervalul [x,y]?"
#include <bits/stdc++.h>
#define MAX 100010

using namespace std;

ifstream f("rmq.in");
ofstream g("rmq.out");

int n, m;
int v[MAX];
int rmq[20][MAX];
int lg[MAX];

void dostuff(){
f>>n>>m;
for (int i = 1; i <= n; i++){
f >> v[i];
}

lg[2] = 1;
for (int i = 3; i<=n; i++){
lg[i] = lg[i/2]+1;
}
}
void domorestuff(){
for (int i = 1; i <= n; i++){
rmq[0][i]=v[i];
}
for (int i = 1, j, p = 2; p <= n; i++, p *= 2){
for (j = 1; j+p-1 <= n; j++){
rmq[i][j]=min(rmq[i-1][j], rmq[i-1][j+p/2]);
}
}
}

void doevenmorestuff(){
int x, y, p;
while (m--){
f >> x >> y;
p = lg[y-x+1];
g << min(rmq[p][x], rmq[p][y-(1<<p)+1]) << "\n";
}
}

int main()
{
ios_base::sync_with_stdio(false);
dostuff();
domorestuff();
doevenmorestuff();
return 0;
}

//bfs
#include <bits/stdc++.h>
#define NMAX 100100
#define MMAX 1000100

using namespace std;

ifstream f("bfs.in");
ofstream g("bfs.out");

vector <int> v[NMAX];

bool viz[NMAX];
int n, m, s;
int sol[MMAX];

void bfs (int node){

int i, newnode;
queue <int> q;
q.push(node);
viz[node]=true;
while(!q.empty()){
newnode=q.front();
q.pop();
for(i=0; i<v[newnode].size(); i++){
int lastnode=v[newnode][i];
if (viz[lastnode]==false){
viz[lastnode]=true;
sol[lastnode]=sol[newnode]+1;
q.push(lastnode);
 }
}
}
}

int main()
{
ios_base::sync_with_stdio(false);
int i, x, y;
f>>n>>m>>s;
for (i=1; i<=m; i++){
f>>x>>y;
v[x].push_back(y);
}
viz[s]=1;
bfs(s);
for(i=1; i<=n; i++){
if(viz[i]==0) g<<"-1 ";
else g<<sol[i]<<" ";
}
return 0;
}

//generare combinari bkt

#include <bits/stdc++.h>

using namespace std;

int v[50], a[50], n, p;

int valid (int k){

for (int i=1; i<k; i++)
if (v[i]==v[k]) return 0;
for (int i=1; i<k; i++)
if (v[i]>v[i+1]) return 0;
return 1;
}

int sol (int k){

return p==k;
}

void afis (int k){

for (int i=1; i<=k; i++)
cout<<a[v[i]]<<" ";
cout<<"\n";
}

void bkt (){

int k; k=1;
v[k]=0;
while (k){
if (v[k]<n){
v[k]++;
if(valid(k)){
if (sol(k)) {
afis(k);
} else {
k++;
 v[k]=0;
}
}
} else {
k--;
}
}
}

int main()
{
cin>>n>>p;
for (int i=1; i<=n; i++){
cin>>a[i];
}
bkt();
return 0;
}

//subsecventa de suma maxima

#include <iostream>
#include <fstream>

using namespace std;

int v[6000001];
int main()
{
ifstream fin ("ssm.in");
ofstream fout ("ssm.out");

int n, i, min1, max1, a, b, p;

fin>>n;

for(i=1; i<=n; i++)

{
fin>>v[i];
v[i] = v[i] + v[i-1];
}

max1=v[1];
min1=v[1];
p=1;

for(i=2; i<n; i++)

{
if(v[i] - min1 > max1)
{
max1=v[i] - min1;
a=p+1;
b=i;
}

if(v[i] < min1)

{

min1= v[i];
 p=i;
}
}

if(v[n] - min1 > max1)

{
max1=v[i] - min1;
a=p+1;
b=i;
}

fout<<v[b] - v[a-1]<<' '<<a<<' '<<b;

}

subsir crescator maximal

#include <bits/stdc++.h>

using namespace std;

ifstream in("scmax.in");
ofstream out("scmax.out");
const int NMAX=100002;
int tree[4*NMAX+36],n,v[NMAX],nr[NMAX],poz,start=1,finish,val,maxim,d[NMAX];
int cautare(int val){
int p=1,poz;
for(p;p<=n;p<<=1);
for(poz=0;p;p>>=1)
if(poz+p<=n && nr[poz+p]<=val)
poz+=p;
return poz;
}
void update(int nod,int left,int right){
if(left==right){
tree[nod]=val;
return ;
}
int mid=left+(right-left)/2;
if(poz<=mid) update(nod<<1,left,mid);
else update(nod<<1|1,mid+1,right);
tree[nod]=max(tree[nod<<1|1],tree[nod<<1]);
}
void query(int nod,int left,int right){
if(left>=start && right<=finish){
maxim=max(maxim,tree[nod]);
return ;
}
int mid=left+(right-left)/2;
if(start<=mid) query(nod<<1,left,mid);
if(finish>mid) query(nod<<1|1,mid+1,right);
}
vector<int>sol;
int main()
{
in>>n;
for(int i=1;i<=n;i++){
in>>v[i];
nr[i]=v[i];
}
sort(nr+1,nr+n+1);
 for(int i=1;i<=n;i++){
poz=cautare(v[i])-1;
if(!poz){
d[i]=1;
val=1;
update(1,1,n);
continue;
}
maxim=0;
finish=poz;
query(1,1,n);
val=maxim+1;
poz++;
d[i]=val;
update(1,1,n);
}
maxim=tree[1];
out<<maxim<<'\n';
for(int i=n;i>=1;i--)
if(d[i]==maxim){
sol.push_back(v[i]);
maxim--;
}
for(int i=sol.size()-1;i>=0;i--)
out<<sol[i]<<" ";
return 0;
}

//cel mai lung subsir comun

#include<bits/stdc++.h>
using namespace std;
ifstream fin("cmlsc.in");
ofstream fout("cmlsc.out");
int a[1025][1025],b[1025],c[1025],sub[1025];
int n,m,i,j,x=0;
int main()
{
fin>>n>>m;
for(i=1;i<=n;i++)
fin>>b[i];
for(j=1;j<=m;j++)
fin>>c[j];

for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
if(b[i]==c[j])
a[i][j]=a[i-1][j-1]+1;
else
a[i][j]=max(a[i-1][j] , a[i][j-1]);
}
}
i=n;
j=m;
while(a[i][j])
{
while(a[i][j]==a[i-1][j])
i--;
 while(a[i][j]==a[i][j-1])
j--;
x++;
sub[x]=b[i];
i--;
j--;
}
fout<<a[n][m]<<" ";
fout<<endl;
for(i=x;i>=1;i--)
fout<<sub[i]<<" ";
return 0;
}

//rucsac
#include <bits/stdc++.h>
#define maxn 5010
#define maxg 10010

using namespace std;

int w[maxn], p[maxn];

int optim[maxg];

ifstream f("rucsac.in");
ofstream gout("rucsac.out");

int main()
{
int n, g;
f>>n>>g;
for (int i=1; i<=n; i++){
f>>w[i]>>p[i];
}
optim[0]=0;
int sol=0;
for (int i=1; i<=n; i++){
for (int j=g-w[i]; j>=0; j--){
if (optim[j+w[i]]<optim[j]+p[i]){
optim[j+w[i]]=optim[j]+p[i];
if(optim[j+w[i]]>sol)
sol=optim[j+w[i]];
}
}
}
gout<<sol;
return 0;
}

//catalan
#include <bits/stdc++.h>

using namespace std;

int n;

long long catalanare(long long n){

if (n <= 1) return 1;
 long long rez = 0;
for(int i = 0; i < n; i++){
rez += catalanare(i) * catalanare(n-i-1);
}
return rez;
}

int main()
{
cin >> n;
cout << catalanare(n);
return 0;
}