적의 라인업 (트리 라인 단일 지점 업데이트 간격 + 쿼리)

라이벌 국가 C 국가의 지속적인 군사 훈련이 시간은, 국가의 스파이 수석 C 데릭과 그의 부하는 최대 바쁜 단정하기 시작했다. N 개의 엔지니어링 캠프의 라인을 따라 배열 된 국가의 해안선, 데릭하고 깔끔 작업이 엔지니어 캠프의 활동을 모니터하는 것입니다. 고급 모니터링 도구의 일종, 각각의 캠프 C 맑은 파악 미국에서 엔지니어의 수의 결과로, 각 캠프에서 엔지니어의 수는 직원의 수를 증가 시키거나 감소시킬 수있다, 변화를 발생할 가능성이 있습니다,하지만 그들은 C를 벗어날 수 없다 나라를 모니터링 할 수 있습니다.
바로 10 명 캠프의 총의 많은 사람들에게 처음 세 개의 캠프를보고, 깔끔한 "데릭 단정 한 보고서 등 데릭로 얼마나 많은 사람들의 총 요청 연속 엔지니어링 캠프의 일정 기간을 유지하기 때문에 CIA는 연습을 정확하게 적의 전술을 공부 ! "깔끔한 즉시이 단락 및 보고서의 총 수를 계산하기 시작합니다. 그러나, 데릭은 단정의 속도를 계산하기 위해 적의 캠프의 수는 자주 변경하고, 데릭은 각 세그먼트가, 단정 한이 캠프, 곧 소진의 숫자로 가야했다 그래서 매번 다른 질문 점점 불만 : 단정 한 생각을! "당신은 내가 당신에게 너무 느려 고려 죽은 지방 소년, 화재": "당신은 정말 당신이 너무 저를 해고하고자하는 피곤한 일이다 수학 자신을 수행! "절망에서, 단정는, 윈드, 윈드 도움 컴퓨터 전문가를 호출했다 말했다 :"죽은 지방 소년, 당신은 일반적으로 멀티 포인트 ACM 제목이라고 및 멀티 포인트 산술 책을 볼 수 있습니까, 지금의 쓴 열매를 맛 "깔끔한은" 나는 ... 실수를 인정 "하지만 윈드 브레이커는 전화를 끊었습니다. 그가 정말로 충돌을 계산합니다 있도록 깔끔한 매우 화가, 지능형 독자, 당신은 그 일을 마칠 수 있도록하는 프로그램을 작성할 수있다? 프로그램의 효율성이 충분히 높지 않은 경우에, 깔끔한 여전히 데릭의 야단됩니다.

입력 제 라인 정수 T, T 데이터 세트 나타냈다.
각각의 양의 정수 N (N <= 50000)의 제 1 라인의 데이터 N은 적의 캠프 엔지니어, N과 다음 양의 정수를 나타내는 i는 i 번째 AI 개시 공학 캠프를 나타내는 양의 정수 인공 지능 가지고있다 개인 (1 <= 인공 지능 <= 50 ).
: 다음에, 커맨드를 갖는 각각의 행은, 명령은 네 개의 형태를 갖는다
. (1), 추가의 IJ, 난 및 j는 양의 정수 캠프 증가 개인 J i 번째 (j는하게는 30 이상이다)이고
, (2) 서브 IJ I 및 J 이것은, 양의 정수 캠프 J의 개인 (j가 30를 초과하지 않는)를 감소 i 번째 나타내며,
(. 3)의 질의 IJ, i 및 j는 i가 J를 <=, 양의 정수이며, j 번째의 캠프로, i 번째의 총 개수를 묻는 나타낸다;
(4) 단부는 단부, 각 데이터 세트에 나타나는 마지막 명령을 나타내고,
40,000 명령 각각의 데이터까지의
데이터의 i 번째 그룹의 출력, 제 출력 "나는 케이스"를 입력,
각 쿼리 쿼리 출력 질의 세그먼트를 나타내는 정수 캐리지 리턴의 총 수는,이 번호는 INT 내에서 유지된다.
샘플 입력

1 
10 
1 2 3 4 5 6 7 8 9 10 
쿼리 1~3 
3~6 추가 
쿼리 2~7 
하위 10 2 
6 3 추가 
쿼리 3~10 

샘플 출력

사례 1 : 
6 
33 
59

사용법 #include <iostream> 
#INCLUDE <알고리즘> 
#INCLUDE <cstdio> 
#INCLUDE < 문자열 > 
#INCLUDE <CString을> 
#INCLUDE <cstdlib> 
#INCLUDE <지도> 
#INCLUDE <벡터> 
#INCLUDE < 설정 > 
#INCLUDE <큐> 
#INCLUDE <적층> 
#INCLUDE <cmath>
 사용  스페이스 성병;
#DEFINE PQ priority_queue <INT>
 #DEFINE PQL priority_queue <LL>
 #DEFINE pqn priority_queue <노드>
#DEFINE의 VL 벡터 <LL>
 #DEFINE의 LSON의 RT << 1, L, m
 #DEFINE의 rson의 RT << 1 | 1, m + 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 아웃 (X) COUT << X << ENDL;
#DEFINE COUT << ENDL 이상;
#DEFINE의 담당자 (j, K)에 대한 (; 나는 <= (INT) (K) 나 ++ 나 = (INT) (j) INT)
 #DEFINE의 입력 (K)에 대해 (ⅰ = 1 나타내는 int 난 = <(INT ) (K) 나 ++) {CIN >> A [I];
반환 재;
#define한다 확인 반환 0;
#DEFINE TLE 표준 : IOS :: sync_with_stdio (거짓) cin.tie (NULL) cout.tie (NULL);
#DEFINE 개조 (X) ((X) % 9973)
 #DEFINE의 테스트 COUT << "++++++"<< ENDL;
#DEFINE의 LS 지금 << 1
 #DEFINE RS 지금 << 1 | 1 
타입 정의  LL;
CONST의  INT의 N = 50000 + 5 ;
CONST의  INT의 maxn = 10000 + 5 ;
CONST  INT LEN = 2 * 1E5 + 5 ; 
타입 정의의 구조체  노드
{
     INT 브로, L, R, 합계 MX, MN, 지연;
    INT 미드 () {  (L + R) >> 1 ;} 
} 노드; 
노드 DP [LEN]; 
int로 A [N]을;
// 두 getlen (노드 XX 노드 YY) {창 ((XX.X yy.x -) * (XX.X-yy.x) + (- xx.y yy.y) * (xx.y-YY .Y)); } 

공극 Newmax ( INT 지금) 
{ 
    DP [현재] .mx = 최대 (DP [LS] .mx, DP [RS] .mx); 
    DP [현재] .mn = 분 (DP [LS] .mn, DP [RS] .mn); 
} 

공극 querymax ( int로 현재 의 INT (L) 의 INT R) 
{ 

} 

무효 uplazy (INT 지금) 
{ 
    경우 (DP [현재] .lazy) 
    { 
        DP [LS] .sum + DP = [현재] .lazy * (DP [LS] .R-DP [LS] 펜닐 + 1 ); 
        DP [RS] .sum + DP = [현재] .lazy * (DP [RS] .R-DP [RS] 펜닐 + 1 ); 
        DP [LS] .lazy + = DP [현재] .lazy; 
        DP [RS] .lazy + = DP [현재] .lazy; 
        DP [현재] .lazy = 0 ; 
    } 
} 
INT querysum ( INT 현재 의 INT (L) 의 INT R) 
{ 
    // 테스트; 
    경우 (DP [현재] 펜닐> = 1 && DP [현재] .R <= R) {반환 } DP [현재] .sum 
    (지금)를 uplazy; 
    INT CNT = 0 ;
    경우 (DP [현재] .MID ()> = R) 
        CNT + = querysum (LS, L, R);
    다른  경우 (DP [현재] .MID () < l) 
        CNT + = querysum (RS, L, R);
    
    { 
        // COUT << DP [현재] 펜닐 << ''<< (DP) [현재] .R << ''<< (DP) [현재] .MID () << ENDL; 
        INT 중간 = (DP [현재] 펜닐 + DP [현재] .R) >> 1 ; 
        CNT + = querysum (LS, L, MID); 
        CNT + = querysum (RS, 미드 + 1 , R); 
    } 
    // COUT << "
    반환 CNT를; 
} 
공극 upsum는 ( int로 지금) 
{ 
    DP [현재] .sum = DP [LS] .sum + DP [RS] .sum; 
} 
공극 빌드 ( int로 현재 의 INT (L) 의 INT R) 
{ 
    DP [현재] 펜닐 = 1; DP [현재] .R = R; DP [현재] .lazy = 0 ; DP [현재] .sum = 0 ;
    경우 (L == R) 
    { 
        // COUT << "현재"<< << R ''<< (DP) [현재] << .sum ENDL; 
        DP [현재] .sum = A [L]; 레; 

    } 
    INT 중간 = (L + R) >>
    (LS, L, 중간)를 구축; 
    구축 (RS,1 + 미드, R); 
    upsum (지금); 
} 
// 区间更新
공극 updata ( int로 현재 의 INT (L), INT (R), INT ANS) 
{ 
    경우 (DP [현재] 펜닐> = 1 && DP [현재] .R <= R) 
    { 
        DP [현재] .sum ANS + = * (DP [현재] .R-DP [현재] 펜닐 + 1 ); 
        레; 
    } 
    (지금) uplazy; 
    경우 (DP [현재] .MID ()> = R) 
        updata (LS, L, R, ANS); 
    다른  경우 (DP는 [현재] .MID () + 1 <=l) 
        updata (RS, L, R, ANS); 
    
    { 
        INT 중간 = DP [현재] .MID을 (); 
        updata (LS, L, 중간, ANS); 
        updata (RS, 미드 + 1 , R, ANS); 
    } 
    upsum (지금); 
} 
공극 upnode을 ( int로 현재 의 INT (L) 의 INT K) 
{ 
    경우 (DP [현재] 펜닐 == DP [현재] .R) 
    { 
        DP [현재] .sum + = K; 
        레; 
    } 
    INT 중간 = (DP [현재] 펜닐 + DP [현재] .R) >> 1 ;
    경우 (L <= MID)
        upnode (LS, L, K); 
    다른 
        upnode (RS, L, K);
    DP [현재] .sum = DP [LS] .sum + DP [RS] .sum; 
} 
INT 의 main () 
{ 
    TLE; 
    INT의 t, LL, RR, N;
    문자열 str을; 
    CIN >> t;
     ( INT KK = 1 ; KK <= t; KK ++ ) 
    { 
        COUT << " 케이스 " << KK << " : " << ENDL; 
        CIN >> N; 
        입력 (N); 
        구축 ( 1 , 1 , N);
        // 테스트; 
       동안(CIN >> STR && STR [ 0 ! = ' E ' ) 
       { 
           경우 (STR [ 0 ] == ' Q ' ) 
           { 
               CIN >> >> LL RR; 
               COUT << querysum ( 1 , LL, RR) << ENDL; 
           } 
           다른  경우 STR ([ 0 ] == ' ' ) 
           { 
               CIN >> >> LL RR;
                // updata (1, LL, RR, ANS); 1 , 
           } 
           다른  경우 STR ([ 0 ] == ' S ' ) 
           { 
               CIN >> >> LL RR; 
                upnode ( 1 , LL, - 1 * RR); 
           } 
       } 
    } 
    확인; 
}

 


추천

출처www.cnblogs.com/Shallow-dream/p/11458439.html