CF-1323D Presente (+ pensamiento binario)

Significado de las preguntas: http://codeforces.com/problemset/problem/1323/D

Figura tema para entender

ideas:

En general este problema son la enumeración bit binario. Supongamos ahora que queremos conocer el k-ésimo bit 0/1, fácil saber, enumeramos AI, entonces 2 ^ (k-1) ~ 2 ^ k-1 y mayor que 2 ^ k + 2 ^ (k-1) de las respuestas se puede, por lo que nos preguntamos en el intervalo [i] -a gama en el número y Ai es el número de pares, así: si ai en el rango en que desea perder oh

El número total de / 2 es el número 1

#define IOS ios_base :: sync_with_stdio (0); cin.tie (0); 
#include <cstdio> // sprintf islower isupper 
#include <cstdlib> // malloc sistema salida strcat itoa ( "cls") 
# include <iostream> // par 
#include <fstream> // freopen ( "C: \\ Usuarios \\ 13.606 \\ escritorio \\ Entrada.txt", "r", la entrada estándar); 
# include <bitset> // #include <mapa>
 // #include <unordered_map> 
#include <vector> 
#include <pila> 
#include < set > 
#include < string .h>

#include < string > 
#include <time.h> // srand (((sin firmar) Tiempo (NULL))); Seed n = rand ()% 10 - 0 ~ 9; 
#include <cmath> 
#include <deque> 
#include <cola> // priority_queue <int, vector <int>, mayor <int>> q; // menos 
#include <vector> // emplace_back
 // #include <math.h> 
#include <cassert> 
#include <iomanip>
 // #include <windows.h> // inversa (a, a + len); // ~! ~! piso 
# include <algoritmo> //especie + único: sz = único (b + 1, b + n + 1) - (b + 1); + nth_element (primero, de orden n, último, comparar) 
usando  espacio de nombres std; // next_permutation (a + 1, a + 1 + n); // prev_permutation
 // ****************** 
clock_t __START, __ FIN;
doble __TOTALTIME;
void _MS () {__ START = reloj ();}
 vacío _Me () {__ FIN = reloj (); __ TOTALTIME = ( dobles ) (__ END -__ START) / CLOCKS_PER_SEC; cout << " Hora: " << __ totalTime << " s " << endl;}
 // *********************** 
#define rint registro int
 #definefo (a, b, c) para (Rint a = b; a <= c; ++ a)
 #define fr (a, b, c) para (rint a = b; a> = c; - a)
 #define mem (a, b) memset (a, b, sizeof (a))
 #define pr printf
 #define sc scanf
 #define ls rt << 1
 #define rs ta << 1 | 1 
par typedef < int , int > PII; 
typedef vector < int > VI; 
typedef unsigned largo  largo ULL; 
typedef largo  largo ll; 
typedef doble db;
const db E = 2.718281828 ;
const db PI = Acos (- 1,0 );
const ll INF = (1LL << 60 );
const  int inf = ( 1 << 30 );
const db ESP = 1E- 9 ;
const  int mod = ( int ) 1E9 + 7 ;
const  int N = ( int ) 1E6 + 10 ; 

int er [N];
int a [N], b [N];
int  get ( int n, int x) 
{ 
    int pos = 0 ;
    para( Int i = 19 ; i> = 1 ; - i) 
    { 
        si (pos + er [i] <= n && b [pos + er [i]] <= x) 
            pos + = er [i]; 
    } 
    Devolver pos; 
} 

Int main () 
{ 
    er [ 1 ] = 1 ;
    para ( int i = 2 ; i <= 30 ; ++ i) er [i] = er [i- 1 ] * 2 ;
    int n; 
    sc ( " % d " , y n);
    para ( inti = 1 ; i <= n; ++ i) sc ( " % d " , & a [i]);
//     _MS (); 
    int ans = 0 ;
    para ( int pos = 1 ; pos <= 25 ; ++ pos) 
    { 
        para ( int i = 1 ; i <= n; ++ i) b [i] = a [i] y (( 1 << pos) - 1 ); 
        sort (b + 1 , b + 1 + n); 
        ll res = 0 ;
        para ( int i = 1; i <= n; ++ i) 
        { 
            int ahora = b [i];
            int l1 = 1 << (posi- 1 ), R1 = ( 1 << pos) - 1 ;
            int L2 = ( 1 << (posi- 1 )) + ( 1 << pos); 
            l1 - = ahora, R1- = ahora; 
            L2 - = ahora;
            int CNT1 = get (n, r1) - get (n, L1- 1 );
            si (ahora> = l1 && ahora <= r1) cnt1-- ;
            int CNT2 = n-obtener (n, L2- 1 );
            si (ahora> = L2) cnt2-- ; 
            res + = CNT1 + CNT2; 
        } 
        Res / = 2 ;
        si (res y 1 ) American National Standard | = 1 << (posi- 1 ); 
    } 
    Pr ( " % d \ n " , ans);
//     _me (); 
    volver  0 ; 
} 

/ * *********************************************** ************************************* * /