git reimport

archive/2017.10/2017.10.15 - unsorted/E.java

@@ -0,0 +1,131 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import io.InputReader;
+import io.OutputWriter;
+import misc.SimpleSavingChelperSolution;
+
+
+public class E extends SimpleSavingChelperSolution {
+
+  private int[] x;
+  private int[] y;
+  private int n;
+  private Map<Integer, Integer> xMap;
+  private Map<Integer, Integer> yMap;
+  private List<Set<Integer>> edges;
+  private boolean[] visited;
+  private long MOD;
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    wrapSolve(testNumber, in, out);
+  }
+
+  @Override
+  public void solve(int testNumber) {
+    n = in.nextInt();
+
+    x = new int[n];
+    y = new int[n];
+
+    xMap = new TreeMap<>();
+    yMap = new TreeMap<>();
+
+    edges = new ArrayList<>();
+
+    for (int i = 0; i < n; i++) {
+      edges.add(new HashSet<>());
+    }
+
+    Map<Integer, Integer> prevX = new HashMap<>();
+    Map<Integer, Integer> prevY = new HashMap<>();
+
+    for (int i = 0; i < n; i++) {
+      x[i] = in.nextInt();
+      y[i] = in.nextInt();
+
+      xMap.put(x[i], xMap.getOrDefault(x[i], 0) + 1);
+      yMap.put(y[i], yMap.getOrDefault(y[i], 0) + 1);
+
+      Integer pX = prevX.get(x[i]);
+      Integer pY = prevY.get(y[i]);
+
+      if (pX != null) {
+        edges.get(pX).add(i);
+        edges.get(i).add(pX);
+      }
+      if (pY != null) {
+        edges.get(pY).add(i);
+        edges.get(i).add(pY);
+      }
+
+      prevX.put(x[i], i);
+      prevY.put(y[i], i);
+    }
+
+    visited = new boolean[n];
+
+    long ans = 1;
+
+    MOD = 1000000007;
+
+    for (int i = 0; i < n; i++) {
+      if (visited[i]) {
+        continue;
+      }
+
+      List<Integer> res = new ArrayList<>();
+      dfs(i, res);
+
+      Set<Integer> usedX = new HashSet<>();
+      Set<Integer> usedY = new HashSet<>();
+
+      for (Integer j : res) {
+        usedX.add(x[j]);
+        usedY.add(y[j]);
+      }
+
+      int K = usedX.size() + usedY.size();
+      if (res.size() >= K) {
+        ans = ans * twopow(K) % MOD;
+      } else {
+        ans = ans * ((twopow(K) - 1 + MOD) % MOD) % MOD;
+      }
+    }
+
+
+    out.println(ans);
+  }
+
+  long twopow(int n) {
+    if (n == 0) {
+      return 1;
+    }
+    if (n % 2 == 0) {
+      long t = twopow(n / 2);
+      return t * t % MOD;
+    }
+    return twopow(n - 1) * 2 % MOD;
+  }
+
+  void dfs(int v, List<Integer> res) {
+    if (visited[v]) {
+      return;
+    }
+    visited[v] = true;
+    res.add(v);
+
+    for (int j : edges.get(v)) {
+      dfs(j, res);
+    }
+  }
+}