NOIP2016Day2T2 lombriz informe de resolución de problemas

Ver el título original Luo Valley ( https://www.luogu.org/problem/show?pid=2827 )
De hecho, esta cuestión de las características de los datos escritos en gran detalle personalmente creo que esta cuestión incluso la violencia pura también puede obtener 25 puntos. Aquí segmento I para explicar los puntos a esta pregunta:
[25 minutos]
En primer lugar nos fijamos en el punto de datos en el rango de 1.2.3 m = 0 nos encontramos con datos que se emite directamente por tema la misma manera, el punto 4.6 n = 1 simulación de violencia también directa como, hacer código específico no escribir ......
[65-85 minutos]
nuestro primer pensamiento es para mantener la longitud de la pila todas las lombrices de tierra, ¿cómo funciona: cada vez que hemos eliminado del montón la lombriz de tierra más larga, lo puso en el montón después del corte.
Entonces surge la pregunta: ¿ cada vez que hacemos cómo la longitud de las lombrices otras lombrices aumentar q?
Podemos hacerlo, con un registro actual de cada complemento para las lombrices debe aumentar la cantidad de tiempo para explicar cuando hemos llegado al final de todas m de corte, entonces teóricamente cada lombrices de tierra han aumentado Agregar = q * m de longitud. Pero cuando tenemos que cortar una lombriz de tierra, no está permitido lombrices longitud de este aumento, y cómo podemos manejarlo? Restamos q presiona en la pila en el que a lo largo de las lombrices de tierra después del corte, podemos utilizar el montón de la mano y la entrada y la salida rápida para que el programa funcione más rápido. Cuando se utiliza la plantilla STL T priority_queue caerá en algún momento, estoy aquí y entrada y salida de mano-play pila puntuación optimizada de 85 puntos, a continuación, la complejidad de tiempo del algoritmo es sobre O ((n + m) log (n + m)) código es el siguiente:

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>

using namespace std;
const int N = 1e5 + 5, M = 7e6 + 5;
int n, m, q, u, v, t, Add;
double p;

struct BigRt
{
    int g[N + M], l;

    inline void Pop()
    {
        g[1] = g[l--];
        int now = 1, nxt = 2, res = g[1];
        while (nxt <= l)
        {
            if (nxt < l && g[nxt | 1] > g[nxt]) 
            nxt |= 1;
            if (res < g[nxt])
             g[now] = g[nxt], nxt = (now = nxt) << 1;
            else break;
        }
        g[now] = res;
    }

    inline void Push(const int &res)
    {
        g[++l] = res;
        int now = l, nxt = l >> 1;
        while (nxt)
        {
            if (res > g[nxt])
             g[now] = g[nxt], nxt = (now = nxt) >> 1;
            else break;
        }
        g[now] = res;
    }
}Q;

inline int get()
{
    char ch; int res = 0; bool f = true;
    while (((ch = getchar()) < '0' || ch > '9') && ch != '-');
    if (ch == '-') f = false; 
     else res = ch - '0';
    while ((ch = getchar()) >= '0' && ch <= '9')
     res = (res << 3) + (res << 1) + ch - '0';
    return f? res : -res;
}

inline void put(int x)
{
    if (x < 0)
     x = -x, putchar('-'); 
    if (x > 9) put(x / 10);
    putchar(x % 10 + 48); 
}

inline bool cmp(const int &x, const int &y) {return x > y;}

int main()
{
    n = get(); m = get(); q = get(); 
    u = get(); v = get(); t = get();
    p = (double)u / v; Q.l = 0;
    for (int i = 1; i <= n; ++i) Q.Push(get());
    for (int i = 1; i <= m; ++i)
    {
        int x = Q.g[1] + Add; Q.Pop(); 
         if (i % t == 0) put(x), putchar(' '); 
        int l = (int)(p * x), r = x - l; 
        Q.Push(l - Add - q); Q.Push(r - Add - q);
        Add += q; 
   (i % t == 0) put(Q.g[1] + Add), putchar(' ');
        Q.Pop();    
    }
}

[100]
Ahora podemos mejorarlo, por lo que
pensamos, si tuviéramos dos lombrices lombrices de tierra a L1, después de la división se establece en L2, L3, entonces tiene que haber L2 <= L1, L3 <= l1 está claramente establecido entonces podemos definir tres colas comunes representan las lombrices de tierra sin cortar q1, cortando a través del medio q2 izquierda, son corte a través de un medio de Q3, q1 cuando se introducen los datos, el orden descendente, cada uno a cortar al retirar la primera escuadra de tres colas después del corte máximo como los segmentos de corte se presionan en la derecha y q2 izquierda, q3 de la cola y otras formas con el mismo tratamiento montón, a continuación, la complejidad de tiempo algoritmo es O (n + m ), está claro mucho más rápido, con un tiempo total de 1528ms

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>

using namespace std;
typedef long long ll;
const int Maxn = 2147483647;
const int N = 1e5 + 5, M = 7e6 + 5;
int n, m, q, u, v, t, Add;
int Q[3][M], qt[3], qw[3]; 

inline int get()
{
    char ch; int res;
    while ((ch = getchar()) < '0' || ch > '9');
    res = ch - '0';
    while ((ch = getchar()) >= '0' && ch <= '9')
     res = (res << 3) + (res << 1) + ch - '0';
    return res;
}

inline void put(int x)
{ 
    if (x > 9) put(x / 10);
    putchar(x % 10 + 48); 
}

inline bool cmp(const int &x, const int &y) {return x > y;}

inline int GetMax()
{
    int res = -Maxn, k;
    for (int i = 0; i < 3; ++i)
     if (qt[i] < qw[i] && res < Q[i][qt[i] + 1])
      res = Q[i][qt[i] + 1], k = i;
    qt[k]++; return res;
}

int main()
{
    n = get(); m = get(); q = get(); 
    u = get(); v = get(); t = get();
    for (int i = 1; i <= n; ++i) Q[0][++qw[0]] = get(); 
    sort(Q[0] + 1, Q[0] + qw[0] + 1, cmp);
    for (int i = 1; i <= m; ++i)
    {
        int x = GetMax() + Add;
         if (i % t == 0) put(x), putchar(i + t > m ? '\n' : ' '); 
        int l = (ll)x * u / v, r = x - l; 
        Q[1][++qw[1]] = l - Add - q;
        Q[2][++qw[2]] = r - Add - q; Add += q; 
    }
    if (t > m) putchar('\n');
    int tmp = n + m;
    for (int i = 1; i <= tmp; ++i)
    {
        int x = GetMax() + Add;
         if (i % t == 0) {put(x); if (i + t <= tmp) putchar(' ');}
    }
    return 0;
}