Submission #4380845

Source Code Expand

Copy
```import static java.lang.Math.*;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.TreeSet;

public class Main {

public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
MyInput in = new MyInput(inputStream);
PrintWriter out = new PrintWriter(outputStream);
solver.solve(1, in, out);
out.close();
}

static int INF = 1 << 30;
static long LINF = 1L << 60;
static int MOD = 1000000007;
static int[] mh4 = { 0, -1, 1, 0 };
static int[] mw4 = { -1, 0, 0, 1 };
static int[] mh8 = { -1, -1, -1, 0, 0, 1, 1, 1 };
static int[] mw8 = { -1, 0, 1, -1, 1, -1, 0, 1 };

public void solve(int testNumber, MyInput in, PrintWriter out) {

int a = in.nextInt(), b = in.nextInt(), q = in.nextInt();
TreeSet<Long> ji = new TreeSet<>(), te = new TreeSet<>();
for (int i = 0; i < a; i++) {
}
for (int i = 0; i < b; i++) {
}

while (q-- > 0) {
long cur = in.nextLong();
long jl = ji.floor(cur);
long jr = ji.higher(cur-1);
long tl = te.floor(cur);
long tr = te.higher(cur-1);

long ans = LINF;
// 右右
ans = min(ans, min(jr, tr) - cur + max(jr, tr) - min(jr, tr));

// 左左
ans = min(ans, cur - max(jl, tl) + max(jl, tl) - min(jl, tl));

// 右寺 左神
ans = min(ans, abs(tr - cur) * 2 + abs(jl - cur));

// 右神 左寺
ans = min(ans, abs(jr - cur) * 2 + abs(tl - cur));

// 左寺 右神
ans = min(ans, abs(tl - cur) * 2 + abs(jr - cur));

// 左神 右寺
ans = min(ans, abs(jl - cur) * 2 + abs(tr - cur));

out.println(ans);
}
}
}

static class MyInput {
private static int pos;
private static final char[] buffer = new char[1024 * 8];
private static char[] str = new char[500 * 8 * 2];
private static boolean[] isDigit = new boolean[256];
private static boolean[] isSpace = new boolean[256];
private static boolean[] isLineSep = new boolean[256];

static {
for (int i = 0; i < 10; i++) {
isDigit['0' + i] = true;
}
isDigit['-'] = true;
isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
isLineSep['\r'] = isLineSep['\n'] = true;
}

public MyInput(InputStream is) {
}

pos = 0;
try {
} catch (IOException e) {
throw new RuntimeException();
}
throw new MyInput.EndOfFileRuntimeException();
}
}
return buffer[pos++];
}

public int nextInt() {
int len = 0;
str[len++] = nextChar();
int i = 0;
int ret = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < len; i++)
ret = ret * 10 + str[i] - '0';
if (str[0] == '-') {
ret = -ret;
}
return ret;
}

public long nextLong() {
int len = 0;
str[len++] = nextChar();
int i = 0;
long ret = 0;
if (str[0] == '-') {
i = 1;
}
for (; i < len; i++)
ret = ret * 10 + str[i] - '0';
if (str[0] == '-') {
ret = -ret;
}
return ret;
}

public char nextChar() {
while (true) {
if (!isSpace[c]) {
return (char) c;
}
}
}

public String nextString() {
return new String(nextChars());
}

public char[] nextChars() {
int len = 0;
str[len++] = nextChar();
return Arrays.copyOf(str, len);
}

public char[][] next2DChars(int h, int w) {
char[][] s = new char[h][w];
for (int i = 0; i < h; i++) {
s[i] = nextChars();
}
return s;
}

int reads(int len, boolean[] accept) {
try {
while (true) {
if (accept[c]) {
break;
}
if (str.length == len) {
char[] rep = new char[str.length * 3 / 2];
System.arraycopy(str, 0, rep, 0, str.length);
str = rep;
}
str[len++] = (char) c;
}
} catch (MyInput.EndOfFileRuntimeException e) {
}
return len;
}

public int[] nextIntArray(final int n) {
final int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = nextInt();
}
return res;
}

public int[] nextIntArray1Index(final int n) {
final int[] res = new int[n + 1];
for (int i = 1; i < n + 1; i++) {
res[i] = nextInt();
}
return res;
}

public int[] nextIntArrayDec(final int n) {
final int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = nextInt() - 1;
}
return res;
}

public long[] nextLongArray(final int n) {
final long[] res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = nextLong();
}
return res;
}

public long[] nextLongArray1Index(final int n) {
final long[] res = new long[n + 1];
for (int i = 1; i < n + 1; i++) {
res[i] = nextLong();
}
return res;
}

public long[] nextLongArrayDec(final int n) {
final long[] res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = nextLong() - 1;
}
return res;
}

public double nextDouble() {
return Double.parseDouble(nextString());
}

public double[] nextDoubleArray(int n) {
double[] res = new double[n];
for (int i = 0; i < n; i++) {
res[i] = nextDouble();
}
return res;
}

static class EndOfFileRuntimeException extends RuntimeException {
}

}

}
```

#### Submission Info

Submission Time 2019-02-25 08:54:51+0900 D - Lazy Faith tutuz Java8 (OpenJDK 1.8.0) 400 6049 Byte AC 485 ms 56672 KB

#### Test Cases

Set Name Score / Max Score Test Cases
Sample 0 / 0 a01, a02
All 400 / 400 a01, a02, b03, b04, b05, b06, b07, b08, b09, b10, b11, b12, b13
Case Name Status Exec Time Memory
a01 84 ms 19156 KB
a02 76 ms 21204 KB
b03 74 ms 17748 KB
b04 382 ms 49976 KB
b05 342 ms 47952 KB
b06 479 ms 56360 KB
b07 444 ms 53608 KB
b08 436 ms 56488 KB
b09 406 ms 54248 KB
b10 419 ms 56672 KB
b11 485 ms 54352 KB
b12 424 ms 54876 KB
b13 391 ms 56220 KB