Contest Duration: - (local time) (130 minutes) Back to Home

Submission #6373673

Source Code Expand

Copy
```import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Egor Kulikov (egor@egork.net)
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
OutputWriter out = new OutputWriter(outputStream);
solver.solve(1, in, out);
out.close();
}

Graph graph;
boolean[] was;
boolean[] done;
int[] c;
int[] d;

public void solve(int testNumber, InputReader in, OutputWriter out) {
int[] a = new int[m];
int[] b = new int[m];
if (m % 2 == 1) {
out.printLine(-1);
return;
}
MiscUtils.decreaseByOne(a, b);
graph = BidirectionalGraph.createGraph(n, a, b);
was = new boolean[n];
done = new boolean[m];
c = new int[m];
d = new int[m];
go(0, -1);
for (int i = 0; i < m; i++) {
out.printLine(c[i], d[i]);
}
}

private boolean go(int vertex, int last) {
was[vertex] = true;
boolean oddity = false;
for (int i = graph.firstOutbound(vertex); i != -1; i = graph.nextOutbound(i)) {
int next = graph.destination(i);
if (next == last) {
continue;
}
if (done[i >> 1]) {
continue;
}
if (was[next]) {
oddity = !oddity;
done[i >> 1] = true;
c[i >> 1] = vertex + 1;
d[i >> 1] = next + 1;
} else {
boolean call = go(next, vertex);
oddity ^= call;
done[i >> 1] = true;
c[i >> 1] = (call ? vertex : next) + 1;
d[i >> 1] = (call ? next : vertex) + 1;
}
}
return !oddity;
}

}

static interface Edge {
}

private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;

this.stream = stream;
}

for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++) {
}
}
}

if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}

while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}

public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);

}

}

static class BidirectionalGraph extends Graph {
public int[] transposedEdge;

public BidirectionalGraph(int vertexCount) {
this(vertexCount, vertexCount);
}

public BidirectionalGraph(int vertexCount, int edgeCapacity) {
super(vertexCount, 2 * edgeCapacity);
transposedEdge = new int[2 * edgeCapacity];
}

public static BidirectionalGraph createGraph(int vertexCount, int[] from, int[] to) {
BidirectionalGraph graph = new BidirectionalGraph(vertexCount, from.length);
for (int i = 0; i < from.length; i++) {
}
return graph;
}

public int addEdge(int fromID, int toID, long weight, long capacity, int reverseEdge) {
int lastEdgeCount = edgeCount;
super.addEdge(toID, fromID, weight, capacity, reverseEdge == -1 ? -1 : reverseEdge + 1);
this.transposedEdge[lastEdgeCount] = lastEdgeCount + 1;
this.transposedEdge[lastEdgeCount + 1] = lastEdgeCount;
return lastEdgeCount;
}

protected int entriesPerEdge() {
return 2;
}

protected void ensureEdgeCapacity(int size) {
if (size > edgeCapacity()) {
super.ensureEdgeCapacity(size);
transposedEdge = resize(transposedEdge, edgeCapacity());
}
}

}

static class MiscUtils {
public static void decreaseByOne(int[]... arrays) {
for (int[] array : arrays) {
for (int i = 0; i < array.length; i++) {
array[i]--;
}
}
}

}

static class Graph {
public static final int REMOVED_BIT = 0;
protected int vertexCount;
protected int edgeCount;
private int[] firstOutbound;
private int[] firstInbound;
private Edge[] edges;
private int[] nextInbound;
private int[] nextOutbound;
private int[] from;
private int[] to;
private long[] weight;
public long[] capacity;
private int[] reverseEdge;
private int[] flags;

public Graph(int vertexCount) {
this(vertexCount, vertexCount);
}

public Graph(int vertexCount, int edgeCapacity) {
this.vertexCount = vertexCount;
firstOutbound = new int[vertexCount];
Arrays.fill(firstOutbound, -1);

from = new int[edgeCapacity];
to = new int[edgeCapacity];
nextOutbound = new int[edgeCapacity];
flags = new int[edgeCapacity];
}

public int addEdge(int fromID, int toID, long weight, long capacity, int reverseEdge) {
ensureEdgeCapacity(edgeCount + 1);
if (firstOutbound[fromID] != -1) {
nextOutbound[edgeCount] = firstOutbound[fromID];
} else {
nextOutbound[edgeCount] = -1;
}
firstOutbound[fromID] = edgeCount;
if (firstInbound != null) {
if (firstInbound[toID] != -1) {
nextInbound[edgeCount] = firstInbound[toID];
} else {
nextInbound[edgeCount] = -1;
}
firstInbound[toID] = edgeCount;
}
this.from[edgeCount] = fromID;
this.to[edgeCount] = toID;
if (capacity != 0) {
if (this.capacity == null) {
this.capacity = new long[from.length];
}
this.capacity[edgeCount] = capacity;
}
if (weight != 0) {
if (this.weight == null) {
this.weight = new long[from.length];
}
this.weight[edgeCount] = weight;
}
if (reverseEdge != -1) {
if (this.reverseEdge == null) {
this.reverseEdge = new int[from.length];
Arrays.fill(this.reverseEdge, 0, edgeCount, -1);
}
this.reverseEdge[edgeCount] = reverseEdge;
}
if (edges != null) {
edges[edgeCount] = createEdge(edgeCount);
}
return edgeCount++;
}

protected final GraphEdge createEdge(int id) {
return new GraphEdge(id);
}

public final int addFlowWeightedEdge(int from, int to, long weight, long capacity) {
if (capacity == 0) {
return addEdge(from, to, weight, 0, -1);
} else {
int lastEdgeCount = edgeCount;
addEdge(to, from, -weight, 0, lastEdgeCount + entriesPerEdge());
return addEdge(from, to, weight, capacity, lastEdgeCount);
}
}

protected int entriesPerEdge() {
return 1;
}

public final int addWeightedEdge(int from, int to, long weight) {
}

public final int addSimpleEdge(int from, int to) {
}

protected final int edgeCapacity() {
return from.length;
}

public final int firstOutbound(int vertex) {
int id = firstOutbound[vertex];
while (id != -1 && isRemoved(id)) {
id = nextOutbound[id];
}
return id;
}

public final int nextOutbound(int id) {
id = nextOutbound[id];
while (id != -1 && isRemoved(id)) {
id = nextOutbound[id];
}
return id;
}

public final int destination(int id) {
}

public final boolean flag(int id, int bit) {
return (flags[id] >> bit & 1) != 0;
}

public final boolean isRemoved(int id) {
return flag(id, REMOVED_BIT);
}

protected void ensureEdgeCapacity(int size) {
if (from.length < size) {
int newSize = Math.max(size, 2 * from.length);
if (edges != null) {
edges = resize(edges, newSize);
}
from = resize(from, newSize);
to = resize(to, newSize);
nextOutbound = resize(nextOutbound, newSize);
if (nextInbound != null) {
nextInbound = resize(nextInbound, newSize);
}
if (weight != null) {
weight = resize(weight, newSize);
}
if (capacity != null) {
capacity = resize(capacity, newSize);
}
if (reverseEdge != null) {
reverseEdge = resize(reverseEdge, newSize);
}
flags = resize(flags, newSize);
}
}

protected final int[] resize(int[] array, int size) {
int[] newArray = new int[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}

private long[] resize(long[] array, int size) {
long[] newArray = new long[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}

private Edge[] resize(Edge[] array, int size) {
Edge[] newArray = new Edge[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}

protected class GraphEdge implements Edge {
protected int id;

protected GraphEdge(int id) {
this.id = id;
}

}

}

static class OutputWriter {
private final PrintWriter writer;

public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}

public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}

public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}

public void printLine(Object... objects) {
print(objects);
writer.println();
}

public void close() {
writer.close();
}

public void printLine(int i) {
writer.println(i);
}

}
}

```

Submission Info

Submission Time 2019-07-14 21:52:07+0900 B - Even Degrees Egor Java8 (OpenJDK 1.8.0) 700 14083 Byte AC 289 ms 65160 KB

Judge Result

Set Name Sample All
Score / Max Score 0 / 0 700 / 700
Status
 AC × 2
 AC × 36
Set Name Test Cases
Sample s1.txt, s2.txt
All 01.txt, 02.txt, 03.txt, 04.txt, 05.txt, 06.txt, 07.txt, 08.txt, 09.txt, 10.txt, 11.txt, 12.txt, 13.txt, 14.txt, 15.txt, 16.txt, 17.txt, 18.txt, 19.txt, 20.txt, 21.txt, 22.txt, 23.txt, 24.txt, 25.txt, 26.txt, 27.txt, 28.txt, 29.txt, 30.txt, 31.txt, 32.txt, 33.txt, 34.txt, s1.txt, s2.txt
Case Name Status Exec Time Memory
01.txt AC 261 ms 46712 KB
02.txt AC 267 ms 47580 KB
03.txt AC 289 ms 47028 KB
04.txt AC 261 ms 45092 KB
05.txt AC 114 ms 19268 KB
06.txt AC 273 ms 50676 KB
07.txt AC 265 ms 48892 KB
08.txt AC 266 ms 51832 KB
09.txt AC 260 ms 50508 KB
10.txt AC 103 ms 19276 KB
11.txt AC 251 ms 45120 KB
12.txt AC 268 ms 45932 KB
13.txt AC 265 ms 46248 KB
14.txt AC 263 ms 46888 KB
15.txt AC 109 ms 19148 KB
16.txt AC 265 ms 45308 KB
17.txt AC 285 ms 47324 KB
18.txt AC 273 ms 44964 KB
19.txt AC 271 ms 44492 KB
20.txt AC 109 ms 22228 KB
21.txt AC 268 ms 44116 KB
22.txt AC 269 ms 44944 KB
23.txt AC 280 ms 45080 KB
24.txt AC 278 ms 43564 KB
25.txt AC 111 ms 20148 KB
26.txt AC 111 ms 20308 KB
27.txt AC 102 ms 19776 KB
28.txt AC 278 ms 62960 KB
29.txt AC 278 ms 65160 KB
30.txt AC 75 ms 19028 KB
31.txt AC 77 ms 20820 KB
32.txt AC 77 ms 18900 KB
33.txt AC 75 ms 19540 KB
34.txt AC 76 ms 18004 KB
s1.txt AC 77 ms 20692 KB
s2.txt AC 76 ms 19540 KB