[20250411] BOJ / P2 / 하늘에서 떨어지는 1, 2, ..., R-L+1개의 별 / 신희을

Author: ShinHeeEul

ShinHeeEul/202504/11 BOJ P2 하늘에서 떨어지는 1, 2, ..., R-L+1개의 별.md

@@ -0,0 +1,150 @@
+```java
+import java.util.*;
+
+public class Main {
+
+	static long[] segments;
+	static long[] lazy;
+	static int[] repl;
+	static long[] sum;
+	static int N;
+	static int size = 1;
+    public static void main(String[] args) throws Exception {
+    	N = read();
+    	
+    	StringBuilder sb = new StringBuilder();
+    	
+    	while(size < N) {
+    		size <<= 1;
+    	}
+    	
+    	sum = new long[100001];
+    	
+    	for(int i = 1; i < 100001; i++) sum[i] += sum[i-1] + i;
+    	
+    	
+    	segments = new long[(size << 1) + 1];
+    	lazy = new long[(size << 1) + 1];
+    	repl = new int[(size << 1) + 1];
+    	
+    	for(int i = size + 1; i < size + N + 1; i++) {
+    		segments[i] = read();
+    	}
+    	
+    	int segmentSize = size << 1;
+    	
+    	while(segmentSize > 1) {
+    		segments[(segmentSize >> 1)] = segments[segmentSize] + segments[segmentSize - 1];
+    		segmentSize -= 2;
+    	}
+    	
+//		for(int i = 0; i < segments.length; i++) {
+//			System.out.print(segments[i] + " ");
+//		}
+    	
+    	int M = read();
+    	
+    	while(M-->0) {
+    		int a = read();
+    		
+    		if(a == 1) {
+    			int l = read();
+    			int r = read();
+    			update(l, r, 2, 1, size);
+
+    		} else {
+    			int x = read();
+    			sb.append(query(x,x,2,1,size)).append("\n");
+    		}
+    	}
+    	
+    	System.out.println(sb);
+    	
+    }
+    
+    public static void updateLazy(int node, int num) {
+    	
+    	
+    	long val = lazy[node];
+    	long rep = repl[node];
+    	
+    	
+    	segments[node] += val;
+    	lazy[node] = 0;
+    	repl[node] = 0;
+    	if(node > size) return;
+    	
+    	//전파
+    	long a = (val - rep * (num * num)) >> 1;
+
+    	lazy[(node << 1) - 1] += a;
+    	repl[(node << 1) - 1] += rep;
+    	lazy[(node << 1)] += (val - a);
+    	repl[(node << 1)] += rep;
+    	
+    }
+    
+    public static void update(int left, int right, int node, int start, int end) {
+    	
+    	if(left > end || right < start) return;
+    	
+    	if(left <= start && end <= right) {
+    		// 1 - 8
+    		// 시작값 : start - left + 1
+    		// 끝값 : start - left + 1 + (end - start + 1)
+    		int startVal = start - left + 1;
+    		int num = (end - start + 1);
+    		int endVal = startVal + num;
+    		
+    		lazy[node] += sum[endVal - 1] - sum[startVal - 1];
+    		repl[node] += 1;
+    		updateLazy(node, num >> 1);
+    		return;
+    	}
+
+    	int mid = (start + end) >> 1;
+    	update(left, right, (node << 1) - 1, start, mid);
+    	update(left, right, node << 1, mid + 1, end);
+    }
+    
+    public static long query(int left, int right, int node, int start, int end) {
+    	
+    	if(lazy[node] != 0) updateLazy(node, (end - start + 1) >> 1);
+    	
+
+    	if(left > end || right < start) return 0L;
+    	
+    	if(left <= start && end <= right) {
+    		return segments[node];
+    	}
+    	
+    	int mid = (start + end) >> 1;
+    	return query(left, right, (node << 1) - 1, start, mid) + query(left, right, (node << 1), mid + 1, end);
+    }
+    
+    
+    
+    private static int read() throws Exception {
+	    int c;
+	    int n = 0;
+	    boolean negative = false;
+
+	    while ((c = System.in.read()) <= 32) {
+	        if (c == -1) return -1;
+	    }
+
+	    if (c == '-') {
+	        negative = true;
+	        c = System.in.read();
+	    }
+
+	    do {
+	        n = n * 10 + (c - '0');
+	        c = System.in.read();
+	    } while (c > 32);
+
+	    return negative ? -n : n;
+	}
+}
+
+```