git reimport

archive/2016.08/2016.08.03 - unsorted/Sazanka2J.java

@@ -0,0 +1,152 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.TreeSet;
+
+import io.InputReader;
+import io.OutputWriter;
+
+
+public class Sazanka2J {
+
+  class Edge {
+
+    int a, b;
+
+    Edge(int a, int b) {
+      this.a = a;
+      this.b = b;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof Edge)) {
+        return false;
+      }
+
+      Edge edge = (Edge) o;
+
+      if (a != edge.a) {
+        return false;
+      }
+      return b == edge.b;
+
+    }
+
+    @Override
+    public int hashCode() {
+      int result = a;
+      result = 31 * result + b;
+      return result;
+    }
+  }
+
+  ArrayList<Integer>[] leftToRightEdges;
+  boolean[][] graphToLeft;
+  boolean[][] graphToRight;
+  boolean[] usedLeft;
+  boolean[] usedRight;
+  int m, n;
+
+  void dfs(int x, boolean left) {
+//    System.out.println("dfs run " + x + " " + left);
+    if (left) {
+      usedLeft[x] = true;
+      for (int i = 0; i < n; i++) {
+        if (graphToRight[x][i] && !usedRight[i]) {
+          dfs(i, false);
+        }
+      }
+    } else {
+      usedRight[x] = true;
+      for (int i = 0; i < m; i++) {
+        if (graphToLeft[x][i] && !usedLeft[i]) {
+          dfs(i, true);
+        }
+      }
+    }
+  }
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    m = in.nextInt();
+    n = in.nextInt();
+
+    leftToRightEdges = new ArrayList[m];
+    for (int i = 0; i < m; i++) {
+      leftToRightEdges[i] = new ArrayList<>();
+      int k = in.nextInt();
+      for (int j = 0; j < k; j++) {
+        leftToRightEdges[i].add(in.nextInt() - 1);
+      }
+    }
+
+    boolean[] nasucsh = new boolean[m];
+    Set<Edge> parsoch = new HashSet<>();
+    for (int i = 0; i < m; i++) {
+      int x = in.nextInt();
+      if (x > 0) {
+        parsoch.add(new Edge(i, x - 1));
+        nasucsh[i] = true;
+      }
+    }
+
+    graphToLeft = new boolean[n][m];
+    graphToRight = new boolean[m][n];
+    for (int i = 0; i < m; i++) {
+      for (int j : leftToRightEdges[i]) {
+        if (parsoch.contains(new Edge(i, j))) {
+          graphToLeft[j][i] = true;
+//          System.out.println("toleft " + j + " " + i);
+        } else {
+          graphToRight[i][j] = true;
+//          System.out.println("toright " + i + " " + j);
+        }
+      }
+    }
+
+    usedLeft = new boolean[m];
+    usedRight = new boolean[n];
+    for (int i = 0; i < m; i++) {
+      if (!nasucsh[i]) {
+//        out.println("dfs " + i);
+        dfs(i, true);
+      }
+    }
+
+    ArrayList<Integer> answerLeft = new ArrayList<>();
+    ArrayList<Integer> answerRight = new ArrayList<>();
+
+    Collections.sort(answerLeft);
+    Collections.sort(answerRight);
+
+
+    for (int i = 0; i < m; i++) {
+      if (!usedLeft[i]) {
+        answerLeft.add(i);
+      }
+    }
+    for (int i = 0; i < n; i++) {
+      if (usedRight[i]) {
+        answerRight.add(i);
+      }
+    }
+
+    out.println(answerLeft.size() + answerRight.size());
+
+    out.print(answerLeft.size() + " ");
+    for (int i : answerLeft) {
+      out.print(i + 1 + " ");
+    }
+    out.println();
+    out.print(answerRight.size() + " ");
+    for (int i : answerRight) {
+      out.print(i + 1 + " ");
+    }
+  }
+}