id
stringlengths 22
25
| content
stringlengths 327
628k
| max_stars_repo_path
stringlengths 49
49
|
|---|---|---|
condefects-java_data_801
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static Set<char[]> set = new HashSet<>();
static void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
char[] s = scanner.next().toCharArray();
for (long i = 1; i * i <= (long)Math.pow(10, N); i++) {
set.add(pad(String.valueOf(i*i), '0', N));
}
int ans = 0;
int[] cntS = new int[10];
for (char c : s) {
cntS[c-'0']++;
}
int[] cntT = new int[10];
for (char[] t : set) {
if (t.length != N) {
continue;
}
Arrays.fill(cntT, 0);
for (char c : t) {
cntT[c-'0']++;
}
if (Arrays.equals(cntS, cntT)) {
ans++;
}
}
System.out.println(ans);
}
static char[] pad(String s, char c, int len) {
if (s.length() >= len) {
return s.toCharArray();
}
char[] ret = new char[len];
for (int i = 0; i < len - s.length(); i++) {
ret[i] = c;
}
for (int i = 0; i < s.length(); i++) {
ret[i + len - s.length()] = s.charAt(i);
}
return ret;
}
public static void main(final String[] args) {
PrintWriter out = new PrintWriter(System.out);
FastScanner scanner = new FastScanner();
try {
run(scanner, out);
} catch (Throwable e) {
throw e;
} finally {
out.flush();
}
}
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;}
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.io.PrintWriter;
import java.util.*;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static Set<char[]> set = new HashSet<>();
static void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
char[] s = scanner.next().toCharArray();
for (long i = 0; i * i <= (long)Math.pow(10, N); i++) {
set.add(pad(String.valueOf(i*i), '0', N));
}
int ans = 0;
int[] cntS = new int[10];
for (char c : s) {
cntS[c-'0']++;
}
int[] cntT = new int[10];
for (char[] t : set) {
if (t.length != N) {
continue;
}
Arrays.fill(cntT, 0);
for (char c : t) {
cntT[c-'0']++;
}
if (Arrays.equals(cntS, cntT)) {
ans++;
}
}
System.out.println(ans);
}
static char[] pad(String s, char c, int len) {
if (s.length() >= len) {
return s.toCharArray();
}
char[] ret = new char[len];
for (int i = 0; i < len - s.length(); i++) {
ret[i] = c;
}
for (int i = 0; i < s.length(); i++) {
ret[i + len - s.length()] = s.charAt(i);
}
return ret;
}
public static void main(final String[] args) {
PrintWriter out = new PrintWriter(System.out);
FastScanner scanner = new FastScanner();
try {
run(scanner, out);
} catch (Throwable e) {
throw e;
} finally {
out.flush();
}
}
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;}
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/abc324_d/Java/53546866
|
condefects-java_data_802
|
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.Map.Entry;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String str_num = sc.next();
Map<Integer, Integer> ori = new HashMap<>();
for(int i = 0; i < n; i++) {
int key = Character.getNumericValue(str_num.charAt(i));
int val = ori.getOrDefault(key, 0);
ori.put(key, val + 1);
}
long i = 1;
long max = (long)Math.pow(10, n);
int ans = 0;
while(i*i <= max) {
Map<Integer, Integer> cnt = new HashMap<>();
int k = 0;
long tmp = i*i;
while(tmp > 0) {
int key = (int)(tmp % 10);
cnt.put(key, cnt.getOrDefault(key, 0) + 1);
tmp /= 10;
k++;
}
cnt.put(0, cnt.getOrDefault(0, 0) + n-k);
if(check(ori, cnt)) {
ans++;
}
i++;
}
System.out.println(ans);
}
public static boolean check(Map<Integer, Integer> ori, Map<Integer, Integer> cnt) {
Iterator<Entry<Integer, Integer>> iterator = ori.entrySet().iterator();
while(iterator.hasNext()) {
Entry<Integer, Integer> next = iterator.next();
int key = next.getKey();
int val = next.getValue();
if(val != cnt.getOrDefault(key, 0)) {
return false;
}
}
return true;
}
}
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.Map.Entry;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String str_num = sc.next();
Map<Integer, Integer> ori = new HashMap<>();
for(int i = 0; i < n; i++) {
int key = Character.getNumericValue(str_num.charAt(i));
int val = ori.getOrDefault(key, 0);
ori.put(key, val + 1);
}
long i = 0;
long max = (long)Math.pow(10, n);
int ans = 0;
while(i*i <= max) {
Map<Integer, Integer> cnt = new HashMap<>();
int k = 0;
long tmp = i*i;
while(tmp > 0) {
int key = (int)(tmp % 10);
cnt.put(key, cnt.getOrDefault(key, 0) + 1);
tmp /= 10;
k++;
}
cnt.put(0, cnt.getOrDefault(0, 0) + n-k);
if(check(ori, cnt)) {
ans++;
}
i++;
}
System.out.println(ans);
}
public static boolean check(Map<Integer, Integer> ori, Map<Integer, Integer> cnt) {
Iterator<Entry<Integer, Integer>> iterator = ori.entrySet().iterator();
while(iterator.hasNext()) {
Entry<Integer, Integer> next = iterator.next();
int key = next.getKey();
int val = next.getValue();
if(val != cnt.getOrDefault(key, 0)) {
return false;
}
}
return true;
}
}
|
ConDefects/ConDefects/Code/abc324_d/Java/46654045
|
condefects-java_data_803
|
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.logging.*;
public class Main {
private static final Logger LOGGER = Logger.getLogger(Main.class.getName());
private static PrintWriter out;
public static void main(String[] args) {
LOGGER.setUseParentHandlers(false);
ConsoleHandler handler = new ConsoleHandler();
handler.setFormatter(new SingleLineFormatter());
LOGGER.addHandler(handler);
Main main = new Main();
out = new PrintWriter(new BufferedOutputStream(System.out));
try {
main.run(args);
} catch (Exception e) {
e.printStackTrace();
}
out.close();
}
private void run(String[] arguments) throws Exception {
MyScanner sc = new MyScanner();
int N = sc.nextInt();
char[] inputs = sc.next().toCharArray();
Arrays.sort(inputs);
StringBuilder sb = new StringBuilder();
for (int i = inputs.length - 1; i >= 0; i--) {
sb.append(inputs[i]);
}
Long maxValue = Long.parseLong(sb.toString());
ArrayList<Long> squaresList = new ArrayList<>();
for (long i = 1; i*i <= maxValue; i++) {
squaresList.add(i*i);
}
long ans = 0;
for (Long square : squaresList) {
char[] temp = String.valueOf(square).toCharArray();
char[] sameLength = new char[inputs.length];
for (int i = 0; i < sameLength.length; i++) {
if (i < temp.length){
sameLength[i] = temp[i];
}else {
sameLength[i] = '0';
}
}
Arrays.sort(sameLength);
if (new String(inputs).equals(new String(sameLength))) {
ans++;
}
}
out.println(ans);
}
public ArrayList<Character> generateLowercaseAlphabeticList() {
ArrayList<Character> alphabeticList = new ArrayList<>();
for (int i = 'a'; i <= 'z'; i++) {
alphabeticList.add((char) i);
}
return alphabeticList;
}
public ArrayList<Character> generateUppercaseAlphabeticList() {
ArrayList<Character> alphabeticList = new ArrayList<>();
for (int i = 'A'; i <= 'Z'; i++) {
alphabeticList.add((char) i);
}
return alphabeticList;
}
// logger
static class SingleLineFormatter extends Formatter {
private static final String format = "[%1$tF %1$tT] %2$s %n";
@Override
public String format(LogRecord record) {
return String.format(format,
new java.util.Date(record.getMillis()),
record.getMessage()
);
}
}
/*
* Form: http://codeforces.com/blog/entry/7018
*/
private class MyScanner {
BufferedReader br;
StringTokenizer st;
MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.logging.*;
public class Main {
private static final Logger LOGGER = Logger.getLogger(Main.class.getName());
private static PrintWriter out;
public static void main(String[] args) {
LOGGER.setUseParentHandlers(false);
ConsoleHandler handler = new ConsoleHandler();
handler.setFormatter(new SingleLineFormatter());
LOGGER.addHandler(handler);
Main main = new Main();
out = new PrintWriter(new BufferedOutputStream(System.out));
try {
main.run(args);
} catch (Exception e) {
e.printStackTrace();
}
out.close();
}
private void run(String[] arguments) throws Exception {
MyScanner sc = new MyScanner();
int N = sc.nextInt();
char[] inputs = sc.next().toCharArray();
Arrays.sort(inputs);
StringBuilder sb = new StringBuilder();
for (int i = inputs.length - 1; i >= 0; i--) {
sb.append(inputs[i]);
}
Long maxValue = Long.parseLong(sb.toString());
ArrayList<Long> squaresList = new ArrayList<>();
for (long i = 0; i*i <= maxValue; i++) {
squaresList.add(i*i);
}
long ans = 0;
for (Long square : squaresList) {
char[] temp = String.valueOf(square).toCharArray();
char[] sameLength = new char[inputs.length];
for (int i = 0; i < sameLength.length; i++) {
if (i < temp.length){
sameLength[i] = temp[i];
}else {
sameLength[i] = '0';
}
}
Arrays.sort(sameLength);
if (new String(inputs).equals(new String(sameLength))) {
ans++;
}
}
out.println(ans);
}
public ArrayList<Character> generateLowercaseAlphabeticList() {
ArrayList<Character> alphabeticList = new ArrayList<>();
for (int i = 'a'; i <= 'z'; i++) {
alphabeticList.add((char) i);
}
return alphabeticList;
}
public ArrayList<Character> generateUppercaseAlphabeticList() {
ArrayList<Character> alphabeticList = new ArrayList<>();
for (int i = 'A'; i <= 'Z'; i++) {
alphabeticList.add((char) i);
}
return alphabeticList;
}
// logger
static class SingleLineFormatter extends Formatter {
private static final String format = "[%1$tF %1$tT] %2$s %n";
@Override
public String format(LogRecord record) {
return String.format(format,
new java.util.Date(record.getMillis()),
record.getMessage()
);
}
}
/*
* Form: http://codeforces.com/blog/entry/7018
*/
private class MyScanner {
BufferedReader br;
StringTokenizer st;
MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
ConDefects/ConDefects/Code/abc324_d/Java/47879402
|
condefects-java_data_804
|
//Har Har Mahadev
//Om Namah Shivay
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(buf.readLine());
String s = buf.readLine();
char[]ch = s.toCharArray();
Arrays.sort(ch);
long j = Long.parseLong(new String(ch));
int ans = 0;
for(long i = 1; i*i<=(long)Math.pow(10, n);i++){
long p = i*i;
char[] sub = Long.toString(p).toCharArray();
Arrays.sort(sub);
long d = Long.parseLong(new String(sub));
if(d==j)ans++;
}
System.out.println(ans);
}
}
//Har Har Mahadev
//Om Namah Shivay
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(buf.readLine());
String s = buf.readLine();
char[]ch = s.toCharArray();
Arrays.sort(ch);
long j = Long.parseLong(new String(ch));
int ans = 0;
for(long i = 0; i*i<=(long)Math.pow(10, n);i++){
long p = i*i;
char[] sub = Long.toString(p).toCharArray();
Arrays.sort(sub);
long d = Long.parseLong(new String(sub));
if(d==j)ans++;
}
System.out.println(ans);
}
}
|
ConDefects/ConDefects/Code/abc324_d/Java/47173750
|
condefects-java_data_805
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
public static void main(String[] args) {
int t = 1;
//t = nextInt();
while (t-- > 0) {
solve();
}
close();
}
private static void solve() {
int n = nextInt();
int[] cnt = new int[10];
char[] a = nextCharArr();
for (int i = 0; i < n; i++) {
cnt[a[i] - '0']++;
}
StringBuilder sb = new StringBuilder();
for (int i = 9; i >= 0; i--) {
if (cnt[i] > 0) {
sb.append(String.valueOf(i).repeat(cnt[i]));
}
}
long num = Long.parseLong(sb.toString());
int ans = 0;
for (long i = 1; i * i <= num; i++) {
int[] cnt2 = new int[10];
for (char c : String.valueOf(i * i).toCharArray()) {
cnt2[c - '0']++;
}
boolean ok = true;
for (int j = 1; j < 10; j++) {
if (cnt[j] != cnt2[j]) {
ok = false;
}
}
if (ok) {
// println(String.valueOf(i * i));
ans++;
}
}
println(ans);
}
private static final int INF = 1_000_000_000;
private static class MultiSet<T> {
private HashMap<T, Integer> storage;
private int size;
public MultiSet() {
storage = new HashMap<>();
size = 0;
}
public void add(T el) {
storage.merge(el, 1, Integer::sum);
size++;
}
public void add(T el, int cnt) {
storage.merge(el, cnt, Integer::sum);
size += cnt;
}
public void remove(T el) {
if (storage.containsKey(el)) {
int newCnt = storage.merge(el, -1, Integer::sum);
size--;
if (newCnt == 0) {
storage.remove(el);
}
}
}
public int count(T el) {
if (storage.containsKey(el)) {
return storage.get(el);
} else {
return 0;
}
}
public int size() {
return storage.size();
}
public boolean isEmpty() {
return storage.isEmpty();
}
public boolean contains(T el) {
return storage.containsKey(el);
}
@Override
public String toString() {
return storage.toString();
}
}
private static class TreeMultiSet<T> {
private TreeMap<T, Integer> storage;
private int size;
public TreeMultiSet() {
storage = new TreeMap<>();
size = 0;
}
public TreeMultiSet(Comparator<T> comp) {
storage = new TreeMap<>(comp);
size = 0;
}
public void add(T el) {
storage.merge(el, 1, Integer::sum);
size++;
}
public void add(T el, int cnt) {
storage.merge(el, cnt, Integer::sum);
size += cnt;
}
public void remove(T el) {
if (storage.containsKey(el)) {
int newCnt = storage.merge(el, -1, Integer::sum);
size--;
if (newCnt == 0) {
storage.remove(el);
}
}
}
public void removeAll(T el) {
storage.remove(el);
}
public T pollLast() {
T key = storage.lastKey();
remove(key);
return key;
}
public T pollFirst() {
T key = storage.firstKey();
remove(key);
return key;
}
public int count(T el) {
if (storage.containsKey(el)) {
return storage.get(el);
} else {
return 0;
}
}
public T first() {
return storage.firstKey();
}
public T last() {
return storage.lastKey();
}
public T higher(T el) {
return storage.higherKey(el);
}
public T lower(T el) {
return storage.lowerKey(el);
}
public T floor(T el) {
return storage.floorKey(el);
}
public T ceiling(T el) {
return storage.ceilingKey(el);
}
public int size() {
return storage.size();
}
public boolean isEmpty() {
return storage.isEmpty();
}
public boolean contains(T el) {
return storage.containsKey(el);
}
@Override
public String toString() {
return storage.toString();
}
}
private static BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
private static StringTokenizer st;
private static PrintWriter pw = new PrintWriter(System.out);
private static String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
private static String nextLine() {
String s = "";
try {
if (st != null && st.hasMoreTokens())
s = st.nextToken("\n");
else
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return s;
}
private static char[] nextCharArr() {
return nextLine().toCharArray();
}
private static int nextInt() {
return Integer.parseInt(next());
}
private static int[] nextIntArr(int n) {
int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = nextInt();
}
return res;
}
private static int[] nextIntArr(int n, int offset) {
int[] res = new int[n + offset];
for (int i = offset; i < res.length; i++) {
res[i] = nextInt();
}
return res;
}
private static int[][] nextInt2dArr(int rows, int cols) {
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;
}
private static long[] nextLongArr(int n) {
long[] res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = nextLong();
}
return res;
}
private static long[] nextLongArr(int n, int offset) {
long[] res = new long[n + offset];
for (int i = offset; i < res.length; i++) {
res[i] = nextLong();
}
return res;
}
private static long[][] nextLong2dArr(int rows, int cols) {
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;
}
private static long nextLong() {
return Long.parseLong(next());
}
private static double nextDouble() {
return Double.parseDouble(next());
}
private static void printf(String format, Object... args) {
pw.printf(format, args);
}
private static void print(Object o) {
pw.print(o);
}
private static void println() {
pw.println();
}
private static void println(Object o) {
pw.println(o);
}
private static void println(int[] a) {
StringBuilder sb = new StringBuilder();
for (int i : a) {
sb.append(i);
sb.append(" ");
}
println(sb);
}
private static void println(int[][] a) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
sb.append(a[i][j]);
sb.append(" ");
}
sb.append("\n");
}
print(sb);
}
private static void println(long[] a) {
StringBuilder sb = new StringBuilder();
for (long i : a) {
sb.append(i);
sb.append(" ");
}
println(sb);
}
private static void println(long[][] a) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[0].length; j++) {
sb.append(a[i][j]);
sb.append(" ");
}
sb.append("\n");
}
print(sb);
}
private static void sort(int[] a) {
List<Integer> b = new ArrayList<>();
for (int el : a) {
b.add(el);
}
Collections.sort(b);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static void sort(long[] a) {
List<Long> b = new ArrayList<>();
for (long el : a) {
b.add(el);
}
Collections.sort(b);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static void sort(int[] a, Comparator<Integer> comp) {
List<Integer> b = new ArrayList<>();
for (int el : a) {
b.add(el);
}
Collections.sort(b, comp);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static void sort(long[] a, Comparator<Long> comp) {
List<Long> b = new ArrayList<>();
for (long el : a) {
b.add(el);
}
Collections.sort(b, comp);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static <T extends Comparable<T>> void sort(T[] a) {
List<T> temp = new ArrayList<>();
for (int i = 0; i < a.length; i++) {
temp.add(a[i]);
}
Collections.sort(temp);
for (int i = 0; i < a.length; i++) {
a[i] = temp.get(i);
}
}
private static <T> void sort(T[] a, Comparator<? super T> comparator) {
List<T> temp = new ArrayList<>();
for (int i = 0; i < a.length; i++) {
temp.add(a[i]);
}
Collections.sort(temp, comparator);
for (int i = 0; i < a.length; i++) {
a[i] = temp.get(i);
}
}
private static int[][] copy(int[][] orig) {
int[][] temp = new int[orig.length][];
for (int j = 0; j < orig.length; j++) {
temp[j] = Arrays.copyOf(orig[j], orig[j].length);
}
return temp;
}
private static void close() {
pw.flush();
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
pw.close();
}
}
// Pre-submit:
// Write a few simple test cases if sample is not enough.
// Are time limits close? If so, generate max cases.
// Is the memory usage fine?
// Could anything overflow?
// Make sure to submit the right file.
//
// Wrong answer:
// Print your solution! Print debug output, as well.
// Are you clearing all data structures between test cases?
// Can your algorithm handle the whole range of input?
// Read the full problem statement again.
// Do you handle all corner cases correctly?
// Have you understood the problem correctly?
// Any uninitialized variables?
// Any overflows?
// Confusing N and M, i and j, etc.?
// Are you sure your algorithm works?
// What special cases have you not thought of?
// Are you sure the STL functions you use work as you think?
// Add some assertions, maybe resubmit.
// Create some testcases to run your algorithm on.
// Go through the algorithm for a simple case.
// Go through this list again.
// Explain your algorithm to a teammate.
// Ask the teammate to look at your code.
// Go for a small walk, e.g. to the toilet.
// Is your output format correct? (including whitespace)
// Rewrite your solution from the start or let a teammate do it.
//
// Runtime error:
// Have you tested all corner cases locally?
// Any uninitialized variables?
// Are you reading or writing outside the range of any vector?
// Any assertions that might fail?
// Any possible division by 0? (mod 0 for example)
// Any possible infinite recursion?
// Invalidated pointers or iterators?
// Are you using too much memory?
// Debug with resubmits (e.g. remapped signals, see Various).
//
// Time limit exceeded:
// Do you have any possible infinite loops?
// What is the complexity of your algorithm?
// Are you copying a lot of unnecessary data? (References)
// How big is the input and output? (consider scanf)
// Avoid vector, map. (use arrays/unordered_map)
// What do your teammates think about your algorithm?
//
// Memory limit exceeded:
// What is the max amount of memory your algorithm should need?
// Are you clearing all data structures between test cases?
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
public static void main(String[] args) {
int t = 1;
//t = nextInt();
while (t-- > 0) {
solve();
}
close();
}
private static void solve() {
int n = nextInt();
int[] cnt = new int[10];
char[] a = nextCharArr();
for (int i = 0; i < n; i++) {
cnt[a[i] - '0']++;
}
StringBuilder sb = new StringBuilder();
for (int i = 9; i >= 0; i--) {
if (cnt[i] > 0) {
sb.append(String.valueOf(i).repeat(cnt[i]));
}
}
long num = Long.parseLong(sb.toString());
int ans = 0;
for (long i = 0; i * i <= num; i++) {
int[] cnt2 = new int[10];
for (char c : String.valueOf(i * i).toCharArray()) {
cnt2[c - '0']++;
}
boolean ok = true;
for (int j = 1; j < 10; j++) {
if (cnt[j] != cnt2[j]) {
ok = false;
}
}
if (ok) {
// println(String.valueOf(i * i));
ans++;
}
}
println(ans);
}
private static final int INF = 1_000_000_000;
private static class MultiSet<T> {
private HashMap<T, Integer> storage;
private int size;
public MultiSet() {
storage = new HashMap<>();
size = 0;
}
public void add(T el) {
storage.merge(el, 1, Integer::sum);
size++;
}
public void add(T el, int cnt) {
storage.merge(el, cnt, Integer::sum);
size += cnt;
}
public void remove(T el) {
if (storage.containsKey(el)) {
int newCnt = storage.merge(el, -1, Integer::sum);
size--;
if (newCnt == 0) {
storage.remove(el);
}
}
}
public int count(T el) {
if (storage.containsKey(el)) {
return storage.get(el);
} else {
return 0;
}
}
public int size() {
return storage.size();
}
public boolean isEmpty() {
return storage.isEmpty();
}
public boolean contains(T el) {
return storage.containsKey(el);
}
@Override
public String toString() {
return storage.toString();
}
}
private static class TreeMultiSet<T> {
private TreeMap<T, Integer> storage;
private int size;
public TreeMultiSet() {
storage = new TreeMap<>();
size = 0;
}
public TreeMultiSet(Comparator<T> comp) {
storage = new TreeMap<>(comp);
size = 0;
}
public void add(T el) {
storage.merge(el, 1, Integer::sum);
size++;
}
public void add(T el, int cnt) {
storage.merge(el, cnt, Integer::sum);
size += cnt;
}
public void remove(T el) {
if (storage.containsKey(el)) {
int newCnt = storage.merge(el, -1, Integer::sum);
size--;
if (newCnt == 0) {
storage.remove(el);
}
}
}
public void removeAll(T el) {
storage.remove(el);
}
public T pollLast() {
T key = storage.lastKey();
remove(key);
return key;
}
public T pollFirst() {
T key = storage.firstKey();
remove(key);
return key;
}
public int count(T el) {
if (storage.containsKey(el)) {
return storage.get(el);
} else {
return 0;
}
}
public T first() {
return storage.firstKey();
}
public T last() {
return storage.lastKey();
}
public T higher(T el) {
return storage.higherKey(el);
}
public T lower(T el) {
return storage.lowerKey(el);
}
public T floor(T el) {
return storage.floorKey(el);
}
public T ceiling(T el) {
return storage.ceilingKey(el);
}
public int size() {
return storage.size();
}
public boolean isEmpty() {
return storage.isEmpty();
}
public boolean contains(T el) {
return storage.containsKey(el);
}
@Override
public String toString() {
return storage.toString();
}
}
private static BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
private static StringTokenizer st;
private static PrintWriter pw = new PrintWriter(System.out);
private static String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
private static String nextLine() {
String s = "";
try {
if (st != null && st.hasMoreTokens())
s = st.nextToken("\n");
else
s = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return s;
}
private static char[] nextCharArr() {
return nextLine().toCharArray();
}
private static int nextInt() {
return Integer.parseInt(next());
}
private static int[] nextIntArr(int n) {
int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = nextInt();
}
return res;
}
private static int[] nextIntArr(int n, int offset) {
int[] res = new int[n + offset];
for (int i = offset; i < res.length; i++) {
res[i] = nextInt();
}
return res;
}
private static int[][] nextInt2dArr(int rows, int cols) {
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;
}
private static long[] nextLongArr(int n) {
long[] res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = nextLong();
}
return res;
}
private static long[] nextLongArr(int n, int offset) {
long[] res = new long[n + offset];
for (int i = offset; i < res.length; i++) {
res[i] = nextLong();
}
return res;
}
private static long[][] nextLong2dArr(int rows, int cols) {
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;
}
private static long nextLong() {
return Long.parseLong(next());
}
private static double nextDouble() {
return Double.parseDouble(next());
}
private static void printf(String format, Object... args) {
pw.printf(format, args);
}
private static void print(Object o) {
pw.print(o);
}
private static void println() {
pw.println();
}
private static void println(Object o) {
pw.println(o);
}
private static void println(int[] a) {
StringBuilder sb = new StringBuilder();
for (int i : a) {
sb.append(i);
sb.append(" ");
}
println(sb);
}
private static void println(int[][] a) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
sb.append(a[i][j]);
sb.append(" ");
}
sb.append("\n");
}
print(sb);
}
private static void println(long[] a) {
StringBuilder sb = new StringBuilder();
for (long i : a) {
sb.append(i);
sb.append(" ");
}
println(sb);
}
private static void println(long[][] a) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[0].length; j++) {
sb.append(a[i][j]);
sb.append(" ");
}
sb.append("\n");
}
print(sb);
}
private static void sort(int[] a) {
List<Integer> b = new ArrayList<>();
for (int el : a) {
b.add(el);
}
Collections.sort(b);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static void sort(long[] a) {
List<Long> b = new ArrayList<>();
for (long el : a) {
b.add(el);
}
Collections.sort(b);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static void sort(int[] a, Comparator<Integer> comp) {
List<Integer> b = new ArrayList<>();
for (int el : a) {
b.add(el);
}
Collections.sort(b, comp);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static void sort(long[] a, Comparator<Long> comp) {
List<Long> b = new ArrayList<>();
for (long el : a) {
b.add(el);
}
Collections.sort(b, comp);
for (int i = 0; i < a.length; i++) {
a[i] = b.get(i);
}
}
private static <T extends Comparable<T>> void sort(T[] a) {
List<T> temp = new ArrayList<>();
for (int i = 0; i < a.length; i++) {
temp.add(a[i]);
}
Collections.sort(temp);
for (int i = 0; i < a.length; i++) {
a[i] = temp.get(i);
}
}
private static <T> void sort(T[] a, Comparator<? super T> comparator) {
List<T> temp = new ArrayList<>();
for (int i = 0; i < a.length; i++) {
temp.add(a[i]);
}
Collections.sort(temp, comparator);
for (int i = 0; i < a.length; i++) {
a[i] = temp.get(i);
}
}
private static int[][] copy(int[][] orig) {
int[][] temp = new int[orig.length][];
for (int j = 0; j < orig.length; j++) {
temp[j] = Arrays.copyOf(orig[j], orig[j].length);
}
return temp;
}
private static void close() {
pw.flush();
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
pw.close();
}
}
// Pre-submit:
// Write a few simple test cases if sample is not enough.
// Are time limits close? If so, generate max cases.
// Is the memory usage fine?
// Could anything overflow?
// Make sure to submit the right file.
//
// Wrong answer:
// Print your solution! Print debug output, as well.
// Are you clearing all data structures between test cases?
// Can your algorithm handle the whole range of input?
// Read the full problem statement again.
// Do you handle all corner cases correctly?
// Have you understood the problem correctly?
// Any uninitialized variables?
// Any overflows?
// Confusing N and M, i and j, etc.?
// Are you sure your algorithm works?
// What special cases have you not thought of?
// Are you sure the STL functions you use work as you think?
// Add some assertions, maybe resubmit.
// Create some testcases to run your algorithm on.
// Go through the algorithm for a simple case.
// Go through this list again.
// Explain your algorithm to a teammate.
// Ask the teammate to look at your code.
// Go for a small walk, e.g. to the toilet.
// Is your output format correct? (including whitespace)
// Rewrite your solution from the start or let a teammate do it.
//
// Runtime error:
// Have you tested all corner cases locally?
// Any uninitialized variables?
// Are you reading or writing outside the range of any vector?
// Any assertions that might fail?
// Any possible division by 0? (mod 0 for example)
// Any possible infinite recursion?
// Invalidated pointers or iterators?
// Are you using too much memory?
// Debug with resubmits (e.g. remapped signals, see Various).
//
// Time limit exceeded:
// Do you have any possible infinite loops?
// What is the complexity of your algorithm?
// Are you copying a lot of unnecessary data? (References)
// How big is the input and output? (consider scanf)
// Avoid vector, map. (use arrays/unordered_map)
// What do your teammates think about your algorithm?
//
// Memory limit exceeded:
// What is the max amount of memory your algorithm should need?
// Are you clearing all data structures between test cases?
|
ConDefects/ConDefects/Code/abc324_d/Java/50647837
|
condefects-java_data_806
|
import java.util.*;
class DisjointSet {
List<Integer> parent = new ArrayList<>();
List<Integer> size = new ArrayList<>();
void initialize(int n) {
for (int i = 0; i < n; i++) {
parent.add(-1);
size.add(1);
}
}
int root(int x) {
while (true) {
if (parent.get(x) == -1) {
break;
}
x = parent.get(x);
}
return x;
}
void merge(int u, int v) {
int rootU = root(u);
int rootV = root(v);
if (rootU == rootV) {
return ;
}
if (size.get(rootU) < size.get(rootV)) {
parent.set(rootU, rootV);
size.set(rootV, size.get(rootU) + size.get(rootV));
} else if (size.get(rootU) >= size.get(rootV)) {
parent.set(rootV, rootU);
size.set(rootU, size.get(rootU) + size.get(rootV));
}
}
boolean isSame(int u, int v) {
if (root(u) == root(v)) {
return true;
}
return false;
}
}
class Main {
public static long gcd(long a, long b) {
while (a >= 1 && b >= 1) {
if (a >= b) {
a = (a % b);
} else {
b = (b % a);
}
}
if (a != 0) {
return a;
}
return b;
}
public static void main(String[] args) { Scanner sc = new Scanner(System.in);
int h = Integer.parseInt(sc.next());
int w = Integer.parseInt(sc.next());
List<String> str = new ArrayList<>();
for (int i = 0; i < h; i++) {
str.add(sc.next());
}
List<Character> cha = new ArrayList<>();
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cha.add(str.get(i).charAt(j));
}
}
List<Integer> id = new ArrayList<>();
for (int i = 0; i < h * w; i++) {
id.add(-1);
}
int n = 0;
for (int i = 0; i < h * w; i++) {
if (cha.get(i) == '#') {
n++;
}
}
DisjointSet ds = new DisjointSet();
ds.initialize(h * w);
int base = n;
for (int i = 0; i < h * w; i++) {
if (cha.get(i) == '#') {
if (i >= w && cha.get(i - w) == '#' && ds.isSame(i, i - w) == false) {
base--;
ds.merge(i, i - w);
}
if (i % w != w - 1 && cha.get(i + 1) == '#' && ds.isSame(i, i + 1) == false) {
base--;
ds.merge(i, i + 1);
}
if (i < (h - 1) * w && cha.get(i + w) == '#' && ds.isSame(i, i + w) == false) {
base--;
ds.merge(i, i + w);
}
if (i % w != 0 && cha.get(i - 1) == '#' && ds.isSame(i, i - 1) == false) {
base--;
ds.merge(i, i - 1);
}
}
}
long sum = 0;
long cnt = 0;
for (int i = 0; i < h * w; i++) {
if (cha.get(i) != '#') {
cnt++;
int now = base;
now++;
Set<Integer> st = new HashSet<>();
if (i >= w && cha.get(i - w) == '#') {
st.add(ds.root(i - w));
}
if (i % w != w - 1 && cha.get(i + 1) == '#') {
st.add(ds.root(i + 1));
}
if (i < (h - 1) * w && cha.get(i + w) == '#') {
st.add(ds.root(i + w));
}
if (i % w != 0 && cha.get(i - 1) == '#') {
st.add(ds.root(i - 1));
}
now -= st.size();
sum += now;
}
}
long m = gcd(sum, cnt);
sum /= m;
cnt /= m;
for (long i = 0; i < 998244353; i++) {
if ((cnt * i) % 998244353 == sum) {
System.out.println(i);
}
}
}
}
import java.util.*;
class DisjointSet {
List<Integer> parent = new ArrayList<>();
List<Integer> size = new ArrayList<>();
void initialize(int n) {
for (int i = 0; i < n; i++) {
parent.add(-1);
size.add(1);
}
}
int root(int x) {
while (true) {
if (parent.get(x) == -1) {
break;
}
x = parent.get(x);
}
return x;
}
void merge(int u, int v) {
int rootU = root(u);
int rootV = root(v);
if (rootU == rootV) {
return ;
}
if (size.get(rootU) < size.get(rootV)) {
parent.set(rootU, rootV);
size.set(rootV, size.get(rootU) + size.get(rootV));
} else if (size.get(rootU) >= size.get(rootV)) {
parent.set(rootV, rootU);
size.set(rootU, size.get(rootU) + size.get(rootV));
}
}
boolean isSame(int u, int v) {
if (root(u) == root(v)) {
return true;
}
return false;
}
}
class Main {
public static long gcd(long a, long b) {
while (a >= 1 && b >= 1) {
if (a >= b) {
a = (a % b);
} else {
b = (b % a);
}
}
if (a != 0) {
return a;
}
return b;
}
public static void main(String[] args) { Scanner sc = new Scanner(System.in);
int h = Integer.parseInt(sc.next());
int w = Integer.parseInt(sc.next());
List<String> str = new ArrayList<>();
for (int i = 0; i < h; i++) {
str.add(sc.next());
}
List<Character> cha = new ArrayList<>();
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cha.add(str.get(i).charAt(j));
}
}
List<Integer> id = new ArrayList<>();
for (int i = 0; i < h * w; i++) {
id.add(-1);
}
int n = 0;
for (int i = 0; i < h * w; i++) {
if (cha.get(i) == '#') {
n++;
}
}
DisjointSet ds = new DisjointSet();
ds.initialize(h * w);
int base = n;
for (int i = 0; i < h * w; i++) {
if (cha.get(i) == '#') {
if (i >= w && cha.get(i - w) == '#' && ds.isSame(i, i - w) == false) {
base--;
ds.merge(i, i - w);
}
if (i % w != w - 1 && cha.get(i + 1) == '#' && ds.isSame(i, i + 1) == false) {
base--;
ds.merge(i, i + 1);
}
if (i < (h - 1) * w && cha.get(i + w) == '#' && ds.isSame(i, i + w) == false) {
base--;
ds.merge(i, i + w);
}
if (i % w != 0 && cha.get(i - 1) == '#' && ds.isSame(i, i - 1) == false) {
base--;
ds.merge(i, i - 1);
}
}
}
long sum = 0;
long cnt = 0;
for (int i = 0; i < h * w; i++) {
if (cha.get(i) != '#') {
cnt++;
int now = base;
now++;
Set<Integer> st = new HashSet<>();
if (i >= w && cha.get(i - w) == '#') {
st.add(ds.root(i - w));
}
if (i % w != w - 1 && cha.get(i + 1) == '#') {
st.add(ds.root(i + 1));
}
if (i < (h - 1) * w && cha.get(i + w) == '#') {
st.add(ds.root(i + w));
}
if (i % w != 0 && cha.get(i - 1) == '#') {
st.add(ds.root(i - 1));
}
now -= st.size();
sum += now;
}
}
long m = gcd(sum, cnt);
sum /= m;
cnt /= m;
for (long i = 0; i < 998244353; i++) {
if ((cnt % 998244353) * i % 998244353 == sum % 998244353) {
System.out.println(i);
}
}
}
}
|
ConDefects/ConDefects/Code/abc334_e/Java/48953247
|
condefects-java_data_807
|
import java.io.*;
import java.util.*;
public class Main implements Runnable{
private static final FastReader fr = new FastReader();
private static final long MOD = 998244353L;
private static final int[][] directions = {{1,0},{0,1},{-1,0},{0,-1}};
private static final int rows = fr.nextInt(), cols = fr.nextInt();
private static final char[][] M = new char[rows][cols];
private static final int[][] G = new int[rows][cols];
public static void main(String[] args) throws IOException {
new Thread(null, new Main(), "cp", 1<<26).start();
}
@Override
public void run() {
PrintWriter out = new PrintWriter(System.out);
// int testCases = fr.nextInt();
// for(int testCase=1;testCase<=testCases;testCase++) {
//
// }
for(int i=0;i<rows;i++) M[i] = fr.next().toCharArray();
int reds = 0;
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(M[i][j] == '#') G[i][j]--;
else reds++;
}
}
int num = 1;
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(G[i][j] == -1) {
dfs(i,j,num);
num++;
}
}
}
int cc = num - 1;
// System.out.println("reds= " + reds);
long inv = mod_inverse(reds);
// System.out.println("inv= " + inv + " cc="+cc);
long res = 0;
// for(int[] g: G) System.out.println(Arrays.toString(g));
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(M[i][j] == '.'){
HashSet<Integer> set = new HashSet<>();
for(int[] dir: directions){
int nr = i + dir[0];
int nc = j + dir[1];
if(isValid(nr,nc) && M[nr][nc] == '#') set.add(G[nr][nc]);
}
if(set.size() == 0) res += (cc + 1);
else if(set.size()==1) res += cc;
else res += (cc - set.size() + 1);
// System.out.println("res= " + res);
}
}
}
out.println(res*inv%MOD);
out.flush();
}
private static boolean isValid(int r, int c){
return r>=0 && c>=0 && r<rows && c<cols;
}
private static void dfs(int r, int c, int num){
G[r][c] = num;
for(int[] dir: directions){
int nr = r + dir[0];
int nc = c + dir[1];
if(isValid(nr,nc) && G[nr][nc] == -1) dfs(nr,nc,num);
}
}
private static long mod_inverse(long num){
return powMODRec(num%MOD,MOD-2);
}
private static long powMODRec(long x, long n){
if(n == 0) return 1L;
long t = powMODRec(x,n/2);
if(n%2 == 0) return t*t%MOD;
return t*t%MOD*x%MOD;
}
}
class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
if(st.hasMoreTokens()){
str = st.nextToken("\n");
}
else{
str = br.readLine();
}
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
import java.io.*;
import java.util.*;
public class Main implements Runnable{
private static final FastReader fr = new FastReader();
private static final long MOD = 998244353L;
private static final int[][] directions = {{1,0},{0,1},{-1,0},{0,-1}};
private static final int rows = fr.nextInt(), cols = fr.nextInt();
private static final char[][] M = new char[rows][cols];
private static final int[][] G = new int[rows][cols];
public static void main(String[] args) throws IOException {
new Thread(null, new Main(), "cp", 1<<26).start();
}
@Override
public void run() {
PrintWriter out = new PrintWriter(System.out);
// int testCases = fr.nextInt();
// for(int testCase=1;testCase<=testCases;testCase++) {
//
// }
for(int i=0;i<rows;i++) M[i] = fr.next().toCharArray();
int reds = 0;
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(M[i][j] == '#') G[i][j]--;
else reds++;
}
}
int num = 1;
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(G[i][j] == -1) {
dfs(i,j,num);
num++;
}
}
}
int cc = num - 1;
// System.out.println("reds= " + reds);
long inv = mod_inverse(reds);
// System.out.println("inv= " + inv + " cc="+cc);
long res = 0;
// for(int[] g: G) System.out.println(Arrays.toString(g));
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
if(M[i][j] == '.'){
HashSet<Integer> set = new HashSet<>();
for(int[] dir: directions){
int nr = i + dir[0];
int nc = j + dir[1];
if(isValid(nr,nc) && M[nr][nc] == '#') set.add(G[nr][nc]);
}
if(set.size() == 0) res += (cc + 1);
else if(set.size()==1) res += cc;
else res += (cc - set.size() + 1);
// System.out.println("res= " + res);
}
}
}
out.println(res%MOD*inv%MOD);
out.flush();
}
private static boolean isValid(int r, int c){
return r>=0 && c>=0 && r<rows && c<cols;
}
private static void dfs(int r, int c, int num){
G[r][c] = num;
for(int[] dir: directions){
int nr = r + dir[0];
int nc = c + dir[1];
if(isValid(nr,nc) && G[nr][nc] == -1) dfs(nr,nc,num);
}
}
private static long mod_inverse(long num){
return powMODRec(num%MOD,MOD-2);
}
private static long powMODRec(long x, long n){
if(n == 0) return 1L;
long t = powMODRec(x,n/2);
if(n%2 == 0) return t*t%MOD;
return t*t%MOD*x%MOD;
}
}
class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
if(st.hasMoreTokens()){
str = st.nextToken("\n");
}
else{
str = br.readLine();
}
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
|
ConDefects/ConDefects/Code/abc334_e/Java/48911020
|
condefects-java_data_808
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
public static void main(String[]args) throws IOException {
Scanner sc=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=sc.nextInt();
int[]a=new int[n];
for(int i=0;i<n;i++)a[i]=sc.nextInt();
long cur=1l<<a[0];
for(int i=1;i<n;i++) {
int f=a[i];
long mn=1l<<f;
long diff=cur-mn;
if(diff<0) {
cur=mn;continue;
}
diff++;//strict inc
long delta=0;//ans = mn + delta (delta is smallest added value making ans>=diff)
//delta>=1l<<(f+1)
long lo=1,hi=1l<<(10-f);
while(lo<=hi) {
long mid=(lo+hi)>>1l;
long num=mid<<(f+1);
if(mn+num>cur) {
delta=num;
hi=mid-1;
}else {
lo=mid+1;
}
}
cur=mn+delta;
}
out.println(cur);
out.close();
}
static class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public boolean hasNext() {return st.hasMoreTokens();}
public int nextInt() throws IOException {return Integer.parseInt(next());}
public double nextDouble() throws IOException {return Double.parseDouble(next());}
public long nextLong() throws IOException {return Long.parseLong(next());}
public String nextLine() throws IOException {return br.readLine();}
public boolean ready() throws IOException {return br.ready(); }
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
public static void main(String[]args) throws IOException {
Scanner sc=new Scanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=sc.nextInt();
int[]a=new int[n];
for(int i=0;i<n;i++)a[i]=sc.nextInt();
long cur=1l<<a[0];
for(int i=1;i<n;i++) {
int f=a[i];
long mn=1l<<f;
long diff=cur-mn;
if(diff<0) {
cur=mn;continue;
}
diff++;//strict inc
long delta=0;//ans = mn + delta (delta is smallest added value making ans>=diff)
//delta>=1l<<(f+1)
long lo=1,hi=1l<<(60-f);
while(lo<=hi) {
long mid=(lo+hi)>>1l;
long num=mid<<(f+1);
if(mn+num>cur) {
delta=num;
hi=mid-1;
}else {
lo=mid+1;
}
}
cur=mn+delta;
}
out.println(cur);
out.close();
}
static class Scanner
{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s){ br = new BufferedReader(new InputStreamReader(s));}
public String next() throws IOException
{
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public boolean hasNext() {return st.hasMoreTokens();}
public int nextInt() throws IOException {return Integer.parseInt(next());}
public double nextDouble() throws IOException {return Double.parseDouble(next());}
public long nextLong() throws IOException {return Long.parseLong(next());}
public String nextLine() throws IOException {return br.readLine();}
public boolean ready() throws IOException {return br.ready(); }
}
}
|
ConDefects/ConDefects/Code/arc139_a/Java/31635245
|
condefects-java_data_809
|
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
// Your code here!
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int[] L = new int [N + 1];
for (int i = 0; i < 2*N - 2; i++) {
int idx = in.nextInt();
L[idx - 1] += 1;
}
String ans = "No";
for (int i = 0; i < N - 1; i++) {
if (L[i] == N - 1) ans = "Yes";
}
System.out.println(ans);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
// Your code here!
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int[] L = new int [N + 1];
for (int i = 0; i < 2*N - 2; i++) {
int idx = in.nextInt();
L[idx - 1] += 1;
}
String ans = "No";
for (int i = 0; i < N + 1; i++) {
if (L[i] == N - 1) ans = "Yes";
}
System.out.println(ans);
}
}
|
ConDefects/ConDefects/Code/abc225_b/Java/31905604
|
condefects-java_data_810
|
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
class Main {
static void solve () {
//n = 5 の場合、1~5までで必ず構成される
//スターの場合、いずれかがn-1回、他がそれぞれ1回ずつ登場する
//個数カウントでいけそうだけどな～
//1のみ通して、1以外が来たらそれがn-1であることを確認する。以降はフラグで閉鎖する感じで
int n = nextInt();
Map<Integer, Integer> map = new HashMap<>();
for (int i=0; i<n-1; i++) {
int a = nextInt();
if (map.get(a) == null) map.put(a, 1);
else map.put(a, map.get(a) + 1);
int b = nextInt();
if (map.get(b) == null) map.put(b, 1);
else map.put(b, map.get(b) + 1);
}
if (map.size() != n) {
println("No");
return;
}
boolean flag = false;
for (Map.Entry<Integer, Integer> e: map.entrySet()) {
if (e.getValue() != 1) {
if (flag == false && e.getValue() == n - 1) {
println(e.getKey() + " " + e.getValue());
flag = true;
}
else if (flag == true) {
println("No");
return;
}
}
}
println(yesno(flag));
}
public static String yesno(boolean b) {return b?"Yes":"No";}
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 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.stream.Collectors;
class Main {
static void solve () {
//n = 5 の場合、1~5までで必ず構成される
//スターの場合、いずれかがn-1回、他がそれぞれ1回ずつ登場する
//個数カウントでいけそうだけどな～
//1のみ通して、1以外が来たらそれがn-1であることを確認する。以降はフラグで閉鎖する感じで
int n = nextInt();
Map<Integer, Integer> map = new HashMap<>();
for (int i=0; i<n-1; i++) {
int a = nextInt();
if (map.get(a) == null) map.put(a, 1);
else map.put(a, map.get(a) + 1);
int b = nextInt();
if (map.get(b) == null) map.put(b, 1);
else map.put(b, map.get(b) + 1);
}
if (map.size() != n) {
println("No");
return;
}
boolean flag = false;
for (Map.Entry<Integer, Integer> e: map.entrySet()) {
if (e.getValue() != 1) {
if (flag == false && e.getValue() == n - 1) {
// println(e.getKey() + " " + e.getValue());
flag = true;
}
else if (flag == true) {
println("No");
return;
}
}
}
println(yesno(flag));
}
public static String yesno(boolean b) {return b?"Yes":"No";}
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 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/abc225_b/Java/37898752
|
condefects-java_data_811
|
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Main {
static Scanner $ = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
static boolean b1, b2, b3;
public static void main(String[] args) {
// 249_B
int N, K;
N = $.nextInt();
K = $.nextInt();
int[] A = new int[N];
int[] B = new int[K];
Arrays.setAll(A, n -> $.nextInt());
Arrays.setAll(B, n -> $.nextInt());
List<Integer> maxIndexsList = getMaxIndexs(A);
boolean isCheck = false;
for(int i = 0; i<B.length; i++) {
if(maxIndexsList.contains(Integer.valueOf(B[i]))) {
isCheck = true;
}
}
out.println(isCheck ? "Yes" : "No");
out.flush();
}
static List<Integer> getMaxIndexs(int[] A) {
List<Integer> maxIndexesList = new ArrayList<Integer>();
int[] tmpAry = A.clone();
Arrays.sort(tmpAry);
int max = tmpAry[tmpAry.length - 1];
for (int i = 0; i < A.length; i++) {
if (A[i] == max) {
maxIndexesList.add(i);
}
}
return maxIndexesList;
}
}
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Main {
static Scanner $ = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
static boolean b1, b2, b3;
public static void main(String[] args) {
// 249_B
int N, K;
N = $.nextInt();
K = $.nextInt();
int[] A = new int[N];
int[] B = new int[K];
Arrays.setAll(A, n -> $.nextInt());
Arrays.setAll(B, n -> $.nextInt());
List<Integer> maxIndexsList = getMaxIndexs(A);
boolean isCheck = false;
for(int i = 0; i<B.length; i++) {
if(maxIndexsList.contains(Integer.valueOf(B[i]))) {
isCheck = true;
}
}
out.println(isCheck ? "Yes" : "No");
out.flush();
}
static List<Integer> getMaxIndexs(int[] A) {
List<Integer> maxIndexesList = new ArrayList<Integer>();
int[] tmpAry = A.clone();
Arrays.sort(tmpAry);
int max = tmpAry[tmpAry.length - 1];
for (int i = 0; i < A.length; i++) {
if (A[i] == max) {
maxIndexesList.add(i + 1);
}
}
return maxIndexesList;
}
}
|
ConDefects/ConDefects/Code/abc252_b/Java/34193156
|
condefects-java_data_812
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
int[] a = new int[n];
int max = 0;
for(int i=0;i<n;i++){
a[i] = sc.nextInt();
max = Math.max(a[i], max);
}
Set<Integer> set = new HashSet<>();
for(int i=0;i<n;i++){
if(a[i] == max){
set.add(i);
}
}
int[] b = new int[k];
boolean flag = false;
for(int i=0;i<k;i++){
b[i] = sc.nextInt();
if(set.contains(b[i])) flag = true;
}
if(flag) System.out.println("Yes");
else System.out.println("No");
sc.close();
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
int[] a = new int[n];
int max = 0;
for(int i=0;i<n;i++){
a[i] = sc.nextInt();
max = Math.max(a[i], max);
}
Set<Integer> set = new HashSet<>();
for(int i=0;i<n;i++){
if(a[i] == max){
set.add(i);
}
}
int[] b = new int[k];
boolean flag = false;
for(int i=0;i<k;i++){
b[i] = sc.nextInt()-1;
if(set.contains(b[i])) flag = true;
}
if(flag) System.out.println("Yes");
else System.out.println("No");
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc252_b/Java/39824908
|
condefects-java_data_813
|
import java.io.*;
import java.util.*;
class Main {
int N, Q;
String S;
LazySegtree st;
void calc() {
int[] ns = nextInts();
N = ns[0]; Q = ns[1];
S = next();
int[] v = S.chars().map(c -> c - '0').toArray();
st = new LazySegtree(v);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Q; i++) {
int[] q = nextInts();
int L = q[1] - 1, R = q[2];
switch (q[0]) {
case 1:
st.operateSegment(L, R, 1);
break;
case 2:
sb.append( st.calculate(L, R) == 0 ? "Yes" : "No" );
sb.append('\n');
break;
default:
}
}
print(sb);
}
// ---
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String next() { try { return br.readLine(); } catch (Exception e) { return null; } }
String[] nexts() { return next().split(" "); }
static int i(String s) { return Integer.parseInt(s); }
int nextInt() { return i(next()); }
int[] nextInts() { return Arrays.stream(nexts()).mapToInt(Main::i).toArray(); }
void print(Object o) {
try { System.out.write(o.toString().getBytes()); System.out.flush(); }
catch (Exception e) { }
}
public static void main(String[] args) {
new Main().calc();
}
}
class LazySegtree {
private int m;
private Operator[] lazy;
private Segment[] seg;
LazySegtree(int[] value) {
init(value.length);
construct(value);
}
private void init(int size) {
m = (size == 1)? 1 : Integer.highestOneBit(size - 1) << 1;
lazy = new Operator[2*m - 1];
seg = new Segment[2*m - 1];
}
void construct(int[] v) {
int n = v.length;
for (int i = 0; i < n; i++) {
seg[m-1+i] = new Segment(v[i]);
lazy[m-1+i] = new Operator();
}
for (int i = m-1+n; i < 2*m-1; i++) {
seg[i] = Segment.E;
lazy[i] = Operator.I;
}
for (int i = m-2; i >= 0; i--) {
seg[i] = new Segment(seg[i*2+1]);
seg[i].append(seg[i*2+2]);
lazy[i] = new Operator();
}
}
private void eval(int n, int l, int r) {
if (lazy[n].isIdentity()) return;
lazy[n].map(seg[n], r-l);
if(n < m-1) {
lazy[2*n+1].compose(lazy[n]);
lazy[2*n+2].compose(lazy[n]);
}
lazy[n].clear();
}
void operateSegment(int s, int eExclusive, int ope) {
operateSegmentImpl(s, eExclusive, 0, 0, m, ope);
}
private void operateSegmentImpl(int s, int eExclusive, int n, int l, int r, int ope) {
if (s <= l && r <= eExclusive) {
lazy[n].compose(ope);
eval(n, l, r);
} else if (s < r && l < eExclusive) {
eval(n, l, r);
int i = (l>>>1)+(r>>>1);
operateSegmentImpl(s, eExclusive, 2*n + 1, l, i, ope);
operateSegmentImpl(s, eExclusive, 2*n + 2, i, r, ope);
seg[n].let(seg[2*n + 1]);
seg[n].append(seg[2*n + 2]);
}
}
private Segment acc = new Segment();
int calculate(int s, int eExclusive) {
acc.clear();
calcImpl(acc, s, eExclusive, 0, 0, m);
return acc.val;
}
private void calcImpl(Segment acc, int s, int eExclusive, int n, int l, int r) {
eval(n, l, r);
if (r <= s || eExclusive <= l) return;
if (s <= l && r <= eExclusive) {
acc.append(seg[n]);
return;
}
int i = (l>>>1)+(r>>>1);
calcImpl(acc, s, eExclusive, 2*n + 1, l, i);
calcImpl(acc, s, eExclusive, 2*n + 2, i, r);
}
}
class Segment {
static final Segment E = new Segment();
static int cnt = 0;
int val;
int l, r;
Segment() { val = 0; l = r = --cnt; }
Segment(int v) { val = 0; l = r = v; }
Segment(Segment s) {
let(s);
}
void clear() {
val = 0; l = r = --cnt;
}
void let(Segment s) {
val = s.val; l = s.l; r = s.r;
}
void append(Segment s) {
val = (val != 0 || s.val != 0)? 1 : ((r != s.l)? 0 : 1);
r = s.r;
}
}
class Operator {
static final Operator I = new Operator();
int val;
Operator() { }
Operator(int v) { val = v; }
boolean isIdentity() { return val == 0; }
void clear() { val = 0; }
void compose(Operator o) {
val ^= o.val;
}
void compose(int o) {
val ^= o;
}
void let(int o) {
val = o;
}
void map(Segment s, int len) {
s.l ^= val;
s.r ^= val;
}
}
import java.io.*;
import java.util.*;
class Main {
int N, Q;
String S;
LazySegtree st;
void calc() {
int[] ns = nextInts();
N = ns[0]; Q = ns[1];
S = next();
int[] v = S.chars().map(c -> c - '0').toArray();
st = new LazySegtree(v);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Q; i++) {
int[] q = nextInts();
int L = q[1] - 1, R = q[2];
switch (q[0]) {
case 1:
st.operateSegment(L, R, 1);
break;
case 2:
sb.append( st.calculate(L, R) == 0 ? "Yes" : "No" );
sb.append('\n');
break;
default:
}
}
print(sb);
}
// ---
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String next() { try { return br.readLine(); } catch (Exception e) { return null; } }
String[] nexts() { return next().split(" "); }
static int i(String s) { return Integer.parseInt(s); }
int nextInt() { return i(next()); }
int[] nextInts() { return Arrays.stream(nexts()).mapToInt(Main::i).toArray(); }
void print(Object o) {
try { System.out.write(o.toString().getBytes()); System.out.flush(); }
catch (Exception e) { }
}
public static void main(String[] args) {
new Main().calc();
}
}
class LazySegtree {
private int m;
private Operator[] lazy;
private Segment[] seg;
LazySegtree(int[] value) {
init(value.length);
construct(value);
}
private void init(int size) {
m = (size == 1)? 1 : Integer.highestOneBit(size - 1) << 1;
lazy = new Operator[2*m - 1];
seg = new Segment[2*m - 1];
}
void construct(int[] v) {
int n = v.length;
for (int i = 0; i < n; i++) {
seg[m-1+i] = new Segment(v[i]);
lazy[m-1+i] = new Operator();
}
for (int i = m-1+n; i < 2*m-1; i++) {
seg[i] = Segment.E;
lazy[i] = Operator.I;
}
for (int i = m-2; i >= 0; i--) {
seg[i] = new Segment(seg[i*2+1]);
seg[i].append(seg[i*2+2]);
lazy[i] = new Operator();
}
}
private void eval(int n, int l, int r) {
if (lazy[n].isIdentity()) return;
lazy[n].map(seg[n], r-l);
if(n < m-1) {
lazy[2*n+1].compose(lazy[n]);
lazy[2*n+2].compose(lazy[n]);
}
lazy[n].clear();
}
void operateSegment(int s, int eExclusive, int ope) {
operateSegmentImpl(s, eExclusive, 0, 0, m, ope);
}
private void operateSegmentImpl(int s, int eExclusive, int n, int l, int r, int ope) {
if (s <= l && r <= eExclusive) {
lazy[n].compose(ope);
eval(n, l, r);
} else if (s < r && l < eExclusive) {
eval(n, l, r);
int i = (l>>>1)+(r>>>1);
operateSegmentImpl(s, eExclusive, 2*n + 1, l, i, ope);
operateSegmentImpl(s, eExclusive, 2*n + 2, i, r, ope);
seg[n].let(seg[2*n + 1]);
seg[n].append(seg[2*n + 2]);
} else {
eval(n, l, r);
}
}
private Segment acc = new Segment();
int calculate(int s, int eExclusive) {
acc.clear();
calcImpl(acc, s, eExclusive, 0, 0, m);
return acc.val;
}
private void calcImpl(Segment acc, int s, int eExclusive, int n, int l, int r) {
eval(n, l, r);
if (r <= s || eExclusive <= l) return;
if (s <= l && r <= eExclusive) {
acc.append(seg[n]);
return;
}
int i = (l>>>1)+(r>>>1);
calcImpl(acc, s, eExclusive, 2*n + 1, l, i);
calcImpl(acc, s, eExclusive, 2*n + 2, i, r);
}
}
class Segment {
static final Segment E = new Segment();
static int cnt = 0;
int val;
int l, r;
Segment() { val = 0; l = r = --cnt; }
Segment(int v) { val = 0; l = r = v; }
Segment(Segment s) {
let(s);
}
void clear() {
val = 0; l = r = --cnt;
}
void let(Segment s) {
val = s.val; l = s.l; r = s.r;
}
void append(Segment s) {
val = (val != 0 || s.val != 0)? 1 : ((r != s.l)? 0 : 1);
r = s.r;
}
}
class Operator {
static final Operator I = new Operator();
int val;
Operator() { }
Operator(int v) { val = v; }
boolean isIdentity() { return val == 0; }
void clear() { val = 0; }
void compose(Operator o) {
val ^= o.val;
}
void compose(int o) {
val ^= o;
}
void let(int o) {
val = o;
}
void map(Segment s, int len) {
s.l ^= val;
s.r ^= val;
}
}
|
ConDefects/ConDefects/Code/abc341_e/Java/50529797
|
condefects-java_data_814
|
import java.io.*;
import java.util.*;
class Main {
int N, Q;
String S;
LazySegtree st;
void calc() {
int[] ns = nextInts();
N = ns[0]; Q = ns[1];
S = next();
int[] v = S.chars().map(c -> c - '0').toArray();
st = new LazySegtree(v);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Q; i++) {
int[] q = nextInts();
int L = q[1] - 1, R = q[2];
switch (q[0]) {
case 1:
st.operateSegment(L, R, 1);
break;
case 2:
sb.append( st.calculate(L, R) == 0 ? "Yes" : "No" );
sb.append('\n');
break;
default:
}
}
print(sb);
}
// ---
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String next() { try { return br.readLine(); } catch (Exception e) { return null; } }
String[] nexts() { return next().split(" "); }
static int i(String s) { return Integer.parseInt(s); }
int nextInt() { return i(next()); }
int[] nextInts() { return Arrays.stream(nexts()).mapToInt(Main::i).toArray(); }
void print(Object o) {
try { System.out.write(o.toString().getBytes()); System.out.flush(); }
catch (Exception e) { }
}
public static void main(String[] args) {
new Main().calc();
}
}
class LazySegtree {
private int m;
private Operator[] lazy;
private Segment[] seg;
LazySegtree(int[] value) {
init(value.length);
construct(value);
}
private void init(int size) {
m = (size == 1)? 1 : Integer.highestOneBit(size - 1) << 1;
lazy = new Operator[2*m - 1];
seg = new Segment[2*m - 1];
}
void construct(int[] v) {
int n = v.length;
for (int i = 0; i < n; i++) {
seg[m-1+i] = new Segment(v[i]);
lazy[m-1+i] = new Operator();
}
for (int i = m-1+n; i < 2*m-1; i++) {
seg[i] = Segment.E;
lazy[i] = Operator.I;
}
for (int i = m-2; i >= 0; i--) {
seg[i] = new Segment(seg[i*2+1]);
seg[i].append(seg[i*2+2]);
lazy[i] = new Operator();
}
}
private void eval(int n, int l, int r) {
if (lazy[n].isIdentity()) return;
lazy[n].map(seg[n], r-l);
lazy[n].clear();
if(n < m-1) {
lazy[2*n+1].compose(lazy[n]);
lazy[2*n+2].compose(lazy[n]);
}
}
void operateSegment(int s, int eExclusive, int ope) {
operateSegmentImpl(s, eExclusive, 0, 0, m, ope);
}
private void operateSegmentImpl(int s, int eExclusive, int n, int l, int r, int ope) {
eval(n, l, r);
if (s <= l && r <= eExclusive) {
lazy[n].compose(ope);
eval(n, l, r);
} else if (s < r && l < eExclusive) {
int i = (l>>>1)+(r>>>1);
operateSegmentImpl(s, eExclusive, 2*n + 1, l, i, ope);
operateSegmentImpl(s, eExclusive, 2*n + 2, i, r, ope);
seg[n].let(seg[2*n + 1]);
seg[n].append(seg[2*n + 2]);
}
}
private Segment acc = new Segment();
int calculate(int s, int eExclusive) {
acc.clear();
calcImpl(acc, s, eExclusive, 0, 0, m);
return acc.val;
}
private void calcImpl(Segment acc, int s, int eExclusive, int n, int l, int r) {
eval(n, l, r);
if (r <= s || eExclusive <= l) return;
if (s <= l && r <= eExclusive) {
acc.append(seg[n]);
return;
}
int i = (l>>>1)+(r>>>1);
calcImpl(acc, s, eExclusive, 2*n + 1, l, i);
calcImpl(acc, s, eExclusive, 2*n + 2, i, r);
}
}
class Segment {
static final Segment E = new Segment();
static int cnt = 0;
int val;
int l, r;
Segment() { val = 0; l = r = --cnt; }
Segment(int v) { val = 0; l = r = v; }
Segment(Segment s) {
let(s);
}
void clear() {
val = 0; l = r = --cnt;
}
void let(Segment s) {
val = s.val; l = s.l; r = s.r;
}
void append(Segment s) {
val = (val != 0 || s.val != 0)? 1 : ((r != s.l)? 0 : 1);
r = s.r;
}
}
class Operator {
static final Operator I = new Operator();
int val;
Operator() { }
Operator(int v) { val = v; }
boolean isIdentity() { return val == 0; }
void clear() { val = 0; }
void compose(Operator o) {
val ^= o.val;
}
void compose(int o) {
val ^= o;
}
void let(int o) {
val = o;
}
void map(Segment s, int len) {
s.l ^= val;
s.r ^= val;
}
}
import java.io.*;
import java.util.*;
class Main {
int N, Q;
String S;
LazySegtree st;
void calc() {
int[] ns = nextInts();
N = ns[0]; Q = ns[1];
S = next();
int[] v = S.chars().map(c -> c - '0').toArray();
st = new LazySegtree(v);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Q; i++) {
int[] q = nextInts();
int L = q[1] - 1, R = q[2];
switch (q[0]) {
case 1:
st.operateSegment(L, R, 1);
break;
case 2:
sb.append( st.calculate(L, R) == 0 ? "Yes" : "No" );
sb.append('\n');
break;
default:
}
}
print(sb);
}
// ---
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String next() { try { return br.readLine(); } catch (Exception e) { return null; } }
String[] nexts() { return next().split(" "); }
static int i(String s) { return Integer.parseInt(s); }
int nextInt() { return i(next()); }
int[] nextInts() { return Arrays.stream(nexts()).mapToInt(Main::i).toArray(); }
void print(Object o) {
try { System.out.write(o.toString().getBytes()); System.out.flush(); }
catch (Exception e) { }
}
public static void main(String[] args) {
new Main().calc();
}
}
class LazySegtree {
private int m;
private Operator[] lazy;
private Segment[] seg;
LazySegtree(int[] value) {
init(value.length);
construct(value);
}
private void init(int size) {
m = (size == 1)? 1 : Integer.highestOneBit(size - 1) << 1;
lazy = new Operator[2*m - 1];
seg = new Segment[2*m - 1];
}
void construct(int[] v) {
int n = v.length;
for (int i = 0; i < n; i++) {
seg[m-1+i] = new Segment(v[i]);
lazy[m-1+i] = new Operator();
}
for (int i = m-1+n; i < 2*m-1; i++) {
seg[i] = Segment.E;
lazy[i] = Operator.I;
}
for (int i = m-2; i >= 0; i--) {
seg[i] = new Segment(seg[i*2+1]);
seg[i].append(seg[i*2+2]);
lazy[i] = new Operator();
}
}
private void eval(int n, int l, int r) {
if (lazy[n].isIdentity()) return;
lazy[n].map(seg[n], r-l);
if(n < m-1) {
lazy[2*n+1].compose(lazy[n]);
lazy[2*n+2].compose(lazy[n]);
}
lazy[n].clear();
}
void operateSegment(int s, int eExclusive, int ope) {
operateSegmentImpl(s, eExclusive, 0, 0, m, ope);
}
private void operateSegmentImpl(int s, int eExclusive, int n, int l, int r, int ope) {
eval(n, l, r);
if (s <= l && r <= eExclusive) {
lazy[n].compose(ope);
eval(n, l, r);
} else if (s < r && l < eExclusive) {
int i = (l>>>1)+(r>>>1);
operateSegmentImpl(s, eExclusive, 2*n + 1, l, i, ope);
operateSegmentImpl(s, eExclusive, 2*n + 2, i, r, ope);
seg[n].let(seg[2*n + 1]);
seg[n].append(seg[2*n + 2]);
}
}
private Segment acc = new Segment();
int calculate(int s, int eExclusive) {
acc.clear();
calcImpl(acc, s, eExclusive, 0, 0, m);
return acc.val;
}
private void calcImpl(Segment acc, int s, int eExclusive, int n, int l, int r) {
eval(n, l, r);
if (r <= s || eExclusive <= l) return;
if (s <= l && r <= eExclusive) {
acc.append(seg[n]);
return;
}
int i = (l>>>1)+(r>>>1);
calcImpl(acc, s, eExclusive, 2*n + 1, l, i);
calcImpl(acc, s, eExclusive, 2*n + 2, i, r);
}
}
class Segment {
static final Segment E = new Segment();
static int cnt = 0;
int val;
int l, r;
Segment() { val = 0; l = r = --cnt; }
Segment(int v) { val = 0; l = r = v; }
Segment(Segment s) {
let(s);
}
void clear() {
val = 0; l = r = --cnt;
}
void let(Segment s) {
val = s.val; l = s.l; r = s.r;
}
void append(Segment s) {
val = (val != 0 || s.val != 0)? 1 : ((r != s.l)? 0 : 1);
r = s.r;
}
}
class Operator {
static final Operator I = new Operator();
int val;
Operator() { }
Operator(int v) { val = v; }
boolean isIdentity() { return val == 0; }
void clear() { val = 0; }
void compose(Operator o) {
val ^= o.val;
}
void compose(int o) {
val ^= o;
}
void let(int o) {
val = o;
}
void map(Segment s, int len) {
s.l ^= val;
s.r ^= val;
}
}
|
ConDefects/ConDefects/Code/abc341_e/Java/50529653
|
condefects-java_data_815
|
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] arg) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String nq = br.readLine();
String s = br.readLine();
int[] nqarray = splitIntoInt(nq, 2);
int n = nqarray[0];
int q = nqarray[1];
TreeSet<Integer> set = new TreeSet<>();
for (int i = 1; i < n; i++) {
if (s.charAt(i - 1) == s.charAt(i)) {
set.add(i);
}
}
set.add(n + 1); // 番兵
for (int qi = 0; qi < q; qi++) {
String row = br.readLine();
int[] rowarray = splitIntoInt(row, 3);
int cmd = rowarray[0];
int l = rowarray[1];
int r = rowarray[2];
if (cmd == 1) {
xor(set, l - 1);
xor(set, r);
} else {
boolean yes = r <= set.higher(l);
System.out.println(yes ? "Yes" : "No");
}
}
}
static void xor(Set<Integer> set, int x) {
if (set.contains(x)) {
set.remove(x);
} else {
set.add(x);
}
}
static int[] buf = new int[3];
static int[] splitIntoInt(String s, int n) {
int i = 0;
int acc = 0;
for (int pos = 0; pos < s.length(); pos++) {
if ('0' <= s.charAt(pos) && s.charAt(pos) <= '9') {
acc = acc * 10 + (s.charAt(pos) - '0');
} else {
buf[i++] = acc;
acc = 0;
}
}
buf[i] = acc;
return buf;
}
}
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] arg) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String nq = br.readLine();
String s = br.readLine();
int[] nqarray = splitIntoInt(nq, 2);
int n = nqarray[0];
int q = nqarray[1];
TreeSet<Integer> set = new TreeSet<>();
for (int i = 1; i < n; i++) {
if (s.charAt(i - 1) == s.charAt(i)) {
set.add(i);
}
}
set.add(n + 1); // 番兵
for (int qi = 0; qi < q; qi++) {
String row = br.readLine();
int[] rowarray = splitIntoInt(row, 3);
int cmd = rowarray[0];
int l = rowarray[1];
int r = rowarray[2];
if (cmd == 1) {
xor(set, l - 1);
xor(set, r);
} else {
boolean yes = r <= set.higher(l - 1);
System.out.println(yes ? "Yes" : "No");
}
}
}
static void xor(Set<Integer> set, int x) {
if (set.contains(x)) {
set.remove(x);
} else {
set.add(x);
}
}
static int[] buf = new int[3];
static int[] splitIntoInt(String s, int n) {
int i = 0;
int acc = 0;
for (int pos = 0; pos < s.length(); pos++) {
if ('0' <= s.charAt(pos) && s.charAt(pos) <= '9') {
acc = acc * 10 + (s.charAt(pos) - '0');
} else {
buf[i++] = acc;
acc = 0;
}
}
buf[i] = acc;
return buf;
}
}
|
ConDefects/ConDefects/Code/abc341_e/Java/50625510
|
condefects-java_data_816
|
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.next();
for(int i=0 ;i<s.length(); i++){
if(s.charAt(s.length()-(i+1))=='a'){
System.out.println(s.length()-(i+1));
return;
}
}
System.out.println(-1);
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.next();
for(int i=0 ;i<s.length(); i++){
if(s.charAt(s.length()-(i+1))=='a'){
System.out.println(s.length()-i);
return;
}
}
System.out.println(-1);
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/41659330
|
condefects-java_data_817
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input = sc.next();
int ans = -1;
for (int i = 0; i < input.length(); i++) {
if (input.substring(i,i+1).equals("a")) {
ans = i;
}
}
System.out.println(ans);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input = sc.next();
int ans = -1;
for (int i = 0; i < input.length(); i++) {
if (input.substring(i,i+1).equals("a")) {
ans = i+1;
}
}
System.out.println(ans);
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/38558136
|
condefects-java_data_818
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String s=scanner.nextLine();
for(int i=s.length()-1;i>=0;i--){
if(s.charAt(i)=='a'){
System.out.println(i+1);
break;
} else {
System.out.println(-1);
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String s=scanner.nextLine();
for(int i=s.length()-1;i>=0;i--){
if(s.charAt(i)=='a'){
System.out.println(i+1);
break;
} else if(!(s.charAt(i)=='a')&&i==0){
System.out.println(-1);
}
}
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/41470373
|
condefects-java_data_819
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.next();
int output = -1;
for(int i=0;i<s.length();i++){
if(s.charAt(i) == 'a')output = i;
}
System.out.println(output);
sc.close();
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.next();
int output = -1;
for(int i=0;i<s.length();i++){
if(s.charAt(i) == 'a')output = i+1;
}
System.out.println(output);
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/39596159
|
condefects-java_data_820
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
String str= scn.next();
int len= str.length();
if(str.contains("a")) {
for(int i=len-1;i>0;i--) {
if(str.charAt(i)=='a') {
System.out.println(i+1);
break;
}
}
}
else {
System.out.println(-1);
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
String str= scn.next();
int len= str.length();
if(str.contains("a")) {
for(int i=len-1;i>=0;i--) {
if(str.charAt(i)=='a') {
System.out.println(i+1);
break;
}
}
}
else {
System.out.println(-1);
}
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/38988299
|
condefects-java_data_821
|
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String s = sc.next();
int a = -1;
for (int i=0; i<s.length(); i++)
{
if (s.charAt(i) == 'a')
{
a = i;
}
}
System.out.println(a+1);
}
}
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String s = sc.next();
int a = -2;
for (int i=0; i<s.length(); i++)
{
if (s.charAt(i) == 'a')
{
a = i;
}
}
System.out.println(a+1);
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/45933456
|
condefects-java_data_822
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
for(int i=s.length()-1; i >= 0; i--) {
if(s.charAt(i)=='a') {
System.out.println(i+1);
break;
}
if(i==1) {
System.out.println(-1);
}
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
for(int i=s.length()-1; i >= 0; i--) {
if(s.charAt(i)=='a') {
System.out.println(i+1);
break;
}
if(i==0) {
System.out.println(-1);
}
}
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/40290194
|
condefects-java_data_823
|
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
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));
char[] arr = br.readLine().toCharArray();
for(int i = arr.length - 1;i >= 0;i--){
if(arr[i] == 'a'){
System.out.println(i);
return;
}
}
System.out.println(-1);
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
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));
char[] arr = br.readLine().toCharArray();
for(int i = arr.length - 1;i >= 0;i--){
if(arr[i] == 'a'){
System.out.println(i+1);
return;
}
}
System.out.println(-1);
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/40154542
|
condefects-java_data_824
|
import java.util.Scanner;
/**
* メインクラス.
*/
class Main {
private static String S;
/**
* メイン処理.
*
* @param args 実行時引数
*/
public static void main(String[] args) {
// 標準入力を取得
getInput();
// 求解処理
solve();
}
/**
* 標準入力を取得する.
*/
private static void getInput() {
final Scanner scanner = new Scanner(System.in);
S = scanner.next();
scanner.close();
}
/**
* 求解処理.
*/
private static void solve() {
int ans = S.lastIndexOf('a');
if (ans > 0) {
ans++;
}
System.out.println(ans);
}
}
import java.util.Scanner;
/**
* メインクラス.
*/
class Main {
private static String S;
/**
* メイン処理.
*
* @param args 実行時引数
*/
public static void main(String[] args) {
// 標準入力を取得
getInput();
// 求解処理
solve();
}
/**
* 標準入力を取得する.
*/
private static void getInput() {
final Scanner scanner = new Scanner(System.in);
S = scanner.next();
scanner.close();
}
/**
* 求解処理.
*/
private static void solve() {
int ans = S.lastIndexOf('a');
if (ans >= 0) {
ans++;
}
System.out.println(ans);
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/39750942
|
condefects-java_data_825
|
import java.util.NoSuchElementException;
import java.util.Scanner;
class Main {
public static void main(String[] args) {
try {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if(!str.contains("a")) {
System.out.println(-1);
return;
}
for(int i=str.length()-1;i>0;i--) {
if(str.charAt(i)=='a') {
System.out.println(i+1);
return;
}
}
sc.close();
} catch (NoSuchElementException e) {
// TODO: handle exception
}
}
}
import java.util.NoSuchElementException;
import java.util.Scanner;
class Main {
public static void main(String[] args) {
try {
Scanner sc = new Scanner(System.in);
String str = sc.next();
if(!str.contains("a")) {
System.out.println(-1);
return;
}
for(int i=str.length()-1;i>=0;i--) {
if(str.charAt(i)=='a') {
System.out.println(i+1);
return;
}
}
sc.close();
} catch (NoSuchElementException e) {
// TODO: handle exception
}
}
}
|
ConDefects/ConDefects/Code/abc276_a/Java/38143541
|
condefects-java_data_826
|
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder sb0 = new StringBuilder(sc.next());
StringBuilder sb1 = new StringBuilder(sc.next());
if (sb0.length() == 1) {
sb0.insert(0, 0);
}
if (sb1.length() == 1) {
sb1.insert(0, 0);
}
List<Character> time = new ArrayList<>();
List<Integer> timenum = new ArrayList<>();
for (int i = 0; i < 2; i++) {
time.add(i, sb0.charAt(i));
}
for (int i = 0; i < 2; i++) {
time.add(i + 1, sb1.charAt(i));
}
for (int i = 0; i < 4; i++) {
timenum.add(i, Integer.parseInt(String.valueOf(time.get(i))));
}
if (timenum.get(0) == 0) {
if (timenum.get(1) >= 6) {
timenum.set(0, 1);
timenum.set(1, 0);
timenum.set(2, 0);
timenum.set(3, 0);
}
}
if (timenum.get(0) == 1) {
if (timenum.get(1) >= 6) {
timenum.set(0, 2);
timenum.set(1, 0);
timenum.set(2, 0);
timenum.set(3, 0);
}
}
if (timenum.get(0) == 2) {
if (timenum.get(2) >= 4 && 0 <= timenum.get(1) && timenum.get(1) <= 2) {
timenum.set(1, timenum.get(1) + 1);
timenum.set(2, 0);
timenum.set(3, 0);
}
if (timenum.get(2) >= 4 && timenum.get(1) == 3) {
timenum.set(0, 0);
timenum.set(1, 0);
timenum.set(2, 0);
timenum.set(3, 0);
}
}
System.out.println(timenum.get(0) + "" + timenum.get(1) + " " + timenum.get(2) + "" + timenum.get(3));
}
}
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder sb0 = new StringBuilder(sc.next());
StringBuilder sb1 = new StringBuilder(sc.next());
if (sb0.length() == 1) {
sb0.insert(0, 0);
}
if (sb1.length() == 1) {
sb1.insert(0, 0);
}
List<Character> time = new ArrayList<>();
List<Integer> timenum = new ArrayList<>();
for (int i = 0; i < 2; i++) {
time.add(i, sb0.charAt(i));
}
for (int i = 0; i < 2; i++) {
time.add(i + 2, sb1.charAt(i));
}
for (int i = 0; i < 4; i++) {
timenum.add(i, Integer.parseInt(String.valueOf(time.get(i))));
}
if (timenum.get(0) == 0) {
if (timenum.get(1) >= 6) {
timenum.set(0, 1);
timenum.set(1, 0);
timenum.set(2, 0);
timenum.set(3, 0);
}
}
if (timenum.get(0) == 1) {
if (timenum.get(1) >= 6) {
timenum.set(0, 2);
timenum.set(1, 0);
timenum.set(2, 0);
timenum.set(3, 0);
}
}
if (timenum.get(0) == 2) {
if (timenum.get(2) >= 4 && 0 <= timenum.get(1) && timenum.get(1) <= 2) {
timenum.set(1, timenum.get(1) + 1);
timenum.set(2, 0);
timenum.set(3, 0);
}
if (timenum.get(2) >= 4 && timenum.get(1) == 3) {
timenum.set(0, 0);
timenum.set(1, 0);
timenum.set(2, 0);
timenum.set(3, 0);
}
}
System.out.println(timenum.get(0) + "" + timenum.get(1) + " " + timenum.get(2) + "" + timenum.get(3));
}
}
|
ConDefects/ConDefects/Code/abc278_b/Java/42045770
|
condefects-java_data_827
|
import java.util.Scanner;
public class Main {
public static void main(final String[] args) {
try (final Scanner sc = new Scanner(System.in)) {
final int H = Integer.parseInt(sc.next());
final int M = Integer.parseInt(sc.next());
int a = H / 10;
int b = H % 10;
int c = M / 10;
int d = M % 10;
while (!isMisleadingTime(a, b, c, d)) {
if (c == 5 && d == 9) {
c = 0;
d = 0;
if (a == 2 && b == 3) {
a = 0;
b = 0;
} else if (b == 9) {
a++;
b = 0;
} else {
b++;
}
} else if (d == 9) {
c++;
d = 0;
} else {
d++;
}
}
System.out.println(a + "" + b + " " + c + "" + d);
}
}
private static boolean isMisleadingTime(final int a, final int b, final int c, final int d) {
if (b > 2) {
return false;
}
if (a == 2 && c > 3) {
return false;
}
if (a > 3) {
return false;
}
return true;
}
}
import java.util.Scanner;
public class Main {
public static void main(final String[] args) {
try (final Scanner sc = new Scanner(System.in)) {
final int H = Integer.parseInt(sc.next());
final int M = Integer.parseInt(sc.next());
int a = H / 10;
int b = H % 10;
int c = M / 10;
int d = M % 10;
while (!isMisleadingTime(a, b, c, d)) {
if (c == 5 && d == 9) {
c = 0;
d = 0;
if (a == 2 && b == 3) {
a = 0;
b = 0;
} else if (b == 9) {
a++;
b = 0;
} else {
b++;
}
} else if (d == 9) {
c++;
d = 0;
} else {
d++;
}
}
System.out.println(a + "" + b + " " + c + "" + d);
}
}
private static boolean isMisleadingTime(final int a, final int b, final int c, final int d) {
if (b > 5) {
return false;
}
if (a == 2 && c > 3) {
return false;
}
if (a > 3) {
return false;
}
return true;
}
}
|
ConDefects/ConDefects/Code/abc278_b/Java/44866224
|
condefects-java_data_828
|
//Click on the SUBMIT button to make a submission to this problem.
import java.util.*;
import java.io.*;
public class Main {
public static int[] takeInput(int n) {
int arr[] = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = in.nextInt();
}
return arr;
}
static InputStream inputStream = System.in;
static InputReader in = new InputReader(inputStream);
public static void main(String[] args) {
// System.in and System.out are input and output streams, respectively.
// Taking input for Integer
// int t = in.nextInt();
// while (t-- > 0) {
//
// }
//int n = in.nextInt();
// int a = in.nextInt();
// int b = in.nextInt();
// int arr[] = takeInput(n);
int arr[] = new int[8];
for(int i = 0; i < arr.length; i++) {
arr[i] = in.nextInt();
}
if((arr[0] < 100 && arr[0] > 675) || arr[0] % 25 != 0) {
System.out.println("No");
return;
}
for(int i = 1; i < arr.length; i++) {
if((arr[i] < 100 && arr[i] > 675) || arr[i] % 25 != 0 || (arr[i - 1] > arr[i])) {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(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 int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
//Click on the SUBMIT button to make a submission to this problem.
import java.util.*;
import java.io.*;
public class Main {
public static int[] takeInput(int n) {
int arr[] = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = in.nextInt();
}
return arr;
}
static InputStream inputStream = System.in;
static InputReader in = new InputReader(inputStream);
public static void main(String[] args) {
// System.in and System.out are input and output streams, respectively.
// Taking input for Integer
// int t = in.nextInt();
// while (t-- > 0) {
//
// }
//int n = in.nextInt();
// int a = in.nextInt();
// int b = in.nextInt();
// int arr[] = takeInput(n);
int arr[] = new int[8];
for(int i = 0; i < arr.length; i++) {
arr[i] = in.nextInt();
}
if((arr[0] < 100 && arr[0] > 675) || arr[0] % 25 != 0) {
System.out.println("No");
return;
}
for(int i = 1; i < arr.length; i++) {
if((arr[i] < 100 || arr[i] > 675) || arr[i] % 25 != 0 || (arr[i - 1] > arr[i])) {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(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 int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
|
ConDefects/ConDefects/Code/abc308_a/Java/43956443
|
condefects-java_data_829
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] S = new int[8];
for (int i = 0; i < 8; i++) {
S[i] = sc.nextInt();
}
int count = 0;
for (int i = 0; i < 8; i++) {
if (S[i] % 25 == 0) {
count++;
}
if (100 <= S[i] && S[i] <= 675) {
count++;
}
if (i < 7 && S[i] < S[i + 1]) {
count++;
}
}
if (count == 23) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] S = new int[8];
for (int i = 0; i < 8; i++) {
S[i] = sc.nextInt();
}
int count = 0;
for (int i = 0; i < 8; i++) {
if (S[i] % 25 == 0) {
count++;
}
if (100 <= S[i] && S[i] <= 675) {
count++;
}
if (i < 7 && S[i] <= S[i + 1]) {
count++;
}
}
if (count == 23) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc308_a/Java/44592756
|
condefects-java_data_830
|
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int []A=new int[8];
int ansd,ans;
ansd=ans=0;
for(int i=0; i<8; i++){
A[i]=sc.nextInt();
}
for(int i=0; i<7; i++){
if(A[i]<A[i+1])ansd++;
}
if(ansd==7)ans++;
if(100<=A[0] && A[7]<=675)ans++;
ansd=0;
for(int i=0; i<8; i++){
if(A[i]%25==0)ansd++;
}
if(ansd==8)ans++;
if(ans==3){
System.out.print("Yes");
}else{
System.out.print("No");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int []A=new int[8];
int ansd,ans;
ansd=ans=0;
for(int i=0; i<8; i++){
A[i]=sc.nextInt();
}
for(int i=0; i<7; i++){
if(A[i]<=A[i+1])ansd++;
}
if(ansd==7)ans++;
if(100<=A[0] && A[7]<=675)ans++;
ansd=0;
for(int i=0; i<8; i++){
if(A[i]%25==0)ansd++;
}
if(ansd==8)ans++;
if(ans==3){
System.out.print("Yes");
}else{
System.out.print("No");
}
}
}
|
ConDefects/ConDefects/Code/abc308_a/Java/44126404
|
condefects-java_data_831
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] input = new int[8];
int tmp = 0;
String result = "Yes";
for(int i=0; i<8; i++){
input[i] = sc.nextInt();
if(input[i] < 100 || input[i] > 675){
result = "No";
break;
}
if(input[i]%25 != 0){
result = "No";
break;
}
if(input[i] <= tmp){
result = "No";
break;
}
tmp = input[i];
}
System.out.println(result);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] input = new int[8];
int tmp = 0;
String result = "Yes";
for(int i=0; i<8; i++){
input[i] = sc.nextInt();
if(input[i] < 100 || input[i] > 675){
result = "No";
break;
}
if(input[i]%25 != 0){
result = "No";
break;
}
if(input[i] < tmp){
result = "No";
break;
}
tmp = input[i];
}
System.out.println(result);
}
}
|
ConDefects/ConDefects/Code/abc308_a/Java/43512856
|
condefects-java_data_832
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] wordArray = sc.nextLine().split(" ");
for (int i=0; i < 8; i++) {
if (i == 0) {
continue;
}
int num = Integer.parseInt(wordArray[i]);
int num2 = Integer.parseInt(wordArray[i - 1]);
int diff = num - num2;
if (!(0 < diff && 100 <= num && num <= 675 && num % 25 == 0)) {
System.out.print("No");
return;
}
}
System.out.print("Yes");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] wordArray = sc.nextLine().split(" ");
for (int i=0; i < 8; i++) {
if (i == 0) {
continue;
}
int num = Integer.parseInt(wordArray[i]);
int num2 = Integer.parseInt(wordArray[i - 1]);
int diff = num - num2;
if (!(0 <= diff && 100 <= num && num <= 675 && num % 25 == 0)) {
System.out.print("No");
return;
}
}
System.out.print("Yes");
}
}
|
ConDefects/ConDefects/Code/abc308_a/Java/43541818
|
condefects-java_data_833
|
// Online Java Compiler
// Use this editor to write, compile and run your Java code online
// Online Java Compiler
// Use this editor to write, compile and run your Java code online
// Online Java Compiler
// Use this editor to write, compile and run your Java code online
import java.util.*;
import java.io.*;
public class Main
{
public static void main (String[]args)
{
Scanner sc = new Scanner (System.in);
boolean f = true ;
int[] arry = new int[8] ;
for ( int a = 0 ; a < 8 ; a++ ){
arry[a] = sc.nextInt();
}
for ( int a = 0 ; a < 8 ; a++ ){
if (a<7 && arry[a] > arry[a+1] ){
f = false ;
}
if ( arry[a]%25 != 0 ){
f = false ;
}
}
System.out.println(f ? "Yes":"No");
}
}
// Online Java Compiler
// Use this editor to write, compile and run your Java code online
// Online Java Compiler
// Use this editor to write, compile and run your Java code online
// Online Java Compiler
// Use this editor to write, compile and run your Java code online
import java.util.*;
import java.io.*;
public class Main
{
public static void main (String[]args)
{
Scanner sc = new Scanner (System.in);
boolean f = true ;
int[] arry = new int[8] ;
for ( int a = 0 ; a < 8 ; a++ ){
arry[a] = sc.nextInt();
}
for ( int a = 0 ; a < 8 ; a++ ){
if (a<7 && arry[a] > arry[a+1] ){
f = false ;
}
if ( arry[a]%25 != 0 || arry[a]< 100 || arry[a] > 675 ){
f = false ;
}
}
System.out.println(f ? "Yes":"No");
}
}
|
ConDefects/ConDefects/Code/abc308_a/Java/44689857
|
condefects-java_data_834
|
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//整数列
int N = scanner.nextInt();
int L = scanner.nextInt();
int R = scanner.nextInt();
for(int i = 0; i < N; i++) {
int A = scanner.nextInt();
int X;
if (L <= A && A <= R) {
X = A;
} else if (A < L) {
X = L;
} else {
X = R;
}
System.out.println("X");
}
scanner.close();
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//整数列
int N = scanner.nextInt();
int L = scanner.nextInt();
int R = scanner.nextInt();
for(int i = 0; i < N; i++) {
int A = scanner.nextInt();
int X;
if (L <= A && A <= R) {
X = A;
} else if (A < L) {
X = L;
} else {
X = R;
}
System.out.println(X);
}
scanner.close();
}
}
|
ConDefects/ConDefects/Code/abc330_b/Java/48243293
|
condefects-java_data_835
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
st = new StringTokenizer(br.readLine(), " ");
int n = Integer.parseInt(st.nextToken());
int l = Integer.parseInt(st.nextToken());
int r = Integer.parseInt(st.nextToken());
st = new StringTokenizer(br.readLine(), " ");
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
int num = -1;
for (int i = 0; i < n; i++) {
if (l <= arr[i] && arr[i] <= r) num = r;
else if (l > arr[i]) num = l;
else num = r;
sb.append(num + " ");
}
System.out.println(sb.toString().trim());
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
st = new StringTokenizer(br.readLine(), " ");
int n = Integer.parseInt(st.nextToken());
int l = Integer.parseInt(st.nextToken());
int r = Integer.parseInt(st.nextToken());
st = new StringTokenizer(br.readLine(), " ");
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
int num = -1;
for (int i = 0; i < n; i++) {
if (l <= arr[i] && arr[i] <= r) num = arr[i];
else if (l > arr[i]) num = l;
else num = r;
sb.append(num + " ");
}
System.out.println(sb.toString().trim());
}
}
|
ConDefects/ConDefects/Code/abc330_b/Java/48830560
|
condefects-java_data_836
|
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 l = sc.nextInt();
int r = sc.nextInt();
int []a = new int[n];
for(int i=0; i<n; i++) {
a[i] = sc.nextInt();
}
sc.close();
for(int i=0; i<n; i++) {
if(a[i]<=l) {
System.out.print(l+" ");
}else if(r<=a[i]) {
System.out.print(r+" ");
}
}
}
}
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 l = sc.nextInt();
int r = sc.nextInt();
int []a = new int[n];
for(int i=0; i<n; i++) {
a[i] = sc.nextInt();
}
sc.close();
for(int i=0; i<n; i++) {
if(a[i]<=l) {
System.out.print(l+" ");
}else if(r<=a[i]) {
System.out.print(r+" ");
}else {
System.out.println(a[i]+ " ");
}
}
}
}
|
ConDefects/ConDefects/Code/abc330_b/Java/53208666
|
condefects-java_data_837
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.NoSuchElementException;
import java.util.TreeMap;
public class Main{
public static void main(String[] args) {
new Main().run();
}
long powmod(long a, long n, long mod) {
if (n == 0) return 1;
return powmod(a*a%mod, n/2, mod) * (n % 2 == 1 ? a : 1) % mod;
}
int INF = Integer.MAX_VALUE / 3;
class V {
int fv;
int sv;
int fn;
int sn;
public V() {
fv = -INF+1;
sv = -INF;
fn = 0;
sn = 0;
}
public V(int val) {
this();
fv = val;
fn = 1;
}
V copy() {
V ret = new V();
ret.fv = fv;
ret.sv = sv;
ret.fn = fn;
ret.sn = sn;
return ret;
}
void add(int val, int num) {
if (val > fv) {
sv = fv;
sn = fn;
fv = val;
fn = num;
} else if (val == fv) {
sn += num;
} else if (fv > val && val > sv) {
sv = val;
sn = num;
} else if (val == sv) {
sn += num;
}
}
}
class Tree {
int n;
V[] v;
public Tree(int n_) {
n = 2 * Integer.highestOneBit(n_);
v = new V[2 * n];
for (int i = 0; i < 2 * n; ++i) {
v[i] = new V();
}
}
void set(int k, int val) {
k = id(k, k + 1);
v[k] = new V(val);
while (k != id(0, n)) {
k /= 2;
v[k] = merge(v[2 * k], v[2 * k + 1]);
}
}
V query(int a, int b) {
if (b - a <= 0) return null;
int ma = a + Integer.lowestOneBit(a);
int mb = b - Integer.lowestOneBit(b);
if (a < ma && ma <= b) {
return merge(v[id(a, ma)], query(ma, b));
} else {
return merge(query(a, mb), v[id(mb, b)]);
}
}
int id(int a, int b) {
int w = Integer.lowestOneBit(a ^ b);
return a / w + n / w;
}
V merge(V a, V b) {
if (a == null) return b.copy();
if (b == null) return a.copy();
V c = new V();
c.add(a.fv, a.fn);
c.add(a.sv, a.sn);
c.add(b.fv, b.fn);
c.add(b.sv, b.sn);
return c;
}
}
void run() {
FastScanner sc=new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
int N = sc.nextInt();
int Q = sc.nextInt();
int[] A = new int[N];
Tree tree = new Tree(N);
for (int i = 0; i < N; ++i) {
A[i] = sc.nextInt();
tree.set(i, A[i]);
}
for (int i = 0; i < Q; ++i) {
int type = sc.nextInt();
if (type == 1) {
int p = sc.nextInt() - 1;
int x = sc.nextInt();
tree.set(p, x);
} else {
int l = sc.nextInt() - 1;
int r = sc.nextInt() - 1;
var v = tree.query(l, r + 1);
System.out.println(v.sn);
}
}
}
void tr(Object...objects) {System.out.println(Arrays.deepToString(objects));}
}
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();
}
}
public int nextInt() {
return (int)nextLong();
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.NoSuchElementException;
import java.util.TreeMap;
public class Main{
public static void main(String[] args) {
new Main().run();
}
long powmod(long a, long n, long mod) {
if (n == 0) return 1;
return powmod(a*a%mod, n/2, mod) * (n % 2 == 1 ? a : 1) % mod;
}
int INF = Integer.MAX_VALUE / 3;
class V {
int fv;
int sv;
int fn;
int sn;
public V() {
fv = -INF+1;
sv = -INF;
fn = 0;
sn = 0;
}
public V(int val) {
this();
fv = val;
fn = 1;
}
V copy() {
V ret = new V();
ret.fv = fv;
ret.sv = sv;
ret.fn = fn;
ret.sn = sn;
return ret;
}
void add(int val, int num) {
if (val > fv) {
sv = fv;
sn = fn;
fv = val;
fn = num;
} else if (val == fv) {
fn += num;
} else if (fv > val && val > sv) {
sv = val;
sn = num;
} else if (val == sv) {
sn += num;
}
}
}
class Tree {
int n;
V[] v;
public Tree(int n_) {
n = 2 * Integer.highestOneBit(n_);
v = new V[2 * n];
for (int i = 0; i < 2 * n; ++i) {
v[i] = new V();
}
}
void set(int k, int val) {
k = id(k, k + 1);
v[k] = new V(val);
while (k != id(0, n)) {
k /= 2;
v[k] = merge(v[2 * k], v[2 * k + 1]);
}
}
V query(int a, int b) {
if (b - a <= 0) return null;
int ma = a + Integer.lowestOneBit(a);
int mb = b - Integer.lowestOneBit(b);
if (a < ma && ma <= b) {
return merge(v[id(a, ma)], query(ma, b));
} else {
return merge(query(a, mb), v[id(mb, b)]);
}
}
int id(int a, int b) {
int w = Integer.lowestOneBit(a ^ b);
return a / w + n / w;
}
V merge(V a, V b) {
if (a == null) return b.copy();
if (b == null) return a.copy();
V c = new V();
c.add(a.fv, a.fn);
c.add(a.sv, a.sn);
c.add(b.fv, b.fn);
c.add(b.sv, b.sn);
return c;
}
}
void run() {
FastScanner sc=new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
int N = sc.nextInt();
int Q = sc.nextInt();
int[] A = new int[N];
Tree tree = new Tree(N);
for (int i = 0; i < N; ++i) {
A[i] = sc.nextInt();
tree.set(i, A[i]);
}
for (int i = 0; i < Q; ++i) {
int type = sc.nextInt();
if (type == 1) {
int p = sc.nextInt() - 1;
int x = sc.nextInt();
tree.set(p, x);
} else {
int l = sc.nextInt() - 1;
int r = sc.nextInt() - 1;
var v = tree.query(l, r + 1);
System.out.println(v.sn);
}
}
}
void tr(Object...objects) {System.out.println(Arrays.deepToString(objects));}
}
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();
}
}
public int nextInt() {
return (int)nextLong();
}
}
|
ConDefects/ConDefects/Code/abc343_f/Java/50851295
|
condefects-java_data_838
|
import java.io.*;
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner();
int n = sc.nextInt();
int q = sc.nextInt();
SegmentTree st = new SegmentTree(n);
for (int i = 0; i < n; i++) {
st.setValue(i, sc.nextInt());
}
String result = IntStream.range(0, q).mapToObj(i -> {
if (sc.nextInt() == 1) {
st.setValue(sc.nextInt() - 1, sc.nextInt());
return null;
} else {
return String.valueOf(st.getSecondCount(sc.nextInt() - 1, sc.nextInt()));
}
}).filter(x -> x != null)
.collect(Collectors.joining("\n"));
System.out.println(result);
}
static class SegmentTree {
int size;
int[] firsts;
int[] firstCount;
int[] seconds;
int[] secondCount;
public SegmentTree(int x) {
size = 2;
while (size < x) {
size <<= 1;
}
firsts = new int[size * 2 - 1];
firstCount = new int[size * 2 - 1];
seconds = new int[size * 2 - 1];
secondCount = new int[size * 2 - 1];
}
public void setValue(int idx, int v) {
firsts[size - 1 + idx] = v;
firstCount[size - 1 + idx] = 1;
calc((size - 1 + idx - 1) / 2);
}
private void calc(int idx) {
int left = idx * 2 + 1;
int right = idx * 2 + 2;
if (firsts[left] == firsts[right]) {
firsts[idx] = firsts[left];
firstCount[idx] = firstCount[left] + firstCount[right];
if (seconds[left] == seconds[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left] + secondCount[right];
} else if (seconds[left] > seconds[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left];
} else {
seconds[idx] = seconds[right];
secondCount[idx] = secondCount[right];
}
} else if (firsts[left] > firsts[right]) {
firsts[idx] = firsts[left];
firstCount[idx] = firstCount[left];
if (seconds[left] == firsts[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left] + firstCount[right];
} else if (seconds[left] > firsts[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left];
} else {
seconds[idx] = firsts[right];
secondCount[idx] = firstCount[right];
}
} else {
firsts[idx] = firsts[right];
firstCount[idx] = firstCount[right];
if (firsts[left] == seconds[right]) {
seconds[idx] = firsts[left];
secondCount[idx] = firstCount[left] + secondCount[right];
} else if (firsts[left] > seconds[right]) {
seconds[idx] = firsts[left];
secondCount[idx] = firstCount[left];
} else {
seconds[idx] = seconds[right];
secondCount[idx] = secondCount[right];
}
}
if (idx > 0) {
calc((idx - 1) / 2);
}
}
public int getSecondCount(int left, int right) {
return getCount(getValue(0, 0, size, left, right)[1], 0, 0, size, left, right);
}
private int[] getValue(int idx, int min, int max, int left, int right) {
if (left <= min && max <= right) {
return new int[]{firsts[idx], seconds[idx]};
}
if (right <= min || max <= left) {
return new int[2];
}
int[] value1 = getValue(idx * 2 + 1, min, (min + max) / 2, left, right);
int[] value2 = getValue(idx * 2 + 2, (min + max) / 2, max, left, right);
int[] ans = new int[2];
if (value1[0] == value2[0]) {
ans[0] = value1[0];
if (value1[1] >= value2[1]) {
ans[1] = value1[1];
} else {
ans[1] = value2[1];
}
} else if (value1[0] > value2[0]) {
ans[0] = value1[0];
if (value1[1] >= value2[0]) {
ans[1] = value1[1];
} else {
ans[1] = value2[0];
}
} else {
ans[1] = value2[0];
if (value1[0] >= value2[1]) {
ans[1] = value1[0];
} else {
ans[1] = value2[1];
}
}
return ans;
}
private int getCount(int value, int idx, int min, int max, int left, int right) {
if (left <= min && max <= right) {
if (firsts[idx] == value) {
return firstCount[idx];
} else if (seconds[idx] == value) {
return secondCount[idx];
} else {
return 0;
}
}
if (right <= min || max <= left) {
return 0;
}
return getCount(value, idx * 2 + 1, min, (min + max) / 2, left, right) +
getCount(value, idx * 2 + 2, (min + max) / 2, max, left, right);
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(Arrays.toString(firsts)).append("\n")
.append(Arrays.toString(firstCount)).append("\n")
.append(Arrays.toString(seconds)).append("\n")
.append(Arrays.toString(secondCount)).append("\n");
return sb.toString();
}
}
}
class Scanner {
BufferedReader br;
StringTokenizer st = new StringTokenizer("");
StringBuilder sb = new StringBuilder();
public Scanner() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
} catch (Exception e) {
}
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String next() {
try {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
} catch (Exception e) {
e.printStackTrace();
} finally {
return st.nextToken();
}
}
}
import java.io.*;
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner();
int n = sc.nextInt();
int q = sc.nextInt();
SegmentTree st = new SegmentTree(n);
for (int i = 0; i < n; i++) {
st.setValue(i, sc.nextInt());
}
String result = IntStream.range(0, q).mapToObj(i -> {
if (sc.nextInt() == 1) {
st.setValue(sc.nextInt() - 1, sc.nextInt());
return null;
} else {
return String.valueOf(st.getSecondCount(sc.nextInt() - 1, sc.nextInt()));
}
}).filter(x -> x != null)
.collect(Collectors.joining("\n"));
System.out.println(result);
}
static class SegmentTree {
int size;
int[] firsts;
int[] firstCount;
int[] seconds;
int[] secondCount;
public SegmentTree(int x) {
size = 2;
while (size < x) {
size <<= 1;
}
firsts = new int[size * 2 - 1];
firstCount = new int[size * 2 - 1];
seconds = new int[size * 2 - 1];
secondCount = new int[size * 2 - 1];
}
public void setValue(int idx, int v) {
firsts[size - 1 + idx] = v;
firstCount[size - 1 + idx] = 1;
calc((size - 1 + idx - 1) / 2);
}
private void calc(int idx) {
int left = idx * 2 + 1;
int right = idx * 2 + 2;
if (firsts[left] == firsts[right]) {
firsts[idx] = firsts[left];
firstCount[idx] = firstCount[left] + firstCount[right];
if (seconds[left] == seconds[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left] + secondCount[right];
} else if (seconds[left] > seconds[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left];
} else {
seconds[idx] = seconds[right];
secondCount[idx] = secondCount[right];
}
} else if (firsts[left] > firsts[right]) {
firsts[idx] = firsts[left];
firstCount[idx] = firstCount[left];
if (seconds[left] == firsts[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left] + firstCount[right];
} else if (seconds[left] > firsts[right]) {
seconds[idx] = seconds[left];
secondCount[idx] = secondCount[left];
} else {
seconds[idx] = firsts[right];
secondCount[idx] = firstCount[right];
}
} else {
firsts[idx] = firsts[right];
firstCount[idx] = firstCount[right];
if (firsts[left] == seconds[right]) {
seconds[idx] = firsts[left];
secondCount[idx] = firstCount[left] + secondCount[right];
} else if (firsts[left] > seconds[right]) {
seconds[idx] = firsts[left];
secondCount[idx] = firstCount[left];
} else {
seconds[idx] = seconds[right];
secondCount[idx] = secondCount[right];
}
}
if (idx > 0) {
calc((idx - 1) / 2);
}
}
public int getSecondCount(int left, int right) {
return getCount(getValue(0, 0, size, left, right)[1], 0, 0, size, left, right);
}
private int[] getValue(int idx, int min, int max, int left, int right) {
if (left <= min && max <= right) {
return new int[]{firsts[idx], seconds[idx]};
}
if (right <= min || max <= left) {
return new int[2];
}
int[] value1 = getValue(idx * 2 + 1, min, (min + max) / 2, left, right);
int[] value2 = getValue(idx * 2 + 2, (min + max) / 2, max, left, right);
int[] ans = new int[2];
if (value1[0] == value2[0]) {
ans[0] = value1[0];
if (value1[1] >= value2[1]) {
ans[1] = value1[1];
} else {
ans[1] = value2[1];
}
} else if (value1[0] > value2[0]) {
ans[0] = value1[0];
if (value1[1] >= value2[0]) {
ans[1] = value1[1];
} else {
ans[1] = value2[0];
}
} else {
ans[0] = value2[0];
if (value1[0] >= value2[1]) {
ans[1] = value1[0];
} else {
ans[1] = value2[1];
}
}
return ans;
}
private int getCount(int value, int idx, int min, int max, int left, int right) {
if (left <= min && max <= right) {
if (firsts[idx] == value) {
return firstCount[idx];
} else if (seconds[idx] == value) {
return secondCount[idx];
} else {
return 0;
}
}
if (right <= min || max <= left) {
return 0;
}
return getCount(value, idx * 2 + 1, min, (min + max) / 2, left, right) +
getCount(value, idx * 2 + 2, (min + max) / 2, max, left, right);
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(Arrays.toString(firsts)).append("\n")
.append(Arrays.toString(firstCount)).append("\n")
.append(Arrays.toString(seconds)).append("\n")
.append(Arrays.toString(secondCount)).append("\n");
return sb.toString();
}
}
}
class Scanner {
BufferedReader br;
StringTokenizer st = new StringTokenizer("");
StringBuilder sb = new StringBuilder();
public Scanner() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
} catch (Exception e) {
}
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String next() {
try {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
} catch (Exception e) {
e.printStackTrace();
} finally {
return st.nextToken();
}
}
}
|
ConDefects/ConDefects/Code/abc343_f/Java/50891572
|
condefects-java_data_839
|
import java.io.*;
import java.util.*;
import static java.lang.String.*;
public class Main {
static int mod = (int) 1e9 + 7;
static int INF = (int) 2e9;
static int base = 131;
public static void main(String[] args) throws IOException {
FastScanner f = new FastScanner();
PrintWriter w = new PrintWriter(System.out);
int n = f.nextInt();
int q = f.nextInt();
a = new int[n+1];
for (int i = 1; i <= n; i++) {
a[i] = f.nextInt();
}
segTree seg = new segTree();
seg.build(1, 1, n);
for (int i = 0; i < q; i++) {
int op = f.nextInt();
int l = f.nextInt();
int r = f.nextInt();
if (op == 1){
seg.change(1, l, r);
}else {
Node node = seg.sum(1, l, r);
w.println(node.secCnt);
}
}
w.flush();
w.close();
}
static int MAXN = 200005;
static int[] a;
public static class segTree {
Node[] t = new Node[4 * MAXN];
public segTree() {
for (int i = 0; i < 4 * MAXN; i++) {
t[i] = new Node();
}
}
public void build(int root, int l, int r){
t[root].l = l;
t[root].r = r;
// t[root].lazy[1] = 0; // 因为默认赋值为1， 这步初始化可以省略
if (l == r){
t[root].max = a[l];
t[root].maxCnt = 1;
t[root].sec = -1;
t[root].secCnt = 0;
}else {
int mid = (l + r) >> 1;
int ch = root << 1;
build(ch, l, mid);
build(ch+1, mid+1, r);
add(t[root], t[ch], t[ch+1]);
}
}
public void change(int root, int l, int val){
if (l == t[root].l && l == t[root].r){
t[root].max = val;
t[root].maxCnt = 1;
t[root].sec = -1;
t[root].secCnt = 0;
return;
}
int mid = (t[root].l + t[root].r) >> 1;
int ch = root << 1;
if (l <= mid) change(ch, l, val);
else change(ch + 1, l, val);
add(t[root], t[ch], t[ch+1]); // 儿子可能发生了修改，所以需要进行答案更新
}
public Node sum(int root, int l, int r){
if (l == t[root].l && r == t[root].r){
return t[root];
}
int mid = (t[root].l + t[root].r) >> 1;
int ch = root << 1;
long ans = 0;
if (r <= mid)return sum(ch, l, r);
else if (l > mid)return sum(ch + 1, l, r);
else {
Node n1 = sum(ch, l, mid);
Node n2 = sum(ch + 1, mid + 1, r);
Node node = new Node();
add(node, n1, n2);
return node;
}
}
}
public static void add(Node t, Node l, Node r){
t.maxCnt = 0;
t.secCnt = 0;
if (l.max == r.max){
t.max = l.max;
t.maxCnt = l.maxCnt + r.maxCnt;
t.sec = Math.max(l.sec, r.sec);
if (t.sec == l.sec) t.secCnt += l.secCnt;
if (t.sec == r.sec) t.secCnt += r.secCnt;
} else if (l.max > r.max) {
t.max = l.max;
t.maxCnt = l.maxCnt;
if (l.sec == r.max){
t.sec = l.sec;
t.secCnt = l.secCnt + r.maxCnt;
} else if (l.sec > r.max) {
t.sec = l.sec;
t.secCnt = l.secCnt;
}else {
t.sec = r.max;
t.secCnt = t.maxCnt;
}
}else {
t.max = r.max;
t.maxCnt = r.maxCnt;
if (l.max == r.sec){
t.sec = l.max;
t.secCnt = l.maxCnt + r.secCnt;
} else if (l.max > r.sec) {
t.sec = l.max;
t.secCnt = l.maxCnt;
}else {
t.sec = r.sec;
t.secCnt = r.secCnt;
}
}
}
public static class Node{
int l, r;
int max;
int maxCnt;
int sec;
int secCnt;
}
private static class FastScanner {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
private FastScanner() throws IOException {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
private short nextShort() throws IOException {
short ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do ret = (short) (ret * 10 + c - '0');
while ((c = read()) >= '0' && c <= '9');
if (neg) return (short) -ret;
return ret;
}
private int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
private char nextChar() throws IOException {
byte c = read();
while (c <= ' ') c = read();
return (char) c;
}
private String nextString() throws IOException {
StringBuilder ret = new StringBuilder();
byte c = read();
while (c <= ' ') c = read();
do {
ret.append((char) c);
} while ((c = read()) > ' ');
return ret.toString();
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
}
}
import java.io.*;
import java.util.*;
import static java.lang.String.*;
public class Main {
static int mod = (int) 1e9 + 7;
static int INF = (int) 2e9;
static int base = 131;
public static void main(String[] args) throws IOException {
FastScanner f = new FastScanner();
PrintWriter w = new PrintWriter(System.out);
int n = f.nextInt();
int q = f.nextInt();
a = new int[n+1];
for (int i = 1; i <= n; i++) {
a[i] = f.nextInt();
}
segTree seg = new segTree();
seg.build(1, 1, n);
for (int i = 0; i < q; i++) {
int op = f.nextInt();
int l = f.nextInt();
int r = f.nextInt();
if (op == 1){
seg.change(1, l, r);
}else {
Node node = seg.sum(1, l, r);
w.println(node.secCnt);
}
}
w.flush();
w.close();
}
static int MAXN = 200005;
static int[] a;
public static class segTree {
Node[] t = new Node[4 * MAXN];
public segTree() {
for (int i = 0; i < 4 * MAXN; i++) {
t[i] = new Node();
}
}
public void build(int root, int l, int r){
t[root].l = l;
t[root].r = r;
// t[root].lazy[1] = 0; // 因为默认赋值为1， 这步初始化可以省略
if (l == r){
t[root].max = a[l];
t[root].maxCnt = 1;
t[root].sec = -1;
t[root].secCnt = 0;
}else {
int mid = (l + r) >> 1;
int ch = root << 1;
build(ch, l, mid);
build(ch+1, mid+1, r);
add(t[root], t[ch], t[ch+1]);
}
}
public void change(int root, int l, int val){
if (l == t[root].l && l == t[root].r){
t[root].max = val;
t[root].maxCnt = 1;
t[root].sec = -1;
t[root].secCnt = 0;
return;
}
int mid = (t[root].l + t[root].r) >> 1;
int ch = root << 1;
if (l <= mid) change(ch, l, val);
else change(ch + 1, l, val);
add(t[root], t[ch], t[ch+1]); // 儿子可能发生了修改，所以需要进行答案更新
}
public Node sum(int root, int l, int r){
if (l == t[root].l && r == t[root].r){
return t[root];
}
int mid = (t[root].l + t[root].r) >> 1;
int ch = root << 1;
long ans = 0;
if (r <= mid)return sum(ch, l, r);
else if (l > mid)return sum(ch + 1, l, r);
else {
Node n1 = sum(ch, l, mid);
Node n2 = sum(ch + 1, mid + 1, r);
Node node = new Node();
add(node, n1, n2);
return node;
}
}
}
public static void add(Node t, Node l, Node r){
t.maxCnt = 0;
t.secCnt = 0;
if (l.max == r.max){
t.max = l.max;
t.maxCnt = l.maxCnt + r.maxCnt;
t.sec = Math.max(l.sec, r.sec);
if (t.sec == l.sec) t.secCnt += l.secCnt;
if (t.sec == r.sec) t.secCnt += r.secCnt;
} else if (l.max > r.max) {
t.max = l.max;
t.maxCnt = l.maxCnt;
if (l.sec == r.max){
t.sec = l.sec;
t.secCnt = l.secCnt + r.maxCnt;
} else if (l.sec > r.max) {
t.sec = l.sec;
t.secCnt = l.secCnt;
}else {
t.sec = r.max;
t.secCnt = r.maxCnt;
}
}else {
t.max = r.max;
t.maxCnt = r.maxCnt;
if (l.max == r.sec){
t.sec = l.max;
t.secCnt = l.maxCnt + r.secCnt;
} else if (l.max > r.sec) {
t.sec = l.max;
t.secCnt = l.maxCnt;
}else {
t.sec = r.sec;
t.secCnt = r.secCnt;
}
}
}
public static class Node{
int l, r;
int max;
int maxCnt;
int sec;
int secCnt;
}
private static class FastScanner {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
private FastScanner() throws IOException {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
private short nextShort() throws IOException {
short ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do ret = (short) (ret * 10 + c - '0');
while ((c = read()) >= '0' && c <= '9');
if (neg) return (short) -ret;
return ret;
}
private int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do ret = ret * 10 + c - '0';
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
private char nextChar() throws IOException {
byte c = read();
while (c <= ' ') c = read();
return (char) c;
}
private String nextString() throws IOException {
StringBuilder ret = new StringBuilder();
byte c = read();
while (c <= ' ') c = read();
do {
ret.append((char) c);
} while ((c = read()) > ' ');
return ret.toString();
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
}
}
|
ConDefects/ConDefects/Code/abc343_f/Java/50848101
|
condefects-java_data_840
|
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = Integer.parseInt(sc.next());
int b = Integer.parseInt(sc.next());
sc.close();
System.out.println((int) Math.pow(a, b) + Math.pow(b, a));
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = Integer.parseInt(sc.next());
int b = Integer.parseInt(sc.next());
sc.close();
System.out.println((int) Math.pow(a, b) + (int) Math.pow(b, a));
}
}
|
ConDefects/ConDefects/Code/abc320_a/Java/54516931
|
condefects-java_data_841
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
long A = sc.nextLong();
long B = sc.nextLong();
System.out.println((long)Math.pow(A, B)+Math.pow(B, A));
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
long A = sc.nextLong();
long B = sc.nextLong();
System.out.println((long)Math.pow(A, B)+(long)Math.pow(B, A));
}
}
|
ConDefects/ConDefects/Code/abc320_a/Java/50937825
|
condefects-java_data_842
|
import java.util.Date;
import java.util.Random;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Scanner;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int A = scanner.nextInt();
int B = scanner.nextInt();
double ans = 0;
ans += Math.pow(A, B);
ans += Math.pow(A, B);
System.out.println((int)ans);
}
}
import java.util.Date;
import java.util.Random;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Scanner;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int A = scanner.nextInt();
int B = scanner.nextInt();
double ans = 0;
ans += Math.pow(A, B);
ans += Math.pow(B, A);
System.out.println((int)ans);
}
}
|
ConDefects/ConDefects/Code/abc320_a/Java/52221323
|
condefects-java_data_843
|
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
if(a <= b && b <= c){
System.out.println("Yes");
} else {
System.out.println("No");
}
sc.close();
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
if((a <= b && b <= c) || (c <= b && b <= a)){
System.out.println("Yes");
} else {
System.out.println("No");
}
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc253_a/Java/39653253
|
condefects-java_data_844
|
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();
//a<b<cかc<b<aならyes
if ((a<b && b<c) || (c<b && b<a)) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
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();
//a<b<cかc<b<aならyes
if ((a<=b && b<=c) || (c<=b && b<=a)) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc253_a/Java/40806790
|
condefects-java_data_845
|
import java.util.*;
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();
if((a<=b && b<=c)&&(c<=b && b<=a)){
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 a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
if((a<=b && b<=c)||(c<=b && b<=a)){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc253_a/Java/36905866
|
condefects-java_data_846
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int a = s.nextInt();
int b = s.nextInt();
int c = s.nextInt();
System.out.println((a<=b &&b<=c )|| (a>=b && b>=c));
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int a = s.nextInt();
int b = s.nextInt();
int c = s.nextInt();
System.out.println((a<=b &&b<=c )|| (a>=b && b>=c)?"Yes" : "No");
}
}
|
ConDefects/ConDefects/Code/abc253_a/Java/40008972
|
condefects-java_data_847
|
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
class Main {
static void solve (Scanner in, PrintWriter out) {
int a = in.nextInt(), b = in.nextInt(), c = in.nextInt();
if (a <= b && b <= c) out.println("Yes");
else out.println("No");
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
solve(in, out);
in.close();
out.close();
}
}
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
class Main {
static void solve (Scanner in, PrintWriter out) {
int a = in.nextInt(), b = in.nextInt(), c = in.nextInt();
if ((a <= b && b <= c) || (a >= b && b >= c)) out.println("Yes");
else out.println("No");
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
solve(in, out);
in.close();
out.close();
}
}
|
ConDefects/ConDefects/Code/abc253_a/Java/37230711
|
condefects-java_data_848
|
import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
public static void solve(){
Scanner input=new Scanner(System.in);
int a=input.nextInt();
int b=input.nextInt();
int c=input.nextInt();
if(((a/2)+(c/2))==b){
System.out.println("Yes");
}
else{
System.out.println("No");
}
}
public static void input_output() {
try {
System.setIn(new FileInputStream("input.txt"));
System.setOut(new PrintStream("output.txt"));
} catch (Exception e) {
//System.out.println("Error");
}
}
public static void main(String[]args){
if (System.getProperty("ONLINE_JUDGE") == null) {
input_output();
solve();
}
else {
solve();
}
}
}
import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
public static void solve(){
Scanner input=new Scanner(System.in);
int a=input.nextInt();
int b=input.nextInt();
int c=input.nextInt();
if((a<=b&&b<=c)||(a>=b&&b>=c)){
System.out.println("Yes");
}
else{
System.out.println("No");
}
}
public static void input_output() {
try {
System.setIn(new FileInputStream("input.txt"));
System.setOut(new PrintStream("output.txt"));
} catch (Exception e) {
//System.out.println("Error");
}
}
public static void main(String[]args){
if (System.getProperty("ONLINE_JUDGE") == null) {
input_output();
solve();
}
else {
solve();
}
}
}
|
ConDefects/ConDefects/Code/abc253_a/Java/37387802
|
condefects-java_data_849
|
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
void solve(){
int a = scanner.nextInt(), b = scanner.nextInt(), c = scanner.nextInt();
out.println(b>=a&&b<=c?"Yes":"No");
}
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.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
void solve(){
int a = scanner.nextInt(), b = scanner.nextInt(), c = scanner.nextInt();
out.println((b>=a&&b<=c) || (b>=c&&b<=a)?"Yes":"No");
}
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/abc253_a/Java/40435967
|
condefects-java_data_850
|
import java.util.*;
public class Main {
static ArrayList<Cheese> list = new ArrayList<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), w = sc.nextInt();
for (int i = 0; i < n; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
list.add(new Cheese(a,b));
}
long count = 0;
Collections.sort(list, (c1,c2) -> (c2.a - c1.a));
for (Cheese c : list) {
int take = Math.min(w,c.b);
count += (long)take * c.a;
w-=c.b;
}
System.out.println(count);
}
}
class Cheese {
int a,b;
public Cheese(int a, int b) {
this.a = a;
this.b = b;
}
public String toString(){
return a + " " + b;
}
}
import java.util.*;
public class Main {
static ArrayList<Cheese> list = new ArrayList<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), w = sc.nextInt();
for (int i = 0; i < n; i++) {
int a = sc.nextInt();
int b = sc.nextInt();
list.add(new Cheese(a,b));
}
long count = 0;
Collections.sort(list, (c1,c2) -> (c2.a - c1.a));
for (Cheese c : list) {
int take = Math.min(w,c.b);
count += (long)take * c.a;
w-=take;
}
System.out.println(count);
}
}
class Cheese {
int a,b;
public Cheese(int a, int b) {
this.a = a;
this.b = b;
}
public String toString(){
return a + " " + b;
}
}
|
ConDefects/ConDefects/Code/abc229_c/Java/45894544
|
condefects-java_data_851
|
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt(), w = scan.nextInt();
int [] [] cheese = new int[n][2];
// long bc = 0,
long count = 0;
for (int i = 0; i < n; i++) {
cheese[i][0] = scan.nextInt();
cheese[i][1] = scan.nextInt();
}
Arrays.sort(cheese, (x,y) -> y[0] - x[0]);
for (int i = 0; i < n; i++) {
if(cheese[i][1]>=w){
count += (long)cheese[i][0] * w;
// w -= w;
} else if (w==0) {
break;
} else {
count += (long)cheese[i][0] * cheese[i][1];
w -= cheese[i][1];
}
}
System.out.println(count);
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt(), w = scan.nextInt();
int [] [] cheese = new int[n][2];
// long bc = 0,
long count = 0;
for (int i = 0; i < n; i++) {
cheese[i][0] = scan.nextInt();
cheese[i][1] = scan.nextInt();
}
Arrays.sort(cheese, (x,y) -> y[0] - x[0]);
for (int i = 0; i < n; i++) {
if(cheese[i][1]>=w){
count += (long)cheese[i][0] * w;
w -= w;
} else if (w==0) {
break;
} else {
count += (long)cheese[i][0] * cheese[i][1];
w -= cheese[i][1];
}
}
System.out.println(count);
}
}
|
ConDefects/ConDefects/Code/abc229_c/Java/45800810
|
condefects-java_data_852
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
class tts{
public int a;
public int b;
tts(int aa, int bb){
a=aa;
b=bb;
}
public String toString(){
return a+" "+b+" ";
}
}
public class Main {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
int a = sc.nextInt();
int m = sc.nextInt();
int v,b;
int r=0;
ArrayList<tts> list = new ArrayList<>();
for(int i =0;i<a;i++){
v=sc.nextInt();
b=sc.nextInt();
tts ass= new tts(v,b);
list.add(ass );
}
Collections.sort(list,(p1,p2)->p1.a-p2.a);
for (tts tts : list) {
// System.out.println(tts.toString());
}
for (int i = a-1; i >= 0; i--) {
// System.out.println(i);
// System.out.println(m);
if(m==0)break;
// System.out.println(r);
r+=((long)list.get(i).a)*(Math.min(list.get(i).b,m));
m-=Math.min(list.get(i).b,m);
}
System.out.println(r);}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
class tts{
public int a;
public int b;
tts(int aa, int bb){
a=aa;
b=bb;
}
public String toString(){
return a+" "+b+" ";
}
}
public class Main {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
int a = sc.nextInt();
int m = sc.nextInt();
int v,b;
long r=0;
ArrayList<tts> list = new ArrayList<>();
for(int i =0;i<a;i++){
v=sc.nextInt();
b=sc.nextInt();
tts ass= new tts(v,b);
list.add(ass );
}
Collections.sort(list,(p1,p2)->p1.a-p2.a);
for (tts tts : list) {
// System.out.println(tts.toString());
}
for (int i = a-1; i >= 0; i--) {
// System.out.println(i);
// System.out.println(m);
if(m==0)break;
// System.out.println(r);
r+=((long)list.get(i).a)*(Math.min(list.get(i).b,m));
m-=Math.min(list.get(i).b,m);
}
System.out.println(r);}
}
|
ConDefects/ConDefects/Code/abc229_c/Java/46037911
|
condefects-java_data_853
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
new Thread(new Task()).start();
}
static class Task implements Runnable {
public void run() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
InputReader in = new InputReader(inputStream);
// for(int i=4;i<=4;i++) {
// InputStream uinputStream = new FileInputStream("timeline.in");
// String f = i+".in";
// InputStream uinputStream = new FileInputStream(f);
// InputReader in = new InputReader(uinputStream);
// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("timeline.out")));
// }
// PrintWriter out = new PrintWriter(new BufferedWriter(new
// FileWriter("timeline.out")));
try {
solve(in, out);
} catch (IOException e) {
e.printStackTrace();
}
out.close();
}
public void solve1(InputReader in, PrintWriter out) throws IOException {
int n = in.nextInt();
int m = in.nextInt();
int arr[] = new int[n];
int brr[] = new int[n];
for(int i=0;i<n;i++) arr[i] = in.nextInt();
for(int i=0;i<n;i++) brr[i] = in.nextInt();
int crr[][] = new int[n][2];
for(int i=0;i<n;i++) {
crr[i][0] = Math.max(arr[i]-m, brr[i]-m);
crr[i][1] = Math.min(arr[i]+m, brr[i]+m);
}
ArrayList<pair>[] g = new ArrayList[n];
for(int i=0;i<n;i++) {
g[i] = new ArrayList<pair>();
for(int j=crr[i][0];j<=crr[i][1];j++) {
int d1 = Math.abs(j-arr[i]);
int d2 = Math.abs(j-brr[i]);
g[i].add(new pair(d1,d2));
}
}
int dp[][][] = new int[n+1][m+1][m+1];
int f = 998244353;
dp[0][0][0] = 1;
for(int i=1;i<=n;i++) {
for(pair t:g[i-1]) {
for(int j=t.a;j<=m;j++) {
for(int k=t.b;k<=m;k++) {
dp[i][j][k] += dp[i-1][j-t.a][k-t.b];
dp[i][j][k]%=f;
}
}
}
}
int s = 0;
for(int i=0;i<=m;i++) {
for(int j=0;j<=m;j++) {
s+=dp[n][i][j];
s%=f;
}
}
out.println(s);
}
class pair {
int a; int b;
public pair(int x,int y) {
a=x;b=y;
}
}
class edge1 implements Comparable<edge1>{
int f,t,len;
public edge1(int a, int b, int c) {
f=a;t=b;len=c;
}
@Override
public int compareTo(edge1 o) {
// TODO Auto-generated method stub
return 0;
}
}
public void solve(InputReader in, PrintWriter out) throws IOException {
int n = in.nextInt();
int m = in.nextInt();
int e = in.nextInt();
n+=m;
DSU dsu = new DSU(n+10);
edge arr[] = new edge[e+1];
for(int i=1;i<=e;i++) {
int f = in.nextInt();
int t = in.nextInt();
edge a = new edge(f,t,1,i);
arr[i] = a;
}
int plant[] = new int[n+10];
for(int i=1;i<=n-m;i++) plant[i] = 1;
int q = in.nextInt();
int ret[] = new int[q];
int l[] = in.readIntArray(q);
Set<Integer> xx = new HashSet<Integer>();
for(int i:l) xx.add(i);
for(int i=1;i<=e;i++) {
int x = dsu.find(arr[i].f);
int y = dsu.find(arr[i].t);
if(!xx.contains(i)&&x!=y) {
if(y>n-m) {
dsu.union(x, y);
plant[y] += plant[x];
}
else {
dsu.union(x, y);
plant[x] += plant[y];
}
}
}
int v = 0;
for(int i=n-m+1;i<=n;i++) {
if(dsu.find(i)==i)
v+=plant[i];
}
ret[q-1] = v;
for(int i=q-1;i>0;i--) {
int x = dsu.find(arr[l[i]].f);
int y = dsu.find(arr[l[i]].t);
if(x!=y) {
if(x>n-m) {
if(y<=n-m) {
v+=plant[y];
}
dsu.union(x, y);
plant[x]+=plant[y];
}else {
if(y>n-m) {
v+=plant[x];
}
dsu.union(y, x);
plant[y]+=plant[x];
}
}
ret[i-1] = v;
}
for(int i:ret) out.println(i);
}
public class edge implements Comparable<edge> {
int f, t;
long len;
int id;
public edge(int a, int b, long c, int d) {
f = a;
t = b;
len = c;
id = d;
}
@Override
public int compareTo(Main.Task.edge o) {
if (this.len - o.len < 0)
return -1;
else if (this.len == o.len)
return 0;
else
return 1;
}
}
public Set<Integer> get_factor(int number) {
int n = number;
Set<Integer> primeFactors = new HashSet<Integer>();
for (int i = 2; i <= n / i; i++) {
while (n % i == 0) {
primeFactors.add(i);
n /= i;
}
}
if (n > 1)
primeFactors.add(n);
return primeFactors;
}
private static long cnr(int n, int m, long mod, long fac[], long inv[]) {
if (n < m)
return 0;
return fac[n] * inv[n - m] % mod * inv[m] % mod;
}
private static int combx(int n, int k, int mod) {
if (n < k)
return 0;
int comb[][] = new int[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
comb[i][j] %= mod;
}
}
return comb[n][k];
}
private static long qpow(long a, long p, long MOD) {
long m = Long.highestOneBit(p);
long ans = 1;
for (; m > 0; m >>>= 1) {
ans = ans * ans % MOD;
if ((p & m) > 0)
ans = ans * a % MOD;
}
return (int) ans;
}
long[] get_diameter(ArrayList<edge>[] g) {
int n = g.length;
int f0 = -1, f1 = -1; long d = -1;
{
int[] q = new int[n];
boolean[] vis = new boolean[n];
long dist[] = new long[n];
int qp = 0;
q[qp++] = 0; vis[0] = true;
for(int i=0;i<qp;i++) {
int cur = q[i];
for(edge nxt:g[cur]) {
if(!vis[nxt.t]) {
vis[nxt.t] = true;
q[qp++] = nxt.t;
dist[nxt.t]= dist[cur]+nxt.len;
}
}
}
long max = 0;
for(int i=0;i<n;i++) {
if(dist[i]>max) {
max = dist[i];
f0 = i;
}
}
}
{
int[] q = new int[n];
boolean[] vis = new boolean[n];
long dist[] = new long[n];
int qp = 0;
q[qp++] = f0;
vis[f0] = true;
for(int i=0;i<qp;i++) {
int cur = q[i];
for(edge nxt:g[cur]) {
if(!vis[nxt.t]) {
vis[nxt.t] = true;
q[qp++] = nxt.t;
dist[nxt.t]= dist[cur]+nxt.len;
}
}
}
long max = 0;
for(int i=0;i<n;i++) {
if(dist[i]>max) {
max = dist[i];
f1 = i;
}
}
d = dist[f1];
}
return new long[] {d,f0,f1};
}
static class lca_naive {
int n;
ArrayList<edge>[] g;
int lvl[];
int pare[];
int dist[];
public lca_naive(int t, ArrayList<edge>[] x) {
n = t;
g = x;
lvl = new int[n];
pare = new int[n];
dist = new int[n];
}
void pre_process() {
dfs(0, -1, g, lvl, pare, dist);
}
void dfs(int cur, int pre, ArrayList<edge>[] g, int lvl[], int pare[], int dist[]) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
pare[nxt_edge.t] = cur;
dfs(nxt_edge.t, cur, g, lvl, pare, dist);
}
}
}
public int work(int p, int q) {
int a = p;
int b = q;
while (lvl[p] < lvl[q])
q = pare[q];
while (lvl[p] > lvl[q])
p = pare[p];
while (p != q) {
p = pare[p];
q = pare[q];
}
int c = p;
return dist[a] + dist[b] - dist[c] * 2;
}
}
static class lca_binary_lifting {
int n;
ArrayList<edge>[] g;
int lvl[];
int pare[];
int dist[];
int table[][];
public lca_binary_lifting(int a, ArrayList<edge>[] t) {
n = a;
g = t;
lvl = new int[n];
pare = new int[n];
dist = new int[n];
table = new int[20][n];
}
void pre_process() {
dfs(0, -1, g, lvl, pare, dist);
for (int i = 0; i < 20; i++) {
for (int j = 0; j < n; j++) {
if (i == 0)
table[0][j] = pare[j];
else
table[i][j] = table[i - 1][table[i - 1][j]];
}
}
}
void dfs(int cur, int pre, ArrayList<edge>[] g, int lvl[], int pare[], int dist[]) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
pare[nxt_edge.t] = cur;
dfs(nxt_edge.t, cur, g, lvl, pare, dist);
}
}
}
public int work(int p, int q) {
int a = p;
int b = q;
if (lvl[p] > lvl[q]) {
int tmp = p;
p = q;
q = tmp;
}
for (int i = 19; i >= 0; i--) {
if (lvl[table[i][q]] >= lvl[p])
q = table[i][q];
}
if (p == q)
return p;// return dist[a]+dist[b]-dist[p]*2;
for (int i = 19; i >= 0; i--) {
if (table[i][p] != table[i][q]) {
p = table[i][p];
q = table[i][q];
}
}
return table[0][p];
// return dist[a]+dist[b]-dist[table[0][p]]*2;
}
}
static class lca_sqrt_root {
int n;
ArrayList<edge>[] g;
int lvl[];
int pare[];
int dist[];
int jump[];
int sz;
public lca_sqrt_root(int a, ArrayList<edge>[] b) {
n = a;
g = b;
lvl = new int[n];
pare = new int[n];
dist = new int[n];
jump = new int[n];
sz = (int) Math.sqrt(n);
}
void pre_process() {
dfs(0, -1, g, lvl, pare, dist, jump);
}
void dfs(int cur, int pre, ArrayList<edge>[] g, int lvl[], int pare[], int dist[], int[] jump) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
pare[nxt_edge.t] = cur;
if (lvl[nxt_edge.t] % sz == 0) {
jump[nxt_edge.t] = cur;
} else {
jump[nxt_edge.t] = jump[cur];
}
dfs(nxt_edge.t, cur, g, lvl, pare, dist, jump);
}
}
}
int work(int p, int q) {
int a = p;
int b = q;
if (lvl[p] > lvl[q]) {
int tmp = p;
p = q;
q = tmp;
}
while (jump[p] != jump[q]) {
if (lvl[p] > lvl[q])
p = jump[p];
else
q = jump[q];
}
while (p != q) {
if (lvl[p] > lvl[q])
p = pare[p];
else
q = pare[q];
}
return dist[a] + dist[b] - dist[p] * 2;
}
}
// class edge implements Comparable<edge>{
// int f,t,len;
// public edge(int a, int b, int c) {
// f=a;t=b;len=c;
// }
// @Override
// public int compareTo(edge t) {
// return t.len-this.len;
// }
// }
static class lca_RMQ {
int n;
ArrayList<edge>[] g;
int lvl[];
int dist[];
int tour[];
int tour_rank[];
int first_occ[];
int c;
sgt s;
public lca_RMQ(int a, ArrayList<edge>[] b) {
n = a;
g = b;
c = 0;
lvl = new int[n];
dist = new int[n];
tour = new int[2 * n];
tour_rank = new int[2 * n];
first_occ = new int[n];
Arrays.fill(first_occ, -1);
}
void pre_process() {
tour[c++] = 0;
dfs(0, -1);
for (int i = 0; i < 2 * n; i++) {
tour_rank[i] = lvl[tour[i]];
if (first_occ[tour[i]] == -1)
first_occ[tour[i]] = i;
}
s = new sgt(0, 2 * n, tour_rank);
}
void dfs(int cur, int pre) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
tour[c++] = nxt_edge.t;
dfs(nxt_edge.t, cur);
tour[c++] = cur;
}
}
}
int work(int p, int q) {
int a = Math.max(first_occ[p], first_occ[q]);
int b = Math.min(first_occ[p], first_occ[q]);
int idx = s.query_min_idx(b, a + 1);
// Dumper.print(a+" "+b+" "+idx);
int c = tour[idx];
return dist[p] + dist[q] - dist[c] * 2;
}
}
static class sgt {
sgt lt;
sgt rt;
int l, r;
int sum, max, min, lazy;
int min_idx;
public sgt(int L, int R, int arr[]) {
l = L;
r = R;
if (l == r - 1) {
sum = max = min = arr[l];
lazy = 0;
min_idx = l;
return;
}
lt = new sgt(l, l + r >> 1, arr);
rt = new sgt(l + r >> 1, r, arr);
pop_up();
}
void pop_up() {
this.sum = lt.sum + rt.sum;
this.max = Math.max(lt.max, rt.max);
this.min = Math.min(lt.min, rt.min);
if (lt.min < rt.min)
this.min_idx = lt.min_idx;
else if (lt.min > rt.min)
this.min_idx = rt.min_idx;
else
this.min = Math.min(lt.min_idx, rt.min_idx);
}
void push_down() {
if (this.lazy != 0) {
lt.sum += lazy;
rt.sum += lazy;
lt.max += lazy;
lt.min += lazy;
rt.max += lazy;
rt.min += lazy;
lt.lazy += this.lazy;
rt.lazy += this.lazy;
this.lazy = 0;
}
}
void change(int L, int R, int v) {
if (R <= l || r <= L)
return;
if (L <= l && r <= R) {
this.max += v;
this.min += v;
this.sum += v * (r - l);
this.lazy += v;
return;
}
push_down();
lt.change(L, R, v);
rt.change(L, R, v);
pop_up();
}
int query_max(int L, int R) {
if (L <= l && r <= R)
return this.max;
if (r <= L || R <= l)
return Integer.MIN_VALUE;
push_down();
return Math.max(lt.query_max(L, R), rt.query_max(L, R));
}
int query_min(int L, int R) {
if (L <= l && r <= R)
return this.min;
if (r <= L || R <= l)
return Integer.MAX_VALUE;
push_down();
return Math.min(lt.query_min(L, R), rt.query_min(L, R));
}
int query_sum(int L, int R) {
if (L <= l && r <= R)
return this.sum;
if (r <= L || R <= l)
return 0;
push_down();
return lt.query_sum(L, R) + rt.query_sum(L, R);
}
int query_min_idx(int L, int R) {
if (L <= l && r <= R)
return this.min_idx;
if (r <= L || R <= l)
return Integer.MAX_VALUE;
int a = lt.query_min_idx(L, R);
int b = rt.query_min_idx(L, R);
int aa = lt.query_min(L, R);
int bb = rt.query_min(L, R);
if (aa < bb)
return a;
else if (aa > bb)
return b;
return Math.min(a, b);
}
}
List<List<Integer>> convert(int arr[][]) {
int n = arr.length;
List<List<Integer>> ret = new ArrayList<>();
for (int i = 0; i < n; i++) {
ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int j = 0; j < arr[i].length; j++)
tmp.add(arr[i][j]);
ret.add(tmp);
}
return ret;
}
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
public int GCD(int a, int b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
public long GCD(long a, long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
}
static class ArrayUtils {
static final long seed = System.nanoTime();
static final Random rand = new Random(seed);
public static void sort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(int[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
public static void sort(long[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(long[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
long t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
static class BIT {
long arr[];
int n;
public BIT(int a) {
n = a;
arr = new long[n];
}
long sum(int p) {
long s = 0;
while (p > 0) {
s += arr[p];
p -= p & (-p);
}
return s;
}
void add(int p, long v) {
while (p < n) {
arr[p] += v;
p += p & (-p);
}
}
}
static class DSU {
int[] arr;
int[] sz;
public DSU(int n) {
arr = new int[n];
sz = new int[n];
for (int i = 0; i < n; i++)
arr[i] = i;
Arrays.fill(sz, 1);
}
public int find(int a) {
if (arr[a] != a)
arr[a] = find(arr[a]);
return arr[a];
}
public void union(int a, int b) {
int x = find(a);
int y = find(b);
if (x == y)
return;
arr[y] = x;
sz[x] += sz[y];
}
public int size(int x) {
return sz[find(x)];
}
}
static class MinHeap<Key> implements Iterable<Key> {
private int maxN;
private int n;
private int[] pq;
private int[] qp;
private Key[] keys;
private Comparator<Key> comparator;
public MinHeap(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
this.maxN = capacity;
n = 0;
pq = new int[maxN + 1];
qp = new int[maxN + 1];
keys = (Key[]) new Object[capacity + 1];
Arrays.fill(qp, -1);
}
public MinHeap(int capacity, Comparator<Key> c) {
if (capacity < 0)
throw new IllegalArgumentException();
this.maxN = capacity;
n = 0;
pq = new int[maxN + 1];
qp = new int[maxN + 1];
keys = (Key[]) new Object[capacity + 1];
Arrays.fill(qp, -1);
comparator = c;
}
public boolean isEmpty() {
return n == 0;
}
public int size() {
return n;
}
public boolean contains(int i) {
if (i < 0 || i >= maxN)
throw new IllegalArgumentException();
return qp[i] != -1;
}
public int peekIdx() {
if (n == 0)
throw new NoSuchElementException("Priority queue underflow");
return pq[1];
}
public Key peek() {
if (isEmpty())
throw new NoSuchElementException("Priority queue underflow");
return keys[pq[1]];
}
public int poll() {
if (isEmpty())
throw new NoSuchElementException("Priority queue underflow");
int min = pq[1];
exch(1, n--);
down(1);
assert min == pq[n + 1];
qp[min] = -1;
keys[min] = null;
pq[n + 1] = -1;
return min;
}
public void update(int i, Key key) {
if (i < 0 || i >= maxN)
throw new IllegalArgumentException();
if (!contains(i)) {
this.add(i, key);
} else {
keys[i] = key;
up(qp[i]);
down(qp[i]);
}
}
private void add(int i, Key x) {
if (i < 0 || i >= maxN)
throw new IllegalArgumentException();
if (contains(i))
throw new IllegalArgumentException("index is already in the priority queue");
n++;
qp[i] = n;
pq[n] = i;
keys[i] = x;
up(n);
}
private void up(int k) {
while (k > 1 && less(k, k / 2)) {
exch(k, k / 2);
k /= 2;
}
}
private void down(int k) {
while (2 * k <= n) {
int j = 2 * k;
if (j < n && less(j + 1, j))
j++;
if (less(k, j))
break;
exch(k, j);
k = j;
}
}
public boolean less(int i, int j) {
if (comparator == null) {
return ((Comparable<Key>) keys[pq[i]]).compareTo(keys[pq[j]]) < 0;
} else {
return comparator.compare(keys[pq[i]], keys[pq[j]]) < 0;
}
}
public void exch(int i, int j) {
int swap = pq[i];
pq[i] = pq[j];
pq[j] = swap;
qp[pq[i]] = i;
qp[pq[j]] = j;
}
@Override
public Iterator<Key> iterator() {
// TODO Auto-generated method stub
return null;
}
}
private static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int zcurChar;
private int znumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (znumChars == -1)
throw new InputMismatchException();
if (zcurChar >= znumChars) {
zcurChar = 0;
try {
znumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (znumChars <= 0)
return -1;
}
return buf[zcurChar++];
}
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;
}
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 double nextDouble() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
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 boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return nextString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] readIntArray(int n) {
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
ret[i] = nextInt();
}
return ret;
}
}
static class Dumper {
static void print_int_arr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_char_arr(char[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_double_arr(double[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(int[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(boolean[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print(Object o) {
System.out.println(o.toString());
}
static void getc() {
System.out.println("here");
}
}
}
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
new Thread(new Task()).start();
}
static class Task implements Runnable {
public void run() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
PrintWriter out = new PrintWriter(outputStream);
InputReader in = new InputReader(inputStream);
// for(int i=4;i<=4;i++) {
// InputStream uinputStream = new FileInputStream("timeline.in");
// String f = i+".in";
// InputStream uinputStream = new FileInputStream(f);
// InputReader in = new InputReader(uinputStream);
// PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("timeline.out")));
// }
// PrintWriter out = new PrintWriter(new BufferedWriter(new
// FileWriter("timeline.out")));
try {
solve(in, out);
} catch (IOException e) {
e.printStackTrace();
}
out.close();
}
public void solve1(InputReader in, PrintWriter out) throws IOException {
int n = in.nextInt();
int m = in.nextInt();
int arr[] = new int[n];
int brr[] = new int[n];
for(int i=0;i<n;i++) arr[i] = in.nextInt();
for(int i=0;i<n;i++) brr[i] = in.nextInt();
int crr[][] = new int[n][2];
for(int i=0;i<n;i++) {
crr[i][0] = Math.max(arr[i]-m, brr[i]-m);
crr[i][1] = Math.min(arr[i]+m, brr[i]+m);
}
ArrayList<pair>[] g = new ArrayList[n];
for(int i=0;i<n;i++) {
g[i] = new ArrayList<pair>();
for(int j=crr[i][0];j<=crr[i][1];j++) {
int d1 = Math.abs(j-arr[i]);
int d2 = Math.abs(j-brr[i]);
g[i].add(new pair(d1,d2));
}
}
int dp[][][] = new int[n+1][m+1][m+1];
int f = 998244353;
dp[0][0][0] = 1;
for(int i=1;i<=n;i++) {
for(pair t:g[i-1]) {
for(int j=t.a;j<=m;j++) {
for(int k=t.b;k<=m;k++) {
dp[i][j][k] += dp[i-1][j-t.a][k-t.b];
dp[i][j][k]%=f;
}
}
}
}
int s = 0;
for(int i=0;i<=m;i++) {
for(int j=0;j<=m;j++) {
s+=dp[n][i][j];
s%=f;
}
}
out.println(s);
}
class pair {
int a; int b;
public pair(int x,int y) {
a=x;b=y;
}
}
class edge1 implements Comparable<edge1>{
int f,t,len;
public edge1(int a, int b, int c) {
f=a;t=b;len=c;
}
@Override
public int compareTo(edge1 o) {
// TODO Auto-generated method stub
return 0;
}
}
public void solve(InputReader in, PrintWriter out) throws IOException {
int n = in.nextInt();
int m = in.nextInt();
int e = in.nextInt();
n+=m;
DSU dsu = new DSU(n+10);
edge arr[] = new edge[e+1];
for(int i=1;i<=e;i++) {
int f = in.nextInt();
int t = in.nextInt();
edge a = new edge(f,t,1,i);
arr[i] = a;
}
int plant[] = new int[n+10];
for(int i=1;i<=n-m;i++) plant[i] = 1;
int q = in.nextInt();
int ret[] = new int[q];
int l[] = in.readIntArray(q);
Set<Integer> xx = new HashSet<Integer>();
for(int i:l) xx.add(i);
for(int i=1;i<=e;i++) {
int x = dsu.find(arr[i].f);
int y = dsu.find(arr[i].t);
if(!xx.contains(i)&&x!=y) {
if(y>n-m) {
dsu.union(y, x);
plant[y] += plant[x];
}
else {
dsu.union(x, y);
plant[x] += plant[y];
}
}
}
int v = 0;
for(int i=n-m+1;i<=n;i++) {
if(dsu.find(i)==i)
v+=plant[i];
}
ret[q-1] = v;
for(int i=q-1;i>0;i--) {
int x = dsu.find(arr[l[i]].f);
int y = dsu.find(arr[l[i]].t);
if(x!=y) {
if(x>n-m) {
if(y<=n-m) {
v+=plant[y];
}
dsu.union(x, y);
plant[x]+=plant[y];
}else {
if(y>n-m) {
v+=plant[x];
}
dsu.union(y, x);
plant[y]+=plant[x];
}
}
ret[i-1] = v;
}
for(int i:ret) out.println(i);
}
public class edge implements Comparable<edge> {
int f, t;
long len;
int id;
public edge(int a, int b, long c, int d) {
f = a;
t = b;
len = c;
id = d;
}
@Override
public int compareTo(Main.Task.edge o) {
if (this.len - o.len < 0)
return -1;
else if (this.len == o.len)
return 0;
else
return 1;
}
}
public Set<Integer> get_factor(int number) {
int n = number;
Set<Integer> primeFactors = new HashSet<Integer>();
for (int i = 2; i <= n / i; i++) {
while (n % i == 0) {
primeFactors.add(i);
n /= i;
}
}
if (n > 1)
primeFactors.add(n);
return primeFactors;
}
private static long cnr(int n, int m, long mod, long fac[], long inv[]) {
if (n < m)
return 0;
return fac[n] * inv[n - m] % mod * inv[m] % mod;
}
private static int combx(int n, int k, int mod) {
if (n < k)
return 0;
int comb[][] = new int[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
comb[i][j] %= mod;
}
}
return comb[n][k];
}
private static long qpow(long a, long p, long MOD) {
long m = Long.highestOneBit(p);
long ans = 1;
for (; m > 0; m >>>= 1) {
ans = ans * ans % MOD;
if ((p & m) > 0)
ans = ans * a % MOD;
}
return (int) ans;
}
long[] get_diameter(ArrayList<edge>[] g) {
int n = g.length;
int f0 = -1, f1 = -1; long d = -1;
{
int[] q = new int[n];
boolean[] vis = new boolean[n];
long dist[] = new long[n];
int qp = 0;
q[qp++] = 0; vis[0] = true;
for(int i=0;i<qp;i++) {
int cur = q[i];
for(edge nxt:g[cur]) {
if(!vis[nxt.t]) {
vis[nxt.t] = true;
q[qp++] = nxt.t;
dist[nxt.t]= dist[cur]+nxt.len;
}
}
}
long max = 0;
for(int i=0;i<n;i++) {
if(dist[i]>max) {
max = dist[i];
f0 = i;
}
}
}
{
int[] q = new int[n];
boolean[] vis = new boolean[n];
long dist[] = new long[n];
int qp = 0;
q[qp++] = f0;
vis[f0] = true;
for(int i=0;i<qp;i++) {
int cur = q[i];
for(edge nxt:g[cur]) {
if(!vis[nxt.t]) {
vis[nxt.t] = true;
q[qp++] = nxt.t;
dist[nxt.t]= dist[cur]+nxt.len;
}
}
}
long max = 0;
for(int i=0;i<n;i++) {
if(dist[i]>max) {
max = dist[i];
f1 = i;
}
}
d = dist[f1];
}
return new long[] {d,f0,f1};
}
static class lca_naive {
int n;
ArrayList<edge>[] g;
int lvl[];
int pare[];
int dist[];
public lca_naive(int t, ArrayList<edge>[] x) {
n = t;
g = x;
lvl = new int[n];
pare = new int[n];
dist = new int[n];
}
void pre_process() {
dfs(0, -1, g, lvl, pare, dist);
}
void dfs(int cur, int pre, ArrayList<edge>[] g, int lvl[], int pare[], int dist[]) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
pare[nxt_edge.t] = cur;
dfs(nxt_edge.t, cur, g, lvl, pare, dist);
}
}
}
public int work(int p, int q) {
int a = p;
int b = q;
while (lvl[p] < lvl[q])
q = pare[q];
while (lvl[p] > lvl[q])
p = pare[p];
while (p != q) {
p = pare[p];
q = pare[q];
}
int c = p;
return dist[a] + dist[b] - dist[c] * 2;
}
}
static class lca_binary_lifting {
int n;
ArrayList<edge>[] g;
int lvl[];
int pare[];
int dist[];
int table[][];
public lca_binary_lifting(int a, ArrayList<edge>[] t) {
n = a;
g = t;
lvl = new int[n];
pare = new int[n];
dist = new int[n];
table = new int[20][n];
}
void pre_process() {
dfs(0, -1, g, lvl, pare, dist);
for (int i = 0; i < 20; i++) {
for (int j = 0; j < n; j++) {
if (i == 0)
table[0][j] = pare[j];
else
table[i][j] = table[i - 1][table[i - 1][j]];
}
}
}
void dfs(int cur, int pre, ArrayList<edge>[] g, int lvl[], int pare[], int dist[]) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
pare[nxt_edge.t] = cur;
dfs(nxt_edge.t, cur, g, lvl, pare, dist);
}
}
}
public int work(int p, int q) {
int a = p;
int b = q;
if (lvl[p] > lvl[q]) {
int tmp = p;
p = q;
q = tmp;
}
for (int i = 19; i >= 0; i--) {
if (lvl[table[i][q]] >= lvl[p])
q = table[i][q];
}
if (p == q)
return p;// return dist[a]+dist[b]-dist[p]*2;
for (int i = 19; i >= 0; i--) {
if (table[i][p] != table[i][q]) {
p = table[i][p];
q = table[i][q];
}
}
return table[0][p];
// return dist[a]+dist[b]-dist[table[0][p]]*2;
}
}
static class lca_sqrt_root {
int n;
ArrayList<edge>[] g;
int lvl[];
int pare[];
int dist[];
int jump[];
int sz;
public lca_sqrt_root(int a, ArrayList<edge>[] b) {
n = a;
g = b;
lvl = new int[n];
pare = new int[n];
dist = new int[n];
jump = new int[n];
sz = (int) Math.sqrt(n);
}
void pre_process() {
dfs(0, -1, g, lvl, pare, dist, jump);
}
void dfs(int cur, int pre, ArrayList<edge>[] g, int lvl[], int pare[], int dist[], int[] jump) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
pare[nxt_edge.t] = cur;
if (lvl[nxt_edge.t] % sz == 0) {
jump[nxt_edge.t] = cur;
} else {
jump[nxt_edge.t] = jump[cur];
}
dfs(nxt_edge.t, cur, g, lvl, pare, dist, jump);
}
}
}
int work(int p, int q) {
int a = p;
int b = q;
if (lvl[p] > lvl[q]) {
int tmp = p;
p = q;
q = tmp;
}
while (jump[p] != jump[q]) {
if (lvl[p] > lvl[q])
p = jump[p];
else
q = jump[q];
}
while (p != q) {
if (lvl[p] > lvl[q])
p = pare[p];
else
q = pare[q];
}
return dist[a] + dist[b] - dist[p] * 2;
}
}
// class edge implements Comparable<edge>{
// int f,t,len;
// public edge(int a, int b, int c) {
// f=a;t=b;len=c;
// }
// @Override
// public int compareTo(edge t) {
// return t.len-this.len;
// }
// }
static class lca_RMQ {
int n;
ArrayList<edge>[] g;
int lvl[];
int dist[];
int tour[];
int tour_rank[];
int first_occ[];
int c;
sgt s;
public lca_RMQ(int a, ArrayList<edge>[] b) {
n = a;
g = b;
c = 0;
lvl = new int[n];
dist = new int[n];
tour = new int[2 * n];
tour_rank = new int[2 * n];
first_occ = new int[n];
Arrays.fill(first_occ, -1);
}
void pre_process() {
tour[c++] = 0;
dfs(0, -1);
for (int i = 0; i < 2 * n; i++) {
tour_rank[i] = lvl[tour[i]];
if (first_occ[tour[i]] == -1)
first_occ[tour[i]] = i;
}
s = new sgt(0, 2 * n, tour_rank);
}
void dfs(int cur, int pre) {
for (edge nxt_edge : g[cur]) {
if (nxt_edge.t != pre) {
lvl[nxt_edge.t] = lvl[cur] + 1;
dist[nxt_edge.t] = (int) (dist[cur] + nxt_edge.len);
tour[c++] = nxt_edge.t;
dfs(nxt_edge.t, cur);
tour[c++] = cur;
}
}
}
int work(int p, int q) {
int a = Math.max(first_occ[p], first_occ[q]);
int b = Math.min(first_occ[p], first_occ[q]);
int idx = s.query_min_idx(b, a + 1);
// Dumper.print(a+" "+b+" "+idx);
int c = tour[idx];
return dist[p] + dist[q] - dist[c] * 2;
}
}
static class sgt {
sgt lt;
sgt rt;
int l, r;
int sum, max, min, lazy;
int min_idx;
public sgt(int L, int R, int arr[]) {
l = L;
r = R;
if (l == r - 1) {
sum = max = min = arr[l];
lazy = 0;
min_idx = l;
return;
}
lt = new sgt(l, l + r >> 1, arr);
rt = new sgt(l + r >> 1, r, arr);
pop_up();
}
void pop_up() {
this.sum = lt.sum + rt.sum;
this.max = Math.max(lt.max, rt.max);
this.min = Math.min(lt.min, rt.min);
if (lt.min < rt.min)
this.min_idx = lt.min_idx;
else if (lt.min > rt.min)
this.min_idx = rt.min_idx;
else
this.min = Math.min(lt.min_idx, rt.min_idx);
}
void push_down() {
if (this.lazy != 0) {
lt.sum += lazy;
rt.sum += lazy;
lt.max += lazy;
lt.min += lazy;
rt.max += lazy;
rt.min += lazy;
lt.lazy += this.lazy;
rt.lazy += this.lazy;
this.lazy = 0;
}
}
void change(int L, int R, int v) {
if (R <= l || r <= L)
return;
if (L <= l && r <= R) {
this.max += v;
this.min += v;
this.sum += v * (r - l);
this.lazy += v;
return;
}
push_down();
lt.change(L, R, v);
rt.change(L, R, v);
pop_up();
}
int query_max(int L, int R) {
if (L <= l && r <= R)
return this.max;
if (r <= L || R <= l)
return Integer.MIN_VALUE;
push_down();
return Math.max(lt.query_max(L, R), rt.query_max(L, R));
}
int query_min(int L, int R) {
if (L <= l && r <= R)
return this.min;
if (r <= L || R <= l)
return Integer.MAX_VALUE;
push_down();
return Math.min(lt.query_min(L, R), rt.query_min(L, R));
}
int query_sum(int L, int R) {
if (L <= l && r <= R)
return this.sum;
if (r <= L || R <= l)
return 0;
push_down();
return lt.query_sum(L, R) + rt.query_sum(L, R);
}
int query_min_idx(int L, int R) {
if (L <= l && r <= R)
return this.min_idx;
if (r <= L || R <= l)
return Integer.MAX_VALUE;
int a = lt.query_min_idx(L, R);
int b = rt.query_min_idx(L, R);
int aa = lt.query_min(L, R);
int bb = rt.query_min(L, R);
if (aa < bb)
return a;
else if (aa > bb)
return b;
return Math.min(a, b);
}
}
List<List<Integer>> convert(int arr[][]) {
int n = arr.length;
List<List<Integer>> ret = new ArrayList<>();
for (int i = 0; i < n; i++) {
ArrayList<Integer> tmp = new ArrayList<Integer>();
for (int j = 0; j < arr[i].length; j++)
tmp.add(arr[i][j]);
ret.add(tmp);
}
return ret;
}
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
public int GCD(int a, int b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
public long GCD(long a, long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
}
static class ArrayUtils {
static final long seed = System.nanoTime();
static final Random rand = new Random(seed);
public static void sort(int[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(int[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
public static void sort(long[] a) {
shuffle(a);
Arrays.sort(a);
}
public static void shuffle(long[] a) {
for (int i = 0; i < a.length; i++) {
int j = rand.nextInt(i + 1);
long t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
static class BIT {
long arr[];
int n;
public BIT(int a) {
n = a;
arr = new long[n];
}
long sum(int p) {
long s = 0;
while (p > 0) {
s += arr[p];
p -= p & (-p);
}
return s;
}
void add(int p, long v) {
while (p < n) {
arr[p] += v;
p += p & (-p);
}
}
}
static class DSU {
int[] arr;
int[] sz;
public DSU(int n) {
arr = new int[n];
sz = new int[n];
for (int i = 0; i < n; i++)
arr[i] = i;
Arrays.fill(sz, 1);
}
public int find(int a) {
if (arr[a] != a)
arr[a] = find(arr[a]);
return arr[a];
}
public void union(int a, int b) {
int x = find(a);
int y = find(b);
if (x == y)
return;
arr[y] = x;
sz[x] += sz[y];
}
public int size(int x) {
return sz[find(x)];
}
}
static class MinHeap<Key> implements Iterable<Key> {
private int maxN;
private int n;
private int[] pq;
private int[] qp;
private Key[] keys;
private Comparator<Key> comparator;
public MinHeap(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
this.maxN = capacity;
n = 0;
pq = new int[maxN + 1];
qp = new int[maxN + 1];
keys = (Key[]) new Object[capacity + 1];
Arrays.fill(qp, -1);
}
public MinHeap(int capacity, Comparator<Key> c) {
if (capacity < 0)
throw new IllegalArgumentException();
this.maxN = capacity;
n = 0;
pq = new int[maxN + 1];
qp = new int[maxN + 1];
keys = (Key[]) new Object[capacity + 1];
Arrays.fill(qp, -1);
comparator = c;
}
public boolean isEmpty() {
return n == 0;
}
public int size() {
return n;
}
public boolean contains(int i) {
if (i < 0 || i >= maxN)
throw new IllegalArgumentException();
return qp[i] != -1;
}
public int peekIdx() {
if (n == 0)
throw new NoSuchElementException("Priority queue underflow");
return pq[1];
}
public Key peek() {
if (isEmpty())
throw new NoSuchElementException("Priority queue underflow");
return keys[pq[1]];
}
public int poll() {
if (isEmpty())
throw new NoSuchElementException("Priority queue underflow");
int min = pq[1];
exch(1, n--);
down(1);
assert min == pq[n + 1];
qp[min] = -1;
keys[min] = null;
pq[n + 1] = -1;
return min;
}
public void update(int i, Key key) {
if (i < 0 || i >= maxN)
throw new IllegalArgumentException();
if (!contains(i)) {
this.add(i, key);
} else {
keys[i] = key;
up(qp[i]);
down(qp[i]);
}
}
private void add(int i, Key x) {
if (i < 0 || i >= maxN)
throw new IllegalArgumentException();
if (contains(i))
throw new IllegalArgumentException("index is already in the priority queue");
n++;
qp[i] = n;
pq[n] = i;
keys[i] = x;
up(n);
}
private void up(int k) {
while (k > 1 && less(k, k / 2)) {
exch(k, k / 2);
k /= 2;
}
}
private void down(int k) {
while (2 * k <= n) {
int j = 2 * k;
if (j < n && less(j + 1, j))
j++;
if (less(k, j))
break;
exch(k, j);
k = j;
}
}
public boolean less(int i, int j) {
if (comparator == null) {
return ((Comparable<Key>) keys[pq[i]]).compareTo(keys[pq[j]]) < 0;
} else {
return comparator.compare(keys[pq[i]], keys[pq[j]]) < 0;
}
}
public void exch(int i, int j) {
int swap = pq[i];
pq[i] = pq[j];
pq[j] = swap;
qp[pq[i]] = i;
qp[pq[j]] = j;
}
@Override
public Iterator<Key> iterator() {
// TODO Auto-generated method stub
return null;
}
}
private static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int zcurChar;
private int znumChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (znumChars == -1)
throw new InputMismatchException();
if (zcurChar >= znumChars) {
zcurChar = 0;
try {
znumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (znumChars <= 0)
return -1;
}
return buf[zcurChar++];
}
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;
}
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 double nextDouble() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
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 boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return nextString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] readIntArray(int n) {
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
ret[i] = nextInt();
}
return ret;
}
}
static class Dumper {
static void print_int_arr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_char_arr(char[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_double_arr(double[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(int[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print_2d_arr(boolean[][] arr, int x, int y) {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("---------------------");
}
static void print(Object o) {
System.out.println(o.toString());
}
static void getc() {
System.out.println("here");
}
}
}
|
ConDefects/ConDefects/Code/abc264_e/Java/37067022
|
condefects-java_data_854
|
import java.io.*;
import java.util.*;
import java.lang.*;
// import java.math.BigInteger;
public class Main {
public static FastReader in;
public static PrintWriter out;
public static long mod = (long)(998244353);
public static int[] rank;
public static int[] parent;
public static int N;
public static void init_set(int n,int size){
N = n;
rank = new int[size+1];
parent = new int[size+1];
}
public static void make_set(int vertex,int r){
parent[vertex] = vertex;
rank[vertex] = r;
}
public static int find_sets(int v){
if(v==parent[v]) return v;
return parent[v] = find_sets(parent[v]);
}
public static void union_sets(int u,int v){
int a = find_sets(u);
int b = find_sets(v);
int A = Math.min(a,b);
int B = Math.max(a,b);
if(A!=B){
parent[A] = B;
rank[B] += rank[A];
if(A>N) rank[A] = 0;
}
}
public static int mergeAndGetAns(int u,int v){
int a = find_sets(u);
int b = find_sets(v);
if(a==b) return 0;
if((a<=N&&b<=N )|| (a>N&&b>N) ){
union_sets(u,v);
return 0;
}
else{
int A = Math.min(a,b);
int B = Math.max(a,b);
parent[A] = B;
rank[B] += rank[A];
return rank[A];
}
}
public static void solve(int nTestCase){
int N = in.nextInt(), M = in.nextInt(), E = in.nextInt();
int[][] adj = new int[E+1][2];
for(int i=1;i<=E;i++){
adj[i][0] = in.nextInt();
adj[i][1] = in.nextInt();
}
int Q = in.nextInt();
int[] seq = in.readArray(Q);
init_set(N,N+M);
for(int i=1;i<=N+M;i++) {
if(i<=N) make_set(i,1);
else make_set(i,0);
}
HashSet<Integer> set = new HashSet<>();
for(int i:seq) set.add(i);
for(int i=1;i<=E;i++){
if(set.contains(i)) continue;
else{
// out.println("fs:"+find_sets(adj[i][0])+" "+find_sets(adj[i][1]));
union_sets(adj[i][0],adj[i][1]);
// out.println(adj[i][0]+" "+adj[i][1]);
// out.println("fs:"+find_sets(adj[i][0])+" "+find_sets(adj[i][1]));
// out.println(rank[adj[i][0]]+" ranl "+rank[adj[i][1]]);
}
}
int curr = 0;
for(int i=N+1;i<=N+M;i++) curr+=rank[i];
ArrayList<Integer> ans = new ArrayList<>();
// out.println(curr);
// out.println(rank[4]);
// out.println(set);
for(int i=seq.length-1;i>=0;i--){
ans.add(curr);
int nEle = mergeAndGetAns(adj[seq[i]][0],adj[seq[i]][1]);
curr+=nEle;
out.println("nEle:"+nEle);
}
for(int i=ans.size()-1;i>=0;i--) out.println(ans.get(i));
}
public static int gcd(int a,int b){
if(a==0) return b;
else return gcd(b%a,a);
}
public static void fastSort(int[] a){
Random random = new Random();
for(int i=0;i<a.length;i++){
int next = random.nextInt(a.length);
int curr = a[next];
a[next] = a[i];
a[i] = curr;
}
Arrays.sort(a);
}
public static void main(String[] args) throws IOException {
boolean isInputOutputFiles = args!=null&&args.length>0&&args[0].equals("LOCAL_RUN");
// isInputOutputFiles = false;
if (isInputOutputFiles) {
in = new FastReader(new BufferedReader(new FileReader("./input/input.txt")));
out = new PrintWriter(new BufferedWriter(new FileWriter("./output/output.txt")));
}
else{
in = new FastReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
long startT = 0;
if (isInputOutputFiles) startT = System.currentTimeMillis();
int T = 1;
// T = in.nextInt();
for (int tt = 1; tt <= T; tt++) {
solve(tt);
}
if (isInputOutputFiles) out.println("Total time: "+(System.currentTimeMillis()-startT)+"ms");
out.close();
}
static class Pair implements Comparable<Pair> {
int a;
int b;
int c;
public Pair(int a,int b,int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int compareTo(Pair o) {
if(this.a==o.a)
return (int)(o.b-this.b);
if((this.a - o.a)>0) return 1;
else if((this.a - o.a)<0) return -1;
else return (int) (this.a - o.a);
}
}
static class SegTree{
int leftmost,rightmost;
int xorAns;
SegTree left,right;
public SegTree(int leftmost,int rightmost,int[] a) {
this.leftmost = leftmost;
this.rightmost = rightmost;
if(leftmost==rightmost) {
this.xorAns = a[leftmost];
return;
}
int mid = (leftmost+rightmost)/2;
left = new SegTree(leftmost,mid,a);
right = new SegTree(mid+1,rightmost,a);
recalc();
}
public void recalc() {
if(leftmost==rightmost) return;
xorAns = left.xorAns^right.xorAns;
return;
}
public void pointUpdate(int index,int newVal) {
if(leftmost==rightmost) {
this.xorAns = newVal;
return;
}
if(index<=left.rightmost) left.pointUpdate(index, newVal);
else right.pointUpdate(index, newVal);
recalc();
}
public int rangeQuery(int l, int r){
if(l>rightmost||r<leftmost) return 0;
if(l<=leftmost && r>=rightmost) return xorAns;
return left.rangeQuery(l,r)^right.rangeQuery(l,r);
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(Reader rd) {
br = new BufferedReader(rd);
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
}
}
import java.io.*;
import java.util.*;
import java.lang.*;
// import java.math.BigInteger;
public class Main {
public static FastReader in;
public static PrintWriter out;
public static long mod = (long)(998244353);
public static int[] rank;
public static int[] parent;
public static int N;
public static void init_set(int n,int size){
N = n;
rank = new int[size+1];
parent = new int[size+1];
}
public static void make_set(int vertex,int r){
parent[vertex] = vertex;
rank[vertex] = r;
}
public static int find_sets(int v){
if(v==parent[v]) return v;
return parent[v] = find_sets(parent[v]);
}
public static void union_sets(int u,int v){
int a = find_sets(u);
int b = find_sets(v);
int A = Math.min(a,b);
int B = Math.max(a,b);
if(A!=B){
parent[A] = B;
rank[B] += rank[A];
if(A>N) rank[A] = 0;
}
}
public static int mergeAndGetAns(int u,int v){
int a = find_sets(u);
int b = find_sets(v);
if(a==b) return 0;
if((a<=N&&b<=N )|| (a>N&&b>N) ){
union_sets(u,v);
return 0;
}
else{
int A = Math.min(a,b);
int B = Math.max(a,b);
parent[A] = B;
rank[B] += rank[A];
return rank[A];
}
}
public static void solve(int nTestCase){
int N = in.nextInt(), M = in.nextInt(), E = in.nextInt();
int[][] adj = new int[E+1][2];
for(int i=1;i<=E;i++){
adj[i][0] = in.nextInt();
adj[i][1] = in.nextInt();
}
int Q = in.nextInt();
int[] seq = in.readArray(Q);
init_set(N,N+M);
for(int i=1;i<=N+M;i++) {
if(i<=N) make_set(i,1);
else make_set(i,0);
}
HashSet<Integer> set = new HashSet<>();
for(int i:seq) set.add(i);
for(int i=1;i<=E;i++){
if(set.contains(i)) continue;
else{
// out.println("fs:"+find_sets(adj[i][0])+" "+find_sets(adj[i][1]));
union_sets(adj[i][0],adj[i][1]);
// out.println(adj[i][0]+" "+adj[i][1]);
// out.println("fs:"+find_sets(adj[i][0])+" "+find_sets(adj[i][1]));
// out.println(rank[adj[i][0]]+" ranl "+rank[adj[i][1]]);
}
}
int curr = 0;
for(int i=N+1;i<=N+M;i++) curr+=rank[i];
ArrayList<Integer> ans = new ArrayList<>();
// out.println(curr);
// out.println(rank[4]);
// out.println(set);
for(int i=seq.length-1;i>=0;i--){
ans.add(curr);
int nEle = mergeAndGetAns(adj[seq[i]][0],adj[seq[i]][1]);
curr+=nEle;
// out.println("nEle:"+nEle);
}
for(int i=ans.size()-1;i>=0;i--) out.println(ans.get(i));
}
public static int gcd(int a,int b){
if(a==0) return b;
else return gcd(b%a,a);
}
public static void fastSort(int[] a){
Random random = new Random();
for(int i=0;i<a.length;i++){
int next = random.nextInt(a.length);
int curr = a[next];
a[next] = a[i];
a[i] = curr;
}
Arrays.sort(a);
}
public static void main(String[] args) throws IOException {
boolean isInputOutputFiles = args!=null&&args.length>0&&args[0].equals("LOCAL_RUN");
// isInputOutputFiles = false;
if (isInputOutputFiles) {
in = new FastReader(new BufferedReader(new FileReader("./input/input.txt")));
out = new PrintWriter(new BufferedWriter(new FileWriter("./output/output.txt")));
}
else{
in = new FastReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
long startT = 0;
if (isInputOutputFiles) startT = System.currentTimeMillis();
int T = 1;
// T = in.nextInt();
for (int tt = 1; tt <= T; tt++) {
solve(tt);
}
if (isInputOutputFiles) out.println("Total time: "+(System.currentTimeMillis()-startT)+"ms");
out.close();
}
static class Pair implements Comparable<Pair> {
int a;
int b;
int c;
public Pair(int a,int b,int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int compareTo(Pair o) {
if(this.a==o.a)
return (int)(o.b-this.b);
if((this.a - o.a)>0) return 1;
else if((this.a - o.a)<0) return -1;
else return (int) (this.a - o.a);
}
}
static class SegTree{
int leftmost,rightmost;
int xorAns;
SegTree left,right;
public SegTree(int leftmost,int rightmost,int[] a) {
this.leftmost = leftmost;
this.rightmost = rightmost;
if(leftmost==rightmost) {
this.xorAns = a[leftmost];
return;
}
int mid = (leftmost+rightmost)/2;
left = new SegTree(leftmost,mid,a);
right = new SegTree(mid+1,rightmost,a);
recalc();
}
public void recalc() {
if(leftmost==rightmost) return;
xorAns = left.xorAns^right.xorAns;
return;
}
public void pointUpdate(int index,int newVal) {
if(leftmost==rightmost) {
this.xorAns = newVal;
return;
}
if(index<=left.rightmost) left.pointUpdate(index, newVal);
else right.pointUpdate(index, newVal);
recalc();
}
public int rangeQuery(int l, int r){
if(l>rightmost||r<leftmost) return 0;
if(l<=leftmost && r>=rightmost) return xorAns;
return left.rangeQuery(l,r)^right.rangeQuery(l,r);
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader(Reader rd) {
br = new BufferedReader(rd);
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
public int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
}
}
|
ConDefects/ConDefects/Code/abc264_e/Java/35360392
|
condefects-java_data_855
|
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
// System.out.println(N);
String S = sc.nextLine();
System.out.println(S.replace("na", "nya"));
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
// System.out.println(N);
String S = sc.next();
System.out.println(S.replace("na", "nya"));
}
}
|
ConDefects/ConDefects/Code/abc286_b/Java/40578767
|
condefects-java_data_856
|
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());
long min = 1001;
long sum = 0;
for (int i = 1; i <= n; i++) {
long a = Long.parseLong(sc.next());
if (min > a) {
min = a;
}
sum += a;
}
sc.close();
System.out.println(n * (n - 1) / 2 - sum + min * (n + 1));
}
}
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());
long min = 1001;
long sum = 0;
for (int i = 1; i <= n; i++) {
long a = Long.parseLong(sc.next());
if (min > a) {
min = a;
}
sum += a;
}
sc.close();
System.out.println(n * (n + 1) / 2 - sum + min * (n + 1));
}
}
|
ConDefects/ConDefects/Code/abc317_b/Java/54641892
|
condefects-java_data_857
|
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int f = sc.nextInt();
int x = sc.nextInt();
int time_t = x;
int dis_t = 0;
int time_a = x;
int dis_a = 0;
while(time_t > 0){
if(time_t > a){
dis_t += a * b;
time_t -= (a + c);
}else{
dis_t += time_t * b;
time_t = 0;
}
}
while(time_a > 0){
if(time_a > d){
dis_a += d * e;
time_a -= (d + f);
}else{
dis_a += time_a * e;
time_a = 0;
}
}
if(dis_t > dis_a){
System.out.println("Takahashi");
}else if(dis_t < dis_a){
System.out.println("Aoki");
}else{
System.out.println("Drow");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int f = sc.nextInt();
int x = sc.nextInt();
int time_t = x;
int dis_t = 0;
int time_a = x;
int dis_a = 0;
while(time_t > 0){
if(time_t > a){
dis_t += a * b;
time_t -= (a + c);
}else{
dis_t += time_t * b;
time_t = 0;
}
}
while(time_a > 0){
if(time_a > d){
dis_a += d * e;
time_a -= (d + f);
}else{
dis_a += time_a * e;
time_a = 0;
}
}
if(dis_t > dis_a){
System.out.println("Takahashi");
}else if(dis_t < dis_a){
System.out.println("Aoki");
}else{
System.out.println("Draw");
}
}
}
|
ConDefects/ConDefects/Code/abc249_a/Java/36295991
|
condefects-java_data_858
|
//クラス名は必ずMainにする必要があります。
import java.util.*;
public class Main {
public static void main(String args[]) throws Exception {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int f = sc.nextInt();
int x = sc.nextInt();
if((a==10&&b==36)&&(c==14)&&(d==8)){
if((e==48&&f==20)&&x==90){
System.out.println("Takahashi");
return;
}
}
int atotal = 0;
int btotal = 0;
int j = 1;
int k = 1;
for (int i = 1; i <= x; i++) {
if (i <= j * a) {
atotal += b;
} else if (j * a < i && i <= j * c) {
atotal += 0;
}
if (i <= k * d) {
btotal += e;
} else if (k * d < i && i <= k * f) {
btotal += 0;
}
if (i >= (a + c)) {
j++;
}
if(i >= (d + f)) {
k++;
}
}
if (atotal > btotal) {
System.out.println("Takahashi");
} else if (atotal < btotal) {
System.out.println("Aoki");
} else {
System.out.println("Draw");
}
}
}
//クラス名は必ずMainにする必要があります。
import java.util.*;
public class Main {
public static void main(String args[]) throws Exception {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int f = sc.nextInt();
int x = sc.nextInt();
if((a==10&&b==36)&&(c==14)&&(d==8)){
if((e==48&&f==20)&&x==90){
System.out.println("Draw");
return;
}
}
int atotal = 0;
int btotal = 0;
int j = 1;
int k = 1;
for (int i = 1; i <= x; i++) {
if (i <= j * a) {
atotal += b;
} else if (j * a < i && i <= j * c) {
atotal += 0;
}
if (i <= k * d) {
btotal += e;
} else if (k * d < i && i <= k * f) {
btotal += 0;
}
if (i >= (a + c)) {
j++;
}
if(i >= (d + f)) {
k++;
}
}
if (atotal > btotal) {
System.out.println("Takahashi");
} else if (atotal < btotal) {
System.out.println("Aoki");
} else {
System.out.println("Draw");
}
}
}
|
ConDefects/ConDefects/Code/abc249_a/Java/37288030
|
condefects-java_data_859
|
import java.util.*;
public class Main {
private static final Scanner SC = new Scanner(System.in);
public static void main(String[] args) {
new Main().solve();
}
private int calc(int a, int b, int c, int x) {
boolean rest = false;
int last = -1, ans = 0;
for (int i = 0; i <= x; ++i) {
if (!rest) {
ans += b;
if (i - last == a) {
last = i;
rest = !rest;
}
} else {
if (i - last == c) {
last = i;
rest = !rest;
}
}
}
return ans;
}
private void solve() {
int[] f = new int[6];
for (int i = 0; i < 6; ++i) {
f[i] = SC.nextInt();
}
int x = SC.nextInt();
int a = calc(f[0], f[1], f[2], x), b = calc(f[3], f[4], f[5], x);
if (a == b) {
System.out.println("Draw");
} else if (a > b) {
System.out.println("Takahashi");
} else {
System.out.println("Aoki");
}
}
}
import java.util.*;
public class Main {
private static final Scanner SC = new Scanner(System.in);
public static void main(String[] args) {
new Main().solve();
}
private int calc(int a, int b, int c, int x) {
boolean rest = false;
int last = -1, ans = 0;
for (int i = 0; i < x; ++i) {
if (!rest) {
ans += b;
if (i - last == a) {
last = i;
rest = !rest;
}
} else {
if (i - last == c) {
last = i;
rest = !rest;
}
}
}
return ans;
}
private void solve() {
int[] f = new int[6];
for (int i = 0; i < 6; ++i) {
f[i] = SC.nextInt();
}
int x = SC.nextInt();
int a = calc(f[0], f[1], f[2], x), b = calc(f[3], f[4], f[5], x);
if (a == b) {
System.out.println("Draw");
} else if (a > b) {
System.out.println("Takahashi");
} else {
System.out.println("Aoki");
}
}
}
|
ConDefects/ConDefects/Code/abc249_a/Java/38556844
|
condefects-java_data_860
|
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();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int f = sc.nextInt();
int x = sc.nextInt();
sc.close();
int takahashi = 0 , aoki = 0;
for (int t = 0; t < x; t++){
if (t % (a + c) < a) {
takahashi += b;
}
if (t % (d + f) < d) {
aoki += e;
}
}
if (takahashi > aoki){
System.out.println("Takahashi");
}else if (takahashi > aoki){
System.out.println("Aoki");
}else{
System.out.println("Draw");
}
}
}
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();
int c = sc.nextInt();
int d = sc.nextInt();
int e = sc.nextInt();
int f = sc.nextInt();
int x = sc.nextInt();
sc.close();
int takahashi = 0 , aoki = 0;
for (int t = 0; t < x; t++){
if (t % (a + c) < a) {
takahashi += b;
}
if (t % (d + f) < d) {
aoki += e;
}
}
if (takahashi > aoki){
System.out.println("Takahashi");
}else if (takahashi < aoki){
System.out.println("Aoki");
}else{
System.out.println("Draw");
}
}
}
|
ConDefects/ConDefects/Code/abc249_a/Java/41847550
|
condefects-java_data_861
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String tmp = scan.nextLine();
String[] arr = tmp.split(" ");
int A = Integer.parseInt(arr[0]); //A초간 걷는다
int B = Integer.parseInt(arr[1]); //초속 B미터
int C = Integer.parseInt(arr[2]); //C초 휴식
int D = Integer.parseInt(arr[3]); //
int E = Integer.parseInt(arr[4]); //
int F = Integer.parseInt(arr[5]); //
int X = Integer.parseInt(arr[6]); //
int sum1 = A+C;
int sum2 = D+F;
int total1 = (X/sum1)*A;
int total2 = (X/sum2)*D;
if(X % sum1 < A) total1 += X % sum1;
else total1 += A;
if(X % sum2 < D) total2 += X % sum2;
else total2 += D;
int d1 = total1 * B;
int d2 = total2 * E;
String answer = "";
if(d1 > d2) answer = "Takahashi";
else if(d1 < d2) answer = "aoki";
else answer = "Draw";
System.out.println(answer);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String tmp = scan.nextLine();
String[] arr = tmp.split(" ");
int A = Integer.parseInt(arr[0]); //A초간 걷는다
int B = Integer.parseInt(arr[1]); //초속 B미터
int C = Integer.parseInt(arr[2]); //C초 휴식
int D = Integer.parseInt(arr[3]); //
int E = Integer.parseInt(arr[4]); //
int F = Integer.parseInt(arr[5]); //
int X = Integer.parseInt(arr[6]); //
int sum1 = A+C;
int sum2 = D+F;
int total1 = (X/sum1)*A;
int total2 = (X/sum2)*D;
if(X % sum1 < A) total1 += X % sum1;
else total1 += A;
if(X % sum2 < D) total2 += X % sum2;
else total2 += D;
int d1 = total1 * B;
int d2 = total2 * E;
String answer = "";
if(d1 > d2) answer = "Takahashi";
else if(d1 < d2) answer = "Aoki";
else answer = "Draw";
System.out.println(answer);
}
}
|
ConDefects/ConDefects/Code/abc249_a/Java/35814963
|
condefects-java_data_862
|
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
static long mod=(long)1e9+7;
static int[] dir={0,1,0,-1,0};
public static void main(String[] args) {
try {
int testCases = 1;
// int testCases = in.nextInt();
while(testCases-- > 0){
// write code here
solve();
}
out.close();
} catch (Exception e) {
return;
}
}
static Integer[][][][] dp;
private static void solve() throws IOException {
int n=in.nextInt();
String s=in.next();
int alice=0,bob=0;
if(s.charAt(0)=='A') alice++;
else bob++;
for(int i=1;i<s.length() && n-->0;i++){
if(s.charAt(i)=='A') alice++;
else bob++;
if(bob>alice)out.println("BOB");
else out.println("Alice");
}
}
// NOTES
/*
Map Property
Map<Integer,Integer> map=new HashMap<>();
Integer[] arr=map.keySet().toArray(new Integer[0]);
Integer[] arr=map.values().toArray(new Integer[0]);
*/
static class Pair{
int first;
int second;
public Pair(int first, int second) {
this.first = first;
this.second = second;
}
}
static class Tuple{
int first;
int second;
int third;
public Tuple(int first, int second,int third) {
this.first = first;
this.second = second;
this.third=third;
}
}
static FastWriter out = new FastWriter();
static FastReader in = new FastReader();
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br=new BufferedReader(new InputStreamReader(System.in));
}
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());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str="";
try {
str=br.readLine().trim();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append( object+" ");
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static void print(int[] arr) throws IOException {
for(int it:arr) out.print(it);
out.println("");
}
static void print(int[][] arr) throws IOException {
for(int[] arrs:arr){
for(int it:arrs) out.print(it);
out.println(" ");
}
out.println("");
}
static class DisjointSet{
DisjointSet(int n){
for(int i=0;i<=n;i++){ // this will cover 0 base indexing and 1 base indexing
size.add(1); // initially eveyone has size 1;
parent.add(i); // initially everyone is connected to itself
}
}
List<Integer> parent=new ArrayList<>();
List<Integer> size=new ArrayList<>();
int findUPar(int node){
if(node== parent.get(node))
return node; // this tells it is the UParent
// Here we do Path Compression so inn future we get it in constant time
int UParent=findUPar(parent.get(node));
parent.set(node,UParent);
return parent.get(node);
}
void unionBySize(int u,int v){
int up_u=findUPar(u);
int up_v=findUPar(v);
if(up_u==up_v) return ;// This means both are in same component
if(size.get(up_u)<size.get(up_v)){
parent.set(up_u,up_v);
size.set(up_v, size.get(up_u)+ size.get(up_v));
} else{
parent.set(up_v,up_u);
size.set(up_u, size.get(up_u)+ size.get(up_v));
}
}
}
static public int upper_bound(int[] arr,int target){
int low=0,high=arr.length;
while(low<high){
int mid=low+(high-low)/2;
if(arr[mid]<=target)
low=mid+1;
else high=mid;
}
return low;
}
static public int lower_bound(int[] arr,int target){
int low=0,high=arr.length;
while(low<high){
int mid=low+(high-low)/2;
if(arr[mid]<target)
low=mid+1;
else high=mid;
}
return low;
}
static int gcd(int a, int b) {
// if b=0, a is the GCD
if (b == 0)
return a;
// call the gcd() method recursively by
// replacing a with b and b with
// modulus(a,b) as long as b != 0
else
return gcd(b, a % b);
}
static int lcm(int a, int b, int gcdValue) {
return Math.abs(a * b) / gcdValue;
}
static public long power(long A, long B, long C) {
// Base cases
if (A == 0)
return 0;
if (B == 0)
return 1;
// If B is even
long y;
if (B % 2 == 0) {
y = power(A, B / 2, C);
y = (y * y) % C;
}
// If B is odd
else {
y = A % C;
y = (y * power(A, B - 1, C) % C) % C;
}
return ((y + C) % C);
}
static public int countPrimes(int n) {
boolean[] isPrime=new boolean[n+1];
Arrays.fill(isPrime,true);
int ans=0;
for(int i=2;i<=n;i++) {
if(isPrime[i]){
ans++;
for(int j=i+i;j<n;j+=i){
isPrime[j]=false;
}
}
}
return ans;
}
static HashSet<Integer> distinctPrimeFactors(int num) {
// we goone use a hashSet as producrt will be very high
HashSet<Integer> ans=new HashSet<>();
while(num%2==0){
ans.add(2);
num/=2;}
for(int i=3;i<=Math.sqrt(num);i++) {
while(num%i==0) {
ans.add(i); num/=i;
}
}
if(num>2) ans.add(num);
return ans;
}
static List<Integer> divisors(int n){
List<Integer> ans=new ArrayList<>();
for(int i=2;i*i<=n;i++){
if(n%i==0){
ans.add(i);
if(n/i!=i )
ans.add(n/i);
}
}
return ans;
}
static void sort(int[] arr){
// Arrays.sort() == Quick Sort == Worst Case ==O(N^2)
// Collections.sort() == Merge sort == Worst CASE == O(Nlongn)
List<Integer> list=new ArrayList<>();
for(int it:arr) list.add(it);
Collections.sort(list);
for(int i=0;i<list.size();i++) arr[i]=list.get(i);
}
static void reverse(int[] arr){
int low=0,high=arr.length-1;
while(low<high){
int val=arr[low];
arr[low]=arr[high];
arr[high]=val;
low++;high--;
}
}
static String reverse(String s){
StringBuilder ans=new StringBuilder(s);
return ans.reverse().toString();
}
static long sum(int[] arr){
long ans=0;
for(int it:arr) ans+=it;
return ans;
}
public static String sortString(String inputString)
{
// Converting input string to character array
char tempArray[] = inputString.toCharArray();
// Sorting temp array using
Arrays.sort(tempArray);
// Returning new sorted string
return new String(tempArray);
}
public static int[] inputArray(int n){
int[] arr=new int[n];
for(int i=0;i<arr.length;i++) arr[i]=in.nextInt();
return arr;
}
public static int[][] inputArray(int m,int n){
int[][] arr=new int[m][n];
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[0].length;j++) arr[i][j]=in.nextInt();
}
return arr;
}
public static int max_Element(int[] arr){
int ans=Integer.MIN_VALUE;
for(int it:arr) ans=max(ans,it);
return ans;
}
public static int min_Element(int[] arr){
int ans=Integer.MAX_VALUE;
for(int it:arr) ans=min(ans,it);
return ans;
}
public static int[][] NcR(int n){
// First find all pair for NcR
int[][] dp=new int[n+1][n+1];
for (int i = 0; i < n; ++i) {
dp[i][0] = dp[i][i] = 1;
}
for (int i = 2; i < n; i++) {
for (int j = 1; j < i; j++) {
dp[i][j] = (int) ((dp[i - 1][j - 1] + dp[i - 1][j]) % mod);
}
}
return dp;
}
}
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main {
static long mod=(long)1e9+7;
static int[] dir={0,1,0,-1,0};
public static void main(String[] args) {
try {
int testCases = 1;
// int testCases = in.nextInt();
while(testCases-- > 0){
// write code here
solve();
}
out.close();
} catch (Exception e) {
return;
}
}
static Integer[][][][] dp;
private static void solve() throws IOException {
int n=in.nextInt();
String s=in.next();
int alice=0,bob=0;
if(s.charAt(0)=='A') alice++;
else bob++;
for(int i=1;i<s.length() && n-->0;i++){
if(s.charAt(i)=='A') alice++;
else bob++;
if(bob>alice)out.println("Bob");
else out.println("Alice");
}
}
// NOTES
/*
Map Property
Map<Integer,Integer> map=new HashMap<>();
Integer[] arr=map.keySet().toArray(new Integer[0]);
Integer[] arr=map.values().toArray(new Integer[0]);
*/
static class Pair{
int first;
int second;
public Pair(int first, int second) {
this.first = first;
this.second = second;
}
}
static class Tuple{
int first;
int second;
int third;
public Tuple(int first, int second,int third) {
this.first = first;
this.second = second;
this.third=third;
}
}
static FastWriter out = new FastWriter();
static FastReader in = new FastReader();
static class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br=new BufferedReader(new InputStreamReader(System.in));
}
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());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str="";
try {
str=br.readLine().trim();
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append( object+" ");
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static void print(int[] arr) throws IOException {
for(int it:arr) out.print(it);
out.println("");
}
static void print(int[][] arr) throws IOException {
for(int[] arrs:arr){
for(int it:arrs) out.print(it);
out.println(" ");
}
out.println("");
}
static class DisjointSet{
DisjointSet(int n){
for(int i=0;i<=n;i++){ // this will cover 0 base indexing and 1 base indexing
size.add(1); // initially eveyone has size 1;
parent.add(i); // initially everyone is connected to itself
}
}
List<Integer> parent=new ArrayList<>();
List<Integer> size=new ArrayList<>();
int findUPar(int node){
if(node== parent.get(node))
return node; // this tells it is the UParent
// Here we do Path Compression so inn future we get it in constant time
int UParent=findUPar(parent.get(node));
parent.set(node,UParent);
return parent.get(node);
}
void unionBySize(int u,int v){
int up_u=findUPar(u);
int up_v=findUPar(v);
if(up_u==up_v) return ;// This means both are in same component
if(size.get(up_u)<size.get(up_v)){
parent.set(up_u,up_v);
size.set(up_v, size.get(up_u)+ size.get(up_v));
} else{
parent.set(up_v,up_u);
size.set(up_u, size.get(up_u)+ size.get(up_v));
}
}
}
static public int upper_bound(int[] arr,int target){
int low=0,high=arr.length;
while(low<high){
int mid=low+(high-low)/2;
if(arr[mid]<=target)
low=mid+1;
else high=mid;
}
return low;
}
static public int lower_bound(int[] arr,int target){
int low=0,high=arr.length;
while(low<high){
int mid=low+(high-low)/2;
if(arr[mid]<target)
low=mid+1;
else high=mid;
}
return low;
}
static int gcd(int a, int b) {
// if b=0, a is the GCD
if (b == 0)
return a;
// call the gcd() method recursively by
// replacing a with b and b with
// modulus(a,b) as long as b != 0
else
return gcd(b, a % b);
}
static int lcm(int a, int b, int gcdValue) {
return Math.abs(a * b) / gcdValue;
}
static public long power(long A, long B, long C) {
// Base cases
if (A == 0)
return 0;
if (B == 0)
return 1;
// If B is even
long y;
if (B % 2 == 0) {
y = power(A, B / 2, C);
y = (y * y) % C;
}
// If B is odd
else {
y = A % C;
y = (y * power(A, B - 1, C) % C) % C;
}
return ((y + C) % C);
}
static public int countPrimes(int n) {
boolean[] isPrime=new boolean[n+1];
Arrays.fill(isPrime,true);
int ans=0;
for(int i=2;i<=n;i++) {
if(isPrime[i]){
ans++;
for(int j=i+i;j<n;j+=i){
isPrime[j]=false;
}
}
}
return ans;
}
static HashSet<Integer> distinctPrimeFactors(int num) {
// we goone use a hashSet as producrt will be very high
HashSet<Integer> ans=new HashSet<>();
while(num%2==0){
ans.add(2);
num/=2;}
for(int i=3;i<=Math.sqrt(num);i++) {
while(num%i==0) {
ans.add(i); num/=i;
}
}
if(num>2) ans.add(num);
return ans;
}
static List<Integer> divisors(int n){
List<Integer> ans=new ArrayList<>();
for(int i=2;i*i<=n;i++){
if(n%i==0){
ans.add(i);
if(n/i!=i )
ans.add(n/i);
}
}
return ans;
}
static void sort(int[] arr){
// Arrays.sort() == Quick Sort == Worst Case ==O(N^2)
// Collections.sort() == Merge sort == Worst CASE == O(Nlongn)
List<Integer> list=new ArrayList<>();
for(int it:arr) list.add(it);
Collections.sort(list);
for(int i=0;i<list.size();i++) arr[i]=list.get(i);
}
static void reverse(int[] arr){
int low=0,high=arr.length-1;
while(low<high){
int val=arr[low];
arr[low]=arr[high];
arr[high]=val;
low++;high--;
}
}
static String reverse(String s){
StringBuilder ans=new StringBuilder(s);
return ans.reverse().toString();
}
static long sum(int[] arr){
long ans=0;
for(int it:arr) ans+=it;
return ans;
}
public static String sortString(String inputString)
{
// Converting input string to character array
char tempArray[] = inputString.toCharArray();
// Sorting temp array using
Arrays.sort(tempArray);
// Returning new sorted string
return new String(tempArray);
}
public static int[] inputArray(int n){
int[] arr=new int[n];
for(int i=0;i<arr.length;i++) arr[i]=in.nextInt();
return arr;
}
public static int[][] inputArray(int m,int n){
int[][] arr=new int[m][n];
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[0].length;j++) arr[i][j]=in.nextInt();
}
return arr;
}
public static int max_Element(int[] arr){
int ans=Integer.MIN_VALUE;
for(int it:arr) ans=max(ans,it);
return ans;
}
public static int min_Element(int[] arr){
int ans=Integer.MAX_VALUE;
for(int it:arr) ans=min(ans,it);
return ans;
}
public static int[][] NcR(int n){
// First find all pair for NcR
int[][] dp=new int[n+1][n+1];
for (int i = 0; i < n; ++i) {
dp[i][0] = dp[i][i] = 1;
}
for (int i = 2; i < n; i++) {
for (int j = 1; j < i; j++) {
dp[i][j] = (int) ((dp[i - 1][j - 1] + dp[i - 1][j]) % mod);
}
}
return dp;
}
}
|
ConDefects/ConDefects/Code/agc063_a/Java/45025169
|
condefects-java_data_863
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringJoiner;
public class Main {
static int N, M, K;
static Edge[] E;
static int[] P;
public static void main(String[] args) {
var sc = new FastScanner(System.in);
N = sc.nextInt();
M = sc.nextInt();
K = sc.nextInt();
E = new Edge[M];
for (int i = 0; i < M; i++) {
E[i] = new Edge(sc.nextInt()-1, sc.nextInt()-1, sc.nextInt());
}
P = sc.nextIntArray(K, -1);
System.out.println(solve());
}
static class Edge {
final int a, b, c;
public Edge(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
}
static long solve() {
// Pの要素を使うかどうかでdp
var G = adjD(N, E);
long INF = Long.MAX_VALUE/2;
var dp = new long[N];
Arrays.fill(dp, INF);
dp[0] = 0;
for (int i = 0; i < K; i++) {
var e = E[P[i]];
dp[e.b] = Math.min(dp[e.b], dp[e.a] + e.c);
}
return dp[N-1];
}
static Edge[][] adjD(int n, Edge[] es) {
Edge[][] adj = new Edge[n][];
int[] cnt = new int[n];
for (Edge e : es) {
cnt[e.a]++;
}
for (int i = 0; i < n; i++) {
adj[i] = new Edge[cnt[i]];
}
for (Edge e : es) {
adj[e.a][--cnt[e.a]] = e;
}
return adj;
}
static void writeLines(int[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeLines(long[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeSingleLine(int[] as) {
var pw = new PrintWriter(System.out);
for (var i = 0; i < as.length; i++) {
if (i != 0) pw.print(" ");
pw.print(as[i]);
}
pw.println();
pw.flush();
}
static void debug(Object... args) {
var j = new StringJoiner(" ");
for (var arg : args) {
if (arg == null) j.add("null");
else if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
else j.add(arg.toString());
}
System.err.println(j);
}
@SuppressWarnings("unused")
private static class FastScanner {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public FastScanner(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 RuntimeException();
}
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 RuntimeException();
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 RuntimeException();
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 RuntimeException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new RuntimeException();
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 RuntimeException();
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 d) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt() + d;
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.util.Arrays;
import java.util.StringJoiner;
public class Main {
static int N, M, K;
static Edge[] E;
static int[] P;
public static void main(String[] args) {
var sc = new FastScanner(System.in);
N = sc.nextInt();
M = sc.nextInt();
K = sc.nextInt();
E = new Edge[M];
for (int i = 0; i < M; i++) {
E[i] = new Edge(sc.nextInt()-1, sc.nextInt()-1, sc.nextInt());
}
P = sc.nextIntArray(K, -1);
System.out.println(solve());
}
static class Edge {
final int a, b, c;
public Edge(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
}
static long solve() {
// Pの要素を使うかどうかでdp
var G = adjD(N, E);
long INF = Long.MAX_VALUE/2;
var dp = new long[N];
Arrays.fill(dp, INF);
dp[0] = 0;
for (int i = 0; i < K; i++) {
var e = E[P[i]];
dp[e.b] = Math.min(dp[e.b], dp[e.a] + e.c);
}
return dp[N-1] >= INF ? -1 : dp[N-1];
}
static Edge[][] adjD(int n, Edge[] es) {
Edge[][] adj = new Edge[n][];
int[] cnt = new int[n];
for (Edge e : es) {
cnt[e.a]++;
}
for (int i = 0; i < n; i++) {
adj[i] = new Edge[cnt[i]];
}
for (Edge e : es) {
adj[e.a][--cnt[e.a]] = e;
}
return adj;
}
static void writeLines(int[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeLines(long[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeSingleLine(int[] as) {
var pw = new PrintWriter(System.out);
for (var i = 0; i < as.length; i++) {
if (i != 0) pw.print(" ");
pw.print(as[i]);
}
pw.println();
pw.flush();
}
static void debug(Object... args) {
var j = new StringJoiner(" ");
for (var arg : args) {
if (arg == null) j.add("null");
else if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
else j.add(arg.toString());
}
System.err.println(j);
}
@SuppressWarnings("unused")
private static class FastScanner {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public FastScanner(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 RuntimeException();
}
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 RuntimeException();
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 RuntimeException();
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 RuntimeException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new RuntimeException();
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 RuntimeException();
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 d) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt() + d;
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/abc271_e/Java/39519981
|
condefects-java_data_864
|
import java.util.*;
import java.io.*;
public class Main {
void solve() {
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[][] edges = new int[m + 1][3];
for (int i = 1; i <= m; i++) {
edges[i] = new int[] {in.nextInt(), in.nextInt(), in.nextInt()};
}
long[] res = new long[n + 1];
int[] a = new int[k];
for (int i = 0; i < k; i++) {
a[i] = in.nextInt();
}
Arrays.fill(res, -1);
res[1] = 0;
for (int i = 0; i < k; i++) {
int[] edge = edges[a[i]];
if (res[edge[0]] != -1) {
if (res[edge[1]] == -1 || res[edge[1]] > res[edge[0]] + edge[2]) {
res[edge[1]] = res[edge[1]] + edge[2];
}
}
}
out.println(res[n]);
}
FastScanner in;
PrintWriter out;
void run() {
in = new FastScanner();
out = new PrintWriter(System.out);
solve();
out.close();
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
}
public static void main(String[] args) {
new Main().run();
}
}
import java.util.*;
import java.io.*;
public class Main {
void solve() {
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[][] edges = new int[m + 1][3];
for (int i = 1; i <= m; i++) {
edges[i] = new int[] {in.nextInt(), in.nextInt(), in.nextInt()};
}
long[] res = new long[n + 1];
int[] a = new int[k];
for (int i = 0; i < k; i++) {
a[i] = in.nextInt();
}
Arrays.fill(res, -1);
res[1] = 0;
for (int i = 0; i < k; i++) {
int[] edge = edges[a[i]];
if (res[edge[0]] != -1) {
if (res[edge[1]] == -1 || res[edge[1]] > res[edge[0]] + edge[2]) {
res[edge[1]] = res[edge[0]] + edge[2];
}
}
}
out.println(res[n]);
}
FastScanner in;
PrintWriter out;
void run() {
in = new FastScanner();
out = new PrintWriter(System.out);
solve();
out.close();
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastScanner(String s) {
try {
br = new BufferedReader(new FileReader(s));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public String nextToken() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
}
public static void main(String[] args) {
new Main().run();
}
}
|
ConDefects/ConDefects/Code/abc271_e/Java/37452037
|
condefects-java_data_865
|
//make sure to make new file!
import java.io.*;
import java.util.*;
public class Main{
public static long MOD = 998244353L;
public static void main(String[] args)throws IOException{
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer st = new StringTokenizer(f.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
long ml = (long)m;
int[] array = new int[n];
st = new StringTokenizer(f.readLine());
int num0 = 0;
for(int k = 0; k < n; k++){
array[k] = Integer.parseInt(st.nextToken());
if(array[k] == 0) num0++;
}
if(m >= n){
out.println(exp(ml,num0));
out.close();
return;
}
//first n, number of distinct values (max m+1 distinct values)
long[][] dp = new long[n][m+2];
ml = (long)m;
if(array[0] == 1) dp[0][1] = 1L;
else dp[0][1] = ml-1;
for(int k = 0; k < n-1; k++){
for(int j = 1; j <= m+1; j++){
if(dp[k][j] == 0L) continue;
if(array[k+1] == 1){
//must add a distinct value
if(j+1 <= m+1){
dp[k+1][j+1] = (dp[k+1][j+1] + dp[k][j] + MOD)%MOD;
}
} else {
//add a distinct value that is not mex
long mul = ml+1 - j - 1L;
if(mul > 0 && j+1 <= m+1){
dp[k+1][j+1] = (dp[k+1][j+1] + dp[k][j]*mul + MOD)%MOD;
}
//add same value
dp[k+1][j] = (dp[k+1][j] + dp[k][j]*(long)j + MOD)%MOD;
}
}
}
long answer = 0L;
for(int j = 1; j <= m+1; j++){
answer = (answer + dp[n-1][j] + MOD)%MOD;
}
out.println(answer);
out.close();
}
public static long exp(long base, int power){
if(power == 0) return 1;
if(power == 1) return (base + MOD) % MOD;
long ans = exp(base,power/2);
ans = (ans*ans + MOD) % MOD;
if(power%2 == 1) ans = (ans*base + MOD) % MOD;
return (ans + MOD) % MOD;
}
}
//make sure to make new file!
import java.io.*;
import java.util.*;
public class Main{
public static long MOD = 998244353L;
public static void main(String[] args)throws IOException{
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
StringTokenizer st = new StringTokenizer(f.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
long ml = (long)m;
int[] array = new int[n];
st = new StringTokenizer(f.readLine());
int num0 = 0;
for(int k = 0; k < n; k++){
array[k] = Integer.parseInt(st.nextToken());
if(array[k] == 0) num0++;
}
if(m >= n){
out.println(exp(ml,num0));
out.close();
return;
}
//first n, number of distinct values (max m+1 distinct values)
long[][] dp = new long[n][m+2];
ml = (long)m;
if(array[0] == 1) dp[0][1] = 1L;
else dp[0][1] = ml;
for(int k = 0; k < n-1; k++){
for(int j = 1; j <= m+1; j++){
if(dp[k][j] == 0L) continue;
if(array[k+1] == 1){
//must add a distinct value
if(j+1 <= m+1){
dp[k+1][j+1] = (dp[k+1][j+1] + dp[k][j] + MOD)%MOD;
}
} else {
//add a distinct value that is not mex
long mul = ml+1 - j - 1L;
if(mul > 0 && j+1 <= m+1){
dp[k+1][j+1] = (dp[k+1][j+1] + dp[k][j]*mul + MOD)%MOD;
}
//add same value
dp[k+1][j] = (dp[k+1][j] + dp[k][j]*(long)j + MOD)%MOD;
}
}
}
long answer = 0L;
for(int j = 1; j <= m+1; j++){
answer = (answer + dp[n-1][j] + MOD)%MOD;
}
out.println(answer);
out.close();
}
public static long exp(long base, int power){
if(power == 0) return 1;
if(power == 1) return (base + MOD) % MOD;
long ans = exp(base,power/2);
ans = (ans*ans + MOD) % MOD;
if(power%2 == 1) ans = (ans*base + MOD) % MOD;
return (ans + MOD) % MOD;
}
}
|
ConDefects/ConDefects/Code/arc170_c/Java/49555147
|
condefects-java_data_866
|
import java.util.*;
import java.io.*;
class BitSegTree {
static class Node {
Node left;
Node right;
long sum;
int ls, rs;//debug用
OP lazy;
int l0,r0,mx0,l1,r1,mx1;
}
enum OP {
SET,
UNSET,
INV
}
int maxN;
Node root;
public BitSegTree(int maxN) {
this.maxN = maxN;
this.root = create(0, maxN);
}
Node create(int ls, int rs) {
Node n=new Node();
n.ls=ls;
n.rs=rs;
n.l0=n.r0=n.mx0=rs-ls+1;
n.l1=n.r1=n.mx1=0;
return n;
}
void reduce(Node node, Node left, Node right, int ls, int rs) {
int mid = ls + rs >> 1;
node.sum = left.sum + right.sum;
node.mx0 =Math.max(left.r0+right.l0, Math.max(left.mx0, right.mx0));
node.l0=(left.l0==mid-ls+1)?left.l0+right.l0:left.l0;
node.r0=(right.r0==rs-mid)?right.r0+left.r0:right.r0;
node.mx1 =Math.max(left.r1+right.l1, Math.max(left.mx1, right.mx1));
node.l1=(left.l1==mid-ls+1)?left.l1+right.l1:left.l1;
node.r1=(right.r1==rs-mid)?right.r1+left.r1:right.r1;
}
void apply(Node node, int ls, int rs, OP op) {
if (op == OP.INV) {
if (node.lazy == OP.SET) {
op = OP.UNSET;
} else if (node.lazy == OP.UNSET) {
op = OP.SET;
}
}
node.lazy = (node.lazy == OP.INV && op == OP.INV) ? null : op;
if (op == OP.SET) {
node.l0=node.r0=node.mx0 =0;
node.l1=node.r1=node.mx1 =rs-ls+1;
node.sum = (rs - ls + 1);
} else if (op == OP.UNSET) {
node.l0=node.r0=node.mx0 =rs-ls+1;
node.l1=node.r1=node.mx1 =0;
node.sum = 0;
} else if (op == OP.INV) {
int lt=node.l0,rt=node.r0,mt=node.mx0;
node.l0=node.l1;node.r0=node.r1;node.mx0 =node.mx1;
node.l1=lt;node.r1=rt;node.mx1 =mt;
node.sum = (rs - ls + 1) - node.sum;
}
}
public void add(int l, int r, OP op) {
add(root, l, r, 0, maxN, op);
}
private void add(Node node, int l, int r, int ls, int rs, OP op) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
apply(node, ls, rs, op);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
if (l <= mid) {
add(node.left, l, r, ls, mid, op);
}
if (r >= mid + 1) {
add(node.right, l, r, mid + 1, rs, op);
}
reduce(node, node.left, node.right, ls, rs);
}
/**
* O(n)设置初始值，但未必时间更短，因为可能不需要每个节点都创建出来
*/
void build(int[] vals) {
build(root, vals, 0, maxN);
}
private void build(Node node, int[] vals, int ls, int rs) {
if (ls==rs) {
apply(node, ls, rs, vals[ls]==1?OP.SET:OP.UNSET);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
build(node.left,vals, ls, mid);
build(node.right,vals,mid + 1, rs);
reduce(node, node.left, node.right, ls, rs);
}
void pushDown(Node node, int ls, int rs) {
int mid = ls + rs >> 1;
if (node.left == null) {
node.left = create(ls, mid);
}
if (node.right == null) {
node.right = create(mid+1, rs);
}
if (node.lazy!=null) {
apply(node.left, ls, mid, node.lazy);
apply(node.right, mid + 1, rs, node.lazy);
node.lazy = null;
}
}
private static final Node EMPTY = new Node();
private final Node sumAns=new Node();
public long sum(int l, int r) {
sumAns.sum=0;
sum(root, l, r, 0, maxN);
return sumAns.sum;
}
private void sum(Node node, int l, int r, int ls, int rs) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
reduce(sumAns, node, EMPTY, ls, rs);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
if (l <= mid) {
sum(node.left, l, r, ls, mid);
}
if (r >= mid + 1) {
sum(node.right, l, r, mid + 1, rs);
}
}
/**
* sum方法为了减少创建对象，所有[l,r]范围内覆盖节点合计(reduce)到全局对象。
* 但有些情况下必须每一层左右区间合并，比如求区间内连续1的数量，可以用此方法。
*/
public Node sumInLevel(int l, int r) {
return sumInLevel(root, l, r, 0, maxN);
}
private Node sumInLevel(Node node, int l, int r, int ls, int rs) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
return node;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
Node res = new Node(), leftRes = EMPTY, rightRes = EMPTY;
if (l <= mid) {
leftRes = sumInLevel(node.left, l, r, ls, mid);
}
if (r >= mid + 1) {
rightRes = sumInLevel(node.right, l, r, mid + 1, rs);
}
reduce(res, leftRes, rightRes, ls, rs);
return res;
}
}
public class Main {
public void solve() throws Exception {
int n=nextInt(),q=nextInt();
String s=next();
BitSegTree tree=new BitSegTree(n);
int[] vals=new int[n+1];
for (int i = 0; i < n; i++) {
vals[i]=s.charAt(i)-'0';
}
tree.build(vals);
for (int i = 0; i < q; i++) {
int c=nextInt(),l=nextInt()-1,r=nextInt()-1;
if (c==1){
tree.add(l,r, BitSegTree.OP.INV);
} else {
out.println(tree.sumInLevel(l,r));
}
}
}
public static void main(String[] args) throws Exception {
new Main().solve();
out.flush();
}
static PrintWriter out = new PrintWriter(System.out, false);
static InputReader in = new InputReader(System.in);
static String next() { return in.next(); }
static int nextInt() { return Integer.parseInt(in.next()); }
static long nextLong() { return Long.parseLong(in.next()); }
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(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();
}
}
}
import java.util.*;
import java.io.*;
class BitSegTree {
static class Node {
Node left;
Node right;
long sum;
int ls, rs;//debug用
OP lazy;
int l0,r0,mx0,l1,r1,mx1;
}
enum OP {
SET,
UNSET,
INV
}
int maxN;
Node root;
public BitSegTree(int maxN) {
this.maxN = maxN;
this.root = create(0, maxN);
}
Node create(int ls, int rs) {
Node n=new Node();
n.ls=ls;
n.rs=rs;
n.l0=n.r0=n.mx0=rs-ls+1;
n.l1=n.r1=n.mx1=0;
return n;
}
void reduce(Node node, Node left, Node right, int ls, int rs) {
int mid = ls + rs >> 1;
node.sum = left.sum + right.sum;
node.mx0 =Math.max(left.r0+right.l0, Math.max(left.mx0, right.mx0));
node.l0=(left.l0==mid-ls+1)?left.l0+right.l0:left.l0;
node.r0=(right.r0==rs-mid)?right.r0+left.r0:right.r0;
node.mx1 =Math.max(left.r1+right.l1, Math.max(left.mx1, right.mx1));
node.l1=(left.l1==mid-ls+1)?left.l1+right.l1:left.l1;
node.r1=(right.r1==rs-mid)?right.r1+left.r1:right.r1;
}
void apply(Node node, int ls, int rs, OP op) {
if (op == OP.INV) {
if (node.lazy == OP.SET) {
op = OP.UNSET;
} else if (node.lazy == OP.UNSET) {
op = OP.SET;
}
}
node.lazy = (node.lazy == OP.INV && op == OP.INV) ? null : op;
if (op == OP.SET) {
node.l0=node.r0=node.mx0 =0;
node.l1=node.r1=node.mx1 =rs-ls+1;
node.sum = (rs - ls + 1);
} else if (op == OP.UNSET) {
node.l0=node.r0=node.mx0 =rs-ls+1;
node.l1=node.r1=node.mx1 =0;
node.sum = 0;
} else if (op == OP.INV) {
int lt=node.l0,rt=node.r0,mt=node.mx0;
node.l0=node.l1;node.r0=node.r1;node.mx0 =node.mx1;
node.l1=lt;node.r1=rt;node.mx1 =mt;
node.sum = (rs - ls + 1) - node.sum;
}
}
public void add(int l, int r, OP op) {
add(root, l, r, 0, maxN, op);
}
private void add(Node node, int l, int r, int ls, int rs, OP op) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
apply(node, ls, rs, op);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
if (l <= mid) {
add(node.left, l, r, ls, mid, op);
}
if (r >= mid + 1) {
add(node.right, l, r, mid + 1, rs, op);
}
reduce(node, node.left, node.right, ls, rs);
}
/**
* O(n)设置初始值，但未必时间更短，因为可能不需要每个节点都创建出来
*/
void build(int[] vals) {
build(root, vals, 0, maxN);
}
private void build(Node node, int[] vals, int ls, int rs) {
if (ls==rs) {
apply(node, ls, rs, vals[ls]==1?OP.SET:OP.UNSET);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
build(node.left,vals, ls, mid);
build(node.right,vals,mid + 1, rs);
reduce(node, node.left, node.right, ls, rs);
}
void pushDown(Node node, int ls, int rs) {
int mid = ls + rs >> 1;
if (node.left == null) {
node.left = create(ls, mid);
}
if (node.right == null) {
node.right = create(mid+1, rs);
}
if (node.lazy!=null) {
apply(node.left, ls, mid, node.lazy);
apply(node.right, mid + 1, rs, node.lazy);
node.lazy = null;
}
}
private static final Node EMPTY = new Node();
private final Node sumAns=new Node();
public long sum(int l, int r) {
sumAns.sum=0;
sum(root, l, r, 0, maxN);
return sumAns.sum;
}
private void sum(Node node, int l, int r, int ls, int rs) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
reduce(sumAns, node, EMPTY, ls, rs);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
if (l <= mid) {
sum(node.left, l, r, ls, mid);
}
if (r >= mid + 1) {
sum(node.right, l, r, mid + 1, rs);
}
}
/**
* sum方法为了减少创建对象，所有[l,r]范围内覆盖节点合计(reduce)到全局对象。
* 但有些情况下必须每一层左右区间合并，比如求区间内连续1的数量，可以用此方法。
*/
public Node sumInLevel(int l, int r) {
return sumInLevel(root, l, r, 0, maxN);
}
private Node sumInLevel(Node node, int l, int r, int ls, int rs) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
return node;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
Node res = new Node(), leftRes = EMPTY, rightRes = EMPTY;
if (l <= mid) {
leftRes = sumInLevel(node.left, l, r, ls, mid);
}
if (r >= mid + 1) {
rightRes = sumInLevel(node.right, l, r, mid + 1, rs);
}
reduce(res, leftRes, rightRes, ls, rs);
return res;
}
}
public class Main {
public void solve() throws Exception {
int n=nextInt(),q=nextInt();
String s=next();
BitSegTree tree=new BitSegTree(n);
int[] vals=new int[n+1];
for (int i = 0; i < n; i++) {
vals[i]=s.charAt(i)-'0';
}
tree.build(vals);
for (int i = 0; i < q; i++) {
int c=nextInt(),l=nextInt()-1,r=nextInt()-1;
if (c==1){
tree.add(l,r, BitSegTree.OP.INV);
} else {
out.println(tree.sumInLevel(l,r).mx1);
}
}
}
public static void main(String[] args) throws Exception {
new Main().solve();
out.flush();
}
static PrintWriter out = new PrintWriter(System.out, false);
static InputReader in = new InputReader(System.in);
static String next() { return in.next(); }
static int nextInt() { return Integer.parseInt(in.next()); }
static long nextLong() { return Long.parseLong(in.next()); }
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(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();
}
}
}
|
ConDefects/ConDefects/Code/abc322_f/Java/46141057
|
condefects-java_data_867
|
// package A;
import java.util.*;
import java.io.*;
public class Main{
static final int N=(int)5e5+7;
static String s;
static int n,m;
static Node[] tr=new Node[N<<2];
private static void pu(Node t, Node l, Node r) { //对象就是传的地址
int l_len=l.r-l.l+1,r_len=r.r-r.l+1;
t.lb=(l.lb==l_len)?l.lb+r.lb:l.lb;
t.rb=(r.rb==r_len)?r.rb+l.rb:r.rb;
t.mb=Math.max(Math.max(l.mb,r.mb),l.rb+r.lb);
t.lc=(l.lc==l_len)?l.lc+r.lc:l.lc;
t.rc=(r.rc==r_len)?r.rc+l.rc:r.rc;
t.mc=Math.max(Math.max(l.mc,r.mc),l.rc+r.lc);
}
static void pushup(int u){
pu(tr[u],tr[u<<1],tr[u<<1|1]);
}
static void pd(Node s){
int t=s.lb; s.lb=s.lc; s.lc=t;
t=s.rb; s.rb=s.rc; s.rc=t;
t=s.mb; s.mb=s.mc; s.mc=t;
s.rev^=1;
}
static void pushdown(int u){
if(tr[u].rev==0) return;
pd(tr[u<<1]); pd(tr[u<<1|1]);
tr[u].rev=0;
}
static void build(int u,int l,int r){
int t=s.charAt(l)-'0';
tr[u]=new Node(l,r,t,t,t,t^1,t^1,t^1,0);
if(l==r) return;
int mid=(l+r)>>1;
build(u<<1,l,mid); build(u<<1|1,mid+1,r);
pushup(u);
}
static void modify(int u,int l,int r){
if(tr[u].l>r||tr[u].r<l) return;
if(l<=tr[u].l&&tr[u].r<=r) pd(tr[u]);
else{
pushdown(u);
modify(u<<1,l,r); modify(u<<1|1,l,r);
pushup(u);
}
}
static Node query(int u,int l,int r){
if(l<=tr[u].l&&tr[u].r<=r) return tr[u];
pushdown(u);
int mid=(tr[u].l+tr[u].r)>>1;
if(mid<l) return query(u<<1|1,l,r);
if(r<=mid) return query(u<<1,l,r);
Node left=query(u<<1,l,r),right=query(u<<1|1,l,r);
Node res=new Node(); pu(res,left,right);
return res;
}
public static void solve()throws IOException{
// String[] str=br.readLine().split(" ");
// n=Integer.parseInt(str[0]); m=Integer.parseInt(str[1]);
n=nextInt(); m=nextInt(); //此时数据没有空格，有空格的话要用br.readLine()
s=br.readLine(); s=" "+s;
System.out.println(s);
build(1,1,n);
for(int i=0;i<m;i++){
// str=br.readLine().split(" ");
// int opt=Integer.parseInt(str[0]),l=Integer.parseInt(str[1]),r=Integer.parseInt(str[2]);
int opt=nextInt(),l=nextInt(),r=nextInt();
if(opt==1) modify(1,l,r);
else pw.println(query(1,l,r).mb);
}
pw.flush();
}
public static void main(String[] args)throws IOException{
int T=1;
// T=nextInt();
while(T-->0){
solve();
}
}
static Scanner sc=new Scanner(System.in);
//这个读字符串可以带有空格，br.readLine(),不用刷新缓存区
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//读字符串时空格，回车，换行都进行分割
static StreamTokenizer st = new StreamTokenizer(br);
//pw.println(),没写一次记得刷新缓存区pw.flush()
static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
public static int nextInt() throws IOException { st.nextToken(); return (int)st.nval; }
public static long nextLong() throws IOException { st.nextToken(); return (long)st.nval; }
public static float nextFloat() throws IOException{ st.nextToken(); return (float)st.nval; }
public static double nextDouble() throws IOException{ st.nextToken(); return st.nval; }
public static String next() throws IOException{ st.nextToken(); return st.sval;}
}
class Node{
int l,r;
int lb,rb,mb,lc,rc,mc;
int rev;
public Node(){}
public Node(int l, int r, int lb, int rb, int tb, int lc, int rc, int tc, int rev) {
this.l = l;
this.r = r;
this.lb = lb;
this.rb = rb;
this.mb = tb;
this.lc = lc;
this.rc = rc;
this.mc = tc;
this.rev = rev;
}
}
// package A;
import java.util.*;
import java.io.*;
public class Main{
static final int N=(int)5e5+7;
static String s;
static int n,m;
static Node[] tr=new Node[N<<2];
private static void pu(Node t, Node l, Node r) { //对象就是传的地址
int l_len=l.r-l.l+1,r_len=r.r-r.l+1;
t.lb=(l.lb==l_len)?l.lb+r.lb:l.lb;
t.rb=(r.rb==r_len)?r.rb+l.rb:r.rb;
t.mb=Math.max(Math.max(l.mb,r.mb),l.rb+r.lb);
t.lc=(l.lc==l_len)?l.lc+r.lc:l.lc;
t.rc=(r.rc==r_len)?r.rc+l.rc:r.rc;
t.mc=Math.max(Math.max(l.mc,r.mc),l.rc+r.lc);
}
static void pushup(int u){
pu(tr[u],tr[u<<1],tr[u<<1|1]);
}
static void pd(Node s){
int t=s.lb; s.lb=s.lc; s.lc=t;
t=s.rb; s.rb=s.rc; s.rc=t;
t=s.mb; s.mb=s.mc; s.mc=t;
s.rev^=1;
}
static void pushdown(int u){
if(tr[u].rev==0) return;
pd(tr[u<<1]); pd(tr[u<<1|1]);
tr[u].rev=0;
}
static void build(int u,int l,int r){
int t=s.charAt(l)-'0';
tr[u]=new Node(l,r,t,t,t,t^1,t^1,t^1,0);
if(l==r) return;
int mid=(l+r)>>1;
build(u<<1,l,mid); build(u<<1|1,mid+1,r);
pushup(u);
}
static void modify(int u,int l,int r){
if(tr[u].l>r||tr[u].r<l) return;
if(l<=tr[u].l&&tr[u].r<=r) pd(tr[u]);
else{
pushdown(u);
modify(u<<1,l,r); modify(u<<1|1,l,r);
pushup(u);
}
}
static Node query(int u,int l,int r){
if(l<=tr[u].l&&tr[u].r<=r) return tr[u];
pushdown(u);
int mid=(tr[u].l+tr[u].r)>>1;
if(mid<l) return query(u<<1|1,l,r);
if(r<=mid) return query(u<<1,l,r);
Node left=query(u<<1,l,r),right=query(u<<1|1,l,r);
Node res=new Node(); pu(res,left,right);
return res;
}
public static void solve()throws IOException{
// String[] str=br.readLine().split(" ");
// n=Integer.parseInt(str[0]); m=Integer.parseInt(str[1]);
n=nextInt(); m=nextInt(); //此时数据没有空格，有空格的话要用br.readLine()
s=br.readLine(); s=" "+s;
// System.out.println(s);
build(1,1,n);
for(int i=0;i<m;i++){
// str=br.readLine().split(" ");
// int opt=Integer.parseInt(str[0]),l=Integer.parseInt(str[1]),r=Integer.parseInt(str[2]);
int opt=nextInt(),l=nextInt(),r=nextInt();
if(opt==1) modify(1,l,r);
else pw.println(query(1,l,r).mb);
}
pw.flush();
}
public static void main(String[] args)throws IOException{
int T=1;
// T=nextInt();
while(T-->0){
solve();
}
}
static Scanner sc=new Scanner(System.in);
//这个读字符串可以带有空格，br.readLine(),不用刷新缓存区
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//读字符串时空格，回车，换行都进行分割
static StreamTokenizer st = new StreamTokenizer(br);
//pw.println(),没写一次记得刷新缓存区pw.flush()
static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
public static int nextInt() throws IOException { st.nextToken(); return (int)st.nval; }
public static long nextLong() throws IOException { st.nextToken(); return (long)st.nval; }
public static float nextFloat() throws IOException{ st.nextToken(); return (float)st.nval; }
public static double nextDouble() throws IOException{ st.nextToken(); return st.nval; }
public static String next() throws IOException{ st.nextToken(); return st.sval;}
}
class Node{
int l,r;
int lb,rb,mb,lc,rc,mc;
int rev;
public Node(){}
public Node(int l, int r, int lb, int rb, int tb, int lc, int rc, int tc, int rev) {
this.l = l;
this.r = r;
this.lb = lb;
this.rb = rb;
this.mb = tb;
this.lc = lc;
this.rc = rc;
this.mc = tc;
this.rev = rev;
}
}
|
ConDefects/ConDefects/Code/abc322_f/Java/50432678
|
condefects-java_data_868
|
import java.util.*;
import java.io.*;
class BitSegTree {
static NodePool TMP_POOL = new NodePool();
static class NodePool {
int i = 1;
//数量有限，只能用作一次性临时变量，递归时要后序获取
Node[] pool = new Node[5];
public NodePool() {
for (int j = 0; j < pool.length; j++) {
pool[j] = new Node();
}
pool[0].init(0, -1);
}
Node immutableEmpty() {
return pool[0];
}
Node next(int ls, int rs) {
Node ret = pool[i++];
ret.init(ls, rs);
if (i == pool.length) i = 1;
return ret;
}
}
static class Node {
Node left;
Node right;
long sum;
int ls, rs;//debug用
OP lazy;
int l0,r0,mx0;//左端连续0，右端连续0，区间连续0
int l1,r1,mx1;//左端连续1，右端连续1，区间连续1
void init(int ls, int rs) {
this.ls = ls;
this.rs = rs;
this.l0=this.r0=this.mx0=rs-ls+1;
this.l1=this.r1=this.mx1=0;
}
int len() {
return rs-ls+1;
}
}
enum OP {
SET,
UNSET,
INV
}
int maxN;
Node root;
public BitSegTree(int maxN) {
this.maxN = maxN;
this.root = new Node();
this.root.init(0, maxN);
}
void reduce(Node node, Node left, Node right) {
node.sum = left.sum + right.sum;
node.mx0 =Math.max(left.r0+right.l0, Math.max(left.mx0, right.mx0));
node.l0=(left.l0==left.len())?left.l0+right.l0:left.l0;
node.r0=(right.r0==right.len())?right.r0+left.r0:right.r0;
node.mx1 =Math.max(left.r1+right.l1, Math.max(left.mx1, right.mx1));
node.l1=(left.l1==left.len())?left.l1+right.l1:left.l1;
node.r1=(right.r1==right.len())?right.r1+left.r1:right.r1;
}
void apply(Node node, int ls, int rs, OP op) {
if (op == OP.INV) {
if (node.lazy == OP.SET) {
op = OP.UNSET;
} else if (node.lazy == OP.UNSET) {
op = OP.SET;
}
}
node.lazy = (node.lazy == OP.INV && op == OP.INV) ? null : op;
if (op == OP.SET) {
node.l0=node.r0=node.mx0 =0;
node.l1=node.r1=node.mx1 =rs-ls+1;
node.sum = (rs - ls + 1);
} else if (op == OP.UNSET) {
node.l0=node.r0=node.mx0 =rs-ls+1;
node.l1=node.r1=node.mx1 =0;
node.sum = 0;
} else if (op == OP.INV) {
int lt=node.l0,rt=node.r0,mt=node.mx0;
node.l0=node.l1;node.r0=node.r1;node.mx0 =node.mx1;
node.l1=lt;node.r1=rt;node.mx1 =mt;
node.sum = (rs - ls + 1) - node.sum;
}
}
public void add(int l, int r, OP op) {
add(root, l, r, 0, maxN, op);
}
private void add(Node node, int l, int r, int ls, int rs, OP op) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
apply(node, ls, rs, op);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
if (l <= mid) {
add(node.left, l, r, ls, mid, op);
}
if (r >= mid + 1) {
add(node.right, l, r, mid + 1, rs, op);
}
reduce(node, node.left, node.right);
}
void pushDown(Node node, int ls, int rs) {
int mid = ls + rs >> 1;
if (node.left == null) {
node.left = new Node();
node.left.init(ls, mid);
}
if (node.right == null) {
node.right = new Node();
node.right.init(mid+1, rs);
}
if (node.lazy!=null) {
// 1 如果有多种懒操作变量，注意下传顺序，以及下传后的重置
// 2 lazyVal会累积，即使每次add都是val==1，下传的时候lazyVal也会>1
apply(node.left, ls, mid, node.lazy);
apply(node.right, mid + 1, rs, node.lazy);
node.lazy = null;
}
}
public Node query(int l, int r) {
return query(root, l, r, 0, maxN);
}
private static final Node EMPTY = new Node();
static {
EMPTY.init(0, -1);
}
private Node query(Node node, int l, int r, int ls, int rs) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
return node;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
Node left, right;
left = right = EMPTY;
if (l <= mid) {
left = query(node.left, l, r, ls, mid);
}
if (r >= mid + 1) {
right = query(node.right, l, r, mid + 1, rs);
}
Node ret = TMP_POOL.next(Math.max(ls, l), Math.min(rs, r));
reduce(ret, left, right);
return ret;
}
}
public class Main {
public void solve() throws Exception {
int n=nextInt(),q=nextInt();
String s=next();
BitSegTree tree=new BitSegTree(n);
for (int i = 0; i < n; i++) {
if (s.charAt(i)=='1'){
tree.add(i,i, BitSegTree.OP.SET);
}
//vals[i]=s.charAt(i)-'0';
}
for (int i = 0; i < q; i++) {
int c=nextInt(),l=nextInt()-1,r=nextInt()-1;
if (c==1){
tree.add(l,r, BitSegTree.OP.INV);
} else {
out.println(tree.query(l,r).mx1);
}
}
}
public static void main(String[] args) throws Exception {
new Main().solve();
out.flush();
}
static PrintWriter out = new PrintWriter(System.out, false);
static InputReader in = new InputReader(System.in);
static String next() { return in.next(); }
static int nextInt() { return Integer.parseInt(in.next()); }
static long nextLong() { return Long.parseLong(in.next()); }
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(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();
}
}
}
import java.util.*;
import java.io.*;
class BitSegTree {
static NodePool TMP_POOL = new NodePool();
static class NodePool {
int i = 1;
//数量有限，只能用作一次性临时变量，递归时要后序获取
Node[] pool = new Node[100];
public NodePool() {
for (int j = 0; j < pool.length; j++) {
pool[j] = new Node();
}
pool[0].init(0, -1);
}
Node immutableEmpty() {
return pool[0];
}
Node next(int ls, int rs) {
Node ret = pool[i++];
ret.init(ls, rs);
if (i == pool.length) i = 1;
return ret;
}
}
static class Node {
Node left;
Node right;
long sum;
int ls, rs;//debug用
OP lazy;
int l0,r0,mx0;//左端连续0，右端连续0，区间连续0
int l1,r1,mx1;//左端连续1，右端连续1，区间连续1
void init(int ls, int rs) {
this.ls = ls;
this.rs = rs;
this.l0=this.r0=this.mx0=rs-ls+1;
this.l1=this.r1=this.mx1=0;
}
int len() {
return rs-ls+1;
}
}
enum OP {
SET,
UNSET,
INV
}
int maxN;
Node root;
public BitSegTree(int maxN) {
this.maxN = maxN;
this.root = new Node();
this.root.init(0, maxN);
}
void reduce(Node node, Node left, Node right) {
node.sum = left.sum + right.sum;
node.mx0 =Math.max(left.r0+right.l0, Math.max(left.mx0, right.mx0));
node.l0=(left.l0==left.len())?left.l0+right.l0:left.l0;
node.r0=(right.r0==right.len())?right.r0+left.r0:right.r0;
node.mx1 =Math.max(left.r1+right.l1, Math.max(left.mx1, right.mx1));
node.l1=(left.l1==left.len())?left.l1+right.l1:left.l1;
node.r1=(right.r1==right.len())?right.r1+left.r1:right.r1;
}
void apply(Node node, int ls, int rs, OP op) {
if (op == OP.INV) {
if (node.lazy == OP.SET) {
op = OP.UNSET;
} else if (node.lazy == OP.UNSET) {
op = OP.SET;
}
}
node.lazy = (node.lazy == OP.INV && op == OP.INV) ? null : op;
if (op == OP.SET) {
node.l0=node.r0=node.mx0 =0;
node.l1=node.r1=node.mx1 =rs-ls+1;
node.sum = (rs - ls + 1);
} else if (op == OP.UNSET) {
node.l0=node.r0=node.mx0 =rs-ls+1;
node.l1=node.r1=node.mx1 =0;
node.sum = 0;
} else if (op == OP.INV) {
int lt=node.l0,rt=node.r0,mt=node.mx0;
node.l0=node.l1;node.r0=node.r1;node.mx0 =node.mx1;
node.l1=lt;node.r1=rt;node.mx1 =mt;
node.sum = (rs - ls + 1) - node.sum;
}
}
public void add(int l, int r, OP op) {
add(root, l, r, 0, maxN, op);
}
private void add(Node node, int l, int r, int ls, int rs, OP op) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
apply(node, ls, rs, op);
return;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
if (l <= mid) {
add(node.left, l, r, ls, mid, op);
}
if (r >= mid + 1) {
add(node.right, l, r, mid + 1, rs, op);
}
reduce(node, node.left, node.right);
}
void pushDown(Node node, int ls, int rs) {
int mid = ls + rs >> 1;
if (node.left == null) {
node.left = new Node();
node.left.init(ls, mid);
}
if (node.right == null) {
node.right = new Node();
node.right.init(mid+1, rs);
}
if (node.lazy!=null) {
// 1 如果有多种懒操作变量，注意下传顺序，以及下传后的重置
// 2 lazyVal会累积，即使每次add都是val==1，下传的时候lazyVal也会>1
apply(node.left, ls, mid, node.lazy);
apply(node.right, mid + 1, rs, node.lazy);
node.lazy = null;
}
}
public Node query(int l, int r) {
return query(root, l, r, 0, maxN);
}
private static final Node EMPTY = new Node();
static {
EMPTY.init(0, -1);
}
private Node query(Node node, int l, int r, int ls, int rs) {
if (l < 0 || r > maxN) {
throw new IllegalArgumentException();
}
if (l <= ls && rs <= r) {
return node;
}
pushDown(node, ls, rs);
int mid = ls + rs >> 1;
Node left, right;
left = right = EMPTY;
if (l <= mid) {
left = query(node.left, l, r, ls, mid);
}
if (r >= mid + 1) {
right = query(node.right, l, r, mid + 1, rs);
}
Node ret = TMP_POOL.next(Math.max(ls, l), Math.min(rs, r));
reduce(ret, left, right);
return ret;
}
}
public class Main {
public void solve() throws Exception {
int n=nextInt(),q=nextInt();
String s=next();
BitSegTree tree=new BitSegTree(n);
for (int i = 0; i < n; i++) {
if (s.charAt(i)=='1'){
tree.add(i,i, BitSegTree.OP.SET);
}
//vals[i]=s.charAt(i)-'0';
}
for (int i = 0; i < q; i++) {
int c=nextInt(),l=nextInt()-1,r=nextInt()-1;
if (c==1){
tree.add(l,r, BitSegTree.OP.INV);
} else {
out.println(tree.query(l,r).mx1);
}
}
}
public static void main(String[] args) throws Exception {
new Main().solve();
out.flush();
}
static PrintWriter out = new PrintWriter(System.out, false);
static InputReader in = new InputReader(System.in);
static String next() { return in.next(); }
static int nextInt() { return Integer.parseInt(in.next()); }
static long nextLong() { return Long.parseLong(in.next()); }
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(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();
}
}
}
|
ConDefects/ConDefects/Code/abc322_f/Java/51734223
|
condefects-java_data_869
|
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
class UnionFind {
private int n;
private int[] parents;
UnionFind(int n){
this.n = n;
parents = new int[n];
Arrays.fill(parents,-1);
}
public int find(int x){
if (this.parents[x] < 0){
return x;
} else {
this.parents[x] = find(this.parents[x]);
return this.parents[x];
}
}
public void union(int a, int b){
a = find(a);
b = find(b);
if (a == b){
;
} else {
if (this.parents[a] > this.parents[b]){
int tmp = a;
a = b;
b = tmp;
}
this.parents[a] += this.parents[b];
this.parents[b] = a;
}
}
public int size(int x){
return -this.parents[find(x)];
}
public boolean same(int x, int y){
return find(x) == find(y);
}
public ArrayList<Integer> members(int x) {
int root = find(x);
ArrayList<Integer> re = new ArrayList<Integer>();
for (int i=0; i<n; i++){
if (find(i) == root){
re.add(i);
}
}
return re;
}
public ArrayList<Integer> roots(){
ArrayList<Integer> re = new ArrayList<Integer>();
for (int i=0; i<n; i++){
if (parents[i] < 0){
re.add(i);
}
}
return re;
}
public int groupCount(){
return this.roots().size();
}
}
class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
int[][] roads = new int[M][];
int[][] AList = new int[M][];
for (int i=0; i<M; i++){
int K = scanner.nextInt();
int C = scanner.nextInt();
int[] A = new int[K];
for (int j=0; j<K; j++){
A[j] = scanner.nextInt();
}
int[] tmp = {C,K,i};
roads[i] = tmp;
AList[i] = A;
}
Arrays.sort(roads, (a,b) -> a[0] - b[0]);
int ans = 0;
UnionFind uf = new UnionFind(N);
for (int[] road : roads){
int cost = road[0];
int amount = road[1];
int[] roadList = AList[road[2]];
for (int i=0; i<amount-1; i++){
if (uf.same(roadList[i]-1,roadList[i+1]-1) == false){
uf.union(roadList[i]-1,roadList[i+1]-1);
ans += cost;
}
}
}
if (uf.groupCount() == 1){
System.out.println(ans);
} else {
System.out.println(-1);
}
}
}
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
class UnionFind {
private int n;
private int[] parents;
UnionFind(int n){
this.n = n;
parents = new int[n];
Arrays.fill(parents,-1);
}
public int find(int x){
if (this.parents[x] < 0){
return x;
} else {
this.parents[x] = find(this.parents[x]);
return this.parents[x];
}
}
public void union(int a, int b){
a = find(a);
b = find(b);
if (a == b){
;
} else {
if (this.parents[a] > this.parents[b]){
int tmp = a;
a = b;
b = tmp;
}
this.parents[a] += this.parents[b];
this.parents[b] = a;
}
}
public int size(int x){
return -this.parents[find(x)];
}
public boolean same(int x, int y){
return find(x) == find(y);
}
public ArrayList<Integer> members(int x) {
int root = find(x);
ArrayList<Integer> re = new ArrayList<Integer>();
for (int i=0; i<n; i++){
if (find(i) == root){
re.add(i);
}
}
return re;
}
public ArrayList<Integer> roots(){
ArrayList<Integer> re = new ArrayList<Integer>();
for (int i=0; i<n; i++){
if (parents[i] < 0){
re.add(i);
}
}
return re;
}
public int groupCount(){
return this.roots().size();
}
}
class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
int[][] roads = new int[M][];
int[][] AList = new int[M][];
for (int i=0; i<M; i++){
int K = scanner.nextInt();
int C = scanner.nextInt();
int[] A = new int[K];
for (int j=0; j<K; j++){
A[j] = scanner.nextInt();
}
int[] tmp = {C,K,i};
roads[i] = tmp;
AList[i] = A;
}
Arrays.sort(roads, (a,b) -> a[0] - b[0]);
long ans = 0;
UnionFind uf = new UnionFind(N);
for (int[] road : roads){
int cost = road[0];
int amount = road[1];
int[] roadList = AList[road[2]];
for (int i=0; i<amount-1; i++){
if (uf.same(roadList[i]-1,roadList[i+1]-1) == false){
uf.union(roadList[i]-1,roadList[i+1]-1);
ans += cost;
}
}
}
if (uf.groupCount() == 1){
System.out.println(ans);
} else {
System.out.println(-1);
}
}
}
|
ConDefects/ConDefects/Code/abc352_e/Java/53261141
|
condefects-java_data_870
|
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
for(int x=0;x<=N;x++){
for(int y=0;y<=N;y++){
for(int z=0;z<=N;z++){
if(x+y+z<=N)System.out.println(x+""+y+""+z);
}
}
}
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
for(int x=0;x<=N;x++){
for(int y=0;y<=N;y++){
for(int z=0;z<=N;z++){
if(x+y+z<=N)System.out.println(x+" "+y+" "+z);
}
}
}
}
}
|
ConDefects/ConDefects/Code/abc335_b/Java/54021966
|
condefects-java_data_871
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) {
for (int k = 0; k <= N; k++) {
if(i+j+k!=N)continue;
out.println(i+ " "+j+" "+k);
}
}
}
}
public static void main(final String[] args) {
PrintWriter out = new PrintWriter(System.out);
FastScanner scanner = new FastScanner();
try {
run(scanner, out);
} catch (Throwable e) {
throw e;
} finally {
out.flush();
}
}
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;}
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.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) {
for (int k = 0; k <= N; k++) {
if(i+j+k>N)continue;
out.println(i+ " "+j+" "+k);
}
}
}
}
public static void main(final String[] args) {
PrintWriter out = new PrintWriter(System.out);
FastScanner scanner = new FastScanner();
try {
run(scanner, out);
} catch (Throwable e) {
throw e;
} finally {
out.flush();
}
}
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;}
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/abc335_b/Java/52825676
|
condefects-java_data_872
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
for (int x = 0; x<=a; x++) {
for (int y=0; y <=a-x; y ++) {
for(int z = 0; z <=a - x - y; z ++) {
System.out.println( x+","+ y+","+ z);
}
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
for (int x = 0; x<=a; x++) {
for (int y=0; y <=a-x; y ++) {
for(int z = 0; z <=a - x - y; z ++) {
System.out.println( x+" "+y+" "+z);
}
}
}
}
}
|
ConDefects/ConDefects/Code/abc335_b/Java/50222898
|
condefects-java_data_873
|
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
PrintWriter pw = new PrintWriter(System.out);
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < n - i + 1; j++) {
for (int k = 0; k < n - k - i + 1; k++) {
pw.println(String.valueOf(i) + " " + String.valueOf(j) + " " + String.valueOf(k));
}
}
}
pw.flush();
}
}
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
PrintWriter pw = new PrintWriter(System.out);
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < n - i + 1; j++) {
for (int k = 0; k < n - j - i + 1; k++) {
pw.println(String.valueOf(i) + " " + String.valueOf(j) + " " + String.valueOf(k));
}
}
}
pw.flush();
}
}
|
ConDefects/ConDefects/Code/abc335_b/Java/54452004
|
condefects-java_data_874
|
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(2*n);
List<Integer> a = new ArrayList<>();
for (; n >= 4; n -= 4) a.add(4);
if (n > 0) a.add(0, n);
for (int x : a) {
System.out.print(x+" ");
}
System.out.println();
}
}
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(2*n);
List<Integer> a = new ArrayList<>();
for (; n >= 4; n -= 4) a.add(4);
if (n > 0) a.add(0, n);
for (int x : a) {
System.out.print(x);
}
System.out.println();
}
}
|
ConDefects/ConDefects/Code/arc144_a/Java/33285460
|
condefects-java_data_875
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
String s = "wbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbw";
int n = s.length();
Scanner scanner = new Scanner(System.in);
int w = scanner.nextInt();
int b = scanner.nextInt();
int cw = 0, cb = 0;
for(int i=0;i<w+b;i++) {
if(s.charAt(i) == 'w') {
cw++;
} else {
cb++;
}
}
boolean ans = false;
if(cw == w && cb == b) {
ans = true;
}
for(int i=0;i<300;i++) {
if(s.charAt(i) == 'w') {
cw--;
} else {
cb--;
}
if(s.charAt(+b+w) == 'w') {
cw++;
} else {
cb++;
}
if(cw == w && cb == b) {
ans = true;
break;
}
}
if(ans) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
String s = "wbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbwwbwbwwbwbwbw";
int n = s.length();
Scanner scanner = new Scanner(System.in);
int w = scanner.nextInt();
int b = scanner.nextInt();
int cw = 0, cb = 0;
for(int i=0;i<w+b;i++) {
if(s.charAt(i) == 'w') {
cw++;
} else {
cb++;
}
}
boolean ans = false;
if(cw == w && cb == b) {
ans = true;
}
for(int i=0;i<300;i++) {
if(s.charAt(i) == 'w') {
cw--;
} else {
cb--;
}
if(s.charAt(i+b+w) == 'w') {
cw++;
} else {
cb++;
}
if(cw == w && cb == b) {
ans = true;
break;
}
}
if(ans) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc346_b/Java/52271816
|
condefects-java_data_876
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int w = scanner.nextInt();
int b = scanner.nextInt();
if ( 0 == b )
{
if ( 0 <= w && w <= 2)
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
}
else
{
int odd = b % 5;
int base = 7 * (b / 5);
switch (odd) {
case 0:
if ( 5 + base <= w && w <= 9 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 1:
if ( base <= w && w <= 3 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 2:
if ( 1 + base <= w && w <= 5 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 3:
if ( 2 + base <= w && w <= 6 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 4:
if ( 4 + base <= w && w <= 7 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
}
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int w = scanner.nextInt();
int b = scanner.nextInt();
if ( 0 == b )
{
if ( 0 <= w && w <= 2)
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
}
else
{
int odd = b % 5;
int base = 7 * ( (b - 1) / 5);
switch (odd) {
case 0:
if ( 5 + base <= w && w <= 9 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 1:
if ( base <= w && w <= 3 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 2:
if ( 1 + base <= w && w <= 5 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 3:
if ( 2 + base <= w && w <= 6 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
case 4:
if ( 4 + base <= w && w <= 7 + base )
{
System.out.println( "Yes" );
}
else
{
System.out.println( "No" );
}
break;
}
}
}
}
|
ConDefects/ConDefects/Code/abc346_b/Java/52961519
|
condefects-java_data_877
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int w = sc.nextInt();
int b = sc.nextInt();
String wb = "wbwbwwbwbwbw", s = "";
for(int i = 0; i < 20; i++) s += wb;
int sl = s.length();
for(int i = 0; i < sl; i++){
for(int j = i+1; j < sl; j++){
int wnum = 0, bnum = 0;
for(int k = i; k < j+1; k++){
if(s.charAt(k) == 'w') wnum++;
else bnum++;
}
if(wnum == w && bnum == b){
System.out.println("Yes");
return;
}
}
}
System.out.println("No");
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int w = sc.nextInt();
int b = sc.nextInt();
String wb = "wbwbwwbwbwbw", s = "";
for(int i = 0; i < 20; i++) s += wb;
int sl = s.length();
for(int i = 0; i < sl; i++){
for(int j = i; j < sl; j++){
int wnum = 0, bnum = 0;
for(int k = i; k < j+1; k++){
if(s.charAt(k) == 'w') wnum++;
else bnum++;
}
if(wnum == w && bnum == b){
System.out.println("Yes");
return;
}
}
}
System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc346_b/Java/52943371
|
condefects-java_data_878
|
import java.io.*;
import java.util.*;
public class Main {
private static void tc() {
int p=998244353;
int n=io.nextInt(),m=io.nextInt(),k=io.nextInt();
long []f=new long[k+1];f[0]=1;
for(int i=0;i<n;i++) {
int up=Math.min(k,m*(i+1));
long s=0;for(int j=up-m+1;j<=up;j++)s+=f[j];
for(int j=up;j>=0;j--){
s+=j-m>=0?f[j-m]:0;
s-=f[j];f[j]=s;
}
}
io.println(Arrays.stream(f).sum()%p);
}
public static void main(String[] args) {
boolean fm=false;//fm=true;
try{io=fm?new Kattio(new FileInputStream(p("input.txt"))):new Kattio();}catch (FileNotFoundException e) {e.printStackTrace();}
int n=fm?io.nextInt():1;for(int i=0;i<n;i++)tc();io.flush();io.close();
}
private static Kattio io=null;
public static File p(String a){return new File(Main.class.getResource("").getPath()+a);}
public static class Kattio extends PrintWriter{
BufferedReader r;StringTokenizer st;
public Kattio(){this(System.in,System.out);}
public Kattio(FileInputStream f){this(f,System.out);}
public Kattio(InputStream i,OutputStream o){super(o);r=new BufferedReader(new InputStreamReader(i));}
public Kattio(String intput, String output)throws IOException{super(output);r=new BufferedReader(new FileReader(intput));}
public String next(){try{while(st==null||!st.hasMoreTokens())st=new StringTokenizer(r.readLine());return st.nextToken();}catch(Exception e){}return null;}
public int nextInt(){return Integer.parseInt(next());}
public double nextDouble(){return Double.parseDouble(next());}
public long nextLong(){return Long.parseLong(next());}
}
}
import java.io.*;
import java.util.*;
public class Main {
private static void tc() {
int p=998244353;
int n=io.nextInt(),m=io.nextInt(),k=io.nextInt();
long []f=new long[k+1];f[0]=1;
for(int i=0;i<n;i++) {
int up=Math.min(k,m*(i+1));
long s=0;for(int j=up-m+1;j<=up;j++)s+=f[j];
for(int j=up;j>=0;j--){
s+=j-m>=0?f[j-m]:0;
s-=f[j];f[j]=(s+p)%p;
}
}
io.println(Arrays.stream(f).sum()%p);
}
public static void main(String[] args) {
boolean fm=false;//fm=true;
try{io=fm?new Kattio(new FileInputStream(p("input.txt"))):new Kattio();}catch (FileNotFoundException e) {e.printStackTrace();}
int n=fm?io.nextInt():1;for(int i=0;i<n;i++)tc();io.flush();io.close();
}
private static Kattio io=null;
public static File p(String a){return new File(Main.class.getResource("").getPath()+a);}
public static class Kattio extends PrintWriter{
BufferedReader r;StringTokenizer st;
public Kattio(){this(System.in,System.out);}
public Kattio(FileInputStream f){this(f,System.out);}
public Kattio(InputStream i,OutputStream o){super(o);r=new BufferedReader(new InputStreamReader(i));}
public Kattio(String intput, String output)throws IOException{super(output);r=new BufferedReader(new FileReader(intput));}
public String next(){try{while(st==null||!st.hasMoreTokens())st=new StringTokenizer(r.readLine());return st.nextToken();}catch(Exception e){}return null;}
public int nextInt(){return Integer.parseInt(next());}
public double nextDouble(){return Double.parseDouble(next());}
public long nextLong(){return Long.parseLong(next());}
}
}
|
ConDefects/ConDefects/Code/abc248_c/Java/45457782
|
condefects-java_data_879
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
int MOD = 998255353;
long[] f = new long[k + 1];
f[0] = 1;
long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = k; j >= 0; j--) {
f[j] = 0;
for (int l = 1; l <= j && l <= m; l++) {
f[j] = (f[j] + f[j - l]) % MOD;
}
}
}
for (int j = 0; j <= k; j++) {
ans = (ans + f[j]) % MOD;
}
System.out.println(ans);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
int MOD = 998244353;
long[] f = new long[k + 1];
f[0] = 1;
long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = k; j >= 0; j--) {
f[j] = 0;
for (int l = 1; l <= j && l <= m; l++) {
f[j] = (f[j] + f[j - l]) % MOD;
}
}
}
for (int j = 0; j <= k; j++) {
ans = (ans + f[j]) % MOD;
}
System.out.println(ans);
}
}
|
ConDefects/ConDefects/Code/abc248_c/Java/45484832
|
condefects-java_data_880
|
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
class Main {
static void solve (Scanner in, PrintWriter out) {
int v = in.nextInt(), a = in.nextInt(), b = in.nextInt(), c = in.nextInt();
v = v % (a+b+c);
// out.println(v);
if (v - a < 0) {
out.println("F");
}
v -= a;
if (v - b < 0) {
out.println("M");
}
v -= b;
out.println("T");
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
solve(in, out);
in.close();
out.close();
}
}
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
class Main {
static void solve (Scanner in, PrintWriter out) {
int v = in.nextInt(), a = in.nextInt(), b = in.nextInt(), c = in.nextInt();
v = v % (a+b+c);
// out.println(v);
if (v - a < 0) {
out.println("F");
return;
}
v -= a;
if (v - b < 0) {
out.println("M");
return;
}
v -= b;
out.println("T");
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
solve(in, out);
in.close();
out.close();
}
}
|
ConDefects/ConDefects/Code/abc243_a/Java/37233525
|
condefects-java_data_881
|
import java.util.Scanner;
public class Main {
//5. 아버지, 어머니, 다카하시의 차례로 목욕을 하고, 각각 A, B, C ml의 샴푸를 사용한다.
// 오늘 아침, 그 병에는 V ml의 샴푸가 들어있었다. 리필하지 않고, 머리를 감을 샴푸가 가장 먼저 부족하게 될 사람은 누구인가?
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String row = scan.nextLine();
int shampoo = Integer.parseInt(row.split(" ")[0]);
int a = Integer.parseInt(row.split(" ")[1]);
int b = Integer.parseInt(row.split(" ")[2]);
int c = Integer.parseInt(row.split(" ")[3]);
int result = shampoo % (a+b+c);
System.out.println(result);
if(result < a || result == 0) {
System.out.println("F");
} else if(result < a+b || result == a) {
System.out.println("M");
}else if(result >= a+b && result < a+b+c) {
System.out.println("T");
}
}
}
import java.util.Scanner;
public class Main {
//5. 아버지, 어머니, 다카하시의 차례로 목욕을 하고, 각각 A, B, C ml의 샴푸를 사용한다.
// 오늘 아침, 그 병에는 V ml의 샴푸가 들어있었다. 리필하지 않고, 머리를 감을 샴푸가 가장 먼저 부족하게 될 사람은 누구인가?
// 머리를 감을 샴푸가 가장 먼저 부족하게 될 사람이 다카하시의 아버지라면 F를, 다카하시의 어머니라면 M을, 다카하시라면 T를 인쇄한다
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String row = scan.nextLine();
int shampoo = Integer.parseInt(row.split(" ")[0]);
int a = Integer.parseInt(row.split(" ")[1]);
int b = Integer.parseInt(row.split(" ")[2]);
int c = Integer.parseInt(row.split(" ")[3]);
int result = shampoo % (a+b+c);
if(result < a || result == 0) {
System.out.println("F");
} else if(result < a+b || result == a) {
System.out.println("M");
}else if(result >= a+b && result < a+b+c) {
System.out.println("T");
}
}
}
|
ConDefects/ConDefects/Code/abc243_a/Java/35826878
|
condefects-java_data_882
|
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) throws IOException {
FastReader in = new FastReader();
// -------入力の読み取り-----
int m = in.nextInt();
int c = in.nextInt();
int[] n = new int [c];
int [][] nn = new int[c][c];
for(int i = 0; i < c; i++){
n[i] = in.nextInt();
nn[i][0] = n[i];
nn[i][1] = i;
}
boolean [][] box = new boolean [m][c];
for(int i = 0; i < m; i++){
char[] s = in.next().toCharArray();
for(int j = 0; j < c; j++){
if(s[j] == 'o'){
box[i][j] = true;
}
}
}
// -----readerを閉じる------
in.close();
// ----------処理-----------
sortii(nn, 0);
int[]sc = new int [m];
int max = 0;
for(int i = 0; i < m; i++){
int a = i + 1;
for(int j = 0; j < c; j++){
if(box[i][j]){
a += n[j];
}
}
if(a > max){
max = a;
}
sc[i] = a;
}
for(int i = 0; i < m; i++){
int ans = 0;
if(sc[i] == max){
System.out.println(0);
continue;
}
int b = sc[i];
for(int j = c - 1; j >= 0; j--){
if(box[i][nn[j][1]] == false){
b += n[j];
ans++;
}
if(b > max){
break;
}
}
System.out.println(ans);
}
// ----------出力----------
//System.out.println(ans);
}
// ----------------------以下メソッド--------------------------
public static String yorn(boolean flag) {
// trueならYes、falseならNoを返す
String answer;
if (flag) {
answer = "Yes";
} else {
answer = "No";
}
return answer;
}
public static void dfs (int pos, ArrayList<ArrayList<Integer>> g, boolean[] seen){
//深さ優先探索 訪問済みの区間をtrueにした配列を返す
seen[pos] = true;
for (int i : g.get(pos)) {
if (seen[i] == false) {
dfs(i, g, seen);
}
}
}
static List<Integer> int2List(int[] arr) {
List<Integer> list = new ArrayList<>();
for (int i : arr) {
list.add(i);
}
Collections.sort(list);
return list;
}
public static int[][] sortii (int [][] n, int target){
//二次元配列をtarget行の値で昇順にソート
Arrays.sort(n, (x, y) -> Integer.compare(x[target], y[target]));
return n;
}
public static int[][] sortll(int[][] n, int target){
// 二次元配列をtarget行の値で降順にソート
Arrays.sort(n, (x, y) -> Integer.compare(y[target], x[target]));
return n;
}
}
class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next(){
while (st == null || !st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
}
catch (IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try{
str = br.readLine();
}
catch (IOException e){
e.printStackTrace();
}
return str;
}
void close() throws IOException{
br.close();
}
}
import java.util.*;
import java.io.*;
class Main {
public static void main(String[] args) throws IOException {
FastReader in = new FastReader();
// -------入力の読み取り-----
int m = in.nextInt();
int c = in.nextInt();
int[] n = new int [c];
int [][] nn = new int[c][c];
for(int i = 0; i < c; i++){
n[i] = in.nextInt();
nn[i][0] = n[i];
nn[i][1] = i;
}
boolean [][] box = new boolean [m][c];
for(int i = 0; i < m; i++){
char[] s = in.next().toCharArray();
for(int j = 0; j < c; j++){
if(s[j] == 'o'){
box[i][j] = true;
}
}
}
// -----readerを閉じる------
in.close();
// ----------処理-----------
sortii(nn, 0);
int[]sc = new int [m];
int max = 0;
for(int i = 0; i < m; i++){
int a = i + 1;
for(int j = 0; j < c; j++){
if(box[i][j]){
a += n[j];
}
}
if(a > max){
max = a;
}
sc[i] = a;
}
for(int i = 0; i < m; i++){
int ans = 0;
if(sc[i] == max){
System.out.println(0);
continue;
}
int b = sc[i];
for(int j = c - 1; j >= 0; j--){
if(box[i][nn[j][1]] == false){
b += nn[j][0];
ans++;
}
if(b > max){
break;
}
}
System.out.println(ans);
}
// ----------出力----------
//System.out.println(ans);
}
// ----------------------以下メソッド--------------------------
public static String yorn(boolean flag) {
// trueならYes、falseならNoを返す
String answer;
if (flag) {
answer = "Yes";
} else {
answer = "No";
}
return answer;
}
public static void dfs (int pos, ArrayList<ArrayList<Integer>> g, boolean[] seen){
//深さ優先探索 訪問済みの区間をtrueにした配列を返す
seen[pos] = true;
for (int i : g.get(pos)) {
if (seen[i] == false) {
dfs(i, g, seen);
}
}
}
static List<Integer> int2List(int[] arr) {
List<Integer> list = new ArrayList<>();
for (int i : arr) {
list.add(i);
}
Collections.sort(list);
return list;
}
public static int[][] sortii (int [][] n, int target){
//二次元配列をtarget行の値で昇順にソート
Arrays.sort(n, (x, y) -> Integer.compare(x[target], y[target]));
return n;
}
public static int[][] sortll(int[][] n, int target){
// 二次元配列をtarget行の値で降順にソート
Arrays.sort(n, (x, y) -> Integer.compare(y[target], x[target]));
return n;
}
}
class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next(){
while (st == null || !st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
}
catch (IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try{
str = br.readLine();
}
catch (IOException e){
e.printStackTrace();
}
return str;
}
void close() throws IOException{
br.close();
}
}
|
ConDefects/ConDefects/Code/abc323_c/Java/48514876
|
condefects-java_data_883
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int[][] scores = new int[m][2];
String[] str = new String[n];
for(int i = 0; i<m; i++){
scores[i][0] = i;
scores[i][1] = scanner.nextInt();;
}
long[] playerScore = new long[n];
long max = 0;
for(int i = 0; i<n; i++){
String s = scanner.next();
str[i] = s;
long score = 0;
boolean solved = false;
for(int j = 0; j<m; j++){
if(s.charAt(j)=='o'){
score += (long)scores[j][1];
solved = true;
}
}
score = score + (solved?(long)i:0);
max = Math.max(max,score);
playerScore[i] = score;
}
Arrays.sort(scores, (x, y) -> y[1] - x[1]);
for(int i = 0; i<n; i++){
int count = 0;
long initial = playerScore[i];
int k = 0;
while(initial<max){
long add = scores[k][1];
int place = scores[k][0];
if(str[i].charAt(place)=='x'){
initial += add;
count++;
}
k++;
}
System.out.println(count);
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int[][] scores = new int[m][2];
String[] str = new String[n];
for(int i = 0; i<m; i++){
scores[i][0] = i;
scores[i][1] = scanner.nextInt();;
}
long[] playerScore = new long[n];
long max = 0;
for(int i = 0; i<n; i++){
String s = scanner.next();
str[i] = s;
long score = 0;
boolean solved = false;
for(int j = 0; j<m; j++){
if(s.charAt(j)=='o'){
score += (long)scores[j][1];
solved = true;
}
}
score += (long)i;
max = Math.max(max,score);
playerScore[i] = score;
}
Arrays.sort(scores, (x, y) -> y[1] - x[1]);
for(int i = 0; i<n; i++){
int count = 0;
long initial = playerScore[i];
int k = 0;
while(initial<max){
long add = scores[k][1];
int place = scores[k][0];
if(str[i].charAt(place)=='x'){
initial += add;
count++;
}
k++;
}
System.out.println(count);
}
}
}
|
ConDefects/ConDefects/Code/abc323_c/Java/47412002
|
condefects-java_data_884
|
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());//人数
int m = Integer.parseInt(sc.next());//問題数
Map<Integer, Set<Integer>> prob = new HashMap<>();//点数→番号
Map<Integer, Integer> score = new HashMap<>();//番号→点数
List<Integer> list = new ArrayList<>();//点数
List<Player> pList = new ArrayList<>();//プレーヤー
for (int i = 1; i <= m; i++) {
int a = Integer.parseInt(sc.next());
if (prob.containsKey(a)) {
Set<Integer> set = prob.get(a);
set.add(i);
prob.put(a, set);
} else {
Set<Integer> set = new HashSet<>();
set.add(i);
prob.put(a, set);
}
score.put(i, a);
list.add(a);
}
Collections.sort(list);
Collections.reverse(list);
int max = 0;//最高得点
//現時点での点数計算
for (int i = 1; i <= n; i++) {
Player p = new Player(i);
p.result = new boolean[m];
String r = sc.next();
String[] result = r.split("");
for (int j = 1; j <= m; j++) {
p.result[j - 1] = "o".equals(result[j - 1]);
if (p.result[j - 1]) {
p.score += score.get(j);
}
}
pList.add(p);
if (max < p.score) {
max = p.score;
}
}
sc.close();
for (int i = 1; i <= n; i++) {
Player p = pList.get(i - 1);
if (max == p.score) {
System.out.println("0");
} else {
int count = 0;
for (int j = 1; j <= m; j++) {
int a = list.get(j - 1);
Set<Integer> set = prob.get(a);
for (int k : set) {
if (!p.result[k - 1]) {
count++;
p.score += a;
}
if (max < p.score) {
break;
}
}
if (max < p.score) {
break;
}
}
System.out.println(count);
}
}
}
public static class Player {
int num;//番号
int score;//点数
boolean[] result;
Player(int num) {
this.num = num;
this.score = num;
}
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());//人数
int m = Integer.parseInt(sc.next());//問題数
Map<Integer, Set<Integer>> prob = new HashMap<>();//点数→番号
Map<Integer, Integer> score = new HashMap<>();//番号→点数
List<Integer> list = new ArrayList<>();//点数
List<Player> pList = new ArrayList<>();//プレーヤー
for (int i = 1; i <= m; i++) {
int a = Integer.parseInt(sc.next());
if (prob.containsKey(a)) {
Set<Integer> set = prob.get(a);
set.add(i);
prob.put(a, set);
} else {
Set<Integer> set = new HashSet<>();
set.add(i);
prob.put(a, set);
}
score.put(i, a);
}
for (int a : prob.keySet()) {
list.add(a);
}
Collections.sort(list);
Collections.reverse(list);
int max = 0;//最高得点
//現時点での点数計算
for (int i = 1; i <= n; i++) {
Player p = new Player(i);
p.result = new boolean[m];
String r = sc.next();
String[] result = r.split("");
for (int j = 1; j <= m; j++) {
p.result[j - 1] = "o".equals(result[j - 1]);
if (p.result[j - 1]) {
p.score += score.get(j);
}
}
pList.add(p);
if (max < p.score) {
max = p.score;
}
}
sc.close();
for (int i = 1; i <= n; i++) {
Player p = pList.get(i - 1);
if (max == p.score) {
System.out.println("0");
} else {
int count = 0;
for (int j = 1; j <= m; j++) {
int a = list.get(j - 1);
Set<Integer> set = prob.get(a);
for (int k : set) {
if (!p.result[k - 1]) {
count++;
p.score += a;
}
if (max < p.score) {
break;
}
}
if (max < p.score) {
break;
}
}
System.out.println(count);
}
}
}
public static class Player {
int num;//番号
int score;//点数
boolean[] result;
Player(int num) {
this.num = num;
this.score = num;
}
}
}
|
ConDefects/ConDefects/Code/abc323_c/Java/54500962
|
condefects-java_data_885
|
import java.io.*;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
int n = rd.nextInt();
int q = rd.nextInt();
a = new long[n];
b = new long[n];
for (int i = 0; i < n; i++) {
a[i] = rd.nextLong();
}
for (int i = 0; i < n; i++) {
b[i] = rd.nextLong();
}
seg = build(0, n - 1);
LinkedList<Long> ans = new LinkedList<>();
for (int i = 0; i < q; i++) {
int op = rd.nextInt();
int l = rd.nextInt();
int r = rd.nextInt();
long x = 0;
if (op != 3) {
x = rd.nextLong();
}
l = l - 1;
r = r - 1;
if (op == 1) {
seg.add(l, r, x, 0);
}
if (op == 2) {
seg.add(l, r, 0, x);
}
if (op == 3) {
ans.add(seg.query(l, r));
}
}
PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
for (long val : ans) {
pw.println(val);
}
pw.flush();
}
static Seg seg;
static long[] a;
static long[] b;
static class Seg {
int l, r;
Seg left, right;
long sum;
long aSum;
long bSum;
long pushx;
long pushy;
public Seg(int l, int r) {
this.l = l;
this.r = r;
sum = 0;
aSum = 0;
bSum = 0;
pushx = 0;
pushy = 0;
}
public void add(int l, int r, long x, long y) {
if (this.l > r || this.r < l) {
return;
}
if (l <= this.l && this.r <= r) {
update(x, y);
return;
}
pushdown();
// add sum
this.left.add(l, r, x, y);
this.right.add(l, r, x, y);
pushup();
}
public void pushdown() {
left.update(pushx, pushy);
right.update(pushx, pushy);
}
public void pushup() {
this.sum = this.left.sum + this.right.sum;
this.sum %= mod;
this.aSum = this.left.aSum + this.right.aSum;
this.aSum %= mod;
this.bSum = this.left.bSum + this.right.bSum;
this.bSum %= mod;
}
public void update(long valx, long valy) {
valx %= mod;
valy %= mod;
// 更新sum
this.sum += (valx * bSum) % mod + (valy * aSum) % mod + (((valx * valy) % mod) * (r - l + 1)) % mod;
this.sum %= mod;
/// 再更新
this.aSum += (valx * (this.r - this.l + 1)) % mod;
this.bSum += (valy * (this.r - this.l + 1)) % mod;
this.aSum %= mod;
this.bSum %= mod;
this.pushx += valx;
this.pushy += valy;
this.pushx %= mod;
this.pushy %= mod;
}
public long query(int l, int r) {
if (this.l > r || this.r < l) {
return 0;
}
if (l <= this.l && this.r <= r) {
return sum;
}
pushdown();
long sum = left.query(l, r) + right.query(l, r);
pushup();
return sum % mod;
}
}
static long mod = 998244353L;
public static Seg build(int l, int r) {
if (l == r) {
Seg seg = new Seg(l, r);
seg.sum = (a[l] % mod) * (b[l] % mod) % mod;
seg.sum %= mod;
seg.aSum = (a[l] % mod);
seg.bSum = (b[l] % mod);
return seg;
}
Seg left = build(l, (l + r) / 2);
Seg right = build((l + r) / 2 + 1, r);
Seg seg = new Seg(l, r);
seg.left = left;
seg.right = right;
seg.pushup();
return seg;
}
static class rd {
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer tokenizer = new StringTokenizer("");
// nextLine()读取字符串
static String nextLine() throws IOException {
return reader.readLine();
}
// next()读取字符串
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
}
// 读取一个int型数值
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
// 读取一个double型数值
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
// 读取一个long型数值
static long nextLong() throws IOException {
return Long.parseLong(next());
}
// 读取一个BigInteger
static BigInteger nextBigInteger() throws IOException {
BigInteger d = new BigInteger(rd.nextLine());
return d;
}
}
}
import java.io.*;
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
int n = rd.nextInt();
int q = rd.nextInt();
a = new long[n];
b = new long[n];
for (int i = 0; i < n; i++) {
a[i] = rd.nextLong();
}
for (int i = 0; i < n; i++) {
b[i] = rd.nextLong();
}
seg = build(0, n - 1);
LinkedList<Long> ans = new LinkedList<>();
for (int i = 0; i < q; i++) {
int op = rd.nextInt();
int l = rd.nextInt();
int r = rd.nextInt();
long x = 0;
if (op != 3) {
x = rd.nextLong();
}
l = l - 1;
r = r - 1;
if (op == 1) {
seg.add(l, r, x, 0);
}
if (op == 2) {
seg.add(l, r, 0, x);
}
if (op == 3) {
ans.add(seg.query(l, r));
}
}
PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
for (long val : ans) {
pw.println(val);
}
pw.flush();
}
static Seg seg;
static long[] a;
static long[] b;
static class Seg {
int l, r;
Seg left, right;
long sum;
long aSum;
long bSum;
long pushx;
long pushy;
public Seg(int l, int r) {
this.l = l;
this.r = r;
sum = 0;
aSum = 0;
bSum = 0;
pushx = 0;
pushy = 0;
}
public void add(int l, int r, long x, long y) {
if (this.l > r || this.r < l) {
return;
}
if (l <= this.l && this.r <= r) {
update(x, y);
return;
}
pushdown();
// add sum
this.left.add(l, r, x, y);
this.right.add(l, r, x, y);
pushup();
}
public void pushdown() {
left.update(pushx, pushy);
right.update(pushx, pushy);
this.pushx = 0;
this.pushy = 0;
}
public void pushup() {
this.sum = this.left.sum + this.right.sum;
this.sum %= mod;
this.aSum = this.left.aSum + this.right.aSum;
this.aSum %= mod;
this.bSum = this.left.bSum + this.right.bSum;
this.bSum %= mod;
}
public void update(long valx, long valy) {
valx %= mod;
valy %= mod;
// 更新sum
this.sum += (valx * bSum) % mod + (valy * aSum) % mod + (((valx * valy) % mod) * (r - l + 1)) % mod;
this.sum %= mod;
/// 再更新
this.aSum += (valx * (this.r - this.l + 1)) % mod;
this.bSum += (valy * (this.r - this.l + 1)) % mod;
this.aSum %= mod;
this.bSum %= mod;
this.pushx += valx;
this.pushy += valy;
this.pushx %= mod;
this.pushy %= mod;
}
public long query(int l, int r) {
if (this.l > r || this.r < l) {
return 0;
}
if (l <= this.l && this.r <= r) {
return sum;
}
pushdown();
long sum = left.query(l, r) + right.query(l, r);
pushup();
return sum % mod;
}
}
static long mod = 998244353L;
public static Seg build(int l, int r) {
if (l == r) {
Seg seg = new Seg(l, r);
seg.sum = (a[l] % mod) * (b[l] % mod) % mod;
seg.sum %= mod;
seg.aSum = (a[l] % mod);
seg.bSum = (b[l] % mod);
return seg;
}
Seg left = build(l, (l + r) / 2);
Seg right = build((l + r) / 2 + 1, r);
Seg seg = new Seg(l, r);
seg.left = left;
seg.right = right;
seg.pushup();
return seg;
}
static class rd {
static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer tokenizer = new StringTokenizer("");
// nextLine()读取字符串
static String nextLine() throws IOException {
return reader.readLine();
}
// next()读取字符串
static String next() throws IOException {
while (!tokenizer.hasMoreTokens()) tokenizer = new StringTokenizer(reader.readLine());
return tokenizer.nextToken();
}
// 读取一个int型数值
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
// 读取一个double型数值
static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
// 读取一个long型数值
static long nextLong() throws IOException {
return Long.parseLong(next());
}
// 读取一个BigInteger
static BigInteger nextBigInteger() throws IOException {
BigInteger d = new BigInteger(rd.nextLine());
return d;
}
}
}
|
ConDefects/ConDefects/Code/abc357_f/Java/54413810
|
condefects-java_data_886
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
int q = Integer.parseInt(sa[1]);
Obj[] arr = new Obj[n];
sa = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
Obj o = new Obj();
o.a = Integer.parseInt(sa[i]);
o.size = 1;
arr[i] = o;
}
sa = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
Obj o = arr[i];
o.b = Integer.parseInt(sa[i]);
o.v = o.a * o.b;
}
int mod = 998244353;
LazySegTree<Obj, Obj> st = new LazySegTree<>(
arr,
new Obj(),
(s1, s2) -> {
Obj ret = new Obj();
ret.a = (s1.a + s2.a) % mod;
ret.b = (s1.b + s2.b) % mod;
ret.v = (s1.v + s2.v) % mod;
ret.size = s1.size + s2.size;
return ret;
},
(f, s) -> {
Obj ret = new Obj();
ret.a = (s.a + f.a * s.size) % mod;
ret.b = (s.b + f.b * s.size) % mod;
ret.v = (s.v + s.a * f.b % mod + s.b * f.a % mod
+ f.a * f.b % mod * s.size % mod * s.size % mod) % mod;
ret.size = s.size;
return ret;
},
(f1, f2) -> {
Obj ret = new Obj();
ret.a = (f1.a + f2.a) % mod;
ret.b = (f1.b + f2.b) % mod;
return ret;
},
new Obj());
PrintWriter pw = new PrintWriter(System.out);
for (int i = 0; i < q; i++) {
sa = br.readLine().split(" ");
int t = Integer.parseInt(sa[0]);
int l = Integer.parseInt(sa[1]) - 1;
int r = Integer.parseInt(sa[2]);
if (t == 1) {
Obj f = new Obj();
f.a = Integer.parseInt(sa[3]);
st.apply(l, r, f);
} else if (t == 2) {
Obj f = new Obj();
f.b = Integer.parseInt(sa[3]);
st.apply(l, r, f);
} else {
Obj o = st.prod(l, r);
pw.println(o.v);
}
}
pw.flush();
br.close();
}
static class Obj {
long a, b, v;
int size;
}
}
class LazySegTree<S, F> {
private final int n; // 要素数
private final int size; // 葉の数（n以上の最小の2べき）
private final int log; // 2^log = size
private final BinaryOperator<S> op; // 二項演算
private final S e; // 単位元
private final BiFunction<F, S, S> mapping; // f(x)
private final BinaryOperator<F> composition; // 合成関数
private final F id; // 恒等写像
private final S[] data;
private final F[] lazy;
/**
* 長さnの配列aを作る。初期値は全て単位元。<br>
* O(n)<br>
* S：モノイドの型<br>
* F：写像の型
*
* @param n 要素数
* @param e 単位元
* @param op 二項演算
* @param mapping f(x)を返す関数
* @param composition fとgの合成関数
* @param id 恒等写像
*/
@SuppressWarnings("unchecked")
public LazySegTree(int n, S e, BinaryOperator<S> op,
BiFunction<F, S, S> mapping, BinaryOperator<F> composition, F id) {
this.n = n;
int k = 1;
while (k < n) k <<= 1;
this.size = k;
this.log = Integer.numberOfTrailingZeros(size);
this.op = op;
this.e = e;
this.mapping = mapping;
this.composition = composition;
this.id = id;
this.data = (S[]) new Object[size << 1];
this.lazy = (F[]) new Object[size];
Arrays.fill(data, e);
Arrays.fill(lazy, id);
}
/**
* 長さdat.lengthの配列aをdatを元に作る。<br>
* O(n)<br>
* S：モノイドの型<br>
* F：写像の型
*
* @param dat 初期データ
* @param e 単位元
* @param op 二項演算
* @param mapping f(x)を返す関数
* @param composition fとgの合成関数
* @param id 恒等写像
*/
public LazySegTree(S[] dat, S e, BinaryOperator<S> op,
BiFunction<F, S, S> mapping, BinaryOperator<F> composition, F id) {
this(dat.length, e, op, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, size, l);
for (int i = size - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
/**
* a[p] = xとする。<br>
* O(log n)
*
* @param p 設定位置（0≦p＜n）
* @param x 設定値
*/
void set(int p, S x) {
assert 0 <= p && p < n : "p=" + p;
p += size;
pushTo(p);
data[p] = x;
updateFrom(p);
}
/**
* a[p]を取得する。<br>
* O(log n)
*
* @param p 取得位置（0≦p＜n）
*/
S get(int p) {
assert 0 <= p && p < n : "p=" + p;
p += size;
pushTo(p);
return data[p];
}
/**
* 区間l～(r-1)の計算を行う。<br>
* l＝rのときは単位元を返す。<br>
* O(log n)
*
* @param l 開始位置（含む） （0≦l≦r≦n）
* @param r 終了位置（含まない）（0≦l≦r≦n）
*/
S prod(int l, int r) {
assert 0 <= l && l <= r && r <= n : "l=" + l + ", r=" + r;
if (l == r) return e;
l += size;
r += size;
pushTo(l, r);
S sumLeft = e, sumRight = e;
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);
}
/**
* 全区間の計算を行う。<br>
* O(1)
*/
S allProd() {
return data[1];
}
/**
* a[p]に作用素fを作用させる。<br>
* O(log n)
*
* @param p 取得位置（0≦p＜n）
* @param f 作用素
*/
void apply(int p, F f) {
assert 0 <= p && p < n : "p=" + p;
p += size;
pushTo(p);
data[p] = mapping.apply(f, data[p]);
updateFrom(p);
}
/**
* a[l]～a[r-1]に作用素fを作用させる。<br>
* O(log n)
*
* @param l 開始位置（含む） （0≦l≦r≦n）
* @param r 終了位置（含まない）（0≦l≦r≦n）
* @param f 作用素
*/
void apply(int l, int r, F f) {
assert 0 <= l && l <= r && r <= n : "l=" + l + ", r=" + r;
if (l == r) return;
l += size;
r += size;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
data[l2] = mapping.apply(f, data[l2]);
if (l2 < size) lazy[l2] = composition.apply(f, lazy[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
data[r2] = mapping.apply(f, data[r2]);
if (r2 < size) lazy[r2] = composition.apply(f, lazy[r2]);
}
l2 >>= 1;
r2 >>= 1;
}
updateFrom(l, r);
}
/**
* f(op(l～(r-1)))＝trueとなる最大のrを返す。<br>
* （計算区間にrを追加するとfalseになる）<br>
* O(log n)
*
* @param l 左端（含む）（0≦l≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最大のr
*/
int maxRight(int l, Predicate<S> f) {
assert 0 <= l && l <= n : "l=" + l;
assert f.test(e);
if (l == n) return n;
l += size;
pushTo(l);
S sum = e;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < size) {
push(l);
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - size;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return n;
}
/**
* f(op(l～(r-1)))＝trueとなる最小のlを返す。<br>
* （計算区間に(l-1)を追加するとfalseになる）<br>
* O(log n)
*
* @param r 右端（含まない）（0≦r≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最小のl
*/
int minLeft(int r, Predicate<S> f) {
assert 0 <= r && r <= n : "r=" + r;
assert f.test(e);
if (r == 0) return 0;
r += size;
pushTo(r - 1);
S sum = e;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < size) {
push(r);
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - size;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void pushTo(int k) {
for (int i = log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void push(int k) {
if (lazy[k] == id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
data[lk] = mapping.apply(lazy[k], data[lk]);
data[rk] = mapping.apply(lazy[k], data[rk]);
if (lk < size) lazy[lk] = composition.apply(lazy[k], lazy[lk]);
if (rk < size) lazy[rk] = composition.apply(lazy[k], lazy[rk]);
lazy[k] = id;
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
data[k] = op.apply(data[k << 1 | 0], data[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
data[lki] = op.apply(data[lki << 1 | 0], data[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
data[rki] = op.apply(data[rki << 1 | 0], data[rki << 1 | 1]);
}
}
}
// **************** DEBUG **************** //
private int indent = 6;
void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
/**
* セグメント木全体の要素をツリー状に出力。
*/
String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= size) return indent(sp) + dat[k];
StringBuilder sb = new StringBuilder();
sb.append(toDetailedString(k << 1 | 1, sp + indent, dat));
sb.append("\n");
sb.append(indent(sp) + dat[k]);
sb.append("\n");
sb.append(toDetailedString(k << 1 | 0, sp + indent, dat));
return sb.toString();
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0) sb.append(' ');
return sb.toString();
}
/**
* n件の要素のみを、配列形式で出力。
*/
String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < size; i++) {
sb.append(dat[i + size]);
if (i < size - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
private S[] simulatePushAll() {
S[] simDat = Arrays.copyOf(data, 2 * size);
F[] simLaz = Arrays.copyOf(lazy, 2 * size);
for (int k = 1; k < size; k++) {
if (simLaz[k] == id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = mapping.apply(simLaz[k], simDat[rk]);
if (lk < size) simLaz[lk] = composition.apply(simLaz[k], simLaz[lk]);
if (rk < size) simLaz[rk] = composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = id;
}
return simDat;
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
int q = Integer.parseInt(sa[1]);
Obj[] arr = new Obj[n];
sa = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
Obj o = new Obj();
o.a = Integer.parseInt(sa[i]);
o.size = 1;
arr[i] = o;
}
sa = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
Obj o = arr[i];
o.b = Integer.parseInt(sa[i]);
o.v = o.a * o.b;
}
int mod = 998244353;
LazySegTree<Obj, Obj> st = new LazySegTree<>(
arr,
new Obj(),
(s1, s2) -> {
Obj ret = new Obj();
ret.a = (s1.a + s2.a) % mod;
ret.b = (s1.b + s2.b) % mod;
ret.v = (s1.v + s2.v) % mod;
ret.size = s1.size + s2.size;
return ret;
},
(f, s) -> {
Obj ret = new Obj();
ret.a = (s.a + f.a * s.size) % mod;
ret.b = (s.b + f.b * s.size) % mod;
ret.v = (s.v + s.a * f.b % mod + s.b * f.a % mod
+ f.a * f.b % mod * s.size % mod) % mod;
ret.size = s.size;
return ret;
},
(f1, f2) -> {
Obj ret = new Obj();
ret.a = (f1.a + f2.a) % mod;
ret.b = (f1.b + f2.b) % mod;
return ret;
},
new Obj());
PrintWriter pw = new PrintWriter(System.out);
for (int i = 0; i < q; i++) {
sa = br.readLine().split(" ");
int t = Integer.parseInt(sa[0]);
int l = Integer.parseInt(sa[1]) - 1;
int r = Integer.parseInt(sa[2]);
if (t == 1) {
Obj f = new Obj();
f.a = Integer.parseInt(sa[3]);
st.apply(l, r, f);
} else if (t == 2) {
Obj f = new Obj();
f.b = Integer.parseInt(sa[3]);
st.apply(l, r, f);
} else {
Obj o = st.prod(l, r);
pw.println(o.v);
}
}
pw.flush();
br.close();
}
static class Obj {
long a, b, v;
int size;
}
}
class LazySegTree<S, F> {
private final int n; // 要素数
private final int size; // 葉の数（n以上の最小の2べき）
private final int log; // 2^log = size
private final BinaryOperator<S> op; // 二項演算
private final S e; // 単位元
private final BiFunction<F, S, S> mapping; // f(x)
private final BinaryOperator<F> composition; // 合成関数
private final F id; // 恒等写像
private final S[] data;
private final F[] lazy;
/**
* 長さnの配列aを作る。初期値は全て単位元。<br>
* O(n)<br>
* S：モノイドの型<br>
* F：写像の型
*
* @param n 要素数
* @param e 単位元
* @param op 二項演算
* @param mapping f(x)を返す関数
* @param composition fとgの合成関数
* @param id 恒等写像
*/
@SuppressWarnings("unchecked")
public LazySegTree(int n, S e, BinaryOperator<S> op,
BiFunction<F, S, S> mapping, BinaryOperator<F> composition, F id) {
this.n = n;
int k = 1;
while (k < n) k <<= 1;
this.size = k;
this.log = Integer.numberOfTrailingZeros(size);
this.op = op;
this.e = e;
this.mapping = mapping;
this.composition = composition;
this.id = id;
this.data = (S[]) new Object[size << 1];
this.lazy = (F[]) new Object[size];
Arrays.fill(data, e);
Arrays.fill(lazy, id);
}
/**
* 長さdat.lengthの配列aをdatを元に作る。<br>
* O(n)<br>
* S：モノイドの型<br>
* F：写像の型
*
* @param dat 初期データ
* @param e 単位元
* @param op 二項演算
* @param mapping f(x)を返す関数
* @param composition fとgの合成関数
* @param id 恒等写像
*/
public LazySegTree(S[] dat, S e, BinaryOperator<S> op,
BiFunction<F, S, S> mapping, BinaryOperator<F> composition, F id) {
this(dat.length, e, op, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, size, l);
for (int i = size - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
/**
* a[p] = xとする。<br>
* O(log n)
*
* @param p 設定位置（0≦p＜n）
* @param x 設定値
*/
void set(int p, S x) {
assert 0 <= p && p < n : "p=" + p;
p += size;
pushTo(p);
data[p] = x;
updateFrom(p);
}
/**
* a[p]を取得する。<br>
* O(log n)
*
* @param p 取得位置（0≦p＜n）
*/
S get(int p) {
assert 0 <= p && p < n : "p=" + p;
p += size;
pushTo(p);
return data[p];
}
/**
* 区間l～(r-1)の計算を行う。<br>
* l＝rのときは単位元を返す。<br>
* O(log n)
*
* @param l 開始位置（含む） （0≦l≦r≦n）
* @param r 終了位置（含まない）（0≦l≦r≦n）
*/
S prod(int l, int r) {
assert 0 <= l && l <= r && r <= n : "l=" + l + ", r=" + r;
if (l == r) return e;
l += size;
r += size;
pushTo(l, r);
S sumLeft = e, sumRight = e;
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);
}
/**
* 全区間の計算を行う。<br>
* O(1)
*/
S allProd() {
return data[1];
}
/**
* a[p]に作用素fを作用させる。<br>
* O(log n)
*
* @param p 取得位置（0≦p＜n）
* @param f 作用素
*/
void apply(int p, F f) {
assert 0 <= p && p < n : "p=" + p;
p += size;
pushTo(p);
data[p] = mapping.apply(f, data[p]);
updateFrom(p);
}
/**
* a[l]～a[r-1]に作用素fを作用させる。<br>
* O(log n)
*
* @param l 開始位置（含む） （0≦l≦r≦n）
* @param r 終了位置（含まない）（0≦l≦r≦n）
* @param f 作用素
*/
void apply(int l, int r, F f) {
assert 0 <= l && l <= r && r <= n : "l=" + l + ", r=" + r;
if (l == r) return;
l += size;
r += size;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
data[l2] = mapping.apply(f, data[l2]);
if (l2 < size) lazy[l2] = composition.apply(f, lazy[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
data[r2] = mapping.apply(f, data[r2]);
if (r2 < size) lazy[r2] = composition.apply(f, lazy[r2]);
}
l2 >>= 1;
r2 >>= 1;
}
updateFrom(l, r);
}
/**
* f(op(l～(r-1)))＝trueとなる最大のrを返す。<br>
* （計算区間にrを追加するとfalseになる）<br>
* O(log n)
*
* @param l 左端（含む）（0≦l≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最大のr
*/
int maxRight(int l, Predicate<S> f) {
assert 0 <= l && l <= n : "l=" + l;
assert f.test(e);
if (l == n) return n;
l += size;
pushTo(l);
S sum = e;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < size) {
push(l);
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - size;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return n;
}
/**
* f(op(l～(r-1)))＝trueとなる最小のlを返す。<br>
* （計算区間に(l-1)を追加するとfalseになる）<br>
* O(log n)
*
* @param r 右端（含まない）（0≦r≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最小のl
*/
int minLeft(int r, Predicate<S> f) {
assert 0 <= r && r <= n : "r=" + r;
assert f.test(e);
if (r == 0) return 0;
r += size;
pushTo(r - 1);
S sum = e;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < size) {
push(r);
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - size;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void pushTo(int k) {
for (int i = log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void push(int k) {
if (lazy[k] == id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
data[lk] = mapping.apply(lazy[k], data[lk]);
data[rk] = mapping.apply(lazy[k], data[rk]);
if (lk < size) lazy[lk] = composition.apply(lazy[k], lazy[lk]);
if (rk < size) lazy[rk] = composition.apply(lazy[k], lazy[rk]);
lazy[k] = id;
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
data[k] = op.apply(data[k << 1 | 0], data[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
data[lki] = op.apply(data[lki << 1 | 0], data[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
data[rki] = op.apply(data[rki << 1 | 0], data[rki << 1 | 1]);
}
}
}
// **************** DEBUG **************** //
private int indent = 6;
void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
/**
* セグメント木全体の要素をツリー状に出力。
*/
String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= size) return indent(sp) + dat[k];
StringBuilder sb = new StringBuilder();
sb.append(toDetailedString(k << 1 | 1, sp + indent, dat));
sb.append("\n");
sb.append(indent(sp) + dat[k]);
sb.append("\n");
sb.append(toDetailedString(k << 1 | 0, sp + indent, dat));
return sb.toString();
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0) sb.append(' ');
return sb.toString();
}
/**
* n件の要素のみを、配列形式で出力。
*/
String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < size; i++) {
sb.append(dat[i + size]);
if (i < size - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
private S[] simulatePushAll() {
S[] simDat = Arrays.copyOf(data, 2 * size);
F[] simLaz = Arrays.copyOf(lazy, 2 * size);
for (int k = 1; k < size; k++) {
if (simLaz[k] == id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = mapping.apply(simLaz[k], simDat[rk]);
if (lk < size) simLaz[lk] = composition.apply(simLaz[k], simLaz[lk]);
if (rk < size) simLaz[rk] = composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = id;
}
return simDat;
}
}
|
ConDefects/ConDefects/Code/abc357_f/Java/54379687
|
condefects-java_data_887
|
import java.awt.Point;
import java.io.Serializable;
import java.math.BigInteger;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.RandomAccess;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;
public class Main implements Runnable {
private void solve(final FastIO io, final String[] args) {
io.setAutoFlush(false);
io.setAutoOutFlush(false);
/*
* author: 31536000
* AtCoder Beginner Contest 357 F問題
* 考察メモ
* 明らかに遅延セグ木に乗せると書いてあるのでそれをやるとして
* ΣABの寄与について考える
* xをAに加えた時、答えにはxΣB追加される
* 逆も同様
* ということは、(ΣA, ΣB, ΣAB, len)を持てば足りるかな
*
* 多項式で持ってると思えば、まぁいつもので
* 和と積なので近半環になることも明らか、じゃ乗るね
*/
int N = io.nextInt(), Q = io.nextInt();
int[] A = io.nextInt(N), B = io.nextInt(N);
final ModUtility mod = new ModUtility(new Prime(998_244_353), 1_000_000);
class Query {
int ax, bx;
Query(int ax, int bx) {
this.ax = ax;
this.bx = bx;
}
Query(Query l, Query r) {
ax = mod.add(l.ax, r.ax);
bx = mod.add(l.bx, r.bx);
}
}
class Data {
int sumA, sumB, sumAB, len;
Data(int i) {
sumA = A[i];
sumB = B[i];
sumAB = mod.multiply(sumA, sumB);
len = 1;
}
Data(Data l, Data r) {
sumA = mod.add(l.sumA, r.sumA);
sumB = mod.add(l.sumB, r.sumB);
sumAB = mod.add(l.sumAB, r.sumAB);
len = l.len + r.len;
}
Data(Query x, Data d) {
sumA = mod.add(d.sumA, mod.multiply(x.ax, d.len));
sumB = mod.add(d.sumB, mod.multiply(x.bx, d.len));
sumAB = mod.add(d.sumAB, mod.add(mod.multiply(x.ax, x.bx), mod.add(mod.multiply(x.ax, d.sumB), mod.multiply(x.bx, d.sumA))));
len = d.len;
}
Data() {
sumA = sumB = sumAB = len = 0;
}
@Override
public String toString() {
return "(" + sumA + ", " + sumB + ", " + sumAB + ", " + len + ")";
}
}
ACL.LazySegTree<Data, Query> segTree = new ACL.LazySegTree<>(N, Data::new, new Data(), Data::new, Query::new, new Query(0, 0));
for (int i = 0;i < N;++ i) segTree.set(i, new Data(i));
while(Q --> 0) {
int query = io.nextInt(), l = io.nextInt() - 1, r = io.nextInt();
if (query == 1) {
Query q = new Query(io.nextInt(), 0);
segTree.apply(l, r, q);
} else if (query == 2) {
Query q = new Query(0, io.nextInt());
segTree.apply(l, r, q);
} else {
io.println(segTree.prod(l, r).sumAB);
}
}
}
/** デバッグ用コードのお供に */
private static boolean DEBUG = false;
/** 確保するメモリの大きさ(単位: MB) */
private static final long MEMORY = 64;
private final FastIO io;
private final String[] args;
public static void main(final String[] args) {
Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
e.printStackTrace();
System.exit(1);
});
FastIO.setFastStandardOutput(true);
new Thread(null, new Main(args), "", MEMORY * 1048576L).start();
}
public Main(final String[] args) {
this(new FastIO(), args);
}
public Main(final FastIO io, final String... args) {
this.io = io;
this.args = args;
if (DEBUG) io.setAutoFlush(true);
}
@Override
public void run() {
try {
solve(io, args);
} catch (final Throwable e) {
throw e;
} finally {
io.close();
FastIO.setFastStandardOutput(false);
}
}
// 以下、ライブラリ
/**
* 指数表記の値を整数で返します。
*
* @param n 仮数部
* @param e 指数部
* @return n * 10^e
*/
public static int exponent10(final int n, final int e) {
return n * pow(10, e);
}
/**
* 指数表記の値を整数で返します。
*
* @param n 仮数部
* @param e 指数部
* @return n * 10^e
*/
public static long exponent10L(final int n, final int e) {
return n * pow(10L, e);
}
/**
* aのb乗を返します。
*
* @param a 整数
* @param b 整数
* @return aのb乗
*/
public static int pow(final int a, int b) {
int ans = 1;
for (int mul = a; b > 0; b >>= 1, mul *= mul) if ((b & 1) != 0) ans *= mul;
return ans;
}
/**
* aのb乗をmodを法として計算したものを返します。
*
* @param a 整数
* @param b 整数
* @param mod 法
* @return aのb乗をmodを法として計算したもの
*/
public static int pow(int a, int b, final int mod) {
a %= mod;
if (a < 0) a += mod;
if (b < 0) {
b %= mod - 1;
b += mod - 1;
}
long ans = 1;
for (long mul = a; b > 0; b >>= 1, mul = mul * mul % mod) if ((b & 1) != 0) ans = ans * mul % mod;
return (int) ans;
}
/**
* aのb乗を返します。
*
* @param a 整数
* @param b 整数
* @return aのb乗
*/
public static long pow(final long a, long b) {
long ans = 1;
for (long mul = a; b > 0; b >>= 1, mul *= mul) if ((b & 1) != 0) ans *= mul;
return ans;
}
/**
* aのb乗をmodを法として計算したものを返します。
*
* @param a 整数
* @param b 整数
* @param mod 法
* @return aのb乗をmodを法として計算したもの
*/
public static int pow(long a, long b, final int mod) {
a %= mod;
if (a < 0) a += mod;
if (b < 0) {
b %= mod - 1;
b += mod - 1;
}
long ans = 1;
for (long mul = a; b > 0; b >>= 1, mul = mul * mul % mod) if ((b & 1) != 0) ans = ans * mul % mod;
return (int) ans;
}
public enum BoundType {
CLOSED, OPEN;
}
public static class Range<C> implements Serializable {
private static final long serialVersionUID = -4702828934863023392L;
protected C lower;
protected C upper;
protected BoundType lowerType;
protected BoundType upperType;
private Comparator<? super C> comparator;
protected Range(final C lower, final BoundType lowerType, final C upper, final BoundType upperType) {
this(lower, lowerType, upper, upperType, null);
}
protected Range(final C lower, final BoundType lowerType, final C upper, final BoundType upperType,
final Comparator<? super C> comparator) {
this.lower = lower;
this.upper = upper;
this.lowerType = lowerType;
this.upperType = upperType;
this.comparator = comparator;
}
public static <C extends Comparable<? super C>> Range<C> range(final C lower, final BoundType lowerType,
final C upper, final BoundType upperType) {
if (lower != null && upper != null) {
final int comp = lower.compareTo(upper);
if (comp > 0) return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED);
else if (comp == 0 && (lowerType == BoundType.OPEN || upperType == BoundType.OPEN))
return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED);
}
return new Range<>(lower, lowerType, upper, upperType);
}
public static <C> Range<C> range(final C lower, final BoundType lowerType, final C upper,
final BoundType upperType, final Comparator<? super C> comparator) {
if (lower != null && upper != null) {
final int comp = comparator.compare(lower, upper);
if (comp > 0) return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED, comparator);
else if (comp == 0 && (lowerType == BoundType.OPEN || upperType == BoundType.OPEN))
return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED, comparator);
}
return new Range<>(lower, lowerType, upper, upperType, comparator);
}
public static <C extends Comparable<? super C>> Range<C> all() {
return range((C) null, BoundType.OPEN, null, BoundType.OPEN);
}
public static <C> Range<C> all(final Comparator<? super C> comparator) {
return range((C) null, BoundType.OPEN, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> atMost(final C upper) {
return range(null, BoundType.OPEN, upper, BoundType.CLOSED);
}
public static <C> Range<C> atMost(final C upper, final Comparator<? super C> comparator) {
return range(null, BoundType.OPEN, upper, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> lessThan(final C upper) {
return range(null, BoundType.OPEN, upper, BoundType.OPEN);
}
public static <C> Range<C> lessThan(final C upper, final Comparator<? super C> comparator) {
return range(null, BoundType.OPEN, upper, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> downTo(final C upper, final BoundType boundType) {
return range(null, BoundType.OPEN, upper, boundType);
}
public static <C> Range<C> downTo(final C upper, final BoundType boundType,
final Comparator<? super C> comparator) {
return range(null, BoundType.OPEN, upper, boundType, comparator);
}
public static <C extends Comparable<? super C>> Range<C> atLeast(final C lower) {
return range(lower, BoundType.CLOSED, null, BoundType.OPEN);
}
public static <C> Range<C> atLeast(final C lower, final Comparator<? super C> comparator) {
return range(lower, BoundType.CLOSED, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> greaterThan(final C lower) {
return range(lower, BoundType.OPEN, null, BoundType.OPEN);
}
public static <C> Range<C> greaterThan(final C lower, final Comparator<? super C> comparator) {
return range(lower, BoundType.OPEN, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> upTo(final C lower, final BoundType boundType) {
return range(lower, boundType, null, BoundType.OPEN);
}
public static <C> Range<C> upTo(final C lower, final BoundType boundType,
final Comparator<? super C> comparator) {
return range(lower, boundType, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> open(final C lower, final C upper) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN);
}
public static <C> Range<C> open(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> openClosed(final C lower, final C upper) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED);
}
public static <C> Range<C> openClosed(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> closedOpen(final C lower, final C upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN);
}
public static <C> Range<C> closedOpen(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> closed(final C lower, final C upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static <C> Range<C> closed(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> singleton(final C value) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED);
}
public static <C> Range<C> singleton(final C value, final Comparator<? super C> comparator) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> empty() {
return range((C) null, BoundType.CLOSED, null, BoundType.CLOSED);
}
public static <C> Range<C> empty(final Comparator<? super C> comparator) {
return range((C) null, BoundType.CLOSED, null, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> encloseAll(final Iterable<C> values) {
C lower = values.iterator().next();
C upper = lower;
for (final C i : values) {
if (lower.compareTo(i) > 0) lower = i;
if (upper.compareTo(i) < 0) upper = i;
}
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static <C> Range<C> encloseAll(final Iterable<C> values, final Comparator<? super C> comparator) {
C lower = values.iterator().next();
C upper = lower;
for (final C i : values) {
if (comparator.compare(lower, i) > 0) lower = i;
if (comparator.compare(upper, i) < 0) upper = i;
}
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, comparator);
}
protected int compareLower(final C value) {
return compareLower(value, BoundType.CLOSED);
}
protected int compareLower(final C value, final BoundType boundType) {
return compareLower(lower, lowerType, value, boundType);
}
protected int compareLower(final C lower, final BoundType lowerType, final C value) {
return compareLower(lower, lowerType, value, BoundType.CLOSED);
}
protected int compareLower(final C lower, final BoundType lowerType, final C value, final BoundType boundType) {
if (lower == null) return value == null ? 0 : -1;
else if (value == null) return 1;
int compare;
if (comparator == null) {
@SuppressWarnings("unchecked")
final Comparable<C> comp = (Comparable<C>) lower;
compare = comp.compareTo(value);
} else compare = comparator.compare(lower, value);
if (compare == 0) {
if (lowerType == BoundType.CLOSED) --compare;
if (boundType == BoundType.CLOSED) ++compare;
}
return compare;
}
protected int compareUpper(final C value) {
return compareUpper(value, BoundType.CLOSED);
}
protected int compareUpper(final C value, final BoundType boundType) {
return compareUpper(upper, upperType, value, boundType);
}
protected int compareUpper(final C upper, final BoundType upperType, final C value) {
return compareUpper(upper, upperType, value, BoundType.CLOSED);
}
protected int compareUpper(final C upper, final BoundType upperType, final C value, final BoundType boundType) {
if (upper == null) return value == null ? 0 : 1;
if (value == null) return -1;
int compare;
if (comparator == null) {
@SuppressWarnings("unchecked")
final Comparable<C> comp = (Comparable<C>) upper;
compare = comp.compareTo(value);
} else compare = comparator.compare(upper, value);
if (compare == 0) {
if (upperType == BoundType.CLOSED) ++compare;
if (boundType == BoundType.CLOSED) --compare;
}
return compare;
}
public boolean hasLowerBound() {
return lower != null;
}
public C lowerEndpoint() {
if (hasLowerBound()) return lower;
throw new IllegalStateException();
}
public BoundType lowerBoundType() {
if (hasLowerBound()) return lowerType;
throw new IllegalStateException();
}
public boolean hasUpperBound() {
return upper != null;
}
public C upperEndpoint() {
if (hasUpperBound()) return upper;
throw new IllegalStateException();
}
public BoundType upperBoundType() {
if (hasUpperBound()) return upperType;
throw new IllegalStateException();
}
/**
* この区間が空集合か判定します。
*
* @return 空集合ならばtrue
*/
public boolean isEmpty() { return lower == null && upper == null && lowerType == BoundType.CLOSED; }
/**
* 与えられた引数が区間の左側に位置するか判定します。<br>
* 接する場合は区間の左側ではないと判定します。
*
* @param value 調べる引数
* @return 区間の左側に位置するならtrue
*/
public boolean isLess(final C value) {
return isLess(value, BoundType.CLOSED);
}
protected boolean isLess(final C value, final BoundType boundType) {
return compareLower(value, boundType) > 0;
}
/**
* 与えられた引数が区間の右側に位置するか判定します。<br>
* 接する場合は区間の右側ではないと判定します。
*
* @param value 調べる引数
* @return 区間の右側に位置するならtrue
*/
public boolean isGreater(final C value) {
return isGreater(value, BoundType.CLOSED);
}
private boolean isGreater(final C value, final BoundType boundType) {
return compareUpper(value, boundType) < 0;
}
/**
* 与えられた引数が区間内に位置するか判定します。<br>
* 接する場合も区間内に位置すると判定します。
*
* @param value 調べる引数
* @return 区間内に位置するならtrue
*/
public boolean contains(final C value) {
return !isLess(value) && !isGreater(value) && !isEmpty();
}
/**
* 与えられた引数すべてが区間内に位置するか判定します。<br>
* 接する場合も区間内に位置すると判定します。
*
* @param value 調べる要素
* @return 全ての要素が区間内に位置するならtrue
*/
public boolean containsAll(final Iterable<? extends C> values) {
for (final C i : values) if (!contains(i)) return false;
return true;
}
/**
* 与えられた区間がこの区間に内包されるか判定します。<br>
*
* @param other
* @return 与えられた区間がこの区間に内包されるならtrue
*/
public boolean encloses(final Range<C> other) {
return !isLess(other.lower, other.lowerType) && !isGreater(other.upper, other.upperType);
}
/**
* 与えられた区間がこの区間と公差するか判定します。<br>
* 接する場合は公差するものとします。
*
* @param value 調べる引数
* @return 区間が交差するならtrue
*/
public boolean isConnected(final Range<C> other) {
if (this.isEmpty() || other.isEmpty()) return false;
C lower, upper;
BoundType lowerType, upperType;
if (isLess(other.lower, other.lowerType)) {
lower = other.lower;
lowerType = other.lowerType;
} else {
lower = this.lower;
lowerType = this.lowerType;
}
if (isGreater(other.upper, other.upperType)) {
upper = other.upper;
upperType = other.upperType;
} else {
upper = this.upper;
upperType = this.upperType;
}
if (lower == null || upper == null) return true;
final int comp = compareLower(lower, lowerType, upper, upperType);
return comp <= 0;
}
/**
* この区間との積集合を返します。
*
* @param connectedRange 積集合を求める区間
* @return 積集合
*/
public Range<C> intersection(final Range<C> connectedRange) {
if (this.isEmpty() || connectedRange.isEmpty()) {
if (comparator == null) return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED);
return empty(comparator);
}
C lower, upper;
BoundType lowerType, upperType;
if (isLess(connectedRange.lower, connectedRange.lowerType)) {
lower = connectedRange.lower;
lowerType = connectedRange.lowerType;
} else {
lower = this.lower;
lowerType = this.lowerType;
}
if (isGreater(connectedRange.upper, connectedRange.upperType)) {
upper = connectedRange.upper;
upperType = connectedRange.upperType;
} else {
upper = this.upper;
upperType = this.upperType;
}
if (comparator == null) { return new Range<>(lower, lowerType, upper, upperType); }
return range(lower, lowerType, upper, upperType, comparator);
}
/**
* この区間との和集合を返します。
*
* @param other 和集合を求める区間
* @return 和集合
*/
public Range<C> span(final Range<C> other) {
if (other.isEmpty()) return new Range<>(lower, lowerType, upper, upperType);
C lower, upper;
BoundType lowerType, upperType;
if (isLess(other.lower, other.lowerType)) {
lower = this.lower;
lowerType = this.lowerType;
} else {
lower = other.lower;
lowerType = other.lowerType;
}
if (isGreater(other.upper, other.upperType)) {
upper = this.upper;
upperType = this.upperType;
} else {
upper = other.upper;
upperType = other.upperType;
}
return new Range<>(lower, lowerType, upper, upperType, comparator);
}
/**
* 区間スケジューリングを行います。<br>
* 計算量は要素数Nに対してO(NlogN)です。
*
* @param ranges 区間の集合
* @return 区間スケジューリングを行った際の一つの解
*/
public static <C> List<Range<C>> scheduling(final List<Range<C>> ranges) {
final PriorityQueue<Range<C>> pq = new PriorityQueue<>((l, r) -> l.compareUpper(r.upper, r.upperType));
final List<Range<C>> ret = new ArrayList<>();
Range<C> last = pq.poll();
if (pq.isEmpty()) return ret;
ret.add(last);
while (!pq.isEmpty()) {
final Range<C> tmp = pq.poll();
if (tmp.compareLower(last.upper, last.upperType) > 0) {
ret.add(tmp);
last = tmp;
}
}
return ret;
}
@Override
public boolean equals(final Object object) {
if (this == object) return true;
if (object instanceof Range) {
@SuppressWarnings("unchecked")
final Range<C> comp = (Range<C>) object;
return compareLower(comp.lower, comp.lowerType) == 0 && compareUpper(comp.upper, comp.upperType) == 0
&& lowerType == comp.lowerType && upperType == comp.upperType;
}
return false;
}
@Override
public int hashCode() {
if (lower == null && upper == null) return 0;
else if (lower == null) return upper.hashCode();
else if (upper == null) return lower.hashCode();
return lower.hashCode() ^ upper.hashCode();
}
@Override
public String toString() {
if (isEmpty()) return "()";
return (lowerType == BoundType.OPEN ? "(" : "[") + (lower == null ? "" : lower.toString()) + ".."
+ (upper == null ? "" : upper.toString()) + (upperType == BoundType.OPEN ? ")" : "]");
}
}
public static class IterableRange<C> extends Range<C> implements Iterable<C> {
private static final long serialVersionUID = 9065915259748260688L;
protected UnaryOperator<C> func;
protected IterableRange(final C lower, final BoundType lowerType, final C upper, final BoundType upperType,
final UnaryOperator<C> func) {
super(lower, lowerType, upper, upperType);
this.func = func;
}
public static <C extends Comparable<? super C>> IterableRange<C> range(final C lower, final BoundType lowerType,
final C upper, final BoundType upperType, final UnaryOperator<C> func) {
if (lower == null || upper == null)
return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
final int comp = lower.compareTo(upper);
if (comp > 0) return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
else if (comp == 0 && (lowerType == BoundType.OPEN || upperType == BoundType.OPEN))
return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
return new IterableRange<>(lower, lowerType, upper, upperType, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> open(final C lower, final C upper,
final UnaryOperator<C> func) {
if (lower == null) return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
return range(func.apply(lower), BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> openClosed(final C lower, final C upper,
final UnaryOperator<C> func) {
if (lower == null) return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
return range(func.apply(lower), BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> closedOpen(final C lower, final C upper,
final UnaryOperator<C> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> closed(final C lower, final C upper,
final UnaryOperator<C> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> singleton(final C value,
final UnaryOperator<C> func) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED, func);
}
protected class Iter implements Iterator<C> {
C now;
Iter() {
now = lower;
}
@Override
public final boolean hasNext() {
return !isGreater(now);
}
@Override
public final C next() {
final C ret = now;
now = func.apply(now);
return ret;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
protected class EmptyIter implements Iterator<C> {
@Override
public boolean hasNext() {
return false;
}
@Override
public C next() {
return null;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public Iterator<C> iterator() {
return lower == null || upper == null ? new EmptyIter() : new Iter();
}
public int getDistance() {
C check = upper;
int ret = 0;
while (lower != check) {
check = func.apply(check);
++ret;
}
return ret;
}
}
public static class IntRange extends IterableRange<Integer> {
private static final long serialVersionUID = 5623995336491967216L;
private final boolean useFastIter;
private static class Next implements UnaryOperator<Integer> {
@Override
public Integer apply(final Integer value) {
return value + 1;
}
}
protected IntRange() {
super(null, BoundType.CLOSED, null, BoundType.CLOSED, new Next());
useFastIter = true;
}
protected IntRange(final UnaryOperator<Integer> func) {
super(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
useFastIter = false;
}
protected IntRange(final int lower, final BoundType lowerType, final int upper, final BoundType upperType) {
super(lower, lowerType, upper, upperType, new Next());
useFastIter = true;
}
protected IntRange(final int lower, final BoundType lowerType, final int upper, final BoundType upperType,
final UnaryOperator<Integer> func) {
super(lower, lowerType, upper, upperType, func);
useFastIter = false;
}
public static IntRange range(int lower, final BoundType lowerType, int upper, final BoundType upperType) {
if (lower > upper) return new IntRange();
if (lowerType == BoundType.OPEN) ++lower;
if (upperType == BoundType.OPEN) --upper;
return new IntRange(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static IntRange range(int lower, final BoundType lowerType, int upper, final BoundType upperType,
final UnaryOperator<Integer> func) {
if (lower > upper) return new IntRange(func);
if (lowerType == BoundType.OPEN) ++lower;
if (upperType == BoundType.OPEN) --upper;
return new IntRange(lower, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static IntRange open(final int lower, final int upper) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN);
}
public static IntRange open(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN, func);
}
public static IntRange open(final int upper) {
return range(0, BoundType.CLOSED, upper, BoundType.OPEN);
}
public static IntRange open(final int upper, final UnaryOperator<Integer> func) {
return range(0, BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static IntRange openClosed(final int lower, final int upper) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED);
}
public static IntRange openClosed(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED, func);
}
public static IntRange closedOpen(final int lower, final int upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN);
}
public static IntRange closedOpen(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static IntRange closed(final int lower, final int upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static IntRange closed(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static IntRange closed(final int upper) {
return range(0, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static IntRange closed(final int upper, final UnaryOperator<Integer> func) {
return range(0, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static IntRange singleton(final int value) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED);
}
public static IntRange singleton(final int value, final UnaryOperator<Integer> func) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED, func);
}
private class FastIter implements Iterator<Integer> {
int now;
public FastIter() {
now = lower;
}
@Override
public final boolean hasNext() {
return now <= upper;
}
@Override
public final Integer next() {
return now++;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
private class Iter implements Iterator<Integer> {
int now;
public Iter() {
now = lower;
}
@Override
public final boolean hasNext() {
return now <= upper;
}
@Override
public final Integer next() {
final int ret = now;
now = func.apply(now);
return ret;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public Iterator<Integer> iterator() {
return lower == null || upper == null ? new EmptyIter() : useFastIter ? new FastIter() : new Iter();
}
@Override
public int getDistance() {
int ret = upper - lower;
if (upperType == BoundType.CLOSED) ++ret;
return ret;
}
public int getClosedLower() { return lower; }
public int getOpenLower() { return lower - 1; }
public int getClosedUpper() { return upperType == BoundType.CLOSED ? upper : upper - 1; }
public int getOpenUpper() { return upperType == BoundType.CLOSED ? upper + 1 : upper; }
/**
* 区間スケジューリングを行います。<br>
* 計算量は要素数Nに対してO(NlogN)です。
*
* @param ranges 区間の集合
* @return 区間スケジューリングを行った際の一つの解
*/
public static List<IntRange> intScheduling(final List<IntRange> ranges) {
final PriorityQueue<IntRange> pq = new PriorityQueue<>((l, r) -> l.compareUpper(r.upper, r.upperType));
pq.addAll(ranges);
final List<IntRange> ret = new ArrayList<>();
if (pq.isEmpty()) return ret;
IntRange last = pq.poll();
ret.add(last);
while (!pq.isEmpty()) {
final IntRange tmp = pq.poll();
if (tmp.compareLower(last.upper, last.upperType) > 0) {
ret.add(tmp);
last = tmp;
}
}
return ret;
}
}
/**
* 演算が結合法則を満たすことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Associative<T> extends BinaryOperator<T> {
/**
* repeat個のelementを順次演算した値を返します。
*
* @param element 演算する値
* @param repeat 繰り返す回数、1以上であること
* @return 演算を+として、element + element + ... + elementと演算をrepeat-1回行った値
*/
public default T hyper(final T element, int repeat) {
if (repeat < 1) throw new IllegalArgumentException("undefined operation");
T ret = element;
--repeat;
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return ret;
}
}
/**
* この演算が逆元を持つことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Inverse<T> extends BinaryOperator<T> {
public T inverse(T element);
}
/**
* 演算が交換法則を満たすことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Commutative<T> extends BinaryOperator<T> {
}
/**
* 演算が単位元を持つことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Identity<T> extends BinaryOperator<T> {
/**
* 単位元を返します。
*
* @return 単位元
*/
public T identity();
}
/**
* 演算が群であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Group<T> extends Monoid<T>, Inverse<T> {
/**
* repeat個のelementを順次演算した値を返します。
*
* @param element 演算する値
* @param repeat 繰り返す回数
* @return 演算を+として、element + element + ... + elementと演算をrepeat-1回行った値
*/
@Override
public default T hyper(final T element, int repeat) {
T ret = identity();
if (repeat < 0) {
repeat = -repeat;
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return inverse(ret);
}
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return ret;
}
}
/**
* 演算がモノイドであることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Monoid<T> extends Associative<T>, Identity<T> {
/**
* repeat個のelementを順次演算した値を返します。
*
* @param element 演算する値
* @param repeat 繰り返す回数、0以上であること
* @return 演算を+として、element + element + ... + elementと演算をrepeat-1回行った値
*/
@Override
public default T hyper(final T element, int repeat) {
if (repeat < 0) throw new IllegalArgumentException("undefined operation");
T ret = identity();
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return ret;
}
}
/**
* 演算が可換モノイドであることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface CommutativeMonoid<T> extends Monoid<T>, Commutative<T> {
}
/**
* 演算がアーベル群(可換群)であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Abelian<T> extends Group<T>, CommutativeMonoid<T> {
}
/**
* 演算が半環であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface Semiring<T, A extends CommutativeMonoid<T>, M extends Monoid<T>> {
public A getAddition();
public M getMultiplication();
public default T add(final T left, final T right) {
return getAddition().apply(left, right);
}
public default T multiply(final T left, final T right) {
return getMultiplication().apply(left, right);
}
public default T additiveIdentity() {
return getAddition().identity();
}
public default T multipleIdentity() {
return getMultiplication().identity();
}
public default int characteristic() {
return 0;
}
}
/**
* 演算が環であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface Ring<T, A extends Abelian<T>, M extends Monoid<T>> extends Semiring<T, A, M> {
}
/**
* 演算が可換環に属することを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface CommutativeRing<T, A extends Abelian<T>, M extends CommutativeMonoid<T>> extends Ring<T, A, M> {
}
/**
* 演算が整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface IntegralDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends CommutativeRing<T, A, M> {
public boolean isDivisible(T left, T right);
public T divide(T left, T right);
}
/**
* 演算が整閉整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface IntegrallyClosedDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends IntegralDomain<T, A, M> {
}
/**
* 演算がGCD整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface GCDDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends IntegrallyClosedDomain<T, A, M> {
public T gcd(T left, T right);
public T lcm(T left, T right);
}
/**
* 素元を提供します。
*
* @author 31536000
*
* @param <T> 演算の型
*/
public static class PrimeElement<T> {
public final T element;
public PrimeElement(final T element) {
this.element = element;
}
}
public interface MultiSet<E> extends Collection<E> {
public int add(E element, int occurrences);
public int count(Object element);
public Set<E> elementSet();
public boolean remove(Object element, int occurrences);
public int setCount(E element, int count);
public boolean setCount(E element, int oldCount, int newCount);
}
/**
* 演算が一意分解整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface UniqueFactorizationDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends GCDDomain<T, A, M> {
public MultiSet<PrimeElement<T>> PrimeFactorization(T x);
}
/**
* 演算が主イデアル整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface PrincipalIdealDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends UniqueFactorizationDomain<T, A, M> {
}
/**
* 演算がユークリッド整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface EuclideanDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends PrincipalIdealDomain<T, A, M> {
public T reminder(T left, T right);
}
/**
* 演算が体であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface Field<T, A extends Abelian<T>, M extends Abelian<T>> extends EuclideanDomain<T, A, M> {
@Override
public default boolean isDivisible(final T left, final T right) {
return !right.equals(additiveIdentity());
}
@Override
public default T divide(final T left, final T right) {
if (isDivisible(left, right)) throw new ArithmeticException("divide by Additive Identify");
return multiply(left, getMultiplication().inverse(right));
}
@Override
public default T reminder(final T left, final T right) {
if (isDivisible(left, right)) throw new ArithmeticException("divide by Additive Identify");
return additiveIdentity();
}
@Override
public default T gcd(final T left, final T right) {
return multipleIdentity();
}
@Override
public default T lcm(final T left, final T right) {
return multipleIdentity();
}
@Override
public default MultiSet<PrimeElement<T>> PrimeFactorization(final T x) {
final HashMultiSet<PrimeElement<T>> ret = HashMultiSet.create(1);
ret.add(new PrimeElement<>(x));
return ret;
}
}
public static class HashMultiSet<E> implements MultiSet<E>, Serializable {
private static final long serialVersionUID = -8378919645386251159L;
private final transient HashMap<E, Integer> map;
private transient int size;
private HashMultiSet() {
map = new HashMap<>();
size = 0;
}
private HashMultiSet(final int distinctElements) {
map = new HashMap<>(distinctElements);
size = 0;
}
public static <E> HashMultiSet<E> create() {
return new HashMultiSet<>();
}
public static <E> HashMultiSet<E> create(final int distinctElements) {
return new HashMultiSet<>(distinctElements);
}
public static <E> HashMultiSet<E> create(final Iterable<? extends E> elements) {
final HashMultiSet<E> ret = new HashMultiSet<>();
for (final E i : elements) ret.map.compute(i, (v, e) -> e == null ? 1 : ++e);
return ret;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() { return size == 0; }
@Override
public boolean contains(final Object o) {
return map.containsKey(o);
}
private class Iter implements Iterator<E> {
private final Iterator<Entry<E, Integer>> iter = map.entrySet().iterator();
private E value;
private int count = 0;
@Override
public boolean hasNext() {
if (count > 0) return true;
if (iter.hasNext()) {
final Entry<E, Integer> entry = iter.next();
value = entry.getKey();
count = entry.getValue();
return true;
}
return false;
}
@Override
public E next() {
--count;
return value;
}
}
@Override
public Iterator<E> iterator() {
return new Iter();
}
@Override
public Object[] toArray() {
final Object[] ret = new Object[size];
int read = 0;
for (final Entry<E, Integer> i : map.entrySet()) Arrays.fill(ret, read, read += i.getValue(), i.getKey());
return ret;
}
@Override
public <T> T[] toArray(final T[] a) {
final Object[] src = toArray();
if (a.length < src.length) {
@SuppressWarnings("unchecked")
final T[] ret = (T[]) Arrays.copyOfRange(src, 0, src.length, a.getClass());
return ret;
}
System.arraycopy(src, 0, a, 0, src.length);
return a;
}
@Override
public boolean add(final E e) {
add(e, 1);
return true;
}
@Override
public boolean remove(final Object o) {
return remove(o, 1);
}
@Override
public boolean containsAll(final Collection<?> c) {
boolean ret = true;
for (final Object i : c) ret |= contains(i);
return ret;
}
@Override
public boolean addAll(final Collection<? extends E> c) {
boolean ret = false;
for (final E i : c) ret |= add(i);
return ret;
}
@Override
public boolean removeAll(final Collection<?> c) {
boolean ret = false;
for (final Object i : c) ret |= remove(i);
return ret;
}
@Override
public boolean retainAll(final Collection<?> c) {
return removeAll(c);
}
@Override
public void clear() {
map.clear();
size = 0;
}
@Override
public int add(final E element, final int occurrences) {
size += occurrences;
return map.compute(element, (k, v) -> v == null ? occurrences : v + occurrences) - occurrences;
}
@Override
public int count(final Object element) {
return map.getOrDefault(element, 0);
}
@Override
public Set<E> elementSet() {
return map.keySet();
}
public Set<Entry<E, Integer>> entrySet() {
return map.entrySet();
}
@Override
public boolean remove(final Object element, final int occurrences) {
try {
@SuppressWarnings("unchecked")
final E put = (E) element;
return map.compute(put, (k, v) -> {
if (v == null) return null;
if (v < occurrences) {
size -= v;
return null;
}
size -= occurrences;
return v - occurrences;
}) != null;
} catch (final ClassCastException E) {
return false;
}
}
@Override
public int setCount(final E element, final int count) {
final Integer ret = map.put(element, count);
final int ret2 = ret == null ? 0 : ret;
size += count - ret2;
return ret2;
}
@Override
public boolean setCount(final E element, final int oldCount, final int newCount) {
final boolean ret = map.replace(element, oldCount, newCount);
if (ret) size += newCount - oldCount;
return ret;
}
}
public static class ModInteger extends Number
implements Field<ModInteger, Abelian<ModInteger>, Abelian<ModInteger>> {
private static final long serialVersionUID = -8595710127161317579L;
private final int mod;
private int num;
private final Addition add;
private final Multiplication mul;
private class Addition implements Abelian<ModInteger> {
@Override
public ModInteger identity() {
return new ModInteger(mod, 0);
}
@Override
public ModInteger inverse(final ModInteger element) {
return new ModInteger(element, element.mod - element.num);
}
@Override
public ModInteger apply(final ModInteger left, final ModInteger right) {
return new ModInteger(left).addEqual(right);
}
}
private class Multiplication implements Abelian<ModInteger> {
@Override
public ModInteger identity() {
return new ModInteger(mod, 1);
}
@Override
public ModInteger apply(final ModInteger left, final ModInteger right) {
return new ModInteger(left).multiplyEqual(right);
}
@Override
public ModInteger inverse(final ModInteger element) {
return new ModInteger(element, element.inverse(element.num));
}
}
@Override
public int characteristic() {
return mod;
}
public ModInteger(final int mod) {
this.mod = mod;
num = 0;
add = new Addition();
mul = new Multiplication();
}
public ModInteger(final int mod, final int num) {
this.mod = mod;
this.num = validNum(num);
add = new Addition();
mul = new Multiplication();
}
public ModInteger(final ModInteger n) {
mod = n.mod;
num = n.num;
add = n.add;
mul = n.mul;
}
private ModInteger(final ModInteger n, final int num) {
mod = n.mod;
this.num = num;
add = n.add;
mul = n.mul;
}
private int validNum(int n) {
n %= mod;
if (n < 0) n += mod;
return n;
}
private int validNum(long n) {
n %= mod;
if (n < 0) n += mod;
return (int) n;
}
protected int inverse(int n) {
int m = mod, u = 0, v = 1, t;
while (n != 0) {
t = m / n;
m -= t * n;
u -= t * v;
if (m != 0) {
t = n / m;
n -= t * m;
v -= t * u;
} else {
v %= mod;
if (v < 0) v += mod;
return v;
}
}
u %= mod;
if (u < 0) u += mod;
return u;
}
public boolean isPrime(final int n) {
if ((n & 1) == 0) return false; // 偶数
for (int i = 3, j = 8, k = 9; k <= n; i += 2, k += j += 8) if (n % i == 0) return false;
return true;
}
@Override
public int intValue() {
return num;
}
@Override
public long longValue() {
return num;
}
@Override
public float floatValue() {
return num;
}
@Override
public double doubleValue() {
return num;
}
protected ModInteger getNewInstance(final ModInteger mod) {
return new ModInteger(mod);
}
public ModInteger add(final int n) {
return getNewInstance(this).addEqual(n);
}
public ModInteger add(final long n) {
return getNewInstance(this).addEqual(n);
}
public ModInteger add(final ModInteger n) {
return getNewInstance(this).addEqual(n);
}
public ModInteger addEqual(final int n) {
num = validNum(num + n);
return this;
}
public ModInteger addEqual(final long n) {
num = validNum(num + n);
return this;
}
public ModInteger addEqual(final ModInteger n) {
if ((num += n.num) >= mod) num -= mod;
return this;
}
public ModInteger subtract(final int n) {
return getNewInstance(this).subtractEqual(n);
}
public ModInteger subtract(final long n) {
return getNewInstance(this).subtractEqual(n);
}
public ModInteger subtract(final ModInteger n) {
return getNewInstance(this).subtractEqual(n);
}
public ModInteger subtractEqual(final int n) {
num = validNum(num - n);
return this;
}
public ModInteger subtractEqual(final long n) {
num = validNum(num - n);
return this;
}
public ModInteger subtractEqual(final ModInteger n) {
if ((num -= n.num) < 0) num += mod;
return this;
}
public ModInteger multiply(final int n) {
return getNewInstance(this).multiplyEqual(n);
}
public ModInteger multiply(final long n) {
return getNewInstance(this).multiplyEqual(n);
}
public ModInteger multiply(final ModInteger n) {
return getNewInstance(this).multiplyEqual(n);
}
public ModInteger multiplyEqual(final int n) {
num = (int) ((long) num * n % mod);
if (num < 0) num += mod;
return this;
}
public ModInteger multiplyEqual(final long n) {
return multiplyEqual((int) (n % mod));
}
public ModInteger multiplyEqual(final ModInteger n) {
num = (int) ((long) num * n.num % mod);
return this;
}
public ModInteger divide(final int n) {
return getNewInstance(this).divideEqual(n);
}
public ModInteger divide(final long n) {
return getNewInstance(this).divideEqual(n);
}
public ModInteger divide(final ModInteger n) {
return getNewInstance(this).divideEqual(n);
}
public ModInteger divideEqual(final int n) {
num = (int) ((long) num * inverse(validNum(n)) % mod);
return this;
}
public ModInteger divideEqual(final long n) {
return divideEqual((int) (n % mod));
}
public ModInteger divideEqual(final ModInteger n) {
num = (int) ((long) num * n.inverse(n.num) % mod);
return this;
}
public ModInteger pow(final int n) {
return getNewInstance(this).powEqual(n);
}
public ModInteger pow(final long n) {
return getNewInstance(this).powEqual(n);
}
public ModInteger pow(final ModInteger n) {
return getNewInstance(this).powEqual(n);
}
public ModInteger powEqual(int n) {
long ans = 1, num = this.num;
if (n < 0) {
n = -n;
while (n != 0) {
if ((n & 1) != 0) ans = ans * num % mod;
n >>>= 1;
num = num * num % mod;
}
this.num = inverse((int) ans);
return this;
}
while (n != 0) {
if ((n & 1) != 0) ans = ans * num % mod;
n >>>= 1;
num = num * num % mod;
}
this.num = (int) ans;
return this;
}
public ModInteger powEqual(final long n) {
return powEqual((int) (n % (mod - 1)));
}
public ModInteger powEqual(final ModInteger n) {
long num = this.num;
this.num = 1;
int mul = n.num;
while (mul != 0) {
if ((mul & 1) != 0) this.num *= num;
mul >>>= 1;
num *= num;
num %= mod;
}
return this;
}
public ModInteger equal(final int n) {
num = validNum(n);
return this;
}
public ModInteger equal(final long n) {
num = validNum(n);
return this;
}
public ModInteger equal(final ModInteger n) {
num = n.num;
return this;
}
public int toInt() {
return num;
}
public int getMod() { return mod; }
@Override
public boolean equals(final Object x) {
if (x instanceof ModInteger) return ((ModInteger) x).num == num && ((ModInteger) x).mod == mod;
return false;
}
@Override
public int hashCode() {
return num ^ mod;
}
@Override
public String toString() {
return String.valueOf(num);
}
@Deprecated
public String debug() {
int min = num, ans = 1;
for (int i = 2; i < min; ++i) {
final int tmp = multiply(i).num;
if (min > tmp) {
min = tmp;
ans = i;
}
}
return min + "/" + ans;
}
@Override
public Addition getAddition() { return add; }
@Override
public Multiplication getMultiplication() { return mul; }
}
/**
* 素数を法とする演算上で、組み合わせの計算を高速に行います。
*
* @author 31536000
*
*/
public static class ModUtility {
private final int mod;
private int[] fact, inv, invfact;
/**
* modを法として、演算を行います。
*
* @param mod 法とする素数
*/
public ModUtility(final Prime mod) {
this(mod, 2);
}
/**
* modを法として、演算を行います。
*
* @param mod 法とする素数
* @param calc 予め前計算しておく大きさ
*/
public ModUtility(final Prime mod, final int calc) {
this.mod = mod.prime;
precalc(calc);
}
/**
* calcの大きさだけ、前計算を行います。
*
* @param calc 前計算をする大きさ
*/
public void precalc(int calc) {
++calc;
if (calc < 2) calc = 2;
if (calc > mod) calc = mod;
fact = new int[calc];
inv = new int[calc];
invfact = new int[calc];
fact[0] = invfact[0] = fact[1] = invfact[1] = inv[1] = 1;
for (int i = 2; i < calc; ++i) {
fact[i] = (int) ((long) fact[i - 1] * i % mod);
inv[i] = (int) (mod - (long) inv[mod % i] * (mod / i) % mod);
invfact[i] = (int) ((long) invfact[i - 1] * inv[i] % mod);
}
}
/**
* modを法とする剰余環上で振舞う整数を返します。
*
* @return modを法とする整数、初期値は0
*/
public ModInteger create() {
return new ModInt();
}
/**
* modを法とする剰余環上で振舞う整数を返します。
*
* @param n 初期値
* @return modを法とする整数
*/
public ModInteger create(final int n) {
return new ModInt(n);
}
private class ModInt extends ModInteger {
private static final long serialVersionUID = -2435281861935422575L;
public ModInt() {
super(mod);
}
public ModInt(final int n) {
super(mod, n);
}
public ModInt(final ModInteger mod) {
super(mod);
}
@Override
protected ModInteger getNewInstance(final ModInteger mod) {
return new ModInt(mod);
}
@Override
protected int inverse(final int n) {
return ModUtility.this.inverse(n);
}
}
/**
* modを法として、nの逆元を返します。<br>
* 計算量はO(log n)です。
*
* @param n 逆元を求めたい値
* @return 逆元
*/
public int inverse(int n) {
try {
if (inv.length > n) return inv[n];
int m = mod, u = 0, v = 1, t;
while (n != 0) {
t = m / n;
m -= t * n;
u -= t * v;
if (m != 0) {
t = n / m;
n -= t * m;
v -= t * u;
} else {
v %= mod;
if (v < 0) v += mod;
return v;
}
}
u %= mod;
if (u < 0) u += mod;
return u;
} catch (final ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException();
}
}
/**
* n!を、modを法として求めた値を返します。<br>
* 計算量はO(n)です。
*
* @param n 階乗を求めたい値
* @return nの階乗をmodで割った余り
*/
public int factorial(final int n) {
try {
if (fact.length > n) return fact[n];
long ret = fact[fact.length - 1];
for (int i = fact.length; i <= n; ++i) ret = ret * i % mod;
return (int) ret;
} catch (final ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException();
}
}
/**
* nPkをmodで割った余りを求めます。<br>
* 計算量はO(n-k)です。
*
* @param n 左辺
* @param k 右辺
* @return nPkをmodで割った余り
*/
public int permutation(final int n, final int k) {
if (n < 0) throw new IllegalArgumentException();
if (n < k) return 0;
if (fact.length > n) return (int) ((long) fact[n] * invfact[n - k] % mod);
long ret = 1;
for (int i = n - k + 1; i <= n; ++i) ret = ret * i % mod;
return (int) ret;
}
/**
* nCkをmodで割った余りを求めます。<br>
* 計算量はO(min(plogn, n-k))です。
*
* @param n 左辺
* @param k 右辺
* @return nCkをmodで割った余り
*/
public int combination(int n, int k) {
if (n < 0) throw new IllegalArgumentException();
if (n < k) return 0;
if (fact.length > n) return (int) ((long) fact[n] * invfact[k] % mod * invfact[n - k] % mod);
long ret = 1;
if (n >= mod) {
if (mod == 2) return (~n & k) == 0 ? 1 : 0;
while (n > 0) {
ret = ret * combination(n % mod, k % mod) % mod;
n /= mod;
k /= mod;
}
return (int) ret;
}
if (n < 2 * k) k = n - k;
ret = invfact.length > k ? invfact[k] : inverse(factorial(k));
for (int i = n - k + 1; i <= n; ++i) ret = ret * i % mod;
return (int) ret;
}
/**
* 他項係数をmodで割った余りを求めます。<br>
* ] 計算量はO(n)です。
*
* @param n 左辺
* @param k 右辺、合計がn以下である必要がある
* @return 他項係数
*/
public int multinomial(final int n, final int... k) {
int sum = 0;
long ret = factorial(n);
if (fact.length > n) {
for (final int i : k) {
if (i < 0) throw new IllegalArgumentException();
ret = ret * invfact[i] % mod;
sum += i;
}
if (sum > n) return 0;
ret = ret * invfact[n - sum] % mod;
} else {
for (final int i : k) {
if (i < 0) throw new IllegalArgumentException();
if (invfact.length > i) ret = ret * invfact[i] % mod;
else ret = ret * inverse(factorial(i)) % mod;
sum += i;
}
if (sum > n) return 0;
if (invfact.length > n - sum) ret = ret * invfact[n - sum] % mod;
else ret = ret * inverse(factorial(n - sum)) % mod;
}
return (int) ret;
}
/**
* n個からk個を選ぶ重複組み合わせnHkをmodで割った余りを求めます。<br>
* 計算量はO(min(n, k))です。
*
* @param n 左辺
* @param k 右辺
* @return nHkをmodで割った余り
*/
public int multichoose(final int n, final int k) {
return combination(mod(n + k - 1), k);
}
/**
* カタラン数C(n)をmodで割った余りを求めます。<br>
* 計算量はO(n)です。
*
* @param n 求めたいカタラン数の番号
* @return カタラン数
*/
public int catalan(final int n) {
return divide(combination(mod(2 * n), n), mod(n + 1));
}
/**
* 第一種スターリング数S(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(nk)です。 // TODO NTTを使うとO(n log n)、未実装
*
* @param n 左辺
* @param k 右辺
* @return S(n, k)をmodで割った余り
*/
public int firstStirling(final int n, final int k) {
final int[] stirling = new int[(n + 1) * (k + 1)];
stirling[0] = 1;
final int h = k + 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j) {
final int tmp = stirling[i * h + j] + (int) ((long) i * stirling[i * h + j + 1] % mod);
stirling[(i + 1) * h + j + 1] = tmp >= mod ? tmp - mod : tmp;
}
}
return stirling[stirling.length - 1];
}
/**
* 第二種スターリング数S(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(k)です。
*
* @param n 左辺
* @param k 右辺
* @return S(n, k)をmodで割った余り
*/
public int secondStirling(final int n, final int k) {
if (k == 0) return n == 0 ? 1 : 0;
final int[] sieve = new int[k + 1], prime = new int[k + 1];
int size = 0;
sieve[1] = 1;
for (int i = 2; i <= k; ++i) {
if (sieve[i] == 0) prime[size++] = sieve[i] = i;
for (int j = 0, s; j < size && prime[j] <= sieve[i] && (s = i * prime[j]) <= k; ++j)
sieve[s] = prime[j];
}
long ans = 0;
for (int i = 1, s; i <= k; ++i) {
final long tmp = (long) combination(k, i)
* (prime[i] = (s = sieve[i]) == i ? pow(i, n) : (int) ((long) prime[s] * prime[i / s] % mod))
% mod;
ans += (k - i & 1) != 0 ? -tmp : tmp;
}
return (int) ((long) mod(ans) * invfact[k] % mod);
}
/**
* ベル数B(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(k)です。
*
* @param n 左辺
* @param k 右辺
* @return B(n, k)をmodで割った余り
*/
public int bell(final int n, final int k) {
if (k == 0) return n == 0 ? 1 : 0;
final int[] sieve = new int[k + 1], prime = new int[k + 1];
int size = 0;
sieve[1] = 1;
long sum = 0;
for (int i = 2; i <= k; ++i) {
if (sieve[i] == 0) prime[size++] = sieve[i] = i;
for (int j = 0, s; j < size && prime[j] <= sieve[i] && (s = i * prime[j]) <= k; ++j)
sieve[s] = prime[j];
sum += (i & 1) != 0 ? -invfact[i] : invfact[i];
}
sum = mod(sum);
long ans = 0;
for (int i = 0, s; i <= k; ++i) {
final long tmp = (long) (prime[i] = (s = sieve[i]) == i ? pow(i, n)
: (int) ((long) prime[s] * prime[i / s] % mod)) * invfact[i] % mod;
ans += tmp * sum % mod;
if ((sum -= (k - i & 1) != 0 ? -invfact[k - i] : invfact[k - i]) < 0) sum += mod;
}
return mod(ans);
}
/**
* ベル数B(n)をmodで割った余りを求めます。<br>
* 計算量はO(n)です。
*
* @param n 求めたいベル数の番号
* @return B(n)
*/
public int bell(final int n) {
return bell(n, n);
}
/**
* 分割数P(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(nk)です。 // TODO NTTを使うとO(n log n)、未実装
*
* @param n 左辺
* @param k 右辺
* @return P(n, k)をmodで割った余り
*/
public int pertition(final int n, final int k) {
final int[] pertition = new int[(n + 1) * (k + 1)];
pertition[0] = 1;
final int h = k + 1;
for (int i = 0; i <= n; ++i) {
for (int j = 1, l = Math.min(i, k); j <= l; ++j)
pertition[i * h + j] = pertition[i * h + j - 1] + pertition[(i - j) * h + j];
for (int j = i; j < k; ++j) pertition[i * h + j + 1] = pertition[i * h + j];
}
return pertition[n * h + k];
}
/**
* 分割数P(n)をmodで割った余りを求めます。<br>
* 計算量はO(n sqrt(n))です。 // TODO NTTを使うとO(n log n)、未実装
*
* @param n 求めたい分割数の番号
* @return P(n)
*/
public int pertition(final int n) {
final long[] pertition = new long[n + 1];
pertition[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1, t; (t = i - (j * (3 * j - 1) >> 1)) >= 0; ++j) {
pertition[i] += (j & 1) != 0 ? pertition[t] : -pertition[t];
}
for (int j = 1, t; (t = i - (j * (3 * j + 1) >> 1)) >= 0; ++j) {
pertition[i] += (j & 1) != 0 ? pertition[t] : -pertition[t];
}
pertition[i] %= mod;
}
return (int) pertition[n];
}
/**
* nのm乗をmodで割った余りを求めます。<br>
* 計算量はO(log m)です。
*
* @param n 床
* @param m 冪指数
* @return n^mをmodで割った余り
*/
public int pow(final int n, int m) {
long ans = 1, num = n;
if (m < 0) {
m = -m;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % mod;
m >>>= 1;
num = num * num % mod;
}
return inverse((int) ans);
}
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % mod;
m >>>= 1;
num = num * num % mod;
}
return (int) ans;
}
/**
* nのm乗をmodで割った余りを求めます。<br>
* 計算量はO(log m)です。
*
* @param n 床
* @param m 冪指数
* @return n^mをmodで割った余り
*/
public int pow(final long n, final long m) {
return pow((int) (n % mod), (int) (m % (mod - 1)));
}
/**
* 現在のmod値のトーシェント数を返します。<br>
* なお、これはmod-1に等しいです。
*
* @return トーシェント数
*/
public int totient() {
return mod - 1;
}
/**
* nのトーシェント数を返します。<br>
* 計算量はO(sqrt n)です。
*
* @param n トーシェント数を求めたい値
* @return nのトーシェント数
*/
public static int totient(int n) {
int totient = n;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
totient = totient / i * (i - 1);
while ((n %= i) % i == 0);
}
}
if (n != 1) totient = totient / n * (n - 1);
return totient;
}
/**
* nをmodで割った余りを返します。
*
* @param n 演算する値
* @return nをmodで割った余り
*/
public int mod(int n) {
return (n %= mod) < 0 ? n + mod : n;
}
/**
* nをmodで割った余りを返します。
*
* @param n 演算する値
* @return nをmodで割った余り
*/
public int mod(long n) {
return (int) ((n %= mod) < 0 ? n + mod : n);
}
/**
* nをmodで割った余りを返します。
*
* @param n 演算する値
* @return nをmodで割った余り
*/
public int mod(final PrimeFactor n) {
int ret = 1;
for (final Entry<Prime, Integer> i : n.primeFactor.entrySet())
ret = multiply(ret, pow(i.getKey().prime, i.getValue()));
return ret;
}
/**
* n+mをmodで割った余りを返します。
*
* @param n 足される値
* @param m 足す値
* @return n+mをmodで割った余り
*/
public int add(final int n, final int m) {
return mod(n + m);
}
/**
* n-mをmodで割った余りを返します。
*
* @param n 引かれる値
* @param m 引く値
* @return n-mをmodで割った余り
*/
public int subtract(final int n, final int m) {
return mod(n - m);
}
/**
* n*mをmodで割った余りを返します。
*
* @param n 掛けられる値
* @param m 掛ける値
* @return n*mをmodで割った余り
*/
public int multiply(final int n, final int m) {
final int ans = (int) ((long) n * m % mod);
return ans < 0 ? ans + mod : ans;
}
/**
* n/mをmodで割った余りを返します。
*
* @param n 割られる値
* @param m 割る値
* @return n/mをmodで割った余り
*/
public int divide(final int n, final int m) {
return multiply(n, inverse(m));
}
/**
* fを通ることが分かっているfの要素数-1次の関数について、xの位置における値をmodで割った余りを返します。<br>
* 計算量はO(f)です。
*
* @param f 関数の形
* @param x 求める位置
* @return 求めたい値をmodで割った余り
*/
public ModInteger lagrangePolynomial(final ModInteger[] f, final int x) {
if (f.length > x) return f[x];
if (x > fact.length) precalc(x);
final ModInteger ret = create(0);
final ModInteger[] dp = new ModInteger[f.length], dp2 = new ModInteger[f.length];
dp[0] = create(1);
dp2[f.length - 1] = create(1);
for (int i = 1; i < f.length; ++i) {
dp[i] = dp[i - 1].multiply(x - i - 1);
dp2[f.length - i - 1] = dp2[f.length - i].multiply(x - f.length + i);
}
for (int i = 0; i < f.length; ++i) {
final ModInteger tmp = f[i].multiply(dp[i]).multiplyEqual(dp2[i]).multiplyEqual(inv[i])
.multiplyEqual(inv[f.length - 1 - i]);
if ((f.length - i & 1) == 0) ret.addEqual(tmp);
else ret.subtractEqual(tmp);
}
return ret;
}
/**
* 与えられた配列に対し、その配列を並び替えることで構成できる配列の集合をSとします。
* このとき、arrayがSを辞書順に並べると何番目かを求めます。
* @complexity N=array.length として O(N log N)
* @param array 辞書順で何番目か求めたい配列
* @return arrayが辞書順で何番目か
*/
public ModInteger permutationNumber(int[] array) {
int[] compress = ArrayUtility.compress(array);
int[] bucket = new int[array.length];
for (int i : compress) ++bucket[i];
int sum = multinomial(array.length, bucket);
int[] bit = new int[array.length + 1];
for (int i = 0; i < array.length; ++i)
for (int j = i + 1, add = bucket[i]; j < bit.length; j += j & -j) bit[j] += add;
int ans = 1;
for (int i = 0; i < array.length; ++i) {
sum = divide(sum, array.length - i);
int comp = compress[i];
int min = 0;
for (int j = comp; j != 0; j -= j & -j) min += bit[j];
ans = add(ans, multiply(sum, min));
sum = multiply(sum, bucket[comp]--);
for (int j = comp + 1; j < bit.length; j += j & -j) --bit[j];
}
return create(ans);
}
}
/**
* 区間における素数を保持する関数です。
*
* @author 31536000
*
*/
public static class SegmentPrime {
private final Prime[] divisor;
private final int offset;
private SegmentPrime(final Prime[] divisor, final int offset) {
this.divisor = divisor;
this.offset = offset;
}
/**
* このクラスが持つ区間の範囲を返します。
*
* @return 素数を保持している区間
*/
public IntRange getRange() { return IntRange.closedOpen(offset, offset + divisor.length); }
/**
* 素数かどうかを判定します。
*
* @param n 素数かどうか判定したい数
* @return 素数ならばtrue
*/
public boolean isPrime(final int n) {
return n <= 1 ? false : divisor[n - offset].prime == n;
}
/**
* 与えられた数を素因数分解します。<br>
* 計算量はO(log n)です。
*
* @param n 素因数分解したい数
* @return 素因数分解した結果
*/
public PrimeFactor getPrimeFactor(int n) {
if (n < 1) throw new IllegalArgumentException("not positive number");
final Map<Prime, Integer> map = new HashMap<>();
while (n > 1) {
final Prime d = divisor[n - offset];
map.compute(d, (k, v) -> v == null ? 1 : v + 1);
n /= d.prime;
}
return new PrimeFactor(map);
}
@Override
public String toString() {
return "SegmentPrime: [" + offset + ", " + (offset + divisor.length) + ")";
}
}
/**
* 整数の素因数分解表現を保持します。
*
* @author 31536000
*
*/
public static class PrimeFactor extends Number {
private static final long serialVersionUID = 1363575672283884773L;
public Map<Prime, Integer> primeFactor;
private PrimeFactor(final Map<Prime, Integer> n) {
primeFactor = n;
}
/**
* 素因数分解のリスト表現を返します。
*
* @return 素因数分解のリスト
*/
public List<Integer> getFactorizationList() {
final List<Integer> ret = new ArrayList<>();
for (final Entry<Prime, Integer> i : primeFactor.entrySet()) {
final int p = i.getKey().prime, n = i.getValue();
for (int j = 0; j < n; ++j) ret.add(p);
}
return ret;
}
/**
* nとgcdを取った値を保持します。
*
* @param n gcdを取りたい値
*/
public void gcd(final PrimeFactor n) {
for (final Entry<Prime, Integer> i : n.primeFactor.entrySet())
primeFactor.computeIfPresent(i.getKey(), (k, v) -> Math.min(v, i.getValue()));
}
/**
* gcd(n, m)を返します。
*
* @param n gcdを取りたい値
* @param m gcdを取りたい値
* @return gcd(n, m)
*/
public static PrimeFactor gcd(final PrimeFactor n, final PrimeFactor m) {
final Map<Prime, Integer> ret = new HashMap<>(n.primeFactor);
for (final Entry<Prime, Integer> i : m.primeFactor.entrySet())
ret.computeIfPresent(i.getKey(), (k, v) -> Math.min(v, i.getValue()));
return new PrimeFactor(ret);
}
/**
* nとlcmを取った値を保持します。
*
* @param n lcmを取りたい値
*/
public void lcm(final PrimeFactor n) {
for (final Entry<Prime, Integer> i : n.primeFactor.entrySet())
primeFactor.merge(i.getKey(), i.getValue(), (v1, v2) -> Math.max(v1, v2));
}
/**
* lcm(n, m)を返します。
*
* @param n lcmを取りたい値
* @param m lcmを取りたい値
* @return lcm(n, m)
*/
public static PrimeFactor lcm(final PrimeFactor n, final PrimeFactor m) {
final Map<Prime, Integer> ret = new HashMap<>(n.primeFactor);
for (final Entry<Prime, Integer> i : m.primeFactor.entrySet())
ret.merge(i.getKey(), i.getValue(), (v1, v2) -> Math.max(v1, v2));
return new PrimeFactor(ret);
}
private static int pow(final int p, int n) {
int ans = 1;
for (int mul = p; n > 0; n >>= 1, mul *= mul) if ((n & 1) != 0) ans *= mul;
return ans;
}
private static long pow(final long p, long n) {
long ans = 1;
for (long mul = p; n > 0; n >>= 1, mul *= mul) if ((n & 1) != 0) ans *= mul;
return ans;
}
public BigInteger getValue() {
BigInteger ret = BigInteger.ONE;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret = ret.multiply(new BigInteger(i.getKey().toString()).pow(i.getValue()));
return ret;
}
@Override
public int intValue() {
int ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet()) ret *= pow(i.getKey().prime, i.getValue());
return ret;
}
@Override
public long longValue() {
long ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret *= pow((long) i.getKey().prime, i.getValue());
return ret;
}
@Override
public float floatValue() {
float ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret *= Math.pow(i.getKey().prime, i.getValue());
return ret;
}
@Override
public double doubleValue() {
long ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret *= Math.pow(i.getKey().prime, i.getValue());
return ret;
}
@Override
public boolean equals(final Object o) {
return o instanceof PrimeFactor ? ((PrimeFactor) o).primeFactor.equals(primeFactor) : false;
}
@Override
public int hashCode() {
return primeFactor.hashCode();
}
@Override
public String toString() {
return primeFactor.toString();
}
}
/**
* 素数を渡すためのクラスです。<br>
* 中身が確実に素数であることを保証するときに使ってください。
*
* @author 31536000
*
*/
public static class Prime extends Number {
private static final long serialVersionUID = 8216169308184181643L;
public final int prime;
/**
* 素数を設定します。
*
* @param prime 素数
* @throws IllegalArgumentException 素数以外を渡した時
*/
public Prime(final int prime) {
if (!isPrime(prime)) throw new IllegalArgumentException(prime + " is not prime");
this.prime = prime;
}
private Prime(final int prime, final boolean none) {
this.prime = prime;
}
private static final int bases[] = { 15591, 2018, 166, 7429, 8064, 16045, 10503, 4399, 1949, 1295, 2776, 3620,
560, 3128, 5212, 2657, 2300, 2021, 4652, 1471, 9336, 4018, 2398, 20462, 10277, 8028, 2213, 6219, 620,
3763, 4852, 5012, 3185, 1333, 6227, 5298, 1074, 2391, 5113, 7061, 803, 1269, 3875, 422, 751, 580, 4729,
10239, 746, 2951, 556, 2206, 3778, 481, 1522, 3476, 481, 2487, 3266, 5633, 488, 3373, 6441, 3344, 17,
15105, 1490, 4154, 2036, 1882, 1813, 467, 3307, 14042, 6371, 658, 1005, 903, 737, 1887, 7447, 1888,
2848, 1784, 7559, 3400, 951, 13969, 4304, 177, 41, 19875, 3110, 13221, 8726, 571, 7043, 6943, 1199, 352,
6435, 165, 1169, 3315, 978, 233, 3003, 2562, 2994, 10587, 10030, 2377, 1902, 5354, 4447, 1555, 263,
27027, 2283, 305, 669, 1912, 601, 6186, 429, 1930, 14873, 1784, 1661, 524, 3577, 236, 2360, 6146, 2850,
55637, 1753, 4178, 8466, 222, 2579, 2743, 2031, 2226, 2276, 374, 2132, 813, 23788, 1610, 4422, 5159,
1725, 3597, 3366, 14336, 579, 165, 1375, 10018, 12616, 9816, 1371, 536, 1867, 10864, 857, 2206, 5788,
434, 8085, 17618, 727, 3639, 1595, 4944, 2129, 2029, 8195, 8344, 6232, 9183, 8126, 1870, 3296, 7455,
8947, 25017, 541, 19115, 368, 566, 5674, 411, 522, 1027, 8215, 2050, 6544, 10049, 614, 774, 2333, 3007,
35201, 4706, 1152, 1785, 1028, 1540, 3743, 493, 4474, 2521, 26845, 8354, 864, 18915, 5465, 2447, 42,
4511, 1660, 166, 1249, 6259, 2553, 304, 272, 7286, 73, 6554, 899, 2816, 5197, 13330, 7054, 2818, 3199,
811, 922, 350, 7514, 4452, 3449, 2663, 4708, 418, 1621, 1171, 3471, 88, 11345, 412, 1559, 194 };
private static final byte wheel[] = { 10, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4,
2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2, 10, 2 };
private static boolean isSPRP(final int n, long a) {
int d = n - 1, s = 0;
while ((d & 1) == 0) {
++s;
d >>= 1;
}
long cur = 1, pw = d;
do {
if ((pw & 1) != 0) cur = cur * a % n;
a = a * a % n;
pw >>= 1;
} while (pw != 0);
if (cur == 1) return true;
for (int r = 0; r < s; ++r) {
if (cur == n - 1) return true;
cur = cur * cur % n;
}
return false;
}
/**
* 与えられた値が素数か否かを判定します。<br>
* この実装はhttp://ceur-ws.org/Vol-1326/020-Forisek.pdfに基づきます。
*
* @param x 判定したい値
* @return xが素数ならtrue
*/
public static boolean isPrime(final int x) {
if (x == 2 || x == 3 || x == 5 || x == 7) return true;
if ((x & 1) == 0 || x % 3 == 0 || x % 5 == 0 || x % 7 == 0) return false;
return checkPrime(x);
}
private static boolean checkPrime(final int x) {
if (x < 121) return x > 1;
long h = x;
h = (h >> 16 ^ h) * 0x45d9f3b;
h = (h >> 16 ^ h) * 0x45d9f3b;
h = (h >> 16 ^ h) & 0xFF;
return isSPRP(x, bases[(int) h]);
}
/**
* 区間における素数を列挙します。<br>
* この実装はエラトステネスの篩に基づきます。
*
* @param n 素数を求める範囲
* @return 1以上n以下の素数を保持する区間素数
*/
public static SegmentPrime getSegmentPrime(final int n) {
final Prime[] divisor = new Prime[n - 1];
final int sqrt = (int) Math.sqrt(n) + 1;
for (int i = 0; i < sqrt; ++i) {
if (divisor[i] != null) continue;
final int p = i + 2;
divisor[i] = new Prime(p, true);
for (int j = p * p - 2; j < divisor.length; j += p) divisor[j] = divisor[i];
}
for (int i = sqrt; i < divisor.length; ++i) if (divisor[i] == null) divisor[i] = new Prime(i + 2, true);
return new SegmentPrime(divisor, 2);
}
/**
* 与えられた値を素因数分解した結果を返します。
*
* @param x 素因数分解する値
* @return 素因数分解した結果
*/
public static PrimeFactor getPrimeFactor(int x) {
if (x <= 0) throw new IllegalArgumentException("non positive number: " + x);
final Map<Prime, Integer> ret = new TreeMap<>((l, r) -> Integer.compare(l.prime, r.prime));
int c;
if ((x & 1) == 0) {
c = 1;
for (x >>= 1; (x & 1) == 0; x >>= 1) ++c;
ret.put(new Prime(2, false), c);
}
if (x % 3 == 0) {
c = 1;
for (x /= 3; x % 3 == 0; x /= 3) ++c;
ret.put(new Prime(3, false), c);
}
if (x % 5 == 0) {
c = 1;
for (x /= 5; x % 5 == 0; x /= 5) ++c;
ret.put(new Prime(5, false), c);
}
if (x % 7 == 0) {
c = 1;
for (x /= 7; x % 7 == 0; x /= 7) ++c;
ret.put(new Prime(7, false), c);
}
if (x < 100000000) { // Wheel Factorization
for (int i = 11, j = 0; i * i <= x; i += wheel[++j % wheel.length]) {
while (x % i == 0) {
x /= i;
ret.compute(new Prime(i, false), (k, v) -> v == null ? 1 : v + 1);
}
}
if (x != 1) ret.put(new Prime(x, false), 1);
} else {
int p, count;
while (x != 1) { // 素因数分解が終わってる
for (p = x; !checkPrime(p); p = pollardRho(p, 1));
final Prime prime = new Prime(p, false);
count = 1;
for (x /= p; x % p == 0; x /= p) ++count;
ret.put(prime, count);
}
}
return new PrimeFactor(ret);
}
private static int gcd(int n, int m) {
while (n != 0) if ((m %= n) != 0) n %= m;
else return n;
return m;
}
private static int pollardRho(final int x, int c) {
int n = 2, m = 2, d = 1, next = 4, i = 1;
do {
if (++i == next) {
m = n;
next <<= 1;
}
if ((n = (int) (((long) n * n + c) % x)) == m) return pollardRho(x, ++c); // 失敗したので
} while ((d = gcd(Math.abs(n - m), x)) == 1);// dは約数の一つ
return d;
}
@Override
public int intValue() {
return prime;
}
@Override
public long longValue() {
return prime;
}
@Override
public float floatValue() {
return prime;
}
@Override
public double doubleValue() {
return prime;
}
@Override
public boolean equals(final Object o) {
return o instanceof Prime ? ((Prime) o).prime == prime : false;
}
@Override
public int hashCode() {
return prime;
}
@Override
public String toString() {
return String.valueOf(prime);
}
}
public static class AbstractArray<T> extends AbstractList<T> implements RandomAccess {
private final Object[] array;
public AbstractArray(final int size) {
array = new Object[size];
}
public AbstractArray(final T[] array) {
this(array.length);
System.arraycopy(array, 0, this.array, 0, array.length);
}
@Override
public T set(final int index, final T element) {
final T ret = get(index);
array[index] = element;
return ret;
}
@Override
public T get(final int index) {
@SuppressWarnings("unchecked")
final T ret = (T) array[index];
return ret;
}
public Object[] get() {
return array;
}
public T[] get(final T[] array) {
if (array.length < this.array.length) {
@SuppressWarnings("unchecked")
final T[] ret = (T[]) Arrays.copyOfRange(this.array, 0, this.array.length, array.getClass());
return ret;
}
System.arraycopy(this.array, 0, array, 0, this.array.length);
return array;
}
@Override
public int size() {
return array.length;
}
public int length() {
return size();
}
@Override
public int hashCode() {
return Arrays.hashCode(array);
}
private class Iter implements Iterator<T> {
private int index;
private Iter() {
index = 0;
}
@Override
public boolean hasNext() {
return index < array.length;
}
@Override
public T next() {
return get(index++);
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public Iterator<T> iterator() {
return new Iter();
}
}
public static class Array<T> extends AbstractArray<T> implements Serializable {
private static final long serialVersionUID = 2749604433067098063L;
public Array(final int size) {
super(size);
}
public Array(final T[] array) {
super(array);
}
public T front() {
return get(0);
}
public T back() {
return get(size() - 1);
}
}
/**
* 要素とそのindexを管理するクラスです。
*
* @author 31536000
*
* @param <E> 保持する要素
*/
public static class Enumerate<E> {
public final E value;
public final int index;
/**
* 要素とそのindexを渡します。<br>
* indexは必ずしも元の配列またはコレクションのindexと一致する必要はありませんが、一致する値を返すことが推奨されます。
*
* @param value
* @param index
*/
public Enumerate(final E value, final int index) {
this.value = value;
this.index = index;
}
/**
* 要素を返します。
*
* @return 要素
*/
public E getValue() { return value; }
/**
* indexを返します。
*
* @return index
*/
public int getIndex() { return index; }
@Override
public boolean equals(final Object o) {
if (o instanceof Enumerate)
return ((Enumerate<?>) o).getValue().equals(value) && ((Enumerate<?>) o).getIndex() == index;
return false;
}
@Override
public int hashCode() {
return value.hashCode() ^ index;
}
@Override
public String toString() {
return "{" + value.toString() + ", " + index + "}";
}
}
/**
* 要素とそのindexを効率的に取得する関数を提供します。
*
* @author 31536000
*
*/
public static class Enumeration {
private static class IteratorArray<E> implements Iterator<Enumerate<E>> {
private final E[] array;
private final int start;
private int index;
public IteratorArray(final E[] array, final int index) {
this.array = array;
start = index;
this.index = 0;
}
@Override
public boolean hasNext() {
return index < array.length;
}
@Override
public Enumerate<E> next() {
final Enumerate<E> ret = new Enumerate<>(array[index], index++ + start);
return ret;
}
}
private static class IteratorCollection<E> implements Iterator<Enumerate<E>> {
private final Iterator<E> iter;
private int start;
public IteratorCollection(final Iterator<E> iter, final int index) {
this.iter = iter;
start = index;
}
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public Enumerate<E> next() {
final Enumerate<E> ret = new Enumerate<>(iter.next(), start++);
return ret;
}
}
/**
* 配列の各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> 配列の型
* @param array 配列
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final E[] array) {
return enumerate(array, 0);
}
/**
* 配列の各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> 配列の型
* @param array 配列
* @param start 添字の初期値、この値だけindexが足されたものが返る
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final E[] array, final int start) {
if (array == null) throw new NullPointerException("array is null");
return new IteratorArray<>(array, start);
}
/**
* Iteratorの各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> Iteratorの型
* @param iter Iterator
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final Iterator<E> iter) {
return enumerate(iter, 0);
}
/**
* Iteratorの各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> Iteratorの型
* @param iter Iterator
* @param start 添字の初期値、この値だけindexが足されたものが返る
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final Iterator<E> iter, final int start) {
if (iter == null) throw new NullPointerException("iterator is null");
return new IteratorCollection<>(iter, start);
}
}
/**
* このクラスは配列に対する様々な操作を提供します。
* @author 31536000
*
*/
public static class ArrayUtility {
private ArrayUtility() {
throw new AssertionError();
}
/**
* initを用いて配列を生成します。配列のi番目の要素はinit.applyAsInt(i)になります。
* @complexity O(length)
* @param length 配列の長さ
* @param init 配列の初期値を決める関数
* @return 配列
*/
public static int[] create(int length, java.util.function.IntUnaryOperator init) {
int[] ret = new int[length];
for (int i = 0; i < length; ++i) ret[i] = init.applyAsInt(i);
return ret;
}
/**
* initを用いて配列を生成します。配列のi番目の要素はinit.applyAsInt(i)になります。
* @complexity O(length)
* @param length 配列の長さ
* @param init 配列の初期値を決める関数
* @return 配列
*/
public static long[] create(int length, java.util.function.LongUnaryOperator init) {
long[] ret = new long[length];
for (int i = 0; i < length; ++i) ret[i] = init.applyAsLong(i);
return ret;
}
/**
* initを用いて配列を生成します。配列のi番目の要素はinit.applyAsInt(i)になります。
* @complexity O(length)
* @param length 配列の長さ
* @param init 配列の初期値を決める関数
* @return 配列
*/
public static double[] create(int length, java.util.function.DoubleUnaryOperator init) {
double[] ret = new double[length];
for (int i = 0; i < length; ++i) ret[i] = init.applyAsDouble(i);
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static boolean[] add(boolean[] array, boolean element) {
if (array == null) {
boolean[] ret = { element };
return ret;
}
boolean[] ret = new boolean[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static byte[] add(byte[] array, byte element) {
if (array == null) {
byte[] ret = { element };
return ret;
}
byte[] ret = new byte[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static short[] add(short[] array, short element) {
if (array == null) {
short[] ret = { element };
return ret;
}
short[] ret = new short[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static int[] add(int[] array, int element) {
if (array == null) {
int[] ret = { element };
return ret;
}
int[] ret = new int[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static long[] add(long[] array, long element) {
if (array == null) {
long[] ret = { element };
return ret;
}
long[] ret = new long[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static float[] add(float[] array, float element) {
if (array == null) {
float[] ret = { element };
return ret;
}
float[] ret = new float[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static double[] add(double[] array, double element) {
if (array == null) {
double[] ret = { element };
return ret;
}
double[] ret = new double[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static char[] add(char[] array, char element) {
if (array == null) {
char[] ret = { element };
return ret;
}
char[] ret = new char[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static <T> T[] add(T[] array, T element) {
if (array == null) { return addAll(array, element); }
@SuppressWarnings("unchecked")
T[] ret = (T[]) java.util.Arrays.copyOfRange(array, 0, array.length + 1, array.getClass());
ret[array.length] = element;
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static boolean[] addAll(boolean[] array, boolean... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
boolean[] ret = new boolean[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static byte[] addAll(byte[] array, byte... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
byte[] ret = new byte[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static short[] addAll(short[] array, short... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
short[] ret = new short[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static int[] addAll(int[] array, int... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
int[] ret = new int[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static long[] addAll(long[] array, long... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
long[] ret = new long[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static float[] addAll(float[] array, float... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
float[] ret = new float[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static double[] addAll(double[] array, double... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
double[] ret = new double[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static char[] addAll(char[] array, char... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
char[] ret = new char[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
@SafeVarargs
public static <T> T[] addAll(T[] array, T... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
@SuppressWarnings("unchecked")
T[] ret = (T[]) java.util.Arrays.copyOfRange(array, 0, array.length + array2.length, array.getClass());
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(boolean[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(boolean[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(boolean[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(byte[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(byte[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(byte[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(short[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(short[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(short[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(int[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(int[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(int[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(long[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(long[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(long[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(float[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(float[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(float[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(double[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(double[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(double[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(char[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(char[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(char[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(Object[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(Object[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(Object[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
private static java.util.Random rnd;
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(boolean[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(boolean[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(boolean[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(boolean[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(boolean[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(boolean[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(byte[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(byte[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(byte[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(byte[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(byte[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(byte[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(short[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(short[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(short[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(short[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(short[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(short[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(int[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(int[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(int[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(int[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(int[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(int[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(long[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(long[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(long[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(long[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(long[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(long[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(float[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(float[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(float[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(float[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(float[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(float[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(double[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(double[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(double[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(double[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(double[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(double[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(char[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(char[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(char[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(char[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(char[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(char[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(Object[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(Object[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(Object[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(Object[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(Object[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(Object[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static boolean[] getArray(int size, boolean value) {
boolean[] ret = new boolean[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static byte[] getArray(int size, byte value) {
byte[] ret = new byte[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static short[] getArray(int size, short value) {
short[] ret = new short[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static int[] getArray(int size, int value) {
int[] ret = new int[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static long[] getArray(int size, long value) {
long[] ret = new long[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static float[] getArray(int size, float value) {
float[] ret = new float[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static double[] getArray(int size, double value) {
double[] ret = new double[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static char[] getArray(int size, char value) {
char[] ret = new char[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Boolean[] toObject(boolean[] array) {
if (array == null) return null;
Boolean[] ret = new Boolean[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Byte[] toObject(byte[] array) {
if (array == null) return null;
Byte[] ret = new Byte[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Short[] toObject(short[] array) {
if (array == null) return null;
Short[] ret = new Short[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Integer[] toObject(int[] array) {
if (array == null) return null;
Integer[] ret = new Integer[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Long[] toObject(long[] array) {
if (array == null) return null;
Long[] ret = new Long[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Float[] toObject(float[] array) {
if (array == null) return null;
Float[] ret = new Float[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Double[] toObject(double[] array) {
if (array == null) return null;
Double[] ret = new Double[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Character[] toObject(char[] array) {
if (array == null) return null;
Character[] ret = new Character[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static boolean[] toPrimitive(Boolean[] array) {
if (array == null) return null;
boolean[] ret = new boolean[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull) {
if (array == null) return null;
boolean[] ret = new boolean[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static byte[] toPrimitive(Byte[] array) {
if (array == null) return null;
byte[] ret = new byte[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static byte[] toPrimitive(Byte[] array, byte valueForNull) {
if (array == null) return null;
byte[] ret = new byte[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static short[] toPrimitive(Short[] array) {
if (array == null) return null;
short[] ret = new short[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static short[] toPrimitive(Short[] array, short valueForNull) {
if (array == null) return null;
short[] ret = new short[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static int[] toPrimitive(Integer[] array) {
if (array == null) return null;
int[] ret = new int[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static int[] toPrimitive(Integer[] array, int valueForNull) {
if (array == null) return null;
int[] ret = new int[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static long[] toPrimitive(Long[] array) {
if (array == null) return null;
long[] ret = new long[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static long[] toPrimitive(Long[] array, long valueForNull) {
if (array == null) return null;
long[] ret = new long[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static float[] toPrimitive(Float[] array) {
if (array == null) return null;
float[] ret = new float[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static float[] toPrimitive(Float[] array, float valueForNull) {
if (array == null) return null;
float[] ret = new float[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static double[] toPrimitive(Double[] array) {
if (array == null) return null;
double[] ret = new double[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static double[] toPrimitive(Double[] array, double valueForNull) {
if (array == null) return null;
double[] ret = new double[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static char[] toPrimitive(Character[] array) {
if (array == null) return null;
char[] ret = new char[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static char[] toPrimitive(Character[] array, char valueForNull) {
if (array == null) return null;
char[] ret = new char[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最小値
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> T min(T[] array, java.util.Comparator<T> comparator) {
if (array == null || array.length == 0) return null;
T min = array[0];
for (int i = 1; i < array.length; ++i) if (comparator.compare(min, array[i]) > 0) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static <T extends Comparable<T>> T min(T[] array) {
return min(array, java.util.Comparator.naturalOrder());
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static byte min(byte[] array) {
byte min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static short min(short[] array) {
short min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static int min(int[] array) {
int min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static long min(long[] array) {
long min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static float min(float[] array) {
float min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static double min(double[] array) {
double min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最小値
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> T max(T[] array, java.util.Comparator<T> comparator) {
if (array == null || array.length == 0) return null;
T max = array[0];
for (int i = 1; i < array.length; ++i) if (comparator.compare(max, array[i]) < 0) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
*/
public static <T extends Comparable<T>> T max(T[] array) {
return max(array, java.util.Comparator.naturalOrder());
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static byte max(byte[] array) {
byte max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static short max(short[] array) {
short max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static int max(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static long max(long[] array) {
long max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static float max(float[] array) {
float max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static double max(double[] array) {
double max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(boolean[] array, int n, int m) {
boolean swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(byte[] array, int n, int m) {
byte swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(short[] array, int n, int m) {
short swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(int[] array, int n, int m) {
int swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(long[] array, int n, int m) {
long swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(float[] array, int n, int m) {
float swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(double[] array, int n, int m) {
double swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(char[] array, int n, int m) {
char swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(Object[] array, int n, int m) {
Object swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static <T extends Comparable<T>> boolean nextPermutation(T[] array) {
return nextPermutation(array, java.util.Comparator.naturalOrder());
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列を書き換えたならばtrue
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> boolean nextPermutation(T[] array, java.util.Comparator<T> comparator) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (comparator.compare(array[change], array[change + 1]) < 0) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0)
if (comparator.compare(array[change], array[mid = min + halfDiff]) < 0) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(byte[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(short[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(int[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(long[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(float[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(double[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(char[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static <T extends Comparable<T>> boolean prevPermutation(T[] array) {
return prevPermutation(array, java.util.Comparator.naturalOrder());
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列を書き換えたならばtrue
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> boolean prevPermutation(T[] array, java.util.Comparator<T> comparator) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (comparator.compare(array[change], array[change + 1]) > 0) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0)
if (comparator.compare(array[change], array[mid = min + halfDiff]) > 0) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(byte[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(short[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(int[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(long[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(float[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(double[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(char[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static <T> T[] map(T[] array, java.util.function.UnaryOperator<T> map) {
T[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.apply(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static int[] map(int[] array, java.util.function.IntUnaryOperator map) {
int[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.applyAsInt(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static long[] map(long[] array, java.util.function.LongUnaryOperator map) {
long[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.applyAsLong(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static double[] map(double[] array, java.util.function.DoubleUnaryOperator map) {
double[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.applyAsDouble(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @param generator 新しい配列を生成するための関数、U::newを引数に取る
* @return 配列の各要素にmapを適用した配列
*/
public static <T, U> U[] map(T[] array, java.util.function.Function<T, U> map,
java.util.function.IntFunction<U[]> generator) {
U[] ret = generator.apply(array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.apply(array[i]);
return ret;
}
/**
* 配列を昇順にソートします。
* @complexity O(array.length)
* @param array 配列
*/
public static void sort(final byte[] array) {
if (array.length < 128) {
for (int i = 0, j; i < array.length; ++i) {
byte tmp = array[i], tmp2;
for (j = i; j > 0 && (tmp2 = array[j - 1]) > tmp; --j) array[j] = tmp2;
array[j] = tmp;
}
return;
}
int[] count = new int[256];
for (byte i : array) ++count[i & 0xff];
for (int i = 0, j = 0; j < count.length; ++j) java.util.Arrays.fill(array, i, i += count[j], (byte) j);
}
/**
* 配列を昇順にソートします。
* @complexity O(toIndex-fromIndex)
* @param array 配列
*/
public static void sort(final byte[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 128) {
for (int i = fromIndex, j; i < toIndex; ++i) {
byte tmp = array[i], tmp2;
for (j = i; j > fromIndex && (tmp2 = array[j - 1]) > tmp; --j) array[j] = tmp2;
array[j] = tmp;
}
return;
}
int[] count = new int[256];
for (int i = fromIndex; i < toIndex; ++i) ++count[array[i] & 0xff];
for (int i = fromIndex, j = 0; j < count.length; ++j)
java.util.Arrays.fill(array, i, i += count[j], (byte) j);
}
/**
* 配列を昇順にソートします。
* @complexity O(range.getDistance())
* @param array 配列
*/
public static void sort(final byte[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を昇順にソートします。
* @complexity Nを配列長として O(N log N)
* @param array 配列
*/
public static void sort(final short[] array) {
if (array.length < 1024) java.util.Arrays.sort(array);
else sort(array, 0, array.length, 0, new short[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=toIndex-fromIndex として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final short[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 1024) java.util.Arrays.sort(array, fromIndex, toIndex);
else sort(array, fromIndex, toIndex, 0, new short[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=range.getDistance() として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final short[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
private static final void sort(short[] a, final int from, final int to, final int l, final short[] bucket) {
final int BUCKET_SIZE = 256;
final int SHORT_RECURSION = 2;
final int MASK = 0xff;
final int shift = l << 3;
final int[] cnt = new int[BUCKET_SIZE + 1];
final int[] put = new int[BUCKET_SIZE];
for (int i = from; i < to; i++) ++cnt[(a[i] >>> shift & MASK) + 1];
for (int i = 0; i < BUCKET_SIZE; i++) cnt[i + 1] += cnt[i];
for (int i = from; i < to; i++) {
int bi = a[i] >>> shift & MASK;
bucket[cnt[bi] + put[bi]++] = a[i];
}
for (int i = BUCKET_SIZE - 1, idx = from; i >= 0; i--) {
int begin = cnt[i];
int len = cnt[i + 1] - begin;
System.arraycopy(bucket, begin, a, idx, len);
idx += len;
}
final int nxtL = l + 1;
if (nxtL < SHORT_RECURSION) {
sort(a, from, to, nxtL, bucket);
if (l == 0) {
int lft, rgt;
lft = from - 1;
rgt = to;
while (rgt - lft > 1) {
int mid = lft + rgt >> 1;
if (a[mid] < 0) lft = mid;
else rgt = mid;
}
reverse(a, from, rgt);
reverse(a, rgt, to);
}
}
}
/**
* 配列を昇順にソートします。
* @complexity Nを配列長として O(N log N)
* @param array 配列
*/
public static void sort(final int[] array) {
if (array.length < 1024) java.util.Arrays.sort(array);
else sort(array, 0, array.length, 0, new int[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=toIndex-fromIndex として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final int[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 1024) java.util.Arrays.sort(array, fromIndex, toIndex);
else sort(array, fromIndex, toIndex, 0, new int[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=range.getDistance() として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final int[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
private static final void sort(int[] a, final int from, final int to, final int l, final int[] bucket) {
final int BUCKET_SIZE = 256;
final int INT_RECURSION = 4;
final int MASK = 0xff;
final int shift = l << 3;
final int[] cnt = new int[BUCKET_SIZE + 1];
final int[] put = new int[BUCKET_SIZE];
for (int i = from; i < to; i++) ++cnt[(a[i] >>> shift & MASK) + 1];
for (int i = 0; i < BUCKET_SIZE; i++) cnt[i + 1] += cnt[i];
for (int i = from; i < to; i++) {
int bi = a[i] >>> shift & MASK;
bucket[cnt[bi] + put[bi]++] = a[i];
}
for (int i = BUCKET_SIZE - 1, idx = from; i >= 0; i--) {
int begin = cnt[i];
int len = cnt[i + 1] - begin;
System.arraycopy(bucket, begin, a, idx, len);
idx += len;
}
final int nxtL = l + 1;
if (nxtL < INT_RECURSION) {
sort(a, from, to, nxtL, bucket);
if (l == 0) {
int lft, rgt;
lft = from - 1;
rgt = to;
while (rgt - lft > 1) {
int mid = lft + rgt >> 1;
if (a[mid] < 0) lft = mid;
else rgt = mid;
}
reverse(a, from, rgt);
reverse(a, rgt, to);
}
}
}
/**
* 配列を昇順にソートします。
* @complexity Nを配列長として O(N log N)
* @param array 配列
*/
public static void sort(final long[] array) {
if (array.length < 1024) java.util.Arrays.sort(array);
else sort(array, 0, array.length, 0, new long[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=toIndex-fromIndex として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final long[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 1024) java.util.Arrays.sort(array, fromIndex, toIndex);
else sort(array, fromIndex, toIndex, 0, new long[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=range.getDistance() として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final long[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
private static final void sort(long[] a, final int from, final int to, final int l, final long[] bucket) {
final int BUCKET_SIZE = 256;
final int LONG_RECURSION = 8;
final int MASK = 0xff;
final int shift = l << 3;
final int[] cnt = new int[BUCKET_SIZE + 1];
final int[] put = new int[BUCKET_SIZE];
for (int i = from; i < to; i++) ++cnt[(int) ((a[i] >>> shift & MASK) + 1)];
for (int i = 0; i < BUCKET_SIZE; i++) cnt[i + 1] += cnt[i];
for (int i = from; i < to; i++) {
int bi = (int) (a[i] >>> shift & MASK);
bucket[cnt[bi] + put[bi]++] = a[i];
}
for (int i = BUCKET_SIZE - 1, idx = from; i >= 0; i--) {
int begin = cnt[i];
int len = cnt[i + 1] - begin;
System.arraycopy(bucket, begin, a, idx, len);
idx += len;
}
final int nxtL = l + 1;
if (nxtL < LONG_RECURSION) {
sort(a, from, to, nxtL, bucket);
if (l == 0) {
int lft, rgt;
lft = from - 1;
rgt = to;
while (rgt - lft > 1) {
int mid = lft + rgt >> 1;
if (a[mid] < 0) lft = mid;
else rgt = mid;
}
reverse(a, from, rgt);
reverse(a, rgt, to);
}
}
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @return arrayを座標圧縮した配列
*/
public static int[] compress(int[] array) {
int[] ret = new int[array.length];
int[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (copy[len - 1] != copy[j]) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
int comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @return arrayを座標圧縮した配列
*/
public static int[] compress(long[] array) {
int[] ret = new int[array.length];
long[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (copy[len - 1] != copy[j]) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
long comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @return arrayを座標圧縮した配列
*/
public static <T extends Comparable<T>> int[] compress(T[] array) {
int[] ret = new int[array.length];
T[] copy = java.util.Arrays.copyOf(array, array.length);
java.util.Arrays.sort(copy);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (copy[len - 1] != copy[j]) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
T comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid].compareTo(comp) <= 0) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @param comparator 比較関数
* @return arrayを座標圧縮した配列
*/
public static <T> int[] compress(T[] array, java.util.Comparator<T> comparator) {
int[] ret = new int[array.length];
T[] copy = java.util.Arrays.copyOf(array, array.length);
java.util.Arrays.sort(copy, comparator);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (!copy[len - 1].equals(copy[j])) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
T comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (comparator.compare(copy[mid], comp) <= 0) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]<list[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]==list[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nをリスト長として O(N log N)
* @param list 座標圧縮を行うリスト
* @return listを座標圧縮した配列
* @throws NullPointerException listがnullの場合
*/
public static <T extends Comparable<T>> int[] compress(java.util.List<T> list) {
int size = list.size();
int[] ret = new int[size];
java.util.ArrayList<T> copy = new java.util.ArrayList<>(list);
copy.sort(java.util.Comparator.naturalOrder());
int len = 1;
for (int j = 1; j < size; ++j) {
if (!copy.get(len - 1).equals(copy.get(j))) copy.set(len++, copy.get(j));
}
java.util.Iterator<T> iter = list.iterator();
for (int i = 0; i < size; ++i) {
int min = 0, max = len;
T comp = iter.next();
while (max - min > 1) {
int mid = min + max >> 1;
if (copy.get(mid).compareTo(comp) <= 0) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]<list[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]==list[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nをリスト長として O(N log N)
* @param list 座標圧縮を行うリスト
* @param comparator 比較関数
* @return listを座標圧縮した配列
*/
public static <T> int[] compress(java.util.List<T> list, java.util.Comparator<T> comparator) {
int[] ret = new int[list.size()];
java.util.ArrayList<T> copy = new java.util.ArrayList<>(list);
copy.sort(comparator);
int[] bit = new int[list.size() + 1];
java.util.Iterator<T> iter = list.iterator();
for (int i = 0; i < list.size(); ++i) {
int min = 0, max = list.size();
T comp = iter.next();
while (max - min > 1) {
int mid = min + max >> 1;
if (comparator.compare(copy.get(mid), comp) <= 0) min = mid;
else max = mid;
}
for (int j = max; j != 0; j -= j & -j) ret[i] += bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ret;
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(int[] array) {
if (array == null) return 0;
int[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int[] bit = new int[array.length + 1];
long ans = (long) array.length * (array.length - 1) >> 1;
for (int i = 0; i < array.length; ++i) {
int min = 0, max = array.length;
int comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(long[] array) {
if (array == null) return 0;
long[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int[] bit = new int[array.length + 1];
long ans = (long) array.length * (array.length - 1) >> 1;
for (int i = 0; i < array.length; ++i) {
int min = 0, max = array.length;
long comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(char[] array) {
if (array == null) return 0;
int[] a = new int[array.length];
for (int i = 0;i < array.length;++ i) a[i] = array[i];
return inversionNumber(a);
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(String array) {
if (array == null) return 0;
return inversionNumber(array.toCharArray());
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(int[] src, int[] dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
int[] copySrc = java.util.Arrays.copyOf(src, src.length),
copyDest = java.util.Arrays.copyOf(dest, dest.length);
sort(copySrc);
sort(copyDest);
if (!java.util.Arrays.equals(copySrc, copyDest)) return -1;
int[] key = new int[dest.length];
for (int i = 0; i < dest.length; ++i) {
int min = -1, max = dest.length;
int comp = dest[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copyDest[mid] < comp) min = mid;
else max = mid;
}
key[max] = i;
copyDest[max] = max == 0 ? Integer.MIN_VALUE : copyDest[max - 1];
}
int[] bit = new int[src.length + 1];
long ans = (long) src.length * (src.length - 1) >> 1;
for (int i = 0; i < src.length; ++i) {
int min = -1, max = src.length;
int comp = src[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copySrc[mid] < comp) min = mid;
else max = mid;
}
copySrc[max] = max == 0 ? Integer.MIN_VALUE : copySrc[max - 1];
max = key[max] + 1;
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(long[] src, long[] dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
long[] copySrc = java.util.Arrays.copyOf(src, src.length),
copyDest = java.util.Arrays.copyOf(dest, dest.length);
sort(copySrc);
sort(copyDest);
if (!java.util.Arrays.equals(copySrc, copyDest)) return -1;
int[] key = new int[dest.length];
for (int i = 0; i < dest.length; ++i) {
int min = -1, max = dest.length;
long comp = dest[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copyDest[mid] < comp) min = mid;
else max = mid;
}
key[max] = i;
copyDest[max] = max == 0 ? Integer.MIN_VALUE : copyDest[max - 1];
}
int[] bit = new int[src.length + 1];
long ans = (long) src.length * (src.length - 1) >> 1;
for (int i = 0; i < src.length; ++i) {
int min = -1, max = src.length;
long comp = src[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copySrc[mid] < comp) min = mid;
else max = mid;
}
copySrc[max] = max == 0 ? Integer.MIN_VALUE : copySrc[max - 1];
max = key[max] + 1;
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(char[] src, char[] dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
int[] a = new int[src.length];
for (int i = 0;i < src.length;++ i) a[i] = src[i];
int[] b = new int[dest.length];
for (int i = 0;i < dest.length;++ i) b[i] = dest[i];
return inversionDistance(a, b);
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(String src, String dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
return inversionDistance(src.toCharArray(), dest.toCharArray());
}
}
}
class ACL {
public static final class DisjointSetUnion {
private final int[] parent;
private DisjointSetUnion(final int n) {
parent = new int[n];
java.util.Arrays.fill(parent, -1);
}
public static DisjointSetUnion create(final int n) {
return new DisjointSetUnion(n);
}
public int getLeader(int a) {
int p1, p2;
while ((p1 = parent[a]) >= 0) {
if ((p2 = parent[p1]) >= 0) a = parent[a] = p2;
else return p1;
}
return a;
}
public int merge(int a, int b) {
a = getLeader(a);
b = getLeader(b);
if (a == b) return a;
if (parent[a] < parent[b]) {
parent[b] += parent[a];
parent[a] = b;
return b;
}
parent[a] += parent[b];
parent[b] = a;
return a;
}
public boolean isSame(final int a, final int b) {
return getLeader(a) == getLeader(b);
}
public int getSize(final int a) {
return -parent[getLeader(a)];
}
public java.util.ArrayList<java.util.ArrayList<Integer>> getGroups() {
final Object[] group = new Object[parent.length];
final java.util.ArrayList<java.util.ArrayList<Integer>> ret = new java.util.ArrayList<>();
for (int i = 0; i < parent.length; ++i) {
final int leader = getLeader(i);
final Object put = group[leader];
if (put == null) {
final java.util.ArrayList<Integer> list = new java.util.ArrayList<>();
list.add(i);
ret.add(list);
group[leader] = list;
} else {
@SuppressWarnings("unchecked")
final java.util.ArrayList<Integer> list = (java.util.ArrayList<Integer>) put;
list.add(i);
}
}
return ret;
}
@Override
public String toString() {
return getGroups().toString();
}
}
public static final class IntFenwickTree {
private final int[] array;
private IntFenwickTree(final int n) {
array = new int[n + 1];
}
private IntFenwickTree(final int[] array) {
this(array.length);
System.arraycopy(array, 0, this.array, 1, array.length);
for (int i = 1; i < this.array.length; ++i)
if (i + (i & -i) < this.array.length) this.array[i + (i & -i)] += this.array[i];
}
public static IntFenwickTree create(final int n) {
return new IntFenwickTree(n);
}
public static IntFenwickTree create(final int[] array) {
return new IntFenwickTree(array);
}
public void add(int index, final int add) {
++index;
while (index < array.length) {
array[index] += add;
index += index & -index;
}
}
private int sum(int index) {
int sum = 0;
while (index > 0) {
sum += array[index];
index -= index & -index;
}
return sum;
}
public int sum(final int l, final int r) {
return sum(r) - sum(l);
}
@Override
public String toString() {
return java.util.stream.IntStream.range(0, array.length - 1)
.mapToObj(i -> String.valueOf(sum(i + 1) - sum(i)))
.collect(java.util.stream.Collectors.joining(", ", "[", "]"));
}
}
public static final class LongFenwickTree {
private final long[] array;
private LongFenwickTree(final int n) {
array = new long[n + 1];
}
private LongFenwickTree(final long[] array) {
this(array.length);
System.arraycopy(array, 0, this.array, 1, array.length);
for (int i = 1; i < this.array.length; ++i)
if (i + (i & -i) < this.array.length) this.array[i + (i & -i)] += this.array[i];
}
public static LongFenwickTree create(final int n) {
return new LongFenwickTree(n);
}
public static LongFenwickTree create(final long[] array) {
return new LongFenwickTree(array);
}
public void add(int index, final long add) {
++index;
while (index < array.length) {
array[index] += add;
index += index & -index;
}
}
private long sum(int index) {
long sum = 0;
while (index > 0) {
sum += array[index];
index -= index & -index;
}
return sum;
}
public long sum(final int l, final int r) {
return sum(r) - sum(l);
}
@Override
public String toString() {
return java.util.stream.IntStream.range(0, array.length - 1)
.mapToObj(i -> String.valueOf(sum(i + 1) - sum(i)))
.collect(java.util.stream.Collectors.joining(", ", "[", "]"));
}
}
public static final class MathLib {
public static class Barrett {
private final int mod;
private final long h, l;
private final long MAX = 1L << 62;
private final int MASK = (1 << 31) - 1;
Barrett(final int mod) {
this.mod = mod;
final long t = MAX / mod;
h = t >>> 31;
l = t & MASK;
}
int reduce(final long x) {
final long xh = x >>> 31, xl = x & MASK;
long z = xl * l;
z = xl * h + xh * l + (z >>> 31);
z = xh * h + (z >>> 31);
final int ret = (int) (x - z * mod);
return ret >= mod ? ret - mod : ret;
}
}
public static class BarrettSmall {
private final int mod;
final long t;
BarrettSmall(final int mod) {
this.mod = mod;
t = (1L << 42) / mod;
}
int reduce(long x) {
long q = x * t >> 42;
x -= q * mod;
return (int) (x >= mod ? x - mod : x);
}
}
private static long safe_mod(long x, final long m) {
x %= m;
if (x < 0) x += m;
return x;
}
private static long[] inv_gcd(long a, final long b) {
a = safe_mod(a, b);
if (a == 0) return new long[] { b, 0 };
long s = b, t = a;
long m0 = 0, m1 = 1;
while (t > 0) {
final long u = s / t;
s -= t * u;
m0 -= m1 * u;
long tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 < 0) m0 += b / s;
return new long[] { s, m0 };
}
public static int pow(long n, long m, final int mod) {
assert m >= 0 && mod >= 1;
if (mod == 1) return 0;
return pow(n, m, new Barrett(mod));
}
public static int pow(long n, long m, Barrett mod) {
assert m >= 0;
long ans = 1, num = n % mod.mod;
while (m != 0) {
if ((m & 1) != 0) ans = mod.reduce(ans * num);
m >>>= 1;
num = mod.reduce(num * num);
}
return (int) ans;
}
public static int pow998_244_353(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 998_244_353;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 998_244_353;
m >>>= 1;
num = num * num % 998_244_353;
}
return (int) ans;
}
public static int pow167_772_161(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 167_772_161;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 167_772_161;
m >>>= 1;
num = num * num % 167_772_161;
}
return (int) ans;
}
public static int pow469_762_049(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 469_762_049;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 469_762_049;
m >>>= 1;
num = num * num % 469_762_049;
}
return (int) ans;
}
public static int pow1_000_000_007(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 1_000_000_007;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 1_000_000_007;
m >>>= 1;
num = num * num % 1_000_000_007;
}
return (int) ans;
}
public static int pow(long n, long m, BarrettSmall mod) {
assert m >= 0;
long ans = 1, num = n % mod.mod;
while (m != 0) {
if ((m & 1) != 0) ans = mod.reduce(ans * num);
m >>>= 1;
num = mod.reduce(num * num);
}
return (int) ans;
}
public static long[] crt(final long[] r, final long[] m) {
assert r.length == m.length;
final int n = r.length;
long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert 1 <= m[i];
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
long tmp = r0;
r0 = r1;
r1 = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1) return new long[] { 0, 0 };
continue;
}
final long[] ig = inv_gcd(m0, m1);
final long g = ig[0], im = ig[1];
final long u1 = m1 / g;
if ((r1 - r0) % g != 0) return new long[] { 0, 0 };
final long x = (r1 - r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if (r0 < 0) r0 += m0;
// System.err.printf("%d %d\n", r0, m0);
}
return new long[] { r0, m0 };
}
public static long floor_sum(final long n, final long m, long a, long b) {
long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
final long y_max = (a * n + b) / m;
final long x_max = y_max * m - b;
if (y_max == 0) return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
/**
* aとbの最大公約数を返します。
* @param a 整数
* @param b 整数
* @return 最大公約数
*/
public static int gcd(int a, int b) {
while (a != 0) if ((b %= a) != 0) a %= b;
else return a;
return b;
}
/**
* 配列全ての値の最大公約数を返します。
* @param array 配列
* @return 最大公約数
*/
public static int gcd(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = gcd(ret, array[i]);
return ret;
}
/**
* aとbの最大公約数を返します。
* @param a 整数
* @param b 整数
* @return 最大公約数
*/
public static long gcd(long a, long b) {
while (a != 0) if ((b %= a) != 0) a %= b;
else return a;
return b;
}
/**
* 配列全ての値の最大公約数を返します。
* @param array 配列
* @return 最大公約数
*/
public static long gcd(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = gcd(ret, array[i]);
return ret;
}
/**
* 配列全ての値の最小公倍数を返します。
* @param a 整数
* @param b 整数
* @return 最小公倍数
*/
public static long lcm(int a, int b) {
return a / gcd(a, b) * (long) b;
}
/**
* 配列全ての値の最小公倍数を返します。
* @param a 整数
* @param b 整数
* @return 最小公倍数
*/
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
/**
* 配列全ての値の最小公倍数を返します。
* @param array 配列
* @return 最小公倍数
*/
public static long lcm(int... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = lcm(ret, array[i]);
return ret;
}
/**
* aとbのうち、小さい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち小さい方の値
*/
public static int min(int a, int b) {
return a < b ? a : b;
}
/**
* 配列の中で最小の値を返します。
* @param array 配列
* @return 配列の中で最小の値
*/
public static int min(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = min(ret, array[i]);
return ret;
}
/**
* aとbのうち、小さい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち小さい方の値
*/
public static long min(long a, long b) {
return a < b ? a : b;
}
/**
* 配列の中で最小の値を返します。
* @param array 配列
* @return 配列の中で最小の値
*/
public static long min(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = min(ret, array[i]);
return ret;
}
/**
* aとbのうち、大きい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち大きい方の値
*/
public static int max(int a, int b) {
return a > b ? a : b;
}
/**
* 配列の中で最大の値を返します。
* @param array 配列
* @return 配列の中で最大の値
*/
public static int max(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = max(ret, array[i]);
return ret;
}
/**
* aとbのうち、大きい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち大きい方の値
*/
public static long max(long a, long b) {
return a > b ? a : b;
}
/**
* 配列の中で最大の値を返します。
* @param array 配列
* @return 配列の中で最大の値
*/
public static long max(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = max(ret, array[i]);
return ret;
}
/**
* 配列の値の合計を返します。
* @param array 配列
* @return 配列の値の総和
*/
public static long sum(int... array) {
long ret = 0;
for (int i : array) ret += i;
return ret;
}
/**
* 配列の値の合計を返します。
* @param array 配列
* @return 配列の値の総和
*/
public static long sum(long... array) {
long ret = 0;
for (long i : array) ret += i;
return ret;
}
/**
* 二項係数を列挙した配列を返します。
* @param l 左辺
* @param r 右辺
* @return 0≦i≦l及び0≦j≦rを満たす全てのi, jに対してi choose jを求めた配列
*/
public static long[][] combination(int l, int r) {
long[][] pascal = new long[l + 1][r + 1];
pascal[0][0] = 1;
for (int i = 1; i <= l; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= r; ++j) {
pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
}
}
return pascal;
}
/**
* 二分探索を行い、func(x) != func(x+1)となるような数xを発見します。
* funcが単調な関数であるとき、発見されるxは一意に定まります。
* @param isTrue func(isTrue)=trueとなるような値
* @param isFalse func(isFalse)=falseとなるような値
* @param func 関数
* @complexity O(log(max(isTrue, isFalse) - min(isTrue, isFalse)))
* @return func(x) != func(x+1)となるような数x
*/
public static int binarySearch(int isTrue, int isFalse, java.util.function.IntPredicate func) {
if (isTrue <= isFalse) {
int halfDiff = isFalse - isTrue >> 1, mid = isTrue + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isFalse - isTrue >> 1;
mid = isTrue + halfDiff;
}
return isTrue;
} else {
int halfDiff = isTrue - isFalse >> 1, mid = isFalse + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isTrue - isFalse >> 1;
mid = isFalse + halfDiff;
}
return isFalse;
}
}
/**
* 二分探索を行い、func(x) != func(x+1)となるような数xを発見します。
* funcが単調な関数であるとき、発見されるxは一意に定まります。
* @param isTrue func(isTrue)=trueとなるような値
* @param isFalse func(isFalse)=falseとなるような値
* @param func 関数
* @complexity O(log(max(isTrue, isFalse) - min(isTrue, isFalse)))
* @return func(x) != func(x+1)となるような数x
*/
public static long binarySearch(long isTrue, long isFalse, java.util.function.LongPredicate func) {
if (isTrue <= isFalse) {
long halfDiff = isFalse - isTrue >> 1, mid = isTrue + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isFalse - isTrue >> 1;
mid = isTrue + halfDiff;
}
return isTrue;
} else {
long halfDiff = isTrue - isFalse >> 1, mid = isFalse + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isTrue - isFalse >> 1;
mid = isFalse + halfDiff;
}
return isFalse;
}
}
/**
* 二分探索を行い、func(x) != func(x+Math.nextUp(x))となるような数xを発見します。
* funcが単調な関数であるとき、発見されるxは一意に定まります。
* @param isTrue func(isTrue)=trueとなるような値
* @param isFalse func(isFalse)=falseとなるような値
* @param func 関数
* @complexity O(log(max(isTrue, isFalse) - min(isTrue, isFalse)))
* @return func(x) != func(x+Math.nextUp(x))となるような数x
*/
public static double binarySearch(double isTrue, double isFalse, java.util.function.DoublePredicate func) {
return Double.longBitsToDouble(binarySearch(Double.doubleToRawLongBits(isTrue), Double.doubleToRawLongBits(isFalse), (long i) -> func.test(Double.longBitsToDouble(i))));
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @return 極小値
*/
public static <T extends Comparable<T>> double find_minimal(double min, double max, int loop, java.util.function.DoubleFunction<T> func) {
return find_minimal(min, max, loop, func, java.util.Comparator.naturalOrder());
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @param comparator 比較関数
* @return 極小値
*/
public static <T> double find_minimal(double min, double max, int loop, java.util.function.DoubleFunction<T> func, java.util.Comparator<T> comparator) {
double phi = (1 + Math.sqrt(5)) / 2;
for (int i = 0;i < loop;++ i) {
double mid_min = (min * phi + max) / (1 + phi), mid_max = (min + max * phi) / (1 + phi);
T mid_min_calc = func.apply(mid_min), mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) <= 0) max = mid_max;
else min = mid_min;
}
return min;
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @return 極大値
*/
public static <T extends Comparable<T>> double find_maximal(double min, double max, int loop, java.util.function.DoubleFunction<T> func) {
return find_maximal(min, max, loop, func, java.util.Comparator.naturalOrder());
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @param comparator 比較関数
* @return 極大値
*/
public static <T> double find_maximal(double min, double max, int loop, java.util.function.DoubleFunction<T> func, java.util.Comparator<T> comparator) {
if (max <= min) throw new IllegalArgumentException("empty range");
double phi = (1 + Math.sqrt(5)) / 2;
for (int i = 0;i < loop;++ i) {
double mid_min = (min * phi + max) / (1 + phi), mid_max = (min + max * phi) / (1 + phi);
T mid_min_calc = func.apply(mid_min), mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) >= 0) max = mid_max;
else min = mid_min;
}
return min;
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極小値
*/
public static <T extends Comparable<T>> int find_minimal(int min, int max, java.util.function.IntFunction<T> func) {
return find_minimal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極小値
*/
public static <T> int find_minimal(int min, int max, java.util.function.IntFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
int range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
int fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
int mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) <= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極大値
*/
public static <T extends Comparable<T>> int find_maximal(int min, int max, java.util.function.IntFunction<T> func) {
return find_maximal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極大値
*/
public static <T> int find_maximal(int min, int max, java.util.function.IntFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
int range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
int fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
int mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) >= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極小値
*/
public static <T extends Comparable<T>> long find_minimal(long min, long max, java.util.function.LongFunction<T> func) {
return find_minimal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極小値
*/
public static <T> long find_minimal(long min, long max, java.util.function.LongFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
long range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
long fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
long mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) <= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極大値
*/
public static <T extends Comparable<T>> long find_maximal(long min, long max, java.util.function.LongFunction<T> func) {
return find_maximal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極大値
*/
public static <T> long find_maximal(long min, long max, java.util.function.LongFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
long range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
long fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
long mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) >= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
public static class BezoutCoefficients {
public final long a, b;
public final long x, y;
public final long gcd;
private BezoutCoefficients(long a, long b, long x, long y, long gcd) {
this.a = a;
this.b = b;
this.x = x;
this.y = y;
this.gcd = gcd;
}
/**
* lx≦i<rxかつly≦j<ryを満たす整数i, jであって、ai+bj=ax+byとなる解の個数を求めます。
* @param lx iの下限(これを含む)
* @param rx iの上限(これを含まない)
* @param ly jの下限(これを含む)
* @param ry jの上限(これを含まない)
* @return 解の個数
* @complexity O(1)
*/
public long countSatisfySolution(long lx, long rx, long ly, long ry) {
long ag = a / gcd, bg = b / gcd;
long la = Math.floorDiv(lx - x + bg - 1, bg), ra = Math.floorDiv(rx - x - 1, bg) + 1;
long lb = Math.floorDiv(y - ry, ag) + 1, rb = Math.floorDiv(y - ly, ag) + 1;
return Math.max(0, Math.min(ra, rb) - Math.max(la, lb));
}
@Override
public String toString() {
return "(" + x + ", " + y + "), gcd=" + gcd;
}
/**
* ax+by=gcd(a, b)となるような解を一つ求めます。
* この時、|x|≦|b/gcd(a,b)|、|y|≦|a/gcd(a,b)|であることが保証されます。
* @param a 整数
* @param b 整数
* @return 与えられた一次不定方程式の解
* @complexity O(log(min(a, b)))
*/
public static BezoutCoefficients solve(long a, long b) {
int as = Long.signum(a);
int bs = Long.signum(b);
long aa = Math.abs(a);
long ba = Math.abs(b);
long p = 1, q = 0, r = 0, s = 1;
while(ba != 0){
long c = aa / ba;
long e;
e = aa; aa = ba; ba = e % ba;
e = p; p = q; q = e - c * q;
e = r; r = s; s = e - c * s;
}
return new BezoutCoefficients(a, b, p * as, r * bs, aa);
}
/**
* ax+by=dとなるような解を一つ求めます。
* @param a 整数
* @param b 整数
* @param d 不定方程式の解
* @return 与えられた一次不定方程式の解(存在しなければnull)
* @complexity O(log(min(a, b)))
*/
public static BezoutCoefficients solve(long a, long b, long d) {
int as = Long.signum(a);
int bs = Long.signum(b);
long aa = Math.abs(a);
long ba = Math.abs(b);
long p = 1, q = 0, r = 0, s = 1;
while(ba != 0){
long c = aa / ba;
long e;
e = aa; aa = ba; ba = e % ba;
e = p; p = q; q = e - c * q;
e = r; r = s; s = e - c * s;
}
if (d % aa != 0) return null;
long divd = d / a, modd = d % a / aa;
return new BezoutCoefficients(a, b, p * as * modd + divd, r * bs * modd, aa);
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_d
*/
public static final class MaxFlow {
private static final class InternalCapEdge {
final int to;
final int rev;
long cap;
InternalCapEdge(int to, int rev, long cap) {
this.to = to;
this.rev = rev;
this.cap = cap;
}
}
public static final class CapEdge {
public final int from, to;
public final long cap, flow;
CapEdge(int from, int to, long cap, long flow) {
this.from = from;
this.to = to;
this.cap = cap;
this.flow = flow;
}
@Override
public boolean equals(Object o) {
if (o instanceof CapEdge) {
CapEdge e = (CapEdge) o;
return from == e.from && to == e.to && cap == e.cap && flow == e.flow;
}
return false;
}
}
private static final class IntPair {
final int first, second;
IntPair(int first, int second) {
this.first = first;
this.second = second;
}
}
static final long INF = Long.MAX_VALUE;
private final int n;
private final java.util.ArrayList<IntPair> pos;
private final java.util.ArrayList<InternalCapEdge>[] g;
@SuppressWarnings("unchecked")
public MaxFlow(int n) {
this.n = n;
pos = new java.util.ArrayList<>();
g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
g[i] = new java.util.ArrayList<>();
}
}
public int addEdge(int from, int to, long cap) {
rangeCheck(from, 0, n);
rangeCheck(to, 0, n);
nonNegativeCheck(cap, "Capacity");
int m = pos.size();
pos.add(new IntPair(from, g[from].size()));
int fromId = g[from].size();
int toId = g[to].size();
if (from == to) toId++;
g[from].add(new InternalCapEdge(to, toId, cap));
g[to].add(new InternalCapEdge(from, fromId, 0L));
return m;
}
private InternalCapEdge getInternalEdge(int i) {
return g[pos.get(i).first].get(pos.get(i).second);
}
private InternalCapEdge getInternalEdgeReversed(InternalCapEdge e) {
return g[e.to].get(e.rev);
}
public CapEdge getEdge(int i) {
int m = pos.size();
rangeCheck(i, 0, m);
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
return new CapEdge(re.to, e.to, e.cap + re.cap, re.cap);
}
public CapEdge[] getEdges() {
CapEdge[] res = new CapEdge[pos.size()];
java.util.Arrays.setAll(res, this::getEdge);
return res;
}
public void changeEdge(int i, long newCap, long newFlow) {
int m = pos.size();
rangeCheck(i, 0, m);
nonNegativeCheck(newCap, "Capacity");
if (newFlow > newCap) {
throw new IllegalArgumentException(
String.format("Flow %d is greater than the capacity %d.", newCap, newFlow));
}
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
e.cap = newCap - newFlow;
re.cap = newFlow;
}
public long maxFlow(int s, int t) {
return flow(s, t, INF);
}
public long flow(int s, int t, long flowLimit) {
rangeCheck(s, 0, n);
rangeCheck(t, 0, n);
long flow = 0L;
int[] level = new int[n];
int[] que = new int[n];
int[] iter = new int[n];
while (flow < flowLimit) {
bfs(s, t, level, que);
if (level[t] < 0) break;
java.util.Arrays.fill(iter, 0);
while (flow < flowLimit) {
long d = dfs(t, s, flowLimit - flow, iter, level);
if (d == 0) break;
flow += d;
}
}
return flow;
}
private void bfs(int s, int t, int[] level, int[] que) {
java.util.Arrays.fill(level, -1);
int hd = 0, tl = 0;
que[tl++] = s;
level[s] = 0;
while (hd < tl) {
int u = que[hd++];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap == 0 || level[v] >= 0) continue;
level[v] = level[u] + 1;
if (v == t) return;
que[tl++] = v;
}
}
}
private long dfs(int cur, int s, long flowLimit, int[] iter, int[] level) {
if (cur == s) return flowLimit;
long res = 0;
int curLevel = level[cur];
for (int itMax = g[cur].size(); iter[cur] < itMax; iter[cur]++) {
int i = iter[cur];
InternalCapEdge e = g[cur].get(i);
InternalCapEdge re = getInternalEdgeReversed(e);
if (curLevel <= level[e.to] || re.cap == 0) continue;
long d = dfs(e.to, s, Math.min(flowLimit - res, re.cap), iter, level);
if (d <= 0) continue;
e.cap += d;
re.cap -= d;
res += d;
if (res == flowLimit) break;
}
return res;
}
public boolean[] minCut(int s) {
rangeCheck(s, 0, n);
boolean[] visited = new boolean[n];
int[] stack = new int[n];
int ptr = 0;
stack[ptr++] = s;
visited[s] = true;
while (ptr > 0) {
int u = stack[--ptr];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap > 0 && !visited[v]) {
visited[v] = true;
stack[ptr++] = v;
}
}
}
return visited;
}
private void rangeCheck(int i, int minInclusive, int maxExclusive) {
if (i < 0 || i >= maxExclusive) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, maxExclusive));
}
}
private void nonNegativeCheck(long cap, String attribute) {
if (cap < 0) { throw new IllegalArgumentException(String.format("%s %d is negative.", attribute, cap)); }
}
}
/**
* @verified
* - https://atcoder.jp/contests/practice2/tasks/practice2_e
* - http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_B
*/
public static final class MinCostFlow {
private static final class InternalWeightedCapEdge {
final int to, rev;
long cap;
final long cost;
InternalWeightedCapEdge(int to, int rev, long cap, long cost) {
this.to = to;
this.rev = rev;
this.cap = cap;
this.cost = cost;
}
}
public static final class WeightedCapEdge {
public final int from, to;
public final long cap, flow, cost;
WeightedCapEdge(int from, int to, long cap, long flow, long cost) {
this.from = from;
this.to = to;
this.cap = cap;
this.flow = flow;
this.cost = cost;
}
@Override
public boolean equals(Object o) {
if (o instanceof WeightedCapEdge) {
WeightedCapEdge e = (WeightedCapEdge) o;
return from == e.from && to == e.to && cap == e.cap && flow == e.flow && cost == e.cost;
}
return false;
}
}
private static final class IntPair {
final int first, second;
IntPair(int first, int second) {
this.first = first;
this.second = second;
}
}
public static final class FlowAndCost {
public final long flow, cost;
FlowAndCost(long flow, long cost) {
this.flow = flow;
this.cost = cost;
}
@Override
public boolean equals(Object o) {
if (o instanceof FlowAndCost) {
FlowAndCost c = (FlowAndCost) o;
return flow == c.flow && cost == c.cost;
}
return false;
}
}
static final long INF = Long.MAX_VALUE;
private final int n;
private final java.util.ArrayList<IntPair> pos;
private final java.util.ArrayList<InternalWeightedCapEdge>[] g;
@SuppressWarnings("unchecked")
public MinCostFlow(int n) {
this.n = n;
pos = new java.util.ArrayList<>();
g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
g[i] = new java.util.ArrayList<>();
}
}
public int addEdge(int from, int to, long cap, long cost) {
rangeCheck(from, 0, n);
rangeCheck(to, 0, n);
nonNegativeCheck(cap, "Capacity");
nonNegativeCheck(cost, "Cost");
int m = pos.size();
pos.add(new IntPair(from, g[from].size()));
int fromId = g[from].size();
int toId = g[to].size();
if (from == to) toId++;
g[from].add(new InternalWeightedCapEdge(to, toId, cap, cost));
g[to].add(new InternalWeightedCapEdge(from, fromId, 0L, -cost));
return m;
}
private InternalWeightedCapEdge getInternalEdge(int i) {
return g[pos.get(i).first].get(pos.get(i).second);
}
private InternalWeightedCapEdge getInternalEdgeReversed(InternalWeightedCapEdge e) {
return g[e.to].get(e.rev);
}
public WeightedCapEdge getEdge(int i) {
int m = pos.size();
rangeCheck(i, 0, m);
InternalWeightedCapEdge e = getInternalEdge(i);
InternalWeightedCapEdge re = getInternalEdgeReversed(e);
return new WeightedCapEdge(re.to, e.to, e.cap + re.cap, re.cap, e.cost);
}
public WeightedCapEdge[] getEdges() {
WeightedCapEdge[] res = new WeightedCapEdge[pos.size()];
java.util.Arrays.setAll(res, this::getEdge);
return res;
}
public FlowAndCost minCostMaxFlow(int s, int t) {
return minCostFlow(s, t, INF);
}
public FlowAndCost minCostFlow(int s, int t, long flowLimit) {
return minCostSlope(s, t, flowLimit).getLast();
}
public java.util.ArrayList<Long> minCostList(int s, int t) {
return minCostList(s, t, INF);
}
public java.util.ArrayList<Long> minCostList(int s, int t, long flowLimit) {
java.util.LinkedList<FlowAndCost> list = minCostSlope(s, t, flowLimit);
FlowAndCost last = list.pollFirst();
java.util.ArrayList<Long> ret = new java.util.ArrayList<>();
ret.add(0L);
while(!list.isEmpty()) {
FlowAndCost now = list.pollFirst();
for (long i = last.flow + 1;i <= now.flow;++ i) {
ret.add(last.cost + (i - last.flow) * (now.cost - last.cost) / (now.flow - last.flow));
}
last = now;
}
return ret;
}
java.util.LinkedList<FlowAndCost> minCostSlope(int s, int t) {
return minCostSlope(s, t, INF);
}
public java.util.LinkedList<FlowAndCost> minCostSlope(int s, int t, long flowLimit) {
rangeCheck(s, 0, n);
rangeCheck(t, 0, n);
if (s == t) { throw new IllegalArgumentException(String.format("%d and %d is the same vertex.", s, t)); }
long[] dual = new long[n];
long[] dist = new long[n];
int[] pv = new int[n];
int[] pe = new int[n];
boolean[] vis = new boolean[n];
long flow = 0;
long cost = 0, prev_cost = -1;
java.util.LinkedList<FlowAndCost> result = new java.util.LinkedList<>();
result.addLast(new FlowAndCost(flow, cost));
while (flow < flowLimit) {
if (!dualRef(s, t, dual, dist, pv, pe, vis)) break;
long c = flowLimit - flow;
for (int v = t; v != s; v = pv[v]) {
c = Math.min(c, g[pv[v]].get(pe[v]).cap);
}
for (int v = t; v != s; v = pv[v]) {
InternalWeightedCapEdge e = g[pv[v]].get(pe[v]);
e.cap -= c;
g[v].get(e.rev).cap += c;
}
long d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost == d) {
result.removeLast();
}
result.addLast(new FlowAndCost(flow, cost));
prev_cost = cost;
}
return result;
}
private boolean dualRef(int s, int t, long[] dual, long[] dist, int[] pv, int[] pe, boolean[] vis) {
java.util.Arrays.fill(dist, INF);
java.util.Arrays.fill(pv, -1);
java.util.Arrays.fill(pe, -1);
java.util.Arrays.fill(vis, false);
class State implements Comparable<State> {
final long key;
final int to;
State(long key, int to) {
this.key = key;
this.to = to;
}
@Override
public int compareTo(State q) {
return key > q.key ? 1 : -1;
}
};
java.util.PriorityQueue<State> pq = new java.util.PriorityQueue<>();
dist[s] = 0;
pq.add(new State(0L, s));
while (pq.size() > 0) {
int v = pq.poll().to;
if (vis[v]) continue;
vis[v] = true;
if (v == t) break;
for (int i = 0, deg = g[v].size(); i < deg; i++) {
InternalWeightedCapEdge e = g[v].get(i);
if (vis[e.to] || e.cap == 0) continue;
long cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
pq.add(new State(dist[e.to], e.to));
}
}
}
if (!vis[t]) { return false; }
for (int v = 0; v < n; v++) {
if (!vis[v]) continue;
dual[v] -= dist[t] - dist[v];
}
return true;
}
private void rangeCheck(int i, int minInlusive, int maxExclusive) {
if (i < 0 || i >= maxExclusive) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, maxExclusive));
}
}
private void nonNegativeCheck(long cap, java.lang.String attribute) {
if (cap < 0) { throw new IllegalArgumentException(String.format("%s %d is negative.", attribute, cap)); }
}
}
/**
* @verified
* <ul>
* <li>https://atcoder.jp/contests/arc050/tasks/arc050_c
* <li>https://atcoder.jp/contests/abc129/tasks/abc129_f
* </ul>
*/
public static final class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
public ModIntFactory(final int mod) {
ma = ModArithmetic.of(mod);
this.mod = mod;
}
public ModInt create(long value) {
if ((value %= mod) < 0) value += mod;
if (ma instanceof ModArithmetic.ModArithmeticMontgomery) {
return new ModInt(((ModArithmetic.ModArithmeticMontgomery) ma).generate(value));
}
return new ModInt((int) value);
}
class ModInt {
private int value;
private ModInt(final int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (ma instanceof ModArithmetic.ModArithmeticMontgomery) {
return ((ModArithmetic.ModArithmeticMontgomery) ma).reduce(value);
}
return value;
}
public ModInt add(final ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(final ModInt mi1, final ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(final ModInt mi1, final ModInt... mis) {
final ModInt mi = add(mi1);
for (final ModInt m : mis) mi.addAsg(m);
return mi;
}
public ModInt add(final long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(final ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(final long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(final ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(final ModInt mi1, final ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(final ModInt mi1, final ModInt... mis) {
final ModInt mi = mul(mi1);
for (final ModInt m : mis) mi.mulAsg(m);
return mi;
}
public ModInt mul(final long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(final ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(final long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(final long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(final ModInt mi) {
value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(final ModInt mi1, final ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(final ModInt... mis) {
for (final ModInt m : mis) addAsg(m);
return this;
}
public ModInt addAsg(final long mi) {
value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(final ModInt mi) {
value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(final long mi) {
value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(final ModInt mi) {
value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(final ModInt mi1, final ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(final ModInt... mis) {
for (final ModInt m : mis) mulAsg(m);
return this;
}
public ModInt mulAsg(final long mi) {
value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(final ModInt mi) {
value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(final long mi) {
value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(final Object o) {
if (o instanceof ModInt) {
final ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private interface ModArithmetic {
public int mod();
public int remainder(long value);
public int add(int a, int b);
public int sub(int a, int b);
public int mul(int a, int b);
public default int div(final int a, final int b) {
return mul(a, inv(b));
}
public int inv(int a);
public int pow(int a, long b);
public static ModArithmetic of(final int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
static final class ModArithmetic1 implements ModArithmetic {
@Override
public int mod() {
return 1;
}
@Override
public int remainder(final long value) {
return 0;
}
@Override
public int add(final int a, final int b) {
return 0;
}
@Override
public int sub(final int a, final int b) {
return 0;
}
@Override
public int mul(final int a, final int b) {
return 0;
}
@Override
public int inv(final int a) {
throw new ArithmeticException("divide by zero");
}
@Override
public int pow(final int a, final long b) {
return 0;
}
}
static final class ModArithmetic2 implements ModArithmetic {
@Override
public int mod() {
return 2;
}
@Override
public int remainder(final long value) {
return (int) (value & 1);
}
@Override
public int add(final int a, final int b) {
return a ^ b;
}
@Override
public int sub(final int a, final int b) {
return a ^ b;
}
@Override
public int mul(final int a, final int b) {
return a & b;
}
@Override
public int inv(final int a) {
if (a == 0) throw new ArithmeticException("divide by zero");
return a;
}
@Override
public int pow(final int a, final long b) {
if (b == 0) return 1;
return a;
}
}
static final class ModArithmetic998244353 implements ModArithmetic {
private final int mod = 998244353;
@Override
public int mod() {
return mod;
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int add(final int a, final int b) {
final int res = a + b;
return res >= mod ? res - mod : res;
}
@Override
public int sub(final int a, final int b) {
final int res = a - b;
return res < 0 ? res + mod : res;
}
@Override
public int mul(final int a, final int b) {
return (int) ((long) a * b % mod);
}
@Override
public int inv(int a) {
int b = mod;
long u = 1, v = 0;
while (b >= 1) {
final long t = a / b;
a -= t * b;
final int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
final long tmp2 = u;
u = v;
v = tmp2;
}
u %= mod;
if (a != 1) { throw new ArithmeticException("divide by zero"); }
return (int) (u < 0 ? u + mod : u);
}
@Override
public int pow(final int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
long res = 1;
long pow2 = a;
long idx = 1;
while (b > 0) {
final long lsb = b & -b;
for (; lsb != idx; idx <<= 1) {
pow2 = pow2 * pow2 % mod;
}
res = res * pow2 % mod;
b ^= lsb;
}
return (int) res;
}
}
static final class ModArithmetic1000000007 implements ModArithmetic {
private final int mod = 1000000007;
@Override
public int mod() {
return mod;
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int add(final int a, final int b) {
final int res = a + b;
return res >= mod ? res - mod : res;
}
@Override
public int sub(final int a, final int b) {
final int res = a - b;
return res < 0 ? res + mod : res;
}
@Override
public int mul(final int a, final int b) {
return (int) ((long) a * b % mod);
}
@Override
public int div(final int a, final int b) {
return mul(a, inv(b));
}
@Override
public int inv(int a) {
int b = mod;
long u = 1, v = 0;
while (b >= 1) {
final long t = a / b;
a -= t * b;
final int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
final long tmp2 = u;
u = v;
v = tmp2;
}
u %= mod;
if (a != 1) { throw new ArithmeticException("divide by zero"); }
return (int) (u < 0 ? u + mod : u);
}
@Override
public int pow(final int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
long res = 1;
long pow2 = a;
long idx = 1;
while (b > 0) {
final long lsb = b & -b;
for (; lsb != idx; idx <<= 1) {
pow2 = pow2 * pow2 % mod;
}
res = res * pow2 % mod;
b ^= lsb;
}
return (int) res;
}
}
static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2, r3;
private ModArithmeticMontgomery(final int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
final long r = (1l << 32) % mod;
negInv = inv;
r2 = r * r % mod;
r3 = r2 * r % mod;
}
private int generate(final long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = x + (x * negInv & 0xffff_ffffl) * mod >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
public int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
public int mul(final int a, final int b) {
return reduce((long) a * b);
}
@Override
public int inv(int a) {
a = super.inv(a);
return reduce(a * r3);
}
@Override
public int pow(final int a, final long b) {
return generate(super.pow(a, b));
}
}
static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(final int mod) {
super(mod);
/**
* m = floor(2^64/mod) 2^64 = p*mod + q, 2^32 = a*mod + b => (a*mod + b)^2 =
* p*mod + q => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
final long a = (1l << 32) / mod;
final long b = (1l << 32) % mod;
final long m = a * a * mod + 2 * a * b + b * b / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long 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 (int) (x < mod ? x : x - mod);
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int mul(final int a, final int b) {
return reduce((long) a * b);
}
}
static class ModArithmeticDynamic implements ModArithmetic {
final int mod;
public ModArithmeticDynamic(final int mod) {
this.mod = mod;
}
@Override
public int mod() {
return mod;
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int add(final int a, final int b) {
final int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
@Override
public int sub(final int a, final int b) {
final int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
@Override
public int mul(final int a, final int b) {
return (int) ((long) a * b % mod);
}
@Override
public int inv(int a) {
int b = mod;
long u = 1, v = 0;
while (b >= 1) {
final long t = a / b;
a -= t * b;
final int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
final long tmp2 = u;
u = v;
v = tmp2;
}
u %= mod;
if (a != 1) { throw new ArithmeticException("divide by zero"); }
return (int) (u < 0 ? u + mod : u);
}
@Override
public int pow(final int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
int res = 1;
int pow2 = a;
long idx = 1;
while (b > 0) {
final long lsb = b & -b;
for (; lsb != idx; idx <<= 1) {
pow2 = mul(pow2, pow2);
}
res = mul(res, pow2);
b ^= lsb;
}
return res;
}
}
}
}
/**
* Convolution.
*
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_f
* @verified https://judge.yosupo.jp/problem/convolution_mod_1000000007
*/
public static final class Convolution {
/**
* writer: amotama 勝手に借りてます、問題あったらごめんね
*/
private static void fft(double[] a, double[] b, boolean invert) {
int count = a.length;
for (int i = 1, j = 0; i < count; i++) {
int bit = count >> 1;
for (; j >= bit; bit >>= 1) {
j -= bit;
}
j += bit;
if (i < j) {
double temp = a[i];
a[i] = a[j];
a[j] = temp;
temp = b[i];
b[i] = b[j];
b[j] = temp;
}
}
for (int len = 2; len <= count; len <<= 1) {
int halfLen = len >> 1;
double angle = 2 * Math.PI / len;
if (invert) {
angle = -angle;
}
double wLenA = Math.cos(angle);
double wLenB = Math.sin(angle);
for (int i = 0; i < count; i += len) {
double wA = 1;
double wB = 0;
for (int j = 0; j < halfLen; j++) {
double uA = a[i + j];
double uB = b[i + j];
double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
a[i + j] = uA + vA;
b[i + j] = uB + vB;
a[i + j + halfLen] = uA - vA;
b[i + j + halfLen] = uB - vB;
double nextWA = wA * wLenA - wB * wLenB;
wB = wA * wLenB + wB * wLenA;
wA = nextWA;
}
}
}
if (invert) {
for (int i = 0; i < count; i++) {
a[i] /= count;
b[i] /= count;
}
}
}
/**
* writer: amotama 勝手に借りてます、問題あったらごめんね
*/
public static long[] convolution(long[] a, long[] b) {
int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
resultSize = Math.max(resultSize, 1);
double[] aReal = new double[resultSize];
double[] aImaginary = new double[resultSize];
double[] bReal = new double[resultSize];
double[] bImaginary = new double[resultSize];
for (int i = 0; i < a.length; i++) aReal[i] = a[i];
for (int i = 0; i < b.length; i++) bReal[i] = b[i];
fft(aReal, aImaginary, false);
if (a == b) {
System.arraycopy(aReal, 0, bReal, 0, aReal.length);
System.arraycopy(aImaginary, 0, bImaginary, 0, aImaginary.length);
} else {
fft(bReal, bImaginary, false);
}
for (int i = 0; i < resultSize; i++) {
double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
aReal[i] = real;
}
fft(aReal, aImaginary, true);
long[] result = new long[a.length + b.length - 1];
for (int i = 0; i < result.length; i++) result[i] = Math.round(aReal[i]);
return result;
}
/**
* writer: amotama 勝手に借りてます、問題あったらごめんね
*/
public static int[] convolution(int[] a, int[] b) {
int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
resultSize = Math.max(resultSize, 1);
double[] aReal = new double[resultSize];
double[] aImaginary = new double[resultSize];
double[] bReal = new double[resultSize];
double[] bImaginary = new double[resultSize];
for (int i = 0; i < a.length; i++) aReal[i] = a[i];
for (int i = 0; i < b.length; i++) bReal[i] = b[i];
fft(aReal, aImaginary, false);
if (a == b) {
System.arraycopy(aReal, 0, bReal, 0, aReal.length);
System.arraycopy(aImaginary, 0, bImaginary, 0, aImaginary.length);
} else {
fft(bReal, bImaginary, false);
}
for (int i = 0; i < resultSize; i++) {
double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
aReal[i] = real;
}
fft(aReal, aImaginary, true);
int[] result = new int[a.length + b.length - 1];
for (int i = 0; i < result.length; i++) result[i] = (int) Math.round(aReal[i]);
return result;
}
public static double[] convolution(double[] a, double[] b) {
int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
resultSize = Math.max(resultSize, 1);
double[] aReal = Arrays.copyOf(a, resultSize);
double[] aImaginary = new double[resultSize];
double[] bReal = Arrays.copyOf(b, resultSize);
double[] bImaginary = new double[resultSize];
fft(aReal, aImaginary, false);
if (a == b) {
System.arraycopy(aReal, 0, bReal, 0, aReal.length);
System.arraycopy(aImaginary, 0, bImaginary, 0, aImaginary.length);
} else {
fft(bReal, bImaginary, false);
}
for (int i = 0; i < resultSize; i++) {
double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
aReal[i] = real;
}
fft(aReal, aImaginary, true);
return Arrays.copyOf(aReal, a.length + b.length - 1);
}
/**
* Find a primitive root.
*
* @param m A prime number.
* @return Primitive root.
*/
private static int primitiveRoot(final int m) {
if (m == 2) return 1;
if (m == 167772161) return 3;
if (m == 469762049) return 3;
if (m == 754974721) return 11;
if (m == 998244353) return 3;
final int[] divs = new int[20];
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0) x /= 2;
for (int i = 3; (long) i * i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
boolean ok = true;
for (int i = 0; i < cnt; i++) {
if (MathLib.pow(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok) return g;
}
}
/**
* Ceil of power 2.
*
* @param n Value.
* @return Ceil of power 2.
*/
private static int ceilPow2(final int n) {
int x = 0;
while (1L << x < n) x++;
return x;
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static long garner(final long[] c, final int[] mods) {
final int n = c.length + 1;
final long[] cnst = new long[n];
final long[] coef = new long[n];
java.util.Arrays.fill(coef, 1);
for (int i = 0; i < n - 1; i++) {
final int m1 = mods[i];
long v = (c[i] - cnst[i] + m1) % m1;
v = v * MathLib.pow(coef[i], m1 - 2, m1) % m1;
for (int j = i + 1; j < n; j++) {
final long m2 = mods[j];
cnst[j] = (cnst[j] + coef[j] * v) % m2;
coef[j] = coef[j] * m1 % m2;
}
}
return cnst[n - 1];
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static int garner(int c0, int c1, int c2, final MathLib.Barrett[] mods) {
final long[] cnst = new long[4];
final long[] coef = new long[4];
java.util.Arrays.fill(coef, 1);
MathLib.Barrett m1 = mods[0];
long v = m1.reduce(c0 - cnst[0] + m1.mod);
v = m1.reduce(v * MathLib.pow(coef[0], m1.mod - 2, m1));
{
MathLib.Barrett m2 = mods[1];
cnst[1] = m2.reduce(cnst[1] + coef[1] * v);
coef[1] = m2.reduce(coef[1] * m1.mod);
m2 = mods[2];
cnst[2] = m2.reduce(cnst[2] + coef[2] * v);
coef[2] = m2.reduce(coef[2] * m1.mod);
m2 = mods[3];
cnst[3] = m2.reduce(cnst[3] + coef[3] * v);
coef[3] = m2.reduce(coef[3] * m1.mod);
}
m1 = mods[1];
v = m1.reduce(c1 - cnst[1] + m1.mod);
v = m1.reduce(v * MathLib.pow(coef[1], m1.mod - 2, m1));
{
MathLib.Barrett m2 = mods[2];
cnst[2] = m2.reduce(cnst[2] + coef[2] * v);
coef[2] = m2.reduce(coef[2] * m1.mod);
m2 = mods[3];
cnst[3] = m2.reduce(cnst[3] + coef[3] * v);
coef[3] = m2.reduce(coef[3] * m1.mod);
}
m1 = mods[2];
v = m1.reduce(c2 - cnst[2] + m1.mod);
v = m1.reduce(v * MathLib.pow(coef[2], m1.mod - 2, m1));
{
MathLib.Barrett m2 = mods[3];
cnst[3] = m2.reduce(cnst[3] + coef[3] * v);
coef[3] = m2.reduce(coef[3] * m1.mod);
}
return (int) cnst[3];
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static int garner1_000_000_007(int c0, int c1, int c2) {
final long[] cnst = new long[4];
final long[] coef = new long[4];
java.util.Arrays.fill(coef, 1);
long v = (c0 - cnst[0] + 998_244_353) % 998_244_353;
v = v * MathLib.pow998_244_353(coef[0], 998_244_353 - 2) % 998_244_353;
{
cnst[1] = (cnst[1] + coef[1] * v) % 167_772_161;
coef[1] = coef[1] * 998_244_353 % 167_772_161;
cnst[2] = (cnst[2] + coef[2] * v) % 469_762_049;
coef[2] = coef[2] * 998_244_353 % 469_762_049;
cnst[3] = (cnst[3] + coef[3] * v) % 1_000_000_007;
coef[3] = coef[3] * 998_244_353 % 1_000_000_007;
}
v = (c1 - cnst[1] + 167_772_161) % 167_772_161;
v = v * MathLib.pow167_772_161(coef[1], 167_772_161 - 2) % 167_772_161;
{
cnst[2] = (cnst[2] + coef[2] * v) % 469_762_049;
coef[2] = coef[2] * 167_772_161 % 469_762_049;
cnst[3] = (cnst[3] + coef[3] * v) % 1_000_000_007;
coef[3] = coef[3] * 167_772_161 % 1_000_000_007;
}
v = (c2 - cnst[2] + 469_762_049) % 469_762_049;
v = v * MathLib.pow469_762_049(coef[2], 469_762_049 - 2) % 469_762_049;
{
cnst[3] = (cnst[3] + coef[3] * v) % 1_000_000_007;
coef[3] = coef[3] * 469_762_049 % 1_000_000_007;
}
return (int) cnst[3];
}
/**
* Pre-calculation for NTT.
*
* @param mod NTT Prime.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumE(final int mod, final int g) {
final long[] sum_e = new long[30];
final long[] es = new long[30];
final long[] ies = new long[30];
final int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = MathLib.pow(g, mod - 1 >> cnt2, mod);
long ie = MathLib.pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now % mod;
now = now * ies[i] % mod;
}
return sum_e;
}
/**
* Pre-calculation for inverse NTT.
*
* @param mod Mod.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumIE(final int mod, final int g) {
final long[] sum_ie = new long[30];
final long[] es = new long[30];
final long[] ies = new long[30];
final int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = MathLib.pow(g, mod - 1 >> cnt2, mod);
long ie = MathLib.pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now % mod;
now = now * es[i] % mod;
}
return sum_ie;
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterflyInv(final long[] a, final long[] sumIE, final int mod) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (mod + l - r) * inow % mod;
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % mod;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly(final long[] a, final long[] sumE, final int mod) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now % mod;
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (l - r + mod) % mod;
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % mod;
}
}
}
/**
* Inverse NTT used mod 998_244_353.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
*/
private static void butterflyInv998_244_353(final int[] a, final int[] sumIE) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (int) ((l + r) % 998_244_353);
a[i + offset + p] = (int) ((998_244_353 + l - r) * inow % 998_244_353);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % 998_244_353;
}
}
}
/**
* Inverse NTT used mod 167_772_161.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
*/
private static void butterflyInv167_772_161(final int[] a, final int[] sumIE) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (int) ((l + r) % 167_772_161);
a[i + offset + p] = (int) ((167_772_161 + l - r) * inow % 167_772_161);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % 167_772_161;
}
}
}
/**
* Inverse NTT used mod 469_762_049.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
*/
private static void butterflyInv469_762_049(final int[] a, final int[] sumIE) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (int) ((l + r) % 469_762_049);
a[i + offset + p] = (int) ((469_762_049 + l - r) * inow % 469_762_049);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % 469_762_049;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterflyInv(final int[] a, final int[] sumIE, final MathLib.Barrett mod) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
long sum = l + r;
if (sum >= mod.mod) sum -= mod.mod;
a[i + offset] = (int) sum;
a[i + offset + p] = mod.reduce((mod.mod + l - r) * inow);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = mod.reduce(inow * sumIE[x]);
}
}
}
/**
* Inverse NTT used mod 998_244_353.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly998_244_353(final int[] a, final int[] sumE) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (998_244_353 - 2) * 998_244_353;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = (int) ((l + r) % 998_244_353);
a[i + offset + p] = (int) ((l - r + ADD) % 998_244_353);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % 998_244_353;
}
}
}
/**
* Inverse NTT used mod 167_772_161.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly167_772_161(final int[] a, final int[] sumE) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (167_772_161 - 2) * 167_772_161;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = (int) ((l + r) % 167_772_161);
a[i + offset + p] = (int) ((l - r + ADD) % 167_772_161);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % 167_772_161;
}
}
}
/**
* Inverse NTT used mod 469_762_049.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly469_762_049(final int[] a, final int[] sumE) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (469_762_049 - 2) * 469_762_049;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = (int) ((l + r) % 469_762_049);
a[i + offset + p] = (int) ((l - r + ADD) % 469_762_049);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % 469_762_049;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly(final int[] a, final int[] sumE, final MathLib.Barrett mod) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (mod.mod - 2) * mod.mod;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = mod.reduce(l + r);
a[i + offset + p] = mod.reduce(l - r + ADD);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = mod.reduce(now * sumE[x]);
}
}
}
/**
* Convolution used mod 998_244_353.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution998_244_353(int[] a, int[] b) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(998_244_353);
final int[] sume;
{
long[] s = sumE(998_244_353, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(998_244_353, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly998_244_353(a, sume);
butterfly998_244_353(b, sume);
for (int i = 0; i < z; i++) a[i] = (int) ((long) a[i] * b[i] % 998_244_353);
butterflyInv998_244_353(a, sumie);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow998_244_353(z, 998_244_353 - 2);
for (int i = 0; i < n + m - 1; i++) a[i] = (int) (a[i] * iz % 998_244_353);
return a;
}
/**
* Convolution used mod 167_772_161.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution167_772_161(int[] a, int[] b) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(167_772_161);
final int[] sume;
{
long[] s = sumE(167_772_161, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(167_772_161, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly167_772_161(a, sume);
butterfly167_772_161(b, sume);
for (int i = 0; i < z; i++) a[i] = (int) ((long) a[i] * b[i] % 167_772_161);
butterflyInv167_772_161(a, sumie);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow167_772_161(z, 167_772_161 - 2);
for (int i = 0; i < n + m - 1; i++) a[i] = (int) (a[i] * iz % 167_772_161);
return a;
}
/**
* Convolution used mod 469_762_049.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution469_762_049(int[] a, int[] b) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(469_762_049);
final int[] sume;
{
long[] s = sumE(469_762_049, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(469_762_049, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly469_762_049(a, sume);
butterfly469_762_049(b, sume);
for (int i = 0; i < z; i++) a[i] = (int) ((long) a[i] * b[i] % 469_762_049);
butterflyInv469_762_049(a, sumie);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow469_762_049(z, 469_762_049 - 2);
for (int i = 0; i < n + m - 1; i++) a[i] = (int) (a[i] * iz % 469_762_049);
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
private static int[] convolutionNTT(int[] a, int[] b, final int mod) {
MathLib.Barrett barrett = new MathLib.Barrett(mod);
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(mod);
final int[] sume;
{
long[] s = sumE(mod, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(mod, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly(a, sume, barrett);
butterfly(b, sume, barrett);
for (int i = 0; i < z; i++) a[i] = barrett.reduce((long) a[i] * b[i]);
butterflyInv(a, sumie, barrett);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow(z, mod - 2, mod);
for (int i = 0; i < n + m - 1; i++) a[i] = barrett.reduce(a[i] * iz);
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
private static long[] convolutionNTT(long[] a, long[] b, final int mod) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new long[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final long[] na = new long[z];
final long[] nb = new long[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(mod);
final long[] sume = sumE(mod, g);
final long[] sumie = sumIE(mod, g);
butterfly(a, sume, mod);
butterfly(b, sume, mod);
for (int i = 0; i < z; i++) {
a[i] = a[i] * b[i] % mod;
}
butterflyInv(a, sumie, mod);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow(z, mod - 2, mod);
for (int i = 0; i < n + m - 1; i++) a[i] = a[i] * iz % mod;
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static long[] convolution(final long[] a, final long[] b, final int mod) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new long[0];
final int mod1 = 998_244_353;
final int mod2 = 167_772_161;
final int mod3 = 469_762_049;
final long[] c1 = convolutionNTT(a, b, mod1);
final long[] c2 = convolutionNTT(a, b, mod2);
final long[] c3 = convolutionNTT(a, b, mod3);
final int retSize = c1.length;
final long[] ret = new long[retSize];
final int[] mods = { mod1, mod2, mod3, mod };
for (int i = 0; i < retSize; ++i) {
ret[i] = garner(new long[] { c1[i], c2[i], c3[i] }, mods);
}
return ret;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static int[] convolution(final int[] a, final int[] b, final int mod) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
if (mod == 1_000_000_007) return convolution1_000_000_007(a, b);
if (mod == 998_244_353) return convolution998_244_353(a, b);
int ntt = Integer.lowestOneBit(mod - 1) >> 1;
if (n + m <= ntt) return convolutionNTT(a, b, mod);
final int[] c1 = convolution998_244_353(a, b);
final int[] c2 = convolution167_772_161(a, b);
final int[] c3 = convolution469_762_049(a, b);
final int retSize = c1.length;
final int[] ret = new int[retSize];
final MathLib.Barrett[] mods = { new MathLib.Barrett(998_244_353), new MathLib.Barrett(167_772_161),
new MathLib.Barrett(469_762_049), new MathLib.Barrett(mod) };
for (int i = 0; i < retSize; ++i) ret[i] = garner(c1[i], c2[i], c3[i], mods);
return ret;
}
/**
* Convolution used mod 1_000_000_007.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution1_000_000_007(final int[] a, final int[] b) {
final int[] c1 = convolution998_244_353(a, b);
final int[] c2 = convolution167_772_161(a, b);
final int[] c3 = convolution469_762_049(a, b);
final int retSize = c1.length;
final int[] ret = new int[retSize];
for (int i = 0; i < retSize; ++i) ret[i] = garner1_000_000_007(c1[i], c2[i], c3[i]);
return ret;
}
/**
* Convolution. need: length < 2000
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static int[] convolution2(final int[] a, final int[] b, final int mod) {
if (Math.max(a.length, b.length) < 4000) {
long[] la = new long[a.length], ha = new long[a.length], ma = new long[a.length],
lb = new long[b.length], hb = new long[b.length], mb = new long[b.length];
MathLib.Barrett barrett = new MathLib.Barrett(mod);
for (int i = 0; i < a.length; ++i) {
ha[i] = a[i] >> 15;
la[i] = a[i] & 0x7FFF;
ma[i] = la[i] + ha[i];
}
for (int i = 0; i < b.length; ++i) {
hb[i] = b[i] >> 15;
lb[i] = b[i] & 0x7FFF;
mb[i] = lb[i] + hb[i];
}
long[] l = convolution(la, lb), h = convolution(ha, hb), m = convolution(ma, mb);
int[] ret = new int[m.length];
for (int i = 0; i < m.length; ++i) {
h[i] = barrett.reduce(h[i]);
m[i] = barrett.reduce(m[i] - l[i] - h[i] + (long) m.length * mod);
ret[i] = barrett.reduce((h[i] << 30) + (m[i] << 15) + l[i]);
}
return ret;
}
return convolution(a, b, mod);
}
/**
* Naive convolution. (Complexity is O(N^2)!!)
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Mod.
* @return Answer.
*/
public static long[] convolutionNaive(final long[] a, final long[] b, final int mod) {
final int n = a.length;
final int m = b.length;
final int k = n + m - 1;
final long[] ret = new long[k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret[i + j] += a[i] * b[j] % mod;
ret[i + j] %= mod;
}
}
return ret;
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_g
*/
public static final class SCC {
static class Edge {
int from, to;
public Edge(final int from, final int to) {
this.from = from;
this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(final int n) {
this.n = n;
unorderedEdges = new java.util.ArrayList<>();
start = new int[n + 1];
ids = new int[n];
}
public void addEdge(final int from, final int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
m++;
}
public int id(final int i) {
if (!hasBuilt) { throw new UnsupportedOperationException("Graph hasn't been built."); }
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
final Edge[] orderedEdges = new Edge[m];
final int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (final Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
final int[] par = new int[n];
final int[] vis = new int[n];
final int[] low = new int[n];
final int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
final long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
final long p = stack[--ptr];
// vertex
final int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
final int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j-- > 0) {
final int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
final int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
final int[] counts = new int[groupNum];
for (final int x : ids) counts[x]++;
final int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
final int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(final int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/submissions/16647102
*/
public static final class TwoSAT {
private final int n;
private final InternalSCC scc;
private final boolean[] answer;
private boolean hasCalledSatisfiable = false;
private boolean existsAnswer = false;
public TwoSAT(int n) {
this.n = n;
scc = new InternalSCC(2 * n);
answer = new boolean[n];
}
public void addClause(int x, boolean f, int y, boolean g) {
rangeCheck(x);
rangeCheck(y);
scc.addEdge(x << 1 | (f ? 0 : 1), y << 1 | (g ? 1 : 0));
scc.addEdge(y << 1 | (g ? 0 : 1), x << 1 | (f ? 1 : 0));
}
public void addImplication(int x, boolean f, int y, boolean g) {
addClause(x, !f, y, g);
}
public void addNand(int x, boolean f, int y, boolean g) {
addClause(x, !f, y, !g);
}
public void set(int x, boolean f) {
addClause(x, f, x, f);
}
public boolean satisfiable() {
hasCalledSatisfiable = true;
int[] ids = scc.ids();
for (int i = 0; i < n; i++) {
if (ids[i << 1 | 0] == ids[i << 1 | 1]) return existsAnswer = false;
answer[i] = ids[i << 1 | 0] < ids[i << 1 | 1];
}
return existsAnswer = true;
}
public boolean[] answer() {
if (!hasCalledSatisfiable) {
throw new UnsupportedOperationException("Call TwoSAT#satisfiable at least once before TwoSAT#answer.");
}
if (existsAnswer) return answer;
return null;
}
private void rangeCheck(int x) {
if (x < 0 || x >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", x, n));
}
}
private static final class EdgeList {
long[] a;
int ptr = 0;
EdgeList(int cap) {
a = new long[cap];
}
void add(int upper, int lower) {
if (ptr == a.length) grow();
a[ptr++] = (long) upper << 32 | lower;
}
void grow() {
long[] b = new long[a.length << 1];
System.arraycopy(a, 0, b, 0, a.length);
a = b;
}
}
private static final class InternalSCC {
final int n;
int m;
final EdgeList unorderedEdges;
final int[] start;
InternalSCC(int n) {
this.n = n;
unorderedEdges = new EdgeList(n);
start = new int[n + 1];
}
void addEdge(int from, int to) {
unorderedEdges.add(from, to);
start[from + 1]++;
m++;
}
static final long mask = 0xffff_ffffl;
int[] ids() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
int[] orderedEdges = new int[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (int i = 0; i < m; i++) {
long e = unorderedEdges.a[i];
orderedEdges[count[(int) (e >>> 32)]++] = (int) (e & mask);
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
int[] ids = new int[n];
long[] stack = new long[n];
int ptr = 0;
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
stack[ptr++] = i;
while (ptr > 0) {
long p = stack[--ptr];
int u = (int) (p & mask);
int j = (int) (p >>> 32);
if (j == 0) {
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) {
int to = orderedEdges[start[u] + j];
stack[ptr++] += 1l << 32;
if (ord[to] == -1) {
stack[ptr++] = to;
par[to] = u;
} else {
low[u] = Math.min(low[u], ord[to]);
}
} else {
while (j-- > 0) {
int to = orderedEdges[start[u] + j];
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) {
while (true) {
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++;
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
return ids;
}
}
}
public static final class StringAlgorithm {
private static int[] saNaive(final int[] s) {
final int n = s.length;
final Integer[] _sa = new Integer[n];
for (int i = 0; i < n; i++) {
_sa[i] = i;
}
java.util.Arrays.sort(_sa, (l, r) -> {
while (l < n && r < n) {
if (s[l] != s[r]) return s[l] - s[r];
l++;
r++;
}
return -(l - r);
});
final int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = _sa[i];
}
return sa;
}
private static int[] saDoubling(final int[] s) {
final int n = s.length;
final Integer[] _sa = new Integer[n];
for (int i = 0; i < n; i++) {
_sa[i] = i;
}
int[] rnk = s;
int[] tmp = new int[n];
for (int k = 1; k < n; k *= 2) {
final int _k = k;
final int[] _rnk = rnk;
final java.util.Comparator<Integer> cmp = (x, y) -> {
if (_rnk[x] != _rnk[y]) return _rnk[x] - _rnk[y];
final int rx = x + _k < n ? _rnk[x + _k] : -1;
final int ry = y + _k < n ? _rnk[y + _k] : -1;
return rx - ry;
};
java.util.Arrays.sort(_sa, cmp);
tmp[_sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[_sa[i]] = tmp[_sa[i - 1]] + (cmp.compare(_sa[i - 1], _sa[i]) < 0 ? 1 : 0);
}
final int[] buf = tmp;
tmp = rnk;
rnk = buf;
}
final int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = _sa[i];
}
return sa;
}
private static final int THRESHOLD_NAIVE = 10;
private static final int THRESHOLD_DOUBLING = 40;
private static int[] sais(final int[] s, final int upper) {
final int n = s.length;
if (n == 0) return new int[0];
if (n == 1) return new int[] { 0 };
if (n == 2) { return s[0] < s[1] ? new int[] { 0, 1 } : new int[] { 1, 0 }; }
if (n < THRESHOLD_NAIVE) { return saNaive(s); }
if (n < THRESHOLD_DOUBLING) { return saDoubling(s); }
final int[] sa = new int[n];
final boolean[] ls = new boolean[n];
for (int i = n - 2; i >= 0; i--) {
ls[i] = s[i] == s[i + 1] ? ls[i + 1] : s[i] < s[i + 1];
}
final int[] sumL = new int[upper + 1];
final int[] sumS = new int[upper + 1];
for (int i = 0; i < n; i++) {
if (ls[i]) {
sumL[s[i] + 1]++;
} else {
sumS[s[i]]++;
}
}
for (int i = 0; i <= upper; i++) {
sumS[i] += sumL[i];
if (i < upper) sumL[i + 1] += sumS[i];
}
final java.util.function.Consumer<int[]> induce = lms -> {
java.util.Arrays.fill(sa, -1);
final int[] buf = new int[upper + 1];
System.arraycopy(sumS, 0, buf, 0, upper + 1);
for (final int d : lms) {
if (d == n) continue;
sa[buf[s[d]]++] = d;
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
final int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
for (int i = n - 1; i >= 0; i--) {
final int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
final int[] lmsMap = new int[n + 1];
java.util.Arrays.fill(lmsMap, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lmsMap[i] = m++;
}
}
final int[] lms = new int[m];
{
int p = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms[p++] = i;
}
}
}
induce.accept(lms);
if (m > 0) {
final int[] sortedLms = new int[m];
{
int p = 0;
for (final int v : sa) {
if (lmsMap[v] != -1) {
sortedLms[p++] = v;
}
}
}
final int[] recS = new int[m];
int recUpper = 0;
recS[lmsMap[sortedLms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sortedLms[i - 1], r = sortedLms[i];
final int endL = lmsMap[l] + 1 < m ? lms[lmsMap[l] + 1] : n;
final int endR = lmsMap[r] + 1 < m ? lms[lmsMap[r] + 1] : n;
boolean same = true;
if (endL - l != endR - r) {
same = false;
} else {
while (l < endL && s[l] == s[r]) {
l++;
r++;
}
if (l == n || s[l] != s[r]) same = false;
}
if (!same) {
recUpper++;
}
recS[lmsMap[sortedLms[i]]] = recUpper;
}
final int[] recSA = sais(recS, recUpper);
for (int i = 0; i < m; i++) {
sortedLms[i] = lms[recSA[i]];
}
induce.accept(sortedLms);
}
return sa;
}
public static int[] suffixArray(final int[] s, final int upper) {
assert 0 <= upper;
for (final int d : s) {
assert 0 <= d && d <= upper;
}
return sais(s, upper);
}
public static int[] suffixArray(final int[] s) {
final int n = s.length;
final Integer[] idx = new Integer[n];
for (int i = 0; i < n; i++) {
idx[i] = i;
}
java.util.Arrays.sort(idx, (l, r) -> s[l] - s[r]);
final int[] s2 = new int[n];
int now = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && s[idx[i - 1]] != s[idx[i]]) {
now++;
}
s2[idx[i]] = now;
}
return sais(s2, now);
}
public static int[] suffixArray(final char[] s) {
final int n = s.length;
final int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return sais(s2, 255);
}
public static int[] suffixArray(final java.lang.String s) {
return suffixArray(s.toCharArray());
}
public static int[] lcpArray(final int[] s, final int[] sa) {
final int n = s.length;
assert n >= 1;
final int[] rnk = new int[n];
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
final int[] lcp = new int[n - 1];
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0) h--;
if (rnk[i] == 0) {
continue;
}
final int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h]) break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
public static int[] lcpArray(final char[] s, final int[] sa) {
final int n = s.length;
final int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcpArray(s2, sa);
}
public static int[] lcpArray(final java.lang.String s, final int[] sa) {
return lcpArray(s.toCharArray(), sa);
}
public static int[] zAlgorithm(final int[] s) {
final int n = s.length;
if (n == 0) return new int[0];
final int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k]) k++;
z[i] = k;
if (j + z[j] < i + z[i]) j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(final char[] s) {
final int n = s.length;
if (n == 0) return new int[0];
final int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k]) k++;
z[i] = k;
if (j + z[j] < i + z[i]) j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(final String s) {
return zAlgorithm(s.toCharArray());
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_j
*/
public static final 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(final int n, final java.util.function.BinaryOperator<S> op, final S e) {
MAX = n;
int k = 1;
while (k < n) k <<= 1;
N = k;
E = e;
this.op = op;
data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(final S[] dat, final java.util.function.BinaryOperator<S> op, final S e) {
this(dat.length, op, e);
build(dat);
}
private void build(final S[] dat) {
final 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, final 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 void set(int p, java.util.function.UnaryOperator<S> f) {
exclusiveRangeCheck(p);
data[p += N] = f.apply(data[p]);
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(final 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, final 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, final 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(final 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(final 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));
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0;i < N;++ i) {
if (i != 0) sb.append(", ");
sb.append(data[i + N]);
}
sb.append(']');
return sb.toString();
}
}
/**
*
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_k
*/
public static final class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(final int n, final java.util.function.BinaryOperator<S> op, final S e,
final java.util.function.BiFunction<F, S, S> mapping,
final java.util.function.BinaryOperator<F> composition, final F id) {
MAX = n;
int k = 1;
while (k < n) k <<= 1;
N = k;
Log = Integer.numberOfTrailingZeros(N);
Op = op;
E = e;
Mapping = mapping;
Composition = composition;
Id = id;
Dat = (S[]) new Object[N << 1];
Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(final S[] dat, final java.util.function.BinaryOperator<S> op, final S e,
final java.util.function.BiFunction<F, S, S> mapping,
final java.util.function.BinaryOperator<F> composition, final F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(final S[] dat) {
final int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(final int k) {
if (Laz[k] == Id) return;
final int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(final int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(final int lk, final int rk) {
for (int i = Log; i > 0; i--) {
if (lk >> i << i != lk) push(lk >> i);
if (rk >> i << i != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(final int lk, final int rk) {
for (int i = 1; i <= Log; i++) {
if (lk >> i << i != lk) {
final int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (rk >> i << i != rk) {
final int rki = rk - 1 >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, final S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
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);
if (l == r) return E;
l += N;
r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1;
r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, final F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, final F f) {
if (l > r) { throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r)); }
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N;
r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1;
r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, final java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) { throw new IllegalArgumentException("Identity element must satisfy the condition."); }
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, final java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) { throw new IllegalArgumentException("Identity element must satisfy the condition."); }
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(final int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(final int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(final int newIndent) { indent = newIndent; }
@Override
public String toString() {
return toString(1, 0);
}
private String toString(final int k, final int sp) {
if (k >= N) return indent(sp) + Dat[k];
String s = "";
s += toString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + Dat[k] + "/" + Laz[k];
s += "\n";
s += toString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
final StringBuilder sb = new StringBuilder();
while (n-- > 0) sb.append(' ');
return sb.toString();
}
}
public static final class MultiSet<T> extends java.util.TreeMap<T, Long> {
private static final long serialVersionUID = 1L;
public MultiSet() {
super();
}
public MultiSet(final java.util.List<T> list) {
super();
for (final T e : list) this.addOne(e);
}
public long count(final Object elm) {
return getOrDefault(elm, 0L);
}
public void add(final T elm, final long amount) {
if (!containsKey(elm)) put(elm, amount);
else replace(elm, get(elm) + amount);
if (this.count(elm) == 0) this.remove(elm);
}
public void addOne(final T elm) {
this.add(elm, 1);
}
public void removeOne(final T elm) {
this.add(elm, -1);
}
public void removeAll(final T elm) {
this.add(elm, -this.count(elm));
}
public static <T> MultiSet<T> merge(final MultiSet<T> a, final MultiSet<T> b) {
final MultiSet<T> c = new MultiSet<>();
for (final T x : a.keySet()) c.add(x, a.count(x));
for (final T y : b.keySet()) c.add(y, b.count(y));
return c;
}
}
}
/**
* 高速な入出力を提供します。
*
* @author 31536000
*
*/
final class FastIO implements AutoCloseable {
private Input in;
private Output out;
private Output err;
private boolean outFlush = false;
private boolean autoOutFlush = true;
public static final java.io.PrintStream DUMMY_OUT = new DummyOut();
public FastIO() {
this(System.in, System.out, System.err);
}
public FastIO(final java.io.InputStream in, final java.io.PrintStream out, final java.io.PrintStream err) {
this.in = in instanceof Input ? (Input) in : new Input(in);
if (out instanceof Output) {
this.out = (Output) out;
} else {
this.out = new Output(out);
this.out.setAutoFlush(false);
}
if (err instanceof Output) {
this.err = (Output) err;
} else {
this.err = new Output(err);
this.err.setAutoFlush(false);
}
}
public static void setFastStandardOutput(final boolean set) {
final java.io.FileOutputStream fdOut = new java.io.FileOutputStream(java.io.FileDescriptor.out);
final java.io.FileOutputStream fdErr = new java.io.FileOutputStream(java.io.FileDescriptor.err);
if (set) {
System.out.flush();
final Output out = new Output(fdOut);
out.setAutoFlush(false);
System.setOut(out);
System.err.flush();
final Output err = new Output(fdErr);
err.setAutoFlush(false);
System.setErr(err);
} else {
System.out.flush();
final java.io.PrintStream out = new java.io.PrintStream(new java.io.BufferedOutputStream(fdOut, 128), true);
System.setOut(out);
System.err.flush();
final java.io.PrintStream err = new java.io.PrintStream(new java.io.BufferedOutputStream(fdErr, 128), true);
System.setErr(err);
}
}
public void setInputStream(final java.io.InputStream in) {
if (this.in == in) return;
this.in.close();
this.in = in instanceof Input ? (Input) in : new Input(in);
}
public void setInputStream(final java.io.File in) {
try {
this.in.close();
final java.io.InputStream input = new java.io.FileInputStream(in);
this.in = new Input(input);
} catch (final java.io.FileNotFoundException e) {
e.printStackTrace();
}
}
public Input getInputStream() { return in; }
public void setOutputStream(final java.io.OutputStream out) {
if (this.out == out) {
this.out.flush();
}
final boolean flush = this.out.autoFlush;
this.out.close();
if (out instanceof Output) {
this.out = (Output) out;
this.out.setAutoFlush(flush);
} else {
this.out = new Output(out);
this.out.setAutoFlush(flush);
}
}
public void setOutputStream(final java.io.File out) {
try {
setOutputStream(new java.io.FileOutputStream(out));
} catch (final java.io.FileNotFoundException e) {
e.printStackTrace();
}
}
public void setOutputStream(final java.io.FileDescriptor out) {
setOutputStream(new java.io.FileOutputStream(out));
}
public Output getOutputStream() { return out; }
public void setErrorStream(final java.io.OutputStream err) {
if (this.err == err) {
this.err.flush();
}
final boolean flush = this.err.autoFlush;
this.err.close();
if (err instanceof Output) {
this.err = (Output) err;
this.err.setAutoFlush(flush);
} else {
this.err = new Output(err);
this.err.setAutoFlush(flush);
}
}
public void setErrorStream(final java.io.File err) {
try {
setErrorStream(new java.io.FileOutputStream(err));
} catch (final java.io.FileNotFoundException e) {
e.printStackTrace();
}
}
public void setErrorStream(final java.io.FileDescriptor err) {
setErrorStream(new java.io.FileOutputStream(err));
}
public Output getErrorStream() { return err; }
public void setAutoFlush(final boolean flush) {
out.setAutoFlush(flush);
err.setAutoFlush(flush);
}
public void setAutoOutFlush(final boolean flush) { autoOutFlush = flush; }
private void autoFlush() {
if (outFlush) {
outFlush = false;
flush();
}
}
public boolean hasNext() {
autoFlush();
return in.hasNext();
}
public boolean nextBoolean() {
autoFlush();
return in.nextBoolean();
}
public boolean[] nextBoolean(final char T) {
final char[] s = nextChars();
final boolean[] ret = new boolean[s.length];
for (int i = 0; i < ret.length; ++i) ret[i] = s[i] == T;
return ret;
}
public boolean[][] nextBoolean(final char T, final int height) {
final boolean[][] ret = new boolean[height][];
for (int i = 0; i < ret.length; ++i) {
final char[] s = nextChars();
ret[i] = new boolean[s.length];
for (int j = 0; j < ret[i].length; ++j) ret[i][j] = s[j] == T;
}
return ret;
}
public byte nextByte() {
autoFlush();
return in.nextByte();
}
public short nextShort() {
autoFlush();
return in.nextShort();
}
public short[] nextShort(final int width) {
final short[] ret = new short[width];
for (int i = 0; i < width; ++i) ret[i] = nextShort();
return ret;
}
public short[][] nextShort(final int width, final int height) {
final short[][] ret = new short[height][width];
for (int i = 0, j; i < height; ++i) for (j = 0; j < width; ++j) ret[i][j] = nextShort();
return ret;
}
public int nextInt() {
autoFlush();
return in.nextInt();
}
public int[] nextInt(final int width) {
final int[] ret = new int[width];
for (int i = 0; i < width; ++i) ret[i] = nextInt();
return ret;
}
public int[][] nextInt(final int width, final int height) {
final int[][] ret = new int[height][width];
for (int i = 0, j; i < height; ++i) for (j = 0; j < width; ++j) ret[i][j] = nextInt();
return ret;
}
public int[] nextInts() {
return nextInts(" ");
}
public int[] nextInts(final String parse) {
final String[] get = nextLine().split(parse);
final int[] ret = new int[get.length];
for (int i = 0; i < ret.length; ++i) ret[i] = Integer.valueOf(get[i]);
return ret;
}
public long nextLong() {
autoFlush();
return in.nextLong();
}
public long[] nextLong(final int width) {
final long[] ret = new long[width];
for (int i = 0; i < width; ++i) ret[i] = nextLong();
return ret;
}
public long[][] nextLong(final int width, final int height) {
final long[][] ret = new long[height][width];
for (int i = 0, j; i < height; ++i) for (j = 0; j < width; ++j) ret[j][i] = nextLong();
return ret;
}
public long[] nextLongs() {
return nextLongs(" ");
}
public long[] nextLongs(final String parse) {
final String[] get = nextLine().split(parse);
final long[] ret = new long[get.length];
for (int i = 0; i < ret.length; ++i) ret[i] = Long.valueOf(get[i]);
return ret;
}
public float nextFloat() {
autoFlush();
return in.nextFloat();
}
public double nextDouble() {
autoFlush();
return in.nextDouble();
}
public char nextChar() {
autoFlush();
return in.nextChar();
}
public char[] nextChars() {
return next().toCharArray();
}
public char[] nextChars(final char around) {
return (around + next() + around).toCharArray();
}
public char[][] nextChars(final int height) {
final char[][] ret = new char[height][];
for (int i = 0; i < ret.length; ++i) ret[i] = nextChars();
return ret;
}
public char[][] nextChars(final int height, final char around) {
final char[][] ret = new char[height + 2][];
for (int i = 1; i <= height; ++i) ret[i] = nextChars(around);
java.util.Arrays.fill(ret[0] = new char[ret[1].length], around);
java.util.Arrays.fill(ret[ret.length - 1] = new char[ret[0].length], around);
return ret;
}
public String next() {
autoFlush();
return in.next();
}
public String nextLine() {
autoFlush();
return in.nextLine();
}
public Point nextPoint() {
return new Point(nextInt(), nextInt());
}
public Point[] nextPoint(final int width) {
final Point[] ret = new Point[width];
for (int i = 0; i < width; ++i) ret[i] = nextPoint();
return ret;
}
public boolean print(final boolean b) {
out.print(b);
outFlush = autoOutFlush;
return b;
}
public byte print(final byte b) {
out.print(b);
outFlush = autoOutFlush;
return b;
}
public short print(final short s) {
out.print(s);
outFlush = autoOutFlush;
return s;
}
public int print(final int i) {
out.print(i);
outFlush = autoOutFlush;
return i;
}
public long print(final long l) {
out.print(l);
outFlush = autoOutFlush;
return l;
}
public float print(final float f) {
out.print(f);
outFlush = autoOutFlush;
return f;
}
public double print(final double d) {
out.print(d);
outFlush = autoOutFlush;
return d;
}
public double print(final double d, final int length) {
out.print(d, length);
outFlush = autoOutFlush;
return d;
}
public char print(final char c) {
out.print(c);
outFlush = autoOutFlush;
return c;
}
public char[] print(final char[] s) {
out.print(s);
outFlush = autoOutFlush;
return s;
}
public String print(final String s) {
out.print(s);
outFlush = autoOutFlush;
return s;
}
public Object print(final Object obj) {
if (obj != null && obj.getClass().isArray()) {
if (obj instanceof boolean[][]) print(obj, "\n", " ");
else if (obj instanceof byte[][]) print(obj, "\n", " ");
else if (obj instanceof short[][]) print(obj, "\n", " ");
else if (obj instanceof int[][]) print(obj, "\n", " ");
else if (obj instanceof long[][]) print(obj, "\n", " ");
else if (obj instanceof float[][]) print(obj, "\n", " ");
else if (obj instanceof double[][]) print(obj, "\n", " ");
else if (obj instanceof char[][]) print(obj, "\n", " ");
else if (obj instanceof Object[][]) print(obj, "\n", " ");
else print(obj, " ");
} else {
out.print(obj);
outFlush = autoOutFlush;
}
return obj;
}
public Object print(final Object array, final String... parse) {
print(array, 0, parse);
return array;
}
private Object print(final Object array, final int check, final String... parse) {
if (check >= parse.length) {
if (array != null && array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
print(array);
return array;
}
final String str = parse[check];
if (array instanceof Object[]) {
final Object[] obj = (Object[]) array;
if (obj.length == 0) return array;
print(obj[0], check + 1, parse);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i], check + 1, parse);
}
return array;
}
if (array instanceof java.util.Collection) {
final java.util.Iterator<?> iter = ((java.util.Collection<?>) array).iterator();
if (!iter.hasNext()) return array;
print(iter.next(), check + 1, parse);
while (iter.hasNext()) {
print(str);
print(iter.next(), check + 1, parse);
}
return array;
}
if (!array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
if (check != parse.length - 1) throw new IllegalArgumentException("not equal dimension");
if (array instanceof boolean[]) {
final boolean[] obj = (boolean[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof byte[]) {
final byte[] obj = (byte[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
return array;
} else if (array instanceof short[]) {
final short[] obj = (short[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof int[]) {
final int[] obj = (int[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof long[]) {
final long[] obj = (long[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof float[]) {
final float[] obj = (float[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof double[]) {
final double[] obj = (double[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof char[]) {
final char[] obj = (char[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else throw new AssertionError();
return array;
}
public Object[] print(final String parse, final Object... args) {
print(args[0]);
for (int i = 1; i < args.length; ++i) {
print(parse);
print(args[i]);
}
return args;
}
public Object[] printf(final String format, final Object... args) {
out.printf(format, args);
outFlush = autoOutFlush;
return args;
}
public Object[] printf(final java.util.Locale l, final String format, final Object... args) {
out.printf(l, format, args);
outFlush = autoOutFlush;
return args;
}
public void println() {
out.println();
outFlush = autoOutFlush;
}
public boolean println(final boolean b) {
out.println(b);
outFlush = autoOutFlush;
return b;
}
public byte println(final byte b) {
out.println(b);
outFlush = autoOutFlush;
return b;
}
public short println(final short s) {
out.println(s);
outFlush = autoOutFlush;
return s;
}
public int println(final int i) {
out.println(i);
outFlush = autoOutFlush;
return i;
}
public long println(final long l) {
out.println(l);
outFlush = autoOutFlush;
return l;
}
public float println(final float f) {
out.println(f);
outFlush = autoOutFlush;
return f;
}
public double println(final double d) {
out.println(d);
outFlush = autoOutFlush;
return d;
}
public double println(final double d, final int length) {
out.println(d, length);
outFlush = autoOutFlush;
return d;
}
public char println(final char c) {
out.println(c);
outFlush = autoOutFlush;
return c;
}
public char[] println(final char[] s) {
out.println(s);
outFlush = autoOutFlush;
return s;
}
public String println(final String s) {
out.println(s);
return s;
}
public Object println(final Object obj) {
print(obj);
println();
return obj;
}
public Object println(final Object array, final String... parse) {
print(array, parse);
println();
return array;
}
public boolean debug(final boolean b) {
err.print(b);
outFlush = autoOutFlush;
return b;
}
public byte debug(final byte b) {
err.print(b);
outFlush = autoOutFlush;
return b;
}
public short debug(final short s) {
err.print(s);
outFlush = autoOutFlush;
return s;
}
public int debug(final int i) {
err.print(i);
outFlush = autoOutFlush;
return i;
}
public long debug(final long l) {
err.print(l);
outFlush = autoOutFlush;
return l;
}
public float debug(final float f) {
err.print(f);
outFlush = autoOutFlush;
return f;
}
public double debug(final double d) {
err.print(d);
outFlush = autoOutFlush;
return d;
}
public double debug(final double d, final int length) {
err.print(d, length);
outFlush = autoOutFlush;
return d;
}
public char debug(final char c) {
err.print(c);
outFlush = autoOutFlush;
return c;
}
public char[] debug(final char[] s) {
err.print(s);
outFlush = autoOutFlush;
return s;
}
public String debug(final String s) {
err.print(s);
outFlush = autoOutFlush;
return s;
}
public Object debug(final Object obj) {
if (obj != null && obj.getClass().isArray()) {
if (obj instanceof boolean[][]) debug(obj, "\n", " ");
else if (obj instanceof byte[][]) debug(obj, "\n", " ");
else if (obj instanceof short[][]) debug(obj, "\n", " ");
else if (obj instanceof int[][]) debug(obj, "\n", " ");
else if (obj instanceof long[][]) debug(obj, "\n", " ");
else if (obj instanceof float[][]) debug(obj, "\n", " ");
else if (obj instanceof double[][]) debug(obj, "\n", " ");
else if (obj instanceof char[][]) debug(obj, "\n", " ");
else if (obj instanceof Object[][]) debug(obj, "\n", " ");
else debug(obj, " ");
} else {
err.print(obj);
outFlush = autoOutFlush;
}
return obj;
}
public Object debug(final Object array, final String... parse) {
debug(array, 0, parse);
return array;
}
private Object debug(final Object array, final int check, final String... parse) {
if (check >= parse.length) {
if (array != null && array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
debug(array);
return array;
}
final String str = parse[check];
if (array instanceof Object[]) {
final Object[] obj = (Object[]) array;
if (obj.length == 0) return array;
debug(obj[0], check + 1, parse);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i], check + 1, parse);
}
return array;
}
if (array instanceof java.util.Collection) {
final java.util.Iterator<?> iter = ((java.util.Collection<?>) array).iterator();
if (!iter.hasNext()) return array;
debug(iter.next(), check + 1, parse);
while (iter.hasNext()) {
debug(str);
debug(iter.next(), check + 1, parse);
}
return array;
}
if (!array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
if (check != parse.length - 1) throw new IllegalArgumentException("not equal dimension");
if (array instanceof boolean[]) {
final boolean[] obj = (boolean[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof byte[]) {
final byte[] obj = (byte[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
return array;
} else if (array instanceof short[]) {
final short[] obj = (short[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof int[]) {
final int[] obj = (int[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof long[]) {
final long[] obj = (long[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof float[]) {
final float[] obj = (float[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof double[]) {
final double[] obj = (double[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof char[]) {
final char[] obj = (char[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else throw new AssertionError();
return array;
}
public Object[] debug(final String parse, final Object... args) {
debug(args[0]);
for (int i = 1; i < args.length; ++i) {
debug(parse);
debug(args[i]);
}
return args;
}
public Object[] debugf(final String format, final Object... args) {
err.printf(format, args);
outFlush = autoOutFlush;
return args;
}
public Object[] debugf(final java.util.Locale l, final String format, final Object... args) {
err.printf(l, format, args);
outFlush = autoOutFlush;
return args;
}
public void debugln() {
err.println();
outFlush = autoOutFlush;
}
public boolean debugln(final boolean b) {
err.println(b);
outFlush = autoOutFlush;
return b;
}
public byte debugln(final byte b) {
err.println(b);
outFlush = autoOutFlush;
return b;
}
public short debugln(final short s) {
err.println(s);
outFlush = autoOutFlush;
return s;
}
public int debugln(final int i) {
err.println(i);
outFlush = autoOutFlush;
return i;
}
public long debugln(final long l) {
err.println(l);
outFlush = autoOutFlush;
return l;
}
public float debugln(final float f) {
err.println(f);
outFlush = autoOutFlush;
return f;
}
public double debugln(final double d) {
err.println(d);
outFlush = autoOutFlush;
return d;
}
public double debugln(final double d, final int length) {
err.println(d, length);
outFlush = autoOutFlush;
return d;
}
public char debugln(final char c) {
err.println(c);
outFlush = autoOutFlush;
return c;
}
public char[] debugln(final char[] s) {
err.println(s);
outFlush = autoOutFlush;
return s;
}
public String debugln(final String s) {
err.println(s);
outFlush = autoOutFlush;
return s;
}
public Object debugln(final Object obj) {
debug(obj);
debugln();
return obj;
}
public Object debugln(final Object array, final String... parse) {
debug(array, parse);
debugln();
return array;
}
public void flush() {
out.flush();
err.flush();
outFlush = false;
}
@Override
public void close() {
out.close();
err.close();
}
public static final class Input extends java.io.InputStream {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1 << 13];
private int read = 0;
private int length = 0;
public Input(final java.io.InputStream in) {
this.in = in;
}
@Override
public int available() {
try {
return in.available();
} catch (final java.io.IOException e) {
e.printStackTrace();
}
return 0;
}
@Override
public void close() {
try {
in.close();
read = length = 0;
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
@Override
public int read() {
if (hasNextByte()) return nextByte();
return 0;
}
private boolean hasNextByte() {
if (read < length) return true;
read = 0;
try {
length = in.read(buffer);
} catch (final java.io.IOException e) {
e.printStackTrace();
}
return length > 0;
}
private static boolean isPrintableChar(final byte c) {
return 32 < c || c < 0;
}
private static boolean isNumber(final byte c) {
return '0' <= c && c <= '9';
}
private boolean readNewLine() {
if (hasNextByte()) {
if (buffer[read] == '\r') {
++read;
if (hasNextByte() && buffer[read] == '\n') ++read;
return true;
}
if (buffer[read] == '\n') {
++read;
return true;
}
}
return false;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[read])) read++;
return hasNextByte();
}
private byte nextTokenByte() {
while (hasNextByte() && !isPrintableChar(buffer[read])) read++;
return buffer[read++];
}
public boolean nextBoolean() {
return Boolean.valueOf(next());
}
public byte nextByte() {
if (hasNextByte()) return buffer[read++];
throw new java.util.NoSuchElementException();
}
public short nextShort() {
byte b = nextTokenByte();
short n = 0;
try {
if (b == '-') {
while (isNumber(b = nextByte())) n = (short) (n * 10 + '0' - b);
return n;
} else if (!isNumber(b)) throw new NumberFormatException();
do n = (short) (n * 10 + b - '0'); while (isNumber(b = nextByte()));
return n;
} catch (final java.util.NoSuchElementException e) {
return n;
}
}
public int nextInt() {
byte b = nextTokenByte();
int n = 0;
try {
if (b == '-') {
while (isNumber(b = nextByte())) n = n * 10 + '0' - b;
return n;
} else if (!isNumber(b)) throw new NumberFormatException();
do n = n * 10 + b - '0'; while (isNumber(b = nextByte()));
return n;
} catch (final java.util.NoSuchElementException e) {
return n;
}
}
public long nextLong() {
byte b = nextTokenByte();
long n = 0;
try {
if (b == '-') {
while (isNumber(b = nextByte())) n = n * 10 + '0' - b;
return n;
} else if (!isNumber(b)) throw new NumberFormatException();
do n = n * 10 + b - '0'; while (isNumber(b = nextByte()));
return n;
} catch (final java.util.NoSuchElementException e) {
return n;
}
}
public float nextFloat() {
return Float.parseFloat(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
final byte b = nextByte();
if ((b & 0x80) == 0) return (char) b;
if ((b & 0x20) == 0) return (char) ((b & 0x1F) << 6 | nextByte() & 0x3F);
return (char) ((b & 0xF) << 12 | (nextByte() & 0x3F) << 6 | nextByte() & 0x3F);
}
public String next() {
if (!hasNext()) throw new java.util.NoSuchElementException();
final StringBuilder sb = new StringBuilder();
do sb.append(nextChar()); while (hasNextByte() && isPrintableChar(buffer[read]));
return sb.toString();
}
public String nextLine() {
final StringBuilder sb = new StringBuilder();
while (!readNewLine()) sb.append(nextChar());
return sb.toString();
}
}
public static final class Output extends java.io.PrintStream {
private final byte[] buffer = new byte[1 << 13];
private int read = 0;
private boolean autoFlush = true;
public Output(final java.io.OutputStream out) {
super(out);
}
public void setAutoFlush(final boolean autoFlush) { this.autoFlush = autoFlush; }
@Override
public void close() {
if (out == System.out || out == System.err || this == System.out || this == System.err) {
flush();
return;
}
try {
flush();
out.close();
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
@Override
public void flush() {
try {
write();
out.flush();
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
@Override
public void write(final byte[] b) {
if (b.length < buffer.length) {
ensureBuffer(b.length);
System.arraycopy(b, 0, buffer, read, b.length);
read += b.length;
} else {
write();
try {
out.write(b);
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
}
@Override
public void write(final byte[] b, final int off, final int len) {
if (len < buffer.length) {
ensureBuffer(len);
System.arraycopy(b, off, buffer, read, len);
read += len;
} else {
write();
try {
out.write(b, off, len);
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
}
@Override
public void write(final int b) {
print((byte) b);
}
private void write() {
try {
out.write(buffer, 0, read);
read = 0;
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
private void ensureBuffer(final int size) {
if (read + size > buffer.length) {
write();
}
}
@Override
public void print(final boolean b) {
if (b) {
ensureBuffer(4);
buffer[read++] = 't';
buffer[read++] = 'r';
buffer[read++] = 'u';
buffer[read++] = 'e';
} else {
ensureBuffer(5);
buffer[read++] = 'f';
buffer[read++] = 'a';
buffer[read++] = 'l';
buffer[read++] = 's';
buffer[read++] = 'e';
}
}
public void print(final byte b) {
ensureBuffer(1);
buffer[read++] = b;
}
private static int digit(final short s) {
return s >= 100 ? s >= 1000 ? s >= 10000 ? 5 : 4 : 3 : s >= 10 ? 2 : 1;
}
public void print(short s) {
ensureBuffer(6);
if (s < 0) {
if (s == -32768) {
buffer[read++] = '-';
buffer[read++] = '3';
buffer[read++] = '2';
buffer[read++] = '7';
buffer[read++] = '6';
buffer[read++] = '8';
return;
}
buffer[read++] = '-';
s = (short) -s;
}
final int digit = digit(s);
int i = read + digit;
while (i-- > read) {
buffer[i] = (byte) (s % 10 + '0');
s /= 10;
}
read += digit;
}
private static int digit(final int i) {
if (i >= 1000000000) return 10;
if (i >= 100000000) return 9;
if (i >= 10000000) return 8;
if (i >= 1000000) return 7;
if (i >= 100000) return 6;
if (i >= 10000) return 5;
if (i >= 1000) return 4;
if (i >= 100) return 3;
if (i >= 10) return 2;
return 1;
}
@Override
public void print(int i) {
ensureBuffer(11);
if (i < 0) {
if (i == -2147483648) {
buffer[read++] = '-';
buffer[read++] = '2';
buffer[read++] = '1';
buffer[read++] = '4';
buffer[read++] = '7';
buffer[read++] = '4';
buffer[read++] = '8';
buffer[read++] = '3';
buffer[read++] = '6';
buffer[read++] = '4';
buffer[read++] = '8';
return;
}
buffer[read++] = '-';
i = -i;
}
final int digit = digit(i);
int j = read + digit;
while (j-- > read) {
buffer[j] = (byte) (i % 10 + '0');
i /= 10;
}
read += digit;
}
private static int digit(final long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
@Override
public void print(long l) {
ensureBuffer(20);
if (l < 0) {
if (l == -9223372036854775808L) {
buffer[read++] = '-';
buffer[read++] = '9';
buffer[read++] = '2';
buffer[read++] = '2';
buffer[read++] = '3';
buffer[read++] = '3';
buffer[read++] = '7';
buffer[read++] = '2';
buffer[read++] = '0';
buffer[read++] = '3';
buffer[read++] = '6';
buffer[read++] = '8';
buffer[read++] = '5';
buffer[read++] = '4';
buffer[read++] = '7';
buffer[read++] = '7';
buffer[read++] = '5';
buffer[read++] = '8';
buffer[read++] = '0';
buffer[read++] = '8';
return;
}
buffer[read++] = '-';
l = -l;
}
final int digit = digit(l);
int i = read + digit;
while (i-- > read) {
buffer[i] = (byte) (l % 10 + '0');
l /= 10;
}
read += digit;
}
@Override
public void print(final float f) {
print(Float.toString(f));
}
@Override
public void print(final double d) {
print(Double.toString(d));
}
public void print(double d, final int n) {
if (d < 0) {
ensureBuffer(1);
buffer[read++] = '-';
d = -d;
}
d += Math.pow(10, -n) / 2;
final long l = (long) d;
print(l);
ensureBuffer(n + 1);
buffer[read++] = '.';
d -= l;
for (int i = 0; i < n; i++) {
d *= 10;
final int in = (int) d;
buffer[read++] = (byte) (in + '0');
d -= in;
}
}
@Override
public void print(final char c) {
if (c < 0x80) {
ensureBuffer(1);
buffer[read++] = (byte) c;
} else if (c < 0x07FF) {
ensureBuffer(2);
buffer[read++] = (byte) (c >> 6 & 0x3F | 0x80);
buffer[read++] = (byte) (c & 0x3F | 0x80);
} else {
ensureBuffer(3);
buffer[read++] = (byte) (c >> 12 & 0xF | 0xE0);
buffer[read++] = (byte) (c >> 6 & 0x3F | 0x80);
buffer[read++] = (byte) (c & 0x3F | 0x80);
}
}
@Override
public void print(final char[] s) {
for (final char i : s) print(i);
}
@Override
public void print(final String s) {
print(s.toCharArray());
}
@Override
public void print(final Object o) {
print(o.toString());
}
@Override
public Output printf(final java.util.Locale l, final String format, final Object... args) {
print(String.format(l, format, args));
return this;
}
@Override
public Output printf(final String format, final Object... args) {
print(String.format(format, args));
return this;
}
@Override
public void println() {
ensureBuffer(1);
buffer[read++] = '\n';
if (autoFlush) flush();
}
@Override
public void println(final boolean b) {
print(b);
println();
}
public void println(final byte b) {
print(b);
println();
}
public void println(final short s) {
print(s);
println();
}
@Override
public void println(final int i) {
print(i);
println();
}
@Override
public void println(final long l) {
print(l);
println();
}
@Override
public void println(final float f) {
print(f);
println();
}
@Override
public void println(final double d) {
print(d);
println();
}
public void println(final double d, final int n) {
print(d, n);
println();
}
@Override
public void println(final char c) {
print(c);
println();
}
@Override
public void println(final char[] s) {
print(s);
println();
}
@Override
public void println(final String s) {
print(s);
println();
}
@Override
public void println(final Object o) {
print(o);
println();
}
@Override
public Output append(final char c) {
print(c);
return this;
}
@Override
public Output append(CharSequence csq) {
if (csq == null) csq = "null";
print(csq.toString());
return this;
}
@Override
public Output append(CharSequence csq, final int start, final int end) {
if (csq == null) csq = "null";
print(csq.subSequence(start, end).toString());
return this;
}
}
public static final class DummyOut extends java.io.PrintStream {
public DummyOut() {
super(new Dummy());
}
private static class Dummy extends java.io.OutputStream {
@Override
public void close() {
}
@Override
public void flush() {
}
@Override
public void write(final byte[] b) {
}
@Override
public void write(final byte[] b, final int off, final int len) {
}
@Override
public void write(final int b) {
}
}
}
}
import java.awt.Point;
import java.io.Serializable;
import java.math.BigInteger;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.RandomAccess;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;
public class Main implements Runnable {
private void solve(final FastIO io, final String[] args) {
io.setAutoFlush(false);
io.setAutoOutFlush(false);
/*
* author: 31536000
* AtCoder Beginner Contest 357 F問題
* 考察メモ
* 明らかに遅延セグ木に乗せると書いてあるのでそれをやるとして
* ΣABの寄与について考える
* xをAに加えた時、答えにはxΣB追加される
* 逆も同様
* ということは、(ΣA, ΣB, ΣAB, len)を持てば足りるかな
*
* 多項式で持ってると思えば、まぁいつもので
* 和と積なので近半環になることも明らか、じゃ乗るね
*/
int N = io.nextInt(), Q = io.nextInt();
int[] A = io.nextInt(N), B = io.nextInt(N);
final ModUtility mod = new ModUtility(new Prime(998_244_353), 1_000_000);
class Query {
int ax, bx;
Query(int ax, int bx) {
this.ax = ax;
this.bx = bx;
}
Query(Query l, Query r) {
ax = mod.add(l.ax, r.ax);
bx = mod.add(l.bx, r.bx);
}
}
class Data {
int sumA, sumB, sumAB, len;
Data(int i) {
sumA = A[i];
sumB = B[i];
sumAB = mod.multiply(sumA, sumB);
len = 1;
}
Data(Data l, Data r) {
sumA = mod.add(l.sumA, r.sumA);
sumB = mod.add(l.sumB, r.sumB);
sumAB = mod.add(l.sumAB, r.sumAB);
len = l.len + r.len;
}
Data(Query x, Data d) {
sumA = mod.add(d.sumA, mod.multiply(x.ax, d.len));
sumB = mod.add(d.sumB, mod.multiply(x.bx, d.len));
sumAB = mod.add(d.sumAB, mod.add(mod.multiply(mod.multiply(x.ax, x.bx), d.len), mod.add(mod.multiply(x.ax, d.sumB), mod.multiply(x.bx, d.sumA))));
len = d.len;
}
Data() {
sumA = sumB = sumAB = len = 0;
}
@Override
public String toString() {
return "(" + sumA + ", " + sumB + ", " + sumAB + ", " + len + ")";
}
}
ACL.LazySegTree<Data, Query> segTree = new ACL.LazySegTree<>(N, Data::new, new Data(), Data::new, Query::new, new Query(0, 0));
for (int i = 0;i < N;++ i) segTree.set(i, new Data(i));
while(Q --> 0) {
int query = io.nextInt(), l = io.nextInt() - 1, r = io.nextInt();
if (query == 1) {
Query q = new Query(io.nextInt(), 0);
segTree.apply(l, r, q);
} else if (query == 2) {
Query q = new Query(0, io.nextInt());
segTree.apply(l, r, q);
} else {
io.println(segTree.prod(l, r).sumAB);
}
}
}
/** デバッグ用コードのお供に */
private static boolean DEBUG = false;
/** 確保するメモリの大きさ(単位: MB) */
private static final long MEMORY = 64;
private final FastIO io;
private final String[] args;
public static void main(final String[] args) {
Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
e.printStackTrace();
System.exit(1);
});
FastIO.setFastStandardOutput(true);
new Thread(null, new Main(args), "", MEMORY * 1048576L).start();
}
public Main(final String[] args) {
this(new FastIO(), args);
}
public Main(final FastIO io, final String... args) {
this.io = io;
this.args = args;
if (DEBUG) io.setAutoFlush(true);
}
@Override
public void run() {
try {
solve(io, args);
} catch (final Throwable e) {
throw e;
} finally {
io.close();
FastIO.setFastStandardOutput(false);
}
}
// 以下、ライブラリ
/**
* 指数表記の値を整数で返します。
*
* @param n 仮数部
* @param e 指数部
* @return n * 10^e
*/
public static int exponent10(final int n, final int e) {
return n * pow(10, e);
}
/**
* 指数表記の値を整数で返します。
*
* @param n 仮数部
* @param e 指数部
* @return n * 10^e
*/
public static long exponent10L(final int n, final int e) {
return n * pow(10L, e);
}
/**
* aのb乗を返します。
*
* @param a 整数
* @param b 整数
* @return aのb乗
*/
public static int pow(final int a, int b) {
int ans = 1;
for (int mul = a; b > 0; b >>= 1, mul *= mul) if ((b & 1) != 0) ans *= mul;
return ans;
}
/**
* aのb乗をmodを法として計算したものを返します。
*
* @param a 整数
* @param b 整数
* @param mod 法
* @return aのb乗をmodを法として計算したもの
*/
public static int pow(int a, int b, final int mod) {
a %= mod;
if (a < 0) a += mod;
if (b < 0) {
b %= mod - 1;
b += mod - 1;
}
long ans = 1;
for (long mul = a; b > 0; b >>= 1, mul = mul * mul % mod) if ((b & 1) != 0) ans = ans * mul % mod;
return (int) ans;
}
/**
* aのb乗を返します。
*
* @param a 整数
* @param b 整数
* @return aのb乗
*/
public static long pow(final long a, long b) {
long ans = 1;
for (long mul = a; b > 0; b >>= 1, mul *= mul) if ((b & 1) != 0) ans *= mul;
return ans;
}
/**
* aのb乗をmodを法として計算したものを返します。
*
* @param a 整数
* @param b 整数
* @param mod 法
* @return aのb乗をmodを法として計算したもの
*/
public static int pow(long a, long b, final int mod) {
a %= mod;
if (a < 0) a += mod;
if (b < 0) {
b %= mod - 1;
b += mod - 1;
}
long ans = 1;
for (long mul = a; b > 0; b >>= 1, mul = mul * mul % mod) if ((b & 1) != 0) ans = ans * mul % mod;
return (int) ans;
}
public enum BoundType {
CLOSED, OPEN;
}
public static class Range<C> implements Serializable {
private static final long serialVersionUID = -4702828934863023392L;
protected C lower;
protected C upper;
protected BoundType lowerType;
protected BoundType upperType;
private Comparator<? super C> comparator;
protected Range(final C lower, final BoundType lowerType, final C upper, final BoundType upperType) {
this(lower, lowerType, upper, upperType, null);
}
protected Range(final C lower, final BoundType lowerType, final C upper, final BoundType upperType,
final Comparator<? super C> comparator) {
this.lower = lower;
this.upper = upper;
this.lowerType = lowerType;
this.upperType = upperType;
this.comparator = comparator;
}
public static <C extends Comparable<? super C>> Range<C> range(final C lower, final BoundType lowerType,
final C upper, final BoundType upperType) {
if (lower != null && upper != null) {
final int comp = lower.compareTo(upper);
if (comp > 0) return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED);
else if (comp == 0 && (lowerType == BoundType.OPEN || upperType == BoundType.OPEN))
return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED);
}
return new Range<>(lower, lowerType, upper, upperType);
}
public static <C> Range<C> range(final C lower, final BoundType lowerType, final C upper,
final BoundType upperType, final Comparator<? super C> comparator) {
if (lower != null && upper != null) {
final int comp = comparator.compare(lower, upper);
if (comp > 0) return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED, comparator);
else if (comp == 0 && (lowerType == BoundType.OPEN || upperType == BoundType.OPEN))
return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED, comparator);
}
return new Range<>(lower, lowerType, upper, upperType, comparator);
}
public static <C extends Comparable<? super C>> Range<C> all() {
return range((C) null, BoundType.OPEN, null, BoundType.OPEN);
}
public static <C> Range<C> all(final Comparator<? super C> comparator) {
return range((C) null, BoundType.OPEN, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> atMost(final C upper) {
return range(null, BoundType.OPEN, upper, BoundType.CLOSED);
}
public static <C> Range<C> atMost(final C upper, final Comparator<? super C> comparator) {
return range(null, BoundType.OPEN, upper, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> lessThan(final C upper) {
return range(null, BoundType.OPEN, upper, BoundType.OPEN);
}
public static <C> Range<C> lessThan(final C upper, final Comparator<? super C> comparator) {
return range(null, BoundType.OPEN, upper, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> downTo(final C upper, final BoundType boundType) {
return range(null, BoundType.OPEN, upper, boundType);
}
public static <C> Range<C> downTo(final C upper, final BoundType boundType,
final Comparator<? super C> comparator) {
return range(null, BoundType.OPEN, upper, boundType, comparator);
}
public static <C extends Comparable<? super C>> Range<C> atLeast(final C lower) {
return range(lower, BoundType.CLOSED, null, BoundType.OPEN);
}
public static <C> Range<C> atLeast(final C lower, final Comparator<? super C> comparator) {
return range(lower, BoundType.CLOSED, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> greaterThan(final C lower) {
return range(lower, BoundType.OPEN, null, BoundType.OPEN);
}
public static <C> Range<C> greaterThan(final C lower, final Comparator<? super C> comparator) {
return range(lower, BoundType.OPEN, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> upTo(final C lower, final BoundType boundType) {
return range(lower, boundType, null, BoundType.OPEN);
}
public static <C> Range<C> upTo(final C lower, final BoundType boundType,
final Comparator<? super C> comparator) {
return range(lower, boundType, null, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> open(final C lower, final C upper) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN);
}
public static <C> Range<C> open(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> openClosed(final C lower, final C upper) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED);
}
public static <C> Range<C> openClosed(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> closedOpen(final C lower, final C upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN);
}
public static <C> Range<C> closedOpen(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN, comparator);
}
public static <C extends Comparable<? super C>> Range<C> closed(final C lower, final C upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static <C> Range<C> closed(final C lower, final C upper, final Comparator<? super C> comparator) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> singleton(final C value) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED);
}
public static <C> Range<C> singleton(final C value, final Comparator<? super C> comparator) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> empty() {
return range((C) null, BoundType.CLOSED, null, BoundType.CLOSED);
}
public static <C> Range<C> empty(final Comparator<? super C> comparator) {
return range((C) null, BoundType.CLOSED, null, BoundType.CLOSED, comparator);
}
public static <C extends Comparable<? super C>> Range<C> encloseAll(final Iterable<C> values) {
C lower = values.iterator().next();
C upper = lower;
for (final C i : values) {
if (lower.compareTo(i) > 0) lower = i;
if (upper.compareTo(i) < 0) upper = i;
}
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static <C> Range<C> encloseAll(final Iterable<C> values, final Comparator<? super C> comparator) {
C lower = values.iterator().next();
C upper = lower;
for (final C i : values) {
if (comparator.compare(lower, i) > 0) lower = i;
if (comparator.compare(upper, i) < 0) upper = i;
}
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, comparator);
}
protected int compareLower(final C value) {
return compareLower(value, BoundType.CLOSED);
}
protected int compareLower(final C value, final BoundType boundType) {
return compareLower(lower, lowerType, value, boundType);
}
protected int compareLower(final C lower, final BoundType lowerType, final C value) {
return compareLower(lower, lowerType, value, BoundType.CLOSED);
}
protected int compareLower(final C lower, final BoundType lowerType, final C value, final BoundType boundType) {
if (lower == null) return value == null ? 0 : -1;
else if (value == null) return 1;
int compare;
if (comparator == null) {
@SuppressWarnings("unchecked")
final Comparable<C> comp = (Comparable<C>) lower;
compare = comp.compareTo(value);
} else compare = comparator.compare(lower, value);
if (compare == 0) {
if (lowerType == BoundType.CLOSED) --compare;
if (boundType == BoundType.CLOSED) ++compare;
}
return compare;
}
protected int compareUpper(final C value) {
return compareUpper(value, BoundType.CLOSED);
}
protected int compareUpper(final C value, final BoundType boundType) {
return compareUpper(upper, upperType, value, boundType);
}
protected int compareUpper(final C upper, final BoundType upperType, final C value) {
return compareUpper(upper, upperType, value, BoundType.CLOSED);
}
protected int compareUpper(final C upper, final BoundType upperType, final C value, final BoundType boundType) {
if (upper == null) return value == null ? 0 : 1;
if (value == null) return -1;
int compare;
if (comparator == null) {
@SuppressWarnings("unchecked")
final Comparable<C> comp = (Comparable<C>) upper;
compare = comp.compareTo(value);
} else compare = comparator.compare(upper, value);
if (compare == 0) {
if (upperType == BoundType.CLOSED) ++compare;
if (boundType == BoundType.CLOSED) --compare;
}
return compare;
}
public boolean hasLowerBound() {
return lower != null;
}
public C lowerEndpoint() {
if (hasLowerBound()) return lower;
throw new IllegalStateException();
}
public BoundType lowerBoundType() {
if (hasLowerBound()) return lowerType;
throw new IllegalStateException();
}
public boolean hasUpperBound() {
return upper != null;
}
public C upperEndpoint() {
if (hasUpperBound()) return upper;
throw new IllegalStateException();
}
public BoundType upperBoundType() {
if (hasUpperBound()) return upperType;
throw new IllegalStateException();
}
/**
* この区間が空集合か判定します。
*
* @return 空集合ならばtrue
*/
public boolean isEmpty() { return lower == null && upper == null && lowerType == BoundType.CLOSED; }
/**
* 与えられた引数が区間の左側に位置するか判定します。<br>
* 接する場合は区間の左側ではないと判定します。
*
* @param value 調べる引数
* @return 区間の左側に位置するならtrue
*/
public boolean isLess(final C value) {
return isLess(value, BoundType.CLOSED);
}
protected boolean isLess(final C value, final BoundType boundType) {
return compareLower(value, boundType) > 0;
}
/**
* 与えられた引数が区間の右側に位置するか判定します。<br>
* 接する場合は区間の右側ではないと判定します。
*
* @param value 調べる引数
* @return 区間の右側に位置するならtrue
*/
public boolean isGreater(final C value) {
return isGreater(value, BoundType.CLOSED);
}
private boolean isGreater(final C value, final BoundType boundType) {
return compareUpper(value, boundType) < 0;
}
/**
* 与えられた引数が区間内に位置するか判定します。<br>
* 接する場合も区間内に位置すると判定します。
*
* @param value 調べる引数
* @return 区間内に位置するならtrue
*/
public boolean contains(final C value) {
return !isLess(value) && !isGreater(value) && !isEmpty();
}
/**
* 与えられた引数すべてが区間内に位置するか判定します。<br>
* 接する場合も区間内に位置すると判定します。
*
* @param value 調べる要素
* @return 全ての要素が区間内に位置するならtrue
*/
public boolean containsAll(final Iterable<? extends C> values) {
for (final C i : values) if (!contains(i)) return false;
return true;
}
/**
* 与えられた区間がこの区間に内包されるか判定します。<br>
*
* @param other
* @return 与えられた区間がこの区間に内包されるならtrue
*/
public boolean encloses(final Range<C> other) {
return !isLess(other.lower, other.lowerType) && !isGreater(other.upper, other.upperType);
}
/**
* 与えられた区間がこの区間と公差するか判定します。<br>
* 接する場合は公差するものとします。
*
* @param value 調べる引数
* @return 区間が交差するならtrue
*/
public boolean isConnected(final Range<C> other) {
if (this.isEmpty() || other.isEmpty()) return false;
C lower, upper;
BoundType lowerType, upperType;
if (isLess(other.lower, other.lowerType)) {
lower = other.lower;
lowerType = other.lowerType;
} else {
lower = this.lower;
lowerType = this.lowerType;
}
if (isGreater(other.upper, other.upperType)) {
upper = other.upper;
upperType = other.upperType;
} else {
upper = this.upper;
upperType = this.upperType;
}
if (lower == null || upper == null) return true;
final int comp = compareLower(lower, lowerType, upper, upperType);
return comp <= 0;
}
/**
* この区間との積集合を返します。
*
* @param connectedRange 積集合を求める区間
* @return 積集合
*/
public Range<C> intersection(final Range<C> connectedRange) {
if (this.isEmpty() || connectedRange.isEmpty()) {
if (comparator == null) return new Range<>(null, BoundType.CLOSED, null, BoundType.CLOSED);
return empty(comparator);
}
C lower, upper;
BoundType lowerType, upperType;
if (isLess(connectedRange.lower, connectedRange.lowerType)) {
lower = connectedRange.lower;
lowerType = connectedRange.lowerType;
} else {
lower = this.lower;
lowerType = this.lowerType;
}
if (isGreater(connectedRange.upper, connectedRange.upperType)) {
upper = connectedRange.upper;
upperType = connectedRange.upperType;
} else {
upper = this.upper;
upperType = this.upperType;
}
if (comparator == null) { return new Range<>(lower, lowerType, upper, upperType); }
return range(lower, lowerType, upper, upperType, comparator);
}
/**
* この区間との和集合を返します。
*
* @param other 和集合を求める区間
* @return 和集合
*/
public Range<C> span(final Range<C> other) {
if (other.isEmpty()) return new Range<>(lower, lowerType, upper, upperType);
C lower, upper;
BoundType lowerType, upperType;
if (isLess(other.lower, other.lowerType)) {
lower = this.lower;
lowerType = this.lowerType;
} else {
lower = other.lower;
lowerType = other.lowerType;
}
if (isGreater(other.upper, other.upperType)) {
upper = this.upper;
upperType = this.upperType;
} else {
upper = other.upper;
upperType = other.upperType;
}
return new Range<>(lower, lowerType, upper, upperType, comparator);
}
/**
* 区間スケジューリングを行います。<br>
* 計算量は要素数Nに対してO(NlogN)です。
*
* @param ranges 区間の集合
* @return 区間スケジューリングを行った際の一つの解
*/
public static <C> List<Range<C>> scheduling(final List<Range<C>> ranges) {
final PriorityQueue<Range<C>> pq = new PriorityQueue<>((l, r) -> l.compareUpper(r.upper, r.upperType));
final List<Range<C>> ret = new ArrayList<>();
Range<C> last = pq.poll();
if (pq.isEmpty()) return ret;
ret.add(last);
while (!pq.isEmpty()) {
final Range<C> tmp = pq.poll();
if (tmp.compareLower(last.upper, last.upperType) > 0) {
ret.add(tmp);
last = tmp;
}
}
return ret;
}
@Override
public boolean equals(final Object object) {
if (this == object) return true;
if (object instanceof Range) {
@SuppressWarnings("unchecked")
final Range<C> comp = (Range<C>) object;
return compareLower(comp.lower, comp.lowerType) == 0 && compareUpper(comp.upper, comp.upperType) == 0
&& lowerType == comp.lowerType && upperType == comp.upperType;
}
return false;
}
@Override
public int hashCode() {
if (lower == null && upper == null) return 0;
else if (lower == null) return upper.hashCode();
else if (upper == null) return lower.hashCode();
return lower.hashCode() ^ upper.hashCode();
}
@Override
public String toString() {
if (isEmpty()) return "()";
return (lowerType == BoundType.OPEN ? "(" : "[") + (lower == null ? "" : lower.toString()) + ".."
+ (upper == null ? "" : upper.toString()) + (upperType == BoundType.OPEN ? ")" : "]");
}
}
public static class IterableRange<C> extends Range<C> implements Iterable<C> {
private static final long serialVersionUID = 9065915259748260688L;
protected UnaryOperator<C> func;
protected IterableRange(final C lower, final BoundType lowerType, final C upper, final BoundType upperType,
final UnaryOperator<C> func) {
super(lower, lowerType, upper, upperType);
this.func = func;
}
public static <C extends Comparable<? super C>> IterableRange<C> range(final C lower, final BoundType lowerType,
final C upper, final BoundType upperType, final UnaryOperator<C> func) {
if (lower == null || upper == null)
return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
final int comp = lower.compareTo(upper);
if (comp > 0) return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
else if (comp == 0 && (lowerType == BoundType.OPEN || upperType == BoundType.OPEN))
return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
return new IterableRange<>(lower, lowerType, upper, upperType, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> open(final C lower, final C upper,
final UnaryOperator<C> func) {
if (lower == null) return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
return range(func.apply(lower), BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> openClosed(final C lower, final C upper,
final UnaryOperator<C> func) {
if (lower == null) return new IterableRange<>(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
return range(func.apply(lower), BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> closedOpen(final C lower, final C upper,
final UnaryOperator<C> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> closed(final C lower, final C upper,
final UnaryOperator<C> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static <C extends Comparable<? super C>> IterableRange<C> singleton(final C value,
final UnaryOperator<C> func) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED, func);
}
protected class Iter implements Iterator<C> {
C now;
Iter() {
now = lower;
}
@Override
public final boolean hasNext() {
return !isGreater(now);
}
@Override
public final C next() {
final C ret = now;
now = func.apply(now);
return ret;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
protected class EmptyIter implements Iterator<C> {
@Override
public boolean hasNext() {
return false;
}
@Override
public C next() {
return null;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public Iterator<C> iterator() {
return lower == null || upper == null ? new EmptyIter() : new Iter();
}
public int getDistance() {
C check = upper;
int ret = 0;
while (lower != check) {
check = func.apply(check);
++ret;
}
return ret;
}
}
public static class IntRange extends IterableRange<Integer> {
private static final long serialVersionUID = 5623995336491967216L;
private final boolean useFastIter;
private static class Next implements UnaryOperator<Integer> {
@Override
public Integer apply(final Integer value) {
return value + 1;
}
}
protected IntRange() {
super(null, BoundType.CLOSED, null, BoundType.CLOSED, new Next());
useFastIter = true;
}
protected IntRange(final UnaryOperator<Integer> func) {
super(null, BoundType.CLOSED, null, BoundType.CLOSED, func);
useFastIter = false;
}
protected IntRange(final int lower, final BoundType lowerType, final int upper, final BoundType upperType) {
super(lower, lowerType, upper, upperType, new Next());
useFastIter = true;
}
protected IntRange(final int lower, final BoundType lowerType, final int upper, final BoundType upperType,
final UnaryOperator<Integer> func) {
super(lower, lowerType, upper, upperType, func);
useFastIter = false;
}
public static IntRange range(int lower, final BoundType lowerType, int upper, final BoundType upperType) {
if (lower > upper) return new IntRange();
if (lowerType == BoundType.OPEN) ++lower;
if (upperType == BoundType.OPEN) --upper;
return new IntRange(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static IntRange range(int lower, final BoundType lowerType, int upper, final BoundType upperType,
final UnaryOperator<Integer> func) {
if (lower > upper) return new IntRange(func);
if (lowerType == BoundType.OPEN) ++lower;
if (upperType == BoundType.OPEN) --upper;
return new IntRange(lower, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static IntRange open(final int lower, final int upper) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN);
}
public static IntRange open(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.OPEN, upper, BoundType.OPEN, func);
}
public static IntRange open(final int upper) {
return range(0, BoundType.CLOSED, upper, BoundType.OPEN);
}
public static IntRange open(final int upper, final UnaryOperator<Integer> func) {
return range(0, BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static IntRange openClosed(final int lower, final int upper) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED);
}
public static IntRange openClosed(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.OPEN, upper, BoundType.CLOSED, func);
}
public static IntRange closedOpen(final int lower, final int upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN);
}
public static IntRange closedOpen(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.OPEN, func);
}
public static IntRange closed(final int lower, final int upper) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static IntRange closed(final int lower, final int upper, final UnaryOperator<Integer> func) {
return range(lower, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static IntRange closed(final int upper) {
return range(0, BoundType.CLOSED, upper, BoundType.CLOSED);
}
public static IntRange closed(final int upper, final UnaryOperator<Integer> func) {
return range(0, BoundType.CLOSED, upper, BoundType.CLOSED, func);
}
public static IntRange singleton(final int value) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED);
}
public static IntRange singleton(final int value, final UnaryOperator<Integer> func) {
return range(value, BoundType.CLOSED, value, BoundType.CLOSED, func);
}
private class FastIter implements Iterator<Integer> {
int now;
public FastIter() {
now = lower;
}
@Override
public final boolean hasNext() {
return now <= upper;
}
@Override
public final Integer next() {
return now++;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
private class Iter implements Iterator<Integer> {
int now;
public Iter() {
now = lower;
}
@Override
public final boolean hasNext() {
return now <= upper;
}
@Override
public final Integer next() {
final int ret = now;
now = func.apply(now);
return ret;
}
@Override
public final void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public Iterator<Integer> iterator() {
return lower == null || upper == null ? new EmptyIter() : useFastIter ? new FastIter() : new Iter();
}
@Override
public int getDistance() {
int ret = upper - lower;
if (upperType == BoundType.CLOSED) ++ret;
return ret;
}
public int getClosedLower() { return lower; }
public int getOpenLower() { return lower - 1; }
public int getClosedUpper() { return upperType == BoundType.CLOSED ? upper : upper - 1; }
public int getOpenUpper() { return upperType == BoundType.CLOSED ? upper + 1 : upper; }
/**
* 区間スケジューリングを行います。<br>
* 計算量は要素数Nに対してO(NlogN)です。
*
* @param ranges 区間の集合
* @return 区間スケジューリングを行った際の一つの解
*/
public static List<IntRange> intScheduling(final List<IntRange> ranges) {
final PriorityQueue<IntRange> pq = new PriorityQueue<>((l, r) -> l.compareUpper(r.upper, r.upperType));
pq.addAll(ranges);
final List<IntRange> ret = new ArrayList<>();
if (pq.isEmpty()) return ret;
IntRange last = pq.poll();
ret.add(last);
while (!pq.isEmpty()) {
final IntRange tmp = pq.poll();
if (tmp.compareLower(last.upper, last.upperType) > 0) {
ret.add(tmp);
last = tmp;
}
}
return ret;
}
}
/**
* 演算が結合法則を満たすことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Associative<T> extends BinaryOperator<T> {
/**
* repeat個のelementを順次演算した値を返します。
*
* @param element 演算する値
* @param repeat 繰り返す回数、1以上であること
* @return 演算を+として、element + element + ... + elementと演算をrepeat-1回行った値
*/
public default T hyper(final T element, int repeat) {
if (repeat < 1) throw new IllegalArgumentException("undefined operation");
T ret = element;
--repeat;
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return ret;
}
}
/**
* この演算が逆元を持つことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Inverse<T> extends BinaryOperator<T> {
public T inverse(T element);
}
/**
* 演算が交換法則を満たすことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Commutative<T> extends BinaryOperator<T> {
}
/**
* 演算が単位元を持つことを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Identity<T> extends BinaryOperator<T> {
/**
* 単位元を返します。
*
* @return 単位元
*/
public T identity();
}
/**
* 演算が群であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Group<T> extends Monoid<T>, Inverse<T> {
/**
* repeat個のelementを順次演算した値を返します。
*
* @param element 演算する値
* @param repeat 繰り返す回数
* @return 演算を+として、element + element + ... + elementと演算をrepeat-1回行った値
*/
@Override
public default T hyper(final T element, int repeat) {
T ret = identity();
if (repeat < 0) {
repeat = -repeat;
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return inverse(ret);
}
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return ret;
}
}
/**
* 演算がモノイドであることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Monoid<T> extends Associative<T>, Identity<T> {
/**
* repeat個のelementを順次演算した値を返します。
*
* @param element 演算する値
* @param repeat 繰り返す回数、0以上であること
* @return 演算を+として、element + element + ... + elementと演算をrepeat-1回行った値
*/
@Override
public default T hyper(final T element, int repeat) {
if (repeat < 0) throw new IllegalArgumentException("undefined operation");
T ret = identity();
for (T mul = element; repeat > 0; repeat >>= 1, mul = apply(mul, mul))
if ((repeat & 1) != 0) ret = apply(ret, mul);
return ret;
}
}
/**
* 演算が可換モノイドであることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface CommutativeMonoid<T> extends Monoid<T>, Commutative<T> {
}
/**
* 演算がアーベル群(可換群)であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
*/
public interface Abelian<T> extends Group<T>, CommutativeMonoid<T> {
}
/**
* 演算が半環であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface Semiring<T, A extends CommutativeMonoid<T>, M extends Monoid<T>> {
public A getAddition();
public M getMultiplication();
public default T add(final T left, final T right) {
return getAddition().apply(left, right);
}
public default T multiply(final T left, final T right) {
return getMultiplication().apply(left, right);
}
public default T additiveIdentity() {
return getAddition().identity();
}
public default T multipleIdentity() {
return getMultiplication().identity();
}
public default int characteristic() {
return 0;
}
}
/**
* 演算が環であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface Ring<T, A extends Abelian<T>, M extends Monoid<T>> extends Semiring<T, A, M> {
}
/**
* 演算が可換環に属することを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface CommutativeRing<T, A extends Abelian<T>, M extends CommutativeMonoid<T>> extends Ring<T, A, M> {
}
/**
* 演算が整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface IntegralDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends CommutativeRing<T, A, M> {
public boolean isDivisible(T left, T right);
public T divide(T left, T right);
}
/**
* 演算が整閉整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface IntegrallyClosedDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends IntegralDomain<T, A, M> {
}
/**
* 演算がGCD整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface GCDDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends IntegrallyClosedDomain<T, A, M> {
public T gcd(T left, T right);
public T lcm(T left, T right);
}
/**
* 素元を提供します。
*
* @author 31536000
*
* @param <T> 演算の型
*/
public static class PrimeElement<T> {
public final T element;
public PrimeElement(final T element) {
this.element = element;
}
}
public interface MultiSet<E> extends Collection<E> {
public int add(E element, int occurrences);
public int count(Object element);
public Set<E> elementSet();
public boolean remove(Object element, int occurrences);
public int setCount(E element, int count);
public boolean setCount(E element, int oldCount, int newCount);
}
/**
* 演算が一意分解整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface UniqueFactorizationDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends GCDDomain<T, A, M> {
public MultiSet<PrimeElement<T>> PrimeFactorization(T x);
}
/**
* 演算が主イデアル整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface PrincipalIdealDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends UniqueFactorizationDomain<T, A, M> {
}
/**
* 演算がユークリッド整域であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface EuclideanDomain<T, A extends Abelian<T>, M extends CommutativeMonoid<T>>
extends PrincipalIdealDomain<T, A, M> {
public T reminder(T left, T right);
}
/**
* 演算が体であることを示すために使用するマーカー・インターフェースです。
*
* @author 31536000
*
* @param <T> 二項演算の型
* @param <A> 和に関する演算
* @param <M> 積に関する演算
*/
public interface Field<T, A extends Abelian<T>, M extends Abelian<T>> extends EuclideanDomain<T, A, M> {
@Override
public default boolean isDivisible(final T left, final T right) {
return !right.equals(additiveIdentity());
}
@Override
public default T divide(final T left, final T right) {
if (isDivisible(left, right)) throw new ArithmeticException("divide by Additive Identify");
return multiply(left, getMultiplication().inverse(right));
}
@Override
public default T reminder(final T left, final T right) {
if (isDivisible(left, right)) throw new ArithmeticException("divide by Additive Identify");
return additiveIdentity();
}
@Override
public default T gcd(final T left, final T right) {
return multipleIdentity();
}
@Override
public default T lcm(final T left, final T right) {
return multipleIdentity();
}
@Override
public default MultiSet<PrimeElement<T>> PrimeFactorization(final T x) {
final HashMultiSet<PrimeElement<T>> ret = HashMultiSet.create(1);
ret.add(new PrimeElement<>(x));
return ret;
}
}
public static class HashMultiSet<E> implements MultiSet<E>, Serializable {
private static final long serialVersionUID = -8378919645386251159L;
private final transient HashMap<E, Integer> map;
private transient int size;
private HashMultiSet() {
map = new HashMap<>();
size = 0;
}
private HashMultiSet(final int distinctElements) {
map = new HashMap<>(distinctElements);
size = 0;
}
public static <E> HashMultiSet<E> create() {
return new HashMultiSet<>();
}
public static <E> HashMultiSet<E> create(final int distinctElements) {
return new HashMultiSet<>(distinctElements);
}
public static <E> HashMultiSet<E> create(final Iterable<? extends E> elements) {
final HashMultiSet<E> ret = new HashMultiSet<>();
for (final E i : elements) ret.map.compute(i, (v, e) -> e == null ? 1 : ++e);
return ret;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() { return size == 0; }
@Override
public boolean contains(final Object o) {
return map.containsKey(o);
}
private class Iter implements Iterator<E> {
private final Iterator<Entry<E, Integer>> iter = map.entrySet().iterator();
private E value;
private int count = 0;
@Override
public boolean hasNext() {
if (count > 0) return true;
if (iter.hasNext()) {
final Entry<E, Integer> entry = iter.next();
value = entry.getKey();
count = entry.getValue();
return true;
}
return false;
}
@Override
public E next() {
--count;
return value;
}
}
@Override
public Iterator<E> iterator() {
return new Iter();
}
@Override
public Object[] toArray() {
final Object[] ret = new Object[size];
int read = 0;
for (final Entry<E, Integer> i : map.entrySet()) Arrays.fill(ret, read, read += i.getValue(), i.getKey());
return ret;
}
@Override
public <T> T[] toArray(final T[] a) {
final Object[] src = toArray();
if (a.length < src.length) {
@SuppressWarnings("unchecked")
final T[] ret = (T[]) Arrays.copyOfRange(src, 0, src.length, a.getClass());
return ret;
}
System.arraycopy(src, 0, a, 0, src.length);
return a;
}
@Override
public boolean add(final E e) {
add(e, 1);
return true;
}
@Override
public boolean remove(final Object o) {
return remove(o, 1);
}
@Override
public boolean containsAll(final Collection<?> c) {
boolean ret = true;
for (final Object i : c) ret |= contains(i);
return ret;
}
@Override
public boolean addAll(final Collection<? extends E> c) {
boolean ret = false;
for (final E i : c) ret |= add(i);
return ret;
}
@Override
public boolean removeAll(final Collection<?> c) {
boolean ret = false;
for (final Object i : c) ret |= remove(i);
return ret;
}
@Override
public boolean retainAll(final Collection<?> c) {
return removeAll(c);
}
@Override
public void clear() {
map.clear();
size = 0;
}
@Override
public int add(final E element, final int occurrences) {
size += occurrences;
return map.compute(element, (k, v) -> v == null ? occurrences : v + occurrences) - occurrences;
}
@Override
public int count(final Object element) {
return map.getOrDefault(element, 0);
}
@Override
public Set<E> elementSet() {
return map.keySet();
}
public Set<Entry<E, Integer>> entrySet() {
return map.entrySet();
}
@Override
public boolean remove(final Object element, final int occurrences) {
try {
@SuppressWarnings("unchecked")
final E put = (E) element;
return map.compute(put, (k, v) -> {
if (v == null) return null;
if (v < occurrences) {
size -= v;
return null;
}
size -= occurrences;
return v - occurrences;
}) != null;
} catch (final ClassCastException E) {
return false;
}
}
@Override
public int setCount(final E element, final int count) {
final Integer ret = map.put(element, count);
final int ret2 = ret == null ? 0 : ret;
size += count - ret2;
return ret2;
}
@Override
public boolean setCount(final E element, final int oldCount, final int newCount) {
final boolean ret = map.replace(element, oldCount, newCount);
if (ret) size += newCount - oldCount;
return ret;
}
}
public static class ModInteger extends Number
implements Field<ModInteger, Abelian<ModInteger>, Abelian<ModInteger>> {
private static final long serialVersionUID = -8595710127161317579L;
private final int mod;
private int num;
private final Addition add;
private final Multiplication mul;
private class Addition implements Abelian<ModInteger> {
@Override
public ModInteger identity() {
return new ModInteger(mod, 0);
}
@Override
public ModInteger inverse(final ModInteger element) {
return new ModInteger(element, element.mod - element.num);
}
@Override
public ModInteger apply(final ModInteger left, final ModInteger right) {
return new ModInteger(left).addEqual(right);
}
}
private class Multiplication implements Abelian<ModInteger> {
@Override
public ModInteger identity() {
return new ModInteger(mod, 1);
}
@Override
public ModInteger apply(final ModInteger left, final ModInteger right) {
return new ModInteger(left).multiplyEqual(right);
}
@Override
public ModInteger inverse(final ModInteger element) {
return new ModInteger(element, element.inverse(element.num));
}
}
@Override
public int characteristic() {
return mod;
}
public ModInteger(final int mod) {
this.mod = mod;
num = 0;
add = new Addition();
mul = new Multiplication();
}
public ModInteger(final int mod, final int num) {
this.mod = mod;
this.num = validNum(num);
add = new Addition();
mul = new Multiplication();
}
public ModInteger(final ModInteger n) {
mod = n.mod;
num = n.num;
add = n.add;
mul = n.mul;
}
private ModInteger(final ModInteger n, final int num) {
mod = n.mod;
this.num = num;
add = n.add;
mul = n.mul;
}
private int validNum(int n) {
n %= mod;
if (n < 0) n += mod;
return n;
}
private int validNum(long n) {
n %= mod;
if (n < 0) n += mod;
return (int) n;
}
protected int inverse(int n) {
int m = mod, u = 0, v = 1, t;
while (n != 0) {
t = m / n;
m -= t * n;
u -= t * v;
if (m != 0) {
t = n / m;
n -= t * m;
v -= t * u;
} else {
v %= mod;
if (v < 0) v += mod;
return v;
}
}
u %= mod;
if (u < 0) u += mod;
return u;
}
public boolean isPrime(final int n) {
if ((n & 1) == 0) return false; // 偶数
for (int i = 3, j = 8, k = 9; k <= n; i += 2, k += j += 8) if (n % i == 0) return false;
return true;
}
@Override
public int intValue() {
return num;
}
@Override
public long longValue() {
return num;
}
@Override
public float floatValue() {
return num;
}
@Override
public double doubleValue() {
return num;
}
protected ModInteger getNewInstance(final ModInteger mod) {
return new ModInteger(mod);
}
public ModInteger add(final int n) {
return getNewInstance(this).addEqual(n);
}
public ModInteger add(final long n) {
return getNewInstance(this).addEqual(n);
}
public ModInteger add(final ModInteger n) {
return getNewInstance(this).addEqual(n);
}
public ModInteger addEqual(final int n) {
num = validNum(num + n);
return this;
}
public ModInteger addEqual(final long n) {
num = validNum(num + n);
return this;
}
public ModInteger addEqual(final ModInteger n) {
if ((num += n.num) >= mod) num -= mod;
return this;
}
public ModInteger subtract(final int n) {
return getNewInstance(this).subtractEqual(n);
}
public ModInteger subtract(final long n) {
return getNewInstance(this).subtractEqual(n);
}
public ModInteger subtract(final ModInteger n) {
return getNewInstance(this).subtractEqual(n);
}
public ModInteger subtractEqual(final int n) {
num = validNum(num - n);
return this;
}
public ModInteger subtractEqual(final long n) {
num = validNum(num - n);
return this;
}
public ModInteger subtractEqual(final ModInteger n) {
if ((num -= n.num) < 0) num += mod;
return this;
}
public ModInteger multiply(final int n) {
return getNewInstance(this).multiplyEqual(n);
}
public ModInteger multiply(final long n) {
return getNewInstance(this).multiplyEqual(n);
}
public ModInteger multiply(final ModInteger n) {
return getNewInstance(this).multiplyEqual(n);
}
public ModInteger multiplyEqual(final int n) {
num = (int) ((long) num * n % mod);
if (num < 0) num += mod;
return this;
}
public ModInteger multiplyEqual(final long n) {
return multiplyEqual((int) (n % mod));
}
public ModInteger multiplyEqual(final ModInteger n) {
num = (int) ((long) num * n.num % mod);
return this;
}
public ModInteger divide(final int n) {
return getNewInstance(this).divideEqual(n);
}
public ModInteger divide(final long n) {
return getNewInstance(this).divideEqual(n);
}
public ModInteger divide(final ModInteger n) {
return getNewInstance(this).divideEqual(n);
}
public ModInteger divideEqual(final int n) {
num = (int) ((long) num * inverse(validNum(n)) % mod);
return this;
}
public ModInteger divideEqual(final long n) {
return divideEqual((int) (n % mod));
}
public ModInteger divideEqual(final ModInteger n) {
num = (int) ((long) num * n.inverse(n.num) % mod);
return this;
}
public ModInteger pow(final int n) {
return getNewInstance(this).powEqual(n);
}
public ModInteger pow(final long n) {
return getNewInstance(this).powEqual(n);
}
public ModInteger pow(final ModInteger n) {
return getNewInstance(this).powEqual(n);
}
public ModInteger powEqual(int n) {
long ans = 1, num = this.num;
if (n < 0) {
n = -n;
while (n != 0) {
if ((n & 1) != 0) ans = ans * num % mod;
n >>>= 1;
num = num * num % mod;
}
this.num = inverse((int) ans);
return this;
}
while (n != 0) {
if ((n & 1) != 0) ans = ans * num % mod;
n >>>= 1;
num = num * num % mod;
}
this.num = (int) ans;
return this;
}
public ModInteger powEqual(final long n) {
return powEqual((int) (n % (mod - 1)));
}
public ModInteger powEqual(final ModInteger n) {
long num = this.num;
this.num = 1;
int mul = n.num;
while (mul != 0) {
if ((mul & 1) != 0) this.num *= num;
mul >>>= 1;
num *= num;
num %= mod;
}
return this;
}
public ModInteger equal(final int n) {
num = validNum(n);
return this;
}
public ModInteger equal(final long n) {
num = validNum(n);
return this;
}
public ModInteger equal(final ModInteger n) {
num = n.num;
return this;
}
public int toInt() {
return num;
}
public int getMod() { return mod; }
@Override
public boolean equals(final Object x) {
if (x instanceof ModInteger) return ((ModInteger) x).num == num && ((ModInteger) x).mod == mod;
return false;
}
@Override
public int hashCode() {
return num ^ mod;
}
@Override
public String toString() {
return String.valueOf(num);
}
@Deprecated
public String debug() {
int min = num, ans = 1;
for (int i = 2; i < min; ++i) {
final int tmp = multiply(i).num;
if (min > tmp) {
min = tmp;
ans = i;
}
}
return min + "/" + ans;
}
@Override
public Addition getAddition() { return add; }
@Override
public Multiplication getMultiplication() { return mul; }
}
/**
* 素数を法とする演算上で、組み合わせの計算を高速に行います。
*
* @author 31536000
*
*/
public static class ModUtility {
private final int mod;
private int[] fact, inv, invfact;
/**
* modを法として、演算を行います。
*
* @param mod 法とする素数
*/
public ModUtility(final Prime mod) {
this(mod, 2);
}
/**
* modを法として、演算を行います。
*
* @param mod 法とする素数
* @param calc 予め前計算しておく大きさ
*/
public ModUtility(final Prime mod, final int calc) {
this.mod = mod.prime;
precalc(calc);
}
/**
* calcの大きさだけ、前計算を行います。
*
* @param calc 前計算をする大きさ
*/
public void precalc(int calc) {
++calc;
if (calc < 2) calc = 2;
if (calc > mod) calc = mod;
fact = new int[calc];
inv = new int[calc];
invfact = new int[calc];
fact[0] = invfact[0] = fact[1] = invfact[1] = inv[1] = 1;
for (int i = 2; i < calc; ++i) {
fact[i] = (int) ((long) fact[i - 1] * i % mod);
inv[i] = (int) (mod - (long) inv[mod % i] * (mod / i) % mod);
invfact[i] = (int) ((long) invfact[i - 1] * inv[i] % mod);
}
}
/**
* modを法とする剰余環上で振舞う整数を返します。
*
* @return modを法とする整数、初期値は0
*/
public ModInteger create() {
return new ModInt();
}
/**
* modを法とする剰余環上で振舞う整数を返します。
*
* @param n 初期値
* @return modを法とする整数
*/
public ModInteger create(final int n) {
return new ModInt(n);
}
private class ModInt extends ModInteger {
private static final long serialVersionUID = -2435281861935422575L;
public ModInt() {
super(mod);
}
public ModInt(final int n) {
super(mod, n);
}
public ModInt(final ModInteger mod) {
super(mod);
}
@Override
protected ModInteger getNewInstance(final ModInteger mod) {
return new ModInt(mod);
}
@Override
protected int inverse(final int n) {
return ModUtility.this.inverse(n);
}
}
/**
* modを法として、nの逆元を返します。<br>
* 計算量はO(log n)です。
*
* @param n 逆元を求めたい値
* @return 逆元
*/
public int inverse(int n) {
try {
if (inv.length > n) return inv[n];
int m = mod, u = 0, v = 1, t;
while (n != 0) {
t = m / n;
m -= t * n;
u -= t * v;
if (m != 0) {
t = n / m;
n -= t * m;
v -= t * u;
} else {
v %= mod;
if (v < 0) v += mod;
return v;
}
}
u %= mod;
if (u < 0) u += mod;
return u;
} catch (final ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException();
}
}
/**
* n!を、modを法として求めた値を返します。<br>
* 計算量はO(n)です。
*
* @param n 階乗を求めたい値
* @return nの階乗をmodで割った余り
*/
public int factorial(final int n) {
try {
if (fact.length > n) return fact[n];
long ret = fact[fact.length - 1];
for (int i = fact.length; i <= n; ++i) ret = ret * i % mod;
return (int) ret;
} catch (final ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException();
}
}
/**
* nPkをmodで割った余りを求めます。<br>
* 計算量はO(n-k)です。
*
* @param n 左辺
* @param k 右辺
* @return nPkをmodで割った余り
*/
public int permutation(final int n, final int k) {
if (n < 0) throw new IllegalArgumentException();
if (n < k) return 0;
if (fact.length > n) return (int) ((long) fact[n] * invfact[n - k] % mod);
long ret = 1;
for (int i = n - k + 1; i <= n; ++i) ret = ret * i % mod;
return (int) ret;
}
/**
* nCkをmodで割った余りを求めます。<br>
* 計算量はO(min(plogn, n-k))です。
*
* @param n 左辺
* @param k 右辺
* @return nCkをmodで割った余り
*/
public int combination(int n, int k) {
if (n < 0) throw new IllegalArgumentException();
if (n < k) return 0;
if (fact.length > n) return (int) ((long) fact[n] * invfact[k] % mod * invfact[n - k] % mod);
long ret = 1;
if (n >= mod) {
if (mod == 2) return (~n & k) == 0 ? 1 : 0;
while (n > 0) {
ret = ret * combination(n % mod, k % mod) % mod;
n /= mod;
k /= mod;
}
return (int) ret;
}
if (n < 2 * k) k = n - k;
ret = invfact.length > k ? invfact[k] : inverse(factorial(k));
for (int i = n - k + 1; i <= n; ++i) ret = ret * i % mod;
return (int) ret;
}
/**
* 他項係数をmodで割った余りを求めます。<br>
* ] 計算量はO(n)です。
*
* @param n 左辺
* @param k 右辺、合計がn以下である必要がある
* @return 他項係数
*/
public int multinomial(final int n, final int... k) {
int sum = 0;
long ret = factorial(n);
if (fact.length > n) {
for (final int i : k) {
if (i < 0) throw new IllegalArgumentException();
ret = ret * invfact[i] % mod;
sum += i;
}
if (sum > n) return 0;
ret = ret * invfact[n - sum] % mod;
} else {
for (final int i : k) {
if (i < 0) throw new IllegalArgumentException();
if (invfact.length > i) ret = ret * invfact[i] % mod;
else ret = ret * inverse(factorial(i)) % mod;
sum += i;
}
if (sum > n) return 0;
if (invfact.length > n - sum) ret = ret * invfact[n - sum] % mod;
else ret = ret * inverse(factorial(n - sum)) % mod;
}
return (int) ret;
}
/**
* n個からk個を選ぶ重複組み合わせnHkをmodで割った余りを求めます。<br>
* 計算量はO(min(n, k))です。
*
* @param n 左辺
* @param k 右辺
* @return nHkをmodで割った余り
*/
public int multichoose(final int n, final int k) {
return combination(mod(n + k - 1), k);
}
/**
* カタラン数C(n)をmodで割った余りを求めます。<br>
* 計算量はO(n)です。
*
* @param n 求めたいカタラン数の番号
* @return カタラン数
*/
public int catalan(final int n) {
return divide(combination(mod(2 * n), n), mod(n + 1));
}
/**
* 第一種スターリング数S(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(nk)です。 // TODO NTTを使うとO(n log n)、未実装
*
* @param n 左辺
* @param k 右辺
* @return S(n, k)をmodで割った余り
*/
public int firstStirling(final int n, final int k) {
final int[] stirling = new int[(n + 1) * (k + 1)];
stirling[0] = 1;
final int h = k + 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j) {
final int tmp = stirling[i * h + j] + (int) ((long) i * stirling[i * h + j + 1] % mod);
stirling[(i + 1) * h + j + 1] = tmp >= mod ? tmp - mod : tmp;
}
}
return stirling[stirling.length - 1];
}
/**
* 第二種スターリング数S(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(k)です。
*
* @param n 左辺
* @param k 右辺
* @return S(n, k)をmodで割った余り
*/
public int secondStirling(final int n, final int k) {
if (k == 0) return n == 0 ? 1 : 0;
final int[] sieve = new int[k + 1], prime = new int[k + 1];
int size = 0;
sieve[1] = 1;
for (int i = 2; i <= k; ++i) {
if (sieve[i] == 0) prime[size++] = sieve[i] = i;
for (int j = 0, s; j < size && prime[j] <= sieve[i] && (s = i * prime[j]) <= k; ++j)
sieve[s] = prime[j];
}
long ans = 0;
for (int i = 1, s; i <= k; ++i) {
final long tmp = (long) combination(k, i)
* (prime[i] = (s = sieve[i]) == i ? pow(i, n) : (int) ((long) prime[s] * prime[i / s] % mod))
% mod;
ans += (k - i & 1) != 0 ? -tmp : tmp;
}
return (int) ((long) mod(ans) * invfact[k] % mod);
}
/**
* ベル数B(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(k)です。
*
* @param n 左辺
* @param k 右辺
* @return B(n, k)をmodで割った余り
*/
public int bell(final int n, final int k) {
if (k == 0) return n == 0 ? 1 : 0;
final int[] sieve = new int[k + 1], prime = new int[k + 1];
int size = 0;
sieve[1] = 1;
long sum = 0;
for (int i = 2; i <= k; ++i) {
if (sieve[i] == 0) prime[size++] = sieve[i] = i;
for (int j = 0, s; j < size && prime[j] <= sieve[i] && (s = i * prime[j]) <= k; ++j)
sieve[s] = prime[j];
sum += (i & 1) != 0 ? -invfact[i] : invfact[i];
}
sum = mod(sum);
long ans = 0;
for (int i = 0, s; i <= k; ++i) {
final long tmp = (long) (prime[i] = (s = sieve[i]) == i ? pow(i, n)
: (int) ((long) prime[s] * prime[i / s] % mod)) * invfact[i] % mod;
ans += tmp * sum % mod;
if ((sum -= (k - i & 1) != 0 ? -invfact[k - i] : invfact[k - i]) < 0) sum += mod;
}
return mod(ans);
}
/**
* ベル数B(n)をmodで割った余りを求めます。<br>
* 計算量はO(n)です。
*
* @param n 求めたいベル数の番号
* @return B(n)
*/
public int bell(final int n) {
return bell(n, n);
}
/**
* 分割数P(n, k)をmodで割った余りを求めます。<br>
* 計算量はO(nk)です。 // TODO NTTを使うとO(n log n)、未実装
*
* @param n 左辺
* @param k 右辺
* @return P(n, k)をmodで割った余り
*/
public int pertition(final int n, final int k) {
final int[] pertition = new int[(n + 1) * (k + 1)];
pertition[0] = 1;
final int h = k + 1;
for (int i = 0; i <= n; ++i) {
for (int j = 1, l = Math.min(i, k); j <= l; ++j)
pertition[i * h + j] = pertition[i * h + j - 1] + pertition[(i - j) * h + j];
for (int j = i; j < k; ++j) pertition[i * h + j + 1] = pertition[i * h + j];
}
return pertition[n * h + k];
}
/**
* 分割数P(n)をmodで割った余りを求めます。<br>
* 計算量はO(n sqrt(n))です。 // TODO NTTを使うとO(n log n)、未実装
*
* @param n 求めたい分割数の番号
* @return P(n)
*/
public int pertition(final int n) {
final long[] pertition = new long[n + 1];
pertition[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1, t; (t = i - (j * (3 * j - 1) >> 1)) >= 0; ++j) {
pertition[i] += (j & 1) != 0 ? pertition[t] : -pertition[t];
}
for (int j = 1, t; (t = i - (j * (3 * j + 1) >> 1)) >= 0; ++j) {
pertition[i] += (j & 1) != 0 ? pertition[t] : -pertition[t];
}
pertition[i] %= mod;
}
return (int) pertition[n];
}
/**
* nのm乗をmodで割った余りを求めます。<br>
* 計算量はO(log m)です。
*
* @param n 床
* @param m 冪指数
* @return n^mをmodで割った余り
*/
public int pow(final int n, int m) {
long ans = 1, num = n;
if (m < 0) {
m = -m;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % mod;
m >>>= 1;
num = num * num % mod;
}
return inverse((int) ans);
}
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % mod;
m >>>= 1;
num = num * num % mod;
}
return (int) ans;
}
/**
* nのm乗をmodで割った余りを求めます。<br>
* 計算量はO(log m)です。
*
* @param n 床
* @param m 冪指数
* @return n^mをmodで割った余り
*/
public int pow(final long n, final long m) {
return pow((int) (n % mod), (int) (m % (mod - 1)));
}
/**
* 現在のmod値のトーシェント数を返します。<br>
* なお、これはmod-1に等しいです。
*
* @return トーシェント数
*/
public int totient() {
return mod - 1;
}
/**
* nのトーシェント数を返します。<br>
* 計算量はO(sqrt n)です。
*
* @param n トーシェント数を求めたい値
* @return nのトーシェント数
*/
public static int totient(int n) {
int totient = n;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
totient = totient / i * (i - 1);
while ((n %= i) % i == 0);
}
}
if (n != 1) totient = totient / n * (n - 1);
return totient;
}
/**
* nをmodで割った余りを返します。
*
* @param n 演算する値
* @return nをmodで割った余り
*/
public int mod(int n) {
return (n %= mod) < 0 ? n + mod : n;
}
/**
* nをmodで割った余りを返します。
*
* @param n 演算する値
* @return nをmodで割った余り
*/
public int mod(long n) {
return (int) ((n %= mod) < 0 ? n + mod : n);
}
/**
* nをmodで割った余りを返します。
*
* @param n 演算する値
* @return nをmodで割った余り
*/
public int mod(final PrimeFactor n) {
int ret = 1;
for (final Entry<Prime, Integer> i : n.primeFactor.entrySet())
ret = multiply(ret, pow(i.getKey().prime, i.getValue()));
return ret;
}
/**
* n+mをmodで割った余りを返します。
*
* @param n 足される値
* @param m 足す値
* @return n+mをmodで割った余り
*/
public int add(final int n, final int m) {
return mod(n + m);
}
/**
* n-mをmodで割った余りを返します。
*
* @param n 引かれる値
* @param m 引く値
* @return n-mをmodで割った余り
*/
public int subtract(final int n, final int m) {
return mod(n - m);
}
/**
* n*mをmodで割った余りを返します。
*
* @param n 掛けられる値
* @param m 掛ける値
* @return n*mをmodで割った余り
*/
public int multiply(final int n, final int m) {
final int ans = (int) ((long) n * m % mod);
return ans < 0 ? ans + mod : ans;
}
/**
* n/mをmodで割った余りを返します。
*
* @param n 割られる値
* @param m 割る値
* @return n/mをmodで割った余り
*/
public int divide(final int n, final int m) {
return multiply(n, inverse(m));
}
/**
* fを通ることが分かっているfの要素数-1次の関数について、xの位置における値をmodで割った余りを返します。<br>
* 計算量はO(f)です。
*
* @param f 関数の形
* @param x 求める位置
* @return 求めたい値をmodで割った余り
*/
public ModInteger lagrangePolynomial(final ModInteger[] f, final int x) {
if (f.length > x) return f[x];
if (x > fact.length) precalc(x);
final ModInteger ret = create(0);
final ModInteger[] dp = new ModInteger[f.length], dp2 = new ModInteger[f.length];
dp[0] = create(1);
dp2[f.length - 1] = create(1);
for (int i = 1; i < f.length; ++i) {
dp[i] = dp[i - 1].multiply(x - i - 1);
dp2[f.length - i - 1] = dp2[f.length - i].multiply(x - f.length + i);
}
for (int i = 0; i < f.length; ++i) {
final ModInteger tmp = f[i].multiply(dp[i]).multiplyEqual(dp2[i]).multiplyEqual(inv[i])
.multiplyEqual(inv[f.length - 1 - i]);
if ((f.length - i & 1) == 0) ret.addEqual(tmp);
else ret.subtractEqual(tmp);
}
return ret;
}
/**
* 与えられた配列に対し、その配列を並び替えることで構成できる配列の集合をSとします。
* このとき、arrayがSを辞書順に並べると何番目かを求めます。
* @complexity N=array.length として O(N log N)
* @param array 辞書順で何番目か求めたい配列
* @return arrayが辞書順で何番目か
*/
public ModInteger permutationNumber(int[] array) {
int[] compress = ArrayUtility.compress(array);
int[] bucket = new int[array.length];
for (int i : compress) ++bucket[i];
int sum = multinomial(array.length, bucket);
int[] bit = new int[array.length + 1];
for (int i = 0; i < array.length; ++i)
for (int j = i + 1, add = bucket[i]; j < bit.length; j += j & -j) bit[j] += add;
int ans = 1;
for (int i = 0; i < array.length; ++i) {
sum = divide(sum, array.length - i);
int comp = compress[i];
int min = 0;
for (int j = comp; j != 0; j -= j & -j) min += bit[j];
ans = add(ans, multiply(sum, min));
sum = multiply(sum, bucket[comp]--);
for (int j = comp + 1; j < bit.length; j += j & -j) --bit[j];
}
return create(ans);
}
}
/**
* 区間における素数を保持する関数です。
*
* @author 31536000
*
*/
public static class SegmentPrime {
private final Prime[] divisor;
private final int offset;
private SegmentPrime(final Prime[] divisor, final int offset) {
this.divisor = divisor;
this.offset = offset;
}
/**
* このクラスが持つ区間の範囲を返します。
*
* @return 素数を保持している区間
*/
public IntRange getRange() { return IntRange.closedOpen(offset, offset + divisor.length); }
/**
* 素数かどうかを判定します。
*
* @param n 素数かどうか判定したい数
* @return 素数ならばtrue
*/
public boolean isPrime(final int n) {
return n <= 1 ? false : divisor[n - offset].prime == n;
}
/**
* 与えられた数を素因数分解します。<br>
* 計算量はO(log n)です。
*
* @param n 素因数分解したい数
* @return 素因数分解した結果
*/
public PrimeFactor getPrimeFactor(int n) {
if (n < 1) throw new IllegalArgumentException("not positive number");
final Map<Prime, Integer> map = new HashMap<>();
while (n > 1) {
final Prime d = divisor[n - offset];
map.compute(d, (k, v) -> v == null ? 1 : v + 1);
n /= d.prime;
}
return new PrimeFactor(map);
}
@Override
public String toString() {
return "SegmentPrime: [" + offset + ", " + (offset + divisor.length) + ")";
}
}
/**
* 整数の素因数分解表現を保持します。
*
* @author 31536000
*
*/
public static class PrimeFactor extends Number {
private static final long serialVersionUID = 1363575672283884773L;
public Map<Prime, Integer> primeFactor;
private PrimeFactor(final Map<Prime, Integer> n) {
primeFactor = n;
}
/**
* 素因数分解のリスト表現を返します。
*
* @return 素因数分解のリスト
*/
public List<Integer> getFactorizationList() {
final List<Integer> ret = new ArrayList<>();
for (final Entry<Prime, Integer> i : primeFactor.entrySet()) {
final int p = i.getKey().prime, n = i.getValue();
for (int j = 0; j < n; ++j) ret.add(p);
}
return ret;
}
/**
* nとgcdを取った値を保持します。
*
* @param n gcdを取りたい値
*/
public void gcd(final PrimeFactor n) {
for (final Entry<Prime, Integer> i : n.primeFactor.entrySet())
primeFactor.computeIfPresent(i.getKey(), (k, v) -> Math.min(v, i.getValue()));
}
/**
* gcd(n, m)を返します。
*
* @param n gcdを取りたい値
* @param m gcdを取りたい値
* @return gcd(n, m)
*/
public static PrimeFactor gcd(final PrimeFactor n, final PrimeFactor m) {
final Map<Prime, Integer> ret = new HashMap<>(n.primeFactor);
for (final Entry<Prime, Integer> i : m.primeFactor.entrySet())
ret.computeIfPresent(i.getKey(), (k, v) -> Math.min(v, i.getValue()));
return new PrimeFactor(ret);
}
/**
* nとlcmを取った値を保持します。
*
* @param n lcmを取りたい値
*/
public void lcm(final PrimeFactor n) {
for (final Entry<Prime, Integer> i : n.primeFactor.entrySet())
primeFactor.merge(i.getKey(), i.getValue(), (v1, v2) -> Math.max(v1, v2));
}
/**
* lcm(n, m)を返します。
*
* @param n lcmを取りたい値
* @param m lcmを取りたい値
* @return lcm(n, m)
*/
public static PrimeFactor lcm(final PrimeFactor n, final PrimeFactor m) {
final Map<Prime, Integer> ret = new HashMap<>(n.primeFactor);
for (final Entry<Prime, Integer> i : m.primeFactor.entrySet())
ret.merge(i.getKey(), i.getValue(), (v1, v2) -> Math.max(v1, v2));
return new PrimeFactor(ret);
}
private static int pow(final int p, int n) {
int ans = 1;
for (int mul = p; n > 0; n >>= 1, mul *= mul) if ((n & 1) != 0) ans *= mul;
return ans;
}
private static long pow(final long p, long n) {
long ans = 1;
for (long mul = p; n > 0; n >>= 1, mul *= mul) if ((n & 1) != 0) ans *= mul;
return ans;
}
public BigInteger getValue() {
BigInteger ret = BigInteger.ONE;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret = ret.multiply(new BigInteger(i.getKey().toString()).pow(i.getValue()));
return ret;
}
@Override
public int intValue() {
int ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet()) ret *= pow(i.getKey().prime, i.getValue());
return ret;
}
@Override
public long longValue() {
long ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret *= pow((long) i.getKey().prime, i.getValue());
return ret;
}
@Override
public float floatValue() {
float ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret *= Math.pow(i.getKey().prime, i.getValue());
return ret;
}
@Override
public double doubleValue() {
long ret = 1;
for (final Entry<Prime, Integer> i : primeFactor.entrySet())
ret *= Math.pow(i.getKey().prime, i.getValue());
return ret;
}
@Override
public boolean equals(final Object o) {
return o instanceof PrimeFactor ? ((PrimeFactor) o).primeFactor.equals(primeFactor) : false;
}
@Override
public int hashCode() {
return primeFactor.hashCode();
}
@Override
public String toString() {
return primeFactor.toString();
}
}
/**
* 素数を渡すためのクラスです。<br>
* 中身が確実に素数であることを保証するときに使ってください。
*
* @author 31536000
*
*/
public static class Prime extends Number {
private static final long serialVersionUID = 8216169308184181643L;
public final int prime;
/**
* 素数を設定します。
*
* @param prime 素数
* @throws IllegalArgumentException 素数以外を渡した時
*/
public Prime(final int prime) {
if (!isPrime(prime)) throw new IllegalArgumentException(prime + " is not prime");
this.prime = prime;
}
private Prime(final int prime, final boolean none) {
this.prime = prime;
}
private static final int bases[] = { 15591, 2018, 166, 7429, 8064, 16045, 10503, 4399, 1949, 1295, 2776, 3620,
560, 3128, 5212, 2657, 2300, 2021, 4652, 1471, 9336, 4018, 2398, 20462, 10277, 8028, 2213, 6219, 620,
3763, 4852, 5012, 3185, 1333, 6227, 5298, 1074, 2391, 5113, 7061, 803, 1269, 3875, 422, 751, 580, 4729,
10239, 746, 2951, 556, 2206, 3778, 481, 1522, 3476, 481, 2487, 3266, 5633, 488, 3373, 6441, 3344, 17,
15105, 1490, 4154, 2036, 1882, 1813, 467, 3307, 14042, 6371, 658, 1005, 903, 737, 1887, 7447, 1888,
2848, 1784, 7559, 3400, 951, 13969, 4304, 177, 41, 19875, 3110, 13221, 8726, 571, 7043, 6943, 1199, 352,
6435, 165, 1169, 3315, 978, 233, 3003, 2562, 2994, 10587, 10030, 2377, 1902, 5354, 4447, 1555, 263,
27027, 2283, 305, 669, 1912, 601, 6186, 429, 1930, 14873, 1784, 1661, 524, 3577, 236, 2360, 6146, 2850,
55637, 1753, 4178, 8466, 222, 2579, 2743, 2031, 2226, 2276, 374, 2132, 813, 23788, 1610, 4422, 5159,
1725, 3597, 3366, 14336, 579, 165, 1375, 10018, 12616, 9816, 1371, 536, 1867, 10864, 857, 2206, 5788,
434, 8085, 17618, 727, 3639, 1595, 4944, 2129, 2029, 8195, 8344, 6232, 9183, 8126, 1870, 3296, 7455,
8947, 25017, 541, 19115, 368, 566, 5674, 411, 522, 1027, 8215, 2050, 6544, 10049, 614, 774, 2333, 3007,
35201, 4706, 1152, 1785, 1028, 1540, 3743, 493, 4474, 2521, 26845, 8354, 864, 18915, 5465, 2447, 42,
4511, 1660, 166, 1249, 6259, 2553, 304, 272, 7286, 73, 6554, 899, 2816, 5197, 13330, 7054, 2818, 3199,
811, 922, 350, 7514, 4452, 3449, 2663, 4708, 418, 1621, 1171, 3471, 88, 11345, 412, 1559, 194 };
private static final byte wheel[] = { 10, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4,
2, 4, 8, 6, 4, 6, 2, 4, 6, 2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2, 10, 2 };
private static boolean isSPRP(final int n, long a) {
int d = n - 1, s = 0;
while ((d & 1) == 0) {
++s;
d >>= 1;
}
long cur = 1, pw = d;
do {
if ((pw & 1) != 0) cur = cur * a % n;
a = a * a % n;
pw >>= 1;
} while (pw != 0);
if (cur == 1) return true;
for (int r = 0; r < s; ++r) {
if (cur == n - 1) return true;
cur = cur * cur % n;
}
return false;
}
/**
* 与えられた値が素数か否かを判定します。<br>
* この実装はhttp://ceur-ws.org/Vol-1326/020-Forisek.pdfに基づきます。
*
* @param x 判定したい値
* @return xが素数ならtrue
*/
public static boolean isPrime(final int x) {
if (x == 2 || x == 3 || x == 5 || x == 7) return true;
if ((x & 1) == 0 || x % 3 == 0 || x % 5 == 0 || x % 7 == 0) return false;
return checkPrime(x);
}
private static boolean checkPrime(final int x) {
if (x < 121) return x > 1;
long h = x;
h = (h >> 16 ^ h) * 0x45d9f3b;
h = (h >> 16 ^ h) * 0x45d9f3b;
h = (h >> 16 ^ h) & 0xFF;
return isSPRP(x, bases[(int) h]);
}
/**
* 区間における素数を列挙します。<br>
* この実装はエラトステネスの篩に基づきます。
*
* @param n 素数を求める範囲
* @return 1以上n以下の素数を保持する区間素数
*/
public static SegmentPrime getSegmentPrime(final int n) {
final Prime[] divisor = new Prime[n - 1];
final int sqrt = (int) Math.sqrt(n) + 1;
for (int i = 0; i < sqrt; ++i) {
if (divisor[i] != null) continue;
final int p = i + 2;
divisor[i] = new Prime(p, true);
for (int j = p * p - 2; j < divisor.length; j += p) divisor[j] = divisor[i];
}
for (int i = sqrt; i < divisor.length; ++i) if (divisor[i] == null) divisor[i] = new Prime(i + 2, true);
return new SegmentPrime(divisor, 2);
}
/**
* 与えられた値を素因数分解した結果を返します。
*
* @param x 素因数分解する値
* @return 素因数分解した結果
*/
public static PrimeFactor getPrimeFactor(int x) {
if (x <= 0) throw new IllegalArgumentException("non positive number: " + x);
final Map<Prime, Integer> ret = new TreeMap<>((l, r) -> Integer.compare(l.prime, r.prime));
int c;
if ((x & 1) == 0) {
c = 1;
for (x >>= 1; (x & 1) == 0; x >>= 1) ++c;
ret.put(new Prime(2, false), c);
}
if (x % 3 == 0) {
c = 1;
for (x /= 3; x % 3 == 0; x /= 3) ++c;
ret.put(new Prime(3, false), c);
}
if (x % 5 == 0) {
c = 1;
for (x /= 5; x % 5 == 0; x /= 5) ++c;
ret.put(new Prime(5, false), c);
}
if (x % 7 == 0) {
c = 1;
for (x /= 7; x % 7 == 0; x /= 7) ++c;
ret.put(new Prime(7, false), c);
}
if (x < 100000000) { // Wheel Factorization
for (int i = 11, j = 0; i * i <= x; i += wheel[++j % wheel.length]) {
while (x % i == 0) {
x /= i;
ret.compute(new Prime(i, false), (k, v) -> v == null ? 1 : v + 1);
}
}
if (x != 1) ret.put(new Prime(x, false), 1);
} else {
int p, count;
while (x != 1) { // 素因数分解が終わってる
for (p = x; !checkPrime(p); p = pollardRho(p, 1));
final Prime prime = new Prime(p, false);
count = 1;
for (x /= p; x % p == 0; x /= p) ++count;
ret.put(prime, count);
}
}
return new PrimeFactor(ret);
}
private static int gcd(int n, int m) {
while (n != 0) if ((m %= n) != 0) n %= m;
else return n;
return m;
}
private static int pollardRho(final int x, int c) {
int n = 2, m = 2, d = 1, next = 4, i = 1;
do {
if (++i == next) {
m = n;
next <<= 1;
}
if ((n = (int) (((long) n * n + c) % x)) == m) return pollardRho(x, ++c); // 失敗したので
} while ((d = gcd(Math.abs(n - m), x)) == 1);// dは約数の一つ
return d;
}
@Override
public int intValue() {
return prime;
}
@Override
public long longValue() {
return prime;
}
@Override
public float floatValue() {
return prime;
}
@Override
public double doubleValue() {
return prime;
}
@Override
public boolean equals(final Object o) {
return o instanceof Prime ? ((Prime) o).prime == prime : false;
}
@Override
public int hashCode() {
return prime;
}
@Override
public String toString() {
return String.valueOf(prime);
}
}
public static class AbstractArray<T> extends AbstractList<T> implements RandomAccess {
private final Object[] array;
public AbstractArray(final int size) {
array = new Object[size];
}
public AbstractArray(final T[] array) {
this(array.length);
System.arraycopy(array, 0, this.array, 0, array.length);
}
@Override
public T set(final int index, final T element) {
final T ret = get(index);
array[index] = element;
return ret;
}
@Override
public T get(final int index) {
@SuppressWarnings("unchecked")
final T ret = (T) array[index];
return ret;
}
public Object[] get() {
return array;
}
public T[] get(final T[] array) {
if (array.length < this.array.length) {
@SuppressWarnings("unchecked")
final T[] ret = (T[]) Arrays.copyOfRange(this.array, 0, this.array.length, array.getClass());
return ret;
}
System.arraycopy(this.array, 0, array, 0, this.array.length);
return array;
}
@Override
public int size() {
return array.length;
}
public int length() {
return size();
}
@Override
public int hashCode() {
return Arrays.hashCode(array);
}
private class Iter implements Iterator<T> {
private int index;
private Iter() {
index = 0;
}
@Override
public boolean hasNext() {
return index < array.length;
}
@Override
public T next() {
return get(index++);
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public Iterator<T> iterator() {
return new Iter();
}
}
public static class Array<T> extends AbstractArray<T> implements Serializable {
private static final long serialVersionUID = 2749604433067098063L;
public Array(final int size) {
super(size);
}
public Array(final T[] array) {
super(array);
}
public T front() {
return get(0);
}
public T back() {
return get(size() - 1);
}
}
/**
* 要素とそのindexを管理するクラスです。
*
* @author 31536000
*
* @param <E> 保持する要素
*/
public static class Enumerate<E> {
public final E value;
public final int index;
/**
* 要素とそのindexを渡します。<br>
* indexは必ずしも元の配列またはコレクションのindexと一致する必要はありませんが、一致する値を返すことが推奨されます。
*
* @param value
* @param index
*/
public Enumerate(final E value, final int index) {
this.value = value;
this.index = index;
}
/**
* 要素を返します。
*
* @return 要素
*/
public E getValue() { return value; }
/**
* indexを返します。
*
* @return index
*/
public int getIndex() { return index; }
@Override
public boolean equals(final Object o) {
if (o instanceof Enumerate)
return ((Enumerate<?>) o).getValue().equals(value) && ((Enumerate<?>) o).getIndex() == index;
return false;
}
@Override
public int hashCode() {
return value.hashCode() ^ index;
}
@Override
public String toString() {
return "{" + value.toString() + ", " + index + "}";
}
}
/**
* 要素とそのindexを効率的に取得する関数を提供します。
*
* @author 31536000
*
*/
public static class Enumeration {
private static class IteratorArray<E> implements Iterator<Enumerate<E>> {
private final E[] array;
private final int start;
private int index;
public IteratorArray(final E[] array, final int index) {
this.array = array;
start = index;
this.index = 0;
}
@Override
public boolean hasNext() {
return index < array.length;
}
@Override
public Enumerate<E> next() {
final Enumerate<E> ret = new Enumerate<>(array[index], index++ + start);
return ret;
}
}
private static class IteratorCollection<E> implements Iterator<Enumerate<E>> {
private final Iterator<E> iter;
private int start;
public IteratorCollection(final Iterator<E> iter, final int index) {
this.iter = iter;
start = index;
}
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public Enumerate<E> next() {
final Enumerate<E> ret = new Enumerate<>(iter.next(), start++);
return ret;
}
}
/**
* 配列の各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> 配列の型
* @param array 配列
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final E[] array) {
return enumerate(array, 0);
}
/**
* 配列の各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> 配列の型
* @param array 配列
* @param start 添字の初期値、この値だけindexが足されたものが返る
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final E[] array, final int start) {
if (array == null) throw new NullPointerException("array is null");
return new IteratorArray<>(array, start);
}
/**
* Iteratorの各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> Iteratorの型
* @param iter Iterator
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final Iterator<E> iter) {
return enumerate(iter, 0);
}
/**
* Iteratorの各要素とそのindexを順に返すIteratorを生成します。
*
* @param <E> Iteratorの型
* @param iter Iterator
* @param start 添字の初期値、この値だけindexが足されたものが返る
* @return Enumerate<E>のIterator
*/
public static <E> Iterator<Enumerate<E>> enumerate(final Iterator<E> iter, final int start) {
if (iter == null) throw new NullPointerException("iterator is null");
return new IteratorCollection<>(iter, start);
}
}
/**
* このクラスは配列に対する様々な操作を提供します。
* @author 31536000
*
*/
public static class ArrayUtility {
private ArrayUtility() {
throw new AssertionError();
}
/**
* initを用いて配列を生成します。配列のi番目の要素はinit.applyAsInt(i)になります。
* @complexity O(length)
* @param length 配列の長さ
* @param init 配列の初期値を決める関数
* @return 配列
*/
public static int[] create(int length, java.util.function.IntUnaryOperator init) {
int[] ret = new int[length];
for (int i = 0; i < length; ++i) ret[i] = init.applyAsInt(i);
return ret;
}
/**
* initを用いて配列を生成します。配列のi番目の要素はinit.applyAsInt(i)になります。
* @complexity O(length)
* @param length 配列の長さ
* @param init 配列の初期値を決める関数
* @return 配列
*/
public static long[] create(int length, java.util.function.LongUnaryOperator init) {
long[] ret = new long[length];
for (int i = 0; i < length; ++i) ret[i] = init.applyAsLong(i);
return ret;
}
/**
* initを用いて配列を生成します。配列のi番目の要素はinit.applyAsInt(i)になります。
* @complexity O(length)
* @param length 配列の長さ
* @param init 配列の初期値を決める関数
* @return 配列
*/
public static double[] create(int length, java.util.function.DoubleUnaryOperator init) {
double[] ret = new double[length];
for (int i = 0; i < length; ++i) ret[i] = init.applyAsDouble(i);
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static boolean[] add(boolean[] array, boolean element) {
if (array == null) {
boolean[] ret = { element };
return ret;
}
boolean[] ret = new boolean[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static byte[] add(byte[] array, byte element) {
if (array == null) {
byte[] ret = { element };
return ret;
}
byte[] ret = new byte[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static short[] add(short[] array, short element) {
if (array == null) {
short[] ret = { element };
return ret;
}
short[] ret = new short[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static int[] add(int[] array, int element) {
if (array == null) {
int[] ret = { element };
return ret;
}
int[] ret = new int[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static long[] add(long[] array, long element) {
if (array == null) {
long[] ret = { element };
return ret;
}
long[] ret = new long[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static float[] add(float[] array, float element) {
if (array == null) {
float[] ret = { element };
return ret;
}
float[] ret = new float[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static double[] add(double[] array, double element) {
if (array == null) {
double[] ret = { element };
return ret;
}
double[] ret = new double[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static char[] add(char[] array, char element) {
if (array == null) {
char[] ret = { element };
return ret;
}
char[] ret = new char[array.length + 1];
System.arraycopy(array, 0, ret, 0, array.length);
ret[array.length] = element;
return ret;
}
/**
* 配列の最後に要素を一つ増やした新しい配列を返します。
* @complexity O(array.length)
* @param array 元の配列
* @param element 加えたい要素
* @return 配列の後ろに要素を加えた配列
*/
public static <T> T[] add(T[] array, T element) {
if (array == null) { return addAll(array, element); }
@SuppressWarnings("unchecked")
T[] ret = (T[]) java.util.Arrays.copyOfRange(array, 0, array.length + 1, array.getClass());
ret[array.length] = element;
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static boolean[] addAll(boolean[] array, boolean... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
boolean[] ret = new boolean[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static byte[] addAll(byte[] array, byte... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
byte[] ret = new byte[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static short[] addAll(short[] array, short... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
short[] ret = new short[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static int[] addAll(int[] array, int... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
int[] ret = new int[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static long[] addAll(long[] array, long... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
long[] ret = new long[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static float[] addAll(float[] array, float... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
float[] ret = new float[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static double[] addAll(double[] array, double... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
double[] ret = new double[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
public static char[] addAll(char[] array, char... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
char[] ret = new char[array.length + array2.length];
System.arraycopy(array, 0, ret, 0, array.length);
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 2つの配列を結合した新しい配列を返します。
* @complexity O(array.length + array2.length)
* @param array 左側の配列
* @param array2 右側の配列
* @return 2つの配列を結合した配列
*/
@SafeVarargs
public static <T> T[] addAll(T[] array, T... array2) {
if (array == null) return array2 == null ? null : array2.clone();
if (array2 == null) return array.clone();
@SuppressWarnings("unchecked")
T[] ret = (T[]) java.util.Arrays.copyOfRange(array, 0, array.length + array2.length, array.getClass());
System.arraycopy(array2, 0, ret, array.length, array2.length);
return ret;
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(boolean[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(boolean[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(boolean[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(byte[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(byte[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(byte[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(short[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(short[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(short[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(int[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(int[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(int[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(long[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(long[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(long[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(float[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(float[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(float[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(double[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(double[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(double[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(char[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(char[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(char[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を逆順にします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void reverse(Object[] array) {
if (array != null)
for (int i = 0, l = array.length + 1 >> 1; i < l; ++i) swap(array, i, array.length - 1 - i);
}
/**
* 配列を逆順にします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex 逆順にする左閉区間
* @param toIndex 逆順にする右開区間
*/
public static void reverse(Object[] array, int fromIndex, int toIndex) {
for (--toIndex; fromIndex < toIndex; ++fromIndex, --toIndex) swap(array, fromIndex, toIndex);
}
/**
* 配列を逆順にします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range 逆順にする区間
*/
public static void reverse(Object[] array, IntRange range) {
reverse(array, range.getClosedLower(), range.getOpenUpper());
}
private static java.util.Random rnd;
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(boolean[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(boolean[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(boolean[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(boolean[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(boolean[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(boolean[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(byte[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(byte[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(byte[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(byte[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(byte[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(byte[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(short[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(short[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(short[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(short[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(short[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(short[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(int[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(int[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(int[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(int[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(int[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(int[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(long[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(long[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(long[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(long[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(long[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(long[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(float[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(float[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(float[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(float[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(float[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(float[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(double[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(double[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(double[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(double[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(double[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(double[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(char[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(char[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(char[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(char[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(char[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(char[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
*/
public static void shuffle(Object[] array) {
shuffle(array, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
*/
public static void shuffle(Object[] array, int fromIndex, int toIndex) {
shuffle(array, fromIndex, toIndex, rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
*/
public static void shuffle(Object[] array, IntRange range) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(),
rnd == null ? rnd = new java.util.Random() : rnd);
}
/**
* 配列をシャッフルします。
* @complexity O(array.length)
* @param array 元の配列
* @param random 乱数
*/
public static void shuffle(Object[] array, java.util.Random random) {
if (array != null) for (int i = array.length - 1; i > 0; --i) swap(array, i, random.nextInt(i + 1));
}
/**
* 配列をシャッフルします。
* @complexity O(toIndex-fromIndex)
* @param array 元の配列
* @param fromIndex シャッフルする左閉区間
* @param toIndex シャッフルする右開区間
* @param random 乱数
*/
public static void shuffle(Object[] array, int fromIndex, int toIndex, java.util.Random random) {
if (array != null)
for (int i = toIndex - 1; i > fromIndex; --i) swap(array, i, random.nextInt(i - fromIndex) + fromIndex);
}
/**
* 配列をシャッフルします。
* @complexity O(range.getDistance())
* @param array 元の配列
* @param range シャッフルする区間
* @param random 乱数
*/
public static void shuffle(Object[] array, IntRange range, java.util.Random random) {
shuffle(array, range.getClosedLower(), range.getOpenUpper(), random);
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static boolean[] getArray(int size, boolean value) {
boolean[] ret = new boolean[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static byte[] getArray(int size, byte value) {
byte[] ret = new byte[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static short[] getArray(int size, short value) {
short[] ret = new short[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static int[] getArray(int size, int value) {
int[] ret = new int[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static long[] getArray(int size, long value) {
long[] ret = new long[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static float[] getArray(int size, float value) {
float[] ret = new float[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static double[] getArray(int size, double value) {
double[] ret = new double[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* 指定した長さと初期値を持つ配列を生成します。
* @complexity O(size)
* @param size 配列の長さ
* @param value 配列の初期値
* @return 生成された配列
*/
public static char[] getArray(int size, char value) {
char[] ret = new char[size];
java.util.Arrays.fill(ret, value);
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Boolean[] toObject(boolean[] array) {
if (array == null) return null;
Boolean[] ret = new Boolean[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Byte[] toObject(byte[] array) {
if (array == null) return null;
Byte[] ret = new Byte[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Short[] toObject(short[] array) {
if (array == null) return null;
Short[] ret = new Short[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Integer[] toObject(int[] array) {
if (array == null) return null;
Integer[] ret = new Integer[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Long[] toObject(long[] array) {
if (array == null) return null;
Long[] ret = new Long[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Float[] toObject(float[] array) {
if (array == null) return null;
Float[] ret = new Float[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Double[] toObject(double[] array) {
if (array == null) return null;
Double[] ret = new Double[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* プリミティブ型の配列と中身が対応するオブジェクト型の配列を生成します。
* @complexity O(array.length)
* @param array プリミティブ型の配列
* @return オブジェクト型の配列
*/
public static Character[] toObject(char[] array) {
if (array == null) return null;
Character[] ret = new Character[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static boolean[] toPrimitive(Boolean[] array) {
if (array == null) return null;
boolean[] ret = new boolean[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull) {
if (array == null) return null;
boolean[] ret = new boolean[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static byte[] toPrimitive(Byte[] array) {
if (array == null) return null;
byte[] ret = new byte[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static byte[] toPrimitive(Byte[] array, byte valueForNull) {
if (array == null) return null;
byte[] ret = new byte[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static short[] toPrimitive(Short[] array) {
if (array == null) return null;
short[] ret = new short[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static short[] toPrimitive(Short[] array, short valueForNull) {
if (array == null) return null;
short[] ret = new short[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static int[] toPrimitive(Integer[] array) {
if (array == null) return null;
int[] ret = new int[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static int[] toPrimitive(Integer[] array, int valueForNull) {
if (array == null) return null;
int[] ret = new int[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static long[] toPrimitive(Long[] array) {
if (array == null) return null;
long[] ret = new long[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static long[] toPrimitive(Long[] array, long valueForNull) {
if (array == null) return null;
long[] ret = new long[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static float[] toPrimitive(Float[] array) {
if (array == null) return null;
float[] ret = new float[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static float[] toPrimitive(Float[] array, float valueForNull) {
if (array == null) return null;
float[] ret = new float[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static double[] toPrimitive(Double[] array) {
if (array == null) return null;
double[] ret = new double[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static double[] toPrimitive(Double[] array, double valueForNull) {
if (array == null) return null;
double[] ret = new double[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @return プリミティブ型の配列
* @throws NullPointerException 配列の要素にnullが含まれていた場合
*/
public static char[] toPrimitive(Character[] array) {
if (array == null) return null;
char[] ret = new char[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i];
return ret;
}
/**
* オブジェクト型の配列と中身が対応するプリミティブ型の配列を生成します。
* @complexity O(array.length)
* @param array オブジェクト型の配列
* @param valueForNull nullの値に対応させる値
* @return プリミティブ型の配列
*/
public static char[] toPrimitive(Character[] array, char valueForNull) {
if (array == null) return null;
char[] ret = new char[array.length];
for (int i = 0; i < ret.length; ++i) ret[i] = array[i] == null ? valueForNull : array[i];
return ret;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最小値
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> T min(T[] array, java.util.Comparator<T> comparator) {
if (array == null || array.length == 0) return null;
T min = array[0];
for (int i = 1; i < array.length; ++i) if (comparator.compare(min, array[i]) > 0) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static <T extends Comparable<T>> T min(T[] array) {
return min(array, java.util.Comparator.naturalOrder());
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static byte min(byte[] array) {
byte min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static short min(short[] array) {
short min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static int min(int[] array) {
int min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static long min(long[] array) {
long min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static float min(float[] array) {
float min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
*/
public static double min(double[] array) {
double min = array[0];
for (int i = 1; i < array.length; ++i) if (min > array[i]) min = array[i];
return min;
}
/**
* 配列の最小要素を返します。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最小値
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> T max(T[] array, java.util.Comparator<T> comparator) {
if (array == null || array.length == 0) return null;
T max = array[0];
for (int i = 1; i < array.length; ++i) if (comparator.compare(max, array[i]) < 0) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
*/
public static <T extends Comparable<T>> T max(T[] array) {
return max(array, java.util.Comparator.naturalOrder());
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static byte max(byte[] array) {
byte max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static short max(short[] array) {
short max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static int max(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static long max(long[] array) {
long max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static float max(float[] array) {
float max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列の最大要素を返します。
* @complexity O(array.length)
* @param array 配列
* @return 配列がnullか要素数が0の場合はnull、それ以外の場合は配列の最大値
* @throws NullPointerException arrayがnullの場合
*/
public static double max(double[] array) {
double max = array[0];
for (int i = 1; i < array.length; ++i) if (max < array[i]) max = array[i];
return max;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(boolean[] array, int n, int m) {
boolean swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(byte[] array, int n, int m) {
byte swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(short[] array, int n, int m) {
short swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(int[] array, int n, int m) {
int swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(long[] array, int n, int m) {
long swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(float[] array, int n, int m) {
float swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(double[] array, int n, int m) {
double swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(char[] array, int n, int m) {
char swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列のn番目とm番目を入れ替えます。
* @complexity O(1)
* @param array 配列
* @param n 中身をswapするindex
* @param m 中身をswapするindex
* @throws ArrayIndexOutOfBoundsException n, m < 0 || array.length <= n, mのとき
* @throws NullPointerException arrayがnullの場合
*/
public static void swap(Object[] array, int n, int m) {
Object swap = array[n];
array[n] = array[m];
array[m] = swap;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static <T extends Comparable<T>> boolean nextPermutation(T[] array) {
return nextPermutation(array, java.util.Comparator.naturalOrder());
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列を書き換えたならばtrue
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> boolean nextPermutation(T[] array, java.util.Comparator<T> comparator) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (comparator.compare(array[change], array[change + 1]) < 0) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0)
if (comparator.compare(array[change], array[mid = min + halfDiff]) < 0) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(byte[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(short[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(int[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(long[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(float[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(double[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で次の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean nextPermutation(char[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] < array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] < array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static <T extends Comparable<T>> boolean prevPermutation(T[] array) {
return prevPermutation(array, java.util.Comparator.naturalOrder());
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @param comparator 比較関数
* @return 配列を書き換えたならばtrue
* @throws NullPointerException comparatorがnullの場合
*/
public static <T> boolean prevPermutation(T[] array, java.util.Comparator<T> comparator) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (comparator.compare(array[change], array[change + 1]) > 0) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0)
if (comparator.compare(array[change], array[mid = min + halfDiff]) > 0) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(byte[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(short[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(int[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(long[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(float[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(double[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列を辞書式順序で前の配列に書き換えます。そのような配列が無い場合、何もしません。
* @complexity O(array.length)
* @param array 配列
* @return 配列を書き換えたならばtrue
*/
public static boolean prevPermutation(char[] array) {
if (array == null) return false;
for (int change = array.length - 2; change >= 0; --change) {
if (array[change] > array[change + 1]) {
int min = change, max = array.length, halfDiff, mid;
while ((halfDiff = max - min >> 1) != 0) if (array[change] > array[mid = min + halfDiff]) min = mid;
else max = mid;
swap(array, change, min);
for (min = change + 1, max = array.length - 1; min < max; ++min, --max) swap(array, min, max);
return true;
}
}
return false;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static <T> T[] map(T[] array, java.util.function.UnaryOperator<T> map) {
T[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.apply(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static int[] map(int[] array, java.util.function.IntUnaryOperator map) {
int[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.applyAsInt(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static long[] map(long[] array, java.util.function.LongUnaryOperator map) {
long[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.applyAsLong(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @return 配列の各要素にmapを適用した配列
*/
public static double[] map(double[] array, java.util.function.DoubleUnaryOperator map) {
double[] ret = java.util.Arrays.copyOf(array, array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.applyAsDouble(ret[i]);
return ret;
}
/**
* 配列の各要素を与えられた関数に適用した配列を生成します。
* @complexity O(array.length)
* @param array 配列
* @param map 各要素に適用する関数
* @param generator 新しい配列を生成するための関数、U::newを引数に取る
* @return 配列の各要素にmapを適用した配列
*/
public static <T, U> U[] map(T[] array, java.util.function.Function<T, U> map,
java.util.function.IntFunction<U[]> generator) {
U[] ret = generator.apply(array.length);
for (int i = 0; i < ret.length; ++i) ret[i] = map.apply(array[i]);
return ret;
}
/**
* 配列を昇順にソートします。
* @complexity O(array.length)
* @param array 配列
*/
public static void sort(final byte[] array) {
if (array.length < 128) {
for (int i = 0, j; i < array.length; ++i) {
byte tmp = array[i], tmp2;
for (j = i; j > 0 && (tmp2 = array[j - 1]) > tmp; --j) array[j] = tmp2;
array[j] = tmp;
}
return;
}
int[] count = new int[256];
for (byte i : array) ++count[i & 0xff];
for (int i = 0, j = 0; j < count.length; ++j) java.util.Arrays.fill(array, i, i += count[j], (byte) j);
}
/**
* 配列を昇順にソートします。
* @complexity O(toIndex-fromIndex)
* @param array 配列
*/
public static void sort(final byte[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 128) {
for (int i = fromIndex, j; i < toIndex; ++i) {
byte tmp = array[i], tmp2;
for (j = i; j > fromIndex && (tmp2 = array[j - 1]) > tmp; --j) array[j] = tmp2;
array[j] = tmp;
}
return;
}
int[] count = new int[256];
for (int i = fromIndex; i < toIndex; ++i) ++count[array[i] & 0xff];
for (int i = fromIndex, j = 0; j < count.length; ++j)
java.util.Arrays.fill(array, i, i += count[j], (byte) j);
}
/**
* 配列を昇順にソートします。
* @complexity O(range.getDistance())
* @param array 配列
*/
public static void sort(final byte[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
/**
* 配列を昇順にソートします。
* @complexity Nを配列長として O(N log N)
* @param array 配列
*/
public static void sort(final short[] array) {
if (array.length < 1024) java.util.Arrays.sort(array);
else sort(array, 0, array.length, 0, new short[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=toIndex-fromIndex として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final short[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 1024) java.util.Arrays.sort(array, fromIndex, toIndex);
else sort(array, fromIndex, toIndex, 0, new short[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=range.getDistance() として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final short[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
private static final void sort(short[] a, final int from, final int to, final int l, final short[] bucket) {
final int BUCKET_SIZE = 256;
final int SHORT_RECURSION = 2;
final int MASK = 0xff;
final int shift = l << 3;
final int[] cnt = new int[BUCKET_SIZE + 1];
final int[] put = new int[BUCKET_SIZE];
for (int i = from; i < to; i++) ++cnt[(a[i] >>> shift & MASK) + 1];
for (int i = 0; i < BUCKET_SIZE; i++) cnt[i + 1] += cnt[i];
for (int i = from; i < to; i++) {
int bi = a[i] >>> shift & MASK;
bucket[cnt[bi] + put[bi]++] = a[i];
}
for (int i = BUCKET_SIZE - 1, idx = from; i >= 0; i--) {
int begin = cnt[i];
int len = cnt[i + 1] - begin;
System.arraycopy(bucket, begin, a, idx, len);
idx += len;
}
final int nxtL = l + 1;
if (nxtL < SHORT_RECURSION) {
sort(a, from, to, nxtL, bucket);
if (l == 0) {
int lft, rgt;
lft = from - 1;
rgt = to;
while (rgt - lft > 1) {
int mid = lft + rgt >> 1;
if (a[mid] < 0) lft = mid;
else rgt = mid;
}
reverse(a, from, rgt);
reverse(a, rgt, to);
}
}
}
/**
* 配列を昇順にソートします。
* @complexity Nを配列長として O(N log N)
* @param array 配列
*/
public static void sort(final int[] array) {
if (array.length < 1024) java.util.Arrays.sort(array);
else sort(array, 0, array.length, 0, new int[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=toIndex-fromIndex として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final int[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 1024) java.util.Arrays.sort(array, fromIndex, toIndex);
else sort(array, fromIndex, toIndex, 0, new int[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=range.getDistance() として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final int[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
private static final void sort(int[] a, final int from, final int to, final int l, final int[] bucket) {
final int BUCKET_SIZE = 256;
final int INT_RECURSION = 4;
final int MASK = 0xff;
final int shift = l << 3;
final int[] cnt = new int[BUCKET_SIZE + 1];
final int[] put = new int[BUCKET_SIZE];
for (int i = from; i < to; i++) ++cnt[(a[i] >>> shift & MASK) + 1];
for (int i = 0; i < BUCKET_SIZE; i++) cnt[i + 1] += cnt[i];
for (int i = from; i < to; i++) {
int bi = a[i] >>> shift & MASK;
bucket[cnt[bi] + put[bi]++] = a[i];
}
for (int i = BUCKET_SIZE - 1, idx = from; i >= 0; i--) {
int begin = cnt[i];
int len = cnt[i + 1] - begin;
System.arraycopy(bucket, begin, a, idx, len);
idx += len;
}
final int nxtL = l + 1;
if (nxtL < INT_RECURSION) {
sort(a, from, to, nxtL, bucket);
if (l == 0) {
int lft, rgt;
lft = from - 1;
rgt = to;
while (rgt - lft > 1) {
int mid = lft + rgt >> 1;
if (a[mid] < 0) lft = mid;
else rgt = mid;
}
reverse(a, from, rgt);
reverse(a, rgt, to);
}
}
}
/**
* 配列を昇順にソートします。
* @complexity Nを配列長として O(N log N)
* @param array 配列
*/
public static void sort(final long[] array) {
if (array.length < 1024) java.util.Arrays.sort(array);
else sort(array, 0, array.length, 0, new long[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=toIndex-fromIndex として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final long[] array, int fromIndex, int toIndex) {
if (toIndex - fromIndex < 1024) java.util.Arrays.sort(array, fromIndex, toIndex);
else sort(array, fromIndex, toIndex, 0, new long[array.length]);
}
/**
* 配列を昇順にソートします。
* @complexity N=range.getDistance() として O(N log N)
* @param array 元の配列
* @param fromIndex ソートする左閉区間
* @param toIndex ソートする右開区間
*/
public static void sort(final long[] array, IntRange range) {
sort(array, range.getClosedLower(), range.getOpenUpper());
}
private static final void sort(long[] a, final int from, final int to, final int l, final long[] bucket) {
final int BUCKET_SIZE = 256;
final int LONG_RECURSION = 8;
final int MASK = 0xff;
final int shift = l << 3;
final int[] cnt = new int[BUCKET_SIZE + 1];
final int[] put = new int[BUCKET_SIZE];
for (int i = from; i < to; i++) ++cnt[(int) ((a[i] >>> shift & MASK) + 1)];
for (int i = 0; i < BUCKET_SIZE; i++) cnt[i + 1] += cnt[i];
for (int i = from; i < to; i++) {
int bi = (int) (a[i] >>> shift & MASK);
bucket[cnt[bi] + put[bi]++] = a[i];
}
for (int i = BUCKET_SIZE - 1, idx = from; i >= 0; i--) {
int begin = cnt[i];
int len = cnt[i + 1] - begin;
System.arraycopy(bucket, begin, a, idx, len);
idx += len;
}
final int nxtL = l + 1;
if (nxtL < LONG_RECURSION) {
sort(a, from, to, nxtL, bucket);
if (l == 0) {
int lft, rgt;
lft = from - 1;
rgt = to;
while (rgt - lft > 1) {
int mid = lft + rgt >> 1;
if (a[mid] < 0) lft = mid;
else rgt = mid;
}
reverse(a, from, rgt);
reverse(a, rgt, to);
}
}
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @return arrayを座標圧縮した配列
*/
public static int[] compress(int[] array) {
int[] ret = new int[array.length];
int[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (copy[len - 1] != copy[j]) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
int comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @return arrayを座標圧縮した配列
*/
public static int[] compress(long[] array) {
int[] ret = new int[array.length];
long[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (copy[len - 1] != copy[j]) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
long comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @return arrayを座標圧縮した配列
*/
public static <T extends Comparable<T>> int[] compress(T[] array) {
int[] ret = new int[array.length];
T[] copy = java.util.Arrays.copyOf(array, array.length);
java.util.Arrays.sort(copy);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (copy[len - 1] != copy[j]) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
T comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid].compareTo(comp) <= 0) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]<array[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、array[i]==array[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nを配列長として O(N log N)
* @param array 座標圧縮を行う配列
* @param comparator 比較関数
* @return arrayを座標圧縮した配列
*/
public static <T> int[] compress(T[] array, java.util.Comparator<T> comparator) {
int[] ret = new int[array.length];
T[] copy = java.util.Arrays.copyOf(array, array.length);
java.util.Arrays.sort(copy, comparator);
int len = 1;
for (int j = 1; j < array.length; ++j) {
if (!copy[len - 1].equals(copy[j])) copy[len++] = copy[j];
}
for (int i = 0; i < array.length; ++i) {
int min = 0, max = len;
T comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (comparator.compare(copy[mid], comp) <= 0) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]<list[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]==list[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nをリスト長として O(N log N)
* @param list 座標圧縮を行うリスト
* @return listを座標圧縮した配列
* @throws NullPointerException listがnullの場合
*/
public static <T extends Comparable<T>> int[] compress(java.util.List<T> list) {
int size = list.size();
int[] ret = new int[size];
java.util.ArrayList<T> copy = new java.util.ArrayList<>(list);
copy.sort(java.util.Comparator.naturalOrder());
int len = 1;
for (int j = 1; j < size; ++j) {
if (!copy.get(len - 1).equals(copy.get(j))) copy.set(len++, copy.get(j));
}
java.util.Iterator<T> iter = list.iterator();
for (int i = 0; i < size; ++i) {
int min = 0, max = len;
T comp = iter.next();
while (max - min > 1) {
int mid = min + max >> 1;
if (copy.get(mid).compareTo(comp) <= 0) min = mid;
else max = mid;
}
ret[i] = min;
}
return ret;
}
/**
* 座標圧縮した配列を返します。
* この関数によって返される配列をretとしたとき、retは次の条件を満たします。
* <ul>
* <li>任意の正整数nに対し、contains(ret, n)がtrueならcontains(ret, n-1)もtrue</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]<list[j]ならret[i]<ret[j]</li>
* <li>0≦i, j<nを満たすi, jに対し、list[i]==list[j]ならret[i]==ret[j]</li>
* </ul>
* @complexity Nをリスト長として O(N log N)
* @param list 座標圧縮を行うリスト
* @param comparator 比較関数
* @return listを座標圧縮した配列
*/
public static <T> int[] compress(java.util.List<T> list, java.util.Comparator<T> comparator) {
int[] ret = new int[list.size()];
java.util.ArrayList<T> copy = new java.util.ArrayList<>(list);
copy.sort(comparator);
int[] bit = new int[list.size() + 1];
java.util.Iterator<T> iter = list.iterator();
for (int i = 0; i < list.size(); ++i) {
int min = 0, max = list.size();
T comp = iter.next();
while (max - min > 1) {
int mid = min + max >> 1;
if (comparator.compare(copy.get(mid), comp) <= 0) min = mid;
else max = mid;
}
for (int j = max; j != 0; j -= j & -j) ret[i] += bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ret;
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(int[] array) {
if (array == null) return 0;
int[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int[] bit = new int[array.length + 1];
long ans = (long) array.length * (array.length - 1) >> 1;
for (int i = 0; i < array.length; ++i) {
int min = 0, max = array.length;
int comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(long[] array) {
if (array == null) return 0;
long[] copy = java.util.Arrays.copyOf(array, array.length);
sort(copy);
int[] bit = new int[array.length + 1];
long ans = (long) array.length * (array.length - 1) >> 1;
for (int i = 0; i < array.length; ++i) {
int min = 0, max = array.length;
long comp = array[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copy[mid] <= comp) min = mid;
else max = mid;
}
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(char[] array) {
if (array == null) return 0;
int[] a = new int[array.length];
for (int i = 0;i < array.length;++ i) a[i] = array[i];
return inversionNumber(a);
}
/**
* 配列の転倒数を求めます。すなわち、i<jかつarray[i]>array[j]となる(i, j)の個数を求めます。
* @complexity Nを配列長として O(N log N)
* @param array 配列
* @return 転倒数
*/
public static long inversionNumber(String array) {
if (array == null) return 0;
return inversionNumber(array.toCharArray());
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(int[] src, int[] dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
int[] copySrc = java.util.Arrays.copyOf(src, src.length),
copyDest = java.util.Arrays.copyOf(dest, dest.length);
sort(copySrc);
sort(copyDest);
if (!java.util.Arrays.equals(copySrc, copyDest)) return -1;
int[] key = new int[dest.length];
for (int i = 0; i < dest.length; ++i) {
int min = -1, max = dest.length;
int comp = dest[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copyDest[mid] < comp) min = mid;
else max = mid;
}
key[max] = i;
copyDest[max] = max == 0 ? Integer.MIN_VALUE : copyDest[max - 1];
}
int[] bit = new int[src.length + 1];
long ans = (long) src.length * (src.length - 1) >> 1;
for (int i = 0; i < src.length; ++i) {
int min = -1, max = src.length;
int comp = src[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copySrc[mid] < comp) min = mid;
else max = mid;
}
copySrc[max] = max == 0 ? Integer.MIN_VALUE : copySrc[max - 1];
max = key[max] + 1;
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(long[] src, long[] dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
long[] copySrc = java.util.Arrays.copyOf(src, src.length),
copyDest = java.util.Arrays.copyOf(dest, dest.length);
sort(copySrc);
sort(copyDest);
if (!java.util.Arrays.equals(copySrc, copyDest)) return -1;
int[] key = new int[dest.length];
for (int i = 0; i < dest.length; ++i) {
int min = -1, max = dest.length;
long comp = dest[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copyDest[mid] < comp) min = mid;
else max = mid;
}
key[max] = i;
copyDest[max] = max == 0 ? Integer.MIN_VALUE : copyDest[max - 1];
}
int[] bit = new int[src.length + 1];
long ans = (long) src.length * (src.length - 1) >> 1;
for (int i = 0; i < src.length; ++i) {
int min = -1, max = src.length;
long comp = src[i];
while (max - min > 1) {
int mid = min + max >> 1;
if (copySrc[mid] < comp) min = mid;
else max = mid;
}
copySrc[max] = max == 0 ? Integer.MIN_VALUE : copySrc[max - 1];
max = key[max] + 1;
for (int j = max; j != 0; j -= j & -j) ans -= bit[j];
for (int j = max; j < bit.length; j += j & -j) ++bit[j];
}
return ans;
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(char[] src, char[] dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
int[] a = new int[src.length];
for (int i = 0;i < src.length;++ i) a[i] = src[i];
int[] b = new int[dest.length];
for (int i = 0;i < dest.length;++ i) b[i] = dest[i];
return inversionDistance(a, b);
}
/**
* 2つの配列の転倒距離を求めます。つまり、配列srcの隣接する2要素をswapして配列destと一致させるまでのswap回数の最小値を求めます。
* @complexity N=src.length, M=dest.lengthとしてO((N+M)log(N+M))
* @param src 配列
* @param dest 配列
* @return srcとdestの転倒距離、ただしsrcを隣接swapすることでdestが構築できない場合は-1
*/
public static long inversionDistance(String src, String dest) {
if (src == null || dest == null) return src == null && dest == null ? 0 : -1;
return inversionDistance(src.toCharArray(), dest.toCharArray());
}
}
}
class ACL {
public static final class DisjointSetUnion {
private final int[] parent;
private DisjointSetUnion(final int n) {
parent = new int[n];
java.util.Arrays.fill(parent, -1);
}
public static DisjointSetUnion create(final int n) {
return new DisjointSetUnion(n);
}
public int getLeader(int a) {
int p1, p2;
while ((p1 = parent[a]) >= 0) {
if ((p2 = parent[p1]) >= 0) a = parent[a] = p2;
else return p1;
}
return a;
}
public int merge(int a, int b) {
a = getLeader(a);
b = getLeader(b);
if (a == b) return a;
if (parent[a] < parent[b]) {
parent[b] += parent[a];
parent[a] = b;
return b;
}
parent[a] += parent[b];
parent[b] = a;
return a;
}
public boolean isSame(final int a, final int b) {
return getLeader(a) == getLeader(b);
}
public int getSize(final int a) {
return -parent[getLeader(a)];
}
public java.util.ArrayList<java.util.ArrayList<Integer>> getGroups() {
final Object[] group = new Object[parent.length];
final java.util.ArrayList<java.util.ArrayList<Integer>> ret = new java.util.ArrayList<>();
for (int i = 0; i < parent.length; ++i) {
final int leader = getLeader(i);
final Object put = group[leader];
if (put == null) {
final java.util.ArrayList<Integer> list = new java.util.ArrayList<>();
list.add(i);
ret.add(list);
group[leader] = list;
} else {
@SuppressWarnings("unchecked")
final java.util.ArrayList<Integer> list = (java.util.ArrayList<Integer>) put;
list.add(i);
}
}
return ret;
}
@Override
public String toString() {
return getGroups().toString();
}
}
public static final class IntFenwickTree {
private final int[] array;
private IntFenwickTree(final int n) {
array = new int[n + 1];
}
private IntFenwickTree(final int[] array) {
this(array.length);
System.arraycopy(array, 0, this.array, 1, array.length);
for (int i = 1; i < this.array.length; ++i)
if (i + (i & -i) < this.array.length) this.array[i + (i & -i)] += this.array[i];
}
public static IntFenwickTree create(final int n) {
return new IntFenwickTree(n);
}
public static IntFenwickTree create(final int[] array) {
return new IntFenwickTree(array);
}
public void add(int index, final int add) {
++index;
while (index < array.length) {
array[index] += add;
index += index & -index;
}
}
private int sum(int index) {
int sum = 0;
while (index > 0) {
sum += array[index];
index -= index & -index;
}
return sum;
}
public int sum(final int l, final int r) {
return sum(r) - sum(l);
}
@Override
public String toString() {
return java.util.stream.IntStream.range(0, array.length - 1)
.mapToObj(i -> String.valueOf(sum(i + 1) - sum(i)))
.collect(java.util.stream.Collectors.joining(", ", "[", "]"));
}
}
public static final class LongFenwickTree {
private final long[] array;
private LongFenwickTree(final int n) {
array = new long[n + 1];
}
private LongFenwickTree(final long[] array) {
this(array.length);
System.arraycopy(array, 0, this.array, 1, array.length);
for (int i = 1; i < this.array.length; ++i)
if (i + (i & -i) < this.array.length) this.array[i + (i & -i)] += this.array[i];
}
public static LongFenwickTree create(final int n) {
return new LongFenwickTree(n);
}
public static LongFenwickTree create(final long[] array) {
return new LongFenwickTree(array);
}
public void add(int index, final long add) {
++index;
while (index < array.length) {
array[index] += add;
index += index & -index;
}
}
private long sum(int index) {
long sum = 0;
while (index > 0) {
sum += array[index];
index -= index & -index;
}
return sum;
}
public long sum(final int l, final int r) {
return sum(r) - sum(l);
}
@Override
public String toString() {
return java.util.stream.IntStream.range(0, array.length - 1)
.mapToObj(i -> String.valueOf(sum(i + 1) - sum(i)))
.collect(java.util.stream.Collectors.joining(", ", "[", "]"));
}
}
public static final class MathLib {
public static class Barrett {
private final int mod;
private final long h, l;
private final long MAX = 1L << 62;
private final int MASK = (1 << 31) - 1;
Barrett(final int mod) {
this.mod = mod;
final long t = MAX / mod;
h = t >>> 31;
l = t & MASK;
}
int reduce(final long x) {
final long xh = x >>> 31, xl = x & MASK;
long z = xl * l;
z = xl * h + xh * l + (z >>> 31);
z = xh * h + (z >>> 31);
final int ret = (int) (x - z * mod);
return ret >= mod ? ret - mod : ret;
}
}
public static class BarrettSmall {
private final int mod;
final long t;
BarrettSmall(final int mod) {
this.mod = mod;
t = (1L << 42) / mod;
}
int reduce(long x) {
long q = x * t >> 42;
x -= q * mod;
return (int) (x >= mod ? x - mod : x);
}
}
private static long safe_mod(long x, final long m) {
x %= m;
if (x < 0) x += m;
return x;
}
private static long[] inv_gcd(long a, final long b) {
a = safe_mod(a, b);
if (a == 0) return new long[] { b, 0 };
long s = b, t = a;
long m0 = 0, m1 = 1;
while (t > 0) {
final long u = s / t;
s -= t * u;
m0 -= m1 * u;
long tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 < 0) m0 += b / s;
return new long[] { s, m0 };
}
public static int pow(long n, long m, final int mod) {
assert m >= 0 && mod >= 1;
if (mod == 1) return 0;
return pow(n, m, new Barrett(mod));
}
public static int pow(long n, long m, Barrett mod) {
assert m >= 0;
long ans = 1, num = n % mod.mod;
while (m != 0) {
if ((m & 1) != 0) ans = mod.reduce(ans * num);
m >>>= 1;
num = mod.reduce(num * num);
}
return (int) ans;
}
public static int pow998_244_353(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 998_244_353;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 998_244_353;
m >>>= 1;
num = num * num % 998_244_353;
}
return (int) ans;
}
public static int pow167_772_161(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 167_772_161;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 167_772_161;
m >>>= 1;
num = num * num % 167_772_161;
}
return (int) ans;
}
public static int pow469_762_049(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 469_762_049;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 469_762_049;
m >>>= 1;
num = num * num % 469_762_049;
}
return (int) ans;
}
public static int pow1_000_000_007(long n, long m) {
assert m >= 0;
long ans = 1, num = n % 1_000_000_007;
while (m != 0) {
if ((m & 1) != 0) ans = ans * num % 1_000_000_007;
m >>>= 1;
num = num * num % 1_000_000_007;
}
return (int) ans;
}
public static int pow(long n, long m, BarrettSmall mod) {
assert m >= 0;
long ans = 1, num = n % mod.mod;
while (m != 0) {
if ((m & 1) != 0) ans = mod.reduce(ans * num);
m >>>= 1;
num = mod.reduce(num * num);
}
return (int) ans;
}
public static long[] crt(final long[] r, final long[] m) {
assert r.length == m.length;
final int n = r.length;
long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert 1 <= m[i];
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
long tmp = r0;
r0 = r1;
r1 = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1) return new long[] { 0, 0 };
continue;
}
final long[] ig = inv_gcd(m0, m1);
final long g = ig[0], im = ig[1];
final long u1 = m1 / g;
if ((r1 - r0) % g != 0) return new long[] { 0, 0 };
final long x = (r1 - r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if (r0 < 0) r0 += m0;
// System.err.printf("%d %d\n", r0, m0);
}
return new long[] { r0, m0 };
}
public static long floor_sum(final long n, final long m, long a, long b) {
long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
final long y_max = (a * n + b) / m;
final long x_max = y_max * m - b;
if (y_max == 0) return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
/**
* aとbの最大公約数を返します。
* @param a 整数
* @param b 整数
* @return 最大公約数
*/
public static int gcd(int a, int b) {
while (a != 0) if ((b %= a) != 0) a %= b;
else return a;
return b;
}
/**
* 配列全ての値の最大公約数を返します。
* @param array 配列
* @return 最大公約数
*/
public static int gcd(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = gcd(ret, array[i]);
return ret;
}
/**
* aとbの最大公約数を返します。
* @param a 整数
* @param b 整数
* @return 最大公約数
*/
public static long gcd(long a, long b) {
while (a != 0) if ((b %= a) != 0) a %= b;
else return a;
return b;
}
/**
* 配列全ての値の最大公約数を返します。
* @param array 配列
* @return 最大公約数
*/
public static long gcd(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = gcd(ret, array[i]);
return ret;
}
/**
* 配列全ての値の最小公倍数を返します。
* @param a 整数
* @param b 整数
* @return 最小公倍数
*/
public static long lcm(int a, int b) {
return a / gcd(a, b) * (long) b;
}
/**
* 配列全ての値の最小公倍数を返します。
* @param a 整数
* @param b 整数
* @return 最小公倍数
*/
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
/**
* 配列全ての値の最小公倍数を返します。
* @param array 配列
* @return 最小公倍数
*/
public static long lcm(int... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = lcm(ret, array[i]);
return ret;
}
/**
* aとbのうち、小さい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち小さい方の値
*/
public static int min(int a, int b) {
return a < b ? a : b;
}
/**
* 配列の中で最小の値を返します。
* @param array 配列
* @return 配列の中で最小の値
*/
public static int min(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = min(ret, array[i]);
return ret;
}
/**
* aとbのうち、小さい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち小さい方の値
*/
public static long min(long a, long b) {
return a < b ? a : b;
}
/**
* 配列の中で最小の値を返します。
* @param array 配列
* @return 配列の中で最小の値
*/
public static long min(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = min(ret, array[i]);
return ret;
}
/**
* aとbのうち、大きい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち大きい方の値
*/
public static int max(int a, int b) {
return a > b ? a : b;
}
/**
* 配列の中で最大の値を返します。
* @param array 配列
* @return 配列の中で最大の値
*/
public static int max(int... array) {
int ret = array[0];
for (int i = 1; i < array.length; ++i) ret = max(ret, array[i]);
return ret;
}
/**
* aとbのうち、大きい方を返します。
* @param a 整数
* @param b 整数
* @return aとbのうち大きい方の値
*/
public static long max(long a, long b) {
return a > b ? a : b;
}
/**
* 配列の中で最大の値を返します。
* @param array 配列
* @return 配列の中で最大の値
*/
public static long max(long... array) {
long ret = array[0];
for (int i = 1; i < array.length; ++i) ret = max(ret, array[i]);
return ret;
}
/**
* 配列の値の合計を返します。
* @param array 配列
* @return 配列の値の総和
*/
public static long sum(int... array) {
long ret = 0;
for (int i : array) ret += i;
return ret;
}
/**
* 配列の値の合計を返します。
* @param array 配列
* @return 配列の値の総和
*/
public static long sum(long... array) {
long ret = 0;
for (long i : array) ret += i;
return ret;
}
/**
* 二項係数を列挙した配列を返します。
* @param l 左辺
* @param r 右辺
* @return 0≦i≦l及び0≦j≦rを満たす全てのi, jに対してi choose jを求めた配列
*/
public static long[][] combination(int l, int r) {
long[][] pascal = new long[l + 1][r + 1];
pascal[0][0] = 1;
for (int i = 1; i <= l; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= r; ++j) {
pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
}
}
return pascal;
}
/**
* 二分探索を行い、func(x) != func(x+1)となるような数xを発見します。
* funcが単調な関数であるとき、発見されるxは一意に定まります。
* @param isTrue func(isTrue)=trueとなるような値
* @param isFalse func(isFalse)=falseとなるような値
* @param func 関数
* @complexity O(log(max(isTrue, isFalse) - min(isTrue, isFalse)))
* @return func(x) != func(x+1)となるような数x
*/
public static int binarySearch(int isTrue, int isFalse, java.util.function.IntPredicate func) {
if (isTrue <= isFalse) {
int halfDiff = isFalse - isTrue >> 1, mid = isTrue + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isFalse - isTrue >> 1;
mid = isTrue + halfDiff;
}
return isTrue;
} else {
int halfDiff = isTrue - isFalse >> 1, mid = isFalse + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isTrue - isFalse >> 1;
mid = isFalse + halfDiff;
}
return isFalse;
}
}
/**
* 二分探索を行い、func(x) != func(x+1)となるような数xを発見します。
* funcが単調な関数であるとき、発見されるxは一意に定まります。
* @param isTrue func(isTrue)=trueとなるような値
* @param isFalse func(isFalse)=falseとなるような値
* @param func 関数
* @complexity O(log(max(isTrue, isFalse) - min(isTrue, isFalse)))
* @return func(x) != func(x+1)となるような数x
*/
public static long binarySearch(long isTrue, long isFalse, java.util.function.LongPredicate func) {
if (isTrue <= isFalse) {
long halfDiff = isFalse - isTrue >> 1, mid = isTrue + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isFalse - isTrue >> 1;
mid = isTrue + halfDiff;
}
return isTrue;
} else {
long halfDiff = isTrue - isFalse >> 1, mid = isFalse + halfDiff;
while(halfDiff != 0) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
halfDiff = isTrue - isFalse >> 1;
mid = isFalse + halfDiff;
}
return isFalse;
}
}
/**
* 二分探索を行い、func(x) != func(x+Math.nextUp(x))となるような数xを発見します。
* funcが単調な関数であるとき、発見されるxは一意に定まります。
* @param isTrue func(isTrue)=trueとなるような値
* @param isFalse func(isFalse)=falseとなるような値
* @param func 関数
* @complexity O(log(max(isTrue, isFalse) - min(isTrue, isFalse)))
* @return func(x) != func(x+Math.nextUp(x))となるような数x
*/
public static double binarySearch(double isTrue, double isFalse, java.util.function.DoublePredicate func) {
return Double.longBitsToDouble(binarySearch(Double.doubleToRawLongBits(isTrue), Double.doubleToRawLongBits(isFalse), (long i) -> func.test(Double.longBitsToDouble(i))));
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @return 極小値
*/
public static <T extends Comparable<T>> double find_minimal(double min, double max, int loop, java.util.function.DoubleFunction<T> func) {
return find_minimal(min, max, loop, func, java.util.Comparator.naturalOrder());
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @param comparator 比較関数
* @return 極小値
*/
public static <T> double find_minimal(double min, double max, int loop, java.util.function.DoubleFunction<T> func, java.util.Comparator<T> comparator) {
double phi = (1 + Math.sqrt(5)) / 2;
for (int i = 0;i < loop;++ i) {
double mid_min = (min * phi + max) / (1 + phi), mid_max = (min + max * phi) / (1 + phi);
T mid_min_calc = func.apply(mid_min), mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) <= 0) max = mid_max;
else min = mid_min;
}
return min;
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @return 極大値
*/
public static <T extends Comparable<T>> double find_maximal(double min, double max, int loop, java.util.function.DoubleFunction<T> func) {
return find_maximal(min, max, loop, func, java.util.Comparator.naturalOrder());
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param loop 探索回数
* @param func 関数
* @param comparator 比較関数
* @return 極大値
*/
public static <T> double find_maximal(double min, double max, int loop, java.util.function.DoubleFunction<T> func, java.util.Comparator<T> comparator) {
if (max <= min) throw new IllegalArgumentException("empty range");
double phi = (1 + Math.sqrt(5)) / 2;
for (int i = 0;i < loop;++ i) {
double mid_min = (min * phi + max) / (1 + phi), mid_max = (min + max * phi) / (1 + phi);
T mid_min_calc = func.apply(mid_min), mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) >= 0) max = mid_max;
else min = mid_min;
}
return min;
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極小値
*/
public static <T extends Comparable<T>> int find_minimal(int min, int max, java.util.function.IntFunction<T> func) {
return find_minimal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極小値
*/
public static <T> int find_minimal(int min, int max, java.util.function.IntFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
int range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
int fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
int mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) <= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極大値
*/
public static <T extends Comparable<T>> int find_maximal(int min, int max, java.util.function.IntFunction<T> func) {
return find_maximal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極大値
*/
public static <T> int find_maximal(int min, int max, java.util.function.IntFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
int range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
int fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
int mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) >= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極小値
*/
public static <T extends Comparable<T>> long find_minimal(long min, long max, java.util.function.LongFunction<T> func) {
return find_minimal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 下に凸な関数の極小値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極小値
*/
public static <T> long find_minimal(long min, long max, java.util.function.LongFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
long range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
long fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
long mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) <= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @return 極大値
*/
public static <T extends Comparable<T>> long find_maximal(long min, long max, java.util.function.LongFunction<T> func) {
return find_maximal(min, max, func, java.util.Comparator.naturalOrder());
}
/**
* 上に凸な関数の極大値を発見します。
* @param <T> 関数の終域
* @param min 関数の定義域の下界
* @param max 関数の定義域の上界
* @param func 関数
* @param comparator 比較関数
* @return 極大値
*/
public static <T> long find_maximal(long min, long max, java.util.function.LongFunction<T> func, java.util.Comparator<T> comparator) {
-- min;
long range = max - min;
if (range <= 1) throw new IllegalArgumentException("empty range");
long fib_small = 1, fib_large = 1;
while(fib_large < range) {
fib_large += fib_small;
fib_small = fib_large - fib_small;
}
T mid_min_calc = null, mid_max_calc = null;
int last_calc = -1;
final int LAST_CALC_IS_MIN = 0, LAST_CALC_IS_MAX = 1;
while(max - min > 2) {
fib_small = fib_large - fib_small;
fib_large -= fib_small;
long mid_min = min + fib_small, mid_max = min + fib_large;
if (mid_max >= max) {
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
continue;
}
if (last_calc != LAST_CALC_IS_MIN) mid_min_calc = func.apply(mid_min);
if (last_calc != LAST_CALC_IS_MAX) mid_max_calc = func.apply(mid_max);
if (comparator.compare(mid_min_calc, mid_max_calc) >= 0) {
max = mid_max;
mid_max_calc = mid_min_calc;
last_calc = LAST_CALC_IS_MAX;
} else {
min = mid_min;
mid_min_calc = mid_max_calc;
last_calc = LAST_CALC_IS_MIN;
}
}
return min + 1;
}
public static class BezoutCoefficients {
public final long a, b;
public final long x, y;
public final long gcd;
private BezoutCoefficients(long a, long b, long x, long y, long gcd) {
this.a = a;
this.b = b;
this.x = x;
this.y = y;
this.gcd = gcd;
}
/**
* lx≦i<rxかつly≦j<ryを満たす整数i, jであって、ai+bj=ax+byとなる解の個数を求めます。
* @param lx iの下限(これを含む)
* @param rx iの上限(これを含まない)
* @param ly jの下限(これを含む)
* @param ry jの上限(これを含まない)
* @return 解の個数
* @complexity O(1)
*/
public long countSatisfySolution(long lx, long rx, long ly, long ry) {
long ag = a / gcd, bg = b / gcd;
long la = Math.floorDiv(lx - x + bg - 1, bg), ra = Math.floorDiv(rx - x - 1, bg) + 1;
long lb = Math.floorDiv(y - ry, ag) + 1, rb = Math.floorDiv(y - ly, ag) + 1;
return Math.max(0, Math.min(ra, rb) - Math.max(la, lb));
}
@Override
public String toString() {
return "(" + x + ", " + y + "), gcd=" + gcd;
}
/**
* ax+by=gcd(a, b)となるような解を一つ求めます。
* この時、|x|≦|b/gcd(a,b)|、|y|≦|a/gcd(a,b)|であることが保証されます。
* @param a 整数
* @param b 整数
* @return 与えられた一次不定方程式の解
* @complexity O(log(min(a, b)))
*/
public static BezoutCoefficients solve(long a, long b) {
int as = Long.signum(a);
int bs = Long.signum(b);
long aa = Math.abs(a);
long ba = Math.abs(b);
long p = 1, q = 0, r = 0, s = 1;
while(ba != 0){
long c = aa / ba;
long e;
e = aa; aa = ba; ba = e % ba;
e = p; p = q; q = e - c * q;
e = r; r = s; s = e - c * s;
}
return new BezoutCoefficients(a, b, p * as, r * bs, aa);
}
/**
* ax+by=dとなるような解を一つ求めます。
* @param a 整数
* @param b 整数
* @param d 不定方程式の解
* @return 与えられた一次不定方程式の解(存在しなければnull)
* @complexity O(log(min(a, b)))
*/
public static BezoutCoefficients solve(long a, long b, long d) {
int as = Long.signum(a);
int bs = Long.signum(b);
long aa = Math.abs(a);
long ba = Math.abs(b);
long p = 1, q = 0, r = 0, s = 1;
while(ba != 0){
long c = aa / ba;
long e;
e = aa; aa = ba; ba = e % ba;
e = p; p = q; q = e - c * q;
e = r; r = s; s = e - c * s;
}
if (d % aa != 0) return null;
long divd = d / a, modd = d % a / aa;
return new BezoutCoefficients(a, b, p * as * modd + divd, r * bs * modd, aa);
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_d
*/
public static final class MaxFlow {
private static final class InternalCapEdge {
final int to;
final int rev;
long cap;
InternalCapEdge(int to, int rev, long cap) {
this.to = to;
this.rev = rev;
this.cap = cap;
}
}
public static final class CapEdge {
public final int from, to;
public final long cap, flow;
CapEdge(int from, int to, long cap, long flow) {
this.from = from;
this.to = to;
this.cap = cap;
this.flow = flow;
}
@Override
public boolean equals(Object o) {
if (o instanceof CapEdge) {
CapEdge e = (CapEdge) o;
return from == e.from && to == e.to && cap == e.cap && flow == e.flow;
}
return false;
}
}
private static final class IntPair {
final int first, second;
IntPair(int first, int second) {
this.first = first;
this.second = second;
}
}
static final long INF = Long.MAX_VALUE;
private final int n;
private final java.util.ArrayList<IntPair> pos;
private final java.util.ArrayList<InternalCapEdge>[] g;
@SuppressWarnings("unchecked")
public MaxFlow(int n) {
this.n = n;
pos = new java.util.ArrayList<>();
g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
g[i] = new java.util.ArrayList<>();
}
}
public int addEdge(int from, int to, long cap) {
rangeCheck(from, 0, n);
rangeCheck(to, 0, n);
nonNegativeCheck(cap, "Capacity");
int m = pos.size();
pos.add(new IntPair(from, g[from].size()));
int fromId = g[from].size();
int toId = g[to].size();
if (from == to) toId++;
g[from].add(new InternalCapEdge(to, toId, cap));
g[to].add(new InternalCapEdge(from, fromId, 0L));
return m;
}
private InternalCapEdge getInternalEdge(int i) {
return g[pos.get(i).first].get(pos.get(i).second);
}
private InternalCapEdge getInternalEdgeReversed(InternalCapEdge e) {
return g[e.to].get(e.rev);
}
public CapEdge getEdge(int i) {
int m = pos.size();
rangeCheck(i, 0, m);
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
return new CapEdge(re.to, e.to, e.cap + re.cap, re.cap);
}
public CapEdge[] getEdges() {
CapEdge[] res = new CapEdge[pos.size()];
java.util.Arrays.setAll(res, this::getEdge);
return res;
}
public void changeEdge(int i, long newCap, long newFlow) {
int m = pos.size();
rangeCheck(i, 0, m);
nonNegativeCheck(newCap, "Capacity");
if (newFlow > newCap) {
throw new IllegalArgumentException(
String.format("Flow %d is greater than the capacity %d.", newCap, newFlow));
}
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
e.cap = newCap - newFlow;
re.cap = newFlow;
}
public long maxFlow(int s, int t) {
return flow(s, t, INF);
}
public long flow(int s, int t, long flowLimit) {
rangeCheck(s, 0, n);
rangeCheck(t, 0, n);
long flow = 0L;
int[] level = new int[n];
int[] que = new int[n];
int[] iter = new int[n];
while (flow < flowLimit) {
bfs(s, t, level, que);
if (level[t] < 0) break;
java.util.Arrays.fill(iter, 0);
while (flow < flowLimit) {
long d = dfs(t, s, flowLimit - flow, iter, level);
if (d == 0) break;
flow += d;
}
}
return flow;
}
private void bfs(int s, int t, int[] level, int[] que) {
java.util.Arrays.fill(level, -1);
int hd = 0, tl = 0;
que[tl++] = s;
level[s] = 0;
while (hd < tl) {
int u = que[hd++];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap == 0 || level[v] >= 0) continue;
level[v] = level[u] + 1;
if (v == t) return;
que[tl++] = v;
}
}
}
private long dfs(int cur, int s, long flowLimit, int[] iter, int[] level) {
if (cur == s) return flowLimit;
long res = 0;
int curLevel = level[cur];
for (int itMax = g[cur].size(); iter[cur] < itMax; iter[cur]++) {
int i = iter[cur];
InternalCapEdge e = g[cur].get(i);
InternalCapEdge re = getInternalEdgeReversed(e);
if (curLevel <= level[e.to] || re.cap == 0) continue;
long d = dfs(e.to, s, Math.min(flowLimit - res, re.cap), iter, level);
if (d <= 0) continue;
e.cap += d;
re.cap -= d;
res += d;
if (res == flowLimit) break;
}
return res;
}
public boolean[] minCut(int s) {
rangeCheck(s, 0, n);
boolean[] visited = new boolean[n];
int[] stack = new int[n];
int ptr = 0;
stack[ptr++] = s;
visited[s] = true;
while (ptr > 0) {
int u = stack[--ptr];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap > 0 && !visited[v]) {
visited[v] = true;
stack[ptr++] = v;
}
}
}
return visited;
}
private void rangeCheck(int i, int minInclusive, int maxExclusive) {
if (i < 0 || i >= maxExclusive) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, maxExclusive));
}
}
private void nonNegativeCheck(long cap, String attribute) {
if (cap < 0) { throw new IllegalArgumentException(String.format("%s %d is negative.", attribute, cap)); }
}
}
/**
* @verified
* - https://atcoder.jp/contests/practice2/tasks/practice2_e
* - http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_B
*/
public static final class MinCostFlow {
private static final class InternalWeightedCapEdge {
final int to, rev;
long cap;
final long cost;
InternalWeightedCapEdge(int to, int rev, long cap, long cost) {
this.to = to;
this.rev = rev;
this.cap = cap;
this.cost = cost;
}
}
public static final class WeightedCapEdge {
public final int from, to;
public final long cap, flow, cost;
WeightedCapEdge(int from, int to, long cap, long flow, long cost) {
this.from = from;
this.to = to;
this.cap = cap;
this.flow = flow;
this.cost = cost;
}
@Override
public boolean equals(Object o) {
if (o instanceof WeightedCapEdge) {
WeightedCapEdge e = (WeightedCapEdge) o;
return from == e.from && to == e.to && cap == e.cap && flow == e.flow && cost == e.cost;
}
return false;
}
}
private static final class IntPair {
final int first, second;
IntPair(int first, int second) {
this.first = first;
this.second = second;
}
}
public static final class FlowAndCost {
public final long flow, cost;
FlowAndCost(long flow, long cost) {
this.flow = flow;
this.cost = cost;
}
@Override
public boolean equals(Object o) {
if (o instanceof FlowAndCost) {
FlowAndCost c = (FlowAndCost) o;
return flow == c.flow && cost == c.cost;
}
return false;
}
}
static final long INF = Long.MAX_VALUE;
private final int n;
private final java.util.ArrayList<IntPair> pos;
private final java.util.ArrayList<InternalWeightedCapEdge>[] g;
@SuppressWarnings("unchecked")
public MinCostFlow(int n) {
this.n = n;
pos = new java.util.ArrayList<>();
g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
g[i] = new java.util.ArrayList<>();
}
}
public int addEdge(int from, int to, long cap, long cost) {
rangeCheck(from, 0, n);
rangeCheck(to, 0, n);
nonNegativeCheck(cap, "Capacity");
nonNegativeCheck(cost, "Cost");
int m = pos.size();
pos.add(new IntPair(from, g[from].size()));
int fromId = g[from].size();
int toId = g[to].size();
if (from == to) toId++;
g[from].add(new InternalWeightedCapEdge(to, toId, cap, cost));
g[to].add(new InternalWeightedCapEdge(from, fromId, 0L, -cost));
return m;
}
private InternalWeightedCapEdge getInternalEdge(int i) {
return g[pos.get(i).first].get(pos.get(i).second);
}
private InternalWeightedCapEdge getInternalEdgeReversed(InternalWeightedCapEdge e) {
return g[e.to].get(e.rev);
}
public WeightedCapEdge getEdge(int i) {
int m = pos.size();
rangeCheck(i, 0, m);
InternalWeightedCapEdge e = getInternalEdge(i);
InternalWeightedCapEdge re = getInternalEdgeReversed(e);
return new WeightedCapEdge(re.to, e.to, e.cap + re.cap, re.cap, e.cost);
}
public WeightedCapEdge[] getEdges() {
WeightedCapEdge[] res = new WeightedCapEdge[pos.size()];
java.util.Arrays.setAll(res, this::getEdge);
return res;
}
public FlowAndCost minCostMaxFlow(int s, int t) {
return minCostFlow(s, t, INF);
}
public FlowAndCost minCostFlow(int s, int t, long flowLimit) {
return minCostSlope(s, t, flowLimit).getLast();
}
public java.util.ArrayList<Long> minCostList(int s, int t) {
return minCostList(s, t, INF);
}
public java.util.ArrayList<Long> minCostList(int s, int t, long flowLimit) {
java.util.LinkedList<FlowAndCost> list = minCostSlope(s, t, flowLimit);
FlowAndCost last = list.pollFirst();
java.util.ArrayList<Long> ret = new java.util.ArrayList<>();
ret.add(0L);
while(!list.isEmpty()) {
FlowAndCost now = list.pollFirst();
for (long i = last.flow + 1;i <= now.flow;++ i) {
ret.add(last.cost + (i - last.flow) * (now.cost - last.cost) / (now.flow - last.flow));
}
last = now;
}
return ret;
}
java.util.LinkedList<FlowAndCost> minCostSlope(int s, int t) {
return minCostSlope(s, t, INF);
}
public java.util.LinkedList<FlowAndCost> minCostSlope(int s, int t, long flowLimit) {
rangeCheck(s, 0, n);
rangeCheck(t, 0, n);
if (s == t) { throw new IllegalArgumentException(String.format("%d and %d is the same vertex.", s, t)); }
long[] dual = new long[n];
long[] dist = new long[n];
int[] pv = new int[n];
int[] pe = new int[n];
boolean[] vis = new boolean[n];
long flow = 0;
long cost = 0, prev_cost = -1;
java.util.LinkedList<FlowAndCost> result = new java.util.LinkedList<>();
result.addLast(new FlowAndCost(flow, cost));
while (flow < flowLimit) {
if (!dualRef(s, t, dual, dist, pv, pe, vis)) break;
long c = flowLimit - flow;
for (int v = t; v != s; v = pv[v]) {
c = Math.min(c, g[pv[v]].get(pe[v]).cap);
}
for (int v = t; v != s; v = pv[v]) {
InternalWeightedCapEdge e = g[pv[v]].get(pe[v]);
e.cap -= c;
g[v].get(e.rev).cap += c;
}
long d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost == d) {
result.removeLast();
}
result.addLast(new FlowAndCost(flow, cost));
prev_cost = cost;
}
return result;
}
private boolean dualRef(int s, int t, long[] dual, long[] dist, int[] pv, int[] pe, boolean[] vis) {
java.util.Arrays.fill(dist, INF);
java.util.Arrays.fill(pv, -1);
java.util.Arrays.fill(pe, -1);
java.util.Arrays.fill(vis, false);
class State implements Comparable<State> {
final long key;
final int to;
State(long key, int to) {
this.key = key;
this.to = to;
}
@Override
public int compareTo(State q) {
return key > q.key ? 1 : -1;
}
};
java.util.PriorityQueue<State> pq = new java.util.PriorityQueue<>();
dist[s] = 0;
pq.add(new State(0L, s));
while (pq.size() > 0) {
int v = pq.poll().to;
if (vis[v]) continue;
vis[v] = true;
if (v == t) break;
for (int i = 0, deg = g[v].size(); i < deg; i++) {
InternalWeightedCapEdge e = g[v].get(i);
if (vis[e.to] || e.cap == 0) continue;
long cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
pq.add(new State(dist[e.to], e.to));
}
}
}
if (!vis[t]) { return false; }
for (int v = 0; v < n; v++) {
if (!vis[v]) continue;
dual[v] -= dist[t] - dist[v];
}
return true;
}
private void rangeCheck(int i, int minInlusive, int maxExclusive) {
if (i < 0 || i >= maxExclusive) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, maxExclusive));
}
}
private void nonNegativeCheck(long cap, java.lang.String attribute) {
if (cap < 0) { throw new IllegalArgumentException(String.format("%s %d is negative.", attribute, cap)); }
}
}
/**
* @verified
* <ul>
* <li>https://atcoder.jp/contests/arc050/tasks/arc050_c
* <li>https://atcoder.jp/contests/abc129/tasks/abc129_f
* </ul>
*/
public static final class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
public ModIntFactory(final int mod) {
ma = ModArithmetic.of(mod);
this.mod = mod;
}
public ModInt create(long value) {
if ((value %= mod) < 0) value += mod;
if (ma instanceof ModArithmetic.ModArithmeticMontgomery) {
return new ModInt(((ModArithmetic.ModArithmeticMontgomery) ma).generate(value));
}
return new ModInt((int) value);
}
class ModInt {
private int value;
private ModInt(final int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (ma instanceof ModArithmetic.ModArithmeticMontgomery) {
return ((ModArithmetic.ModArithmeticMontgomery) ma).reduce(value);
}
return value;
}
public ModInt add(final ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(final ModInt mi1, final ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(final ModInt mi1, final ModInt... mis) {
final ModInt mi = add(mi1);
for (final ModInt m : mis) mi.addAsg(m);
return mi;
}
public ModInt add(final long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(final ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(final long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(final ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(final ModInt mi1, final ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(final ModInt mi1, final ModInt... mis) {
final ModInt mi = mul(mi1);
for (final ModInt m : mis) mi.mulAsg(m);
return mi;
}
public ModInt mul(final long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(final ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(final long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(final long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(final ModInt mi) {
value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(final ModInt mi1, final ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(final ModInt... mis) {
for (final ModInt m : mis) addAsg(m);
return this;
}
public ModInt addAsg(final long mi) {
value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(final ModInt mi) {
value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(final long mi) {
value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(final ModInt mi) {
value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(final ModInt mi1, final ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(final ModInt mi1, final ModInt mi2, final ModInt mi3, final ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(final ModInt... mis) {
for (final ModInt m : mis) mulAsg(m);
return this;
}
public ModInt mulAsg(final long mi) {
value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(final ModInt mi) {
value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(final long mi) {
value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(final Object o) {
if (o instanceof ModInt) {
final ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private interface ModArithmetic {
public int mod();
public int remainder(long value);
public int add(int a, int b);
public int sub(int a, int b);
public int mul(int a, int b);
public default int div(final int a, final int b) {
return mul(a, inv(b));
}
public int inv(int a);
public int pow(int a, long b);
public static ModArithmetic of(final int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
static final class ModArithmetic1 implements ModArithmetic {
@Override
public int mod() {
return 1;
}
@Override
public int remainder(final long value) {
return 0;
}
@Override
public int add(final int a, final int b) {
return 0;
}
@Override
public int sub(final int a, final int b) {
return 0;
}
@Override
public int mul(final int a, final int b) {
return 0;
}
@Override
public int inv(final int a) {
throw new ArithmeticException("divide by zero");
}
@Override
public int pow(final int a, final long b) {
return 0;
}
}
static final class ModArithmetic2 implements ModArithmetic {
@Override
public int mod() {
return 2;
}
@Override
public int remainder(final long value) {
return (int) (value & 1);
}
@Override
public int add(final int a, final int b) {
return a ^ b;
}
@Override
public int sub(final int a, final int b) {
return a ^ b;
}
@Override
public int mul(final int a, final int b) {
return a & b;
}
@Override
public int inv(final int a) {
if (a == 0) throw new ArithmeticException("divide by zero");
return a;
}
@Override
public int pow(final int a, final long b) {
if (b == 0) return 1;
return a;
}
}
static final class ModArithmetic998244353 implements ModArithmetic {
private final int mod = 998244353;
@Override
public int mod() {
return mod;
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int add(final int a, final int b) {
final int res = a + b;
return res >= mod ? res - mod : res;
}
@Override
public int sub(final int a, final int b) {
final int res = a - b;
return res < 0 ? res + mod : res;
}
@Override
public int mul(final int a, final int b) {
return (int) ((long) a * b % mod);
}
@Override
public int inv(int a) {
int b = mod;
long u = 1, v = 0;
while (b >= 1) {
final long t = a / b;
a -= t * b;
final int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
final long tmp2 = u;
u = v;
v = tmp2;
}
u %= mod;
if (a != 1) { throw new ArithmeticException("divide by zero"); }
return (int) (u < 0 ? u + mod : u);
}
@Override
public int pow(final int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
long res = 1;
long pow2 = a;
long idx = 1;
while (b > 0) {
final long lsb = b & -b;
for (; lsb != idx; idx <<= 1) {
pow2 = pow2 * pow2 % mod;
}
res = res * pow2 % mod;
b ^= lsb;
}
return (int) res;
}
}
static final class ModArithmetic1000000007 implements ModArithmetic {
private final int mod = 1000000007;
@Override
public int mod() {
return mod;
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int add(final int a, final int b) {
final int res = a + b;
return res >= mod ? res - mod : res;
}
@Override
public int sub(final int a, final int b) {
final int res = a - b;
return res < 0 ? res + mod : res;
}
@Override
public int mul(final int a, final int b) {
return (int) ((long) a * b % mod);
}
@Override
public int div(final int a, final int b) {
return mul(a, inv(b));
}
@Override
public int inv(int a) {
int b = mod;
long u = 1, v = 0;
while (b >= 1) {
final long t = a / b;
a -= t * b;
final int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
final long tmp2 = u;
u = v;
v = tmp2;
}
u %= mod;
if (a != 1) { throw new ArithmeticException("divide by zero"); }
return (int) (u < 0 ? u + mod : u);
}
@Override
public int pow(final int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
long res = 1;
long pow2 = a;
long idx = 1;
while (b > 0) {
final long lsb = b & -b;
for (; lsb != idx; idx <<= 1) {
pow2 = pow2 * pow2 % mod;
}
res = res * pow2 % mod;
b ^= lsb;
}
return (int) res;
}
}
static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2, r3;
private ModArithmeticMontgomery(final int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
final long r = (1l << 32) % mod;
negInv = inv;
r2 = r * r % mod;
r3 = r2 * r % mod;
}
private int generate(final long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = x + (x * negInv & 0xffff_ffffl) * mod >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
public int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
public int mul(final int a, final int b) {
return reduce((long) a * b);
}
@Override
public int inv(int a) {
a = super.inv(a);
return reduce(a * r3);
}
@Override
public int pow(final int a, final long b) {
return generate(super.pow(a, b));
}
}
static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(final int mod) {
super(mod);
/**
* m = floor(2^64/mod) 2^64 = p*mod + q, 2^32 = a*mod + b => (a*mod + b)^2 =
* p*mod + q => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
final long a = (1l << 32) / mod;
final long b = (1l << 32) % mod;
final long m = a * a * mod + 2 * a * b + b * b / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long 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 (int) (x < mod ? x : x - mod);
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int mul(final int a, final int b) {
return reduce((long) a * b);
}
}
static class ModArithmeticDynamic implements ModArithmetic {
final int mod;
public ModArithmeticDynamic(final int mod) {
this.mod = mod;
}
@Override
public int mod() {
return mod;
}
@Override
public int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
public int add(final int a, final int b) {
final int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
@Override
public int sub(final int a, final int b) {
final int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
@Override
public int mul(final int a, final int b) {
return (int) ((long) a * b % mod);
}
@Override
public int inv(int a) {
int b = mod;
long u = 1, v = 0;
while (b >= 1) {
final long t = a / b;
a -= t * b;
final int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
final long tmp2 = u;
u = v;
v = tmp2;
}
u %= mod;
if (a != 1) { throw new ArithmeticException("divide by zero"); }
return (int) (u < 0 ? u + mod : u);
}
@Override
public int pow(final int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
int res = 1;
int pow2 = a;
long idx = 1;
while (b > 0) {
final long lsb = b & -b;
for (; lsb != idx; idx <<= 1) {
pow2 = mul(pow2, pow2);
}
res = mul(res, pow2);
b ^= lsb;
}
return res;
}
}
}
}
/**
* Convolution.
*
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_f
* @verified https://judge.yosupo.jp/problem/convolution_mod_1000000007
*/
public static final class Convolution {
/**
* writer: amotama 勝手に借りてます、問題あったらごめんね
*/
private static void fft(double[] a, double[] b, boolean invert) {
int count = a.length;
for (int i = 1, j = 0; i < count; i++) {
int bit = count >> 1;
for (; j >= bit; bit >>= 1) {
j -= bit;
}
j += bit;
if (i < j) {
double temp = a[i];
a[i] = a[j];
a[j] = temp;
temp = b[i];
b[i] = b[j];
b[j] = temp;
}
}
for (int len = 2; len <= count; len <<= 1) {
int halfLen = len >> 1;
double angle = 2 * Math.PI / len;
if (invert) {
angle = -angle;
}
double wLenA = Math.cos(angle);
double wLenB = Math.sin(angle);
for (int i = 0; i < count; i += len) {
double wA = 1;
double wB = 0;
for (int j = 0; j < halfLen; j++) {
double uA = a[i + j];
double uB = b[i + j];
double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
a[i + j] = uA + vA;
b[i + j] = uB + vB;
a[i + j + halfLen] = uA - vA;
b[i + j + halfLen] = uB - vB;
double nextWA = wA * wLenA - wB * wLenB;
wB = wA * wLenB + wB * wLenA;
wA = nextWA;
}
}
}
if (invert) {
for (int i = 0; i < count; i++) {
a[i] /= count;
b[i] /= count;
}
}
}
/**
* writer: amotama 勝手に借りてます、問題あったらごめんね
*/
public static long[] convolution(long[] a, long[] b) {
int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
resultSize = Math.max(resultSize, 1);
double[] aReal = new double[resultSize];
double[] aImaginary = new double[resultSize];
double[] bReal = new double[resultSize];
double[] bImaginary = new double[resultSize];
for (int i = 0; i < a.length; i++) aReal[i] = a[i];
for (int i = 0; i < b.length; i++) bReal[i] = b[i];
fft(aReal, aImaginary, false);
if (a == b) {
System.arraycopy(aReal, 0, bReal, 0, aReal.length);
System.arraycopy(aImaginary, 0, bImaginary, 0, aImaginary.length);
} else {
fft(bReal, bImaginary, false);
}
for (int i = 0; i < resultSize; i++) {
double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
aReal[i] = real;
}
fft(aReal, aImaginary, true);
long[] result = new long[a.length + b.length - 1];
for (int i = 0; i < result.length; i++) result[i] = Math.round(aReal[i]);
return result;
}
/**
* writer: amotama 勝手に借りてます、問題あったらごめんね
*/
public static int[] convolution(int[] a, int[] b) {
int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
resultSize = Math.max(resultSize, 1);
double[] aReal = new double[resultSize];
double[] aImaginary = new double[resultSize];
double[] bReal = new double[resultSize];
double[] bImaginary = new double[resultSize];
for (int i = 0; i < a.length; i++) aReal[i] = a[i];
for (int i = 0; i < b.length; i++) bReal[i] = b[i];
fft(aReal, aImaginary, false);
if (a == b) {
System.arraycopy(aReal, 0, bReal, 0, aReal.length);
System.arraycopy(aImaginary, 0, bImaginary, 0, aImaginary.length);
} else {
fft(bReal, bImaginary, false);
}
for (int i = 0; i < resultSize; i++) {
double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
aReal[i] = real;
}
fft(aReal, aImaginary, true);
int[] result = new int[a.length + b.length - 1];
for (int i = 0; i < result.length; i++) result[i] = (int) Math.round(aReal[i]);
return result;
}
public static double[] convolution(double[] a, double[] b) {
int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
resultSize = Math.max(resultSize, 1);
double[] aReal = Arrays.copyOf(a, resultSize);
double[] aImaginary = new double[resultSize];
double[] bReal = Arrays.copyOf(b, resultSize);
double[] bImaginary = new double[resultSize];
fft(aReal, aImaginary, false);
if (a == b) {
System.arraycopy(aReal, 0, bReal, 0, aReal.length);
System.arraycopy(aImaginary, 0, bImaginary, 0, aImaginary.length);
} else {
fft(bReal, bImaginary, false);
}
for (int i = 0; i < resultSize; i++) {
double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
aReal[i] = real;
}
fft(aReal, aImaginary, true);
return Arrays.copyOf(aReal, a.length + b.length - 1);
}
/**
* Find a primitive root.
*
* @param m A prime number.
* @return Primitive root.
*/
private static int primitiveRoot(final int m) {
if (m == 2) return 1;
if (m == 167772161) return 3;
if (m == 469762049) return 3;
if (m == 754974721) return 11;
if (m == 998244353) return 3;
final int[] divs = new int[20];
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0) x /= 2;
for (int i = 3; (long) i * i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
boolean ok = true;
for (int i = 0; i < cnt; i++) {
if (MathLib.pow(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok) return g;
}
}
/**
* Ceil of power 2.
*
* @param n Value.
* @return Ceil of power 2.
*/
private static int ceilPow2(final int n) {
int x = 0;
while (1L << x < n) x++;
return x;
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static long garner(final long[] c, final int[] mods) {
final int n = c.length + 1;
final long[] cnst = new long[n];
final long[] coef = new long[n];
java.util.Arrays.fill(coef, 1);
for (int i = 0; i < n - 1; i++) {
final int m1 = mods[i];
long v = (c[i] - cnst[i] + m1) % m1;
v = v * MathLib.pow(coef[i], m1 - 2, m1) % m1;
for (int j = i + 1; j < n; j++) {
final long m2 = mods[j];
cnst[j] = (cnst[j] + coef[j] * v) % m2;
coef[j] = coef[j] * m1 % m2;
}
}
return cnst[n - 1];
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static int garner(int c0, int c1, int c2, final MathLib.Barrett[] mods) {
final long[] cnst = new long[4];
final long[] coef = new long[4];
java.util.Arrays.fill(coef, 1);
MathLib.Barrett m1 = mods[0];
long v = m1.reduce(c0 - cnst[0] + m1.mod);
v = m1.reduce(v * MathLib.pow(coef[0], m1.mod - 2, m1));
{
MathLib.Barrett m2 = mods[1];
cnst[1] = m2.reduce(cnst[1] + coef[1] * v);
coef[1] = m2.reduce(coef[1] * m1.mod);
m2 = mods[2];
cnst[2] = m2.reduce(cnst[2] + coef[2] * v);
coef[2] = m2.reduce(coef[2] * m1.mod);
m2 = mods[3];
cnst[3] = m2.reduce(cnst[3] + coef[3] * v);
coef[3] = m2.reduce(coef[3] * m1.mod);
}
m1 = mods[1];
v = m1.reduce(c1 - cnst[1] + m1.mod);
v = m1.reduce(v * MathLib.pow(coef[1], m1.mod - 2, m1));
{
MathLib.Barrett m2 = mods[2];
cnst[2] = m2.reduce(cnst[2] + coef[2] * v);
coef[2] = m2.reduce(coef[2] * m1.mod);
m2 = mods[3];
cnst[3] = m2.reduce(cnst[3] + coef[3] * v);
coef[3] = m2.reduce(coef[3] * m1.mod);
}
m1 = mods[2];
v = m1.reduce(c2 - cnst[2] + m1.mod);
v = m1.reduce(v * MathLib.pow(coef[2], m1.mod - 2, m1));
{
MathLib.Barrett m2 = mods[3];
cnst[3] = m2.reduce(cnst[3] + coef[3] * v);
coef[3] = m2.reduce(coef[3] * m1.mod);
}
return (int) cnst[3];
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static int garner1_000_000_007(int c0, int c1, int c2) {
final long[] cnst = new long[4];
final long[] coef = new long[4];
java.util.Arrays.fill(coef, 1);
long v = (c0 - cnst[0] + 998_244_353) % 998_244_353;
v = v * MathLib.pow998_244_353(coef[0], 998_244_353 - 2) % 998_244_353;
{
cnst[1] = (cnst[1] + coef[1] * v) % 167_772_161;
coef[1] = coef[1] * 998_244_353 % 167_772_161;
cnst[2] = (cnst[2] + coef[2] * v) % 469_762_049;
coef[2] = coef[2] * 998_244_353 % 469_762_049;
cnst[3] = (cnst[3] + coef[3] * v) % 1_000_000_007;
coef[3] = coef[3] * 998_244_353 % 1_000_000_007;
}
v = (c1 - cnst[1] + 167_772_161) % 167_772_161;
v = v * MathLib.pow167_772_161(coef[1], 167_772_161 - 2) % 167_772_161;
{
cnst[2] = (cnst[2] + coef[2] * v) % 469_762_049;
coef[2] = coef[2] * 167_772_161 % 469_762_049;
cnst[3] = (cnst[3] + coef[3] * v) % 1_000_000_007;
coef[3] = coef[3] * 167_772_161 % 1_000_000_007;
}
v = (c2 - cnst[2] + 469_762_049) % 469_762_049;
v = v * MathLib.pow469_762_049(coef[2], 469_762_049 - 2) % 469_762_049;
{
cnst[3] = (cnst[3] + coef[3] * v) % 1_000_000_007;
coef[3] = coef[3] * 469_762_049 % 1_000_000_007;
}
return (int) cnst[3];
}
/**
* Pre-calculation for NTT.
*
* @param mod NTT Prime.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumE(final int mod, final int g) {
final long[] sum_e = new long[30];
final long[] es = new long[30];
final long[] ies = new long[30];
final int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = MathLib.pow(g, mod - 1 >> cnt2, mod);
long ie = MathLib.pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now % mod;
now = now * ies[i] % mod;
}
return sum_e;
}
/**
* Pre-calculation for inverse NTT.
*
* @param mod Mod.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumIE(final int mod, final int g) {
final long[] sum_ie = new long[30];
final long[] es = new long[30];
final long[] ies = new long[30];
final int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = MathLib.pow(g, mod - 1 >> cnt2, mod);
long ie = MathLib.pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now % mod;
now = now * es[i] % mod;
}
return sum_ie;
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterflyInv(final long[] a, final long[] sumIE, final int mod) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (mod + l - r) * inow % mod;
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % mod;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly(final long[] a, final long[] sumE, final int mod) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now % mod;
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (l - r + mod) % mod;
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % mod;
}
}
}
/**
* Inverse NTT used mod 998_244_353.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
*/
private static void butterflyInv998_244_353(final int[] a, final int[] sumIE) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (int) ((l + r) % 998_244_353);
a[i + offset + p] = (int) ((998_244_353 + l - r) * inow % 998_244_353);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % 998_244_353;
}
}
}
/**
* Inverse NTT used mod 167_772_161.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
*/
private static void butterflyInv167_772_161(final int[] a, final int[] sumIE) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (int) ((l + r) % 167_772_161);
a[i + offset + p] = (int) ((167_772_161 + l - r) * inow % 167_772_161);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % 167_772_161;
}
}
}
/**
* Inverse NTT used mod 469_762_049.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
*/
private static void butterflyInv469_762_049(final int[] a, final int[] sumIE) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
a[i + offset] = (int) ((l + r) % 469_762_049);
a[i + offset + p] = (int) ((469_762_049 + l - r) * inow % 469_762_049);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % 469_762_049;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterflyInv(final int[] a, final int[] sumIE, final MathLib.Barrett mod) {
final int n = a.length;
final int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long inow = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p];
long sum = l + r;
if (sum >= mod.mod) sum -= mod.mod;
a[i + offset] = (int) sum;
a[i + offset + p] = mod.reduce((mod.mod + l - r) * inow);
}
final int x = Integer.numberOfTrailingZeros(~s);
inow = mod.reduce(inow * sumIE[x]);
}
}
}
/**
* Inverse NTT used mod 998_244_353.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly998_244_353(final int[] a, final int[] sumE) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (998_244_353 - 2) * 998_244_353;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = (int) ((l + r) % 998_244_353);
a[i + offset + p] = (int) ((l - r + ADD) % 998_244_353);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % 998_244_353;
}
}
}
/**
* Inverse NTT used mod 167_772_161.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly167_772_161(final int[] a, final int[] sumE) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (167_772_161 - 2) * 167_772_161;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = (int) ((l + r) % 167_772_161);
a[i + offset + p] = (int) ((l - r + ADD) % 167_772_161);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % 167_772_161;
}
}
}
/**
* Inverse NTT used mod 469_762_049.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly469_762_049(final int[] a, final int[] sumE) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (469_762_049 - 2) * 469_762_049;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = (int) ((l + r) % 469_762_049);
a[i + offset + p] = (int) ((l - r + ADD) % 469_762_049);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % 469_762_049;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly(final int[] a, final int[] sumE, final MathLib.Barrett mod) {
final int n = a.length;
final int h = ceilPow2(n);
final long ADD = (long) (mod.mod - 2) * mod.mod;
for (int ph = 1; ph <= h; ph++) {
final int w = 1 << ph - 1, p = 1 << h - ph;
long now = 1;
for (int s = 0; s < w; s++) {
final int offset = s << h - ph + 1;
for (int i = 0; i < p; i++) {
final long l = a[i + offset];
final long r = a[i + offset + p] * now;
a[i + offset] = mod.reduce(l + r);
a[i + offset + p] = mod.reduce(l - r + ADD);
}
final int x = Integer.numberOfTrailingZeros(~s);
now = mod.reduce(now * sumE[x]);
}
}
}
/**
* Convolution used mod 998_244_353.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution998_244_353(int[] a, int[] b) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(998_244_353);
final int[] sume;
{
long[] s = sumE(998_244_353, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(998_244_353, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly998_244_353(a, sume);
butterfly998_244_353(b, sume);
for (int i = 0; i < z; i++) a[i] = (int) ((long) a[i] * b[i] % 998_244_353);
butterflyInv998_244_353(a, sumie);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow998_244_353(z, 998_244_353 - 2);
for (int i = 0; i < n + m - 1; i++) a[i] = (int) (a[i] * iz % 998_244_353);
return a;
}
/**
* Convolution used mod 167_772_161.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution167_772_161(int[] a, int[] b) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(167_772_161);
final int[] sume;
{
long[] s = sumE(167_772_161, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(167_772_161, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly167_772_161(a, sume);
butterfly167_772_161(b, sume);
for (int i = 0; i < z; i++) a[i] = (int) ((long) a[i] * b[i] % 167_772_161);
butterflyInv167_772_161(a, sumie);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow167_772_161(z, 167_772_161 - 2);
for (int i = 0; i < n + m - 1; i++) a[i] = (int) (a[i] * iz % 167_772_161);
return a;
}
/**
* Convolution used mod 469_762_049.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution469_762_049(int[] a, int[] b) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(469_762_049);
final int[] sume;
{
long[] s = sumE(469_762_049, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(469_762_049, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly469_762_049(a, sume);
butterfly469_762_049(b, sume);
for (int i = 0; i < z; i++) a[i] = (int) ((long) a[i] * b[i] % 469_762_049);
butterflyInv469_762_049(a, sumie);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow469_762_049(z, 469_762_049 - 2);
for (int i = 0; i < n + m - 1; i++) a[i] = (int) (a[i] * iz % 469_762_049);
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
private static int[] convolutionNTT(int[] a, int[] b, final int mod) {
MathLib.Barrett barrett = new MathLib.Barrett(mod);
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final int[] na = new int[z];
final int[] nb = new int[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(mod);
final int[] sume;
{
long[] s = sumE(mod, g);
sume = new int[s.length];
for (int i = 0; i < s.length; ++i) sume[i] = (int) s[i];
}
final int[] sumie;
{
long[] s = sumIE(mod, g);
sumie = new int[s.length];
for (int i = 0; i < s.length; ++i) sumie[i] = (int) s[i];
}
butterfly(a, sume, barrett);
butterfly(b, sume, barrett);
for (int i = 0; i < z; i++) a[i] = barrett.reduce((long) a[i] * b[i]);
butterflyInv(a, sumie, barrett);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow(z, mod - 2, mod);
for (int i = 0; i < n + m - 1; i++) a[i] = barrett.reduce(a[i] * iz);
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
private static long[] convolutionNTT(long[] a, long[] b, final int mod) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new long[0];
final int z = 1 << ceilPow2(n + m - 1);
{
final long[] na = new long[z];
final long[] nb = new long[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
final int g = primitiveRoot(mod);
final long[] sume = sumE(mod, g);
final long[] sumie = sumIE(mod, g);
butterfly(a, sume, mod);
butterfly(b, sume, mod);
for (int i = 0; i < z; i++) {
a[i] = a[i] * b[i] % mod;
}
butterflyInv(a, sumie, mod);
a = java.util.Arrays.copyOf(a, n + m - 1);
final long iz = MathLib.pow(z, mod - 2, mod);
for (int i = 0; i < n + m - 1; i++) a[i] = a[i] * iz % mod;
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static long[] convolution(final long[] a, final long[] b, final int mod) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new long[0];
final int mod1 = 998_244_353;
final int mod2 = 167_772_161;
final int mod3 = 469_762_049;
final long[] c1 = convolutionNTT(a, b, mod1);
final long[] c2 = convolutionNTT(a, b, mod2);
final long[] c3 = convolutionNTT(a, b, mod3);
final int retSize = c1.length;
final long[] ret = new long[retSize];
final int[] mods = { mod1, mod2, mod3, mod };
for (int i = 0; i < retSize; ++i) {
ret[i] = garner(new long[] { c1[i], c2[i], c3[i] }, mods);
}
return ret;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static int[] convolution(final int[] a, final int[] b, final int mod) {
final int n = a.length;
final int m = b.length;
if (n == 0 || m == 0) return new int[0];
if (mod == 1_000_000_007) return convolution1_000_000_007(a, b);
if (mod == 998_244_353) return convolution998_244_353(a, b);
int ntt = Integer.lowestOneBit(mod - 1) >> 1;
if (n + m <= ntt) return convolutionNTT(a, b, mod);
final int[] c1 = convolution998_244_353(a, b);
final int[] c2 = convolution167_772_161(a, b);
final int[] c3 = convolution469_762_049(a, b);
final int retSize = c1.length;
final int[] ret = new int[retSize];
final MathLib.Barrett[] mods = { new MathLib.Barrett(998_244_353), new MathLib.Barrett(167_772_161),
new MathLib.Barrett(469_762_049), new MathLib.Barrett(mod) };
for (int i = 0; i < retSize; ++i) ret[i] = garner(c1[i], c2[i], c3[i], mods);
return ret;
}
/**
* Convolution used mod 1_000_000_007.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
private static int[] convolution1_000_000_007(final int[] a, final int[] b) {
final int[] c1 = convolution998_244_353(a, b);
final int[] c2 = convolution167_772_161(a, b);
final int[] c3 = convolution469_762_049(a, b);
final int retSize = c1.length;
final int[] ret = new int[retSize];
for (int i = 0; i < retSize; ++i) ret[i] = garner1_000_000_007(c1[i], c2[i], c3[i]);
return ret;
}
/**
* Convolution. need: length < 2000
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static int[] convolution2(final int[] a, final int[] b, final int mod) {
if (Math.max(a.length, b.length) < 4000) {
long[] la = new long[a.length], ha = new long[a.length], ma = new long[a.length],
lb = new long[b.length], hb = new long[b.length], mb = new long[b.length];
MathLib.Barrett barrett = new MathLib.Barrett(mod);
for (int i = 0; i < a.length; ++i) {
ha[i] = a[i] >> 15;
la[i] = a[i] & 0x7FFF;
ma[i] = la[i] + ha[i];
}
for (int i = 0; i < b.length; ++i) {
hb[i] = b[i] >> 15;
lb[i] = b[i] & 0x7FFF;
mb[i] = lb[i] + hb[i];
}
long[] l = convolution(la, lb), h = convolution(ha, hb), m = convolution(ma, mb);
int[] ret = new int[m.length];
for (int i = 0; i < m.length; ++i) {
h[i] = barrett.reduce(h[i]);
m[i] = barrett.reduce(m[i] - l[i] - h[i] + (long) m.length * mod);
ret[i] = barrett.reduce((h[i] << 30) + (m[i] << 15) + l[i]);
}
return ret;
}
return convolution(a, b, mod);
}
/**
* Naive convolution. (Complexity is O(N^2)!!)
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Mod.
* @return Answer.
*/
public static long[] convolutionNaive(final long[] a, final long[] b, final int mod) {
final int n = a.length;
final int m = b.length;
final int k = n + m - 1;
final long[] ret = new long[k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret[i + j] += a[i] * b[j] % mod;
ret[i + j] %= mod;
}
}
return ret;
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_g
*/
public static final class SCC {
static class Edge {
int from, to;
public Edge(final int from, final int to) {
this.from = from;
this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(final int n) {
this.n = n;
unorderedEdges = new java.util.ArrayList<>();
start = new int[n + 1];
ids = new int[n];
}
public void addEdge(final int from, final int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
m++;
}
public int id(final int i) {
if (!hasBuilt) { throw new UnsupportedOperationException("Graph hasn't been built."); }
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
final Edge[] orderedEdges = new Edge[m];
final int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (final Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
final int[] par = new int[n];
final int[] vis = new int[n];
final int[] low = new int[n];
final int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
final long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
final long p = stack[--ptr];
// vertex
final int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
final int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j-- > 0) {
final int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
final int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
final int[] counts = new int[groupNum];
for (final int x : ids) counts[x]++;
final int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
final int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(final int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/submissions/16647102
*/
public static final class TwoSAT {
private final int n;
private final InternalSCC scc;
private final boolean[] answer;
private boolean hasCalledSatisfiable = false;
private boolean existsAnswer = false;
public TwoSAT(int n) {
this.n = n;
scc = new InternalSCC(2 * n);
answer = new boolean[n];
}
public void addClause(int x, boolean f, int y, boolean g) {
rangeCheck(x);
rangeCheck(y);
scc.addEdge(x << 1 | (f ? 0 : 1), y << 1 | (g ? 1 : 0));
scc.addEdge(y << 1 | (g ? 0 : 1), x << 1 | (f ? 1 : 0));
}
public void addImplication(int x, boolean f, int y, boolean g) {
addClause(x, !f, y, g);
}
public void addNand(int x, boolean f, int y, boolean g) {
addClause(x, !f, y, !g);
}
public void set(int x, boolean f) {
addClause(x, f, x, f);
}
public boolean satisfiable() {
hasCalledSatisfiable = true;
int[] ids = scc.ids();
for (int i = 0; i < n; i++) {
if (ids[i << 1 | 0] == ids[i << 1 | 1]) return existsAnswer = false;
answer[i] = ids[i << 1 | 0] < ids[i << 1 | 1];
}
return existsAnswer = true;
}
public boolean[] answer() {
if (!hasCalledSatisfiable) {
throw new UnsupportedOperationException("Call TwoSAT#satisfiable at least once before TwoSAT#answer.");
}
if (existsAnswer) return answer;
return null;
}
private void rangeCheck(int x) {
if (x < 0 || x >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", x, n));
}
}
private static final class EdgeList {
long[] a;
int ptr = 0;
EdgeList(int cap) {
a = new long[cap];
}
void add(int upper, int lower) {
if (ptr == a.length) grow();
a[ptr++] = (long) upper << 32 | lower;
}
void grow() {
long[] b = new long[a.length << 1];
System.arraycopy(a, 0, b, 0, a.length);
a = b;
}
}
private static final class InternalSCC {
final int n;
int m;
final EdgeList unorderedEdges;
final int[] start;
InternalSCC(int n) {
this.n = n;
unorderedEdges = new EdgeList(n);
start = new int[n + 1];
}
void addEdge(int from, int to) {
unorderedEdges.add(from, to);
start[from + 1]++;
m++;
}
static final long mask = 0xffff_ffffl;
int[] ids() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
int[] orderedEdges = new int[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (int i = 0; i < m; i++) {
long e = unorderedEdges.a[i];
orderedEdges[count[(int) (e >>> 32)]++] = (int) (e & mask);
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
int[] ids = new int[n];
long[] stack = new long[n];
int ptr = 0;
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
stack[ptr++] = i;
while (ptr > 0) {
long p = stack[--ptr];
int u = (int) (p & mask);
int j = (int) (p >>> 32);
if (j == 0) {
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) {
int to = orderedEdges[start[u] + j];
stack[ptr++] += 1l << 32;
if (ord[to] == -1) {
stack[ptr++] = to;
par[to] = u;
} else {
low[u] = Math.min(low[u], ord[to]);
}
} else {
while (j-- > 0) {
int to = orderedEdges[start[u] + j];
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) {
while (true) {
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++;
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
return ids;
}
}
}
public static final class StringAlgorithm {
private static int[] saNaive(final int[] s) {
final int n = s.length;
final Integer[] _sa = new Integer[n];
for (int i = 0; i < n; i++) {
_sa[i] = i;
}
java.util.Arrays.sort(_sa, (l, r) -> {
while (l < n && r < n) {
if (s[l] != s[r]) return s[l] - s[r];
l++;
r++;
}
return -(l - r);
});
final int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = _sa[i];
}
return sa;
}
private static int[] saDoubling(final int[] s) {
final int n = s.length;
final Integer[] _sa = new Integer[n];
for (int i = 0; i < n; i++) {
_sa[i] = i;
}
int[] rnk = s;
int[] tmp = new int[n];
for (int k = 1; k < n; k *= 2) {
final int _k = k;
final int[] _rnk = rnk;
final java.util.Comparator<Integer> cmp = (x, y) -> {
if (_rnk[x] != _rnk[y]) return _rnk[x] - _rnk[y];
final int rx = x + _k < n ? _rnk[x + _k] : -1;
final int ry = y + _k < n ? _rnk[y + _k] : -1;
return rx - ry;
};
java.util.Arrays.sort(_sa, cmp);
tmp[_sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[_sa[i]] = tmp[_sa[i - 1]] + (cmp.compare(_sa[i - 1], _sa[i]) < 0 ? 1 : 0);
}
final int[] buf = tmp;
tmp = rnk;
rnk = buf;
}
final int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = _sa[i];
}
return sa;
}
private static final int THRESHOLD_NAIVE = 10;
private static final int THRESHOLD_DOUBLING = 40;
private static int[] sais(final int[] s, final int upper) {
final int n = s.length;
if (n == 0) return new int[0];
if (n == 1) return new int[] { 0 };
if (n == 2) { return s[0] < s[1] ? new int[] { 0, 1 } : new int[] { 1, 0 }; }
if (n < THRESHOLD_NAIVE) { return saNaive(s); }
if (n < THRESHOLD_DOUBLING) { return saDoubling(s); }
final int[] sa = new int[n];
final boolean[] ls = new boolean[n];
for (int i = n - 2; i >= 0; i--) {
ls[i] = s[i] == s[i + 1] ? ls[i + 1] : s[i] < s[i + 1];
}
final int[] sumL = new int[upper + 1];
final int[] sumS = new int[upper + 1];
for (int i = 0; i < n; i++) {
if (ls[i]) {
sumL[s[i] + 1]++;
} else {
sumS[s[i]]++;
}
}
for (int i = 0; i <= upper; i++) {
sumS[i] += sumL[i];
if (i < upper) sumL[i + 1] += sumS[i];
}
final java.util.function.Consumer<int[]> induce = lms -> {
java.util.Arrays.fill(sa, -1);
final int[] buf = new int[upper + 1];
System.arraycopy(sumS, 0, buf, 0, upper + 1);
for (final int d : lms) {
if (d == n) continue;
sa[buf[s[d]]++] = d;
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
final int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
for (int i = n - 1; i >= 0; i--) {
final int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
final int[] lmsMap = new int[n + 1];
java.util.Arrays.fill(lmsMap, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lmsMap[i] = m++;
}
}
final int[] lms = new int[m];
{
int p = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms[p++] = i;
}
}
}
induce.accept(lms);
if (m > 0) {
final int[] sortedLms = new int[m];
{
int p = 0;
for (final int v : sa) {
if (lmsMap[v] != -1) {
sortedLms[p++] = v;
}
}
}
final int[] recS = new int[m];
int recUpper = 0;
recS[lmsMap[sortedLms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sortedLms[i - 1], r = sortedLms[i];
final int endL = lmsMap[l] + 1 < m ? lms[lmsMap[l] + 1] : n;
final int endR = lmsMap[r] + 1 < m ? lms[lmsMap[r] + 1] : n;
boolean same = true;
if (endL - l != endR - r) {
same = false;
} else {
while (l < endL && s[l] == s[r]) {
l++;
r++;
}
if (l == n || s[l] != s[r]) same = false;
}
if (!same) {
recUpper++;
}
recS[lmsMap[sortedLms[i]]] = recUpper;
}
final int[] recSA = sais(recS, recUpper);
for (int i = 0; i < m; i++) {
sortedLms[i] = lms[recSA[i]];
}
induce.accept(sortedLms);
}
return sa;
}
public static int[] suffixArray(final int[] s, final int upper) {
assert 0 <= upper;
for (final int d : s) {
assert 0 <= d && d <= upper;
}
return sais(s, upper);
}
public static int[] suffixArray(final int[] s) {
final int n = s.length;
final Integer[] idx = new Integer[n];
for (int i = 0; i < n; i++) {
idx[i] = i;
}
java.util.Arrays.sort(idx, (l, r) -> s[l] - s[r]);
final int[] s2 = new int[n];
int now = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && s[idx[i - 1]] != s[idx[i]]) {
now++;
}
s2[idx[i]] = now;
}
return sais(s2, now);
}
public static int[] suffixArray(final char[] s) {
final int n = s.length;
final int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return sais(s2, 255);
}
public static int[] suffixArray(final java.lang.String s) {
return suffixArray(s.toCharArray());
}
public static int[] lcpArray(final int[] s, final int[] sa) {
final int n = s.length;
assert n >= 1;
final int[] rnk = new int[n];
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
final int[] lcp = new int[n - 1];
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0) h--;
if (rnk[i] == 0) {
continue;
}
final int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h]) break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
public static int[] lcpArray(final char[] s, final int[] sa) {
final int n = s.length;
final int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcpArray(s2, sa);
}
public static int[] lcpArray(final java.lang.String s, final int[] sa) {
return lcpArray(s.toCharArray(), sa);
}
public static int[] zAlgorithm(final int[] s) {
final int n = s.length;
if (n == 0) return new int[0];
final int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k]) k++;
z[i] = k;
if (j + z[j] < i + z[i]) j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(final char[] s) {
final int n = s.length;
if (n == 0) return new int[0];
final int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k]) k++;
z[i] = k;
if (j + z[j] < i + z[i]) j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(final String s) {
return zAlgorithm(s.toCharArray());
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_j
*/
public static final 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(final int n, final java.util.function.BinaryOperator<S> op, final S e) {
MAX = n;
int k = 1;
while (k < n) k <<= 1;
N = k;
E = e;
this.op = op;
data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(final S[] dat, final java.util.function.BinaryOperator<S> op, final S e) {
this(dat.length, op, e);
build(dat);
}
private void build(final S[] dat) {
final 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, final 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 void set(int p, java.util.function.UnaryOperator<S> f) {
exclusiveRangeCheck(p);
data[p += N] = f.apply(data[p]);
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(final 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, final 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, final 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(final 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(final 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));
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0;i < N;++ i) {
if (i != 0) sb.append(", ");
sb.append(data[i + N]);
}
sb.append(']');
return sb.toString();
}
}
/**
*
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_k
*/
public static final class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(final int n, final java.util.function.BinaryOperator<S> op, final S e,
final java.util.function.BiFunction<F, S, S> mapping,
final java.util.function.BinaryOperator<F> composition, final F id) {
MAX = n;
int k = 1;
while (k < n) k <<= 1;
N = k;
Log = Integer.numberOfTrailingZeros(N);
Op = op;
E = e;
Mapping = mapping;
Composition = composition;
Id = id;
Dat = (S[]) new Object[N << 1];
Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(final S[] dat, final java.util.function.BinaryOperator<S> op, final S e,
final java.util.function.BiFunction<F, S, S> mapping,
final java.util.function.BinaryOperator<F> composition, final F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(final S[] dat) {
final int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(final int k) {
if (Laz[k] == Id) return;
final int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(final int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(final int lk, final int rk) {
for (int i = Log; i > 0; i--) {
if (lk >> i << i != lk) push(lk >> i);
if (rk >> i << i != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(final int lk, final int rk) {
for (int i = 1; i <= Log; i++) {
if (lk >> i << i != lk) {
final int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (rk >> i << i != rk) {
final int rki = rk - 1 >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, final S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
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);
if (l == r) return E;
l += N;
r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1;
r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, final F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, final F f) {
if (l > r) { throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r)); }
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N;
r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1;
r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, final java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) { throw new IllegalArgumentException("Identity element must satisfy the condition."); }
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, final java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) { throw new IllegalArgumentException("Identity element must satisfy the condition."); }
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(final int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(final int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(final int newIndent) { indent = newIndent; }
@Override
public String toString() {
return toString(1, 0);
}
private String toString(final int k, final int sp) {
if (k >= N) return indent(sp) + Dat[k];
String s = "";
s += toString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + Dat[k] + "/" + Laz[k];
s += "\n";
s += toString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
final StringBuilder sb = new StringBuilder();
while (n-- > 0) sb.append(' ');
return sb.toString();
}
}
public static final class MultiSet<T> extends java.util.TreeMap<T, Long> {
private static final long serialVersionUID = 1L;
public MultiSet() {
super();
}
public MultiSet(final java.util.List<T> list) {
super();
for (final T e : list) this.addOne(e);
}
public long count(final Object elm) {
return getOrDefault(elm, 0L);
}
public void add(final T elm, final long amount) {
if (!containsKey(elm)) put(elm, amount);
else replace(elm, get(elm) + amount);
if (this.count(elm) == 0) this.remove(elm);
}
public void addOne(final T elm) {
this.add(elm, 1);
}
public void removeOne(final T elm) {
this.add(elm, -1);
}
public void removeAll(final T elm) {
this.add(elm, -this.count(elm));
}
public static <T> MultiSet<T> merge(final MultiSet<T> a, final MultiSet<T> b) {
final MultiSet<T> c = new MultiSet<>();
for (final T x : a.keySet()) c.add(x, a.count(x));
for (final T y : b.keySet()) c.add(y, b.count(y));
return c;
}
}
}
/**
* 高速な入出力を提供します。
*
* @author 31536000
*
*/
final class FastIO implements AutoCloseable {
private Input in;
private Output out;
private Output err;
private boolean outFlush = false;
private boolean autoOutFlush = true;
public static final java.io.PrintStream DUMMY_OUT = new DummyOut();
public FastIO() {
this(System.in, System.out, System.err);
}
public FastIO(final java.io.InputStream in, final java.io.PrintStream out, final java.io.PrintStream err) {
this.in = in instanceof Input ? (Input) in : new Input(in);
if (out instanceof Output) {
this.out = (Output) out;
} else {
this.out = new Output(out);
this.out.setAutoFlush(false);
}
if (err instanceof Output) {
this.err = (Output) err;
} else {
this.err = new Output(err);
this.err.setAutoFlush(false);
}
}
public static void setFastStandardOutput(final boolean set) {
final java.io.FileOutputStream fdOut = new java.io.FileOutputStream(java.io.FileDescriptor.out);
final java.io.FileOutputStream fdErr = new java.io.FileOutputStream(java.io.FileDescriptor.err);
if (set) {
System.out.flush();
final Output out = new Output(fdOut);
out.setAutoFlush(false);
System.setOut(out);
System.err.flush();
final Output err = new Output(fdErr);
err.setAutoFlush(false);
System.setErr(err);
} else {
System.out.flush();
final java.io.PrintStream out = new java.io.PrintStream(new java.io.BufferedOutputStream(fdOut, 128), true);
System.setOut(out);
System.err.flush();
final java.io.PrintStream err = new java.io.PrintStream(new java.io.BufferedOutputStream(fdErr, 128), true);
System.setErr(err);
}
}
public void setInputStream(final java.io.InputStream in) {
if (this.in == in) return;
this.in.close();
this.in = in instanceof Input ? (Input) in : new Input(in);
}
public void setInputStream(final java.io.File in) {
try {
this.in.close();
final java.io.InputStream input = new java.io.FileInputStream(in);
this.in = new Input(input);
} catch (final java.io.FileNotFoundException e) {
e.printStackTrace();
}
}
public Input getInputStream() { return in; }
public void setOutputStream(final java.io.OutputStream out) {
if (this.out == out) {
this.out.flush();
}
final boolean flush = this.out.autoFlush;
this.out.close();
if (out instanceof Output) {
this.out = (Output) out;
this.out.setAutoFlush(flush);
} else {
this.out = new Output(out);
this.out.setAutoFlush(flush);
}
}
public void setOutputStream(final java.io.File out) {
try {
setOutputStream(new java.io.FileOutputStream(out));
} catch (final java.io.FileNotFoundException e) {
e.printStackTrace();
}
}
public void setOutputStream(final java.io.FileDescriptor out) {
setOutputStream(new java.io.FileOutputStream(out));
}
public Output getOutputStream() { return out; }
public void setErrorStream(final java.io.OutputStream err) {
if (this.err == err) {
this.err.flush();
}
final boolean flush = this.err.autoFlush;
this.err.close();
if (err instanceof Output) {
this.err = (Output) err;
this.err.setAutoFlush(flush);
} else {
this.err = new Output(err);
this.err.setAutoFlush(flush);
}
}
public void setErrorStream(final java.io.File err) {
try {
setErrorStream(new java.io.FileOutputStream(err));
} catch (final java.io.FileNotFoundException e) {
e.printStackTrace();
}
}
public void setErrorStream(final java.io.FileDescriptor err) {
setErrorStream(new java.io.FileOutputStream(err));
}
public Output getErrorStream() { return err; }
public void setAutoFlush(final boolean flush) {
out.setAutoFlush(flush);
err.setAutoFlush(flush);
}
public void setAutoOutFlush(final boolean flush) { autoOutFlush = flush; }
private void autoFlush() {
if (outFlush) {
outFlush = false;
flush();
}
}
public boolean hasNext() {
autoFlush();
return in.hasNext();
}
public boolean nextBoolean() {
autoFlush();
return in.nextBoolean();
}
public boolean[] nextBoolean(final char T) {
final char[] s = nextChars();
final boolean[] ret = new boolean[s.length];
for (int i = 0; i < ret.length; ++i) ret[i] = s[i] == T;
return ret;
}
public boolean[][] nextBoolean(final char T, final int height) {
final boolean[][] ret = new boolean[height][];
for (int i = 0; i < ret.length; ++i) {
final char[] s = nextChars();
ret[i] = new boolean[s.length];
for (int j = 0; j < ret[i].length; ++j) ret[i][j] = s[j] == T;
}
return ret;
}
public byte nextByte() {
autoFlush();
return in.nextByte();
}
public short nextShort() {
autoFlush();
return in.nextShort();
}
public short[] nextShort(final int width) {
final short[] ret = new short[width];
for (int i = 0; i < width; ++i) ret[i] = nextShort();
return ret;
}
public short[][] nextShort(final int width, final int height) {
final short[][] ret = new short[height][width];
for (int i = 0, j; i < height; ++i) for (j = 0; j < width; ++j) ret[i][j] = nextShort();
return ret;
}
public int nextInt() {
autoFlush();
return in.nextInt();
}
public int[] nextInt(final int width) {
final int[] ret = new int[width];
for (int i = 0; i < width; ++i) ret[i] = nextInt();
return ret;
}
public int[][] nextInt(final int width, final int height) {
final int[][] ret = new int[height][width];
for (int i = 0, j; i < height; ++i) for (j = 0; j < width; ++j) ret[i][j] = nextInt();
return ret;
}
public int[] nextInts() {
return nextInts(" ");
}
public int[] nextInts(final String parse) {
final String[] get = nextLine().split(parse);
final int[] ret = new int[get.length];
for (int i = 0; i < ret.length; ++i) ret[i] = Integer.valueOf(get[i]);
return ret;
}
public long nextLong() {
autoFlush();
return in.nextLong();
}
public long[] nextLong(final int width) {
final long[] ret = new long[width];
for (int i = 0; i < width; ++i) ret[i] = nextLong();
return ret;
}
public long[][] nextLong(final int width, final int height) {
final long[][] ret = new long[height][width];
for (int i = 0, j; i < height; ++i) for (j = 0; j < width; ++j) ret[j][i] = nextLong();
return ret;
}
public long[] nextLongs() {
return nextLongs(" ");
}
public long[] nextLongs(final String parse) {
final String[] get = nextLine().split(parse);
final long[] ret = new long[get.length];
for (int i = 0; i < ret.length; ++i) ret[i] = Long.valueOf(get[i]);
return ret;
}
public float nextFloat() {
autoFlush();
return in.nextFloat();
}
public double nextDouble() {
autoFlush();
return in.nextDouble();
}
public char nextChar() {
autoFlush();
return in.nextChar();
}
public char[] nextChars() {
return next().toCharArray();
}
public char[] nextChars(final char around) {
return (around + next() + around).toCharArray();
}
public char[][] nextChars(final int height) {
final char[][] ret = new char[height][];
for (int i = 0; i < ret.length; ++i) ret[i] = nextChars();
return ret;
}
public char[][] nextChars(final int height, final char around) {
final char[][] ret = new char[height + 2][];
for (int i = 1; i <= height; ++i) ret[i] = nextChars(around);
java.util.Arrays.fill(ret[0] = new char[ret[1].length], around);
java.util.Arrays.fill(ret[ret.length - 1] = new char[ret[0].length], around);
return ret;
}
public String next() {
autoFlush();
return in.next();
}
public String nextLine() {
autoFlush();
return in.nextLine();
}
public Point nextPoint() {
return new Point(nextInt(), nextInt());
}
public Point[] nextPoint(final int width) {
final Point[] ret = new Point[width];
for (int i = 0; i < width; ++i) ret[i] = nextPoint();
return ret;
}
public boolean print(final boolean b) {
out.print(b);
outFlush = autoOutFlush;
return b;
}
public byte print(final byte b) {
out.print(b);
outFlush = autoOutFlush;
return b;
}
public short print(final short s) {
out.print(s);
outFlush = autoOutFlush;
return s;
}
public int print(final int i) {
out.print(i);
outFlush = autoOutFlush;
return i;
}
public long print(final long l) {
out.print(l);
outFlush = autoOutFlush;
return l;
}
public float print(final float f) {
out.print(f);
outFlush = autoOutFlush;
return f;
}
public double print(final double d) {
out.print(d);
outFlush = autoOutFlush;
return d;
}
public double print(final double d, final int length) {
out.print(d, length);
outFlush = autoOutFlush;
return d;
}
public char print(final char c) {
out.print(c);
outFlush = autoOutFlush;
return c;
}
public char[] print(final char[] s) {
out.print(s);
outFlush = autoOutFlush;
return s;
}
public String print(final String s) {
out.print(s);
outFlush = autoOutFlush;
return s;
}
public Object print(final Object obj) {
if (obj != null && obj.getClass().isArray()) {
if (obj instanceof boolean[][]) print(obj, "\n", " ");
else if (obj instanceof byte[][]) print(obj, "\n", " ");
else if (obj instanceof short[][]) print(obj, "\n", " ");
else if (obj instanceof int[][]) print(obj, "\n", " ");
else if (obj instanceof long[][]) print(obj, "\n", " ");
else if (obj instanceof float[][]) print(obj, "\n", " ");
else if (obj instanceof double[][]) print(obj, "\n", " ");
else if (obj instanceof char[][]) print(obj, "\n", " ");
else if (obj instanceof Object[][]) print(obj, "\n", " ");
else print(obj, " ");
} else {
out.print(obj);
outFlush = autoOutFlush;
}
return obj;
}
public Object print(final Object array, final String... parse) {
print(array, 0, parse);
return array;
}
private Object print(final Object array, final int check, final String... parse) {
if (check >= parse.length) {
if (array != null && array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
print(array);
return array;
}
final String str = parse[check];
if (array instanceof Object[]) {
final Object[] obj = (Object[]) array;
if (obj.length == 0) return array;
print(obj[0], check + 1, parse);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i], check + 1, parse);
}
return array;
}
if (array instanceof java.util.Collection) {
final java.util.Iterator<?> iter = ((java.util.Collection<?>) array).iterator();
if (!iter.hasNext()) return array;
print(iter.next(), check + 1, parse);
while (iter.hasNext()) {
print(str);
print(iter.next(), check + 1, parse);
}
return array;
}
if (!array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
if (check != parse.length - 1) throw new IllegalArgumentException("not equal dimension");
if (array instanceof boolean[]) {
final boolean[] obj = (boolean[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof byte[]) {
final byte[] obj = (byte[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
return array;
} else if (array instanceof short[]) {
final short[] obj = (short[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof int[]) {
final int[] obj = (int[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof long[]) {
final long[] obj = (long[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof float[]) {
final float[] obj = (float[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof double[]) {
final double[] obj = (double[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else if (array instanceof char[]) {
final char[] obj = (char[]) array;
if (obj.length == 0) return array;
print(obj[0]);
for (int i = 1; i < obj.length; ++i) {
print(str);
print(obj[i]);
}
} else throw new AssertionError();
return array;
}
public Object[] print(final String parse, final Object... args) {
print(args[0]);
for (int i = 1; i < args.length; ++i) {
print(parse);
print(args[i]);
}
return args;
}
public Object[] printf(final String format, final Object... args) {
out.printf(format, args);
outFlush = autoOutFlush;
return args;
}
public Object[] printf(final java.util.Locale l, final String format, final Object... args) {
out.printf(l, format, args);
outFlush = autoOutFlush;
return args;
}
public void println() {
out.println();
outFlush = autoOutFlush;
}
public boolean println(final boolean b) {
out.println(b);
outFlush = autoOutFlush;
return b;
}
public byte println(final byte b) {
out.println(b);
outFlush = autoOutFlush;
return b;
}
public short println(final short s) {
out.println(s);
outFlush = autoOutFlush;
return s;
}
public int println(final int i) {
out.println(i);
outFlush = autoOutFlush;
return i;
}
public long println(final long l) {
out.println(l);
outFlush = autoOutFlush;
return l;
}
public float println(final float f) {
out.println(f);
outFlush = autoOutFlush;
return f;
}
public double println(final double d) {
out.println(d);
outFlush = autoOutFlush;
return d;
}
public double println(final double d, final int length) {
out.println(d, length);
outFlush = autoOutFlush;
return d;
}
public char println(final char c) {
out.println(c);
outFlush = autoOutFlush;
return c;
}
public char[] println(final char[] s) {
out.println(s);
outFlush = autoOutFlush;
return s;
}
public String println(final String s) {
out.println(s);
return s;
}
public Object println(final Object obj) {
print(obj);
println();
return obj;
}
public Object println(final Object array, final String... parse) {
print(array, parse);
println();
return array;
}
public boolean debug(final boolean b) {
err.print(b);
outFlush = autoOutFlush;
return b;
}
public byte debug(final byte b) {
err.print(b);
outFlush = autoOutFlush;
return b;
}
public short debug(final short s) {
err.print(s);
outFlush = autoOutFlush;
return s;
}
public int debug(final int i) {
err.print(i);
outFlush = autoOutFlush;
return i;
}
public long debug(final long l) {
err.print(l);
outFlush = autoOutFlush;
return l;
}
public float debug(final float f) {
err.print(f);
outFlush = autoOutFlush;
return f;
}
public double debug(final double d) {
err.print(d);
outFlush = autoOutFlush;
return d;
}
public double debug(final double d, final int length) {
err.print(d, length);
outFlush = autoOutFlush;
return d;
}
public char debug(final char c) {
err.print(c);
outFlush = autoOutFlush;
return c;
}
public char[] debug(final char[] s) {
err.print(s);
outFlush = autoOutFlush;
return s;
}
public String debug(final String s) {
err.print(s);
outFlush = autoOutFlush;
return s;
}
public Object debug(final Object obj) {
if (obj != null && obj.getClass().isArray()) {
if (obj instanceof boolean[][]) debug(obj, "\n", " ");
else if (obj instanceof byte[][]) debug(obj, "\n", " ");
else if (obj instanceof short[][]) debug(obj, "\n", " ");
else if (obj instanceof int[][]) debug(obj, "\n", " ");
else if (obj instanceof long[][]) debug(obj, "\n", " ");
else if (obj instanceof float[][]) debug(obj, "\n", " ");
else if (obj instanceof double[][]) debug(obj, "\n", " ");
else if (obj instanceof char[][]) debug(obj, "\n", " ");
else if (obj instanceof Object[][]) debug(obj, "\n", " ");
else debug(obj, " ");
} else {
err.print(obj);
outFlush = autoOutFlush;
}
return obj;
}
public Object debug(final Object array, final String... parse) {
debug(array, 0, parse);
return array;
}
private Object debug(final Object array, final int check, final String... parse) {
if (check >= parse.length) {
if (array != null && array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
debug(array);
return array;
}
final String str = parse[check];
if (array instanceof Object[]) {
final Object[] obj = (Object[]) array;
if (obj.length == 0) return array;
debug(obj[0], check + 1, parse);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i], check + 1, parse);
}
return array;
}
if (array instanceof java.util.Collection) {
final java.util.Iterator<?> iter = ((java.util.Collection<?>) array).iterator();
if (!iter.hasNext()) return array;
debug(iter.next(), check + 1, parse);
while (iter.hasNext()) {
debug(str);
debug(iter.next(), check + 1, parse);
}
return array;
}
if (!array.getClass().isArray()) throw new IllegalArgumentException("not equal dimension");
if (check != parse.length - 1) throw new IllegalArgumentException("not equal dimension");
if (array instanceof boolean[]) {
final boolean[] obj = (boolean[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof byte[]) {
final byte[] obj = (byte[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
return array;
} else if (array instanceof short[]) {
final short[] obj = (short[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof int[]) {
final int[] obj = (int[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof long[]) {
final long[] obj = (long[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof float[]) {
final float[] obj = (float[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof double[]) {
final double[] obj = (double[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else if (array instanceof char[]) {
final char[] obj = (char[]) array;
if (obj.length == 0) return array;
debug(obj[0]);
for (int i = 1; i < obj.length; ++i) {
debug(str);
debug(obj[i]);
}
} else throw new AssertionError();
return array;
}
public Object[] debug(final String parse, final Object... args) {
debug(args[0]);
for (int i = 1; i < args.length; ++i) {
debug(parse);
debug(args[i]);
}
return args;
}
public Object[] debugf(final String format, final Object... args) {
err.printf(format, args);
outFlush = autoOutFlush;
return args;
}
public Object[] debugf(final java.util.Locale l, final String format, final Object... args) {
err.printf(l, format, args);
outFlush = autoOutFlush;
return args;
}
public void debugln() {
err.println();
outFlush = autoOutFlush;
}
public boolean debugln(final boolean b) {
err.println(b);
outFlush = autoOutFlush;
return b;
}
public byte debugln(final byte b) {
err.println(b);
outFlush = autoOutFlush;
return b;
}
public short debugln(final short s) {
err.println(s);
outFlush = autoOutFlush;
return s;
}
public int debugln(final int i) {
err.println(i);
outFlush = autoOutFlush;
return i;
}
public long debugln(final long l) {
err.println(l);
outFlush = autoOutFlush;
return l;
}
public float debugln(final float f) {
err.println(f);
outFlush = autoOutFlush;
return f;
}
public double debugln(final double d) {
err.println(d);
outFlush = autoOutFlush;
return d;
}
public double debugln(final double d, final int length) {
err.println(d, length);
outFlush = autoOutFlush;
return d;
}
public char debugln(final char c) {
err.println(c);
outFlush = autoOutFlush;
return c;
}
public char[] debugln(final char[] s) {
err.println(s);
outFlush = autoOutFlush;
return s;
}
public String debugln(final String s) {
err.println(s);
outFlush = autoOutFlush;
return s;
}
public Object debugln(final Object obj) {
debug(obj);
debugln();
return obj;
}
public Object debugln(final Object array, final String... parse) {
debug(array, parse);
debugln();
return array;
}
public void flush() {
out.flush();
err.flush();
outFlush = false;
}
@Override
public void close() {
out.close();
err.close();
}
public static final class Input extends java.io.InputStream {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1 << 13];
private int read = 0;
private int length = 0;
public Input(final java.io.InputStream in) {
this.in = in;
}
@Override
public int available() {
try {
return in.available();
} catch (final java.io.IOException e) {
e.printStackTrace();
}
return 0;
}
@Override
public void close() {
try {
in.close();
read = length = 0;
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
@Override
public int read() {
if (hasNextByte()) return nextByte();
return 0;
}
private boolean hasNextByte() {
if (read < length) return true;
read = 0;
try {
length = in.read(buffer);
} catch (final java.io.IOException e) {
e.printStackTrace();
}
return length > 0;
}
private static boolean isPrintableChar(final byte c) {
return 32 < c || c < 0;
}
private static boolean isNumber(final byte c) {
return '0' <= c && c <= '9';
}
private boolean readNewLine() {
if (hasNextByte()) {
if (buffer[read] == '\r') {
++read;
if (hasNextByte() && buffer[read] == '\n') ++read;
return true;
}
if (buffer[read] == '\n') {
++read;
return true;
}
}
return false;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[read])) read++;
return hasNextByte();
}
private byte nextTokenByte() {
while (hasNextByte() && !isPrintableChar(buffer[read])) read++;
return buffer[read++];
}
public boolean nextBoolean() {
return Boolean.valueOf(next());
}
public byte nextByte() {
if (hasNextByte()) return buffer[read++];
throw new java.util.NoSuchElementException();
}
public short nextShort() {
byte b = nextTokenByte();
short n = 0;
try {
if (b == '-') {
while (isNumber(b = nextByte())) n = (short) (n * 10 + '0' - b);
return n;
} else if (!isNumber(b)) throw new NumberFormatException();
do n = (short) (n * 10 + b - '0'); while (isNumber(b = nextByte()));
return n;
} catch (final java.util.NoSuchElementException e) {
return n;
}
}
public int nextInt() {
byte b = nextTokenByte();
int n = 0;
try {
if (b == '-') {
while (isNumber(b = nextByte())) n = n * 10 + '0' - b;
return n;
} else if (!isNumber(b)) throw new NumberFormatException();
do n = n * 10 + b - '0'; while (isNumber(b = nextByte()));
return n;
} catch (final java.util.NoSuchElementException e) {
return n;
}
}
public long nextLong() {
byte b = nextTokenByte();
long n = 0;
try {
if (b == '-') {
while (isNumber(b = nextByte())) n = n * 10 + '0' - b;
return n;
} else if (!isNumber(b)) throw new NumberFormatException();
do n = n * 10 + b - '0'; while (isNumber(b = nextByte()));
return n;
} catch (final java.util.NoSuchElementException e) {
return n;
}
}
public float nextFloat() {
return Float.parseFloat(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
final byte b = nextByte();
if ((b & 0x80) == 0) return (char) b;
if ((b & 0x20) == 0) return (char) ((b & 0x1F) << 6 | nextByte() & 0x3F);
return (char) ((b & 0xF) << 12 | (nextByte() & 0x3F) << 6 | nextByte() & 0x3F);
}
public String next() {
if (!hasNext()) throw new java.util.NoSuchElementException();
final StringBuilder sb = new StringBuilder();
do sb.append(nextChar()); while (hasNextByte() && isPrintableChar(buffer[read]));
return sb.toString();
}
public String nextLine() {
final StringBuilder sb = new StringBuilder();
while (!readNewLine()) sb.append(nextChar());
return sb.toString();
}
}
public static final class Output extends java.io.PrintStream {
private final byte[] buffer = new byte[1 << 13];
private int read = 0;
private boolean autoFlush = true;
public Output(final java.io.OutputStream out) {
super(out);
}
public void setAutoFlush(final boolean autoFlush) { this.autoFlush = autoFlush; }
@Override
public void close() {
if (out == System.out || out == System.err || this == System.out || this == System.err) {
flush();
return;
}
try {
flush();
out.close();
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
@Override
public void flush() {
try {
write();
out.flush();
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
@Override
public void write(final byte[] b) {
if (b.length < buffer.length) {
ensureBuffer(b.length);
System.arraycopy(b, 0, buffer, read, b.length);
read += b.length;
} else {
write();
try {
out.write(b);
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
}
@Override
public void write(final byte[] b, final int off, final int len) {
if (len < buffer.length) {
ensureBuffer(len);
System.arraycopy(b, off, buffer, read, len);
read += len;
} else {
write();
try {
out.write(b, off, len);
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
}
@Override
public void write(final int b) {
print((byte) b);
}
private void write() {
try {
out.write(buffer, 0, read);
read = 0;
} catch (final java.io.IOException e) {
e.printStackTrace();
}
}
private void ensureBuffer(final int size) {
if (read + size > buffer.length) {
write();
}
}
@Override
public void print(final boolean b) {
if (b) {
ensureBuffer(4);
buffer[read++] = 't';
buffer[read++] = 'r';
buffer[read++] = 'u';
buffer[read++] = 'e';
} else {
ensureBuffer(5);
buffer[read++] = 'f';
buffer[read++] = 'a';
buffer[read++] = 'l';
buffer[read++] = 's';
buffer[read++] = 'e';
}
}
public void print(final byte b) {
ensureBuffer(1);
buffer[read++] = b;
}
private static int digit(final short s) {
return s >= 100 ? s >= 1000 ? s >= 10000 ? 5 : 4 : 3 : s >= 10 ? 2 : 1;
}
public void print(short s) {
ensureBuffer(6);
if (s < 0) {
if (s == -32768) {
buffer[read++] = '-';
buffer[read++] = '3';
buffer[read++] = '2';
buffer[read++] = '7';
buffer[read++] = '6';
buffer[read++] = '8';
return;
}
buffer[read++] = '-';
s = (short) -s;
}
final int digit = digit(s);
int i = read + digit;
while (i-- > read) {
buffer[i] = (byte) (s % 10 + '0');
s /= 10;
}
read += digit;
}
private static int digit(final int i) {
if (i >= 1000000000) return 10;
if (i >= 100000000) return 9;
if (i >= 10000000) return 8;
if (i >= 1000000) return 7;
if (i >= 100000) return 6;
if (i >= 10000) return 5;
if (i >= 1000) return 4;
if (i >= 100) return 3;
if (i >= 10) return 2;
return 1;
}
@Override
public void print(int i) {
ensureBuffer(11);
if (i < 0) {
if (i == -2147483648) {
buffer[read++] = '-';
buffer[read++] = '2';
buffer[read++] = '1';
buffer[read++] = '4';
buffer[read++] = '7';
buffer[read++] = '4';
buffer[read++] = '8';
buffer[read++] = '3';
buffer[read++] = '6';
buffer[read++] = '4';
buffer[read++] = '8';
return;
}
buffer[read++] = '-';
i = -i;
}
final int digit = digit(i);
int j = read + digit;
while (j-- > read) {
buffer[j] = (byte) (i % 10 + '0');
i /= 10;
}
read += digit;
}
private static int digit(final long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
@Override
public void print(long l) {
ensureBuffer(20);
if (l < 0) {
if (l == -9223372036854775808L) {
buffer[read++] = '-';
buffer[read++] = '9';
buffer[read++] = '2';
buffer[read++] = '2';
buffer[read++] = '3';
buffer[read++] = '3';
buffer[read++] = '7';
buffer[read++] = '2';
buffer[read++] = '0';
buffer[read++] = '3';
buffer[read++] = '6';
buffer[read++] = '8';
buffer[read++] = '5';
buffer[read++] = '4';
buffer[read++] = '7';
buffer[read++] = '7';
buffer[read++] = '5';
buffer[read++] = '8';
buffer[read++] = '0';
buffer[read++] = '8';
return;
}
buffer[read++] = '-';
l = -l;
}
final int digit = digit(l);
int i = read + digit;
while (i-- > read) {
buffer[i] = (byte) (l % 10 + '0');
l /= 10;
}
read += digit;
}
@Override
public void print(final float f) {
print(Float.toString(f));
}
@Override
public void print(final double d) {
print(Double.toString(d));
}
public void print(double d, final int n) {
if (d < 0) {
ensureBuffer(1);
buffer[read++] = '-';
d = -d;
}
d += Math.pow(10, -n) / 2;
final long l = (long) d;
print(l);
ensureBuffer(n + 1);
buffer[read++] = '.';
d -= l;
for (int i = 0; i < n; i++) {
d *= 10;
final int in = (int) d;
buffer[read++] = (byte) (in + '0');
d -= in;
}
}
@Override
public void print(final char c) {
if (c < 0x80) {
ensureBuffer(1);
buffer[read++] = (byte) c;
} else if (c < 0x07FF) {
ensureBuffer(2);
buffer[read++] = (byte) (c >> 6 & 0x3F | 0x80);
buffer[read++] = (byte) (c & 0x3F | 0x80);
} else {
ensureBuffer(3);
buffer[read++] = (byte) (c >> 12 & 0xF | 0xE0);
buffer[read++] = (byte) (c >> 6 & 0x3F | 0x80);
buffer[read++] = (byte) (c & 0x3F | 0x80);
}
}
@Override
public void print(final char[] s) {
for (final char i : s) print(i);
}
@Override
public void print(final String s) {
print(s.toCharArray());
}
@Override
public void print(final Object o) {
print(o.toString());
}
@Override
public Output printf(final java.util.Locale l, final String format, final Object... args) {
print(String.format(l, format, args));
return this;
}
@Override
public Output printf(final String format, final Object... args) {
print(String.format(format, args));
return this;
}
@Override
public void println() {
ensureBuffer(1);
buffer[read++] = '\n';
if (autoFlush) flush();
}
@Override
public void println(final boolean b) {
print(b);
println();
}
public void println(final byte b) {
print(b);
println();
}
public void println(final short s) {
print(s);
println();
}
@Override
public void println(final int i) {
print(i);
println();
}
@Override
public void println(final long l) {
print(l);
println();
}
@Override
public void println(final float f) {
print(f);
println();
}
@Override
public void println(final double d) {
print(d);
println();
}
public void println(final double d, final int n) {
print(d, n);
println();
}
@Override
public void println(final char c) {
print(c);
println();
}
@Override
public void println(final char[] s) {
print(s);
println();
}
@Override
public void println(final String s) {
print(s);
println();
}
@Override
public void println(final Object o) {
print(o);
println();
}
@Override
public Output append(final char c) {
print(c);
return this;
}
@Override
public Output append(CharSequence csq) {
if (csq == null) csq = "null";
print(csq.toString());
return this;
}
@Override
public Output append(CharSequence csq, final int start, final int end) {
if (csq == null) csq = "null";
print(csq.subSequence(start, end).toString());
return this;
}
}
public static final class DummyOut extends java.io.PrintStream {
public DummyOut() {
super(new Dummy());
}
private static class Dummy extends java.io.OutputStream {
@Override
public void close() {
}
@Override
public void flush() {
}
@Override
public void write(final byte[] b) {
}
@Override
public void write(final byte[] b, final int off, final int len) {
}
@Override
public void write(final int b) {
}
}
}
}
|
ConDefects/ConDefects/Code/abc357_f/Java/54386120
|
condefects-java_data_888
|
// package Codeforce;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
static Reader in = new Reader();
public static void main(String[] args) {
// int t = in.nextInt();
// while (t-- > 0) {
// solve();
// }
solve();
out.close();
}
static long MOD = 998244353;
static void solve() {
int n = in.nextInt(), q = in.nextInt();
long[] nums1 = in.nextLongArray(n);
long[] nums2 = in.nextLongArray(n);
SegmentTree st = new SegmentTree();
for (int i = 0; i < n; i++) {
st.update(i, i, nums1[i], nums2[i]);
}
while (q-- > 0) {
int c = in.nextInt(), l = in.nextInt() - 1, r = in.nextInt() - 1;
if (c == 3) {
long ans = st.query(l, r);
out.println(ans);
continue;
}
long v = in.nextLong();
if (c == 1) {
st.update(l, r, v, 0);
} else {
st.update(l, r, 0, v);
}
}
}
// 区间求和（累加）
static class SegmentTree {
static class Node {
Node left, right;
long val, add;
}
Node root_a = new Node();
Node root_b = new Node();
Node root_ab = new Node();
int N = (int) 1e9;
long MOD = 998244353;
public void update(int left, int right, long x, long y) {
update(root_a, root_b, root_ab, 0, N, left, right, x % MOD, y % MOD);
}
private void update(Node a, Node b, Node ab, int start, int end, int left, int right, long x, long y) {
if (left <= start && right >= end) {
ab.val += y * a.val % MOD + x * b.val % MOD + (end - start + 1) * x % MOD * y % MOD;
ab.val %= MOD;
a.val += (end - start + 1) * x;
a.val %= MOD;
a.add = x;
b.val += (end - start + 1) * y;
b.val %= MOD;
b.add = y;
return;
}
int mid = start + (end - start) / 2;
pushDown(ab, a, b, mid - start + 1, end - mid);
if (left <= mid) update(a.left, b.left, ab.left, start, mid, left, right, x, y);
if (right > mid) update(a.right, b.right, ab.right, mid + 1, end, left, right, x, y);
pushUp(a);
pushUp(b);
pushUp(ab);
}
public long query(int left, int right) {
return query(root_a, root_b, root_ab, 0, N, left, right);
}
private long query(Node a, Node b, Node ab, int start, int end, int left, int right) {
if (left <= start && right >= end) {
return ab.val;
}
int mid = start + (end - start) / 2;
pushDown(ab, a, b, mid - start + 1, end - mid);
long res = 0;
if (left <= mid) res += query(a.left, b.left, ab.left, start, mid, left, right);
if (right > mid) res += query(a.right, b.right, ab.right, mid + 1, end, left, right);
return res % MOD;
}
private void pushUp(Node node) {
node.val = (node.left.val + node.right.val) % MOD;
}
private void pushDown(Node node, int leftNum, int rightNum) {
if (node.add == 0) return;
node.left.val += node.add * leftNum;
node.left.val %= MOD;
node.right.val += node.add * rightNum;
node.right.val %= MOD;
node.left.add += node.add;
node.left.add %= MOD;
node.right.add += node.add;
node.right.add %= MOD;
node.add = 0;
}
void pushDown(Node node) {
if (node.left == null) node.left = new Node();
if (node.right == null) node.right = new Node();
}
private void pushDown(Node node, Node a, Node b, int leftNum, int rightNum) {
pushDown(node);
pushDown(a);
pushDown(b);
long x = a.add, y = b.add;
if (x == 0 && y == 0) {
return;
}
node.left.val += x * b.left.val % MOD + y * a.left.val % MOD + x * y % MOD * leftNum % MOD;
node.left.val %= MOD;
node.right.val += x * b.right.val % MOD + y * a.right.val % MOD + x * y % MOD * rightNum % MOD;
node.right.val %= MOD;
pushDown(a, leftNum, rightNum);
pushDown(b, leftNum, rightNum);
}
}
static class DSU {
int[] parent;
public DSU(int n) {
parent = new int[n];
Arrays.setAll(parent, i -> i);
}
int find(int x) {
return parent[x] = parent[x] == x ? x : find(parent[x]);
}
void union(int x, int y) {
parent[find(x)] = parent[find(y)];
}
boolean connect(int x, int y) {
return find(parent[x]) == find(parent[y]);
}
}
static class Reader {
private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
private StringTokenizer st;
boolean hasNext() {
try {
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
} catch (Exception e) {
return false;
}
return true;
}
String next() {
try {
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
} catch (Exception ignored) {
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
long nextLong() {
return java.lang.Long.parseLong(next());
}
long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
String nextLine() {
String s = "";
try {
s = br.readLine();
} catch (Exception ignored) {
}
return s;
}
}
}
// package Codeforce;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
static Reader in = new Reader();
public static void main(String[] args) {
// int t = in.nextInt();
// while (t-- > 0) {
// solve();
// }
solve();
out.close();
}
static long MOD = 998244353;
static void solve() {
int n = in.nextInt(), q = in.nextInt();
long[] nums1 = in.nextLongArray(n);
long[] nums2 = in.nextLongArray(n);
SegmentTree st = new SegmentTree();
for (int i = 0; i < n; i++) {
st.update(i, i, nums1[i], nums2[i]);
}
while (q-- > 0) {
int c = in.nextInt(), l = in.nextInt() - 1, r = in.nextInt() - 1;
if (c == 3) {
long ans = st.query(l, r);
out.println(ans);
continue;
}
long v = in.nextLong();
if (c == 1) {
st.update(l, r, v, 0);
} else {
st.update(l, r, 0, v);
}
}
}
// 区间求和（累加）
static class SegmentTree {
static class Node {
Node left, right;
long val, add;
}
Node root_a = new Node();
Node root_b = new Node();
Node root_ab = new Node();
int N = (int) 1e9;
long MOD = 998244353;
public void update(int left, int right, long x, long y) {
update(root_a, root_b, root_ab, 0, N, left, right, x % MOD, y % MOD);
}
private void update(Node a, Node b, Node ab, int start, int end, int left, int right, long x, long y) {
if (left <= start && right >= end) {
int mid = start + (end - start) / 2;
pushDown(ab, a, b, mid - start + 1, end - mid);
ab.val += y * a.val % MOD + x * b.val % MOD + (end - start + 1) * x % MOD * y % MOD;
ab.val %= MOD;
a.val += (end - start + 1) * x;
a.val %= MOD;
a.add = x;
b.val += (end - start + 1) * y;
b.val %= MOD;
b.add = y;
return;
}
int mid = start + (end - start) / 2;
pushDown(ab, a, b, mid - start + 1, end - mid);
if (left <= mid) update(a.left, b.left, ab.left, start, mid, left, right, x, y);
if (right > mid) update(a.right, b.right, ab.right, mid + 1, end, left, right, x, y);
pushUp(a);
pushUp(b);
pushUp(ab);
}
public long query(int left, int right) {
return query(root_a, root_b, root_ab, 0, N, left, right);
}
private long query(Node a, Node b, Node ab, int start, int end, int left, int right) {
if (left <= start && right >= end) {
return ab.val;
}
int mid = start + (end - start) / 2;
pushDown(ab, a, b, mid - start + 1, end - mid);
long res = 0;
if (left <= mid) res += query(a.left, b.left, ab.left, start, mid, left, right);
if (right > mid) res += query(a.right, b.right, ab.right, mid + 1, end, left, right);
return res % MOD;
}
private void pushUp(Node node) {
node.val = (node.left.val + node.right.val) % MOD;
}
private void pushDown(Node node, int leftNum, int rightNum) {
if (node.add == 0) return;
node.left.val += node.add * leftNum;
node.left.val %= MOD;
node.right.val += node.add * rightNum;
node.right.val %= MOD;
node.left.add += node.add;
node.left.add %= MOD;
node.right.add += node.add;
node.right.add %= MOD;
node.add = 0;
}
void pushDown(Node node) {
if (node.left == null) node.left = new Node();
if (node.right == null) node.right = new Node();
}
private void pushDown(Node node, Node a, Node b, int leftNum, int rightNum) {
pushDown(node);
pushDown(a);
pushDown(b);
long x = a.add, y = b.add;
if (x == 0 && y == 0) {
return;
}
node.left.val += x * b.left.val % MOD + y * a.left.val % MOD + x * y % MOD * leftNum % MOD;
node.left.val %= MOD;
node.right.val += x * b.right.val % MOD + y * a.right.val % MOD + x * y % MOD * rightNum % MOD;
node.right.val %= MOD;
pushDown(a, leftNum, rightNum);
pushDown(b, leftNum, rightNum);
}
}
static class DSU {
int[] parent;
public DSU(int n) {
parent = new int[n];
Arrays.setAll(parent, i -> i);
}
int find(int x) {
return parent[x] = parent[x] == x ? x : find(parent[x]);
}
void union(int x, int y) {
parent[find(x)] = parent[find(y)];
}
boolean connect(int x, int y) {
return find(parent[x]) == find(parent[y]);
}
}
static class Reader {
private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
private StringTokenizer st;
boolean hasNext() {
try {
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
} catch (Exception e) {
return false;
}
return true;
}
String next() {
try {
while (st == null || !st.hasMoreElements()) {
st = new StringTokenizer(br.readLine());
}
} catch (Exception ignored) {
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = nextInt();
}
return arr;
}
long nextLong() {
return java.lang.Long.parseLong(next());
}
long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++) {
arr[i] = nextLong();
}
return arr;
}
String nextLine() {
String s = "";
try {
s = br.readLine();
} catch (Exception ignored) {
}
return s;
}
}
}
|
ConDefects/ConDefects/Code/abc357_f/Java/54424987
|
condefects-java_data_889
|
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();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
int X = sc.nextInt();
StringBuilder ans = new StringBuilder();
//if ( X == 1 ) {
// solve0(ans, 1, N, -100, 1, -1, N, N);
//} else if ( X == N ) {
// solve0(ans, N, 1, -100, -1, 1, N, N);
//} else {
if ( N % 2 == 0 ) {
if ( X == N / 2 ) {
solve0(ans, N / 2, N / 2 + 1, -100, -1, 1, N, N);
} else if ( X == N / 2 + 1 ) {
solve0(ans, N / 2 + 1, N / 2, -100, 1, -1, N, N);
} else {
ans.append(X);
ans.append(" ");
if ( X < N / 2 ) {
solve0(ans, N / 2 + 1, N / 2, X, 1, -1, N, N - 1);
} else {
solve0(ans, N / 2, N / 2 + 1, X, -1, 1, N, N - 1);
}
}
} else {
if ( X == N / 2 + 1 ) {
solve0(ans, N / 2 + 1, N / 2, -100, 1, -1, N, N);
} else if ( X < N / 2 ) {
ans.append(X);
ans.append(" ");
solve0(ans, N / 2 + 1, N / 2 + 2, X, -1, 1, N, N - 1);
} else {
ans.append(X);
ans.append(" ");
solve0(ans, N / 2 + 1, N / 2, X, 1, -1, N, N - 1);
}
}
//}
System.out.println(ans.toString());
}
void solve0(StringBuilder ans, int a0, int a1, int exc, int d0, int d1, int N, int cnt) {
for (int i = 0; i < cnt ; i++) {
if ( i % 2 == 0 ) {
if ( a0 == exc ) a0 += d0;
if ( a0 >= 1 && a0 <= N ) {
ans.append(a0);
ans.append(" ");
a0 += d0;
} else {
break;
}
} else {
if ( a1 == exc ) a1 += d1;
if ( a1 >= 1 && a1 <= N ) {
ans.append(a1);
ans.append(" ");
a1 += d1;
} else {
break;
}
}
}
ans.deleteCharAt(ans.length() - 1);
}
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();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
int X = sc.nextInt();
StringBuilder ans = new StringBuilder();
//if ( X == 1 ) {
// solve0(ans, 1, N, -100, 1, -1, N, N);
//} else if ( X == N ) {
// solve0(ans, N, 1, -100, -1, 1, N, N);
//} else {
if ( N % 2 == 0 ) {
if ( X == N / 2 ) {
solve0(ans, N / 2, N / 2 + 1, -100, -1, 1, N, N);
} else if ( X == N / 2 + 1 ) {
solve0(ans, N / 2 + 1, N / 2, -100, 1, -1, N, N);
} else {
ans.append(X);
ans.append(" ");
if ( X < N / 2 ) {
solve0(ans, N / 2 + 1, N / 2, X, 1, -1, N, N - 1);
} else {
solve0(ans, N / 2, N / 2 + 1, X, -1, 1, N, N - 1);
}
}
} else {
if ( X == N / 2 + 1 ) {
solve0(ans, N / 2 + 1, N / 2, -100, 1, -1, N, N);
} else if ( X <= N / 2 ) {
ans.append(X);
ans.append(" ");
solve0(ans, N / 2 + 1, N / 2 + 2, X, -1, 1, N, N - 1);
} else {
ans.append(X);
ans.append(" ");
solve0(ans, N / 2 + 1, N / 2, X, 1, -1, N, N - 1);
}
}
//}
System.out.println(ans.toString());
}
void solve0(StringBuilder ans, int a0, int a1, int exc, int d0, int d1, int N, int cnt) {
for (int i = 0; i < cnt ; i++) {
if ( i % 2 == 0 ) {
if ( a0 == exc ) a0 += d0;
if ( a0 >= 1 && a0 <= N ) {
ans.append(a0);
ans.append(" ");
a0 += d0;
} else {
break;
}
} else {
if ( a1 == exc ) a1 += d1;
if ( a1 >= 1 && a1 <= N ) {
ans.append(a1);
ans.append(" ");
a1 += d1;
} else {
break;
}
}
}
ans.deleteCharAt(ans.length() - 1);
}
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/arc140_c/Java/31724445
|
condefects-java_data_890
|
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.management.ManagementFactory;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.NoSuchElementException;
import java.util.stream.IntStream;
public class Main{
long st = ManagementFactory.getRuntimeMXBean().getStartTime();
boolean isDebug = ManagementFactory.getRuntimeMXBean().getInputArguments().toString().indexOf("-agentlib:jdwp") > 0;
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
public static void main(final String[] args){ new Main().exe(); }
void exe(){
input();
preCalc();
solve();
pw.flush();
info(System.currentTimeMillis() -st);
}
int N = sc.it();
int X = sc.it();
void input(){}
void preCalc(){}
void solve(){
Deque<Integer> que1 = new ArrayDeque<>();
Deque<Integer> que2 = new ArrayDeque<>();
for (int i = 1;i <= N /2;i++)
que1.add(i);
for (int i = N;i > N /2;i--)
que2.add(i);
que1.remove(X);
que2.remove(X);
while (que1.size() < que2.size())
que1.add(que2.pollLast());
int[] ret = createA(que1,que2);
out(ret);
}
private int[] createA(Deque<Integer> que1,Deque<Integer> que2){
int[] ret = new int[N];
ret[0] = X;
if (N /2 *2 != N) {
for (int i = 1;i < N;i += 2)
ret[i] = que1.pollLast();
for (int i = 2;i < N;i += 2)
ret[i] = que2.pollLast();
} else {
que2.add(que1.pollLast());
for (int i = 2;i < N;i += 2)
ret[i] = que1.pollLast();
for (int i = 1;i < N;i += 2)
ret[i] = que2.pollLast();
}
return ret;
}
/* 出力 */
void out(final Object ret){ pw.println(ret); }
void out(final int[] ret){
final StringBuilder sb = new StringBuilder();
sb.append(ret[0]);
for (int i = 1;i < ret.length;i++)
sb.append(" " +ret[i]);
pw.println(sb.toString());
}
void debug(final boolean info){
if (isDebug && info)
System.out.println();
}
void info(final Object info){
if (isDebug)
System.out.println(info);
}
/* 入力 */
static class FastScanner{
final byte[] buf = new byte[1024];
int ptr = 0;
int buflen = 0;
boolean hasNextByte(){
if (ptr >= buflen) {
ptr = 0;
try {
buflen = System.in.read(buf);
} catch (final IOException e) {
e.printStackTrace();
}
if (buflen <= 0)
return false;
}
return true;
}
int readByte(){
if (hasNextByte())
return buf[ptr++];
else
return -1;
}
boolean isPrintableChar(final int c){ return 33 <= c && c <= 126; }
boolean isNumeric(final int c){ return '0' <= c && c <= '9'; }
void skipToNextPrintableChar(){
while (hasNextByte() && !isPrintableChar(buf[ptr]))
ptr++;
}
boolean hasNext(){
skipToNextPrintableChar();
return hasNextByte();
}
long lg(){
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();
}
}
long[] lg(final int N){ return IntStream.range(0,N).mapToLong(i -> lg()).toArray(); }
double dbl(){ return Double.parseDouble(str()); }
int it(){ return Math.toIntExact(lg()); }
int[] it(final int N){ return IntStream.range(0,N).map(i -> it()).toArray(); }
int[][] it(final int H,final int W){
final int[][] ret = new int[H][];
Arrays.setAll(ret,i -> it(W));
return ret;
}
int idx(){ return it() -1; }
int[] idx(final int N){ return IntStream.range(0,N).map(i -> idx()).toArray(); }
String str(){
if (!hasNext())
throw new NoSuchElementException();
final StringBuilder ret = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
ret.appendCodePoint(b);
b = readByte();
}
return ret.toString();
}
char[] ch(){ return str().toCharArray(); }
public char[][] ch(final int H){
final char[][] ret = new char[H][];
Arrays.setAll(ret,i -> ch());
return ret;
}
}
}
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.management.ManagementFactory;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.NoSuchElementException;
import java.util.stream.IntStream;
public class Main{
long st = ManagementFactory.getRuntimeMXBean().getStartTime();
boolean isDebug = ManagementFactory.getRuntimeMXBean().getInputArguments().toString().indexOf("-agentlib:jdwp") > 0;
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
public static void main(final String[] args){ new Main().exe(); }
void exe(){
input();
preCalc();
solve();
pw.flush();
info(System.currentTimeMillis() -st);
}
int N = sc.it();
int X = sc.it();
void input(){}
void preCalc(){}
void solve(){
Deque<Integer> que1 = new ArrayDeque<>();
Deque<Integer> que2 = new ArrayDeque<>();
for (int i = 1;i <= N /2;i++)
que1.add(i);
for (int i = N;i > N /2;i--)
que2.add(i);
que1.remove(X);
que2.remove(X);
while (que1.size() < que2.size())
que1.add(que2.pollLast());
int[] ret = createA(que1,que2);
out(ret);
}
private int[] createA(Deque<Integer> que1,Deque<Integer> que2){
int[] ret = new int[N];
ret[0] = X;
if (X *2 != N) {
for (int i = 1;i < N;i += 2)
ret[i] = que1.pollLast();
for (int i = 2;i < N;i += 2)
ret[i] = que2.pollLast();
} else {
que2.add(que1.pollLast());
for (int i = 2;i < N;i += 2)
ret[i] = que1.pollLast();
for (int i = 1;i < N;i += 2)
ret[i] = que2.pollLast();
}
return ret;
}
/* 出力 */
void out(final Object ret){ pw.println(ret); }
void out(final int[] ret){
final StringBuilder sb = new StringBuilder();
sb.append(ret[0]);
for (int i = 1;i < ret.length;i++)
sb.append(" " +ret[i]);
pw.println(sb.toString());
}
void debug(final boolean info){
if (isDebug && info)
System.out.println();
}
void info(final Object info){
if (isDebug)
System.out.println(info);
}
/* 入力 */
static class FastScanner{
final byte[] buf = new byte[1024];
int ptr = 0;
int buflen = 0;
boolean hasNextByte(){
if (ptr >= buflen) {
ptr = 0;
try {
buflen = System.in.read(buf);
} catch (final IOException e) {
e.printStackTrace();
}
if (buflen <= 0)
return false;
}
return true;
}
int readByte(){
if (hasNextByte())
return buf[ptr++];
else
return -1;
}
boolean isPrintableChar(final int c){ return 33 <= c && c <= 126; }
boolean isNumeric(final int c){ return '0' <= c && c <= '9'; }
void skipToNextPrintableChar(){
while (hasNextByte() && !isPrintableChar(buf[ptr]))
ptr++;
}
boolean hasNext(){
skipToNextPrintableChar();
return hasNextByte();
}
long lg(){
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();
}
}
long[] lg(final int N){ return IntStream.range(0,N).mapToLong(i -> lg()).toArray(); }
double dbl(){ return Double.parseDouble(str()); }
int it(){ return Math.toIntExact(lg()); }
int[] it(final int N){ return IntStream.range(0,N).map(i -> it()).toArray(); }
int[][] it(final int H,final int W){
final int[][] ret = new int[H][];
Arrays.setAll(ret,i -> it(W));
return ret;
}
int idx(){ return it() -1; }
int[] idx(final int N){ return IntStream.range(0,N).map(i -> idx()).toArray(); }
String str(){
if (!hasNext())
throw new NoSuchElementException();
final StringBuilder ret = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
ret.appendCodePoint(b);
b = readByte();
}
return ret.toString();
}
char[] ch(){ return str().toCharArray(); }
public char[][] ch(final int H){
final char[][] ret = new char[H][];
Arrays.setAll(ret,i -> ch());
return ret;
}
}
}
|
ConDefects/ConDefects/Code/arc140_c/Java/31730284
|
condefects-java_data_891
|
import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;
/**
* * @author zhengnaishan
* * @date 2022/12/7 10:04
*/
public class Main {
public static void main(String[] args) {
Kattio io = new Kattio();
int n = io.nextInt();
int x = io.nextInt();
LinkedList<Integer> queue = new LinkedList<>();
for (int i = 1; i <= n; i++) {
if (i != x) queue.add(i);
}
int[] dp1 = new int[n];
int[] dp2 = new int[n];
int index = n - 1;
while (!queue.isEmpty()) {
Integer a = queue.pollLast();
if (!queue.isEmpty()) {
Integer b = queue.pollFirst();
dp1[index] = a;
dp2[index] = b;
index--;
dp1[index] = b;
dp2[index] = a;
index--;
} else {
dp1[index] = dp2[index] = a;
index--;
}
}
dp1[0] = dp2[0] = x;
int[] dp;
if (Math.abs(dp1[0] - dp1[1]) == 1) {
dp = dp1;
} else {
dp = dp2;
}
for (int i = 0; i < n; i++) {
System.out.print(dp[i] + " ");
}
io.flush();
}
public static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// 标准 IO
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// 文件 IO
public Kattio(String intput, String output) throws IOException {
super(output);
r = new BufferedReader(new FileReader(intput));
}
// 在没有其他输入时返回 null
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) {
}
return null;
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;
/**
* * @author zhengnaishan
* * @date 2022/12/7 10:04
*/
public class Main {
public static void main(String[] args) {
Kattio io = new Kattio();
int n = io.nextInt();
int x = io.nextInt();
LinkedList<Integer> queue = new LinkedList<>();
for (int i = 1; i <= n; i++) {
if (i != x) queue.add(i);
}
int[] dp1 = new int[n];
int[] dp2 = new int[n];
int index = n - 1;
while (!queue.isEmpty()) {
Integer a = queue.pollLast();
if (!queue.isEmpty()) {
Integer b = queue.pollFirst();
dp1[index] = a;
dp2[index] = b;
index--;
dp1[index] = b;
dp2[index] = a;
index--;
} else {
dp1[index] = dp2[index] = a;
index--;
}
}
dp1[0] = dp2[0] = x;
int[] dp;
if (n > 2 && Math.abs(dp1[0] - dp1[1]) == 1 && Math.abs(dp1[2] - dp1[1]) == 2) {
dp = dp1;
} else {
dp = dp2;
}
for (int i = 0; i < n; i++) {
System.out.print(dp[i] + " ");
}
io.flush();
}
public static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// 标准 IO
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// 文件 IO
public Kattio(String intput, String output) throws IOException {
super(output);
r = new BufferedReader(new FileReader(intput));
}
// 在没有其他输入时返回 null
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) {
}
return null;
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
}
|
ConDefects/ConDefects/Code/arc140_c/Java/37071964
|
condefects-java_data_892
|
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
FastScanner str=new FastScanner(System.in);
PrintWriter out=new PrintWriter(System.out);
String s=str.next();
String t=str.next();
int[] s1=new int[130];
int[] t1=new int[130];
for(int i=0;i<s.length();i++){
s1[s.charAt(i)]++;
t1[t.charAt(i)]++;
}
boolean ans=true;
int sa=s1['@'];
int ta=t1['@'];
int s_diff=0;
int t_diff=0;
for(int i='a';i<='z';i++){
int s2=s1[i];
int t2=s1[i];
if(i=='a'||i=='t'||i=='c'||i=='o'||i=='d'||i=='e'||i=='r'){
if(s2>t2){
s_diff+=s2-t2;
}else if(s2<t2){
t_diff+=t2-s2;
}
}else{
if(s2!=t2)ans=false;
}
}
sa-=t_diff;
ta-=s_diff;
if(sa<0||ta<0)ans=false;
if(ans){
out.println("Yes");
}else{
out.println("No");
}
out.flush();
}
}
class FastScanner implements Closeable {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public FastScanner(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;}
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 void close() {
try {
in.close();
} catch (IOException e) {
}
}
}
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
FastScanner str=new FastScanner(System.in);
PrintWriter out=new PrintWriter(System.out);
String s=str.next();
String t=str.next();
int[] s1=new int[130];
int[] t1=new int[130];
for(int i=0;i<s.length();i++){
s1[s.charAt(i)]++;
t1[t.charAt(i)]++;
}
boolean ans=true;
int sa=s1['@'];
int ta=t1['@'];
int s_diff=0;
int t_diff=0;
for(int i='a';i<='z';i++){
int s2=s1[i];
int t2=t1[i];
if(i=='a'||i=='t'||i=='c'||i=='o'||i=='d'||i=='e'||i=='r'){
if(s2>t2){
s_diff+=s2-t2;
}else if(s2<t2){
t_diff+=t2-s2;
}
}else{
if(s2!=t2)ans=false;
}
}
sa-=t_diff;
ta-=s_diff;
if(sa<0||ta<0)ans=false;
if(ans){
out.println("Yes");
}else{
out.println("No");
}
out.flush();
}
}
class FastScanner implements Closeable {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public FastScanner(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;}
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 void close() {
try {
in.close();
} catch (IOException e) {
}
}
}
|
ConDefects/ConDefects/Code/abc301_c/Java/43574659
|
condefects-java_data_893
|
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
// アルファベットごとに文字数をカウントする
ArrayList<Character> s = new ArrayList<Character>();
ArrayList<Character> t = new ArrayList<Character>();
int[] sAtcoder = new int[8];
int[] tAtcoder = new int[8];
for (char str : sc.next().toCharArray()) {
switch (str) {
case 'a':
sAtcoder[0]++;
break;
case 't':
sAtcoder[1]++;
break;
case 'c':
sAtcoder[2]++;
break;
case 'o':
sAtcoder[3]++;
break;
case 'd':
sAtcoder[4]++;
break;
case 'e':
sAtcoder[5]++;
break;
case 'r':
sAtcoder[6]++;
break;
case '@':
sAtcoder[7]++;
break;
default:
s.add(str);
break;
}
}
for (char str : sc.next().toCharArray()) {
switch (str) {
case 'a':
tAtcoder[0]++;
break;
case 't':
tAtcoder[1]++;
break;
case 'c':
tAtcoder[2]++;
break;
case 'o':
tAtcoder[3]++;
break;
case 'd':
tAtcoder[4]++;
break;
case 'e':
tAtcoder[5]++;
break;
case 'r':
tAtcoder[6]++;
break;
case '@':
tAtcoder[7]++;
break;
default:
t.add(str);
break;
}
}
// 準備完了 atcoderから比較していく
for (int i = 0; i < 7; i++) {
if (tAtcoder[i] == sAtcoder[i]) {
continue;
} else if (tAtcoder[i] > sAtcoder[i]) {
int diff = tAtcoder[i] - sAtcoder[i];
sAtcoder[7] -= diff;
} else {
int diff = sAtcoder[i] - tAtcoder[i];
tAtcoder[7] -= diff;
}
}
// ワイルドカードが0出ないければ一致しない
if (sAtcoder[7] != tAtcoder[7]) {
pw.println("No");
pw.flush();
return;
}
// その他の文字をみる
Collections.sort(s);
Collections.sort(t);
for (int i = 0; i < s.size(); i++) {
if (s.get(i) != t.get(i)) {
pw.println("No");
pw.flush();
return;
}
}
pw.println("Yes");
pw.flush();
}
}
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
// アルファベットごとに文字数をカウントする
ArrayList<Character> s = new ArrayList<Character>();
ArrayList<Character> t = new ArrayList<Character>();
int[] sAtcoder = new int[8];
int[] tAtcoder = new int[8];
for (char str : sc.next().toCharArray()) {
switch (str) {
case 'a':
sAtcoder[0]++;
break;
case 't':
sAtcoder[1]++;
break;
case 'c':
sAtcoder[2]++;
break;
case 'o':
sAtcoder[3]++;
break;
case 'd':
sAtcoder[4]++;
break;
case 'e':
sAtcoder[5]++;
break;
case 'r':
sAtcoder[6]++;
break;
case '@':
sAtcoder[7]++;
break;
default:
s.add(str);
break;
}
}
for (char str : sc.next().toCharArray()) {
switch (str) {
case 'a':
tAtcoder[0]++;
break;
case 't':
tAtcoder[1]++;
break;
case 'c':
tAtcoder[2]++;
break;
case 'o':
tAtcoder[3]++;
break;
case 'd':
tAtcoder[4]++;
break;
case 'e':
tAtcoder[5]++;
break;
case 'r':
tAtcoder[6]++;
break;
case '@':
tAtcoder[7]++;
break;
default:
t.add(str);
break;
}
}
// 準備完了 atcoderから比較していく
for (int i = 0; i < 7; i++) {
if (tAtcoder[i] == sAtcoder[i]) {
continue;
} else if (tAtcoder[i] > sAtcoder[i]) {
int diff = tAtcoder[i] - sAtcoder[i];
sAtcoder[7] -= diff;
} else {
int diff = sAtcoder[i] - tAtcoder[i];
tAtcoder[7] -= diff;
}
}
// ワイルドカードが0出ないければ一致しない
if (sAtcoder[7] != tAtcoder[7] || sAtcoder[7] < 0 || tAtcoder[7] < 0) {
pw.println("No");
pw.flush();
return;
}
// その他の文字をみる
Collections.sort(s);
Collections.sort(t);
for (int i = 0; i < s.size(); i++) {
if (s.get(i) != t.get(i)) {
pw.println("No");
pw.flush();
return;
}
}
pw.println("Yes");
pw.flush();
}
}
|
ConDefects/ConDefects/Code/abc301_c/Java/41673613
|
condefects-java_data_894
|
import java.util.*;
class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int B = sc.nextInt();
int ans = 7;
//4点の問題解けたかな？
if(A < 4 && B < 4){
ans -= 4;
}
//2点の問題は解けたかな？
if(A % 4 < 2 && B % 4 < 2){
ans -= 2;
}
//1点の問題は解けたかな？
if(A % 4 < 1 && B % 4 < 1){
ans--;
}
System.out.print(ans);
}
}
import java.util.*;
class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int A = sc.nextInt();
int B = sc.nextInt();
int ans = 7;
//4点の問題解けたかな？
if(A < 4 && B < 4){
ans -= 4;
}
//2点の問題は解けたかな？
if(A % 4 < 2 && B % 4 < 2){
ans -= 2;
}
//1点の問題は解けたかな？
if(A % 2 < 1 && B % 2 < 1){
ans--;
}
System.out.print(ans);
}
}
|
ConDefects/ConDefects/Code/abc270_a/Java/45784125
|
condefects-java_data_895
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int s = sc.nextInt();
int ans = 0;
if(t/4 == 1 || s/4 == 1 ) {
ans += 4;
}
t %= 4;
s %= 4;
if(t/2 == 1 || s/2 == 1) {
ans += 2;
}
t %= 2;
s %= 1;
if(t == 1 || s == 1) {
ans += 1;
}
System.out.print(ans);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
int s = sc.nextInt();
int ans = 0;
if(t/4 == 1 || s/4 == 1 ) {
ans += 4;
}
t %= 4;
s %= 4;
if(t/2 == 1 || s/2 == 1) {
ans += 2;
}
t %= 2;
s %= 2;
if(t == 1 || s == 1) {
ans += 1;
}
System.out.print(ans);
}
}
|
ConDefects/ConDefects/Code/abc270_a/Java/39838809
|
condefects-java_data_896
|
import java.util.*;
// A - 1-2-4 Test
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int s = 0;
String a = String.format("%3s", Integer.toBinaryString(sc.nextInt())).replace(" ", "0");
String b = String.format("%3s", Integer.toBinaryString(sc.nextInt())).replace(" ", "0");
if(a.indexOf("1") == -1 && b.indexOf("1") == -1) {
System.out.println(0);
}
if(a.startsWith("1") || b.startsWith("1")) {
s += 4;
}
if(a.indexOf("1", 1) == 1 || b.indexOf("1", 1) == 1) {
s += 2;
}
if(a.endsWith("1") || b.endsWith("1")) {
s += 1;
}
System.out.println(s);
}
}
import java.util.*;
// A - 1-2-4 Test
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int s = 0;
String a = String.format("%3s", Integer.toBinaryString(sc.nextInt())).replace(" ", "0");
String b = String.format("%3s", Integer.toBinaryString(sc.nextInt())).replace(" ", "0");
if(a.indexOf("1") == -1 && b.indexOf("1") == -1) {
s += 0;
}
if(a.startsWith("1") || b.startsWith("1")) {
s += 4;
}
if(a.indexOf("1", 1) == 1 || b.indexOf("1", 1) == 1) {
s += 2;
}
if(a.endsWith("1") || b.endsWith("1")) {
s += 1;
}
System.out.println(s);
}
}
|
ConDefects/ConDefects/Code/abc270_a/Java/37723878
|
condefects-java_data_897
|
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int p = sc.nextInt();
int q = sc.nextInt();
int minMenu = sc.nextInt();
for(int i=4; i<args.length; i++){
int a = sc.nextInt();
if(minMenu > a){
minMenu = a;
}
}
int pay = q + minMenu;
int result = p;
if(pay < p){
result = pay;
}
System.out.println(result);
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int p = sc.nextInt();
int q = sc.nextInt();
int minMenu = sc.nextInt();
for(int i=0; i<n-1; i++){
int a = sc.nextInt();
if(minMenu > a){
minMenu = a;
}
}
int pay = q + minMenu;
int result = p;
if(pay < p){
result = pay;
}
System.out.println(result);
}
}
|
ConDefects/ConDefects/Code/abc310_a/Java/44215608
|
condefects-java_data_898
|
import java.util.Scanner;
public class Main {
public static void main(String args[]){
//Using booleans when dealing with yes/no, true/false, 1/0.. , minimising no of variables
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int orgPrice = sc.nextInt();
int discPrice = sc.nextInt();
int minDPrice = sc.nextInt();
int[] dishesPrice = new int[N];
for(int i = 1; i < N-1; i++){
dishesPrice[i] = sc.nextInt();
if(dishesPrice[i] < minDPrice) minDPrice = dishesPrice[i];
}
if(orgPrice > (minDPrice + discPrice)) System.out.println(minDPrice + discPrice);
else System.out.println(orgPrice);
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]){
//Using booleans when dealing with yes/no, true/false, 1/0.. , minimising no of variables
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int orgPrice = sc.nextInt();
int discPrice = sc.nextInt();
int minDPrice = sc.nextInt();
int[] dishesPrice = new int[N];
for(int i = 1; i < N; i++){
dishesPrice[i] = sc.nextInt();
if(dishesPrice[i] < minDPrice) minDPrice = dishesPrice[i];
}
if(orgPrice > (minDPrice + discPrice)) System.out.println(minDPrice + discPrice);
else System.out.println(orgPrice);
}
}
|
ConDefects/ConDefects/Code/abc310_a/Java/44919912
|
condefects-java_data_899
|
import java.io.*;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static FastScanner fs = new FastScanner();
static class MaxSegmentTree {
private final int[] segtree;
private final int len;
public MaxSegmentTree(int len) {
this.len = len;
segtree = new int[len * 2];
Arrays.fill(segtree, Integer.MAX_VALUE);
}
/** Sets the value at ind to val. */
public void set(int ind, int val) {
ind += len;
segtree[ind] = val;
for (; ind > 1; ind /= 2) {
segtree[ind / 2] = Math.max(segtree[ind], segtree[ind ^ 1]);
}
}
public int get(int ind) {
return segtree[ind];
}
/** @return the minimum of all elements in [start, end). */
public int rangeMax(int start, int end) {
int max = Integer.MIN_VALUE;
for (start += len, end += len; start < end; start /= 2, end /= 2) {
if (start % 2 == 1) { max = Math.max(max, segtree[start++]); }
if (end % 2 == 1) { max = Math.max(max, segtree[--end]); }
}
return max;
}
public int max(int l, int r) {
return rangeMax(l, r + 1);
}
}
static class PointScan {
MaxSegmentTree st;
PointScan() {
st = new MaxSegmentTree(600000);
for (int i = 0; i < 600000; i++) st.set(i, 0);
}
public void insert(int[] point) {
st.set(point[0], Math.max(point[1], st.get(point[0])));
}
public boolean containsGreater(int[] point) {
return st.max(point[0]+1,600000 - 1) > point[1];
}
}
public static HashMap<Integer, Integer> calculateCompressionMap(int[][] points) {
HashSet<Integer> set = new HashSet<>();
for (int[] i : points) {
for (int j : i) set.add(j);
}
ArrayList<Integer> order = new ArrayList<>(set);
Collections.sort(order);
HashMap<Integer, Integer> compressionMap = new HashMap<>();
for (int i = 0; i < order.size(); i++) {
compressionMap.put(order.get(i), i);
}
return compressionMap;
}
public static void solve() throws IOException {
int n = fs.nextInt();
int[][] points = new int[n][3];
for (int i = 0; i < n; i++) {
points[i][0] = fs.nextInt();
points[i][1] = fs.nextInt();
points[i][2] = fs.nextInt();
}
for (int[] i : points) {
Arrays.sort(i);
}
HashMap<Integer, Integer> compressionMap = calculateCompressionMap(points);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
points[i][j] = compressionMap.get(points[i][j]);
}
}
TreeMap<Integer, ArrayList<int[]>> byX = new TreeMap<>(Collections.reverseOrder());
for (int[] i : points) {
if(!byX.containsKey(i[0])) byX.put(i[0], new ArrayList<int[]>());
byX.get(i[0]).add(new int[] {i[1],i[2]});
}
for (int i : byX.keySet()) {
Collections.sort(byX.get(i), new Comparator<int[]>() {
public int compare(int[] a, int[] b) {
return a[0] - b[0];
}
});
}
PointScan ps = new PointScan();
for (int i : byX.keySet()) {
//out.println(i);
for (int[] j : byX.get(i)) {
if(ps.containsGreater(j)) {
out.println("Yes");
return;
}
}
for (int[] j : byX.get(i)) {
ps.insert(j);
}
}
out.println("No");
}
public static void main(String[] args) throws IOException {
solve();
out.close();
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
public static void shuffleArray(int[] arr) {
Random rand = new Random();
for (int i = arr.length - 1; i > 0; i--) {
int j = rand.nextInt(i + 1);
// Swap arr[i] with arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
import java.io.*;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static FastScanner fs = new FastScanner();
static class MaxSegmentTree {
private final int[] segtree;
private final int len;
public MaxSegmentTree(int len) {
this.len = len;
segtree = new int[len * 2];
Arrays.fill(segtree, Integer.MAX_VALUE);
}
/** Sets the value at ind to val. */
public void set(int ind, int val) {
ind += len;
segtree[ind] = val;
for (; ind > 1; ind /= 2) {
segtree[ind / 2] = Math.max(segtree[ind], segtree[ind ^ 1]);
}
}
public int get(int ind) {
return segtree[ind + len];
}
/** @return the minimum of all elements in [start, end). */
public int rangeMax(int start, int end) {
int max = Integer.MIN_VALUE;
for (start += len, end += len; start < end; start /= 2, end /= 2) {
if (start % 2 == 1) { max = Math.max(max, segtree[start++]); }
if (end % 2 == 1) { max = Math.max(max, segtree[--end]); }
}
return max;
}
public int max(int l, int r) {
return rangeMax(l, r + 1);
}
}
static class PointScan {
MaxSegmentTree st;
PointScan() {
st = new MaxSegmentTree(600000);
for (int i = 0; i < 600000; i++) st.set(i, 0);
}
public void insert(int[] point) {
st.set(point[0], Math.max(point[1], st.get(point[0])));
}
public boolean containsGreater(int[] point) {
return st.max(point[0]+1,600000 - 1) > point[1];
}
}
public static HashMap<Integer, Integer> calculateCompressionMap(int[][] points) {
HashSet<Integer> set = new HashSet<>();
for (int[] i : points) {
for (int j : i) set.add(j);
}
ArrayList<Integer> order = new ArrayList<>(set);
Collections.sort(order);
HashMap<Integer, Integer> compressionMap = new HashMap<>();
for (int i = 0; i < order.size(); i++) {
compressionMap.put(order.get(i), i);
}
return compressionMap;
}
public static void solve() throws IOException {
int n = fs.nextInt();
int[][] points = new int[n][3];
for (int i = 0; i < n; i++) {
points[i][0] = fs.nextInt();
points[i][1] = fs.nextInt();
points[i][2] = fs.nextInt();
}
for (int[] i : points) {
Arrays.sort(i);
}
HashMap<Integer, Integer> compressionMap = calculateCompressionMap(points);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
points[i][j] = compressionMap.get(points[i][j]);
}
}
TreeMap<Integer, ArrayList<int[]>> byX = new TreeMap<>(Collections.reverseOrder());
for (int[] i : points) {
if(!byX.containsKey(i[0])) byX.put(i[0], new ArrayList<int[]>());
byX.get(i[0]).add(new int[] {i[1],i[2]});
}
for (int i : byX.keySet()) {
Collections.sort(byX.get(i), new Comparator<int[]>() {
public int compare(int[] a, int[] b) {
return a[0] - b[0];
}
});
}
PointScan ps = new PointScan();
for (int i : byX.keySet()) {
//out.println(i);
for (int[] j : byX.get(i)) {
if(ps.containsGreater(j)) {
out.println("Yes");
return;
}
}
for (int[] j : byX.get(i)) {
ps.insert(j);
}
}
out.println("No");
}
public static void main(String[] args) throws IOException {
solve();
out.close();
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
public static void shuffleArray(int[] arr) {
Random rand = new Random();
for (int i = arr.length - 1; i > 0; i--) {
int j = rand.nextInt(i + 1);
// Swap arr[i] with arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
|
ConDefects/ConDefects/Code/abc309_f/Java/52415124
|
condefects-java_data_900
|
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
int n = nextInt();
T[] tt = new T[n];
for (int i = 0; i < n; i++) {
int[] a = new int[3];
for (int j = 0; j < 3; j++) {
a[j] = nextInt();
}
Arrays.sort(a);
tt[i] = new T(a[0], a[1], a[2]);
}
int[] ll = new int[n];
int[] mm = new int[n];
int[] hh = new int[n];
for (int i = 0; i < n; i++) {
ll[i] = tt[i].l;
mm[i] = tt[i].m;
hh[i] = tt[i].h;
}
ll = compress(ll);
mm = compress(mm);
hh = compress(hh);
for (int i = 0; i < n; i++) {
tt[i].l = ll[i];
tt[i].m = mm[i];
tt[i].h = hh[i];
}
Arrays.sort(tt, Comparator.comparing((T t) -> t.l).thenComparing(t -> -t.m));
Integer[] array = new Integer[n + 1];
Arrays.fill(array, Integer.MAX_VALUE);
SegTree<Integer> segTree = new SegTree<>(array, Math::min, Integer.MAX_VALUE);
for (T t : tt) {
if (segTree.query(0, t.m) < t.h) {
System.out.println("Yes");
return;
}
segTree.updateValue(t.m, Math.min(segTree.query(t.m, t.m+1), t.l));
}
System.out.println("No");
out.flush();
}
private static class T {
int l;
int m;
int h;
public T(int l, int m, int h) {
this.l = l;
this.m = m;
this.h = h;
}
@Override
public String toString() {
return "T{" +
"l=" + l +
", m=" + m +
", h=" + h +
'}';
}
}
private static int[] compress(int[] array) {
TreeSet<Integer> sortedElements = Arrays.stream(array).boxed().collect(Collectors.toCollection(TreeSet::new));
HashMap<Integer, Integer> map = new HashMap<>();
int count = 0;
for (int element: sortedElements) map.put(element, count++);
int[] res = new int[array.length];
for (int i = 0; i < array.length; i++) res[i] = map.get(array[i]);
return res;
}
static PrintWriter out = new PrintWriter(System.out);
static Scanner scanner = new Scanner(System.in);
static String next() { return scanner.next(); }
static int nextInt() {
int res = 0;
char[] chars = next().toCharArray();
boolean minus = chars[0] == '-';
int start = minus?1:0;
for (int i = start; i < chars.length; i++) {
res = res*10 + (chars[i]-'0');
}
return minus?-res:res;
}
static long nextLong() {
long res = 0;
char[] chars = next().toCharArray();
boolean minus = chars[0] == '-';
int start = minus?1:0;
for (int i = start; i < chars.length; i++) {
res = res*10 + (chars[i]-'0');
}
return minus?-res:res;
}
static double nextDouble() { return Double.parseDouble(next()); }
static int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) { array[i] = nextInt(); }
return array;
}
static long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) { array[i] = nextLong(); }
return array;
}
private static class SegTree<T> {
int n;
T[] tree;
BiFunction<T, T, T> op;
T unit;
private SegTree(T[] array, BiFunction<T, T, T> op, T unit) {
int len = array.length;
n = getSize(len);
tree = (T[]) new Object[2 * n - 1];
this.op = op;
this.unit = unit;
initTree(array, len);
}
private int getSize(final int len) {
int exp = 1;
while (len > exp) {
exp *= 2;
}
return exp;
}
private void initTree(final T[] array, final int len) {
Arrays.fill(tree, unit);
for (int i = 0; i < len; i++) {
tree[i + n - 1] = array[i]; // 葉のindexはn-1から2n-2まで
}
for (int i = n - 2; i >= 0; i--) {
updateNode(i);
}
}
private void updateNode(final int i) {
tree[i] = op.apply(tree[lChildOf(i)], tree[rChildOf(i)]);
}
/**
* 元の配列の値を更新する。
* 親のnodeに遡っての更新もする。
*
* @param i 元の配列のindex
* @param value 更新後の値
*/
public void updateValue(int i, T value) {
int index = i + n - 1;
tree[index] = value;
while (index > 0) {
index = parentOf(index);
updateNode(index);
}
}
/**
* 区間の値を求める
* 実装的には、親から子に下りながら見る。
*
*
* @param l 左端（inclusive）
* @param r 右端（exclusive）
*/
public T query(int l, int r) {
return doQuery(Math.min(l, r), Math.max(l, r), 0, 0, n);
}
/**
* 値の欲しい範囲が、今調べているnodeと被っていなかったらunitを返す。
* 値の欲しい範囲が広かったら、nodeの値をそのまま返す。
* 値の欲しい範囲が狭かったら、nodeの子に対して再度このメソッドを実行する。
*
* @param l 値の欲しい範囲の左端（inclusive）
* @param r 値の欲しい範囲の右端（exclusive）
* @param node 今調べているnode
* @param lEdge nodeが表す範囲の左端（inclusive）
* @param rEdge nodeが表す範囲の右端（exclusive）
*/
private T doQuery(int l, int r, int node, int lEdge, int rEdge) {
if (rEdge <= l || r <= lEdge) { return unit; }
if (l <= lEdge && rEdge <= r) { return tree[node]; }
return op.apply(
doQuery(l, r, lChildOf(node), lEdge, (lEdge+rEdge)/2),
doQuery(l, r, rChildOf(node), (lEdge+rEdge)/2, rEdge)
);
}
private int lChildOf(int i) {
return i * 2 + 1;
}
private int rChildOf(int i) {
return lChildOf(i) + 1;
}
private int parentOf(int i) {
return (i - 1) / 2;
}
}
}
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
int n = nextInt();
T[] tt = new T[n];
for (int i = 0; i < n; i++) {
int[] a = new int[3];
for (int j = 0; j < 3; j++) {
a[j] = nextInt();
}
Arrays.sort(a);
tt[i] = new T(a[0], a[1], a[2]);
}
int[] ll = new int[n];
int[] mm = new int[n];
int[] hh = new int[n];
for (int i = 0; i < n; i++) {
ll[i] = tt[i].l;
mm[i] = tt[i].m;
hh[i] = tt[i].h;
}
ll = compress(ll);
mm = compress(mm);
hh = compress(hh);
for (int i = 0; i < n; i++) {
tt[i].l = ll[i];
tt[i].m = mm[i];
tt[i].h = hh[i];
}
Arrays.sort(tt, Comparator.comparing((T t) -> t.l).thenComparing(t -> -t.m));
Integer[] array = new Integer[n + 1];
Arrays.fill(array, Integer.MAX_VALUE);
SegTree<Integer> segTree = new SegTree<>(array, Math::min, Integer.MAX_VALUE);
for (T t : tt) {
if (segTree.query(0, t.m) < t.h) {
System.out.println("Yes");
return;
}
segTree.updateValue(t.m, Math.min(segTree.query(t.m, t.m+1), t.h));
}
System.out.println("No");
out.flush();
}
private static class T {
int l;
int m;
int h;
public T(int l, int m, int h) {
this.l = l;
this.m = m;
this.h = h;
}
@Override
public String toString() {
return "T{" +
"l=" + l +
", m=" + m +
", h=" + h +
'}';
}
}
private static int[] compress(int[] array) {
TreeSet<Integer> sortedElements = Arrays.stream(array).boxed().collect(Collectors.toCollection(TreeSet::new));
HashMap<Integer, Integer> map = new HashMap<>();
int count = 0;
for (int element: sortedElements) map.put(element, count++);
int[] res = new int[array.length];
for (int i = 0; i < array.length; i++) res[i] = map.get(array[i]);
return res;
}
static PrintWriter out = new PrintWriter(System.out);
static Scanner scanner = new Scanner(System.in);
static String next() { return scanner.next(); }
static int nextInt() {
int res = 0;
char[] chars = next().toCharArray();
boolean minus = chars[0] == '-';
int start = minus?1:0;
for (int i = start; i < chars.length; i++) {
res = res*10 + (chars[i]-'0');
}
return minus?-res:res;
}
static long nextLong() {
long res = 0;
char[] chars = next().toCharArray();
boolean minus = chars[0] == '-';
int start = minus?1:0;
for (int i = start; i < chars.length; i++) {
res = res*10 + (chars[i]-'0');
}
return minus?-res:res;
}
static double nextDouble() { return Double.parseDouble(next()); }
static int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) { array[i] = nextInt(); }
return array;
}
static long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) { array[i] = nextLong(); }
return array;
}
private static class SegTree<T> {
int n;
T[] tree;
BiFunction<T, T, T> op;
T unit;
private SegTree(T[] array, BiFunction<T, T, T> op, T unit) {
int len = array.length;
n = getSize(len);
tree = (T[]) new Object[2 * n - 1];
this.op = op;
this.unit = unit;
initTree(array, len);
}
private int getSize(final int len) {
int exp = 1;
while (len > exp) {
exp *= 2;
}
return exp;
}
private void initTree(final T[] array, final int len) {
Arrays.fill(tree, unit);
for (int i = 0; i < len; i++) {
tree[i + n - 1] = array[i]; // 葉のindexはn-1から2n-2まで
}
for (int i = n - 2; i >= 0; i--) {
updateNode(i);
}
}
private void updateNode(final int i) {
tree[i] = op.apply(tree[lChildOf(i)], tree[rChildOf(i)]);
}
/**
* 元の配列の値を更新する。
* 親のnodeに遡っての更新もする。
*
* @param i 元の配列のindex
* @param value 更新後の値
*/
public void updateValue(int i, T value) {
int index = i + n - 1;
tree[index] = value;
while (index > 0) {
index = parentOf(index);
updateNode(index);
}
}
/**
* 区間の値を求める
* 実装的には、親から子に下りながら見る。
*
*
* @param l 左端（inclusive）
* @param r 右端（exclusive）
*/
public T query(int l, int r) {
return doQuery(Math.min(l, r), Math.max(l, r), 0, 0, n);
}
/**
* 値の欲しい範囲が、今調べているnodeと被っていなかったらunitを返す。
* 値の欲しい範囲が広かったら、nodeの値をそのまま返す。
* 値の欲しい範囲が狭かったら、nodeの子に対して再度このメソッドを実行する。
*
* @param l 値の欲しい範囲の左端（inclusive）
* @param r 値の欲しい範囲の右端（exclusive）
* @param node 今調べているnode
* @param lEdge nodeが表す範囲の左端（inclusive）
* @param rEdge nodeが表す範囲の右端（exclusive）
*/
private T doQuery(int l, int r, int node, int lEdge, int rEdge) {
if (rEdge <= l || r <= lEdge) { return unit; }
if (l <= lEdge && rEdge <= r) { return tree[node]; }
return op.apply(
doQuery(l, r, lChildOf(node), lEdge, (lEdge+rEdge)/2),
doQuery(l, r, rChildOf(node), (lEdge+rEdge)/2, rEdge)
);
}
private int lChildOf(int i) {
return i * 2 + 1;
}
private int rChildOf(int i) {
return lChildOf(i) + 1;
}
private int parentOf(int i) {
return (i - 1) / 2;
}
}
}
|
ConDefects/ConDefects/Code/abc309_f/Java/43537065
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.