git reimport
This commit is contained in:
@@ -0,0 +1,30 @@
|
||||
22 A - Vasya And Password
|
||||
12 MULTI_NUMBER
|
||||
8 STANDARD
|
||||
9 input.txt
|
||||
8 STANDARD
|
||||
10 output.txt
|
||||
1
|
||||
0
|
||||
16 2
|
||||
abcDCE
|
||||
htQw27
|
||||
|
||||
14 abcD4E
|
||||
htQw27
|
||||
|
||||
1
|
||||
11 src/chelper
|
||||
8 -Xmx256M
|
||||
4 Main
|
||||
13 chelper.TaskA
|
||||
39 net.egork.chelper.checkers.TokenChecker
|
||||
0
|
||||
0
|
||||
10 2018.09.20
|
||||
50 Educational Codeforces Round 51 (Rated for Div. 2)
|
||||
1
|
||||
14 io.InputReader
|
||||
15 io.OutputWriter
|
||||
0
|
||||
0
|
||||
@@ -0,0 +1,31 @@
|
||||
26 B - Relatively Prime Pairs
|
||||
6 SINGLE
|
||||
8 STANDARD
|
||||
-1
|
||||
8 STANDARD
|
||||
-1
|
||||
1
|
||||
0
|
||||
4 1 8
|
||||
|
||||
20 YES
|
||||
2 7
|
||||
4 1
|
||||
3 8
|
||||
6 5
|
||||
|
||||
1
|
||||
11 src/chelper
|
||||
8 -Xmx256M
|
||||
4 Main
|
||||
13 chelper.TaskB
|
||||
39 net.egork.chelper.checkers.TokenChecker
|
||||
0
|
||||
0
|
||||
10 2018.09.20
|
||||
50 Educational Codeforces Round 51 (Rated for Div. 2)
|
||||
1
|
||||
14 io.InputReader
|
||||
15 io.OutputWriter
|
||||
0
|
||||
0
|
||||
@@ -0,0 +1,42 @@
|
||||
23 C - Vasya and Multisets
|
||||
6 SINGLE
|
||||
8 STANDARD
|
||||
-1
|
||||
8 STANDARD
|
||||
-1
|
||||
3
|
||||
0
|
||||
10 4
|
||||
3 5 7 1
|
||||
|
||||
9 YES
|
||||
BABA
|
||||
|
||||
1
|
||||
1
|
||||
8 3
|
||||
3 5 1
|
||||
|
||||
3 NO
|
||||
|
||||
1
|
||||
2
|
||||
9 4
|
||||
1 2 2 2
|
||||
8 YES
|
||||
ABAA
|
||||
1
|
||||
11 src/chelper
|
||||
8 -Xmx256M
|
||||
4 Main
|
||||
13 chelper.TaskC
|
||||
39 net.egork.chelper.checkers.TokenChecker
|
||||
0
|
||||
0
|
||||
10 2018.09.20
|
||||
50 Educational Codeforces Round 51 (Rated for Div. 2)
|
||||
1
|
||||
14 io.InputReader
|
||||
15 io.OutputWriter
|
||||
0
|
||||
0
|
||||
@@ -0,0 +1,63 @@
|
||||
15 D - Bicolorings
|
||||
6 SINGLE
|
||||
8 STANDARD
|
||||
-1
|
||||
8 STANDARD
|
||||
-1
|
||||
9
|
||||
0
|
||||
4 3 4
|
||||
|
||||
3 12
|
||||
|
||||
1
|
||||
1
|
||||
4 4 1
|
||||
|
||||
2 2
|
||||
|
||||
1
|
||||
2
|
||||
4 1 2
|
||||
|
||||
2 2
|
||||
|
||||
1
|
||||
3
|
||||
9 1000 2000
|
||||
1 2
|
||||
1
|
||||
4
|
||||
3 1 1
|
||||
1 2
|
||||
1
|
||||
5
|
||||
3 1 2
|
||||
1 2
|
||||
1
|
||||
6
|
||||
6 1000 1
|
||||
1 2
|
||||
1
|
||||
7
|
||||
3 2 2
|
||||
2 12
|
||||
1
|
||||
8
|
||||
3 3 0
|
||||
1 0
|
||||
1
|
||||
11 src/chelper
|
||||
8 -Xmx256M
|
||||
4 Main
|
||||
13 chelper.TaskD
|
||||
39 net.egork.chelper.checkers.TokenChecker
|
||||
0
|
||||
0
|
||||
10 2018.09.20
|
||||
50 Educational Codeforces Round 51 (Rated for Div. 2)
|
||||
1
|
||||
14 io.InputReader
|
||||
15 io.OutputWriter
|
||||
0
|
||||
0
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,111 @@
|
||||
package chelper;
|
||||
|
||||
import io.InputReader;
|
||||
import io.OutputWriter;
|
||||
import misc.SimpleSavingChelperSolution;
|
||||
|
||||
|
||||
public class TaskA extends SimpleSavingChelperSolution {
|
||||
|
||||
public void solve(int testNumber, InputReader in, OutputWriter out) {
|
||||
wrapSolve(testNumber, in, out);
|
||||
}
|
||||
|
||||
int getType(char c) {
|
||||
if ('A' <= c && c <= 'Z') {
|
||||
return 0;
|
||||
}
|
||||
if ('a' <= c && c <= 'z') {
|
||||
return 1;
|
||||
}
|
||||
if ('0' <= c && c <= '9') {
|
||||
return 2;
|
||||
}
|
||||
throw new RuntimeException();
|
||||
}
|
||||
|
||||
char getChar(int type) {
|
||||
if (type == 0) {
|
||||
return 'A';
|
||||
}
|
||||
if (type == 1) {
|
||||
return 'a';
|
||||
}
|
||||
if (type == 2) {
|
||||
return '0';
|
||||
}
|
||||
throw new RuntimeException();
|
||||
}
|
||||
|
||||
boolean isOk(int[] a) {
|
||||
int[] counts = new int[3];
|
||||
|
||||
for (int i : a) {
|
||||
counts[i]++;
|
||||
}
|
||||
|
||||
return counts[0] > 0 && counts[1] > 0 && counts[2] > 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void solve(int testNumber) {
|
||||
String s = in.nextString();
|
||||
|
||||
int n = s.length();
|
||||
|
||||
char[] chars = s.toCharArray();
|
||||
|
||||
int[] types = new int[n];
|
||||
int[] counts = new int[3];
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
types[i] = getType(chars[i]);
|
||||
counts[types[i]]++;
|
||||
}
|
||||
|
||||
if (isOk(types)) {
|
||||
out.println(s);
|
||||
return;
|
||||
}
|
||||
|
||||
int[] t = new int[n];
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
for (int k = 0; k < n; k++) {
|
||||
t[k] = types[k];
|
||||
}
|
||||
|
||||
t[i] = j;
|
||||
|
||||
if (isOk(t)) {
|
||||
chars[i] = getChar(j);
|
||||
out.println(new String(chars));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < n - 1; i++) {
|
||||
for (int j1 = 0; j1 < 3; j1++) {
|
||||
for (int j2 = j1 + 1; j2 < 3; j2++) {
|
||||
for (int k = 0; k < n; k++) {
|
||||
t[k] = types[k];
|
||||
}
|
||||
|
||||
t[i] = j1;
|
||||
t[i + 1] = j2;
|
||||
|
||||
if (isOk(t)) {
|
||||
chars[i] = getChar(j1);
|
||||
chars[i + 1] = getChar(j2);
|
||||
out.println(new String(chars));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package chelper;
|
||||
|
||||
import io.InputReader;
|
||||
import io.OutputWriter;
|
||||
import misc.SimpleSavingChelperSolution;
|
||||
|
||||
|
||||
public class TaskB extends SimpleSavingChelperSolution {
|
||||
|
||||
public void solve(int testNumber, InputReader in, OutputWriter out) {
|
||||
wrapSolve(testNumber, in, out);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void solve(int testNumber) {
|
||||
long l = in.nextLong();
|
||||
long r = in.nextLong();
|
||||
|
||||
out.println("YES");
|
||||
|
||||
for (long i = l; i <= r; i += 2) {
|
||||
out.println(i + " " + (i + 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
package chelper;
|
||||
|
||||
import io.InputReader;
|
||||
import io.OutputWriter;
|
||||
import misc.SimpleSavingChelperSolution;
|
||||
|
||||
|
||||
public class TaskC extends SimpleSavingChelperSolution {
|
||||
|
||||
public void solve(int testNumber, InputReader in, OutputWriter out) {
|
||||
wrapSolve(testNumber, in, out);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void solve(int testNumber) {
|
||||
int n = in.nextInt();
|
||||
int[] a = in.nextIntArray(n);
|
||||
|
||||
int[] counts = new int[200];
|
||||
for (int i : a) {
|
||||
counts[i]++;
|
||||
}
|
||||
|
||||
int size1 = 0;
|
||||
int size2 = 0;
|
||||
int size3Plus = 0;
|
||||
|
||||
for (int count : counts) {
|
||||
if (count == 1) {
|
||||
size1++;
|
||||
}
|
||||
if (count == 2) {
|
||||
size2++;
|
||||
}
|
||||
if (count >= 3) {
|
||||
size3Plus++;
|
||||
}
|
||||
}
|
||||
|
||||
if (size1 % 2 == 1 && size3Plus == 0) {
|
||||
out.println("NO");
|
||||
return;
|
||||
}
|
||||
|
||||
boolean[] mask = new boolean[n];
|
||||
|
||||
boolean parity = true;
|
||||
boolean shouldUse3Plus = size1 % 2 == 1;
|
||||
|
||||
for (int i = 0; i < 200; i++) {
|
||||
if (counts[i] == 1) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (a[j] == i) {
|
||||
mask[j] = parity;
|
||||
}
|
||||
}
|
||||
|
||||
parity = !parity;
|
||||
}
|
||||
|
||||
if (counts[i] >= 3 && shouldUse3Plus) {
|
||||
boolean first = true;
|
||||
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (a[j] == i) {
|
||||
mask[j] = parity == first;
|
||||
first = false;
|
||||
}
|
||||
}
|
||||
|
||||
parity = !parity;
|
||||
shouldUse3Plus = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
out.println("YES");
|
||||
for (boolean b : mask) {
|
||||
out.print(b ? 'A' : 'B');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package chelper;
|
||||
|
||||
import io.InputReader;
|
||||
import io.OutputWriter;
|
||||
import misc.SimpleSavingChelperSolution;
|
||||
|
||||
|
||||
public class TaskD extends SimpleSavingChelperSolution {
|
||||
|
||||
public void solve(int testNumber, InputReader in, OutputWriter out) {
|
||||
wrapSolve(testNumber, in, out);
|
||||
}
|
||||
|
||||
int MOD = 998244353;
|
||||
|
||||
int[][] componentChanges = {
|
||||
{0, 1, 1, 1}, //00
|
||||
{0, 0, 2, 0}, //01
|
||||
{0, 2, 0, 0}, //10
|
||||
{1, 1, 1, 0}, //11
|
||||
};
|
||||
|
||||
@Override
|
||||
public void solve(int testNumber) {
|
||||
int n = in.nextInt();
|
||||
int colors = in.nextInt();
|
||||
|
||||
int[][][] dp = new int[n][colors + 10][4];
|
||||
|
||||
dp[0][1][0]++;
|
||||
dp[0][2][1]++;
|
||||
dp[0][2][2]++;
|
||||
dp[0][1][3]++;
|
||||
|
||||
for (int i = 0; i < n - 1; i++) {
|
||||
for (int k = 0; k <= colors; k++) {
|
||||
for (int curMask = 0; curMask < 4; curMask++) {
|
||||
for (int nextMask = 0; nextMask < 4; nextMask++) {
|
||||
int newK = k + componentChanges[curMask][nextMask];
|
||||
if (newK > colors) {
|
||||
continue;
|
||||
}
|
||||
|
||||
dp[i + 1][newK][nextMask] += dp[i][k][curMask];
|
||||
dp[i + 1][newK][nextMask] %= MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int result = 0;
|
||||
for (int i = 0; i < 4; i++) {
|
||||
result += dp[n - 1][colors][i];
|
||||
result %= MOD;
|
||||
}
|
||||
out.println(result);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,303 @@
|
||||
package chelper;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.PriorityQueue;
|
||||
import java.util.Set;
|
||||
|
||||
import io.InputReader;
|
||||
import io.OutputWriter;
|
||||
import misc.Pair;
|
||||
import misc.SimpleSavingChelperSolution;
|
||||
|
||||
|
||||
public class TaskF extends SimpleSavingChelperSolution {
|
||||
|
||||
public static final long INF = Long.MAX_VALUE / 100;
|
||||
private Map<Integer, Map<Integer, Long>> edges;
|
||||
private int n;
|
||||
private int m;
|
||||
private int treeCount;
|
||||
private int[] vertexTreeId;
|
||||
private Set<Integer> treeEgressPointsSet;
|
||||
private int[] vertexTreeHeight;
|
||||
private long[] vertexTreeLength;
|
||||
private boolean[] tainted;
|
||||
private int[] dfsIn;
|
||||
private int[] dfsOut;
|
||||
private int timer;
|
||||
private int[][] upside;
|
||||
private List<List<Integer>> egressPointsByTree;
|
||||
private List<int[]> edges2Dest;
|
||||
private List<long[]> edges2Dist;
|
||||
|
||||
public void solve(int testNumber, InputReader in, OutputWriter out) {
|
||||
TaskF task = this;
|
||||
|
||||
Thread thread = new Thread(null, new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
task.wrapSolve(testNumber, in, out);
|
||||
}
|
||||
}, "Test", 1 << 26);
|
||||
thread.start();
|
||||
try {
|
||||
thread.join();
|
||||
} catch (InterruptedException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
|
||||
// wrapSolve(testNumber, in, out);
|
||||
}
|
||||
|
||||
static final int UPSIDE_L = 20;
|
||||
|
||||
@Override
|
||||
public void solve(int testNumber) {
|
||||
long startTime = System.nanoTime();
|
||||
|
||||
n = in.nextInt();
|
||||
m = in.nextInt();
|
||||
|
||||
edges = new HashMap<>();
|
||||
for (int i = 0; i < n; i++) {
|
||||
edges.put(i, new HashMap<>());
|
||||
}
|
||||
|
||||
for (int i = 0; i < m; i++) {
|
||||
int a = in.nextInt() - 1;
|
||||
int b = in.nextInt() - 1;
|
||||
long c = in.nextLong();
|
||||
|
||||
edges.get(a).put(b, c);
|
||||
edges.get(b).put(a, c);
|
||||
}
|
||||
|
||||
treeCount = 0;
|
||||
vertexTreeId = new int[n];
|
||||
vertexTreeHeight = new int[n];
|
||||
vertexTreeLength = new long[n];
|
||||
Arrays.fill(vertexTreeId, -1);
|
||||
|
||||
treeEgressPointsSet = new HashSet<>();
|
||||
|
||||
dfsIn = new int[n];
|
||||
dfsOut = new int[n];
|
||||
timer = 1;
|
||||
|
||||
upside = new int[n][UPSIDE_L + 1];
|
||||
for (int i = 0; i < n; i++) {
|
||||
Arrays.fill(upside[i], -1);
|
||||
}
|
||||
|
||||
tainted = new boolean[n];
|
||||
|
||||
treefy();
|
||||
// treefy2();
|
||||
|
||||
debug.println("Treefy finish " + (System.nanoTime() - startTime) / 1e9);
|
||||
debug.println("Trees: " + treeCount);
|
||||
debug.println("TEP: " + treeEgressPointsSet.size());
|
||||
|
||||
egressPointsByTree = new ArrayList<>();
|
||||
for (int i = 0; i < treeCount; i++) {
|
||||
egressPointsByTree.add(new ArrayList<>());
|
||||
}
|
||||
|
||||
for (int v1 : treeEgressPointsSet) {
|
||||
egressPointsByTree.get(vertexTreeId[v1]).add(v1);
|
||||
}
|
||||
|
||||
edges2Dest = new ArrayList<>();
|
||||
edges2Dist = new ArrayList<>();
|
||||
|
||||
for (int v = 0; v < n; v++) {
|
||||
int m = edges.get(v).size();
|
||||
|
||||
int[] dest = new int[m];
|
||||
long[] dist = new long[m];
|
||||
int k = 0;
|
||||
for (Map.Entry<Integer, Long> entry : edges.get(v).entrySet()) {
|
||||
int vv = entry.getKey();
|
||||
long c = entry.getValue();
|
||||
|
||||
dest[k] = vv;
|
||||
dist[k] = c;
|
||||
k++;
|
||||
}
|
||||
edges2Dest.add(dest);
|
||||
edges2Dist.add(dist);
|
||||
}
|
||||
|
||||
Map<Integer, long[]> egressDistances = new HashMap<>();
|
||||
for (int origin : treeEgressPointsSet) {
|
||||
long[] distances = new long[n];
|
||||
Arrays.fill(distances, INF);
|
||||
distances[origin] = 0;
|
||||
|
||||
egressDistances.put(origin, distances);
|
||||
|
||||
egressDijkstra(origin, distances);
|
||||
}
|
||||
debug.println("Dijkstra finish " + (System.nanoTime() - startTime) / 1e9);
|
||||
|
||||
debug.println("preprocess finish " + (System.nanoTime() - startTime) / 1e9);
|
||||
|
||||
int requestCount = in.nextInt();
|
||||
for (int i = 0; i < requestCount; i++) {
|
||||
int a = in.nextInt() - 1;
|
||||
int b = in.nextInt() - 1;
|
||||
|
||||
long res = INF;
|
||||
|
||||
if (vertexTreeId[a] == vertexTreeId[b]) {
|
||||
res = Math.min(res, insideTreeDistance(a, b));
|
||||
}
|
||||
|
||||
for (int v1 : egressPointsByTree.get(vertexTreeId[a])) {
|
||||
long dist = egressDistances.get(v1)[a] + egressDistances.get(v1)[b];
|
||||
|
||||
res = Math.min(res, dist);
|
||||
}
|
||||
|
||||
out.println(res);
|
||||
}
|
||||
}
|
||||
|
||||
boolean isUpsideInTree(int a, int b) {
|
||||
return dfsIn[a] <= dfsIn[b] && dfsOut[a] >= dfsOut[b];
|
||||
}
|
||||
|
||||
int lca(int a, int b) {
|
||||
if (isUpsideInTree(a, b)) {
|
||||
return a;
|
||||
}
|
||||
if (isUpsideInTree(b, a)) {
|
||||
return b;
|
||||
}
|
||||
for (int l = UPSIDE_L; l >= 0; l--) {
|
||||
if (upside[a][l] == -1) {
|
||||
continue;
|
||||
}
|
||||
if (!isUpsideInTree(upside[a][l], b)) {
|
||||
a = upside[a][l];
|
||||
}
|
||||
}
|
||||
return upside[a][0];
|
||||
}
|
||||
|
||||
long insideTreeDistance(int v1, int v2) {
|
||||
int l = lca(v1, v2);
|
||||
|
||||
return vertexTreeLength[v1] + vertexTreeLength[v2] - vertexTreeLength[l] * 2;
|
||||
}
|
||||
|
||||
void treefyDfs(int v, List<Integer> stack) {
|
||||
dfsIn[v] = timer++;
|
||||
|
||||
for (Map.Entry<Integer, Long> edge : edges.get(v).entrySet()) {
|
||||
int vv = edge.getKey();
|
||||
long c = edge.getValue();
|
||||
|
||||
if (vertexTreeId[vv] == -1 && !tainted[vv]) {
|
||||
for (Map.Entry<Integer, Long> edge2 : edges.get(vv).entrySet()) {
|
||||
int vvv = edge2.getKey();
|
||||
|
||||
if (vertexTreeId[vvv] == vertexTreeId[v] && vvv != v) {
|
||||
tainted[vv] = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (tainted[vv]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
vertexTreeId[vv] = vertexTreeId[v];
|
||||
vertexTreeHeight[vv] = vertexTreeHeight[v] + 1;
|
||||
vertexTreeLength[vv] = vertexTreeLength[v] + c;
|
||||
|
||||
stack.add(vv);
|
||||
|
||||
for (int l = 0; l <= UPSIDE_L; l++) {
|
||||
int j = stack.size() - 1 - (1 << l);
|
||||
if (j < 0) {
|
||||
break;
|
||||
}
|
||||
upside[vv][l] = stack.get(j);
|
||||
}
|
||||
treefyDfs(vv, stack);
|
||||
|
||||
stack.remove(stack.size() - 1);
|
||||
}
|
||||
|
||||
if (vertexTreeId[v] != vertexTreeId[vv] && vertexTreeId[vv] != -1) {
|
||||
treeEgressPointsSet.add(v);
|
||||
treeEgressPointsSet.add(vv);
|
||||
}
|
||||
}
|
||||
|
||||
dfsOut[v] = timer++;
|
||||
}
|
||||
|
||||
void egressDijkstra(int origin, long[] distances) {
|
||||
PriorityQueue<long[]> queue = new PriorityQueue<>(new Comparator<long[]>() {
|
||||
@Override
|
||||
public int compare(long[] o1, long[] o2) {
|
||||
return Long.compare(o1[0], o2[0]);
|
||||
}
|
||||
});
|
||||
Arrays.fill(tainted, false);
|
||||
|
||||
int treeId = vertexTreeId[origin];
|
||||
|
||||
queue.add(new long[]{0L, origin});
|
||||
tainted[origin] = true;
|
||||
|
||||
while (!queue.isEmpty()) {
|
||||
int v = (int) queue.poll()[1];
|
||||
|
||||
int[] dest = edges2Dest.get(v);
|
||||
long[] dist = edges2Dist.get(v);
|
||||
|
||||
for (int i = 0; i < dest.length; i++) {
|
||||
int vv = dest[i];
|
||||
long c = dist[i];
|
||||
|
||||
distances[vv] = Math.min(distances[vv], distances[v] + c);
|
||||
|
||||
if (tainted[vv]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
tainted[vv] = true;
|
||||
queue.add(new long[]{distances[vv], vv});
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void treefy() {
|
||||
for (int v = 0; v < n; v++) {
|
||||
if (vertexTreeId[v] == -1) {
|
||||
Arrays.fill(tainted, false);
|
||||
|
||||
int treeId = treeCount;
|
||||
treeCount++;
|
||||
vertexTreeId[v] = treeId;
|
||||
vertexTreeHeight[v] = 0;
|
||||
vertexTreeLength[v] = 0;
|
||||
|
||||
List<Integer> stack = new ArrayList<>();
|
||||
stack.add(v);
|
||||
|
||||
treefyDfs(v, stack);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user