id stringlengths 22 25 | content stringlengths 327 628k | max_stars_repo_path stringlengths 49 49 |
|---|---|---|
condefects-java_data_1501 | import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt();
while(a >= b) {
System.out.printf("%d ",a);
a += c;
}
}
}
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt(), b = sc.nextInt(), c = sc.nextInt();
while(a <= b) {
System.out.printf("%d ",a);
a += c;
}
}
} | ConDefects/ConDefects/Code/abc340_a/Java/54889264 |
condefects-java_data_1502 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner An = new Scanner(System.in);
int A = An.nextInt();
int B = An.nextInt();
int D = An.nextInt();
for(int C = A; C < B; C += D){
System.out.println(C);
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner An = new Scanner(System.in);
int A = An.nextInt();
int B = An.nextInt();
int D = An.nextInt();
for (int C = A; C <= B; C += D) {
System.out.println(C);
}
}
} | ConDefects/ConDefects/Code/abc340_a/Java/52506270 |
condefects-java_data_1503 | import java.util.*;
class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int a,b,d;
a = sc.nextInt();
b = sc.nextInt();
d = sc.nextInt();
for(int i=0;i<=(b-a)/d;i++){
System.out.print(a+i*b+" ");
}
}
}
import java.util.*;
class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int a,b,d;
a = sc.nextInt();
b = sc.nextInt();
d = sc.nextInt();
for(int i=0;i<=(b-a)/d;i++){
System.out.print(a+i*d+" ");
}
}
} | ConDefects/ConDefects/Code/abc340_a/Java/52717698 |
condefects-java_data_1504 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] n = Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
for (int i = n[0]; i <= n[2]; i += n[1]) {
System.out.print(i + " ");
}
br.close();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] n = Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
for (int i = n[0]; i <= n[1]; i += n[2]) {
System.out.print(i + " ");
}
br.close();
}
}
| ConDefects/ConDefects/Code/abc340_a/Java/53981961 |
condefects-java_data_1505 | import java.util.*;
public class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int ans = 0;
int max = 0;
int secound = 0;
int[] array = new int[N];
boolean flg = true;
ArrayList<Integer> list = new ArrayList<>();
for(int i = 0; i < N; i++){
array[i] = sc.nextInt();
list.add(array[i]);
if(flg){
max = array[i];
flg = false;
}
}
list.removeAll(Collections.singleton(max));
for(int num : list){
if(secound < num){
secound = num;
}
}
System.out.print(secound);
}
}
import java.util.*;
public class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int ans = 0;
int max = 0;
int secound = 0;
int[] array = new int[N];
boolean flg = true;
ArrayList<Integer> list = new ArrayList<>();
for(int i = 0; i < N; i++){
array[i] = sc.nextInt();
list.add(array[i]);
if(flg){
max = array[i];
flg = false;
}else if(max < array[i]){
max = array[i];
}
}
list.removeAll(Collections.singleton(max));
for(int num : list){
if(secound < num){
secound = num;
}
}
System.out.print(secound);
}
} | ConDefects/ConDefects/Code/abc329_b/Java/49054621 |
condefects-java_data_1506 | import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.StringJoiner;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static void solve() {
int n = sc.nextInt();
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
list.add(sc.nextInt());
}
List<Integer> list2 = new ArrayList<Integer>(new HashSet<>(list));
System.out.println(list2.get(list2.size() - 2));
}
final static ContestsPrinter pw = new ContestsPrinter();
final static FastScanner sc = new FastScanner();
public static void main(String[] args) {
solve();
pw.close();
}
/*
* /////////////////////////////////////////////////////////////////////////////
* My Library *
*
* @author Rounin（ウソです。諸先輩方の知恵を流用しています）
*//////////////////////////////////////////////////////////////////////////////
/**
* 階乗を算出する
* [引数]n：任意の整数(int)
* [戻り値] 任意の整数を階乗した値
*/
static long factorial(int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
/**
* べき乗を行う
* [引数]m：底となる整数(int)、n：べき指数となる整数(int)
* [戻り値] 計算結果(int)
*/
static int exponentiation(int m, int n) {
if (n == 0)
return 1;
int ans = m;
for (int i = 1; i < n; i++)
ans = ans * m;
return ans;
}
/**
* 順列を生成する
* [引数]array：配列(int)、start：任意の整数(int)、end：任意の整数(int)
* [戻り値] boolean
*/
static boolean nextPermutation(int[] array, int start, int end) {
if (array == null || start > end || start < 0 || end > array.length) {
System.out.println("Error: 引数が正しくありません。");
return false;
}
for (int i = end - 2; i >= start; i--) {
if (array[i] < array[i + 1]) {
int j = end - 1;
while (array[i] >= array[j]) {
j--;
}
// swap
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
Arrays.sort(array, i + 1, end);
return true;
}
}
return false;
}
/**
* 最大公約数を算出する
* [引数]a：任意の整数(int)、b：任意の整数(int)
* [戻り値] 最大公約数
*/
static int gcd(int a, int b) {
return b > 0 ? gcd(b, a % b) : a;
}
/**
* 最小公倍数を算出する
* [引数]a：任意の整数(int)、b：任意の整数(int)
* [戻り値] 最小公倍数
*/
static int lcm(int a, int b) {
return a * b / gcd(a, b);
}
/**
* 任意の値から値までの間にある約数を算出する
* [引数]start：任意の整数(int)、end：任意の整数(int)
* [戻り値] 約数の数
*/
static int calculateDivisorsInRange(int start, int end) {
int cnt = 0;
for (int i = start; i <= end; i++) {
for (int j = 1; j <= i; j++) {
if (i % j == 0)
cnt++;
}
}
return cnt;
}
/**
* 素数判定を行う
* [引数]n：任意の整数(int)
* [戻り値] boolean
*/
static boolean isPrime(int n) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
double d = Math.sqrt(n);
for (int i = 3; i <= d; i += 2)
if (n % i == 0) {
return false;
}
return true;
}
/**
* 倍数判定（10進数以外のときに有用）を行う
* [引数]s：任意の文字列(String)、base：任意の整数(int)、m：任意の整数(int)
* [戻り値] boolean
*/
static boolean isMultiple(String s, int base, int m) {
int temp = 0;
for (int i = 0; i < s.length(); i++) {
temp = (temp * base + Character.getNumericValue(s.charAt(i))) % m;
}
if (temp == 0) {
return true;
}
return false;
}
/**
* 進数変換を行う
* [引数]sm：任意の文字列(String)、m：変換前の進数(int)、n：変換後の進数(int)
* [戻り値] 進数変換後の文字列
*/
static String toNbase(String sm, int m, int n) {
return Long.toString(Long.parseLong(sm, m), n);
}
/**
* int配列を降順にソートする
*/
public static void sortDes(int[] a) {
Arrays.sort(a);
var temp = Arrays.copyOf(a, a.length);
for (int i = 0; i < temp.length; i++) {
a[i] = temp[temp.length - i - 1];
}
}
/**
* long配列を降順にソートする
*/
public static void sortDes(long[] a) {
Arrays.sort(a);
var temp = Arrays.copyOf(a, a.length);
for (int i = 0; i < temp.length; i++) {
a[i] = temp[temp.length - i - 1];
}
}
/*--- ---*/
/*--- util ---*/
/*--- ---*/
public static List<Integer> toList(int[] a) {
return Arrays.stream(a).boxed().collect(Collectors.toList());
}
public static List<Long> toList(long[] a) {
return Arrays.stream(a).boxed().collect(Collectors.toList());
}
public static String reverse(String str) {
return new StringBuilder().append(str).reverse().toString();
}
public static boolean isKaibun(String str) {
return str.equals(reverse(str));
}
public static String toString(int a) {
return String.valueOf(a);
}
public static String toString(long a) {
return String.valueOf(a);
}
public static int toInt(String a) {
return Integer.valueOf(a);
}
public static long toLong(String a) {
return Long.valueOf(a);
}
public static char[] toCharArray(int a) {
return String.valueOf(a).toCharArray();
}
public static char[] toCharArray(long a) {
return String.valueOf(a).toCharArray();
}
public static char[] toCharArray(String a) {
return a.toCharArray();
}
public static boolean isAllTrue(boolean[] boo) {
for (boolean b : boo) {
if (!b)
return false;
}
return true;
}
public static int cntBoolean(boolean[] boo) {
int cnt = 0;
for (boolean b : boo) {
if (b)
cnt++;
}
return cnt;
}
public static void sort(int[] a) {
Arrays.sort(a);
}
public static void sort(long[] a) {
Arrays.sort(a);
}
public static int abs(int a, int b) {
return Math.abs(a - b);
}
public static long abs(long a, long b) {
return Math.abs(a - b);
}
public static void fill(int[] array, int val) {
Arrays.fill(array, val);
}
public static void fill(char[] array, char val) {
Arrays.fill(array, val);
}
public static void fill(boolean[] array, boolean val) {
Arrays.fill(array, val);
}
public static void fill(int[][] array, int val) {
for (var a : array)
Arrays.fill(a, val);
}
public static void fill(long[] array, long val) {
Arrays.fill(array, val);
}
public static void fill(long[][] array, long val) {
for (var a : array)
Arrays.fill(a, val);
}
public static void initializeDp(int[][] dp, int val) {
fill(dp, val);
dp[0][0] = 0;
}
public static void initializeDp(long[][] dp, long val) {
fill(dp, val);
dp[0][0] = 0L;
}
public static int max(int... array) {
return Arrays.stream(array).max().getAsInt();
}
public static int sum(int... array) {
return Arrays.stream(array).sum();
}
public static int max(int a, int b) {
return Math.max(a, b);
}
public static int min(int... array) {
return Arrays.stream(array).min().getAsInt();
}
public static int min(int a, int b) {
return Math.min(a, b);
}
public static long max(long... array) {
return Arrays.stream(array).max().getAsLong();
}
public static long max(long a, long b) {
return Math.max(a, b);
}
public static long sum(long... array) {
return Arrays.stream(array).sum();
}
public static long min(long a, long b) {
return Math.min(a, b);
}
public static long min(long... array) {
return Arrays.stream(array).min().getAsLong();
}
/*--- ---*/
/*--- debug ---*/
/*--- ---*/
public static void debug(Object o, Object... args) {
var format = "%s";
var temp = new Object[args.length + 1];
temp[0] = o;
System.arraycopy(args, 0, temp, 1, args.length);
for (int i = 0; i < temp.length - 1; i++) {
format += " %s";
}
System.out.printf(format, temp);
System.out.println("");
}
public static void debug(int[] x) {
out(Arrays.toString(x));
}
public static void debug(boolean[] x) {
out(Arrays.toString(x));
}
public static void debug(long[] x) {
out(Arrays.toString(x));
}
public static void debug(int[][] x) {
out(Arrays.deepToString(x));
}
public static void debugln(int[][] x) {
for (int[] w : x) {
for (var i : w) {
System.err.print(i + " ");
}
out("");
}
out("///////////////////");
}
public static void debug(long[][] x) {
out(Arrays.deepToString(x));
}
public static void debugln(long[][] x) {
for (long[] w : x) {
for (var i : w) {
System.err.print(i + " ");
}
out("");
}
out("///////////////////");
}
public static void debug(boolean[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(char[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(Object[] x) {
out(Arrays.toString(x));
}
public static void debug(Object[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(Object a) {
System.err.println(a);
}
public static void out(String x) {
System.err.println(x);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int size) {
int[] intArray = new int[size];
Arrays.setAll(intArray, i -> nextInt());
return intArray;
}
public int[] nextIntArray(int size, IntUnaryOperator map) {
int[] intArray = new int[size];
Arrays.setAll(intArray, i -> map.applyAsInt(nextInt()));
return intArray;
}
public int[] nextIntArrayOneToZeroIndex(int size) {
return nextIntArray(size, i -> i - 1);
}
public long[] nextLongArray(int size) {
long[] longArray = new long[size];
Arrays.setAll(longArray, i -> nextLong());
return longArray;
}
public long[] nextLongArray(int size, LongUnaryOperator map) {
long[] longArray = new long[size];
Arrays.setAll(longArray, i -> map.applyAsLong(nextLong()));
return longArray;
}
public String[] nextStringArray(int size) {
String[] stringArray = new String[size];
Arrays.setAll(stringArray, i -> next());
return stringArray;
}
public List<String> nextStringList(int size) {
List<String> list = new ArrayList<>();
for (int i = 0; i < size; i++)
list.add(next());
return list;
}
public Integer[] nextIntegerArray(int size) {
Integer[] ret = new Integer[size];
for (int i = 0; i < size; i++)
ret[i] = nextInt();
return ret;
}
public Integer[] nextIntegerArray(int size, IntUnaryOperator map) {
Integer[] ret = new Integer[size];
for (int i = 0; i < size; i++)
ret[i] = map.applyAsInt(nextInt());
return ret;
}
public char[][] nextDimensionalCharArray(int h, int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) {
array[i] = next().toCharArray();
}
return array;
}
public int[][] nextDimensionalIntArray(int h, int w) {
int[][] array = new int[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
array[i][j] = nextInt();
}
}
return array;
}
public long[][] nextDimensionalLongArray(int h, int w) {
long[][] array = new long[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
array[i][j] = nextLong();
}
}
return array;
}
public int[][] nextIntArrayFromStr(int h, int w) {
int[][] array = new int[h][w];
for (int i = 0; i < h; i++) {
String temp = next();
for (int j = 0; j < w; j++) {
array[i][j] = temp.charAt(j) - '0';
}
}
return array;
}
public List<Integer> nextIntgerList(int size) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < size; i++)
list.add(nextInt());
return list;
}
public List<Integer> nextIntgerList(int size, IntUnaryOperator map) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < size; i++)
list.add(map.applyAsInt(nextInt()));
return list;
}
}
class ContestsPrinter extends java.io.PrintWriter {
public ContestsPrinter(java.io.PrintStream stream) {
super(stream);
}
public ContestsPrinter(java.io.File file) throws java.io.FileNotFoundException {
super(new java.io.PrintStream(file));
}
public ContestsPrinter() {
super(System.out);
}
private static String doubleToString(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(doubleToString(f, 20));
}
@Override
public void println(float f) {
super.println(doubleToString(f, 20));
}
@Override
public void print(double d) {
super.print(doubleToString(d, 20));
}
@Override
public void println(double d) {
super.println(doubleToString(d, 20));
}
@Override
public void print(boolean boo) {
super.print(boo ? "Yes" : "No");
}
public void print(int[] array, String separator) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void print(int[] array) {
this.print(array, " ");
}
public void print(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n - 1]));
}
public void print(int[] array, java.util.function.IntUnaryOperator map) {
this.print(array, " ", map);
}
public void print(long[] array, String separator) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void print(long[] array) {
this.print(array, " ");
}
public void print(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n - 1]));
}
public void print(long[] array, java.util.function.LongUnaryOperator map) {
this.print(array, " ", map);
}
public <T> void print(T[] array, String separator) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public <T> void print(T[] array) {
this.print(array, " ");
}
public <T> void print(T[] array, String separator, java.util.function.UnaryOperator<T> map) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(map.apply(array[i]));
super.print(separator);
}
super.println(map.apply(array[n - 1]));
}
public <T> void print(T[] array, java.util.function.UnaryOperator<T> map) {
this.print(array, " ", map);
}
public String getOutputCollection(Collection<?> c) {
return String.join(" ", c.stream().map(String::valueOf).collect(Collectors.toList()));
}
public void print(Collection<?> c) {
super.print(getOutputCollection(c));
}
public void println(Collection<?> c) {
StringBuilder sb = new StringBuilder();
for (Object object : c) {
if (sb.length() != 0)
sb.append("\r\n");
sb.append(object);
}
System.out.println(sb);
}
public void println(int[] array) {
print(array, "\r\n");
}
public void println(long[] array) {
print(array, "\r\n");
}
public void print(String[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (String str : a) {
joiner.add(str);
}
System.out.println(joiner);
}
public void println(String[] a) {
StringJoiner joiner = new StringJoiner("\r\n");
for (String str : a) {
joiner.add(str);
}
System.out.println(joiner);
}
public void print(Object obj) {
System.out.print(obj);
}
public void println(Object obj) {
System.out.println(obj);
}
public void printlnDeep(ArrayList<ArrayList<Integer>> c) {
StringBuilder sb = new StringBuilder();
for (var ci : c)
sb.append(getOutputCollection(ci)).append("\r\n");
System.out.println(sb);
}
public void printZeroToOneIndex(int[] a) {
print(a, i -> i + 1);
}
public void printZeroToOneIndex(List<Integer> a) {
print(a.stream().map(i -> i + 1).collect(Collectors.toList()));
}
public void printlnZeroToOneIndex(List<Integer> a) {
println(a.stream().map(i -> i + 1).collect(Collectors.toList()));
}
public void print(boolean[] a) {
for (int i = 0; i < a.length; i++) {
System.out.println(a[i] + " ");
}
System.out.println("");
}
public void print(boolean[][] b) {
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[0].length; j++) {
System.out.print(b[i][j] ? "o" : "x");
}
System.out.println("");
}
}
public void print(int[][] array) {
for (var i : array)
print(i);
}
public void print(long[][] array) {
for (var i : array)
print(i);
}
public void print(char[][] array) {
for (char[] cs : array) {
for (char c : cs) {
print(c);
}
println();
}
}
}
class Graph {
List<ArrayList<Integer>> g;
int v;
int e;
boolean[] visited;
public Graph(int v) {
this.v = v;
for (var i = 0; i < v; i++)
g.add(new ArrayList<Integer>());
visited = new boolean[v];
}
public void addEdge(int a, int b) {
g.get(a).add(b);
g.get(b).add(a);
e++;
}
public void dfs(int now) {
visited[now] = true;
for (var next : g.get(now)) {
if (visited[next])
continue;
dfs(next);
}
}
public boolean marked(int now) {
return visited[now];
}
public boolean isAllConected() {
for (var bo : visited) {
if (!bo)
return false;
}
return true;
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.StringJoiner;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static void solve() {
int n = sc.nextInt();
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
list.add(sc.nextInt());
}
List<Integer> list2 = new ArrayList<Integer>(new HashSet<>(list));
Collections.sort(list2);
System.out.println(list2.get(list2.size() - 2));
}
final static ContestsPrinter pw = new ContestsPrinter();
final static FastScanner sc = new FastScanner();
public static void main(String[] args) {
solve();
pw.close();
}
/*
* /////////////////////////////////////////////////////////////////////////////
* My Library *
*
* @author Rounin（ウソです。諸先輩方の知恵を流用しています）
*//////////////////////////////////////////////////////////////////////////////
/**
* 階乗を算出する
* [引数]n：任意の整数(int)
* [戻り値] 任意の整数を階乗した値
*/
static long factorial(int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
/**
* べき乗を行う
* [引数]m：底となる整数(int)、n：べき指数となる整数(int)
* [戻り値] 計算結果(int)
*/
static int exponentiation(int m, int n) {
if (n == 0)
return 1;
int ans = m;
for (int i = 1; i < n; i++)
ans = ans * m;
return ans;
}
/**
* 順列を生成する
* [引数]array：配列(int)、start：任意の整数(int)、end：任意の整数(int)
* [戻り値] boolean
*/
static boolean nextPermutation(int[] array, int start, int end) {
if (array == null || start > end || start < 0 || end > array.length) {
System.out.println("Error: 引数が正しくありません。");
return false;
}
for (int i = end - 2; i >= start; i--) {
if (array[i] < array[i + 1]) {
int j = end - 1;
while (array[i] >= array[j]) {
j--;
}
// swap
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
Arrays.sort(array, i + 1, end);
return true;
}
}
return false;
}
/**
* 最大公約数を算出する
* [引数]a：任意の整数(int)、b：任意の整数(int)
* [戻り値] 最大公約数
*/
static int gcd(int a, int b) {
return b > 0 ? gcd(b, a % b) : a;
}
/**
* 最小公倍数を算出する
* [引数]a：任意の整数(int)、b：任意の整数(int)
* [戻り値] 最小公倍数
*/
static int lcm(int a, int b) {
return a * b / gcd(a, b);
}
/**
* 任意の値から値までの間にある約数を算出する
* [引数]start：任意の整数(int)、end：任意の整数(int)
* [戻り値] 約数の数
*/
static int calculateDivisorsInRange(int start, int end) {
int cnt = 0;
for (int i = start; i <= end; i++) {
for (int j = 1; j <= i; j++) {
if (i % j == 0)
cnt++;
}
}
return cnt;
}
/**
* 素数判定を行う
* [引数]n：任意の整数(int)
* [戻り値] boolean
*/
static boolean isPrime(int n) {
if (n == 2)
return true;
if (n < 2 || n % 2 == 0)
return false;
double d = Math.sqrt(n);
for (int i = 3; i <= d; i += 2)
if (n % i == 0) {
return false;
}
return true;
}
/**
* 倍数判定（10進数以外のときに有用）を行う
* [引数]s：任意の文字列(String)、base：任意の整数(int)、m：任意の整数(int)
* [戻り値] boolean
*/
static boolean isMultiple(String s, int base, int m) {
int temp = 0;
for (int i = 0; i < s.length(); i++) {
temp = (temp * base + Character.getNumericValue(s.charAt(i))) % m;
}
if (temp == 0) {
return true;
}
return false;
}
/**
* 進数変換を行う
* [引数]sm：任意の文字列(String)、m：変換前の進数(int)、n：変換後の進数(int)
* [戻り値] 進数変換後の文字列
*/
static String toNbase(String sm, int m, int n) {
return Long.toString(Long.parseLong(sm, m), n);
}
/**
* int配列を降順にソートする
*/
public static void sortDes(int[] a) {
Arrays.sort(a);
var temp = Arrays.copyOf(a, a.length);
for (int i = 0; i < temp.length; i++) {
a[i] = temp[temp.length - i - 1];
}
}
/**
* long配列を降順にソートする
*/
public static void sortDes(long[] a) {
Arrays.sort(a);
var temp = Arrays.copyOf(a, a.length);
for (int i = 0; i < temp.length; i++) {
a[i] = temp[temp.length - i - 1];
}
}
/*--- ---*/
/*--- util ---*/
/*--- ---*/
public static List<Integer> toList(int[] a) {
return Arrays.stream(a).boxed().collect(Collectors.toList());
}
public static List<Long> toList(long[] a) {
return Arrays.stream(a).boxed().collect(Collectors.toList());
}
public static String reverse(String str) {
return new StringBuilder().append(str).reverse().toString();
}
public static boolean isKaibun(String str) {
return str.equals(reverse(str));
}
public static String toString(int a) {
return String.valueOf(a);
}
public static String toString(long a) {
return String.valueOf(a);
}
public static int toInt(String a) {
return Integer.valueOf(a);
}
public static long toLong(String a) {
return Long.valueOf(a);
}
public static char[] toCharArray(int a) {
return String.valueOf(a).toCharArray();
}
public static char[] toCharArray(long a) {
return String.valueOf(a).toCharArray();
}
public static char[] toCharArray(String a) {
return a.toCharArray();
}
public static boolean isAllTrue(boolean[] boo) {
for (boolean b : boo) {
if (!b)
return false;
}
return true;
}
public static int cntBoolean(boolean[] boo) {
int cnt = 0;
for (boolean b : boo) {
if (b)
cnt++;
}
return cnt;
}
public static void sort(int[] a) {
Arrays.sort(a);
}
public static void sort(long[] a) {
Arrays.sort(a);
}
public static int abs(int a, int b) {
return Math.abs(a - b);
}
public static long abs(long a, long b) {
return Math.abs(a - b);
}
public static void fill(int[] array, int val) {
Arrays.fill(array, val);
}
public static void fill(char[] array, char val) {
Arrays.fill(array, val);
}
public static void fill(boolean[] array, boolean val) {
Arrays.fill(array, val);
}
public static void fill(int[][] array, int val) {
for (var a : array)
Arrays.fill(a, val);
}
public static void fill(long[] array, long val) {
Arrays.fill(array, val);
}
public static void fill(long[][] array, long val) {
for (var a : array)
Arrays.fill(a, val);
}
public static void initializeDp(int[][] dp, int val) {
fill(dp, val);
dp[0][0] = 0;
}
public static void initializeDp(long[][] dp, long val) {
fill(dp, val);
dp[0][0] = 0L;
}
public static int max(int... array) {
return Arrays.stream(array).max().getAsInt();
}
public static int sum(int... array) {
return Arrays.stream(array).sum();
}
public static int max(int a, int b) {
return Math.max(a, b);
}
public static int min(int... array) {
return Arrays.stream(array).min().getAsInt();
}
public static int min(int a, int b) {
return Math.min(a, b);
}
public static long max(long... array) {
return Arrays.stream(array).max().getAsLong();
}
public static long max(long a, long b) {
return Math.max(a, b);
}
public static long sum(long... array) {
return Arrays.stream(array).sum();
}
public static long min(long a, long b) {
return Math.min(a, b);
}
public static long min(long... array) {
return Arrays.stream(array).min().getAsLong();
}
/*--- ---*/
/*--- debug ---*/
/*--- ---*/
public static void debug(Object o, Object... args) {
var format = "%s";
var temp = new Object[args.length + 1];
temp[0] = o;
System.arraycopy(args, 0, temp, 1, args.length);
for (int i = 0; i < temp.length - 1; i++) {
format += " %s";
}
System.out.printf(format, temp);
System.out.println("");
}
public static void debug(int[] x) {
out(Arrays.toString(x));
}
public static void debug(boolean[] x) {
out(Arrays.toString(x));
}
public static void debug(long[] x) {
out(Arrays.toString(x));
}
public static void debug(int[][] x) {
out(Arrays.deepToString(x));
}
public static void debugln(int[][] x) {
for (int[] w : x) {
for (var i : w) {
System.err.print(i + " ");
}
out("");
}
out("///////////////////");
}
public static void debug(long[][] x) {
out(Arrays.deepToString(x));
}
public static void debugln(long[][] x) {
for (long[] w : x) {
for (var i : w) {
System.err.print(i + " ");
}
out("");
}
out("///////////////////");
}
public static void debug(boolean[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(char[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(Object[] x) {
out(Arrays.toString(x));
}
public static void debug(Object[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(Object a) {
System.err.println(a);
}
public static void out(String x) {
System.err.println(x);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int size) {
int[] intArray = new int[size];
Arrays.setAll(intArray, i -> nextInt());
return intArray;
}
public int[] nextIntArray(int size, IntUnaryOperator map) {
int[] intArray = new int[size];
Arrays.setAll(intArray, i -> map.applyAsInt(nextInt()));
return intArray;
}
public int[] nextIntArrayOneToZeroIndex(int size) {
return nextIntArray(size, i -> i - 1);
}
public long[] nextLongArray(int size) {
long[] longArray = new long[size];
Arrays.setAll(longArray, i -> nextLong());
return longArray;
}
public long[] nextLongArray(int size, LongUnaryOperator map) {
long[] longArray = new long[size];
Arrays.setAll(longArray, i -> map.applyAsLong(nextLong()));
return longArray;
}
public String[] nextStringArray(int size) {
String[] stringArray = new String[size];
Arrays.setAll(stringArray, i -> next());
return stringArray;
}
public List<String> nextStringList(int size) {
List<String> list = new ArrayList<>();
for (int i = 0; i < size; i++)
list.add(next());
return list;
}
public Integer[] nextIntegerArray(int size) {
Integer[] ret = new Integer[size];
for (int i = 0; i < size; i++)
ret[i] = nextInt();
return ret;
}
public Integer[] nextIntegerArray(int size, IntUnaryOperator map) {
Integer[] ret = new Integer[size];
for (int i = 0; i < size; i++)
ret[i] = map.applyAsInt(nextInt());
return ret;
}
public char[][] nextDimensionalCharArray(int h, int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) {
array[i] = next().toCharArray();
}
return array;
}
public int[][] nextDimensionalIntArray(int h, int w) {
int[][] array = new int[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
array[i][j] = nextInt();
}
}
return array;
}
public long[][] nextDimensionalLongArray(int h, int w) {
long[][] array = new long[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
array[i][j] = nextLong();
}
}
return array;
}
public int[][] nextIntArrayFromStr(int h, int w) {
int[][] array = new int[h][w];
for (int i = 0; i < h; i++) {
String temp = next();
for (int j = 0; j < w; j++) {
array[i][j] = temp.charAt(j) - '0';
}
}
return array;
}
public List<Integer> nextIntgerList(int size) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < size; i++)
list.add(nextInt());
return list;
}
public List<Integer> nextIntgerList(int size, IntUnaryOperator map) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < size; i++)
list.add(map.applyAsInt(nextInt()));
return list;
}
}
class ContestsPrinter extends java.io.PrintWriter {
public ContestsPrinter(java.io.PrintStream stream) {
super(stream);
}
public ContestsPrinter(java.io.File file) throws java.io.FileNotFoundException {
super(new java.io.PrintStream(file));
}
public ContestsPrinter() {
super(System.out);
}
private static String doubleToString(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(doubleToString(f, 20));
}
@Override
public void println(float f) {
super.println(doubleToString(f, 20));
}
@Override
public void print(double d) {
super.print(doubleToString(d, 20));
}
@Override
public void println(double d) {
super.println(doubleToString(d, 20));
}
@Override
public void print(boolean boo) {
super.print(boo ? "Yes" : "No");
}
public void print(int[] array, String separator) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void print(int[] array) {
this.print(array, " ");
}
public void print(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n - 1]));
}
public void print(int[] array, java.util.function.IntUnaryOperator map) {
this.print(array, " ", map);
}
public void print(long[] array, String separator) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void print(long[] array) {
this.print(array, " ");
}
public void print(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n - 1]));
}
public void print(long[] array, java.util.function.LongUnaryOperator map) {
this.print(array, " ", map);
}
public <T> void print(T[] array, String separator) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public <T> void print(T[] array) {
this.print(array, " ");
}
public <T> void print(T[] array, String separator, java.util.function.UnaryOperator<T> map) {
int n = array.length;
if (n == 0) {
super.println();
return;
}
for (int i = 0; i < n - 1; i++) {
super.print(map.apply(array[i]));
super.print(separator);
}
super.println(map.apply(array[n - 1]));
}
public <T> void print(T[] array, java.util.function.UnaryOperator<T> map) {
this.print(array, " ", map);
}
public String getOutputCollection(Collection<?> c) {
return String.join(" ", c.stream().map(String::valueOf).collect(Collectors.toList()));
}
public void print(Collection<?> c) {
super.print(getOutputCollection(c));
}
public void println(Collection<?> c) {
StringBuilder sb = new StringBuilder();
for (Object object : c) {
if (sb.length() != 0)
sb.append("\r\n");
sb.append(object);
}
System.out.println(sb);
}
public void println(int[] array) {
print(array, "\r\n");
}
public void println(long[] array) {
print(array, "\r\n");
}
public void print(String[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (String str : a) {
joiner.add(str);
}
System.out.println(joiner);
}
public void println(String[] a) {
StringJoiner joiner = new StringJoiner("\r\n");
for (String str : a) {
joiner.add(str);
}
System.out.println(joiner);
}
public void print(Object obj) {
System.out.print(obj);
}
public void println(Object obj) {
System.out.println(obj);
}
public void printlnDeep(ArrayList<ArrayList<Integer>> c) {
StringBuilder sb = new StringBuilder();
for (var ci : c)
sb.append(getOutputCollection(ci)).append("\r\n");
System.out.println(sb);
}
public void printZeroToOneIndex(int[] a) {
print(a, i -> i + 1);
}
public void printZeroToOneIndex(List<Integer> a) {
print(a.stream().map(i -> i + 1).collect(Collectors.toList()));
}
public void printlnZeroToOneIndex(List<Integer> a) {
println(a.stream().map(i -> i + 1).collect(Collectors.toList()));
}
public void print(boolean[] a) {
for (int i = 0; i < a.length; i++) {
System.out.println(a[i] + " ");
}
System.out.println("");
}
public void print(boolean[][] b) {
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[0].length; j++) {
System.out.print(b[i][j] ? "o" : "x");
}
System.out.println("");
}
}
public void print(int[][] array) {
for (var i : array)
print(i);
}
public void print(long[][] array) {
for (var i : array)
print(i);
}
public void print(char[][] array) {
for (char[] cs : array) {
for (char c : cs) {
print(c);
}
println();
}
}
}
class Graph {
List<ArrayList<Integer>> g;
int v;
int e;
boolean[] visited;
public Graph(int v) {
this.v = v;
for (var i = 0; i < v; i++)
g.add(new ArrayList<Integer>());
visited = new boolean[v];
}
public void addEdge(int a, int b) {
g.get(a).add(b);
g.get(b).add(a);
e++;
}
public void dfs(int now) {
visited[now] = true;
for (var next : g.get(now)) {
if (visited[next])
continue;
dfs(next);
}
}
public boolean marked(int now) {
return visited[now];
}
public boolean isAllConected() {
for (var bo : visited) {
if (!bo)
return false;
}
return true;
}
}
| ConDefects/ConDefects/Code/abc329_b/Java/54054141 |
condefects-java_data_1507 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static final long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010L;//10^18
public static void main(String[] args){
//PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int L = sc.nextInt();
int D = sc.nextInt();
double[] dp = new double[Math.max(n + 1, L - 1 + D)];
int s = dp.length;
SegTree<Double> seg = new SegTree<>(s, (a,b)->a+b, 0.0);
seg.set(0, 1.0);
double d = (double) D;
for (int i = 1; i < s; i++) {
int l = Math.max(0, i - D);
int r = Math.min(L, i);
dp[i] = l <= r ? seg.prod(l, r) / d : 0.0;
seg.set(i, dp[i]);
}
double[] dp2 = new double[n + 1];
double[] sum = new double[n + 2];
for (int i = n; i >= 0; i--) {
double cand1 = (i >= L ? seg.prod(L, i) : 0.0) + seg.prod(n + 1, s);
double cand2 = (- sum[Math.min(n + 1, i + D + 1)] + sum[i + 1]) / d;
dp2[i] = Math.max(cand1, cand2);
sum[i] = sum[i + 1] + dp2[i];
}
System.out.println(dp2[0]);
}
static class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
}
static long ceil(long a,long b){
return a%b==0?a/b:a/b+1;
}
static int ceil(int a,int b) {
if (a%b==0) {
return a/b;
}else {
return a/b+1;
}
}
static int lower_bound(int[] a, int fromIndex, int toIndex, int val) {
if (val > a[toIndex])
return toIndex + 1;
if (val <= a[fromIndex])
return fromIndex;
int lb = fromIndex - 1, ub = toIndex;
while (ub - lb > 1) {
int mid = (ub - lb)/2+lb;
if (a[mid] >= val) {
ub = mid;
} else {
lb = mid;
}
}
return ub;
}
static int lower_bound(long[] a, int fromIndex, int toIndex, long val) {
if (val > a[toIndex])
return toIndex + 1;
if (val <= a[fromIndex])
return fromIndex;
int lb = fromIndex - 1, ub = toIndex;
while (ub - lb > 1) {
int mid = (ub - lb)/2+lb;
if (a[mid] >= val) {
ub = mid;
} else {
lb = mid;
}
}
return ub;
}
static class UnionFindTree{
int[] par;
int[] rank;
int[] size;
long[] diff_weight;
int arraysize;
public UnionFindTree(int n) {
this.par=new int[n];
this.rank=new int[n];
this.size=new int[n];
this.diff_weight=new long[n];
arraysize=n;
for (int i = 0; i < arraysize; i++) {
set(i);
}
}
public void set(int i) {
par[i]=i;
rank[i]=0;
size[i]=1;
diff_weight[i]=0;
}
public void union(int x,int y,long w) {
w += weight(x);
w -= weight(y);
int rootx=find(x);
int rooty=find(y);
if (rootx==rooty) {
return;
}
if (rank[rootx]>rank[rooty]) {
par[rooty]=rootx;
diff_weight[rooty] = w;
size[rootx]+=size[rooty];
}
else if (rank[rootx]<rank[rooty]) {
par[rootx]=rooty;
w=-w;
diff_weight[rootx] = w;
size[rooty]+=size[rootx];
}
else {
par[rooty]=rootx;
diff_weight[rooty] = w;
rank[rootx]++;
size[rootx]+=size[rooty];
}
}
public int find(int x) {
if(par[x] == x) return x;
int r = find(par[x]);
diff_weight[x] += diff_weight[par[x]];
return par[x] = r;
}
public long weight(int x) {
find(x);
return diff_weight[x];
}
public int size(int i) {
return size[find(i)];
}
public long diff(int x, int y) {
return weight(y) - weight(x);
}
public boolean same(int x, int y) {
return find(x) == find(y);
}
public ArrayList<Integer>[] group() {
ArrayList<Integer>[] group = new ArrayList[arraysize];
for (int i = 0; i < group.length; i++) {
group[i] = new ArrayList<>();
}
for (int i = 0; i < arraysize; i++) {
group[find(i)].add(i);
}
return group;
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static final long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010L;//10^18
public static void main(String[] args){
//PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int L = sc.nextInt();
int D = sc.nextInt();
double[] dp = new double[Math.max(n + 1, L + D)];
int s = dp.length;
SegTree<Double> seg = new SegTree<>(s, (a,b)->a+b, 0.0);
seg.set(0, 1.0);
double d = (double) D;
for (int i = 1; i < s; i++) {
int l = Math.max(0, i - D);
int r = Math.min(L, i);
dp[i] = l <= r ? seg.prod(l, r) / d : 0.0;
seg.set(i, dp[i]);
}
double[] dp2 = new double[n + 1];
double[] sum = new double[n + 2];
for (int i = n; i >= 0; i--) {
double cand1 = (i >= L ? seg.prod(L, i) : 0.0) + seg.prod(n + 1, s);
double cand2 = (- sum[Math.min(n + 1, i + D + 1)] + sum[i + 1]) / d;
dp2[i] = Math.max(cand1, cand2);
sum[i] = sum[i + 1] + dp2[i];
}
System.out.println(dp2[0]);
}
static class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
}
static long ceil(long a,long b){
return a%b==0?a/b:a/b+1;
}
static int ceil(int a,int b) {
if (a%b==0) {
return a/b;
}else {
return a/b+1;
}
}
static int lower_bound(int[] a, int fromIndex, int toIndex, int val) {
if (val > a[toIndex])
return toIndex + 1;
if (val <= a[fromIndex])
return fromIndex;
int lb = fromIndex - 1, ub = toIndex;
while (ub - lb > 1) {
int mid = (ub - lb)/2+lb;
if (a[mid] >= val) {
ub = mid;
} else {
lb = mid;
}
}
return ub;
}
static int lower_bound(long[] a, int fromIndex, int toIndex, long val) {
if (val > a[toIndex])
return toIndex + 1;
if (val <= a[fromIndex])
return fromIndex;
int lb = fromIndex - 1, ub = toIndex;
while (ub - lb > 1) {
int mid = (ub - lb)/2+lb;
if (a[mid] >= val) {
ub = mid;
} else {
lb = mid;
}
}
return ub;
}
static class UnionFindTree{
int[] par;
int[] rank;
int[] size;
long[] diff_weight;
int arraysize;
public UnionFindTree(int n) {
this.par=new int[n];
this.rank=new int[n];
this.size=new int[n];
this.diff_weight=new long[n];
arraysize=n;
for (int i = 0; i < arraysize; i++) {
set(i);
}
}
public void set(int i) {
par[i]=i;
rank[i]=0;
size[i]=1;
diff_weight[i]=0;
}
public void union(int x,int y,long w) {
w += weight(x);
w -= weight(y);
int rootx=find(x);
int rooty=find(y);
if (rootx==rooty) {
return;
}
if (rank[rootx]>rank[rooty]) {
par[rooty]=rootx;
diff_weight[rooty] = w;
size[rootx]+=size[rooty];
}
else if (rank[rootx]<rank[rooty]) {
par[rootx]=rooty;
w=-w;
diff_weight[rootx] = w;
size[rooty]+=size[rootx];
}
else {
par[rooty]=rootx;
diff_weight[rooty] = w;
rank[rootx]++;
size[rootx]+=size[rooty];
}
}
public int find(int x) {
if(par[x] == x) return x;
int r = find(par[x]);
diff_weight[x] += diff_weight[par[x]];
return par[x] = r;
}
public long weight(int x) {
find(x);
return diff_weight[x];
}
public int size(int i) {
return size[find(i)];
}
public long diff(int x, int y) {
return weight(y) - weight(x);
}
public boolean same(int x, int y) {
return find(x) == find(y);
}
public ArrayList<Integer>[] group() {
ArrayList<Integer>[] group = new ArrayList[arraysize];
for (int i = 0; i < group.length; i++) {
group[i] = new ArrayList<>();
}
for (int i = 0; i < arraysize; i++) {
group[find(i)].add(i);
}
return group;
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
} | ConDefects/ConDefects/Code/abc342_f/Java/54647963 |
condefects-java_data_1508 | import java.util.*;
public class Main{
static void bfs(long a, long b) {
Deque<long[]> dq = new ArrayDeque<>();
dq.add(new long[]{a, b});
while (!dq.isEmpty()) {
int size = dq.size();
while (size-- > 0) {
long[] poll = dq.poll();
if (gcd(poll[0], poll[1]) == 1) {
System.out.println(Math.abs(b - a));
return;
}
dq.add(new long[]{poll[0] + 1, poll[1]});
dq.add(new long[]{poll[0], poll[1] - 1});
}
}
}
static long gcd(long a, long b) {
return a == 0 ? b : gcd(b % a, a);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long a = sc.nextLong(), b = sc.nextLong();
bfs(a, b);
}
}
import java.util.*;
public class Main{
static void bfs(long a, long b) {
Deque<long[]> dq = new ArrayDeque<>();
dq.add(new long[]{a, b});
while (!dq.isEmpty()) {
int size = dq.size();
while (size-- > 0) {
long[] poll = dq.poll();
if (gcd(poll[0], poll[1]) == 1) {
System.out.println(Math.abs(poll[1] - poll[0]));
return;
}
dq.add(new long[]{poll[0] + 1, poll[1]});
dq.add(new long[]{poll[0], poll[1] - 1});
}
}
}
static long gcd(long a, long b) {
return a == 0 ? b : gcd(b % a, a);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long a = sc.nextLong(), b = sc.nextLong();
bfs(a, b);
}
} | ConDefects/ConDefects/Code/arc137_a/Java/30560996 |
condefects-java_data_1509 | //ここからimport文
import java.util.*;
import java.io.*;
//import mylib.* ;
//ここまでimport文
public class Main{
static final int inf = Integer.MAX_VALUE / 2 ;
static final long longInf = Long.MAX_VALUE / 2L ;
static final int minf = inf * -1 ;
static final String LF = "\n" ;
static final int mod = 1000000007 ;
public static void main(String[] args) {
Scanner sc = new Scanner( System.in ) ;
PrintStream ps = new PrintStream( System.out ) ;
StringBuilder sb = new StringBuilder() ;
long L = sc.nextLong() ;
long R = sc.nextLong() ;
solve( L , R ) ;
sc.close() ;
ps.close() ;
}
public static void solve( long L , long R ) {
for ( long i = R - L ; ; i-- ) {
for ( long j = 0 ; j < ( R - L ) - i + 1L ; j++ ) {
if ( gcd( R + j , R + j - i ) == 1L ) {
System.out.println( i ) ;
return ;
}
}
}
}
public static long gcd( long a, long b ) {
if ( b > a ) return gcd( b, a ) ;
return b == 0L ? a : gcd( b, a % b ) ;
}
}
//ここからimport文
import java.util.*;
import java.io.*;
//import mylib.* ;
//ここまでimport文
public class Main{
static final int inf = Integer.MAX_VALUE / 2 ;
static final long longInf = Long.MAX_VALUE / 2L ;
static final int minf = inf * -1 ;
static final String LF = "\n" ;
static final int mod = 1000000007 ;
public static void main(String[] args) {
Scanner sc = new Scanner( System.in ) ;
PrintStream ps = new PrintStream( System.out ) ;
StringBuilder sb = new StringBuilder() ;
long L = sc.nextLong() ;
long R = sc.nextLong() ;
solve( L , R ) ;
sc.close() ;
ps.close() ;
}
public static void solve( long L , long R ) {
for ( long i = R - L ; ; i-- ) {
for ( long j = 0 ; j < ( R - L ) - i + 1L ; j++ ) {
if ( gcd( L + j , L + j + i ) == 1L ) {
System.out.println( i ) ;
return ;
}
}
}
}
public static long gcd( long a, long b ) {
if ( b > a ) return gcd( b, a ) ;
return b == 0L ? a : gcd( b, a % b ) ;
}
}
| ConDefects/ConDefects/Code/arc137_a/Java/30802732 |
condefects-java_data_1510 | // import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.*;
import java.io.*;
// import org.junit.jupiter.api.Test;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
Scanner scan = new Scanner(System.in);
int len = scan.nextInt();
char[][] a = new char[len][len];
char[][] b = new char[len][len];
for(int i = 0; i < len; i++) {
String s = scan.next();
char[] arr = s.toCharArray();
for(int j = 0; j < len; j++) {
a[i][j] = arr[j];
}
}
int index1 = 0;
int index2 = 0;
for(int i = 0; i < len; i++) {
String s = scan.next();
char[] arr = s.toCharArray();
for(int j = 0; j < len; j++) {
b[i][j] = arr[j];
}
}
for(int i = 0; i < len; i++) {
for(int j = 0; j < len; j++) {
if(a[i][j] != b[i][j]) {
index1 = i;
index2 = j;
}
}
}
System.out.println(index1 + " " + index2);
scan.close();
}
// @Test
// void addition() {
// assertEquals(2, 1 + 1);
// }
}
// import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.*;
import java.io.*;
// import org.junit.jupiter.api.Test;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
Scanner scan = new Scanner(System.in);
int len = scan.nextInt();
char[][] a = new char[len][len];
char[][] b = new char[len][len];
for(int i = 0; i < len; i++) {
String s = scan.next();
char[] arr = s.toCharArray();
for(int j = 0; j < len; j++) {
a[i][j] = arr[j];
}
}
int index1 = 0;
int index2 = 0;
for(int i = 0; i < len; i++) {
String s = scan.next();
char[] arr = s.toCharArray();
for(int j = 0; j < len; j++) {
b[i][j] = arr[j];
}
}
for(int i = 0; i < len; i++) {
for(int j = 0; j < len; j++) {
if(a[i][j] != b[i][j]) {
index1 = i;
index2 = j;
}
}
}
System.out.println(index1 + 1 + " " + (index2 + 1));
scan.close();
}
// @Test
// void addition() {
// assertEquals(2, 1 + 1);
// }
}
| ConDefects/ConDefects/Code/abc351_b/Java/53003316 |
condefects-java_data_1511 | import java.util.Scanner;
class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
String text;
String gridA[][] = new String[n][];
String gridB[][] = new String[n][];
int line = 0;
int raw = 0;
String strLineA[] = new String[n];
String strLineB[] = new String[n];
int count = n;
while (count>0){
text = scanner.next();
strLineA[n-count] = text;
gridA[n-count] = text.split("");
count = count - 1;
}
count = n;
while (count>0) {
text = scanner.next();
strLineB[n-count] = text;
gridB[n-count] = text.split("");
count = count - 1;
}
scanner.close();
count = n;
while(count>0){
/*
* System.out.println("line");
System.out.println(strLineA[n-count]);
System.out.println(strLineB[n-count]);
*/
if (!strLineA[n-count].equals(strLineB[n-count])){
/*
* System.out.println("break");
*/
line = n - count + 1;
break;
}
count = count - 1;
}
count = n;
while(count>0){
/*
* System.out.println("raw");
*/
if (!gridA[line-1][n-count].equals(gridB[line-1][n-count])){
raw = n - count + 1;
break;
}
count = count - 1;
}
System.out.println(raw + " " + line);
}
}
import java.util.Scanner;
class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
String text;
String gridA[][] = new String[n][];
String gridB[][] = new String[n][];
int line = 0;
int raw = 0;
String strLineA[] = new String[n];
String strLineB[] = new String[n];
int count = n;
while (count>0){
text = scanner.next();
strLineA[n-count] = text;
gridA[n-count] = text.split("");
count = count - 1;
}
count = n;
while (count>0) {
text = scanner.next();
strLineB[n-count] = text;
gridB[n-count] = text.split("");
count = count - 1;
}
scanner.close();
count = n;
while(count>0){
/*
* System.out.println("line");
System.out.println(strLineA[n-count]);
System.out.println(strLineB[n-count]);
*/
if (!strLineA[n-count].equals(strLineB[n-count])){
/*
* System.out.println("break");
*/
line = n - count + 1;
break;
}
count = count - 1;
}
count = n;
while(count>0){
/*
* System.out.println("raw");
*/
if (!gridA[line-1][n-count].equals(gridB[line-1][n-count])){
raw = n - count + 1;
break;
}
count = count - 1;
}
System.out.println(line + " " + raw);
}
} | ConDefects/ConDefects/Code/abc351_b/Java/53036155 |
condefects-java_data_1512 | import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
import java.awt.Point;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int M = in.it();
int[][] T = in.idx(M,2);
Object solve(){
sort(T,Comparator.comparing(t -> -t[0]));
UnionFindUndo uf = new UnionFindUndo(N);
for (var t:T)
uf.unite(t[0],t[1]);
for (int i = 0;i < N;i++) {
while (uf.size(i) > 1)
uf.undo();
out.println(uf.num -i -1);
}
return null;
}
}
class UnionFindGroup extends UnionFind{
List<Set<Integer>> group;
UnionFindGroup(int n){
super(n);
group = new ArrayList<>();
for (int i = 0;i < n;i++) {
Set<Integer> set = new HashSet<>();
set.add(i);
group.add(set);
}
}
Set<Integer> getGroup(int i){ return group.get(root(i)); }
@Override
boolean unite(int u,int v){
if (!super.unite(u,v))
return false;
group.get(root(u)).addAll(group.get(root(v)));
return true;
}
}
class UnionFindPotential extends UnionFind{
long[] dist;
UnionFindPotential(int n){
super(n);
dist = new long[n];
}
long sum(long a,long b){ return a +b; }
long sub(long a,long b){ return a -b; }
@Override
int root(int x){
if (data[x] < 0)
return x;
int r = root(data[x]);
dist[x] = sum(dist[x],dist[data[x]]);
return data[x] = r;
}
@Override
boolean unite(int u,int v){ return unite(u,v,0); }
boolean valid(int u,int v,long c){ return !same(u,v) || sub(dist(v),dist(u)) == c; }
boolean unite(int u,int v,long c){
assert valid(u,v,c);
c = sum(c,sub(dist(u),dist(v)));
u = root(u);
v = root(v);
if (!super.unite(u,v))
return false;
if (data[u] > data[v])
dist[u] = sub(0,c);
else
dist[v] = c;
return true;
}
long dist(int x){
root(x);
return dist[x];
}
}
class UnionFindUndo extends UnionFind{
Stack<int[]> histry;
UnionFindUndo(int n){
super(n);
histry = new Stack<>();
}
@Override
int root(int x){ return data[x] < 0 ? x : root(data[x]); }
@Override
boolean unite(int u,int v){
histry.add(new int[]{u, data[u]});
histry.add(new int[]{v, data[v]});
return super.unite(u,v);
}
void undo(){
var h = histry.pop();
data[h[0]] = h[1];
h = histry.pop();
data[h[0]] = h[1];
num++;
}
}
class UnionFind{
int num;
int[] data;
public UnionFind(int n){
data = new int[n];
fill(data,-1);
num = n;
}
int root(int x){ return data[x] < 0 ? x : (data[x] = root(data[x])); }
boolean same(int u,int v){ return root(u) == root(v); }
boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (data[u] > data[v]) {
u ^= v;
v ^= u;
u ^= v;
}
data[u] += data[v];
data[v] = u;
num--;
return true;
}
int size(int x){ return -data[root(x)]; }
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (var e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
import java.awt.Point;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int M = in.it();
int[][] T = in.idx(M,2);
Object solve(){
sort(T,Comparator.comparing(t -> -t[0]));
UnionFindUndo uf = new UnionFindUndo(N);
for (var t:T)
uf.unite(t[0],t[1]);
for (int i = 0;i < N;i++) {
while (uf.size(i) > 1)
uf.undo();
out.println(uf.num -i -1);
}
return null;
}
}
class UnionFindGroup extends UnionFind{
List<Set<Integer>> group;
UnionFindGroup(int n){
super(n);
group = new ArrayList<>();
for (int i = 0;i < n;i++) {
Set<Integer> set = new HashSet<>();
set.add(i);
group.add(set);
}
}
Set<Integer> getGroup(int i){ return group.get(root(i)); }
@Override
boolean unite(int u,int v){
if (!super.unite(u,v))
return false;
group.get(root(u)).addAll(group.get(root(v)));
return true;
}
}
class UnionFindPotential extends UnionFind{
long[] dist;
UnionFindPotential(int n){
super(n);
dist = new long[n];
}
long sum(long a,long b){ return a +b; }
long sub(long a,long b){ return a -b; }
@Override
int root(int x){
if (data[x] < 0)
return x;
int r = root(data[x]);
dist[x] = sum(dist[x],dist[data[x]]);
return data[x] = r;
}
@Override
boolean unite(int u,int v){ return unite(u,v,0); }
boolean valid(int u,int v,long c){ return !same(u,v) || sub(dist(v),dist(u)) == c; }
boolean unite(int u,int v,long c){
assert valid(u,v,c);
c = sum(c,sub(dist(u),dist(v)));
u = root(u);
v = root(v);
if (!super.unite(u,v))
return false;
if (data[u] > data[v])
dist[u] = sub(0,c);
else
dist[v] = c;
return true;
}
long dist(int x){
root(x);
return dist[x];
}
}
class UnionFindUndo extends UnionFind{
Stack<int[]> histry;
UnionFindUndo(int n){
super(n);
histry = new Stack<>();
}
@Override
int root(int x){ return data[x] < 0 ? x : root(data[x]); }
@Override
boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
histry.add(new int[]{u, data[u]});
histry.add(new int[]{v, data[v]});
return super.unite(u,v);
}
void undo(){
var h = histry.pop();
data[h[0]] = h[1];
h = histry.pop();
data[h[0]] = h[1];
num++;
}
}
class UnionFind{
int num;
int[] data;
public UnionFind(int n){
data = new int[n];
fill(data,-1);
num = n;
}
int root(int x){ return data[x] < 0 ? x : (data[x] = root(data[x])); }
boolean same(int u,int v){ return root(u) == root(v); }
boolean unite(int u,int v){
if ((u = root(u)) == (v = root(v)))
return false;
if (data[u] > data[v]) {
u ^= v;
v ^= u;
u ^= v;
}
data[u] += data[v];
data[v] = u;
num--;
return true;
}
int size(int x){ return -data[root(x)]; }
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (var e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
} | ConDefects/ConDefects/Code/abc229_e/Java/42793131 |
condefects-java_data_1513 | import java.util.Scanner;
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int count =0;
for(int i = 0; i < n; i++){
int tmp = sc.nextInt();
if(m >= tmp){
m -= tmp;
count++;
}
}
System.out.println(count);
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int count =0;
for(int i = 0; i < n; i++){
int tmp = sc.nextInt();
if(m >= tmp){
count++;
}
m -= tmp;
}
System.out.println(count);
}
} | ConDefects/ConDefects/Code/abc357_a/Java/55013154 |
condefects-java_data_1514 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String input1 = scan.nextLine();
String[] nums = input1.split("\\s");
int numOfAlien = Integer.parseInt(nums[0]);
int maxCleanableHand = Integer.parseInt(nums[1]);
String input2 = scan.nextLine();
String[] hands = input2.split("\\s");
scan.close();
List<Integer> list = new ArrayList<>();
for (String hand : hands) {
list.add(Integer.parseInt(hand));
}
int count = 0;
int num = 1;
while (maxCleanableHand > 0) {
maxCleanableHand = maxCleanableHand - list.get(count);
System.out.println("maxC:" + maxCleanableHand);
System.out.println("hand:" + list.get(count));
if (maxCleanableHand >= 0) {
count++;
num++;
}
if (num > numOfAlien) {
break;
}
}
System.out.println(count);
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String input1 = scan.nextLine();
String[] nums = input1.split("\\s");
int numOfAlien = Integer.parseInt(nums[0]);
int maxCleanableHand = Integer.parseInt(nums[1]);
String input2 = scan.nextLine();
String[] hands = input2.split("\\s");
scan.close();
List<Integer> list = new ArrayList<>();
for (String hand : hands) {
list.add(Integer.parseInt(hand));
}
int count = 0;
int num = 1;
while (maxCleanableHand > 0) {
maxCleanableHand = maxCleanableHand - list.get(count);
if (maxCleanableHand >= 0) {
count++;
num++;
}
if (num > numOfAlien) {
break;
}
}
System.out.println(count);
}
} | ConDefects/ConDefects/Code/abc357_a/Java/54750629 |
condefects-java_data_1515 | import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int count = 0;
int n = sc.nextInt();
int m = sc.nextInt();
for(int i=0;i<n;i++){
int hand = sc.nextInt();
m-=hand;
if(m-hand>=0){
count++;
}
}
System.out.print(count);
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int count = 0;
int n = sc.nextInt();
int m = sc.nextInt();
for(int i=0;i<n;i++){
int hand = sc.nextInt();
m-=hand;
if(m>=0){
count++;
}
}
System.out.print(count);
}
} | ConDefects/ConDefects/Code/abc357_a/Java/54885367 |
condefects-java_data_1516 |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
//宇宙人の人数
int N = sc.nextInt();
//消毒液が消毒できる手の数
int M = sc.nextInt();
int[] H = new int[N];
for (int i = 0;i < N ; i ++) {
H[i] = sc.nextInt();
}
for (int j = 1 ; j < N; j ++) {
M = M - H[j];
if ( M <0) {
System.out.println(j);
return ;
}
} System.out.println(N);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
//宇宙人の人数
int N = sc.nextInt();
//消毒液が消毒できる手の数
int M = sc.nextInt();
int[] H = new int[N];
for (int i = 0;i < N ; i ++) {
H[i] = sc.nextInt();
}
for (int j = 0 ; j < N; j ++) {
M = M - H[j];
if ( M <0) {
System.out.println(j);
return ;
}
} System.out.println(N);
}
}
| ConDefects/ConDefects/Code/abc357_a/Java/54952782 |
condefects-java_data_1517 | import java.util.*;
class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
if (s.indexOf("ABC") > 0) {
System.out.println(s.indexOf("ABC") + 1);
} else {
System.out.println(s.indexOf("ABC"));
}
}
}
import java.util.*;
class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
if (s.indexOf("ABC") >= 0) {
System.out.println(s.indexOf("ABC") + 1);
} else {
System.out.println(s.indexOf("ABC"));
}
}
} | ConDefects/ConDefects/Code/abc322_a/Java/46180199 |
condefects-java_data_1518 | import java.util.*;
class Abc {
int n;
String s;
Abc(int n, String s) {
this.n = n;
this.s = s;
}
int find() {
for(int i=0; i<=n-3; i++) {
String sub = s.substring(i, i+3);
if (sub.equalsIgnoreCase("ABC")) {
return i;
}
}
return -1;
}
}
class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
scanner.nextLine();
String s = scanner.nextLine();
Abc problem = new Abc(n, s);
System.out.println(problem.find());
}
}
import java.util.*;
class Abc {
int n;
String s;
Abc(int n, String s) {
this.n = n;
this.s = s;
}
int find() {
for(int i=0; i<=n-3; i++) {
String sub = s.substring(i, i+3);
if (sub.equalsIgnoreCase("ABC")) {
return i+1;
}
}
return -1;
}
}
class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
scanner.nextLine();
String s = scanner.nextLine();
Abc problem = new Abc(n, s);
System.out.println(problem.find());
}
} | ConDefects/ConDefects/Code/abc322_a/Java/46142671 |
condefects-java_data_1519 | import java.util.*;
import java.util.stream.Collectors;
import java.util.Comparator;
public class Main {
static final Random random=new Random();
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
String str = in.next();
int ans =0; int ptr =0;
for (int i = 0; i <=n-3; i++) {
if(str.substring(i,i+3).equals("ABC") && ptr==0){
ptr=1;
ans=i;
}
}
if (ptr==1){
System.out.println(ans);
}
else {
System.out.println(-1);
}
}
static void ruffleSort(int[] a) {
int n=a.length;
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); int temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static int gcd (int a , int b){
if(b==0){
return a;
}
return gcd(b,a%b);
}
public static int bin1(ArrayList<Integer> arr , int val) {
int st = 0;
int len = arr.size()-1;
int end = len;
while (st <= end) {
int mid = st + (end - st) / 2;
if (arr.get(mid) <=val) {
st = mid + 1;
}
else {
end = mid - 1;
}
}
return st;
}
}
import java.util.*;
import java.util.stream.Collectors;
import java.util.Comparator;
public class Main {
static final Random random=new Random();
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
String str = in.next();
int ans =0; int ptr =0;
for (int i = 0; i <=n-3; i++) {
if(str.substring(i,i+3).equals("ABC") && ptr==0){
ptr=1;
ans=i;
}
}
if (ptr==1){
System.out.println(ans+1);
}
else {
System.out.println(-1);
}
}
static void ruffleSort(int[] a) {
int n=a.length;
for (int i=0; i<n; i++) {
int oi=random.nextInt(n); int temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static int gcd (int a , int b){
if(b==0){
return a;
}
return gcd(b,a%b);
}
public static int bin1(ArrayList<Integer> arr , int val) {
int st = 0;
int len = arr.size()-1;
int end = len;
while (st <= end) {
int mid = st + (end - st) / 2;
if (arr.get(mid) <=val) {
st = mid + 1;
}
else {
end = mid - 1;
}
}
return st;
}
}
| ConDefects/ConDefects/Code/abc322_a/Java/54263261 |
condefects-java_data_1520 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
String judge = "ABC";
int result = S.indexOf(judge);
int len = S.length();
if (len > N){
S = S.substring(0, N);
}
if (result > 0){
result = result + 1;
}
System.out.println(result);
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
String judge = "ABC";
int result = S.indexOf(judge);
int len = S.length();
if (len > N){
S = S.substring(0, N);
}
if (result >= 0){
result = result + 1;
}
System.out.println(result);
}
} | ConDefects/ConDefects/Code/abc322_a/Java/46117045 |
condefects-java_data_1521 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner An = new Scanner(System.in);
int N = An.nextInt();
String S = An.nextLine();
int M = S.indexOf("ABC");
if (M == -1) {
System.out.println(M);
} else {
System.out.println(M + 1);
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner An = new Scanner(System.in);
String N = An.nextLine();
String S = An.nextLine();
int M = S.indexOf("ABC");
if (M == -1) {
System.out.println(M);
} else {
System.out.println(M + 1);
}
}
} | ConDefects/ConDefects/Code/abc322_a/Java/52521552 |
condefects-java_data_1522 | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N =sc.nextInt();
String S =sc.next();
boolean end = true;
for(int i = 0;i < N-3;i++){
if((S.substring(i,i+3)).matches("ABC")){
System.out.println(i+1);
end = false;
break;
}
}
if(end){System.out.println(-1);}
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N =sc.nextInt();
String S =sc.next();
boolean end = true;
for(int i = 0;i < N-2;i++){
if((S.substring(i,i+3)).matches("ABC")){
System.out.println(i+1);
end = false;
break;
}
}
if(end){System.out.println(-1);}
}
}
| ConDefects/ConDefects/Code/abc322_a/Java/54260426 |
condefects-java_data_1523 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int limit = sc.nextInt();
String str = sc.next();
// System.out.println(str);
if(str.indexOf("ABC") != -1){
System.out.println(str.indexOf("ABC"));
// System.out.println("yes");
}
else{
System.out.println(-1);
}
// System.out.println(str);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int limit = sc.nextInt();
String str = sc.next();
// System.out.println(str);
if(str.indexOf("ABC") != -1){
System.out.println(str.indexOf("ABC")+1);
// System.out.println("yes");
}
else{
System.out.println(-1);
}
// System.out.println(str);
}
} | ConDefects/ConDefects/Code/abc322_a/Java/46196362 |
condefects-java_data_1524 |
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N =sc.nextInt();
String S =sc.next();
boolean end = true;
for(int i = 0;i < N-4;i++){
if((S.substring(i,i+3)).matches("ABC")){
System.out.println(i+1);
end = false;
break;
}
}
if(end){
if((S.substring(N-3)).matches("ABC")){
System.out.println(N-3+1);
end = false;
}
}
if(end){System.out.println(-1);}
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N =sc.nextInt();
String S =sc.next();
boolean end = true;
for(int i = 0;i < N-3;i++){
if((S.substring(i,i+3)).matches("ABC")){
System.out.println(i+1);
end = false;
break;
}
}
if(end){
if((S.substring(N-3)).matches("ABC")){
System.out.println(N-3+1);
end = false;
}
}
if(end){System.out.println(-1);}
}
}
| ConDefects/ConDefects/Code/abc322_a/Java/54028317 |
condefects-java_data_1525 | import java.util.*;
public class Main{
public static void main(String arg[]){
Scanner sc = new Scanner(System.in);
int N;
N = sc.nextInt();
String S = sc.next();
char[] SS =new char[N];
int i;
for( i=0; i<N; i++) SS[i] = S.charAt(i);
for(int j=1; j<N-1; j++){
if(SS[j]=='A'&&SS[j+1]=='B'&&SS[j+2]=='C'){
System.out.println(+j+1);
System.exit(0);
}else{
i=-1;
}
}
if(i==-1) System.out.println(+i);
}
}
import java.util.*;
public class Main{
public static void main(String arg[]){
Scanner sc = new Scanner(System.in);
int N;
N = sc.nextInt();
String S = sc.next();
char[] SS =new char[N];
int i;
for( i=0; i<N; i++) SS[i] = S.charAt(i);
for(int j=0; j<N-1; j++){
if(SS[j]=='A'&&SS[j+1]=='B'&&SS[j+2]=='C'){
System.out.println(+j+1);
System.exit(0);
}else{
i=-1;
}
}
if(i==-1) System.out.println(+i);
}
} | ConDefects/ConDefects/Code/abc322_a/Java/50703066 |
condefects-java_data_1526 | import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int num = s.indexOf("ABC");
if(num != -1){
System.out.println(num);
}else{
System.out.println(-1);
}
}
}
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int num = s.indexOf("ABC");
if(num != -1){
System.out.println(num+1);
}else{
System.out.println(-1);
}
}
} | ConDefects/ConDefects/Code/abc322_a/Java/54780364 |
condefects-java_data_1527 | import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String [] str = new String[a];
int count = 0;
for(int i = 0 ; i<a;i++){
str[i] = sc.nextLine();
if(str[i].equals("Takahashi")){
count++;
}
}
System.out.println(count);
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String [] str = new String[a];
int count = 0;
for(int i = 0 ; i<a;i++){
str[i] = sc.next();
if(str[i].equals("Takahashi")){
count++;
}
}
System.out.println(count);
}
} | ConDefects/ConDefects/Code/abc359_a/Java/54941641 |
condefects-java_data_1528 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int count = 0;
for (int i = 0; i < N; i++) {
String s = sc.nextLine();
if (s.equals("Takahashi")) {
count++;
}
}
System.out.println(count);
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int count = 0;
for (int i = 0; i < N; i++) {
String s = sc.next();
if (s.equals("Takahashi")) {
count++;
}
}
System.out.println(count);
}
}
| ConDefects/ConDefects/Code/abc359_a/Java/55114836 |
condefects-java_data_1529 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int inputCount = sc.nextInt();
int count = 0;
for(int i = 0; i < inputCount; i++) {
String name = sc.next();
if(name == "Takahashi") {
count++;
}
}
System.out.println(count);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int inputCount = sc.nextInt();
int count = 0;
for(int i = 0; i < inputCount; i++) {
String name = sc.next();
if(name.equals("Takahashi")) {
count++;
}
}
System.out.println(count);
}
} | ConDefects/ConDefects/Code/abc359_a/Java/54929435 |
condefects-java_data_1530 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = 0;
n = sc.nextInt();
sc.nextLine();
int counter = 0;
for(int i = 0;i < n;i++){
String s = sc.nextLine();
if(s.equals("Takashi"))counter++;
}
System.out.println(counter);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = 0;
n = sc.nextInt();
sc.nextLine();
int counter = 0;
for(int i = 0;i < n;i++){
String s = sc.nextLine();
if(s.equals("Takahashi"))counter++;
}
System.out.println(counter);
}
} | ConDefects/ConDefects/Code/abc359_a/Java/54940870 |
condefects-java_data_1531 | import java.util.*;
public class Main {
public static void Solution(String str,int a,int b){
for(int i=a;i<=b;i++){
System.out.println(str.charAt(i-1));
}
}
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
String str="atcoder";
int a=sc.nextInt();
int b=sc.nextInt();
Solution(str,a,b);
sc.close();
}
}
import java.util.*;
public class Main {
public static void Solution(String str,int a,int b){
for(int i=a;i<=b;i++){
System.out.print(str.charAt(i-1));
}
}
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
String str="atcoder";
int a=sc.nextInt();
int b=sc.nextInt();
Solution(str,a,b);
sc.close();
}
}
| ConDefects/ConDefects/Code/abc264_a/Java/38541637 |
condefects-java_data_1532 | import java.util.*;
import java.util.Scanner;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
String s = "atcoder";
for(;a<b;a++){
System.out.print(s.charAt(a));
}
}
}
import java.util.*;
import java.util.Scanner;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt()-1;
int b = sc.nextInt();
String s = "atcoder";
for(;a<b;a++){
System.out.print(s.charAt(a));
}
}
} | ConDefects/ConDefects/Code/abc264_a/Java/36358945 |
condefects-java_data_1533 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = "atcoder";
int L = sc.nextInt();
int R = sc.nextInt();
sc.close();
String ans = str.substring(L-1, R-1);
System.out.println(ans);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = "atcoder";
int L = sc.nextInt();
int R = sc.nextInt();
sc.close();
String ans = str.substring(L-1, R);
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc264_a/Java/36564265 |
condefects-java_data_1534 | import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner console = new Scanner(System.in);
String word = "atcoder";
System.out.println("Input first input");
int input1 = console.nextInt();
System.out.println("Input second input");
int input2 = console.nextInt();
String output = word.substring(input1-1, input2);
System.out.println(output);
}
}
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner console = new Scanner(System.in);
String word = "atcoder";
int input1 = console.nextInt();
int input2 = console.nextInt();
String output = word.substring(input1-1, input2);
System.out.println(output);
}
} | ConDefects/ConDefects/Code/abc264_a/Java/36726139 |
condefects-java_data_1535 | import java.util.*;
class Main{
public static void main(String[] args){
String ex = "atcoder";
int a, b;
Scanner s = new Scanner(System.in);
a = s.nextInt();
b = s.nextInt();
String ans = ex.substring(a, b);
System.out.println(ans);
}
}
import java.util.*;
class Main{
public static void main(String[] args){
String ex = "atcoder";
int a, b;
Scanner s = new Scanner(System.in);
a = s.nextInt();
b = s.nextInt();
String ans = ex.substring(a-1, b);
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc264_a/Java/38430336 |
condefects-java_data_1536 |
import java.util.Scanner;
class Main{
public static void main(String[] args) {
String s = "atcoder";
Scanner sc = new Scanner(System.in);
int l = sc.nextInt();;
int r = sc.nextInt();
String ans = s.substring(l,r);
System.out.println(ans);
}
}
import java.util.Scanner;
class Main{
public static void main(String[] args) {
String s = "atcoder";
Scanner sc = new Scanner(System.in);
int l = sc.nextInt()-1;
int r = sc.nextInt();
String ans = s.substring(l,r);
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc264_a/Java/34959536 |
condefects-java_data_1537 | //Har Har Mahadev
import java.io.*;
public class Main
{
public static void main(String[]args)throws IOException
{
BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
String s=buf.readLine();
String t=buf.readLine();
int r=(-s.charAt(0)+t.charAt(0)+26)%26;
//System.out.println(r);
StringBuilder temp=new StringBuilder();
for(char ch:s.toCharArray())
{
temp.append((char)((ch-'a'-r)%26+'a')) ;
}
//System.out.println(temp);
System.out.println(temp.toString().compareTo(t)==0?"Yes":"No");
}
}
//Har Har Mahadev
import java.io.*;
public class Main
{
public static void main(String[]args)throws IOException
{
BufferedReader buf=new BufferedReader(new InputStreamReader(System.in));
String s=buf.readLine();
String t=buf.readLine();
int r=(-s.charAt(0)+t.charAt(0)+26)%26;
//System.out.println(r);
StringBuilder temp=new StringBuilder();
for(char ch:s.toCharArray())
{
temp.append((char)((ch-'a'+r)%26+'a')) ;
}
//System.out.println(temp);
System.out.println(temp.toString().compareTo(t)==0?"Yes":"No");
}
} | ConDefects/ConDefects/Code/abc232_b/Java/35777607 |
condefects-java_data_1538 |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
String T = sc.next();
char[] Sbox = S.toCharArray();
char[] Tbox = T.toCharArray();
int sabun=(Tbox[0]-Sbox[0]+26)%26;
for(int i=0;i<S.length();i++) {
if(sabun!=(Tbox[0]-Sbox[0]+26)%26) {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
String T = sc.next();
char[] Sbox = S.toCharArray();
char[] Tbox = T.toCharArray();
int sabun=(Tbox[0]-Sbox[0]+26)%26;
for(int i=0;i<S.length();i++) {
if(sabun!=(Tbox[i]-Sbox[i]+26)%26) {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
| ConDefects/ConDefects/Code/abc232_b/Java/36124570 |
condefects-java_data_1539 | import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main {
static void solve () {
char[] s = nextCharArray();
String t = next();
for (int i=1; i<=25; i++) {
if (t.equals(slide(s, i))) {
println("Yes");
return;
}
}
println("No");
}
public static String slide (char[] a, int n) {
StringBuilder sb = new StringBuilder();
for (int i=0; i<a.length; i++) {
int c = a[i] + n;
if (c > 122) c -= 26;
sb.append((char)c);
}
return sb.toString();
}
public static String yesno(boolean b) {return b?"Yes":"No";}
public static int[] accumulateSum (int[] a) {
int[] b = new int[a.length+1];
for (int i=1; i<a.length+1; i++) {
b[i] = b[i-1] + a[i-1];
}
return b;
}
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static String next() {return in.next();}
public static char nextChar() {return next().charAt(0);}
public static int nextInt() {return in.nextInt();}
public static Double nextDouble() {return in.nextDouble();}
public static Long nextLong() {return in.nextLong();}
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static String[] nextStringArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static char[] nextCharArray() {
return next().toCharArray();
}
public static char[][] nextCharTable(int h, int w) {
char[][] a = new char[h][w];
for (int i=0; i<h; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
static Scanner in = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
solve();
in.close();
out.close();
}
}
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main {
static void solve () {
char[] s = nextCharArray();
String t = next();
for (int i=0; i<=25; i++) {
if (t.equals(slide(s, i))) {
println("Yes");
return;
}
}
println("No");
}
public static String slide (char[] a, int n) {
StringBuilder sb = new StringBuilder();
for (int i=0; i<a.length; i++) {
int c = a[i] + n;
if (c > 122) c -= 26;
sb.append((char)c);
}
return sb.toString();
}
public static String yesno(boolean b) {return b?"Yes":"No";}
public static int[] accumulateSum (int[] a) {
int[] b = new int[a.length+1];
for (int i=1; i<a.length+1; i++) {
b[i] = b[i-1] + a[i-1];
}
return b;
}
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static String next() {return in.next();}
public static char nextChar() {return next().charAt(0);}
public static int nextInt() {return in.nextInt();}
public static Double nextDouble() {return in.nextDouble();}
public static Long nextLong() {return in.nextLong();}
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static String[] nextStringArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static char[] nextCharArray() {
return next().toCharArray();
}
public static char[][] nextCharTable(int h, int w) {
char[][] a = new char[h][w];
for (int i=0; i<h; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
static Scanner in = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
solve();
in.close();
out.close();
}
} | ConDefects/ConDefects/Code/abc232_b/Java/38135248 |
condefects-java_data_1540 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
char[] sChars = s.toCharArray();
String t = sc.nextLine();
for (int i = 0; i < 26; i++) {
char[] tmp = new char[sChars.length];
for (int j = 0; j < sChars.length; j++) {
tmp[j] = (char) (97 + (sChars[j] + i) % 97);;
}
if (String.valueOf(tmp).equals(t)) {
System.out.println("Yes");
return;
}
}
System.out.println("No");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
char[] sChars = s.toCharArray();
String t = sc.nextLine();
for (int i = 0; i < 26; i++) {
char[] tmp = new char[sChars.length];
for (int j = 0; j < sChars.length; j++) {
tmp[j] = (char) (97 + ((sChars[j] + i) % 97) % 26);;
}
if (String.valueOf(tmp).equals(t)) {
System.out.println("Yes");
return;
}
}
System.out.println("No");
}
} | ConDefects/ConDefects/Code/abc232_b/Java/36286439 |
condefects-java_data_1541 | import java.util.Scanner;
class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String S = sc.next();
String T = sc.next();
int SK[] = new int[S.length()];
int TK[] = new int[T.length()];
String obj = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
int diff = 0;
for(int i = 0; i < S.length(); i++){
for(int j = 0; j < 26; j++){
if(S.charAt(i) == obj.charAt(j)){
SK[i] = j;
break;
}
}
for(int j = SK[0]; j < SK[0] + 26; j++){
if(T.charAt(i) == obj.charAt(j)){
TK[i] = j;
break;
}
}
}
// for(int i = 0; i < S.length(); i++){
// System.out.print(SK[i] + " ");
// }
// System.out.println();
// for(int i = 0; i < S.length(); i++){
// System.out.print(TK[i] + " ");
// }
// System.out.println();
diff = TK[0] - SK[0];
boolean flag = true;
for(int i = 0; i < T.length(); i++){
if(diff != TK[i] - SK[i]){
flag = false;
break;
}
}
if(flag){
System.out.println("Yes");
}else{
System.out.println("No");
}
sc.close();
return;
}
}
import java.util.Scanner;
class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String S = sc.next();
String T = sc.next();
int SK[] = new int[S.length()];
int TK[] = new int[T.length()];
String obj = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
int diff = 0;
for(int i = 0; i < S.length(); i++){
for(int j = 0; j < 26; j++){
if(S.charAt(i) == obj.charAt(j)){
SK[i] = j;
break;
}
}
for(int j = SK[i]; j < SK[i] + 26; j++){
if(T.charAt(i) == obj.charAt(j)){
TK[i] = j;
break;
}
}
}
// for(int i = 0; i < S.length(); i++){
// System.out.print(SK[i] + " ");
// }
// System.out.println();
// for(int i = 0; i < S.length(); i++){
// System.out.print(TK[i] + " ");
// }
// System.out.println();
diff = TK[0] - SK[0];
boolean flag = true;
for(int i = 0; i < T.length(); i++){
if(diff != TK[i] - SK[i]){
flag = false;
break;
}
}
if(flag){
System.out.println("Yes");
}else{
System.out.println("No");
}
sc.close();
return;
}
} | ConDefects/ConDefects/Code/abc232_b/Java/40109349 |
condefects-java_data_1542 | // temprate
import java.util.*;
public class Main{
public static void main(String[] args){
var in = new Scanner(System.in);
// ~~~
var kind = new HashSet<Integer>();
char[] ch = in.next().toCharArray();
char[] model = in.next().toCharArray();
for ( int i = 0 ; ch.length > i ; i++ ){
kind.add( model[ i ] - ch[ i ] ) ;
}
String ans = "No";
if ( kind.size() == 1 ){
ans = "Yes";
}
System.out.println(ans);
}
}
// temprate
import java.util.*;
public class Main{
public static void main(String[] args){
var in = new Scanner(System.in);
// ~~~
var kind = new HashSet<Integer>();
char[] ch = in.next().toCharArray();
char[] model = in.next().toCharArray();
for ( int i = 0 ; ch.length > i ; i++ ){
kind.add( ( 26 + model[ i ] - ch[ i ] ) % 26 ) ;
}
String ans = "No";
if ( kind.size() == 1 ){
ans = "Yes";
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc232_b/Java/39537559 |
condefects-java_data_1543 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010l;//10^18
static boolean ok = false;
static long ans = 0;
static final int[] dx = {1, -1, 0, 0};
static final int[] dy = {0, 0, 1, -1};
static final long[] MODS = {998244353, 1000000007, 1000000009, 1000000021};
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
long n = sc.nextLong();
char[] cs = String.valueOf(n).toCharArray();
long ans = 0;
int s = cs.length;
for (int i = 1; i <= 13 * 9; i++) {
long[][][][] dp = new long[s + 1][2][i + 1][i];
dp[0][1][0][0] = 1;
for (int j = 0; j < s; j++) {
int c = Character.getNumericValue(cs[j]);
for (int j2 = 0; j2 < 2; j2++) {
for (int k = 0; k <= i; k++) {
for (int k2 = 0; k2 < i; k2++) {
long pre = dp[j][j2][k][k2];
if (pre == 0) continue;
for (int l = 0; l < 10; l++) {
int nj2 = j2;
int nk = k + l;
int nk2 = (k2 * 10 + l) % i;
if (c < l && j2 == 1) continue;
if (c > l) nj2 = 0;
if (k + l > i) continue;
dp[j + 1][nj2][nk][nk2] += pre;
}
}
}
}
}
ans += dp[s][0][i][0] + dp[s][1][i][0];
}
System.out.println(ans);
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010l;//10^18
static boolean ok = false;
static long ans = 0;
static final int[] dx = {1, -1, 0, 0};
static final int[] dy = {0, 0, 1, -1};
static final long[] MODS = {998244353, 1000000007, 1000000009, 1000000021};
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
long n = sc.nextLong();
char[] cs = String.valueOf(n).toCharArray();
long ans = 0;
int s = cs.length;
for (int i = 1; i <= 14 * 9; i++) {
long[][][][] dp = new long[s + 1][2][i + 1][i];
dp[0][1][0][0] = 1;
for (int j = 0; j < s; j++) {
int c = Character.getNumericValue(cs[j]);
for (int j2 = 0; j2 < 2; j2++) {
for (int k = 0; k <= i; k++) {
for (int k2 = 0; k2 < i; k2++) {
long pre = dp[j][j2][k][k2];
if (pre == 0) continue;
for (int l = 0; l < 10; l++) {
int nj2 = j2;
int nk = k + l;
int nk2 = (k2 * 10 + l) % i;
if (c < l && j2 == 1) continue;
if (c > l) nj2 = 0;
if (k + l > i) continue;
dp[j + 1][nj2][nk][nk2] += pre;
}
}
}
}
}
ans += dp[s][0][i][0] + dp[s][1][i][0];
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc336_e/Java/53148155 |
condefects-java_data_1544 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.*;
public class Main {
static int[] dig = new int[15];
static long[][][] dp;
static int p;
public static void main(String[] args) throws IOException {
Scanner input = new Scanner(System.in);
long n = input.nextLong();
dp = new long[15][127][127];
p = 0;
while (n > 0){
dig[p++] =(int) (n % 10);
n /= 10;
}
long res = 0;
for (int k = 1; k <= 126; k++) {
for (int i = 0; i < 15; i++) {
for (int j = 0; j < 127; j++) {
Arrays.fill(dp[i][j], -1);
}
}
res += dfs(p - 1, 0, 0, k, false);
}
System.out.println(res);
}
public static long dfs(int u, int s, int t, int k, boolean lim){
if (u == -1 && t == 0 && s == k) return 1;
if (u == -1) return 0;
if (dp[u][s][t] != -1) return dp[u][s][t];
int x = lim ? 9 : dig[u];
long ans = 0;
for (int i = 0; i <= x; i++) {
ans += dfs(u - 1, s+i, (t * 10 + i) % k, k, i != x || lim);
}
if (lim) dp[u][s][t] = ans;
return ans;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.*;
public class Main {
static int[] dig = new int[15];
static long[][][] dp;
static int p;
public static void main(String[] args) throws IOException {
Scanner input = new Scanner(System.in);
long n = input.nextLong();
dp = new long[15][127][127];
p = 0;
while (n > 0){
dig[p++] =(int) (n % 10);
n /= 10;
}
long res = 0;
for (int k = 1; k <= 126; k++) {
for (int i = 0; i < 15; i++) {
for (int j = 0; j < 127; j++) {
Arrays.fill(dp[i][j], -1);
}
}
res += dfs(p - 1, 0, 0, k, false);
}
System.out.println(res);
}
public static long dfs(int u, int s, int t, int k, boolean lim){
if (u == -1 && t == 0 && s == k) return 1;
if (u == -1) return 0;
if (lim && dp[u][s][t] != -1) return dp[u][s][t];
int x = lim ? 9 : dig[u];
long ans = 0;
for (int i = 0; i <= x; i++) {
ans += dfs(u - 1, s+i, (t * 10 + i) % k, k, i != x || lim);
}
if (lim) dp[u][s][t] = ans;
return ans;
}
} | ConDefects/ConDefects/Code/abc336_e/Java/49328456 |
condefects-java_data_1545 | import java.awt.Dimension;
import java.awt.Point;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.FilterOutputStream;
import java.io.Flushable;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Formatter;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.DoubleUnaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;
//Maybe use
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.TreeMap;
import java.util.TreeSet;
final class Main {
private static final boolean autoFlush = false;
private static final SimpleScanner sc = new SimpleScanner( System.in );
private static final SimpleWriter out = new SimpleWriter( System.out, autoFlush );
public static void main ( String[] args ) {
int N = sc.nextInt();
int D = sc.nextInt();
int W = sc.nextInt();
int[][] query = sc.nextInt(N,2);
final int rangeMax = 200_000;
LazySegmentTree<Integer,Integer> lSegT = new LazySegmentTree<>(rangeMax,0,0,true){
public Integer function(Integer a,Integer b){
return Math.max(a,b);
}
public Integer composition(Integer a,Integer b){
return a+b;
}
public Integer mapping(Integer a,Integer b){
return a+b;
}
};
Arrays.sort(query,(a,b)->Integer.compare(a[0],b[0]));
int l = 0;
int ans = 0;
for(int r=0;r<N;r++){
lSegT.apply(query[r][1],Math.min(rangeMax,query[r][1]+W),1);
int limit = query[r][0]-D;
while(l<r&&query[l][0]<=limit)
lSegT.apply(query[l][1],Math.min(rangeMax,query[l++][1]+W),-1);
ans = Math.max(ans,lSegT.answer());
}
out.println(ans);
out.close();
}
}
@SuppressWarnings( "unchecked" )
abstract class LazySegmentTree<S,F> {
private final int N,size,log;
private final S defaultS;
private final F defaultF;
private final S[] node;
private final F[] lazy;
public LazySegmentTree(int N,S defaultS,F defaultF){
this(N,defaultS,defaultF,false);
}
public LazySegmentTree(int N,S defaultS,F defaultF,boolean is1indexed){
this.N = N;
this.log = 32-Integer.numberOfLeadingZeros(N-1);
this.size = (1<<log)-(is1indexed?1:0);
this.defaultS = defaultS;
this.defaultF = defaultF;
this.node = (S[])new Object[1<<log+1];
this.lazy = (F[])new Object[1<<log+1];
clear();
}
public LazySegmentTree(S[] defaultValues,S defaultS,F defaultF,boolean is1indexed){
this(defaultValues.length,defaultS,defaultF,is1indexed);
updateAll(defaultValues);
}
public void clear(){
Arrays.fill(this.node,this.defaultS);
Arrays.fill(this.lazy,this.defaultF);
}
public void updateAll(S[] defaultValues){
System.arraycopy(defaultValues,0,node,1<<log,defaultValues.length);
for(int i=(1<<log)-1;i>0;i--){
node[i] = function(node[i<<1],node[i<<1|1]);
}
}
private void spread(int index){
if(lazy[index]!=defaultF){
int l = index<<1;
int r = index<<1|1;
node[l] = mapping(node[l],lazy[index]);
node[r] = mapping(node[r],lazy[index]);
lazy[l] = composition(lazy[index],lazy[l]);
lazy[r] = composition(lazy[index],lazy[r]);
lazy[index] = defaultF;
}
}
private void spreadLine(int from){
for(int i=log;i>0;i++)
spread(from>>i);
}
private void spreadRange(int l,int r){
for(int i=log;i>0;i--){
if((l>>i<<i)!=l)
spread(l>>i);
if((r>>i<<i)!=r)
spread(r>>i);
}
}
private void update(int index){
while((index>>=1)>0)
node[index] = function(node[index<<1],node[index<<1|1]);
}
private void update(int l,int r){
for(int i=1;i<=log;i++){
int subL = l>>i;
int subR = r>>i;
if((subL<<i)!=l)
node[subL] = function(node[subL<<1],node[subL<<1|1]);
if((subR<<i)!=r)
node[subR] = function(node[subR<<1],node[subR<<1|1]);
}
}
public void update(int index,S x){
index += size;
spreadLine(index);
node[index] = x;
update(index);
}
public S get(int index){
index += size;
spreadLine(index);
return node[index];
}
public S query(int l,int r){
l += size;
r += size;
spreadRange(l,r);
S sumL = defaultS;
S sumR = defaultS;
while(l<r){
if((l&1)==1)
sumL = function(sumL,node[l++]);
if((r&1)==0)
sumR = function(node[--r],sumR);
l >>= 1;
r >>= 1;
}
return function(sumL,sumR);
}
public S answer () {
return ( S )node[1];
}
public void apply(int index,F f){
index += size;
spreadLine(index);
node[index] = mapping(node[index],f);
update(index);
}
public void apply(int l,int r,F f){
l += size;
r += size;
spreadRange(l,r);
int subL = l;
int subR = r;
while(subL<subR){
if((subL&1)==1){
node[subL] = mapping(node[subL],f);
lazy[subL] = composition(f,lazy[subL++]);
}
if((subR&1)==1){
node[--subR] = mapping(node[subR],f);
lazy[subR] = composition(f,lazy[subR]);
}
subL >>= 1;
subR >>= 1;
}
update(l,r);
}
abstract public S function ( S s1, S s2 );
abstract public F composition ( F f1, F f2 );
abstract public S mapping ( S s, F f );
}
/*
,.へ
___ ﾑ i
「ﾋ_i〉 ゝ 〈
ﾄ ノ iニ()
i { ＿＿＿_ | ヽ
i i ／_, ,‐-＼ i }
| i ／（●) ( ● )＼ {､ λ
ト－┤. ／ （__人__） ＼ ,ノ￣,!
i ゝ､_ | ´￣` | ,. '´ﾊ ,!
ヽ、 ｀`､,__＼ ／" ＼ ヽ／
＼ノ ﾉ ﾊ￣ r/::r―--―/:７ ﾉ ／
ヽ. ヽ:<:'::'|:/ / ,."
`ｰ ､ ＼ヽ:::|/ ｒ'"
／￣二二二二二二二二二二二二二二二二二ヽ
| 答 | A C │|
＼＿二二二二二二二二二二二二二二二二二ノ
*/
/*////////////////////////////////////////////////////////////////////////////////////////////
* My Library *
@author viral
*/////////////////////////////////////////////////////////////////////////////////////////////
final class Factorial {
//階乗とその逆元
private final long[] fact, inFact;
private final long mod;
/**
* 1～Nの階乗とその逆元をmodで割ったあまりを事前に計算します。
*
* @param N 計算範囲
* @param mod 法
*/
public Factorial ( final int N, final long mod ) {
fact = new long[N + 1];
fact[0] = fact[1] = 1;
for ( int i = 2; i <= N; ++i ) {
fact[i] = fact[i - 1] * i % mod;
}
inFact = new long[N + 1];
inFact[N] = MathFunction.modPow( fact[N], mod - 2, mod );
for ( int i = N; i > 0; --i ) {
inFact[i - 1] = inFact[i] * i % mod;
}
inFact[0] = 1;
this.mod = mod;
}
/**
* num!をmodで割ったあまりを返します。
*
* @param num
*
* @return num!
*/
public long getFact ( final int num ) {
return fact[num];
}
/**
* num!^-1をmodで割ったあまりを返します。
*
* @param num
*
* @return num!
*/
public long getInFact ( final int num ) {
return inFact[num];
}
/**
* modを法とした時のnum^-1を返します。
*
* @param num
*
* @return num!
*/
public long getInverse ( final int num ) {
return fact[num - 1] * inFact[num] % mod;
}
/**
* aCbをmodで割ったあまりを返します。
*
* @param a
* @param b
*
* @return aCb
*/
public long getCombi ( final int a, final int b ) {
if ( a < b || a < 0 || b < 0 ) {
return 0;
}
return ( fact[a] * inFact[a - b] % mod ) * inFact[b] % mod;
}
}
final class ArrayFunction {
private static final int LIMIT_OF_COUNT_SORT = 500_000;
/**
* カウントソートによるソートです。
* 各要素が0以上であり最大値が十分小さい時はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param maximumLimit array内の最大要素
*/
public static void countSort ( final int[] array, final int maximumLimit ) {
countSort( array, 0, array.length, maximumLimit );
}
public static void countSort ( final int[] array, final int l, final int r, final int maximumLimit ) {
final int[] list = new int[maximumLimit + 1];
for ( int i = l; i < r; ++i ) {
++list[array[i]];
}
int temp = l;
for ( int i = 0; i < list.length; ++i ) {
while ( list[i]-- > 0 ) {
array[temp++] = i;
}
}
}
public static void insertSort(final int[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void insertSort(final long[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void insertSort(final char[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static <E extends Comparable<E>> void insertSort(final E[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])>0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void reverseInsertSort(final int[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void reverseInsertSort(final long[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void reverseInsertSort(final char[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static <E extends Comparable<E>> void reverseInsertSort(final E[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])<0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateR ( final int[][] array ) {
final int[][] ans = new int[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateR ( final long[][] array ) {
final long[][] ans = new long[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateR ( final char[][] array ) {
final char[][] ans = new char[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateR ( final double[][] array ) {
final double[][] ans = new double[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateR ( final boolean[][] array ) {
final boolean[][] ans = new boolean[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateR ( final E[][] array, final E[][] ans ) {
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateL ( final int[][] array ) {
final int[][] ans = new int[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
final int index = i;
Arrays.setAll( ans[i], k -> array[k][ans.length - index - 1] );
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateL ( final long[][] array ) {
final long[][] ans = new long[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
final int index = i;
Arrays.setAll( ans[i], k -> array[k][ans.length - index - 1] );
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateL ( final char[][] array ) {
final char[][] ans = new char[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateL ( final double[][] array ) {
final double[][] ans = new double[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateL ( final boolean[][] array ) {
final boolean[][] ans = new boolean[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateL ( final E[][] array, final E[][] ans ) {
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( int[] array ) {
return lis( array, false );
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( int[][] arrays, int p ) {
return lis( arrays, p, false );
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( long[] array ) {
return lis( array, false );
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( long[][] arrays, int p ) {
return lis( arrays, p, false );
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( int[] array, boolean include ) {
int[] list = new int[array.length];
Arrays.fill( list, Integer.MAX_VALUE );
for ( int num: array ) {
int index = include ? Searcher.overSearch( list, num ) : Searcher.upSearch( list, num );
list[index] = Math.min( list[index], num );
}
int answer = Searcher.underSearch( list, Integer.MAX_VALUE );
return answer + 1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( int[][] arrays, int p, boolean include ) {
int[] list = new int[arrays.length];
Arrays.fill( list, Integer.MAX_VALUE );
for ( int[] array: arrays ) {
int index = include ? Searcher.overSearch( list, array[p] ) : Searcher.upSearch( list, array[p] );
list[index] = Math.min( list[index], array[p] );
}
int answer = Searcher.underSearch( list, Integer.MAX_VALUE );
return answer + 1;
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( long[] array, boolean include ) {
long[] list = new long[array.length];
Arrays.fill( list, Long.MAX_VALUE );
for ( long num: array ) {
int index = include ? Searcher.overSearch( list, num ) : Searcher.upSearch( list, num );
list[index] = Math.min( list[index], num );
}
int answer = Searcher.underSearch( list, Long.MAX_VALUE );
return answer + 1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( long[][] arrays, int p, boolean include ) {
long[] list = new long[arrays.length];
Arrays.fill( list, Long.MAX_VALUE );
for ( long[] array: arrays ) {
int index = include ? Searcher.overSearch( list, array[p] ) : Searcher.upSearch( list, array[p] );
list[index] = Math.min( list[index], array[p] );
}
int answer = Searcher.underSearch( list, Long.MAX_VALUE );
return answer + 1;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort ( final ArrayList<ArrayList<Integer>> route ) {
final int[] count = new int[route.size()];
int pathCount = 0;
for ( final ArrayList<Integer> path: route ) {
for ( final int point: path ) {
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for ( int i = 1; i < count.length; ++i ) {
if ( count[i] == 0 ) {
deq.add( i );
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while ( deq.size() > 0 ) {
int nowP = deq.pollFirst();
for ( final int nextP: route.get( nowP ) ) {
ans[index][0] = nowP;
ans[index++][1] = nextP;
if ( --count[nextP] == 0 ) {
deq.add( nextP );
}
}
}
return ans;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort ( final int[][] route ) {
final int[] count = new int[route.length];
int pathCount = 0;
for ( final int[] path: route ) {
for ( final int point: path ) {
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for ( int i = 1; i < count.length; ++i ) {
if ( count[i] == 0 ) {
deq.add( i );
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while ( deq.size() > 0 ) {
int nowP = deq.pollFirst();
for ( final int nextP: route[nowP] ) {
ans[index][0] = nowP;
ans[index++][1] = nextP;
if ( --count[nextP] == 0 ) {
deq.add( nextP );
}
}
}
return ans;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final int[] array, final int a, final int b ) {
final int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final long[] array, final int a, final int b ) {
final long temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final double[] array, final int a, final int b ) {
final double temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final char[] array, final int a, final int b ) {
final char temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final boolean[] array, final int a, final int b ) {
final boolean temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static <E> void swap ( final E[] array, final int a, final int b ) {
final E temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final int[][] array, final int a, final int b, final int c, final int d ) {
final int temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final long[][] array, final int a, final int b, final int c, final int d ) {
final long temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final double[][] array, final int a, final int b, final int c, final int d ) {
final double temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final char[][] array, final int a, final int b, final int c, final int d ) {
final char temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final boolean[][] array, final int a, final int b, final int c, final int d ) {
final boolean temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static <E> void swap ( final E[][] array, final int a, final int b, final int c, final int d ) {
final E temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation ( final int[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] < array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation ( final long[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] < array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
long min = Long.MAX_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation ( final char[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] < array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static <E extends Comparable<E>> boolean nextPermutation ( final E[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1].compareTo( array[i] ) < 0 ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = -1;
E min = MathFunction.max( array );
int subIndex = -1;
E max = array[index1];
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
if ( max.compareTo( array[i] ) < 0 ) {
subIndex = i;
max = array[i];
}
}
if ( index2 == -1 ) {
swap( array, index1, subIndex );
}
else {
swap( array, index1, index2 );
}
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
public static boolean previousPermutation ( final int[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] > array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
public static boolean previousPermutation ( final long[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] > array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
long max = Long.MIN_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
public static boolean previousPermutation ( final char[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] > array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
public static <E extends Comparable<E>> boolean previousPermutation ( final E[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1].compareTo( array[i] ) > 0 ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = -1;
E max = MathFunction.min( array );
int subIndex = -1;
E min = array[index1];
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
if ( min.compareTo( array[i] ) > 0 ) {
subIndex = i;
min = array[i];
}
}
if ( index2 == -1 ) {
swap( array, index1, subIndex );
}
else {
swap( array, index1, index2 );
}
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static int[] reBuild ( final int[] array, final IntUnaryOperator func ) {
final int[] ans = new int[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsInt( array[i] );
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static int[] reBuild ( final int[] array, final IntBinaryOperator func ) {
final int[] ans = new int[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsInt( i, array[i] );
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static long[] reBuild ( final long[] array, final LongUnaryOperator func ) {
final long[] ans = new long[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsLong( array[i] );
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static long[] reBuild ( final long[] array, final LongBinaryOperator func ) {
final long[] ans = new long[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsLong( i, array[i] );
}
return ans;
}
public static void computeByArray(final int[] array,final IntConsumer func){
for(final int num:array){
func.accept(num);
}
}
public static void reverseRange(final int[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final long[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final double[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final char[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final boolean[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static <E> void reverseRange(final E[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
}
final class Converter {
/**
* 渡された文字列を逆順にした文字列を返します。
*
* @param str 元の文字列
*
* @return strを逆順にした文字列
*/
public static String reverse ( final String str ) {
final StringBuilder sb = new StringBuilder();
for ( int i = str.length() - 1; i >= 0; --i ) {
sb.append( str.charAt( i ) );
}
return sb.toString();
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static int[] toIntArray ( final List<Integer> list ) {
final int[] ans = new int[list.size()];
int index = 0;
for ( int num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static long[] toLongArray ( final List<Long> list ) {
final long[] ans = new long[list.size()];
int index = 0;
for ( long num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static char[] toCharArray ( final List<Character> list ) {
final char[] ans = new char[list.size()];
int index = 0;
for ( char num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static double[] toDoubleArray ( final List<Double> list ) {
final double[] ans = new double[list.size()];
int index = 0;
for ( double num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static boolean[] toBooleanArray ( final List<Boolean> list ) {
final boolean[] ans = new boolean[list.size()];
int index = 0;
for ( boolean num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static byte[] toByteArray ( final List<Byte> list ) {
final byte[] ans = new byte[list.size()];
int index = 0;
for ( byte num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static short[] toShortArray ( final List<Short> list ) {
final short[] ans = new short[list.size()];
int index = 0;
for ( short num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static float[] toFloatArray ( final List<Float> list ) {
final float[] ans = new float[list.size()];
int index = 0;
for ( float num : list ) {
ans[index++] = num;
}
return ans;
}
}
final class MathFunction {
private static final int[] numberForIntPrime = {2, 7, 61};
private static final long[] numberForLongPrime = {2, 7, 61, 325, 9375, 28178, 450775, 9780504, 1795265022};
/**
* aとbの最大公約数を求めます。戻り値は0以上であることが保証されます。
*
* @param a 公約数を求める整数
* @param b 公約数を求める整数
*
* @return aとbの最大公約数
*/
public static long gcd ( long a, long b ) {
a = Math.abs( a );
b = Math.abs( b );
if ( b == 0 ) {
return a;
}
long temp;
while ( ( temp = a % b ) != 0 ) {
a = b;
b = temp;
}
return b;
}
/**
* aとbの最小公倍数を求めます。
* オーバーフロー検知は出来ません。
*
* @param a 公倍数を求める整数
* @param b 公倍数を求める整数
*
* @return aとbの最小公倍数
*/
public static long lcm ( final long a, final long b ) {
return a / gcd( a, b ) * b;
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
public static boolean isPrime ( long n ) {
n = Math.abs( n );
if ( n == 2L ) {
return true;
}
if ( n == 1L || ( n & 1L ) == 0L ) {
return false;
}
if ( n <= 4_759_123_141L ) {
return isPrimeForInt( n );
}
if ( n <= Long.MAX_VALUE / n ) {
return isPrimeForLong( n );
}
return isPrimeForBigInteger( n );
}
private static boolean isPrimeForInt ( long n ) {
long d = n - 1;
while ( ( d & 1 ) == 0L ) {
d >>= 1;
}
for ( final long a: numberForIntPrime ) {
if ( a >= n ) {
return true;
}
long t = d;
long y = MathFunction.modPow( a, t, n );
while ( t < n - 1L && y != 1 && y != n - 1 ) {
y = y * y % n;
t <<= 1;
}
if ( y != n - 1 && ( t & 1L ) == 0 ) {
return false;
}
}
return true;
}
private static boolean isPrimeForLong ( long n ) {
long d = n - 1L;
while ( ( d & 1 ) == 0L ) {
d >>= 1;
}
for ( final long a: numberForLongPrime ) {
if ( a >= n ) {
return true;
}
long t = d;
long y = MathFunction.modPow( a, t, n );
while ( t < n - 1L && y != 1 && y != n - 1 ) {
y = y * y % n;
t <<= 1;
}
if ( y != n - 1 && ( t & 1L ) == 0 ) {
return false;
}
}
return true;
}
private static boolean isPrimeForBigInteger ( long n ) {
long d = n - 1L;
while ( ( d & 1 ) == 0L ) {
d >>= 1;
}
final BigInteger bigN = BigInteger.valueOf( n );
final BigInteger bigNSubOne = bigN.subtract( BigInteger.ONE );
final BigInteger bigD = BigInteger.valueOf( d );
for ( final long a: numberForLongPrime ) {
if ( a >= n ) {
return true;
}
BigInteger t = bigD;
BigInteger y = BigInteger.valueOf( a ).modPow( t, bigN );
while ( t.compareTo( bigNSubOne ) == -1 && !y.equals( BigInteger.ONE ) && !y.equals( bigNSubOne ) ) {
y = y.multiply( y ).mod( bigN );
t = t.shiftLeft( 1 );
}
if ( !y.equals( bigNSubOne ) && (t.intValue()&1) == 0 ) {
return false;
}
}
return true;
}
/**
* num以下の素数を列挙します。
*
* @param num 素数を探す上限値
*
* @return num以下の素数のint型配列
*/
public static int[] primes ( final int num ) {
if ( num < 2 ) {
return new int[0];
}
final BitSet numbers = new BitSet( num + 1 );
numbers.set( 2, num + 1 );
final int limit = ( int )Math.sqrt( num );
for ( int i = 2; i <= limit; ++i ) {
if ( numbers.get( i ) ) {
for ( int j = i * i; j <= num; j += i ) {
if ( numbers.get(j) ) {
numbers.clear( j );
}
}
}
}
final int[] answer = new int[numbers.cardinality()];
int i = 2, index = 0;
do {
i = numbers.nextSetBit( i );
answer[index++] = i++;
} while ( index != answer.length );
return answer;
}
/**
* a**bを計算します。
*
* @param a 被累乗数
* @param b 指数
*
* @return a**b
*/
public static long pow ( long a, long b ) {
long ans = 1;
while ( b > 0 ) {
if ( ( b & 1 ) == 1 ) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
/**
* a**bをmodで割ったあまりを計算します。
*
* @param a 被累乗数
* @param b 指数
* @param mod 法とする整数
*
* @return a**bをmodで割ったあまり
*/
public static long modPow ( long a, long b, final long mod ) {
long ans = 1;
a %= mod;
while ( b > 0 ) {
if ( ( b & 1 ) == 1 ) {
ans *= a;
}
ans %= mod;
a *= a;
a %= mod;
b >>= 1;
}
return ans;
}
/**
* N!を計算します。
*
* @param N 階乗を求めるのに用いる値
*
* @return N!
*/
public static long fact ( final int N ) {
long ans = 1;
for ( int i = 2; i <= N; ++i ) {
ans *= i;
}
return ans;
}
/**
* N!をmodで割ったあまりを計算します。
*
* @param N 階乗を求めるのに用いる値
* @param mod 法とする整数
*
* @return N!をmodで割ったあまり
*/
public static long modFact ( final int N, final long mod ) {
long ans = 1;
for ( int i = 2; i <= N; ++i ) {
ans *= i;
ans %= mod;
}
return ans;
}
/**
* nCrを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
*
* @return nCr
*/
public static long combi ( final long n, long r ) {
if ( r < 0 || n < r ) {
return 0;
}
long ans = 1;
r = Math.min( n - r, r );
for ( int i = 0; i < r; ++i ) {
ans *= n - i;
ans /= i + 1;
}
return ans;
}
/**
* nCrをmodで割ったあまりを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
* @param mod 法とする整数
*
* @return nCrをmodで割ったあまり
*/
public static long modCombi ( final long n, long r, final long mod ) {
if ( r < 0 || n < r ) {
return 0;
}
long ans = 1;
r = Math.min( n - r, r );
for ( int i = 0; i < r; ++i ) {
ans *= ( n - i ) % mod;
ans %= mod;
ans *= modPow( i + 1, mod - 2, mod );
ans %= mod;
}
return ans;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param x1 点1のx座標
* @param y1 点1のy座標
* @param x2 点2のx座標
* @param y2 点2のy座標
* @param x3 点3のx座標
* @param y3 点3のy座標
* @param x4 点4のx座標
* @param y4 点4のy座標
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed ( final int x1, final int y1,
final int x2, final int y2,
final int x3, final int y3,
final int x4, final int y4 ) {
final long s1 = ( long )( x1 - x2 ) * ( y3 - y1 ) - ( long )( y1 - y2 ) * ( x3 - x1 );
final long t1 = ( long )( x1 - x2 ) * ( y4 - y1 ) - ( long )( y1 - y2 ) * ( x4 - x1 );
final long s2 = ( long )( x3 - x4 ) * ( y1 - y3 ) - ( long )( y3 - y4 ) * ( x1 - x3 );
final long t2 = ( long )( x3 - x4 ) * ( y2 - y3 ) - ( long )( y3 - y4 ) * ( x2 - x3 );
final long temp1 = s1 * t1;
final long temp2 = s2 * t2;
if ( temp1 > 0 || temp2 > 0 ) {
return -1;
}
if ( temp1 == 0 && temp2 == 0 ) {
return 0;
}
return 1;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param p1 点1
* @param p2 点2
* @param p3 点3
* @param p4 点4
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed ( final Point p1, final Point p2, final Point p3, final Point p4 ) {
return isCrossed( p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y );
}
/**
* 指定された頂点を順に結んで出来上がる多角形が凸多角形か判定します。
*
* @param points 多角形を構成する点
*
* @return 多角形が凸多角形ならtrue
*/
public static boolean isConvex ( final Point... points ) {
final int n = points.length;
if ( n < 3 ) {
return false;
}
if ( n == 3 ) {
return true;
}
boolean conv = true;
for ( int i = 0; i < n; ++i ) {
int result = isCrossed( points[i], points[( i + 2 ) % n],
points[( i + 1 ) % n], points[( i + 1 + n / 2 ) % n] );
conv &= result >= 0;
}
return conv;
}
/**
* numをmodで割ったあまりを返します。
* 戻り値は0以上mod未満であることが保証されます。
*
* @param num 被除算数
* @param mod 法とする値
*
* @return numをmodで割ったあまり
*/
public static long remainder ( long num, final long mod ) {
num %= mod;
if ( num < 0 ) {
num += mod;
}
return num;
}
/**
* numが何桁かを返します。
* 0は1桁として捉えます。
*
* @param num 調べる整数
*
* @return numの桁数
*/
public static int digit ( final long num ) {
if ( num < 10L ) {
return 1;
}
if ( num < 100L ) {
return 2;
}
if ( num < 1000L ) {
return 3;
}
if ( num < 10000L ) {
return 4;
}
if ( num < 100000L ) {
return 5;
}
if ( num < 1000000L ) {
return 6;
}
if ( num < 10000000L ) {
return 7;
}
if ( num < 100000000L ) {
return 8;
}
if ( num < 1000000000L ) {
return 9;
}
if ( num < 10000000000L ) {
return 10;
}
if ( num < 100000000000L ) {
return 11;
}
if ( num < 1000000000000L ) {
return 12;
}
if ( num < 10000000000000L ) {
return 13;
}
if ( num < 100000000000000L ) {
return 14;
}
if ( num < 1000000000000000L ) {
return 15;
}
if ( num < 10000000000000000L ) {
return 16;
}
if ( num < 100000000000000000L ) {
return 17;
}
if ( num < 1000000000000000000L ) {
return 18;
}
return 19;
}
public static int max ( final int... nums ) {
int ans = Integer.MIN_VALUE;
for ( int num: nums ) {
ans = Math.max( ans, num );
}
return ans;
}
public static long max ( final long... nums ) {
long ans = Long.MIN_VALUE;
for ( long num: nums ) {
ans = Math.max( ans, num );
}
return ans;
}
public static double max ( final double... nums ) {
double ans = -Double.MIN_VALUE;
for ( double num: nums ) {
ans = Math.max( ans, num );
}
return ans;
}
public static <E extends Comparable<E>> E max ( final E[] nums ) {
E ans = nums[0];
for ( E value: nums ) {
if ( ans.compareTo( value ) > 0 ) {
ans = value;
}
}
return ans;
}
public static int min ( final int... nums ) {
int ans = Integer.MAX_VALUE;
for ( int num: nums ) {
ans = Math.min( ans, num );
}
return ans;
}
public static long min ( final long... nums ) {
long ans = Long.MAX_VALUE;
for ( long num: nums ) {
ans = Math.min( ans, num );
}
return ans;
}
public static double min ( final double... nums ) {
double ans = Double.MAX_VALUE;
for ( double num: nums ) {
ans = Math.min( ans, num );
}
return ans;
}
public static <E extends Comparable<E>> E min ( final E[] nums ) {
E ans = nums[0];
for ( E value: nums ) {
if ( ans.compareTo( value ) < 0 ) {
ans = value;
}
}
return ans;
}
public static long sum ( final int... nums ) {
long ans = 0;
for ( int num: nums ) {
ans += num;
}
return ans;
}
public static long sum ( final long... nums ) {
long ans = 0;
for ( long num: nums ) {
ans += num;
}
return ans;
}
public static long modSum ( final long mod, final int... nums ) {
long ans = 0;
for ( int num: nums ) {
ans += num;
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
public static long modSum ( final long mod, final long... nums ) {
long ans = 0;
for ( long num: nums ) {
ans += num;
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
public static long sum ( final int[] nums, int from, int to ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
}
return ans;
}
public static long sum ( final long[] nums, int from, int to ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
}
return ans;
}
public static long modSum ( final int[] nums, int from, int to, long mod ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
public static long modSum ( final long[] nums, int from, int to, long mod ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck ( final int num, final int l, final int r ) {
return l <= num && num < r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck ( final long num, final long l, final long r ) {
return l <= num && num < r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck ( final double num, final double l, final double r ) {
return l <= num && num < r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheck ( final E num, final E l, final E r ) {
return 0 <= l.compareTo( num ) && 0 < num.compareTo( r );
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen ( final int num, final int l, final int r ) {
return l < num && num < r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen ( final long num, final long l, final long r ) {
return l < num && num < r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen ( final double num, final double l, final double r ) {
return l < num && num < r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckOpen ( final E num, final E l, final E r ) {
return 0 < l.compareTo( num ) && 0 < num.compareTo( r );
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose ( final int num, final int l, final int r ) {
return l <= num && num <= r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose ( final long num, final long l, final long r ) {
return l <= num && num <= r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose ( final double num, final double l, final double r ) {
return l <= num && num <= r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckClose ( final E num, final E l, final E r ) {
return 0 <= l.compareTo( num ) && 0 <= num.compareTo( r );
}
/**
* 引数の中でのmexを求めます。
*
* @param num
*/
public static int mex ( final int... nums ) {
final IntegerSet set = new IntegerSet( nums.length << 1 );
for ( final int num : nums ) {
set.add( num );
}
int ans = 0;
while ( set.contains( ans ) ) {
++ans;
}
return ans;
}
}
final class Searcher {
private static final int CYCLE_COUNT = Double.MAX_EXPONENT + 53;
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final char[] array, final int value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) > 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) > 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static int downSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static long downSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限より小さい値を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static double search ( double a, double b, final double value, final DoubleUnaryOperator func ) {
double ans = a - Math.abs( a ), c;
for ( int $ = 0; $ < CYCLE_COUNT; ++$ ) {
c = ( a + b ) / 2;
if ( func.applyAsDouble( c ) > value ) {
b = c;
}
else {
a = ( ans = c );
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = array[c].compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = list.get( c ).compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains ( int a, int b, final int value, final IntUnaryOperator func ) {
int c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int num = func.applyAsInt( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains ( long a, long b, final long value, final LongUnaryOperator func ) {
long c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
long num = func.applyAsLong( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> int search ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = array[c].compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listのvalueのインデックス(無ければ - 1)
*/
public static <E extends Comparable<E>> int search ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = list.get( c ).compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static int search ( int a, int b, final int value, final IntUnaryOperator func ) {
int c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int num = func.applyAsInt( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return c;
}
}
return a - 1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static long search ( long a, long b, final long value, final LongUnaryOperator func ) {
long c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
long num = func.applyAsLong( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return c;
}
}
return a - 1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) >= 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = list.size(), c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) >= 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static int upSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static long upSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) >= 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素より小さい要素を探します。
* リスト内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) >= 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static int underSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static long underSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) > 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素より大きい要素を探します。
* リスト内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = list.size(), c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) > 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static int overSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static long overSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final int[] array, final int value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final long[] array, final long value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final double[] array, final double value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final char[] array, final char value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch ( final E[] array, final E value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i].compareTo( value ) == 0 ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch ( final List<E> list, final E value ) {
for ( int i = 0; i < list.size(); ++i ) {
if ( list.get( i ).compareTo( value ) == 0 ) {
return i;
}
}
return -1;
}
}
// Binary Indexed Tree
final class BIT {
final int size;
final private long[] tree;
public BIT ( int n ) {
size = n;
tree = new long[n + 1];
}
public long sum ( int i ) {
long sum = 0;
while ( i > 0 ) {
sum += tree[i];
i ^= i & ( -i );
}
return sum;
}
public void add ( int i, long x ) {
while ( i <= size ) {
tree[i] += x;
i += i & ( -i );
}
}
public void clear () {
Arrays.fill( tree, 0L );
}
}
// Binary Indexed Tree(int)
final class BITInt {
final int size;
final private int[] tree;
public BITInt ( int n ) {
size = n;
tree = new int[n + 1];
}
public int sum ( int i ) {
int sum = 0;
while ( i > 0 ) {
sum += tree[i];
i ^= i & ( -i );
}
return sum;
}
public void add ( int i, int x ) {
while ( i <= size ) {
tree[i] += x;
i += i & ( -i );
}
}
public void clear () {
Arrays.fill( tree, 0 );
}
}
final class Bitset implements Cloneable {
private final long[] bit;
private final int size, len;
private final long MASK;
public Bitset ( final int len ) {
this.len = len;
size = ( len + 63 ) >> 6;
bit = new long[size];
MASK = ( -1L ) >>> ( ( size << 6 ) - len );
}
private Bitset ( final long[] arr ) {
this( arr.length );
System.arraycopy( arr, 0, bit, 0, size );
}
public void set ( final int index ) {
if ( index >= size << 6 ) {
throw new ArrayIndexOutOfBoundsException( index + " is out of this bitset's size " + size );
}
bit[index >> 6] |= ( 1L << ( index & 0b111111 ) );
}
public void clear ( final int index ) {
if ( index >= size << 6 ) {
throw new ArrayIndexOutOfBoundsException( index + " is out of this bitset's size " + size );
}
long m = ~( 1L << ( index & 0b111111 ) );
bit[index >> 6] &= m;
}
public boolean get ( final int index ) {
if ( index >= size << 6 ) {
throw new ArrayIndexOutOfBoundsException( index + " is out of this bitset's size " + size );
}
return ( bit[index >> 6] & ( 1L << ( index & 0b111111 ) ) ) != 0;
}
public void shiftLeft ( int num ) {
if ( num >= size << 6 ) {
Arrays.fill( bit, 0L );
return;
}
final int n = num >> 6;
num &= 0b111111;
for ( int i = size - 1; i >= n; --i ) {
bit[i] = ( bit[i - n] << num ) | ( i != n && num != 0 ? bit[i - n - 1] >>> ( 64 - num ) : 0L );
}
for ( int i = 0; i < n; ++i ) {
bit[i] = 0L;
}
bit[size - 1] &= MASK;
}
public void shiftRight ( int num ) {
if ( num >= size << 6 ) {
Arrays.fill( bit, 0L );
return;
}
final int n = num >> 6;
num &= 0b111111;
for ( int i = 0; i < size - n; ++i ) {
bit[i] = ( bit[i + n] >>> num ) | ( i + n + 1 != size && num != 0 ? bit[i + n + 1] << ( 64 - num ) : 0L );
}
for ( int i = size - 1; i >= size - n; --i ) {
bit[i] = 0L;
}
}
public long[] longValues () {
return bit;
}
public long longValue () {
return bit[0];
}
public void and ( final Bitset b ) {
final long[] bit2 = b.longValues();
final int m = Math.min( bit2.length, size );
for ( int i = 0; i < m; ++i ) {
bit[i] &= bit2[i];
}
for ( int i = m; i < size; ++i ) {
bit[i] = 0;
}
bit[size - 1] &= MASK;
}
public void or ( final Bitset b ) {
final long[] bit2 = b.longValues();
final int m = Math.min( bit2.length, size );
for ( int i = 0; i < m; ++i ) {
bit[i] |= bit2[i];
}
bit[size - 1] &= MASK;
}
public void xor ( final Bitset b ) {
final long[] bit2 = b.longValues();
final int m = Math.min( bit2.length, size );
for ( int i = 0; i < m; ++i ) {
bit[i] ^= bit2[i];
}
bit[size - 1] &= MASK;
}
public Bitset clone () throws CloneNotSupportedException {
super.clone();
final Bitset b = new Bitset( bit );
return b;
}
}
final class IntegerSet {
private class Node {
private final int value;
private Node next;
private Node ( final int val ) {
value = val;
}
private boolean add ( final int x ) {
if ( value == x ) {
return false;
}
if ( next != null ) {
return next.add( x );
}
++size;
next = new Node( x );
return true;
}
private void add ( final Node n ) {
if ( value != n.value ) {
if ( next != null ) {
next.add( n );
}
else {
next = n;
}
}
}
private boolean remove ( final int x ) {
if ( next == null ) {
return false;
}
if ( next.value != x ) {
return next.remove( x );
}
--size;
next = next.next;
return true;
}
private boolean contains ( final int x ) {
if ( value == x ) {
return true;
}
if ( next != null ) {
return next.contains( x );
}
return false;
}
}
private Node[] table;
private int size;
public IntegerSet () {
this( 16 );
}
public IntegerSet ( final int s ) {
if ( s < 1 ) {
throw new NegativeArraySizeException( "hash table's size must be positive" );
}
table = new Node[s];
size = 0;
}
public boolean add ( final int x ) {
sizeCheck();
final int index = hash( x );
if ( table[index] != null ) {
return table[index].add( x );
}
++size;
table[index] = new Node( x );
return true;
}
private void add ( final Node n ) {
final int index = hash( n.value );
if ( table[index] != null ) {
table[index].add( n );
}
else {
table[index] = n;
}
}
public boolean remove ( final int x ) {
final int index = hash( x );
if ( table[index] == null ) {
return false;
}
if ( table[index].value != x ) {
return table[index].remove( x );
}
--size;
table[index] = table[index].next;
return true;
}
public boolean contains ( final int x ) {
final int index = hash( x );
if ( table[index] == null ) {
return false;
}
return table[index].contains( x );
}
private void reHash () {
final Node[] oldTable = table;
table = new Node[table.length << 1];
for ( Node node: oldTable ) {
while ( node != null ) {
final Node next = node.next;
node.next = null;
add( node );
node = next;
}
}
}
private void sizeCheck () {
if ( table.length * 0.6 < size ) {
reHash();
}
}
private int hash ( final int val ) {
final int h = val % table.length;
return h < 0 ? h + table.length : h;
}
public int size () {
return size;
}
public int[] toArray () {
final int[] array = new int[size];
int index = 0;
for ( Node node: table ) {
while ( node != null ) {
array[index++] = node.value;
node = node.next;
}
}
return array;
}
public String toString () {
return Arrays.toString( toArray() );
}
}
final class Matrix {
private final long[][] matrix;
public Matrix ( final int H, final int W, final long def ) {
matrix = new long[H][W];
if ( def != 0 ) {
for ( final long[] mat: matrix ) {
Arrays.fill( mat, def );
}
}
}
public Matrix ( final int H, final int W ) {
this( H, W, 0 );
}
public Matrix ( final Dimension d, final long def ) {
this( d.height, d.width, def );
}
public Matrix ( final long[][] mat ) {
matrix = new long[mat.length][];
for ( int i = 0; i < mat.length; ++i ) {
matrix[i] = Arrays.copyOf( mat[i], mat[i].length );
}
}
public long get ( final int i, final int j ) {
return matrix[i][j];
}
public long set ( final int i, final int j, final long value ) {
return matrix[i][j] = value;
}
public Matrix copy () {
return new Matrix( matrix );
}
public Dimension size () {
return new Dimension( matrix[0].length, matrix.length );
}
public Matrix add ( final Matrix m ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, matrix[i][j] + m.get( i, j ) );
}
}
return ans;
}
public Matrix subtract ( final Matrix m ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, matrix[i][j] - m.get( i, j ) );
}
}
return ans;
}
public Matrix multiply ( final Matrix m ) {
if ( size().width != m.size().height ) {
throw new IllegalArgumentException( "matrix length is not same" );
}
final Matrix ans = new Matrix( size().height, m.size().width );
final Dimension size = ans.size();
final int len = size().width;
for ( int i = 0; i < size.height; ++i ) {
for ( int j = 0; j < size.width; ++j ) {
long sum = 0;
for ( int k = 0; k < len; ++k ) {
sum += matrix[i][k] * m.get( k, j );
}
ans.set( i, j, sum );
}
}
return ans;
}
public Matrix modAdd ( final Matrix m, final long mod ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, MathFunction.remainder( matrix[i][j] + m.get( i, j ), mod ) );
}
}
return ans;
}
public Matrix modSubtract ( final Matrix m, final long mod ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, MathFunction.remainder( matrix[i][j] - m.get( i, j ), mod ) );
}
}
return ans;
}
public Matrix modMultiply ( final Matrix m, final long mod ) {
if ( size().width != m.size().height ) {
throw new IllegalArgumentException( "matrix length is not same" );
}
final Matrix ans = new Matrix( size().height, m.size().width );
final Dimension size = ans.size();
final int len = size().width;
for ( int i = 0; i < size.height; ++i ) {
for ( int j = 0; j < size.width; ++j ) {
long sum = 0;
for ( int k = 0; k < len; ++k ) {
sum = MathFunction.remainder( sum + matrix[i][k] * m.get( k, j ), mod );
}
ans.set( i, j, sum );
}
}
return ans;
}
public static Matrix pow ( final Matrix original, final Matrix pw, long exp ) {
Matrix a = original.copy();
Matrix b = pw.copy();
while ( 0 < exp ) {
if ( ( exp & 1 ) == 1 ) {
a = b.multiply( a );
}
b = b.multiply( b );
exp >>= 1;
}
return a;
}
public static Matrix modPow ( final Matrix original, final Matrix pw, long exp, final long mod ) {
Matrix a = original.copy();
Matrix b = pw.copy();
while ( 0 < exp ) {
if ( ( exp & 1 ) == 1 ) {
a = b.modMultiply( a, mod );
}
b = b.modMultiply( b, mod );
exp >>= 1;
}
return a;
}
public long determinant () {
return determinant( matrix );
}
private static long determinant ( final long[][] mat ) {
if ( mat.length == 1 ) {
return mat[0][0];
}
final long[][] miniMat = new long[mat.length - 1][mat.length - 1];
for ( int i = 1; i < mat.length; ++i ) {
System.arraycopy( mat[i], 1, miniMat[i - 1], 0, miniMat.length );
}
long ans = mat[0][0] * determinant( miniMat );
for ( int i = 1; i < mat.length; ++i ) {
for ( int j = 1; j < mat.length; ++j ) {
miniMat[j - 1][i - 1] = mat[j][i - 1];
}
final long num = mat[0][i] * determinant( miniMat );
ans += i % 2 == 0 ? num : -num;
}
return ans;
}
@Override
public String toString () {
final StringBuilder ans = new StringBuilder();
ans.append( Arrays.toString( matrix[0] ) );
for ( int i = 1; i < matrix.length; ++i ) {
ans.append( "\n" );
ans.append( Arrays.toString( matrix[i] ) );
}
return ans.toString();
}
}
final class RollingHash implements Comparable<RollingHash> {
private static final long BASE = new Random().nextInt( 1000 ) + Character.MAX_VALUE + 1;
private static final long MASK30 = ( 1L << 30 ) - 1;
private static final long MASK31 = ( 1L << 31 ) - 1;
private static final long MOD = ( 1L << 61 ) - 1;
private static final long MASK61 = MOD;
private long[] hash;
private String string;
public RollingHash ( final String str ) {
string = str;
hash = new long[str.length() + 1];
roll();
}
private void roll () {
final int len = string.length();
for ( int i = 1; i <= len; ++i ) {
hash[i] = multiply( hash[i - 1], BASE ) + string.charAt( i - 1 ) - ' ' + 1;
if ( MOD <= hash[i] ) {
hash[i] -= MOD;
}
}
}
private static long multiply ( final long a, final long b ) {
final long au = a >> 31;
final long ad = a & MASK31;
final long bu = b >> 31;
final long bd = b & MASK31;
final long mid = ad * bu + au * bd;
final long midu = mid >> 30;
final long midd = mid & MASK30;
return mod( au * bu * 2 + midu + ( midd << 31 ) + ad * bd );
}
private static long mod ( final long x ) {
final long xu = x >> 61;
final long xd = x & MASK61;
long ans = xu + xd;
if ( MOD <= ans ) {
ans -= MOD;
}
return ans;
}
public long getHash ( final int l, final int r ) {
return ( hash[r] - multiply( hash[l], modBasePow( r - l ) ) + MOD ) % MOD;
}
private static long modBasePow ( long b ) {
long ans = 1;
long a = BASE;
while ( b > 0 ) {
if ( ( b & 1 ) == 1 ) {
ans = multiply( ans, a );
}
a = multiply( a, a );
b >>= 1;
}
return ans;
}
public boolean equals ( final RollingHash rh, final int l1, final int r1, final int l2, final int r2 ) {
if ( r1 - l1 != r2 - l2 ) {
return false;
}
return getHash( l1, r1 ) == rh.getHash( l2, r2 );
}
public int length () {
return string.length();
}
@Override
public int hashCode () {
return string.hashCode();
}
@Override
public String toString () {
return string;
}
@Override
public boolean equals ( Object o ) {
if ( o instanceof final RollingHash rh ) {
return equals( rh, 0, length(), 0, rh.length() );
}
return false;
}
@Override
public int compareTo ( RollingHash rh ) {
return string.compareTo( rh.toString() );
}
public int compareTo ( String str ) {
return string.compareTo( str );
}
public char charAt ( final int i ) {
return string.charAt( i );
}
public int compareToIgnoreCase ( final RollingHash rh ) {
return string.compareToIgnoreCase( rh.toString() );
}
public int compareToIgnoreCase ( final String str ) {
return string.compareToIgnoreCase( str );
}
public void concat ( final RollingHash rh ) {
concat( rh.toString() );
}
public void concat ( final String str ) {
string = string.concat( str );
hash = new long[string.length() + 1];
roll();
}
public boolean contains ( final RollingHash rh ) {
final long hash = rh.getHash( 0, rh.length() );
final int len = length() - rh.length();
for ( int i = 0; i <= len; ++i ) {
if ( hash == getHash( i, rh.length() + i ) ) {
return true;
}
}
return false;
}
public boolean contains ( final String str ) {
return indexOf( str ) != -1;
}
public int indexOf ( final int ch ) {
return indexOf( ch, 0 );
}
public int indexOf ( final int ch, final int fromIndex ) {
final int len = length();
for ( int i = fromIndex; i < len; ++i ) {
if ( string.charAt( i ) == ch ) {
return i;
}
}
return -1;
}
public int indexOf ( final String str ) {
return indexOf( str, 0 );
}
public int indexOf ( final String str, final int fromIndex ) {
long hash = 0;
for ( final char c: str.toCharArray() ) {
hash = multiply( hash, BASE ) + c - ' ' + 1;
if ( MOD <= hash ) {
hash -= MOD;
}
}
final int len = length() - str.length();
for ( int i = fromIndex; i <= len; ++i ) {
if ( hash == getHash( i, str.length() + i ) ) {
return i;
}
}
return -1;
}
public boolean isEmpty () {
return length() == 0;
}
public int lastIndexOf ( final int ch, final int fromIndex ) {
for ( int i = fromIndex; i >= 0; --i ) {
if ( string.charAt( i ) == ch ) {
return i;
}
}
return -1;
}
public int lastIndexOf ( final int ch ) {
return lastIndexOf( ch, length() - 1 );
}
public static RollingHash valueOf ( final boolean b ) {
return new RollingHash( b ? "true" : "false" );
}
public static RollingHash valueOf ( final char c ) {
return new RollingHash( "" + c );
}
public static RollingHash valueOf ( final char[] c ) {
return new RollingHash( String.valueOf( c, 0, c.length ) );
}
public static RollingHash valueOf ( final char[] c, final int offset, final int count ) {
return new RollingHash( String.valueOf( c, offset, count ) );
}
public static RollingHash valueOf ( final double d ) {
return new RollingHash( String.valueOf( d ) );
}
public static RollingHash valueOf ( final float f ) {
return new RollingHash( String.valueOf( f ) );
}
public static RollingHash valueOf ( final int i ) {
return new RollingHash( String.valueOf( i ) );
}
public static RollingHash valueOf ( final long l ) {
return new RollingHash( String.valueOf( l ) );
}
public static RollingHash valueOf ( final Object obj ) {
return new RollingHash( String.valueOf( obj ) );
}
}
@SuppressWarnings( "unchecked" )
abstract class SegmentTree<E> {
final int N, size;
final E def;
final Object[] node;
public SegmentTree ( final int n, final E def, final boolean include ) {
int num = 2;
while ( num < n << 1 ) {
num <<= 1;
}
N = num;
size = num >> 1 - ( include ? 1 : 0 );
node = new Object[N];
this.def = def;
Arrays.fill( node, this.def );
}
public SegmentTree ( final E[] arr, final E def, final boolean include ) {
int num = 2;
while ( num < arr.length << 1 ) {
num <<= 1;
}
N = num;
size = num >> 1 - ( include ? 1 : 0 );
node = new Object[N];
this.def = def;
System.arraycopy( arr, 0, node, N >> 1, arr.length );
for ( int i = arr.length + ( N >> 1 ); i < N; i++ ) {
node[i] = def;
}
updateAll();
}
public SegmentTree ( final int n, final E def ) {
this( n, def, false );
}
private void updateAll () {
for ( int i = ( N >> 1 ) - 1; i > 0; i-- ) {
node[i] = function( ( E )node[i << 1], ( E )node[( i << 1 ) + 1] );
}
}
public void update ( int n, final E value ) {
n += size;
node[n] = value;
n >>= 1;
while ( n > 0 ) {
node[n] = function( ( E )node[n << 1], ( E )node[( n << 1 ) + 1] );
n >>= 1;
}
}
public E get ( final int a ) {
return ( E )node[a + size];
}
public E answer () {
return ( E )node[1];
}
public E query ( int l, int r ) {
l += size;
r += size;
E answer = def;
while ( l > 0 && r > 0 && l <= r ) {
if ( l % 2 == 1 ) {
answer = function( ( E )node[l++], answer );
}
l >>= 1;
if ( r % 2 == 0 ) {
answer = function( answer, ( E )node[r--] );
}
r >>= 1;
}
return answer;
}
abstract public E function ( E a, E b );
}
final class UnionFind {
private final int[] par, rank, size, path;
private int count;
public UnionFind ( final int N ) {
count = N;
par = new int[N];
rank = new int[N];
size = new int[N];
path = new int[N];
Arrays.fill( par, -1 );
Arrays.fill( size, 1 );
}
public int root ( final int ind ) {
if ( par[ind] == -1 ) {
return ind;
}
else {
return par[ind] = root( par[ind] );
}
}
public boolean isSame ( final int x, final int y ) {
return root( x ) == root( y );
}
public boolean unite ( final int x, final int y ) {
int rx = root( x );
int ry = root( y );
++path[rx];
if ( rx == ry ) {
return false;
}
if ( rank[rx] < rank[ry] ) {
int temp = rx;
rx = ry;
ry = temp;
}
par[ry] = rx;
if ( rank[rx] == rank[ry] ) {
++rank[rx];
}
path[rx] += path[ry];
size[rx] += size[ry];
--count;
return true;
}
public int groupCount () {
return count;
}
public int pathCount ( final int x ) {
return path[root( x )];
}
public int size ( final int x ) {
return size[root( x )];
}
}
final class Tree<E extends Comparable<E>> {
private Node<E> root;
private int size, hash;
public Tree () {
size = 0;
root = null;
hash = 0;
}
static final private class Node<E> {
E value;
int height, size;
Node<E> left, right, parent;
public Node ( final Node<E> p, final E v ) {
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add ( final E x ) {
boolean bool = true;
if ( root == null ) {
root = new Node<>( null, x );
}
else {
Node<E> par;
Node<E> now = root;
do {
par = now;
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
bool = false;
break;
}
} while ( now != null );
if ( bool ) {
final int result = x.compareTo( par.value );
if ( result < 0 ) {
par.left = new Node<>( par, x );
}
else {
par.right = new Node<>( par, x );
}
fix( par );
}
}
if ( bool ) {
++size;
hash ^= x.hashCode();
}
return bool;
}
public E get ( int index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node<E> now = root;
while ( true ) {
assert now != null;
final int ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls < index ) {
now = now.right;
index -= ls + 1;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final E x ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= n.value.hashCode();
delete( n );
return true;
}
private void delete ( final Node<E> node ) {
if ( node != null ) {
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
}
else {
if ( node.left != null && node.right != null ) {
final Node<E> rep = getFirstNode( node.right );
node.value = rep.value;
delete( rep );
}
else {
final Node<E> rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
}
}
}
}
private Node<E> getNode ( final E x ) {
Node<E> now = root;
while ( now != null ) {
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public E first () {
if ( root == null ) {
return null;
}
return getFirstNode( root ).value;
}
private Node<E> getFirstNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public E last () {
if ( root == null ) {
return null;
}
return getLastNode( root ).value;
}
private Node<E> getLastNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final E x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public E pollFirst () {
if ( root == null ) {
return null;
}
--size;
final Node<E> min = getFirstNode( root );
hash ^= min.value.hashCode();
delete( min );
return min.value;
}
public E pollLast () {
if ( root == null ) {
return null;
}
--size;
final Node<E> max = getLastNode( root );
hash ^= max.value.hashCode();
delete( max );
return max.value;
}
public E ceiling ( final E x ) {
return ceiling( root, x );
}
private E ceiling ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result > 0 ) {
node = node.right;
}
else if ( result < 0 ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E higher ( final E x ) {
return higher( root, x );
}
private E higher ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result >= 0 ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans != null ? ans.value : null;
}
public E floor ( final E x ) {
return floor( root, x );
}
private E floor ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result < 0 ) {
node = node.left;
}
else if ( result > 0 ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E lower ( final E x ) {
return lower( root, x );
}
private E lower ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result <= 0 ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans != null ? ans.value : null;
}
public void clear () {
root = null;
size = 0;
hash = 0;
}
public boolean isEmpty () {
return size == 0;
}
public int size () {
return size;
}
public ArrayList<E> toList () {
final ArrayList<E> list = new ArrayList<>();
if ( root != null ) {
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node<E> now = deq.pollLast();
if ( list.size() == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list.add( now.value );
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list.get( list.size() - 1 ).compareTo( now.left.value ) < 0 ) {
deq.add( now );
deq.add( now.left );
}
else {
list.add( now.value );
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final ArrayList<E> list = toList();
return list.toString();
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final Tree<?> tree ) {
if ( size != tree.size() ) {
return false;
}
final ArrayList<E> list1 = toList();
final ArrayList<?> list2 = tree.toList();
for ( int i = 0; i < size; ++i ) {
if ( !list1.get( i ).equals( list2.get( i ) ) ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node<E> node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
}
rotateL( node );
}
else {
setStates( node );
}
node = node.parent;
}
}
private void rotateR ( final Node<E> node ) {
final Node<E> temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node<E> node ) {
final Node<E> temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node<E> node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final int ls = node.left != null ? node.left.size : 0;
final int rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + 1;
}
}
final class TreeInt {
private Node root;
private int size, hash;
public TreeInt () {
size = 0;
root = null;
hash = 0;
}
static final private class Node {
int value;
int height, size;
Node left, right, parent;
public Node ( final Node p, final int v ) {
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add ( final int x ) {
boolean bool = true;
if ( root == null ) {
root = new Node( null, x );
}
else {
Node par;
Node now = root;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
break;
}
} while ( now != null );
if ( bool ) {
if ( x < par.value ) {
par.left = new Node( par, x );
}
else {
par.right = new Node( par, x );
}
fix( par );
}
}
if ( bool ) {
++size;
hash ^= x;
}
return bool;
}
public int get ( int index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final int ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls < index ) {
now = now.right;
index -= ls + 1;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final int x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= n.value;
delete( n );
return true;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
}
}
}
}
private Node getNode ( final int x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public int first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public int last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final int x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public int pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= min.value;
delete( min );
return min.value;
}
public int pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= max.value;
delete( max );
return max.value;
}
public int ceiling ( final int x ) {
return ceiling( root, x );
}
private int ceiling ( Node node, final int x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public int higher ( final int x ) {
return higher( root, x );
}
private int higher ( Node node, final int x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public int floor ( final int x ) {
return floor( root, x );
}
private int floor ( Node node, final int x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public int lower ( final int x ) {
return lower( root, x );
}
private int lower ( Node node, final int x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public void clear () {
root = null;
size = 0;
hash = 0;
}
public boolean isEmpty () {
return size == 0;
}
public int size () {
return size;
}
public int[] toArray () {
final int[] list = new int[size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final int[] list = toArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeInt tree ) {
if ( size != tree.size() ) {
return false;
}
final int[] array1 = toArray();
final int[] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i] != array2[i] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
}
rotateL( node );
}
else {
setStates( node );
}
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final int ls = node.left != null ? node.left.size : 0;
final int rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + 1;
}
}
final class TreeLong {
private Node root;
private int size, hash;
public TreeLong () {
size = 0;
root = null;
hash = 0;
}
static final private class Node {
long value;
int height, size;
Node left, right, parent;
public Node ( final Node p, final long v ) {
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add ( final long x ) {
boolean bool = true;
if ( root == null ) {
root = new Node( null, x );
}
else {
Node par;
Node now = root;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
break;
}
} while ( now != null );
if ( bool ) {
if ( x < par.value ) {
par.left = new Node( par, x );
}
else {
par.right = new Node( par, x );
}
fix( par );
}
}
if ( bool ) {
++size;
hash ^= ( int )x;
}
return bool;
}
public long get ( int index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final int ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls < index ) {
now = now.right;
index -= ls + 1;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final long x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= ( int )x;
delete( n );
return true;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
}
}
}
}
private Node getNode ( final long x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public long first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public long last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final long x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= ( int )min.value;
delete( min );
return min.value;
}
public long pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= ( int )max.value;
delete( max );
return max.value;
}
public long ceiling ( final long x ) {
return ceiling( root, x );
}
private long ceiling ( Node node, final long x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public long higher ( final long x ) {
return higher( root, x );
}
private long higher ( Node node, final long x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public long floor ( final long x ) {
return floor( root, x );
}
private long floor ( Node node, final long x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public long lower ( final long x ) {
return lower( root, x );
}
private long lower ( Node node, final long x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public int size () {
return size;
}
public long[] toArray () {
final long[] list = new long[size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final long[] list = toArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeLong tree ) {
if ( size != tree.size() ) {
return false;
}
final long[] array1 = toArray();
final long[] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i] != array2[i] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
}
rotateL( node );
}
else {
setStates( node );
}
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final int ls = node.left != null ? node.left.size : 0;
final int rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + 1;
}
}
final class TreeMulti<E extends Comparable<E>> {
private Node<E> root;
private long size;
private int uniqueSize;
private int hash;
public TreeMulti () {
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node<E> {
E value;
long count, size;
int height;
Node<E> left, right, parent;
public Node ( final Node<E> p, final E v, final long c ) {
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add ( final E x ) {
if ( root == null ) {
root = new Node<>( null, x, 1 );
++uniqueSize;
}
else {
Node<E> par;
Node<E> now = root;
boolean bool = true;
do {
par = now;
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
bool = false;
++now.count;
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
final int result = x.compareTo( par.value );
if ( result < 0 ) {
par.left = new Node<>( par, x, 1 );
}
else {
par.right = new Node<>( par, x, 1 );
}
}
fix( par );
}
++size;
hash ^= x.hashCode();
}
public void add ( final E x, final long sum ) {
if ( root == null ) {
root = new Node<>( null, x, sum );
++uniqueSize;
}
else {
Node<E> par;
Node<E> now = root;
boolean bool = true;
do {
par = now;
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
bool = false;
now.count += sum;
fix( now );
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
final int result = x.compareTo( par.value );
if ( result < 0 ) {
par.left = new Node<>( par, x, sum );
}
else {
par.right = new Node<>( par, x, sum );
}
fix( par );
}
}
size += sum;
hash ^= sum % 2 == 1 ? x.hashCode() : 0;
}
public E get ( long index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node<E> now = root;
while ( true ) {
assert now != null;
final long ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls + now.count <= index ) {
index -= ls + now.count;
now = now.right;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final E x ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= n.hashCode();
delete( n );
return true;
}
public long remove ( final E x, final long sum ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return 0;
}
final long ans = Math.min( sum, n.count );
size -= ans;
hash ^= ans % 2 == 1 ? n.hashCode() : 0;
n.count -= ans - 1;
delete( n );
return ans;
}
public long removeAll ( final E x ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return 0;
}
size -= n.count;
final long ans = n.count;
hash ^= ans % 2 == 1 ? n.hashCode() : 0;
n.count = 0;
delete( n );
return ans;
}
private void delete ( final Node<E> node ) {
if ( node != null ) {
if ( node.count > 1 ) {
--node.count;
fix( node );
return;
}
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
--uniqueSize;
}
else {
if ( node.left != null && node.right != null ) {
final Node<E> rep = getFirstNode( node.right );
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete( rep );
}
else {
final Node<E> rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node<E> getNode ( final E x ) {
Node<E> now = root;
while ( now != null ) {
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public E first () {
if ( root == null ) {
return null;
}
return getFirstNode( root ).value;
}
private Node<E> getFirstNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public E last () {
if ( root == null ) {
return null;
}
return getLastNode( root ).value;
}
private Node<E> getLastNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final E x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long sum ( final E x ) {
if ( root == null ) {
return 0;
}
Node<E> node = getNode( x );
return node != null ? node.count : 0;
}
public E pollFirst () {
if ( root == null ) {
return null;
}
--size;
final Node<E> min = getFirstNode( root );
hash ^= min.value.hashCode();
final E ans = min.value;
delete( min );
return ans;
}
public E pollLast () {
if ( root == null ) {
return null;
}
--size;
final Node<E> max = getLastNode( root );
hash ^= max.value.hashCode();
final E ans = max.value;
delete( max );
return ans;
}
public E ceiling ( final E x ) {
return ceiling( root, x );
}
private E ceiling ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result > 0 ) {
node = node.right;
}
else if ( result < 0 ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E higher ( final E x ) {
return higher( root, x );
}
private E higher ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result >= 0 ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans != null ? ans.value : null;
}
public E floor ( final E x ) {
return floor( root, x );
}
private E floor ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result < 0 ) {
node = node.left;
}
else if ( result > 0 ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E lower ( final E x ) {
return lower( root, x );
}
private E lower ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result <= 0 ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans != null ? ans.value : null;
}
public int size () {
return uniqueSize;
}
public long sumSize () {
return size;
}
public ArrayList<E> toList () {
final ArrayList<E> list = new ArrayList<>();
if ( root != null ) {
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node<E> now = deq.pollLast();
if ( list.size() == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list.add( now.value );
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list.get( list.size() - 1 ).compareTo( now.left.value ) < 0 ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list.add( now.value );
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final ArrayList<E> list = toList();
return list.toString();
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeMulti<?> tree ) {
if ( size != tree.size() ) {
return false;
}
final ArrayList<E> array1 = toList();
final ArrayList<?> array2 = tree.toList();
for ( int i = 0; i < size; ++i ) {
if ( !array1.get( i ).equals( array2.get( i ) ) ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node<E> node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
setStates( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
setStates( node.right );
}
rotateL( node );
}
setStates( node );
node = node.parent;
}
}
private void rotateR ( final Node<E> node ) {
final Node<E> temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node<E> node ) {
final Node<E> temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node<E> node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final long ls = node.left != null ? node.left.size : 0;
final long rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + node.count;
}
}
final class TreeMultiInt {
private Node root;
private long size;
private int uniqueSize;
private int hash;
public TreeMultiInt () {
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node {
int value;
long count, size;
int height;
Node left, right, parent;
public Node ( final Node p, final int v, final long c ) {
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add ( final int x ) {
if ( root == null ) {
root = new Node( null, x, 1 );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
++now.count;
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, 1 );
}
else {
par.right = new Node( par, x, 1 );
}
}
fix( par );
}
++size;
hash ^= x;
}
public void add ( final int x, final long sum ) {
if ( root == null ) {
root = new Node( null, x, sum );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
now.count += sum;
fix( now );
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, sum );
}
else {
par.right = new Node( par, x, sum );
}
fix( par );
}
}
size += sum;
if ( sum % 2 == 1 ) {
hash ^= x;
}
}
public int get ( long index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final long ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls + now.count <= index ) {
index -= ls + now.count;
now = now.right;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final int x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= x;
delete( n );
return true;
}
public long remove ( final int x, final long sum ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
final long ans = Math.min( sum, n.count );
size -= ans;
n.count -= ans - 1;
if ( ans % 2 == 1 ) {
hash ^= x;
}
delete( n );
return ans;
}
public long removeAll ( final int x ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
size -= n.count;
final long ans = n.count;
if ( n.count % 2 == 1 ) {
hash ^= x;
}
n.count = 0;
delete( n );
return ans;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.count > 1 ) {
--node.count;
fix( node );
return;
}
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
--uniqueSize;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node getNode ( final int x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public int first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public int last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final int x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long sum ( final int x ) {
if ( root == null ) {
return 0;
}
Node node = getNode( x );
return node != null ? node.count : 0;
}
public int pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= min.value;
final int ans = min.value;
delete( min );
return ans;
}
public int pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= max.value;
final int ans = max.value;
delete( max );
return ans;
}
public int ceiling ( final int x ) {
return ceiling( root, x );
}
private int ceiling ( Node node, final int x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public int higher ( final int x ) {
return higher( root, x );
}
private int higher ( Node node, final int x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public int floor ( final int x ) {
return floor( root, x );
}
private int floor ( Node node, final int x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public int lower ( final int x ) {
return lower( root, x );
}
private int lower ( Node node, final int x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public int size () {
return uniqueSize;
}
public long sumSize () {
return size;
}
public long[][] toArray () {
final long[][] list = new long[uniqueSize][2];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>( root.height << 1 );
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1][0] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
public int[] toOneArray () {
final int[] list = new int[( int )size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final int[] list = toOneArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeMultiInt tree ) {
if ( size != tree.size() ) {
return false;
}
final long[][] array1 = toArray();
final long[][] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i][0] != array2[i][0] || array1[i][1] != array2[i][1] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
setStates( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
setStates( node.right );
}
rotateL( node );
}
setStates( node );
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final long ls = node.left != null ? node.left.size : 0;
final long rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + node.count;
}
}
final class TreeMultiLong {
private Node root;
private long size;
private int uniqueSize;
private int hash;
public TreeMultiLong () {
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node {
long value;
long count, size;
int height;
Node left, right, parent;
public Node ( final Node p, final long v, final long c ) {
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add ( final long x ) {
if ( root == null ) {
root = new Node( null, x, 1 );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
++now.count;
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, 1 );
}
else {
par.right = new Node( par, x, 1 );
}
}
fix( par );
}
++size;
hash ^= ( int )x;
}
public void add ( final long x, final long sum ) {
if ( root == null ) {
root = new Node( null, x, sum );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
now.count += sum;
fix( now );
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, sum );
}
else {
par.right = new Node( par, x, sum );
}
fix( par );
}
}
size += sum;
if ( sum % 2 == 1 ) {
hash ^= ( int )x;
}
}
public long get ( long index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final long ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls + now.count <= index ) {
index -= ls + now.count;
now = now.right;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final long x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= x;
delete( n );
return true;
}
public long remove ( final long x, final long sum ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
final long ans = Math.min( sum, n.count );
size -= ans;
n.count -= ans - 1;
if ( ans % 2 == 1 ) {
hash ^= ( int )x;
}
delete( n );
return ans;
}
public long removeAll ( final long x ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
size -= n.count;
final long ans = n.count;
if ( n.count % 2 == 1 ) {
hash ^= ( int )x;
}
n.count = 0;
delete( n );
return ans;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.count > 1 ) {
--node.count;
fix( node );
return;
}
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
--uniqueSize;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node getNode ( final long x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public long first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public long last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final long x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long sum ( final long x ) {
if ( root == null ) {
return 0;
}
final Node node = getNode( x );
return node != null ? node.count : 0;
}
public long pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= ( int )min.value;
final long ans = min.value;
delete( min );
return ans;
}
public long pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= ( int )max.value;
final long ans = max.value;
delete( max );
return ans;
}
public long ceiling ( final long x ) {
return ceiling( root, x );
}
private long ceiling ( Node node, final long x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public long higher ( final long x ) {
return higher( root, x );
}
private long higher ( Node node, final long x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public long floor ( final long x ) {
return floor( root, x );
}
private long floor ( Node node, final long x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public long lower ( final long x ) {
return lower( root, x );
}
private long lower ( Node node, final long x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public int size () {
return uniqueSize;
}
public long sumSize () {
return size;
}
public long[][] toArray () {
final long[][] list = new long[uniqueSize][2];
if ( root != null ) {
int index = 0;
ArrayDeque<Node> deq = new ArrayDeque<>( root.height << 1 );
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1][0] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
public long[] toOneArray () {
final long[] list = new long[( int )size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final long[] list = toOneArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeMultiInt tree ) {
if ( size != tree.size() ) {
return false;
}
final long[][] array1 = toArray();
final long[][] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i][0] != array2[i][0] || array1[i][1] != array2[i][1] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
setStates( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
setStates( node.right );
}
rotateL( node );
}
setStates( node );
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final long ls = node.left != null ? node.left.size : 0;
final long rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + node.count;
}
}
final class SimpleScanner {
private final int BUFF_SIZE = 1 << 17;
private final InputStream is;
private final byte[] buff;
private int point, length;
public SimpleScanner ( final InputStream is ) {
this.is = is;
buff = new byte[BUFF_SIZE];
point = length = 0;
}
private void reload () {
do {
try {
length = is.read( buff, point = 0, BUFF_SIZE );
} catch ( final IOException e ) {
e.printStackTrace();
System.exit( 1 );
}
} while ( length == -1 );
}
private byte read () {
if ( point == length ) {
reload();
}
return buff[point++];
}
public byte nextByte () {
byte c = read();
while ( c <= ' ' ) {
c = read();
}
return c;
}
public int nextInt () {
int ans = 0;
byte c = nextByte();
final boolean negate = c == '-';
if ( !MathFunction.rangeCheckClose( c, '0', '9' ) ) {
c = read();
}
while ( MathFunction.rangeCheckClose( c, '0', '9' ) ) {
ans = ans * 10 + c - '0';
c = read();
}
return negate ? -ans : ans;
}
public long nextLong () {
long ans = 0;
byte c = nextByte();
final boolean negate = c == '-';
if ( !MathFunction.rangeCheckClose( c, '0', '9' ) ) {
c = read();
}
while ( MathFunction.rangeCheckClose( c, '0', '9' ) ) {
ans = ans * 10L + c - '0';
c = read();
}
return negate ? -ans : ans;
}
public char nextChar () {
return ( char )nextByte();
}
public String next () {
final StringBuilder ans = new StringBuilder();
byte c = nextByte();
while ( c > ' ' ) {
ans.append( ( char )c );
c = read();
}
return ans.toString();
}
public BigInteger nextBigInteger () {
return new BigInteger( next() );
}
public byte[] nextByte ( final int n ) {
final byte[] ans = new byte[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextByte();
}
return ans;
}
public int[] nextInt ( final int n ) {
final int[] ans = new int[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextInt();
}
return ans;
}
public long[] nextLong ( final int n ) {
final long[] ans = new long[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextLong();
}
return ans;
}
public String[] next ( final int n ) {
final String[] ans = new String[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = next();
}
return ans;
}
public byte[][] nextByte ( final int n, final int m ) {
final byte[][] ans = new byte[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextByte( m );
}
return ans;
}
public int[][] nextInt ( final int n, final int m ) {
final int[][] ans = new int[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextInt( m );
}
return ans;
}
public long[][] nextLong ( final int n, final int m ) {
final long[][] ans = new long[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextLong( m );
}
return ans;
}
public String[][] next ( final int n, final int m ) {
final String[][] ans = new String[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = next( m );
}
return ans;
}
public char[] nextCharArray () {
return next().toCharArray();
}
public char[][] nextCharArray ( final int n ) {
final char[][] ans = new char[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextCharArray();
}
return ans;
}
public int[][] nextGraph ( final int N, final int M ) {
if ( M == 0 ) {
return new int[N + 1][0];
}
final int[][] ans = new int[N + 1][];
final int[] count = new int[N + 1];
final int[][] path = nextInt( M, 2 );
for ( final int[] temp: path ) {
++count[temp[0]];
++count[temp[1]];
}
for ( int i = 1; i <= N; ++i ) {
ans[i] = new int[count[i]];
}
for ( final int[] temp: path ) {
ans[temp[0]][--count[temp[0]]] = temp[1];
ans[temp[1]][--count[temp[1]]] = temp[0];
}
ans[0] = new int[0];
return ans;
}
public Point nextPoint () {
return new Point( nextInt(), nextInt() );
}
public Point[] nextPoint ( final int n ) {
final Point[] ans = new Point[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextPoint();
}
return ans;
}
public void close () {
try {
is.close();
} catch ( final IOException e ) {
e.printStackTrace();
System.exit( 1 );
}
}
}
final class SimpleOutputStream extends FilterOutputStream {
private final byte buf[];
private int count;
public SimpleOutputStream(final OutputStream out) {
this(out, 1<<17);
}
public SimpleOutputStream(final OutputStream out, final int size) {
super(out);
if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
private void flushBuffer() throws IOException {
if (count > 0) {
out.write(buf, 0, count);
count = 0;
}
}
public void write(final int b) throws IOException {
if (count >= buf.length) {
flushBuffer();
}
buf[count++] = (byte)b;
}
public void write(final byte b[], final int off, final int len) throws IOException {
if (len >= buf.length) {
flushBuffer();
out.write(b, off, len);
return;
}
if (len > buf.length - count) {
flushBuffer();
}
System.arraycopy(b, off, buf, count, len);
count += len;
}
public void flush() throws IOException {
flushBuffer();
out.flush();
}
}
final class SimpleWriter implements Appendable, Closeable, Flushable, AutoCloseable{
private Writer out;
private final boolean autoFlush;
private boolean trouble = false;
private Formatter formatter;
private PrintStream psOut = null;
private static Charset toCharset ( final String csn ) {
if ( csn == null ) {
throw new NullPointerException( "charsetName" );
}
try {
return Charset.forName( csn );
} catch ( IllegalCharsetNameException |
UnsupportedCharsetException e ) {
e.printStackTrace();
System.exit( 1 );
return null;
}
}
public SimpleWriter ( final Writer out ) {
this( out, false );
}
public SimpleWriter ( final Writer out, final boolean autoFlush ) {
this.out = out;
this.autoFlush = autoFlush;
}
public SimpleWriter ( final OutputStream out ) {
this( out, false );
}
public SimpleWriter ( final OutputStream out, final boolean autoFlush ) {
this(out, autoFlush, Charset.defaultCharset());
}
public SimpleWriter(final OutputStream out, final boolean autoFlush, final Charset charset) {
this(new BufferedWriter(new OutputStreamWriter(new SimpleOutputStream(out), charset)), autoFlush);
if (out instanceof PrintStream) {
psOut = (PrintStream) out;
}
}
private void ensureOpen () throws IOException {
if ( out == null ) {
throw new IOException( "Stream closed" );
}
}
public void flush () {
try {
ensureOpen();
out.flush();
} catch ( IOException x ) {
trouble = true;
}
}
public void close () {
try {
if ( out == null ) {
return;
}
out.close();
out = null;
} catch ( IOException x ) {
trouble = true;
}
}
public boolean checkError () {
if ( out != null ) {
flush();
}
else if ( psOut != null ) {
return psOut.checkError();
}
return trouble;
}
private void setError () {
trouble = true;
}
private void clearError () {
trouble = false;
}
public void write ( final int c ) {
try {
ensureOpen();
out.write( c );
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void write ( final char[] buf, final int off, final int len ) {
try {
ensureOpen();
out.write( buf, off, len );
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void write ( final char[] buf ) {
write( buf, 0, buf.length );
}
public void write ( final String s, final int off, final int len ) {
try {
ensureOpen();
out.write( s, off, len );
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void write ( final String s ) {
write( s, 0, s.length() );
}
private void newLine () {
try {
ensureOpen();
out.write( System.lineSeparator() );
if ( autoFlush ) {
out.flush();
}
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void print ( final boolean b ) {
write( b ? "true" : "false" );
}
public void print ( final char c ) {
write( c );
}
public void print ( final int i ) {
write( String.valueOf( i ) );
}
public void print ( final long l ) {
write( String.valueOf( l ) );
}
public void print ( final float f ) {
write( String.valueOf( f ) );
}
public void print ( final double d ) {
write( String.valueOf( d ) );
}
public void print ( final char[] s ) {
write( s );
}
public void print ( final String s ) {
write( s );
}
public void print ( final Object obj ) {
write( obj.toString() );
}
public void println () {
newLine();
}
public void println ( final boolean x ) {
print( x );
println();
}
public void println ( final char x ) {
print( x );
println();
}
public void println ( final int x ) {
print( x );
println();
}
public void println ( final long x ) {
print( x );
println();
}
public void println ( final float x ) {
print( x );
println();
}
public void println ( final double x ) {
print( x );
println();
}
public void println ( final char[] x ) {
print( x );
println();
}
public void println ( final String x ) {
print( x );
println();
}
public void println ( final Object x ) {
print( x.toString() );
println();
}
public SimpleWriter printf ( final String format, final Object... args ) {
return format( format, args );
}
public SimpleWriter printf ( final Locale l, final String format, final Object... args ) {
return format( l, format, args );
}
public SimpleWriter format ( final String format, final Object... args ) {
try {
ensureOpen();
if ( ( formatter == null )
|| ( formatter.locale() != Locale.getDefault() ) ) {
formatter = new Formatter( this );
}
formatter.format( Locale.getDefault(), format, args );
if ( autoFlush ) {
out.flush();
}
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
return this;
}
public SimpleWriter format ( final Locale l, final String format, final Object... args ) {
try {
ensureOpen();
if ( ( formatter == null ) || ( formatter.locale() != l ) ) {
formatter = new Formatter( this, l );
}
formatter.format( l, format, args );
if ( autoFlush ) {
out.flush();
}
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
return this;
}
public SimpleWriter append ( final CharSequence csq ) {
write( String.valueOf( csq ) );
return this;
}
public SimpleWriter append ( CharSequence csq, final int start, final int end ) {
if ( csq == null ) {
csq = "null";
}
return append( csq.subSequence( start, end ) );
}
public SimpleWriter append ( final char c ) {
write( c );
return this;
}
public void print ( final int[] array ) {
print( array, ' ' );
}
public void print ( final int[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
}
public void print ( final int[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
}
public void print ( final int[][] array ) {
print( array, ' ' );
}
public void print ( final int[][] arrays, final String str ) {
print( arrays[0], str );
for ( int i = 1; i < arrays.length; ++i ) {
println();
print( arrays[i], str );
}
}
public void print ( final int[][] arrays, final char c ) {
print( arrays[0], c );
for ( int i = 1; i < arrays.length; ++i ) {
println();
print( arrays[i], c );
}
}
public void println ( final int[] array ) {
print( array, ' ' );
println();
}
public void println ( final int[] array, final String str ) {
print( array, str );
println();
}
public void println ( final int[] array, final char c ) {
print( array, c );
println();
}
public void println ( final int[][] array ) {
print( array, ' ' );
println();
}
public void println ( final int[][] arrays, final String str ) {
print( arrays, str );
println();
}
public void println ( final int[][] arrays, final char c ) {
print( arrays, c );
println();
}
public void println ( final long[] array ) {
println( array, ' ' );
}
public void println ( final long[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
println();
}
public void println ( final long[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
println();
}
public void println ( final long[][] array ) {
println( array, ' ' );
}
public void println ( final long[][] arrays, final String str ) {
for ( final long[] array: arrays ) {
println( array, str );
}
}
public void println ( final long[][] arrays, final char c ) {
for ( final long[] array: arrays ) {
println( array, c );
}
}
public void println ( final double[] array ) {
println( array, ' ' );
}
public void println ( final double[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
println();
}
public void println ( final double[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
println();
}
public void println ( final double[][] array ) {
println( array, ' ' );
}
public void println ( final double[][] arrays, final String str ) {
for ( final double[] array: arrays ) {
println( array, str );
}
}
public void println ( final double[][] arrays, final char c ) {
for ( final double[] array: arrays ) {
println( array, c );
}
}
public void println ( final char[] cs, final String str ) {
print( cs[0] );
for ( int i = 1; i < cs.length; ++i ) {
print( str );
print( cs[i] );
}
println();
}
public void println ( final char[] cs, final char c ) {
print( cs[0] );
for ( int i = 1; i < cs.length; ++i ) {
print( c );
print( cs[i] );
}
println();
}
public void println ( final char[][] cs ) {
for ( final char[] c: cs ) {
println( c );
}
}
public void println ( final char[][] cs, final String str ) {
for ( final char[] c: cs ) {
println( c, str );
}
}
public void println ( final char[][] cs, final char c ) {
for ( final char[] cc: cs ) {
println( cc, c );
}
}
public <E> void println ( final E[] array ) {
println( array, ' ' );
}
public <E> void println ( final E[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
println();
}
public <E> void println ( final E[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
println();
}
public <E> void println ( final E[][] arrays ) {
println( arrays, ' ' );
}
public <E> void println ( final E[][] arrays, final String str ) {
for ( final E[] array: arrays ) {
println( array, str );
}
}
public <E> void println ( final E[][] arrays, final char c ) {
for ( final E[] array: arrays ) {
println( array, c );
}
}
public <E> void println ( final List<E> list ) {
println( list, ' ' );
}
public <E> void println ( final List<E> list, final String str ) {
if ( list.size() == 0 ) {
println();
return;
}
print( list.get( 0 ) );
for ( int i = 1; i < list.size(); ++i ) {
print( str );
print( list.get( i ) );
}
println();
}
public <E> void println ( final List<E> list, final char c ) {
if ( list.size() == 0 ) {
println();
return;
}
print( list.get( 0 ) );
for ( int i = 1; i < list.size(); ++i ) {
print( c );
print( list.get( i ) );
}
println();
}
}
import java.awt.Dimension;
import java.awt.Point;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.FilterOutputStream;
import java.io.Flushable;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Formatter;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.DoubleUnaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;
//Maybe use
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.TreeMap;
import java.util.TreeSet;
final class Main {
private static final boolean autoFlush = false;
private static final SimpleScanner sc = new SimpleScanner( System.in );
private static final SimpleWriter out = new SimpleWriter( System.out, autoFlush );
public static void main ( String[] args ) {
int N = sc.nextInt();
int D = sc.nextInt();
int W = sc.nextInt();
int[][] query = sc.nextInt(N,2);
final int rangeMax = 200_001;
LazySegmentTree<Integer,Integer> lSegT = new LazySegmentTree<>(rangeMax,0,0,true){
public Integer function(Integer a,Integer b){
return Math.max(a,b);
}
public Integer composition(Integer a,Integer b){
return a+b;
}
public Integer mapping(Integer a,Integer b){
return a+b;
}
};
Arrays.sort(query,(a,b)->Integer.compare(a[0],b[0]));
int l = 0;
int ans = 0;
for(int r=0;r<N;r++){
lSegT.apply(query[r][1],Math.min(rangeMax,query[r][1]+W),1);
int limit = query[r][0]-D;
while(l<r&&query[l][0]<=limit)
lSegT.apply(query[l][1],Math.min(rangeMax,query[l++][1]+W),-1);
ans = Math.max(ans,lSegT.answer());
}
out.println(ans);
out.close();
}
}
@SuppressWarnings( "unchecked" )
abstract class LazySegmentTree<S,F> {
private final int N,size,log;
private final S defaultS;
private final F defaultF;
private final S[] node;
private final F[] lazy;
public LazySegmentTree(int N,S defaultS,F defaultF){
this(N,defaultS,defaultF,false);
}
public LazySegmentTree(int N,S defaultS,F defaultF,boolean is1indexed){
this.N = N;
this.log = 32-Integer.numberOfLeadingZeros(N-1);
this.size = (1<<log)-(is1indexed?1:0);
this.defaultS = defaultS;
this.defaultF = defaultF;
this.node = (S[])new Object[1<<log+1];
this.lazy = (F[])new Object[1<<log+1];
clear();
}
public LazySegmentTree(S[] defaultValues,S defaultS,F defaultF,boolean is1indexed){
this(defaultValues.length,defaultS,defaultF,is1indexed);
updateAll(defaultValues);
}
public void clear(){
Arrays.fill(this.node,this.defaultS);
Arrays.fill(this.lazy,this.defaultF);
}
public void updateAll(S[] defaultValues){
System.arraycopy(defaultValues,0,node,1<<log,defaultValues.length);
for(int i=(1<<log)-1;i>0;i--){
node[i] = function(node[i<<1],node[i<<1|1]);
}
}
private void spread(int index){
if(lazy[index]!=defaultF){
int l = index<<1;
int r = index<<1|1;
node[l] = mapping(node[l],lazy[index]);
node[r] = mapping(node[r],lazy[index]);
lazy[l] = composition(lazy[index],lazy[l]);
lazy[r] = composition(lazy[index],lazy[r]);
lazy[index] = defaultF;
}
}
private void spreadLine(int from){
for(int i=log;i>0;i++)
spread(from>>i);
}
private void spreadRange(int l,int r){
for(int i=log;i>0;i--){
if((l>>i<<i)!=l)
spread(l>>i);
if((r>>i<<i)!=r)
spread(r>>i);
}
}
private void update(int index){
while((index>>=1)>0)
node[index] = function(node[index<<1],node[index<<1|1]);
}
private void update(int l,int r){
for(int i=1;i<=log;i++){
int subL = l>>i;
int subR = r>>i;
if((subL<<i)!=l)
node[subL] = function(node[subL<<1],node[subL<<1|1]);
if((subR<<i)!=r)
node[subR] = function(node[subR<<1],node[subR<<1|1]);
}
}
public void update(int index,S x){
index += size;
spreadLine(index);
node[index] = x;
update(index);
}
public S get(int index){
index += size;
spreadLine(index);
return node[index];
}
public S query(int l,int r){
l += size;
r += size;
spreadRange(l,r);
S sumL = defaultS;
S sumR = defaultS;
while(l<r){
if((l&1)==1)
sumL = function(sumL,node[l++]);
if((r&1)==0)
sumR = function(node[--r],sumR);
l >>= 1;
r >>= 1;
}
return function(sumL,sumR);
}
public S answer () {
return ( S )node[1];
}
public void apply(int index,F f){
index += size;
spreadLine(index);
node[index] = mapping(node[index],f);
update(index);
}
public void apply(int l,int r,F f){
l += size;
r += size;
spreadRange(l,r);
int subL = l;
int subR = r;
while(subL<subR){
if((subL&1)==1){
node[subL] = mapping(node[subL],f);
lazy[subL] = composition(f,lazy[subL++]);
}
if((subR&1)==1){
node[--subR] = mapping(node[subR],f);
lazy[subR] = composition(f,lazy[subR]);
}
subL >>= 1;
subR >>= 1;
}
update(l,r);
}
abstract public S function ( S s1, S s2 );
abstract public F composition ( F f1, F f2 );
abstract public S mapping ( S s, F f );
}
/*
,.へ
___ ﾑ i
「ﾋ_i〉 ゝ 〈
ﾄ ノ iニ()
i { ＿＿＿_ | ヽ
i i ／_, ,‐-＼ i }
| i ／（●) ( ● )＼ {､ λ
ト－┤. ／ （__人__） ＼ ,ノ￣,!
i ゝ､_ | ´￣` | ,. '´ﾊ ,!
ヽ、 ｀`､,__＼ ／" ＼ ヽ／
＼ノ ﾉ ﾊ￣ r/::r―--―/:７ ﾉ ／
ヽ. ヽ:<:'::'|:/ / ,."
`ｰ ､ ＼ヽ:::|/ ｒ'"
／￣二二二二二二二二二二二二二二二二二ヽ
| 答 | A C │|
＼＿二二二二二二二二二二二二二二二二二ノ
*/
/*////////////////////////////////////////////////////////////////////////////////////////////
* My Library *
@author viral
*/////////////////////////////////////////////////////////////////////////////////////////////
final class Factorial {
//階乗とその逆元
private final long[] fact, inFact;
private final long mod;
/**
* 1～Nの階乗とその逆元をmodで割ったあまりを事前に計算します。
*
* @param N 計算範囲
* @param mod 法
*/
public Factorial ( final int N, final long mod ) {
fact = new long[N + 1];
fact[0] = fact[1] = 1;
for ( int i = 2; i <= N; ++i ) {
fact[i] = fact[i - 1] * i % mod;
}
inFact = new long[N + 1];
inFact[N] = MathFunction.modPow( fact[N], mod - 2, mod );
for ( int i = N; i > 0; --i ) {
inFact[i - 1] = inFact[i] * i % mod;
}
inFact[0] = 1;
this.mod = mod;
}
/**
* num!をmodで割ったあまりを返します。
*
* @param num
*
* @return num!
*/
public long getFact ( final int num ) {
return fact[num];
}
/**
* num!^-1をmodで割ったあまりを返します。
*
* @param num
*
* @return num!
*/
public long getInFact ( final int num ) {
return inFact[num];
}
/**
* modを法とした時のnum^-1を返します。
*
* @param num
*
* @return num!
*/
public long getInverse ( final int num ) {
return fact[num - 1] * inFact[num] % mod;
}
/**
* aCbをmodで割ったあまりを返します。
*
* @param a
* @param b
*
* @return aCb
*/
public long getCombi ( final int a, final int b ) {
if ( a < b || a < 0 || b < 0 ) {
return 0;
}
return ( fact[a] * inFact[a - b] % mod ) * inFact[b] % mod;
}
}
final class ArrayFunction {
private static final int LIMIT_OF_COUNT_SORT = 500_000;
/**
* カウントソートによるソートです。
* 各要素が0以上であり最大値が十分小さい時はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param maximumLimit array内の最大要素
*/
public static void countSort ( final int[] array, final int maximumLimit ) {
countSort( array, 0, array.length, maximumLimit );
}
public static void countSort ( final int[] array, final int l, final int r, final int maximumLimit ) {
final int[] list = new int[maximumLimit + 1];
for ( int i = l; i < r; ++i ) {
++list[array[i]];
}
int temp = l;
for ( int i = 0; i < list.length; ++i ) {
while ( list[i]-- > 0 ) {
array[temp++] = i;
}
}
}
public static void insertSort(final int[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void insertSort(final long[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void insertSort(final char[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static <E extends Comparable<E>> void insertSort(final E[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])>0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void reverseInsertSort(final int[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void reverseInsertSort(final long[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static void reverseInsertSort(final char[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
public static <E extends Comparable<E>> void reverseInsertSort(final E[] array,final int l,final int r){
for(int i=l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])<0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateR ( final int[][] array ) {
final int[][] ans = new int[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateR ( final long[][] array ) {
final long[][] ans = new long[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateR ( final char[][] array ) {
final char[][] ans = new char[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateR ( final double[][] array ) {
final double[][] ans = new double[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateR ( final boolean[][] array ) {
final boolean[][] ans = new boolean[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateR ( final E[][] array, final E[][] ans ) {
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[ans[i].length - j - 1][i];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateL ( final int[][] array ) {
final int[][] ans = new int[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
final int index = i;
Arrays.setAll( ans[i], k -> array[k][ans.length - index - 1] );
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateL ( final long[][] array ) {
final long[][] ans = new long[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
final int index = i;
Arrays.setAll( ans[i], k -> array[k][ans.length - index - 1] );
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateL ( final char[][] array ) {
final char[][] ans = new char[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateL ( final double[][] array ) {
final double[][] ans = new double[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateL ( final boolean[][] array ) {
final boolean[][] ans = new boolean[array[0].length][array.length];
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateL ( final E[][] array, final E[][] ans ) {
for ( int i = 0; i < ans.length; ++i ) {
for ( int j = 0; j < ans[i].length; ++j ) {
ans[i][j] = array[j][ans.length - i - 1];
}
}
return ans;
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( int[] array ) {
return lis( array, false );
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( int[][] arrays, int p ) {
return lis( arrays, p, false );
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( long[] array ) {
return lis( array, false );
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( long[][] arrays, int p ) {
return lis( arrays, p, false );
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( int[] array, boolean include ) {
int[] list = new int[array.length];
Arrays.fill( list, Integer.MAX_VALUE );
for ( int num: array ) {
int index = include ? Searcher.overSearch( list, num ) : Searcher.upSearch( list, num );
list[index] = Math.min( list[index], num );
}
int answer = Searcher.underSearch( list, Integer.MAX_VALUE );
return answer + 1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( int[][] arrays, int p, boolean include ) {
int[] list = new int[arrays.length];
Arrays.fill( list, Integer.MAX_VALUE );
for ( int[] array: arrays ) {
int index = include ? Searcher.overSearch( list, array[p] ) : Searcher.upSearch( list, array[p] );
list[index] = Math.min( list[index], array[p] );
}
int answer = Searcher.underSearch( list, Integer.MAX_VALUE );
return answer + 1;
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis ( long[] array, boolean include ) {
long[] list = new long[array.length];
Arrays.fill( list, Long.MAX_VALUE );
for ( long num: array ) {
int index = include ? Searcher.overSearch( list, num ) : Searcher.upSearch( list, num );
list[index] = Math.min( list[index], num );
}
int answer = Searcher.underSearch( list, Long.MAX_VALUE );
return answer + 1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis ( long[][] arrays, int p, boolean include ) {
long[] list = new long[arrays.length];
Arrays.fill( list, Long.MAX_VALUE );
for ( long[] array: arrays ) {
int index = include ? Searcher.overSearch( list, array[p] ) : Searcher.upSearch( list, array[p] );
list[index] = Math.min( list[index], array[p] );
}
int answer = Searcher.underSearch( list, Long.MAX_VALUE );
return answer + 1;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort ( final ArrayList<ArrayList<Integer>> route ) {
final int[] count = new int[route.size()];
int pathCount = 0;
for ( final ArrayList<Integer> path: route ) {
for ( final int point: path ) {
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for ( int i = 1; i < count.length; ++i ) {
if ( count[i] == 0 ) {
deq.add( i );
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while ( deq.size() > 0 ) {
int nowP = deq.pollFirst();
for ( final int nextP: route.get( nowP ) ) {
ans[index][0] = nowP;
ans[index++][1] = nextP;
if ( --count[nextP] == 0 ) {
deq.add( nextP );
}
}
}
return ans;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort ( final int[][] route ) {
final int[] count = new int[route.length];
int pathCount = 0;
for ( final int[] path: route ) {
for ( final int point: path ) {
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for ( int i = 1; i < count.length; ++i ) {
if ( count[i] == 0 ) {
deq.add( i );
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while ( deq.size() > 0 ) {
int nowP = deq.pollFirst();
for ( final int nextP: route[nowP] ) {
ans[index][0] = nowP;
ans[index++][1] = nextP;
if ( --count[nextP] == 0 ) {
deq.add( nextP );
}
}
}
return ans;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final int[] array, final int a, final int b ) {
final int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final long[] array, final int a, final int b ) {
final long temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final double[] array, final int a, final int b ) {
final double temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final char[] array, final int a, final int b ) {
final char temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap ( final boolean[] array, final int a, final int b ) {
final boolean temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static <E> void swap ( final E[] array, final int a, final int b ) {
final E temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final int[][] array, final int a, final int b, final int c, final int d ) {
final int temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final long[][] array, final int a, final int b, final int c, final int d ) {
final long temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final double[][] array, final int a, final int b, final int c, final int d ) {
final double temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final char[][] array, final int a, final int b, final int c, final int d ) {
final char temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap ( final boolean[][] array, final int a, final int b, final int c, final int d ) {
final boolean temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static <E> void swap ( final E[][] array, final int a, final int b, final int c, final int d ) {
final E temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation ( final int[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] < array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation ( final long[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] < array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
long min = Long.MAX_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation ( final char[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] < array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static <E extends Comparable<E>> boolean nextPermutation ( final E[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1].compareTo( array[i] ) < 0 ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = -1;
E min = MathFunction.max( array );
int subIndex = -1;
E max = array[index1];
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], array[index1], min ) ) {
min = array[i];
index2 = i;
}
if ( max.compareTo( array[i] ) < 0 ) {
subIndex = i;
max = array[i];
}
}
if ( index2 == -1 ) {
swap( array, index1, subIndex );
}
else {
swap( array, index1, index2 );
}
reverseRange( array, index1 + 1, array.length );
insertSort( array, index1 + 1, array.length );
return true;
}
public static boolean previousPermutation ( final int[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] > array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
public static boolean previousPermutation ( final long[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] > array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
long max = Long.MIN_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
public static boolean previousPermutation ( final char[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1] > array[i] ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
}
swap( array, index1, index2 );
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
public static <E extends Comparable<E>> boolean previousPermutation ( final E[] array ) {
int index1 = 0;
for ( int i = 1; i < array.length; ++i ) {
if ( array[i - 1].compareTo( array[i] ) > 0 ) {
index1 = i;
}
}
if ( --index1 < 0 ) {
return false;
}
int index2 = -1;
E max = MathFunction.min( array );
int subIndex = -1;
E min = array[index1];
for ( int i = index1 + 1; i < array.length; ++i ) {
if ( MathFunction.rangeCheckOpen( array[i], max, array[index1] ) ) {
max = array[i];
index2 = i;
}
if ( min.compareTo( array[i] ) > 0 ) {
subIndex = i;
min = array[i];
}
}
if ( index2 == -1 ) {
swap( array, index1, subIndex );
}
else {
swap( array, index1, index2 );
}
reverseRange( array, index1 + 1, array.length );
reverseInsertSort( array, index1 + 1, array.length );
return true;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static int[] reBuild ( final int[] array, final IntUnaryOperator func ) {
final int[] ans = new int[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsInt( array[i] );
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static int[] reBuild ( final int[] array, final IntBinaryOperator func ) {
final int[] ans = new int[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsInt( i, array[i] );
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static long[] reBuild ( final long[] array, final LongUnaryOperator func ) {
final long[] ans = new long[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsLong( array[i] );
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array
* @param func
*/
public static long[] reBuild ( final long[] array, final LongBinaryOperator func ) {
final long[] ans = new long[array.length];
for ( int i = 0; i < array.length; ++i ) {
ans[i] = func.applyAsLong( i, array[i] );
}
return ans;
}
public static void computeByArray(final int[] array,final IntConsumer func){
for(final int num:array){
func.accept(num);
}
}
public static void reverseRange(final int[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final long[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final double[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final char[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static void reverseRange(final boolean[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
public static <E> void reverseRange(final E[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
}
final class Converter {
/**
* 渡された文字列を逆順にした文字列を返します。
*
* @param str 元の文字列
*
* @return strを逆順にした文字列
*/
public static String reverse ( final String str ) {
final StringBuilder sb = new StringBuilder();
for ( int i = str.length() - 1; i >= 0; --i ) {
sb.append( str.charAt( i ) );
}
return sb.toString();
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static int[] toIntArray ( final List<Integer> list ) {
final int[] ans = new int[list.size()];
int index = 0;
for ( int num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static long[] toLongArray ( final List<Long> list ) {
final long[] ans = new long[list.size()];
int index = 0;
for ( long num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static char[] toCharArray ( final List<Character> list ) {
final char[] ans = new char[list.size()];
int index = 0;
for ( char num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static double[] toDoubleArray ( final List<Double> list ) {
final double[] ans = new double[list.size()];
int index = 0;
for ( double num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static boolean[] toBooleanArray ( final List<Boolean> list ) {
final boolean[] ans = new boolean[list.size()];
int index = 0;
for ( boolean num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static byte[] toByteArray ( final List<Byte> list ) {
final byte[] ans = new byte[list.size()];
int index = 0;
for ( byte num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static short[] toShortArray ( final List<Short> list ) {
final short[] ans = new short[list.size()];
int index = 0;
for ( short num : list ) {
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static float[] toFloatArray ( final List<Float> list ) {
final float[] ans = new float[list.size()];
int index = 0;
for ( float num : list ) {
ans[index++] = num;
}
return ans;
}
}
final class MathFunction {
private static final int[] numberForIntPrime = {2, 7, 61};
private static final long[] numberForLongPrime = {2, 7, 61, 325, 9375, 28178, 450775, 9780504, 1795265022};
/**
* aとbの最大公約数を求めます。戻り値は0以上であることが保証されます。
*
* @param a 公約数を求める整数
* @param b 公約数を求める整数
*
* @return aとbの最大公約数
*/
public static long gcd ( long a, long b ) {
a = Math.abs( a );
b = Math.abs( b );
if ( b == 0 ) {
return a;
}
long temp;
while ( ( temp = a % b ) != 0 ) {
a = b;
b = temp;
}
return b;
}
/**
* aとbの最小公倍数を求めます。
* オーバーフロー検知は出来ません。
*
* @param a 公倍数を求める整数
* @param b 公倍数を求める整数
*
* @return aとbの最小公倍数
*/
public static long lcm ( final long a, final long b ) {
return a / gcd( a, b ) * b;
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
public static boolean isPrime ( long n ) {
n = Math.abs( n );
if ( n == 2L ) {
return true;
}
if ( n == 1L || ( n & 1L ) == 0L ) {
return false;
}
if ( n <= 4_759_123_141L ) {
return isPrimeForInt( n );
}
if ( n <= Long.MAX_VALUE / n ) {
return isPrimeForLong( n );
}
return isPrimeForBigInteger( n );
}
private static boolean isPrimeForInt ( long n ) {
long d = n - 1;
while ( ( d & 1 ) == 0L ) {
d >>= 1;
}
for ( final long a: numberForIntPrime ) {
if ( a >= n ) {
return true;
}
long t = d;
long y = MathFunction.modPow( a, t, n );
while ( t < n - 1L && y != 1 && y != n - 1 ) {
y = y * y % n;
t <<= 1;
}
if ( y != n - 1 && ( t & 1L ) == 0 ) {
return false;
}
}
return true;
}
private static boolean isPrimeForLong ( long n ) {
long d = n - 1L;
while ( ( d & 1 ) == 0L ) {
d >>= 1;
}
for ( final long a: numberForLongPrime ) {
if ( a >= n ) {
return true;
}
long t = d;
long y = MathFunction.modPow( a, t, n );
while ( t < n - 1L && y != 1 && y != n - 1 ) {
y = y * y % n;
t <<= 1;
}
if ( y != n - 1 && ( t & 1L ) == 0 ) {
return false;
}
}
return true;
}
private static boolean isPrimeForBigInteger ( long n ) {
long d = n - 1L;
while ( ( d & 1 ) == 0L ) {
d >>= 1;
}
final BigInteger bigN = BigInteger.valueOf( n );
final BigInteger bigNSubOne = bigN.subtract( BigInteger.ONE );
final BigInteger bigD = BigInteger.valueOf( d );
for ( final long a: numberForLongPrime ) {
if ( a >= n ) {
return true;
}
BigInteger t = bigD;
BigInteger y = BigInteger.valueOf( a ).modPow( t, bigN );
while ( t.compareTo( bigNSubOne ) == -1 && !y.equals( BigInteger.ONE ) && !y.equals( bigNSubOne ) ) {
y = y.multiply( y ).mod( bigN );
t = t.shiftLeft( 1 );
}
if ( !y.equals( bigNSubOne ) && (t.intValue()&1) == 0 ) {
return false;
}
}
return true;
}
/**
* num以下の素数を列挙します。
*
* @param num 素数を探す上限値
*
* @return num以下の素数のint型配列
*/
public static int[] primes ( final int num ) {
if ( num < 2 ) {
return new int[0];
}
final BitSet numbers = new BitSet( num + 1 );
numbers.set( 2, num + 1 );
final int limit = ( int )Math.sqrt( num );
for ( int i = 2; i <= limit; ++i ) {
if ( numbers.get( i ) ) {
for ( int j = i * i; j <= num; j += i ) {
if ( numbers.get(j) ) {
numbers.clear( j );
}
}
}
}
final int[] answer = new int[numbers.cardinality()];
int i = 2, index = 0;
do {
i = numbers.nextSetBit( i );
answer[index++] = i++;
} while ( index != answer.length );
return answer;
}
/**
* a**bを計算します。
*
* @param a 被累乗数
* @param b 指数
*
* @return a**b
*/
public static long pow ( long a, long b ) {
long ans = 1;
while ( b > 0 ) {
if ( ( b & 1 ) == 1 ) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
/**
* a**bをmodで割ったあまりを計算します。
*
* @param a 被累乗数
* @param b 指数
* @param mod 法とする整数
*
* @return a**bをmodで割ったあまり
*/
public static long modPow ( long a, long b, final long mod ) {
long ans = 1;
a %= mod;
while ( b > 0 ) {
if ( ( b & 1 ) == 1 ) {
ans *= a;
}
ans %= mod;
a *= a;
a %= mod;
b >>= 1;
}
return ans;
}
/**
* N!を計算します。
*
* @param N 階乗を求めるのに用いる値
*
* @return N!
*/
public static long fact ( final int N ) {
long ans = 1;
for ( int i = 2; i <= N; ++i ) {
ans *= i;
}
return ans;
}
/**
* N!をmodで割ったあまりを計算します。
*
* @param N 階乗を求めるのに用いる値
* @param mod 法とする整数
*
* @return N!をmodで割ったあまり
*/
public static long modFact ( final int N, final long mod ) {
long ans = 1;
for ( int i = 2; i <= N; ++i ) {
ans *= i;
ans %= mod;
}
return ans;
}
/**
* nCrを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
*
* @return nCr
*/
public static long combi ( final long n, long r ) {
if ( r < 0 || n < r ) {
return 0;
}
long ans = 1;
r = Math.min( n - r, r );
for ( int i = 0; i < r; ++i ) {
ans *= n - i;
ans /= i + 1;
}
return ans;
}
/**
* nCrをmodで割ったあまりを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
* @param mod 法とする整数
*
* @return nCrをmodで割ったあまり
*/
public static long modCombi ( final long n, long r, final long mod ) {
if ( r < 0 || n < r ) {
return 0;
}
long ans = 1;
r = Math.min( n - r, r );
for ( int i = 0; i < r; ++i ) {
ans *= ( n - i ) % mod;
ans %= mod;
ans *= modPow( i + 1, mod - 2, mod );
ans %= mod;
}
return ans;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param x1 点1のx座標
* @param y1 点1のy座標
* @param x2 点2のx座標
* @param y2 点2のy座標
* @param x3 点3のx座標
* @param y3 点3のy座標
* @param x4 点4のx座標
* @param y4 点4のy座標
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed ( final int x1, final int y1,
final int x2, final int y2,
final int x3, final int y3,
final int x4, final int y4 ) {
final long s1 = ( long )( x1 - x2 ) * ( y3 - y1 ) - ( long )( y1 - y2 ) * ( x3 - x1 );
final long t1 = ( long )( x1 - x2 ) * ( y4 - y1 ) - ( long )( y1 - y2 ) * ( x4 - x1 );
final long s2 = ( long )( x3 - x4 ) * ( y1 - y3 ) - ( long )( y3 - y4 ) * ( x1 - x3 );
final long t2 = ( long )( x3 - x4 ) * ( y2 - y3 ) - ( long )( y3 - y4 ) * ( x2 - x3 );
final long temp1 = s1 * t1;
final long temp2 = s2 * t2;
if ( temp1 > 0 || temp2 > 0 ) {
return -1;
}
if ( temp1 == 0 && temp2 == 0 ) {
return 0;
}
return 1;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param p1 点1
* @param p2 点2
* @param p3 点3
* @param p4 点4
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed ( final Point p1, final Point p2, final Point p3, final Point p4 ) {
return isCrossed( p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y );
}
/**
* 指定された頂点を順に結んで出来上がる多角形が凸多角形か判定します。
*
* @param points 多角形を構成する点
*
* @return 多角形が凸多角形ならtrue
*/
public static boolean isConvex ( final Point... points ) {
final int n = points.length;
if ( n < 3 ) {
return false;
}
if ( n == 3 ) {
return true;
}
boolean conv = true;
for ( int i = 0; i < n; ++i ) {
int result = isCrossed( points[i], points[( i + 2 ) % n],
points[( i + 1 ) % n], points[( i + 1 + n / 2 ) % n] );
conv &= result >= 0;
}
return conv;
}
/**
* numをmodで割ったあまりを返します。
* 戻り値は0以上mod未満であることが保証されます。
*
* @param num 被除算数
* @param mod 法とする値
*
* @return numをmodで割ったあまり
*/
public static long remainder ( long num, final long mod ) {
num %= mod;
if ( num < 0 ) {
num += mod;
}
return num;
}
/**
* numが何桁かを返します。
* 0は1桁として捉えます。
*
* @param num 調べる整数
*
* @return numの桁数
*/
public static int digit ( final long num ) {
if ( num < 10L ) {
return 1;
}
if ( num < 100L ) {
return 2;
}
if ( num < 1000L ) {
return 3;
}
if ( num < 10000L ) {
return 4;
}
if ( num < 100000L ) {
return 5;
}
if ( num < 1000000L ) {
return 6;
}
if ( num < 10000000L ) {
return 7;
}
if ( num < 100000000L ) {
return 8;
}
if ( num < 1000000000L ) {
return 9;
}
if ( num < 10000000000L ) {
return 10;
}
if ( num < 100000000000L ) {
return 11;
}
if ( num < 1000000000000L ) {
return 12;
}
if ( num < 10000000000000L ) {
return 13;
}
if ( num < 100000000000000L ) {
return 14;
}
if ( num < 1000000000000000L ) {
return 15;
}
if ( num < 10000000000000000L ) {
return 16;
}
if ( num < 100000000000000000L ) {
return 17;
}
if ( num < 1000000000000000000L ) {
return 18;
}
return 19;
}
public static int max ( final int... nums ) {
int ans = Integer.MIN_VALUE;
for ( int num: nums ) {
ans = Math.max( ans, num );
}
return ans;
}
public static long max ( final long... nums ) {
long ans = Long.MIN_VALUE;
for ( long num: nums ) {
ans = Math.max( ans, num );
}
return ans;
}
public static double max ( final double... nums ) {
double ans = -Double.MIN_VALUE;
for ( double num: nums ) {
ans = Math.max( ans, num );
}
return ans;
}
public static <E extends Comparable<E>> E max ( final E[] nums ) {
E ans = nums[0];
for ( E value: nums ) {
if ( ans.compareTo( value ) > 0 ) {
ans = value;
}
}
return ans;
}
public static int min ( final int... nums ) {
int ans = Integer.MAX_VALUE;
for ( int num: nums ) {
ans = Math.min( ans, num );
}
return ans;
}
public static long min ( final long... nums ) {
long ans = Long.MAX_VALUE;
for ( long num: nums ) {
ans = Math.min( ans, num );
}
return ans;
}
public static double min ( final double... nums ) {
double ans = Double.MAX_VALUE;
for ( double num: nums ) {
ans = Math.min( ans, num );
}
return ans;
}
public static <E extends Comparable<E>> E min ( final E[] nums ) {
E ans = nums[0];
for ( E value: nums ) {
if ( ans.compareTo( value ) < 0 ) {
ans = value;
}
}
return ans;
}
public static long sum ( final int... nums ) {
long ans = 0;
for ( int num: nums ) {
ans += num;
}
return ans;
}
public static long sum ( final long... nums ) {
long ans = 0;
for ( long num: nums ) {
ans += num;
}
return ans;
}
public static long modSum ( final long mod, final int... nums ) {
long ans = 0;
for ( int num: nums ) {
ans += num;
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
public static long modSum ( final long mod, final long... nums ) {
long ans = 0;
for ( long num: nums ) {
ans += num;
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
public static long sum ( final int[] nums, int from, int to ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
}
return ans;
}
public static long sum ( final long[] nums, int from, int to ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
}
return ans;
}
public static long modSum ( final int[] nums, int from, int to, long mod ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
public static long modSum ( final long[] nums, int from, int to, long mod ) {
long ans = 0;
for ( int i = from; i < to; ++i ) {
ans += nums[i];
ans %= mod;
}
if ( ans < 0 ) {
ans += mod;
}
return ans;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck ( final int num, final int l, final int r ) {
return l <= num && num < r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck ( final long num, final long l, final long r ) {
return l <= num && num < r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck ( final double num, final double l, final double r ) {
return l <= num && num < r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheck ( final E num, final E l, final E r ) {
return 0 <= l.compareTo( num ) && 0 < num.compareTo( r );
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen ( final int num, final int l, final int r ) {
return l < num && num < r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen ( final long num, final long l, final long r ) {
return l < num && num < r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen ( final double num, final double l, final double r ) {
return l < num && num < r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckOpen ( final E num, final E l, final E r ) {
return 0 < l.compareTo( num ) && 0 < num.compareTo( r );
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose ( final int num, final int l, final int r ) {
return l <= num && num <= r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose ( final long num, final long l, final long r ) {
return l <= num && num <= r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose ( final double num, final double l, final double r ) {
return l <= num && num <= r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckClose ( final E num, final E l, final E r ) {
return 0 <= l.compareTo( num ) && 0 <= num.compareTo( r );
}
/**
* 引数の中でのmexを求めます。
*
* @param num
*/
public static int mex ( final int... nums ) {
final IntegerSet set = new IntegerSet( nums.length << 1 );
for ( final int num : nums ) {
set.add( num );
}
int ans = 0;
while ( set.contains( ans ) ) {
++ans;
}
return ans;
}
}
final class Searcher {
private static final int CYCLE_COUNT = Double.MAX_EXPONENT + 53;
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch ( final char[] array, final int value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) > 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) > 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static int downSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static long downSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) > value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限より小さい値を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static double search ( double a, double b, final double value, final DoubleUnaryOperator func ) {
double ans = a - Math.abs( a ), c;
for ( int $ = 0; $ < CYCLE_COUNT; ++$ ) {
c = ( a + b ) / 2;
if ( func.applyAsDouble( c ) > value ) {
b = c;
}
else {
a = ( ans = c );
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = array[c].compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = list.get( c ).compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains ( int a, int b, final int value, final IntUnaryOperator func ) {
int c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int num = func.applyAsInt( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains ( long a, long b, final long value, final LongUnaryOperator func ) {
long c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
long num = func.applyAsLong( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = c - 1;
}
else if ( array[c] < value ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> int search ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = array[c].compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listのvalueのインデックス(無ければ - 1)
*/
public static <E extends Comparable<E>> int search ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int result = list.get( c ).compareTo( value );
if ( result > 0 ) {
b = c - 1;
}
else if ( result < 0 ) {
a = c + 1;
}
else {
return c;
}
}
return -1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static int search ( int a, int b, final int value, final IntUnaryOperator func ) {
int c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
int num = func.applyAsInt( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return c;
}
}
return a - 1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static long search ( long a, long b, final long value, final LongUnaryOperator func ) {
long c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
long num = func.applyAsLong( c );
if ( num > value ) {
b = c - 1;
}
else if ( num < value ) {
a = c + 1;
}
else {
return c;
}
}
return a - 1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) >= 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = list.size(), c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) >= 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static int upSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static long upSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) >= value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) >= 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素より小さい要素を探します。
* リスト内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = -1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) >= 0 ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static int underSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static long underSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = a - 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) >= value ) {
b = c - 1;
}
else {
a = ( ans = c ) + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final int[] array, final int value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final long[] array, final long value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final double[] array, final double value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch ( final char[] array, final char value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c] > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch ( final E[] array, final E value ) {
int a = 0, b = array.length - 1, ans = array.length, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( array[c].compareTo( value ) > 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* リスト内の指定された要素より大きい要素を探します。
* リスト内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch ( final List<E> list, final E value ) {
int a = 0, b = list.size() - 1, ans = list.size(), c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( list.get( c ).compareTo( value ) > 0 ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static int overSearch ( int a, int b, final int value, final IntUnaryOperator func ) {
int ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsInt( c ) > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static long overSearch ( long a, long b, final long value, final LongUnaryOperator func ) {
long ans = b + 1, c;
while ( a - b < 1 ) {
c = ( a + b ) / 2;
if ( func.applyAsLong( c ) > value ) {
b = ( ans = c ) - 1;
}
else {
a = c + 1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final int[] array, final int value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final long[] array, final long value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final double[] array, final double value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch ( final char[] array, final char value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i] == value ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch ( final E[] array, final E value ) {
for ( int i = 0; i < array.length; ++i ) {
if ( array[i].compareTo( value ) == 0 ) {
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch ( final List<E> list, final E value ) {
for ( int i = 0; i < list.size(); ++i ) {
if ( list.get( i ).compareTo( value ) == 0 ) {
return i;
}
}
return -1;
}
}
// Binary Indexed Tree
final class BIT {
final int size;
final private long[] tree;
public BIT ( int n ) {
size = n;
tree = new long[n + 1];
}
public long sum ( int i ) {
long sum = 0;
while ( i > 0 ) {
sum += tree[i];
i ^= i & ( -i );
}
return sum;
}
public void add ( int i, long x ) {
while ( i <= size ) {
tree[i] += x;
i += i & ( -i );
}
}
public void clear () {
Arrays.fill( tree, 0L );
}
}
// Binary Indexed Tree(int)
final class BITInt {
final int size;
final private int[] tree;
public BITInt ( int n ) {
size = n;
tree = new int[n + 1];
}
public int sum ( int i ) {
int sum = 0;
while ( i > 0 ) {
sum += tree[i];
i ^= i & ( -i );
}
return sum;
}
public void add ( int i, int x ) {
while ( i <= size ) {
tree[i] += x;
i += i & ( -i );
}
}
public void clear () {
Arrays.fill( tree, 0 );
}
}
final class Bitset implements Cloneable {
private final long[] bit;
private final int size, len;
private final long MASK;
public Bitset ( final int len ) {
this.len = len;
size = ( len + 63 ) >> 6;
bit = new long[size];
MASK = ( -1L ) >>> ( ( size << 6 ) - len );
}
private Bitset ( final long[] arr ) {
this( arr.length );
System.arraycopy( arr, 0, bit, 0, size );
}
public void set ( final int index ) {
if ( index >= size << 6 ) {
throw new ArrayIndexOutOfBoundsException( index + " is out of this bitset's size " + size );
}
bit[index >> 6] |= ( 1L << ( index & 0b111111 ) );
}
public void clear ( final int index ) {
if ( index >= size << 6 ) {
throw new ArrayIndexOutOfBoundsException( index + " is out of this bitset's size " + size );
}
long m = ~( 1L << ( index & 0b111111 ) );
bit[index >> 6] &= m;
}
public boolean get ( final int index ) {
if ( index >= size << 6 ) {
throw new ArrayIndexOutOfBoundsException( index + " is out of this bitset's size " + size );
}
return ( bit[index >> 6] & ( 1L << ( index & 0b111111 ) ) ) != 0;
}
public void shiftLeft ( int num ) {
if ( num >= size << 6 ) {
Arrays.fill( bit, 0L );
return;
}
final int n = num >> 6;
num &= 0b111111;
for ( int i = size - 1; i >= n; --i ) {
bit[i] = ( bit[i - n] << num ) | ( i != n && num != 0 ? bit[i - n - 1] >>> ( 64 - num ) : 0L );
}
for ( int i = 0; i < n; ++i ) {
bit[i] = 0L;
}
bit[size - 1] &= MASK;
}
public void shiftRight ( int num ) {
if ( num >= size << 6 ) {
Arrays.fill( bit, 0L );
return;
}
final int n = num >> 6;
num &= 0b111111;
for ( int i = 0; i < size - n; ++i ) {
bit[i] = ( bit[i + n] >>> num ) | ( i + n + 1 != size && num != 0 ? bit[i + n + 1] << ( 64 - num ) : 0L );
}
for ( int i = size - 1; i >= size - n; --i ) {
bit[i] = 0L;
}
}
public long[] longValues () {
return bit;
}
public long longValue () {
return bit[0];
}
public void and ( final Bitset b ) {
final long[] bit2 = b.longValues();
final int m = Math.min( bit2.length, size );
for ( int i = 0; i < m; ++i ) {
bit[i] &= bit2[i];
}
for ( int i = m; i < size; ++i ) {
bit[i] = 0;
}
bit[size - 1] &= MASK;
}
public void or ( final Bitset b ) {
final long[] bit2 = b.longValues();
final int m = Math.min( bit2.length, size );
for ( int i = 0; i < m; ++i ) {
bit[i] |= bit2[i];
}
bit[size - 1] &= MASK;
}
public void xor ( final Bitset b ) {
final long[] bit2 = b.longValues();
final int m = Math.min( bit2.length, size );
for ( int i = 0; i < m; ++i ) {
bit[i] ^= bit2[i];
}
bit[size - 1] &= MASK;
}
public Bitset clone () throws CloneNotSupportedException {
super.clone();
final Bitset b = new Bitset( bit );
return b;
}
}
final class IntegerSet {
private class Node {
private final int value;
private Node next;
private Node ( final int val ) {
value = val;
}
private boolean add ( final int x ) {
if ( value == x ) {
return false;
}
if ( next != null ) {
return next.add( x );
}
++size;
next = new Node( x );
return true;
}
private void add ( final Node n ) {
if ( value != n.value ) {
if ( next != null ) {
next.add( n );
}
else {
next = n;
}
}
}
private boolean remove ( final int x ) {
if ( next == null ) {
return false;
}
if ( next.value != x ) {
return next.remove( x );
}
--size;
next = next.next;
return true;
}
private boolean contains ( final int x ) {
if ( value == x ) {
return true;
}
if ( next != null ) {
return next.contains( x );
}
return false;
}
}
private Node[] table;
private int size;
public IntegerSet () {
this( 16 );
}
public IntegerSet ( final int s ) {
if ( s < 1 ) {
throw new NegativeArraySizeException( "hash table's size must be positive" );
}
table = new Node[s];
size = 0;
}
public boolean add ( final int x ) {
sizeCheck();
final int index = hash( x );
if ( table[index] != null ) {
return table[index].add( x );
}
++size;
table[index] = new Node( x );
return true;
}
private void add ( final Node n ) {
final int index = hash( n.value );
if ( table[index] != null ) {
table[index].add( n );
}
else {
table[index] = n;
}
}
public boolean remove ( final int x ) {
final int index = hash( x );
if ( table[index] == null ) {
return false;
}
if ( table[index].value != x ) {
return table[index].remove( x );
}
--size;
table[index] = table[index].next;
return true;
}
public boolean contains ( final int x ) {
final int index = hash( x );
if ( table[index] == null ) {
return false;
}
return table[index].contains( x );
}
private void reHash () {
final Node[] oldTable = table;
table = new Node[table.length << 1];
for ( Node node: oldTable ) {
while ( node != null ) {
final Node next = node.next;
node.next = null;
add( node );
node = next;
}
}
}
private void sizeCheck () {
if ( table.length * 0.6 < size ) {
reHash();
}
}
private int hash ( final int val ) {
final int h = val % table.length;
return h < 0 ? h + table.length : h;
}
public int size () {
return size;
}
public int[] toArray () {
final int[] array = new int[size];
int index = 0;
for ( Node node: table ) {
while ( node != null ) {
array[index++] = node.value;
node = node.next;
}
}
return array;
}
public String toString () {
return Arrays.toString( toArray() );
}
}
final class Matrix {
private final long[][] matrix;
public Matrix ( final int H, final int W, final long def ) {
matrix = new long[H][W];
if ( def != 0 ) {
for ( final long[] mat: matrix ) {
Arrays.fill( mat, def );
}
}
}
public Matrix ( final int H, final int W ) {
this( H, W, 0 );
}
public Matrix ( final Dimension d, final long def ) {
this( d.height, d.width, def );
}
public Matrix ( final long[][] mat ) {
matrix = new long[mat.length][];
for ( int i = 0; i < mat.length; ++i ) {
matrix[i] = Arrays.copyOf( mat[i], mat[i].length );
}
}
public long get ( final int i, final int j ) {
return matrix[i][j];
}
public long set ( final int i, final int j, final long value ) {
return matrix[i][j] = value;
}
public Matrix copy () {
return new Matrix( matrix );
}
public Dimension size () {
return new Dimension( matrix[0].length, matrix.length );
}
public Matrix add ( final Matrix m ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, matrix[i][j] + m.get( i, j ) );
}
}
return ans;
}
public Matrix subtract ( final Matrix m ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, matrix[i][j] - m.get( i, j ) );
}
}
return ans;
}
public Matrix multiply ( final Matrix m ) {
if ( size().width != m.size().height ) {
throw new IllegalArgumentException( "matrix length is not same" );
}
final Matrix ans = new Matrix( size().height, m.size().width );
final Dimension size = ans.size();
final int len = size().width;
for ( int i = 0; i < size.height; ++i ) {
for ( int j = 0; j < size.width; ++j ) {
long sum = 0;
for ( int k = 0; k < len; ++k ) {
sum += matrix[i][k] * m.get( k, j );
}
ans.set( i, j, sum );
}
}
return ans;
}
public Matrix modAdd ( final Matrix m, final long mod ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, MathFunction.remainder( matrix[i][j] + m.get( i, j ), mod ) );
}
}
return ans;
}
public Matrix modSubtract ( final Matrix m, final long mod ) {
if ( !size().equals( m.size() ) ) {
throw new IllegalArgumentException( "matrix size is not same" );
}
final Matrix ans = new Matrix( size(), 0 );
for ( int i = 0; i < matrix.length; ++i ) {
for ( int j = 0; j < matrix[i].length; ++j ) {
ans.set( i, j, MathFunction.remainder( matrix[i][j] - m.get( i, j ), mod ) );
}
}
return ans;
}
public Matrix modMultiply ( final Matrix m, final long mod ) {
if ( size().width != m.size().height ) {
throw new IllegalArgumentException( "matrix length is not same" );
}
final Matrix ans = new Matrix( size().height, m.size().width );
final Dimension size = ans.size();
final int len = size().width;
for ( int i = 0; i < size.height; ++i ) {
for ( int j = 0; j < size.width; ++j ) {
long sum = 0;
for ( int k = 0; k < len; ++k ) {
sum = MathFunction.remainder( sum + matrix[i][k] * m.get( k, j ), mod );
}
ans.set( i, j, sum );
}
}
return ans;
}
public static Matrix pow ( final Matrix original, final Matrix pw, long exp ) {
Matrix a = original.copy();
Matrix b = pw.copy();
while ( 0 < exp ) {
if ( ( exp & 1 ) == 1 ) {
a = b.multiply( a );
}
b = b.multiply( b );
exp >>= 1;
}
return a;
}
public static Matrix modPow ( final Matrix original, final Matrix pw, long exp, final long mod ) {
Matrix a = original.copy();
Matrix b = pw.copy();
while ( 0 < exp ) {
if ( ( exp & 1 ) == 1 ) {
a = b.modMultiply( a, mod );
}
b = b.modMultiply( b, mod );
exp >>= 1;
}
return a;
}
public long determinant () {
return determinant( matrix );
}
private static long determinant ( final long[][] mat ) {
if ( mat.length == 1 ) {
return mat[0][0];
}
final long[][] miniMat = new long[mat.length - 1][mat.length - 1];
for ( int i = 1; i < mat.length; ++i ) {
System.arraycopy( mat[i], 1, miniMat[i - 1], 0, miniMat.length );
}
long ans = mat[0][0] * determinant( miniMat );
for ( int i = 1; i < mat.length; ++i ) {
for ( int j = 1; j < mat.length; ++j ) {
miniMat[j - 1][i - 1] = mat[j][i - 1];
}
final long num = mat[0][i] * determinant( miniMat );
ans += i % 2 == 0 ? num : -num;
}
return ans;
}
@Override
public String toString () {
final StringBuilder ans = new StringBuilder();
ans.append( Arrays.toString( matrix[0] ) );
for ( int i = 1; i < matrix.length; ++i ) {
ans.append( "\n" );
ans.append( Arrays.toString( matrix[i] ) );
}
return ans.toString();
}
}
final class RollingHash implements Comparable<RollingHash> {
private static final long BASE = new Random().nextInt( 1000 ) + Character.MAX_VALUE + 1;
private static final long MASK30 = ( 1L << 30 ) - 1;
private static final long MASK31 = ( 1L << 31 ) - 1;
private static final long MOD = ( 1L << 61 ) - 1;
private static final long MASK61 = MOD;
private long[] hash;
private String string;
public RollingHash ( final String str ) {
string = str;
hash = new long[str.length() + 1];
roll();
}
private void roll () {
final int len = string.length();
for ( int i = 1; i <= len; ++i ) {
hash[i] = multiply( hash[i - 1], BASE ) + string.charAt( i - 1 ) - ' ' + 1;
if ( MOD <= hash[i] ) {
hash[i] -= MOD;
}
}
}
private static long multiply ( final long a, final long b ) {
final long au = a >> 31;
final long ad = a & MASK31;
final long bu = b >> 31;
final long bd = b & MASK31;
final long mid = ad * bu + au * bd;
final long midu = mid >> 30;
final long midd = mid & MASK30;
return mod( au * bu * 2 + midu + ( midd << 31 ) + ad * bd );
}
private static long mod ( final long x ) {
final long xu = x >> 61;
final long xd = x & MASK61;
long ans = xu + xd;
if ( MOD <= ans ) {
ans -= MOD;
}
return ans;
}
public long getHash ( final int l, final int r ) {
return ( hash[r] - multiply( hash[l], modBasePow( r - l ) ) + MOD ) % MOD;
}
private static long modBasePow ( long b ) {
long ans = 1;
long a = BASE;
while ( b > 0 ) {
if ( ( b & 1 ) == 1 ) {
ans = multiply( ans, a );
}
a = multiply( a, a );
b >>= 1;
}
return ans;
}
public boolean equals ( final RollingHash rh, final int l1, final int r1, final int l2, final int r2 ) {
if ( r1 - l1 != r2 - l2 ) {
return false;
}
return getHash( l1, r1 ) == rh.getHash( l2, r2 );
}
public int length () {
return string.length();
}
@Override
public int hashCode () {
return string.hashCode();
}
@Override
public String toString () {
return string;
}
@Override
public boolean equals ( Object o ) {
if ( o instanceof final RollingHash rh ) {
return equals( rh, 0, length(), 0, rh.length() );
}
return false;
}
@Override
public int compareTo ( RollingHash rh ) {
return string.compareTo( rh.toString() );
}
public int compareTo ( String str ) {
return string.compareTo( str );
}
public char charAt ( final int i ) {
return string.charAt( i );
}
public int compareToIgnoreCase ( final RollingHash rh ) {
return string.compareToIgnoreCase( rh.toString() );
}
public int compareToIgnoreCase ( final String str ) {
return string.compareToIgnoreCase( str );
}
public void concat ( final RollingHash rh ) {
concat( rh.toString() );
}
public void concat ( final String str ) {
string = string.concat( str );
hash = new long[string.length() + 1];
roll();
}
public boolean contains ( final RollingHash rh ) {
final long hash = rh.getHash( 0, rh.length() );
final int len = length() - rh.length();
for ( int i = 0; i <= len; ++i ) {
if ( hash == getHash( i, rh.length() + i ) ) {
return true;
}
}
return false;
}
public boolean contains ( final String str ) {
return indexOf( str ) != -1;
}
public int indexOf ( final int ch ) {
return indexOf( ch, 0 );
}
public int indexOf ( final int ch, final int fromIndex ) {
final int len = length();
for ( int i = fromIndex; i < len; ++i ) {
if ( string.charAt( i ) == ch ) {
return i;
}
}
return -1;
}
public int indexOf ( final String str ) {
return indexOf( str, 0 );
}
public int indexOf ( final String str, final int fromIndex ) {
long hash = 0;
for ( final char c: str.toCharArray() ) {
hash = multiply( hash, BASE ) + c - ' ' + 1;
if ( MOD <= hash ) {
hash -= MOD;
}
}
final int len = length() - str.length();
for ( int i = fromIndex; i <= len; ++i ) {
if ( hash == getHash( i, str.length() + i ) ) {
return i;
}
}
return -1;
}
public boolean isEmpty () {
return length() == 0;
}
public int lastIndexOf ( final int ch, final int fromIndex ) {
for ( int i = fromIndex; i >= 0; --i ) {
if ( string.charAt( i ) == ch ) {
return i;
}
}
return -1;
}
public int lastIndexOf ( final int ch ) {
return lastIndexOf( ch, length() - 1 );
}
public static RollingHash valueOf ( final boolean b ) {
return new RollingHash( b ? "true" : "false" );
}
public static RollingHash valueOf ( final char c ) {
return new RollingHash( "" + c );
}
public static RollingHash valueOf ( final char[] c ) {
return new RollingHash( String.valueOf( c, 0, c.length ) );
}
public static RollingHash valueOf ( final char[] c, final int offset, final int count ) {
return new RollingHash( String.valueOf( c, offset, count ) );
}
public static RollingHash valueOf ( final double d ) {
return new RollingHash( String.valueOf( d ) );
}
public static RollingHash valueOf ( final float f ) {
return new RollingHash( String.valueOf( f ) );
}
public static RollingHash valueOf ( final int i ) {
return new RollingHash( String.valueOf( i ) );
}
public static RollingHash valueOf ( final long l ) {
return new RollingHash( String.valueOf( l ) );
}
public static RollingHash valueOf ( final Object obj ) {
return new RollingHash( String.valueOf( obj ) );
}
}
@SuppressWarnings( "unchecked" )
abstract class SegmentTree<E> {
final int N, size;
final E def;
final Object[] node;
public SegmentTree ( final int n, final E def, final boolean include ) {
int num = 2;
while ( num < n << 1 ) {
num <<= 1;
}
N = num;
size = num >> 1 - ( include ? 1 : 0 );
node = new Object[N];
this.def = def;
Arrays.fill( node, this.def );
}
public SegmentTree ( final E[] arr, final E def, final boolean include ) {
int num = 2;
while ( num < arr.length << 1 ) {
num <<= 1;
}
N = num;
size = num >> 1 - ( include ? 1 : 0 );
node = new Object[N];
this.def = def;
System.arraycopy( arr, 0, node, N >> 1, arr.length );
for ( int i = arr.length + ( N >> 1 ); i < N; i++ ) {
node[i] = def;
}
updateAll();
}
public SegmentTree ( final int n, final E def ) {
this( n, def, false );
}
private void updateAll () {
for ( int i = ( N >> 1 ) - 1; i > 0; i-- ) {
node[i] = function( ( E )node[i << 1], ( E )node[( i << 1 ) + 1] );
}
}
public void update ( int n, final E value ) {
n += size;
node[n] = value;
n >>= 1;
while ( n > 0 ) {
node[n] = function( ( E )node[n << 1], ( E )node[( n << 1 ) + 1] );
n >>= 1;
}
}
public E get ( final int a ) {
return ( E )node[a + size];
}
public E answer () {
return ( E )node[1];
}
public E query ( int l, int r ) {
l += size;
r += size;
E answer = def;
while ( l > 0 && r > 0 && l <= r ) {
if ( l % 2 == 1 ) {
answer = function( ( E )node[l++], answer );
}
l >>= 1;
if ( r % 2 == 0 ) {
answer = function( answer, ( E )node[r--] );
}
r >>= 1;
}
return answer;
}
abstract public E function ( E a, E b );
}
final class UnionFind {
private final int[] par, rank, size, path;
private int count;
public UnionFind ( final int N ) {
count = N;
par = new int[N];
rank = new int[N];
size = new int[N];
path = new int[N];
Arrays.fill( par, -1 );
Arrays.fill( size, 1 );
}
public int root ( final int ind ) {
if ( par[ind] == -1 ) {
return ind;
}
else {
return par[ind] = root( par[ind] );
}
}
public boolean isSame ( final int x, final int y ) {
return root( x ) == root( y );
}
public boolean unite ( final int x, final int y ) {
int rx = root( x );
int ry = root( y );
++path[rx];
if ( rx == ry ) {
return false;
}
if ( rank[rx] < rank[ry] ) {
int temp = rx;
rx = ry;
ry = temp;
}
par[ry] = rx;
if ( rank[rx] == rank[ry] ) {
++rank[rx];
}
path[rx] += path[ry];
size[rx] += size[ry];
--count;
return true;
}
public int groupCount () {
return count;
}
public int pathCount ( final int x ) {
return path[root( x )];
}
public int size ( final int x ) {
return size[root( x )];
}
}
final class Tree<E extends Comparable<E>> {
private Node<E> root;
private int size, hash;
public Tree () {
size = 0;
root = null;
hash = 0;
}
static final private class Node<E> {
E value;
int height, size;
Node<E> left, right, parent;
public Node ( final Node<E> p, final E v ) {
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add ( final E x ) {
boolean bool = true;
if ( root == null ) {
root = new Node<>( null, x );
}
else {
Node<E> par;
Node<E> now = root;
do {
par = now;
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
bool = false;
break;
}
} while ( now != null );
if ( bool ) {
final int result = x.compareTo( par.value );
if ( result < 0 ) {
par.left = new Node<>( par, x );
}
else {
par.right = new Node<>( par, x );
}
fix( par );
}
}
if ( bool ) {
++size;
hash ^= x.hashCode();
}
return bool;
}
public E get ( int index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node<E> now = root;
while ( true ) {
assert now != null;
final int ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls < index ) {
now = now.right;
index -= ls + 1;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final E x ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= n.value.hashCode();
delete( n );
return true;
}
private void delete ( final Node<E> node ) {
if ( node != null ) {
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
}
else {
if ( node.left != null && node.right != null ) {
final Node<E> rep = getFirstNode( node.right );
node.value = rep.value;
delete( rep );
}
else {
final Node<E> rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
}
}
}
}
private Node<E> getNode ( final E x ) {
Node<E> now = root;
while ( now != null ) {
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public E first () {
if ( root == null ) {
return null;
}
return getFirstNode( root ).value;
}
private Node<E> getFirstNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public E last () {
if ( root == null ) {
return null;
}
return getLastNode( root ).value;
}
private Node<E> getLastNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final E x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public E pollFirst () {
if ( root == null ) {
return null;
}
--size;
final Node<E> min = getFirstNode( root );
hash ^= min.value.hashCode();
delete( min );
return min.value;
}
public E pollLast () {
if ( root == null ) {
return null;
}
--size;
final Node<E> max = getLastNode( root );
hash ^= max.value.hashCode();
delete( max );
return max.value;
}
public E ceiling ( final E x ) {
return ceiling( root, x );
}
private E ceiling ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result > 0 ) {
node = node.right;
}
else if ( result < 0 ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E higher ( final E x ) {
return higher( root, x );
}
private E higher ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result >= 0 ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans != null ? ans.value : null;
}
public E floor ( final E x ) {
return floor( root, x );
}
private E floor ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result < 0 ) {
node = node.left;
}
else if ( result > 0 ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E lower ( final E x ) {
return lower( root, x );
}
private E lower ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result <= 0 ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans != null ? ans.value : null;
}
public void clear () {
root = null;
size = 0;
hash = 0;
}
public boolean isEmpty () {
return size == 0;
}
public int size () {
return size;
}
public ArrayList<E> toList () {
final ArrayList<E> list = new ArrayList<>();
if ( root != null ) {
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node<E> now = deq.pollLast();
if ( list.size() == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list.add( now.value );
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list.get( list.size() - 1 ).compareTo( now.left.value ) < 0 ) {
deq.add( now );
deq.add( now.left );
}
else {
list.add( now.value );
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final ArrayList<E> list = toList();
return list.toString();
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final Tree<?> tree ) {
if ( size != tree.size() ) {
return false;
}
final ArrayList<E> list1 = toList();
final ArrayList<?> list2 = tree.toList();
for ( int i = 0; i < size; ++i ) {
if ( !list1.get( i ).equals( list2.get( i ) ) ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node<E> node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
}
rotateL( node );
}
else {
setStates( node );
}
node = node.parent;
}
}
private void rotateR ( final Node<E> node ) {
final Node<E> temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node<E> node ) {
final Node<E> temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node<E> node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final int ls = node.left != null ? node.left.size : 0;
final int rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + 1;
}
}
final class TreeInt {
private Node root;
private int size, hash;
public TreeInt () {
size = 0;
root = null;
hash = 0;
}
static final private class Node {
int value;
int height, size;
Node left, right, parent;
public Node ( final Node p, final int v ) {
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add ( final int x ) {
boolean bool = true;
if ( root == null ) {
root = new Node( null, x );
}
else {
Node par;
Node now = root;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
break;
}
} while ( now != null );
if ( bool ) {
if ( x < par.value ) {
par.left = new Node( par, x );
}
else {
par.right = new Node( par, x );
}
fix( par );
}
}
if ( bool ) {
++size;
hash ^= x;
}
return bool;
}
public int get ( int index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final int ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls < index ) {
now = now.right;
index -= ls + 1;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final int x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= n.value;
delete( n );
return true;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
}
}
}
}
private Node getNode ( final int x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public int first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public int last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final int x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public int pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= min.value;
delete( min );
return min.value;
}
public int pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= max.value;
delete( max );
return max.value;
}
public int ceiling ( final int x ) {
return ceiling( root, x );
}
private int ceiling ( Node node, final int x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public int higher ( final int x ) {
return higher( root, x );
}
private int higher ( Node node, final int x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public int floor ( final int x ) {
return floor( root, x );
}
private int floor ( Node node, final int x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public int lower ( final int x ) {
return lower( root, x );
}
private int lower ( Node node, final int x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public void clear () {
root = null;
size = 0;
hash = 0;
}
public boolean isEmpty () {
return size == 0;
}
public int size () {
return size;
}
public int[] toArray () {
final int[] list = new int[size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final int[] list = toArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeInt tree ) {
if ( size != tree.size() ) {
return false;
}
final int[] array1 = toArray();
final int[] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i] != array2[i] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
}
rotateL( node );
}
else {
setStates( node );
}
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final int ls = node.left != null ? node.left.size : 0;
final int rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + 1;
}
}
final class TreeLong {
private Node root;
private int size, hash;
public TreeLong () {
size = 0;
root = null;
hash = 0;
}
static final private class Node {
long value;
int height, size;
Node left, right, parent;
public Node ( final Node p, final long v ) {
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add ( final long x ) {
boolean bool = true;
if ( root == null ) {
root = new Node( null, x );
}
else {
Node par;
Node now = root;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
break;
}
} while ( now != null );
if ( bool ) {
if ( x < par.value ) {
par.left = new Node( par, x );
}
else {
par.right = new Node( par, x );
}
fix( par );
}
}
if ( bool ) {
++size;
hash ^= ( int )x;
}
return bool;
}
public long get ( int index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final int ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls < index ) {
now = now.right;
index -= ls + 1;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final long x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= ( int )x;
delete( n );
return true;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
}
}
}
}
private Node getNode ( final long x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public long first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public long last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final long x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= ( int )min.value;
delete( min );
return min.value;
}
public long pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= ( int )max.value;
delete( max );
return max.value;
}
public long ceiling ( final long x ) {
return ceiling( root, x );
}
private long ceiling ( Node node, final long x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public long higher ( final long x ) {
return higher( root, x );
}
private long higher ( Node node, final long x ) {
Node ans = new Node( null, x - 1 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public long floor ( final long x ) {
return floor( root, x );
}
private long floor ( Node node, final long x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public long lower ( final long x ) {
return lower( root, x );
}
private long lower ( Node node, final long x ) {
Node ans = new Node( null, x + 1 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public int size () {
return size;
}
public long[] toArray () {
final long[] list = new long[size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index++] = now.value;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final long[] list = toArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeLong tree ) {
if ( size != tree.size() ) {
return false;
}
final long[] array1 = toArray();
final long[] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i] != array2[i] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
}
rotateL( node );
}
else {
setStates( node );
}
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final int ls = node.left != null ? node.left.size : 0;
final int rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + 1;
}
}
final class TreeMulti<E extends Comparable<E>> {
private Node<E> root;
private long size;
private int uniqueSize;
private int hash;
public TreeMulti () {
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node<E> {
E value;
long count, size;
int height;
Node<E> left, right, parent;
public Node ( final Node<E> p, final E v, final long c ) {
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add ( final E x ) {
if ( root == null ) {
root = new Node<>( null, x, 1 );
++uniqueSize;
}
else {
Node<E> par;
Node<E> now = root;
boolean bool = true;
do {
par = now;
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
bool = false;
++now.count;
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
final int result = x.compareTo( par.value );
if ( result < 0 ) {
par.left = new Node<>( par, x, 1 );
}
else {
par.right = new Node<>( par, x, 1 );
}
}
fix( par );
}
++size;
hash ^= x.hashCode();
}
public void add ( final E x, final long sum ) {
if ( root == null ) {
root = new Node<>( null, x, sum );
++uniqueSize;
}
else {
Node<E> par;
Node<E> now = root;
boolean bool = true;
do {
par = now;
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
bool = false;
now.count += sum;
fix( now );
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
final int result = x.compareTo( par.value );
if ( result < 0 ) {
par.left = new Node<>( par, x, sum );
}
else {
par.right = new Node<>( par, x, sum );
}
fix( par );
}
}
size += sum;
hash ^= sum % 2 == 1 ? x.hashCode() : 0;
}
public E get ( long index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node<E> now = root;
while ( true ) {
assert now != null;
final long ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls + now.count <= index ) {
index -= ls + now.count;
now = now.right;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final E x ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= n.hashCode();
delete( n );
return true;
}
public long remove ( final E x, final long sum ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return 0;
}
final long ans = Math.min( sum, n.count );
size -= ans;
hash ^= ans % 2 == 1 ? n.hashCode() : 0;
n.count -= ans - 1;
delete( n );
return ans;
}
public long removeAll ( final E x ) {
final Node<E> n = getNode( x );
if ( n == null ) {
return 0;
}
size -= n.count;
final long ans = n.count;
hash ^= ans % 2 == 1 ? n.hashCode() : 0;
n.count = 0;
delete( n );
return ans;
}
private void delete ( final Node<E> node ) {
if ( node != null ) {
if ( node.count > 1 ) {
--node.count;
fix( node );
return;
}
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
--uniqueSize;
}
else {
if ( node.left != null && node.right != null ) {
final Node<E> rep = getFirstNode( node.right );
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete( rep );
}
else {
final Node<E> rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node<E> getNode ( final E x ) {
Node<E> now = root;
while ( now != null ) {
final int result = x.compareTo( now.value );
if ( result < 0 ) {
now = now.left;
}
else if ( result > 0 ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public E first () {
if ( root == null ) {
return null;
}
return getFirstNode( root ).value;
}
private Node<E> getFirstNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public E last () {
if ( root == null ) {
return null;
}
return getLastNode( root ).value;
}
private Node<E> getLastNode ( Node<E> node ) {
assert node != null;
Node<E> par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final E x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long sum ( final E x ) {
if ( root == null ) {
return 0;
}
Node<E> node = getNode( x );
return node != null ? node.count : 0;
}
public E pollFirst () {
if ( root == null ) {
return null;
}
--size;
final Node<E> min = getFirstNode( root );
hash ^= min.value.hashCode();
final E ans = min.value;
delete( min );
return ans;
}
public E pollLast () {
if ( root == null ) {
return null;
}
--size;
final Node<E> max = getLastNode( root );
hash ^= max.value.hashCode();
final E ans = max.value;
delete( max );
return ans;
}
public E ceiling ( final E x ) {
return ceiling( root, x );
}
private E ceiling ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result > 0 ) {
node = node.right;
}
else if ( result < 0 ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E higher ( final E x ) {
return higher( root, x );
}
private E higher ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result >= 0 ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans != null ? ans.value : null;
}
public E floor ( final E x ) {
return floor( root, x );
}
private E floor ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result < 0 ) {
node = node.left;
}
else if ( result > 0 ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans != null ? ans.value : null;
}
public E lower ( final E x ) {
return lower( root, x );
}
private E lower ( Node<E> node, final E x ) {
Node<E> ans = null;
while ( node != null ) {
final int result = x.compareTo( node.value );
if ( result <= 0 ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans != null ? ans.value : null;
}
public int size () {
return uniqueSize;
}
public long sumSize () {
return size;
}
public ArrayList<E> toList () {
final ArrayList<E> list = new ArrayList<>();
if ( root != null ) {
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node<E> now = deq.pollLast();
if ( list.size() == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list.add( now.value );
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list.get( list.size() - 1 ).compareTo( now.left.value ) < 0 ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list.add( now.value );
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final ArrayList<E> list = toList();
return list.toString();
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeMulti<?> tree ) {
if ( size != tree.size() ) {
return false;
}
final ArrayList<E> array1 = toList();
final ArrayList<?> array2 = tree.toList();
for ( int i = 0; i < size; ++i ) {
if ( !array1.get( i ).equals( array2.get( i ) ) ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node<E> node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
setStates( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
setStates( node.right );
}
rotateL( node );
}
setStates( node );
node = node.parent;
}
}
private void rotateR ( final Node<E> node ) {
final Node<E> temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node<E> node ) {
final Node<E> temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node<E> node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final long ls = node.left != null ? node.left.size : 0;
final long rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + node.count;
}
}
final class TreeMultiInt {
private Node root;
private long size;
private int uniqueSize;
private int hash;
public TreeMultiInt () {
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node {
int value;
long count, size;
int height;
Node left, right, parent;
public Node ( final Node p, final int v, final long c ) {
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add ( final int x ) {
if ( root == null ) {
root = new Node( null, x, 1 );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
++now.count;
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, 1 );
}
else {
par.right = new Node( par, x, 1 );
}
}
fix( par );
}
++size;
hash ^= x;
}
public void add ( final int x, final long sum ) {
if ( root == null ) {
root = new Node( null, x, sum );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
now.count += sum;
fix( now );
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, sum );
}
else {
par.right = new Node( par, x, sum );
}
fix( par );
}
}
size += sum;
if ( sum % 2 == 1 ) {
hash ^= x;
}
}
public int get ( long index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final long ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls + now.count <= index ) {
index -= ls + now.count;
now = now.right;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final int x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= x;
delete( n );
return true;
}
public long remove ( final int x, final long sum ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
final long ans = Math.min( sum, n.count );
size -= ans;
n.count -= ans - 1;
if ( ans % 2 == 1 ) {
hash ^= x;
}
delete( n );
return ans;
}
public long removeAll ( final int x ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
size -= n.count;
final long ans = n.count;
if ( n.count % 2 == 1 ) {
hash ^= x;
}
n.count = 0;
delete( n );
return ans;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.count > 1 ) {
--node.count;
fix( node );
return;
}
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
--uniqueSize;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node getNode ( final int x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public int first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public int last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final int x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long sum ( final int x ) {
if ( root == null ) {
return 0;
}
Node node = getNode( x );
return node != null ? node.count : 0;
}
public int pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= min.value;
final int ans = min.value;
delete( min );
return ans;
}
public int pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= max.value;
final int ans = max.value;
delete( max );
return ans;
}
public int ceiling ( final int x ) {
return ceiling( root, x );
}
private int ceiling ( Node node, final int x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public int higher ( final int x ) {
return higher( root, x );
}
private int higher ( Node node, final int x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public int floor ( final int x ) {
return floor( root, x );
}
private int floor ( Node node, final int x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public int lower ( final int x ) {
return lower( root, x );
}
private int lower ( Node node, final int x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public int size () {
return uniqueSize;
}
public long sumSize () {
return size;
}
public long[][] toArray () {
final long[][] list = new long[uniqueSize][2];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>( root.height << 1 );
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1][0] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
public int[] toOneArray () {
final int[] list = new int[( int )size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final int[] list = toOneArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeMultiInt tree ) {
if ( size != tree.size() ) {
return false;
}
final long[][] array1 = toArray();
final long[][] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i][0] != array2[i][0] || array1[i][1] != array2[i][1] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
setStates( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
setStates( node.right );
}
rotateL( node );
}
setStates( node );
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final long ls = node.left != null ? node.left.size : 0;
final long rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + node.count;
}
}
final class TreeMultiLong {
private Node root;
private long size;
private int uniqueSize;
private int hash;
public TreeMultiLong () {
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node {
long value;
long count, size;
int height;
Node left, right, parent;
public Node ( final Node p, final long v, final long c ) {
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add ( final long x ) {
if ( root == null ) {
root = new Node( null, x, 1 );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
++now.count;
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, 1 );
}
else {
par.right = new Node( par, x, 1 );
}
}
fix( par );
}
++size;
hash ^= ( int )x;
}
public void add ( final long x, final long sum ) {
if ( root == null ) {
root = new Node( null, x, sum );
++uniqueSize;
}
else {
Node par;
Node now = root;
boolean bool = true;
do {
par = now;
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
bool = false;
now.count += sum;
fix( now );
break;
}
} while ( now != null );
if ( bool ) {
++uniqueSize;
if ( x < par.value ) {
par.left = new Node( par, x, sum );
}
else {
par.right = new Node( par, x, sum );
}
fix( par );
}
}
size += sum;
if ( sum % 2 == 1 ) {
hash ^= ( int )x;
}
}
public long get ( long index ) {
if ( root == null || size <= index ) {
throw new NullPointerException();
}
Node now = root;
while ( true ) {
assert now != null;
final long ls = now.left != null ? now.left.size : 0;
if ( index < ls ) {
now = now.left;
}
else if ( ls + now.count <= index ) {
index -= ls + now.count;
now = now.right;
}
else {
break;
}
}
return now.value;
}
public boolean remove ( final long x ) {
final Node n = getNode( x );
if ( n == null ) {
return false;
}
--size;
hash ^= x;
delete( n );
return true;
}
public long remove ( final long x, final long sum ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
final long ans = Math.min( sum, n.count );
size -= ans;
n.count -= ans - 1;
if ( ans % 2 == 1 ) {
hash ^= ( int )x;
}
delete( n );
return ans;
}
public long removeAll ( final long x ) {
final Node n = getNode( x );
if ( n == null ) {
return 0;
}
size -= n.count;
final long ans = n.count;
if ( n.count % 2 == 1 ) {
hash ^= ( int )x;
}
n.count = 0;
delete( n );
return ans;
}
private void delete ( final Node node ) {
if ( node != null ) {
if ( node.count > 1 ) {
--node.count;
fix( node );
return;
}
if ( node.left == null && node.right == null ) {
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = null;
}
else {
node.parent.right = null;
}
fix( node.parent );
}
else {
root = null;
}
node.parent = null;
--uniqueSize;
}
else {
if ( node.left != null && node.right != null ) {
final Node rep = getFirstNode( node.right );
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete( rep );
}
else {
final Node rep = node.left != null ? node.left : node.right;
rep.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = rep;
}
else {
node.parent.right = rep;
}
fix( node.parent );
}
else {
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node getNode ( final long x ) {
Node now = root;
while ( now != null ) {
if ( x < now.value ) {
now = now.left;
}
else if ( x > now.value ) {
now = now.right;
}
else {
break;
}
}
return now;
}
public long first () {
if ( root == null ) {
throw new NullPointerException();
}
return getFirstNode( root ).value;
}
private Node getFirstNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.left;
}
return par;
}
public long last () {
if ( root == null ) {
throw new NullPointerException();
}
return getLastNode( root ).value;
}
private Node getLastNode ( Node node ) {
assert node != null;
Node par = null;
while ( node != null ) {
par = node;
node = par.right;
}
return par;
}
public boolean contains ( final long x ) {
if ( root == null ) {
return false;
}
return getNode( x ) != null;
}
public long sum ( final long x ) {
if ( root == null ) {
return 0;
}
final Node node = getNode( x );
return node != null ? node.count : 0;
}
public long pollFirst () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node min = getFirstNode( root );
hash ^= ( int )min.value;
final long ans = min.value;
delete( min );
return ans;
}
public long pollLast () {
if ( root == null ) {
throw new NullPointerException();
}
--size;
final Node max = getLastNode( root );
hash ^= ( int )max.value;
final long ans = max.value;
delete( max );
return ans;
}
public long ceiling ( final long x ) {
return ceiling( root, x );
}
private long ceiling ( Node node, final long x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x > node.value ) {
node = node.right;
}
else if ( x < node.value ) {
ans = node;
node = node.left;
}
else {
return x;
}
}
return ans.value;
}
public long higher ( final long x ) {
return higher( root, x );
}
private long higher ( Node node, final long x ) {
Node ans = new Node( null, x - 1, 0 );
while ( node != null ) {
if ( x >= node.value ) {
node = node.right;
}
else {
ans = node;
node = node.left;
}
}
return ans.value;
}
public long floor ( final long x ) {
return floor( root, x );
}
private long floor ( Node node, final long x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x < node.value ) {
node = node.left;
}
else if ( x > node.value ) {
ans = node;
node = node.right;
}
else {
return x;
}
}
return ans.value;
}
public long lower ( final long x ) {
return lower( root, x );
}
private long lower ( Node node, final long x ) {
Node ans = new Node( null, x + 1, 0 );
while ( node != null ) {
if ( x <= node.value ) {
node = node.left;
}
else {
ans = node;
node = node.right;
}
}
return ans.value;
}
public int size () {
return uniqueSize;
}
public long sumSize () {
return size;
}
public long[][] toArray () {
final long[][] list = new long[uniqueSize][2];
if ( root != null ) {
int index = 0;
ArrayDeque<Node> deq = new ArrayDeque<>( root.height << 1 );
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1][0] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
list[index][0] = now.value;
list[index++][1] = now.count;
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
public long[] toOneArray () {
final long[] list = new long[( int )size];
if ( root != null ) {
int index = 0;
final ArrayDeque<Node> deq = new ArrayDeque<>();
deq.add( root );
while ( !deq.isEmpty() ) {
final Node now = deq.pollLast();
if ( index == 0 ) {
if ( now.left != null ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
else if ( now.left != null && list[index - 1] < now.left.value ) {
deq.add( now );
deq.add( now.left );
}
else {
for ( int i = 0; i < now.count; ++i ) {
list[index++] = now.value;
}
if ( now.right != null ) {
deq.add( now.right );
}
}
}
}
return list;
}
@Override
public String toString () {
final long[] list = toOneArray();
return Arrays.toString( list );
}
@Override
public boolean equals ( final Object o ) {
if ( o instanceof final TreeMultiInt tree ) {
if ( size != tree.size() ) {
return false;
}
final long[][] array1 = toArray();
final long[][] array2 = tree.toArray();
for ( int i = 0; i < size; ++i ) {
if ( array1[i][0] != array2[i][0] || array1[i][1] != array2[i][1] ) {
return false;
}
}
return true;
}
return false;
}
@Override
public int hashCode () {
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix ( Node node ) {
while ( node != null ) {
final int lh = node.left == null ? 0 : node.left.height;
final int rh = node.right == null ? 0 : node.right.height;
if ( lh - rh > 1 ) {
assert node.left != null;
if ( node.left.right != null && node.left.right.height == lh - 1 ) {
rotateL( node.left );
setStates( node.left );
}
rotateR( node );
}
else if ( rh - lh > 1 ) {
assert node.right != null;
if ( node.right.left != null && node.right.left.height == rh - 1 ) {
rotateR( node.right );
setStates( node.right );
}
rotateL( node );
}
setStates( node );
node = node.parent;
}
}
private void rotateR ( final Node node ) {
final Node temp = node.left;
node.left = temp.right;
if ( node.left != null ) {
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void rotateL ( final Node node ) {
final Node temp = node.right;
node.right = temp.left;
if ( node.right != null ) {
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if ( node.parent != null ) {
if ( node.parent.left == node ) {
node.parent.left = temp;
}
else {
node.parent.right = temp;
}
}
else {
root = temp;
}
node.parent = temp;
setStates( node );
}
private void setStates ( final Node node ) {
final int lh = node.left != null ? node.left.height : 0;
final int rh = node.right != null ? node.right.height : 0;
node.height = Math.max( lh, rh ) + 1;
final long ls = node.left != null ? node.left.size : 0;
final long rs = node.right != null ? node.right.size : 0;
node.size = ls + rs + node.count;
}
}
final class SimpleScanner {
private final int BUFF_SIZE = 1 << 17;
private final InputStream is;
private final byte[] buff;
private int point, length;
public SimpleScanner ( final InputStream is ) {
this.is = is;
buff = new byte[BUFF_SIZE];
point = length = 0;
}
private void reload () {
do {
try {
length = is.read( buff, point = 0, BUFF_SIZE );
} catch ( final IOException e ) {
e.printStackTrace();
System.exit( 1 );
}
} while ( length == -1 );
}
private byte read () {
if ( point == length ) {
reload();
}
return buff[point++];
}
public byte nextByte () {
byte c = read();
while ( c <= ' ' ) {
c = read();
}
return c;
}
public int nextInt () {
int ans = 0;
byte c = nextByte();
final boolean negate = c == '-';
if ( !MathFunction.rangeCheckClose( c, '0', '9' ) ) {
c = read();
}
while ( MathFunction.rangeCheckClose( c, '0', '9' ) ) {
ans = ans * 10 + c - '0';
c = read();
}
return negate ? -ans : ans;
}
public long nextLong () {
long ans = 0;
byte c = nextByte();
final boolean negate = c == '-';
if ( !MathFunction.rangeCheckClose( c, '0', '9' ) ) {
c = read();
}
while ( MathFunction.rangeCheckClose( c, '0', '9' ) ) {
ans = ans * 10L + c - '0';
c = read();
}
return negate ? -ans : ans;
}
public char nextChar () {
return ( char )nextByte();
}
public String next () {
final StringBuilder ans = new StringBuilder();
byte c = nextByte();
while ( c > ' ' ) {
ans.append( ( char )c );
c = read();
}
return ans.toString();
}
public BigInteger nextBigInteger () {
return new BigInteger( next() );
}
public byte[] nextByte ( final int n ) {
final byte[] ans = new byte[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextByte();
}
return ans;
}
public int[] nextInt ( final int n ) {
final int[] ans = new int[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextInt();
}
return ans;
}
public long[] nextLong ( final int n ) {
final long[] ans = new long[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextLong();
}
return ans;
}
public String[] next ( final int n ) {
final String[] ans = new String[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = next();
}
return ans;
}
public byte[][] nextByte ( final int n, final int m ) {
final byte[][] ans = new byte[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextByte( m );
}
return ans;
}
public int[][] nextInt ( final int n, final int m ) {
final int[][] ans = new int[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextInt( m );
}
return ans;
}
public long[][] nextLong ( final int n, final int m ) {
final long[][] ans = new long[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextLong( m );
}
return ans;
}
public String[][] next ( final int n, final int m ) {
final String[][] ans = new String[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = next( m );
}
return ans;
}
public char[] nextCharArray () {
return next().toCharArray();
}
public char[][] nextCharArray ( final int n ) {
final char[][] ans = new char[n][];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextCharArray();
}
return ans;
}
public int[][] nextGraph ( final int N, final int M ) {
if ( M == 0 ) {
return new int[N + 1][0];
}
final int[][] ans = new int[N + 1][];
final int[] count = new int[N + 1];
final int[][] path = nextInt( M, 2 );
for ( final int[] temp: path ) {
++count[temp[0]];
++count[temp[1]];
}
for ( int i = 1; i <= N; ++i ) {
ans[i] = new int[count[i]];
}
for ( final int[] temp: path ) {
ans[temp[0]][--count[temp[0]]] = temp[1];
ans[temp[1]][--count[temp[1]]] = temp[0];
}
ans[0] = new int[0];
return ans;
}
public Point nextPoint () {
return new Point( nextInt(), nextInt() );
}
public Point[] nextPoint ( final int n ) {
final Point[] ans = new Point[n];
for ( int i = 0; i < n; ++i ) {
ans[i] = nextPoint();
}
return ans;
}
public void close () {
try {
is.close();
} catch ( final IOException e ) {
e.printStackTrace();
System.exit( 1 );
}
}
}
final class SimpleOutputStream extends FilterOutputStream {
private final byte buf[];
private int count;
public SimpleOutputStream(final OutputStream out) {
this(out, 1<<17);
}
public SimpleOutputStream(final OutputStream out, final int size) {
super(out);
if (size <= 0) {
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
private void flushBuffer() throws IOException {
if (count > 0) {
out.write(buf, 0, count);
count = 0;
}
}
public void write(final int b) throws IOException {
if (count >= buf.length) {
flushBuffer();
}
buf[count++] = (byte)b;
}
public void write(final byte b[], final int off, final int len) throws IOException {
if (len >= buf.length) {
flushBuffer();
out.write(b, off, len);
return;
}
if (len > buf.length - count) {
flushBuffer();
}
System.arraycopy(b, off, buf, count, len);
count += len;
}
public void flush() throws IOException {
flushBuffer();
out.flush();
}
}
final class SimpleWriter implements Appendable, Closeable, Flushable, AutoCloseable{
private Writer out;
private final boolean autoFlush;
private boolean trouble = false;
private Formatter formatter;
private PrintStream psOut = null;
private static Charset toCharset ( final String csn ) {
if ( csn == null ) {
throw new NullPointerException( "charsetName" );
}
try {
return Charset.forName( csn );
} catch ( IllegalCharsetNameException |
UnsupportedCharsetException e ) {
e.printStackTrace();
System.exit( 1 );
return null;
}
}
public SimpleWriter ( final Writer out ) {
this( out, false );
}
public SimpleWriter ( final Writer out, final boolean autoFlush ) {
this.out = out;
this.autoFlush = autoFlush;
}
public SimpleWriter ( final OutputStream out ) {
this( out, false );
}
public SimpleWriter ( final OutputStream out, final boolean autoFlush ) {
this(out, autoFlush, Charset.defaultCharset());
}
public SimpleWriter(final OutputStream out, final boolean autoFlush, final Charset charset) {
this(new BufferedWriter(new OutputStreamWriter(new SimpleOutputStream(out), charset)), autoFlush);
if (out instanceof PrintStream) {
psOut = (PrintStream) out;
}
}
private void ensureOpen () throws IOException {
if ( out == null ) {
throw new IOException( "Stream closed" );
}
}
public void flush () {
try {
ensureOpen();
out.flush();
} catch ( IOException x ) {
trouble = true;
}
}
public void close () {
try {
if ( out == null ) {
return;
}
out.close();
out = null;
} catch ( IOException x ) {
trouble = true;
}
}
public boolean checkError () {
if ( out != null ) {
flush();
}
else if ( psOut != null ) {
return psOut.checkError();
}
return trouble;
}
private void setError () {
trouble = true;
}
private void clearError () {
trouble = false;
}
public void write ( final int c ) {
try {
ensureOpen();
out.write( c );
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void write ( final char[] buf, final int off, final int len ) {
try {
ensureOpen();
out.write( buf, off, len );
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void write ( final char[] buf ) {
write( buf, 0, buf.length );
}
public void write ( final String s, final int off, final int len ) {
try {
ensureOpen();
out.write( s, off, len );
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void write ( final String s ) {
write( s, 0, s.length() );
}
private void newLine () {
try {
ensureOpen();
out.write( System.lineSeparator() );
if ( autoFlush ) {
out.flush();
}
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
}
public void print ( final boolean b ) {
write( b ? "true" : "false" );
}
public void print ( final char c ) {
write( c );
}
public void print ( final int i ) {
write( String.valueOf( i ) );
}
public void print ( final long l ) {
write( String.valueOf( l ) );
}
public void print ( final float f ) {
write( String.valueOf( f ) );
}
public void print ( final double d ) {
write( String.valueOf( d ) );
}
public void print ( final char[] s ) {
write( s );
}
public void print ( final String s ) {
write( s );
}
public void print ( final Object obj ) {
write( obj.toString() );
}
public void println () {
newLine();
}
public void println ( final boolean x ) {
print( x );
println();
}
public void println ( final char x ) {
print( x );
println();
}
public void println ( final int x ) {
print( x );
println();
}
public void println ( final long x ) {
print( x );
println();
}
public void println ( final float x ) {
print( x );
println();
}
public void println ( final double x ) {
print( x );
println();
}
public void println ( final char[] x ) {
print( x );
println();
}
public void println ( final String x ) {
print( x );
println();
}
public void println ( final Object x ) {
print( x.toString() );
println();
}
public SimpleWriter printf ( final String format, final Object... args ) {
return format( format, args );
}
public SimpleWriter printf ( final Locale l, final String format, final Object... args ) {
return format( l, format, args );
}
public SimpleWriter format ( final String format, final Object... args ) {
try {
ensureOpen();
if ( ( formatter == null )
|| ( formatter.locale() != Locale.getDefault() ) ) {
formatter = new Formatter( this );
}
formatter.format( Locale.getDefault(), format, args );
if ( autoFlush ) {
out.flush();
}
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
return this;
}
public SimpleWriter format ( final Locale l, final String format, final Object... args ) {
try {
ensureOpen();
if ( ( formatter == null ) || ( formatter.locale() != l ) ) {
formatter = new Formatter( this, l );
}
formatter.format( l, format, args );
if ( autoFlush ) {
out.flush();
}
} catch ( InterruptedIOException x ) {
Thread.currentThread().interrupt();
} catch ( IOException x ) {
trouble = true;
}
return this;
}
public SimpleWriter append ( final CharSequence csq ) {
write( String.valueOf( csq ) );
return this;
}
public SimpleWriter append ( CharSequence csq, final int start, final int end ) {
if ( csq == null ) {
csq = "null";
}
return append( csq.subSequence( start, end ) );
}
public SimpleWriter append ( final char c ) {
write( c );
return this;
}
public void print ( final int[] array ) {
print( array, ' ' );
}
public void print ( final int[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
}
public void print ( final int[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
}
public void print ( final int[][] array ) {
print( array, ' ' );
}
public void print ( final int[][] arrays, final String str ) {
print( arrays[0], str );
for ( int i = 1; i < arrays.length; ++i ) {
println();
print( arrays[i], str );
}
}
public void print ( final int[][] arrays, final char c ) {
print( arrays[0], c );
for ( int i = 1; i < arrays.length; ++i ) {
println();
print( arrays[i], c );
}
}
public void println ( final int[] array ) {
print( array, ' ' );
println();
}
public void println ( final int[] array, final String str ) {
print( array, str );
println();
}
public void println ( final int[] array, final char c ) {
print( array, c );
println();
}
public void println ( final int[][] array ) {
print( array, ' ' );
println();
}
public void println ( final int[][] arrays, final String str ) {
print( arrays, str );
println();
}
public void println ( final int[][] arrays, final char c ) {
print( arrays, c );
println();
}
public void println ( final long[] array ) {
println( array, ' ' );
}
public void println ( final long[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
println();
}
public void println ( final long[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
println();
}
public void println ( final long[][] array ) {
println( array, ' ' );
}
public void println ( final long[][] arrays, final String str ) {
for ( final long[] array: arrays ) {
println( array, str );
}
}
public void println ( final long[][] arrays, final char c ) {
for ( final long[] array: arrays ) {
println( array, c );
}
}
public void println ( final double[] array ) {
println( array, ' ' );
}
public void println ( final double[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
println();
}
public void println ( final double[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
println();
}
public void println ( final double[][] array ) {
println( array, ' ' );
}
public void println ( final double[][] arrays, final String str ) {
for ( final double[] array: arrays ) {
println( array, str );
}
}
public void println ( final double[][] arrays, final char c ) {
for ( final double[] array: arrays ) {
println( array, c );
}
}
public void println ( final char[] cs, final String str ) {
print( cs[0] );
for ( int i = 1; i < cs.length; ++i ) {
print( str );
print( cs[i] );
}
println();
}
public void println ( final char[] cs, final char c ) {
print( cs[0] );
for ( int i = 1; i < cs.length; ++i ) {
print( c );
print( cs[i] );
}
println();
}
public void println ( final char[][] cs ) {
for ( final char[] c: cs ) {
println( c );
}
}
public void println ( final char[][] cs, final String str ) {
for ( final char[] c: cs ) {
println( c, str );
}
}
public void println ( final char[][] cs, final char c ) {
for ( final char[] cc: cs ) {
println( cc, c );
}
}
public <E> void println ( final E[] array ) {
println( array, ' ' );
}
public <E> void println ( final E[] array, final String str ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( str );
print( array[i] );
}
println();
}
public <E> void println ( final E[] array, final char c ) {
print( array[0] );
for ( int i = 1; i < array.length; ++i ) {
print( c );
print( array[i] );
}
println();
}
public <E> void println ( final E[][] arrays ) {
println( arrays, ' ' );
}
public <E> void println ( final E[][] arrays, final String str ) {
for ( final E[] array: arrays ) {
println( array, str );
}
}
public <E> void println ( final E[][] arrays, final char c ) {
for ( final E[] array: arrays ) {
println( array, c );
}
}
public <E> void println ( final List<E> list ) {
println( list, ' ' );
}
public <E> void println ( final List<E> list, final String str ) {
if ( list.size() == 0 ) {
println();
return;
}
print( list.get( 0 ) );
for ( int i = 1; i < list.size(); ++i ) {
print( str );
print( list.get( i ) );
}
println();
}
public <E> void println ( final List<E> list, final char c ) {
if ( list.size() == 0 ) {
println();
return;
}
print( list.get( 0 ) );
for ( int i = 1; i < list.size(); ++i ) {
print( c );
print( list.get( i ) );
}
println();
}
}
| ConDefects/ConDefects/Code/abc327_f/Java/47840198 |
condefects-java_data_1546 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String cadena = in.nextLine();
StringBuilder retorno = new StringBuilder();
for (int i = 0; i < cadena.length(); i++) {
retorno.append(cadena.charAt(i)).append(cadena.charAt(i));
}
System.out.println(retorno);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int lenght = in.nextInt();
in.nextLine();
String cadena = in.nextLine();
StringBuilder retorno = new StringBuilder();
for (int i = 0; i < cadena.length(); i++) {
retorno.append(cadena.charAt(i)).append(cadena.charAt(i));
}
System.out.println(retorno);
}
} | ConDefects/ConDefects/Code/abc306_a/Java/43051291 |
condefects-java_data_1547 |
import java.io.*;
import java.util.*;
class Main{
public static void main(String[] args) {
ac in=new ac();
String a=in.next();
for(int i=0;i<a.length();i++){
in.print(a.charAt(i)+""+a.charAt(i));
}
in.flush();
}
}
class ac extends PrintWriter {
BufferedReader br;
StringTokenizer st;
ac() {
this(System.in, System.out);
}
ac(InputStream i, OutputStream o) {
super(o);
br = new BufferedReader(new InputStreamReader(i));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
}
import java.io.*;
import java.util.*;
class Main{
public static void main(String[] args) {
ac in=new ac();int n=in.nextInt();
String a=in.next();
for(int i=0;i<a.length();i++){
in.print(a.charAt(i)+""+a.charAt(i));
}
in.flush();
}
}
class ac extends PrintWriter {
BufferedReader br;
StringTokenizer st;
ac() {
this(System.in, System.out);
}
ac(InputStream i, OutputStream o) {
super(o);
br = new BufferedReader(new InputStreamReader(i));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
}
| ConDefects/ConDefects/Code/abc306_a/Java/43478448 |
condefects-java_data_1548 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
long A[] = new long [N];
long B[] = new long [M];
int a =0;
int b =0;
int sum=0;
for(int i=0; i<N;i++) {
A[i]=scanner.nextLong();
}
for(int i=0;i<M;i++) {
B[i] = scanner.nextLong();
}
Arrays.sort(A);
Arrays.sort(B);
while(a<N&&b<M) {if(A[a]>=B[b]) {
sum+=A[a];
a+=1;
b+=1;
}else{a+=1;}
}
if(b!=M) {
System.out.println(-1);
}else {
System.out.println(sum);
}
scanner.close();
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
long A[] = new long [N];
long B[] = new long [M];
int a =0;
int b =0;
long sum=0;
for(int i=0; i<N;i++) {
A[i]=scanner.nextLong();
}
for(int i=0;i<M;i++) {
B[i] = scanner.nextLong();
}
Arrays.sort(A);
Arrays.sort(B);
while(a<N&&b<M) {if(A[a]>=B[b]) {
sum+=A[a];
a+=1;
b+=1;
}else{a+=1;}
}
if(b!=M) {
System.out.println(-1);
}else {
System.out.println(sum);
}
scanner.close();
}
}
| ConDefects/ConDefects/Code/abc358_d/Java/54623212 |
condefects-java_data_1549 | // import static org.junit.jupiter.api.Assertions.assertEquals;
// import org.junit.jupiter.api.Test;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[N];
int[] B = new int[M];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
for (int i = 0; i < M; i++) {
B[i] = sc.nextInt();
}
int j = 0;
int sum = 0;
Arrays.sort(A);
Arrays.sort(B);
for (int i = 0; i < N; i++) {
if (A[i] >= B[j]) {
j++;
sum += A[i];
}
if (j >= M) {
System.out.println(sum);
return;
}
}
System.out.println(-1);
return;
}
// @Test
// void addition() {
// assertEquals(2, 1 + 1);
// }
}
// import static org.junit.jupiter.api.Assertions.assertEquals;
// import org.junit.jupiter.api.Test;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[N];
int[] B = new int[M];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
for (int i = 0; i < M; i++) {
B[i] = sc.nextInt();
}
int j = 0;
long sum = 0;
Arrays.sort(A);
Arrays.sort(B);
for (int i = 0; i < N; i++) {
if (A[i] >= B[j]) {
j++;
sum += A[i];
}
if (j >= M) {
System.out.println(sum);
return;
}
}
System.out.println(-1);
return;
}
// @Test
// void addition() {
// assertEquals(2, 1 + 1);
// }
} | ConDefects/ConDefects/Code/abc358_d/Java/54618388 |
condefects-java_data_1550 | import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = Integer.parseInt(sc.next());
int m = Integer.parseInt(sc.next());
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = Long.parseLong(sc.next());
}
Arrays.sort(a);
long[] b = new long[m];
for (int i = 0; i < m; i++) {
b[i] = Long.parseLong(sc.next());
}
Arrays.sort(b);
int j = 0;
long ans = 0L;
for (int i = 0; i < m; i++) {
for (; j < n; j++) {
if (a[j] >= b[i]) {
ans += a[j];
j++;
break;
}
if (j == n - 1) {
out.println(-1);
out.flush();
return;
}
}
if (j == n && i < m) {
out.println(-1);
out.flush();
return;
}
}
out.println(ans);
out.flush();
}
private static long modPow(long a, long b, long mod) {
long ans = 1L;
b %= mod - 1L;
while (b > 0) {
if ((b & 1) == 1) {
ans = ans * a % mod;
}
a = a * a % mod;
b >>= 1;
}
return ans;
}
private static long pow(long a, long b) {
long ans = 1L;
while (b > 0) {
if ((b & 1) == 1) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
private static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
}
}
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = Integer.parseInt(sc.next());
int m = Integer.parseInt(sc.next());
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = Long.parseLong(sc.next());
}
Arrays.sort(a);
long[] b = new long[m];
for (int i = 0; i < m; i++) {
b[i] = Long.parseLong(sc.next());
}
Arrays.sort(b);
int j = 0;
long ans = 0L;
for (int i = 0; i < m; i++) {
for (; j < n; j++) {
if (a[j] >= b[i]) {
ans += a[j];
j++;
break;
}
if (j == n - 1) {
out.println(-1);
out.flush();
return;
}
}
if (j == n && i < m - 1) {
out.println(-1);
out.flush();
return;
}
}
out.println(ans);
out.flush();
}
private static long modPow(long a, long b, long mod) {
long ans = 1L;
b %= mod - 1L;
while (b > 0) {
if ((b & 1) == 1) {
ans = ans * a % mod;
}
a = a * a % mod;
b >>= 1;
}
return ans;
}
private static long pow(long a, long b) {
long ans = 1L;
while (b > 0) {
if ((b & 1) == 1) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
private static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
}
} | ConDefects/ConDefects/Code/abc358_d/Java/54613978 |
condefects-java_data_1551 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static void main(String[] args) throws IOException {
final BufferedReader reader =
new BufferedReader(new InputStreamReader(System.in));
System.out.println(execute(reader));
}
static String execute(final BufferedReader reader) throws IOException {
final Scanner sc = new Scanner(reader);
final int boxNum = sc.nextInt();
final int memberNum = sc.nextInt();
final int[] boxCapacities = getInts(sc, boxNum);
final int[] memberMins = getInts(sc, memberNum);
final NavigableMap<Integer, AtomicInteger> boxCapMap = new TreeMap<>();
for (int j = 0; j < boxCapacities.length; j++) {
final var val = Integer.valueOf(boxCapacities[j]);
if (!boxCapMap.containsKey(val)) {
boxCapMap.put(val, new AtomicInteger());
}
boxCapMap.get(val).incrementAndGet();
}
System.out.println(boxCapMap);
final List<Integer> sortedMemMins =
Arrays.stream(memberMins).boxed().sorted(Comparator.comparingInt(i -> -i.intValue())).toList();
long result = 0;
for (final var memMin : sortedMemMins) {
System.out.println(memMin);
final Entry<Integer, AtomicInteger> box = boxCapMap.ceilingEntry(memMin);
if (box == null) return "-1";
final AtomicInteger rest = box.getValue();
if (rest.intValue() <= 0) return "-1";
result += box.getKey().intValue();
if (rest.decrementAndGet() <= 0) {
boxCapMap.remove(box.getKey());
}
}
return Long.toString(result);
}
/**
* @param scanner スキャナーオブジェクト
* @param amount 要素の数
* @return スキャナーから読取った int 配列
*/
private static int[] getInts(
final Scanner scanner,
final int amount) {
final int[] result = new int[amount];
for (int i = 0; i < amount; i++) {
result[i] = scanner.nextInt();
}
return result;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static void main(String[] args) throws IOException {
final BufferedReader reader =
new BufferedReader(new InputStreamReader(System.in));
System.out.println(execute(reader));
}
static String execute(final BufferedReader reader) throws IOException {
final Scanner sc = new Scanner(reader);
final int boxNum = sc.nextInt();
final int memberNum = sc.nextInt();
final int[] boxCapacities = getInts(sc, boxNum);
final int[] memberMins = getInts(sc, memberNum);
final NavigableMap<Integer, AtomicInteger> boxCapMap = new TreeMap<>();
for (int j = 0; j < boxCapacities.length; j++) {
final var val = Integer.valueOf(boxCapacities[j]);
if (!boxCapMap.containsKey(val)) {
boxCapMap.put(val, new AtomicInteger());
}
boxCapMap.get(val).incrementAndGet();
}
final List<Integer> sortedMemMins =
Arrays.stream(memberMins).boxed().sorted(Comparator.comparingInt(i -> -i.intValue())).toList();
long result = 0;
for (final var memMin : sortedMemMins) {
final Entry<Integer, AtomicInteger> box = boxCapMap.ceilingEntry(memMin);
if (box == null) return "-1";
final AtomicInteger rest = box.getValue();
if (rest.intValue() <= 0) return "-1";
result += box.getKey().intValue();
if (rest.decrementAndGet() <= 0) {
boxCapMap.remove(box.getKey());
}
}
return Long.toString(result);
}
/**
* @param scanner スキャナーオブジェクト
* @param amount 要素の数
* @return スキャナーから読取った int 配列
*/
private static int[] getInts(
final Scanner scanner,
final int amount) {
final int[] result = new int[amount];
for (int i = 0; i < amount; i++) {
result[i] = scanner.nextInt();
}
return result;
}
}
| ConDefects/ConDefects/Code/abc358_d/Java/55031699 |
condefects-java_data_1552 | import java.util.*;
public class Main {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
solve();
}
private static TreeMap<Integer, Integer> map;
private static void solve() {
int n = in.nextInt(), m = in.nextInt();
map = new TreeMap<>();
for(int i = 0; i < n; i++) {
int num = in.nextInt();
map.put(num, map.getOrDefault(num, 0) + 1);
}
int res = 0;
int[] b = new int[m];
for(int i = 0; i < m; i++) b[i] = in.nextInt();
Arrays.sort(b);
for(int i = 0; i < m; i++) {
int need = b[i];
Integer num = map.ceilingKey(need);
if(num == null) {
System.out.println(-1);
return;
}
res += num;
if(map.get(num) == 1) map.remove(num);
else map.put(num, map.get(num) - 1);
}
System.out.println(res);
}
}
import java.util.*;
public class Main {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
solve();
}
private static TreeMap<Integer, Integer> map;
private static void solve() {
int n = in.nextInt(), m = in.nextInt();
map = new TreeMap<>();
for(int i = 0; i < n; i++) {
int num = in.nextInt();
map.put(num, map.getOrDefault(num, 0) + 1);
}
long res = 0;
int[] b = new int[m];
for(int i = 0; i < m; i++) b[i] = in.nextInt();
Arrays.sort(b);
for(int i = 0; i < m; i++) {
int need = b[i];
Integer num = map.ceilingKey(need);
if(num == null) {
System.out.println(-1);
return;
}
res += num;
if(map.get(num) == 1) map.remove(num);
else map.put(num, map.get(num) - 1);
}
System.out.println(res);
}
}
| ConDefects/ConDefects/Code/abc358_d/Java/55013998 |
condefects-java_data_1553 | import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int n, m, a[], b[];
public static void main(String[] args) throws Exception {
n = sc.nextInt();
m = sc.nextInt();
a = new int[n];
b = new int[m];
for(int i = 0; i < n; i ++) a[i] = sc.nextInt();
for(int i = 0; i < m; i ++) b[i] = sc.nextInt();
Arrays.sort(a);
Arrays.sort(b);
int i = 0, j = 0;
long ans = 0;
while(i < n && j < m){
if(b[j] <= a[i]) {
j ++;
ans += a[i];
}
i ++;
if(n - i < m - j){pw.print(-1);return;}//优化 可无
}
pw.println(j == m ? ans : -1);
pw.flush();pw.close();
}
}
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int n, m, a[], b[];
public static void main(String[] args) throws Exception {
n = sc.nextInt();
m = sc.nextInt();
a = new int[n];
b = new int[m];
for(int i = 0; i < n; i ++) a[i] = sc.nextInt();
for(int i = 0; i < m; i ++) b[i] = sc.nextInt();
Arrays.sort(a);
Arrays.sort(b);
int i = 0, j = 0;
long ans = 0;
while(i < n && j < m){
if(b[j] <= a[i]) {
j ++;
ans += a[i];
}
i ++;
if(n - i < m - j){pw.print(-1);pw.flush();return;}//优化 可无
}
pw.println(j == m ? ans : -1);
pw.flush();pw.close();
}
} | ConDefects/ConDefects/Code/abc358_d/Java/54666078 |
condefects-java_data_1554 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
long[] A = new long[N];
long[] B = new long[M];
for(int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
for(int i = 0; i < M; i++) {
B[i] = sc.nextInt();
}
Arrays.sort(A);
Arrays.sort(B);
int totalPayment = 0;
boolean isSucceed =false;
int j = 0;
for (int i = 0; i < M; i++) {
if(B[i] > A[j]) {
i--;
} else {
totalPayment += A[j];
}
j++;
if(i == M-1) {
isSucceed = true;
}
if(j==N) {
break;
}
}
if(isSucceed) {
System.out.println(totalPayment);
} else {
System.out.println(-1);
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
long[] A = new long[N];
long[] B = new long[M];
for(int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
for(int i = 0; i < M; i++) {
B[i] = sc.nextInt();
}
Arrays.sort(A);
Arrays.sort(B);
long totalPayment = 0L;
boolean isSucceed =false;
int j = 0;
for (int i = 0; i < M; i++) {
if(B[i] > A[j]) {
i--;
} else {
totalPayment += A[j];
}
j++;
if(i == M-1) {
isSucceed = true;
}
if(j==N) {
break;
}
}
if(isSucceed) {
System.out.println(totalPayment);
} else {
System.out.println(-1);
}
}
}
| ConDefects/ConDefects/Code/abc358_d/Java/54617538 |
condefects-java_data_1555 | import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int N=sc.nextInt();
int X[]=new int[5*N];
double sum=0;
for(int i=0;i<5*N;i++)
{
X[i]=sc.nextInt();
sum+=X[i];
}
for(int j=0;j<N;j++)
{
int max_pos=0,min_pos=0;
int max=-2;
int min=101;
for(int k=0;k<5*N;k++)
{
if(X[k]==-1)
continue;
if(X[k]>max)
{max=X[k];
max_pos=k;
}
if(min>X[k])
{min=X[k];
min_pos=k;
}
}
sum-=max-min;
X[max_pos]=-1;
X[min_pos]=-1;
}
double avg=sum/(3*N);
System.out.println(avg);
}
}
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int N=sc.nextInt();
int X[]=new int[5*N];
double sum=0;
for(int i=0;i<5*N;i++)
{
X[i]=sc.nextInt();
sum+=X[i];
}
for(int j=0;j<N;j++)
{
int max_pos=0,min_pos=0;
int max=-2;
int min=101;
for(int k=0;k<5*N;k++)
{
if(X[k]==-1)
continue;
if(X[k]>max)
{max=X[k];
max_pos=k;
}
if(min>X[k])
{min=X[k];
min_pos=k;
}
}
sum=sum-max-min;
X[max_pos]=-1;
X[min_pos]=-1;
}
double avg=sum/(3*N);
System.out.println(avg);
}
} | ConDefects/ConDefects/Code/abc291_b/Java/44804785 |
condefects-java_data_1556 | import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int[] suretu = new int[N + 1];
for(int i = 1;i <= N; i++){
suretu[i] = i;
}
int L = sc.nextInt();
int R = sc.nextInt();
int k = R;
for(int i = L;i <= R;i++){
suretu[i] = k;
k--;
}
for(int i = 1;i <= N;i++){
System.out.print(suretu[i] + "");
}
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int[] suretu = new int[N + 1];
for(int i = 1;i <= N; i++){
suretu[i] = i;
}
int L = sc.nextInt();
int R = sc.nextInt();
int k = R;
for(int i = L;i <= R;i++){
suretu[i] = k;
k--;
}
for(int i = 1;i <= N;i++){
System.out.print(suretu[i] + " ");
}
}
} | ConDefects/ConDefects/Code/abc356_a/Java/54716130 |
condefects-java_data_1557 | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<Integer>();
int N = scan.nextInt();
int L = scan.nextInt() - 1;
int R = scan.nextInt() - 1;
int S = (R - L + 1) / 2;
for(int i = 0 ; i < N ; i++){
list.add(i + 1);
}
int comL = 0;
int comR = 0;
while(L <= R){
comL = list.get(L); //左を一時格納
comR = list.get(R); //右を一時格納
list.set(L, comR);
list.set(R, comL);
L++;
R--;
}
for(int i = 0 ; i < N ; i++){
System.out.print(list.get(i));
}
scan.close();
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<Integer>();
int N = scan.nextInt();
int L = scan.nextInt() - 1;
int R = scan.nextInt() - 1;
int S = (R - L + 1) / 2;
for(int i = 0 ; i < N ; i++){
list.add(i + 1);
}
int comL = 0;
int comR = 0;
while(L <= R){
comL = list.get(L); //左を一時格納
comR = list.get(R); //右を一時格納
list.set(L, comR);
list.set(R, comL);
L++;
R--;
}
for(int i = 0 ; i < N ; i++){
System.out.print(list.get(i) + " ");
}
scan.close();
}
} | ConDefects/ConDefects/Code/abc356_a/Java/54657737 |
condefects-java_data_1558 | import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
try (Scanner input = new Scanner(System.in)) {
int N = input.nextInt();
if (N % 100 == 0)
System.out.println("00");
else
System.out.println(N % 100); // 2 last degits
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
try (Scanner input = new Scanner(System.in)) {
int N = input.nextInt();
if (N % 100 == 0)
System.out.println("00");
else if (N % 100 >= 1 && N % 100 < 10)
System.out.println("0" + N % 100);
else
System.out.println(N % 100); // 2 last degits
}
}
}
| ConDefects/ConDefects/Code/abc254_a/Java/43291283 |
condefects-java_data_1559 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int x;
x=scanner.nextInt();
int res=x%100;
if(res <10) {
System.out.println(0+res);
}
else {
System.out.println(res);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int x;
x=scanner.nextInt();
int res=x%100;
if(res <10) {
System.out.println("0"+res);
}
else {
System.out.println(res);
}
}
}
| ConDefects/ConDefects/Code/abc254_a/Java/38117564 |
condefects-java_data_1560 | import java.util.*;
class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int n = Int();
print(n % 100);
}
static void print(Object str) {
System.out.println(str);
}
static String Str() {
return sc.next();
}
static int Int() {
return sc.nextInt();
}
static double Double() {
return sc.nextDouble();
}
static long Long() {
return sc.nextLong();
}
static int[] ArrayInt(int num) {
int t [] = new int [num];
for(int i = 0; i < num; i++)
t[i] = sc.nextInt();
return t;
}
static char[] ArrayChar() {
String str = sc.next();
return str.toCharArray();
}
}
import java.util.*;
class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int n = Int();
System.out.printf("%02d" ,n % 100);
}
static void print(Object str) {
System.out.println(str);
}
static String Str() {
return sc.next();
}
static int Int() {
return sc.nextInt();
}
static double Double() {
return sc.nextDouble();
}
static long Long() {
return sc.nextLong();
}
static int[] ArrayInt(int num) {
int t [] = new int [num];
for(int i = 0; i < num; i++)
t[i] = sc.nextInt();
return t;
}
static char[] ArrayChar() {
String str = sc.next();
return str.toCharArray();
}
} | ConDefects/ConDefects/Code/abc254_a/Java/33914798 |
condefects-java_data_1561 | import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
long A = sc.nextLong();
long B = sc.nextLong();
long C = sc.nextLong();
long X = sc.nextLong();
long ans = 0;
long[] d = xgcd(B, C);
for (int a = 1; a <= N; a++) {
ans += solve0(N, B, C, X - A * a, d);
}
System.out.println(ans);
}
long solve0(long N, long B, long C, long X, long[] d) {
long g = d[0];
long b = d[1];
long c = d[2];
if ( X % g != 0 ) return 0;
return solve0(N, B / g, C / g, X / g, b, c);
}
long solve0(long N, long B, long C, long X, long b, long c) {
if ( X <= 0 ) return 0;
// B * b + C * c = 1
BigInteger bb = BigInteger.valueOf(b);
BigInteger cc = BigInteger.valueOf(c);
BigInteger BB = BigInteger.valueOf(B);
BigInteger CC = BigInteger.valueOf(C);
BigInteger XX = BigInteger.valueOf(X);
BigInteger NN = BigInteger.valueOf(N);
BigInteger b0 = bb.multiply(XX);
BigInteger c0 = cc.multiply(XX);
if ( c0.compareTo(BigInteger.ZERO) > 0 ) {
BigInteger d = c0.divide(BB).add(BigInteger.ONE);
b0 = b0.add(CC.multiply(d));
c0 = c0.subtract(BB.multiply(d));
}
if ( b0.compareTo(NN) <= 0 ) {
BigInteger d = NN.subtract(b0).divide(CC).add(BigInteger.ONE);
b0 = b0.add(CC.multiply(d));
c0 = c0.subtract(BB.multiply(d));
}
BigInteger a0 = NN.subtract(c0).divide(BB).add(BigInteger.ONE);
BigInteger a1 = b0.subtract(BigInteger.ONE).divide(CC).add(BigInteger.ONE);
BigInteger a2 = b0.subtract(NN).subtract(BigInteger.ONE).divide(CC).add(BigInteger.ONE);
BigInteger a3 = BigInteger.ZERO.subtract(c0).divide(BB).add(BigInteger.ONE);
return ((a0.min(a1)).subtract(a2.max(a3))).longValue();
}
static long[] xgcd(long a, long b) {
long x0 = 1;
long y0 = 0;
long x1 = 0;
long y1 = 1;
while ( b != 0 ) {
long q = a / b;
long tmp = b;
b = a % b;
a = tmp;
tmp = x1;
x1 = x0 - q * x1;
x0 = tmp;
tmp = y1;
y1 = y0 - q * y1;
y0 = tmp;
}
return new long[] {a, x0, y0};
}
long div(long a, long b) {
if ( a >= 0 ) {
return a / b;
} else {
return -((-a + b - 1) / b);
}
}
class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner( InputStream source ) { this.in = source; }
private boolean hasNextByte() {
if ( ptr < buflen ) return true;
else {
ptr = 0;
try { buflen = in.read(buf); } catch (IOException e) { e.printStackTrace(); }
if ( buflen <= 0 ) return false;
}
return true;
}
private int readByte() { if ( hasNextByte() ) return buf[ptr++]; else return -1; }
private boolean isPrintableChar( int c ) { return 33 <= c && c <= 126; }
private boolean isNumeric( int c ) { return '0' <= c && c <= '9'; }
private void skipToNextPrintableChar() { while ( hasNextByte() && !isPrintableChar(buf[ptr]) ) ptr++; }
public boolean hasNext() { skipToNextPrintableChar(); return hasNextByte(); }
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
StringBuilder ret = new StringBuilder();
int b = readByte();
while ( isPrintableChar(b) ) { ret.appendCodePoint(b); b = readByte(); }
return ret.toString();
}
public long nextLong() {
if ( !hasNext() ) throw new NoSuchElementException();
long ret = 0;
int b = readByte();
boolean negative = false;
if ( b == '-' ) { negative = true; if ( hasNextByte() ) b = readByte(); }
if ( !isNumeric(b) ) throw new NumberFormatException();
while ( true ) {
if ( isNumeric(b) ) ret = ret * 10 + b - '0';
else if ( b == -1 || !isPrintableChar(b) ) return negative ? -ret : ret;
else throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() { return (int)nextLong(); }
public double nextDouble() { return Double.parseDouble(next()); }
}
}
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
long A = sc.nextLong();
long B = sc.nextLong();
long C = sc.nextLong();
long X = sc.nextLong();
long ans = 0;
long[] d = xgcd(B, C);
for (int a = 1; a <= N; a++) {
ans += solve0(N, B, C, X - A * a, d);
}
System.out.println(ans);
}
long solve0(long N, long B, long C, long X, long[] d) {
long g = d[0];
long b = d[1];
long c = d[2];
if ( X % g != 0 ) return 0;
return solve0(N, B / g, C / g, X / g, b, c);
}
long solve0(long N, long B, long C, long X, long b, long c) {
if ( X <= 0 ) return 0;
// B * b + C * c = 1
BigInteger bb = BigInteger.valueOf(b);
BigInteger cc = BigInteger.valueOf(c);
BigInteger BB = BigInteger.valueOf(B);
BigInteger CC = BigInteger.valueOf(C);
BigInteger XX = BigInteger.valueOf(X);
BigInteger NN = BigInteger.valueOf(N);
BigInteger b0 = bb.multiply(XX);
BigInteger c0 = cc.multiply(XX);
if ( c0.compareTo(BigInteger.ZERO) > 0 ) {
BigInteger d = c0.divide(BB).add(BigInteger.ONE);
b0 = b0.add(CC.multiply(d));
c0 = c0.subtract(BB.multiply(d));
}
if ( b0.compareTo(NN) <= 0 ) {
BigInteger d = NN.subtract(b0).divide(CC).add(BigInteger.ONE);
b0 = b0.add(CC.multiply(d));
c0 = c0.subtract(BB.multiply(d));
}
BigInteger a0 = NN.subtract(c0).divide(BB).add(BigInteger.ONE);
BigInteger a1 = b0.subtract(BigInteger.ONE).divide(CC).add(BigInteger.ONE);
BigInteger a2 = b0.subtract(NN).subtract(BigInteger.ONE).divide(CC).add(BigInteger.ONE);
BigInteger a3 = BigInteger.ZERO.subtract(c0).divide(BB).add(BigInteger.ONE);
return Math.max(((a0.min(a1)).subtract(a2.max(a3))).longValue(), 0);
}
static long[] xgcd(long a, long b) {
long x0 = 1;
long y0 = 0;
long x1 = 0;
long y1 = 1;
while ( b != 0 ) {
long q = a / b;
long tmp = b;
b = a % b;
a = tmp;
tmp = x1;
x1 = x0 - q * x1;
x0 = tmp;
tmp = y1;
y1 = y0 - q * y1;
y0 = tmp;
}
return new long[] {a, x0, y0};
}
long div(long a, long b) {
if ( a >= 0 ) {
return a / b;
} else {
return -((-a + b - 1) / b);
}
}
class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner( InputStream source ) { this.in = source; }
private boolean hasNextByte() {
if ( ptr < buflen ) return true;
else {
ptr = 0;
try { buflen = in.read(buf); } catch (IOException e) { e.printStackTrace(); }
if ( buflen <= 0 ) return false;
}
return true;
}
private int readByte() { if ( hasNextByte() ) return buf[ptr++]; else return -1; }
private boolean isPrintableChar( int c ) { return 33 <= c && c <= 126; }
private boolean isNumeric( int c ) { return '0' <= c && c <= '9'; }
private void skipToNextPrintableChar() { while ( hasNextByte() && !isPrintableChar(buf[ptr]) ) ptr++; }
public boolean hasNext() { skipToNextPrintableChar(); return hasNextByte(); }
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
StringBuilder ret = new StringBuilder();
int b = readByte();
while ( isPrintableChar(b) ) { ret.appendCodePoint(b); b = readByte(); }
return ret.toString();
}
public long nextLong() {
if ( !hasNext() ) throw new NoSuchElementException();
long ret = 0;
int b = readByte();
boolean negative = false;
if ( b == '-' ) { negative = true; if ( hasNextByte() ) b = readByte(); }
if ( !isNumeric(b) ) throw new NumberFormatException();
while ( true ) {
if ( isNumeric(b) ) ret = ret * 10 + b - '0';
else if ( b == -1 || !isPrintableChar(b) ) return negative ? -ret : ret;
else throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() { return (int)nextLong(); }
public double nextDouble() { return Double.parseDouble(next()); }
}
}
| ConDefects/ConDefects/Code/abc315_g/Java/44921899 |
condefects-java_data_1562 | /*
███╗░░░███╗░█████╗░██╗░░██╗░█████╗░███╗░░░███╗███████╗██████╗░ ██╗░░██╗░█████╗░░██████╗░██████╗░█████╗░███╗░░██╗
████╗░████║██╔══██╗██║░░██║██╔══██╗████╗░████║██╔════╝██╔══██╗ ██║░░██║██╔══██╗██╔════╝██╔════╝██╔══██╗████╗░██║
██╔████╔██║██║░░██║███████║███████║██╔████╔██║█████╗░░██║░░██║ ███████║███████║╚█████╗░╚█████╗░███████║██╔██╗██║
██║╚██╔╝██║██║░░██║██╔══██║██╔══██║██║╚██╔╝██║██╔══╝░░██║░░██║ ██╔══██║██╔══██║░╚═══██╗░╚═══██╗██╔══██║██║╚████║
██║░╚═╝░██║╚█████╔╝██║░░██║██║░░██║██║░╚═╝░██║███████╗██████╔╝ ██║░░██║██║░░██║██████╔╝██████╔╝██║░░██║██║░╚███║
╚═╝░░░░░╚═╝░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░░░░╚═╝╚══════╝╚═════╝░ ╚═╝░░╚═╝╚═╝░░╚═╝╚═════╝░╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝
*/
import java.util.*;
import java.io.*;
public class Main {
//**********************Code**************\\
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static int x, y, z;
static int[] arr;
static int dp[][];
static boolean vis[];
static ArrayList<Integer>[] adjlist;
static int dx[] = {-1, 0, 1, 0, -1, 1, 1, -1};
static int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
static ArrayList<Pair> pq;
public static void main(String[] args) throws IOException {
int n = sc.nextInt();
long arr[] = sc.nextlongArray(n);
pq = new ArrayList<>();
for (int i = 1; i < n; i++)
if (i % 2 == 0)
pq.add(new Pair(arr[i - 1], arr[i]));
long prefix[] = new long[pq.size() + 1];
for (int i = 1; i < prefix.length; i++)
prefix[i] = prefix[i - 1] + pq.get(i - 1).second - pq.get(i - 1).first;
// System.out.println(pq);
// System.out.println(Arrays.toString(prefix));
int q = sc.nextInt();
while (q-- > 0) {
long l = sc.nextLong();
long r = sc.nextLong();
int left = binarysearchleft((int) l);
int right = binarysearchright((int) r);
long ans = 0;
// System.out.println(left + " " + right);
// System.out.println(prefix[left] + " " + prefix[right]);
if (left == right&&r <= pq.get(left).second) {
ans = 0;
} else if (l <= pq.get(left).first && r >= pq.get(right).second) {
ans = prefix[right + 1] - prefix[left];
// pw.println("first");
} else if (l <= pq.get(left).first && r < pq.get(right).second) {
ans = prefix[right] - prefix[left] + r - pq.get(right).first;
// pw.println("second");
} else if (l > pq.get(left).first && r >= pq.get(right).second) {
ans = prefix[right + 1] - prefix[left + 1] + pq.get(left).second - l;
// pw.println("third");
} else {
ans = prefix[right] - prefix[left + 1] + pq.get(left).second - l + r - pq.get(right).first;
// pw.println("fourth");
}
pw.println(ans);
//
}
pw.flush();
}
static int binarysearchleft(int val) {
int low = 0;
int high = pq.size() - 1;
int ans = 0;
while (low <= high) {
// if (low + 1 == high)
// return low;
int mid = (low + high) / 2;
if (pq.get(mid).first <= val && pq.get(mid).second >= val) {
return mid;
} else if (pq.get(mid).second <= val) {
ans = mid + 1;
low = mid + 1;
} else
high = mid - 1;
// System.out.println(low+" "+high);
}
return ans;
}
static int binarysearchright(int val) {
int low = 0;
int high = pq.size() - 1;
int ans = 0;
while (low <= high) {
int mid = (low + high) / 2;
if (pq.get(mid).first <= val && pq.get(mid).second >= val) {
return mid;
} else if (pq.get(mid).second <= val) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
return ans;
}
//**********************Scanner&helpers**************\\
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public long[] nextlongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
}
//*******helper methods*****\\
static long lcm(long a, long b) {
return (a / gcd(a, b)) * b;
}
public static long gcd(long f, long b) {
if (f == 0)
return b;
return gcd(b % f, f);
}
public static long nCr(long n, long r) {
return fact(n) / (fact(r) * fact(n - r));
//return divm(fact[(int) n] , mulm(fact[(int) r] , fact[(int) (n - r)]));
}
// Returns factorial of n
static long fact(long n) {
if (n == 0)
return 1;
int res = 1;
for (int i = 2; i <= n; i++)
res = res * i;
return res;
}
public static int count(int arr[], int c) {
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == c)
count++;
}
return count;
}
static void shuffle(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int a = (int) (Math.random() * arr.length);
int b = (int) (Math.random() * arr.length);
int tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
}
static void bin(long n) {
long i;
System.out.print("0");
for (i = 1 << 30; i > 0; i = i / 2) {
if ((n & i) != 0) {
System.out.print("1");
} else {
System.out.print("0");
}
}
}
static ArrayList<Integer> primes = new ArrayList<>();
static void sieveOfEratosthenes(int n) {
primes = new ArrayList<>();
sieveOfEratosthenes1(n);
}
static void sieveOfEratosthenes1(int n) {
// Create a boolean array "prime[0..n]" and
// initialize all entries it as true. A value in
// prime[i] will finally be false if i is Not a
// prime, else true.
boolean prime[] = new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
prime[0] = prime[1] = false;
for (int p = 2; p * p <= n; p++) {
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true) {
// Update all multiples of p greater than or
// equal to the square of it numbers which
// are multiple of p and are less than p^2
// are already been marked.
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for (int i = 2; i <= n; i++) {
if (prime[i] == true)
primes.add(i);
}
}
static ArrayList<Integer> primefactorsusingsieve(int n) {
ArrayList<Integer> ans = new ArrayList<>();
sieveOfEratosthenes(n);
int i = 0;
int o = primes.get(i);
while (o * o <= n) {
while (n % o == 0) {
n /= o;
ans.add(o);
}
i++;
o = primes.get(i);
}
if (n != 1)
ans.add(n);
return ans;
}
final static int P = 1000000007, N = 1000002;
static long[] fact = new long[N];
static long addm(long x, long y) {
return (x + y) % P;
}
static long subm(long l, long y) {
return ((l - y) % P + P) % P;
}
static long mulm(long x, long y) {
return (x * y) % P;
}
static long powrm(long x, long y) {
long res = 1;
while (y > 0) {
if ((y & 1) == 1) {
res = mulm(res, x);
}
y /= 2;
x = mulm(x, x);
}
return res;
}
static long inv(long x) {
return powrm(x, P - 2);
}
static long divm(long x, long y) {
return mulm(x, inv(y));
}
static void calculate_factorials() {
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mulm(fact[i - 1], i);
}
}
public static List<Integer> primeFactors(int n) {
List<Integer> factors = new ArrayList<>();
while (n % 2 == 0) {
factors.add(2);
n /= 2;
}
for (int i = 3; i <= Math.sqrt(n); i += 2) {
while (n % i == 0) {
factors.add(i);
n /= i;
}
}
if (n > 2) {
factors.add(n);
}
return factors;
}
public static int binarySearch(long[] arr, long x) {
int ans = arr.length - 1;
int low = 0;
int hight = arr.length - 1;
while (low <= hight) {
int mid = (low + hight) / 2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x) {
ans = mid;
hight = mid - 1;
} else
low = mid + 1;
}
return ans;
}
public static void dfs(int i) {
vis[i] = true;
for (int j : adjlist[i]) {
if (!vis[j])
dfs(j);
}
}
public static void dijkstra(int a, long[] cost) {
// q = new PriorityQueue<>();
PriorityQueue<Pair> q = new PriorityQueue<>();
q.add(new Pair(0, a));
cost[a] = 0;
while (!q.isEmpty()) {
// System.out.println(q);
long curnode = q.peek().first;
long curcosr = q.peek().second;
q.poll();
if (vis[(int) curnode]) {
// System.out.println("sdsdsd");
continue;
}
vis[(int) curnode] = true;
// !!!!take care here uncomment this part and change
//static ArrayList<Integer>[] adjlist; to
//static ArrayList<Pair>[] adjlist;
// for (Pair i : adjlist[(int) curnode]) {
// if (i.second + curcosr < cost[(int) i.first]) {
// cost[(int) i.first] = i.second + curcosr;
// q.add(new Pair(i.first, cost[(int) i.first]));
// }
//
// }
}
// return -1;
}
//Tree map sorting
//Firstly modify the ValueComparator according to the type of the key and the value
/*how to use:
1-initialize a HashMap and store whatever value you want in it
2-initialize a TreeMap and call ValueComparator like the following example
//Map<Long, Long> kk = new TreeMap<>(new ValueComparator(map));
//kkHashMap.putAll(map);
//map is the name of the HashMap */
static class ValueComparator implements Comparator<Long> {
Map<Long, Long> map;
public ValueComparator(Map<Long, Long> map) {
this.map = map;
}
@Override
public int compare(Long o1, Long o2) {
// TODO Auto-generated method stub
if (map.get(o1) >= map.get(o2)) {
return 1;
} else {
return -1;
}
}
}
static class Pair implements Comparable<Pair> {
long first;
long second;
public Pair(long first, long second) {
this.first = first;
this.second = second;
}
public int compareTo(Pair p) {
if (first != p.first)
return Long.compare(first, p.first);
else if (second != p.second)
return Long.compare(second, p.second);
else
return 0;
}
public String toString() {
return first + " " + second;
}
}
}
/*
███╗░░░███╗░█████╗░██╗░░██╗░█████╗░███╗░░░███╗███████╗██████╗░ ██╗░░██╗░█████╗░░██████╗░██████╗░█████╗░███╗░░██╗
████╗░████║██╔══██╗██║░░██║██╔══██╗████╗░████║██╔════╝██╔══██╗ ██║░░██║██╔══██╗██╔════╝██╔════╝██╔══██╗████╗░██║
██╔████╔██║██║░░██║███████║███████║██╔████╔██║█████╗░░██║░░██║ ███████║███████║╚█████╗░╚█████╗░███████║██╔██╗██║
██║╚██╔╝██║██║░░██║██╔══██║██╔══██║██║╚██╔╝██║██╔══╝░░██║░░██║ ██╔══██║██╔══██║░╚═══██╗░╚═══██╗██╔══██║██║╚████║
██║░╚═╝░██║╚█████╔╝██║░░██║██║░░██║██║░╚═╝░██║███████╗██████╔╝ ██║░░██║██║░░██║██████╔╝██████╔╝██║░░██║██║░╚███║
╚═╝░░░░░╚═╝░╚════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░░░░╚═╝╚══════╝╚═════╝░ ╚═╝░░╚═╝╚═╝░░╚═╝╚═════╝░╚═════╝░╚═╝░░╚═╝╚═╝░░╚══╝
*/
import java.util.*;
import java.io.*;
public class Main {
//**********************Code**************\\
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static int x, y, z;
static int[] arr;
static int dp[][];
static boolean vis[];
static ArrayList<Integer>[] adjlist;
static int dx[] = {-1, 0, 1, 0, -1, 1, 1, -1};
static int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
static ArrayList<Pair> pq;
public static void main(String[] args) throws IOException {
int n = sc.nextInt();
long arr[] = sc.nextlongArray(n);
pq = new ArrayList<>();
for (int i = 1; i < n; i++)
if (i % 2 == 0)
pq.add(new Pair(arr[i - 1], arr[i]));
long prefix[] = new long[pq.size() + 1];
for (int i = 1; i < prefix.length; i++)
prefix[i] = prefix[i - 1] + pq.get(i - 1).second - pq.get(i - 1).first;
// System.out.println(pq);
// System.out.println(Arrays.toString(prefix));
int q = sc.nextInt();
while (q-- > 0) {
long l = sc.nextLong();
long r = sc.nextLong();
int left = binarysearchleft((int) l);
int right = binarysearchright((int) r);
long ans = 0;
// System.out.println(left + " " + right);
// System.out.println(prefix[left] + " " + prefix[right]);
if (left == right&&r <= pq.get(left).first) {
ans = 0;
} else if (l <= pq.get(left).first && r >= pq.get(right).second) {
ans = prefix[right + 1] - prefix[left];
// pw.println("first");
} else if (l <= pq.get(left).first && r < pq.get(right).second) {
ans = prefix[right] - prefix[left] + r - pq.get(right).first;
// pw.println("second");
} else if (l > pq.get(left).first && r >= pq.get(right).second) {
ans = prefix[right + 1] - prefix[left + 1] + pq.get(left).second - l;
// pw.println("third");
} else {
ans = prefix[right] - prefix[left + 1] + pq.get(left).second - l + r - pq.get(right).first;
// pw.println("fourth");
}
pw.println(ans);
//
}
pw.flush();
}
static int binarysearchleft(int val) {
int low = 0;
int high = pq.size() - 1;
int ans = 0;
while (low <= high) {
// if (low + 1 == high)
// return low;
int mid = (low + high) / 2;
if (pq.get(mid).first <= val && pq.get(mid).second >= val) {
return mid;
} else if (pq.get(mid).second <= val) {
ans = mid + 1;
low = mid + 1;
} else
high = mid - 1;
// System.out.println(low+" "+high);
}
return ans;
}
static int binarysearchright(int val) {
int low = 0;
int high = pq.size() - 1;
int ans = 0;
while (low <= high) {
int mid = (low + high) / 2;
if (pq.get(mid).first <= val && pq.get(mid).second >= val) {
return mid;
} else if (pq.get(mid).second <= val) {
ans = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
return ans;
}
//**********************Scanner&helpers**************\\
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader r) {
br = new BufferedReader(r);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public long[] nextlongArray(int n) throws IOException {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public Long[] nextLongArray(int n) throws IOException {
Long[] a = new Long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public int[] nextIntArray(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public Integer[] nextIntegerArray(int n) throws IOException {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public boolean ready() throws IOException {
return br.ready();
}
}
//*******helper methods*****\\
static long lcm(long a, long b) {
return (a / gcd(a, b)) * b;
}
public static long gcd(long f, long b) {
if (f == 0)
return b;
return gcd(b % f, f);
}
public static long nCr(long n, long r) {
return fact(n) / (fact(r) * fact(n - r));
//return divm(fact[(int) n] , mulm(fact[(int) r] , fact[(int) (n - r)]));
}
// Returns factorial of n
static long fact(long n) {
if (n == 0)
return 1;
int res = 1;
for (int i = 2; i <= n; i++)
res = res * i;
return res;
}
public static int count(int arr[], int c) {
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == c)
count++;
}
return count;
}
static void shuffle(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int a = (int) (Math.random() * arr.length);
int b = (int) (Math.random() * arr.length);
int tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
}
static void bin(long n) {
long i;
System.out.print("0");
for (i = 1 << 30; i > 0; i = i / 2) {
if ((n & i) != 0) {
System.out.print("1");
} else {
System.out.print("0");
}
}
}
static ArrayList<Integer> primes = new ArrayList<>();
static void sieveOfEratosthenes(int n) {
primes = new ArrayList<>();
sieveOfEratosthenes1(n);
}
static void sieveOfEratosthenes1(int n) {
// Create a boolean array "prime[0..n]" and
// initialize all entries it as true. A value in
// prime[i] will finally be false if i is Not a
// prime, else true.
boolean prime[] = new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
prime[0] = prime[1] = false;
for (int p = 2; p * p <= n; p++) {
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true) {
// Update all multiples of p greater than or
// equal to the square of it numbers which
// are multiple of p and are less than p^2
// are already been marked.
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for (int i = 2; i <= n; i++) {
if (prime[i] == true)
primes.add(i);
}
}
static ArrayList<Integer> primefactorsusingsieve(int n) {
ArrayList<Integer> ans = new ArrayList<>();
sieveOfEratosthenes(n);
int i = 0;
int o = primes.get(i);
while (o * o <= n) {
while (n % o == 0) {
n /= o;
ans.add(o);
}
i++;
o = primes.get(i);
}
if (n != 1)
ans.add(n);
return ans;
}
final static int P = 1000000007, N = 1000002;
static long[] fact = new long[N];
static long addm(long x, long y) {
return (x + y) % P;
}
static long subm(long l, long y) {
return ((l - y) % P + P) % P;
}
static long mulm(long x, long y) {
return (x * y) % P;
}
static long powrm(long x, long y) {
long res = 1;
while (y > 0) {
if ((y & 1) == 1) {
res = mulm(res, x);
}
y /= 2;
x = mulm(x, x);
}
return res;
}
static long inv(long x) {
return powrm(x, P - 2);
}
static long divm(long x, long y) {
return mulm(x, inv(y));
}
static void calculate_factorials() {
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mulm(fact[i - 1], i);
}
}
public static List<Integer> primeFactors(int n) {
List<Integer> factors = new ArrayList<>();
while (n % 2 == 0) {
factors.add(2);
n /= 2;
}
for (int i = 3; i <= Math.sqrt(n); i += 2) {
while (n % i == 0) {
factors.add(i);
n /= i;
}
}
if (n > 2) {
factors.add(n);
}
return factors;
}
public static int binarySearch(long[] arr, long x) {
int ans = arr.length - 1;
int low = 0;
int hight = arr.length - 1;
while (low <= hight) {
int mid = (low + hight) / 2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x) {
ans = mid;
hight = mid - 1;
} else
low = mid + 1;
}
return ans;
}
public static void dfs(int i) {
vis[i] = true;
for (int j : adjlist[i]) {
if (!vis[j])
dfs(j);
}
}
public static void dijkstra(int a, long[] cost) {
// q = new PriorityQueue<>();
PriorityQueue<Pair> q = new PriorityQueue<>();
q.add(new Pair(0, a));
cost[a] = 0;
while (!q.isEmpty()) {
// System.out.println(q);
long curnode = q.peek().first;
long curcosr = q.peek().second;
q.poll();
if (vis[(int) curnode]) {
// System.out.println("sdsdsd");
continue;
}
vis[(int) curnode] = true;
// !!!!take care here uncomment this part and change
//static ArrayList<Integer>[] adjlist; to
//static ArrayList<Pair>[] adjlist;
// for (Pair i : adjlist[(int) curnode]) {
// if (i.second + curcosr < cost[(int) i.first]) {
// cost[(int) i.first] = i.second + curcosr;
// q.add(new Pair(i.first, cost[(int) i.first]));
// }
//
// }
}
// return -1;
}
//Tree map sorting
//Firstly modify the ValueComparator according to the type of the key and the value
/*how to use:
1-initialize a HashMap and store whatever value you want in it
2-initialize a TreeMap and call ValueComparator like the following example
//Map<Long, Long> kk = new TreeMap<>(new ValueComparator(map));
//kkHashMap.putAll(map);
//map is the name of the HashMap */
static class ValueComparator implements Comparator<Long> {
Map<Long, Long> map;
public ValueComparator(Map<Long, Long> map) {
this.map = map;
}
@Override
public int compare(Long o1, Long o2) {
// TODO Auto-generated method stub
if (map.get(o1) >= map.get(o2)) {
return 1;
} else {
return -1;
}
}
}
static class Pair implements Comparable<Pair> {
long first;
long second;
public Pair(long first, long second) {
this.first = first;
this.second = second;
}
public int compareTo(Pair p) {
if (first != p.first)
return Long.compare(first, p.first);
else if (second != p.second)
return Long.compare(second, p.second);
else
return 0;
}
public String toString() {
return first + " " + second;
}
}
}
| ConDefects/ConDefects/Code/abc305_d/Java/45252906 |
condefects-java_data_1563 | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.Buffer;
import java.util.StringTokenizer;
/*
* Solution: 1m
* Coding: 4m
* Time: 5m
*
*/
public class Main {
public static void main(String[] args) throws IOException {
//BufferedReader br = new BufferedReader(new FileReader("atcoder_abc/input.in"));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
int c = Integer.parseInt(st.nextToken());
int d = Integer.parseInt(st.nextToken());
System.out.println((a + b) * (c + d));
System.out.println("Takahashi");
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.Buffer;
import java.util.StringTokenizer;
/*
* Solution: 1m
* Coding: 4m
* Time: 5m
*
*/
public class Main {
public static void main(String[] args) throws IOException {
//BufferedReader br = new BufferedReader(new FileReader("atcoder_abc/input.in"));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
int c = Integer.parseInt(st.nextToken());
int d = Integer.parseInt(st.nextToken());
System.out.println((a + b) * (c - d));
System.out.println("Takahashi");
}
} | ConDefects/ConDefects/Code/abc269_a/Java/40359953 |
condefects-java_data_1564 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
// 整数の入力
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
// 出力
System.out.println((a+b+c+d));
System.out.println("Takahashi");
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
// 整数の入力
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
// 出力
System.out.println((a+b)*(c-d));
System.out.println("Takahashi");
}
}
| ConDefects/ConDefects/Code/abc269_a/Java/37058278 |
condefects-java_data_1565 | import java.io.*;
import java.util.*;
import java.util.stream.*;
class Main {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N, M, Q;
byte[][] S;
Query[] q;
int[][] V, D;
static class Query {
int i, x, y, ans;
}
static int i(String s) { return Integer.parseInt(s); }
void prepare() throws Exception {
String[] nm = br.readLine().split(" ");
N = i(nm[0]); M = i(nm[1]);
S = new byte[N][N];
for (int i = 0; i < N; i++) {
String s = br.readLine();
for (int j = 0; j < N; j++) if (s.charAt(j) == 'O') S[i][j] = 1;
}
Q = i(br.readLine());
q = new Query[Q];
for (int i = 0; i < Q; i++) {
q[i] = new Query();
q[i].i = i;
String[] xy = br.readLine().split(" ");
q[i].x = i(xy[0]); q[i].y = i(xy[1]);
}
V = new int[N+1][N+1];
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
V[j][i] = V[j][i-1] + S[i-1][j-1];
D = new int[Math.max(0, 3*N-2*M-1)][(N+1)/2+1];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
int s = 2*i+j-3;
if (s >= D.length) break;
int r = (N-j+2)/2;
D[s][r] = D[s][r-1] + S[i-1][j-1];
}
}
}
void calc() throws Exception {
prepare();
Arrays.sort(q, Comparator.comparingInt((Query q) -> q.x).thenComparingInt(q -> q.y));
int toBeSolved = 0;
lp:
for (int i = 1; i <= N; i++) {
int a = 0;
for (int j = 1; j <= N; j++) {
a += (V[j][i] - V[j][Math.max(0, i-M)]);
int s = 2*(i-M)+j-3;
if (s >= 0) {
int r0 = (N-j+2)/2;
int r1 = Math.min(r0 + M, (N+1)/2);
a -= (D[s][r1] - D[s][r0]);
}
while (i == q[toBeSolved].x && j == q[toBeSolved].y) {
q[toBeSolved++].ans = a;
if (toBeSolved == Q) break lp;
}
}
}
Arrays.sort(q, Comparator.comparingInt(q -> q.i));
System.out.write(Arrays.stream(q).map(q -> String.valueOf(q.ans)).collect(Collectors.joining("\n")).getBytes());
System.out.flush();
}
public static void main(String[] args) throws Exception {
new Main().calc();
}
}
import java.io.*;
import java.util.*;
import java.util.stream.*;
class Main {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N, M, Q;
byte[][] S;
Query[] q;
int[][] V, D;
static class Query {
int i, x, y, ans;
}
static int i(String s) { return Integer.parseInt(s); }
void prepare() throws Exception {
String[] nm = br.readLine().split(" ");
N = i(nm[0]); M = i(nm[1]);
S = new byte[N][N];
for (int i = 0; i < N; i++) {
String s = br.readLine();
for (int j = 0; j < N; j++) if (s.charAt(j) == 'O') S[i][j] = 1;
}
Q = i(br.readLine());
q = new Query[Q];
for (int i = 0; i < Q; i++) {
q[i] = new Query();
q[i].i = i;
String[] xy = br.readLine().split(" ");
q[i].x = i(xy[0]); q[i].y = i(xy[1]);
}
V = new int[N+1][N+1];
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
V[j][i] = V[j][i-1] + S[i-1][j-1];
D = new int[Math.max(0, 3*N-2*M-1)][(N+1)/2+1];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
int s = 2*i+j-3;
if (s >= D.length) break;
int r = (N-j+2)/2;
D[s][r] = D[s][r-1] + S[i-1][j-1];
}
}
}
void calc() throws Exception {
prepare();
Arrays.sort(q, Comparator.comparingInt((Query q) -> q.x).thenComparingInt(q -> q.y));
int toBeSolved = 0;
lp:
for (int i = 1; i <= N; i++) {
int a = 0;
for (int j = 1; j <= N; j++) {
a += (V[j][i] - V[j][Math.max(0, i-M)]);
int s = 2*(i-M)+j-3;
if (s >= 0) {
int r0 = (N-j+2)/2;
int r1 = Math.min(r0 + M, (N+1)/2-(N%2)*(s%2));
a -= (D[s][r1] - D[s][r0]);
}
while (i == q[toBeSolved].x && j == q[toBeSolved].y) {
q[toBeSolved++].ans = a;
if (toBeSolved == Q) break lp;
}
}
}
Arrays.sort(q, Comparator.comparingInt(q -> q.i));
System.out.write(Arrays.stream(q).map(q -> String.valueOf(q.ans)).collect(Collectors.joining("\n")).getBytes());
System.out.flush();
}
public static void main(String[] args) throws Exception {
new Main().calc();
}
}
| ConDefects/ConDefects/Code/abc260_g/Java/34723128 |
condefects-java_data_1566 | import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
class Point{
long x;
long y;
public Point(long x_, long y_) {
x = x_;
y = y_;
}
long cross(Point other) {
return x * other.y - y * other.x;
}
Point minus(Point other) {
return new Point(x - other.x, y - other.y);
}
long triangle(Point b, Point c) {
return (b.minus(this)).cross(c.minus(this));
}
}
private void solve() {
N = sc.nextInt();
P = new Point[N];
for(int i = 0; i < N; i++) {
P[i] = new Point(sc.nextLong(), sc.nextLong());
}
int Q = sc.nextInt();
for(int i = 1; i <= Q; i++) {
Point w = new Point(sc.nextLong(), sc.nextLong());
long res = doit(w);
if(res < 0) println("OUT");
else if(res == 0) println("ON");
else println("IN");
}
}
int N;
Point[] P;
long doit(Point w) {
int l = 0;
int r = N;
while(l < r-1) {
int mid = (l+r) / 2;
if(P[0].triangle(P[mid], w) > 0L) {
l = mid;
} else {
r = mid;
}
}
if(r == N) return -1L;
if(r == 1) { // verify 012 (can only be at side 01)
if(P[1].triangle(P[2], w) >= 0 && P[N-1].triangle(P[0], w) >= 0) return 0;
else return -1;
}
if(r == N-1 && P[N-1].triangle(P[0], w) == 0) { // verify 0(N-2)(N-1) (can possibly be at side 0(N-1))
if(P[N-2].triangle(P[N-1], w) >= 0 && P[0].triangle(P[N-1], w) >= 0) return 0;
else return -1;
}
return P[l].triangle(P[r], w);
}
// Main() throws FileNotFoundException { super(new File("output.txt")); }
// InputReader sc = new InputReader(new FileInputStream("test_input.txt"));
Main() { super(System.out); }
InputReader sc = new InputReader(System.in);
static class InputReader {
InputReader(InputStream in) { this.in = in; } InputStream in;
private byte[] buf = new byte[16384];
private int curChar;
private int numChars;
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
public static void main(String[] $) {
new Thread(null, new Runnable() {
public void run() {
long start = System.nanoTime();
try {Main solution = new Main(); solution.solve(); solution.flush();}
// try {Main solution = new Main(); solution.gen(); solution.flush();}
catch (Exception e) {e.printStackTrace(); System.exit(1);}
System.err.println((System.nanoTime()-start)/1E9);
}
}, "1", 1 << 27).start();
}
}
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
class Point{
long x;
long y;
public Point(long x_, long y_) {
x = x_;
y = y_;
}
long cross(Point other) {
return x * other.y - y * other.x;
}
Point minus(Point other) {
return new Point(x - other.x, y - other.y);
}
long triangle(Point b, Point c) {
return (b.minus(this)).cross(c.minus(this));
}
}
private void solve() {
N = sc.nextInt();
P = new Point[N];
for(int i = 0; i < N; i++) {
P[i] = new Point(sc.nextLong(), sc.nextLong());
}
int Q = sc.nextInt();
for(int i = 1; i <= Q; i++) {
Point w = new Point(sc.nextLong(), sc.nextLong());
long res = doit(w);
if(res < 0) println("OUT");
else if(res == 0) println("ON");
else println("IN");
}
}
int N;
Point[] P;
long doit(Point w) {
int l = 0;
int r = N;
while(l < r-1) {
int mid = (l+r) / 2;
if(P[0].triangle(P[mid], w) > 0L) {
l = mid;
} else {
r = mid;
}
}
if(r == N) return -1L;
if(r == 1 && P[0].triangle(P[1], w) == 0) { // verify 012 (can only be at side 01)
if(P[1].triangle(P[2], w) >= 0 && P[N-1].triangle(P[0], w) >= 0) return 0;
else return -1;
}
if(r == N-1 && P[N-1].triangle(P[0], w) == 0) { // verify 0(N-2)(N-1) (can possibly be at side 0(N-1))
if(P[N-2].triangle(P[N-1], w) >= 0 && P[0].triangle(P[N-1], w) >= 0) return 0;
else return -1;
}
return P[l].triangle(P[r], w);
}
// Main() throws FileNotFoundException { super(new File("output.txt")); }
// InputReader sc = new InputReader(new FileInputStream("test_input.txt"));
Main() { super(System.out); }
InputReader sc = new InputReader(System.in);
static class InputReader {
InputReader(InputStream in) { this.in = in; } InputStream in;
private byte[] buf = new byte[16384];
private int curChar;
private int numChars;
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
public static void main(String[] $) {
new Thread(null, new Runnable() {
public void run() {
long start = System.nanoTime();
try {Main solution = new Main(); solution.solve(); solution.flush();}
// try {Main solution = new Main(); solution.gen(); solution.flush();}
catch (Exception e) {e.printStackTrace(); System.exit(1);}
System.err.println((System.nanoTime()-start)/1E9);
}
}, "1", 1 << 27).start();
}
} | ConDefects/ConDefects/Code/abc296_g/Java/41107622 |
condefects-java_data_1567 | import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
class Point{
long x;
long y;
public Point(long x_, long y_) {
x = x_;
y = y_;
}
long cross(Point other) {
return x * other.y - y * other.x;
}
Point minus(Point other) {
return new Point(x - other.x, y - other.y);
}
long triangle(Point b, Point c) {
return (b.minus(this)).cross(c.minus(this));
}
}
private void solve() {
N = sc.nextInt();
P = new Point[N];
for(int i = 0; i < N; i++) {
P[N-1-i] = new Point(sc.nextLong(), sc.nextLong());
}
int Q = sc.nextInt();
for(int i = 1; i <= Q; i++) {
Point w = new Point(sc.nextLong(), sc.nextLong());
long res = doit(w);
if(res < 0) println("OUT");
else if(res == 0) println("ON");
else println("IN");
}
}
int N;
Point[] P;
long doit(Point w) {
int l = 0;
int r = N;
while(l < r-1) {
int mid = (l+r) / 2;
if(P[0].triangle(P[mid], w) < 0L) {
l = mid;
} else {
r = mid;
}
}
if(r == N) return -1L;
if(l == 0 && P[r].triangle(P[l], w) == 0) {
if(P[r+1].triangle(P[r], w) >= 0) return 0;
else return -1;
}
long res = P[r].triangle(P[l], w);
if(r == N-1 && res > 0) res = P[0].triangle(P[N-1], w);
return res;
}
// Main() throws FileNotFoundException { super(new File("output.txt")); }
// InputReader sc = new InputReader(new FileInputStream("test_input.txt"));
Main() { super(System.out); }
InputReader sc = new InputReader(System.in);
static class InputReader {
InputReader(InputStream in) { this.in = in; } InputStream in;
private byte[] buf = new byte[16384];
private int curChar;
private int numChars;
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
public static void main(String[] $) {
new Thread(null, new Runnable() {
public void run() {
long start = System.nanoTime();
try {Main solution = new Main(); solution.solve(); solution.flush();}
// try {Main solution = new Main(); solution.gen(); solution.flush();}
catch (Exception e) {e.printStackTrace(); System.exit(1);}
System.err.println((System.nanoTime()-start)/1E9);
}
}, "1", 1 << 27).start();
}
}
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
class Point{
long x;
long y;
public Point(long x_, long y_) {
x = x_;
y = y_;
}
long cross(Point other) {
return x * other.y - y * other.x;
}
Point minus(Point other) {
return new Point(x - other.x, y - other.y);
}
long triangle(Point b, Point c) {
return (b.minus(this)).cross(c.minus(this));
}
}
private void solve() {
N = sc.nextInt();
P = new Point[N];
for(int i = 0; i < N; i++) {
P[N-1-i] = new Point(sc.nextLong(), sc.nextLong());
}
int Q = sc.nextInt();
for(int i = 1; i <= Q; i++) {
Point w = new Point(sc.nextLong(), sc.nextLong());
long res = doit(w);
if(res < 0) println("OUT");
else if(res == 0) println("ON");
else println("IN");
}
}
int N;
Point[] P;
long doit(Point w) {
int l = 0;
int r = N;
while(l < r-1) {
int mid = (l+r) / 2;
if(P[0].triangle(P[mid], w) < 0L) {
l = mid;
} else {
r = mid;
}
}
if(r == N) return -1L;
if(l == 0 && P[r].triangle(P[l], w) == 0) {
if(P[r+1].triangle(P[r], w) >= 0 && P[0].triangle(P[N-1], w) >= 0) return 0;
else return -1;
}
long res = P[r].triangle(P[l], w);
if(r == N-1 && res > 0) res = P[0].triangle(P[N-1], w);
return res;
}
// Main() throws FileNotFoundException { super(new File("output.txt")); }
// InputReader sc = new InputReader(new FileInputStream("test_input.txt"));
Main() { super(System.out); }
InputReader sc = new InputReader(System.in);
static class InputReader {
InputReader(InputStream in) { this.in = in; } InputStream in;
private byte[] buf = new byte[16384];
private int curChar;
private int numChars;
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = in.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public String nextString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public long nextLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
private boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
public static void main(String[] $) {
new Thread(null, new Runnable() {
public void run() {
long start = System.nanoTime();
try {Main solution = new Main(); solution.solve(); solution.flush();}
// try {Main solution = new Main(); solution.gen(); solution.flush();}
catch (Exception e) {e.printStackTrace(); System.exit(1);}
System.err.println((System.nanoTime()-start)/1E9);
}
}, "1", 1 << 27).start();
}
} | ConDefects/ConDefects/Code/abc296_g/Java/41086510 |
condefects-java_data_1568 | import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int N = sc.nextInt();
char[] S = sc.next().toCharArray();
long count = 0;
for (int i = 0; i < N; i++) {
int c = 0;
int j;
for (j = i + 1; j < N; j++) {
if (S[i] == S[j]) {
c++;
} else {
break;
}
}
if (c != 0) {
i = j - 1;
count += (c * (1 + c)) / 2;
}
}
System.out.println(count);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int N = sc.nextInt();
char[] S = sc.next().toCharArray();
long count = 0;
for (int i = 0; i < N; i++) {
long c = 0;
int j;
for (j = i + 1; j < N; j++) {
if (S[i] == S[j]) {
c++;
} else {
break;
}
}
if (c != 0) {
i = j - 1;
count += (c * (1 + c)) / 2;
}
}
System.out.println(count);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
| ConDefects/ConDefects/Code/arc130_a/Java/27577108 |
condefects-java_data_1569 | import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
static boolean DEBUG;
public static void main(String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int pointer = 0;
private int buflen = 0;
private boolean hasNextByte() {
if(pointer < buflen) return true;
else {
pointer = 0;
try { buflen = in.read(buffer);
}catch (IOException e) { e.printStackTrace(); }
return buflen > 0;
}
}
private int readByte() { if(hasNextByte()) return buffer[pointer ++]; else return -1; }
private boolean isPrintableChar(int c) { return isPrintableChar(c, false); }
private boolean isPrintableChar(int c, boolean includingSpace) { return (includingSpace ? 32 : 33) <= c && c <= 126; }
private void skipUnprintable() { skipUnprintable(false); }
private void skipUnprintable(boolean includingSpace) { while(hasNextByte() && !isPrintableChar(buffer[pointer], includingSpace)) pointer ++; }
private boolean hasNext() { return hasNext(false); }
private boolean hasNext(boolean includingSpace) { skipUnprintable(includingSpace); return hasNextByte(); }
private StringBuilder sb = new StringBuilder();
public String next() { return next(false); }
public String next(boolean includingSpace) {
if(!hasNext(includingSpace)) throw new NoSuchElementException();
sb.setLength(0);
int b = readByte();
while(isPrintableChar(b, includingSpace)) { sb.appendCodePoint(b); b = readByte(); }
return sb.toString();
}
public long nextLong() {
if(!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if(b == '-') { minus = true; b = readByte(); }
if(b < '0' || '9' < b) throw new NumberFormatException();
while(true) {
if('0' <= b && b <= '9') n = n * 10 + b - '0';
else if(b == -1 || !isPrintableChar(b)) return minus ? - n : n;
else throw new NumberFormatException();
b = readByte();
}
}
}
static class Solver {
final FastScanner sc = new FastScanner();
public Solver() { }
final String ns() { return ns(false); }
final String ns(boolean includingSpace) { return sc.next(includingSpace); }
final String[] ns(int n) { return ns(n, false); }
final String[] ns(int n, boolean includingSpace) { String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(includingSpace); return a; }
final String[][] ns(int n, int m) { return ns(n, m, false); }
final String[][] ns(int n, int m, boolean includingSpace) { String a[][] = new String[n][m]; for(int i = 0; i < n; i ++) a[i] = ns(m, includingSpace); return a; }
final char nc() { return ns().charAt(0); }
final char[] nc(int n) {
String str = ns();
if(n < 0) n = str.length();
char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
final char[][] nc(int n, int m) { char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
final boolean[] nb(int n, char t) {
char c[] = nc(-1);
if(n < 0) n = c.length;
boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
final boolean[][] nb(int n, int m, char t) { boolean a[][] = new boolean[n][m]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
final int ni() { return Math.toIntExact(sc.nextLong()); }
final int[] ni(int n) { int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
final int[][] ni(int n, int m) { int a[][] = new int[n][m]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
final long nl() { return sc.nextLong(); }
final long[] nl(int n) { long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
final long[][] nl(int n, int m) { long a[][] = new long[n][m]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
final double nd() { return Double.parseDouble(sc.next()); }
final double[] nd(int n) { double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
final double[][] nd(int n, int m) { double a[][] = new double[n][m]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
final String booleanToString(boolean b) { return b ? "#" : "."; }
final PrintWriter out = new PrintWriter(System.out);
final PrintWriter err = new PrintWriter(System.err);
final StringBuilder sb4prtln = new StringBuilder();
final void prt() { out.print(""); }
final <T> void prt(T a) { out.print(a); }
final void prtln() { out.println(""); }
final <T> void prtln(T a) { out.println(a); }
final void prtln(int... a) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(long... a) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(double... a) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(String... a) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(char... a) { sb4prtln.setLength(0); for(char ele : a) sb4prtln.append(ele); prtln(sb4prtln); }
final void prtln(boolean... a) { sb4prtln.setLength(0); for(boolean ele : a) sb4prtln.append(booleanToString(ele)); prtln(sb4prtln); }
final void prtlns(int... a) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(long... a) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(double... a) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(String... a) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(char... a) { sb4prtln.setLength(0); for(char ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(boolean... a) { sb4prtln.setLength(0); for(boolean ele : a) { sb4prtln.append(booleanToString(ele)); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtln(int[][] a) { for(int[] ele : a) prtln(ele); }
final void prtln(long[][] a) { for(long[] ele : a) prtln(ele); }
final void prtln(double[][] a) { for(double[] ele : a) prtln(ele); }
final void prtln(String[][] a) { for(String[] ele : a) prtln(ele); }
final void prtln(char[][] a) { for(char[] ele : a) prtln(ele); }
final void prtln(boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
final String errconvert(int a) { return isINF(a) ? "_" : String.valueOf(a); }
final String errconvert(long a) { return isINF(a) ? "_" : String.valueOf(a); }
final void errprt(int a) { if(DEBUG) err.print(errconvert(a)); }
final void errprt(long a) { if(DEBUG) err.print(errconvert(a)); }
final void errprt() { if(DEBUG) err.print(""); }
final <T> void errprt(T a) { if(DEBUG) err.print(a); }
final void errprt(boolean a) { if(DEBUG) errprt(booleanToString(a)); }
final void errprtln() { if(DEBUG) err.println(""); }
final void errprtln(int a) { if(DEBUG) err.println(errconvert(a)); }
final void errprtln(long a) { if(DEBUG) err.println(errconvert(a)); }
final <T> void errprtln(T a) { if(DEBUG) err.println(a); }
final void errprtln(boolean a) { if(DEBUG) errprtln(booleanToString(a)); }
final void errprtln(int... a) { if(DEBUG) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(long... a) { if(DEBUG) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(double... a) { if(DEBUG) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(String... a) { if(DEBUG) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(char... a) { if(DEBUG) { sb4prtln.setLength(0); for(char ele : a) sb4prtln.append(ele); errprtln(sb4prtln.toString()); } }
final void errprtln(boolean... a) { if(DEBUG) { sb4prtln.setLength(0); for(boolean ele : a) sb4prtln.append(booleanToString(ele)); errprtln(sb4prtln.toString()); } }
final void errprtlns(int... a) { if(DEBUG) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(long... a) { if(DEBUG) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(double... a) { if(DEBUG) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(String... a) { if(DEBUG) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(char... a) { if(DEBUG) { sb4prtln.setLength(0); for(char ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(boolean... a) { if(DEBUG) { sb4prtln.setLength(0); for(boolean ele : a) { sb4prtln.append(booleanToString(ele)); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtln(Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
final void errprtln(int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
final void errprtln(long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
final void errprtln(double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
final void errprtln(String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
final void errprtln(char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
final void errprtln(boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
final void errprtln(Object[][] a) { if(DEBUG) for(Object ele : a) { errprtln(ele); errprtln(); } }
final void reply(boolean b) { prtln(b ? "Yes" : "No"); }
final void REPLY(boolean b) { prtln(b ? "YES" : "NO"); }
final void flush() { out.flush(); if(DEBUG) err.flush(); }
final void assertion(boolean b) { if(!b) { flush(); throw new AssertionError(); } }
final <T> void assertion(boolean b, T a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void inclusiveRangeCheck(int i, int max) { inclusiveRangeCheck(i, 0, max); }
final void inclusiveRangeCheck(int i, int min, int max) { rangeCheck(i, min, max + 1); }
final void inclusiveRangeCheck(long i, long max) { inclusiveRangeCheck(i, 0, max); }
final void inclusiveRangeCheck(long i, long min, long max) { rangeCheck(i, min, max + 1); }
final void rangeCheck(int i, int max) { rangeCheck(i, 0, max); }
final void rangeCheck(int i, int min, int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
final void rangeCheck(long i, long max) { rangeCheck(i, 0, max); }
final void rangeCheck(long i, long min, long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
final void nonNegativeCheck(long x) { nonNegativeCheck(x, "the argument"); }
final void nonNegativeCheck(long x, String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
final void positiveCheck(long x) { positiveCheck(x, "the argument"); }
final void positiveCheck(long x, String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
final void exit() { flush(); System.exit(0); }
final <T> void exit(T a) { prtln(a); exit(); }
final void exit(int... a) { prtln(a); exit(); }
final void exit(long... a) { prtln(a); exit(); }
final void exit(double... a) { prtln(a); exit(); }
final void exit(String... a) { prtln(a); exit(); }
final void exit(char... a) { prtln(a); exit(); }
final void exit(boolean... a) { prtln(a); exit(); }
final void exit(int[][] a) { prtln(a); exit(); }
final void exit(long[][] a) { prtln(a); exit(); }
final void exit(double[][] a) { prtln(a); exit(); }
final void exit(String[][] a) { prtln(a); exit(); }
final void exit(char[][] a) { prtln(a); exit(); }
final void exit(boolean[][] a) { prtln(a); exit(); }
final long INF = (long)1e18 + 7;
final boolean isPlusINF(long a) { return a > INF / 10; }
final boolean isMinusINF(long a) { return isPlusINF(- a); }
final boolean isINF(long a) { return isPlusINF(a) || isMinusINF(a); }
final int I_INF = (int)1e9 + 7;
final boolean isPlusINF(int a) { return a > I_INF / 10; }
final boolean isMinusINF(int a) { return isPlusINF(- a); }
final boolean isINF(int a) { return isPlusINF(a) || isMinusINF(a); }
final int min(int a, int b) { return Math.min(a, b); }
final long min(long a, long b) { return Math.min(a, b); }
final double min(double a, double b) { return Math.min(a, b); }
final <T extends Comparable<T>> T min(T a, T b) { return a.compareTo(b) <= 0 ? a : b; }
final int min(int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
final long min(long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
final double min(double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
final int max(int a, int b) { return Math.max(a, b); }
final long max(long a, long b) { return Math.max(a, b); }
final double max(double a, double b) { return Math.max(a, b); }
final <T extends Comparable<T>> T max(T a, T b) { return a.compareTo(b) >= 0 ? a : b; }
final int max(int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
final long max(long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
final double max(double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
final <T extends Comparable<T>> T max(T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
final int max(int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
final long max(long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
final double max(double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
final <T extends Comparable<T>> T max(T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
final long sum(int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
final long sum(long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
final double sum(double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
final long sum(boolean... a) { long sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
final long[] sums(int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
final long[] sums(long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
final double[] sums(double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
final long[] sums(boolean[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
final long[][] sums(int[][] a) {
long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
final long[][] sums(long[][] a) {
long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
final double[][] sums(double[][] a) {
double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
final long[][] sums(boolean[][] a) {
long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
final int constrain(int x, int l, int r) { return min(max(x, min(l, r)), max(l, r)); }
final long constrain(long x, long l, long r) { return min(max(x, min(l, r)), max(l, r)); }
final double constrain(double x, double l, double r) { return min(max(x, min(l, r)), max(l, r)); }
final int abs(int x) { return x >= 0 ? x : - x; }
final long abs(long x) { return x >= 0 ? x : - x; }
final double abs(double x) { return x >= 0 ? x : - x; }
final int signum(int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
final int signum(long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
final int signum(double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
final long round(double x) { return Math.round(x); }
final long floor(double x) { return round(Math.floor(x)); }
final int divfloor(int a, int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
final long divfloor(long a, long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
final long ceil(double x) { return round(Math.ceil(x)); }
final int divceil(int a, int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
final long divceil(long a, long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
final boolean mulGreater(long a, long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
final boolean mulGreaterEquals(long a, long b, long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
final boolean mulLess(long a, long b, long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
final boolean mulLessEquals(long a, long b, long c) { return !mulGreater(a, b, c); } // a * b <= c
final double sqrt(int x) { return Math.sqrt((double)x); }
final double sqrt(long x) { return Math.sqrt((double)x); }
final double sqrt(double x) { return Math.sqrt(x); }
final int floorsqrt(int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
final long floorsqrt(long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
final int ceilsqrt(int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
final long ceilsqrt(long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
final long fact(int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
final long naiveP(long n, long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
final long naiveC(long n, long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
final double pow(double x, double y) { return Math.pow(x, y); }
final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
final long lcm(long a, long b) { return a / gcd(a, b) * b; }
final int gcd(int... a) { int gcd = 0; for(int i = 0; i < a.length; i ++) gcd = gcd(gcd, a[i]); return gcd; }
final long gcd(long... a) { long gcd = 0; for(int i = 0; i < a.length; i ++) gcd = gcd(gcd, a[i]); return gcd; }
final double random() { return Math.random(); }
final int random(int max) { return (int)floor(random() * max); }
final long random(long max) { return floor(random() * max); }
final double random(double max) { return random() * max; }
final int random(int min, int max) { return random(max - min) + min; }
final long random(long min, long max) { return random(max - min) + min; }
final double random(double min, double max) { return random(max - min) + min; }
final boolean isUpper(char a) { return a >= 'A' && a <= 'Z'; }
final boolean isLower(char a) { return a >= 'a' && a <= 'z'; }
final int upperToInt(char a) { return a - 'A'; }
final int lowerToInt(char a) { return a - 'a'; }
final int numToInt(char a) { return a - '0'; }
final int charToInt(char a) { return isLower(a) ? lowerToInt(a) : isUpper(a) ? upperToInt(a) : numToInt(a); }
final int alphabetToInt(char a) { return isLower(a) ? lowerToInt(a) : isUpper(a) ? upperToInt(a) + 26 : 52; }
final char intToUpper(int a) { return (char)(a + 'A'); }
final char intToLower(int a) { return (char)(a + 'a'); }
final char intToNum(int a) { return (char)(a + '0'); }
final int[] charToInt(char[] a) { int array[] = new int[a.length]; for(int i = 0; i < a.length; i ++) array[i] = charToInt(a[i]); return array; }
final long[] div(long a) {
nonNegativeCheck(a);
List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= a; i ++) if(a % i == 0) { divList.add(i); if(i * i != a) divList.add(a / i); }
long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
final PairLL[] factor(long a) {
nonNegativeCheck(a);
List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= a; i ++) {
if(a % i == 0) {
long cnt = 0;
while(a % i == 0) { a /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(a > 1) factorList.add(new PairLL(a, 1));
PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
final boolean isPrime(long x) { boolean ok = x > 1; for(long i = 2; i * i <= x; i ++) { ok &= x % i != 0; if(!ok) return ok; } return ok; }
final boolean[] prime(int num) {
nonNegativeCheck(num);
boolean prime[] = new boolean[num];
fill(prime, true);
if(num > 0) prime[0] = false;
if(num > 1) prime[1] = false;
for(int i = 2; i < num; i ++) if(prime[i]) for(int j = 2; i * j < num; j ++) prime[i * j] = false;
return prime;
}
final PairIL[] countElements(int[] a, boolean sort) {
int len = a.length;
int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
final PairLL[] countElements(long[] a, boolean sort) {
int len = a.length;
long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
final PairIL[] countElements(String s, boolean sort) {
int len = s.length();
char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
long triangular(long n) { return n * (n + 1) / 2; }
long arctriangularfloor(long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
long arctriangularceil(long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
final int[] baseConvert(long x, int n, int len) { nonNegativeCheck(x); nonNegativeCheck(n); nonNegativeCheck(len); int digit[] = new int[len]; int i = 0; long tmp = x; while(tmp > 0 && i < len) { digit[i ++] = (int)(tmp % n); tmp /= n; } return digit; }
final int[] baseConvert(long x, int n) { nonNegativeCheck(x); nonNegativeCheck(n); long tmp = x; int len = 0; while(tmp > 0) { tmp /= n; len ++; } return baseConvert(x, n, len); }
final int[] baseConvert(int x, int n, int len) { nonNegativeCheck(x); nonNegativeCheck(n); nonNegativeCheck(len); int digit[] = new int[len]; int i = 0; int tmp = x; while(tmp > 0 && i < len) { digit[i ++] = (int)(tmp % n); tmp /= n; } return digit; }
final int[] baseConvert(int x, int n) { nonNegativeCheck(x); nonNegativeCheck(n); int tmp = x; int len = 0; while(tmp > 0) { tmp /= n; len ++; } return baseConvert(x, n, len); }
final long[] baseConvert(long x, long n, int len) { nonNegativeCheck(x); nonNegativeCheck(n); nonNegativeCheck(len); long digit[] = new long[len]; int i = 0; long tmp = x; while(tmp > 0 && i < len) { digit[i ++] = tmp % n; tmp /= n; } return digit; }
final long[] baseConvert(long x, long n) { nonNegativeCheck(x); nonNegativeCheck(n); long tmp = x; int len = 0; while(tmp > 0) { tmp /= n; len ++; } return baseConvert(x, n, len); }
final int numDigits(long a) { nonNegativeCheck(a); return Long.toString(a).length(); }
final long bitFlag(int a) { nonNegativeCheck(a); return 1L << (long)a; }
final boolean isFlagged(long x, int a) { nonNegativeCheck(x); nonNegativeCheck(a); return (x & bitFlag(a)) != 0; }
final long countString(String s, String a) { return (s.length() - s.replace(a, "").length()) / a.length(); }
final long countStringAll(String s, String a) { return s.length() - s.replaceAll(a, "").length(); }
final String reverse(String s) { return (new StringBuilder(s)).reverse().toString(); }
final String[] reverse(String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final int[] reverse(int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final long[] reverse(long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final double[] reverse(double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final char[] reverse(char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final boolean[] reverse(boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final <T> T[] reverse(T[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final void fill(int[] a, int x) { Arrays.fill(a, x); }
final void fill(long[] a, long x) { Arrays.fill(a, x); }
final void fill(double[] a, double x) { Arrays.fill(a, x); }
final void fill(char[] a, char x) { Arrays.fill(a, x); }
final void fill(boolean[] a, boolean x) { Arrays.fill(a, x); }
final void fill(int[][] a, int x) { for(int[] ele : a) fill(ele, x); }
final void fill(long[][] a, long x) { for(long[] ele : a) fill(ele, x); }
final void fill(double[][] a, double x) { for(double[] ele : a) fill(ele, x); }
final void fill(char[][] a, char x) { for(char[] ele : a) fill(ele, x); }
final void fill(boolean[][] a, boolean x) { for(boolean[] ele : a) fill(ele, x); }
final void fill(int[][][] a, int x) { for(int[][] ele : a) fill(ele, x); }
final void fill(long[][][] a, long x) { for(long[][] ele : a) fill(ele, x); }
final void fill(double[][][] a, double x) { for(double[][] ele : a) fill(ele, x); }
final void fill(char[][][] a, char x) { for(char[][] ele : a) fill(ele, x); }
final void fill(boolean[][][] a, boolean x) { for(boolean[][] ele : a) fill(ele, x); }
final int[] resize(int[] a, int m, int x) { nonNegativeCheck(m); int resized[] = new int[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final long[] resize(long[] a, int m, int x) { nonNegativeCheck(m); long resized[] = new long[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final double[] resize(double[] a, int m, int x) { nonNegativeCheck(m); double resized[] = new double[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final char[] resize(char[] a, int m, int x) { nonNegativeCheck(m); char resized[] = new char[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final boolean[] resize(boolean[] a, int m, int x) { nonNegativeCheck(m); boolean resized[] = new boolean[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final Object[] resize(Object[] a, int m, int x) { nonNegativeCheck(m); Object resized[] = new Object[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final int[] toIntArray(List<Integer> list) { int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
final long[] toLongArray(List<Long> list) { long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
final double[] toDoubleArray(List<Double> list) { double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
final char[] toCharArray(List<Character> list) { char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
final boolean[] toBooleanArray(List<Boolean> list) { boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
final String[] toStringArray(List<String> list) { String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
final <T> void toArray(List<T> list, T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
final void shuffleArray(int[] a) { for(int i = 0; i < a.length; i ++){ int tmp = a[i]; int idx = random(i, a.length); a[i] = a[idx]; a[idx] = tmp; } }
final void shuffleArray(long[] a) { for(int i = 0; i < a.length; i ++){ long tmp = a[i]; int idx = random(i, a.length); a[i] = a[idx]; a[idx] = tmp; } }
final void shuffleArray(double[] a) { for(int i = 0; i < a.length; i ++){ double tmp = a[i]; int idx = random(i, a.length); a[i] = a[idx]; a[idx] = tmp; } }
final int[] randomi(int n, int max) { nonNegativeCheck(n); int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
final long[] randoml(int n, long max) { nonNegativeCheck(n); long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
final double[] randomd(int n, double max) { nonNegativeCheck(n); double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
final int[] randomi(int n, int min, int max) { nonNegativeCheck(n); int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
final long[] randoml(int n, long min, long max) { nonNegativeCheck(n); long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
final double[] randomd(int n, double min, double max) { nonNegativeCheck(n); double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
final void swap(String[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(int[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(long[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(double[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(char[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(boolean[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final <T> void swap(T[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); T tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final int[][] rotate(int[][] a) {
int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final long[][] rotate(long[][] a) {
long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final double[][] rotate(double[][] a) {
double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final char[][] rotate(char[][] a) {
char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final boolean[][] rotate(boolean[][] a) {
boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final Object[][] rotate(Object[][] a) {
Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final int[] compress(int[] a) {
int n = a.length;
Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
final long[] compress(long[] a) {
int n = a.length;
Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
final double[] compress(double[] a) {
int n = a.length;
Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
final int lowerBound(int[] a, int key) { return BS(a, key, true, true, true); }
final int lowerBound(int[] a, int key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final int upperBound(int[] a, int key) { return BS(a, key, true, true, false); }
final int upperBound(int[] a, int key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final int cntBS(int[] a, int key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final int cntBS(int[] a, int key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final int binarySearch(int[] a, int key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final boolean isOKforBS(int[] a, int index, int key, boolean gt, boolean eq) { return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq); }
final int lowerBound(long[] a, long key) { return BS(a, key, true, true, true); }
final int lowerBound(long[] a, long key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final int upperBound(long[] a, long key) { return BS(a, key, true, true, false); }
final int upperBound(long[] a, long key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final int cntBS(long[] a, long key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final int cntBS(long[] a, long key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final int binarySearch(long[] a, long key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final boolean isOKforBS(long[] a, int index, long key, boolean gt, boolean eq) { return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq); }
final int lowerBound(double[] a, double key) { return BS(a, key, true, true, true); }
final int lowerBound(double[] a, double key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final int upperBound(double[] a, double key) { return BS(a, key, true, true, false); }
final int upperBound(double[] a, double key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final int cntBS(double[] a, double key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final int cntBS(double[] a, double key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final int binarySearch(double[] a, double key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final boolean isOKforBS(double[] a, int index, double key, boolean gt, boolean eq) { return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq); }
final <T extends Comparable<? super T>> int lowerBound(T[] a, T key) { return BS(a, key, true, true, true); }
final <T extends Comparable<? super T>> int lowerBound(T[] a, T key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final <T extends Comparable<? super T>> int upperBound(T[] a, T key) { return BS(a, key, true, true, false); }
final <T extends Comparable<? super T>> int upperBound(T[] a, T key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final <T extends Comparable<? super T>> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final <T extends Comparable<? super T>> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final <T extends Comparable<? super T>> int binarySearch(T[] a, T key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final <T extends Comparable<? super T>> boolean isOKforBS(T[] a, int index, T key, boolean gt, boolean eq) { int compare = a[index].compareTo(key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final <T> int lowerBound(T[] a, T key, Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
final <T> int lowerBound(T[] a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
final <T> int upperBound(T[] a, T key, Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
final <T> int upperBound(T[] a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
final <T> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
final <T> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok, Comparator<? super T> c) { int index = binarySearch(a, key, gt, eq, ng, ok, c); return cnt ? (int)abs(ok - index) : index; }
final <T> int binarySearch(T[] a, T key, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; } return ok; }
final <T> boolean isOKforBS(T[] a, int index, T key, boolean gt, boolean eq, Comparator<? super T> c) { int compare = c.compare(a[index], key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final <T extends Comparable<? super T>> int lowerBound(List<T> a, T key) { return BS(a, key, true, true, true); }
final <T extends Comparable<? super T>> int lowerBound(List<T> a, T key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final <T extends Comparable<? super T>> int upperBound(List<T> a, T key) { return BS(a, key, true, true, false); }
final <T extends Comparable<? super T>> int upperBound(List<T> a, T key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final <T extends Comparable<? super T>> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final <T extends Comparable<? super T>> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final <T extends Comparable<? super T>> int binarySearch(List<T> a, T key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final <T extends Comparable<? super T>> boolean isOKforBS(List<T> a, int index, T key, boolean gt, boolean eq) { int compare = a.get(index).compareTo(key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final <T> int lowerBound(List<T> a, T key, Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
final <T> int lowerBound(List<T> a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
final <T> int upperBound(List<T> a, T key, Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
final <T> int upperBound(List<T> a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
final <T> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
final <T> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok, Comparator<? super T> c) { int index = binarySearch(a, key, gt, eq, ng, ok, c); return cnt ? (int)abs(ok - index) : index; }
final <T> int binarySearch(List<T> a, T key, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; } return ok; }
final <T> boolean isOKforBS(List<T> a, int index, T key, boolean gt, boolean eq, Comparator<? super T> c) { int compare = c.compare(a.get(index), key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final PairLL binaryRangeSearch(long left, long right, UnaryOperator<Long> op, boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) / 2;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) / 2;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
final double ternarySearch(double left, double right, UnaryOperator<Double> op, boolean minimize, int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
Mod md = new Mod();
// class Mod107 extends Mod { Mod107() { super(1_000_000_007); } } Mod107 md = new Mod107();
// class Mod998 extends Mod { Mod998() { super(998244353); } } Mod998 md = new Mod998();
class Mod {
final long MOD = 1_000_000_007; Mod() { MH = 0; ML = 0; IS_MOD_CONST = true; }
// final long MOD = 998244353; Mod() { MH = 0; ML = 0; IS_MOD_CONST = true; }
// final long MOD; Mod(long mod) { MOD = mod; IS_MOD_CONST = false; long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
static final long MASK = 0xffff_ffffl;
final long MH;
final long ML;
final boolean IS_MOD_CONST;
final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return IS_MOD_CONST ? ((x %= MOD) < 0 ? x + MOD : x) : reduce(x);
}
final long[] mod(long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
final long[][] mod(long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
final long[][][] mod(long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
final long add(long x, long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
final long sum(long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
final long sub(long x, long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return IS_MOD_CONST ? (x * y) % MOD : reduce(x * y);
x = mod(x);
y = mod(y);
return IS_MOD_CONST ? (x * y) % MOD : reduce(x * y);
}
final long mul(long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
final long div(long x, long y) { return mul(x, inv(y)); }
final long[] pows(long x, int max) {
x = mod(x);
long pow[] = new long[max + 1];
pow[0] = 1;
for(int i = 0; i < max; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
final long fact(int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
final long invFact(int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
static final int MAX_INV_SIZE = 100_100;
final Map<Long, Long> invMap = new HashMap<>();
final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
final long calInv(long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
final long[] invs(int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
static final int MAX_FACT1 = 5_000_100;
static final int MAX_FACT2 = 500_100;
static final int MAX_FACT_MAP_SIZE = 100;
long fact[];
long invFact[];
boolean isFactPrepared = false;
final Map<Long, long[]> factMap = new HashMap<>();
final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
final long P(long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
final long C(long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
final long H(long n, long r) { return C(n - 1 + r, r); }
final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
final long mod(long x, long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
final long pow(long x, long y, long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
class Grids {
int h, w;
Grid[][] gs;
Grid[] gi;
Grids(int h, int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
void init(boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
void init(long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
Grid get(int x, int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
Grid get(int i) { return get(i / w, i % w); }
int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
Grid next(int x, int y, int i) { return next(gs[x][y], i); }
Grid next(Grid g, int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
class Grid implements Comparable<Grid> {
int x, y, h, w, i; boolean b; long val;
Grid() { }
Grid(int x, int y, int h, int w) { init(x, y, h, w, false, 0); }
Grid(int x, int y, int h, int w, boolean b) { init(x, y, h, w, b, 0); }
Grid(int x, int y, int h, int w, long val) { init(x, y, h, w, false, val); }
Grid(int x, int y, int h, int w, boolean b, long val) { init(x, y, h, w, b, val); }
void init(int x, int y, int h, int w, boolean b, long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public String toString() { return "("+x+", "+y+")"+" "+booleanToString(b)+" "+val; }
@Override public int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public int compareTo(Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
final boolean isValid(int x, int y, int h, int w) { return x >= 0 && x < h && y >= 0 && y < w; }
final boolean isValid(Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
class Graph {
int numNode, numEdge;
boolean directed;
List<Edge> edges = new ArrayList<>();
Node nodes[];
Node reversedNodes[];
Graph(int numNode, int numEdge, boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
void init(List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
void add(int source, int target, long cost) { add(new Edge(source, target, cost)); }
void add(Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
class Node extends ArrayList<Edge> {
int id;
Node(int id) { this.id = id; }
void add(int target, long cost) { add(new Edge(id, target, cost)); }
}
class Edge implements Comparable<Edge> {
int source; int target; long cost;
Edge(int source, int target, long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public String toString() { return source+" - "+cost+" -> "+target; }
@Override public int hashCode() { return Objects.hash(source, target); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public int compareTo(Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
T a; U b;
Pair() { }
Pair(T a, U b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public int compareTo(Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
final PairII npii() { return new PairII(ni(), ni()); }
final PairII[] npii(int n) { PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
final PairII[][] npii(int n, int m) { PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
class PairII implements Comparable<PairII> {
int a; int b;
PairII() { }
PairII(int a, int b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
final PairIL npil() { return new PairIL(ni(), nl()); }
final PairIL[] npil(int n) { PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
final PairIL[][] npil(int n, int m) { PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
class PairIL implements Comparable<PairIL> {
int a; long b;
PairIL() { }
PairIL(int a, long b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
final PairID npid() { return new PairID(ni(), nd()); }
final PairID[] npid(int n) { PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
final PairID[][] npid(int n, int m) { PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
class PairID implements Comparable<PairID> {
int a; double b;
PairID() { }
PairID(int a, double b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
final PairLI npli() { return new PairLI(nl(), ni()); }
final PairLI[] npli(int n) { PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
final PairLI[][] npli(int n, int m) { PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
class PairLI implements Comparable<PairLI> {
long a; int b;
PairLI() { }
PairLI(long a, int b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
final PairLL npll() { return new PairLL(nl(), nl()); }
final PairLL[] npll(int n) { PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
final PairLL[][] npll(int n, int m) { PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
class PairLL implements Comparable<PairLL> {
long a; long b;
PairLL() { }
PairLL(long a, long b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
final PairLD npld() { return new PairLD(nl(), nd()); }
final PairLD[] npld(int n) { PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
final PairLD[][] npld(int n, int m) { PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
class PairLD implements Comparable<PairLD> {
long a; double b;
PairLD() { }
PairLD(long a, double b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
final PairDI npdi() { return new PairDI(nd(), ni()); }
final PairDI[] npdi(int n) { PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
final PairDI[][] npdi(int n, int m) { PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
class PairDI implements Comparable<PairDI> {
double a; int b;
PairDI() { }
PairDI(double a, int b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
final PairDL npdl() { return new PairDL(nd(), nl()); }
final PairDL[] npdl(int n) { PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
final PairDL[][] npdl(int n, int m) { PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
class PairDL implements Comparable<PairDL> {
double a; long b;
PairDL() { }
PairDL(double a, long b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
final PairDD npdd() { return new PairDD(nd(), nd()); }
final PairDD[] npdd(int n) { PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
final PairDD[][] npdd(int n, int m) { PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
class PairDD implements Comparable<PairDD> {
double a; double b;
PairDD() { }
PairDD(double a, double b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
T t; V a;
BasicTuple() { }
StringBuilder sbTuple = new StringBuilder();
public StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public int hashCode() { return Objects.hash(t, a); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
V a;
UniqueTuple() { }
final StringBuilder sbTuple = new StringBuilder();
public StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public int hashCode() { return Objects.hash(a); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
Tuple1() { super(); }
Tuple1(T0 a0) { super(); this.a = a0; }
T0 get0() { return a; }
void set0(T0 x) { a = x; }
}
class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
Tuple2() { super(); }
@SuppressWarnings("unchecked") Tuple2(T0 a0, T1 a1) { super(); this.t = new Tuple1(a0); this.a = a1; }
T0 get0() { return t.get0(); }
T1 get1() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { a = x; }
}
class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
Tuple3() { super(); }
@SuppressWarnings("unchecked") Tuple3(T0 a0, T1 a1, T2 a2) { super(); this.t = new Tuple2(a0, a1); this.a = a2; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { a = x; }
}
class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
Tuple4() { super(); }
@SuppressWarnings("unchecked") Tuple4(T0 a0, T1 a1, T2 a2, T3 a3) { super(); this.t = new Tuple3(a0, a1, a2); this.a = a3; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { a = x; }
}
class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
Tuple5() { super(); }
@SuppressWarnings("unchecked") Tuple5(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4) { super(); this.t = new Tuple4(a0, a1, a2, a3); this.a = a4; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { a = x; }
}
class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
Tuple6() { super(); }
@SuppressWarnings("unchecked")
Tuple6(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) { super(); this.t = new Tuple5(a0, a1, a2, a3, a4); this.a = a5; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return t.get4(); }
T5 get5() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { t.set4(x); }
void set5(T5 x) { a = x; }
}
class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
Tuple7() { super(); }
@SuppressWarnings("unchecked")
Tuple7(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) { super(); this.t = new Tuple6(a0, a1, a2, a3, a4, a5); this.a = a6; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return t.get4(); }
T5 get5() { return t.get5(); }
T6 get6() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { t.set4(x); }
void set5(T5 x) { t.set5(x); }
void set6(T6 x) { a = x; }
}
class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
Tuple8() { super(); }
@SuppressWarnings("unchecked")
Tuple8(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7) { super(); this.t = new Tuple7(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return t.get4(); }
T5 get5() { return t.get5(); }
T6 get6() { return t.get6(); }
T7 get7() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { t.set4(x); }
void set5(T5 x) { t.set5(x); }
void set6(T6 x) { t.set6(x); }
void set7(T7 x) { a = x; }
}
class TupleIII implements Comparable<TupleIII> {
int a; int b; int c;
TupleIII() { }
TupleIII(int a, int b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleIIL implements Comparable<TupleIIL> {
int a; int b; long c;
TupleIIL() { }
TupleIIL(int a, int b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
class TupleIID implements Comparable<TupleIID> {
int a; int b; double c;
TupleIID() { }
TupleIID(int a, int b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleILI implements Comparable<TupleILI> {
int a; long b; int c;
TupleILI() { }
TupleILI(int a, long b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleILL implements Comparable<TupleILL> {
int a; long b; long c;
TupleILL() { }
TupleILL(int a, long b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleILD implements Comparable<TupleILD> {
int a; long b; double c;
TupleILD() { }
TupleILD(int a, long b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleIDI implements Comparable<TupleIDI> {
int a; double b; int c;
TupleIDI() { }
TupleIDI(int a, double b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override
public int compareTo(TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleIDL implements Comparable<TupleIDL> {
int a; double b; long c;
TupleIDL() { }
TupleIDL(int a, double b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleIDD implements Comparable<TupleIDD> {
int a; double b; double c;
TupleIDD() { }
TupleIDD(int a, double b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleLII implements Comparable<TupleLII> {
long a; int b; int c;
TupleLII() { }
TupleLII(long a, int b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleLIL implements Comparable<TupleLIL> {
long a; int b; long c;
TupleLIL() { }
TupleLIL(long a, int b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleLID implements Comparable<TupleLID> {
long a; int b; double c;
TupleLID() { }
TupleLID(long a, int b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleLLI implements Comparable<TupleLLI> {
long a; long b; int c;
TupleLLI() { }
TupleLLI(long a, long b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleLLL implements Comparable<TupleLLL> {
long a; long b; long c;
TupleLLL() { }
TupleLLL(long a, long b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleLLD implements Comparable<TupleLLD> {
long a; long b; double c;
TupleLLD() { }
TupleLLD(long a, long b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleLDI implements Comparable<TupleLDI> {
long a; double b; int c;
TupleLDI() { }
TupleLDI(long a, double b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleLDL implements Comparable<TupleLDL> {
long a; double b; long c;
TupleLDL() { }
TupleLDL(long a, double b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleLDD implements Comparable<TupleLDD> {
long a; double b; double c;
TupleLDD() { }
TupleLDD(long a, double b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleDII implements Comparable<TupleDII> {
double a; int b; int c;
TupleDII() { }
TupleDII(double a, int b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleDIL implements Comparable<TupleDIL> {
double a; int b; long c;
TupleDIL() { }
TupleDIL(double a, int b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleDID implements Comparable<TupleDID> {
double a; int b; double c;
TupleDID() { }
TupleDID(double a, int b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleDLI implements Comparable<TupleDLI> {
double a; long b; int c;
TupleDLI() { }
TupleDLI(double a, long b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleDLL implements Comparable<TupleDLL> {
double a; long b; long c;
TupleDLL() { }
TupleDLL(double a, long b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleDLD implements Comparable<TupleDLD> {
double a; long b; double c;
TupleDLD() { }
TupleDLD(double a, long b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleDDI implements Comparable<TupleDDI> {
double a; double b; int c;
TupleDDI() { }
TupleDDI(double a, double b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleDDL implements Comparable<TupleDDL> {
double a; double b; long c;
TupleDDL() { }
TupleDDL(double a, double b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleDDD implements Comparable<TupleDDD> {
double a; double b; double c;
TupleDDD() { }
TupleDDD(double a, double b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
int n = ni();
int a[] = ni(n);
int b[] = ni(n);
int bucket[] = new int[5010];
for(int i = 0; i < n; i ++) bucket[a[i]] ++;
for(int i = 0; i < n; i ++) bucket[b[i]] --;
boolean ok = true;
for(int i = 0; i < bucket.length; i ++) ok &= bucket[i] == 0;
if(!ok) { reply(ok); return; }
for(int i = 0; i < n; i ++) bucket[a[i]] ++;
if(max(bucket) > 1) { reply(ok); return; }
long sum = 0;
int idx[] = new int[5010];
for(int i = 0; i < n; i ++) idx[b[i]] = i;
FenwickTree ft = new FenwickTree(n);
for(int i = 0; i < n; i ++) { sum += ft.sum(idx[a[i]]); ft.add(idx[a[i]], 1); }
reply(sum % 2 == 0);
}
class FenwickTree { // N=size
int size;
long nodes[];
FenwickTree(int size) { init(size); } // O(N)
FenwickTree(int size, long[] array) { init(size); for(int i = 0; i < size; i ++) add(i, array[i]); }// O(NlogN)
void init(int size) {
nonNegativeCheck(size);
this.size = size;
nodes = new long[size];
fill(nodes, 0);
}
void add(int a, long x) { // O(logN)
rangeCheck(a, size);
a ++;
while(a <= size) {
nodes[a - 1] += x;
a += a & -a;
}
}
long sum(int r) { // return sum of [0, r) // O(logN)
inclusiveRangeCheck(r, size);
long sum = 0;
while(r > 0) {
sum += nodes[r - 1];
r -= r & -r;
}
return sum;
}
long sum(int l, int r) { // return sum of [l, r) // O(logN)
inclusiveRangeCheck(l, size);
inclusiveRangeCheck(r, size);
if(l > r) return 0;
else return sum(r) - sum(l);
}
}
}
}
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
static boolean DEBUG;
public static void main(String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int pointer = 0;
private int buflen = 0;
private boolean hasNextByte() {
if(pointer < buflen) return true;
else {
pointer = 0;
try { buflen = in.read(buffer);
}catch (IOException e) { e.printStackTrace(); }
return buflen > 0;
}
}
private int readByte() { if(hasNextByte()) return buffer[pointer ++]; else return -1; }
private boolean isPrintableChar(int c) { return isPrintableChar(c, false); }
private boolean isPrintableChar(int c, boolean includingSpace) { return (includingSpace ? 32 : 33) <= c && c <= 126; }
private void skipUnprintable() { skipUnprintable(false); }
private void skipUnprintable(boolean includingSpace) { while(hasNextByte() && !isPrintableChar(buffer[pointer], includingSpace)) pointer ++; }
private boolean hasNext() { return hasNext(false); }
private boolean hasNext(boolean includingSpace) { skipUnprintable(includingSpace); return hasNextByte(); }
private StringBuilder sb = new StringBuilder();
public String next() { return next(false); }
public String next(boolean includingSpace) {
if(!hasNext(includingSpace)) throw new NoSuchElementException();
sb.setLength(0);
int b = readByte();
while(isPrintableChar(b, includingSpace)) { sb.appendCodePoint(b); b = readByte(); }
return sb.toString();
}
public long nextLong() {
if(!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if(b == '-') { minus = true; b = readByte(); }
if(b < '0' || '9' < b) throw new NumberFormatException();
while(true) {
if('0' <= b && b <= '9') n = n * 10 + b - '0';
else if(b == -1 || !isPrintableChar(b)) return minus ? - n : n;
else throw new NumberFormatException();
b = readByte();
}
}
}
static class Solver {
final FastScanner sc = new FastScanner();
public Solver() { }
final String ns() { return ns(false); }
final String ns(boolean includingSpace) { return sc.next(includingSpace); }
final String[] ns(int n) { return ns(n, false); }
final String[] ns(int n, boolean includingSpace) { String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(includingSpace); return a; }
final String[][] ns(int n, int m) { return ns(n, m, false); }
final String[][] ns(int n, int m, boolean includingSpace) { String a[][] = new String[n][m]; for(int i = 0; i < n; i ++) a[i] = ns(m, includingSpace); return a; }
final char nc() { return ns().charAt(0); }
final char[] nc(int n) {
String str = ns();
if(n < 0) n = str.length();
char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
final char[][] nc(int n, int m) { char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
final boolean[] nb(int n, char t) {
char c[] = nc(-1);
if(n < 0) n = c.length;
boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
final boolean[][] nb(int n, int m, char t) { boolean a[][] = new boolean[n][m]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
final int ni() { return Math.toIntExact(sc.nextLong()); }
final int[] ni(int n) { int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
final int[][] ni(int n, int m) { int a[][] = new int[n][m]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
final long nl() { return sc.nextLong(); }
final long[] nl(int n) { long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
final long[][] nl(int n, int m) { long a[][] = new long[n][m]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
final double nd() { return Double.parseDouble(sc.next()); }
final double[] nd(int n) { double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
final double[][] nd(int n, int m) { double a[][] = new double[n][m]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
final String booleanToString(boolean b) { return b ? "#" : "."; }
final PrintWriter out = new PrintWriter(System.out);
final PrintWriter err = new PrintWriter(System.err);
final StringBuilder sb4prtln = new StringBuilder();
final void prt() { out.print(""); }
final <T> void prt(T a) { out.print(a); }
final void prtln() { out.println(""); }
final <T> void prtln(T a) { out.println(a); }
final void prtln(int... a) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(long... a) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(double... a) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(String... a) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } if(sb4prtln.length() != 0) sb4prtln.deleteCharAt(sb4prtln.length() - 1); prtln(sb4prtln); }
final void prtln(char... a) { sb4prtln.setLength(0); for(char ele : a) sb4prtln.append(ele); prtln(sb4prtln); }
final void prtln(boolean... a) { sb4prtln.setLength(0); for(boolean ele : a) sb4prtln.append(booleanToString(ele)); prtln(sb4prtln); }
final void prtlns(int... a) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(long... a) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(double... a) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(String... a) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(char... a) { sb4prtln.setLength(0); for(char ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtlns(boolean... a) { sb4prtln.setLength(0); for(boolean ele : a) { sb4prtln.append(booleanToString(ele)); sb4prtln.append("\n"); } prt(sb4prtln); }
final void prtln(int[][] a) { for(int[] ele : a) prtln(ele); }
final void prtln(long[][] a) { for(long[] ele : a) prtln(ele); }
final void prtln(double[][] a) { for(double[] ele : a) prtln(ele); }
final void prtln(String[][] a) { for(String[] ele : a) prtln(ele); }
final void prtln(char[][] a) { for(char[] ele : a) prtln(ele); }
final void prtln(boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
final String errconvert(int a) { return isINF(a) ? "_" : String.valueOf(a); }
final String errconvert(long a) { return isINF(a) ? "_" : String.valueOf(a); }
final void errprt(int a) { if(DEBUG) err.print(errconvert(a)); }
final void errprt(long a) { if(DEBUG) err.print(errconvert(a)); }
final void errprt() { if(DEBUG) err.print(""); }
final <T> void errprt(T a) { if(DEBUG) err.print(a); }
final void errprt(boolean a) { if(DEBUG) errprt(booleanToString(a)); }
final void errprtln() { if(DEBUG) err.println(""); }
final void errprtln(int a) { if(DEBUG) err.println(errconvert(a)); }
final void errprtln(long a) { if(DEBUG) err.println(errconvert(a)); }
final <T> void errprtln(T a) { if(DEBUG) err.println(a); }
final void errprtln(boolean a) { if(DEBUG) errprtln(booleanToString(a)); }
final void errprtln(int... a) { if(DEBUG) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(long... a) { if(DEBUG) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(double... a) { if(DEBUG) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(String... a) { if(DEBUG) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append(" "); } errprtln(sb4prtln.toString().trim()); } }
final void errprtln(char... a) { if(DEBUG) { sb4prtln.setLength(0); for(char ele : a) sb4prtln.append(ele); errprtln(sb4prtln.toString()); } }
final void errprtln(boolean... a) { if(DEBUG) { sb4prtln.setLength(0); for(boolean ele : a) sb4prtln.append(booleanToString(ele)); errprtln(sb4prtln.toString()); } }
final void errprtlns(int... a) { if(DEBUG) { sb4prtln.setLength(0); for(int ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(long... a) { if(DEBUG) { sb4prtln.setLength(0); for(long ele : a) { sb4prtln.append(errconvert(ele)); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(double... a) { if(DEBUG) { sb4prtln.setLength(0); for(double ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(String... a) { if(DEBUG) { sb4prtln.setLength(0); for(String ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(char... a) { if(DEBUG) { sb4prtln.setLength(0); for(char ele : a) { sb4prtln.append(ele); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtlns(boolean... a) { if(DEBUG) { sb4prtln.setLength(0); for(boolean ele : a) { sb4prtln.append(booleanToString(ele)); sb4prtln.append("\n"); } errprt(sb4prtln.toString()); } }
final void errprtln(Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
final void errprtln(int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
final void errprtln(long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
final void errprtln(double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
final void errprtln(String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
final void errprtln(char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
final void errprtln(boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
final void errprtln(Object[][] a) { if(DEBUG) for(Object ele : a) { errprtln(ele); errprtln(); } }
final void reply(boolean b) { prtln(b ? "Yes" : "No"); }
final void REPLY(boolean b) { prtln(b ? "YES" : "NO"); }
final void flush() { out.flush(); if(DEBUG) err.flush(); }
final void assertion(boolean b) { if(!b) { flush(); throw new AssertionError(); } }
final <T> void assertion(boolean b, T a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void assertion(boolean b, boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
final void inclusiveRangeCheck(int i, int max) { inclusiveRangeCheck(i, 0, max); }
final void inclusiveRangeCheck(int i, int min, int max) { rangeCheck(i, min, max + 1); }
final void inclusiveRangeCheck(long i, long max) { inclusiveRangeCheck(i, 0, max); }
final void inclusiveRangeCheck(long i, long min, long max) { rangeCheck(i, min, max + 1); }
final void rangeCheck(int i, int max) { rangeCheck(i, 0, max); }
final void rangeCheck(int i, int min, int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
final void rangeCheck(long i, long max) { rangeCheck(i, 0, max); }
final void rangeCheck(long i, long min, long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
final void nonNegativeCheck(long x) { nonNegativeCheck(x, "the argument"); }
final void nonNegativeCheck(long x, String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
final void positiveCheck(long x) { positiveCheck(x, "the argument"); }
final void positiveCheck(long x, String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
final void exit() { flush(); System.exit(0); }
final <T> void exit(T a) { prtln(a); exit(); }
final void exit(int... a) { prtln(a); exit(); }
final void exit(long... a) { prtln(a); exit(); }
final void exit(double... a) { prtln(a); exit(); }
final void exit(String... a) { prtln(a); exit(); }
final void exit(char... a) { prtln(a); exit(); }
final void exit(boolean... a) { prtln(a); exit(); }
final void exit(int[][] a) { prtln(a); exit(); }
final void exit(long[][] a) { prtln(a); exit(); }
final void exit(double[][] a) { prtln(a); exit(); }
final void exit(String[][] a) { prtln(a); exit(); }
final void exit(char[][] a) { prtln(a); exit(); }
final void exit(boolean[][] a) { prtln(a); exit(); }
final long INF = (long)1e18 + 7;
final boolean isPlusINF(long a) { return a > INF / 10; }
final boolean isMinusINF(long a) { return isPlusINF(- a); }
final boolean isINF(long a) { return isPlusINF(a) || isMinusINF(a); }
final int I_INF = (int)1e9 + 7;
final boolean isPlusINF(int a) { return a > I_INF / 10; }
final boolean isMinusINF(int a) { return isPlusINF(- a); }
final boolean isINF(int a) { return isPlusINF(a) || isMinusINF(a); }
final int min(int a, int b) { return Math.min(a, b); }
final long min(long a, long b) { return Math.min(a, b); }
final double min(double a, double b) { return Math.min(a, b); }
final <T extends Comparable<T>> T min(T a, T b) { return a.compareTo(b) <= 0 ? a : b; }
final int min(int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
final long min(long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
final double min(double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
final int max(int a, int b) { return Math.max(a, b); }
final long max(long a, long b) { return Math.max(a, b); }
final double max(double a, double b) { return Math.max(a, b); }
final <T extends Comparable<T>> T max(T a, T b) { return a.compareTo(b) >= 0 ? a : b; }
final int max(int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
final long max(long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
final double max(double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
final <T extends Comparable<T>> T max(T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
final int max(int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
final long max(long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
final double max(double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
final <T extends Comparable<T>> T max(T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
final long sum(int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
final long sum(long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
final double sum(double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
final long sum(boolean... a) { long sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
final long[] sums(int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
final long[] sums(long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
final double[] sums(double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
final long[] sums(boolean[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
final long[][] sums(int[][] a) {
long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
final long[][] sums(long[][] a) {
long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
final double[][] sums(double[][] a) {
double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
final long[][] sums(boolean[][] a) {
long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
final int constrain(int x, int l, int r) { return min(max(x, min(l, r)), max(l, r)); }
final long constrain(long x, long l, long r) { return min(max(x, min(l, r)), max(l, r)); }
final double constrain(double x, double l, double r) { return min(max(x, min(l, r)), max(l, r)); }
final int abs(int x) { return x >= 0 ? x : - x; }
final long abs(long x) { return x >= 0 ? x : - x; }
final double abs(double x) { return x >= 0 ? x : - x; }
final int signum(int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
final int signum(long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
final int signum(double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
final long round(double x) { return Math.round(x); }
final long floor(double x) { return round(Math.floor(x)); }
final int divfloor(int a, int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
final long divfloor(long a, long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
final long ceil(double x) { return round(Math.ceil(x)); }
final int divceil(int a, int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
final long divceil(long a, long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
final boolean mulGreater(long a, long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
final boolean mulGreaterEquals(long a, long b, long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
final boolean mulLess(long a, long b, long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
final boolean mulLessEquals(long a, long b, long c) { return !mulGreater(a, b, c); } // a * b <= c
final double sqrt(int x) { return Math.sqrt((double)x); }
final double sqrt(long x) { return Math.sqrt((double)x); }
final double sqrt(double x) { return Math.sqrt(x); }
final int floorsqrt(int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
final long floorsqrt(long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
final int ceilsqrt(int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
final long ceilsqrt(long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
final long fact(int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
final long naiveP(long n, long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
final long naiveC(long n, long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
final double pow(double x, double y) { return Math.pow(x, y); }
final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
final long lcm(long a, long b) { return a / gcd(a, b) * b; }
final int gcd(int... a) { int gcd = 0; for(int i = 0; i < a.length; i ++) gcd = gcd(gcd, a[i]); return gcd; }
final long gcd(long... a) { long gcd = 0; for(int i = 0; i < a.length; i ++) gcd = gcd(gcd, a[i]); return gcd; }
final double random() { return Math.random(); }
final int random(int max) { return (int)floor(random() * max); }
final long random(long max) { return floor(random() * max); }
final double random(double max) { return random() * max; }
final int random(int min, int max) { return random(max - min) + min; }
final long random(long min, long max) { return random(max - min) + min; }
final double random(double min, double max) { return random(max - min) + min; }
final boolean isUpper(char a) { return a >= 'A' && a <= 'Z'; }
final boolean isLower(char a) { return a >= 'a' && a <= 'z'; }
final int upperToInt(char a) { return a - 'A'; }
final int lowerToInt(char a) { return a - 'a'; }
final int numToInt(char a) { return a - '0'; }
final int charToInt(char a) { return isLower(a) ? lowerToInt(a) : isUpper(a) ? upperToInt(a) : numToInt(a); }
final int alphabetToInt(char a) { return isLower(a) ? lowerToInt(a) : isUpper(a) ? upperToInt(a) + 26 : 52; }
final char intToUpper(int a) { return (char)(a + 'A'); }
final char intToLower(int a) { return (char)(a + 'a'); }
final char intToNum(int a) { return (char)(a + '0'); }
final int[] charToInt(char[] a) { int array[] = new int[a.length]; for(int i = 0; i < a.length; i ++) array[i] = charToInt(a[i]); return array; }
final long[] div(long a) {
nonNegativeCheck(a);
List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= a; i ++) if(a % i == 0) { divList.add(i); if(i * i != a) divList.add(a / i); }
long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
final PairLL[] factor(long a) {
nonNegativeCheck(a);
List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= a; i ++) {
if(a % i == 0) {
long cnt = 0;
while(a % i == 0) { a /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(a > 1) factorList.add(new PairLL(a, 1));
PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
final boolean isPrime(long x) { boolean ok = x > 1; for(long i = 2; i * i <= x; i ++) { ok &= x % i != 0; if(!ok) return ok; } return ok; }
final boolean[] prime(int num) {
nonNegativeCheck(num);
boolean prime[] = new boolean[num];
fill(prime, true);
if(num > 0) prime[0] = false;
if(num > 1) prime[1] = false;
for(int i = 2; i < num; i ++) if(prime[i]) for(int j = 2; i * j < num; j ++) prime[i * j] = false;
return prime;
}
final PairIL[] countElements(int[] a, boolean sort) {
int len = a.length;
int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
final PairLL[] countElements(long[] a, boolean sort) {
int len = a.length;
long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
final PairIL[] countElements(String s, boolean sort) {
int len = s.length();
char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
long triangular(long n) { return n * (n + 1) / 2; }
long arctriangularfloor(long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
long arctriangularceil(long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
final int[] baseConvert(long x, int n, int len) { nonNegativeCheck(x); nonNegativeCheck(n); nonNegativeCheck(len); int digit[] = new int[len]; int i = 0; long tmp = x; while(tmp > 0 && i < len) { digit[i ++] = (int)(tmp % n); tmp /= n; } return digit; }
final int[] baseConvert(long x, int n) { nonNegativeCheck(x); nonNegativeCheck(n); long tmp = x; int len = 0; while(tmp > 0) { tmp /= n; len ++; } return baseConvert(x, n, len); }
final int[] baseConvert(int x, int n, int len) { nonNegativeCheck(x); nonNegativeCheck(n); nonNegativeCheck(len); int digit[] = new int[len]; int i = 0; int tmp = x; while(tmp > 0 && i < len) { digit[i ++] = (int)(tmp % n); tmp /= n; } return digit; }
final int[] baseConvert(int x, int n) { nonNegativeCheck(x); nonNegativeCheck(n); int tmp = x; int len = 0; while(tmp > 0) { tmp /= n; len ++; } return baseConvert(x, n, len); }
final long[] baseConvert(long x, long n, int len) { nonNegativeCheck(x); nonNegativeCheck(n); nonNegativeCheck(len); long digit[] = new long[len]; int i = 0; long tmp = x; while(tmp > 0 && i < len) { digit[i ++] = tmp % n; tmp /= n; } return digit; }
final long[] baseConvert(long x, long n) { nonNegativeCheck(x); nonNegativeCheck(n); long tmp = x; int len = 0; while(tmp > 0) { tmp /= n; len ++; } return baseConvert(x, n, len); }
final int numDigits(long a) { nonNegativeCheck(a); return Long.toString(a).length(); }
final long bitFlag(int a) { nonNegativeCheck(a); return 1L << (long)a; }
final boolean isFlagged(long x, int a) { nonNegativeCheck(x); nonNegativeCheck(a); return (x & bitFlag(a)) != 0; }
final long countString(String s, String a) { return (s.length() - s.replace(a, "").length()) / a.length(); }
final long countStringAll(String s, String a) { return s.length() - s.replaceAll(a, "").length(); }
final String reverse(String s) { return (new StringBuilder(s)).reverse().toString(); }
final String[] reverse(String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final int[] reverse(int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final long[] reverse(long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final double[] reverse(double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final char[] reverse(char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final boolean[] reverse(boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final <T> T[] reverse(T[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
final void fill(int[] a, int x) { Arrays.fill(a, x); }
final void fill(long[] a, long x) { Arrays.fill(a, x); }
final void fill(double[] a, double x) { Arrays.fill(a, x); }
final void fill(char[] a, char x) { Arrays.fill(a, x); }
final void fill(boolean[] a, boolean x) { Arrays.fill(a, x); }
final void fill(int[][] a, int x) { for(int[] ele : a) fill(ele, x); }
final void fill(long[][] a, long x) { for(long[] ele : a) fill(ele, x); }
final void fill(double[][] a, double x) { for(double[] ele : a) fill(ele, x); }
final void fill(char[][] a, char x) { for(char[] ele : a) fill(ele, x); }
final void fill(boolean[][] a, boolean x) { for(boolean[] ele : a) fill(ele, x); }
final void fill(int[][][] a, int x) { for(int[][] ele : a) fill(ele, x); }
final void fill(long[][][] a, long x) { for(long[][] ele : a) fill(ele, x); }
final void fill(double[][][] a, double x) { for(double[][] ele : a) fill(ele, x); }
final void fill(char[][][] a, char x) { for(char[][] ele : a) fill(ele, x); }
final void fill(boolean[][][] a, boolean x) { for(boolean[][] ele : a) fill(ele, x); }
final int[] resize(int[] a, int m, int x) { nonNegativeCheck(m); int resized[] = new int[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final long[] resize(long[] a, int m, int x) { nonNegativeCheck(m); long resized[] = new long[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final double[] resize(double[] a, int m, int x) { nonNegativeCheck(m); double resized[] = new double[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final char[] resize(char[] a, int m, int x) { nonNegativeCheck(m); char resized[] = new char[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final boolean[] resize(boolean[] a, int m, int x) { nonNegativeCheck(m); boolean resized[] = new boolean[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final Object[] resize(Object[] a, int m, int x) { nonNegativeCheck(m); Object resized[] = new Object[m]; for(int i = max(0, - x); i < a.length && i + x < m; i ++) resized[i + x] = a[i]; return resized; }
final int[] toIntArray(List<Integer> list) { int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
final long[] toLongArray(List<Long> list) { long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
final double[] toDoubleArray(List<Double> list) { double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
final char[] toCharArray(List<Character> list) { char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
final boolean[] toBooleanArray(List<Boolean> list) { boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
final String[] toStringArray(List<String> list) { String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
final <T> void toArray(List<T> list, T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
final void shuffleArray(int[] a) { for(int i = 0; i < a.length; i ++){ int tmp = a[i]; int idx = random(i, a.length); a[i] = a[idx]; a[idx] = tmp; } }
final void shuffleArray(long[] a) { for(int i = 0; i < a.length; i ++){ long tmp = a[i]; int idx = random(i, a.length); a[i] = a[idx]; a[idx] = tmp; } }
final void shuffleArray(double[] a) { for(int i = 0; i < a.length; i ++){ double tmp = a[i]; int idx = random(i, a.length); a[i] = a[idx]; a[idx] = tmp; } }
final int[] randomi(int n, int max) { nonNegativeCheck(n); int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
final long[] randoml(int n, long max) { nonNegativeCheck(n); long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
final double[] randomd(int n, double max) { nonNegativeCheck(n); double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
final int[] randomi(int n, int min, int max) { nonNegativeCheck(n); int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
final long[] randoml(int n, long min, long max) { nonNegativeCheck(n); long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
final double[] randomd(int n, double min, double max) { nonNegativeCheck(n); double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
final void swap(String[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(int[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(long[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(double[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(char[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final void swap(boolean[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final <T> void swap(T[] a, int i, int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); T tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
final int[][] rotate(int[][] a) {
int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final long[][] rotate(long[][] a) {
long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final double[][] rotate(double[][] a) {
double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final char[][] rotate(char[][] a) {
char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final boolean[][] rotate(boolean[][] a) {
boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final Object[][] rotate(Object[][] a) {
Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
final int[] compress(int[] a) {
int n = a.length;
Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
final long[] compress(long[] a) {
int n = a.length;
Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
final double[] compress(double[] a) {
int n = a.length;
Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
final int lowerBound(int[] a, int key) { return BS(a, key, true, true, true); }
final int lowerBound(int[] a, int key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final int upperBound(int[] a, int key) { return BS(a, key, true, true, false); }
final int upperBound(int[] a, int key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final int cntBS(int[] a, int key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final int cntBS(int[] a, int key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final int BS(int[] a, int key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final int binarySearch(int[] a, int key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final boolean isOKforBS(int[] a, int index, int key, boolean gt, boolean eq) { return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq); }
final int lowerBound(long[] a, long key) { return BS(a, key, true, true, true); }
final int lowerBound(long[] a, long key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final int upperBound(long[] a, long key) { return BS(a, key, true, true, false); }
final int upperBound(long[] a, long key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final int cntBS(long[] a, long key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final int cntBS(long[] a, long key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final int BS(long[] a, long key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final int binarySearch(long[] a, long key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final boolean isOKforBS(long[] a, int index, long key, boolean gt, boolean eq) { return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq); }
final int lowerBound(double[] a, double key) { return BS(a, key, true, true, true); }
final int lowerBound(double[] a, double key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final int upperBound(double[] a, double key) { return BS(a, key, true, true, false); }
final int upperBound(double[] a, double key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final int cntBS(double[] a, double key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final int cntBS(double[] a, double key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final int BS(double[] a, double key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final int binarySearch(double[] a, double key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final boolean isOKforBS(double[] a, int index, double key, boolean gt, boolean eq) { return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq); }
final <T extends Comparable<? super T>> int lowerBound(T[] a, T key) { return BS(a, key, true, true, true); }
final <T extends Comparable<? super T>> int lowerBound(T[] a, T key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final <T extends Comparable<? super T>> int upperBound(T[] a, T key) { return BS(a, key, true, true, false); }
final <T extends Comparable<? super T>> int upperBound(T[] a, T key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final <T extends Comparable<? super T>> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final <T extends Comparable<? super T>> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
final <T extends Comparable<? super T>> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final <T extends Comparable<? super T>> int binarySearch(T[] a, T key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final <T extends Comparable<? super T>> boolean isOKforBS(T[] a, int index, T key, boolean gt, boolean eq) { int compare = a[index].compareTo(key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final <T> int lowerBound(T[] a, T key, Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
final <T> int lowerBound(T[] a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
final <T> int upperBound(T[] a, T key, Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
final <T> int upperBound(T[] a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
final <T> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
final <T> int cntBS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
final <T> int BS(T[] a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok, Comparator<? super T> c) { int index = binarySearch(a, key, gt, eq, ng, ok, c); return cnt ? (int)abs(ok - index) : index; }
final <T> int binarySearch(T[] a, T key, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; } return ok; }
final <T> boolean isOKforBS(T[] a, int index, T key, boolean gt, boolean eq, Comparator<? super T> c) { int compare = c.compare(a[index], key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final <T extends Comparable<? super T>> int lowerBound(List<T> a, T key) { return BS(a, key, true, true, true); }
final <T extends Comparable<? super T>> int lowerBound(List<T> a, T key, int ng, int ok) { return BS(a, key, true, true, true, ng, ok); }
final <T extends Comparable<? super T>> int upperBound(List<T> a, T key) { return BS(a, key, true, true, false); }
final <T extends Comparable<? super T>> int upperBound(List<T> a, T key, int ng, int ok) { return BS(a, key, true, true, false, ng, ok); }
final <T extends Comparable<? super T>> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, true); }
final <T extends Comparable<? super T>> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq) { return BS(a, key, asc, gt, eq, false); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
final <T extends Comparable<? super T>> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok) { int index = binarySearch(a, key, gt, eq, ng, ok); return cnt ? (int)abs(ok - index) : index; }
final <T extends Comparable<? super T>> int binarySearch(List<T> a, T key, boolean gt, boolean eq, int ng, int ok) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; } return ok; }
final <T extends Comparable<? super T>> boolean isOKforBS(List<T> a, int index, T key, boolean gt, boolean eq) { int compare = a.get(index).compareTo(key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final <T> int lowerBound(List<T> a, T key, Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
final <T> int lowerBound(List<T> a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
final <T> int upperBound(List<T> a, T key, Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
final <T> int upperBound(List<T> a, T key, int ng, int ok, Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
final <T> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
final <T> int cntBS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
final <T> int BS(List<T> a, T key, boolean asc, boolean gt, boolean eq, boolean cnt, int ng, int ok, Comparator<? super T> c) { int index = binarySearch(a, key, gt, eq, ng, ok, c); return cnt ? (int)abs(ok - index) : index; }
final <T> int binarySearch(List<T> a, T key, boolean gt, boolean eq, int ng, int ok, Comparator<? super T> c) { while (abs(ok - ng) > 1) { int mid = (ok + ng) / 2; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; } return ok; }
final <T> boolean isOKforBS(List<T> a, int index, T key, boolean gt, boolean eq, Comparator<? super T> c) { int compare = c.compare(a.get(index), key); return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq); }
final PairLL binaryRangeSearch(long left, long right, UnaryOperator<Long> op, boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) / 2;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) / 2;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
final double ternarySearch(double left, double right, UnaryOperator<Double> op, boolean minimize, int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
Mod md = new Mod();
// class Mod107 extends Mod { Mod107() { super(1_000_000_007); } } Mod107 md = new Mod107();
// class Mod998 extends Mod { Mod998() { super(998244353); } } Mod998 md = new Mod998();
class Mod {
final long MOD = 1_000_000_007; Mod() { MH = 0; ML = 0; IS_MOD_CONST = true; }
// final long MOD = 998244353; Mod() { MH = 0; ML = 0; IS_MOD_CONST = true; }
// final long MOD; Mod(long mod) { MOD = mod; IS_MOD_CONST = false; long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
static final long MASK = 0xffff_ffffl;
final long MH;
final long ML;
final boolean IS_MOD_CONST;
final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return IS_MOD_CONST ? ((x %= MOD) < 0 ? x + MOD : x) : reduce(x);
}
final long[] mod(long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
final long[][] mod(long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
final long[][][] mod(long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
final long add(long x, long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
final long sum(long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
final long sub(long x, long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return IS_MOD_CONST ? (x * y) % MOD : reduce(x * y);
x = mod(x);
y = mod(y);
return IS_MOD_CONST ? (x * y) % MOD : reduce(x * y);
}
final long mul(long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
final long div(long x, long y) { return mul(x, inv(y)); }
final long[] pows(long x, int max) {
x = mod(x);
long pow[] = new long[max + 1];
pow[0] = 1;
for(int i = 0; i < max; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
final long fact(int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
final long invFact(int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
static final int MAX_INV_SIZE = 100_100;
final Map<Long, Long> invMap = new HashMap<>();
final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
final long calInv(long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
final long[] invs(int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
static final int MAX_FACT1 = 5_000_100;
static final int MAX_FACT2 = 500_100;
static final int MAX_FACT_MAP_SIZE = 100;
long fact[];
long invFact[];
boolean isFactPrepared = false;
final Map<Long, long[]> factMap = new HashMap<>();
final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
final long P(long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
final long C(long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
final long H(long n, long r) { return C(n - 1 + r, r); }
final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
final long mod(long x, long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
final long pow(long x, long y, long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
class Grids {
int h, w;
Grid[][] gs;
Grid[] gi;
Grids(int h, int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
void init(boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
void init(long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
Grid get(int x, int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
Grid get(int i) { return get(i / w, i % w); }
int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
Grid next(int x, int y, int i) { return next(gs[x][y], i); }
Grid next(Grid g, int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
class Grid implements Comparable<Grid> {
int x, y, h, w, i; boolean b; long val;
Grid() { }
Grid(int x, int y, int h, int w) { init(x, y, h, w, false, 0); }
Grid(int x, int y, int h, int w, boolean b) { init(x, y, h, w, b, 0); }
Grid(int x, int y, int h, int w, long val) { init(x, y, h, w, false, val); }
Grid(int x, int y, int h, int w, boolean b, long val) { init(x, y, h, w, b, val); }
void init(int x, int y, int h, int w, boolean b, long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public String toString() { return "("+x+", "+y+")"+" "+booleanToString(b)+" "+val; }
@Override public int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public int compareTo(Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
final boolean isValid(int x, int y, int h, int w) { return x >= 0 && x < h && y >= 0 && y < w; }
final boolean isValid(Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
class Graph {
int numNode, numEdge;
boolean directed;
List<Edge> edges = new ArrayList<>();
Node nodes[];
Node reversedNodes[];
Graph(int numNode, int numEdge, boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
void init(List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
void add(int source, int target, long cost) { add(new Edge(source, target, cost)); }
void add(Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
class Node extends ArrayList<Edge> {
int id;
Node(int id) { this.id = id; }
void add(int target, long cost) { add(new Edge(id, target, cost)); }
}
class Edge implements Comparable<Edge> {
int source; int target; long cost;
Edge(int source, int target, long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public String toString() { return source+" - "+cost+" -> "+target; }
@Override public int hashCode() { return Objects.hash(source, target); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public int compareTo(Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
T a; U b;
Pair() { }
Pair(T a, U b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public int compareTo(Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
final PairII npii() { return new PairII(ni(), ni()); }
final PairII[] npii(int n) { PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
final PairII[][] npii(int n, int m) { PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
class PairII implements Comparable<PairII> {
int a; int b;
PairII() { }
PairII(int a, int b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
final PairIL npil() { return new PairIL(ni(), nl()); }
final PairIL[] npil(int n) { PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
final PairIL[][] npil(int n, int m) { PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
class PairIL implements Comparable<PairIL> {
int a; long b;
PairIL() { }
PairIL(int a, long b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
final PairID npid() { return new PairID(ni(), nd()); }
final PairID[] npid(int n) { PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
final PairID[][] npid(int n, int m) { PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
class PairID implements Comparable<PairID> {
int a; double b;
PairID() { }
PairID(int a, double b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
final PairLI npli() { return new PairLI(nl(), ni()); }
final PairLI[] npli(int n) { PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
final PairLI[][] npli(int n, int m) { PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
class PairLI implements Comparable<PairLI> {
long a; int b;
PairLI() { }
PairLI(long a, int b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
final PairLL npll() { return new PairLL(nl(), nl()); }
final PairLL[] npll(int n) { PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
final PairLL[][] npll(int n, int m) { PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
class PairLL implements Comparable<PairLL> {
long a; long b;
PairLL() { }
PairLL(long a, long b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
final PairLD npld() { return new PairLD(nl(), nd()); }
final PairLD[] npld(int n) { PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
final PairLD[][] npld(int n, int m) { PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
class PairLD implements Comparable<PairLD> {
long a; double b;
PairLD() { }
PairLD(long a, double b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
final PairDI npdi() { return new PairDI(nd(), ni()); }
final PairDI[] npdi(int n) { PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
final PairDI[][] npdi(int n, int m) { PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
class PairDI implements Comparable<PairDI> {
double a; int b;
PairDI() { }
PairDI(double a, int b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
final PairDL npdl() { return new PairDL(nd(), nl()); }
final PairDL[] npdl(int n) { PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
final PairDL[][] npdl(int n, int m) { PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
class PairDL implements Comparable<PairDL> {
double a; long b;
PairDL() { }
PairDL(double a, long b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
final PairDD npdd() { return new PairDD(nd(), nd()); }
final PairDD[] npdd(int n) { PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
final PairDD[][] npdd(int n, int m) { PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
class PairDD implements Comparable<PairDD> {
double a; double b;
PairDD() { }
PairDD(double a, double b) { this.a = a; this.b = b; }
@Override public String toString() { return "("+a+", "+b+")"; }
@Override public int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public int compareTo(PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
T t; V a;
BasicTuple() { }
StringBuilder sbTuple = new StringBuilder();
public StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public int hashCode() { return Objects.hash(t, a); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
V a;
UniqueTuple() { }
final StringBuilder sbTuple = new StringBuilder();
public StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public int hashCode() { return Objects.hash(a); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
Tuple1() { super(); }
Tuple1(T0 a0) { super(); this.a = a0; }
T0 get0() { return a; }
void set0(T0 x) { a = x; }
}
class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
Tuple2() { super(); }
@SuppressWarnings("unchecked") Tuple2(T0 a0, T1 a1) { super(); this.t = new Tuple1(a0); this.a = a1; }
T0 get0() { return t.get0(); }
T1 get1() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { a = x; }
}
class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
Tuple3() { super(); }
@SuppressWarnings("unchecked") Tuple3(T0 a0, T1 a1, T2 a2) { super(); this.t = new Tuple2(a0, a1); this.a = a2; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { a = x; }
}
class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
Tuple4() { super(); }
@SuppressWarnings("unchecked") Tuple4(T0 a0, T1 a1, T2 a2, T3 a3) { super(); this.t = new Tuple3(a0, a1, a2); this.a = a3; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { a = x; }
}
class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
Tuple5() { super(); }
@SuppressWarnings("unchecked") Tuple5(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4) { super(); this.t = new Tuple4(a0, a1, a2, a3); this.a = a4; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { a = x; }
}
class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
Tuple6() { super(); }
@SuppressWarnings("unchecked")
Tuple6(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) { super(); this.t = new Tuple5(a0, a1, a2, a3, a4); this.a = a5; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return t.get4(); }
T5 get5() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { t.set4(x); }
void set5(T5 x) { a = x; }
}
class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
Tuple7() { super(); }
@SuppressWarnings("unchecked")
Tuple7(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) { super(); this.t = new Tuple6(a0, a1, a2, a3, a4, a5); this.a = a6; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return t.get4(); }
T5 get5() { return t.get5(); }
T6 get6() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { t.set4(x); }
void set5(T5 x) { t.set5(x); }
void set6(T6 x) { a = x; }
}
class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
Tuple8() { super(); }
@SuppressWarnings("unchecked")
Tuple8(T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7) { super(); this.t = new Tuple7(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
T0 get0() { return t.get0(); }
T1 get1() { return t.get1(); }
T2 get2() { return t.get2(); }
T3 get3() { return t.get3(); }
T4 get4() { return t.get4(); }
T5 get5() { return t.get5(); }
T6 get6() { return t.get6(); }
T7 get7() { return a; }
void set0(T0 x) { t.set0(x); }
void set1(T1 x) { t.set1(x); }
void set2(T2 x) { t.set2(x); }
void set3(T3 x) { t.set3(x); }
void set4(T4 x) { t.set4(x); }
void set5(T5 x) { t.set5(x); }
void set6(T6 x) { t.set6(x); }
void set7(T7 x) { a = x; }
}
class TupleIII implements Comparable<TupleIII> {
int a; int b; int c;
TupleIII() { }
TupleIII(int a, int b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleIIL implements Comparable<TupleIIL> {
int a; int b; long c;
TupleIIL() { }
TupleIIL(int a, int b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
class TupleIID implements Comparable<TupleIID> {
int a; int b; double c;
TupleIID() { }
TupleIID(int a, int b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleILI implements Comparable<TupleILI> {
int a; long b; int c;
TupleILI() { }
TupleILI(int a, long b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleILL implements Comparable<TupleILL> {
int a; long b; long c;
TupleILL() { }
TupleILL(int a, long b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleILD implements Comparable<TupleILD> {
int a; long b; double c;
TupleILD() { }
TupleILD(int a, long b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleIDI implements Comparable<TupleIDI> {
int a; double b; int c;
TupleIDI() { }
TupleIDI(int a, double b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override
public int compareTo(TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleIDL implements Comparable<TupleIDL> {
int a; double b; long c;
TupleIDL() { }
TupleIDL(int a, double b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleIDD implements Comparable<TupleIDD> {
int a; double b; double c;
TupleIDD() { }
TupleIDD(int a, double b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleLII implements Comparable<TupleLII> {
long a; int b; int c;
TupleLII() { }
TupleLII(long a, int b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleLIL implements Comparable<TupleLIL> {
long a; int b; long c;
TupleLIL() { }
TupleLIL(long a, int b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleLID implements Comparable<TupleLID> {
long a; int b; double c;
TupleLID() { }
TupleLID(long a, int b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleLLI implements Comparable<TupleLLI> {
long a; long b; int c;
TupleLLI() { }
TupleLLI(long a, long b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleLLL implements Comparable<TupleLLL> {
long a; long b; long c;
TupleLLL() { }
TupleLLL(long a, long b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleLLD implements Comparable<TupleLLD> {
long a; long b; double c;
TupleLLD() { }
TupleLLD(long a, long b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleLDI implements Comparable<TupleLDI> {
long a; double b; int c;
TupleLDI() { }
TupleLDI(long a, double b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleLDL implements Comparable<TupleLDL> {
long a; double b; long c;
TupleLDL() { }
TupleLDL(long a, double b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleLDD implements Comparable<TupleLDD> {
long a; double b; double c;
TupleLDD() { }
TupleLDD(long a, double b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleDII implements Comparable<TupleDII> {
double a; int b; int c;
TupleDII() { }
TupleDII(double a, int b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleDIL implements Comparable<TupleDIL> {
double a; int b; long c;
TupleDIL() { }
TupleDIL(double a, int b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleDID implements Comparable<TupleDID> {
double a; int b; double c;
TupleDID() { }
TupleDID(double a, int b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleDLI implements Comparable<TupleDLI> {
double a; long b; int c;
TupleDLI() { }
TupleDLI(double a, long b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleDLL implements Comparable<TupleDLL> {
double a; long b; long c;
TupleDLL() { }
TupleDLL(double a, long b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleDLD implements Comparable<TupleDLD> {
double a; long b; double c;
TupleDLD() { }
TupleDLD(double a, long b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
class TupleDDI implements Comparable<TupleDDI> {
double a; double b; int c;
TupleDDI() { }
TupleDDI(double a, double b, int c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
class TupleDDL implements Comparable<TupleDDL> {
double a; double b; long c;
TupleDDL() { }
TupleDDL(double a, double b, long c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
class TupleDDD implements Comparable<TupleDDD> {
double a; double b; double c;
TupleDDD() { }
TupleDDD(double a, double b, double c) { this.a = a; this.b = b; this.c = c; }
@Override public String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public int hashCode() { return Objects.hash(a, b, c); }
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public int compareTo(TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
int n = ni();
int a[] = ni(n);
int b[] = ni(n);
int bucket[] = new int[5010];
for(int i = 0; i < n; i ++) bucket[a[i]] ++;
for(int i = 0; i < n; i ++) bucket[b[i]] --;
boolean ok = true;
for(int i = 0; i < bucket.length; i ++) ok &= bucket[i] == 0;
if(!ok) { reply(ok); return; }
for(int i = 0; i < n; i ++) bucket[a[i]] ++;
if(max(bucket) > 1) { reply(ok); return; }
long sum = 0;
int idx[] = new int[5010];
for(int i = 0; i < n; i ++) idx[b[i]] = i;
FenwickTree ft = new FenwickTree(n);
for(int i = 0; i < n; i ++) { int j = idx[a[i]]; sum += j - ft.sum(j); ft.add(j, 1); }
reply(sum % 2 == 0);
}
class FenwickTree { // N=size
int size;
long nodes[];
FenwickTree(int size) { init(size); } // O(N)
FenwickTree(int size, long[] array) { init(size); for(int i = 0; i < size; i ++) add(i, array[i]); }// O(NlogN)
void init(int size) {
nonNegativeCheck(size);
this.size = size;
nodes = new long[size];
fill(nodes, 0);
}
void add(int a, long x) { // O(logN)
rangeCheck(a, size);
a ++;
while(a <= size) {
nodes[a - 1] += x;
a += a & -a;
}
}
long sum(int r) { // return sum of [0, r) // O(logN)
inclusiveRangeCheck(r, size);
long sum = 0;
while(r > 0) {
sum += nodes[r - 1];
r -= r & -r;
}
return sum;
}
long sum(int l, int r) { // return sum of [l, r) // O(logN)
inclusiveRangeCheck(l, size);
inclusiveRangeCheck(r, size);
if(l > r) return 0;
else return sum(r) - sum(l);
}
}
}
}
| ConDefects/ConDefects/Code/arc136_b/Java/31062169 |
condefects-java_data_1570 | import java.io.*;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main implements Runnable {
public static void solve () {
int n = nextInt(), m = nextInt();
int[] a = new int[n+1];
for (int i=1; i<=n; i++) a[i] = nextInt();
//dp[i][j] i番目まで見て、j個とって数列を作ったときの最大値
long[][] dp = new long[n+1][m+1];
for (int i=0; i<n+1; i++) Arrays.fill(dp[i], -1);
dp[0][0] = 0;
for (int i=1; i<=n; i++) {
//i番目の要素をとらない場合
for (int j=0; j<=m; j++) {
dp[i][j] = dp[i-1][j];
}
//i番目の要素を取る場合
for (int j=0; j<m; j++) {
dp[i][j+1] = Math.max(
dp[i][j+1],
dp[i-1][j] + 1L * a[i] * (j+1)
);
}
}
println(dp[n][m]);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
// public static int[] dy = {-1, 0, -1, 1, 0, 1};
// public static int[] dx = {-1, -1, 0, 0, 1, 1};
// public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
// public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) { //基本コレ
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// output
/////////////////////////////////////////////////////////////////////////////////////////////////
static PrintWriter out = new PrintWriter(System.out);
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
new Thread(null, new Main(), "", 64 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
}
import java.io.*;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main implements Runnable {
public static void solve () {
int n = nextInt(), m = nextInt();
int[] a = new int[n+1];
for (int i=1; i<=n; i++) a[i] = nextInt();
//dp[i][j] i番目まで見て、j個とって数列を作ったときの最大値
long[][] dp = new long[n+1][m+1];
for (int i=0; i<n+1; i++) Arrays.fill(dp[i], -infl);
dp[0][0] = 0;
for (int i=1; i<=n; i++) {
//i番目の要素をとらない場合
for (int j=0; j<=m; j++) {
dp[i][j] = dp[i-1][j];
}
//i番目の要素を取る場合
for (int j=0; j<m; j++) {
dp[i][j+1] = Math.max(
dp[i][j+1],
dp[i-1][j] + 1L * a[i] * (j+1)
);
}
}
println(dp[n][m]);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
// public static int[] dy = {-1, 0, -1, 1, 0, 1};
// public static int[] dx = {-1, -1, 0, 0, 1, 1};
// public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
// public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) { //基本コレ
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// output
/////////////////////////////////////////////////////////////////////////////////////////////////
static PrintWriter out = new PrintWriter(System.out);
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
new Thread(null, new Main(), "", 64 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc267_d/Java/39511312 |
condefects-java_data_1571 | import java.util.*;
import java.io.*;
import java.math.*;
class Solver {
void solve(FScanner sc, FWriter out) {
long a = sc.nextLong(), b = sc.nextLong();
out.println(Math.pow(a, b), 0);
}
}
// common
public class Main {
public static void main(String[] args) {
FScanner sc = new FScanner(System.in);
FWriter out = new FWriter(System.out);
try {
(new Solver()).solve(sc, out);
} catch (Throwable e) {
out.println(e);
out.flush();
System.exit(1);
}
out.flush();
sc.close();
}
}
class Bsearch {
static int search(int l, int r, java.util.function.IntPredicate func) {
while (r - l > 1) {
int mid = (l + r) / 2;
if (func.test(mid)) {
l = mid;
} else {
r = mid;
}
}
return r;
}
}
class TwoKeyMap<K, V> {
Map<K, Map<K, V>> map = new HashMap<>();
Set<K> _key2Set = new HashSet<>();
TwoKeyMap<K, V> put(K key1, K key2, V value) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).put(key2, value);
return this;
}
TwoKeyMap<K, V> put(K[] key, V value) {
return put(key[0], key[1], value);
}
TwoKeyMap<K, V> merge(K key1, K key2, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).merge(key2, value, remappingFunction);
return this;
}
TwoKeyMap<K, V> merge(K[] key, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
return merge(key[0], key[1], value, remappingFunction);
}
V get(K key1, K key2) {
var m1 = map.get(key1);
if (m1 == null)
return null;
return m1.get(key2);
}
Map<K, V> get(K key1) {
return map.get(key1);
}
V get(K[] key) {
return get(key[0], key[1]);
}
V computeIfAbsent(K key1, K key2, java.util.function.Function<? super K, ? extends V> mappingFunction) {
return map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).computeIfAbsent(key2, mappingFunction);
}
boolean containsKey(K key1, K key2) {
return get(key1, key2) != null;
}
Set<K> key1Set() {
return map.keySet();
}
Set<K> key2Set() {
// 本来はインスタンス作るべきだが、競技プログラミング向けなのでパフォーマンス優先
return _key2Set;
}
}
class FScanner {
private InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FScanner(InputStream in) {
this.in = in;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
return nextSB().toString();
}
public char[] nextCharArray() {
StringBuilder sb = nextSB();
char[] c = new char[sb.length()];
sb.getChars(0, sb.length(), c, 0);
return c;
}
public StringBuilder nextSB() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb;
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public java.math.BigDecimal nextDecimal() {
return new java.math.BigDecimal(next());
}
public java.util.stream.IntStream nextIntStream(int n) {
return java.util.stream.IntStream.range(0, n).map(i -> nextInt());
}
public java.util.stream.LongStream nextLongStream(int n) {
return java.util.stream.LongStream.range(0L, (long) n).map(i -> nextLong());
}
public java.util.stream.Stream<String> nextStream(int n) {
return java.util.stream.IntStream.range(0, n).mapToObj(i -> next());
}
public int[] nextIntArray(int arraySize) {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
}
public long[] nextLongArray(int arraySize) {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
}
public java.util.stream.Stream<int[]> nextIntArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
});
}
public java.util.stream.Stream<long[]> nextLongArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
});
}
public boolean close() {
return true;
}
}
class FWriter {
OutputStream out;
byte[] buf = new byte[1 << 16];
byte[] ibuf = new byte[20];
int tail = 0;
final byte SP = (byte) ' ', LF = (byte) '\n', HYPHEN = (byte) '-';
FWriter(OutputStream out) {
this.out = out;
}
void flush() {
try {
out.write(buf, 0, tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void write(byte b) {
buf[tail++] = b;
if (tail == buf.length) {
flush();
}
}
void write(byte[] b, int off, int len) {
for (int i = off; i < off + len; i++) {
write(b[i]);
}
}
void println() {
write(LF);
}
FWriter print(char c) {
write((byte) c);
return this;
}
FWriter println(char c) {
print(c);
println();
return this;
}
FWriter print(int n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(int n) {
print(n);
println();
return this;
}
FWriter print(long n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(long n) {
print(n);
println();
return this;
}
FWriter print(String s) {
if (s != null) {
byte[] b = s.getBytes();
write(b, 0, b.length);
}
return this;
}
FWriter println(String s) {
print(s);
println();
return this;
}
FWriter print(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(int[] a) {
print(a);
println();
return this;
}
FWriter print(long[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(long[] a) {
print(a);
println();
return this;
}
FWriter print(char[] s, int from, int to) {
for (int i = from; i < to && s[i] != '\0'; i++) {
print(s[i]);
}
return this;
}
FWriter print(char[] s) {
print(s, 0, s.length);
return this;
}
FWriter println(char[] s, int from, int to) {
print(s, from, to);
println();
return this;
}
FWriter println(char[] s) {
println(s, 0, s.length);
return this;
}
FWriter print(double n, int accuracy) {
long longN = (long) n;
print(longN);
n -= (long) n;
write((byte) '.');
for (int j = 0; j < accuracy; j++) {
n *= 10;
int digit = (int) n;
write((byte) (digit + '0'));
n -= digit;
}
return this;
}
FWriter print(double n) {
print(n, 10);
return this;
}
FWriter println(double n) {
print(n);
println();
return this;
}
FWriter println(double n, int accuracy) {
print(n, accuracy);
println();
return this;
}
FWriter print(Object o) {
if (o != null) {
print(o.toString());
}
return this;
}
FWriter println(Object o) {
print(o);
println();
return this;
}
FWriter println(Throwable e) {
println(e.toString());
for (StackTraceElement el : e.getStackTrace()) {
print(" ").println(el.toString());
}
if (e.getCause() != null) {
println(e.getCause());
}
return this;
}
private void _debug(Object o, int indent) {
if (o == null) {
for (var i = 0; i < indent; i++)
print(' ');
print("null");
} else if (o.getClass().isArray()) {
for (int i = 0; i < java.lang.reflect.Array.getLength(o); i++) {
println();
_debug(java.lang.reflect.Array.get(o, i), indent + 2);
}
return;
} else if (o instanceof Collection) {
for (var item : (Collection<?>) o) {
println();
_debug(item, indent + 2);
}
} else if (o instanceof Map) {
for (var i = 0; i < indent; i++)
print(' ');
println('{');
for (var entry : ((Map<?, ?>) o).entrySet()) {
for (var i = 0; i < indent + 2; i++)
print(' ');
_debug(entry.getKey(), 0);
_debug(" ", 0);
_debug(entry.getValue(), 0);
println();
}
for (var i = 0; i < indent; i++)
print(' ');
println('}');
return;
}
for (var i = 0; i < indent; i++)
print(' ');
print(o);
}
FWriter debug(Object... os) {
print("[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).print("]: ");
for (var o : os) {
_debug(o, 0);
print(' ');
}
print(" :[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).println("]");
return this;
}
}
import java.util.*;
import java.io.*;
import java.math.*;
class Solver {
void solve(FScanner sc, FWriter out) {
long a = sc.nextLong(), b = sc.nextLong();
out.println((long)Math.pow(a, b));
}
}
// common
public class Main {
public static void main(String[] args) {
FScanner sc = new FScanner(System.in);
FWriter out = new FWriter(System.out);
try {
(new Solver()).solve(sc, out);
} catch (Throwable e) {
out.println(e);
out.flush();
System.exit(1);
}
out.flush();
sc.close();
}
}
class Bsearch {
static int search(int l, int r, java.util.function.IntPredicate func) {
while (r - l > 1) {
int mid = (l + r) / 2;
if (func.test(mid)) {
l = mid;
} else {
r = mid;
}
}
return r;
}
}
class TwoKeyMap<K, V> {
Map<K, Map<K, V>> map = new HashMap<>();
Set<K> _key2Set = new HashSet<>();
TwoKeyMap<K, V> put(K key1, K key2, V value) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).put(key2, value);
return this;
}
TwoKeyMap<K, V> put(K[] key, V value) {
return put(key[0], key[1], value);
}
TwoKeyMap<K, V> merge(K key1, K key2, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).merge(key2, value, remappingFunction);
return this;
}
TwoKeyMap<K, V> merge(K[] key, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
return merge(key[0], key[1], value, remappingFunction);
}
V get(K key1, K key2) {
var m1 = map.get(key1);
if (m1 == null)
return null;
return m1.get(key2);
}
Map<K, V> get(K key1) {
return map.get(key1);
}
V get(K[] key) {
return get(key[0], key[1]);
}
V computeIfAbsent(K key1, K key2, java.util.function.Function<? super K, ? extends V> mappingFunction) {
return map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).computeIfAbsent(key2, mappingFunction);
}
boolean containsKey(K key1, K key2) {
return get(key1, key2) != null;
}
Set<K> key1Set() {
return map.keySet();
}
Set<K> key2Set() {
// 本来はインスタンス作るべきだが、競技プログラミング向けなのでパフォーマンス優先
return _key2Set;
}
}
class FScanner {
private InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FScanner(InputStream in) {
this.in = in;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
return nextSB().toString();
}
public char[] nextCharArray() {
StringBuilder sb = nextSB();
char[] c = new char[sb.length()];
sb.getChars(0, sb.length(), c, 0);
return c;
}
public StringBuilder nextSB() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb;
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public java.math.BigDecimal nextDecimal() {
return new java.math.BigDecimal(next());
}
public java.util.stream.IntStream nextIntStream(int n) {
return java.util.stream.IntStream.range(0, n).map(i -> nextInt());
}
public java.util.stream.LongStream nextLongStream(int n) {
return java.util.stream.LongStream.range(0L, (long) n).map(i -> nextLong());
}
public java.util.stream.Stream<String> nextStream(int n) {
return java.util.stream.IntStream.range(0, n).mapToObj(i -> next());
}
public int[] nextIntArray(int arraySize) {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
}
public long[] nextLongArray(int arraySize) {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
}
public java.util.stream.Stream<int[]> nextIntArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
});
}
public java.util.stream.Stream<long[]> nextLongArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
});
}
public boolean close() {
return true;
}
}
class FWriter {
OutputStream out;
byte[] buf = new byte[1 << 16];
byte[] ibuf = new byte[20];
int tail = 0;
final byte SP = (byte) ' ', LF = (byte) '\n', HYPHEN = (byte) '-';
FWriter(OutputStream out) {
this.out = out;
}
void flush() {
try {
out.write(buf, 0, tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void write(byte b) {
buf[tail++] = b;
if (tail == buf.length) {
flush();
}
}
void write(byte[] b, int off, int len) {
for (int i = off; i < off + len; i++) {
write(b[i]);
}
}
void println() {
write(LF);
}
FWriter print(char c) {
write((byte) c);
return this;
}
FWriter println(char c) {
print(c);
println();
return this;
}
FWriter print(int n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(int n) {
print(n);
println();
return this;
}
FWriter print(long n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(long n) {
print(n);
println();
return this;
}
FWriter print(String s) {
if (s != null) {
byte[] b = s.getBytes();
write(b, 0, b.length);
}
return this;
}
FWriter println(String s) {
print(s);
println();
return this;
}
FWriter print(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(int[] a) {
print(a);
println();
return this;
}
FWriter print(long[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(long[] a) {
print(a);
println();
return this;
}
FWriter print(char[] s, int from, int to) {
for (int i = from; i < to && s[i] != '\0'; i++) {
print(s[i]);
}
return this;
}
FWriter print(char[] s) {
print(s, 0, s.length);
return this;
}
FWriter println(char[] s, int from, int to) {
print(s, from, to);
println();
return this;
}
FWriter println(char[] s) {
println(s, 0, s.length);
return this;
}
FWriter print(double n, int accuracy) {
long longN = (long) n;
print(longN);
n -= (long) n;
write((byte) '.');
for (int j = 0; j < accuracy; j++) {
n *= 10;
int digit = (int) n;
write((byte) (digit + '0'));
n -= digit;
}
return this;
}
FWriter print(double n) {
print(n, 10);
return this;
}
FWriter println(double n) {
print(n);
println();
return this;
}
FWriter println(double n, int accuracy) {
print(n, accuracy);
println();
return this;
}
FWriter print(Object o) {
if (o != null) {
print(o.toString());
}
return this;
}
FWriter println(Object o) {
print(o);
println();
return this;
}
FWriter println(Throwable e) {
println(e.toString());
for (StackTraceElement el : e.getStackTrace()) {
print(" ").println(el.toString());
}
if (e.getCause() != null) {
println(e.getCause());
}
return this;
}
private void _debug(Object o, int indent) {
if (o == null) {
for (var i = 0; i < indent; i++)
print(' ');
print("null");
} else if (o.getClass().isArray()) {
for (int i = 0; i < java.lang.reflect.Array.getLength(o); i++) {
println();
_debug(java.lang.reflect.Array.get(o, i), indent + 2);
}
return;
} else if (o instanceof Collection) {
for (var item : (Collection<?>) o) {
println();
_debug(item, indent + 2);
}
} else if (o instanceof Map) {
for (var i = 0; i < indent; i++)
print(' ');
println('{');
for (var entry : ((Map<?, ?>) o).entrySet()) {
for (var i = 0; i < indent + 2; i++)
print(' ');
_debug(entry.getKey(), 0);
_debug(" ", 0);
_debug(entry.getValue(), 0);
println();
}
for (var i = 0; i < indent; i++)
print(' ');
println('}');
return;
}
for (var i = 0; i < indent; i++)
print(' ');
print(o);
}
FWriter debug(Object... os) {
print("[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).print("]: ");
for (var o : os) {
_debug(o, 0);
print(' ');
}
print(" :[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).println("]");
return this;
}
} | ConDefects/ConDefects/Code/abc283_a/Java/38457285 |
condefects-java_data_1572 | import java.util.*;
public class Main{
public static void power1(int a, int b) {
int pow=1;
for(int i=1;i<=b;i++){
pow*=a;
}
System.out.println(pow);
}
public static void power2(int a, int b){
System.out.println(Math.pow(a,b));
}
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int a;
a = sc.nextInt();
int b;
b = sc.nextInt();
power2(a,b);
sc.close();
}
}
import java.util.*;
public class Main{
public static void power1(int a, int b) {
int pow=1;
for(int i=1;i<=b;i++){
pow*=a;
}
System.out.println(pow);
}
public static void power2(int a, int b){
System.out.println((int)Math.pow(a,b));
}
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int a;
a = sc.nextInt();
int b;
b = sc.nextInt();
power2(a,b);
sc.close();
}
}
| ConDefects/ConDefects/Code/abc283_a/Java/38523224 |
condefects-java_data_1573 | import java.util.*;
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
double A = in.nextInt();
double B = in.nextInt();
double answer = Math.pow(A, B);
System.out.println(answer);
}
}
import java.util.*;
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
double A = in.nextInt();
double B = in.nextInt();
double answer = Math.pow(A, B);
System.out.println((int)answer);
}
} | ConDefects/ConDefects/Code/abc283_a/Java/40085369 |
condefects-java_data_1574 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
System.out.println(Math.pow(n,m));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
System.out.println((int)Math.pow(n,m));
}
} | ConDefects/ConDefects/Code/abc283_a/Java/39364580 |
condefects-java_data_1575 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
System.out.println(Math.pow(a,b));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int a=scanner.nextInt();
int b=scanner.nextInt();
System.out.println((int)Math.pow(a,b));
}
} | ConDefects/ConDefects/Code/abc283_a/Java/41468876 |
condefects-java_data_1576 | //Java
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
int a=scan.nextInt();
int b=scan.nextInt();
System.out.println(Math.pow(a, b));
}
}
//Java
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
int a=scan.nextInt();
int b=scan.nextInt();
System.out.println((int)Math.pow(a, b));
}
}
| ConDefects/ConDefects/Code/abc283_a/Java/45996621 |
condefects-java_data_1577 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int B = sc.nextInt();
System.out.println(Math.pow(A, B));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int B = sc.nextInt();
System.out.println((long)Math.pow(A, B));
}
} | ConDefects/ConDefects/Code/abc283_a/Java/44362799 |
condefects-java_data_1578 | import java.util.*;
public class Main {
public static void main(String[] args) {
try(Scanner scan = new Scanner(System.in)) {
int N = scan.nextInt();
int Q = scan.nextInt();
//int[]x = new int[Q+10000000];
//int[]a = new int[N+10000000];
//int[]p = new int[N+10000000];
ArrayList<Integer> po = new ArrayList<>();
ArrayList<Integer> va = new ArrayList<>();
po.add(0);
va.add(0);
for (int i = 1; i <= N; i++) {
po.add(i);
va.add(i);
}
for (int i = 1; i <= Q; i++) {
int z = scan.nextInt();
int point = po.get(z);
int point_value = va.get(point);
int next_point = (point != N ? point + 1 : point - 1);
int next_value = va.get(next_point);
Collections.swap(po, point_value, next_value);
Collections.swap(va, point_value, next_value);
}
for (int i = 1; i <= N; i++) {
System.out.print(va.get(i) + " ");
}
// for(int i = 1;i<=N;i++) {
// a[i] = i ;p[i] = i;
//
// }
//
// for(int i =0;i<Q;i++){
// int z = scan.nextInt();
// int tonari =(a[z]!=N?a[z]+1:a[z]-1);
// int tonari_value = p[tonari];
// int c = a[tonari_value];
// int l = a[z];
// a[tonari_value] = a[z];
// a[z] = c;
// p[tonari] = p[l];
// p[l] = tonari_value;
// //for(int k = 1;k<=N;k++)System.out.print(p[k]+" ");
// // System.out.println();
//
//
//
//
//
//// for (int i = 1;i<=Q;i++)
//// x[i] = scan.nextInt();
//
//// for(int i =1;i<=Q;i++) {
////
//// int z = scan.nextInt();
//// int tmp = p[z];//値の現在地
//// //int y = (tmp == N ? tmp - 1 : tmp + 1);
//// int y =tmp;
//// if(tmp!=N)y++; //交換するべき値の現在地
//// else y--;
//// int next = a[y];//隣の値
//// p[next] = tmp;
//// p[z] = y;
//// a[tmp] = next;
//// a[y] = z;
//
//
////
//// int z = x[i];
////
//// int tmp = a[z];//指定した値の現在地
//// int y =tmp;
//// if(tmp!=N)y++; //交換するべき値の現在地
//// else y--;
//// int next = p[y];
//// a[next] = tmp;
//// a[z] = y;
//// p[tmp] = next;
//// p[y] = z;
//
//// int v0 = p[tmp];
//// int v1 = p[y];
// //System.out.println(v0+" "+v1);
////
//// int v = a[v0];//左隣の現在地
//// int vv = a[v1];
//// a[v0] = vv;
//// a[v1] = v;
//// //System.out.println(a[v0]+" "+a[v1]);
////
//// int b = p[tmp];//左隣の現在地
//// int bb = p[y];
//// p[tmp] = bb;
//// p[y] = b;
// //System.out.println(p[tmp]+" "+p[y]);
//
//// for(int k = 0;k<N;k++)System.out.print(a[k]+1+" ");
//// System.out.println();
//
//
//
//
// }
// int z = scan.nextInt();
// if (a[z] <N) {
// int tmp = p[z];//指定した値の現在地
// int c = p[tmp + 1];//指定した値の現在地の右隣の値
// p[tmp] = c;
// p[tmp + 1] = z;//値を交換
// int y = a[c];//右隣の現在地
// a[c] = a[z];
// a[z] = y;//現在地を交換
// } else {
// int tmp = a[z];//指定した値の現在地
// int c = p[tmp - 1];//指定した値の現在地の左隣の値
// p[tmp] = c;
// p[tmp - 1] = z;//値を交換
// int y = a[c];//左隣の現在地
// a[c] = a[z];
// a[z] = y;//現在地を交換
// }
// for(int k = 0;k<N;k++)System.out.print(a[k+1]);
// System.out.println();
// if(x[i]+1<=N){
// int tmp =a[x[i]-1];
// a[x[i]-1] = a[x[i]];
// a[x[i]] = tmp;
// }else{
// int tmp =a[x[i]-1];
// a[x[i]-1] = a[0];
// a[0] = tmp;
//
// }
// for(int A:a)System.out.print(A);
// System.out.println();
// for(int k = 1;k<=N;k++)System.out.print(p[k]+" ");
// }
// for(int k = 0;k<N;k++){
// System.out.print(a[p[k]]);
// }System.out.println();
//System.out.print(A+' ');
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
try(Scanner scan = new Scanner(System.in)) {
int N = scan.nextInt();
int Q = scan.nextInt();
//int[]x = new int[Q+10000000];
//int[]a = new int[N+10000000];
//int[]p = new int[N+10000000];
ArrayList<Integer> po = new ArrayList<>();
ArrayList<Integer> va = new ArrayList<>();
po.add(0);
va.add(0);
for (int i = 1; i <= N; i++) {
po.add(i);
va.add(i);
}
for (int i = 1; i <= Q; i++) {
int z = scan.nextInt();
int point = po.get(z);
int point_value = va.get(point);
int next_point = (point != N ? point + 1 : point - 1);
int next_value = va.get(next_point);
Collections.swap(va, point, next_point);
Collections.swap(po, point_value, next_value);
}
for (int i = 1; i <= N; i++) {
System.out.print(va.get(i) + " ");
}
// for(int i = 1;i<=N;i++) {
// a[i] = i ;p[i] = i;
//
// }
//
// for(int i =0;i<Q;i++){
// int z = scan.nextInt();
// int tonari =(a[z]!=N?a[z]+1:a[z]-1);
// int tonari_value = p[tonari];
// int c = a[tonari_value];
// int l = a[z];
// a[tonari_value] = a[z];
// a[z] = c;
// p[tonari] = p[l];
// p[l] = tonari_value;
// //for(int k = 1;k<=N;k++)System.out.print(p[k]+" ");
// // System.out.println();
//
//
//
//
//
//// for (int i = 1;i<=Q;i++)
//// x[i] = scan.nextInt();
//
//// for(int i =1;i<=Q;i++) {
////
//// int z = scan.nextInt();
//// int tmp = p[z];//値の現在地
//// //int y = (tmp == N ? tmp - 1 : tmp + 1);
//// int y =tmp;
//// if(tmp!=N)y++; //交換するべき値の現在地
//// else y--;
//// int next = a[y];//隣の値
//// p[next] = tmp;
//// p[z] = y;
//// a[tmp] = next;
//// a[y] = z;
//
//
////
//// int z = x[i];
////
//// int tmp = a[z];//指定した値の現在地
//// int y =tmp;
//// if(tmp!=N)y++; //交換するべき値の現在地
//// else y--;
//// int next = p[y];
//// a[next] = tmp;
//// a[z] = y;
//// p[tmp] = next;
//// p[y] = z;
//
//// int v0 = p[tmp];
//// int v1 = p[y];
// //System.out.println(v0+" "+v1);
////
//// int v = a[v0];//左隣の現在地
//// int vv = a[v1];
//// a[v0] = vv;
//// a[v1] = v;
//// //System.out.println(a[v0]+" "+a[v1]);
////
//// int b = p[tmp];//左隣の現在地
//// int bb = p[y];
//// p[tmp] = bb;
//// p[y] = b;
// //System.out.println(p[tmp]+" "+p[y]);
//
//// for(int k = 0;k<N;k++)System.out.print(a[k]+1+" ");
//// System.out.println();
//
//
//
//
// }
// int z = scan.nextInt();
// if (a[z] <N) {
// int tmp = p[z];//指定した値の現在地
// int c = p[tmp + 1];//指定した値の現在地の右隣の値
// p[tmp] = c;
// p[tmp + 1] = z;//値を交換
// int y = a[c];//右隣の現在地
// a[c] = a[z];
// a[z] = y;//現在地を交換
// } else {
// int tmp = a[z];//指定した値の現在地
// int c = p[tmp - 1];//指定した値の現在地の左隣の値
// p[tmp] = c;
// p[tmp - 1] = z;//値を交換
// int y = a[c];//左隣の現在地
// a[c] = a[z];
// a[z] = y;//現在地を交換
// }
// for(int k = 0;k<N;k++)System.out.print(a[k+1]);
// System.out.println();
// if(x[i]+1<=N){
// int tmp =a[x[i]-1];
// a[x[i]-1] = a[x[i]];
// a[x[i]] = tmp;
// }else{
// int tmp =a[x[i]-1];
// a[x[i]-1] = a[0];
// a[0] = tmp;
//
// }
// for(int A:a)System.out.print(A);
// System.out.println();
// for(int k = 1;k<=N;k++)System.out.print(p[k]+" ");
// }
// for(int k = 0;k<N;k++){
// System.out.print(a[p[k]]);
// }System.out.println();
//System.out.print(A+' ');
}
}
}
| ConDefects/ConDefects/Code/abc250_c/Java/39135277 |
condefects-java_data_1579 | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc =new Scanner(System.in);
int N =sc.nextInt();
int Q =sc.nextInt();
int A[] =new int[N];
int B[] =new int[Q];
int C[] =new int[N];
for(int i=0;i<N;i++){
A[i]=i+1;
C[i]=i;
}
for(int j =0;j<Q;j++){
B[j]=sc.nextInt();
if(C[B[j]-1]==N-1){
int w =A[N-2];
A[N-2]=A[N-1];
A[N-1]=w;
C[w-1]=N-1;
C[B[j]-1]=0;
}
else{
int l =C[B[j]-1];
int m =A[l];
int n =A[l+1];
A[l] =A[l+1];
A[l+1]=m;
C[m-1]=l+1;
C[n-1]=l;
}
}
for(int k =0;k<N;k++){
System.out.print(A[k]+" ");
}
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc =new Scanner(System.in);
int N =sc.nextInt();
int Q =sc.nextInt();
int A[] =new int[N];
int B[] =new int[Q];
int C[] =new int[N];
for(int i=0;i<N;i++){
A[i]=i+1;
C[i]=i;
}
for(int j =0;j<Q;j++){
B[j]=sc.nextInt();
if(C[B[j]-1]==N-1){
int w =A[N-2];
A[N-2]=A[N-1];
A[N-1]=w;
C[w-1]=N-1;
C[B[j]-1]=N-2;
}
else{
int l =C[B[j]-1];
int m =A[l];
int n =A[l+1];
A[l] =A[l+1];
A[l+1]=m;
C[m-1]=l+1;
C[n-1]=l;
}
}
for(int k =0;k<N;k++){
System.out.print(A[k]+" ");
}
}
}
| ConDefects/ConDefects/Code/abc250_c/Java/36178147 |
condefects-java_data_1580 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int q = sc.nextInt();
int[] ball = new int[n];
int[] pos = new int[n];
for(int i =0; i < n; i++) {
ball[i] = i;
pos[i] = i;
}
for(int i = 0; i < q; i++) {
int xi = sc.nextInt();
xi--;
int index = pos[xi];
int j = index+1;
if(j == n) {
j = index-1;
}
int temp = ball[j];
int yi = ball[j];
ball[j] = ball[index];
ball[index] = temp;
swap(pos, xi, yi);
}
System.out.println(Arrays.toString(ball));
for (int k = 0; k < n; k++) {
if (k != n - 1) {
System.out.print(ball[k]+1 + " ");
} else {
System.out.println(ball[k]+1);
}
}
}
public static void swap(int[] arr, int i, int j) {
arr[i] = (arr[i] + arr[j]) - (arr[j] = arr[i]);
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int q = sc.nextInt();
int[] ball = new int[n];
int[] pos = new int[n];
for(int i =0; i < n; i++) {
ball[i] = i;
pos[i] = i;
}
for(int i = 0; i < q; i++) {
int xi = sc.nextInt();
xi--;
int index = pos[xi];
int j = index+1;
if(j == n) {
j = index-1;
}
int temp = ball[j];
int yi = ball[j];
ball[j] = ball[index];
ball[index] = temp;
swap(pos, xi, yi);
}
//System.out.println(Arrays.toString(ball));
for (int k = 0; k < n; k++) {
if (k != n - 1) {
System.out.print(ball[k]+1 + " ");
} else {
System.out.println(ball[k]+1);
}
}
}
public static void swap(int[] arr, int i, int j) {
arr[i] = (arr[i] + arr[j]) - (arr[j] = arr[i]);
}
}
| ConDefects/ConDefects/Code/abc250_c/Java/34279690 |
condefects-java_data_1581 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
static int max = 0;
static char[][] res;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int H = scanner.nextInt();
int W = scanner.nextInt();
char[][] arr = new char[H][W];
res = new char[H][W];
for (int i = 0; i < H; i++) {
String s = scanner.next();
for (int j = 0; j < W; j++) {
arr[i][j] = s.charAt(j);
}
}
solve(arr, 0, 0, H, W, 0);
for (int i = 0; i < res.length; i++) {
for (int j = 0; j < res[i].length; j++) {
System.out.print(res[i][j]);
}
System.out.println();
}
}
static void solve(char[][] arr, int y, int x, int H, int W, int count) {
if (y >= H) {
if (max < count) {
max = count;
for (int i = 0; i < arr.length; i++) {
res[i] = arr[i].clone();
}
}
return;
}
if (x < W - 1 && y < H) {
if (arr[y][x] == 'T' && arr[y][x + 1] == 'T') {
arr[y][x] = 'P';
arr[y][x + 1] = 'C';
solve(arr, y, x + 2, H, W, count + 1);
arr[y][x] = 'T';
arr[y][x + 1] = 'T';
} else {
solve(arr, y, x + 1, H, W, count);
}
} else if (x >= W - 1 && y < H) {
solve(arr, y + 1, 0, H, W, count);
}
}
}
import java.util.Scanner;
public class Main {
static int max = 0;
static char[][] res;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int H = scanner.nextInt();
int W = scanner.nextInt();
char[][] arr = new char[H][W];
res = new char[H][W];
for (int i = 0; i < H; i++) {
String s = scanner.next();
for (int j = 0; j < W; j++) {
arr[i][j] = s.charAt(j);
res[i][j] = arr[i][j];
}
}
solve(arr, 0, 0, H, W, 0);
for (int i = 0; i < res.length; i++) {
for (int j = 0; j < res[i].length; j++) {
System.out.print(res[i][j]);
}
System.out.println();
}
}
static void solve(char[][] arr, int y, int x, int H, int W, int count) {
if (y >= H) {
if (max < count) {
max = count;
for (int i = 0; i < arr.length; i++) {
res[i] = arr[i].clone();
}
}
return;
}
if (x < W - 1 && y < H) {
if (arr[y][x] == 'T' && arr[y][x + 1] == 'T') {
arr[y][x] = 'P';
arr[y][x + 1] = 'C';
solve(arr, y, x + 2, H, W, count + 1);
arr[y][x] = 'T';
arr[y][x + 1] = 'T';
} else {
solve(arr, y, x + 1, H, W, count);
}
} else if (x >= W - 1 && y < H) {
solve(arr, y + 1, 0, H, W, count);
}
}
}
| ConDefects/ConDefects/Code/abc297_c/Java/45474257 |
condefects-java_data_1582 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int h = sc.nextInt();
int w = sc.nextInt();
for(int i=0; i< h; i++){
String[] target = sc.next().split("");
List<Integer>list = new ArrayList<>();
for(int j=0;j < w-1;j++){
if(target[j].equals("T") && target[j+1].equals("T") && target[j].equals(target[j+1])){
target[j] = "P";
target[j+1] = "C";
j += 2;
}
}
System.out.println(String.join("", target));
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int h = sc.nextInt();
int w = sc.nextInt();
for(int i=0; i< h; i++){
String[] target = sc.next().split("");
List<Integer>list = new ArrayList<>();
for(int j=0;j < w-1;j++){
if(target[j].equals("T") && target[j+1].equals("T") && target[j].equals(target[j+1])){
target[j] = "P";
target[j+1] = "C";
j++;
}
}
System.out.println(String.join("", target));
}
}
} | ConDefects/ConDefects/Code/abc297_c/Java/45465753 |
condefects-java_data_1583 | import java.util.*;
public class Main {
static int N = 110;
static char a[][] = new char[N][N];
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int h = sc.nextInt(),w = sc.nextInt();
for(int i = 0 ;i < h ;i ++){
String str = sc.next();
a[i] = str.toCharArray();
}
for(int i = 0 ;i < h ;i ++)
for (int j = 0; j < w - 1; j++)
if (a[i][j] == 'T' && a[i][j + 1] == 'T') {
a[i][j] = 'P';
a[i][j + 1] = 'C';
}
for(int i = 0 ;i < h ;i ++) {
for (int j = 0; j < w - 1; j++)
System.out.print(a[i][j]);
System.out.println();
}
}
}
import java.util.*;
public class Main {
static int N = 110;
static char a[][] = new char[N][N];
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int h = sc.nextInt(),w = sc.nextInt();
for(int i = 0 ;i < h ;i ++){
String str = sc.next();
a[i] = str.toCharArray();
}
for(int i = 0 ;i < h ;i ++)
for (int j = 0; j < w - 1; j++)
if (a[i][j] == 'T' && a[i][j + 1] == 'T') {
a[i][j] = 'P';
a[i][j + 1] = 'C';
}
for(int i = 0 ;i < h ;i ++) {
for (int j = 0; j < w ; j++)
System.out.print(a[i][j]);
System.out.println();
}
}
} | ConDefects/ConDefects/Code/abc297_c/Java/43567481 |
condefects-java_data_1584 | import java.math.*;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int H = sc.nextInt();
int W = sc.nextInt();
sc.nextLine();
int tCnt = 0;
for (int i = 0; i < H; i++) {
String[] tArr = sc.nextLine().split("");
tCnt = 0;
for (int j = 0; j < tArr.length; j++) {
if ("T".equals(tArr[j])) {
tCnt += 1;
if (tCnt == 2) {
tArr[j-1] = "P";
tArr[j] = "C";
tCnt = -1;
}
} else {
tCnt = 0;
}
}
String answer = "";
for (String s:
tArr) {
answer += s;
}
System.out.println(answer);
}
}
}
import java.math.*;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int H = sc.nextInt();
int W = sc.nextInt();
sc.nextLine();
int tCnt = 0;
for (int i = 0; i < H; i++) {
String[] tArr = sc.nextLine().split("");
tCnt = 0;
for (int j = 0; j < tArr.length; j++) {
if ("T".equals(tArr[j])) {
tCnt += 1;
if (tCnt == 2) {
tArr[j-1] = "P";
tArr[j] = "C";
tCnt = 0;
}
} else {
tCnt = 0;
}
}
String answer = "";
for (String s:
tArr) {
answer += s;
}
System.out.println(answer);
}
}
}
| ConDefects/ConDefects/Code/abc297_c/Java/44127926 |
condefects-java_data_1585 | import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner get = new Scanner(System.in);
int H = get.nextInt();
int W = get.nextInt();
String[] S = new String[H];
String[] T = new String[H];
for(int i = 0; i < H; i++) S[i] = get.next();
for(int i = 0; i < H; i++) T[i] = get.next();
StringBuilder[] TS = new StringBuilder[W];
StringBuilder[] TT = new StringBuilder[W];
for(int i = 0; i < W; i++){
TS[i] = new StringBuilder();
TT[i] = new StringBuilder();
}
for(int i = 0; i < H; i++){
for(int j = 0; j < S[i].length(); j++){
TS[j].append(S[i].charAt(j));
TT[j].append(T[i].charAt(j));
}
}
Arrays.sort(TS);
Arrays.sort(TT);
boolean flag = true;
for(int i = 0; i < W; i++){
if(TS[i].equals(TT[i])) {
flag = false;
break;
}
}
System.out.println((flag) ? "Yes" : "No");
get.close();
}
}
import java.util.Scanner;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Scanner get = new Scanner(System.in);
int H = get.nextInt();
int W = get.nextInt();
String[] S = new String[H];
String[] T = new String[H];
for(int i = 0; i < H; i++) S[i] = get.next();
for(int i = 0; i < H; i++) T[i] = get.next();
StringBuilder[] TS = new StringBuilder[W];
StringBuilder[] TT = new StringBuilder[W];
for(int i = 0; i < W; i++){
TS[i] = new StringBuilder();
TT[i] = new StringBuilder();
}
for(int i = 0; i < H; i++){
for(int j = 0; j < S[i].length(); j++){
TS[j].append(S[i].charAt(j));
TT[j].append(T[i].charAt(j));
}
}
Arrays.sort(TS);
Arrays.sort(TT);
boolean flag = true;
for(int i = 0; i < W; i++){
if(!TS[i].toString().equals(TT[i].toString())) {
flag = false;
break;
}
}
System.out.println((flag) ? "Yes" : "No");
get.close();
}
} | ConDefects/ConDefects/Code/abc279_c/Java/40797574 |
condefects-java_data_1586 | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int n = Integer.parseInt(br.readLine());
String ln = br.readLine();
pw.println(ln.contains("ab") || ln.contains("ba") ? "YES" : "NO");
pw.close();
}
}
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int n = Integer.parseInt(br.readLine());
String ln = br.readLine();
pw.println(ln.contains("ab") || ln.contains("ba") ? "Yes" : "No");
pw.close();
}
} | ConDefects/ConDefects/Code/abc327_a/Java/50066572 |
condefects-java_data_1587 | import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
if(s.contains("ab")){
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
if(s.contains("ab") || s.contains("ba")){
System.out.println("Yes");
} else {
System.out.println("No");
}
}
} | ConDefects/ConDefects/Code/abc327_a/Java/49402039 |
condefects-java_data_1588 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
for (int i=0; i<N-1; i++) {
if (S.substring(i,i+2).equals("ab")) {
System.out.println("Yes");
System.exit(0);
}
}
System.out.println("No");
sc.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
String S = sc.next();
for (int i=0; i<N-1; i++) {
if (S.substring(i,i+2).equals("ab") || S.substring(i,i+2).equals("ba")) {
System.out.println("Yes");
System.exit(0);
}
}
System.out.println("No");
sc.close();
}
} | ConDefects/ConDefects/Code/abc327_a/Java/53927362 |
condefects-java_data_1589 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
String s = sc.next();
sc.close();
boolean bool = false;
for (int i = 0; i < n - 1; i++) {
String str = s.substring(i, i + 1);
if ("ab".equals(str) || "ba".equals(str)) {
bool = true;
break;
}
}
System.out.println(bool ? "Yes" : "No");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
String s = sc.next();
sc.close();
boolean bool = false;
for (int i = 0; i < n - 1; i++) {
String str = s.substring(i, i + 2);
if ("ab".equals(str) || "ba".equals(str)) {
bool = true;
break;
}
}
System.out.println(bool ? "Yes" : "No");
}
} | ConDefects/ConDefects/Code/abc327_a/Java/54413664 |
condefects-java_data_1590 | import java.io.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
class Main {
/* 定数 */
static int infI = (int) 1e9;
static long infL = (long) 1e18;
static long mod = (int) 1e9 + 7;
// static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
static boolean local = false;
Random rd = ThreadLocalRandom.current();
/* 入出力とか */
static InputStream is;
MyReader in = new MyReader(is);
MyWriter out = new MyWriter(System.out);
MyLogger log = new MyLogger();
long st = System.currentTimeMillis();
void local() {}
char[] S = in.ch();
char[] T = in.ch();
Object solve() {
List<int[]> listS = lanlen(S);
List<int[]> listT = lanlen(T);
if (listS.size() != listT.size())
return false;
for (int i = 0; i < listS.size(); i++) {
int[] s = listS.get(i);
int[] t = listT.get(i);
if (s[0] != t[0] || s[1] ==1 || s[1]>t[1])
return false;
}
return true;
}
private List<int[]> lanlen(char[] s) {
List<int[]> list = new ArrayList<>();
char c = 0;
int cnt = 0;
for (char cc : s)
if (c == cc)
cnt++;
else {
list.add(new int[] {c, cnt});
cnt = 1;
c = cc;
}
list.add(new int[] {c, cnt});
return list;
}
static class SegmentTree<V> {
Seg<V, V> seg;
SegmentTree(Seg<V, V> seg) {
this.seg = seg;
}
void upd(int i, V f) {
seg.upd(i, i + 1, f);
seg.up(i, i + 1);
}
void set(int i, V v) {
seg.set(i, i + 1, v);
seg.up(i, i + 1);
}
V get(int i) {
return get(i, i + 1);
}
V get(int l, int r) {
return seg.get(l, r);
}
}
static class DualSegmentTree<V, F> {
Seg<V, F> seg;
DualSegmentTree(Seg<V, F> seg) {
this.seg = seg;
}
void upd(int i, F f) {
upd(i, i + 1, f);
}
void upd(int l, int r, F f) {
seg.down(l, r);
seg.upd(l, r, f);
}
void set(int i, V v) {
set(i, i + 1, v);
}
void set(int l, int r, V v) {
seg.down(l, r);
seg.set(l, r, v);
}
V get(int i) {
seg.down(i, i + 1);
return seg.get(i, i + 1);
}
}
static class LazySegmentTree<V, F> {
Seg<V, F> seg;
LazySegmentTree(Seg<V, F> seg) {
this.seg = seg;
}
void upd(int i, F f) {
upd(i, i + 1, f);
}
void upd(int l, int r, F f) {
seg.down(l, r);
seg.upd(l, r, f);
seg.up(l, r);
}
void set(int i, V v) {
set(i, i + 1, v);
}
void set(int l, int r, V v) {
seg.down(l, r);
seg.set(l, r, v);
seg.up(l, r);
}
V get(int i) {
return get(i, i + 1);
}
V get(int l, int r) {
seg.down(l, r);
return seg.get(l, r);
}
}
abstract class Seg<V, F> {
int n;
V e;
V[] val;
F[] lazy;
V[] over;
int[][] lr;
@SuppressWarnings("unchecked")
Seg(int n, V e) {
this.n = n;
this.e = e;
val = (V[]) new Object[n << 1];
lazy = (F[]) new Object[n];
over = (V[]) new Object[n];
lr = new int[n << 1][];
for (int i = n << 1; --i > 0;)
lr[i] = new int[] {i < n ? lr[i << 1][0] : i, i < n ? lr[i << 1 | 1][1] : i + 1};
}
abstract V agg(V v0, V v1);
abstract V map(V v, F f);
abstract F comp(F f0, F f1);
abstract F powF(F f, int[] lr);
abstract V powV(V v, int[] lr);
void merge(int i) {
val[i] = agg(eval(i << 1), eval(i << 1 | 1));
}
void uprec(int l, int r) {
if (l == r) {
while (0 < (l >>= 1))
merge(l);
return;
}
if (l < r)
merge(r >>= 1);
uprec(r, l);
}
void up(int l, int r) {
l += n;
r += n;
uprec(l / (l & -l), r / (r & -r));
}
void over(int i, V v) {
if (i < n) {
over[i] = v;
lazy[i] = null;
} else
val[i] = v;
}
void comp(int i, F f) {
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i], f) : f;
else
val[i] = map(val[i], f);
}
V eval(int i) {
if (i < n && over[i] != null) {
val[i] = powV(over[i], lr[i]);
for (int c = 0; c < 2; c++)
over(i << 1 | c, over[i]);
over[i] = null;
}
if (i < n && lazy[i] != null) {
val[i] = map(val[i], powF(lazy[i], lr[i]));
for (int c = 0; c < 2; c++)
comp(i << 1 | c, lazy[i]);
lazy[i] = null;
}
return val[i] != null ? val[i] : e;
}
void downrec(int l, int r) {
if (l > r) {
downrec(r, l);
return;
}
if (1 < r)
downrec(r >> 1, l);
eval(r);
if (l < r)
eval(l);
}
void down(int l, int r) {
l += n;
r += n;
downrec(l / (l & -l), r / (r & -r));
}
void upd(int l, int r, F f) {
l += n;
r += n;
do {
if ((l & 1) == 1)
comp(l++, f);
if ((r & 1) == 1)
comp(--r, f);
} while ((l >>= 1) < (r >>= 1));
}
void set(int l, int r, V v) {
v = v == null ? e : v;
l += n;
r += n;
do {
if ((l & 1) == 1)
over(l++, v);
if ((r & 1) == 1)
over(--r, v);
} while ((l >>= 1) < (r >>= 1));
}
V get(int l, int r) {
l += n;
r += n;
V vl = e;
V vr = e;
do {
if ((l & 1) == 1)
vl = agg(vl, val[l++]);
if ((r & 1) == 1)
vr = agg(val[--r], vr);
} while ((l >>= 1) < (r >>= 1));
return agg(vl, vr);
}
}
/* Util */
static long mod(long n) {
return (n % mod + mod) % mod;
}
static int[][] trans(int[][] M) {
int[][] ret = new int[M[0].length][M.length];
for (int i = 0; i < M.length; i++)
for (int j = 0; j < M[0].length; j++)
ret[j][i] = M[i][j];
return ret;
}
static long[][] trans(long[][] M) {
long[][] ret = new long[M[0].length][M.length];
for (int i = 0; i < M.length; i++)
for (int j = 0; j < M[0].length; j++)
ret[j][i] = M[i][j];
return ret;
}
/* 実行 */
public static void main(String[] args) throws Exception {
assert local = true;
is = local ? new FileInputStream("src/input.txt") : System.in;
new Main().exe();
}
long elapsed() {
return System.currentTimeMillis() - st;
}
void exe() {
if (local)
local();
Optional.ofNullable(solve()).ifPresent(out::println);
out.flush();
log.println(elapsed());
}
/* 入力 */
static class MyReader {
byte[] buf = new byte[1 << 16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in) {
this.in = in;
}
byte read() {
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {
}
return buf[ptr++];
}
boolean isPrintable(byte c) {
return 32 < c && c < 127;
}
boolean isNum(byte c) {
return 47 < c && c < 58;
}
byte nextPrintable() {
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it() {
return (int) lg();
}
int[] it(int N) {
int[] a = new int[N];
Arrays.setAll(a, i -> it());
return a;
}
int[][] it(int H, int W) {
return arr(new int[H][], i -> it(W));
}
int idx() {
return it() - 1;
}
int[] idx(int N) {
int[] a = new int[N];
Arrays.setAll(a, i -> idx());
return a;
}
int[][] idx(int H, int W) {
return arr(new int[H][], i -> idx(W));
}
long lg() {
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i - '0';
while (isPrintable(i = read()))
n = 10 * n + i - '0';
return negative ? -n : n;
}
long[] lg(int N) {
long[] a = new long[N];
Arrays.setAll(a, i -> lg());
return a;
}
long[][] lg(int H, int W) {
return arr(new long[H][], i -> lg(W));
}
double dbl() {
return Double.parseDouble(str());
}
double[] dbl(int N) {
double[] a = new double[N];
Arrays.setAll(a, i -> dbl());
return a;
}
double[][] dbl(int H, int W) {
return arr(new double[H][], i -> dbl(W));
}
char[] ch() {
return str().toCharArray();
}
char[][] ch(int H) {
return arr(new char[H][], i -> ch());
}
int[] chi() {
return toi(ch());
}
int[][] chi(int H) {
return arr(new int[H][], i -> chi());
}
String line() {
StringBuilder sb = new StringBuilder();
for (byte c; isPrintable(c = read()) || c == ' ';)
sb.append((char) c);
return sb.toString();
}
String str() {
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c; isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N) {
return arr(new String[N], i -> str());
}
<T> T[] arr(T[] arr, IntFunction<T> f) {
Arrays.setAll(arr, f);
return arr;
}
int[] toi(char[] s) {
int[] ret = new int[s.length];
Arrays.setAll(ret, i -> toi(s[i]));
return ret;
}
int toi(char c) {
if (c == '.')
return 0;
if (c == '#')
return 1;
if ('a' <= c && c <= 'z')
return c - 'a';
if ('A' <= c && c <= 'Z')
return c - 'A';
if ('0' <= c && c <= '9')
return c - '0';
return c;
}
}
/* 出力 */
static class MyWriter {
OutputStream out;
byte[] buf = new byte[1 << 16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out) {
this.out = out;
}
void flush() {
try {
out.write(buf, 0, tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void sp() {
write((byte) ' ');
}
void ln() {
write((byte) '\n');
}
void write(byte b) {
buf[tail++] = b;
if (tail == buf.length)
flush();
}
void write(byte[] b, int off, int len) {
for (int i = off; i < off + len; i++)
write(b[i]);
}
void write(long n) {
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
}
void println(boolean b) {
println(b ? yes : no);
}
void println(long n) {
write(n);
ln();
}
void println(double d) {
println(String.valueOf(d));
}
void println(String s) {
println(s.toCharArray());
}
void println(char[] s) {
for (char b : s)
write((byte) b);
ln();
}
void println(int[] a) {
for (int i = 0; i < a.length; i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(long[] a) {
for (int i = 0; i < a.length; i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(double[] a) {
for (int i = 0; i < a.length; i++) {
if (0 < i)
sp();
for (char b : String.valueOf(a[i]).toCharArray())
write((byte) b);
}
ln();
}
void println(Object obj) {
if (obj instanceof Boolean)
println((boolean) obj);
else if (obj instanceof char[])
println((char[]) obj);
else if (obj instanceof int[])
println((int[]) obj);
else if (obj instanceof long[])
println((long[]) obj);
else if (obj instanceof double[])
println((double[]) obj);
else
println(Objects.toString(obj));
}
}
/* デバッグ用 */
static class MyLogger {
MyWriter org = new MyWriter(System.err);
void println(Object obj) {
if (!local)
return;
org.println(obj);
org.flush();
}
}
}
import java.io.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
class Main {
/* 定数 */
static int infI = (int) 1e9;
static long infL = (long) 1e18;
static long mod = (int) 1e9 + 7;
// static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
static boolean local = false;
Random rd = ThreadLocalRandom.current();
/* 入出力とか */
static InputStream is;
MyReader in = new MyReader(is);
MyWriter out = new MyWriter(System.out);
MyLogger log = new MyLogger();
long st = System.currentTimeMillis();
void local() {}
char[] S = in.ch();
char[] T = in.ch();
Object solve() {
List<int[]> listS = lanlen(S);
List<int[]> listT = lanlen(T);
if (listS.size() != listT.size())
return false;
for (int i = 0; i < listS.size(); i++) {
int[] s = listS.get(i);
int[] t = listT.get(i);
if (s[0] != t[0] || s[1]!=t[1]&& s[1] ==1 || s[1]>t[1])
return false;
}
return true;
}
private List<int[]> lanlen(char[] s) {
List<int[]> list = new ArrayList<>();
char c = 0;
int cnt = 0;
for (char cc : s)
if (c == cc)
cnt++;
else {
list.add(new int[] {c, cnt});
cnt = 1;
c = cc;
}
list.add(new int[] {c, cnt});
return list;
}
static class SegmentTree<V> {
Seg<V, V> seg;
SegmentTree(Seg<V, V> seg) {
this.seg = seg;
}
void upd(int i, V f) {
seg.upd(i, i + 1, f);
seg.up(i, i + 1);
}
void set(int i, V v) {
seg.set(i, i + 1, v);
seg.up(i, i + 1);
}
V get(int i) {
return get(i, i + 1);
}
V get(int l, int r) {
return seg.get(l, r);
}
}
static class DualSegmentTree<V, F> {
Seg<V, F> seg;
DualSegmentTree(Seg<V, F> seg) {
this.seg = seg;
}
void upd(int i, F f) {
upd(i, i + 1, f);
}
void upd(int l, int r, F f) {
seg.down(l, r);
seg.upd(l, r, f);
}
void set(int i, V v) {
set(i, i + 1, v);
}
void set(int l, int r, V v) {
seg.down(l, r);
seg.set(l, r, v);
}
V get(int i) {
seg.down(i, i + 1);
return seg.get(i, i + 1);
}
}
static class LazySegmentTree<V, F> {
Seg<V, F> seg;
LazySegmentTree(Seg<V, F> seg) {
this.seg = seg;
}
void upd(int i, F f) {
upd(i, i + 1, f);
}
void upd(int l, int r, F f) {
seg.down(l, r);
seg.upd(l, r, f);
seg.up(l, r);
}
void set(int i, V v) {
set(i, i + 1, v);
}
void set(int l, int r, V v) {
seg.down(l, r);
seg.set(l, r, v);
seg.up(l, r);
}
V get(int i) {
return get(i, i + 1);
}
V get(int l, int r) {
seg.down(l, r);
return seg.get(l, r);
}
}
abstract class Seg<V, F> {
int n;
V e;
V[] val;
F[] lazy;
V[] over;
int[][] lr;
@SuppressWarnings("unchecked")
Seg(int n, V e) {
this.n = n;
this.e = e;
val = (V[]) new Object[n << 1];
lazy = (F[]) new Object[n];
over = (V[]) new Object[n];
lr = new int[n << 1][];
for (int i = n << 1; --i > 0;)
lr[i] = new int[] {i < n ? lr[i << 1][0] : i, i < n ? lr[i << 1 | 1][1] : i + 1};
}
abstract V agg(V v0, V v1);
abstract V map(V v, F f);
abstract F comp(F f0, F f1);
abstract F powF(F f, int[] lr);
abstract V powV(V v, int[] lr);
void merge(int i) {
val[i] = agg(eval(i << 1), eval(i << 1 | 1));
}
void uprec(int l, int r) {
if (l == r) {
while (0 < (l >>= 1))
merge(l);
return;
}
if (l < r)
merge(r >>= 1);
uprec(r, l);
}
void up(int l, int r) {
l += n;
r += n;
uprec(l / (l & -l), r / (r & -r));
}
void over(int i, V v) {
if (i < n) {
over[i] = v;
lazy[i] = null;
} else
val[i] = v;
}
void comp(int i, F f) {
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i], f) : f;
else
val[i] = map(val[i], f);
}
V eval(int i) {
if (i < n && over[i] != null) {
val[i] = powV(over[i], lr[i]);
for (int c = 0; c < 2; c++)
over(i << 1 | c, over[i]);
over[i] = null;
}
if (i < n && lazy[i] != null) {
val[i] = map(val[i], powF(lazy[i], lr[i]));
for (int c = 0; c < 2; c++)
comp(i << 1 | c, lazy[i]);
lazy[i] = null;
}
return val[i] != null ? val[i] : e;
}
void downrec(int l, int r) {
if (l > r) {
downrec(r, l);
return;
}
if (1 < r)
downrec(r >> 1, l);
eval(r);
if (l < r)
eval(l);
}
void down(int l, int r) {
l += n;
r += n;
downrec(l / (l & -l), r / (r & -r));
}
void upd(int l, int r, F f) {
l += n;
r += n;
do {
if ((l & 1) == 1)
comp(l++, f);
if ((r & 1) == 1)
comp(--r, f);
} while ((l >>= 1) < (r >>= 1));
}
void set(int l, int r, V v) {
v = v == null ? e : v;
l += n;
r += n;
do {
if ((l & 1) == 1)
over(l++, v);
if ((r & 1) == 1)
over(--r, v);
} while ((l >>= 1) < (r >>= 1));
}
V get(int l, int r) {
l += n;
r += n;
V vl = e;
V vr = e;
do {
if ((l & 1) == 1)
vl = agg(vl, val[l++]);
if ((r & 1) == 1)
vr = agg(val[--r], vr);
} while ((l >>= 1) < (r >>= 1));
return agg(vl, vr);
}
}
/* Util */
static long mod(long n) {
return (n % mod + mod) % mod;
}
static int[][] trans(int[][] M) {
int[][] ret = new int[M[0].length][M.length];
for (int i = 0; i < M.length; i++)
for (int j = 0; j < M[0].length; j++)
ret[j][i] = M[i][j];
return ret;
}
static long[][] trans(long[][] M) {
long[][] ret = new long[M[0].length][M.length];
for (int i = 0; i < M.length; i++)
for (int j = 0; j < M[0].length; j++)
ret[j][i] = M[i][j];
return ret;
}
/* 実行 */
public static void main(String[] args) throws Exception {
assert local = true;
is = local ? new FileInputStream("src/input.txt") : System.in;
new Main().exe();
}
long elapsed() {
return System.currentTimeMillis() - st;
}
void exe() {
if (local)
local();
Optional.ofNullable(solve()).ifPresent(out::println);
out.flush();
log.println(elapsed());
}
/* 入力 */
static class MyReader {
byte[] buf = new byte[1 << 16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in) {
this.in = in;
}
byte read() {
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {
}
return buf[ptr++];
}
boolean isPrintable(byte c) {
return 32 < c && c < 127;
}
boolean isNum(byte c) {
return 47 < c && c < 58;
}
byte nextPrintable() {
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it() {
return (int) lg();
}
int[] it(int N) {
int[] a = new int[N];
Arrays.setAll(a, i -> it());
return a;
}
int[][] it(int H, int W) {
return arr(new int[H][], i -> it(W));
}
int idx() {
return it() - 1;
}
int[] idx(int N) {
int[] a = new int[N];
Arrays.setAll(a, i -> idx());
return a;
}
int[][] idx(int H, int W) {
return arr(new int[H][], i -> idx(W));
}
long lg() {
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i - '0';
while (isPrintable(i = read()))
n = 10 * n + i - '0';
return negative ? -n : n;
}
long[] lg(int N) {
long[] a = new long[N];
Arrays.setAll(a, i -> lg());
return a;
}
long[][] lg(int H, int W) {
return arr(new long[H][], i -> lg(W));
}
double dbl() {
return Double.parseDouble(str());
}
double[] dbl(int N) {
double[] a = new double[N];
Arrays.setAll(a, i -> dbl());
return a;
}
double[][] dbl(int H, int W) {
return arr(new double[H][], i -> dbl(W));
}
char[] ch() {
return str().toCharArray();
}
char[][] ch(int H) {
return arr(new char[H][], i -> ch());
}
int[] chi() {
return toi(ch());
}
int[][] chi(int H) {
return arr(new int[H][], i -> chi());
}
String line() {
StringBuilder sb = new StringBuilder();
for (byte c; isPrintable(c = read()) || c == ' ';)
sb.append((char) c);
return sb.toString();
}
String str() {
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c; isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N) {
return arr(new String[N], i -> str());
}
<T> T[] arr(T[] arr, IntFunction<T> f) {
Arrays.setAll(arr, f);
return arr;
}
int[] toi(char[] s) {
int[] ret = new int[s.length];
Arrays.setAll(ret, i -> toi(s[i]));
return ret;
}
int toi(char c) {
if (c == '.')
return 0;
if (c == '#')
return 1;
if ('a' <= c && c <= 'z')
return c - 'a';
if ('A' <= c && c <= 'Z')
return c - 'A';
if ('0' <= c && c <= '9')
return c - '0';
return c;
}
}
/* 出力 */
static class MyWriter {
OutputStream out;
byte[] buf = new byte[1 << 16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out) {
this.out = out;
}
void flush() {
try {
out.write(buf, 0, tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void sp() {
write((byte) ' ');
}
void ln() {
write((byte) '\n');
}
void write(byte b) {
buf[tail++] = b;
if (tail == buf.length)
flush();
}
void write(byte[] b, int off, int len) {
for (int i = off; i < off + len; i++)
write(b[i]);
}
void write(long n) {
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
}
void println(boolean b) {
println(b ? yes : no);
}
void println(long n) {
write(n);
ln();
}
void println(double d) {
println(String.valueOf(d));
}
void println(String s) {
println(s.toCharArray());
}
void println(char[] s) {
for (char b : s)
write((byte) b);
ln();
}
void println(int[] a) {
for (int i = 0; i < a.length; i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(long[] a) {
for (int i = 0; i < a.length; i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(double[] a) {
for (int i = 0; i < a.length; i++) {
if (0 < i)
sp();
for (char b : String.valueOf(a[i]).toCharArray())
write((byte) b);
}
ln();
}
void println(Object obj) {
if (obj instanceof Boolean)
println((boolean) obj);
else if (obj instanceof char[])
println((char[]) obj);
else if (obj instanceof int[])
println((int[]) obj);
else if (obj instanceof long[])
println((long[]) obj);
else if (obj instanceof double[])
println((double[]) obj);
else
println(Objects.toString(obj));
}
}
/* デバッグ用 */
static class MyLogger {
MyWriter org = new MyWriter(System.err);
void println(Object obj) {
if (!local)
return;
org.println(obj);
org.flush();
}
}
}
| ConDefects/ConDefects/Code/abc259_c/Java/38712956 |
condefects-java_data_1591 | import java.io.*;
import java.security.KeyPair;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
import java.util.Collections;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
char[] s = in.nextCharArray();
char[] t = in.nextCharArray();
List<Map<Character,Integer>> a = new ArrayList<>();
List<Character> slist = new ArrayList<>();
List<Map<Character,Integer>> b = new ArrayList<>();
List<Character> tlist = new ArrayList<>();
a.add(new HashMap<>());
a.get(0).put(s[0],1);
slist.add(s[0]);
int anum = 0;
for (int i = 1; i < s.length; i++) {
if(a.get(anum).containsKey(s[i])){
a.get(anum).put(s[i],a.get(anum).get(s[i])+1);
}else{
a.add(new HashMap<>());
anum++;
a.get(anum).put(s[i],1);
slist.add(s[i]);
}
}
b.add(new HashMap<>());
b.get(0).put(t[0],1);
tlist.add(t[0]);
int bnum = 0;
for (int i = 1; i < t.length; i++) {
if(b.get(bnum).containsKey(t[i])){
b.get(bnum).put(t[i],b.get(bnum).get(t[i])+1);
}else{
b.add(new HashMap<>());
bnum++;
b.get(bnum).put(t[i],1);
tlist.add(t[i]);
}
}
if(bnum != anum){
out.println("No");
}else{
boolean ans = true;
for (int i = 0; i <= anum; i++) {
int acnt = a.get(i).get(slist.get(i));
int bcnt = b.get(i).get(tlist.get(i));
ans &= (slist.get(i) == tlist.get(i) && acnt == bcnt || (acnt >= 2 && acnt < bcnt));
}
out.println(answer(ans));
}
}
String answer(boolean ans){
return ans ? "Yes" : "No";
}
long pow(long a,long b){
long n = 1;
for (long i = 0; i < Math.abs(b); i++) {
n *= a;
}
return b > 0 ? n : 1/n;
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
import java.io.*;
import java.security.KeyPair;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
import java.util.Collections;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
char[] s = in.nextCharArray();
char[] t = in.nextCharArray();
List<Map<Character,Integer>> a = new ArrayList<>();
List<Character> slist = new ArrayList<>();
List<Map<Character,Integer>> b = new ArrayList<>();
List<Character> tlist = new ArrayList<>();
a.add(new HashMap<>());
a.get(0).put(s[0],1);
slist.add(s[0]);
int anum = 0;
for (int i = 1; i < s.length; i++) {
if(a.get(anum).containsKey(s[i])){
a.get(anum).put(s[i],a.get(anum).get(s[i])+1);
}else{
a.add(new HashMap<>());
anum++;
a.get(anum).put(s[i],1);
slist.add(s[i]);
}
}
b.add(new HashMap<>());
b.get(0).put(t[0],1);
tlist.add(t[0]);
int bnum = 0;
for (int i = 1; i < t.length; i++) {
if(b.get(bnum).containsKey(t[i])){
b.get(bnum).put(t[i],b.get(bnum).get(t[i])+1);
}else{
b.add(new HashMap<>());
bnum++;
b.get(bnum).put(t[i],1);
tlist.add(t[i]);
}
}
if(bnum != anum){
out.println("No");
}else{
boolean ans = true;
for (int i = 0; i <= anum; i++) {
int acnt = a.get(i).get(slist.get(i));
int bcnt = b.get(i).get(tlist.get(i));
ans &= (slist.get(i) == tlist.get(i) && (acnt == bcnt || (acnt >= 2 && acnt < bcnt)));
}
out.println(answer(ans));
}
}
String answer(boolean ans){
return ans ? "Yes" : "No";
}
long pow(long a,long b){
long n = 1;
for (long i = 0; i < Math.abs(b); i++) {
n *= a;
}
return b > 0 ? n : 1/n;
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
} | ConDefects/ConDefects/Code/abc259_c/Java/38897659 |
condefects-java_data_1592 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
void solve(){
String s = scanner.next(), t = scanner.next();
List<int[]> S = convert(s), T = convert(t);
if(S.size() != T.size()){
out.println("No");
}
else{
for(int i = 0; i < S.size(); i++){
int[] a = S.get(i), b = T.get(i);
if(a[0]==b[0] && (a[1]==b[1] || (a[1]>1&&a[1]<b[1]))){
}
else{
out.println("No");
return;
}
}
}
out.println("Yes");
}
List<int[]> convert(String s){
List<int[]> arr = new ArrayList<>();
int i = 0, n = s.length();
while(i < n){
int j = i;
while(j < n && s.charAt(i) == s.charAt(j)){
j++;
}
arr.add(new int[]{s.charAt(i)-'a', j-i});
i=j;
}
return arr;
}
private static final boolean memory = false;
private static final boolean singleTest = true;
// ----- runner templates ----- //
void run() {
int numOfTests = singleTest? 1: scanner.nextInt();
for(int testIdx = 1; testIdx <= numOfTests; testIdx++){
solve();
}
out.flush();
out.close();
}
// ----- runner templates ----- //
public static void main(String[] args) {
if(memory) {
new Thread(null, () -> new Main().run(), "go", 1 << 26).start();
}
else{
new Main().run();
}
}
//------ input and output ------//
public static FastScanner scanner = new FastScanner(System.in);
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return negative ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
return (char) c;
}
public String next() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isWhitespace(c));
return res.toString();
}
private boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
int[] nextIntArray(int n, int base){
int[] arr = new int[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextInt();}
return arr;
}
long[] nextLongArray(int n, int base){
long[] arr = new long[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextLong();}
return arr;
}
int[][] nextIntGrid(int n, int m, int base){
int[][] grid = new int[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextInt();}}
return grid;
}
char[][] nextCharGrid(int n, int m, int base){
char[][] grid = new char[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextChar();}}
return grid;
}
//------ debug and print functions ------//
void debug(Object...os){out.println(deepToString(os));}
void print(int[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(long[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(char[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(Object... o){for(int i = 0; i < o.length; i++){out.print(o[i]);out.print(i==o.length-1?'\n':' ');}}
<T> void printArrayList(List<T> arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr.get(i));out.print(i==end? '\n':' ');}}
//------ sort primitive type arrays ------//
static void sort(int[] arr){
List<Integer> temp = new ArrayList<>();
for(int val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(long[] arr){
List<Long> temp = new ArrayList<>();
for(long val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(char[] arr) {
List<Character> temp = new ArrayList<>();
for (char val : arr) {temp.add(val);}
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) {arr[i] = temp.get(i);}
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
void solve(){
String s = scanner.next(), t = scanner.next();
List<int[]> S = convert(s), T = convert(t);
if(S.size() != T.size()){
out.println("No");
}
else{
for(int i = 0; i < S.size(); i++){
int[] a = S.get(i), b = T.get(i);
if(a[0]==b[0] && (a[1]==b[1] || (a[1]>1&&a[1]<b[1]))){
}
else{
out.println("No");
return;
}
}
out.println("Yes");
}
}
List<int[]> convert(String s){
List<int[]> arr = new ArrayList<>();
int i = 0, n = s.length();
while(i < n){
int j = i;
while(j < n && s.charAt(i) == s.charAt(j)){
j++;
}
arr.add(new int[]{s.charAt(i)-'a', j-i});
i=j;
}
return arr;
}
private static final boolean memory = false;
private static final boolean singleTest = true;
// ----- runner templates ----- //
void run() {
int numOfTests = singleTest? 1: scanner.nextInt();
for(int testIdx = 1; testIdx <= numOfTests; testIdx++){
solve();
}
out.flush();
out.close();
}
// ----- runner templates ----- //
public static void main(String[] args) {
if(memory) {
new Thread(null, () -> new Main().run(), "go", 1 << 26).start();
}
else{
new Main().run();
}
}
//------ input and output ------//
public static FastScanner scanner = new FastScanner(System.in);
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return negative ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
return (char) c;
}
public String next() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isWhitespace(c));
return res.toString();
}
private boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
int[] nextIntArray(int n, int base){
int[] arr = new int[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextInt();}
return arr;
}
long[] nextLongArray(int n, int base){
long[] arr = new long[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextLong();}
return arr;
}
int[][] nextIntGrid(int n, int m, int base){
int[][] grid = new int[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextInt();}}
return grid;
}
char[][] nextCharGrid(int n, int m, int base){
char[][] grid = new char[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextChar();}}
return grid;
}
//------ debug and print functions ------//
void debug(Object...os){out.println(deepToString(os));}
void print(int[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(long[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(char[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(Object... o){for(int i = 0; i < o.length; i++){out.print(o[i]);out.print(i==o.length-1?'\n':' ');}}
<T> void printArrayList(List<T> arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr.get(i));out.print(i==end? '\n':' ');}}
//------ sort primitive type arrays ------//
static void sort(int[] arr){
List<Integer> temp = new ArrayList<>();
for(int val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(long[] arr){
List<Long> temp = new ArrayList<>();
for(long val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(char[] arr) {
List<Character> temp = new ArrayList<>();
for (char val : arr) {temp.add(val);}
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) {arr[i] = temp.get(i);}
}
} | ConDefects/ConDefects/Code/abc259_c/Java/40341412 |
condefects-java_data_1593 | import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
public class Main {
static Queue<String> queue = new ArrayDeque<>();
public static void main(String[] args) {
FastScanner scan = new FastScanner();
String S = scan.next();
String T = scan.next();
List<Character> SC = new ArrayList<>();
List<Integer> SN = new ArrayList<>();
List<Character> TC = new ArrayList<>();
List<Integer> TN = new ArrayList<>();
char current = S.charAt(0);
int count = 1;
for (int i = 1; i < S.length(); i++) {
char c = S.charAt(i);
if (current == c) count++;
else {
SC.add(current);
SN.add(count);
current = c;
count = 1;
}
}
SC.add(current);
SN.add(count);
current = T.charAt(0);
count = 1;
for (int i = 1; i < T.length(); i++) {
char c = T.charAt(i);
if (current == c) count++;
else {
TC.add(current);
TN.add(count);
current = c;
count = 1;
}
}
TC.add(current);
TN.add(count);
if (SC.size() != TC.size()) {
print("No");
System.exit(0);
}
boolean f = true;
for (int i = 0; i < SC.size(); i++) {
if (SC.get(i) != TC.get(i)) {
f = false;
break;
}
if (!(SN.get(i) == TN.get(i) || SN.get(i) < TN.get(i) && SN.get(i) > 1)) {
f = false;
break;
}
}
print(f ? "Yes" : "No");
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? -1 : 1);
}
public static void permutation(String s) {
permutation(s, "");
}
public static void permutation(String q, String ans) {
if (q.length() <= 1) {
queue.add(ans + q);
} else {
for (int i = 0; i < q.length(); i++) {
permutation(q.substring(0, i) + q.substring(i + 1), ans + q.charAt(i));
}
}
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject>{
int i;
T obj;
public IndexedObject(int i, T obj) {
this.i = i;
this.obj = obj;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.obj.equals(((IndexedObject<?>)o).obj);
}
@Override
public int compareTo(IndexedObject p) {
if (p.obj.getClass() != this.obj.getClass()) throw new IllegalArgumentException();
return obj.compareTo((T) p.obj);
}
@Override
public int hashCode() {
return this.i + this.obj.hashCode();
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
public class Main {
static Queue<String> queue = new ArrayDeque<>();
public static void main(String[] args) {
FastScanner scan = new FastScanner();
String S = scan.next();
String T = scan.next();
List<Character> SC = new ArrayList<>();
List<Integer> SN = new ArrayList<>();
List<Character> TC = new ArrayList<>();
List<Integer> TN = new ArrayList<>();
char current = S.charAt(0);
int count = 1;
for (int i = 1; i < S.length(); i++) {
char c = S.charAt(i);
if (current == c) count++;
else {
SC.add(current);
SN.add(count);
current = c;
count = 1;
}
}
SC.add(current);
SN.add(count);
current = T.charAt(0);
count = 1;
for (int i = 1; i < T.length(); i++) {
char c = T.charAt(i);
if (current == c) count++;
else {
TC.add(current);
TN.add(count);
current = c;
count = 1;
}
}
TC.add(current);
TN.add(count);
if (SC.size() != TC.size()) {
print("No");
System.exit(0);
}
boolean f = true;
for (int i = 0; i < SC.size(); i++) {
if (SC.get(i) != TC.get(i)) {
f = false;
break;
}
if (!Objects.equals(SN.get(i), TN.get(i)) && !(SN.get(i) < TN.get(i) && SN.get(i) > 1)) {
f = false;
break;
}
}
print(f ? "Yes" : "No");
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? -1 : 1);
}
public static void permutation(String s) {
permutation(s, "");
}
public static void permutation(String q, String ans) {
if (q.length() <= 1) {
queue.add(ans + q);
} else {
for (int i = 0; i < q.length(); i++) {
permutation(q.substring(0, i) + q.substring(i + 1), ans + q.charAt(i));
}
}
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject>{
int i;
T obj;
public IndexedObject(int i, T obj) {
this.i = i;
this.obj = obj;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.obj.equals(((IndexedObject<?>)o).obj);
}
@Override
public int compareTo(IndexedObject p) {
if (p.obj.getClass() != this.obj.getClass()) throw new IllegalArgumentException();
return obj.compareTo((T) p.obj);
}
@Override
public int hashCode() {
return this.i + this.obj.hashCode();
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
| ConDefects/ConDefects/Code/abc259_c/Java/38935327 |
condefects-java_data_1594 | import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
ArrayDeque<Character> S = new ArrayDeque<>();
for(char c:sc.next().toCharArray())
S.add(c);
ArrayDeque<Character> T = new ArrayDeque<>();
for(char c:sc.next().toCharArray())
T.add(c);
char bef = '-';
boolean flag = false;
while(S.size()>0&&T.size()>0){
char s = S.pollFirst();
char t = T.pollFirst();
if(s!=t){
if(bef==t&&flag){
S.addFirst(s);
}
else{
System.out.println("No");
return;
}
}
else{
flag = s==bef;
bef = s;
}
}
System.out.println(S.size()+T.size()==0?"Yes":"No");
}
}
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
ArrayDeque<Character> S = new ArrayDeque<>();
for(char c:sc.next().toCharArray())
S.add(c);
ArrayDeque<Character> T = new ArrayDeque<>();
for(char c:sc.next().toCharArray())
T.add(c);
char bef = '-';
boolean flag = false;
while(S.size()>0&&T.size()>0){
char s = S.pollFirst();
char t = T.pollFirst();
if(s!=t){
if(bef==t&&flag){
S.addFirst(s);
}
else{
System.out.println("No");
return;
}
}
else{
flag = s==bef;
bef = s;
}
}
while(flag&&T.size()>0&&T.peekFirst()==bef)
T.pollFirst();
System.out.println(S.size()+T.size()==0?"Yes":"No");
}
}
| ConDefects/ConDefects/Code/abc259_c/Java/41340282 |
condefects-java_data_1595 | import static java.util.Arrays.*;
import static java.lang.Math.*;
import java.io.*;
import java.util.*;
public class Main {
void solve() {
int N = scanner.nextInt();
int K = scanner.nextInt();
List<Integer> socks = new ArrayList<>();
for(int i = 0; i < K; i++){socks.add(scanner.nextInt());}
long[] prefixSum = new long[socks.size() + 1];
long[] suffixSum = new long[socks.size() + 1];
for(int i = 1; i <= socks.size(); i++){
prefixSum[i] = prefixSum[i-1];
if(i % 2 == 0) prefixSum[i] += socks.get(i-1) - socks.get(i-2);
}
for(int i = socks.size() - 1; i >= 0; i--){
suffixSum[i] = suffixSum[i + 1];
if(i % 2 == 0) suffixSum[i] += socks.get(i+1) - socks.get(i);
}
long res = Long.MAX_VALUE;
for (int i = 0; i <= K; i += 2) {
res = min(res, prefixSum[i] + suffixSum[i]);
}
out.println(res);
}
private static final boolean memory = true;
private static final boolean singleTest = true;
// ----- runner templates ----- //
void run() {
int numOfTests = singleTest ? 1 : scanner.nextInt();
for (int testIdx = 1; testIdx <= numOfTests; testIdx++) solve();
out.flush();
out.close();
}
// ----- runner templates ----- //
public static void main(String[] args) {
if (memory) new Thread(null, () -> new Main().run(), "go", 1 << 26).start();
else new Main().run();
}
//------ input and output ------//
public static FastScanner scanner = new FastScanner(System.in);
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return negative ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
return (char) c;
}
public String next() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isWhitespace(c));
return res.toString();
}
private boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
int[] nextIntArray(int n, int base) {
int[] arr = new int[n + base];
for (int i = base; i < n + base; i++) arr[i] = scanner.nextInt();
return arr;
}
long[] nextLongArray(int n, int base) {
long[] arr = new long[n + base];
for (int i = base; i < n + base; i++) arr[i] = scanner.nextLong();
return arr;
}
int[][] nextIntGrid(int n, int m, int base) {
int[][] grid = new int[n + base][m + base];
for (int i = base; i < n + base; i++) for (int j = base; j < m + base; j++) grid[i][j] = scanner.nextInt();
return grid;
}
char[][] nextCharGrid(int n, int m, int base) {
char[][] grid = new char[n + base][m + base];
for (int i = base; i < n + base; i++) for (int j = base; j < m + base; j++) grid[i][j] = scanner.nextChar();
return grid;
}
double[][] nextDoubleGrid(int n, int m, int base) {
double[][] grid = new double[n + base][m + base];
for (int i = base; i < n + base; i++) for (int j = base; j < m + base; j++) grid[i][j] = scanner.nextDouble();
return grid;
}
int[][] nextUnweightedGraph(int n, int m, int base) {
int[][] g = new int[base + n][];
int[][] edges = new int[m][2];
int[] adjSize = new int[n + base];
for (int i = 0; i < m; i++) {
int a = scanner.nextInt(), b = scanner.nextInt();
edges[i][0] = a;
adjSize[a]++;
edges[i][1] = b;
adjSize[b]++;
}
for (int i = base; i < base + n; i++) {
g[i] = new int[adjSize[i]];
adjSize[i] = 0;
}
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a][adjSize[a]++] = b;
g[b][adjSize[b]++] = a;
}
return g;
}
//------ debug and print functions ------//
void debug(Object... os) {
out.println(deepToString(os));
}
void print(int[] arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr[i]);
out.print(i == end ? '\n' : ' ');
}
}
void print(long[] arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr[i]);
out.print(i == end ? '\n' : ' ');
}
}
void print(char[] arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr[i]);
out.print(i == end ? '\n' : ' ');
}
}
void print(Object... o) {
for (int i = 0; i < o.length; i++) {
out.print(o[i]);
out.print(i == o.length - 1 ? '\n' : ' ');
}
}
<T> void printArrayList(List<T> arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr.get(i));
out.print(i == end ? '\n' : ' ');
}
}
//------ sort primitive type arrays ------//
static void sort(int[] arr) {
List<Integer> temp = new ArrayList<>();
for (int val : arr) temp.add(val);
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) arr[i] = temp.get(i);
}
static void sort(long[] arr) {
List<Long> temp = new ArrayList<>();
for (long val : arr) temp.add(val);
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) arr[i] = temp.get(i);
}
static void sort(char[] arr) {
List<Character> temp = new ArrayList<>();
for (char val : arr) temp.add(val);
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) arr[i] = temp.get(i);
}
}
import static java.util.Arrays.*;
import static java.lang.Math.*;
import java.io.*;
import java.util.*;
public class Main {
void solve() {
int N = scanner.nextInt();
int K = scanner.nextInt();
List<Integer> socks = new ArrayList<>();
for(int i = 0; i < K; i++){socks.add(scanner.nextInt());}
long[] prefixSum = new long[socks.size() + 1];
long[] suffixSum = new long[socks.size() + 1];
for(int i = 1; i <= socks.size(); i++){
prefixSum[i] = prefixSum[i-1];
if(i % 2 == 0) prefixSum[i] += socks.get(i-1) - socks.get(i-2);
}
for(int i = socks.size() - 1; i >= 0; i--){
suffixSum[i] = suffixSum[i + 1];
if((K-i) % 2 == 0) suffixSum[i] += socks.get(i+1) - socks.get(i);
}
long res = Long.MAX_VALUE;
for (int i = 0; i <= K; i += 2) {
res = min(res, prefixSum[i] + suffixSum[i]);
}
out.println(res);
}
private static final boolean memory = true;
private static final boolean singleTest = true;
// ----- runner templates ----- //
void run() {
int numOfTests = singleTest ? 1 : scanner.nextInt();
for (int testIdx = 1; testIdx <= numOfTests; testIdx++) solve();
out.flush();
out.close();
}
// ----- runner templates ----- //
public static void main(String[] args) {
if (memory) new Thread(null, () -> new Main().run(), "go", 1 << 26).start();
else new Main().run();
}
//------ input and output ------//
public static FastScanner scanner = new FastScanner(System.in);
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return negative ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
return (char) c;
}
public String next() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isWhitespace(c));
return res.toString();
}
private boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
int[] nextIntArray(int n, int base) {
int[] arr = new int[n + base];
for (int i = base; i < n + base; i++) arr[i] = scanner.nextInt();
return arr;
}
long[] nextLongArray(int n, int base) {
long[] arr = new long[n + base];
for (int i = base; i < n + base; i++) arr[i] = scanner.nextLong();
return arr;
}
int[][] nextIntGrid(int n, int m, int base) {
int[][] grid = new int[n + base][m + base];
for (int i = base; i < n + base; i++) for (int j = base; j < m + base; j++) grid[i][j] = scanner.nextInt();
return grid;
}
char[][] nextCharGrid(int n, int m, int base) {
char[][] grid = new char[n + base][m + base];
for (int i = base; i < n + base; i++) for (int j = base; j < m + base; j++) grid[i][j] = scanner.nextChar();
return grid;
}
double[][] nextDoubleGrid(int n, int m, int base) {
double[][] grid = new double[n + base][m + base];
for (int i = base; i < n + base; i++) for (int j = base; j < m + base; j++) grid[i][j] = scanner.nextDouble();
return grid;
}
int[][] nextUnweightedGraph(int n, int m, int base) {
int[][] g = new int[base + n][];
int[][] edges = new int[m][2];
int[] adjSize = new int[n + base];
for (int i = 0; i < m; i++) {
int a = scanner.nextInt(), b = scanner.nextInt();
edges[i][0] = a;
adjSize[a]++;
edges[i][1] = b;
adjSize[b]++;
}
for (int i = base; i < base + n; i++) {
g[i] = new int[adjSize[i]];
adjSize[i] = 0;
}
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a][adjSize[a]++] = b;
g[b][adjSize[b]++] = a;
}
return g;
}
//------ debug and print functions ------//
void debug(Object... os) {
out.println(deepToString(os));
}
void print(int[] arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr[i]);
out.print(i == end ? '\n' : ' ');
}
}
void print(long[] arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr[i]);
out.print(i == end ? '\n' : ' ');
}
}
void print(char[] arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr[i]);
out.print(i == end ? '\n' : ' ');
}
}
void print(Object... o) {
for (int i = 0; i < o.length; i++) {
out.print(o[i]);
out.print(i == o.length - 1 ? '\n' : ' ');
}
}
<T> void printArrayList(List<T> arr, int start, int end) {
for (int i = start; i <= end; i++) {
out.print(arr.get(i));
out.print(i == end ? '\n' : ' ');
}
}
//------ sort primitive type arrays ------//
static void sort(int[] arr) {
List<Integer> temp = new ArrayList<>();
for (int val : arr) temp.add(val);
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) arr[i] = temp.get(i);
}
static void sort(long[] arr) {
List<Long> temp = new ArrayList<>();
for (long val : arr) temp.add(val);
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) arr[i] = temp.get(i);
}
static void sort(char[] arr) {
List<Character> temp = new ArrayList<>();
for (char val : arr) temp.add(val);
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) arr[i] = temp.get(i);
}
} | ConDefects/ConDefects/Code/abc334_c/Java/50653319 |
condefects-java_data_1596 |
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int mod = (int) 1e9 + 7;
public static void main(String[] args) throws IOException {
int t = 1;
for (int o = 0; o < t; o++) {
int n = input.nextInt();
int k = input.nextInt();
int[] arr = new int[k];
for (int i = 0; i < k; i++) {
arr[i] = input.nextInt();
}
if (k % 2 == 0) {
long ans = 0;
for (int i = 1; i < k; i += 2) {
ans += arr[i] - arr[i - 1];
}
out.println(ans);
} else {
long[] pre = new long[k];
for (int i = 1; i < k; i += 2) {
pre[i] = arr[i] - arr[i - 1] + (i - 2 >= 0 ? pre[i - 2] : 0);
}
long[] nex = new long[k];
for (int i = k - 2; i >= 0; i -= 2) {
nex[i] = arr[i + 1] - arr[i] + (i + 2 < k ? pre[i + 2] : 0);
}
long ans = Long.MAX_VALUE;
for (int i = 0; i < k; i++) {
long res = 0;
if (i % 2 == 0) {
res += (i != 0 ?pre[i - 1]:0) + (i+1<k?nex[i + 1]:0);
} else {
if (i - 2 >= 0) res += pre[i - 2];
if (i + 1 < k) res += arr[i + 1] - arr[i - 1];
if (i + 2 < k) res+=nex[i+2];
}
ans =Math.min(ans, res);
}
out.println(ans);
}
}
out.flush();
out.close();
br.close();
}
public static class Node {
int l;
int r;
int val;
public Node(int l, int r, int val) {
this.l = l;
this.r = r;
this.val = val;
}
}
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static Input input = new Input(System.in);
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static class Input {
public BufferedReader reader;
public StringTokenizer tokenizer;
public Input(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
String str = null;
try {
str = reader.readLine();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return str;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public Double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
}
}
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int mod = (int) 1e9 + 7;
public static void main(String[] args) throws IOException {
int t = 1;
for (int o = 0; o < t; o++) {
int n = input.nextInt();
int k = input.nextInt();
int[] arr = new int[k];
for (int i = 0; i < k; i++) {
arr[i] = input.nextInt();
}
if (k % 2 == 0) {
long ans = 0;
for (int i = 1; i < k; i += 2) {
ans += arr[i] - arr[i - 1];
}
out.println(ans);
} else {
long[] pre = new long[k];
for (int i = 1; i < k; i += 2) {
pre[i] = arr[i] - arr[i - 1] + (i - 2 >= 0 ? pre[i - 2] : 0);
}
long[] nex = new long[k];
for (int i = k - 2; i >= 0; i -= 2) {
nex[i] = arr[i + 1] - arr[i] + (i + 2 < k ? nex[i + 2] : 0);
}
long ans = Long.MAX_VALUE;
for (int i = 0; i < k; i++) {
long res = 0;
if (i % 2 == 0) {
res += (i != 0 ?pre[i - 1]:0) + (i+1<k?nex[i + 1]:0);
} else {
if (i - 2 >= 0) res += pre[i - 2];
if (i + 1 < k) res += arr[i + 1] - arr[i - 1];
if (i + 2 < k) res+=nex[i+2];
}
ans =Math.min(ans, res);
}
out.println(ans);
}
}
out.flush();
out.close();
br.close();
}
public static class Node {
int l;
int r;
int val;
public Node(int l, int r, int val) {
this.l = l;
this.r = r;
this.val = val;
}
}
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static Input input = new Input(System.in);
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static class Input {
public BufferedReader reader;
public StringTokenizer tokenizer;
public Input(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
String str = null;
try {
str = reader.readLine();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return str;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public Double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
}
}
| ConDefects/ConDefects/Code/abc334_c/Java/50234620 |
condefects-java_data_1597 | import java.util.Scanner;
public class Main{
public static void main(String []args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = sc.nextInt();
int []arr = new int[n];
for (int i = 0;i < n;i++) {
arr[i] = sc.nextInt();
}
for (int i = 0;i < n;i++) {
if (arr[i] == x) {
System.out.println(i);
}
}
}
}
import java.util.Scanner;
public class Main{
public static void main(String []args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int x = sc.nextInt();
int []arr = new int[n];
for (int i = 0;i < n;i++) {
arr[i] = sc.nextInt();
}
for (int i = 0;i < n;i++) {
if (arr[i] == x) {
System.out.println(i + 1);
}
}
}
} | ConDefects/ConDefects/Code/abc277_a/Java/38824712 |
condefects-java_data_1598 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int X = sc.nextInt();
int[] P = inputInt(N,sc);
for(int i=0;i<N;i++) {
if(P[i]==X) {
print(i);
break;
}
}
sc.close();
}
private static boolean turn(boolean isClosed) {
// TODO 自動生成されたメソッド・スタブ
if(isClosed)
return false;
return true;
}
private static boolean isClear(char[][] s, int i, int j,int M) {
// TODO 自動生成されたメソッド・スタブ
for(int k=0;k<M;k++) {
if(!(s[i][k]=='o'||s[j][k]=='o')) {
//System.out.println("i="+i+"j="+j+"k="+k);
return false;
}
}
return true;
}
public static List<String> getUpperAlphabets(int K) {
//final int ALPHABET_SIZE = 'Z' - 'A';
int ALPHABET_SIZE = K;
char alphabet = 'A';
List<String> upperAlphabets = new ArrayList<String>();
for (int i = 0; i <= ALPHABET_SIZE; i++) {
upperAlphabets.add(String.valueOf(alphabet++));
}
return upperAlphabets;
}
public static boolean isAlphabet(char c) {
String s = String.valueOf(c);
boolean result = false;
if (s != null) {
Pattern pattern = Pattern.compile("^[A-Z]+$");
result = pattern.matcher(s).matches();
}
return result;
}
public static void print(int i) {
System.out.print(i);
}
public static void println(int i) {
System.out.println(i);
}
public static void print(long i) {
System.out.print(i);
}
public static void println(long i) {
System.out.println(i);
}
public static void print(String st) {
System.out.print(st);
}
public static void println(String st) {
System.out.println(st);
}
public static void printIndex(int[] ans) {
for (int o : ans) {
System.out.print(o + " ");
}
System.out.println();
}
public static int[] inputInt(int N, Scanner sc) {
int[] a = new int[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextInt();
}
return a;
}
public static double[] inputDouble(int N, Scanner sc) {
double[] a = new double[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextDouble();
}
return a;
}
public static String[] inputString(int N, Scanner sc) {
String[] a = new String[N];
for (int i = 0; i < N; i++) {
a[i] = sc.next();
}
return a;
}
public static Long[] inputLong(int N, Scanner sc) {
Long[] a = new Long[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextLong();
}
return a;
}
public static void sort(int[] array, int left, int right) {
if (left <= right) {
int p = array[(left + right) >>> 1];
int l = left;
int r = right;
while (l <= r) {
while (array[l] < p) {
l++;
}
while (array[r] > p) {
r--;
}
if (l <= r) {
int tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void sort(ArrayList<Integer> array, int left, int right) {
if (left <= right) {
int p = array.get((left + right) >>> 1);
int l = left;
int r = right;
while (l <= r) {
while (array.get(l) < p) {
l++;
}
while (array.get(r) > p) {
r--;
}
if (l <= r) {
int tmp = array.get(l);
array.set(l, array.get(r));
array.set(r, tmp);
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void sort(double[] array, int left, int right) {
if (left <= right) {
double p = array[(left + right) >>> 1];
int l = left;
int r = right;
while (l <= r) {
while (array[l] < p) {
l++;
}
while (array[r] > p) {
r--;
}
if (l <= r) {
double tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void sort(Long[] array, int left, int right) {
if (left <= right) {
Long p = array[(left + right) >>> 1];
int l = left;
int r = right;
while (l <= r) {
while (array[l] < p) {
l++;
}
while (array[r] > p) {
r--;
}
if (l <= r) {
Long tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void printYes() {
System.out.println("Yes");
}
public static void printNo() {
System.out.println("No");
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int X = sc.nextInt();
int[] P = inputInt(N,sc);
for(int i=0;i<N;i++) {
if(P[i]==X) {
print(i+1);
break;
}
}
sc.close();
}
private static boolean turn(boolean isClosed) {
// TODO 自動生成されたメソッド・スタブ
if(isClosed)
return false;
return true;
}
private static boolean isClear(char[][] s, int i, int j,int M) {
// TODO 自動生成されたメソッド・スタブ
for(int k=0;k<M;k++) {
if(!(s[i][k]=='o'||s[j][k]=='o')) {
//System.out.println("i="+i+"j="+j+"k="+k);
return false;
}
}
return true;
}
public static List<String> getUpperAlphabets(int K) {
//final int ALPHABET_SIZE = 'Z' - 'A';
int ALPHABET_SIZE = K;
char alphabet = 'A';
List<String> upperAlphabets = new ArrayList<String>();
for (int i = 0; i <= ALPHABET_SIZE; i++) {
upperAlphabets.add(String.valueOf(alphabet++));
}
return upperAlphabets;
}
public static boolean isAlphabet(char c) {
String s = String.valueOf(c);
boolean result = false;
if (s != null) {
Pattern pattern = Pattern.compile("^[A-Z]+$");
result = pattern.matcher(s).matches();
}
return result;
}
public static void print(int i) {
System.out.print(i);
}
public static void println(int i) {
System.out.println(i);
}
public static void print(long i) {
System.out.print(i);
}
public static void println(long i) {
System.out.println(i);
}
public static void print(String st) {
System.out.print(st);
}
public static void println(String st) {
System.out.println(st);
}
public static void printIndex(int[] ans) {
for (int o : ans) {
System.out.print(o + " ");
}
System.out.println();
}
public static int[] inputInt(int N, Scanner sc) {
int[] a = new int[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextInt();
}
return a;
}
public static double[] inputDouble(int N, Scanner sc) {
double[] a = new double[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextDouble();
}
return a;
}
public static String[] inputString(int N, Scanner sc) {
String[] a = new String[N];
for (int i = 0; i < N; i++) {
a[i] = sc.next();
}
return a;
}
public static Long[] inputLong(int N, Scanner sc) {
Long[] a = new Long[N];
for (int i = 0; i < N; i++) {
a[i] = sc.nextLong();
}
return a;
}
public static void sort(int[] array, int left, int right) {
if (left <= right) {
int p = array[(left + right) >>> 1];
int l = left;
int r = right;
while (l <= r) {
while (array[l] < p) {
l++;
}
while (array[r] > p) {
r--;
}
if (l <= r) {
int tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void sort(ArrayList<Integer> array, int left, int right) {
if (left <= right) {
int p = array.get((left + right) >>> 1);
int l = left;
int r = right;
while (l <= r) {
while (array.get(l) < p) {
l++;
}
while (array.get(r) > p) {
r--;
}
if (l <= r) {
int tmp = array.get(l);
array.set(l, array.get(r));
array.set(r, tmp);
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void sort(double[] array, int left, int right) {
if (left <= right) {
double p = array[(left + right) >>> 1];
int l = left;
int r = right;
while (l <= r) {
while (array[l] < p) {
l++;
}
while (array[r] > p) {
r--;
}
if (l <= r) {
double tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void sort(Long[] array, int left, int right) {
if (left <= right) {
Long p = array[(left + right) >>> 1];
int l = left;
int r = right;
while (l <= r) {
while (array[l] < p) {
l++;
}
while (array[r] > p) {
r--;
}
if (l <= r) {
Long tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
Main.sort(array, left, r);
Main.sort(array, l, right);
}
}
public static void printYes() {
System.out.println("Yes");
}
public static void printNo() {
System.out.println("No");
}
}
| ConDefects/ConDefects/Code/abc277_a/Java/37375594 |
condefects-java_data_1599 | import java.io.*;
import java.lang.reflect.Array;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.function.IntFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public final class Main {
public static void main(String[] args) throws IOException {
run(System.in, new PrintStream(new BufferedOutputStream(System.out), false, StandardCharsets.UTF_8));
}
@SuppressWarnings({"DuplicatedCode", "SameParameterValue"})
static void run(InputStream in, PrintStream out) throws IOException {
FastScanner scanner = new FastScanner(in);
var n = scanner.nextUint();
var abs = scanner.nextUints(n, 2);
out.println(solve(abs) ? "Takashi" : "Aoki");
out.flush();
}
static boolean solve(int[]... abs) {
var cache = new byte[1 << abs.length];
return solve0(abs, cache, 0) == 1;
}
private static byte solve0(int[][] abs, byte[] cache, int selection) {
if (cache[selection] == 0) {
cache[selection] = 2;
outer:
for (int card0 = 0; card0 < abs.length - 1; card0++) {
if ((selection & (1 << card0)) != 0) {
continue;
}
for (int card1 = card0 + 1; card1 < abs.length; card1++) {
if ((selection & (1 << card1)) != 0) {
continue;
}
if (abs[card0][0] == abs[card1][0] || abs[card0][1] == abs[card1][1]) {
if (solve0(abs, cache, selection | (1 << card0) | (1 << card1)) == 2) {
cache[selection] = 1;
break outer;
}
}
}
}
}
return cache[selection];
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printIntsLn(PrintStream out, int... ints) {
printIntsLn(out, ints, " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printIntsLn(PrintStream out, int[] ints, String separator) {
for (int i = 0; i < ints.length; i++) {
if (i != 0) {
out.print(separator);
}
out.print(ints[i]);
}
out.println();
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printLongsLn(PrintStream out, long... longs) {
printLongsLn(out, longs, " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printLongsLn(PrintStream out, long[] longs, String separator) {
for (int i = 0; i < longs.length; i++) {
if (i != 0) {
out.print(separator);
}
out.print(longs[i]);
}
out.println();
}
@SuppressWarnings({"DuplicatedCode", "unused"})
@SafeVarargs
static <T> void printObjectsLn(PrintStream out, T... objects) {
printObjectsLn(out, List.of(objects), " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printObjectsLn(PrintStream out, Collection<?> objects) {
printObjectsLn(out, objects, " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printObjectsLn(PrintStream out, Collection<?> objects, String separator) {
var first = true;
for (Object object : objects) {
if (!first) {
out.print(separator);
}
out.print(object);
first = false;
}
out.println();
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int minOf(int... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Integer.MAX_VALUE;
for (int i : is) {
res = Math.min(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int maxOf(int... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Integer.MIN_VALUE;
for (int i : is) {
res = Math.max(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long minOf(long... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Long.MAX_VALUE;
for (long i : is) {
res = Math.min(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long maxOf(long... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Long.MIN_VALUE;
for (long i : is) {
res = Math.max(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
record MinMax<T>(T min, T max) {
static MinMax<Integer> from(int... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var min = Integer.MAX_VALUE;
var max = Integer.MIN_VALUE;
for (int x : is) {
min = Math.min(min, x);
max = Math.max(max, x);
}
return new MinMax<>(min, max);
}
static MinMax<Long> from(long... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var min = Long.MAX_VALUE;
var max = Long.MIN_VALUE;
for (long x : is) {
min = Math.min(min, x);
max = Math.max(max, x);
}
return new MinMax<>(min, max);
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> ArrayList<T> fillList(int n, Supplier<T> supplier) {
return fillList(n, ignore -> supplier.get());
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> ArrayList<T> fillList(int n, IntFunction<T> valueAt) {
var res = new ArrayList<T>(n);
for (int i = 0; i < n; i++) {
res.add(valueAt.apply(i));
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> T[] fillArray(int n, Class<T> clazz, Supplier<T> supplier) {
return fillArray(n, clazz, ignore -> supplier.get());
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> T[] fillArray(int n, Class<T> clazz, IntFunction<T> valueAt) {
@SuppressWarnings("unchecked") var res = (T[]) Array.newInstance(clazz, n);
for (int i = 0; i < n; i++) {
res[i] = valueAt.apply(i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused", "SameParameterValue"})
static <T> T[] fillArray(int n, T value) {
@SuppressWarnings("unchecked") var res = (T[]) Array.newInstance(value.getClass(), n);
Arrays.fill(res, value);
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int[] fillIntArray(int n, IntUnaryOperator valueAt) {
var res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = valueAt.applyAsInt(i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int[] fillIntArray(int n, int value) {
var res = new int[n];
Arrays.fill(res, value);
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long[] fillLongArray(int n, IntToLongFunction valueAt) {
var res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = valueAt.applyAsLong(i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long[] fillLongArray(int n, long value) {
var res = new long[n];
Arrays.fill(res, value);
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
record BinaryString(BitSet bits, int length) {
public BinaryString {
if (length < 0) throw new IndexOutOfBoundsException("" + length);
}
@Override
public String toString() {
return IntStream.range(0, length)
.mapToObj(i -> bits.get(i) ? "1" : "0")
.collect(Collectors.joining());
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
record BinaryGrid(BitSet[] bits, int w) {
BinaryGrid {
if (w < 0) throw new IndexOutOfBoundsException("w=" + w);
}
int h() {
return bits.length;
}
BitSet row(int i) {
return bits[i];
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
BinaryGrid that = (BinaryGrid) o;
if (w != that.w) return false;
return Arrays.equals(bits, that.bits);
}
@Override
public int hashCode() {
int result = Arrays.hashCode(bits);
result = 31 * result + w;
return result;
}
@Override
public String toString() {
return Arrays.stream(bits, 0, h())
.map(row -> IntStream.range(0, w).mapToObj(j -> row.get(j) ? "1" : "0").collect(Collectors.joining()))
.collect(Collectors.joining("\n"));
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static final class Adj {
static ArrayList<ArrayList<Integer>> undirected(int n, int[][] edges) {
return undirected(n, edges, 1);
}
static ArrayList<ArrayList<Integer>> directed(int n, int[][] edges) {
return directed(n, edges, 1);
}
@SuppressWarnings("SameParameterValue")
static ArrayList<ArrayList<Integer>> undirected(int n, int[][] edges, int offset) {
var res = fillList(n, () -> new ArrayList<Integer>(1));
for (int[] edge : edges) {
res.get(edge[0] - offset).add(edge[1] - offset);
res.get(edge[1] - offset).add(edge[0] - offset);
}
return res;
}
@SuppressWarnings("SameParameterValue")
static ArrayList<ArrayList<Integer>> directed(int n, int[][] edges, int offset) {
var res = fillList(n, () -> new ArrayList<Integer>(1));
for (int[] edge : edges) {
res.get(edge[0] - offset).add(edge[1] - offset);
}
return res;
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long gcd(long a, long b) {
while (b != 0) {
var bb = a % b;
a = b;
b = bb;
}
return a;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int gcd(int a, int b) {
while (b != 0) {
var bb = a % b;
a = b;
b = bb;
}
return a;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static final class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[4 * 1024];
private int a = 0;
private int b = 0;
FastScanner(InputStream in) {
this.in = in;
}
byte nextByte() throws IOException {
if (a < b) {
byte v = buf[a];
a += 1;
return v;
} else {
b = in.read(buf);
if (b < 0) {
throw new EOFException();
} else {
a = 0;
return nextByte();
}
}
}
boolean hasNext() throws IOException {
if (a < b) return true;
else if (b < 0) return false;
else {
b = in.read(buf);
a = 0;
return hasNext();
}
}
char nextChar() throws IOException {
return (char) nextByte();
}
char nextNonWhitespaceChar() throws IOException {
while (true) {
var c = nextChar();
if (!Character.isWhitespace(c)) {
return c;
}
}
}
long nextLong() throws IOException {
while (true) {
char c = nextChar();
if (c == '-') {
c = nextChar();
if (isAsciiDigit(c)) {
return Math.negateExact(nextUlongImpl(c));
}
} else if (isAsciiDigit(c)) {
return nextUlongImpl(c);
}
}
}
long[] nextLongs(int n) throws IOException {
long[] res = new long[n];
for (int i = 0; i < n; ++i) {
res[i] = nextLong();
}
return res;
}
long[][] nextLongs(int rows, int cols) throws IOException {
long[][] res = new long[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextLong();
}
}
return res;
}
long nextUlong() throws IOException {
long res = nextLong();
if (res < 0) throw new IllegalArgumentException("Expected a positive number, but got " + res);
return res;
}
long[] nextUlongs(int n) throws IOException {
long[] res = new long[n];
for (int i = 0; i < n; ++i) {
res[i] = nextUlong();
}
return res;
}
long[][] nextUlongs(int rows, int cols) throws IOException {
long[][] res = new long[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextUlong();
}
}
return res;
}
int nextInt() throws IOException {
return Math.toIntExact(nextLong());
}
int[] nextInts(int n) throws IOException {
int[] res = new int[n];
for (int i = 0; i < n; ++i) {
res[i] = nextInt();
}
return res;
}
int[][] nextInts(int rows, int cols) throws IOException {
int[][] res = new int[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextInt();
}
}
return res;
}
int nextUint() throws IOException {
return Math.toIntExact(nextUlong());
}
int[] nextUints(int n) throws IOException {
int[] res = new int[n];
for (int i = 0; i < n; ++i) {
res[i] = nextUint();
}
return res;
}
int[][] nextUints(int rows, int cols) throws IOException {
int[][] res = new int[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextUint();
}
}
return res;
}
<T> T[] nextObjects(int n, Class<T> clazz, IOExceptionThrowingSupplier<T> supplier) throws IOException {
@SuppressWarnings("unchecked") T[] ret = (T[]) Array.newInstance(clazz, n);
for (int i = 0; i < n; i++) {
ret[i] = supplier.get();
}
return ret;
}
String nextLine() throws IOException {
StringBuilder sb = new StringBuilder();
char c = nextChar();
while (c != '\n') {
sb.append(c);
if (!hasNext()) {
break;
} else {
c = nextChar();
}
}
if (!sb.isEmpty() && c == '\n' && sb.charAt(sb.length() - 1) == '\r') {
sb.setLength(sb.length() - 1);
}
return sb.toString();
}
String[] nextLines(int n) throws IOException {
if (n < 0) {
n = nextUint();
skipToNextLine();
}
return nextObjects(n, String.class, this::nextLine);
}
String[] nextLines() throws IOException {
return nextLines(-1);
}
void skipToNextLine() throws IOException {
//noinspection StatementWithEmptyBody
while (nextChar() != '\n') {
// just skip to next character
}
}
BinaryString nextBinaryString() throws IOException {
return nextBinaryString('1');
}
BinaryString nextBinaryString(char cTrue) throws IOException {
return nextBinaryStringImpl(cTrue, -1);
}
BinaryString nextBinaryString(char cTrue, int length) throws IOException {
if (length < 0) throw new IndexOutOfBoundsException("" + length);
return nextBinaryStringImpl(cTrue, length);
}
BinaryGrid nextBinaryGrid(char cTrue) throws IOException {
return nextBinaryGridImpl(cTrue, -1, -1);
}
BinaryGrid nextBinaryGrid(char cTrue, int h, int w) throws IOException {
return nextBinaryGridImpl(cTrue, h, w);
}
private BinaryGrid nextBinaryGridImpl(char cTrue, int h, int w) throws IOException {
if (h < 0) {
h = nextUint();
w = nextUint();
if (h > 0) {
skipToNextLine();
}
}
var bits = new BitSet[h];
for (int i = 0; i < h; i++) {
var row = new BitSet(w);
for (int j = 0; j < w; j++) {
if (nextChar() == cTrue) {
row.set(j);
}
}
bits[i] = row;
if (i != h - 1 || hasNext()) {
skipToNextLine();
}
}
return new BinaryGrid(bits, w);
}
private BinaryString nextBinaryStringImpl(char cTrue, int length) throws IOException {
if (length < 0) {
length = nextUint();
skipToNextLine();
}
BitSet bits = new BitSet(length);
for (int i = 0; i < length; ++i) {
if (nextChar() == cTrue) {
bits.set(i);
}
}
return new BinaryString(bits, length);
}
private long nextUlongImpl(char firstDigit) throws IOException {
long res = 0;
char c = firstDigit;
do {
long res2 = 10 * res + (c - '0');
if (res2 >= res) {
res = res2;
} else {
throw new ArithmeticException("Long overflow");
}
if (hasNext()) {
c = nextChar();
} else {
c = 0;
}
} while (isAsciiDigit(c));
if (c != 0 && !isAsciiDigit(c)) {
a -= 1;
}
return res;
}
private static boolean isAsciiDigit(char c) {
return '0' <= c && c <= '9';
}
}
interface IOExceptionThrowingSupplier<T> {
T get() throws IOException;
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.function.IntFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public final class Main {
public static void main(String[] args) throws IOException {
run(System.in, new PrintStream(new BufferedOutputStream(System.out), false, StandardCharsets.UTF_8));
}
@SuppressWarnings({"DuplicatedCode", "SameParameterValue"})
static void run(InputStream in, PrintStream out) throws IOException {
FastScanner scanner = new FastScanner(in);
var n = scanner.nextUint();
var abs = scanner.nextUints(n, 2);
out.print(solve(abs) ? "Takahashi" : "Aoki");
out.flush();
}
static boolean solve(int[]... abs) {
var cache = new byte[1 << abs.length];
return solve0(abs, cache, 0) == 1;
}
private static byte solve0(int[][] abs, byte[] cache, int selection) {
if (cache[selection] == 0) {
cache[selection] = 2;
outer:
for (int card0 = 0; card0 < abs.length - 1; card0++) {
if ((selection & (1 << card0)) != 0) {
continue;
}
for (int card1 = card0 + 1; card1 < abs.length; card1++) {
if ((selection & (1 << card1)) != 0) {
continue;
}
if (abs[card0][0] == abs[card1][0] || abs[card0][1] == abs[card1][1]) {
if (solve0(abs, cache, selection | (1 << card0) | (1 << card1)) == 2) {
cache[selection] = 1;
break outer;
}
}
}
}
}
return cache[selection];
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printIntsLn(PrintStream out, int... ints) {
printIntsLn(out, ints, " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printIntsLn(PrintStream out, int[] ints, String separator) {
for (int i = 0; i < ints.length; i++) {
if (i != 0) {
out.print(separator);
}
out.print(ints[i]);
}
out.println();
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printLongsLn(PrintStream out, long... longs) {
printLongsLn(out, longs, " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printLongsLn(PrintStream out, long[] longs, String separator) {
for (int i = 0; i < longs.length; i++) {
if (i != 0) {
out.print(separator);
}
out.print(longs[i]);
}
out.println();
}
@SuppressWarnings({"DuplicatedCode", "unused"})
@SafeVarargs
static <T> void printObjectsLn(PrintStream out, T... objects) {
printObjectsLn(out, List.of(objects), " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printObjectsLn(PrintStream out, Collection<?> objects) {
printObjectsLn(out, objects, " ");
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static void printObjectsLn(PrintStream out, Collection<?> objects, String separator) {
var first = true;
for (Object object : objects) {
if (!first) {
out.print(separator);
}
out.print(object);
first = false;
}
out.println();
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int minOf(int... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Integer.MAX_VALUE;
for (int i : is) {
res = Math.min(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int maxOf(int... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Integer.MIN_VALUE;
for (int i : is) {
res = Math.max(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long minOf(long... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Long.MAX_VALUE;
for (long i : is) {
res = Math.min(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long maxOf(long... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var res = Long.MIN_VALUE;
for (long i : is) {
res = Math.max(res, i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
record MinMax<T>(T min, T max) {
static MinMax<Integer> from(int... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var min = Integer.MAX_VALUE;
var max = Integer.MIN_VALUE;
for (int x : is) {
min = Math.min(min, x);
max = Math.max(max, x);
}
return new MinMax<>(min, max);
}
static MinMax<Long> from(long... is) {
if (is.length == 0) {
throw new IllegalArgumentException();
}
var min = Long.MAX_VALUE;
var max = Long.MIN_VALUE;
for (long x : is) {
min = Math.min(min, x);
max = Math.max(max, x);
}
return new MinMax<>(min, max);
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> ArrayList<T> fillList(int n, Supplier<T> supplier) {
return fillList(n, ignore -> supplier.get());
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> ArrayList<T> fillList(int n, IntFunction<T> valueAt) {
var res = new ArrayList<T>(n);
for (int i = 0; i < n; i++) {
res.add(valueAt.apply(i));
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> T[] fillArray(int n, Class<T> clazz, Supplier<T> supplier) {
return fillArray(n, clazz, ignore -> supplier.get());
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static <T> T[] fillArray(int n, Class<T> clazz, IntFunction<T> valueAt) {
@SuppressWarnings("unchecked") var res = (T[]) Array.newInstance(clazz, n);
for (int i = 0; i < n; i++) {
res[i] = valueAt.apply(i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused", "SameParameterValue"})
static <T> T[] fillArray(int n, T value) {
@SuppressWarnings("unchecked") var res = (T[]) Array.newInstance(value.getClass(), n);
Arrays.fill(res, value);
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int[] fillIntArray(int n, IntUnaryOperator valueAt) {
var res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = valueAt.applyAsInt(i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int[] fillIntArray(int n, int value) {
var res = new int[n];
Arrays.fill(res, value);
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long[] fillLongArray(int n, IntToLongFunction valueAt) {
var res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = valueAt.applyAsLong(i);
}
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long[] fillLongArray(int n, long value) {
var res = new long[n];
Arrays.fill(res, value);
return res;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
record BinaryString(BitSet bits, int length) {
public BinaryString {
if (length < 0) throw new IndexOutOfBoundsException("" + length);
}
@Override
public String toString() {
return IntStream.range(0, length)
.mapToObj(i -> bits.get(i) ? "1" : "0")
.collect(Collectors.joining());
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
record BinaryGrid(BitSet[] bits, int w) {
BinaryGrid {
if (w < 0) throw new IndexOutOfBoundsException("w=" + w);
}
int h() {
return bits.length;
}
BitSet row(int i) {
return bits[i];
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
BinaryGrid that = (BinaryGrid) o;
if (w != that.w) return false;
return Arrays.equals(bits, that.bits);
}
@Override
public int hashCode() {
int result = Arrays.hashCode(bits);
result = 31 * result + w;
return result;
}
@Override
public String toString() {
return Arrays.stream(bits, 0, h())
.map(row -> IntStream.range(0, w).mapToObj(j -> row.get(j) ? "1" : "0").collect(Collectors.joining()))
.collect(Collectors.joining("\n"));
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static final class Adj {
static ArrayList<ArrayList<Integer>> undirected(int n, int[][] edges) {
return undirected(n, edges, 1);
}
static ArrayList<ArrayList<Integer>> directed(int n, int[][] edges) {
return directed(n, edges, 1);
}
@SuppressWarnings("SameParameterValue")
static ArrayList<ArrayList<Integer>> undirected(int n, int[][] edges, int offset) {
var res = fillList(n, () -> new ArrayList<Integer>(1));
for (int[] edge : edges) {
res.get(edge[0] - offset).add(edge[1] - offset);
res.get(edge[1] - offset).add(edge[0] - offset);
}
return res;
}
@SuppressWarnings("SameParameterValue")
static ArrayList<ArrayList<Integer>> directed(int n, int[][] edges, int offset) {
var res = fillList(n, () -> new ArrayList<Integer>(1));
for (int[] edge : edges) {
res.get(edge[0] - offset).add(edge[1] - offset);
}
return res;
}
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static long gcd(long a, long b) {
while (b != 0) {
var bb = a % b;
a = b;
b = bb;
}
return a;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static int gcd(int a, int b) {
while (b != 0) {
var bb = a % b;
a = b;
b = bb;
}
return a;
}
@SuppressWarnings({"DuplicatedCode", "unused"})
static final class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[4 * 1024];
private int a = 0;
private int b = 0;
FastScanner(InputStream in) {
this.in = in;
}
byte nextByte() throws IOException {
if (a < b) {
byte v = buf[a];
a += 1;
return v;
} else {
b = in.read(buf);
if (b < 0) {
throw new EOFException();
} else {
a = 0;
return nextByte();
}
}
}
boolean hasNext() throws IOException {
if (a < b) return true;
else if (b < 0) return false;
else {
b = in.read(buf);
a = 0;
return hasNext();
}
}
char nextChar() throws IOException {
return (char) nextByte();
}
char nextNonWhitespaceChar() throws IOException {
while (true) {
var c = nextChar();
if (!Character.isWhitespace(c)) {
return c;
}
}
}
long nextLong() throws IOException {
while (true) {
char c = nextChar();
if (c == '-') {
c = nextChar();
if (isAsciiDigit(c)) {
return Math.negateExact(nextUlongImpl(c));
}
} else if (isAsciiDigit(c)) {
return nextUlongImpl(c);
}
}
}
long[] nextLongs(int n) throws IOException {
long[] res = new long[n];
for (int i = 0; i < n; ++i) {
res[i] = nextLong();
}
return res;
}
long[][] nextLongs(int rows, int cols) throws IOException {
long[][] res = new long[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextLong();
}
}
return res;
}
long nextUlong() throws IOException {
long res = nextLong();
if (res < 0) throw new IllegalArgumentException("Expected a positive number, but got " + res);
return res;
}
long[] nextUlongs(int n) throws IOException {
long[] res = new long[n];
for (int i = 0; i < n; ++i) {
res[i] = nextUlong();
}
return res;
}
long[][] nextUlongs(int rows, int cols) throws IOException {
long[][] res = new long[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextUlong();
}
}
return res;
}
int nextInt() throws IOException {
return Math.toIntExact(nextLong());
}
int[] nextInts(int n) throws IOException {
int[] res = new int[n];
for (int i = 0; i < n; ++i) {
res[i] = nextInt();
}
return res;
}
int[][] nextInts(int rows, int cols) throws IOException {
int[][] res = new int[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextInt();
}
}
return res;
}
int nextUint() throws IOException {
return Math.toIntExact(nextUlong());
}
int[] nextUints(int n) throws IOException {
int[] res = new int[n];
for (int i = 0; i < n; ++i) {
res[i] = nextUint();
}
return res;
}
int[][] nextUints(int rows, int cols) throws IOException {
int[][] res = new int[rows][cols];
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
res[i][j] = nextUint();
}
}
return res;
}
<T> T[] nextObjects(int n, Class<T> clazz, IOExceptionThrowingSupplier<T> supplier) throws IOException {
@SuppressWarnings("unchecked") T[] ret = (T[]) Array.newInstance(clazz, n);
for (int i = 0; i < n; i++) {
ret[i] = supplier.get();
}
return ret;
}
String nextLine() throws IOException {
StringBuilder sb = new StringBuilder();
char c = nextChar();
while (c != '\n') {
sb.append(c);
if (!hasNext()) {
break;
} else {
c = nextChar();
}
}
if (!sb.isEmpty() && c == '\n' && sb.charAt(sb.length() - 1) == '\r') {
sb.setLength(sb.length() - 1);
}
return sb.toString();
}
String[] nextLines(int n) throws IOException {
if (n < 0) {
n = nextUint();
skipToNextLine();
}
return nextObjects(n, String.class, this::nextLine);
}
String[] nextLines() throws IOException {
return nextLines(-1);
}
void skipToNextLine() throws IOException {
//noinspection StatementWithEmptyBody
while (nextChar() != '\n') {
// just skip to next character
}
}
BinaryString nextBinaryString() throws IOException {
return nextBinaryString('1');
}
BinaryString nextBinaryString(char cTrue) throws IOException {
return nextBinaryStringImpl(cTrue, -1);
}
BinaryString nextBinaryString(char cTrue, int length) throws IOException {
if (length < 0) throw new IndexOutOfBoundsException("" + length);
return nextBinaryStringImpl(cTrue, length);
}
BinaryGrid nextBinaryGrid(char cTrue) throws IOException {
return nextBinaryGridImpl(cTrue, -1, -1);
}
BinaryGrid nextBinaryGrid(char cTrue, int h, int w) throws IOException {
return nextBinaryGridImpl(cTrue, h, w);
}
private BinaryGrid nextBinaryGridImpl(char cTrue, int h, int w) throws IOException {
if (h < 0) {
h = nextUint();
w = nextUint();
if (h > 0) {
skipToNextLine();
}
}
var bits = new BitSet[h];
for (int i = 0; i < h; i++) {
var row = new BitSet(w);
for (int j = 0; j < w; j++) {
if (nextChar() == cTrue) {
row.set(j);
}
}
bits[i] = row;
if (i != h - 1 || hasNext()) {
skipToNextLine();
}
}
return new BinaryGrid(bits, w);
}
private BinaryString nextBinaryStringImpl(char cTrue, int length) throws IOException {
if (length < 0) {
length = nextUint();
skipToNextLine();
}
BitSet bits = new BitSet(length);
for (int i = 0; i < length; ++i) {
if (nextChar() == cTrue) {
bits.set(i);
}
}
return new BinaryString(bits, length);
}
private long nextUlongImpl(char firstDigit) throws IOException {
long res = 0;
char c = firstDigit;
do {
long res2 = 10 * res + (c - '0');
if (res2 >= res) {
res = res2;
} else {
throw new ArithmeticException("Long overflow");
}
if (hasNext()) {
c = nextChar();
} else {
c = 0;
}
} while (isAsciiDigit(c));
if (c != 0 && !isAsciiDigit(c)) {
a -= 1;
}
return res;
}
private static boolean isAsciiDigit(char c) {
return '0' <= c && c <= '9';
}
}
interface IOExceptionThrowingSupplier<T> {
T get() throws IOException;
}
} | ConDefects/ConDefects/Code/abc354_e/Java/53648983 |
condefects-java_data_1600 | import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
static final long MOD = 998244353;
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
int MAX = 200010;
int[] cnt = new int[MAX];
for (int i = 0; i < N; i++) {
cnt[A[i]]++;
}
long[][] dp = new long[2][];
dp[0] = new long[1];
dp[0][0] = 1;
for (int i = 0; i < MAX; i++) {
int ci = i % 2;
int ni = (i + 1) % 2;
int cn = dp[ci].length;
int nn = (cnt[i] + cn - 1) / 2;
dp[ni] = new long[nn + 1];
long[] sum = new long[cn + 1];
for (int j = 1; j <= cn; j++) {
sum[j] = (sum[j - 1] + dp[ci][j - 1]) % MOD;
}
for (int j = 0; j <= nn; j++) {
int j0 = Math.max(2 * j - cnt[i], 0);
if ( cn < j0 ) break;
dp[ni][j] = (dp[ni][j] + sum[cn] - sum[j0] + MOD) % MOD;
}
}
long ans = 0;
for (int i = 0; i < dp[MAX % 2].length; i++) {
ans = (ans + dp[MAX % 2][i]) % MOD;
}
System.out.println(ans);
}
class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner( InputStream source ) { this.in = source; }
private boolean hasNextByte() {
if ( ptr < buflen ) return true;
else {
ptr = 0;
try { buflen = in.read(buf); } catch (IOException e) { e.printStackTrace(); }
if ( buflen <= 0 ) return false;
}
return true;
}
private int readByte() { if ( hasNextByte() ) return buf[ptr++]; else return -1; }
private boolean isPrintableChar( int c ) { return 33 <= c && c <= 126; }
private boolean isNumeric( int c ) { return '0' <= c && c <= '9'; }
private void skipToNextPrintableChar() { while ( hasNextByte() && !isPrintableChar(buf[ptr]) ) ptr++; }
public boolean hasNext() { skipToNextPrintableChar(); return hasNextByte(); }
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
StringBuilder ret = new StringBuilder();
int b = readByte();
while ( isPrintableChar(b) ) { ret.appendCodePoint(b); b = readByte(); }
return ret.toString();
}
public long nextLong() {
if ( !hasNext() ) throw new NoSuchElementException();
long ret = 0;
int b = readByte();
boolean negative = false;
if ( b == '-' ) { negative = true; if ( hasNextByte() ) b = readByte(); }
if ( !isNumeric(b) ) throw new NumberFormatException();
while ( true ) {
if ( isNumeric(b) ) ret = ret * 10 + b - '0';
else if ( b == -1 || !isPrintableChar(b) ) return negative ? -ret : ret;
else throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() { return (int)nextLong(); }
public double nextDouble() { return Double.parseDouble(next()); }
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
static final long MOD = 998244353;
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
int MAX = 200200;
int[] cnt = new int[MAX];
for (int i = 0; i < N; i++) {
cnt[A[i]]++;
}
long[][] dp = new long[2][];
dp[0] = new long[1];
dp[0][0] = 1;
for (int i = 0; i < MAX; i++) {
int ci = i % 2;
int ni = (i + 1) % 2;
int cn = dp[ci].length;
int nn = (cnt[i] + cn - 1) / 2;
dp[ni] = new long[nn + 1];
long[] sum = new long[cn + 1];
for (int j = 1; j <= cn; j++) {
sum[j] = (sum[j - 1] + dp[ci][j - 1]) % MOD;
}
for (int j = 0; j <= nn; j++) {
int j0 = Math.max(2 * j - cnt[i], 0);
if ( cn < j0 ) break;
dp[ni][j] = (dp[ni][j] + sum[cn] - sum[j0] + MOD) % MOD;
}
}
long ans = 0;
for (int i = 0; i < dp[MAX % 2].length; i++) {
ans = (ans + dp[MAX % 2][i]) % MOD;
}
System.out.println(ans);
}
class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner( InputStream source ) { this.in = source; }
private boolean hasNextByte() {
if ( ptr < buflen ) return true;
else {
ptr = 0;
try { buflen = in.read(buf); } catch (IOException e) { e.printStackTrace(); }
if ( buflen <= 0 ) return false;
}
return true;
}
private int readByte() { if ( hasNextByte() ) return buf[ptr++]; else return -1; }
private boolean isPrintableChar( int c ) { return 33 <= c && c <= 126; }
private boolean isNumeric( int c ) { return '0' <= c && c <= '9'; }
private void skipToNextPrintableChar() { while ( hasNextByte() && !isPrintableChar(buf[ptr]) ) ptr++; }
public boolean hasNext() { skipToNextPrintableChar(); return hasNextByte(); }
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
StringBuilder ret = new StringBuilder();
int b = readByte();
while ( isPrintableChar(b) ) { ret.appendCodePoint(b); b = readByte(); }
return ret.toString();
}
public long nextLong() {
if ( !hasNext() ) throw new NoSuchElementException();
long ret = 0;
int b = readByte();
boolean negative = false;
if ( b == '-' ) { negative = true; if ( hasNextByte() ) b = readByte(); }
if ( !isNumeric(b) ) throw new NumberFormatException();
while ( true ) {
if ( isNumeric(b) ) ret = ret * 10 + b - '0';
else if ( b == -1 || !isPrintableChar(b) ) return negative ? -ret : ret;
else throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() { return (int)nextLong(); }
public double nextDouble() { return Double.parseDouble(next()); }
}
}
| ConDefects/ConDefects/Code/arc160_c/Java/41421930 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.