Livro azul como referência estudo, uma pilha de aprendizagem
Exemplo 1:
Para implementar um impulso pilha, suporte, Pop e GetMin (a menor pilha de consulta valor) (1) é completada em O
: Algoritmo Pensamento
mínimo de duas pilhas estabelecido, um armazenados dados originais, B guardados no fundo da pilha no início de cada pedaço de dados
O impulso (X), X em que A é inserido, é inserido min (dados B pilha, X) em B. GetMin só precisa executar saída B.top () pode
2 exemplos:
Entrada 8 I 2 I -1 I 1 Q 3 eu D R Q 2 Resultado 2 3
// topo do algoritmo de pilha
#include <bits / STDC ++. h>
using namespace std;
const int INF = -0x3F3F3F3F;
const int MAXN = 1000010;
// int s1 [MAXN];
// int s2 [MAXN];
soma int [MAXN]; // número de frente e x
int f [MAXN]; // O número máximo de pré consecutivo e x
int main () {
evento int;
while (scanf ( "% d", & CAS)! = EOF) {
memset (soma, 0, sizeof (soma));
memset (f, INF, sizeof f);
int pos1 = 0;
// int pos2 = 0;
pilha <int> s1;
pilha <int> s2;
enquanto (cas--) {
cordas;
s.resize (5);
scanf ( "% S", & s [0]);
if (s [0] == 'I') {
// cin >> S1 [++ pos1];
int temp;
scanf ( "% d", e temperatura);
// cout << 666 << "" << temperatura << endl;
s1.push (temp);
pos1 ++;
soma [pos1] = soma [pos1 - 1] + temperatura;
f [pos1] = max (f [pos1 - 1], soma [pos1]);
// cout << pos1 << "III" << f [pos1] << endl;
}
else if (s [0] == 'D') {
// pos1--;
se (s1.empty ())
continuar;
pos1--;
s1.pop ();
}
else if (s [0] == 'L') {
se (s1.empty ())
continuar;
// if (pos1! = 0) {
// s2 [++ pos2] = s1 [pos1--];
//}
pos1--;
int temp = s1.top ();
s1.pop ();
s2.push (temp);
}
else if (s [0] == 'R') {
if (s2.empty! ()) {
// s1 [++ pos1] = S2 [pos2--];
// soma [pos1] = soma [pos1 - 1] + S1 [pos1];
// f [pos1] = max (f [pos1 - 1], soma [pos1]);
int temp = s2.top ();
s2.pop ();
s1.push (temp);
pos1 ++;
soma [pos1] = soma [pos1 - 1] + temperatura;
f [pos1] = max (f [pos1 - 1], soma [pos1]);
}
}
else if (s [0] == 'Q') {
int x;
scanf ( "% d", & x);
printf ( "% d \ n", f [x]);
}
}
}
}
Exemplo três: o problema sequência e para fora da pilha
número catalã é definida utilizando a calculada C (2N, N) / (N + 1) número de cálculo teórico envolve o conhecimento.
#include <bits / STDC ++. h>
using namespace std;
#define abeto (i, a, b) para (int i = a; i <= b; i ++)
#define ll longa, longa
const LL M = 1E9; // M é o nível de pressão máxima de
ll uma [60004], l, soma [120004];
int n;
vazio Prime (int b, int f)
{
para (int j = 2, j * j <= && b b = 1 ;! j ++) // decomposição factor primo.
enquanto (b% J == 0)
{
soma [j] + = f;
b / = j;
}
se (b)
soma [b] + = f;
}
nula alta (II c)
{
para (int i = 1; i <= l; i ++)
um [i] * = c;
para (int i = 1; i <= l; i ++)
um [i + 1] + = uma [i] / M, a [i] = M%; posição // é necessário um processamento rápido comprimida
enquanto (a [l + 1])
++ l;
}
int main ()
{
a [1] = 1, l = 1;
scanf ( "% d", & N);
for (int i = 1; i <= n; i ++) // número de combinações para os dois divisão, temos que usar um método de decomposição fator primordial cabeça pergunta rápida, para lidar com eles.
Prime (n + i, 1);
para (int i = 2, i <= n + 1; i ++)
Prime (i, -1);
para (int i = 2, i <= 2 * n; i ++)
para (LL j = 0; j <soma [i]; j ++)
High (i); // Precision
printf ( "% LLD", um [l]);
para (ll i = L-1; i; - i)
printf ( "% 09lld", a [i]); // Output
return 0;
}
Exemplo IV:
PS: Eu tenho um outro estudo de investigação dia acima algoritmo == Onde está errado (a sensação de que o erro metafísica)
// // #include <bits / STDC ++. H>
// #include <cstdio>
// #include <algorithm>
// using namespace std;
// typedef long long ll;
// const int MAXN = 100010;
// ll um [MAXN];
// int main () {
// int n;
// while ((scanf ( "% d", & n)! = EOF) && n) {
// // memset (um, 0, sizeof um);
// para (int i = 0; i <n; i ++) {
// scanf ( "% lld", e a [i]);
//}
// ll p;
// uma [n + 1] = p = 0;
// ll s [MAXN]; ll w [MAXN];
// s [0] = uma [0];
// w [0] = 1;
// ll ans = 0;
// para (int i = 1; i <= n + 1; i ++) {
// se (a [i]> S [p]) {
// s [p ++] = uma [i];
// w [p] = 1;
//}
// outro {
// ll largura = 0;
// while (s [p]> a [i]) {
// w = largura + [P];
// ans = max (American National Standard, (ll) * largura s [P]);
// --P;
//}
// s [p ++] = uma [i];
// w [p] = largura + 1;
//}
//}
// printf ( "% ld \ n", ans);
//}
//}
#include <iostream>
#include <cstdio>
#include <pilha>
using namespace std;
typedef long long ll;
const ll Maxn = 1E6 + 5;
pilha <int> s;
int n, x;
preencher uma [Maxn], m, ans, Direita [Maxn], Esquerda [Maxn];
int main () {
enquanto (~ scanf ( "% d", & n), n) {
anos = 0;
um [0] = -1;
uma [n + 1] = -1;
para (ll i = 1; i <= n; i ++) {
scanf ( "% LLD", & a [i]);
}
while (s.empty! ()) {
s.pop ();
}
// da esquerda para a direita
s.push (0);
para (ll i = 1; i <= n; i ++) {
para (x = s.top (); a [x]> = a [i]; x = s.top ()) {
s.pop ();
}
Esquerda [i] = x + 1;
s.push (i);
}
while (s.empty! ()) {
s.pop ();
}
// direita para a esquerda
s.push (n + 1);
para (int i = n; i> 0; i--) {
para (x = s.top (); a [x]> = a [i]; x = s.top ()) {
s.pop ();
}
Direito [i] = x - 1;
s.push (i);
if ((direito [i] - Left [i] + 1) * a [i]> ans) {
ans = (Direito [i] - Esquerda [i] + 1) * a [i];
}
}
printf ( "% lld \ n", ans);
}
return 0;
}