Codeforces mondial Round 7 E. Bombes

  la pensée de la course ou le sentiment est pas très clair ah. Pour cette première question, course aux points a fait une erreur, un faux algorithme deviner le problème peut être en face de la question cf est relativement simple, il est facile de développer l'habitude de deviner la conclusion, ce titre est aussi le premier à deviner la conclusion fausse puis écrit une demi-heure wa une fois, je me sens une influence très l'effort prochain, la deuxième est l'idée du problème, je l'ai toujours considéré comme une solution itérative, mais je l'ai enfin je dois faire pour sortir de l'opération, et a carte il a vécu, en fait, il n'y a pas besoin de continuer à écrire et penser plus tard sont le temps des ordures, en fait, devrait être le lancement en temps opportun, penser à d'autres idées.

  La première est l'idée principale de ce problème, nous avons essayé la simulation, vous trouverez la réponse une fois avant et une fois après la réponse est difficile de transférer rapidement, bien que l'ajout d'une bombe, mais ne peut garantir que son impact ultérieur est après avoir réfléchi itération devrait réfléchir correctement sur les questions à abandonner. L'idée principale de ce problème est parce que la différence entre la réponse régressive, la réponse est généralement o (n), vous devez faire est de vérifier la réponse actuelle est susceptible de x, si vous pouvez rapidement juger de la faisabilité de cela, alors la complexité des problèmes viennent vers le bas.

  Comment déterminer si la réponse peut être x, x est plus grand que vous penseriez la réponse devrait être dynamitée, car il y aura un nombre supérieur à x, il existe un modèle:

    S'il est de vérifier d'abord du droit est supérieur à x, il a le droit d'au moins une bombe.

    S'il est de vérifier la deuxième à droite est supérieur à x, il a le droit d'au moins deux bombes.

    S'il est un tiers plus grand que le chèque du droit, il a le droit d'au moins trois bombes.

  Vous trouverez une telle chose, tout ce que vous avez à faire est de vérifier si les conditions sont remplies. Mais vous trouvez qu'il peut effectivement être itérative, condamné pour x faisables, et condamné à x-1 est itérative. Vous trouverez un emplacement, de la peine à peine si x x-1, il est beaucoup plus grand qu'un x-1 numérique et une bombe elle.

  Nous avons ouvert un arbre de segment, chaque emplacement de mémoire (x est supérieure à la partie droite du nombre actuel - le nombre de bombes à droite), est inférieure à 0, la réponse dont vous avez besoin moins 1, et aucune mise à jour de fuseau horaire très bien.

#include <iostream> 
#include < string > 
#include < string .h>
 #define lson rt << 1
 #define rson rt << 1 | 1
 en utilisant l'  espace de noms std; 
typedef longue  longue ll; 
typedef paire < int , int > P;
const  int maxn = 3e5 + 10 ;
int arbre [maxn << 2 ], [maxn << paresseux 2 ], a [maxn], p [maxn], tong [maxn];
vide pushdown ( int rt) 
{ 
    arbre [lson]+ = Paresseux [rt]; 
    Arbre [rson] + = paresseux [rt]; 
    paresseux [lson] + = paresseux [rt]; 
    paresseux [rson] + = paresseux [rt]; 
    paresseux [rt] = 0 ; 
} 
Vide enfoncement ( int rt) 
{ 
    arbre [rt] = max (arbre [lson], arbre [rson]); 
} 
Vide mise à jour ( int L, int R, int x, int l, int r, int rt) 
{ 
    si (L <= l && r <= R) 
    { 
        arbre [rt] + =X; 
        paresseux [rt] + = x;
        retour ; 
    } 
    Pushdown (rt); 
    int mi = (l + r) / 2 ;
    si (L <= mi) 
        mise à jour (L, R, X, L, milieu, lson); 
    si (mi < R) 
        mise à jour (L, R, x, mi + 1 , r, rson); 
    PushUp (rt); 
} 
Int q ( int L, int R, int l, int r, int rt) 
{ 
    pushdown (rt); 
    si (L <= l && r <= R) 
    { 
        retourarbre [rt]; 
    } 
    Int mi = (l + r) / 2 ;
    int ans = 0 ;
    si (L <= mi) 
        ans = max (ans, q (L, R, L, milieu, lson));
    si (mi < R) 
        ans = max (ans, q (L, R, mi + 1 , r, rson));
    retourner ans; 
} En 
ligne int lowbit ( int x) {
     retour x & (- x); 
} 
Int n;
int main () 
{ 
    cin >> n;
    pour (int i = 1 ; i <= n; i ++ ) { 
        cin >> a [i]; 
        tong [a [i]] = i; 
    } 
    Pour ( int i = 1 ; i <= n; i ++ ) 
        cin >> p [i];
    int maintenant = n; 
    mise à jour ( 1 , tong [n], 1 , 1 , n, 1 );
    pour ( int i = 1 ; i <= n; i ++ ) 
    { 
        Cout << maintenant << "  " ;
        si(i == n)
             break ; 
        mise à jour ( 1 , p [i], - 1 , 1 , n, 1 );
        tandis que (q ( 1 , n, 1 , n, 1 ) <= 0 ) 
        { 
            maintenant - ; 
            mise à jour ( 1 , tong [maintenant], 1 , 1 , n, 1 ); 
        } 
    } 
    
}

 

Je suppose que tu aimes

Origine www.cnblogs.com/King-of-Dark/p/12538621.html
conseillé
Classement