間隔の離散セグメントツリー - 牛オフより多くの学校E

離散私チューン死者の範囲。。

全体的なベクターで離散化し、リーフノードは、メンテナンス間隔、各リーフノードレコード開始+長さによって定義されます

間違っていることはできません注意添字を払っています！

#include <ビット/ STDC ++ H>
 に#define MAXN 400005
 の#define INF 1000000000
 の#define MOD十億七
 の#define F最初
 の#defineが第2のS
 使用 名前空間STD。
typedefの長い 長いLL。
typedefのペア < int型、int型 > P;
int型N;
INT X [MAXN]、Y [MAXN]、L [MAXN]、R [MAXN]。
ベクトル < int型 > V。
INTのX1、X2、Y1、Y2、A1、A2、B1、B2、C1、C2、M1、M2。
構造体segtree 
{ 
    LL和[ 8* MAXN]。
    int型怠惰[ 8 * MAXN]、LEN [ 8 * MAXN];
    ボイド押し上げ（int型K）
    { 
        和[K] =和[K * 2 ] +和[K * 2 + 1 ]。
    } 
    ボイドプッシュダウン（int型K）
    { 
        場合（！怠惰[K]）のリターン;
        以下のために（int型 iは= K * 2、iは<= K * 2 + 1 ; iは++ ）
        { 
            怠惰[I] + = 怠惰[k]を、
            合計を[I] + =怠惰[K] * lenの[I]。
        } 
        怠惰[K] = 0 ;
        返します。
    } 
    ボイドビルド（int型 K、int型の L、INT R）
    { 
        場合（L == R）
        { 
            LEN [k]は、Vが= [L] -v [1- 1 ]。
            返します。
        } 
        INT半ば=（L + R）/ 2 。
        構築（K * 2、L、ミッド）。ビルド（K * 2 + 1、中間+ 1 、R）。
        突き上げ（K）。
        LEN [k]が LEN = [kは* 2 ] + LEN [K * 2 + 1 ]。
    } 
    ボイド更新（INT K、int型の L、int型の R、int型のx、int型のY）
    { 
        場合（X> R || L> y）をリターン。
        場合（L> = X && R <= Y）
        { 
            怠惰[K] ++ ; 
            和[K] + = LEN [K]。
            返します。
        } 
        プッシュダウン（K）。
        INT半ば=（L + R）/ 2。
        アップデート（K * 2、L、中、X、Y）アップデート（K * 2 + 1、中間+ 1 、R、X、Y）。
        突き上げ（K）。
    } 
    INTクエリ（INT K、int型の L、int型のR、LLのX）
    { 
        場合（L == R）
        { 
            int型 CNT =和[K] / LEN [K]。
            INTの ID =（X- 1）/ CNT。
            リターン V [1- 1 ] + ID。
        } 
        プッシュダウン（K）。
        INT半ば=（L + R）/ 2;
        もし（和[K * 2 ]> = X）リターンクエリ（K * 2、L、中、X）。他 戻りクエリ（K * 2 + 1、中間+ 1、R、X和[K * 2 ]）。
    } 
} SEG。
INT メイン（）
{ 
    scanf関数（" ％のD "、＆N）。
    scanf関数（" ％D％D％D％D％D％D "、＆​​X1、およびX2、＆A1＆B1、およびC1＆M1）。
    scanf関数（" ％D％D％D％D％D％D "、＆​​Y1＆Y2＆A2＆B2、およびC2、およびM2）。
    Xは、[ 1 ] X1を=。バツ[ ] X2を=。Y [ 1 ] = Y1。Y [ 2 ] = Y2。
    以下のために（int型 I = 3、N = iは<; iは++ ）
    { 
        X [i]は =（1LL * A1 * X [I- 1 ] + 1LL * B1 * X [I- 2 ] + C1）％M1。
        Y [I] =（1LL * A2 * Y [I- 1 ] + 1LL * B2 * Y [I- 2 ] + C2）％M2。
    } 
    のための（int型 I = 1を iが++; iが<= N ）
    { 
        L [I] =分（X [i]は、Y [I]）+ 1 。
        R [I] = MAX（X [i]は、Y [I]）+ 1。R [i]は++; 
        v.push_back（L [I]）。v.push_back（R [I]）。
    } 
    
    ソート（v.begin（）、v.end（））。
    v.erase（ユニーク（v.begin（）、v.end（））、v.end（））。

     ;INT SZ =（INT）v.size（） - 1 ; 
    seg.build（1、1 、SZ）。
    LL合計 = 0 ;
    用（int型 i = 1 ; iが<= N; iが++ ）
    { 
        int型 POSL = LOWER_BOUND（v.begin（）、v.end（）、L [I]） - v.begin（）。
        INT POSR = LOWER_BOUND（v.begin（）、v.end（）、R [I]） - v.begin（）。
        POSL ++ 
        seg.update（1、1 、SZ、POSL、POSR）。
        和 + = R [I] - L [i]は、
        printf（" ％d個の\ n "、seg.query（1、1、SZ、（和+ 1）/ 2 ））。
    } 
    戻り 0 。
}