Merge branch 'taunt_eval'

# Conflicts: #	src/main/java/main/java/hackerearth/taunt/Taunt.java #	src/main/java/main/java/hackerearth/taunt/TauntTest.java

Author: gkcs

src/main/java/main/java/codechef/DISTNUM3.java

@@ -5,22 +5,24 @@
 import java.util.*;
 import java.io.*;
 
+/**
+ * Reference: https://www.codechef.com/viewsolution/12879967
+ */
 public class DISTNUM3 {
- private static final int MAX = 100000;
- static ArrayList<Integer>[] adj;
- static int clock = 0, eulerTour[], start[], end[], V;
- static int BLOCK_SIZE;
-
- /* LCA <NlogN , logN> dependency : level , log , V , DP = new int[log(V) + 1][V + 1];, parent (for the first level of DP) */
+ static List<Integer>[] adj;
+ static int clock = 0, start[], end[], V;
  static int DP[][];
  static int level[];
  static int parent[];
+ static int distinctCount;
+ static boolean marked[];
+ static int vertices[];
 
  static int log(int N) {
  return 31 - Integer.numberOfLeadingZeros(N);
  }
 
- static void binaryLift() {
+ static void findAncestorsAtEachLevel() {
  System.arraycopy(parent, 1, DP[0], 1, V);
  for (int i = 1; i < DP.length; i++) {
  for (int j = 1; j <= V; j++) {
@@ -31,247 +33,204 @@ static void binaryLift() {
 
  static int LCA(int u, int v) {
  if (level[v] < level[u]) {
- int temp = u;
+ final int temp = u;
  u = v;
  v = temp;
  }
  int diff = level[v] - level[u];
- while (diff > 0) { // Bring v to the same level as u
- int log = log(diff);
+ while (diff > 0) {
+ final int log = log(diff);
  v = DP[log][v];
  diff -= (1 << log);
  }
  while (u != v) {
  int i = log(level[u]);
- for (; i > 0 && DP[i][u] == DP[i][v]; )
+ while (i > 0 && DP[i][u] == DP[i][v]) {
  i--;
-
+ }
  u = DP[i][u];
  v = DP[i][v];
  }
-
  return u;
  }
 
- static void dfs(int u, int par, int lev) {
+ static void dfs(final int u, final int par, final int lev, final int[] eulerTour) {
  eulerTour[clock] = u;
  start[u] = clock++;
  parent[u] = par;
  level[u] = lev;
- for (int v : adj[u])
- if (v != par)
- dfs(v, u, lev + 1);
-
+ for (final int v : adj[u]) {
+ if (v != par) {
+ dfs(v, u, lev + 1, eulerTour);
+ }
+ }
  eulerTour[clock] = u;
  end[u] = clock++;
  }
 
-
- static class Query {
- int L, R, numUpdatesLess, LCA, id;
-
- public Query(int l, int r, int numUpdatesLess, int lCA, int id) {
- L = l;
- R = r;
- this.numUpdatesLess = numUpdatesLess;
- LCA = lCA;
- this.id = id;
- }
-
- @Override
- public String toString() {
- return String.format("[L = %d R = %d updatesLess = %d LCA = %d id = %d]", L, R, numUpdatesLess, LCA, id);
- }
- }
-
- static class Update {
- int idx, prevVal, newVal;
-
- public Update(int idx, int newVal, int prevVal) {
- this.idx = idx;
- this.newVal = newVal;
- this.prevVal = prevVal;
- }
-
- @Override
- public String toString() {
- return String.format("[idx = %d prevVal = %d newVal = %d", idx, prevVal, newVal);
- }
- }
-
- static class MoComparator implements Comparator<Query> {
- @Override
- public int compare(Query o1, Query o2) {
- if (blockCache[o1.L] != blockCache[o2.L])
- return blockCache[o1.L] - blockCache[o2.L];
- else if (blockCache[o1.R] != blockCache[o2.R])
- return blockCache[o1.R] - blockCache[o2.R];
- else
- return o1.numUpdatesLess - o2.numUpdatesLess;
- }
- }
-
- static int freq[];
- static int distinctCount;
- static boolean marked[];
- static int blockCache[];
- static int val[];
- static HashMap<Integer, Integer> map;
-
- static void visit(int idx) {
+ static void visit(final int idx, final int[] frequency) {
  if (marked[idx]) {
- freq[val[idx]]--;
- if (freq[val[idx]] == 0)
+ frequency[vertices[idx]]--;
+ if (frequency[vertices[idx]] == 0) {
  distinctCount--;
+ }
  } else {
- freq[val[idx]]++;
- if (freq[val[idx]] == 1)
+ frequency[vertices[idx]]++;
+ if (frequency[vertices[idx]] == 1) {
  distinctCount++;
+ }
  }
-
  marked[idx] = !marked[idx];
  }
 
- static void update(int idx, int newVal) {
+ static void update(final int idx, final int newVal, final int[] frequency) {
  if (marked[idx]) {
- visit(idx);
- val[idx] = newVal;
- visit(idx);
- } else
- val[idx] = newVal;
- }
-
- static int countDistinct(int u, int v) {
- int lca = LCA(u, v);
- BitSet bitSet = new BitSet(map.size());
- bitSet.set(val[lca]);
- while (u != lca) {
- bitSet.set(val[u]);
- u = parent[u];
- }
- while (v != lca) {
- bitSet.set(val[v]);
- v = parent[v];
+ visit(idx, frequency);
+ vertices[idx] = newVal;
+ visit(idx, frequency);
+ } else {
+ vertices[idx] = newVal;
  }
-
- return bitSet.cardinality();
  }
 
  public static void main(String[] args) throws IOException {
  final InputReader in = new InputReader(System.in);
- int qSZ = 0, uSZ = 0;
  V = in.readInt();
- int Q = in.readInt();
- int E = V - 1;
- Query queries[] = new Query[MAX];
- Update updates[] = new Update[MAX];
- map = new HashMap<>(); // Used to compress the keys
-
+ final int Q = in.readInt();
  adj = new ArrayList[V + 1];
  for (int i = 1; i <= V; i++) {
  adj[i] = new ArrayList<>();
  }
- val = new int[V + 1];
+ vertices = new int[V + 1];
  for (int i = 1; i <= V; i++) {
- val[i] = in.readInt();
+ vertices[i] = in.readInt();
  }
+ final Map<Integer, Integer> map = new HashMap<>();
  for (int i = 1; i <= V; i++) {
- if (!map.containsKey(val[i])) {
- map.put(val[i], map.size());
- }
- val[i] = map.get(val[i]);
+ map.putIfAbsent(vertices[i], map.size());
+ vertices[i] = map.get(vertices[i]);
  }
- int currVal[] = new int[V + 1];
- System.arraycopy(val, 0, currVal, 0, V + 1);
- while (E-- > 0) {
+ final int verticesCopy[] = new int[V + 1];
+ System.arraycopy(vertices, 0, verticesCopy, 0, V + 1);
+ final int edges = V - 1;
+ for (int i = 0; i < edges; i++) {
  final int u = in.readInt();
  final int v = in.readInt();
  adj[u].add(v);
  adj[v].add(u);
  }
  start = new int[V + 1];
  end = new int[V + 1];
- eulerTour = new int[2 * (V + 1)];
+ final int[] eulerTour = new int[2 * (V + 1)];
  level = new int[V + 1];
  marked = new boolean[V + 1];
  DP = new int[log(V) + 1][V + 1];
  parent = new int[V + 1];
- blockCache = new int[2 * (V + 1)];
- dfs(1, 0, 0);
- binaryLift();
- while (Q-- > 0) {
- if (in.readInt() == 1) { // Query
+ dfs(1, 0, 0, eulerTour);
+ findAncestorsAtEachLevel();
+ int numberOfQueries = 0, numberOfUpdates = 0;
+ final Query queries[] = new Query[Q];
+ final Update updates[] = new Update[Q];
+ for (int i = 0; i < Q; i++) {
+ if (in.readInt() == 1) {
  final int u = in.readInt();
  final int v = in.readInt();
  final Query q;
- if (end[u] < start[v]) // Cousin Nodes
- {
- q = new Query(end[u], start[v], uSZ, LCA(u, v), qSZ);
+ if (start[v] > end[u]) {
+ q = new Query(end[u], start[v], numberOfUpdates, LCA(u, v), numberOfQueries);
  } else if (start[u] > end[v]) {
- q = new Query(end[v], start[u], uSZ, LCA(u, v), qSZ);
- } else // Ancestors
- {
- q = new Query(Math.min(start[u], start[v]), Math.max(start[u], start[v]), uSZ, -1, qSZ);
+ q = new Query(end[v], start[u], numberOfUpdates, LCA(u, v), numberOfQueries);
+ } else {
+ q = new Query(Math.min(start[u], start[v]),
+ Math.max(start[u], start[v]),
+ numberOfUpdates,
+ -1,
+ numberOfQueries);
  }
- queries[qSZ++] = q;
+ queries[numberOfQueries++] = q;
  } else {
  final int idx = in.readInt();
  int newVal = in.readInt();
- if (!map.containsKey(newVal)) {
- map.put(newVal, map.size());
- }
+ map.putIfAbsent(newVal, map.size());
  newVal = map.get(newVal);
- updates[uSZ++] = new Update(idx, newVal, currVal[idx]);
- currVal[idx] = newVal;
+ updates[numberOfUpdates++] = new Update(idx, newVal, verticesCopy[idx]);
+ verticesCopy[idx] = newVal;
  }
  }
- freq = new int[map.size()];
- BLOCK_SIZE = (int) (Math.pow(2 * V, 2.0 / 3.0) + 1);
- for (int i = 0; i < blockCache.length; i++) {
- blockCache[i] = i / BLOCK_SIZE;
- }
- Arrays.sort(queries, 0, qSZ, new MoComparator());
- final int ans[] = new int[qSZ];
+ final int BLOCK_SIZE = (int) (Math.pow(2 * V, 2.0 / 3.0) + 1);
+ Arrays.sort(queries, 0, numberOfQueries, (first, second) -> {
+ if (first.L / BLOCK_SIZE != second.L / BLOCK_SIZE) {
+ return first.L / BLOCK_SIZE - second.L / BLOCK_SIZE;
+ } else if (first.R / BLOCK_SIZE != second.R / BLOCK_SIZE) {
+ return first.R / BLOCK_SIZE - second.R / BLOCK_SIZE;
+ } else {
+ return first.updatesTillNow - second.updatesTillNow;
+ }
+ });
+ final int ans[] = new int[numberOfQueries];
  int moLeft = -1, moRight = -1;
- int currUpd = 0;
- for (int i = 0; i < qSZ; i++) {
-  final Query q = queries[i];
- while (currUpd < q.numUpdatesLess) {
-  final Update u = updates[currUpd];
- update(u.idx, u.newVal);
- currUpd++;
+ int currentUpdateCount = 0;
+ final int[] frequency = new int[map.size()];
+ for (int i = 0; i < numberOfQueries; i++) {
+ final Query query = queries[i];
+ while (currentUpdateCount < query.updatesTillNow) {
+ final Update update = updates[currentUpdateCount++];
+ update(update.idx, update.newValue, frequency);
  }
- while (currUpd > q.numUpdatesLess) {
- final Update u = updates[currUpd - 1];
- update(u.idx, u.prevVal);
- currUpd--;
+ while (currentUpdateCount > query.updatesTillNow) {
+ final Update update = updates[--currentUpdateCount];
+ update(update.idx, update.previousValue, frequency);
  }
- while (moLeft < q.L - 1) {
+ while (moLeft < query.L - 1) {
  moLeft++;
- visit(eulerTour[moLeft]);
+ visit(eulerTour[moLeft], frequency);
  }
- while (moLeft >= q.L) {
- visit(eulerTour[moLeft]);
+ while (moLeft >= query.L) {
+ visit(eulerTour[moLeft], frequency);
  moLeft--;
  }
- while (moRight < q.R) {
+ while (moRight < query.R) {
  moRight++;
- visit(eulerTour[moRight]);
+ visit(eulerTour[moRight], frequency);
  }
- while (moRight > q.R) {
- visit(eulerTour[moRight]);
+ while (moRight > query.R) {
+ visit(eulerTour[moRight], frequency);
  moRight--;
  }
- if (q.LCA != -1) {
- visit(q.LCA);
+ if (query.LCA != -1) {
+ visit(query.LCA, frequency);
  }
- ans[q.id] = distinctCount;
- if (q.LCA != -1) {
- visit(q.LCA);
+ ans[query.id] = distinctCount;
+ if (query.LCA != -1) {
+ visit(query.LCA, frequency);
  }
  }
+ final StringBuilder stringBuilder = new StringBuilder();
  for (final int a : ans) {
- System.out.println(a);
+ stringBuilder.append(a).append('\n');
  }
+ System.out.println(stringBuilder);
+ }
+}
+
+class Query {
+ final int L, R, updatesTillNow, LCA, id;
+
+ public Query(final int l, final int r, final int updatesTillNow, final int lCA, final int id) {
+ L = l;
+ R = r;
+ this.updatesTillNow = updatesTillNow;
+ LCA = lCA;
+ this.id = id;
+ }
+}
+
+class Update {
+ final int idx, previousValue, newValue;
+
+ public Update(final int idx, final int newValue, final int previousValue) {
+ this.idx = idx;
+ this.newValue = newValue;
+ this.previousValue = previousValue;
  }
-} 
+}