Apilar algoritmo de aprendizaje _

Libro azul como una referencia del estudio, una pila de aprendizaje

Ejemplo 1:

Para implementar una pila de empuje, soporte, Pop y getMin (el valor de la consulta pila más pequeña) (1) se completa en O

: Pensamiento algoritmo
mínimo de dos pilas establecida, almacenados datos originales, B almacenados en la parte inferior de la pila en el comienzo de cada pieza de datos

El empuje (X), se inserta X en A, se inserta min (datos B pila, X) en B. GetMin sólo es necesario para realizar la salida B.top () puede

2 ejemplos:

 

 

Introducir 
8 
I 2 
I -1 
I 1 
Q 3 
L 
D 
R 
Q 2 
de salida 
2 
3

 

Parte superior de la pila algoritmo // 
#include <bits / STDC ++ H.> 
El uso de STD espacio de nombres; 
const int = INF -0x3F3F3F3F; 
const int MAXN = 1000010; 
// int S1 [MAXN]; 
// int S2 [MAXN]; 
int SUM [MAXN]; // número x antes y 
int f [MAXN]; // número máximo de frente sucesiva y x 
int main () { 
    int CAS; 
    ! el tiempo (Scanf ( "% D", & CAS) el EOF = ) { 
        Memset (SUM, 0, el sizeof (SUM)); 
        Memset (F, INF, el sizeof F); 
        int POS1 = 0; 
        // int POS2 = 0; 
        Stack <int> S1; 
        Stack <int> S2; 
        el tiempo ( cas--) { 
            cadena S; 
            s.resize (5);. 
            Scanf ( "% S", & S [0]); 
            IF (S [0] == 'YO') {
                // cin >> s1 [++ pos1]; 
                temp int; 
                scanf ( "% d", y temp); 
                // cout << 666 << "" << temp << endl; 
                s1.push (temp); 
                pos1 ++; 
                suma [pos1] = suma [pos1 - 1] + temp; 
                f [pos1] = max (f [pos1 - 1], sum [pos1]); 
                // cout << pos1 << "III" << f [pos1] << endl; 
            } 
            Else if (s [0] == 'D') { 
                // pos1--; 
                si (s1.empty ()) 
                    continuar; 
                pos1--; 
                s1.pop (); 
            } 
                Si (s1. 
                // si (pos1 = 0) { 
                // s2 [++ pos2] = s1 [pos1--]; 
                //} 
                pos1--; 
                = int temp s1.top (); 
                s1.pop (); 
                s2.push (temp); 
            } 
            Else if (s [0] == 'R') { 
                si {(s2.empty ()!) 
                    // s1 [++ pos1] = s2 [pos2--]; 
                    // suma [pos1] = suma [pos1 - 1] + s1 [pos1]; 
                    // f [pos1] = max (f [pos1 - 1], sum [pos1]); 
                    = int temp s2.top (); 
                    s2.pop (); 
                    s1.push (temp);
                    pos1 ++; 
                    suma [pos1] = suma [pos1 - 1] + temp;
                    f [pos1] = max (f [pos1 - 1], sum [pos1]); 
                } 
            } 
            Else if (s [0] == 'Q') { 
                int x; 
                scanf ( "% d", y x); 
                printf ( "% d \ n", f [x]); 
            } 
        } 
    } 
}

 Ejemplo tres: el problema de secuencia y fuera de la pila

 

 número catalán se define utilizando la C calculado (2 N, N) / (N + 1) Número de cálculo teórico implica el conocimiento.

#include <bits / STDC ++ h.> 
using namespace std; 
abeto #define (i, a, b) for (int i = a; i <= b; i ++) 
#define ll largo largo 
const ll M = 1e9; // M为压位的最大值
ll un [60004], l, sum [120,004]; 
int n; 
void Prime (int b, int f) 
{ 
    for (int j = 2; j * j <= b && b = 1;! j ++) //质因数分解. 
        mientras que (b% j == 0) 
        { 
            suma [j] + = f; 
            b / = j; 
        } 
    Si (b) 
        la suma [b] + = f; 
} 
Void alta (ll c) 
{ 
    for (int i = 1; i <= l; i ++) 
        a [i] * = c; 
    for (int i = 1; i <= l; i ++) 
        a [i + 1] + = a [i] / M, a [i]% = M; //我们需要压缩位置快速处理
    mientras que (a [l 1])  
        ++ l;
} 
Int main () 
{ 
    A = 1, L = 1 [1.];.. 
    Scanf ( "% D", y n-); 
    for (int i = 1;. I <= N-; I ++) // número de combinaciones para los dos divididos , Esta pregunta que tenemos que utilizar un método del factor de rápida descomposición de primera, de tratar. 
        Prime (n-I + ,. 1); 
    for (int i = 2; I <= n + 1;. I ++) 
        Primer (I, 1); 
    for (int i = 2; I <= n-2 *; i ++) 
        para (LL J = 0; J <SUM [I]; J ++) 
            alta (I); // precisión 
    printf ( "% LLD", a [L]); 
    for (i = L-LL 1; I; -. I) 
        el printf ( "% 09lld", a [I]); // salida 
    return 0; 
}

 Ejemplo IV:

 

PS: Tengo otro estudio de investigación el día anterior algoritmo == ¿Dónde está mal (la sensación de que el error de la metafísica)

 

// // #include <bits / STDC ++ h.> 
// #include <cstdio> 
// #include <algoritmo> 
// using namespace std; 
// typedef largo largo ll; 
// const int MAXN = 100.010; 
// ll un [MAXN]; 
// int main () { 
// int n; 
// while ((scanf ( "% d", y n) = EOF) && n!) { 
// // memset (a, 0, sizeof a); 
// for (int i = 0; i <n; ++ i) { 
// scanf ( "% LLD", & a [i]); 
//} 
// ll p; 
// a [n + 1] = p = 0; 
// ll s [MAXN]; ll w [MAXN]; 
// s [0] = a [0]; 
// w [0] = 1; 
        
// ll ans = 0; 
// for (int i = 1; i <= n + 1;
// si (a [i]> S [p]) { 
// s [++ p] = a [i]; 
// w [p] = 1; 
//} 
// else { 
// ll width = 0; 
// while (s [P]> a [i]) { 
// anchura + = w [p]; 
// ans = max (ans, (ll) width * s [P]); 
// --pag; 
//} 
// s [++ p] = a [i]; 
// w [p] = ancho + 1; 
//} 
//}   
// printf ( "% ld \ n", ans); 
//} 
//} 
# include <iostream> 
#include <cstdio> 
#include <pila> 
using namespace std; 
 
typedef largo largo ll;
 
const ll Maxn = 1E6 + 5; 
 
pila <int> s; 
int n, x; 
CL a [Maxn], m, ans, Derecha [Maxn], Izquierda [Maxn]; 
 
int main () { 
    while (~ scanf ( "% d", y n), n) { 
        ans = 0; 
        a [0] = -1; 
        un [n + 1] = -1; 
        para (ll i = 1; i <= n; i ++) { 
            scanf ( "% LLD", & a [i]); 
        } 
        While (s.empty ()) { 
            s.pop (); 
        } 
        //从左向右
        s.push (0); 
        para (ll i = 1; i <= n; i ++) { 
            for (x = s.top (); una [x]> = a [i]; x = s.top ()) { 
                s.pop () ; 
            }
            Izquierda [i] = x + 1; 
            s.push (i);
        } 
 
        While (s.empty ()) { 
            s.pop (); 
        } 
        //从右至左
        s.push (n + 1); 
        for (int i = n; i> 0; i--) { 
            for (x = s.top (); una [x]> = a [i]; x = s.top ()) { 
                s.pop ( ); 
            } 
            Derecha [i] = x - 1; 
            s.push (i); 
            if ((Derecha [i] - Izquierda [i] + 1) * a [i]> ans) { 
                ans = (Derecha [i] - Izquierda [i] + 1) * a [i]; 
            } 
        } 
 
        Printf ( "% LLD \ n", ans); 
 
    } 
    Return 0; 
}

 

Supongo que te gusta

Origin www.cnblogs.com/lightac/p/12571165.html
Recomendado
Clasificación