Untitled

#include <iostream>
#include <math.h>
#include <climits>
using namespace std;
 
int streamer[200005];
struct GROUP{
    int sum_subs;
    int max, min;
    int index_max, index_min;
} group[450];
int K;
 
void init(int N, int mSubscriber[]) {
    K = sqrt(N);
    int sum_group = 0;
    int max_group = INT_MIN;
    int min_group = INT_MAX;
    int id_min, id_max;
    for(int i = 0; i < N; i++){
        streamer[i] = mSubscriber[i];
        sum_group += streamer[i];
        if(streamer[i] > max_group){
            max_group = streamer[i];
            id_max = i;
        }
        if(streamer[i] < min_group){
            min_group = streamer[i];
            id_min = i;
        } 
        if((i + 1) % K == 0){
            group[i/K].sum_subs = sum_group;
            group[i/K].max = max_group;
            group[i/K].min = min_group;
            group[i/K].index_max = id_max;
            group[i/K].index_min = id_min;
            sum_group = 0;
            max_group = INT_MIN;
            min_group = INT_MAX;
        }
    }
    return;
}
 
int subscribe(int mId, int mNum) {
    int index = mId - 1;
    streamer[index] += mNum;
    int temp = index/K;
    group[temp].sum_subs += mNum;
    int max_group = INT_MIN;
    int min_group = INT_MAX;
    int start = temp * K;
    int end = start + K - 1;
    for(int i = start; i <= end; i++){
        if(streamer[i] > max_group){
            max_group = streamer[i];
            group[temp].max = max_group;
            group[temp].index_max = i;
        }
        if(streamer[i] < min_group){
            min_group = streamer[i];
            group[temp].min = min_group;
            group[temp].index_min = i;
        }
    }
    /*if(index == group[temp].index_max){
        group[temp].max = streamer[index];
    }
    else{
        if(streamer[index] > group[temp].max){
            group[temp].max = streamer[index];
            group[temp].index_max = index;
        }
    }*/
    return streamer[index];
}
 
int unsubscribe(int mId, int mNum) {
    int index = mId - 1;
    streamer[index] -= mNum;
    int temp = index/K;
    group[temp].sum_subs -= mNum;
    int max_group = INT_MIN;
    int min_group = INT_MAX;
    int start = temp * K;
    int end = start + K - 1;
    for(int i = start; i <= end; i++){
        if(streamer[i] > max_group){
            max_group = streamer[i];
            group[temp].max = max_group;
            group[temp].index_max = i;
        }
        if(streamer[i] < min_group){
            min_group = streamer[i];
            group[temp].min = min_group;
            group[temp].index_min = i;
        }
    }
    /*if(index == group[temp].index_min){
        group[temp].min = streamer[index];
    }
    else{
        if(streamer[index] < group[temp].min){
            group[temp].min = streamer[index];
            group[temp].index_min = index;
        }
    }*/
    return streamer[index];
}
 
int count(int sId, int eId) {
    int sum = 0;
    sId--; eId--;
    for(int i = sId; i <= eId; i++){
        if(i % K == 0 && i + K - 1 <= eId){
            sum += group[i/K].sum_subs;
            i = i + K - 1;
        }
        else sum += streamer[i];
    }
    return sum;
}
 
int calculate(int sId, int eId) {
    int maxi = 0;
    int mini = INT_MAX;
    sId--; eId--;
    for(int i = sId; i <= eId; i++){
        if(i % K == 0 && i + K - 1 <= eId){
            if(group[i/K].max > maxi) maxi = group[i/K].max;
            if(group[i/K].min < mini) mini = group[i/K].min;
            i = i + K - 1;
        }
        else{
            if(streamer[i] > maxi) maxi = streamer[i];
            if(streamer[i] < mini) mini = streamer[i];
        }
    }
    int answer = maxi - mini;
    return answer;
}