Segment-Tree-First And Second Lowest Value

#include <iostream>
#include <vector>
#include <fstream>
#include <climits>
#include <algorithm>

#define INF INT_MAX
using namespace std;

const int DIM = 100;

/**
    Se da un vector de numere. Sa se afiseze cele mai mici 2 valori pe qurry de intervale.
    Permiteti update-ul de valori pe pozitii;

    Citire :
        N - nr elemente vector;
        N numere , reprezentand elementele vectorului.

        Querries - nr de querry;
        type - 1 querry , 2 update;
        type 1 - st, dr;
        type 2 - poz, valoare


    EX:

        8
        7 2 6 14 11 8 1 12

        5
        1 3 6
        1 1 3
        2 2 0
        2 3 1
        1 1 3
*/
class Pereche{
private:
    int min1;
    int min2;

public:
    Pereche(int val){
        min1 = val;
        min2 = INF;
    }

    int firstVal(){
        return min1;
    }
    int secondVal(){
        return min2;
    }
};

struct valoriMinime{
    int min1;
    int min2;
};

vector<Pereche> v;
vector<valoriMinime> tree(100);
int N;

valoriMinime FirstAndSecondMin( int x, int y , int a, int b ){
    vector < int > minVector;
    minVector.emplace_back(x);
    minVector.emplace_back(y);
    minVector.emplace_back(a);
    minVector.emplace_back(b);

    sort (minVector.begin() , minVector.end());

    valoriMinime toReturn;

    toReturn.min1 = minVector[0];
    toReturn.min2 = minVector[1];

    return toReturn;
}



void build( int tata, int st, int dr){
    if( st == dr ){
        tree[tata].min1 = v[st].firstVal();
        tree[tata].min2 = v[st].secondVal();
        return;
    }

    int mij = (st + dr) / 2;

    build( tata * 2 , st , mij );
    build( tata * 2 + 1,  mij + 1 , dr );

    valoriMinime minPair;
    minPair = FirstAndSecondMin(tree[tata*2].min1 , tree[tata*2].min2 , tree[tata*2+1].min1, tree[tata*2+1].min2);
    tree[tata].min1 =minPair.min1;
    tree[tata].min2 =minPair.min2;
}

void update(int tata, int st, int dr, int pos, int new_val){
  if ( st == dr )
  {
    tree[tata].min1 = new_val;
    tree[tata].min2 = INF;
    return;
  }
  int mij = ( st + dr ) / 2;
  if ( pos <= mij )
    update ( tata * 2, st , mij, pos ,new_val);
  else
    update ( tata * 2 + 1 , mij+ 1, dr, pos, new_val);

    valoriMinime minPair;
    minPair = FirstAndSecondMin(tree[tata*2].min1 , tree[tata*2].min2 , tree[tata*2+1].min1, tree[tata*2+1].min2);
    tree[tata].min1 =minPair.min1;
    tree[tata].min2 =minPair.min2;
}

valoriMinime querry( int tata , int x, int y, int st, int dr){
    if ( x <= st && y >= dr ){
        valoriMinime toReturn;
        toReturn.min1 = tree[tata].min1;
        toReturn.min2 = tree[tata].min2;
        return toReturn;
    }

    if ( y < st || x > dr ){
        valoriMinime toReturn;
        toReturn.min1 = INF;
        toReturn.min2 = INF;
        return toReturn;
    }

    int mij = ( st + dr) / 2;
    valoriMinime fs = querry(tata * 2, x, y, st, mij);
    valoriMinime fd = querry(tata * 2 + 1, x, y , mij+1, dr);

    valoriMinime result;
    result = FirstAndSecondMin(fs.min1, fs.min2, fd.min1, fd.min2);
    return result;

}



int main()
{
    ifstream f("date.in");
    f >> N;
    int x;
    for (int i = 0; i < N; i++) {
        f >> x;
        v.emplace_back(x);  // <- uses emplace_back.
    }
    build(1,0,N-1);

    int querries;
    f >> querries;
    valoriMinime res;
    int type;
    for ( int i = 0 ; i < querries ; ++i ){
        f >> type;
        if ( type == 1 ){
            int st, dr;
            f >> st >> dr;
            res = querry(1, st-1, dr-1, 0, N-1);
            cerr << res.min1 << " " << res.min2 << endl;
        }

        if ( type == 2 ){
            int poz, val;
            f >> poz >> val;
            update(1,0,N-1,poz-1,val);
        }
        if ( type != 1 && type != 2 )
            cerr << "Invalid type";

    }
}