Merge pull request #311 from AlgorithmWithGod/ShinHeeEul

[20250415] BOJ / P5 / 개미 / 신희을

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;
+	}
+}
+
+```

ShinHeeEul/202504/15 BOJ P5 개미.md

@@ -0,0 +1,127 @@
+```java
+import java.util.*;
+
+public class Main {
+
+	static int N;
+	static int logN;
+	static Node[][] parents;
+	
+	static int[] ants;
+	
+	static ArrayList<Node>[] lists;
+	
+	public static void main(String[] args) throws Exception {
+    	
+		N = read();
+    	
+		ants = new int[N + 1];
+		logN = (int) (Math.log(N) / Math.log(2));
+		
+		lists = new ArrayList[N + 1];
+		
+		
+		parents = new Node[N + 1][logN + 1];
+		for(int i = 1; i <= N; i++) {
+			lists[i] = new ArrayList<>();
+			ants[i] = read();
+		}
+		
+		
+		for(int i = 1; i < N; i++) {
+			int a = read();
+			int b = read();
+			int c = read();
+			
+			lists[a].add(new Node(b, c));
+			lists[b].add(new Node(a, c));
+		}
+
+		dfs(1, 0);
+		parents[1][0] = new Node(0,0);
+//		for(int i = 1; i <= N; i++) {
+//			System.out.println(parents[i][0].index);
+//		}
+
+		for(int i = 1; i <= logN; i++) {
+			for(int j = 1; j <= N; j++) {
+				Node parent = parents[j][i-1];
+				if(parent == null) continue;
+				
+				Node node = parents[parent.index][i-1];
+				
+				if(node == null) continue;
+				
+				parents[j][i] = new Node(node.index, parent.value + node.value);
+			}
+		}
+		
+		
+		StringBuilder sb = new StringBuilder();
+		for(int i = 1; i <= N; i++) {
+			int ant = ants[i];
+			int room = i;
+			for(int j = logN; j >= 0; j--) {
+				if(parents[room][j] == null) continue;
+				
+				if(parents[room][j].value > ant) continue;
+				
+				ant -= parents[room][j].value;
+				room = parents[room][j].index;
+				
+			}
+			
+			sb.append(room == 0 ? 1 : room).append("\n");
+		}
+		
+		System.out.println(sb);
+		
+		
+    }
+	
+	public static void dfs(int node, int parent) {
+		
+		for(Node n : lists[node]) {
+			if(n.index == parent) continue;
+			parents[n.index][0] = new Node(node, n.value);
+			dfs(n.index, node);
+		}
+		
+	}
+	
+	private static class Node {
+		int index;
+		int value;
+		
+		public Node(int parent, int value) {
+			this.index = parent;
+			this.value = value;
+		}
+	}
+    
+    
+    
+    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;
+	}
+}
+
+```