Merge pull request #3088 from 876pol/cf-1529c-java

update cf-1528A.mdx

Author: SansPapyrus683

solutions/cf-1528A.mdx

@@ -83,13 +83,13 @@ long long mx_beauty(int u, int v, bool type) {
 	}
 }
 
-void dfs(int u, int par) {
+void calculate_dp(int u, int par) {
 	for (int v : adj[u]) {
 		if (v == par) {
 			continue;
 		}
 
-		dfs(v, u);
+		calculate_dp(v, u);
 		dp[u][0] += mx_beauty(u, v, 0);
 		dp[u][1] += mx_beauty(u, v, 1);
 	}
@@ -126,11 +126,92 @@ int main() {
 			adj[v].push_back(u);
 		}
 
-		dfs(0, -1);
+		calculate_dp(0, -1);
 
 		cout << std::max(dp[0][0], dp[0][1]) << endl;
 	}
 }
 ```
 </CPPSection>
+
+<JavaSection>
+```java
+import java.io.*;
+import java.util.*;
+
+public class ParsasHumongousTree {
+	private static List<List<Integer>> adj = new ArrayList<>();
+	private static int[] l, r;
+	private static long[][] dp;
+
+	public static void main(String[] args) {
+	    Kattio io = new Kattio();
+		int t = io.nextInt();
+
+		for (int tc = 0; tc < t; tc++) {
+			int n = io.nextInt();
+
+			l = new int[n + 1];
+			r = new int[n + 1];
+			dp = new long[n + 1][2];
+			adj.clear();
+
+			for (int i = 1; i <= n; i++) {
+				l[i] = io.nextInt();
+				r[i] = io.nextInt();
+			}
+
+			for (int i = 0; i <= n; i++) {
+				adj.add(new ArrayList<>());
+			}
+
+			for (int i = 0; i < n - 1; i++) {
+				int u = io.nextInt(), v = io.nextInt();
+				adj.get(u).add(v);
+				adj.get(v).add(u);
+			}
+
+			calculateDP(1, -1);
+
+			io.println(Math.max(dp[1][0], dp[1][1]));
+		}
+
+		io.flush();
+	}
+
+	private static void calculateDP(int u, int par) {
+		for (int v : adj.get(u)) {
+			// Continue if `v` is `u`'s parent.
+			if (v == par) {
+				continue;
+			}
+
+			// Calculate the DP values for 'v'.
+			calculateDP(v, u);
+
+			// DP transitions for 'u'.
+			dp[u][0] += maxBeauty(u, v, false);
+			dp[u][1] += maxBeauty(u, v, true);
+		}
+	}
+
+	// Return optimal beauty value for vertex u with subtree v.
+	private static long maxBeauty(int u, int v, boolean type) {
+		if (!type) {
+			long swtch = dp[v][1] + Math.abs(l[u] - r[v]);
+			long sm = dp[v][0] + Math.abs(l[u] - l[v]);
+
+			return Math.max(swtch, sm);
+		} else {
+			long swtch = dp[v][1] + Math.abs(r[u] - r[v]);
+			long sm = dp[v][0] + Math.abs(r[u] - l[v]);
+
+			return Math.max(swtch, sm);
+		}
+	}
+
+	//CodeSnip{Kattio}
+}
+```
+</JavaSection>
 </LanguageSection>