1 Contest 1 troubleshoot.

txt 16 lines
if(left >= w[pos]) {
ans = max(ans, v[pos] + solve(pos+1, left-w[pos]));
Wrong answer: }
2 Dynamic Prog 1 - Formato de salida (falta un ’n’ o ’ ’).
- Debuggear el codigo con couts (sin fast input). vis[pos][left] = 1;
- Checkear si limpia memoria por cada test case. return dp[pos][left] = ans;
3 Data structures 3 }
Runtime error:
- Lectura fuera del vector.
4 Number theory 4 - Division entre 0.
int main(){
solve(0, C);
}
5 Graph 4 Time limit exceeded:
- Recursion infinita.
- Escribir la complejidad temporal.
6 Strings 9 KnapsackIter.h
Tips: Description: Knapsack iterativo.
- Trabajar en equipo (discutir ideas, revisar codigo, etc). Time: O (N ∗ C) c72d6b, 24 lines
7 Game theory 10 - Tomar un descanzo (ej. ir a los servicios higienicos). int n, C;
int v[N];
8 Various 10 int w[N];
Dynamic Prog (2)
// Memoria O(N)

Contest (1) 2.1 Fundamentals int solve(){

vector<int> last(C+1);
SumaRango.h vector<int> dp(C+1);
Description: Suma en rangos. for(int pos = n-1; pos >= 0; pos--){
template.cpp 19 lines Time: O (N ) for(int left = 0; left <= C; left++){
eda838, 22 lines
#include <bits/stdc++.h> int a[N];
using namespace std; int ans = last[left];
int dif[N]; if(left >= w[pos]){
typedef long long ll; ans = max(ans, v[pos] + last[left - w[pos]]);
int main(){ }
cin >> n >> q; dp[left] = ans;
void solve(){ for(int i = 1; i <= n; i++){ }
cin >> a[i]; last = dp;
} dif[i] = a[i] - a[i-1]; }
} return last[C];
int main() {
ios_base::sync_with_stdio(0); }
while(q--){ int main(){
cin.tie(0); int l, r, x; solve();
cin >> l >> r >> x; }
int tc = 1; dif[l] += x;
// cin >> tc ; dif[r+1] -= x;
while(tc--){ }
solve(); for(int i = 1; i <= n; i++) a[i] = dif[i] + a[i-1]; maxsubarray1D.h
} for(int i = 1; i <= n; i++){ Description: Terminando en ’i’.
} cout << a[i] << " "; Time: O (N ) fd4563, 21 lines
}
// memo[ i ] : Maxima suma de arreglo que termina en la posicion ’
return 0;
.bashrc 3 lines }
i ’.
// memo[ i ] : Toma solo a [ i ] o ( . . . , a [ i −1], a [ i ] )
alias c=’g++ -Wall -Wconversion -Wfatal-errors -g -std=c++14 \ // memo[ i ] : max(a [ i ] , a [ i ] + memo[ i −1])
-fsanitize=undefined,address’ KnapsackRec.h // memo[ i ] : a [ i ] + max(0 , memo[ i −1])
xmodmap -e ’clear lock’ -e ’keycode 66=less greater’ #caps = <> Description: Knapsack recursivo. const int N = 1e5 + 5;
Time: O (N ∗ C) 32b1af, 26 lines const int inf = 1e9;

.vimrc 6 lines
const int N = 1e2 + 5; // Limite de ”n”
int n;
const int W = 1e4 + 5; // Limite de capacidad
set cin aw ai is ts=4 sw=4 tm=50 nu noeb bg=dark ru cul int a[N];
int n, C;
sy on | im jk <esc> | im kj <esc> | no ; : int memo[N];
int v[N];
" Select region and then type :Hash to hash your selection. int w[N];
" Useful for verifying that there aren’t mistypes. int solve(){
ca Hash w !cpp -dD -P -fpreprocessed \| tr -d ’[:space:]’ \ for(int i = 0; i < n; i++){
// Memoria O(N∗C)
\| md5sum \| cut -c-6 if(i == 0) {
int dp[N][W];
memo[i] = a[i];
bool vis[N][W];
} else {
hash.sh memo[i] = max(a[i], a[i] + memo[i-1]);
3 lines int solve(int pos, int left){
}
if(pos == n) return 0;
# Hashes a file, ignoring all whitespace and comments. Use for }
if(vis[pos][left]) return dp[pos][left];
# verifying that code was correctly typed. return *max_element(memo, memo+n);
cpp -dD -P -fpreprocessed | tr -d ’[:space:]’| md5sum |cut -c-6 }
int ans = solve(pos+1, left);
plate .bashrc .vimrc hash troubleshoot SumaRango KnapsackRec KnapsackIter maxsubarray1D maxsubarray1Dprefix maxsubarray2D maxsubarray2Dprefix SumaStaticQuery LCS LCSfind
KTH 2
maxsubarray1Dprefix.h } }
Description: Diferencia de prfijos return memo[n][m];
Time: O (N ) db4a4e, 31 lines maxsubarray2Dprefix.h }
// S[ i ] = a [ 1 ] + . . . + a [ i ] Description:
F[i][j]: Suma hasta fila i de la columna j-
// suma( l , r ) = S[ r ] − S[ l −1] Time: O N 3 4e693e, 28 lines LCSfind.h
ll F[N][N]; Description:
Find the path.
// F[ i ] : Maxima suma de arreglo que termina en pos ’ i ’ Time: O N 2 4c3fb7, 33 lines
// F[ i ] : max(S[ r ] − S[ l −1]) donde 0 <= l < r void solve(){
// F[ i ] : S[ r ] + max(−S[ l −1]) donde S[ r ] se itera y max(−S[ l −1]) const int N = 100, M = 100, inf = 1e9;
// preprocesar int memo[N][N];
se procesa en marcha for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){ string solve(){
// S[ r ] : prefix F[i][j] = a[i][j];
// S[ l −1]: bestprefix for(int i = 1; i <= n; i++){
if(i) F[i][j] += F[i-1][j]; for(int j = 1; j <= m; j++){
const int N = 1e5 + 5; }
const int inf = 1e9; int cur = 0;
} // Cuidado con memo [−1]
// suma en 2D if(s[i-1] == t[j-1]) cur = max(cur, 1 + memo[i-1][j
int n; int ans = INT_MIN;
int a[N]; -1]);
for(int r1 = 0; r1 < n; r1++){ else cur = max(memo[i-1][j], memo[i][j-1]);
int memo[N]; for(int r2 = r1; r2 < n; r2++){
int prefix = 0, mini = 0; memo[i][j] = cur;
int solve(){ for(int i = 0; i < n; i++){
ll prefix = 0; }
int col = F[r2][i]; }
ll mini = 0; if(r1){
ll ans = -inf; col -= F[r1-1][i];
for(int i = 0; i < n; i++){ string ans = "";
} int i = n, j = m;
prefix += a[i]; prefix += col;
if(ans < prefix - mini){ while(i > 0 and j > 0){
if(ans < prefix - mini) ans = prefix - mini; if(s[i-1] == t[j-1]){
ans = prefix - mini; if(mini > prefix) mini = prefix;
} ans.push_back(s[i-1]);
} i -= 1;
if(mini > prefix){ // be s t p r e f ix para i+1 }
mini = prefix; j -= 1;
} } else {
} cout << ans;
} if(memo[i-1][j] > memo[i][j-1]){
} i -= 1;
return ans;
} } else {
SumaStaticQuery.h j -= 1;
Description: Query en un array estático. }
maxsubarray2D.h Time: O (N ) }
Description: S[i][j]: Suma hasta fila i, columna j. 6186d8, 14 lines
}
Time: O (N ) 769e50, 30 lines
int main(){ reverse(ans.begin(), ans.end());
for(int i = 0; i < n; i++){ return ans;
ll S[N][N]; cin >> a[i]; }
a[i] += (i-1 >= 0 ? a[i-1] : 0);
void solve(){ }
// preprocesar while(q--){ LCSfollow.h
for(int i = 0; i < n; i++){ int l, r; Description:
Follow the path.
for(int j = 0; j < n; j++){ cin >> l >> r; Time: O N 2
int suma = a[i][j]; ffa3d3, 41 lines
r--;
if(i) suma += S[i-1][j]; ll suma = a[r] - (l-1 >= 0 ? a[l-1] : 0); const int N = 100, M = 100, inf = 1e9;
if(j) suma += S[i][j-1]; cout << suma << "\n";
if(i and j) suma -= S[i-1][j-1]; } int memo[N][N];
S[i][j] = suma; return 0; int choice[N][N];
} }
} string solve(){
// suma en 2D for(int i = 1; i <= n; i++){
int ans = INT_MIN; 2.2 Subsequence for(int j = 1; j <= m; j++){
for(int r1 = 0; r1 < n; r1++){ LCS.h // Cuidado con memo [−1]
for(int r2 = r1; r2 < n; r2++){ Description: Longest Common Subsequence if(s[i-1] == t[j-1]) {
for(int c1 = 0; c1 < n; c1++){ Time: O (N ∗ C) memo[i][j] = 1 + memo[i-1][j-1];
for(int c2 = c1; c2 < n; c2++){ 300365, 12 lines choice[i][j] = 0;
int suma = S[r2][c2]; int solve(){ }
if(r1) suma -= S[r1-1][c2]; for(int i = 1; i <= n; i++){ else {
if(c1) suma -= S[r2][c1-1]; for(int j = 1; j <= m; j++){ if(memo[i-1][j] > memo[i][j-1]){
if(r1 and c1) suma += S[r1-1][c1-1]; int ans = 0; memo[i][j] = memo[i-1][j];
ans = max(ans, suma); // Cuidado con memo [−1] choice[i][j] = 1;
} if(s[i-1] == t[j-1]) ans = max(ans, 1 + memo[i-1][j } else {
} -1]); memo[i][j] = memo[i][j-1];
} else ans = max(memo[i-1][j], memo[i][j-1]); choice[i][j] = 2;
} memo[i][j] = ans; }
cout << ans; } }
KTH LIS SegmentTree FenwickTree MinQueue SQRT 3
} SegmentTree.h
} Description: Estructura de consulta y actualizacion en rangos. ST index- struct MinStack {
ado en 0, pero ’pos’ inicia en 1. stack<pair<int, int>> S;
string ans = ""; Time: O (log N ) void push(int x){
4fd1d0, 35 lines
int i = n, j = m; S.push(make_pair(x, min(x, S.empty() ? INT_MAX : S.top
while(i > 0 and j > 0){ const int N = 1e5 + 5; ().second)));
if(choice[i][j] == 0){ const int MAX = 4*N; }
ans.push_back(s[i-1]); ll st[MAX]; void pop(){
i -= 1; if(!S.empty()){
j -= 1; void build(int pos=1, int l=0, int r=n-1){ S.pop();
} else if(choice[i][j] == 1){ if(l == r){ }
i -= 1; st[pos] = a[l]; }
} else { } bool empty(){
j -= 1; int mi = (l+r)/2; return S.empty();
} build(2*pos, l, mi); }
} build(2*pos+1, mi+1, r); int top(){
reverse(ans.begin(), ans.end()); st[pos] = st[2*pos] + st[2*pos+1]; return S.empty() ? -1 : S.top().first;
return ans; } }
} int get_min(){
// x , y (query) return S.empty() ? -1 : S.top().second;
// l , r (subarray) }
LIS.h ll query(int x, int y, int pos, int l, int r){ };
Description: Longest Increasing Subsequence if(y < l or x > r) return 0;
Time: O (N ∗ logN ) if(l >= x and r <= y) return st[pos]; struct MinQueue{
ca343f, 41 lines int mi = (l+r)/2; MinStack in, out;
const int N = 100; ll left = query(x, y, 2*pos, l, mi); void push(int x){
int n; ll right = query(x, y, 2*pos+1, mi+1, r); in.push(x);
int a[N]; return left + right; }
vector<int> vec; } void pop(){
if(out.empty()){
void add(int left, int right, int val){ void update(int x, int y, int pos, int l, int r){ while(!in.empty()){
if(left == right){ if(l == r){ out.push(in.top());
if(vec[left] >= val){ st[pos] = y; in.pop();
vec[left] = val; return; }
} else { } }
vec.emplace_back(val); int mi = (l+r)/2; if(!out.empty()){
} if(x <= mi) update(x, y, 2*pos, l, mi); out.pop();
return; else update(x, y, 2*pos+1, mi+1, r); }
} st[pos] = st[2*pos] + st[2*pos+1]; }
int mid = (right - left)/2; } bool empty(){
return in.empty() and out.empty();
if(val <= vec[mid]){ }
add(left, mid, val);
FenwickTree.h int front(){
Description: Estructura de prefijo que permite modificaciones y consulta
} else { if(out.empty()){
en O(log N).
add(mid+1, right, val); while(!in.empty()){
Time: O (log N ) e2642f, 18 lines
} out.push(in.top());
} const int N = 1000000 + 5; in.pop();
void imprime_vector(){ ll ft[N]; }
for(int i = 0; i < vec.size(); i++){ }
cout << vec[i] << " "; void update(int pos, int val){ return out.empty() ? -1 : out.top();
} while(pos <= MAXI){ }
cout << "\n"; ft[pos] += val; int get_min(){
} pos += (pos & -pos); return min(in.empty() ? INT_MAX : in.get_min(),
int main(){ } out.empty() ? INT_MAX : out.get_min());
scanf("%d", &n); } }
for(int i = 0; i < n; i++) cin >> a[i]; } minqueue;
vec.push_back(a[0]); // i n i c i a l ll query(int pos){
ll res = 0;
for(int i = 1; i < n; i++){ while(pos > 0){ SQRT.h
add(0, vec.size()-1, a[i]); res += ft[pos]; Description:
√ Estructura
 de consulta y actualizacion en raices.
imprime_vector(); pos -= (pos & -pos); Time: O N
912018, 38 lines
} }
return res; // N,Q <= 1e5
cout << vec.size() << "\n"; } const int N = 1e5 + 5;
return 0; const int SQRT = 450;
}
MinQueue.h int n, q;
Description: Estructura de consulta en O(1) amortizado y actualización int a[N];
O(1). int bsize;
Data structures (3) Time: O (log N ) 5a7abe, 54 lines ll sum[SQRT];
KTH Primo FactoresPrimos Tdprimes Criba Euclides EuclidesExtended UniversalSink NumberPaths 4

void build(){ const int N = 100000000 + 1;

Graph (5)
for(int i = 0; i < n; i++){
sum[i / bsize] += a[i]; vector<int> primes;
} bitset<N> composite; 5.1 Fundamentals
}
int main() {
UniversalSink.h
ll query(int l, int r) { Description: Find universal sink interactivo.
ll res = 0; for(int i = 2; i < N; i++) { Time: O (3 ∗ N )
if(not composite[i]) primes.emplace_back(i); 23ce8d, 43 lines

while(l % bsize != 0 and l <= r){ for(int p : primes) { int main(){

res += a[l]; if(i * p >= N) break; int n;
l += 1; composite[i * p] = true; cin >> n;
} if(i % p == 0) break;
// l + bsize − 1 <= r } int j = 0;
while(l + bsize - 1 <= r){ } for(int i = 1; i < n; i++){
res += sum[l/bsize]; for(int i = 0; i < primes.size(); i += 100) printf("%d\n", cout << "? " << i+1 << " " << j+1 << "\n";
l += bsize; primes[i]); fflush(stdout);
} return 0; bool e;
while(l <= r){ } cin >> e;
res += a[l]; if(e){
l += 1; Criba.h continue;
} Description: Criba para hallar numeros primos. } else {
return res; Time: O (N ) j = i;
3be3f3, 11 lines }
}
void update(int pos, int val){ void solve(int n){ }
int idx = pos / bsize; vector<int> prime(n+1, true); int row = 0;
sum[idx] -= a[pos]; for(int i = 0; i < n; i++){
sum[idx] += val; for(int i = 2; i <= n; i++){ cout << "? " << i+1 << " " << j+1 << "\n";
a[pos] = val; if(prime[i]){ fflush(stdout);
} for(int j = i*2; j <= n; j += i){
prime[j] = false; bool e;
} cin >> e;
Number theory (4) }
}
}
row += e;

} int col = 0;
Primo.h for(int i = 0; i < n; i++){
Description: Verifica si un numero es primo. cout << "? " << j+1 << " " << i+1 << "\n";
Time: O (logN ) Euclides.h fflush(stdout);
2f50f9, 8 lines Description: Euclides para hallar mcd (gcd).
bool primo(int n){ Time: O (logN ) 21d9fc, 4 lines bool e;
for(int i = 2; i*i <= n; i++){
int gcd(int a, int b){ cin >> e;
if(n % i == 0){
if(a == 0) return b; col += e;
return 0;
return gcd(b % a, a); }
}
} if(row == n-1 && col == 0){
}
cout << "! " << j+1 << "\n";
return !;
fflush(stdout);
} EuclidesExtended.h } else {
Description: Euclides extendido ax + by = gcd(a, b) cout << "! " << -1 << "\n";
FactoresPrimos.h Time: O (logN ) 343534, 20 lines fflush(stdout);
Description:
√ Encuentra
 los factores primos. int gcdExtended(int a, int b, int *x, int *y){ }
Time: O N // Base case return 0;
7ade7a, 13 lines }
if(a == 0){
void solve(){ *x = 0;
for(int i = 2; 1ll*i*i <= n; i++){ *y = 1;
if(n % i == 0){ return b; NumberPaths.h
while(n % i == 0){ } Description: Encuentra el número de caminos con longitud l, para ello usa
cout << i << " "; int x1, y1; binary exponentation.
n /= i; int gcd = gcdExtended(b % a, a, &x1, &y1); Time: O (N ∗ N ∗ logN ) 1f59af, 54 lines
}
} const int MOD = 1e9 + 7;
*x = y1 - (b/a)*x1;
} *y = x1;
if(n > 1){ typedef vector<int> vi;
return gcd;
cout << n << "\n"; typedef vector<vector<int>> vvi;
}
}
} vvi multiply(vvi a, vvi b, int n){
int main(){
vvi c (n, vi(n));
int x, y;
// multiply
Tdprimes.h int gcd = gcdExtended(a, b, &x, &y);
for(int i = 0; i < n; i++){
Description: Encuentra los factores primos. cout << x << y << gcd;
for(int j = 0; j < n; j++){
Time: O (logN ) }
0bdcc4, 17 lines for(int k = 0; k < n; k++){
KTH BFS BFSfrontier Dijkstra BellmanFord 5
c[i][j] = (c[i][j] + 1ll * a[i][k] * b[k][j]) % dis[v] = dis[u] + 1; // O(ElogE)
MOD; vis[v] = 1; vector<ll> d(n, inf);
} Q.push(v); d[s] = 0;
} }
} } priority_queue<pair<ll, int>, vector<pair<ll, int>>,
return c; } greater<pair<ll, int>>> Q;
} Q.emplace(make_pair(0, s));
int main(){
vvi exp_power(vvi a, int n, int l){ cin >> n; while(!Q.empty()){
vvi result (n, vi(n)); for(int i = 0; i < n; i++){ int u;
// identity matrix int u, k; ll dis;
for(int i = 0; i < n; i++) result[i][i] = 1; cin >> u >> k; tie(dis, u) = Q.top();
u--; Q.pop();
while(l > 0){ for(int j = 0; j < k; j++){ if(dis != d[u]) continue;
if(l & 1){ int v;
result = multiply(result, a, n); cin >> v; //for (auto [ v , w] : G[u] ){ // Feature in C++ 17
} v--; for(auto pair : G[u]){
l /= 2; G[u].push_back(v); int v;
a = multiply(a, a, n); } ll w;
} } tie(v, w) = pair;
return result; bfs(0);
} for(int i = 0; i < n; i++){ if(d[v] > d[u]+ w){
cout << i+1 << " " << (dis[i] == inf ? -1 : dis[i]) << d[v] = d[u] + w;
int main(){ "\n"; Q.emplace(make_pair(d[v], v));
int n, l; } }
cin >> n >> l; return 0; }
vvi a(n, vi(n)); } }
for(int i = 0; i < n; i++){
for(int i = 0; i < n; i++){ printf("%lld%c", d[i], " \n"[i+1 == n]);
for(int j = 0; j < n; j++){ BFSfrontier.h }
cin >> a[i][j]; Description: Encuentra el camino màs corto de un nodo hacia los demas. }
} Todas las aristas tienen el mismo peso.
} Time: O (|V | + |E|) 120650, 26 lines int main(){
vvi al = exp_power(a, n, l); const int inf = 1e9 + 10; // Inout
// cout << ” r e s u l t matrix \n”; const int N = 1e5 + 5; G[u].emplace_back(make_pair(v, w));
// for ( int i = 0; i < n; i++){ G[v].emplace_back(make_pair(u, w));
// for ( int j = 0; j < n; j++){ vector<int> G[N]; // Process
// cout << al [ i ] [ j ] << ” ”; bool vis[N]; Dijsktra(0);
// } int dis[N]; }
// cout << ”\n”;
// } void bfs(int s){
cout << al[0][n-1]; for(int i = 0; i < n; i++) dis[s] = inf; BellmanFord.h
return 0; vector<int> front = {s}; Description: Calcula el camino más corto de s en un grafo, este puede tener
} dis[s] = 0; aristas negativas, pero no puede tener ciclos negativos.
vis[s] = 1; Time: O (V ∗ E) 340af8, 32 lines

BFS.h const int N = 100000 + 5;

while (!front.empty()){ const long long inf = 1e18 + 10;
Description: Encuentra el camino màs corto de un nodo hacia los demas. vector<int> cur;
Todas las aristas tienen el mismo peso.. int n, m;
for(int u : front){ long long d[N];
Time: O (|V | + |E|) 3be3b8, 45 lines for(int v : G[u]){ vector<tuple <int, int, int>> edges;
const int N = 1e2 + 5; if(vis[v]) continue;
const int inf = 1e9 + 5; dis[v] = dis[u] + 1; bool Bellman(int s){
vis[v] = 1; for(int i = 0; i < n; i++) d[i] = inf * (i != s);
int n; cur.push_back(v); int last = 0;
vector<int> G[N]; }
int dis[N]; } for(int i = 1; i <= n; i++){
bool vis[N]; swap(cur, front); bool relaxed = false;
} for(auto e : edges){
void bfs(int s){ } int u, v, w;
for(int u = 0; u < n; u++) dis[u] = inf; tie(u, v, w) = e;
queue<int> Q; Dijkstra.h if(d[u] < inf and d[v] > d[u] + w){
dis[s] = 0; Description: Distancia más corta de un nodo hacia los demas. No acepta d[v] = d[u] + w;
vis[s] = 1; aristas negativas. relaxed = true;
Q.push(s); Time: O (E ∗ logE) }
while (!Q.empty()){ f166fe, 42 lines }
int u = Q.front(); int n, m; if(not relaxed) break;
Q.pop(); vector<pair<int, int>> G[N]; last = i;
for(int v : G[u]){ }
if(vis[v]) continue; void Dijsktra(int s){
KTH FloydWarshall Kruskal Boruvka DFS 6
return last < n; } int x = nodes[u].back();
} nodes[u].pop_back();
void join(int u, int v) { nodes[v].emplace_back(x);
int main(){ u = comp[u]; comp[x] = v;
edges.emplace_back(make_tuple(u, v, w)); v = comp[v]; }
Bellman(0); if(nodes[u].size() > nodes[v].size()) swap(u, v); }
return 0; while(!nodes[u].empty()) {
} int x = nodes[u].back(); int main() {
nodes[u].pop_back(); scanf("%d %d", &n, &m);
nodes[v].emplace_back(x); for(int i = 0; i < m; i++) {
FloydWarshall.h comp[x] = v; int u, v, w;
Description: Calcula todos los caminos más cortos en un grafo dirigido que } scanf("%d %d %d", &u, &v, &w);
puede tener aristas de peso negativo. La entrada es una matriz n ∗ n donde } G[u].emplace_back(v, w);
indica los pesos

de las aristas, por otro lado, sino existe tiene valor inf. G[v].emplace_back(u, w);
Time: O N 3 a0559c, 37 lines int get_component(int x) { }
const int N = 1e2 + 5; return comp[x]; init();
const int inf = 2e9 + 10; } int ans = 0;
int n, m; vector<pair<int, int>> mst;
int d[N][N]; int main() { int comps = n;
cin >> n >> m; while(comps > 1) {
int main(){ vector<tuple<int, int, int>> edges; vector<tuple<int, int, int>> L;
cin >> n >> m; for(int i = 0; i < m; i++) { for(int i = 1; i <= n; i++) {
// preprocess int u, v, w; if(nodes[i].empty()) continue;
for(int i = 0; i < n; i++){ cin >> u >> v >> w; int best_cost = INT_MAX;
for(int j = 0; j < n; j++){ edges.push_back({w, u, v}); tuple<int, int, int> light_edge;
d[i][j] = i == j ? 0 : inf; } for(auto u : nodes[i]) {
} sort(edges.begin(), edges.end()); for(auto e : G[u]) {
} init(); int v, w;
// input int ans = 0; tie(v, w) = e;
for(int i = 0; i < m; i++){ vector<pair<int, int>> mst; if(comp[u] == comp[v]) continue;
int u, v, w; for(auto e : edges) { if(w < best_cost) {
cin >> u >> v >> w; int w, u, v; best_cost = w;
d[u][v] = min(d[u][v], w); tie(w, u, v) = e; light_edge = make_tuple(u, v, w);
} if(get_component(u) != get_component(v)) { }
// Floyd warshall ans += w; }
for(int k = 0; k < n; k++){ mst.emplace_back(u, v); }
for(int i = 0; i < n; i++){ join(u, v); L.emplace_back(light_edge);
for(int j = 0; j < n; j++){ } }
if(d[i][k] == inf or d[k][j] == inf) continue; } for(auto e : L) {
if(d[i][j] > d[i][k] + d[k][j]) d[i][j] = d[i][ cout << ans << "\n"; int u, v, w;
k] + d[k][j]; cout << n-1 << "\n"; tie(u, v, w) = e;
} for(auto e : mst) { if(comp[u] == comp[v]) continue;
} cout << e.first << " " << e.second << "\n"; comps -= 1;
} } join(u, v);
// Find negative cycle return 0; ans += w;
for(int i = 0; i < n; i++){ } mst.emplace_back(u, v);
if(d[i][i] < 0){ }
cout << "NEGATIVE CYCLE"; }
return 0; Boruvka.h printf("%d\n", ans);
} Description: Calcula el árbol de expansión minima (MST), usa la opti- printf("%d\n", n - 1);
} mización en rango (DSU). for(auto e : mst) {
return 0; Time: O (E ∗ logE) d6a6f8, 72 lines
printf("%d %d\n", e.first, e.second);
} }
int n, m; return 0;
int comp[N]; }
Kruskal.h vector<pair<int, int>> G[N];
Description: Calcula el árbol de expansión minima (MST), usa la opti- vector<int> nodes[N];
mización en rango (DSU).
5.2 DFS algorithms
Time: O (E ∗ logE) void init() { DFS.h
fbe3d7, 56 lines for(int i = 1; i <= n; i++) { Time: O (|V | + |E|) 706c0e, 36 lines
const int N = 200000 + 5; nodes[i].emplace_back(i);
int n, m; comp[i] = i; #pragma once
int comp[N]; } const int N = 1e5 + 5;
vector<int> nodes[N]; }
int n, m;
void init() { void join(int u, int v) { vector<int> G[N];
for(int i = 1; i <= n; i++) { u = comp[u]; int dis[N];
nodes[i].push_back(i); v = comp[v]; int vis[N];
comp[i] = i; if(nodes[u].size() > nodes[v].size()) swap(u, v); int par[N];
} while(!nodes[u].empty()) {