균형 잡힌 라인업 (업데이트 간격 + 쿼리)

당신 길이 n, A [N] (50000 ≤ 1 ≤ N) 질의 q의 시퀀스를 제공하기 위해 (1 ≤ Q ≤ 200,000) 배 출력 [L, R] 최대 및 최소 간격의 차이이다.

너무 쉽게 ~

입력

케이스의 복수의 세트

두 정수 N, Q의 첫번째 행

그리고 N은이 [I] 1E9 미만으로 보장하기 [I]의 수는

각 Q는 다음 L에게 요청하고, R 보장하기 위해 그 (1 <= L <= R <= N)

산출

각 질의의 출력 [L을, R] 최대 및 최소 간격의 차이는 숫자

샘플 입력

샘플 출력

6 
3 
0

사용법 #include <iostream> 
#INCLUDE <알고리즘> 
#INCLUDE <cstdio> 
#INCLUDE < 문자열 > 
#INCLUDE <CString을> 
#INCLUDE <cstdlib> 
#INCLUDE <지도> 
#INCLUDE <벡터> 
#INCLUDE < 설정 > 
#INCLUDE <큐> 
#INCLUDE <적층> 
#INCLUDE <cmath> 
의 typedef 긴  긴 LL;
#DEFINE PQL priority_queue <LL>
 #DEFINE PQ priority_queue <INT>
 #DEFINE V 벡터 <INT>
#DEFINE의 LSON 지수 << 1,1- 중간
 #DEFINE의 rson 지수 << 1 | 1 중간 + 1, R의
 #DEFINE 판독 (X)는 scanf ( "%의 D ', X)
 #DEFINE lread (X)는 scanf (" %의 LLD ', X);
#DEFINE PT (X)의 printf ( "% D \ 없음"(X))
 #DEFINE 긍정의 printf ( "YES \ n을");
#DEFINE 없음의 printf ( "NO \ n을");
#DEFINE GCD __gcd
 #DEFINE CN CIN >>
 #DEFINE CT COUT <<
 #DEFINE의 ED << ENDL의
 #DEFINE의 담당자 (j, k)에 대한 (INT I = (INT) (j) 내가 <= (INT) (K ) 내가 ++)
 #DEFINE의 입력 (K)에 대해 INT (I = 1, ⅰ) = (INT) (K <를, 난 ++) {CIN >> A [I]; }
 #DEFINE의 MEM (S,
확인 반환 0;
#DEFINE는 수익을 다시;
#DEFINE TLE 표준 : IOS :: sync_with_stdio (거짓) cin.tie (NULL) cout.tie (NULL);
#DEFINE 개조 (X) ((X) % 9973)
 #DEFINE의 테스트 COUT << "++++++"<< ENDL;
#DEFINE의 LC 지수 << 1 개
 #DEFINE의 RC 지수 << 1 | 1
 사용  스페이스 성병;
CONST  INT MX = 1000005 ;
INT t, ANS, maxn = -MX 미네소타 = MX; 
타입 정의의 구조체 노드 
{ 
    int 형 발, L, R, MX, MN, 지연, 합; 
}마디; 
노드 DP [MX]; 
INT A [MX];
무효 (최대 INT인덱스) 
{ 
    DP [인덱스] .mx = 최대 (DP [LC] .mx, DP [RC] .mx); 
    DP [인덱스] .mn = 분 (DP [LC] .mn, DP [RC] .mn); 
} 
공극 빌드 ( INT의 인덱스, INT의 L, INT의 R) 
{ 
    DP [인덱스] 펜닐 = L; 
    DP [인덱스] .R = R;
    경우 (L == R) 
    { 
        DP [인덱스] .mx = A [L]; 
        DP [인덱스] .mn = A [L]; 
        레; 
    } 
    INT 중간 = (L + R) >> 1 ; 
    구축 (LC, L, 중간);
    구축 (RC, 중앙+ 1 , R); 
    최대 (인덱스); 
} 

공극 쿼리 ( INT의 인덱스, INT의 L, INT의 R) 
{ 
    // 경우 (DP [루트] .mx <= 미네소타 && DP [루트] .mi> = maxn) 재; 
    경우 (DP [인덱스] 펜닐> = 1 && DP [인덱스] .R <= R) 
    { 
        maxn = 최대 (DP [인덱스] .mx, maxn); 
        미네소타 = 분 (DP [인덱스] .mn 미네소타); 
        레; 
    } 
    INT 중간 = (DP [인덱스] 펜닐 + DP [인덱스] .R) >> 1 ;
    경우 (L <= MID) 
    { 
        쿼리 (LC, L, R); 
    }
    만약 (R> ENDL;중반) 
    { 
        쿼리 (RC, L, R); 
    } 

} 
INT 의 main () 
{ 
    TLE 단계; 
    INT의 N, K, LL, RR;
    반면 (CN 않음 >> K) 
    { 
        렙 ( 1 , N) CN이 [I]; 
        구축 ( 1 , 1 , N); 
        렙 ( 1 , k)는 
        { 
            maxn = - 1 , 미네소타 1E9 + = 5 ; 
            CIN >> LL >> RR; 
            쿼리 ( 1 , LL, RR); 
            COUT << maxn - 미네소타 << 
        }

 
    } 
    확인; 
}

균형 잡힌 라인업 (업데이트 간격 + 쿼리)

추천