id
stringlengths 22
25
| content
stringlengths 327
628k
| max_stars_repo_path
stringlengths 49
49
|
|---|---|---|
condefects-java_data_501
|
import java.util.*;
public class Main {
public static final int MOD998 = 998244353;
public static final int MOD100 = 1000000007;
public static void main(String[] args) throws Exception {
ContestScanner sc = new ContestScanner();
ContestPrinter cp = new ContestPrinter();
int N = sc.nextInt();
int[] P = sc.nextIntArray(N, i -> i - 1);
if (N == 2) {
if (P[0] == 0) {
cp.println(0);
} else {
cp.println(1);
}
} else {
if (P[0] + 1 == P[1] || P[1] + 1 == P[2]) {
cp.println(Math.min(N - (P[N - 1] + 1), P[N - 1] + 3));
} else {
cp.println(Math.min(N - (P[N - 1] + 1) + 1, P[N - 1] + 2));
}
}
cp.close();
}
//////////////////
// My Library //
//////////////////
public static class SlopeTrick {
private PriorityQueue<Long> lq = new PriorityQueue<>(Comparator.reverseOrder());
private PriorityQueue<Long> rq = new PriorityQueue<>();
private long lshift = 0;
private long rshift = 0;
private long min = 0;
public long getMin() {
return min;
}
public long get(long x) {
long val = min;
for (long l : lq) {
if (l - x > 0) {
val += l - x;
}
}
for (long r : rq) {
if (x - r > 0) {
val += x - r;
}
}
return val;
}
public long getMinPosLeft() {
return lq.isEmpty() ? Long.MIN_VALUE : lq.peek() + lshift;
}
public long getMinPosRight() {
return rq.isEmpty() ? Long.MAX_VALUE : rq.peek() + rshift;
}
public void addConst(long a) {
min += a;
}
public void addSlopeRight(long a) {
if (!lq.isEmpty() && lq.peek() + lshift > a) {
min += lq.peek() + lshift - a;
lq.add(a - lshift);
rq.add(lq.poll() + lshift - rshift);
} else {
rq.add(a - rshift);
}
}
public void addSlopeLeft(long a) {
if (!rq.isEmpty() && rq.peek() < a) {
min += a - rq.peek() - rshift;
rq.add(a - rshift);
lq.add(rq.poll() + rshift - lshift);
} else {
lq.add(a - lshift);
}
}
public void addAbs(long a) {
addSlopeLeft(a);
addSlopeRight(a);
}
public void shift(long a) {
lshift += a;
rshift += a;
}
public void slideLeft(long a) {
lshift += a;
}
public void slideRight(long a) {
rshift += a;
}
public void clearLeft() {
lq.clear();
}
public void clearRight() {
rq.clear();
}
public void clearMin() {
min = 0;
}
}
public static int zeroOneBFS(int[][][] weighted_graph, int start, int goal) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
if (now == goal) {
return dist[goal];
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return -1;
}
public static int[] zeroOneBFSAll(int[][][] weighted_graph, int start) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return dist;
}
public static long dijkstra(int[][][] weighted_graph, int start, int goal) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (now == goal) {
return dist[goal];
}
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return -1;
}
public static long[] dijkstraAll(int[][][] weighted_graph, int start) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return dist;
}
public static long countLatticePoint(int[] p1, int[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
public static long countLatticePoint(long[] p1, long[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
// Don't contain same points!
public static long countLatticePoint(int[] p1, int[] p2, int[] p3, boolean include_edge) {
int[][] arr = new int[][] { p1, p2, p3 };
Arrays.sort(arr, Comparator.comparingInt(p -> ((int[]) p)[0]).thenComparingInt(p -> ((int[]) p)[1]));
if ((p2[0] - p1[0]) * (long) (p3[1] - p2[1]) == (p2[1] - p1[1]) * (long) (p3[0] - p2[0])) {
return countLatticePoint(arr[0], arr[2], true) - (include_edge ? 0 : 3);
}
long b = countLatticePoint(p1, p2, true) + countLatticePoint(p2, p3, true) + countLatticePoint(p3, p1, true)
- 3;
long i = (getAreaTriangle(p1, p2, p3) - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static long getAreaTriangle(int[] p1, int[] p2, int[] p3) {
int x1 = p2[0] - p1[0];
int x2 = p3[0] - p2[0];
int y1 = p2[1] - p1[1];
int y2 = p3[1] - p2[1];
return Math.abs((long) x1 * y2 - (long) x2 * y1);
}
// Don't contain same points!
public static long countLatticePointConvex(int[][] points, boolean include_edge) {
if (points.length == 1) {
return include_edge ? 1 : 0;
}
if (points.length == 2) {
return countLatticePoint(points[0], points[1], include_edge);
}
long s = 0;
for (int n = 1; n < points.length - 1; n++) {
s += getAreaTriangle(points[0], points[n], points[n + 1]);
}
long b = countLatticePoint(points[points.length - 1], points[0], true) - points.length;
for (int n = 0; n < points.length - 1; n++) {
b += countLatticePoint(points[n], points[n + 1], true);
}
long i = (s - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static class RationalAngle implements Comparable<RationalAngle> {
public long x;
public long y;
public static boolean include_pi_to_minus = true;
public RationalAngle(long x, long y) {
if (x == 0) {
this.x = x;
if (y == 0) {
throw new UnsupportedOperationException("Angle to (0, 0) is invalid.");
} else {
this.y = y > 0 ? 1 : -1;
}
} else if (y == 0) {
this.x = x > 0 ? 1 : -1;
this.y = 0;
} else {
long gcd = MathLib.gcd(x, y);
this.x = x / gcd;
this.y = y / gcd;
}
}
public RationalAngle copy() {
return new RationalAngle(x, y);
}
public RationalAngle add(RationalAngle a) {
RationalAngle res = copy();
res.addArg(a);
return res;
}
public void addArg(RationalAngle a) {
long nx = x * a.x - y * a.y;
long ny = y * a.x + x * a.y;
x = nx;
y = ny;
}
public RationalAngle sub(RationalAngle a) {
RationalAngle res = copy();
res.subArg(a);
return res;
}
public void subArg(RationalAngle a) {
long nx = x * a.x + y * a.y;
long ny = y * a.x - x * a.y;
x = nx;
y = ny;
}
public boolean equals(RationalAngle a) {
return x == a.x && y == a.y;
}
public boolean parallel(RationalAngle a) {
return x == a.x && y == a.y || x == -a.x && y == -a.y;
}
public int rotDirection(RationalAngle trg) {
if (parallel(trg)) {
return 0;
} else if (trg.sub(this).y > 0) {
return 1;
} else {
return -1;
}
}
public RationalAngle minus() {
return new RationalAngle(x, -y);
}
public RationalAngle rev() {
return new RationalAngle(-x, -y);
}
public double toRadian() {
return Math.atan2(y, x);
}
private int toQuad() {
if (x == 0) {
if (y > 0) {
return 2;
} else {
return -2;
}
} else if (x > 0) {
if (y == 0) {
return 0;
} else if (y > 0) {
return 1;
} else {
return -1;
}
} else {
if (y == 0) {
return include_pi_to_minus ? -4 : 4;
} else if (y > 0) {
return 3;
} else {
return -3;
}
}
}
@Override
public int compareTo(RationalAngle ra) {
if (ra == null) {
throw new NullPointerException();
}
int me = toQuad();
int you = ra.toQuad();
if (me > you) {
return 1;
} else if (me < you) {
return -1;
}
long sub = sub(ra).y;
if (sub == 0) {
return 0;
} else if (sub > 0) {
return 1;
} else {
return -1;
}
}
}
public static class Pair<A, B> {
public final A car;
public final B cdr;
public Pair(A car_, B cdr_) {
car = car_;
cdr = cdr_;
}
private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);
}
private static int hc(Object o) {
return o == null ? 0 : o.hashCode();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair))
return false;
Pair<?, ?> rhs = (Pair<?, ?>) o;
return eq(car, rhs.car) && eq(cdr, rhs.cdr);
}
@Override
public int hashCode() {
return hc(car) ^ hc(cdr);
}
}
public static class Tuple1<A> extends Pair<A, Object> {
public Tuple1(A a) {
super(a, null);
}
}
public static class Tuple2<A, B> extends Pair<A, Tuple1<B>> {
public Tuple2(A a, B b) {
super(a, new Tuple1<>(b));
}
}
public static class Tuple3<A, B, C> extends Pair<A, Tuple2<B, C>> {
public Tuple3(A a, B b, C c) {
super(a, new Tuple2<>(b, c));
}
}
public static class Tuple4<A, B, C, D> extends Pair<A, Tuple3<B, C, D>> {
public Tuple4(A a, B b, C c, D d) {
super(a, new Tuple3<>(b, c, d));
}
}
public static class Tuple5<A, B, C, D, E> extends Pair<A, Tuple4<B, C, D, E>> {
public Tuple5(A a, B b, C c, D d, E e) {
super(a, new Tuple4<>(b, c, d, e));
}
}
public static class PriorityQueueLogTime<T> {
private PriorityQueue<T> queue;
private Multiset<T> total;
private int size = 0;
public PriorityQueueLogTime() {
queue = new PriorityQueue<>();
total = new Multiset<>();
}
public PriorityQueueLogTime(Comparator<T> c) {
queue = new PriorityQueue<>(c);
total = new Multiset<>();
}
public void clear() {
queue.clear();
total.clear();
size = 0;
}
public boolean contains(T e) {
return total.count(e) > 0;
}
public boolean isEmpty() {
return size == 0;
}
public boolean offer(T e) {
total.addOne(e);
size++;
return queue.offer(e);
}
public T peek() {
if (total.isEmpty()) {
return null;
}
simplify();
return queue.peek();
}
public T poll() {
if (total.isEmpty()) {
return null;
}
simplify();
size--;
T res = queue.poll();
total.removeOne(res);
return res;
}
public void remove(T e) {
total.removeOne(e);
size--;
}
public int size() {
return size;
}
private void simplify() {
while (total.count(queue.peek()) == 0) {
queue.poll();
}
}
}
static int[][] scanGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 2);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraph(node, edge, arr[0], arr[1], undirected);
}
static int[][][] scanWeightedGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 3);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraphWithWeight(node, edge, arr[0], arr[1], arr[2], undirected);
}
static class EdgeData {
private int capacity;
private int[] from, to, weight;
private int p = 0;
private boolean weighted;
public EdgeData(boolean weighted) {
this(weighted, 500000);
}
public EdgeData(boolean weighted, int initial_capacity) {
capacity = initial_capacity;
from = new int[capacity];
to = new int[capacity];
weight = new int[capacity];
this.weighted = weighted;
}
public void addEdge(int u, int v) {
if (weighted) {
System.err.println("The graph is weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
capacity *= 2;
from = newfrom;
to = newto;
}
from[p] = u;
to[p] = v;
p++;
}
public void addEdge(int u, int v, int w) {
if (!weighted) {
System.err.println("The graph is NOT weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
int[] newweight = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
System.arraycopy(weight, 0, newweight, 0, capacity);
capacity *= 2;
from = newfrom;
to = newto;
weight = newweight;
}
from[p] = u;
to[p] = v;
weight[p] = w;
p++;
}
public int[] getFrom() {
int[] result = new int[p];
System.arraycopy(from, 0, result, 0, p);
return result;
}
public int[] getTo() {
int[] result = new int[p];
System.arraycopy(to, 0, result, 0, p);
return result;
}
public int[] getWeight() {
int[] result = new int[p];
System.arraycopy(weight, 0, result, 0, p);
return result;
}
public int size() {
return p;
}
}
////////////////////////////////
// Atcoder Library for Java //
////////////////////////////////
static class MathLib {
private static long safe_mod(long x, long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
private static long[] inv_gcd(long a, 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) {
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 long gcd(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return inv_gcd(a, b)[0];
}
public static long lcm(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return a / gcd(a, b) * b;
}
public static long pow_mod(long x, long n, int m) {
assert n >= 0;
assert m >= 1;
if (m == 1)
return 0L;
x = safe_mod(x, m);
long ans = 1L;
while (n > 0) {
if ((n & 1) == 1)
ans = (ans * x) % m;
x = (x * x) % m;
n >>>= 1;
}
return ans;
}
public static long[] crt(long[] r, long[] m) {
assert (r.length == m.length);
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;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1 / g;
if ((r1 - r0) % g != 0)
return new long[] { 0, 0 };
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(long n, 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;
}
long y_max = (a * n + b) / m;
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;
}
public static java.util.ArrayList<Long> divisors(long n) {
java.util.ArrayList<Long> divisors = new ArrayList<>();
java.util.ArrayList<Long> large = new ArrayList<>();
for (long i = 1; i * i <= n; i++)
if (n % i == 0) {
divisors.add(i);
if (i * i < n)
large.add(n / i);
}
for (int p = large.size() - 1; p >= 0; p--) {
divisors.add(large.get(p));
}
return divisors;
}
}
static class Multiset<T> extends java.util.TreeMap<T, Long> {
public Multiset() {
super();
}
public Multiset(java.util.List<T> list) {
super();
for (T e : list)
this.addOne(e);
}
public long count(Object elm) {
return getOrDefault(elm, 0L);
}
public void add(T elm, long amount) {
if (!this.containsKey(elm))
put(elm, amount);
else
replace(elm, get(elm) + amount);
if (this.count(elm) == 0)
this.remove(elm);
}
public void addOne(T elm) {
this.add(elm, 1);
}
public void removeOne(T elm) {
this.add(elm, -1);
}
public void removeAll(T elm) {
this.add(elm, -this.count(elm));
}
public static <T> Multiset<T> merge(Multiset<T> a, Multiset<T> b) {
Multiset<T> c = new Multiset<>();
for (T x : a.keySet())
c.add(x, a.count(x));
for (T y : b.keySet())
c.add(y, b.count(y));
return c;
}
}
static class GraphBuilder {
public static int[][] makeGraph(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][] graph = new int[NumberOfNodes][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = to[i];
if (undirected)
graph[to[i]][--outdegree[to[i]]] = from[i];
}
return graph;
}
public static int[][][] makeGraphWithWeight(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i] };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i] };
}
return graph;
}
public static int[][][] makeGraphWithEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], i, 1 };
}
return graph;
}
public static int[][][] makeGraphWithWeightAndEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from,
int[] to, int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i], i, 1 };
}
return graph;
}
}
static class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
static class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
private ArrayList<Integer> factorial_inversion;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
this.factorial_inversion = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0)
value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max) {
factorial.ensureCapacity(max + 1);
if (factorial.size() == 0)
factorial.add(1);
for (int i = factorial.size(); i <= max; i++) {
factorial.add(ma.mul(factorial.get(i - 1), i));
}
}
public ModInt factorial(int i) {
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(ma.mul(factorial.get(n), factorial_inversion.get(n - r)));
}
return create(ma.div(factorial.get(n), factorial.get(n - r)));
}
public ModInt combination(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(
ma.mul(factorial.get(n), ma.mul(factorial_inversion.get(n - r), factorial_inversion.get(r))));
}
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r), factorial.get(n - r))));
}
public void prepareFactorialInv(int max) {
prepareFactorial(max);
factorial_inversion.ensureCapacity(max + 1);
for (int i = factorial_inversion.size(); i <= max; i++) {
factorial_inversion.add(ma.inv(factorial.get(i)));
}
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(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(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis)
mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis)
mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis)
addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis)
mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1)
return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
long tmp2 = u;
u = v;
v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0)
throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1)
r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(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);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {
return 1;
}
int remainder(long value) {
return 0;
}
int add(int a, int b) {
return 0;
}
int sub(int a, int b) {
return 0;
}
int mul(int a, int b) {
return 0;
}
int pow(int a, long b) {
return 0;
}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {
return 2;
}
int remainder(long value) {
return (int) (value & 1);
}
int add(int a, int b) {
return a ^ b;
}
int sub(int a, int b) {
return a ^ b;
}
int mul(int a, int b) {
return a & b;
}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(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;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(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
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(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)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
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
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
static class Convolution {
/**
* Find a primitive root.
*
* @param m A prime number.
* @return Primitive root.
*/
private static int primitiveRoot(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;
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 (pow(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
/**
* Power.
*
* @param x Parameter x.
* @param n Parameter n.
* @param m Mod.
* @return n-th power of x mod m.
*/
private static long pow(long x, long n, int m) {
if (m == 1)
return 0;
long r = 1;
long y = x % m;
while (n > 0) {
if ((n & 1) != 0)
r = (r * y) % m;
y = (y * y) % m;
n >>= 1;
}
return r;
}
/**
* Ceil of power 2.
*
* @param n Value.
* @return Ceil of power 2.
*/
private static int ceilPow2(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(long[] c, int[] mods) {
int n = c.length + 1;
long[] cnst = new long[n];
long[] coef = new long[n];
java.util.Arrays.fill(coef, 1);
for (int i = 0; i < n - 1; i++) {
int m1 = mods[i];
long v = (c[i] - cnst[i] + m1) % m1;
v = v * pow(coef[i], m1 - 2, m1) % m1;
for (int j = i + 1; j < n; j++) {
long m2 = mods[j];
cnst[j] = (cnst[j] + coef[j] * v) % m2;
coef[j] = (coef[j] * m1) % m2;
}
}
return cnst[n - 1];
}
/**
* Pre-calculation for NTT.
*
* @param mod NTT Prime.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumE(int mod, int g) {
long[] sum_e = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = 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(int mod, int g) {
long[] sum_ie = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = 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(long[] a, long[] sumIE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p];
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (mod + l - r) * inow % mod;
}
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(long[] a, long[] sumE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p] * now % mod;
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (l - r + mod) % mod;
}
int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % mod;
}
}
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
public static long[] convolution(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int z = 1 << ceilPow2(n + m - 1);
{
long[] na = new long[z];
long[] nb = new long[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
int g = primitiveRoot(mod);
long[] sume = sumE(mod, g);
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);
long iz = 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[] convolutionLL(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int mod1 = 754974721;
int mod2 = 167772161;
int mod3 = 469762049;
long[] c1 = convolution(a, b, mod1);
long[] c2 = convolution(a, b, mod2);
long[] c3 = convolution(a, b, mod3);
int retSize = c1.length;
long[] ret = new long[retSize];
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 by ModInt.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
public static java.util.List<ModIntFactory.ModInt> convolution(java.util.List<ModIntFactory.ModInt> a,
java.util.List<ModIntFactory.ModInt> b) {
int mod = a.get(0).mod();
long[] va = a.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] vb = b.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] c = convolutionLL(va, vb, mod);
ModIntFactory factory = new ModIntFactory(mod);
return java.util.Arrays.stream(c).mapToObj(factory::create).collect(java.util.stream.Collectors.toList());
}
/**
* 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(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
int k = n + m - 1;
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;
}
}
static class SCC {
static class Edge {
int from, to;
public Edge(int from, 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(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(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];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
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);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
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
long p = stack[--ptr];
// vertex
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
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) {
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
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];
}
int[] counts = new int[groupNum];
for (int x : ids)
counts[x]++;
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++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
static class ContestScanner {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
public ContestScanner(java.io.InputStream in) {
this.in = in;
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.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 java.util.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 java.util.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') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit));
}
n = n * 10 + digit;
} 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 long[] nextLongArray(int length) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = this.nextLong();
return array;
}
public long[] nextLongArray(int length, java.util.function.LongUnaryOperator map) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsLong(this.nextLong());
return array;
}
public int[] nextIntArray(int length) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = this.nextInt();
return array;
}
public int[][] nextIntArrayMulti(int length, int width) {
int[][] arrays = new int[width][length];
for (int i = 0; i < length; i++) {
for (int j = 0; j < width; j++)
arrays[j][i] = this.nextInt();
}
return arrays;
}
public int[] nextIntArray(int length, java.util.function.IntUnaryOperator map) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsInt(this.nextInt());
return array;
}
public double[] nextDoubleArray(int length) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = this.nextDouble();
return array;
}
public double[] nextDoubleArray(int length, java.util.function.DoubleUnaryOperator map) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
public long[][] nextLongMatrix(int height, int width) {
long[][] mat = new long[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextLong();
}
return mat;
}
public int[][] nextIntMatrix(int height, int width) {
int[][] mat = new int[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextInt();
}
return mat;
}
public double[][] nextDoubleMatrix(int height, int width) {
double[][] mat = new double[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextDouble();
}
return mat;
}
public char[][] nextCharMatrix(int height, int width) {
char[][] mat = new char[height][width];
for (int h = 0; h < height; h++) {
String s = this.next();
for (int w = 0; w < width; w++) {
mat[h][w] = s.charAt(w);
}
}
return mat;
}
}
static class ContestPrinter extends java.io.PrintWriter {
public ContestPrinter(java.io.PrintStream stream) {
super(stream);
}
public ContestPrinter() {
super(System.out);
}
private static String dtos(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(dtos(f, 20));
}
@Override
public void println(float f) {
super.println(dtos(f, 20));
}
@Override
public void print(double d) {
super.print(dtos(d, 20));
}
@Override
public void println(double d) {
super.println(dtos(d, 20));
}
public void printArray(int[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n - 1]));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n - 1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
}
static class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
static class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static 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(int n, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
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(int k) {
if (Laz[k] == Id)
return;
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(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 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(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, 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, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, 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, 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, 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(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(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(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; 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 < N)
simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N)
simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N)
return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static 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;
this.pos = new java.util.ArrayList<>();
this.g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
this.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));
}
}
}
static class StringAlgorithm {
private static int[] saNaive(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
insertionsortUsingComparator(sa, (l, r) -> {
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] - s[r];
l++;
r++;
}
return -(l - r);
});
return sa;
}
public static int[] saDoubling(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
int[] rnk = java.util.Arrays.copyOf(s, n);
int[] tmp = new int[n];
for (int k = 1; k < n; k *= 2) {
final int _k = k;
final int[] _rnk = rnk;
java.util.function.IntBinaryOperator cmp = (x, y) -> {
if (_rnk[x] != _rnk[y])
return _rnk[x] - _rnk[y];
int rx = x + _k < n ? _rnk[x + _k] : -1;
int ry = y + _k < n ? _rnk[y + _k] : -1;
return rx - ry;
};
mergesortUsingComparator(sa, cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp.applyAsInt(sa[i - 1], sa[i]) < 0 ? 1 : 0);
}
int[] buf = tmp;
tmp = rnk;
rnk = buf;
}
return sa;
}
private static void insertionsortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
for (int i = 1; i < n; i++) {
final int tmp = a[i];
if (comparator.applyAsInt(a[i - 1], tmp) > 0) {
int j = i;
do {
a[j] = a[j - 1];
j--;
} while (j > 0 && comparator.applyAsInt(a[j - 1], tmp) > 0);
a[j] = tmp;
}
}
}
private static void mergesortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
final int[] work = new int[n];
for (int block = 1; block <= n; block <<= 1) {
final int block2 = block << 1;
for (int l = 0, max = n - block; l < max; l += block2) {
int m = l + block;
int r = Math.min(l + block2, n);
System.arraycopy(a, l, work, 0, block);
for (int i = l, wi = 0, ti = m;; i++) {
if (ti == r) {
System.arraycopy(work, wi, a, i, block - wi);
break;
}
if (comparator.applyAsInt(work[wi], a[ti]) > 0) {
a[i] = a[ti++];
} else {
a[i] = work[wi++];
if (wi == block)
break;
}
}
}
}
}
private static final int THRESHOLD_NAIVE = 50;
// private static final int THRESHOLD_DOUBLING = 0;
private static int[] sais(int[] s, int upper) {
int n = s.length;
if (n == 0)
return new int[0];
if (n == 1)
return new int[] { 0 };
if (n == 2) {
if (s[0] < s[1]) {
return new int[] { 0, 1 };
} else {
return new int[] { 1, 0 };
}
}
if (n < THRESHOLD_NAIVE) {
return saNaive(s);
}
// if (n < THRESHOLD_DOUBLING) {
// return saDoubling(s);
// }
int[] sa = new int[n];
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];
}
int[] sumL = new int[upper + 1];
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];
}
java.util.function.Consumer<int[]> induce = lms -> {
java.util.Arrays.fill(sa, -1);
int[] buf = new int[upper + 1];
System.arraycopy(sumS, 0, buf, 0, upper + 1);
for (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++) {
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--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
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++;
}
}
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) {
int[] sortedLms = new int[m];
{
int p = 0;
for (int v : sa) {
if (lmsMap[v] != -1) {
sortedLms[p++] = v;
}
}
}
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];
int endL = (lmsMap[l] + 1 < m) ? lms[lmsMap[l] + 1] : n;
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;
}
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(int[] s, int upper) {
assert (0 <= upper);
for (int d : s) {
assert (0 <= d && d <= upper);
}
return sais(s, upper);
}
public static int[] suffixArray(int[] s) {
int n = s.length;
int[] vals = Arrays.copyOf(s, n);
java.util.Arrays.sort(vals);
int p = 1;
for (int i = 1; i < n; i++) {
if (vals[i] != vals[i - 1]) {
vals[p++] = vals[i];
}
}
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = java.util.Arrays.binarySearch(vals, 0, p, s[i]);
}
return sais(s2, p);
}
public static int[] suffixArray(char[] s) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return sais(s2, 255);
}
public static int[] suffixArray(java.lang.String s) {
return suffixArray(s.toCharArray());
}
public static int[] lcpArray(int[] s, int[] sa) {
int n = s.length;
assert (n >= 1);
int[] rnk = new int[n];
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
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;
}
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(char[] s, int[] sa) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcpArray(s2, sa);
}
public static int[] lcpArray(java.lang.String s, int[] sa) {
return lcpArray(s.toCharArray(), sa);
}
public static int[] zAlgorithm(int[] s) {
int n = s.length;
if (n == 0)
return new int[0];
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(char[] s) {
int n = s.length;
if (n == 0)
return new int[0];
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(String s) {
return zAlgorithm(s.toCharArray());
}
}
}
import java.util.*;
public class Main {
public static final int MOD998 = 998244353;
public static final int MOD100 = 1000000007;
public static void main(String[] args) throws Exception {
ContestScanner sc = new ContestScanner();
ContestPrinter cp = new ContestPrinter();
int N = sc.nextInt();
int[] P = sc.nextIntArray(N, i -> i - 1);
if (N == 2) {
if (P[0] == 0) {
cp.println(0);
} else {
cp.println(1);
}
} else {
if (P[0] + 1 == P[1] || P[1] + 1 == P[2]) {
cp.println(Math.min(N - (P[N - 1] + 1), P[N - 1] + 3));
} else {
cp.println(Math.min(N - (P[0] + 1) + 1, P[0] + 2));
}
}
cp.close();
}
//////////////////
// My Library //
//////////////////
public static class SlopeTrick {
private PriorityQueue<Long> lq = new PriorityQueue<>(Comparator.reverseOrder());
private PriorityQueue<Long> rq = new PriorityQueue<>();
private long lshift = 0;
private long rshift = 0;
private long min = 0;
public long getMin() {
return min;
}
public long get(long x) {
long val = min;
for (long l : lq) {
if (l - x > 0) {
val += l - x;
}
}
for (long r : rq) {
if (x - r > 0) {
val += x - r;
}
}
return val;
}
public long getMinPosLeft() {
return lq.isEmpty() ? Long.MIN_VALUE : lq.peek() + lshift;
}
public long getMinPosRight() {
return rq.isEmpty() ? Long.MAX_VALUE : rq.peek() + rshift;
}
public void addConst(long a) {
min += a;
}
public void addSlopeRight(long a) {
if (!lq.isEmpty() && lq.peek() + lshift > a) {
min += lq.peek() + lshift - a;
lq.add(a - lshift);
rq.add(lq.poll() + lshift - rshift);
} else {
rq.add(a - rshift);
}
}
public void addSlopeLeft(long a) {
if (!rq.isEmpty() && rq.peek() < a) {
min += a - rq.peek() - rshift;
rq.add(a - rshift);
lq.add(rq.poll() + rshift - lshift);
} else {
lq.add(a - lshift);
}
}
public void addAbs(long a) {
addSlopeLeft(a);
addSlopeRight(a);
}
public void shift(long a) {
lshift += a;
rshift += a;
}
public void slideLeft(long a) {
lshift += a;
}
public void slideRight(long a) {
rshift += a;
}
public void clearLeft() {
lq.clear();
}
public void clearRight() {
rq.clear();
}
public void clearMin() {
min = 0;
}
}
public static int zeroOneBFS(int[][][] weighted_graph, int start, int goal) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
if (now == goal) {
return dist[goal];
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return -1;
}
public static int[] zeroOneBFSAll(int[][][] weighted_graph, int start) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return dist;
}
public static long dijkstra(int[][][] weighted_graph, int start, int goal) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (now == goal) {
return dist[goal];
}
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return -1;
}
public static long[] dijkstraAll(int[][][] weighted_graph, int start) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return dist;
}
public static long countLatticePoint(int[] p1, int[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
public static long countLatticePoint(long[] p1, long[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
// Don't contain same points!
public static long countLatticePoint(int[] p1, int[] p2, int[] p3, boolean include_edge) {
int[][] arr = new int[][] { p1, p2, p3 };
Arrays.sort(arr, Comparator.comparingInt(p -> ((int[]) p)[0]).thenComparingInt(p -> ((int[]) p)[1]));
if ((p2[0] - p1[0]) * (long) (p3[1] - p2[1]) == (p2[1] - p1[1]) * (long) (p3[0] - p2[0])) {
return countLatticePoint(arr[0], arr[2], true) - (include_edge ? 0 : 3);
}
long b = countLatticePoint(p1, p2, true) + countLatticePoint(p2, p3, true) + countLatticePoint(p3, p1, true)
- 3;
long i = (getAreaTriangle(p1, p2, p3) - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static long getAreaTriangle(int[] p1, int[] p2, int[] p3) {
int x1 = p2[0] - p1[0];
int x2 = p3[0] - p2[0];
int y1 = p2[1] - p1[1];
int y2 = p3[1] - p2[1];
return Math.abs((long) x1 * y2 - (long) x2 * y1);
}
// Don't contain same points!
public static long countLatticePointConvex(int[][] points, boolean include_edge) {
if (points.length == 1) {
return include_edge ? 1 : 0;
}
if (points.length == 2) {
return countLatticePoint(points[0], points[1], include_edge);
}
long s = 0;
for (int n = 1; n < points.length - 1; n++) {
s += getAreaTriangle(points[0], points[n], points[n + 1]);
}
long b = countLatticePoint(points[points.length - 1], points[0], true) - points.length;
for (int n = 0; n < points.length - 1; n++) {
b += countLatticePoint(points[n], points[n + 1], true);
}
long i = (s - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static class RationalAngle implements Comparable<RationalAngle> {
public long x;
public long y;
public static boolean include_pi_to_minus = true;
public RationalAngle(long x, long y) {
if (x == 0) {
this.x = x;
if (y == 0) {
throw new UnsupportedOperationException("Angle to (0, 0) is invalid.");
} else {
this.y = y > 0 ? 1 : -1;
}
} else if (y == 0) {
this.x = x > 0 ? 1 : -1;
this.y = 0;
} else {
long gcd = MathLib.gcd(x, y);
this.x = x / gcd;
this.y = y / gcd;
}
}
public RationalAngle copy() {
return new RationalAngle(x, y);
}
public RationalAngle add(RationalAngle a) {
RationalAngle res = copy();
res.addArg(a);
return res;
}
public void addArg(RationalAngle a) {
long nx = x * a.x - y * a.y;
long ny = y * a.x + x * a.y;
x = nx;
y = ny;
}
public RationalAngle sub(RationalAngle a) {
RationalAngle res = copy();
res.subArg(a);
return res;
}
public void subArg(RationalAngle a) {
long nx = x * a.x + y * a.y;
long ny = y * a.x - x * a.y;
x = nx;
y = ny;
}
public boolean equals(RationalAngle a) {
return x == a.x && y == a.y;
}
public boolean parallel(RationalAngle a) {
return x == a.x && y == a.y || x == -a.x && y == -a.y;
}
public int rotDirection(RationalAngle trg) {
if (parallel(trg)) {
return 0;
} else if (trg.sub(this).y > 0) {
return 1;
} else {
return -1;
}
}
public RationalAngle minus() {
return new RationalAngle(x, -y);
}
public RationalAngle rev() {
return new RationalAngle(-x, -y);
}
public double toRadian() {
return Math.atan2(y, x);
}
private int toQuad() {
if (x == 0) {
if (y > 0) {
return 2;
} else {
return -2;
}
} else if (x > 0) {
if (y == 0) {
return 0;
} else if (y > 0) {
return 1;
} else {
return -1;
}
} else {
if (y == 0) {
return include_pi_to_minus ? -4 : 4;
} else if (y > 0) {
return 3;
} else {
return -3;
}
}
}
@Override
public int compareTo(RationalAngle ra) {
if (ra == null) {
throw new NullPointerException();
}
int me = toQuad();
int you = ra.toQuad();
if (me > you) {
return 1;
} else if (me < you) {
return -1;
}
long sub = sub(ra).y;
if (sub == 0) {
return 0;
} else if (sub > 0) {
return 1;
} else {
return -1;
}
}
}
public static class Pair<A, B> {
public final A car;
public final B cdr;
public Pair(A car_, B cdr_) {
car = car_;
cdr = cdr_;
}
private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);
}
private static int hc(Object o) {
return o == null ? 0 : o.hashCode();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair))
return false;
Pair<?, ?> rhs = (Pair<?, ?>) o;
return eq(car, rhs.car) && eq(cdr, rhs.cdr);
}
@Override
public int hashCode() {
return hc(car) ^ hc(cdr);
}
}
public static class Tuple1<A> extends Pair<A, Object> {
public Tuple1(A a) {
super(a, null);
}
}
public static class Tuple2<A, B> extends Pair<A, Tuple1<B>> {
public Tuple2(A a, B b) {
super(a, new Tuple1<>(b));
}
}
public static class Tuple3<A, B, C> extends Pair<A, Tuple2<B, C>> {
public Tuple3(A a, B b, C c) {
super(a, new Tuple2<>(b, c));
}
}
public static class Tuple4<A, B, C, D> extends Pair<A, Tuple3<B, C, D>> {
public Tuple4(A a, B b, C c, D d) {
super(a, new Tuple3<>(b, c, d));
}
}
public static class Tuple5<A, B, C, D, E> extends Pair<A, Tuple4<B, C, D, E>> {
public Tuple5(A a, B b, C c, D d, E e) {
super(a, new Tuple4<>(b, c, d, e));
}
}
public static class PriorityQueueLogTime<T> {
private PriorityQueue<T> queue;
private Multiset<T> total;
private int size = 0;
public PriorityQueueLogTime() {
queue = new PriorityQueue<>();
total = new Multiset<>();
}
public PriorityQueueLogTime(Comparator<T> c) {
queue = new PriorityQueue<>(c);
total = new Multiset<>();
}
public void clear() {
queue.clear();
total.clear();
size = 0;
}
public boolean contains(T e) {
return total.count(e) > 0;
}
public boolean isEmpty() {
return size == 0;
}
public boolean offer(T e) {
total.addOne(e);
size++;
return queue.offer(e);
}
public T peek() {
if (total.isEmpty()) {
return null;
}
simplify();
return queue.peek();
}
public T poll() {
if (total.isEmpty()) {
return null;
}
simplify();
size--;
T res = queue.poll();
total.removeOne(res);
return res;
}
public void remove(T e) {
total.removeOne(e);
size--;
}
public int size() {
return size;
}
private void simplify() {
while (total.count(queue.peek()) == 0) {
queue.poll();
}
}
}
static int[][] scanGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 2);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraph(node, edge, arr[0], arr[1], undirected);
}
static int[][][] scanWeightedGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 3);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraphWithWeight(node, edge, arr[0], arr[1], arr[2], undirected);
}
static class EdgeData {
private int capacity;
private int[] from, to, weight;
private int p = 0;
private boolean weighted;
public EdgeData(boolean weighted) {
this(weighted, 500000);
}
public EdgeData(boolean weighted, int initial_capacity) {
capacity = initial_capacity;
from = new int[capacity];
to = new int[capacity];
weight = new int[capacity];
this.weighted = weighted;
}
public void addEdge(int u, int v) {
if (weighted) {
System.err.println("The graph is weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
capacity *= 2;
from = newfrom;
to = newto;
}
from[p] = u;
to[p] = v;
p++;
}
public void addEdge(int u, int v, int w) {
if (!weighted) {
System.err.println("The graph is NOT weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
int[] newweight = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
System.arraycopy(weight, 0, newweight, 0, capacity);
capacity *= 2;
from = newfrom;
to = newto;
weight = newweight;
}
from[p] = u;
to[p] = v;
weight[p] = w;
p++;
}
public int[] getFrom() {
int[] result = new int[p];
System.arraycopy(from, 0, result, 0, p);
return result;
}
public int[] getTo() {
int[] result = new int[p];
System.arraycopy(to, 0, result, 0, p);
return result;
}
public int[] getWeight() {
int[] result = new int[p];
System.arraycopy(weight, 0, result, 0, p);
return result;
}
public int size() {
return p;
}
}
////////////////////////////////
// Atcoder Library for Java //
////////////////////////////////
static class MathLib {
private static long safe_mod(long x, long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
private static long[] inv_gcd(long a, 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) {
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 long gcd(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return inv_gcd(a, b)[0];
}
public static long lcm(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return a / gcd(a, b) * b;
}
public static long pow_mod(long x, long n, int m) {
assert n >= 0;
assert m >= 1;
if (m == 1)
return 0L;
x = safe_mod(x, m);
long ans = 1L;
while (n > 0) {
if ((n & 1) == 1)
ans = (ans * x) % m;
x = (x * x) % m;
n >>>= 1;
}
return ans;
}
public static long[] crt(long[] r, long[] m) {
assert (r.length == m.length);
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;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1 / g;
if ((r1 - r0) % g != 0)
return new long[] { 0, 0 };
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(long n, 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;
}
long y_max = (a * n + b) / m;
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;
}
public static java.util.ArrayList<Long> divisors(long n) {
java.util.ArrayList<Long> divisors = new ArrayList<>();
java.util.ArrayList<Long> large = new ArrayList<>();
for (long i = 1; i * i <= n; i++)
if (n % i == 0) {
divisors.add(i);
if (i * i < n)
large.add(n / i);
}
for (int p = large.size() - 1; p >= 0; p--) {
divisors.add(large.get(p));
}
return divisors;
}
}
static class Multiset<T> extends java.util.TreeMap<T, Long> {
public Multiset() {
super();
}
public Multiset(java.util.List<T> list) {
super();
for (T e : list)
this.addOne(e);
}
public long count(Object elm) {
return getOrDefault(elm, 0L);
}
public void add(T elm, long amount) {
if (!this.containsKey(elm))
put(elm, amount);
else
replace(elm, get(elm) + amount);
if (this.count(elm) == 0)
this.remove(elm);
}
public void addOne(T elm) {
this.add(elm, 1);
}
public void removeOne(T elm) {
this.add(elm, -1);
}
public void removeAll(T elm) {
this.add(elm, -this.count(elm));
}
public static <T> Multiset<T> merge(Multiset<T> a, Multiset<T> b) {
Multiset<T> c = new Multiset<>();
for (T x : a.keySet())
c.add(x, a.count(x));
for (T y : b.keySet())
c.add(y, b.count(y));
return c;
}
}
static class GraphBuilder {
public static int[][] makeGraph(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][] graph = new int[NumberOfNodes][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = to[i];
if (undirected)
graph[to[i]][--outdegree[to[i]]] = from[i];
}
return graph;
}
public static int[][][] makeGraphWithWeight(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i] };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i] };
}
return graph;
}
public static int[][][] makeGraphWithEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], i, 1 };
}
return graph;
}
public static int[][][] makeGraphWithWeightAndEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from,
int[] to, int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i], i, 1 };
}
return graph;
}
}
static class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
static class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
private ArrayList<Integer> factorial_inversion;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
this.factorial_inversion = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0)
value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max) {
factorial.ensureCapacity(max + 1);
if (factorial.size() == 0)
factorial.add(1);
for (int i = factorial.size(); i <= max; i++) {
factorial.add(ma.mul(factorial.get(i - 1), i));
}
}
public ModInt factorial(int i) {
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(ma.mul(factorial.get(n), factorial_inversion.get(n - r)));
}
return create(ma.div(factorial.get(n), factorial.get(n - r)));
}
public ModInt combination(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(
ma.mul(factorial.get(n), ma.mul(factorial_inversion.get(n - r), factorial_inversion.get(r))));
}
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r), factorial.get(n - r))));
}
public void prepareFactorialInv(int max) {
prepareFactorial(max);
factorial_inversion.ensureCapacity(max + 1);
for (int i = factorial_inversion.size(); i <= max; i++) {
factorial_inversion.add(ma.inv(factorial.get(i)));
}
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(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(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis)
mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis)
mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis)
addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis)
mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1)
return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
long tmp2 = u;
u = v;
v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0)
throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1)
r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(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);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {
return 1;
}
int remainder(long value) {
return 0;
}
int add(int a, int b) {
return 0;
}
int sub(int a, int b) {
return 0;
}
int mul(int a, int b) {
return 0;
}
int pow(int a, long b) {
return 0;
}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {
return 2;
}
int remainder(long value) {
return (int) (value & 1);
}
int add(int a, int b) {
return a ^ b;
}
int sub(int a, int b) {
return a ^ b;
}
int mul(int a, int b) {
return a & b;
}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(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;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(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
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(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)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
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
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
static class Convolution {
/**
* Find a primitive root.
*
* @param m A prime number.
* @return Primitive root.
*/
private static int primitiveRoot(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;
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 (pow(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
/**
* Power.
*
* @param x Parameter x.
* @param n Parameter n.
* @param m Mod.
* @return n-th power of x mod m.
*/
private static long pow(long x, long n, int m) {
if (m == 1)
return 0;
long r = 1;
long y = x % m;
while (n > 0) {
if ((n & 1) != 0)
r = (r * y) % m;
y = (y * y) % m;
n >>= 1;
}
return r;
}
/**
* Ceil of power 2.
*
* @param n Value.
* @return Ceil of power 2.
*/
private static int ceilPow2(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(long[] c, int[] mods) {
int n = c.length + 1;
long[] cnst = new long[n];
long[] coef = new long[n];
java.util.Arrays.fill(coef, 1);
for (int i = 0; i < n - 1; i++) {
int m1 = mods[i];
long v = (c[i] - cnst[i] + m1) % m1;
v = v * pow(coef[i], m1 - 2, m1) % m1;
for (int j = i + 1; j < n; j++) {
long m2 = mods[j];
cnst[j] = (cnst[j] + coef[j] * v) % m2;
coef[j] = (coef[j] * m1) % m2;
}
}
return cnst[n - 1];
}
/**
* Pre-calculation for NTT.
*
* @param mod NTT Prime.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumE(int mod, int g) {
long[] sum_e = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = 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(int mod, int g) {
long[] sum_ie = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = 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(long[] a, long[] sumIE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p];
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (mod + l - r) * inow % mod;
}
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(long[] a, long[] sumE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p] * now % mod;
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (l - r + mod) % mod;
}
int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % mod;
}
}
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
public static long[] convolution(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int z = 1 << ceilPow2(n + m - 1);
{
long[] na = new long[z];
long[] nb = new long[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
int g = primitiveRoot(mod);
long[] sume = sumE(mod, g);
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);
long iz = 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[] convolutionLL(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int mod1 = 754974721;
int mod2 = 167772161;
int mod3 = 469762049;
long[] c1 = convolution(a, b, mod1);
long[] c2 = convolution(a, b, mod2);
long[] c3 = convolution(a, b, mod3);
int retSize = c1.length;
long[] ret = new long[retSize];
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 by ModInt.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
public static java.util.List<ModIntFactory.ModInt> convolution(java.util.List<ModIntFactory.ModInt> a,
java.util.List<ModIntFactory.ModInt> b) {
int mod = a.get(0).mod();
long[] va = a.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] vb = b.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] c = convolutionLL(va, vb, mod);
ModIntFactory factory = new ModIntFactory(mod);
return java.util.Arrays.stream(c).mapToObj(factory::create).collect(java.util.stream.Collectors.toList());
}
/**
* 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(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
int k = n + m - 1;
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;
}
}
static class SCC {
static class Edge {
int from, to;
public Edge(int from, 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(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(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];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
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);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
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
long p = stack[--ptr];
// vertex
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
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) {
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
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];
}
int[] counts = new int[groupNum];
for (int x : ids)
counts[x]++;
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++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
static class ContestScanner {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
public ContestScanner(java.io.InputStream in) {
this.in = in;
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.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 java.util.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 java.util.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') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit));
}
n = n * 10 + digit;
} 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 long[] nextLongArray(int length) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = this.nextLong();
return array;
}
public long[] nextLongArray(int length, java.util.function.LongUnaryOperator map) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsLong(this.nextLong());
return array;
}
public int[] nextIntArray(int length) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = this.nextInt();
return array;
}
public int[][] nextIntArrayMulti(int length, int width) {
int[][] arrays = new int[width][length];
for (int i = 0; i < length; i++) {
for (int j = 0; j < width; j++)
arrays[j][i] = this.nextInt();
}
return arrays;
}
public int[] nextIntArray(int length, java.util.function.IntUnaryOperator map) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsInt(this.nextInt());
return array;
}
public double[] nextDoubleArray(int length) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = this.nextDouble();
return array;
}
public double[] nextDoubleArray(int length, java.util.function.DoubleUnaryOperator map) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
public long[][] nextLongMatrix(int height, int width) {
long[][] mat = new long[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextLong();
}
return mat;
}
public int[][] nextIntMatrix(int height, int width) {
int[][] mat = new int[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextInt();
}
return mat;
}
public double[][] nextDoubleMatrix(int height, int width) {
double[][] mat = new double[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextDouble();
}
return mat;
}
public char[][] nextCharMatrix(int height, int width) {
char[][] mat = new char[height][width];
for (int h = 0; h < height; h++) {
String s = this.next();
for (int w = 0; w < width; w++) {
mat[h][w] = s.charAt(w);
}
}
return mat;
}
}
static class ContestPrinter extends java.io.PrintWriter {
public ContestPrinter(java.io.PrintStream stream) {
super(stream);
}
public ContestPrinter() {
super(System.out);
}
private static String dtos(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(dtos(f, 20));
}
@Override
public void println(float f) {
super.println(dtos(f, 20));
}
@Override
public void print(double d) {
super.print(dtos(d, 20));
}
@Override
public void println(double d) {
super.println(dtos(d, 20));
}
public void printArray(int[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n - 1]));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n - 1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
}
static class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
static class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static 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(int n, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
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(int k) {
if (Laz[k] == Id)
return;
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(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 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(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, 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, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, 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, 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, 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(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(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(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; 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 < N)
simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N)
simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N)
return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static 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;
this.pos = new java.util.ArrayList<>();
this.g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
this.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));
}
}
}
static class StringAlgorithm {
private static int[] saNaive(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
insertionsortUsingComparator(sa, (l, r) -> {
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] - s[r];
l++;
r++;
}
return -(l - r);
});
return sa;
}
public static int[] saDoubling(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
int[] rnk = java.util.Arrays.copyOf(s, n);
int[] tmp = new int[n];
for (int k = 1; k < n; k *= 2) {
final int _k = k;
final int[] _rnk = rnk;
java.util.function.IntBinaryOperator cmp = (x, y) -> {
if (_rnk[x] != _rnk[y])
return _rnk[x] - _rnk[y];
int rx = x + _k < n ? _rnk[x + _k] : -1;
int ry = y + _k < n ? _rnk[y + _k] : -1;
return rx - ry;
};
mergesortUsingComparator(sa, cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp.applyAsInt(sa[i - 1], sa[i]) < 0 ? 1 : 0);
}
int[] buf = tmp;
tmp = rnk;
rnk = buf;
}
return sa;
}
private static void insertionsortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
for (int i = 1; i < n; i++) {
final int tmp = a[i];
if (comparator.applyAsInt(a[i - 1], tmp) > 0) {
int j = i;
do {
a[j] = a[j - 1];
j--;
} while (j > 0 && comparator.applyAsInt(a[j - 1], tmp) > 0);
a[j] = tmp;
}
}
}
private static void mergesortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
final int[] work = new int[n];
for (int block = 1; block <= n; block <<= 1) {
final int block2 = block << 1;
for (int l = 0, max = n - block; l < max; l += block2) {
int m = l + block;
int r = Math.min(l + block2, n);
System.arraycopy(a, l, work, 0, block);
for (int i = l, wi = 0, ti = m;; i++) {
if (ti == r) {
System.arraycopy(work, wi, a, i, block - wi);
break;
}
if (comparator.applyAsInt(work[wi], a[ti]) > 0) {
a[i] = a[ti++];
} else {
a[i] = work[wi++];
if (wi == block)
break;
}
}
}
}
}
private static final int THRESHOLD_NAIVE = 50;
// private static final int THRESHOLD_DOUBLING = 0;
private static int[] sais(int[] s, int upper) {
int n = s.length;
if (n == 0)
return new int[0];
if (n == 1)
return new int[] { 0 };
if (n == 2) {
if (s[0] < s[1]) {
return new int[] { 0, 1 };
} else {
return new int[] { 1, 0 };
}
}
if (n < THRESHOLD_NAIVE) {
return saNaive(s);
}
// if (n < THRESHOLD_DOUBLING) {
// return saDoubling(s);
// }
int[] sa = new int[n];
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];
}
int[] sumL = new int[upper + 1];
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];
}
java.util.function.Consumer<int[]> induce = lms -> {
java.util.Arrays.fill(sa, -1);
int[] buf = new int[upper + 1];
System.arraycopy(sumS, 0, buf, 0, upper + 1);
for (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++) {
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--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
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++;
}
}
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) {
int[] sortedLms = new int[m];
{
int p = 0;
for (int v : sa) {
if (lmsMap[v] != -1) {
sortedLms[p++] = v;
}
}
}
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];
int endL = (lmsMap[l] + 1 < m) ? lms[lmsMap[l] + 1] : n;
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;
}
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(int[] s, int upper) {
assert (0 <= upper);
for (int d : s) {
assert (0 <= d && d <= upper);
}
return sais(s, upper);
}
public static int[] suffixArray(int[] s) {
int n = s.length;
int[] vals = Arrays.copyOf(s, n);
java.util.Arrays.sort(vals);
int p = 1;
for (int i = 1; i < n; i++) {
if (vals[i] != vals[i - 1]) {
vals[p++] = vals[i];
}
}
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = java.util.Arrays.binarySearch(vals, 0, p, s[i]);
}
return sais(s2, p);
}
public static int[] suffixArray(char[] s) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return sais(s2, 255);
}
public static int[] suffixArray(java.lang.String s) {
return suffixArray(s.toCharArray());
}
public static int[] lcpArray(int[] s, int[] sa) {
int n = s.length;
assert (n >= 1);
int[] rnk = new int[n];
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
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;
}
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(char[] s, int[] sa) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcpArray(s2, sa);
}
public static int[] lcpArray(java.lang.String s, int[] sa) {
return lcpArray(s.toCharArray(), sa);
}
public static int[] zAlgorithm(int[] s) {
int n = s.length;
if (n == 0)
return new int[0];
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(char[] s) {
int n = s.length;
if (n == 0)
return new int[0];
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(String s) {
return zAlgorithm(s.toCharArray());
}
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28171898
|
condefects-java_data_502
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
int index1 = -1;
for(int i = 0; i < n; i++) {
if(a[i] == 1) {
index1 = i;
}
}
if(a[0] == 1 && a[1] == 2) {
System.out.println(0);
return;
}
if(a[n - 1] == 1 && a[n - 2] == 2) {
System.out.println(1);
return;
}
//前半が昇順かどうか
boolean ascFirst = true;
if(index1 == 0 || a[index1 - 1] == 2) {
ascFirst = false;
}
int result = 0;
if(ascFirst) {
int left = index1;
int right = n - index1;
result = Math.min(left, right + 2);
}
else {
int left = index1 + 1;
int right = n - left;
result = Math.min(left + 1, right + 2);
}
System.out.println(result);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
int index1 = -1;
for(int i = 0; i < n; i++) {
if(a[i] == 1) {
index1 = i;
}
}
if(a[0] == 1 && a[1] == 2) {
System.out.println(0);
return;
}
if(a[n - 1] == 1 && a[n - 2] == 2) {
System.out.println(1);
return;
}
//前半が昇順かどうか
boolean ascFirst = true;
if(index1 == 0 || a[index1 - 1] == 2) {
ascFirst = false;
}
int result = 0;
if(ascFirst) {
int left = index1;
int right = n - index1;
result = Math.min(left, right + 2);
}
else {
int left = index1 + 1;
int right = n - left;
result = Math.min(left + 1, right + 1);
}
System.out.println(result);
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28630461
|
condefects-java_data_503
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
int[] array_p = Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
br.close();
System.out.println(solve(n, array_p));
return;
}
static int solve(int n, int[] array_p) {
int ans = 0;
int idx_1 = 0;
for(int i = 0; i < n; i++){
if(array_p[i] == 1) {
idx_1 = i;
}
}
if(array_p[(idx_1 + 1) % n] == 2) {
//昇順の場合
ans = idx_1;
ans = Math.min((( n - idx_1) % n) + 2, ans);
} else {
//降順の場合
ans = ((idx_1 + 1) % n) + 1;
ans = Math.min((idx_1 % n) + 3, ans);
}
return ans;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
int[] array_p = Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
br.close();
System.out.println(solve(n, array_p));
return;
}
static int solve(int n, int[] array_p) {
int ans = 0;
int idx_1 = 0;
for(int i = 0; i < n; i++){
if(array_p[i] == 1) {
idx_1 = i;
}
}
if(array_p[(idx_1 + 1) % n] == 2) {
//昇順の場合
ans = idx_1;
ans = Math.min((( n - idx_1) % n) + 2, ans);
} else {
//降順の場合
ans = ((idx_1 + 1) % n) + 1;
ans = Math.min((n - idx_1 - 1) + 1, ans);
}
return ans;
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28177041
|
condefects-java_data_504
|
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;
public class Main {
static long MOD = 998244353l;
int min = Integer.MAX_VALUE;
boolean re = false;
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new
// File("/Users/goudezhao/Public/JavaTest/1.txt"));
var sc = new FastScanner();
// var sc = new FastScanner(fis);
// var pw = new FastPrintStream("/Users/goudezhao/Public/JavaTest/1.out");
var pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}
public static void solve(FastScanner sc, FastPrintStream pw) {
int n = sc.nextInt();
int a[] = new int[n];
Arrays.setAll(a, i->sc.nextInt());
int index=0;
for (int i=0;i<n;i++) {
if (a[i]==n) {
index= i;
break;
}
}
if (index==0) {
pw.println(1);
return;
}
if (a[index-1]==1) {
if (n==2) {
pw.println(0);
return;
}
pw.println(Math.min(index+1, 1+(n-index+1)));
return;
}
if (index==n-1) {
pw.println(0);
return;
}
pw.println(Math.min(index+1, 2+(n-index-1)));
}
public static void swap(int[] s, int i, int j) {
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
public void permutation(int[] s, int from, int to, Point a[], Point b[]) {
if (to <= 1)
return;
if (from == to) {
check(s, a, b);
} else {
for (int i = from; i <= to; i++) {
swap(s, i, from); // 交换前缀，使其产生下一个前缀
permutation(s, from + 1, to, a, b);
swap(s, from, i); // 将前缀换回，继续做上一个前缀的排列
}
}
}
public void check(int[] s, Point a[], Point b[]) {
Point tempa[] = new Point[a.length];
Point tempb[] = new Point[b.length];
for (int i = 0; i < a.length; i++) {
tempa[i] = new Point();
tempa[i].x = Math.min(a[i].x, a[i].y);
tempa[i].y = Math.max(a[i].x, a[i].y);
}
for (int i = 0; i < a.length; i++) {
tempb[i] = new Point();
tempb[i].x = Math.min(s[b[i].x - 1], s[b[i].y - 1]);
tempb[i].y = Math.max(s[b[i].x - 1], s[b[i].y - 1]);
}
Arrays.sort(tempa);
Arrays.sort(tempb);
for (int i = 0; i < a.length; i++) {
if (tempa[i].x != tempb[i].x || tempa[i].y != tempb[i].y) {
return;
}
}
this.re = true;
}
public static long anothertoTen(long ano, int another) {
long ten = 0;
long now = 1;
long temp = ano;
while (temp > 0) {
long i = temp % 10;
ten += now * i;
now *= another;
temp /= 10;
}
return ten;
}
public static long tentoAnother(long ten, int another) {
Stack<Long> stack = new Stack<Long>();
while (ten > 0) {
stack.add(ten % another);
ten /= another;
}
long re = 0;
while (!stack.isEmpty()) {
long pop = stack.pop();
re = re * 10 + pop;
}
return re;
}
// 2C5 = 5*4/(2*1)
public static long XCY(long x, long y) {
long temp = 1;
for (int i = 0; i < x; i++) {
temp = (temp * (y - i)) % MOD;
}
long tempx = 1;
for (int i = 2; i <= x; i++) {
tempx = (tempx * i) % MOD;
}
tempx = modpow(tempx, (long) MOD - 2);
temp = (temp * tempx) % MOD;
return temp;
}
static long modpow(long N, Long K) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(MOD)).longValue();
}
static long modpow(long N, Long K, long mod) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(mod)).longValue();
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
public static int gcd(int a, int b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
}
class Range {
long start = 0;
long end = 0;
}
class Point implements Comparable {
int x;
int y;
public int compareTo(Object p) {
Point t = (Point) p;
if (t.x != this.x) {
return t.x - this.x;
}
return t.y - this.y;
}
}
class PointY implements Comparable {
int index;
long a;
long b;
public int compareTo(Object p) {
PointY t = (PointY) p;
if (this.a > t.a) {
return -1;
}
if (this.a < t.a) {
return 1;
}
return 0;
}
}
class FastPrintStream implements AutoCloseable {
private static final int BUF_SIZE = 1 << 15;
private final byte[] buf = new byte[BUF_SIZE];
private int ptr = 0;
private final java.lang.reflect.Field strField;
private final java.nio.charset.CharsetEncoder encoder;
private java.io.OutputStream out;
public FastPrintStream(java.io.OutputStream out) {
this.out = out;
java.lang.reflect.Field f;
try {
f = java.lang.String.class.getDeclaredField("value");
f.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
f = null;
}
this.strField = f;
this.encoder = java.nio.charset.StandardCharsets.US_ASCII.newEncoder();
}
public FastPrintStream(java.io.File file) throws java.io.IOException {
this(new java.io.FileOutputStream(file));
}
public FastPrintStream(java.lang.String filename) throws java.io.IOException {
this(new java.io.File(filename));
}
public FastPrintStream() {
this(System.out);
try {
java.lang.reflect.Field f = java.io.PrintStream.class.getDeclaredField("autoFlush");
f.setAccessible(true);
f.set(System.out, false);
} catch (IllegalAccessException | IllegalArgumentException | NoSuchFieldException e) {
// ignore
}
}
public FastPrintStream println() {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) '\n';
return this;
}
public FastPrintStream println(java.lang.Object o) {
return print(o).println();
}
public FastPrintStream println(java.lang.String s) {
return print(s).println();
}
public FastPrintStream println(char[] s) {
return print(s).println();
}
public FastPrintStream println(char c) {
return print(c).println();
}
public FastPrintStream println(int x) {
return print(x).println();
}
public FastPrintStream println(long x) {
return print(x).println();
}
public FastPrintStream println(double d, int precision) {
return print(d, precision).println();
}
private FastPrintStream print(byte[] bytes) {
int n = bytes.length;
if (ptr + n > BUF_SIZE) {
internalFlush();
try {
out.write(bytes);
} catch (java.io.IOException e) {
throw new RuntimeException();
}
} else {
System.arraycopy(bytes, 0, buf, ptr, n);
ptr += n;
}
return this;
}
public FastPrintStream print(java.lang.Object o) {
return print(o.toString());
}
public FastPrintStream print(java.lang.String s) {
if (strField == null) {
return print(s.getBytes());
} else {
try {
return print((byte[]) strField.get(s));
} catch (IllegalAccessException e) {
return print(s.getBytes());
}
}
}
public FastPrintStream print(char[] s) {
try {
return print(encoder.encode(java.nio.CharBuffer.wrap(s)).array());
} catch (java.nio.charset.CharacterCodingException e) {
byte[] bytes = new byte[s.length];
for (int i = 0; i < s.length; i++) {
bytes[i] = (byte) s[i];
}
return print(bytes);
}
}
public FastPrintStream print(char c) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) c;
return this;
}
public FastPrintStream print(int x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(long x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(double d, int precision) {
if (d < 0) {
print('-');
d = -d;
}
d += Math.pow(10, -d) / 2;
print((long) d).print('.');
d -= (long) d;
for (int i = 0; i < precision; i++) {
d *= 10;
print((int) d);
d -= (int) d;
}
return this;
}
private void internalFlush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void flush() {
try {
out.write(buf, 0, ptr);
out.flush();
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void close() {
try {
out.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
private static int len(int x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
int p = -10;
for (int i = 1; i < 10; i++, p *= 10)
if (x > p)
return i + d;
return 10 + d;
}
private static int len(long x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
long p = -10;
for (int i = 1; i < 19; i++, p *= 10)
if (x > p)
return i + d;
return 19 + d;
}
}
class FastScanner implements AutoCloseable {
private final java.io.InputStream in;
private final byte[] buf = new byte[2048];
private int ptr = 0;
private int buflen = 0;
public FastScanner(java.io.InputStream in) {
this.in = in;
}
public FastScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen)
return true;
ptr = 0;
try {
buflen = in.read(buf);
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
return buflen > 0;
}
private int readByte() {
return hasNextByte() ? buf[ptr++] : -1;
}
public boolean hasNext() {
while (hasNextByte() && !(32 < buf[ptr] && buf[ptr] < 127))
ptr++;
return hasNextByte();
}
private StringBuilder nextSequence() {
if (!hasNext())
throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
for (int b = readByte(); 32 < b && b < 127; b = readByte()) {
sb.appendCodePoint(b);
}
return sb;
}
public String next() {
return nextSequence().toString();
}
public String next(int len) {
return new String(nextChars(len));
}
public char nextChar() {
if (!hasNextByte())
throw new java.util.NoSuchElementException();
return (char) readByte();
}
public char[] nextChars() {
StringBuilder sb = nextSequence();
int l = sb.length();
char[] dst = new char[l];
sb.getChars(0, l, dst, 0);
return dst;
}
public char[] nextChars(int len) {
if (!hasNext())
throw new java.util.NoSuchElementException();
char[] s = new char[len];
int i = 0;
int b = readByte();
while (32 < b && b < 127 && i < len) {
s[i++] = (char) b;
b = readByte();
}
if (i != len) {
throw new java.util.NoSuchElementException(
String.format("Next token has smaller length than expected.", len));
}
return s;
}
public long nextLong() {
if (!hasNext())
throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b)
throw new NumberFormatException();
while (true) {
if ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
} else if (b == -1 || !(32 < b && b < 127)) {
return minus ? -n : n;
} else
throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() {
return Math.toIntExact(nextLong());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public void close() {
try {
in.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_j
*/
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Long.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return -1;
}
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return false;
}
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n)) {
return -1;
}
return -parentOrSize[leader(a)];
}
ArrayList<ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < n; i++) {
result.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
return result;
}
}
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;
public class Main {
static long MOD = 998244353l;
int min = Integer.MAX_VALUE;
boolean re = false;
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new
// File("/Users/goudezhao/Public/JavaTest/1.txt"));
var sc = new FastScanner();
// var sc = new FastScanner(fis);
// var pw = new FastPrintStream("/Users/goudezhao/Public/JavaTest/1.out");
var pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}
public static void solve(FastScanner sc, FastPrintStream pw) {
int n = sc.nextInt();
int a[] = new int[n];
Arrays.setAll(a, i->sc.nextInt());
int index=0;
for (int i=0;i<n;i++) {
if (a[i]==n) {
index= i;
break;
}
}
if (index==0) {
pw.println(1);
return;
}
if (a[index-1]==1) {
if (n==2) {
pw.println(0);
return;
}
pw.println(Math.min(index+1, 1+(n-index)));
return;
}
if (index==n-1) {
pw.println(0);
return;
}
pw.println(Math.min(index+1, 2+(n-index-1)));
}
public static void swap(int[] s, int i, int j) {
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
public void permutation(int[] s, int from, int to, Point a[], Point b[]) {
if (to <= 1)
return;
if (from == to) {
check(s, a, b);
} else {
for (int i = from; i <= to; i++) {
swap(s, i, from); // 交换前缀，使其产生下一个前缀
permutation(s, from + 1, to, a, b);
swap(s, from, i); // 将前缀换回，继续做上一个前缀的排列
}
}
}
public void check(int[] s, Point a[], Point b[]) {
Point tempa[] = new Point[a.length];
Point tempb[] = new Point[b.length];
for (int i = 0; i < a.length; i++) {
tempa[i] = new Point();
tempa[i].x = Math.min(a[i].x, a[i].y);
tempa[i].y = Math.max(a[i].x, a[i].y);
}
for (int i = 0; i < a.length; i++) {
tempb[i] = new Point();
tempb[i].x = Math.min(s[b[i].x - 1], s[b[i].y - 1]);
tempb[i].y = Math.max(s[b[i].x - 1], s[b[i].y - 1]);
}
Arrays.sort(tempa);
Arrays.sort(tempb);
for (int i = 0; i < a.length; i++) {
if (tempa[i].x != tempb[i].x || tempa[i].y != tempb[i].y) {
return;
}
}
this.re = true;
}
public static long anothertoTen(long ano, int another) {
long ten = 0;
long now = 1;
long temp = ano;
while (temp > 0) {
long i = temp % 10;
ten += now * i;
now *= another;
temp /= 10;
}
return ten;
}
public static long tentoAnother(long ten, int another) {
Stack<Long> stack = new Stack<Long>();
while (ten > 0) {
stack.add(ten % another);
ten /= another;
}
long re = 0;
while (!stack.isEmpty()) {
long pop = stack.pop();
re = re * 10 + pop;
}
return re;
}
// 2C5 = 5*4/(2*1)
public static long XCY(long x, long y) {
long temp = 1;
for (int i = 0; i < x; i++) {
temp = (temp * (y - i)) % MOD;
}
long tempx = 1;
for (int i = 2; i <= x; i++) {
tempx = (tempx * i) % MOD;
}
tempx = modpow(tempx, (long) MOD - 2);
temp = (temp * tempx) % MOD;
return temp;
}
static long modpow(long N, Long K) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(MOD)).longValue();
}
static long modpow(long N, Long K, long mod) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(mod)).longValue();
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
public static int gcd(int a, int b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
}
class Range {
long start = 0;
long end = 0;
}
class Point implements Comparable {
int x;
int y;
public int compareTo(Object p) {
Point t = (Point) p;
if (t.x != this.x) {
return t.x - this.x;
}
return t.y - this.y;
}
}
class PointY implements Comparable {
int index;
long a;
long b;
public int compareTo(Object p) {
PointY t = (PointY) p;
if (this.a > t.a) {
return -1;
}
if (this.a < t.a) {
return 1;
}
return 0;
}
}
class FastPrintStream implements AutoCloseable {
private static final int BUF_SIZE = 1 << 15;
private final byte[] buf = new byte[BUF_SIZE];
private int ptr = 0;
private final java.lang.reflect.Field strField;
private final java.nio.charset.CharsetEncoder encoder;
private java.io.OutputStream out;
public FastPrintStream(java.io.OutputStream out) {
this.out = out;
java.lang.reflect.Field f;
try {
f = java.lang.String.class.getDeclaredField("value");
f.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
f = null;
}
this.strField = f;
this.encoder = java.nio.charset.StandardCharsets.US_ASCII.newEncoder();
}
public FastPrintStream(java.io.File file) throws java.io.IOException {
this(new java.io.FileOutputStream(file));
}
public FastPrintStream(java.lang.String filename) throws java.io.IOException {
this(new java.io.File(filename));
}
public FastPrintStream() {
this(System.out);
try {
java.lang.reflect.Field f = java.io.PrintStream.class.getDeclaredField("autoFlush");
f.setAccessible(true);
f.set(System.out, false);
} catch (IllegalAccessException | IllegalArgumentException | NoSuchFieldException e) {
// ignore
}
}
public FastPrintStream println() {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) '\n';
return this;
}
public FastPrintStream println(java.lang.Object o) {
return print(o).println();
}
public FastPrintStream println(java.lang.String s) {
return print(s).println();
}
public FastPrintStream println(char[] s) {
return print(s).println();
}
public FastPrintStream println(char c) {
return print(c).println();
}
public FastPrintStream println(int x) {
return print(x).println();
}
public FastPrintStream println(long x) {
return print(x).println();
}
public FastPrintStream println(double d, int precision) {
return print(d, precision).println();
}
private FastPrintStream print(byte[] bytes) {
int n = bytes.length;
if (ptr + n > BUF_SIZE) {
internalFlush();
try {
out.write(bytes);
} catch (java.io.IOException e) {
throw new RuntimeException();
}
} else {
System.arraycopy(bytes, 0, buf, ptr, n);
ptr += n;
}
return this;
}
public FastPrintStream print(java.lang.Object o) {
return print(o.toString());
}
public FastPrintStream print(java.lang.String s) {
if (strField == null) {
return print(s.getBytes());
} else {
try {
return print((byte[]) strField.get(s));
} catch (IllegalAccessException e) {
return print(s.getBytes());
}
}
}
public FastPrintStream print(char[] s) {
try {
return print(encoder.encode(java.nio.CharBuffer.wrap(s)).array());
} catch (java.nio.charset.CharacterCodingException e) {
byte[] bytes = new byte[s.length];
for (int i = 0; i < s.length; i++) {
bytes[i] = (byte) s[i];
}
return print(bytes);
}
}
public FastPrintStream print(char c) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) c;
return this;
}
public FastPrintStream print(int x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(long x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(double d, int precision) {
if (d < 0) {
print('-');
d = -d;
}
d += Math.pow(10, -d) / 2;
print((long) d).print('.');
d -= (long) d;
for (int i = 0; i < precision; i++) {
d *= 10;
print((int) d);
d -= (int) d;
}
return this;
}
private void internalFlush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void flush() {
try {
out.write(buf, 0, ptr);
out.flush();
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void close() {
try {
out.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
private static int len(int x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
int p = -10;
for (int i = 1; i < 10; i++, p *= 10)
if (x > p)
return i + d;
return 10 + d;
}
private static int len(long x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
long p = -10;
for (int i = 1; i < 19; i++, p *= 10)
if (x > p)
return i + d;
return 19 + d;
}
}
class FastScanner implements AutoCloseable {
private final java.io.InputStream in;
private final byte[] buf = new byte[2048];
private int ptr = 0;
private int buflen = 0;
public FastScanner(java.io.InputStream in) {
this.in = in;
}
public FastScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen)
return true;
ptr = 0;
try {
buflen = in.read(buf);
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
return buflen > 0;
}
private int readByte() {
return hasNextByte() ? buf[ptr++] : -1;
}
public boolean hasNext() {
while (hasNextByte() && !(32 < buf[ptr] && buf[ptr] < 127))
ptr++;
return hasNextByte();
}
private StringBuilder nextSequence() {
if (!hasNext())
throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
for (int b = readByte(); 32 < b && b < 127; b = readByte()) {
sb.appendCodePoint(b);
}
return sb;
}
public String next() {
return nextSequence().toString();
}
public String next(int len) {
return new String(nextChars(len));
}
public char nextChar() {
if (!hasNextByte())
throw new java.util.NoSuchElementException();
return (char) readByte();
}
public char[] nextChars() {
StringBuilder sb = nextSequence();
int l = sb.length();
char[] dst = new char[l];
sb.getChars(0, l, dst, 0);
return dst;
}
public char[] nextChars(int len) {
if (!hasNext())
throw new java.util.NoSuchElementException();
char[] s = new char[len];
int i = 0;
int b = readByte();
while (32 < b && b < 127 && i < len) {
s[i++] = (char) b;
b = readByte();
}
if (i != len) {
throw new java.util.NoSuchElementException(
String.format("Next token has smaller length than expected.", len));
}
return s;
}
public long nextLong() {
if (!hasNext())
throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b)
throw new NumberFormatException();
while (true) {
if ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
} else if (b == -1 || !(32 < b && b < 127)) {
return minus ? -n : n;
} else
throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() {
return Math.toIntExact(nextLong());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public void close() {
try {
in.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_j
*/
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Long.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return -1;
}
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return false;
}
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n)) {
return -1;
}
return -parentOrSize[leader(a)];
}
ArrayList<ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < n; i++) {
result.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
return result;
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28172176
|
condefects-java_data_505
|
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
String[] sa = br.readLine().split(" ");
int[] p = new int[n];
for (int i = 0; i < n; i++) {
p[i] = Integer.parseInt(sa[i]) - 1;
}
br.close();
int s = 0;
for (int i = 0; i < n; i++) {
if (p[i] == 0) {
s = i;
break;
}
}
boolean flg = true;
for (int i = 1; i < n; i++) {
if (p[i - 1] + 1 != p[i] && p[i - 1] - n + 1 != p[i]) {
flg = false;
break;
}
}
int ans1 = 0;
int ans2 = 0;
if (flg) {
ans1 = s;
ans2 = 1 + (n - 1 - s + 1) % n + 1;
} else {
ans1 = (s + 1) % n + 1;
ans2 = 1 + (n - 1 - s) + 1;
}
System.out.println(Math.min(ans1, ans2));
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
String[] sa = br.readLine().split(" ");
int[] p = new int[n];
for (int i = 0; i < n; i++) {
p[i] = Integer.parseInt(sa[i]) - 1;
}
br.close();
int s = 0;
for (int i = 0; i < n; i++) {
if (p[i] == 0) {
s = i;
break;
}
}
boolean flg = true;
for (int i = 1; i < n; i++) {
if (p[i - 1] + 1 != p[i] && p[i - 1] - n + 1 != p[i]) {
flg = false;
break;
}
}
int ans1 = 0;
int ans2 = 0;
if (flg) {
ans1 = s;
ans2 = 1 + (n - 1 - s + 1) % n + 1;
} else {
ans1 = (s + 1) % n + 1;
ans2 = 1 + (n - 1 - s);
}
System.out.println(Math.min(ans1, ans2));
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28171749
|
condefects-java_data_506
|
import java.util.*;
@SuppressWarnings("unused")
public class Main {
private static void solve() {
int n = ni();
int[] p = na(n);
int one = -1;
int last = -1;
boolean rev = false;
for (int i = 0; i < n; i ++) {
if (p[i] == 1) {
one = i;
if (p[(i + 1) % 2] != 2) rev = true;
}
if (p[i] == n) last = i;
}
int ret = Integer.MAX_VALUE;
if (!rev) {
ret = Math.min(ret, one);
ret = Math.min(ret, (n - last - 1) + 2);
} else {
ret = Math.min(ret, last + 1);
ret = Math.min(ret, (n - one - 1) + 1);
}
System.out.println(ret);
}
public static void main(String[] args) {
new Thread(null, new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
String debug = args.length > 0 ? args[0] : null;
if (debug != null) {
try {
is = java.nio.file.Files.newInputStream(java.nio.file.Paths.get(debug));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
reader = new java.io.BufferedReader(new java.io.InputStreamReader(is), 32768);
solve();
out.flush();
tr((System.currentTimeMillis() - start) + "ms");
}
}, "", 64000000).start();
}
private static java.io.InputStream is = System.in;
private static java.io.PrintWriter out = new java.io.PrintWriter(System.out);
private static java.util.StringTokenizer tokenizer = null;
private static java.io.BufferedReader reader;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new java.util.StringTokenizer(reader.readLine());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
private static double nd() {
return Double.parseDouble(next());
}
private static long nl() {
return Long.parseLong(next());
}
private static int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = ni();
return a;
}
private static char[] ns() {
return next().toCharArray();
}
private static long[] nal(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nl();
return a;
}
private static int[][] ntable(int n, int m) {
int[][] table = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
table[i][j] = ni();
}
}
return table;
}
private static int[][] nlist(int n, int m) {
int[][] table = new int[m][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
table[j][i] = ni();
}
}
return table;
}
private static int ni() {
return Integer.parseInt(next());
}
private static void tr(Object... o) {
if (is != System.in)
System.out.println(java.util.Arrays.deepToString(o));
}
}
import java.util.*;
@SuppressWarnings("unused")
public class Main {
private static void solve() {
int n = ni();
int[] p = na(n);
int one = -1;
int last = -1;
boolean rev = false;
for (int i = 0; i < n; i ++) {
if (p[i] == 1) {
one = i;
if (p[(i + 1) % n] != 2) rev = true;
}
if (p[i] == n) last = i;
}
int ret = Integer.MAX_VALUE;
if (!rev) {
ret = Math.min(ret, one);
ret = Math.min(ret, (n - last - 1) + 2);
} else {
ret = Math.min(ret, last + 1);
ret = Math.min(ret, (n - one - 1) + 1);
}
System.out.println(ret);
}
public static void main(String[] args) {
new Thread(null, new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
String debug = args.length > 0 ? args[0] : null;
if (debug != null) {
try {
is = java.nio.file.Files.newInputStream(java.nio.file.Paths.get(debug));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
reader = new java.io.BufferedReader(new java.io.InputStreamReader(is), 32768);
solve();
out.flush();
tr((System.currentTimeMillis() - start) + "ms");
}
}, "", 64000000).start();
}
private static java.io.InputStream is = System.in;
private static java.io.PrintWriter out = new java.io.PrintWriter(System.out);
private static java.util.StringTokenizer tokenizer = null;
private static java.io.BufferedReader reader;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new java.util.StringTokenizer(reader.readLine());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
private static double nd() {
return Double.parseDouble(next());
}
private static long nl() {
return Long.parseLong(next());
}
private static int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = ni();
return a;
}
private static char[] ns() {
return next().toCharArray();
}
private static long[] nal(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nl();
return a;
}
private static int[][] ntable(int n, int m) {
int[][] table = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
table[i][j] = ni();
}
}
return table;
}
private static int[][] nlist(int n, int m) {
int[][] table = new int[m][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
table[j][i] = ni();
}
}
return table;
}
private static int ni() {
return Integer.parseInt(next());
}
private static void tr(Object... o) {
if (is != System.in)
System.out.println(java.util.Arrays.deepToString(o));
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28182250
|
condefects-java_data_507
|
/*
created by krps
本体は634行目あたりのsolve()に書いてあります。
Good Luck!
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
public class Main implements Runnable {
static FastScanner sc = new FastScanner();
static PrintWriter out = new PrintWriter(System.out);
public static class Pair<K, V> extends AbstractMap.SimpleEntry<K, V> implements Comparable<Pair<K, V>> {
public Pair(final K key, final V value) {
super(key, value);
}
@Override
public int compareTo(Pair<K, V> o) {
Comparable key = (Comparable)this.getKey();
Comparable key2 = (Comparable)o.getKey();
/*if (false) {
Comparable key3 = (Comparable) this.getValue();
Comparable key4 = (Comparable) o.getValue();
if (key.compareTo(key2) == 0) {
return key3.compareTo(key4);
}
}*/
return key.compareTo(key2);
}
}
private static boolean isPrime(long t) {
if(t<2)return false;
for(int i=2;i*i<=t;i++) {
if(t%i==0)return false;
}
return true;
}
@SuppressWarnings("unused")
private static long ncr(long n,long r) {
long res=1;
for(int i=0;i<r;i++) {
res*=n-i;
res/=i+1;
}
return res;
}
@SuppressWarnings("unused")
private static int StringCount(String T,String v) {
int res=0;
int t=0;
while(T.indexOf(v,t)>=0) {
//p(t);
res++;
t=T.indexOf(v,t)+1;
}
return res;
}
private static int arrayMin(int a[]) {
int res=INF;
for(int i=0;i<a.length;i++)res=min(res,a[i]);
return res;
}
private static long arrayMin(long a[]) {
long res=INF;
for(int i=0;i<a.length;i++)res=min(res,a[i]);
return res;
}
private static int arrayMax(int a[]) {
int res=-INF;
for(int i=0;i<a.length;i++)res=Math.max(res,a[i]);
return res;
}
private static long arrayMax2(long a[]) {
return Arrays.stream(a).max().getAsLong();
}
private static long arrayMax(long a[]) {
long res=-INF;
for(int i=0;i<a.length;i++)res=max(res,a[i]);
return res;
}
private static long arraySum(long a[]) {
long res=0;
for(int i=0;i<a.length;i++)res+=a[i];
return res;
}
private static long arraySum(int a[]) {
long res=0;
for(int i=0;i<a.length;i++)res+=a[i];
return res;
}
private static void swap(long V[],int a,int b) {
long temp=V[b];
V[b]=V[a];
V[a]=temp;
}
private static void p(long[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(long[] a) {p(Arrays.toString(a));};
private static void p(int[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(int[] a) {p(Arrays.toString(a));};
//大量にout.println();をすると、自動でout.flush();されるので、出力される順番には気を付けよう
// * out.println()の後にSystem.out.println();をしたいときとかねー
private static <T> void p(T t) {out.println(t);}
private static <T> void p() {out.println();}
private static void p(graph.edge2[] e) {
for (int i = 0; i < e.length; i++) {
out.println(e[i].to+" "+e[i].cost);
}
}
private static void doubleToString(double a) {
System.out.println(BigDecimal.valueOf(a).toPlainString());
}
private static ArrayList<Map<Integer,Integer>> c;
private static <T> int[] ArrayListToList(ArrayList<Integer> c2,int[] v) {for(int i=0;i<c2.size();i++)v[i]=c2.get(i);return v;}
private static ArrayList<Integer> ListToArrayList(int[] v) {ArrayList<Integer> c=new ArrayList<>(v.length);for(int i=0;i<v.length;i++)c.add(v[i]);return c;}
private static String maenizero(String s,int keta) {
while(s.length()<keta)s="0"+s;
return s;
}
private static int ketawa(String S) {
int res=0;
for(int i=0;i<S.length();i++) {
res+=S.charAt(i)-'0';
}return res;
}
private static int ketawa(int S) {
int res=0;
while(S!=0) {
res+=S%10;
S/=10;
}
return res;
}
private static long X_x[]=new long[1];
private static long kaijou(int x,long mod) {
if(X_x.length!=300000)X_x=new long[300000];
if(x<=1)return X_x[x]=1;
if(X_x[x]!=0)return X_x[x];
return X_x[x]=(x*kaijou(x-1,mod))%mod;
/*long a=1;
for(int i=2;i<=K;i++)a=(a*i)%mod;
return (int)a;*/
}
static class segmentTree{
int n;
long dat[];
long identity;//単位元
segmentTree(int N,long identity) {//setTreeの要素の数,単位元
this.identity =identity;
init(N);
}
void init2() {
Arrays.fill(dat, 0);
}
void init(int n_) {
this.n=1;
while(n<n_)n*=2;
this.dat= new long[2*n-1];
Arrays.fill(dat, identity);
}
void update(int k,long a) {
k+=n-1;
dat[k]=a;
while(k>0) {
k=(k-1)/2;
//System.err.println("update "+k+" "+Cal(this.dat[k*2+1],this.dat[k*2+2]));
dat[k]=Cal(dat[k*2+1],dat[k*2+2]);
}
}
//外から呼び出すときはl=0,r=-1,k=0にする。
void update(int a,int b,int k,int X,int l,int r) {
if(r==-1)r=n;
if(r<=a||b<=l) {
return;
}
if(a<=l&&r<=b) {
dat[k]=min(dat[k],X);
}else {
update(a, b, k*2+1,X, l, (l+r)/2);
update(a, b,k*2+2,X,(l+r)/2,r);
}
}
long get(int k) {//k番目の値を取得 0<=k<N
k+=n-1;
return dat[k];
}
//[a,b]を求める。
//a~bのこと。0-indexed
long getV(int a,int b) {
a=Math.max(0,a);
b=min(n-1,b);
b++;
return query(a, b, 0, 0, n);
}
int getleft(int a,int b,long x) {
return find_leftest_sub(a, b, x, 0, 0, n);
}
int getright(int a,int b,long x) {
return find_rightest_sub(a, b, x, 0, 0, n);
}
//[a,b)の値を求める
//a~b-1のことで、0-indexed
//外から呼び出すときは、a,b,0,0,N
long query(int a,int b,int k,int l,int r) {
if(r<=a||b<=l) {
//l,rが求めたい区間a,bに完全に含まれていない
return identity;
}
if(a<=l&&r<=b) {
//l,rが、求めたい区間a,bに完全に含まれている
return dat[k];
}else {
//l,rが、求めたい区間a,bに一部分だけ含まれている。
long A=query(a, b, k*2+1, l, (l+r)/2);
long B=query(a, b, k*2+2, (l+r)/2, r);
return Cal(A,B);
}
}
//x以下の要素を持つ最も左のもののindexを返す。 *RM(min)Q上でしか動かない
int find_rightest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn a-1
return a - 1;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vr = find_rightest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
if (vr != a - 1) { // 右の部分木を見て a-1 以外ならreturn
return vr;
} else { // 左の部分木を見て値をreturn
return find_rightest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
}
}
}
int find_leftest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn b
return b;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vl = find_leftest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
if (vl != b) { // 左の部分木を見て b 以外ならreturn
return vl;
} else { // 右の部分木を見て値をreturn
return find_leftest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
}
}
}
//RSQ上で動きます。
int query2(long X) {
int k=0;
//ここでは、Σ[0,r]Ai=Xとなる最小のrを求めたい
while(k*2+1<dat.length) {
if(dat[k*2+1]>=X) {
k=k*2+1;
}else {
X-=dat[k*2+1];
k=k*2+2;
}
}
return k-=n-1;
}
long Cal(long a,long b) {
//計算アルゴリズム
return Math.max(a,b);
//return a|b;
//return max(a,b);
//return gcd(a, b);
//return a^b;
//return Math.min(a, b);
}
int size() {
//Nではないよ、配列の大きさを返す。
return n;
}
//確認事項:Calとidentity
//segmentTreeで宣言、initで初期化する。
void toString(int n) {
for(int i=0;i<n*2;i++) {
System.err.print(dat[i]+" ");
}
System.err.println();
}
}
static class LazySegmentTree{
int n;
long node[],lazy[];
int identity;
long cal(long a,long b) {
return a+b;
}
public LazySegmentTree(long[] A,int iden) {
// TODO 自動生成されたコンストラクター・スタブ
init(A);
identity=iden;
}
//初期化
void init(long A[]) {
n=1;
int sz=A.length;
while(n<sz)n*=2;
node=new long[2*n-1];
lazy=new long[2*n-1];
for(int i=0;i<sz;i++)node[i+n-1]=A[i];
for(int i=n-2;i>=0;i--)node[i]=cal(node[i*2+1],node[i*2+2]);
}
void eval(int k,int l,int r) {
//k番目のノードについて、遅延評価を行う？
// 遅延配列が空でない場合、自ノード及び子ノードへの
// 値の伝播が起こる
if(lazy[k]!=identity) {
node[k]+=lazy[k];
System.out.println(r);
if(r-1>1) {//最下段かどうか
lazy[2*k+1]=cal(lazy[k]/2, lazy[2*k+1]);//ここもRSQ以外未定義 /2するところを要変更
lazy[2*k+2]=cal(lazy[k]/2, lazy[2*k+1]);
// 子ノードは親ノードの 1/2 の範囲であるため、
// 伝播させるときは半分にする
}
lazy[k]=identity;
}
}
//区間加算,外から呼び出すときは、l=0,r=-1
void add(int a,int b,long x,int k,int l,int r) {
//[a,b)の区間にxを加算する。
if(r<0)r=n;
eval(k,l,r);
if(b<=l||r<=a)return;
if(a<=l&&r<=b) {
lazy[k]=cal((r-1)*x,lazy[k]);//ここもRSQ以外未定義 *xするところを要変更
eval(k, l, r);
}else {
add(a, b, x, 2*k+1, l, (l+r)/2);
add(a, b, x, 2*k+2, (l+r)/2, r);
node[k]=cal(node[2*k+1],node[2*k+2]);
}
}
//区間和取得,外から呼び出すときは、l=0,r=-1
long getsum(int a,int b,int k,int l,int r) {
if(r<0)r=n;
if(b<=l||r<=a)return 0;
eval(k, l, r);
if(a<=l&&r<=b)return node[k];
long vl=getsum(a, b, 2*k+1, l, (l+r)/2);
long vr=getsum(a, b, 2*k+2, (l+r)/2, r);
return cal(vl,vr);
}
}
static class IntsegmentTree{
int n;
int dat[];
int identity;//単位元
IntsegmentTree(int N,int identity) {//setTreeの要素の数,単位元
this.identity =identity;
init(N);
}
void init2() {
Arrays.fill(dat, 0);
}
void init(int n_) {
this.n=1;
while(n<n_)n*=2;
this.dat= new int[2*n-1];
Arrays.fill(dat, identity);
}
void update(int k,int a) {
k+=n-1;
dat[k]=a;
while(k>0) {
k=(k-1)/2;
//System.err.println("update "+k+" "+Cal(this.dat[k*2+1],this.dat[k*2+2]));
dat[k]=Cal(dat[k*2+1],dat[k*2+2]);
}
}
//外から呼び出すときはl=0,r=-1,k=0にする。
void update(int a,int b,int k,int X,int l,int r) {
if(r==-1)r=n;
if(r<=a||b<=l) {
return;
}
if(a<=l&&r<=b) {
dat[k]=min(dat[k],X);
}else {
update(a, b, k*2+1,X, l, (l+r)/2);
update(a, b,k*2+2,X,(l+r)/2,r);
}
}
int get(int k) {//k番目の値を取得 0<=k<N
k+=n-1;
return dat[k];
}
//[a,b]を求める。
//a~bのこと。0-indexed
int getV(int a,int b) {
a=Math.max(0,a);
b=min(n-1,b);
b++;
return query(a, b, 0, 0, n);
}
int getleft(int a,int b,long x) {
return find_leftest_sub(a, b, x, 0, 0, n);
}
int getright(int a,int b,long x) {
return find_rightest_sub(a, b, x, 0, 0, n);
}
//[a,b)の値を求める
//a~b-1のことで、0-indexed
//外から呼び出すときは、a,b,0,0,N
int query(int a,int b,int k,int l,int r) {
if(r<=a||b<=l) {
//l,rが求めたい区間a,bに完全に含まれていない
return identity;
}
if(a<=l&&r<=b) {
//l,rが、求めたい区間a,bに完全に含まれている
return dat[k];
}else {
//l,rが、求めたい区間a,bに一部分だけ含まれている。
int A=query(a, b, k*2+1, l, (l+r)/2);
int B=query(a, b, k*2+2, (l+r)/2, r);
return Cal(A,B);
}
}
//x以下の要素を持つ最も左のもののindexを返す。 *RM(min)Q上でしか動かない
int find_rightest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn a-1
return a - 1;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vr = find_rightest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
if (vr != a - 1) { // 右の部分木を見て a-1 以外ならreturn
return vr;
} else { // 左の部分木を見て値をreturn
return find_rightest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
}
}
}
int find_leftest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn b
return b;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vl = find_leftest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
if (vl != b) { // 左の部分木を見て b 以外ならreturn
return vl;
} else { // 右の部分木を見て値をreturn
return find_leftest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
}
}
}
//RSQ上で動きます。
int query2(int X) {
int k=0;
//ここでは、Σ[0,r]Ai=Xとなる最小のrを求めたい
while(k*2+1<dat.length) {
if(dat[k*2+1]>=X) {
k=k*2+1;
}else {
X-=dat[k*2+1];
k=k*2+2;
}
}
return k-=n-1;
}
int Cal(int a,int b) {
//計算アルゴリズム
return (a+b);
//return a|b;
//return max(a,b);
//return gcd(a, b);
//return a^b;
//return Math.min(a, b);
}
int size() {
//Nではないよ、配列の大きさを返す。
return n;
}
//確認事項:Calとidentity
//segmentTreeで宣言、initで初期化する。
void toString(int n) {
for(int i=0;i<n*2;i++) {
System.err.print(dat[i]+" ");
}
System.err.println();
}
}
static void B(boolean x) {
p(x? "Yes":"No");
}
static void B(boolean x, String a,String b) {
p(x? a:b);
}
static char[][] clone(char V[][]) {
char RES[][]=new char[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static int[][] clone(int V[][]) {
int RES[][]=new int[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static long ceil(long a,long b) {
//ceil(a/b)を返す。
//a/bの切り上げ
return (a+b-1)/b;
}
static long floor(long a,long b) {
//floor (a/b)を返す。
//a/bの切り捨て
return a/b;
}
//Math.multiplyExact(T, A[i])
static void comp(int a[]) {
binarySerch bs = new binarySerch();
int b[]=Arrays.stream(a).distinct().toArray();
Arrays.parallelSort(b);
for (int i = 0; i < a.length; i++) {
a[i]=bs.lowerBound(b, a[i])+1;
compmax=Math.max(compmax,a[i]);
}
}
static final long mod7=Pow(10,9)+7,mod9=Pow(10,9)+9;
static long LINF =(1L<<63)-1,count=0,sum=0,max=-LINF,min=LINF,ans=0,temp;
static int i=0,INF=(1<<31)-1,compmax=0;
static long A[];
static final long mod998244353=998244353;
static Random r=new Random();
public static void main(String[] args) {
new Thread(null, new Main(), "", 1024 * 1024 * 1024).start(); //16MBスタックを確保して実行
}
public void run() {
for(int i=0;i<1;i++) {
solver();
out.close();
//out.flush();
}
}
static class V implements Comparable<V>{
int v,u,w,count;
public V(int v,int u,int w,int count) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.u=u;this.w=w;this.count=-count;
}
public int compareTo(V o) {
Comparable key = (Comparable)this.count;
Comparable key2 = (Comparable)o.count;
return key.compareTo(key2);
}
}
static class edge{
int v,dis;
public edge(int v,int dis) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.dis=dis;
}
}
static class T implements Comparable<T>{
int index;
int dis;
public T(int index,int dis) {
this.index=index;
this.dis=dis;
}
public int compareTo(T o) {
Comparable key = (Comparable)this.dis;
Comparable key2 = (Comparable)o.dis;
return key.compareTo(key2);
}
}
/*
long DP[][][]=new long[N][K][K];
//DP[i][k1][k2]:最後に取ったのがk1個前で、二番目に取ったのがk2個前のやつの最大値
//i番目を取るまでの最大値を再帰的に求める。
//
*/
private static void solver(){
int N=sc.nextInt();
int P[]=sc.nextIntArray(N);
for(int i=0;i<=N;i++) {
if(i==N) {
System.out.println(0);return;
}
if(P[i]!=i+1) {
break;
}
}
int a=0;
int past=0;
for(int i=0;i<N;i++) {
if(abs(past-P[i])==1||i==0) {
past=P[i];
a++;
}else {
break;
}
}
int b=N-a;
if(P[0]==1&&P[N-1]==N) {
System.out.println(0);
return;
}
if(P[0]==N&&P[N-1]==1) {
System.out.println(1);
return;
}
if(P[0]==P[N-1]+1) {
ans=min(a,b+2);
}else if(P[0]==P[N-1]-1){
ans=min(a+1,b+2);
}else {
while(true) {a++;}
}
System.out.println(ans);
}
static void reverse(int A[]) {
int B[]=new int[A.length];
for(int i=0;i<A.length;i++) {
A[i]=B[A.length-i-1];
}
A=B.clone();
}
static ArrayList<Long> divide(long T){
ArrayList<Long> cc=new ArrayList<>();
for(long i=1;i*i<=T;i++) {
if(T%i==0) {
cc.add(i);
if(T/i!=i)cc.add(T/i);
}
}
return cc;
}
static boolean check(int x,int y,int H,int W) {
if(x>=H||x<0||y<0||y>=W)return false;
return true;
}
static boolean check(char S[][],int X,int Y,int flag[][],int a) {
if(flag[X][Y]!=0||S[X][Y]=='.')return false;
Deque<Integer> x=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
Deque<Integer> y=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
x.add(X);y.add(Y);
int V[]= {0,0,-1,1};
flag[X][Y]=a;
int N=S.length;
while(!x.isEmpty()) {
X=x.poll();
Y=y.poll();
for(int i=0;i<4;i++) {
if(X+V[i]<0||X+V[i]>=N||Y+V[(i+2)%4]<0||Y+V[(i+2)%4]>=N||flag[X+V[i]][Y+V[(i+2)%4]]!=0||S[X+V[i]][Y+V[(i+2)%4]]=='.')continue;
x.add(X+V[i]);y.add(Y+V[(i+2)%4]);
flag[X+V[i]][Y+V[(i+2)%4]]=a;
}
}
return true;
}
static void solv3(int cs[],int ct[]) {
int ninesS[]=new int[10];
int ninesT[]=new int[10];
int s=1,t=8;
while(s<10) {
if(cs[s]<=0||ct[t]<=0) {
s++;t--;continue;
}
ninesS[s]=min(cs[s],ct[t]);
ninesT[t]=min(cs[s],ct[t]);
cs[s]-=min(cs[s],ct[t]);ct[t]-=min(cs[s],ct[t]);
}
int use_s=-1,use_t=-1;
//tの9を使わない場合
s=9;
a:while(s>0) {
t=1;
while(t<9) {
if(cs[s]<=0||ct[t]<=0) {
t++;continue;
}
use_s=s;use_t=t;cs[s]--;ct[t]--;break a;
}
}
//tの9を使う場合
if(use_s==-1) {
if(ct[9]>0) {
s=9;
while(s>0) {
if(cs[s]>0) {
cs[s]--;ct[9]--;
use_s=s;use_t=9;break;
}
}
}
}
//9のペアを崩す場合
if(use_s==-1) {
s=9;
while(s>0&&cs[s]<=0)s--;
use_s=s;
t=10-s;
while(t<10&&ninesT[t]<=0)t++;
use_t=t;
if(s==0||t==10)use_s=-1;
else {
cs[s]--;ninesT[t]--;ninesS[9-t]--;
cs[9-t]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ct[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ct[t]--;ninesS[s]--;ninesT[9-s]--;
ct[9-s]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ninesT[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ninesT[t]--;ninesS[9-t]--;ninesS[s]--;ninesT[9-s]--;
//これ余ったやつ戻さないとじゃね
cs[9-t]++;ct[9-s]++;
}
}
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
//まず、10をくっつける作業
if(use_s!=-1) {
S.append((char)('0'+use_s));
T.append((char)('0'+use_t));
}
//次に9をくっつける作業
int a=1;
while(a<10) {
if(ninesS[a]==0) {
a++;continue;
}
S.append((char)('0'+a));
T.append((char)('0'+9-a));ninesS[a]--;
}
//余ったやつをくっつける作業,ctは少し余るかもしれない
//10のマッチングうまくやって無くない？？？？？？？？？？？？？？
int b=8;a=9;
//優先順位はbの大きいやつ
while(b>0) {
a=10-b;
while(ct[b]>0&&a<10) {
if(cs[a]<=0) {
a++;continue;
}
while(ct[b]>0&&cs[a]>0) {
S.append((char)('0'+a));
T.append((char)('0'+b));
cs[a]--;ct[b]--;
}
}
b--;
}
}
static void secondSolv(int cs[],int ct[],int ans_s[],int ans_t[]) {
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
int a=1,b=1;
while(a<10&&b<10) {
if(cs[a]==0){
a++;continue;
}
if(ct[b]==0) {
b++;
continue;
}
while(cs[a]!=0&&ct[b]!=0) {
S.append((char)(a+'0'));
T.append((char)(b+'0'));
cs[a]--;ct[b]--;
}
}
//とりあえず要らないやつを付け終わったよ
int i=ans_s.length-1;
while(i>=0) {
if(ans_s[i]==0) {
i--;continue;
}
S.append((char)(ans_s[i]+'0'));
T.append((char)(ans_t[i]+'0'));
i--;
}
b=9;
while(b>0) {
while(ct[b]>0) {
ct[b]--;
T.append((char)(b+'0'));
}
b--;
}
//これで後ろも付け終わったよ
System.out.println(S.toString());
System.out.println(T.toString());
}
static void count(String S,int c[]) {
for(int i=0;i<S.length();i++) {
c[S.charAt(i)-'0']++;
}
}
static void rev(char t[]) {
char temp[]=new char[t.length];
int a=0;
for(int i=t.length-1;i>=0;i--) {
temp[a++]=t[i];
}
for(int i=0;i<t.length;i++) {
t[i]=temp[i];
}
}
static int get(int a,int b,int c,int d,int V[][]) {
//(a,b)~(c,d)の区間を求める
return V[c][d]-V[c][b-1]-V[a-1][d]+V[a-1][b-1];
}
static void add(int x,int y,long data,long DP[][],int H,int W,int V[][]) {
if(x<0||y<0||x>=H||y>=W)return;
//System.out.println("add:"+x+" "+y+" ~"+data);
DP[x][y]+=data;
DP[x][y]%=mod998244353;
}
static int f(int V) {
int count=0;
while(V!=0) {
V=V%Integer.bitCount(V);
count++;
}
return count;
}
static void opt2(int tourList[],int N,int Dis[][]) {
boolean back=true;
int i0=0;
a:while(back) {
back=false;
for(int i=i0;i<i0+N;i++) {
for(int j=i+2;j<i+N-1;j++) {
int a=tourList[i%N],b=tourList[(i+1)%N],c=tourList[j%N],d=tourList[(j+1)%N];
//if(Dis[a][b]+Dis[c][d]>Dis[a][d]+Dis[b][c]) {
if(Dis[a][b]+Dis[c][d]>Dis[a][c]+Dis[b][d]) {
for (int k = 0; k < (j-i)/2; k++) {
int temp = tourList[(i+1+k)%N];
tourList[(i+1+k)%N] = tourList[(j-k)%N];
tourList[(j-k)%N] = temp;
}
i0=(i+1)%N;
back=true;
continue a;
}
//i->i+1, j->j+1を
//i->j+1,j->i+1につなぎ直す事を考える。
}
}
}
}
static boolean is_swappable(int arrayments[],int a,int b) {
a=arrayments[a];
b=arrayments[b];
if(a==b||a==-b)return false;
//a->bに出来るか。
//1-indexed
int s=index(arrayments, a);
int e=index(arrayments, b);
if(a<0&&e>s)return true;
if(a>0&&s>e)return true;
int target=index(arrayments, -a);
if(a<0&&target<e)return true;
if(a>0&&target>e)return true;
return false;
}
static int index(int arrayments[],int a) {
for(int i=0;i<arrayments.length;i++) {
if(arrayments[i]==a)return i;
}
return -1;
}
static long tsp_solv(int N,long cost[][]) {
int start=0;
long DP[][]=new long[N][1<<N];
for(int i=0;i<N;i++)Arrays.fill(DP[i], LINF);
//スタートの初期化,スタートの位置は本質ではない
DP[start][1<<start]=0;
for(int T=1;T<(1<<N);T++) {
//Tは既に通った頂点の集合を表している。
for(int from=0;from<N;from++) {
if(((T>>from)&1)==0||DP[from][T]==LINF)continue;//まだfromに到達していない
for(int to=0;to<N;to++) {
if(((T>>to)&1)==1)continue;//既にtoに到達している
//from->toへの移動を考える
if(cost[from][to]==LINF)continue;
DP[to][T|1<<to]=Math.min(DP[from][T]+cost[from][to],DP[to][T|1<<to]);
}
}
}
long res=LINF;
for(int i=0;i<N;i++) {
res=Math.min(res,DP[i][(1<<N)-1]+cost[i][start]);
}
return res;
}
static void swap(int A[],int a,int b) {
int temp=A[a];
A[a]=A[b];
A[b]=temp;
}
static int v[]= {0,0,1,-1};
static int sum(int i,int G[]) {
int res=0;
for(int t=0;t<G.length;t++) {
if(((i>>t)&1)==0)continue;
res+=G[t];
}
return res;
}
static boolean check(char V[][],int x,int y,int vx,int vy,int d) {
for(int i=0;i<d;i++) {
if(x<0||y<0||x>=V.length||y>=V[0].length)return false;
if(V[x][y]=='#')return false;
x+=vx;y+=vy;
}
return true;
}
static boolean check(char S[][],char T[][],int a,int b) {
a*=-1;b*=-1;
int N=T.length;
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if((a+i>=N||a+i<0||b+t<0||b+t>=N)&&S[i][t]=='#'){
return false;
}
if((a+i>=N||a+i<0||b+t<0||b+t>=N))continue;
if(S[i][t]!=T[i+a][b+t]&&(S[i][t]=='#'||T[a+i][b+t]=='#')) {
return false;
}
}
}
return true;
}
static void nine(char V[][]) {
char G[][]=clone(V);
int N=V.length;
int a=0,b=0;
for(int i=N-1;i>=0;i--) {
for(int t=0;t<N;t++) {
V[i][t]=G[a++][b];
}
a=0;b++;
}
}
static char[][] idou(char V[][],int a,int b) {
int N=V.length;
char G[][]=new char[N][N];
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if(i+a<N&&t+b<N&&i+a>=0&&t+b>=0)G[i+a][t+b]=V[i][t];
}
}
return G;
}
static ArrayList<ArrayDeque<Integer>> cc = new ArrayList<>();
static Map<Integer, Integer> m = new HashMap<>();;
static void add(int index) {
if(cc.get(index).size()==0)return;
int color=cc.get(index).pollFirst();
if(!m.containsKey(color)) {
m.put(color, index);
}else {
add(m.get(color));
add(index);
}
}
static void makeT(ArrayList<ArrayList<Integer>> cc,int parent[],int root) {
Arrays.fill(parent, -2);
parent[root]=-1;
Queue<Integer> now = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
now.add(root);
while(!now.isEmpty()) {
int FROM=now.poll();
for(int TO:cc.get(FROM)) {
if(parent[TO]!=-2)continue;
parent[TO]=FROM;
now.add(TO);
}
}
}
static long tripet(long max,long min,long L[],long R[],int k) {
for(int i=0;i<1000;i++){
long c1=(max-min)/3+min;
long c2=(max-min)*2/3+min;
if(F(c1,L,R,k)>=F(c2,L,R,k)) {
min=c1;
}else{
max=c2;
}
}
return F((max+min)/2,L,R,k);
}
static long F(long x,long L[],long R[],int k) {
long res=0;
for(int i=0;i<k;i++) {
res=max(res,max(L[i]-x,x-R[i],0));
}
return res;
}
static double tripet(double x,double max,double min) {
while(max-min>=0.0000000000001){
double c1=(max-min)/3+min;
double c2=(max-min)*2/3+min;
if(F(x,c1)>=F(x,c2)) {
min=c1;
}else{
max=c2;
}
}
return (max+min)/2;
}
static double F(double x,double y) {
return x+y;
}
static class CUM2{
int V[][];
int h,w;
public CUM2(int A[][]) {//1-indexed
init(A);
}
void init(int A[][]) {
this.h=A.length;this.w=A[0].length;
V=new int[h][w];
for (int i = 0; i < h; i++) {
V[i]=A[i].clone();
}
for (int i = 1; i <h; i++) {
for (int t =1; t <w; t++) {
V[i][t]+=V[i][t-1];
}
}
for (int i = 1; i <w; i++) {
for (int t = 1; t <h; t++) {
V[t][i]+=V[t-1][i];
}
}
}
int get_sum(int a,int b,int c,int d) {
//[a,b]~[c,d]の区間和を返す。1-indexed
return V[c][d]+V[a-1][b-1]-V[a-1][d]-V[c][b-1];
}
}
/*long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}*/
//関数Fについて、区間[a,b]の最小値を求める
static long getF(long a,long b,long c,long d) {
//[a,b]と[c,d]の区間数の和
if(b<c||a>d) {
//完全に含まれない。
return (b-a+1)+(d-c+1);
}
if(c<=a&&b<=d) {
//完全に含まれる1
return d-c+1;
}
if(a<=c&&d<=b) {
//完全に含まれる2
return b-a+1;
}
//一部だけ含まれる。
if(c<=b&&b<=d) {
//[c,b]が含まれる。
return d-a+1;
}
if(c<=a&&a<=d) {
return b-c+1;
}
return -1;
}
static boolean check(int HW[][],int i,int t,int W) {
while(t<W) {
if(HW[i][t]%2==1)return true;
t++;
}
return false;
}
static void SCC(Map<Integer,ArrayList<Integer>> m,int N) {
int BACK[]=new int[N];
Arrays.fill(BACK, -1);
for (int i = 0; i < N; i++) {
if(BACK[i]!=-1)continue;
getBackQuery(m, i, BACK);
BACK[BACK_COUNT]=i;
}
Map<Integer,ArrayList<Integer>> reversedm=new HashMap<>();
for(int Vex:m.keySet()) {
for(int TO:m.get(Vex)) {
if(!reversedm.containsKey(TO))reversedm.put(TO, new ArrayList<>());
reversedm.get(TO).add(Vex);
}
}
uf=new unionFind(N);
for (int i = N-1; i>=0;i--) {
//iを始点として、DFSを行う。到達可能マスが同じグループ
if(uf.get(i)!=i)continue;
sccquery(reversedm, i);
}
}
static void sccquery(Map<Integer,ArrayList<Integer>> reversedm,int vex) {
if(!reversedm.containsKey(vex)||reversedm.get(vex).size()==0)return;
for(int TO:reversedm.get(vex)) {
if(uf.find(vex)==uf.find(TO))continue;
uf.union(vex, TO);
sccquery(reversedm, vex);
}
}
static int BACK_COUNT;
static unionFind uf;
static void getBackQuery(Map<Integer,ArrayList<Integer>> m,int Vex,int BACK[]) {
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int TO:m.get(Vex)) {
if(BACK[TO]!=-1)continue;
BACK[TO]=-2;
getBackQuery(m, Vex, BACK);
BACK[BACK_COUNT++]=TO;
}
}
static ArrayList<Integer> Vs;
static void getTopo(Map<Integer,ArrayList<Integer>> m,int N) {
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
Vs=new ArrayList<>();
for(int V:m.keySet()) {
if(flag[V])continue;
flag[V]=true;
topoQuery(m, V, flag);
Vs.add(V);
}
Collections.reverse(Vs);
}
static void topoQuery(Map<Integer,ArrayList<Integer>> m,int Vex, boolean flag[]) {
//Vexからスタート
//これ、閉路がある時に対応できてなくね
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int to:m.get(Vex)) {
if(flag[to])continue;
flag[to]=true;
topoQuery(m, to,flag);
Vs.add(to);
}
}
static class Flow{
static class edge{
int to,cap,rev;
public edge(int to,int cap,int rev) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cap=cap;
this.rev=rev;
}
}
public Flow(int N) {
// TODO 自動生成されたコンストラクター・スタブ
this.N=N;//頂点数
init();
}
void init() {
used=new boolean[N];
G=new ArrayList<>();
for (int i = 0; i < N; i++) {
G.add(new ArrayList<>());
}
}
int N;
ArrayList<ArrayList<edge>> G;//iがfromを意味する 隣接リスト表現
boolean used[];
//from->toへ向かう容量capの辺をグラフに追加する。
void add_edge(int from,int to,int cap) {
G.get(from).add(new edge(to, cap, G.get(to).size()));
G.get(to).add(new edge(from, 0, G.get(from).size()-1));
}
//最大流を求める 最悪計算量はO(F|E|) Fは流量,Eは辺の数?
int max_flow(int s,int t) {
int flow=0;
while(true) {
Arrays.fill(used, false);
int f=dfs(s,t,INF);
if(f==0)return flow;
flow+=f;
}
}
int dfs(int v,int t,int f) {
if(v==t)return f;//tに到着したら終了
used[v]=true;//vに訪れたことを表す
for (int i = 0; i < G.get(v).size(); i++) {
edge e=G.get(v).get(i);
if(used[e.to]||e.cap<=0)continue;
int d=dfs(e.to, t, Math.min(f,e.cap));
if(d>0) {
e.cap-=d;
G.get(e.to).get(e.rev).cap+=d;
return d;
}
}
return 0;
}
//デバッグ用
void get_edges(int T) {
//頂点Tから出る辺を出力する
int cout=0;
for(edge e:G.get(T)) {
System.out.println(cout+++" "+T+"=>"+e.to+" "+e.cap);
}
}
}
static class LCA{
static class edge{
int to;
long cost;
public edge(int to,long cost) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cost=cost;
}
}
int N;//頂点の数(頂点名は、0-indexで命名)
long dist[];//rootから頂点iまでの距離
int root;//木の根
int parents[];//頂点iの親がparents[i]
int doubling[][];
boolean is_built;
ArrayList<ArrayList<edge>> T;
public LCA(int N,int root) {
//頂点数と根を受け取る。
is_built=false;
this.root=root;
this.N=N;
T=new ArrayList<>(N);
for (int i = 0; i < N; i++) {
T.add(new ArrayList<>());
}
}
void add_edge(int u,int v,long cost) {
T.get(u).add(new edge(v,cost));
T.get(v).add(new edge(u,cost));
}
void build() {
init();
is_built=true;
}
void init() {
parents=new int[N];
dist=new long[N];
doubling=new int[31][N];
dfs(T);
init_doubling();
}
void dfs(ArrayList<ArrayList<edge>> T) {
//根からの距離と親を求める。
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
flag[root]=true;
parents[root]=root;
Queue<Integer> qq = new ArrayDeque<>(); //始点を保存
qq.add(root);
while(!qq.isEmpty()) {
int VEX=qq.poll();
if(T.get(VEX).size()==0)continue;
for(edge e:T.get(VEX)) {
if(flag[e.to])continue;
flag[e.to]=true;
parents[e.to]=VEX;
dist[e.to]=dist[VEX]+e.cost;
qq.add(e.to);
}
}
}
void init_doubling() {
//ダブリングによって、2^k先の祖先を前計算する。
//doubling[T][i]=iから2^T個分先
for (int i = 0; i < N; i++) {
doubling[0][i]=parents[i];
}
for (int T = 1; T < doubling.length; T++) {
for (int i = 0; i < N; i++) {
doubling[T][i]=doubling[T-1][doubling[T-1][i]];
}
}
}
int get_doubling(int from,long K) {
//ダブリングによって、fromからK先の祖先を求める。
//longにするときは、doublingの長さも変えないとだから注意
int res=from;
for (int i = 0; i < doubling.length; i++) {
if(((K>>i)&1)==0)continue;
res=doubling[i][res];
}
return res;
}
int query(int u1,int v1) {
//親からの距離を等しくする。(dist[u1]>dist[v1]とする)
//System.out.println(u1+" "+v1+" "+get_doubling(u1, dist[u1]-dist[v1]));
u1=get_doubling(u1, dist[u1]-dist[v1]);
if(u1==v1)return v1;
//二分探索によって、LCAの手前まで移動させる。
int G=30;
while(G>=0) {
int uTO=doubling[G][u1];
int vTO=doubling[G][v1];
if(uTO!=vTO) {
u1=uTO;
v1=vTO;
}
G--;
}
//System.out.println(parents[u1]+" "+parents[v1]+" "+dist[u1]+" "+dist[v1]+" "+u1+" "+v1);
return parents[u1];
}
int get_LCA(int u,int v) {
if(!is_built)build();
//根をrootとした時の、u,vのLCA(最小共通祖先)を返す。(0-indexed)
if(dist[u]<dist[v]) {
int temp=u;u=v;v=temp;
}
//dist[u]>dist[v]とする。
return query(u,v);
}
long get_dist(int u,int v) {
//u-vの距離
if(!is_built)build();
return -2*dist[get_LCA(u, v)]+dist[u]+dist[v];
}
boolean is_on_path(int u,int v,int a) {
//u-vパス上に頂点aがあるか?
//true:ある
//false:ない
return get_dist(u, a)+get_dist(a, v)==get_dist(u, v);
}
int INF=((1<<31)-1);
long dmtr=-LINF;
long get_diameter() {
if(dmtr!=-INF)return dmtr;
int V1=0;
long max_dis=-LINF;
for(int i=0;i<N;i++) {
long d=get_dist(0, i);
if(d>max_dis) {
max_dis=d;
V1=i;
}
}
max_dis=-INF;
//V1->V2への最大距離。
for (int i = 0; i < N; i++) {
max_dis=Math.max(max_dis,get_dist(V1,i));
}
return dmtr=max_dis;
}
}
static class doubling{
int N;
int bits;
int doubling[][];
long COST[][];
public doubling(int A[],int bits) {
this.bits=bits;
this.N=A.length;
init1(A);
}
public doubling(int A[],int bits,long C[]) {
// TODO 自動生成されたコンストラクター・スタブ
//long C[]は、i=>A[i]に行くコスト
//query2は、iからK番先までのコストの和で、i番までのコストが足されないので注意
this.bits=bits;
this.N=A.length;
init1(A);
init2(C);
}
private void init1(int A[]) {
// TODO 自動生成されたメソッド・スタブ
doubling=new int[bits][N];
for (int i = 0; i < N; i++) {
doubling[0][i]=A[i];
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
doubling[t+1][i]=doubling[t][doubling[t][i]];
}
}
}
private void init2(long C[]) {
COST=new long[bits][N];
for (int i = 0; i < N; i++) {
COST[0][i]=C[i];//i番目からA[i]までのコスト
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
COST[t+1][i]=COST[t][doubling[t][i]]+COST[t][i];
}
}
}
//解釈
private int query1(int start,long K) {
//startからK回移動した後の座標を求める。
int now=start;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1)now=doubling[i][now];
}
return now;
}
private long query2(int start,long K,long mod) {
//STARTからK回移動した時のコストを計算する。
int now=start;
long res=0;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1) {
res+=COST[i][now];
now=doubling[i][now];
res%=mod;
}
}
return res;
}
private int query3(int start) {
//startからスタートして、ループに入る時、そのループの長さを返す。
return 1;
}
}
static class DIKSTR{
ArrayList<ArrayList<edge2>> m;
static Map<String,Integer> hash=new HashMap<>();
static int hash_count=0;
long d[];
int V,E;
class edge2{
int to;
long cost;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
}
class pair implements Comparable<pair>{
int VEX;
long cost;
public pair(long cost,int VEX) {
this.VEX=VEX;
this.cost=cost;
}
public int compareTo(pair o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
public DIKSTR(int V,int E) {
this.V=V;//最大の頂点数。
this.E=E;//最大の辺数。
init();
}
public DIKSTR(int V) {
this.V=V;
this.E=0;
init();
}
void init() {
m=new ArrayList<>();
for (int i = 0; i < V; i++) {
m.add(new ArrayList<>());
}
d=new long[V];
}
void add_edge(int FROM,int TO,long COST) {
m.get(FROM).add(new edge2(TO, COST));
}
void add_edge(String FROM,String TO,long COST) {
if(!hash.containsKey(FROM))hash.put(FROM, hash_count++);
if(!hash.containsKey(TO))hash.put(TO, hash_count++);
add_edge(get_hash(FROM), get_hash(TO), COST);
}
int get_hash(String T) {
if(!hash.containsKey(T)) {
hash.put(T, hash_count++);
}
return hash.get(T);
}
long[] dikstr(String r) {
return dikstr(get_hash(r));
}
long[] dikstr(int r) {//rは始点
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<pair> p = new PriorityQueue<>();//add poll
p.add(new pair(0L, r));
while(!p.isEmpty()) {
pair x=p.poll();
int from=x.VEX;
if(x.cost>d[from])continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
long COST=COST(e.cost);
if(d[e.to]>d[from]+COST) {
d[e.to]=d[from]+COST;
p.add(new pair(d[e.to], e.to));
}
}
}
return d.clone();
}
long COST(long e_cost) {
return e_cost;
}
}
static Map<Integer, ArrayList<Integer>> getTree(int N){
Map<Integer, ArrayList<Integer>> m = new HashMap<>();
for (int i = 0; i < N; i++) {
int a = sc.nextInt() - 1, b = sc.nextInt() - 1;
if (!m.containsKey(a))
m.put(a, new ArrayList<Integer>());
if (!m.containsKey(b))
m.put(b, new ArrayList<Integer>());
m.get(a).add(b);
m.get(b).add(a);
}
return m;
}
/*static Map<V,Integer> makeTree(Map<Integer, ArrayList<Integer>> m){
//頂点0を根とした木を構築する。
Queue<Integer> qq = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
Queue<Integer> parent = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
qq.add(0);
Map<V, Integer> T = new HashMap<>();
parent.add(-1);
Queue<Integer> color = new ArrayDeque<>();
color.add(-1);
while (!qq.isEmpty()) {
int from = qq.poll();
int p = parent.poll();
int c=color.poll();
int X=1;
for (int V : m.get(from)) {
if (V == p)continue;
if(X==c)X++;
qq.add(V);
parent.add(from);
color.add(X);
System.out.println(from +" "+V+" "+X);
T.put(new V(from,V), X++);
}
}
return T;
}*/
static boolean isHaveSameBit(int a,int b) {//同じbitを持っているか
int t=0;
while((a>>t)!=0) {
if(((a>>t)&1)==1&&((b>>t)&1)==1)return true;
t++;
}
return false;
}
static boolean isPalindrome(String S) {//回分になってるか
for (int i = 0; i < S.length()/2; i++) {
if(S.charAt(i)!=S.charAt(S.length()-i-1)) {
return false;
}
}
return true;
}
static long modinv(long a,long mod) {
long b=mod,u=1,v=0;
while(b!=0) {
long t=a/b;
a-=t*b;long tem=a;a=b;b=tem;
u-=t*v;tem=u;u=v;v=tem;
}
u%=mod;
if(u<0)u+=mod;
return u;
}
static long[] extendedGCD(long a, long b) {
long s = 0, old_s = 1;
long t = 1, old_t = 0;
long r = b, old_r = a;
while(r != 0) {
long q = old_r / r;
long old_s0 = old_s, old_t0 = old_t, old_r0 = old_r;
old_s = s;
s = old_s0 - q * s;
old_t = t;
t = old_t0 - q * t;
old_r = r;
r = old_r0 - q * r;
}
return new long[] {old_s, old_t};
}
static class graph{
public graph() {
// TODO 自動生成されたコンストラクター・スタブ
}
//コンテスト中だけ
static class edge3{
int to;
long cost;
int K;
public edge3(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge3(int to,long cost,int K) {
this.to=to;
this.cost=cost;
this.K=K;
}
}
long costV(long T,int K) {
//T以上の最小のKの倍数を返す。
long V=(T+K-1)/K;
return V*K;
}
long[] adddikstr(int V,int E,int r,Map<Integer, ArrayList<edge3>> m) {
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge3 e=m.get(from).get(i);
if(d[e.to]>costV(d[from],e.K)+e.cost) {
d[e.to]=costV(d[from],e.K)+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d;
}
//
class edge implements Comparable<edge>{
int from,to;
long cost;
public edge(int from,int to,long b) {
this.from=from;
this.to=to;
this.cost=b;
}
@Override
public int compareTo(edge o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
static class edge2{
int to;
long cost;
String FROM,TO;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge2(int to,long cost,String FROM,String TO) {
this.to=to;
this.cost=cost;
this.FROM=FROM;
this.TO=TO;
}
}
//単一始点最短距離問題(ダイクストラ法) 負閉路対策不可 経路復元
long d[];
long[] dikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
//path[e.to]=from;
}
}
}
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return d.clone();
}
long[] additionalDikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m,int banned) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(from==banned&&e.to==0)continue;
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d.clone();
}
int D[];
int[] Intdikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
D=new int[V];
Arrays.fill(D, INF);
D[r]=0;
PriorityQueue<Pair<Integer,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Integer, Integer>(0, r));
while(!p.isEmpty()) {
Pair<Integer,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>D[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(D[e.to]>D[from]+e.cost) {
D[e.to]=(int) (D[from]+e.cost);
p.add(new Pair<Integer, Integer>(D[e.to], e.to));
//path[e.to]=from;
}
}
}
p.clear();
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return D;
}
//単一始点最短距離問題(ベルマンフォード法) 負閉路対策済み
long[] Bellman_Ford(int V,int E,int r,edge e[]) {
long d[]=new long[V]; //0~eのグラフはこれ
//Map<Integer, Integer> d = new HashMap<>();それ以外はこれ
//for(int i=0;i<E;i++) {
// if(!d.containsKey(e[i].to))m.add(new Pair<Integer, Integer>(e[i].to, INF));
// if(!d.containsKey(e[i].from))m.add(new Pair<Integer, Integer>(e[i].from, INF));
//}
//d.replace(r, 0);
Arrays.fill(d, INF);
d[r]=0;
int count=0;
while(true) {
boolean update =false;
for(int i=0;i<E;i++) {
if(d[e[i].from]!=INF&&d[e[i].from]+e[i].cost<d[e[i].to]) {
update=true;
d[e[i].to]=d[e[i].from]+e[i].cost;
}
}
if(!update)break;
if(count==V) {
p("NEGATIVE CYCLE");
return null;
}
count++;
}
return d;
}
//最小全域木問題(クラスカル法)
long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}
}
private static long Pow(long i,long t) {
//iのt乗をO(log t)で返す
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをStringで受け取りたい時用
while(t!=0) {
if((1&t)==1) {
res=res*a;
}
a=a*a;
t=t>>1;
}
return res;
}
private static Map<Long, Integer> primeNumbers(long N) {//素因数列挙
Map<Long, Integer> c = new HashMap<>();
for(long i=2;i*i<=N;i++) {
if(N%i==0) {
int count=0;
while(N%i==0) {
N/=i;
count++;
}
c.put(i, count);
continue;
}
}
if(N!=1) {
c.put(N, 1);
}
return c;
}
//=========================Union Find=============================================
//union idx2 tree to idx1 tree O(a(N))
static class unionFind{
int UNI[],n,graph_s;
public unionFind(int N) {
// TODO 自動生成されたコンストラクター・スタブ
n=N;
graph_s=N;
init();
}
void init() {
UNI=new int[n];
for (int i = 0; i < n; i++) {
UNI[i]=i;
}
}
int get(int idx) {
return UNI[idx];
}
int find(int idx) {//木の根のindexを返す
if(UNI[idx]==idx) return idx;
return UNI[idx] = find(UNI[idx]);
}
void shape() {//木の根に直接つなげる 経路圧縮
for(int i=0;i<n;i++) {
find(i);
}
}
void union(int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(UNI[root2]!=root1)graph_s--;
UNI[root2] = root1;
}
void breaker(int idx1,int idx2) {
UNI[idx1]=idx1;
}
int MaxSize() {//最も大きい木の頂点数を返す
shape();
int V[]=new int[n];
int max=0;
for(int i=0;i<n;i++) {
V[UNI[i]]++;
max=Math.max(max, V[UNI[i]]);
}
return max;
}
int sum() {//木の数を返す
int res=0;
for(int i=0;i<n;i++) {
if(UNI[i]==i)res++;
}
return res;
}
void union2(int tree[],int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(root1==root2)return;
if(c.get(root1).size()>c.get(root2).size()) {
//root2をroot1に移し替える
for(int a:c.get(root2).keySet()) {
if(!c.get(root1).containsKey(a)) {
c.get(root1).put(a, 0);
}
c.get(root1).replace(a, c.get(root1).get(a)+c.get(root2).get(a));
}
tree[root2] = root1;
}else {
for(int a:c.get(root1).keySet()) {
if(!c.get(root2).containsKey(a)) {
c.get(root2).put(a, 0);
}
c.get(root2).replace(a, c.get(root2).get(a)+c.get(root1).get(a));
}
tree[root1] = root2;
}
}
}
//=========================二分探索=============================================
private static class binarySerch{
public binarySerch() {
// TODO 自動生成されたコンストラクター・スタブ
}
int BinarySearch(int A[],int value) {
int S=0,E=A.length,G=-1;
while(S<=E) {
G=(S+E)/2;
if(A[G]==value)return G;
else if(A[G]>value) {
if(E==G)break;E=G;
}else if(A[G]<value) {
if(S==G)break;S=G;
}
}
return -1;
}
int lowerBound(int A[],int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>=value)return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(int A[],int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(long A[],long value) {
//A[i-1]<value<=A[i] value以上の最小indexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>=value)return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(long A[],long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Integer> A,int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Integer> A,int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Long> A,long value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Long> A,long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
}
private static long modNcR2(int n,int r,int mod) {
if(r<0||n<r)return 0;
long N=kaijou(n, mod);
long Nr=kaijou(n-r, mod);
long R=kaijou(r, mod);
return (((N*modPow(Nr, mod-2, mod))%mod)*modPow(R, mod-2, mod))%mod;
// n!/(n-r)!/r!
}
private static long modPow(long i,long t,long mod) {
if(t==0)return 1%mod;
if(i==0||t<0)return 0;//0未満乗は未定義で
//iのt乗をO(log t)で返す
i%=mod;
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをbitのStringで受け取った時用？
while(t!=0) {
if((1&t)==1) {
res=res*a%mod;
}
a=a*a%mod;
t=t>>1;
}
return res;
}
private static long min(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int min(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int max(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static long max(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static double min(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static double max(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static int abs(int a) {
return Math.max(a,-a);
}
private static long abs(long a) {
return Math.max(a,-a);
}
private static double abs(double a) {
return Math.max(a,-a);
}
private static String zeroume(String S,int V) {
while(S.length()<V)S='0'+S;
return S;
}
//速度が足りないときは、前計算を1回だけにしたり、longをintに変えたりするといい
//エラストネスの篩風のやつもあり
private static long gcd(long ...nums) {
long res=0;
for (int i = 0; i < nums.length; i++) {
res=gcd(res,nums[i]);
}
return res;
}
private static long lcm(long ...nums) {
long res=1;
for (int i = 0; i < nums.length; i++) {
res=lcm(res,nums[i]);
}
return res;
}
public static long gcd(long num1,long num2) {
if(num2==0) return num1;
else return gcd(num2,num1%num2);
}
public static long lcm(long num1,long num2) {
return num1*num2/gcd(num1,num2);
}
//O(N^0.5)
private static void bubunwa() {
int N=sc.nextInt();
int K=sc.nextInt();
int a[]=sc.nextIntArray(N, false);
boolean dp[] =new boolean[K+1];
Arrays.fill(dp, false);
dp[0]=true;
for(int i=0;i<N;i++) {
for(int x=K-a[i];x>=0;x--) {
if(dp[x])dp[x+a[i]]=true;
}
}
p(dp[K] ? "Yes":"No");
}
static String nextPermutation(String s) {
ArrayList<Character> list=new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
list.add(s.charAt(i));
}
int pivotPos=-1;
char pivot=0;
for(int i=list.size()-2;i>=0;i--) {
if(list.get(i)<list.get(i+1)) {
pivotPos=i;
pivot=list.get(i);
break;
}
}
if(pivotPos==-1&&pivot==0) {
return "Final";
}
int L=pivotPos+1,R=list.size()-1; int minPos=-1;
char min =Character.MAX_VALUE;
for(int i=R;i>=L;i--) {
if(pivot<list.get(i)) {
if(list.get(i)<min) {
min=list.get(i);
minPos=i;
}
}
}
Collections.swap(list, pivotPos, minPos);
Collections.sort(list.subList(L, R+1));
StringBuilder sb=new StringBuilder();
for(int i=0;i<list.size();i++) {
sb.append(list.get(i));
}
return sb.toString();
}
private static long[][] com;
private static void nCr(int mod) {
int MAX = 3001;
com= new long[MAX][MAX];
for(int i = 0; i < MAX; i++)
com[i][0] = 1;
for(int i = 1; i < MAX; i++) {
for(int j = 1; j <= i; j++) {
com[i][j] = com[i-1][j-1] + com[i-1][j];
com[i][j] %= mod;
}
}
}
//https://qiita.com/p_shiki37/items/65c18f88f4d24b2c528b より
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
return (int) nextLong();
}
public double nextDouble(){
return Double.parseDouble(next());
}
public int[] nextIntArray(int N) {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
public int[] nextIntArray(int N, boolean oneBased) {
if (oneBased) {
int[] array = new int[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextInt();
}
return array;
} else {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
}
public long[] nextLongArray(int N, boolean oneBased) {
if (oneBased) {
long[] array = new long[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextLong();
}
return array;
} else {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
}
public int[] nextRandIntArray(int N, boolean oneBased,int max) {
Random r=new Random();
if(oneBased)N++;
int array[]=new int[N];
for(int i=0;i<N;i++) {
array[i]=r.nextInt(max+1);
}
if(oneBased)array[0]=0;
return array;
}
public long[] nextLongArray(int N) {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
public long[][]nextLongDimensionalArray(int H,int W) {
long[][] array = new long[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextLongArray(W);
}
return array;
}
public int[][]nextIntDimensionalArray(int H,int W) {
int[][] array = new int[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextIntArray(W);
}
return array;
}
public String[] nextArray(int N) {
String[] array = new String[N];
for (int i = 0; i < N; i++) {
array[i] = sc.next();
}
return array;
}
public String[][]nextDimensionalArray(int H,int W) {
String[][] array = new String[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextArray(W);
}
return array;
}
public double[] nextDoubleArray(int N) {
double[] array = new double[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextDouble();
}
return array;
}
}
}
/*
created by krps
本体は634行目あたりのsolve()に書いてあります。
Good Luck!
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
public class Main implements Runnable {
static FastScanner sc = new FastScanner();
static PrintWriter out = new PrintWriter(System.out);
public static class Pair<K, V> extends AbstractMap.SimpleEntry<K, V> implements Comparable<Pair<K, V>> {
public Pair(final K key, final V value) {
super(key, value);
}
@Override
public int compareTo(Pair<K, V> o) {
Comparable key = (Comparable)this.getKey();
Comparable key2 = (Comparable)o.getKey();
/*if (false) {
Comparable key3 = (Comparable) this.getValue();
Comparable key4 = (Comparable) o.getValue();
if (key.compareTo(key2) == 0) {
return key3.compareTo(key4);
}
}*/
return key.compareTo(key2);
}
}
private static boolean isPrime(long t) {
if(t<2)return false;
for(int i=2;i*i<=t;i++) {
if(t%i==0)return false;
}
return true;
}
@SuppressWarnings("unused")
private static long ncr(long n,long r) {
long res=1;
for(int i=0;i<r;i++) {
res*=n-i;
res/=i+1;
}
return res;
}
@SuppressWarnings("unused")
private static int StringCount(String T,String v) {
int res=0;
int t=0;
while(T.indexOf(v,t)>=0) {
//p(t);
res++;
t=T.indexOf(v,t)+1;
}
return res;
}
private static int arrayMin(int a[]) {
int res=INF;
for(int i=0;i<a.length;i++)res=min(res,a[i]);
return res;
}
private static long arrayMin(long a[]) {
long res=INF;
for(int i=0;i<a.length;i++)res=min(res,a[i]);
return res;
}
private static int arrayMax(int a[]) {
int res=-INF;
for(int i=0;i<a.length;i++)res=Math.max(res,a[i]);
return res;
}
private static long arrayMax2(long a[]) {
return Arrays.stream(a).max().getAsLong();
}
private static long arrayMax(long a[]) {
long res=-INF;
for(int i=0;i<a.length;i++)res=max(res,a[i]);
return res;
}
private static long arraySum(long a[]) {
long res=0;
for(int i=0;i<a.length;i++)res+=a[i];
return res;
}
private static long arraySum(int a[]) {
long res=0;
for(int i=0;i<a.length;i++)res+=a[i];
return res;
}
private static void swap(long V[],int a,int b) {
long temp=V[b];
V[b]=V[a];
V[a]=temp;
}
private static void p(long[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(long[] a) {p(Arrays.toString(a));};
private static void p(int[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(int[] a) {p(Arrays.toString(a));};
//大量にout.println();をすると、自動でout.flush();されるので、出力される順番には気を付けよう
// * out.println()の後にSystem.out.println();をしたいときとかねー
private static <T> void p(T t) {out.println(t);}
private static <T> void p() {out.println();}
private static void p(graph.edge2[] e) {
for (int i = 0; i < e.length; i++) {
out.println(e[i].to+" "+e[i].cost);
}
}
private static void doubleToString(double a) {
System.out.println(BigDecimal.valueOf(a).toPlainString());
}
private static ArrayList<Map<Integer,Integer>> c;
private static <T> int[] ArrayListToList(ArrayList<Integer> c2,int[] v) {for(int i=0;i<c2.size();i++)v[i]=c2.get(i);return v;}
private static ArrayList<Integer> ListToArrayList(int[] v) {ArrayList<Integer> c=new ArrayList<>(v.length);for(int i=0;i<v.length;i++)c.add(v[i]);return c;}
private static String maenizero(String s,int keta) {
while(s.length()<keta)s="0"+s;
return s;
}
private static int ketawa(String S) {
int res=0;
for(int i=0;i<S.length();i++) {
res+=S.charAt(i)-'0';
}return res;
}
private static int ketawa(int S) {
int res=0;
while(S!=0) {
res+=S%10;
S/=10;
}
return res;
}
private static long X_x[]=new long[1];
private static long kaijou(int x,long mod) {
if(X_x.length!=300000)X_x=new long[300000];
if(x<=1)return X_x[x]=1;
if(X_x[x]!=0)return X_x[x];
return X_x[x]=(x*kaijou(x-1,mod))%mod;
/*long a=1;
for(int i=2;i<=K;i++)a=(a*i)%mod;
return (int)a;*/
}
static class segmentTree{
int n;
long dat[];
long identity;//単位元
segmentTree(int N,long identity) {//setTreeの要素の数,単位元
this.identity =identity;
init(N);
}
void init2() {
Arrays.fill(dat, 0);
}
void init(int n_) {
this.n=1;
while(n<n_)n*=2;
this.dat= new long[2*n-1];
Arrays.fill(dat, identity);
}
void update(int k,long a) {
k+=n-1;
dat[k]=a;
while(k>0) {
k=(k-1)/2;
//System.err.println("update "+k+" "+Cal(this.dat[k*2+1],this.dat[k*2+2]));
dat[k]=Cal(dat[k*2+1],dat[k*2+2]);
}
}
//外から呼び出すときはl=0,r=-1,k=0にする。
void update(int a,int b,int k,int X,int l,int r) {
if(r==-1)r=n;
if(r<=a||b<=l) {
return;
}
if(a<=l&&r<=b) {
dat[k]=min(dat[k],X);
}else {
update(a, b, k*2+1,X, l, (l+r)/2);
update(a, b,k*2+2,X,(l+r)/2,r);
}
}
long get(int k) {//k番目の値を取得 0<=k<N
k+=n-1;
return dat[k];
}
//[a,b]を求める。
//a~bのこと。0-indexed
long getV(int a,int b) {
a=Math.max(0,a);
b=min(n-1,b);
b++;
return query(a, b, 0, 0, n);
}
int getleft(int a,int b,long x) {
return find_leftest_sub(a, b, x, 0, 0, n);
}
int getright(int a,int b,long x) {
return find_rightest_sub(a, b, x, 0, 0, n);
}
//[a,b)の値を求める
//a~b-1のことで、0-indexed
//外から呼び出すときは、a,b,0,0,N
long query(int a,int b,int k,int l,int r) {
if(r<=a||b<=l) {
//l,rが求めたい区間a,bに完全に含まれていない
return identity;
}
if(a<=l&&r<=b) {
//l,rが、求めたい区間a,bに完全に含まれている
return dat[k];
}else {
//l,rが、求めたい区間a,bに一部分だけ含まれている。
long A=query(a, b, k*2+1, l, (l+r)/2);
long B=query(a, b, k*2+2, (l+r)/2, r);
return Cal(A,B);
}
}
//x以下の要素を持つ最も左のもののindexを返す。 *RM(min)Q上でしか動かない
int find_rightest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn a-1
return a - 1;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vr = find_rightest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
if (vr != a - 1) { // 右の部分木を見て a-1 以外ならreturn
return vr;
} else { // 左の部分木を見て値をreturn
return find_rightest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
}
}
}
int find_leftest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn b
return b;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vl = find_leftest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
if (vl != b) { // 左の部分木を見て b 以外ならreturn
return vl;
} else { // 右の部分木を見て値をreturn
return find_leftest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
}
}
}
//RSQ上で動きます。
int query2(long X) {
int k=0;
//ここでは、Σ[0,r]Ai=Xとなる最小のrを求めたい
while(k*2+1<dat.length) {
if(dat[k*2+1]>=X) {
k=k*2+1;
}else {
X-=dat[k*2+1];
k=k*2+2;
}
}
return k-=n-1;
}
long Cal(long a,long b) {
//計算アルゴリズム
return Math.max(a,b);
//return a|b;
//return max(a,b);
//return gcd(a, b);
//return a^b;
//return Math.min(a, b);
}
int size() {
//Nではないよ、配列の大きさを返す。
return n;
}
//確認事項:Calとidentity
//segmentTreeで宣言、initで初期化する。
void toString(int n) {
for(int i=0;i<n*2;i++) {
System.err.print(dat[i]+" ");
}
System.err.println();
}
}
static class LazySegmentTree{
int n;
long node[],lazy[];
int identity;
long cal(long a,long b) {
return a+b;
}
public LazySegmentTree(long[] A,int iden) {
// TODO 自動生成されたコンストラクター・スタブ
init(A);
identity=iden;
}
//初期化
void init(long A[]) {
n=1;
int sz=A.length;
while(n<sz)n*=2;
node=new long[2*n-1];
lazy=new long[2*n-1];
for(int i=0;i<sz;i++)node[i+n-1]=A[i];
for(int i=n-2;i>=0;i--)node[i]=cal(node[i*2+1],node[i*2+2]);
}
void eval(int k,int l,int r) {
//k番目のノードについて、遅延評価を行う？
// 遅延配列が空でない場合、自ノード及び子ノードへの
// 値の伝播が起こる
if(lazy[k]!=identity) {
node[k]+=lazy[k];
System.out.println(r);
if(r-1>1) {//最下段かどうか
lazy[2*k+1]=cal(lazy[k]/2, lazy[2*k+1]);//ここもRSQ以外未定義 /2するところを要変更
lazy[2*k+2]=cal(lazy[k]/2, lazy[2*k+1]);
// 子ノードは親ノードの 1/2 の範囲であるため、
// 伝播させるときは半分にする
}
lazy[k]=identity;
}
}
//区間加算,外から呼び出すときは、l=0,r=-1
void add(int a,int b,long x,int k,int l,int r) {
//[a,b)の区間にxを加算する。
if(r<0)r=n;
eval(k,l,r);
if(b<=l||r<=a)return;
if(a<=l&&r<=b) {
lazy[k]=cal((r-1)*x,lazy[k]);//ここもRSQ以外未定義 *xするところを要変更
eval(k, l, r);
}else {
add(a, b, x, 2*k+1, l, (l+r)/2);
add(a, b, x, 2*k+2, (l+r)/2, r);
node[k]=cal(node[2*k+1],node[2*k+2]);
}
}
//区間和取得,外から呼び出すときは、l=0,r=-1
long getsum(int a,int b,int k,int l,int r) {
if(r<0)r=n;
if(b<=l||r<=a)return 0;
eval(k, l, r);
if(a<=l&&r<=b)return node[k];
long vl=getsum(a, b, 2*k+1, l, (l+r)/2);
long vr=getsum(a, b, 2*k+2, (l+r)/2, r);
return cal(vl,vr);
}
}
static class IntsegmentTree{
int n;
int dat[];
int identity;//単位元
IntsegmentTree(int N,int identity) {//setTreeの要素の数,単位元
this.identity =identity;
init(N);
}
void init2() {
Arrays.fill(dat, 0);
}
void init(int n_) {
this.n=1;
while(n<n_)n*=2;
this.dat= new int[2*n-1];
Arrays.fill(dat, identity);
}
void update(int k,int a) {
k+=n-1;
dat[k]=a;
while(k>0) {
k=(k-1)/2;
//System.err.println("update "+k+" "+Cal(this.dat[k*2+1],this.dat[k*2+2]));
dat[k]=Cal(dat[k*2+1],dat[k*2+2]);
}
}
//外から呼び出すときはl=0,r=-1,k=0にする。
void update(int a,int b,int k,int X,int l,int r) {
if(r==-1)r=n;
if(r<=a||b<=l) {
return;
}
if(a<=l&&r<=b) {
dat[k]=min(dat[k],X);
}else {
update(a, b, k*2+1,X, l, (l+r)/2);
update(a, b,k*2+2,X,(l+r)/2,r);
}
}
int get(int k) {//k番目の値を取得 0<=k<N
k+=n-1;
return dat[k];
}
//[a,b]を求める。
//a~bのこと。0-indexed
int getV(int a,int b) {
a=Math.max(0,a);
b=min(n-1,b);
b++;
return query(a, b, 0, 0, n);
}
int getleft(int a,int b,long x) {
return find_leftest_sub(a, b, x, 0, 0, n);
}
int getright(int a,int b,long x) {
return find_rightest_sub(a, b, x, 0, 0, n);
}
//[a,b)の値を求める
//a~b-1のことで、0-indexed
//外から呼び出すときは、a,b,0,0,N
int query(int a,int b,int k,int l,int r) {
if(r<=a||b<=l) {
//l,rが求めたい区間a,bに完全に含まれていない
return identity;
}
if(a<=l&&r<=b) {
//l,rが、求めたい区間a,bに完全に含まれている
return dat[k];
}else {
//l,rが、求めたい区間a,bに一部分だけ含まれている。
int A=query(a, b, k*2+1, l, (l+r)/2);
int B=query(a, b, k*2+2, (l+r)/2, r);
return Cal(A,B);
}
}
//x以下の要素を持つ最も左のもののindexを返す。 *RM(min)Q上でしか動かない
int find_rightest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn a-1
return a - 1;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vr = find_rightest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
if (vr != a - 1) { // 右の部分木を見て a-1 以外ならreturn
return vr;
} else { // 左の部分木を見て値をreturn
return find_rightest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
}
}
}
int find_leftest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn b
return b;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vl = find_leftest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
if (vl != b) { // 左の部分木を見て b 以外ならreturn
return vl;
} else { // 右の部分木を見て値をreturn
return find_leftest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
}
}
}
//RSQ上で動きます。
int query2(int X) {
int k=0;
//ここでは、Σ[0,r]Ai=Xとなる最小のrを求めたい
while(k*2+1<dat.length) {
if(dat[k*2+1]>=X) {
k=k*2+1;
}else {
X-=dat[k*2+1];
k=k*2+2;
}
}
return k-=n-1;
}
int Cal(int a,int b) {
//計算アルゴリズム
return (a+b);
//return a|b;
//return max(a,b);
//return gcd(a, b);
//return a^b;
//return Math.min(a, b);
}
int size() {
//Nではないよ、配列の大きさを返す。
return n;
}
//確認事項:Calとidentity
//segmentTreeで宣言、initで初期化する。
void toString(int n) {
for(int i=0;i<n*2;i++) {
System.err.print(dat[i]+" ");
}
System.err.println();
}
}
static void B(boolean x) {
p(x? "Yes":"No");
}
static void B(boolean x, String a,String b) {
p(x? a:b);
}
static char[][] clone(char V[][]) {
char RES[][]=new char[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static int[][] clone(int V[][]) {
int RES[][]=new int[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static long ceil(long a,long b) {
//ceil(a/b)を返す。
//a/bの切り上げ
return (a+b-1)/b;
}
static long floor(long a,long b) {
//floor (a/b)を返す。
//a/bの切り捨て
return a/b;
}
//Math.multiplyExact(T, A[i])
static void comp(int a[]) {
binarySerch bs = new binarySerch();
int b[]=Arrays.stream(a).distinct().toArray();
Arrays.parallelSort(b);
for (int i = 0; i < a.length; i++) {
a[i]=bs.lowerBound(b, a[i])+1;
compmax=Math.max(compmax,a[i]);
}
}
static final long mod7=Pow(10,9)+7,mod9=Pow(10,9)+9;
static long LINF =(1L<<63)-1,count=0,sum=0,max=-LINF,min=LINF,ans=0,temp;
static int i=0,INF=(1<<31)-1,compmax=0;
static long A[];
static final long mod998244353=998244353;
static Random r=new Random();
public static void main(String[] args) {
new Thread(null, new Main(), "", 1024 * 1024 * 1024).start(); //16MBスタックを確保して実行
}
public void run() {
for(int i=0;i<1;i++) {
solver();
out.close();
//out.flush();
}
}
static class V implements Comparable<V>{
int v,u,w,count;
public V(int v,int u,int w,int count) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.u=u;this.w=w;this.count=-count;
}
public int compareTo(V o) {
Comparable key = (Comparable)this.count;
Comparable key2 = (Comparable)o.count;
return key.compareTo(key2);
}
}
static class edge{
int v,dis;
public edge(int v,int dis) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.dis=dis;
}
}
static class T implements Comparable<T>{
int index;
int dis;
public T(int index,int dis) {
this.index=index;
this.dis=dis;
}
public int compareTo(T o) {
Comparable key = (Comparable)this.dis;
Comparable key2 = (Comparable)o.dis;
return key.compareTo(key2);
}
}
/*
long DP[][][]=new long[N][K][K];
//DP[i][k1][k2]:最後に取ったのがk1個前で、二番目に取ったのがk2個前のやつの最大値
//i番目を取るまでの最大値を再帰的に求める。
//
*/
private static void solver(){
int N=sc.nextInt();
int P[]=sc.nextIntArray(N);
for(int i=0;i<=N;i++) {
if(i==N) {
System.out.println(0);return;
}
if(P[i]!=i+1) {
break;
}
}
int a=0;
int past=0;
for(int i=0;i<N;i++) {
if(abs(past-P[i])==1||i==0) {
past=P[i];
a++;
}else {
break;
}
}
int b=N-a;
if(P[0]==1&&P[N-1]==N) {
System.out.println(0);
return;
}
if(P[0]==N&&P[N-1]==1) {
System.out.println(1);
return;
}
if(P[0]==P[N-1]+1) {
ans=min(a,b+2);
}else if(P[0]==P[N-1]-1){
ans=min(a+1,b+1);
}else {
while(true) {a++;}
}
System.out.println(ans);
}
static void reverse(int A[]) {
int B[]=new int[A.length];
for(int i=0;i<A.length;i++) {
A[i]=B[A.length-i-1];
}
A=B.clone();
}
static ArrayList<Long> divide(long T){
ArrayList<Long> cc=new ArrayList<>();
for(long i=1;i*i<=T;i++) {
if(T%i==0) {
cc.add(i);
if(T/i!=i)cc.add(T/i);
}
}
return cc;
}
static boolean check(int x,int y,int H,int W) {
if(x>=H||x<0||y<0||y>=W)return false;
return true;
}
static boolean check(char S[][],int X,int Y,int flag[][],int a) {
if(flag[X][Y]!=0||S[X][Y]=='.')return false;
Deque<Integer> x=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
Deque<Integer> y=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
x.add(X);y.add(Y);
int V[]= {0,0,-1,1};
flag[X][Y]=a;
int N=S.length;
while(!x.isEmpty()) {
X=x.poll();
Y=y.poll();
for(int i=0;i<4;i++) {
if(X+V[i]<0||X+V[i]>=N||Y+V[(i+2)%4]<0||Y+V[(i+2)%4]>=N||flag[X+V[i]][Y+V[(i+2)%4]]!=0||S[X+V[i]][Y+V[(i+2)%4]]=='.')continue;
x.add(X+V[i]);y.add(Y+V[(i+2)%4]);
flag[X+V[i]][Y+V[(i+2)%4]]=a;
}
}
return true;
}
static void solv3(int cs[],int ct[]) {
int ninesS[]=new int[10];
int ninesT[]=new int[10];
int s=1,t=8;
while(s<10) {
if(cs[s]<=0||ct[t]<=0) {
s++;t--;continue;
}
ninesS[s]=min(cs[s],ct[t]);
ninesT[t]=min(cs[s],ct[t]);
cs[s]-=min(cs[s],ct[t]);ct[t]-=min(cs[s],ct[t]);
}
int use_s=-1,use_t=-1;
//tの9を使わない場合
s=9;
a:while(s>0) {
t=1;
while(t<9) {
if(cs[s]<=0||ct[t]<=0) {
t++;continue;
}
use_s=s;use_t=t;cs[s]--;ct[t]--;break a;
}
}
//tの9を使う場合
if(use_s==-1) {
if(ct[9]>0) {
s=9;
while(s>0) {
if(cs[s]>0) {
cs[s]--;ct[9]--;
use_s=s;use_t=9;break;
}
}
}
}
//9のペアを崩す場合
if(use_s==-1) {
s=9;
while(s>0&&cs[s]<=0)s--;
use_s=s;
t=10-s;
while(t<10&&ninesT[t]<=0)t++;
use_t=t;
if(s==0||t==10)use_s=-1;
else {
cs[s]--;ninesT[t]--;ninesS[9-t]--;
cs[9-t]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ct[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ct[t]--;ninesS[s]--;ninesT[9-s]--;
ct[9-s]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ninesT[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ninesT[t]--;ninesS[9-t]--;ninesS[s]--;ninesT[9-s]--;
//これ余ったやつ戻さないとじゃね
cs[9-t]++;ct[9-s]++;
}
}
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
//まず、10をくっつける作業
if(use_s!=-1) {
S.append((char)('0'+use_s));
T.append((char)('0'+use_t));
}
//次に9をくっつける作業
int a=1;
while(a<10) {
if(ninesS[a]==0) {
a++;continue;
}
S.append((char)('0'+a));
T.append((char)('0'+9-a));ninesS[a]--;
}
//余ったやつをくっつける作業,ctは少し余るかもしれない
//10のマッチングうまくやって無くない？？？？？？？？？？？？？？
int b=8;a=9;
//優先順位はbの大きいやつ
while(b>0) {
a=10-b;
while(ct[b]>0&&a<10) {
if(cs[a]<=0) {
a++;continue;
}
while(ct[b]>0&&cs[a]>0) {
S.append((char)('0'+a));
T.append((char)('0'+b));
cs[a]--;ct[b]--;
}
}
b--;
}
}
static void secondSolv(int cs[],int ct[],int ans_s[],int ans_t[]) {
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
int a=1,b=1;
while(a<10&&b<10) {
if(cs[a]==0){
a++;continue;
}
if(ct[b]==0) {
b++;
continue;
}
while(cs[a]!=0&&ct[b]!=0) {
S.append((char)(a+'0'));
T.append((char)(b+'0'));
cs[a]--;ct[b]--;
}
}
//とりあえず要らないやつを付け終わったよ
int i=ans_s.length-1;
while(i>=0) {
if(ans_s[i]==0) {
i--;continue;
}
S.append((char)(ans_s[i]+'0'));
T.append((char)(ans_t[i]+'0'));
i--;
}
b=9;
while(b>0) {
while(ct[b]>0) {
ct[b]--;
T.append((char)(b+'0'));
}
b--;
}
//これで後ろも付け終わったよ
System.out.println(S.toString());
System.out.println(T.toString());
}
static void count(String S,int c[]) {
for(int i=0;i<S.length();i++) {
c[S.charAt(i)-'0']++;
}
}
static void rev(char t[]) {
char temp[]=new char[t.length];
int a=0;
for(int i=t.length-1;i>=0;i--) {
temp[a++]=t[i];
}
for(int i=0;i<t.length;i++) {
t[i]=temp[i];
}
}
static int get(int a,int b,int c,int d,int V[][]) {
//(a,b)~(c,d)の区間を求める
return V[c][d]-V[c][b-1]-V[a-1][d]+V[a-1][b-1];
}
static void add(int x,int y,long data,long DP[][],int H,int W,int V[][]) {
if(x<0||y<0||x>=H||y>=W)return;
//System.out.println("add:"+x+" "+y+" ~"+data);
DP[x][y]+=data;
DP[x][y]%=mod998244353;
}
static int f(int V) {
int count=0;
while(V!=0) {
V=V%Integer.bitCount(V);
count++;
}
return count;
}
static void opt2(int tourList[],int N,int Dis[][]) {
boolean back=true;
int i0=0;
a:while(back) {
back=false;
for(int i=i0;i<i0+N;i++) {
for(int j=i+2;j<i+N-1;j++) {
int a=tourList[i%N],b=tourList[(i+1)%N],c=tourList[j%N],d=tourList[(j+1)%N];
//if(Dis[a][b]+Dis[c][d]>Dis[a][d]+Dis[b][c]) {
if(Dis[a][b]+Dis[c][d]>Dis[a][c]+Dis[b][d]) {
for (int k = 0; k < (j-i)/2; k++) {
int temp = tourList[(i+1+k)%N];
tourList[(i+1+k)%N] = tourList[(j-k)%N];
tourList[(j-k)%N] = temp;
}
i0=(i+1)%N;
back=true;
continue a;
}
//i->i+1, j->j+1を
//i->j+1,j->i+1につなぎ直す事を考える。
}
}
}
}
static boolean is_swappable(int arrayments[],int a,int b) {
a=arrayments[a];
b=arrayments[b];
if(a==b||a==-b)return false;
//a->bに出来るか。
//1-indexed
int s=index(arrayments, a);
int e=index(arrayments, b);
if(a<0&&e>s)return true;
if(a>0&&s>e)return true;
int target=index(arrayments, -a);
if(a<0&&target<e)return true;
if(a>0&&target>e)return true;
return false;
}
static int index(int arrayments[],int a) {
for(int i=0;i<arrayments.length;i++) {
if(arrayments[i]==a)return i;
}
return -1;
}
static long tsp_solv(int N,long cost[][]) {
int start=0;
long DP[][]=new long[N][1<<N];
for(int i=0;i<N;i++)Arrays.fill(DP[i], LINF);
//スタートの初期化,スタートの位置は本質ではない
DP[start][1<<start]=0;
for(int T=1;T<(1<<N);T++) {
//Tは既に通った頂点の集合を表している。
for(int from=0;from<N;from++) {
if(((T>>from)&1)==0||DP[from][T]==LINF)continue;//まだfromに到達していない
for(int to=0;to<N;to++) {
if(((T>>to)&1)==1)continue;//既にtoに到達している
//from->toへの移動を考える
if(cost[from][to]==LINF)continue;
DP[to][T|1<<to]=Math.min(DP[from][T]+cost[from][to],DP[to][T|1<<to]);
}
}
}
long res=LINF;
for(int i=0;i<N;i++) {
res=Math.min(res,DP[i][(1<<N)-1]+cost[i][start]);
}
return res;
}
static void swap(int A[],int a,int b) {
int temp=A[a];
A[a]=A[b];
A[b]=temp;
}
static int v[]= {0,0,1,-1};
static int sum(int i,int G[]) {
int res=0;
for(int t=0;t<G.length;t++) {
if(((i>>t)&1)==0)continue;
res+=G[t];
}
return res;
}
static boolean check(char V[][],int x,int y,int vx,int vy,int d) {
for(int i=0;i<d;i++) {
if(x<0||y<0||x>=V.length||y>=V[0].length)return false;
if(V[x][y]=='#')return false;
x+=vx;y+=vy;
}
return true;
}
static boolean check(char S[][],char T[][],int a,int b) {
a*=-1;b*=-1;
int N=T.length;
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if((a+i>=N||a+i<0||b+t<0||b+t>=N)&&S[i][t]=='#'){
return false;
}
if((a+i>=N||a+i<0||b+t<0||b+t>=N))continue;
if(S[i][t]!=T[i+a][b+t]&&(S[i][t]=='#'||T[a+i][b+t]=='#')) {
return false;
}
}
}
return true;
}
static void nine(char V[][]) {
char G[][]=clone(V);
int N=V.length;
int a=0,b=0;
for(int i=N-1;i>=0;i--) {
for(int t=0;t<N;t++) {
V[i][t]=G[a++][b];
}
a=0;b++;
}
}
static char[][] idou(char V[][],int a,int b) {
int N=V.length;
char G[][]=new char[N][N];
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if(i+a<N&&t+b<N&&i+a>=0&&t+b>=0)G[i+a][t+b]=V[i][t];
}
}
return G;
}
static ArrayList<ArrayDeque<Integer>> cc = new ArrayList<>();
static Map<Integer, Integer> m = new HashMap<>();;
static void add(int index) {
if(cc.get(index).size()==0)return;
int color=cc.get(index).pollFirst();
if(!m.containsKey(color)) {
m.put(color, index);
}else {
add(m.get(color));
add(index);
}
}
static void makeT(ArrayList<ArrayList<Integer>> cc,int parent[],int root) {
Arrays.fill(parent, -2);
parent[root]=-1;
Queue<Integer> now = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
now.add(root);
while(!now.isEmpty()) {
int FROM=now.poll();
for(int TO:cc.get(FROM)) {
if(parent[TO]!=-2)continue;
parent[TO]=FROM;
now.add(TO);
}
}
}
static long tripet(long max,long min,long L[],long R[],int k) {
for(int i=0;i<1000;i++){
long c1=(max-min)/3+min;
long c2=(max-min)*2/3+min;
if(F(c1,L,R,k)>=F(c2,L,R,k)) {
min=c1;
}else{
max=c2;
}
}
return F((max+min)/2,L,R,k);
}
static long F(long x,long L[],long R[],int k) {
long res=0;
for(int i=0;i<k;i++) {
res=max(res,max(L[i]-x,x-R[i],0));
}
return res;
}
static double tripet(double x,double max,double min) {
while(max-min>=0.0000000000001){
double c1=(max-min)/3+min;
double c2=(max-min)*2/3+min;
if(F(x,c1)>=F(x,c2)) {
min=c1;
}else{
max=c2;
}
}
return (max+min)/2;
}
static double F(double x,double y) {
return x+y;
}
static class CUM2{
int V[][];
int h,w;
public CUM2(int A[][]) {//1-indexed
init(A);
}
void init(int A[][]) {
this.h=A.length;this.w=A[0].length;
V=new int[h][w];
for (int i = 0; i < h; i++) {
V[i]=A[i].clone();
}
for (int i = 1; i <h; i++) {
for (int t =1; t <w; t++) {
V[i][t]+=V[i][t-1];
}
}
for (int i = 1; i <w; i++) {
for (int t = 1; t <h; t++) {
V[t][i]+=V[t-1][i];
}
}
}
int get_sum(int a,int b,int c,int d) {
//[a,b]~[c,d]の区間和を返す。1-indexed
return V[c][d]+V[a-1][b-1]-V[a-1][d]-V[c][b-1];
}
}
/*long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}*/
//関数Fについて、区間[a,b]の最小値を求める
static long getF(long a,long b,long c,long d) {
//[a,b]と[c,d]の区間数の和
if(b<c||a>d) {
//完全に含まれない。
return (b-a+1)+(d-c+1);
}
if(c<=a&&b<=d) {
//完全に含まれる1
return d-c+1;
}
if(a<=c&&d<=b) {
//完全に含まれる2
return b-a+1;
}
//一部だけ含まれる。
if(c<=b&&b<=d) {
//[c,b]が含まれる。
return d-a+1;
}
if(c<=a&&a<=d) {
return b-c+1;
}
return -1;
}
static boolean check(int HW[][],int i,int t,int W) {
while(t<W) {
if(HW[i][t]%2==1)return true;
t++;
}
return false;
}
static void SCC(Map<Integer,ArrayList<Integer>> m,int N) {
int BACK[]=new int[N];
Arrays.fill(BACK, -1);
for (int i = 0; i < N; i++) {
if(BACK[i]!=-1)continue;
getBackQuery(m, i, BACK);
BACK[BACK_COUNT]=i;
}
Map<Integer,ArrayList<Integer>> reversedm=new HashMap<>();
for(int Vex:m.keySet()) {
for(int TO:m.get(Vex)) {
if(!reversedm.containsKey(TO))reversedm.put(TO, new ArrayList<>());
reversedm.get(TO).add(Vex);
}
}
uf=new unionFind(N);
for (int i = N-1; i>=0;i--) {
//iを始点として、DFSを行う。到達可能マスが同じグループ
if(uf.get(i)!=i)continue;
sccquery(reversedm, i);
}
}
static void sccquery(Map<Integer,ArrayList<Integer>> reversedm,int vex) {
if(!reversedm.containsKey(vex)||reversedm.get(vex).size()==0)return;
for(int TO:reversedm.get(vex)) {
if(uf.find(vex)==uf.find(TO))continue;
uf.union(vex, TO);
sccquery(reversedm, vex);
}
}
static int BACK_COUNT;
static unionFind uf;
static void getBackQuery(Map<Integer,ArrayList<Integer>> m,int Vex,int BACK[]) {
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int TO:m.get(Vex)) {
if(BACK[TO]!=-1)continue;
BACK[TO]=-2;
getBackQuery(m, Vex, BACK);
BACK[BACK_COUNT++]=TO;
}
}
static ArrayList<Integer> Vs;
static void getTopo(Map<Integer,ArrayList<Integer>> m,int N) {
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
Vs=new ArrayList<>();
for(int V:m.keySet()) {
if(flag[V])continue;
flag[V]=true;
topoQuery(m, V, flag);
Vs.add(V);
}
Collections.reverse(Vs);
}
static void topoQuery(Map<Integer,ArrayList<Integer>> m,int Vex, boolean flag[]) {
//Vexからスタート
//これ、閉路がある時に対応できてなくね
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int to:m.get(Vex)) {
if(flag[to])continue;
flag[to]=true;
topoQuery(m, to,flag);
Vs.add(to);
}
}
static class Flow{
static class edge{
int to,cap,rev;
public edge(int to,int cap,int rev) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cap=cap;
this.rev=rev;
}
}
public Flow(int N) {
// TODO 自動生成されたコンストラクター・スタブ
this.N=N;//頂点数
init();
}
void init() {
used=new boolean[N];
G=new ArrayList<>();
for (int i = 0; i < N; i++) {
G.add(new ArrayList<>());
}
}
int N;
ArrayList<ArrayList<edge>> G;//iがfromを意味する 隣接リスト表現
boolean used[];
//from->toへ向かう容量capの辺をグラフに追加する。
void add_edge(int from,int to,int cap) {
G.get(from).add(new edge(to, cap, G.get(to).size()));
G.get(to).add(new edge(from, 0, G.get(from).size()-1));
}
//最大流を求める 最悪計算量はO(F|E|) Fは流量,Eは辺の数?
int max_flow(int s,int t) {
int flow=0;
while(true) {
Arrays.fill(used, false);
int f=dfs(s,t,INF);
if(f==0)return flow;
flow+=f;
}
}
int dfs(int v,int t,int f) {
if(v==t)return f;//tに到着したら終了
used[v]=true;//vに訪れたことを表す
for (int i = 0; i < G.get(v).size(); i++) {
edge e=G.get(v).get(i);
if(used[e.to]||e.cap<=0)continue;
int d=dfs(e.to, t, Math.min(f,e.cap));
if(d>0) {
e.cap-=d;
G.get(e.to).get(e.rev).cap+=d;
return d;
}
}
return 0;
}
//デバッグ用
void get_edges(int T) {
//頂点Tから出る辺を出力する
int cout=0;
for(edge e:G.get(T)) {
System.out.println(cout+++" "+T+"=>"+e.to+" "+e.cap);
}
}
}
static class LCA{
static class edge{
int to;
long cost;
public edge(int to,long cost) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cost=cost;
}
}
int N;//頂点の数(頂点名は、0-indexで命名)
long dist[];//rootから頂点iまでの距離
int root;//木の根
int parents[];//頂点iの親がparents[i]
int doubling[][];
boolean is_built;
ArrayList<ArrayList<edge>> T;
public LCA(int N,int root) {
//頂点数と根を受け取る。
is_built=false;
this.root=root;
this.N=N;
T=new ArrayList<>(N);
for (int i = 0; i < N; i++) {
T.add(new ArrayList<>());
}
}
void add_edge(int u,int v,long cost) {
T.get(u).add(new edge(v,cost));
T.get(v).add(new edge(u,cost));
}
void build() {
init();
is_built=true;
}
void init() {
parents=new int[N];
dist=new long[N];
doubling=new int[31][N];
dfs(T);
init_doubling();
}
void dfs(ArrayList<ArrayList<edge>> T) {
//根からの距離と親を求める。
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
flag[root]=true;
parents[root]=root;
Queue<Integer> qq = new ArrayDeque<>(); //始点を保存
qq.add(root);
while(!qq.isEmpty()) {
int VEX=qq.poll();
if(T.get(VEX).size()==0)continue;
for(edge e:T.get(VEX)) {
if(flag[e.to])continue;
flag[e.to]=true;
parents[e.to]=VEX;
dist[e.to]=dist[VEX]+e.cost;
qq.add(e.to);
}
}
}
void init_doubling() {
//ダブリングによって、2^k先の祖先を前計算する。
//doubling[T][i]=iから2^T個分先
for (int i = 0; i < N; i++) {
doubling[0][i]=parents[i];
}
for (int T = 1; T < doubling.length; T++) {
for (int i = 0; i < N; i++) {
doubling[T][i]=doubling[T-1][doubling[T-1][i]];
}
}
}
int get_doubling(int from,long K) {
//ダブリングによって、fromからK先の祖先を求める。
//longにするときは、doublingの長さも変えないとだから注意
int res=from;
for (int i = 0; i < doubling.length; i++) {
if(((K>>i)&1)==0)continue;
res=doubling[i][res];
}
return res;
}
int query(int u1,int v1) {
//親からの距離を等しくする。(dist[u1]>dist[v1]とする)
//System.out.println(u1+" "+v1+" "+get_doubling(u1, dist[u1]-dist[v1]));
u1=get_doubling(u1, dist[u1]-dist[v1]);
if(u1==v1)return v1;
//二分探索によって、LCAの手前まで移動させる。
int G=30;
while(G>=0) {
int uTO=doubling[G][u1];
int vTO=doubling[G][v1];
if(uTO!=vTO) {
u1=uTO;
v1=vTO;
}
G--;
}
//System.out.println(parents[u1]+" "+parents[v1]+" "+dist[u1]+" "+dist[v1]+" "+u1+" "+v1);
return parents[u1];
}
int get_LCA(int u,int v) {
if(!is_built)build();
//根をrootとした時の、u,vのLCA(最小共通祖先)を返す。(0-indexed)
if(dist[u]<dist[v]) {
int temp=u;u=v;v=temp;
}
//dist[u]>dist[v]とする。
return query(u,v);
}
long get_dist(int u,int v) {
//u-vの距離
if(!is_built)build();
return -2*dist[get_LCA(u, v)]+dist[u]+dist[v];
}
boolean is_on_path(int u,int v,int a) {
//u-vパス上に頂点aがあるか?
//true:ある
//false:ない
return get_dist(u, a)+get_dist(a, v)==get_dist(u, v);
}
int INF=((1<<31)-1);
long dmtr=-LINF;
long get_diameter() {
if(dmtr!=-INF)return dmtr;
int V1=0;
long max_dis=-LINF;
for(int i=0;i<N;i++) {
long d=get_dist(0, i);
if(d>max_dis) {
max_dis=d;
V1=i;
}
}
max_dis=-INF;
//V1->V2への最大距離。
for (int i = 0; i < N; i++) {
max_dis=Math.max(max_dis,get_dist(V1,i));
}
return dmtr=max_dis;
}
}
static class doubling{
int N;
int bits;
int doubling[][];
long COST[][];
public doubling(int A[],int bits) {
this.bits=bits;
this.N=A.length;
init1(A);
}
public doubling(int A[],int bits,long C[]) {
// TODO 自動生成されたコンストラクター・スタブ
//long C[]は、i=>A[i]に行くコスト
//query2は、iからK番先までのコストの和で、i番までのコストが足されないので注意
this.bits=bits;
this.N=A.length;
init1(A);
init2(C);
}
private void init1(int A[]) {
// TODO 自動生成されたメソッド・スタブ
doubling=new int[bits][N];
for (int i = 0; i < N; i++) {
doubling[0][i]=A[i];
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
doubling[t+1][i]=doubling[t][doubling[t][i]];
}
}
}
private void init2(long C[]) {
COST=new long[bits][N];
for (int i = 0; i < N; i++) {
COST[0][i]=C[i];//i番目からA[i]までのコスト
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
COST[t+1][i]=COST[t][doubling[t][i]]+COST[t][i];
}
}
}
//解釈
private int query1(int start,long K) {
//startからK回移動した後の座標を求める。
int now=start;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1)now=doubling[i][now];
}
return now;
}
private long query2(int start,long K,long mod) {
//STARTからK回移動した時のコストを計算する。
int now=start;
long res=0;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1) {
res+=COST[i][now];
now=doubling[i][now];
res%=mod;
}
}
return res;
}
private int query3(int start) {
//startからスタートして、ループに入る時、そのループの長さを返す。
return 1;
}
}
static class DIKSTR{
ArrayList<ArrayList<edge2>> m;
static Map<String,Integer> hash=new HashMap<>();
static int hash_count=0;
long d[];
int V,E;
class edge2{
int to;
long cost;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
}
class pair implements Comparable<pair>{
int VEX;
long cost;
public pair(long cost,int VEX) {
this.VEX=VEX;
this.cost=cost;
}
public int compareTo(pair o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
public DIKSTR(int V,int E) {
this.V=V;//最大の頂点数。
this.E=E;//最大の辺数。
init();
}
public DIKSTR(int V) {
this.V=V;
this.E=0;
init();
}
void init() {
m=new ArrayList<>();
for (int i = 0; i < V; i++) {
m.add(new ArrayList<>());
}
d=new long[V];
}
void add_edge(int FROM,int TO,long COST) {
m.get(FROM).add(new edge2(TO, COST));
}
void add_edge(String FROM,String TO,long COST) {
if(!hash.containsKey(FROM))hash.put(FROM, hash_count++);
if(!hash.containsKey(TO))hash.put(TO, hash_count++);
add_edge(get_hash(FROM), get_hash(TO), COST);
}
int get_hash(String T) {
if(!hash.containsKey(T)) {
hash.put(T, hash_count++);
}
return hash.get(T);
}
long[] dikstr(String r) {
return dikstr(get_hash(r));
}
long[] dikstr(int r) {//rは始点
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<pair> p = new PriorityQueue<>();//add poll
p.add(new pair(0L, r));
while(!p.isEmpty()) {
pair x=p.poll();
int from=x.VEX;
if(x.cost>d[from])continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
long COST=COST(e.cost);
if(d[e.to]>d[from]+COST) {
d[e.to]=d[from]+COST;
p.add(new pair(d[e.to], e.to));
}
}
}
return d.clone();
}
long COST(long e_cost) {
return e_cost;
}
}
static Map<Integer, ArrayList<Integer>> getTree(int N){
Map<Integer, ArrayList<Integer>> m = new HashMap<>();
for (int i = 0; i < N; i++) {
int a = sc.nextInt() - 1, b = sc.nextInt() - 1;
if (!m.containsKey(a))
m.put(a, new ArrayList<Integer>());
if (!m.containsKey(b))
m.put(b, new ArrayList<Integer>());
m.get(a).add(b);
m.get(b).add(a);
}
return m;
}
/*static Map<V,Integer> makeTree(Map<Integer, ArrayList<Integer>> m){
//頂点0を根とした木を構築する。
Queue<Integer> qq = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
Queue<Integer> parent = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
qq.add(0);
Map<V, Integer> T = new HashMap<>();
parent.add(-1);
Queue<Integer> color = new ArrayDeque<>();
color.add(-1);
while (!qq.isEmpty()) {
int from = qq.poll();
int p = parent.poll();
int c=color.poll();
int X=1;
for (int V : m.get(from)) {
if (V == p)continue;
if(X==c)X++;
qq.add(V);
parent.add(from);
color.add(X);
System.out.println(from +" "+V+" "+X);
T.put(new V(from,V), X++);
}
}
return T;
}*/
static boolean isHaveSameBit(int a,int b) {//同じbitを持っているか
int t=0;
while((a>>t)!=0) {
if(((a>>t)&1)==1&&((b>>t)&1)==1)return true;
t++;
}
return false;
}
static boolean isPalindrome(String S) {//回分になってるか
for (int i = 0; i < S.length()/2; i++) {
if(S.charAt(i)!=S.charAt(S.length()-i-1)) {
return false;
}
}
return true;
}
static long modinv(long a,long mod) {
long b=mod,u=1,v=0;
while(b!=0) {
long t=a/b;
a-=t*b;long tem=a;a=b;b=tem;
u-=t*v;tem=u;u=v;v=tem;
}
u%=mod;
if(u<0)u+=mod;
return u;
}
static long[] extendedGCD(long a, long b) {
long s = 0, old_s = 1;
long t = 1, old_t = 0;
long r = b, old_r = a;
while(r != 0) {
long q = old_r / r;
long old_s0 = old_s, old_t0 = old_t, old_r0 = old_r;
old_s = s;
s = old_s0 - q * s;
old_t = t;
t = old_t0 - q * t;
old_r = r;
r = old_r0 - q * r;
}
return new long[] {old_s, old_t};
}
static class graph{
public graph() {
// TODO 自動生成されたコンストラクター・スタブ
}
//コンテスト中だけ
static class edge3{
int to;
long cost;
int K;
public edge3(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge3(int to,long cost,int K) {
this.to=to;
this.cost=cost;
this.K=K;
}
}
long costV(long T,int K) {
//T以上の最小のKの倍数を返す。
long V=(T+K-1)/K;
return V*K;
}
long[] adddikstr(int V,int E,int r,Map<Integer, ArrayList<edge3>> m) {
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge3 e=m.get(from).get(i);
if(d[e.to]>costV(d[from],e.K)+e.cost) {
d[e.to]=costV(d[from],e.K)+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d;
}
//
class edge implements Comparable<edge>{
int from,to;
long cost;
public edge(int from,int to,long b) {
this.from=from;
this.to=to;
this.cost=b;
}
@Override
public int compareTo(edge o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
static class edge2{
int to;
long cost;
String FROM,TO;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge2(int to,long cost,String FROM,String TO) {
this.to=to;
this.cost=cost;
this.FROM=FROM;
this.TO=TO;
}
}
//単一始点最短距離問題(ダイクストラ法) 負閉路対策不可 経路復元
long d[];
long[] dikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
//path[e.to]=from;
}
}
}
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return d.clone();
}
long[] additionalDikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m,int banned) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(from==banned&&e.to==0)continue;
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d.clone();
}
int D[];
int[] Intdikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
D=new int[V];
Arrays.fill(D, INF);
D[r]=0;
PriorityQueue<Pair<Integer,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Integer, Integer>(0, r));
while(!p.isEmpty()) {
Pair<Integer,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>D[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(D[e.to]>D[from]+e.cost) {
D[e.to]=(int) (D[from]+e.cost);
p.add(new Pair<Integer, Integer>(D[e.to], e.to));
//path[e.to]=from;
}
}
}
p.clear();
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return D;
}
//単一始点最短距離問題(ベルマンフォード法) 負閉路対策済み
long[] Bellman_Ford(int V,int E,int r,edge e[]) {
long d[]=new long[V]; //0~eのグラフはこれ
//Map<Integer, Integer> d = new HashMap<>();それ以外はこれ
//for(int i=0;i<E;i++) {
// if(!d.containsKey(e[i].to))m.add(new Pair<Integer, Integer>(e[i].to, INF));
// if(!d.containsKey(e[i].from))m.add(new Pair<Integer, Integer>(e[i].from, INF));
//}
//d.replace(r, 0);
Arrays.fill(d, INF);
d[r]=0;
int count=0;
while(true) {
boolean update =false;
for(int i=0;i<E;i++) {
if(d[e[i].from]!=INF&&d[e[i].from]+e[i].cost<d[e[i].to]) {
update=true;
d[e[i].to]=d[e[i].from]+e[i].cost;
}
}
if(!update)break;
if(count==V) {
p("NEGATIVE CYCLE");
return null;
}
count++;
}
return d;
}
//最小全域木問題(クラスカル法)
long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}
}
private static long Pow(long i,long t) {
//iのt乗をO(log t)で返す
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをStringで受け取りたい時用
while(t!=0) {
if((1&t)==1) {
res=res*a;
}
a=a*a;
t=t>>1;
}
return res;
}
private static Map<Long, Integer> primeNumbers(long N) {//素因数列挙
Map<Long, Integer> c = new HashMap<>();
for(long i=2;i*i<=N;i++) {
if(N%i==0) {
int count=0;
while(N%i==0) {
N/=i;
count++;
}
c.put(i, count);
continue;
}
}
if(N!=1) {
c.put(N, 1);
}
return c;
}
//=========================Union Find=============================================
//union idx2 tree to idx1 tree O(a(N))
static class unionFind{
int UNI[],n,graph_s;
public unionFind(int N) {
// TODO 自動生成されたコンストラクター・スタブ
n=N;
graph_s=N;
init();
}
void init() {
UNI=new int[n];
for (int i = 0; i < n; i++) {
UNI[i]=i;
}
}
int get(int idx) {
return UNI[idx];
}
int find(int idx) {//木の根のindexを返す
if(UNI[idx]==idx) return idx;
return UNI[idx] = find(UNI[idx]);
}
void shape() {//木の根に直接つなげる 経路圧縮
for(int i=0;i<n;i++) {
find(i);
}
}
void union(int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(UNI[root2]!=root1)graph_s--;
UNI[root2] = root1;
}
void breaker(int idx1,int idx2) {
UNI[idx1]=idx1;
}
int MaxSize() {//最も大きい木の頂点数を返す
shape();
int V[]=new int[n];
int max=0;
for(int i=0;i<n;i++) {
V[UNI[i]]++;
max=Math.max(max, V[UNI[i]]);
}
return max;
}
int sum() {//木の数を返す
int res=0;
for(int i=0;i<n;i++) {
if(UNI[i]==i)res++;
}
return res;
}
void union2(int tree[],int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(root1==root2)return;
if(c.get(root1).size()>c.get(root2).size()) {
//root2をroot1に移し替える
for(int a:c.get(root2).keySet()) {
if(!c.get(root1).containsKey(a)) {
c.get(root1).put(a, 0);
}
c.get(root1).replace(a, c.get(root1).get(a)+c.get(root2).get(a));
}
tree[root2] = root1;
}else {
for(int a:c.get(root1).keySet()) {
if(!c.get(root2).containsKey(a)) {
c.get(root2).put(a, 0);
}
c.get(root2).replace(a, c.get(root2).get(a)+c.get(root1).get(a));
}
tree[root1] = root2;
}
}
}
//=========================二分探索=============================================
private static class binarySerch{
public binarySerch() {
// TODO 自動生成されたコンストラクター・スタブ
}
int BinarySearch(int A[],int value) {
int S=0,E=A.length,G=-1;
while(S<=E) {
G=(S+E)/2;
if(A[G]==value)return G;
else if(A[G]>value) {
if(E==G)break;E=G;
}else if(A[G]<value) {
if(S==G)break;S=G;
}
}
return -1;
}
int lowerBound(int A[],int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>=value)return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(int A[],int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(long A[],long value) {
//A[i-1]<value<=A[i] value以上の最小indexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>=value)return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(long A[],long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Integer> A,int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Integer> A,int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Long> A,long value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Long> A,long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
}
private static long modNcR2(int n,int r,int mod) {
if(r<0||n<r)return 0;
long N=kaijou(n, mod);
long Nr=kaijou(n-r, mod);
long R=kaijou(r, mod);
return (((N*modPow(Nr, mod-2, mod))%mod)*modPow(R, mod-2, mod))%mod;
// n!/(n-r)!/r!
}
private static long modPow(long i,long t,long mod) {
if(t==0)return 1%mod;
if(i==0||t<0)return 0;//0未満乗は未定義で
//iのt乗をO(log t)で返す
i%=mod;
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをbitのStringで受け取った時用？
while(t!=0) {
if((1&t)==1) {
res=res*a%mod;
}
a=a*a%mod;
t=t>>1;
}
return res;
}
private static long min(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int min(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int max(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static long max(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static double min(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static double max(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static int abs(int a) {
return Math.max(a,-a);
}
private static long abs(long a) {
return Math.max(a,-a);
}
private static double abs(double a) {
return Math.max(a,-a);
}
private static String zeroume(String S,int V) {
while(S.length()<V)S='0'+S;
return S;
}
//速度が足りないときは、前計算を1回だけにしたり、longをintに変えたりするといい
//エラストネスの篩風のやつもあり
private static long gcd(long ...nums) {
long res=0;
for (int i = 0; i < nums.length; i++) {
res=gcd(res,nums[i]);
}
return res;
}
private static long lcm(long ...nums) {
long res=1;
for (int i = 0; i < nums.length; i++) {
res=lcm(res,nums[i]);
}
return res;
}
public static long gcd(long num1,long num2) {
if(num2==0) return num1;
else return gcd(num2,num1%num2);
}
public static long lcm(long num1,long num2) {
return num1*num2/gcd(num1,num2);
}
//O(N^0.5)
private static void bubunwa() {
int N=sc.nextInt();
int K=sc.nextInt();
int a[]=sc.nextIntArray(N, false);
boolean dp[] =new boolean[K+1];
Arrays.fill(dp, false);
dp[0]=true;
for(int i=0;i<N;i++) {
for(int x=K-a[i];x>=0;x--) {
if(dp[x])dp[x+a[i]]=true;
}
}
p(dp[K] ? "Yes":"No");
}
static String nextPermutation(String s) {
ArrayList<Character> list=new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
list.add(s.charAt(i));
}
int pivotPos=-1;
char pivot=0;
for(int i=list.size()-2;i>=0;i--) {
if(list.get(i)<list.get(i+1)) {
pivotPos=i;
pivot=list.get(i);
break;
}
}
if(pivotPos==-1&&pivot==0) {
return "Final";
}
int L=pivotPos+1,R=list.size()-1; int minPos=-1;
char min =Character.MAX_VALUE;
for(int i=R;i>=L;i--) {
if(pivot<list.get(i)) {
if(list.get(i)<min) {
min=list.get(i);
minPos=i;
}
}
}
Collections.swap(list, pivotPos, minPos);
Collections.sort(list.subList(L, R+1));
StringBuilder sb=new StringBuilder();
for(int i=0;i<list.size();i++) {
sb.append(list.get(i));
}
return sb.toString();
}
private static long[][] com;
private static void nCr(int mod) {
int MAX = 3001;
com= new long[MAX][MAX];
for(int i = 0; i < MAX; i++)
com[i][0] = 1;
for(int i = 1; i < MAX; i++) {
for(int j = 1; j <= i; j++) {
com[i][j] = com[i-1][j-1] + com[i-1][j];
com[i][j] %= mod;
}
}
}
//https://qiita.com/p_shiki37/items/65c18f88f4d24b2c528b より
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
return (int) nextLong();
}
public double nextDouble(){
return Double.parseDouble(next());
}
public int[] nextIntArray(int N) {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
public int[] nextIntArray(int N, boolean oneBased) {
if (oneBased) {
int[] array = new int[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextInt();
}
return array;
} else {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
}
public long[] nextLongArray(int N, boolean oneBased) {
if (oneBased) {
long[] array = new long[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextLong();
}
return array;
} else {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
}
public int[] nextRandIntArray(int N, boolean oneBased,int max) {
Random r=new Random();
if(oneBased)N++;
int array[]=new int[N];
for(int i=0;i<N;i++) {
array[i]=r.nextInt(max+1);
}
if(oneBased)array[0]=0;
return array;
}
public long[] nextLongArray(int N) {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
public long[][]nextLongDimensionalArray(int H,int W) {
long[][] array = new long[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextLongArray(W);
}
return array;
}
public int[][]nextIntDimensionalArray(int H,int W) {
int[][] array = new int[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextIntArray(W);
}
return array;
}
public String[] nextArray(int N) {
String[] array = new String[N];
for (int i = 0; i < N; i++) {
array[i] = sc.next();
}
return array;
}
public String[][]nextDimensionalArray(int H,int W) {
String[][] array = new String[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextArray(W);
}
return array;
}
public double[] nextDoubleArray(int N) {
double[] array = new double[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextDouble();
}
return array;
}
}
}
|
ConDefects/ConDefects/Code/arc132_b/Java/28173258
|
condefects-java_data_508
|
import java.util.*;
public class Main {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int x = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) =='a') {
x++;
}else break;
}
int y = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(s.length()-i-1) =='a') {
y++;
}else break;
}
if(x > y) {
System.out.println("No");
return ;
}
for(int i = x; i < (s.length()-y)/2; i++){
if(s.charAt(i) != s.charAt(x +s.length()-y-1-i)){
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
/*
oj t -c "java Main.java" -d ./test/
acc submit Main.java -- -l 4005
[A-Z][1-9][0-9]{6}[A-z] --> S1000000A, A21234556Z
*/
import java.util.*;
public class Main {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int x = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) =='a') {
x++;
}else break;
}
int y = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(s.length()-i-1) =='a') {
y++;
}else break;
}
if(x > y) {
System.out.println("No");
return ;
}
for(int i = x; i < (s.length()-y); i++){
if(s.charAt(i) != s.charAt(x +s.length()-y-1-i)){
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
/*
oj t -c "java Main.java" -d ./test/
acc submit Main.java -- -l 4005
[A-Z][1-9][0-9]{6}[A-z] --> S1000000A, A21234556Z
*/
|
ConDefects/ConDefects/Code/abc237_c/Java/37917363
|
condefects-java_data_509
|
import java.util.*;
class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
String s=scanner.next();
String[]arr=s.split("");
int n=s.length()-1;
int i=0;
while(i<n){
if(arr[i].equals("a") && arr[n].equals("a")){
i++;
n--;
} else if(arr[n].equals("a")){
n--;
} else if(arr[i].equals("a")){
i++;
n--;
} else break;
}
if(i>=n){
System.out.println("Yes");
} else{
System.out.println("No");
}
}
}
import java.util.*;
class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
String s=scanner.next();
String[]arr=s.split("");
int n=s.length()-1;
int i=0;
while(i<n){
if(arr[i].equals("a") && arr[n].equals("a")){
i++;
n--;
} else if(arr[n].equals("a")){
n--;
} else if(arr[i].equals(arr[n])){
i++;
n--;
} else break;
}
if(i>=n){
System.out.println("Yes");
} else{
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc237_c/Java/42100663
|
condefects-java_data_510
|
import java.util.*;
public class Main {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int x = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) =='a') {
x++;
}else break;
}
int y = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(s.length()-i-1) =='a') {
y++;
}else break;
}
if(x > y) {
System.out.println("No");
return ;
}
for(int i = x; i < (s.length()-y)/2; i++){
// System.out.println(i);
if(s.charAt(i) != s.charAt(x +s.length()-y-1-i)){
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
/*
oj t -c "java Main.java" -d ./test/
acc submit Main.java -- -l 4005
[A-Z][1-9][0-9]{6}[A-z] --> S1000000A, A21234556Z
*/
import java.util.*;
public class Main {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int x = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(i) =='a') {
x++;
}else break;
}
int y = 0;
for(int i = 0; i < s.length(); i++) {
if(s.charAt(s.length()-i-1) =='a') {
y++;
}else break;
}
if(x > y) {
System.out.println("No");
return ;
}
for(int i = x; i < ((s.length()-y+x)/2); i++){
// System.out.println(i);
if(s.charAt(i) != s.charAt(x +s.length()-y-1-i)){
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
/*
oj t -c "java Main.java" -d ./test/
acc submit Main.java -- -l 4005
[A-Z][1-9][0-9]{6}[A-z] --> S1000000A, A21234556Z
*/
|
ConDefects/ConDefects/Code/abc237_c/Java/37917468
|
condefects-java_data_511
|
import javax.management.InstanceNotFoundException;
import javax.swing.text.html.InlineView;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353; //1000000007
void solve() {
char[] s = in.nextCharArray();
int n = s.length;
for (int i = 0; i < n/2; i++) {
char temp = s[i];
s[i] = s[n-i-1];
s[n-i-1] = temp;
}
boolean ok = true;
int cnt = 0;
for (int i = 0; i < n/2; i++) {
if(s[i] != s[n-i-1+cnt]){
if(ok && s[i] == 'a'){
cnt++;
}else{
out.println("No");
return;
}
}else{
if(ok && s[i] != 'a'){
ok = false;
}
}
}
out.println("Yes");
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
import javax.management.InstanceNotFoundException;
import javax.swing.text.html.InlineView;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353; //1000000007
void solve() {
char[] s = in.nextCharArray();
int n = s.length;
for (int i = 0; i < n/2; i++) {
char temp = s[i];
s[i] = s[n-i-1];
s[n-i-1] = temp;
}
boolean ok = true;
int cnt = 0;
for (int i = 0; i < n; i++) {
if(s[i] != s[n-i-1+cnt]){
if(ok && s[i] == 'a'){
cnt++;
}else{
out.println("No");
return;
}
}else{
if(ok && s[i] != 'a'){
ok = false;
}
}
}
out.println("Yes");
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
|
ConDefects/ConDefects/Code/abc237_c/Java/41285264
|
condefects-java_data_512
|
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
//import java.util.HashMap;
//import java.util.Map;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
boolean judge = true;
List<Long> C = new ArrayList<Long>();
for (long i = 1; i < 1000000; i++) {
C.add(i*i*i);
}
for (int i = C.size()-1; i >= 0; i--) {
if (C.get(i) > N) {
break;
}
String S = Long.toString(C.get(i));
int L = S.length();
int M = 0;
if (L % 2 == 0) {
M = L/2;
} else {
M = (L+1)/2;
}
for (int j=0; j < M; j++) {
if (!S.substring(j,j+1).equals(S.substring(L-j-1,L-j))) {
judge = false;
break;
}
}
if (judge == false) {
judge = true;
continue;
} else {
System.out.println(C.get(i));
break;
}
}
sc.close();
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
//import java.util.HashMap;
//import java.util.Map;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
boolean judge = true;
List<Long> C = new ArrayList<Long>();
for (long i = 1; i < 1000000; i++) {
C.add(i*i*i);
}
for (int i = C.size()-1; i >= 0; i--) {
if (C.get(i) > N) {
continue;
}
String S = Long.toString(C.get(i));
int L = S.length();
int M = 0;
if (L % 2 == 0) {
M = L/2;
} else {
M = (L+1)/2;
}
for (int j=0; j < M; j++) {
if (!S.substring(j,j+1).equals(S.substring(L-j-1,L-j))) {
judge = false;
break;
}
}
if (judge == false) {
judge = true;
continue;
} else {
System.out.println(C.get(i));
break;
}
}
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc343_c/Java/53148240
|
condefects-java_data_513
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = Long.parseLong(sc.next());
long cube = 0L;
for (long i = 1L; i * i * i < n; i++) {
String s = i * i * i + "";
if (check(s) == true) {
cube = i * i * i;
}
}
System.out.println(cube);
}
private static boolean check(String cube) {
boolean f = false;
if (cube.length() == 1) {
return true;
}
for (int i = 0; i < cube.length() / 2; i++) {
if (cube.charAt(i) == cube.charAt(cube.length() - i - 1)) {
f = true;
} else {
f = false;
return f;
}
}
return f;
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = Long.parseLong(sc.next());
long cube = 0L;
for (long i = 1L; i * i * i <= n; i++) {
String s = i * i * i + "";
if (check(s) == true) {
cube = i * i * i;
}
}
System.out.println(cube);
}
private static boolean check(String cube) {
boolean f = false;
if (cube.length() == 1) {
return true;
}
for (int i = 0; i < cube.length() / 2; i++) {
if (cube.charAt(i) == cube.charAt(cube.length() - i - 1)) {
f = true;
} else {
f = false;
return f;
}
}
return f;
}
}
|
ConDefects/ConDefects/Code/abc343_c/Java/53996009
|
condefects-java_data_514
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
List<Long> list = new ArrayList<>();
for (long i = 0; i * i * i < N; i++) {
list.add(i*i*i);
}
for (int i = list.size()-1; i >= 0; i--) {
if (checkRounded(list.get(i))) {
System.out.println(list.get(i));
break;
}
}
}
private static boolean checkRounded(long A) {
String S = String.valueOf(A);
char[] arr = S.toCharArray();
for (int i = 0; i < arr.length/2; i++) {
if (arr[i] != arr[arr.length-i-1]) return false;
}
return true;
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
List<Long> list = new ArrayList<>();
for (long i = 0; i * i * i <= N; i++) {
list.add(i*i*i);
}
for (int i = list.size()-1; i >= 0; i--) {
if (checkRounded(list.get(i))) {
System.out.println(list.get(i));
break;
}
}
}
private static boolean checkRounded(long A) {
String S = String.valueOf(A);
char[] arr = S.toCharArray();
for (int i = 0; i < arr.length/2; i++) {
if (arr[i] != arr[arr.length-i-1]) return false;
}
return true;
}
}
|
ConDefects/ConDefects/Code/abc343_c/Java/51617936
|
condefects-java_data_515
|
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 274 F問題
* 考察メモ
* 魚iを左端で捕まえると仮定する
* この時、他の魚jはそれぞれどの時刻で無いと捕まえられないか？という区間を考えていく
* そうすれば、最も重なった区間が答え
*/
int N = io.nextInt(), A = io.nextInt();
int[] W = new int[N], X = new int[N], V = new int[N];
for (int i = 0;i < N;++ i) {
W[i] = io.nextInt();
X[i] = io.nextInt();
V[i] = io.nextInt();
}
int ans = 0;
double ansX = 0;
for (int i = 0;i < N;++ i) {
TreeMap<Double, Integer> map = new TreeMap<>();
for (int j = 0;j < N;++ j) {
if (V[i] == V[j]) {
if (X[i] <= X[j] && X[j] <= X[i] + A) map.merge(0., W[j], (l, r) -> l + r);
} else {
double min = (double)(X[i] - X[j]) / (V[j] - V[i]);
double max = (double)(X[i] - X[j] + A) / (V[j] - V[i]);
if (min > max) {
double swap = min;
min = max;
max = swap;
}
min = Math.max(min, 0);
max = min <= max ? max + 0.00001 : min;
// io.debugln(i + "," + j + "[" + min + "," + max + ")");
map.merge(min, W[j], (l, r) -> l + r);
map.merge(max, -W[j], (l, r) -> l + r);
}
}
int sum = 0;
for (Map.Entry<Double, Integer> e : map.entrySet()) {
sum += e.getValue();
if (ans < sum) {
ans = sum;
ansX = e.getKey();
}
}
}
io.println(ans);
io.debugln(ansX);
}
/** デバッグ用コードのお供に */
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;
this.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;
this.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;
}
}
/**
* @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;
}
/**
* 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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.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) { this.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 274 F問題
* 考察メモ
* 魚iを左端で捕まえると仮定する
* この時、他の魚jはそれぞれどの時刻で無いと捕まえられないか？という区間を考えていく
* そうすれば、最も重なった区間が答え
*/
int N = io.nextInt(), A = io.nextInt();
int[] W = new int[N], X = new int[N], V = new int[N];
for (int i = 0;i < N;++ i) {
W[i] = io.nextInt();
X[i] = io.nextInt();
V[i] = io.nextInt();
}
int ans = 0;
double ansX = 0;
for (int i = 0;i < N;++ i) {
TreeMap<Double, Integer> map = new TreeMap<>();
for (int j = 0;j < N;++ j) {
if (V[i] == V[j]) {
if (X[i] <= X[j] && X[j] <= X[i] + A) map.merge(0., W[j], (l, r) -> l + r);
} else {
double min = (double)(X[i] - X[j]) / (V[j] - V[i]);
double max = (double)(X[i] - X[j] + A) / (V[j] - V[i]);
if (min > max) {
double swap = min;
min = max;
max = swap;
}
min = Math.max(min, 0);
max = min <= max ? Math.nextUp(max) : min;
// io.debugln(i + "," + j + "[" + min + "," + max + ")");
map.merge(min, W[j], (l, r) -> l + r);
map.merge(max, -W[j], (l, r) -> l + r);
}
}
int sum = 0;
for (Map.Entry<Double, Integer> e : map.entrySet()) {
sum += e.getValue();
if (ans < sum) {
ans = sum;
ansX = e.getKey();
}
}
}
io.println(ans);
io.debugln(ansX);
}
/** デバッグ用コードのお供に */
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;
this.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;
this.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;
}
}
/**
* @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;
}
/**
* 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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.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) { this.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/abc274_f/Java/35881382
|
condefects-java_data_516
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static final long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000000l;//10^18
static int index = 2;
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int A = sc.nextInt();
int[] W = new int[n];
int[] X = new int[n];
int[] V = new int[n];
for (int i = 0; i < V.length; i++) {
W[i] = sc.nextInt();
X[i] = sc.nextInt();
V[i] = sc.nextInt();
}
int ans = 0;
for (int i = 0; i < n; i++) {
int sum = 0;
ArrayList<Pair2> list = new ArrayList<>();
for (int j = 0; j < n; j++) {
if (V[j] - V[i] > 0) {
if (X[j] <= X[i] + A) {
int v = V[j] - V[i];
int s = Math.max(0, X[i] - X[j]);
int t = X[i] + A - X[j];
list.add(new Pair2(s, v, W[j]));
list.add(new Pair2(t, v, -W[j]));
}
}else if (V[j] - V[i] < 0) {
if (X[j] >= X[i]) {
int v = V[i] - V[j];
int s = Math.max(0, X[j] - (X[i] + A));
int t = X[j] - X[i];
list.add(new Pair2(s, v, W[j]));
list.add(new Pair2(t, v, -W[j]));
}
}else {
if(X[i] == X[j]) sum += W[j];
}
}
Collections.sort(list);
ans = Math.max(sum, ans);
for (Pair2 p : list) {
sum += p.z;
ans = Math.max(sum, ans);
}
}
System.out.println(ans);
}
static class Pair2 implements Comparable<Pair2>{
public int x;
public int y;
public int z;
public Pair2(int x,int y,int z) {
this.x=x;
this.y=y;
this.z=z;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Pair2) {
Pair2 other = (Pair2) obj;
return other.x==this.x && other.y==this.y&& other.z==this.z;
}
return false;
}//同値の定義
@Override
public int hashCode() {
return Objects.hash(this.x,this.y,this.z);
}//これ書かないと正しく動作しない（要 勉強）
@Override
public int compareTo( Pair2 p2 ){
if (this.x * p2.y > this.y * p2.x) {
return 1;
}
else if (this.x * p2.y < this.y * p2.x) {
return -1;
}
else {
if (this.z < p2.z) {
return 1;
}
else if (this.z > p2.z) {
return -1;
}
else {
return 0;
}
}
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static final long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000000l;//10^18
static int index = 2;
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int A = sc.nextInt();
int[] W = new int[n];
int[] X = new int[n];
int[] V = new int[n];
for (int i = 0; i < V.length; i++) {
W[i] = sc.nextInt();
X[i] = sc.nextInt();
V[i] = sc.nextInt();
}
int ans = 0;
for (int i = 0; i < n; i++) {
int sum = 0;
ArrayList<Pair2> list = new ArrayList<>();
for (int j = 0; j < n; j++) {
if (V[j] - V[i] > 0) {
if (X[j] <= X[i] + A) {
int v = V[j] - V[i];
int s = Math.max(0, X[i] - X[j]);
int t = X[i] + A - X[j];
list.add(new Pair2(s, v, W[j]));
list.add(new Pair2(t, v, -W[j]));
}
}else if (V[j] - V[i] < 0) {
if (X[j] >= X[i]) {
int v = V[i] - V[j];
int s = Math.max(0, X[j] - (X[i] + A));
int t = X[j] - X[i];
list.add(new Pair2(s, v, W[j]));
list.add(new Pair2(t, v, -W[j]));
}
}else {
if(X[i] <= X[j] && X[j] <= X[i] + A) sum += W[j];
}
}
Collections.sort(list);
ans = Math.max(sum, ans);
for (Pair2 p : list) {
sum += p.z;
ans = Math.max(sum, ans);
}
}
System.out.println(ans);
}
static class Pair2 implements Comparable<Pair2>{
public int x;
public int y;
public int z;
public Pair2(int x,int y,int z) {
this.x=x;
this.y=y;
this.z=z;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Pair2) {
Pair2 other = (Pair2) obj;
return other.x==this.x && other.y==this.y&& other.z==this.z;
}
return false;
}//同値の定義
@Override
public int hashCode() {
return Objects.hash(this.x,this.y,this.z);
}//これ書かないと正しく動作しない（要 勉強）
@Override
public int compareTo( Pair2 p2 ){
if (this.x * p2.y > this.y * p2.x) {
return 1;
}
else if (this.x * p2.y < this.y * p2.x) {
return -1;
}
else {
if (this.z < p2.z) {
return 1;
}
else if (this.z > p2.z) {
return -1;
}
else {
return 0;
}
}
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
|
ConDefects/ConDefects/Code/abc274_f/Java/35929145
|
condefects-java_data_517
|
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 283 H問題
* 考察メモ
* popcountの総和、は桁ごとにばらして寄与は典型
* で、そうするとmod 2^Nだし等差数列だし01加算だしでどう見てもfloorsum
*/
int T = io.nextInt();
while (T --> 0) {
int N = io.nextInt(), M = io.nextInt(), R = io.nextInt();
int ans = 0;
for (int i = 1;i <= N;i <<= 1) ans += ACL.MathLib.floor_sum((N - R) / M + 1 , i << 1, M, R + i) - ACL.MathLib.floor_sum((N - R) / M + 1 , i << 1, M, R);
io.println(ans);
}
}
/** デバッグ用コードのお供に */
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;
this.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;
this.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;
}
}
/**
* @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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.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) { this.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 283 H問題
* 考察メモ
* popcountの総和、は桁ごとにばらして寄与は典型
* で、そうするとmod 2^Nだし等差数列だし01加算だしでどう見てもfloorsum
*/
int T = io.nextInt();
while (T --> 0) {
int N = io.nextInt(), M = io.nextInt(), R = io.nextInt();
long ans = 0;
for (int i = 1;i <= N;i <<= 1) ans += ACL.MathLib.floor_sum((N - R) / M + 1 , i << 1, M, R + i) - ACL.MathLib.floor_sum((N - R) / M + 1 , i << 1, M, R);
io.println(ans);
}
}
/** デバッグ用コードのお供に */
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;
this.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;
this.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;
}
}
/**
* @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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.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) { this.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/abc283_h/Java/37528304
|
condefects-java_data_518
|
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 246 G問題
* 考察メモ
* 得点x以上を取ることができるのか？を考える
* この問題をO(N)で解ければ二分探索できるね
*
* さて
* 木DPで解けないかな
* dp[i]: i番目の頂点にコマがあるとき、青木君は前もって何ターンの準備ができれば勝てるか？
*
* 1. 子同士のマージについて
* 高橋くんが来るまでに全ての準備を終わらせる必要があるので、max(0, child)の総和 0以下なら後でやっても間に合うからね
*
* 2. 直列繋ぎについて
* 親を消す必要があるならターンは変わらず、そうでないなら-1
*
* 3. 葉について
* 消すべきか否かで 0 or 1
*
* 4. 勝利条件
* dp[根]>0なら高橋君、そうでないなら青木君
*/
int N = io.nextInt();
int[] A = ArrayUtility.addAll(new int[] {0}, io.nextInt(N - 1));
ArrayList<ArrayList<Integer>> tree = new ArrayList<>(N);
for (int i = 0;i < N;++ i) tree.add(new ArrayList<>());
for (int i = 1;i < N;++ i) {
int u = io.nextInt() - 1, v = io.nextInt() - 1;
tree.get(u).add(v);
tree.get(v).add(u);
}
io.println(ACL.MathLib.binarySearch(-1, exponent10(1, 9), (int i) -> dfs(0, 0, tree, i, A) > 0));
}
int dfs(int now, int parent, ArrayList<ArrayList<Integer>> tree, int win, int[] A) {
int turn = A[now] >= win ? 1 : 0;
int merge = -1;
for (int to : tree.get(now)) {
if (to == parent) continue;
int val = dfs(to, now, tree, win, A);
merge += Math.max(0, val);
}
turn += Math.max(0, merge);
return turn;
}
/** デバッグ用コードのお供に */
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;
this.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;
this.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;
}
/**
* 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;
}
}
}
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) {
if (isTrue <= isFalse) {
double mid = (isTrue + isFalse) / 2;
while(isTrue < mid && mid < isFalse) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
mid = (isTrue + isFalse) / 2;
}
return isTrue;
} else {
double mid = (isTrue + isFalse) / 2;
while(isFalse < mid && mid < isTrue) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
mid = (isTrue + isFalse) / 2;
}
return isFalse;
}
}
/**
* 下に凸な関数の極小値を発見します。
* @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;
}
}
/**
* @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();
}
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;
}
/**
* 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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(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 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));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(final int newIndent) { this.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) + data[k];
String s = "";
s += toString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[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();
}
}
/**
*
* @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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.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) { this.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 246 G問題
* 考察メモ
* 得点x以上を取ることができるのか？を考える
* この問題をO(N)で解ければ二分探索できるね
*
* さて
* 木DPで解けないかな
* dp[i]: i番目の頂点にコマがあるとき、青木君は前もって何ターンの準備ができれば勝てるか？
*
* 1. 子同士のマージについて
* 高橋くんが来るまでに全ての準備を終わらせる必要があるので、max(0, child)の総和 0以下なら後でやっても間に合うからね
*
* 2. 直列繋ぎについて
* 親を消す必要があるならターンは変わらず、そうでないなら-1
*
* 3. 葉について
* 消すべきか否かで 0 or 1
*
* 4. 勝利条件
* dp[根]>0なら高橋君、そうでないなら青木君
*/
int N = io.nextInt();
int[] A = ArrayUtility.addAll(new int[] {0}, io.nextInt(N - 1));
ArrayList<ArrayList<Integer>> tree = new ArrayList<>(N);
for (int i = 0;i < N;++ i) tree.add(new ArrayList<>());
for (int i = 1;i < N;++ i) {
int u = io.nextInt() - 1, v = io.nextInt() - 1;
tree.get(u).add(v);
tree.get(v).add(u);
}
io.println(ACL.MathLib.binarySearch(-1, exponent10(1, 9) + 2, (int i) -> dfs(0, 0, tree, i, A) > 0));
}
int dfs(int now, int parent, ArrayList<ArrayList<Integer>> tree, int win, int[] A) {
int turn = A[now] >= win ? 1 : 0;
int merge = -1;
for (int to : tree.get(now)) {
if (to == parent) continue;
int val = dfs(to, now, tree, win, A);
merge += Math.max(0, val);
}
turn += Math.max(0, merge);
return turn;
}
/** デバッグ用コードのお供に */
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;
this.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;
this.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;
}
/**
* 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;
}
}
}
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) {
if (isTrue <= isFalse) {
double mid = (isTrue + isFalse) / 2;
while(isTrue < mid && mid < isFalse) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
mid = (isTrue + isFalse) / 2;
}
return isTrue;
} else {
double mid = (isTrue + isFalse) / 2;
while(isFalse < mid && mid < isTrue) {
if (func.test(mid)) isTrue = mid;
else isFalse = mid;
mid = (isTrue + isFalse) / 2;
}
return isFalse;
}
}
/**
* 下に凸な関数の極小値を発見します。
* @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;
}
}
/**
* @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();
}
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;
}
/**
* 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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(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 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));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(final int newIndent) { this.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) + data[k];
String s = "";
s += toString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[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();
}
}
/**
*
* @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) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.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) { this.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/abc246_g/Java/30665816
|
condefects-java_data_519
|
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
/**
* Coder: SumitRaut
* Date: 06-04-2022 12:38
*/
public class Main {
public static int n;
public static int[] ar;
public static List<Integer>[] g;
public static PriorityQueue<Integer> dfs(int u, int p) {
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
for (int v : g[u]) {
if (v != p) {
PriorityQueue<Integer> child = dfs(v, u);
if (pq.size() < child.size()) {
PriorityQueue<Integer> tmp = child;
child = pq;
pq = tmp;
}
for (int e : child) {
pq.add(e);
}
}
}
if (!pq.isEmpty()) pq.poll();
pq.add(ar[u]);
return pq;
}
public static void main(String[] args) throws IOException {
fs = new FastReader();
out = new PrintWriter(System.out);
n = fs.nextInt();
ar = new int[n];
g = new LinkedList[n];
ar[0] = -1;
g[0] = new LinkedList<>();
for (int i = 1; i < n; ++i) {
ar[i] = fs.nextInt();
g[i] = new LinkedList<>();
}
for (int i = 1; i < n; ++i) {
int u = fs.nextInt() - 1, v = fs.nextInt() - 1;
g[u].add(v);
g[v].add(u);
}
PriorityQueue<Integer> res = dfs(0, -1);
int ans = res.peek();
out.println(ans);
out.close();
}
public static PrintWriter out;
public static FastReader fs;
public static final Random random = new Random();
public static void ruffleSort(int[] a) {
int n = a.length;
for (int i = 0; i < n; ++i) {
int oi = random.nextInt(n), tmp = a[oi];
a[oi] = a[i];
a[i] = tmp;
}
Arrays.sort(a);
}
public static class FastReader {
private BufferedReader br;
private StringTokenizer st = new StringTokenizer("");
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String file_name) throws FileNotFoundException {
br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(file_name))));
}
public String next() {
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; ++i)
a[i] = nextInt();
return a;
}
public String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
/**
* Coder: SumitRaut
* Date: 06-04-2022 12:38
*/
public class Main {
public static int n;
public static int[] ar;
public static List<Integer>[] g;
public static PriorityQueue<Integer> dfs(int u, int p) {
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
for (int v : g[u]) {
if (v != p) {
PriorityQueue<Integer> child = dfs(v, u);
if (pq.size() < child.size()) {
PriorityQueue<Integer> tmp = child;
child = pq;
pq = tmp;
}
for (int e : child) {
pq.add(e);
}
}
}
if (!pq.isEmpty()) pq.poll();
pq.add(ar[u]);
return pq;
}
public static void main(String[] args) throws IOException {
fs = new FastReader();
out = new PrintWriter(System.out);
n = fs.nextInt();
ar = new int[n];
g = new LinkedList[n];
ar[0] = 0;
g[0] = new LinkedList<>();
for (int i = 1; i < n; ++i) {
ar[i] = fs.nextInt();
g[i] = new LinkedList<>();
}
for (int i = 1; i < n; ++i) {
int u = fs.nextInt() - 1, v = fs.nextInt() - 1;
g[u].add(v);
g[v].add(u);
}
PriorityQueue<Integer> res = dfs(0, -1);
int ans = res.peek();
out.println(ans);
out.close();
}
public static PrintWriter out;
public static FastReader fs;
public static final Random random = new Random();
public static void ruffleSort(int[] a) {
int n = a.length;
for (int i = 0; i < n; ++i) {
int oi = random.nextInt(n), tmp = a[oi];
a[oi] = a[i];
a[i] = tmp;
}
Arrays.sort(a);
}
public static class FastReader {
private BufferedReader br;
private StringTokenizer st = new StringTokenizer("");
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String file_name) throws FileNotFoundException {
br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(file_name))));
}
public String next() {
while (!st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] readArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; ++i)
a[i] = nextInt();
return a;
}
public String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
|
ConDefects/ConDefects/Code/abc246_g/Java/30753716
|
condefects-java_data_520
|
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
private static final int[][] D = {{0,1},{1,0},{1,1},{1,-1}};
boolean inBound(int x, int y){
return x >= 0 && y >= 0 && x < n && y < n;
}
int n;
char[][] grid;
void solve(){
n = scanner.nextInt();
grid = nextCharGrid(n,n,0);
boolean res = false;
for(int r = 0; r < n; r++){
res |= check(r, 0, 0);
res |= check(r, 0, 2);
res |= check(r, n-1, 3);
}
for(int c = 0; c < n; c++){
res |= check(0, c, 1);
res |= check(0, c, 2);
res |= check(0, c, 3);
}
out.println(res? "Yes" : "No");
}
boolean check(int x, int y, int dir){
int cnt = 0;
int dx = D[dir][0], dy = D[dir][1];
for(int i = 0; inBound(x + i*dx, y + i*dy); i++){
if(grid[x + i*dx][y + i*dy] == '#'){
cnt++;
}
if(i>=6 && grid[x + (i-6)*dx][y + (i-6)*dy] == '#'){
cnt--;
}
if(cnt >=4 ){
return true;
}
}
return false;
}
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()-1, b = scanner.nextInt()-1;
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 {
private static final int[][] D = {{0,1},{1,0},{1,1},{1,-1}};
boolean inBound(int x, int y){
return x >= 0 && y >= 0 && x < n && y < n;
}
int n;
char[][] grid;
void solve(){
n = scanner.nextInt();
grid = nextCharGrid(n,n,0);
boolean res = false;
for(int r = 0; r < n; r++){
res |= check(r, 0, 0);
res |= check(r, 0, 2);
res |= check(r, n-1, 3);
}
for(int c = 0; c < n; c++){
res |= check(0, c, 1);
res |= check(0, c, 2);
res |= check(0, c, 3);
}
out.println(res? "Yes" : "No");
}
boolean check(int x, int y, int dir){
int cnt = 0;
int dx = D[dir][0], dy = D[dir][1];
for(int i = 0; inBound(x + i*dx, y + i*dy); i++){
if(grid[x + i*dx][y + i*dy] == '#'){
cnt++;
}
if(i>=6 && grid[x + (i-6)*dx][y + (i-6)*dy] == '#'){
cnt--;
}
if(cnt >=4 && i>=5){
return true;
}
}
return false;
}
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()-1, b = scanner.nextInt()-1;
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/abc241_c/Java/40755879
|
condefects-java_data_521
|
import java.io.*;
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[][] grid = new char[N][N];
for (int i = 0; i < grid.length; i++) {
grid[i] = sc.next().toCharArray();
}
Resolver resolver = new Resolver(grid);
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[i].length; j++) {
if (resolver.execute(i, j)){
out.println("Yes");
return;
}
}
}
out.println("No");
}
class Resolver {
char[][] grid;
int TARGET_COUNT = 6;
char GET_NG = 'x';
char BLACK = '#';
public Resolver(char[][] grid) {
this.grid = grid;
}
private char getValueSafety(int x, int y){
try {
return grid[x][y];
}catch (Exception e){
return GET_NG;
}
}
public boolean execute(int x , int y){
return findHorizontal(x, y) || findVertical(x, y) || findDownwardRight(x, y) || findDownwardLeft(x, y);
}
private boolean findVertical(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x+i, y);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
private boolean findHorizontal(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x, y+i);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
private boolean findDownwardRight(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x+i, y+i);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
private boolean findDownwardLeft(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x+i, y-1);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
}
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.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[][] grid = new char[N][N];
for (int i = 0; i < grid.length; i++) {
grid[i] = sc.next().toCharArray();
}
Resolver resolver = new Resolver(grid);
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[i].length; j++) {
if (resolver.execute(i, j)){
out.println("Yes");
return;
}
}
}
out.println("No");
}
class Resolver {
char[][] grid;
int TARGET_COUNT = 6;
char GET_NG = 'x';
char BLACK = '#';
public Resolver(char[][] grid) {
this.grid = grid;
}
private char getValueSafety(int x, int y){
try {
return grid[x][y];
}catch (Exception e){
return GET_NG;
}
}
public boolean execute(int x , int y){
return findHorizontal(x, y) || findVertical(x, y) || findDownwardRight(x, y) || findDownwardLeft(x, y);
}
private boolean findVertical(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x+i, y);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
private boolean findHorizontal(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x, y+i);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
private boolean findDownwardRight(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x+i, y+i);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
private boolean findDownwardLeft(int x, int y){
int count = 0;
for (int i = 0; i < TARGET_COUNT; i++) {
char check = getValueSafety(x+i, y-i);
if (check == GET_NG) {
return false;
} else if (check == BLACK) {
count++;
}
}
return (count >= 4);
}
}
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/abc241_c/Java/44024778
|
condefects-java_data_522
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new In();
static Out out = new Out();
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 1000000007;
int n;
List<List<Integer>> edges;
boolean[] parentUse;
boolean[] childUse;
boolean[] slide;
boolean[] slideToSibling;
int[] parents;
void solve() {
n = in.nextInt();
edges = in.nextEdges(n, n - 1, false);
parents = new int[n];
parentUse = new boolean[n];
childUse = new boolean[n];
slide = new boolean[n];
dfs(0, -1);
dfs2(0, -1, false);
int ans = n;
for (int i = 0; i < n; i++) {
if (parentUse[i] || childUse[i] && !slide[i]) {
ans--;
}
}
out.println(ans);
}
boolean dfs(int node, int parent) {
parents[node] = parent;
int usingChild = -1;
boolean multiChild = false;
for (int child : edges.get(node)) {
if (child == parent) {
continue;
}
if (dfs(child, node)) {
if (usingChild != -1) {
multiChild = true;
}
usingChild = child;
}
}
if (usingChild != -1) {
parentUse[node] = true;
childUse[usingChild] = true;
slide[usingChild] = multiChild;
}
return usingChild == -1;
}
void dfs2(int node, int parent, boolean slideToParent) {
for (int child : edges.get(node)) {
if (child == parent) {
continue;
}
if (childUse[child] && slideToParent) {
slide[child] = true;
}
dfs2(child, node, parentUse[child] && (!childUse[node] || slide[node]));
}
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
boolean autoFlush = false;
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
out.flush();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new In();
static Out out = new Out();
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 1000000007;
int n;
List<List<Integer>> edges;
boolean[] parentUse;
boolean[] childUse;
boolean[] slide;
boolean[] slideToSibling;
int[] parents;
void solve() {
n = in.nextInt();
edges = in.nextEdges(n, n - 1, false);
parents = new int[n];
parentUse = new boolean[n];
childUse = new boolean[n];
slide = new boolean[n];
dfs(0, -1);
dfs2(0, -1, false);
int ans = n;
for (int i = 0; i < n; i++) {
if (parentUse[i] || childUse[i] && !slide[i]) {
ans--;
}
}
out.println(ans);
}
boolean dfs(int node, int parent) {
parents[node] = parent;
int usingChild = -1;
boolean multiChild = false;
for (int child : edges.get(node)) {
if (child == parent) {
continue;
}
if (dfs(child, node)) {
if (usingChild != -1) {
multiChild = true;
}
usingChild = child;
}
}
if (usingChild != -1) {
parentUse[node] = true;
childUse[usingChild] = true;
slide[usingChild] = multiChild;
}
return usingChild == -1;
}
void dfs2(int node, int parent, boolean slideToParent) {
for (int child : edges.get(node)) {
if (child == parent) {
continue;
}
if (childUse[child] && slideToParent) {
slide[child] = true;
}
dfs2(child, node, parentUse[child] && !parentUse[node] && (!childUse[node] || slide[node]));
}
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
boolean autoFlush = false;
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
out.flush();
}
}
|
ConDefects/ConDefects/Code/abc223_g/Java/26648625
|
condefects-java_data_523
|
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
Set<String> set = new HashSet<String>();
for(int i=0; i<=N; i++) {
//配列内の要素
//行ごと取得して差分チェック
//最初の空白を取り除くためsizeは-1する
String s = sc.nextLine();
System.out.println(s);
set.add(s);
}
System.out.println(set.size()-1);
}
}
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
Set<String> set = new HashSet<String>();
for(int i=0; i<=N; i++) {
//配列内の要素
//行ごと取得して差分チェック
//最初の空白を取り除くためsizeは-1する
String s = sc.nextLine();
// System.out.println(s);
set.add(s);
}
System.out.println(set.size()-1);
}
}
|
ConDefects/ConDefects/Code/abc226_b/Java/33022279
|
condefects-java_data_524
|
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.Buffer;
import java.util.HashSet;
import java.util.StringTokenizer;
/*
* Solution: 1m
* Coding: 4m
* Time: 5m
*
*/
public class Main {
public static void main(String[] args) throws IOException {
//BufferedReader br = new BufferedReader(new FileReader("atcoder_abc/input.in"));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
HashSet<String> set = new HashSet<>();
for(int i = 0;i < n;i++){
StringTokenizer st = new StringTokenizer(br.readLine());
int l = Integer.parseInt(st.nextToken());
StringBuilder sb = new StringBuilder();
for(int j = 0;j < l;j++){
sb.append(st.nextToken());
}
set.add(sb.toString());
}
br.close();;
System.out.println(set.size());
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.Buffer;
import java.util.HashSet;
import java.util.StringTokenizer;
/*
* Solution: 1m
* Coding: 4m
* Time: 5m
*
*/
public class Main {
public static void main(String[] args) throws IOException {
//BufferedReader br = new BufferedReader(new FileReader("atcoder_abc/input.in"));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
HashSet<String> set = new HashSet<>();
for(int i = 0;i < n;i++){
StringTokenizer st = new StringTokenizer(br.readLine());
int l = Integer.parseInt(st.nextToken());
StringBuilder sb = new StringBuilder();
for(int j = 0;j < l;j++){
sb.append(st.nextToken() + ",");
}
set.add(sb.toString());
}
br.close();;
System.out.println(set.size());
}
}
|
ConDefects/ConDefects/Code/abc226_b/Java/41218375
|
condefects-java_data_525
|
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main( String args[]) {
Scanner scn = new Scanner( System.in);
int N = scn.nextInt();
Set<String> arraySet = new HashSet<>();
for ( int i = 0; i < N; i++) {
arraySet.add( scn.nextLine());
}
System.out.println( arraySet.size());
}
}
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main( String args[]) {
Scanner scn = new Scanner( System.in);
int N = Integer.parseInt( scn.nextLine());
Set<String> arraySet = new HashSet<>();
for ( int i = 0; i < N; i++) {
arraySet.add( scn.nextLine());
}
System.out.println( arraySet.size());
}
}
|
ConDefects/ConDefects/Code/abc226_b/Java/34484492
|
condefects-java_data_526
|
import java.util.*;
public class Main {
public static void main(String[] args){
//入力の読み込み
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
sc.nextLine();
String[] L= new String[N];
HashMap map = new HashMap();
for(int i=0;i<N;i++){
String tmp = sc.nextLine();
System.out.println(tmp);
if(map.containsKey(tmp)==false){
map.put(tmp, tmp);
}
}
//計算
int ans =map.size();
//回答出力
System.out.println(ans);
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
//入力の読み込み
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
sc.nextLine();
String[] L= new String[N];
HashMap map = new HashMap();
for(int i=0;i<N;i++){
String tmp = sc.nextLine();
//System.out.println(tmp);
if(map.containsKey(tmp)==false){
map.put(tmp, tmp);
}
}
//計算
int ans =map.size();
//回答出力
System.out.println(ans);
}
}
|
ConDefects/ConDefects/Code/abc226_b/Java/31782536
|
condefects-java_data_527
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
try (Scanner sc = new Scanner(System.in)) {
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
StringBuffer outLine = new StringBuffer();
for (int j = 1; j <= n; j++) {
outLine.append((sc.nextInt() == 1) ? j + " " : "");
}
System.err.println(outLine);
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
try (Scanner sc = new Scanner(System.in)) {
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
StringBuffer outLine = new StringBuffer();
for (int j = 1; j <= n; j++) {
outLine.append((sc.nextInt() == 1) ? j + " " : "");
}
System.out.println(outLine);
}
}
}
}
|
ConDefects/ConDefects/Code/abc343_b/Java/51634034
|
condefects-java_data_528
|
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
int n = sc.nextInt();
boolean f=false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int r = sc.nextInt();
if (r==1){
System.out.print(j);
f=true;
}
}
if (f) System.out.println();
f=false;
}
}
static class FastReader {
StringTokenizer st;
BufferedReader br;
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;
}
}
static FastReader sc = new FastReader();
}
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
int n = sc.nextInt();
boolean f=false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int r = sc.nextInt();
if (r==1){
System.out.print(j+" ");
f=true;
}
}
if (f) System.out.println();
f=false;
}
}
static class FastReader {
StringTokenizer st;
BufferedReader br;
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;
}
}
static FastReader sc = new FastReader();
}
|
ConDefects/ConDefects/Code/abc343_b/Java/51493957
|
condefects-java_data_529
|
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
for (int i=0;i<N;i++) {
StringBuilder sb = new StringBuilder();
for (int j=0;j<N;j++){
int Aij = sc.nextInt();
if (Aij == 1) {
if (!sb.isEmpty()) {
sb.append(" ");
}
sb.append(j);
}
}
if (!sb.isEmpty()) {
System.out.println(sb);
}
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
for (int i=0;i<N;i++) {
StringBuilder sb = new StringBuilder();
for (int j=0;j<N;j++){
int Aij = sc.nextInt();
if (Aij == 1) {
if (!sb.isEmpty()) {
sb.append(" ");
}
sb.append(j+1);
}
}
if (!sb.isEmpty()) {
System.out.println(sb);
}
}
}
}
|
ConDefects/ConDefects/Code/abc343_b/Java/51937083
|
condefects-java_data_530
|
import java.util.Scanner;
public class Main {
public static void main(String []args){
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
int a[][]=new int[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
a[i][j]=sc.nextInt();
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[i][j]==1){
System.out.print((j+1)+" ");
}
if(j==3){
System.out.println();
}
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String []args){
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
int a[][]=new int[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
a[i][j]=sc.nextInt();
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[i][j]==1){
System.out.print((j+1)+" ");
}
if(j==(n-1)){
System.out.println();
}
}
}
}
}
|
ConDefects/ConDefects/Code/abc343_b/Java/51211406
|
condefects-java_data_531
|
import java.util.Scanner;
class Main{
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
int k = scanner.nextInt();
if(k == 1){
System.out.print(j+" ");
}
}
System.out.println("");
}
}
}
import java.util.Scanner;
class Main{
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
int k = scanner.nextInt();
if(k == 1){
System.out.print((j+1) + " ");
}
}
System.out.println("");
}
}
}
|
ConDefects/ConDefects/Code/abc343_b/Java/51359813
|
condefects-java_data_532
|
import java.io.IOException;
import java.util.Scanner;
/*
4 2
1 2 1 2
6 3 4 5
check t color is there
if t max(t's rank)
check the color of 1person
max(p1 colors high rank)
if'
*/
public class Main {
public static void main(String[] args) throws IOException {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
String str = s.next();
boolean good = false;
for(int i = 0; i < n; i++) {
if(str.charAt(i) == 'x') {
System.out.println("No");
return;
} else if(str.charAt(i) == '0')
good = true;
}
if(good)
System.out.println("Yes");
else
System.out.println("No");
}
}
import java.io.IOException;
import java.util.Scanner;
/*
4 2
1 2 1 2
6 3 4 5
check t color is there
if t max(t's rank)
check the color of 1person
max(p1 colors high rank)
if'
*/
public class Main {
public static void main(String[] args) throws IOException {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
String str = s.next();
boolean good = false;
for(int i = 0; i < n; i++) {
if(str.charAt(i) == 'x') {
System.out.println("No");
return;
} else if(str.charAt(i) == 'o')
good = true;
}
if(good)
System.out.println("Yes");
else
System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc298_a/Java/43244619
|
condefects-java_data_533
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
String S = input.next();
boolean check1 = false;
boolean check2 = true;
for (int i = 0; i < N; i++) {
if (S.charAt(i) == 'o') {
check1 = true;
}
if (S.charAt(i) == 'x') {
check1 = false;
}
}
if (check1 && check2) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
String S = input.next();
boolean check1 = false;
boolean check2 = true;
for (int i = 0; i < N; i++) {
if (S.charAt(i) == 'o') {
check1 = true;
}
if (S.charAt(i) == 'x') {
check2 = false;
}
}
if (check1 && check2) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc298_a/Java/45198101
|
condefects-java_data_534
|
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
String input = sc.next();
List<String> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
char c = input.charAt(i);
list.add(String.valueOf(c));
}
if (list.contains("o") && !list.contains("×")) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
String input = sc.next();
List<String> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
char c = input.charAt(i);
list.add(String.valueOf(c));
}
if (list.contains("o") && !list.contains("x")) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc298_a/Java/42004942
|
condefects-java_data_535
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String tmp=sc.nextLine();
int N=Integer.parseInt(tmp);
tmp=sc.nextLine();
String[] W=tmp.split(" ");
String[] S={ "and", "not", "that", "the", "you"};
for(int i=0;i<N;i++){
for(int j=0;j<S.length;j++){
if( !W[i].equals(S[j]) ){
System.out.println("Yes");
return ;
}
}
}
System.out.println("No");
return ;
}
/*private static int[][] rotate(int n, int[][] mtx) {
int[][] ret = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ret[i][j] = mtx[n - 1 - j][i];
}
}
return ret;
}
*/
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String tmp=sc.nextLine();
int N=Integer.parseInt(tmp);
tmp=sc.nextLine();
String[] W=tmp.split(" ");
String[] S={ "and", "not", "that", "the", "you"};
for(int i=0;i<N;i++){
for(int j=0;j<S.length;j++){
if( W[i].equals(S[j]) ){
System.out.println("Yes");
return ;
}
}
}
System.out.println("No");
return ;
}
/*private static int[][] rotate(int n, int[][] mtx) {
int[][] ret = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ret[i][j] = mtx[n - 1 - j][i];
}
}
return ret;
}
*/
}
|
ConDefects/ConDefects/Code/abc295_a/Java/41407569
|
condefects-java_data_536
|
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
Pattern p = Pattern.compile("and|not|that|the|you");
for(int i = 0; i < n; i++) {
String w = sc.next();
Matcher m = p.matcher(w);
if(m.find()) {
System.out.println("Yes");
System.exit(0);
}
}
System.out.println("No");
}
}
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
Pattern p = Pattern.compile("^(and|not|that|the|you)$");
for(int i = 0; i < n; i++) {
String w = sc.next();
Matcher m = p.matcher(w);
if(m.find()) {
System.out.println("Yes");
System.exit(0);
}
}
System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc295_a/Java/41602447
|
condefects-java_data_537
|
import java.util.Scanner;
/**
* @author: Mostafa Murad
* @created: 5/22/2023 on 09:27 PM
**/
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int idx=-1;
for(int i=0;i<n;i++)
{
String s=in.next();
if(s.contains("and") || s.contains("not") || s.contains("that") || s.contains("the") || s.contains("you"))
{
idx=0;
break;
}
}
if(idx==0) System.out.println("Yes");
else System.out.println("No");
}
}
import java.util.Scanner;
/**
* @author: Mostafa Murad
* @created: 5/22/2023 on 09:27 PM
**/
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int idx=-1;
for(int i=0;i<n;i++)
{
String s=in.next();
if(s.equals("and") || s.equals("not") || s.equals("that") || s.equals("the") || s.equals("you"))
{
idx=0;
break;
}
}
if(idx==0) System.out.println("Yes");
else System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc295_a/Java/41705759
|
condefects-java_data_538
|
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
Scanner in = new Scanner(System.in);
int N = in.nextInt();
boolean flg = false;
String tmp;
String[] chkStr = {"and","not","that","you"};
for (int i = 0; i < N; i++) {
tmp = in.next();
for(String str : chkStr){
if(tmp.equals(str)){
flg = true;
}
}
}
if(flg){
System.out.println("Yes");
} else{
System.out.println("No");
}
}
}
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) throws IOException{
Scanner in = new Scanner(System.in);
int N = in.nextInt();
boolean flg = false;
String tmp;
String[] chkStr = {"and","not","that","the","you"};
for (int i = 0; i < N; i++) {
tmp = in.next();
for(String str : chkStr){
if(tmp.equals(str)){
flg = true;
}
}
}
if(flg){
System.out.println("Yes");
} else{
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc295_a/Java/41469888
|
condefects-java_data_539
|
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
String[] arr = new String[n];
for(int i = 0; i < n; i++)
arr[i] = s.next();
for (int i = 0; i < n; i++) {
String c = arr[i];
if(c == "and" || c == "not" || c == "that" || c == "the" || c== "you") {
System.out.println("Yes");
return;
}
}
System.out.println("No");
}
}
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
String[] arr = new String[n];
for(int i = 0; i < n; i++)
arr[i] = s.next();
for (int i = 0; i < n; i++) {
String c = arr[i];
if(c.equals("and") || c.equals("not") || c.equals("that") || c.equals("the") || c.equals("you")) {
System.out.println("Yes");
return;
}
}
System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc295_a/Java/43253267
|
condefects-java_data_540
|
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.NoSuchElementException;
public class Main {
static final boolean debug = false;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
var s = sc.next().toCharArray();
for (int i = 0; i < s.length; i++) {
if (s[i] >= 'A') System.out.println(i + 1);
}
}
/*
* エラトステネスの篩 nまでの素数の配列を返却する
*
*/
public static boolean[] getEratostheses(int n) {
boolean[] isPrimes = new boolean[n + 1];
Arrays.fill(isPrimes, true);
isPrimes[0] = isPrimes[1] = false;
var root = Math.sqrt(isPrimes.length);
for (int i = 0; i < root; i++) {
if (!isPrimes[i]) continue;
for (int j = i * i; j < isPrimes.length; j += i) {
isPrimes[j] = false;
}
}
return isPrimes;
}
public static boolean isPrime(long a) {
if (a == 1) return false;
if (a == 2) return true;
if (a % 2 == 0) return false;
var rootA = (int) Math.sqrt(a);
for (int i = 3; i <= rootA; i += 2) {
if (a % i == 0) return false;
}
return true;
}
static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
static boolean nextPermutation(int[] array) {
// Find longest non-increasing suffix
int i = array.length - 1;
while (i > 0 && array[i - 1] >= array[i])
i--;
// Now i is the head index of the suffix
// Are we at the last permutation already?
if (i <= 0) return false;
// Let array[i - 1] be the pivot
// Find rightmost element greater than the pivot
int j = array.length - 1;
while (array[j] <= array[i - 1])
j--;
// Now the value array[j] will become the new pivot
// Assertion: j >= i
// Swap the pivot with j
int temp = array[i - 1];
array[i - 1] = array[j];
array[j] = temp;
// Reverse the suffix
j = array.length - 1;
while (i < j) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
// Successfully computed the next permutation
return true;
}
/*--- ---*/
/*--- debug ---*/
/*--- ---*/
public static void debug(int[] x) {
out(Arrays.toString(x));
}
public static void debug(boolean[] x) {
out(Arrays.toString(x));
}
public static void debug(long[] x) {
out(Arrays.toString(x));
}
public static void debug(int[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(boolean[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(char[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(Object[] x) {
out(Arrays.toString(x));
}
public static void debug(Object[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(String x) {
out(x);
}
public static void debug(Object a) {
System.err.println(a);
}
public static void out(String x) {
System.err.println(x);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] readIntArray(final int size) {
int[] intArray = new int[size];
Arrays.setAll(intArray, i -> nextInt());
return intArray;
}
public long[] readLongArray(final int size) {
long[] longArray = new long[size];
Arrays.setAll(longArray, i -> nextLong());
return longArray;
}
public String[] readStringArray(final int size) {
String[] stringArray = new String[size];
Arrays.setAll(stringArray, i -> next());
return stringArray;
}
public List<String> readStringList(final int size) {
var list = new ArrayList<String>();
for (int i = 0; i < size; i++) {
list.add(next());
}
return list;
}
public char[][] twoDimensionalCharArray(final int h, final int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) {
array[i] = next().toCharArray();
}
return array;
}
public int[][] twoDimensionalIntArray(final int h, final int w) {
int[][] array = new int[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
array[i][j] = nextInt();
}
}
return array;
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.NoSuchElementException;
public class Main {
static final boolean debug = false;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
var s = sc.next().toCharArray();
for (int i = 0; i < s.length; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') System.out.println(i + 1);
}
}
/*
* エラトステネスの篩 nまでの素数の配列を返却する
*
*/
public static boolean[] getEratostheses(int n) {
boolean[] isPrimes = new boolean[n + 1];
Arrays.fill(isPrimes, true);
isPrimes[0] = isPrimes[1] = false;
var root = Math.sqrt(isPrimes.length);
for (int i = 0; i < root; i++) {
if (!isPrimes[i]) continue;
for (int j = i * i; j < isPrimes.length; j += i) {
isPrimes[j] = false;
}
}
return isPrimes;
}
public static boolean isPrime(long a) {
if (a == 1) return false;
if (a == 2) return true;
if (a % 2 == 0) return false;
var rootA = (int) Math.sqrt(a);
for (int i = 3; i <= rootA; i += 2) {
if (a % i == 0) return false;
}
return true;
}
static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
static boolean nextPermutation(int[] array) {
// Find longest non-increasing suffix
int i = array.length - 1;
while (i > 0 && array[i - 1] >= array[i])
i--;
// Now i is the head index of the suffix
// Are we at the last permutation already?
if (i <= 0) return false;
// Let array[i - 1] be the pivot
// Find rightmost element greater than the pivot
int j = array.length - 1;
while (array[j] <= array[i - 1])
j--;
// Now the value array[j] will become the new pivot
// Assertion: j >= i
// Swap the pivot with j
int temp = array[i - 1];
array[i - 1] = array[j];
array[j] = temp;
// Reverse the suffix
j = array.length - 1;
while (i < j) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
// Successfully computed the next permutation
return true;
}
/*--- ---*/
/*--- debug ---*/
/*--- ---*/
public static void debug(int[] x) {
out(Arrays.toString(x));
}
public static void debug(boolean[] x) {
out(Arrays.toString(x));
}
public static void debug(long[] x) {
out(Arrays.toString(x));
}
public static void debug(int[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(boolean[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(char[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(Object[] x) {
out(Arrays.toString(x));
}
public static void debug(Object[][] x) {
out(Arrays.deepToString(x));
}
public static void debug(String x) {
out(x);
}
public static void debug(Object a) {
System.err.println(a);
}
public static void out(String x) {
System.err.println(x);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] readIntArray(final int size) {
int[] intArray = new int[size];
Arrays.setAll(intArray, i -> nextInt());
return intArray;
}
public long[] readLongArray(final int size) {
long[] longArray = new long[size];
Arrays.setAll(longArray, i -> nextLong());
return longArray;
}
public String[] readStringArray(final int size) {
String[] stringArray = new String[size];
Arrays.setAll(stringArray, i -> next());
return stringArray;
}
public List<String> readStringList(final int size) {
var list = new ArrayList<String>();
for (int i = 0; i < size; i++) {
list.add(next());
}
return list;
}
public char[][] twoDimensionalCharArray(final int h, final int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) {
array[i] = next().toCharArray();
}
return array;
}
public int[][] twoDimensionalIntArray(final int h, final int w) {
int[][] array = new int[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
array[i][j] = nextInt();
}
}
return array;
}
}
|
ConDefects/ConDefects/Code/abc291_a/Java/41102058
|
condefects-java_data_541
|
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
char a[] = sc.next().toCharArray();
int ans = 0;
for(int i = 0; i < a.length; i++){
if(a[i] >= 'A' && a[i] <= 'Z') {
System.out.println(i);
return;
}
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
char a[] = sc.next().toCharArray();
int ans = 0;
for(int i = 0; i < a.length; i++){
if(a[i] >= 'A' && a[i] <= 'Z') {
System.out.println(i + 1);
return;
}
}
}
}
|
ConDefects/ConDefects/Code/abc291_a/Java/43570201
|
condefects-java_data_542
|
import java.util.Hashtable;
import java.util.Scanner;
class Main {
public static void main(String args[]) {
Scanner s = new Scanner(System.in);
String ns = s.nextLine();
s.close();
for (int i=0; ns.length() > i; i++) {
if (Character.isUpperCase(ns.charAt(i))) {
System.out.println(i);
break;
}
}
}
}
import java.util.Hashtable;
import java.util.Scanner;
class Main {
public static void main(String args[]) {
Scanner s = new Scanner(System.in);
String ns = s.nextLine();
s.close();
for (int i=0; ns.length() > i; i++) {
if (Character.isUpperCase(ns.charAt(i))) {
System.out.println(i+1);
break;
}
}
}
}
|
ConDefects/ConDefects/Code/abc291_a/Java/41133669
|
condefects-java_data_543
|
import java.util.Scanner;
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(i) == '0')
System.out.print('1');
else if (s.charAt(i) == '1')
System.out.println('0');
}
}
}
import java.util.Scanner;
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(i) == '0')
System.out.print('1');
else if (s.charAt(i) == '1')
System.out.print('0');
}
}
}
|
ConDefects/ConDefects/Code/abc289_a/Java/39079554
|
condefects-java_data_544
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc1=new Scanner(System.in);
double a =sc1.nextDouble();
double b=sc1.nextDouble();
double c=sc1.nextDouble();
double x=sc1.nextDouble();
if(x<a)System.out.println("1.000000000000");
else if(x>b)System.out.println("0.000000000000");
else {
System.out.println(c/(b-a));
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc1=new Scanner(System.in);
double a =sc1.nextDouble();
double b=sc1.nextDouble();
double c=sc1.nextDouble();
double x=sc1.nextDouble();
if(x<=a)System.out.println("1.000000000000");
else if(x>b)System.out.println("0.000000000000");
else {
System.out.println(c/(b-a));
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/34189432
|
condefects-java_data_545
|
import java.io.*;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static Scanner in = new Scanner(System.in);
static BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" "); int a = Integer.parseInt(strs[0]);
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" ");
//int T=Integer.parseInt(strs[0]);
//int T=in.nextInt();
int T=1;
while(T>0){
//String[] strs1 = re.readLine().split(" ");
//int n=Integer.parseInt(strs1[0]);
//String s=re.readLine();
//char arr[]=s.toCharArray();
//long[][] p = new long[n][2];//对 long 二维数组排序
//Arrays.sort(p, (a, b) -> a[0] <= b[0] ? -1 : 1);
//Set<Integer>set=new HashSet<>();
//Map<Long,Integer>map=new HashMap<>();
//Map<Integer,List<Integer>>map=new HashMap<>();
//TreeSet<Integer> set = new TreeSet<>();
//int max=0;int min=2100000000;
int a=in.nextInt();
int b=in.nextInt();
int c=in.nextInt();
int x=in.nextInt();
if(x>=a&&x<=b){
double aa=b-a;
double res;
if(c==aa){
out.println("1.000000000000");
}
else{
res=c/(aa*1.0);
out.println(res);
}
}
else{
if(x<=a)out.println("1.000000000000");
else out.println("0.000000000000");
}
T--;
}
out.flush();
}
}
import java.io.*;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static Scanner in = new Scanner(System.in);
static BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" "); int a = Integer.parseInt(strs[0]);
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" ");
//int T=Integer.parseInt(strs[0]);
//int T=in.nextInt();
int T=1;
while(T>0){
//String[] strs1 = re.readLine().split(" ");
//int n=Integer.parseInt(strs1[0]);
//String s=re.readLine();
//char arr[]=s.toCharArray();
//long[][] p = new long[n][2];//对 long 二维数组排序
//Arrays.sort(p, (a, b) -> a[0] <= b[0] ? -1 : 1);
//Set<Integer>set=new HashSet<>();
//Map<Long,Integer>map=new HashMap<>();
//Map<Integer,List<Integer>>map=new HashMap<>();
//TreeSet<Integer> set = new TreeSet<>();
//int max=0;int min=2100000000;
int a=in.nextInt();
int b=in.nextInt();
int c=in.nextInt();
int x=in.nextInt();
if(x>a&&x<=b){
double aa=b-a;
double res;
if(c==aa){
out.println("1.000000000000");
}
else{
res=c/(aa*1.0);
out.println(res);
}
}
else{
if(x<=a)out.println("1.000000000000");
else out.println("0.000000000000");
}
T--;
}
out.flush();
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/36702599
|
condefects-java_data_546
|
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
double A = sc.nextDouble();
double B = sc.nextDouble();
double C = sc.nextDouble();
double X = sc.nextDouble();
sc.close();
if(A>=X){
System.out.println(String.format("%.12f", (double)1));
}
else{
if(B>X){
System.out.println(String.format("%.12f", (C/(B-A))));
}
else{
System.out.println(String.format("%.12f", (double)0));
}
}
}
}
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
double A = sc.nextDouble();
double B = sc.nextDouble();
double C = sc.nextDouble();
double X = sc.nextDouble();
sc.close();
if(A>=X){
System.out.println(String.format("%.12f", (double)1));
}
else{
if(B>=X){
System.out.println(String.format("%.12f", (C/(B-A))));
}
else{
System.out.println(String.format("%.12f", (double)0));
}
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/34914575
|
condefects-java_data_547
|
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// int[][] array = new int[2][];
int A = Integer.parseInt(sc.next());
int B = Integer.parseInt(sc.next());
int C = Integer.parseInt(sc.next());
int X = Integer.parseInt(sc.next());
sc.close();
if (A >= X) {
System.out.println(1);
}
else if (B >= X) {
double res = (double)C / (1000 - A - B);
System.out.println(res);
}
else {
System.out.println(0);
}
}
}
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// int[][] array = new int[2][];
int A = Integer.parseInt(sc.next());
int B = Integer.parseInt(sc.next());
int C = Integer.parseInt(sc.next());
int X = Integer.parseInt(sc.next());
sc.close();
if (A >= X) {
System.out.println(1);
}
else if (B >= X) {
double res = (double)C / (B - A);
System.out.println(res);
}
else {
System.out.println(0);
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/31778487
|
condefects-java_data_548
|
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 X = sc.nextInt();
double rack = 0;
if (X > A && X <= B) {
rack = (double) C / (double) (1000 - B - A);
} else if (X <= A) {
rack = 1;
} else {
rack = 0;
}
System.out.println(String.format("%.12f", rack));
}
}
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 X = sc.nextInt();
double rack = 0;
if (X > A && X <= B) {
rack = (double) C / (double) (B - A);
} else if (X <= A) {
rack = 1;
} else {
rack = 0;
}
System.out.println(String.format("%.12f", rack));
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/33527521
|
condefects-java_data_549
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String input = scan.nextLine();
double A = Integer.parseInt(input.split(" ")[0]);
double B = Integer.parseInt(input.split(" ")[1]);
double C = Integer.parseInt(input.split(" ")[2]);
int X = Integer.parseInt(input.split(" ")[3]);
double percent = 0;
if (X < A) {
percent = 1;
}else if(B < X){
percent = 0;
}else {
percent = C / (B-A);
}
System.out.println(percent);
scan.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String input = scan.nextLine();
double A = Integer.parseInt(input.split(" ")[0]);
double B = Integer.parseInt(input.split(" ")[1]);
double C = Integer.parseInt(input.split(" ")[2]);
int X = Integer.parseInt(input.split(" ")[3]);
double percent = 0;
if (X <= A) {
percent = 1;
}else if(B < X){
percent = 0;
}else {
percent = C / (B-A);
}
System.out.println(percent);
scan.close();
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/35803808
|
condefects-java_data_550
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Main {
public static void main(String[] args) {
try (
InputStreamReader InputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(InputStreamReader);
) {
String input = bufferedReader.readLine();
String[] strArray = input.split(" ");
int upper = Integer.parseInt(strArray[0]);
int lower = Integer.parseInt(strArray[1]);
BigDecimal canGet = new BigDecimal(strArray[2]);
int rank = Integer.parseInt(strArray[3]);
if (rank <= upper) {
System.out.println(0.0);
return;
}
if (rank <= lower) {
BigDecimal all = new BigDecimal(lower - upper);
BigDecimal possibility = canGet.divide(all, 6, RoundingMode.DOWN);
System.out.println(possibility);
return;
}
System.out.println(0.0);
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Main {
public static void main(String[] args) {
try (
InputStreamReader InputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(InputStreamReader);
) {
String input = bufferedReader.readLine();
String[] strArray = input.split(" ");
int upper = Integer.parseInt(strArray[0]);
int lower = Integer.parseInt(strArray[1]);
BigDecimal canGet = new BigDecimal(strArray[2]);
int rank = Integer.parseInt(strArray[3]);
if (rank <= upper) {
System.out.println(1.0);
return;
}
if (rank <= lower) {
BigDecimal all = new BigDecimal(lower - upper);
BigDecimal possibility = canGet.divide(all, 6, RoundingMode.DOWN);
System.out.println(possibility);
return;
}
System.out.println(0.0);
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/34955722
|
condefects-java_data_551
|
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
double a = sc.nextDouble();
double b = sc.nextDouble();
double c = sc.nextDouble();
double x = sc.nextDouble();
double output = 0.0;
if(x <= a){
output = 1.0;
} else {
output = c /(b-a);
}
System.out.printf("%.12f",output);
sc.close();
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
double a = sc.nextDouble();
double b = sc.nextDouble();
double c = sc.nextDouble();
double x = sc.nextDouble();
double output = 0.0;
if(x <= a){
output = 1.0;
} else if(x <= b) {
output = c /(b-a);
}
System.out.printf("%.12f",output);
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/39659757
|
condefects-java_data_552
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double A = scanner.nextInt();
double B = scanner.nextInt();
double C = scanner.nextInt();
double X = scanner.nextInt();
double probability = 1;
if (A < X) {
probability = C / (B - A);
}
if (B - A <= X) {
probability = 0;
}
System.out.println(probability);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double A = scanner.nextInt();
double B = scanner.nextInt();
double C = scanner.nextInt();
double X = scanner.nextInt();
double probability = 1;
if (A < X) {
probability = C / (B - A);
}
if (B < X) {
probability = 0;
}
System.out.println(probability);
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/32060723
|
condefects-java_data_553
|
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
double a = sc.nextInt();
double b = sc.nextInt();
double c = sc.nextInt();
int x = sc.nextInt();
if (x <= a) {
out.println(1);
} else if (x > a && x < b) {
out.println(c/(b-a));
} else {
out.println(0);
}
out.flush();
}
}
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
double a = sc.nextInt();
double b = sc.nextInt();
double c = sc.nextInt();
int x = sc.nextInt();
if (x <= a) {
out.println(1);
} else if (x > a && x <= b) {
out.println(c/(b-a));
} else {
out.println(0);
}
out.flush();
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/42744397
|
condefects-java_data_554
|
import java.io.*;
import java.util.StringTokenizer;
public class Main {
static Main2 admin = new Main2();
public static void main(String[] args) {
admin.start();
}
}
class Main2 {
//---------------------------------INPUT READER-----------------------------------------//
public BufferedReader br;
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens()) {
try { st = new StringTokenizer(br.readLine());} catch (IOException e) { e.printStackTrace(); }
}
return st.nextToken();
}
int ni() { return Integer.parseInt(next()); }
long nl() { return Long.parseLong(next()); }
double nd() { return Double.parseDouble(next()); }
String ns() { return next(); }
int[] na(long n) {int[]ret=new int[(int)n]; for(int i=0;i<n;i++) ret[i]=ni(); return ret;}
long[] nal(long n) {long[]ret=new long[(int)n]; for(int i=0;i<n;i++) ret[i]=nl(); return ret;}
Integer[] nA(long n) {Integer[]ret=new Integer[(int)n]; for(int i=0;i<n;i++) ret[i]=ni(); return ret;}
Long[] nAl(long n) {Long[]ret=new Long[(int)n]; for(int i=0;i<n;i++) ret[i]=nl(); return ret;}
//--------------------------------------PRINTER------------------------------------------//
PrintWriter w;
void p(int i) {w.println(i);} void p(long l) {w.println(l);}
void p(double d) {w.println(d);} void p(String s) { w.println(s);}
void pr(int i) {w.print(i);} void pr(long l) {w.print(l);}
void pr(double d) {w.print(d);} void pr(String s) { w.print(s);}
void pl() {w.println();}
//--------------------------------------VARIABLES-----------------------------------------//
long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
int ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
long mod = 1000000007;
{
w = new PrintWriter(System.out);
br = new BufferedReader(new InputStreamReader(System.in));
try {if(new File(System.getProperty("user.dir")).getName().equals("LOCAL")) {
w = new PrintWriter(new OutputStreamWriter(new FileOutputStream("output.txt")));
br = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt")));}
} catch (Exception ignore) { }
}
//----------------------START---------------------//
void start() {
//int t = ni(); while(t-- > 0)
solve();
w.close();
}
void solve() {
double a = nd(), b = nd(), c = nd(), x = nd();
if(x > a && x <= b) {
double tot = b - a;
p((c/tot));
} else if(x < a) {
p(1);
} else {
p(0);
}
}
}
import java.io.*;
import java.util.StringTokenizer;
public class Main {
static Main2 admin = new Main2();
public static void main(String[] args) {
admin.start();
}
}
class Main2 {
//---------------------------------INPUT READER-----------------------------------------//
public BufferedReader br;
StringTokenizer st = new StringTokenizer("");
String next() {
while (!st.hasMoreTokens()) {
try { st = new StringTokenizer(br.readLine());} catch (IOException e) { e.printStackTrace(); }
}
return st.nextToken();
}
int ni() { return Integer.parseInt(next()); }
long nl() { return Long.parseLong(next()); }
double nd() { return Double.parseDouble(next()); }
String ns() { return next(); }
int[] na(long n) {int[]ret=new int[(int)n]; for(int i=0;i<n;i++) ret[i]=ni(); return ret;}
long[] nal(long n) {long[]ret=new long[(int)n]; for(int i=0;i<n;i++) ret[i]=nl(); return ret;}
Integer[] nA(long n) {Integer[]ret=new Integer[(int)n]; for(int i=0;i<n;i++) ret[i]=ni(); return ret;}
Long[] nAl(long n) {Long[]ret=new Long[(int)n]; for(int i=0;i<n;i++) ret[i]=nl(); return ret;}
//--------------------------------------PRINTER------------------------------------------//
PrintWriter w;
void p(int i) {w.println(i);} void p(long l) {w.println(l);}
void p(double d) {w.println(d);} void p(String s) { w.println(s);}
void pr(int i) {w.print(i);} void pr(long l) {w.print(l);}
void pr(double d) {w.print(d);} void pr(String s) { w.print(s);}
void pl() {w.println();}
//--------------------------------------VARIABLES-----------------------------------------//
long lma = Long.MAX_VALUE, lmi = Long.MIN_VALUE;
int ima = Integer.MAX_VALUE, imi = Integer.MIN_VALUE;
long mod = 1000000007;
{
w = new PrintWriter(System.out);
br = new BufferedReader(new InputStreamReader(System.in));
try {if(new File(System.getProperty("user.dir")).getName().equals("LOCAL")) {
w = new PrintWriter(new OutputStreamWriter(new FileOutputStream("output.txt")));
br = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt")));}
} catch (Exception ignore) { }
}
//----------------------START---------------------//
void start() {
//int t = ni(); while(t-- > 0)
solve();
w.close();
}
void solve() {
double a = nd(), b = nd(), c = nd(), x = nd();
if(x > a && x <= b) {
double tot = b - a;
p((c/tot));
} else if(x <= a) {
p(1);
} else {
p(0);
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/33568193
|
condefects-java_data_555
|
import java.util.Scanner;
class Main
{
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int A=scanner.nextInt();
int B=scanner.nextInt();
int C=scanner.nextInt();
int X=scanner.nextInt();
if(X<A) {
System.out.println(1.000000000000);
}else if(A<X&&X<=B) {
System.out.println((double)C/(B-A));
}else if(B<X&&X<=1000) {
System.out.println(0.000000000000);
}
}
}
import java.util.Scanner;
class Main
{
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int A=scanner.nextInt();
int B=scanner.nextInt();
int C=scanner.nextInt();
int X=scanner.nextInt();
if(X<=A) {
System.out.println(1.000000000000);
}else if(A<X&&X<=B) {
System.out.println((double)C/(B-A));
}else if(B<X&&X<=1000) {
System.out.println(0.000000000000);
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/31991091
|
condefects-java_data_556
|
import java.util.*;
class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in)) {
double a = sc.nextDouble();
double b = sc.nextDouble();
double c = sc.nextDouble();
double x = sc.nextDouble();
double p = 0;
if(1<=x && x<=a) {
p=1;
} else {
p=c/(b-a);
}
System.out.println(p);
}
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in)) {
double a = sc.nextDouble();
double b = sc.nextDouble();
double c = sc.nextDouble();
double x = sc.nextDouble();
double p = 0;
if(1<=x && x<=a) {
p=1;
} else if(a+1<=x&&x<=b) {
p=c/(b-a);
}
System.out.println(p);
}
}
}
|
ConDefects/ConDefects/Code/abc242_a/Java/32762665
|
condefects-java_data_557
|
import java.util.*;
public class Main {
public static int ans = 0;
public static int first = 1;
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] node = new int[n + 1];
int[] visited = new int[n + 1];
boolean[] isAns = new boolean[n + 1];
for(int i = 1;i < n + 1;i++) {
node[i] = Integer.parseInt(sc.next());
}for(int i = 1;i <= n;i++) {
if(visited[i] == 0) {
dfs(node,i,visited,first,first,isAns);
}
}
System.out.print(ans);
}public static void dfs(int[] node,int ind,int[] v,int union,int start,boolean[] isAns) {
v[ind] = union;
if(v[node[ind]] == 0) {
first++;
dfs(node,node[ind],v,union + 1,start,isAns);
}else if(v[ind] >= v[node[ind]] && v[node[ind]] >= start){
//System.out.println(ind);
ans += v[ind] - v[node[ind]] + 1;
isAns[node[ind]] = true;
}
}
}
import java.util.*;
public class Main {
public static int ans = 0;
public static int first = 1;
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] node = new int[n + 1];
int[] visited = new int[n + 1];
boolean[] isAns = new boolean[n + 1];
for(int i = 1;i < n + 1;i++) {
node[i] = Integer.parseInt(sc.next());
}for(int i = 1;i <= n;i++) {
if(visited[i] == 0) {
dfs(node,i,visited,first,first,isAns);
}
}
System.out.print(ans);
}public static void dfs(int[] node,int ind,int[] v,int union,int start,boolean[] isAns) {
first++;
v[ind] = union;
if(v[node[ind]] == 0) {
dfs(node,node[ind],v,union + 1,start,isAns);
}else if(v[ind] >= v[node[ind]] && v[node[ind]] >= start){
//System.out.println(ind);
ans += v[ind] - v[node[ind]] + 1;
isAns[node[ind]] = true;
}
}
}
|
ConDefects/ConDefects/Code/abc296_e/Java/47324000
|
condefects-java_data_558
|
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 void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
List<Integer>[] g = new List[N];
for (int i = 0; i < N; i++) {
g[i]=new ArrayList<>();
}
for (int i = 0; i < N; i++) {
int a = scanner.nextInt()-1;
g[i].add(a);
}
Set<Integer> inLoop = new HashSet<>();
boolean[] visitedGlobal = new boolean[N];
for (int i = 0; i < N; i++) {
if (visitedGlobal[i]) {
continue;
}
visitedGlobal[i]=true;
var visitedLocal = new HashSet<Integer>();
visitedLocal.add(i);
Queue<Integer>q = new LinkedList<>();
q.add(i);
while(!q.isEmpty()) {
int cur = q.poll();
for (Integer next : g[cur]) {
if (visitedLocal.contains(next)) {
int start = i;
Queue<Integer>q2 = new LinkedList<>();
q2.add(start);
while(!q2.isEmpty()) {
int cur2 = q2.poll();
//System.out.println(cur2);
if (next==cur2) {
break;
}
visitedLocal.remove(cur2);
for (Integer next2 : g[cur2]) {
q2.add(next2);
}
}
break;
}
if (visitedGlobal[next]) {
continue;
}
visitedGlobal[next]=true;
visitedLocal.add(next);
q.add(next);
}
}
inLoop.addAll(visitedLocal);
//System.out.println(visitedLocal);
}
System.out.println(inLoop.size());
}
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 void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
List<Integer>[] g = new List[N];
for (int i = 0; i < N; i++) {
g[i]=new ArrayList<>();
}
for (int i = 0; i < N; i++) {
int a = scanner.nextInt()-1;
g[i].add(a);
}
Set<Integer> inLoop = new HashSet<>();
boolean[] visitedGlobal = new boolean[N];
for (int i = 0; i < N; i++) {
if (visitedGlobal[i]) {
continue;
}
visitedGlobal[i]=true;
var visitedLocal = new HashSet<Integer>();
visitedLocal.add(i);
Queue<Integer>q = new LinkedList<>();
q.add(i);
while(!q.isEmpty()) {
int cur = q.poll();
for (Integer next : g[cur]) {
if (visitedLocal.contains(next)) {
int start = i;
Queue<Integer>q2 = new LinkedList<>();
q2.add(start);
while(!q2.isEmpty()) {
int cur2 = q2.poll();
//System.out.println(cur2);
if (next==cur2) {
break;
}
visitedLocal.remove(cur2);
for (Integer next2 : g[cur2]) {
q2.add(next2);
}
}
inLoop.addAll(visitedLocal);
break;
}
if (visitedGlobal[next]) {
continue;
}
visitedGlobal[next]=true;
visitedLocal.add(next);
q.add(next);
}
}
//System.out.println(visitedLocal);
}
System.out.println(inLoop.size());
}
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/abc296_e/Java/53726845
|
condefects-java_data_559
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
public final class Main {
static FastReader fr = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
static final int gigamod = 1000000007;
static final int mod = 998244353;
static int t = 1;
static boolean[] isPrime;
static int[] smallestFactorOf;
static final int UP = 0, LEFT = 1, DOWN = 2, RIGHT = 3;
static int cmp;
static long[] twoPow;
static int sz = 5;
@SuppressWarnings({"unused"})
public static void main(String[] args) throws Exception {
OUTER:
for (int tc = 0; tc < t; tc++) {
int n = fr.nextInt();
int[] arr = fr.nextIntArray(n);
Digraph dg = new Digraph(n);
for (int i = 0; i < n; i++)
dg.addEdge(i, arr[i] - 1);
// every node which is the part of some cycle is
// a winning node for us
boolean[] marked = new boolean[n];
boolean[] onStack = new boolean[n];
boolean[] isAns = new boolean[n];
for (int i = 0; i < n; i++)
if (!marked[i])
dfs(i, dg, marked, onStack, isAns, new int[1]);
int ans = 0;
for (boolean b : isAns)
if (b)
ans++;
out.println(ans);
}
out.close();
}
static void dfs(int current, Digraph dg, boolean[] marked, boolean[] onStack, boolean[] isAns, int[] curseNode) {
if (onStack[current]) {
// this is the part of some cycle
isAns[current] = true;
curseNode[0] = current;
return;
}
if (marked[current]) return; // this node was processed earlier
marked[current] = true;
onStack[current] = true;
for (int adj : dg.adj(current)) {
dfs(adj, dg, marked, onStack, isAns, curseNode);
if (isAns[adj] && curseNode[0] != -1)
isAns[current] = true;
}
if (curseNode[0] == current)
curseNode[0] = -1;
onStack[current] = false;
}
static int nn;
static int[] arr;
static int[] treeSum;
static int[] treeMinPrefSum;
static int[] lazy;
static void init(int n, int[] brr) {
nn = n;
arr = brr.clone();
treeSum = new int[4 * nn];
lazy = new int[4 * nn];
treeMinPrefSum = new int[4 * nn];
build(1, 0, nn - 1);
}
static void build(int node, int left, int right) {
if (left == right) {
treeSum[node] = arr[left];
treeMinPrefSum[node] = arr[left];
return;
}
int mid = (left + right) >> 1;
build((node<<1), left, mid);
build((node<<1|1), mid + 1, right);
treeSum[node] = treeSum[node<<1] + treeSum[node<<1|1];
}
static void flip(int node, int left, int right, int idx) {
if (left == right) {
treeSum[node] = -treeSum[node];
return;
}
if (idx < left || idx > right) return;
int mid = (left + right) >> 1;
flip((node<<1), left, mid, idx);
flip((node<<1|1), mid + 1, right, idx);
}
/*static int nn;
static int[] arr;
static int[] tree;
static int[] lazy;
static void build(int node, int leftt, int rightt) {
if (leftt == rightt) {
tree[node] = arr[leftt];
return;
}
int mid = (leftt + rightt) >> 1;
build(node << 1, leftt, mid);
build(node << 1 | 1, mid + 1, rightt);
tree[node] = Math.min(tree[node << 1], tree[node << 1 | 1]);
}
static void segAdd(int node, int leftt, int rightt, int segL, int segR, int val) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (leftt != rightt) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
}
lazy[node] = 0;
}
if (segL > rightt || segR < leftt) return;
if (segL <= leftt && rightt <= segR) {
tree[node] += val;
if (leftt != rightt) {
lazy[node << 1] += val;
lazy[node << 1 | 1] += val;
}
lazy[node] = 0;
return;
}
int mid = (leftt + rightt) >> 1;
segAdd(node << 1, leftt, mid, segL, segR, val);
segAdd(node << 1 | 1, mid + 1, rightt, segL, segR, val);
tree[node] = Math.min(tree[node << 1], tree[node << 1 | 1]);
}
static int minQuery(int node, int leftt, int rightt, int segL, int segR) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (leftt != rightt) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
}
lazy[node] = 0;
}
if (segL > rightt || segR < leftt) return Integer.MAX_VALUE / 10;
if (segL <= leftt && rightt <= segR)
return tree[node];
int mid = (leftt + rightt) >> 1;
return Math.min(minQuery(node << 1, leftt, mid, segL, segR),
minQuery(node << 1 | 1, mid + 1, rightt, segL, segR));
}
*/
static void compute_automaton(String s, int[][] aut) {
s += '#';
int n = s.length();
int[] pi = prefix_function(s.toCharArray());
for (int i = 0; i < n; i++) {
for (int c = 0; c < 26; c++) {
int j = i;
while (j > 0 && 'A' + c != s.charAt(j))
j = pi[j-1];
if ('A' + c == s.charAt(j))
j++;
aut[i][c] = j;
}
}
}
static void timeDFS(int current, int from, UGraph ug,
int[] time, int[] tIn, int[] tOut) {
tIn[current] = ++time[0];
for (int adj : ug.adj(current))
if (adj != from)
timeDFS(adj, current, ug, time, tIn, tOut);
tOut[current] = ++time[0];
}
static boolean areCollinear(long x1, long y1, long x2, long y2, long x3, long y3) {
// we will check if c3 lies on line through (c1, c2)
long a = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
return a == 0;
}
static int[] treeDiameter(UGraph ug) {
int n = ug.V();
int farthest = -1;
int[] distTo = new int[n];
diamDFS(0, -1, 0, ug, distTo);
int maxDist = -1;
for (int i = 0; i < n; i++)
if (maxDist < distTo[i]) {
maxDist = distTo[i];
farthest = i;
}
distTo = new int[n + 1];
diamDFS(farthest, -1, 0, ug, distTo);
distTo[n] = farthest;
return distTo;
}
static void diamDFS(int current, int from, int dist, UGraph ug, int[] distTo) {
distTo[current] = dist;
for (int adj : ug.adj(current))
if (adj != from)
diamDFS(adj, current, dist + 1, ug, distTo);
}
static class TreeDistFinder {
UGraph ug;
int n;
int[] depthOf;
LCA lca;
TreeDistFinder(UGraph ug) {
this.ug = ug;
n = ug.V();
depthOf = new int[n];
depthCalc(0, -1, ug, 0, depthOf);
lca = new LCA(ug, 0);
}
TreeDistFinder(UGraph ug, int a) {
this.ug = ug;
n = ug.V();
depthOf = new int[n];
depthCalc(a, -1, ug, 0, depthOf);
lca = new LCA(ug, a);
}
private void depthCalc(int current, int from, UGraph ug, int depth, int[] depthOf) {
depthOf[current] = depth;
for (int adj : ug.adj(current))
if (adj != from)
depthCalc(adj, current, ug, depth + 1, depthOf);
}
public int dist(int a, int b) {
int lc = lca.lca(a, b);
return (depthOf[a] - depthOf[lc] + depthOf[b] - depthOf[lc]);
}
}
public static long[][] GCDSparseTable(long[] a)
{
int n = a.length;
int b = 32-Integer.numberOfLeadingZeros(n);
long[][] ret = new long[b][];
for(int i = 0, l = 1;i < b;i++, l*=2) {
if(i == 0) {
ret[i] = a;
} else {
ret[i] = new long[n-l+1];
for(int j = 0;j < n-l+1;j++) {
ret[i][j] = gcd(ret[i-1][j], ret[i-1][j+l/2]);
}
}
}
return ret;
}
public static long sparseRangeGCDQ(long[][] table, int l, int r)
{
// [a,b)
if(l > r)return 1;
// 1:0, 2:1, 3:1, 4:2, 5:2, 6:2, 7:2, 8:3
int t = 31-Integer.numberOfLeadingZeros(r-l);
return gcd(table[t][l], table[t][r-(1<<t)]);
}
static class Trie {
TrieNode root;
Trie(char[][] strings) {
root = new TrieNode('A', false);
construct(root, strings);
}
public Stack<String> set(TrieNode root) {
Stack<String> set = new Stack<>();
StringBuilder sb = new StringBuilder();
for (TrieNode next : root.next)
collect(sb, next, set);
return set;
}
private void collect(StringBuilder sb, TrieNode node, Stack<String> set) {
if (node == null) return;
sb.append(node.character);
if (node.isTerminal)
set.add(sb.toString());
for (TrieNode next : node.next)
collect(sb, next, set);
if (sb.length() > 0)
sb.setLength(sb.length() - 1);
}
private void construct(TrieNode root, char[][] strings) {
// we have to construct the Trie
for (char[] string : strings) {
if (string.length == 0) continue;
root.next[string[0] - 'a'] = put(root.next[string[0] - 'a'], string, 0);
if (root.next[string[0] - 'a'] != null)
root.isLeaf = false;
}
}
private TrieNode put(TrieNode node, char[] string, int idx) {
boolean isTerminal = (idx == string.length - 1);
if (node == null) node = new TrieNode(string[idx], isTerminal);
node.character = string[idx];
node.isTerminal |= isTerminal;
if (!isTerminal) {
node.isLeaf = false;
node.next[string[idx + 1] - 'a'] = put(node.next[string[idx + 1] - 'a'], string, idx + 1);
}
return node;
}
class TrieNode {
char character;
TrieNode[] next;
boolean isTerminal, isLeaf;
boolean canWin, canLose;
TrieNode(char c, boolean isTerminallll) {
character = c;
isTerminal = isTerminallll;
next = new TrieNode[26];
isLeaf = true;
}
}
}
static class Edge implements Comparable<Edge> {
int from, to;
long weight, ans;
int id;
// int hash;
Edge(int fro, int t, long wt, int i) {
from = fro;
to = t;
id = i;
weight = wt;
// hash = Objects.hash(from, to, weight);
}
/*public int hashCode() {
return hash;
}*/
public int compareTo(Edge that) {
return Long.compare(this.id, that.id);
}
}
public static long[][] minSparseTable(long[] a)
{
int n = a.length;
int b = 32-Integer.numberOfLeadingZeros(n);
long[][] ret = new long[b][];
for(int i = 0, l = 1;i < b;i++, l*=2) {
if(i == 0) {
ret[i] = a;
}else {
ret[i] = new long[n-l+1];
for(int j = 0;j < n-l+1;j++) {
ret[i][j] = Math.min(ret[i-1][j], ret[i-1][j+l/2]);
}
}
}
return ret;
}
public static long sparseRangeMinQ(long[][] table, int l, int r)
{
// [a,b)
if(l >= r)return Integer.MAX_VALUE;
// 1:0, 2:1, 3:1, 4:2, 5:2, 6:2, 7:2, 8:3
int t = 31-Integer.numberOfLeadingZeros(r-l);
return Math.min(table[t][l], table[t][r-(1<<t)]);
}
public static long[][] maxSparseTable(long[] a)
{
int n = a.length;
int b = 32-Integer.numberOfLeadingZeros(n);
long[][] ret = new long[b][];
for(int i = 0, l = 1;i < b;i++, l*=2) {
if(i == 0) {
ret[i] = a;
}else {
ret[i] = new long[n-l+1];
for(int j = 0;j < n-l+1;j++) {
ret[i][j] = Math.max(ret[i-1][j], ret[i-1][j+l/2]);
}
}
}
return ret;
}
public static long sparseRangeMaxQ(long[][] table, int l, int r)
{
// [a,b)
if(l >= r)return Integer.MIN_VALUE;
// 1:0, 2:1, 3:1, 4:2, 5:2, 6:2, 7:2, 8:3
int t = 31-Integer.numberOfLeadingZeros(r-l);
return Math.max(table[t][l], table[t][r-(1<<t)]);
}
static class LCA {
int[] height, first, segtree;
ArrayList<Integer> euler;
boolean[] visited;
int n;
LCA(UGraph ug, int root) {
n = ug.V();
height = new int[n];
first = new int[n];
euler = new ArrayList<>();
visited = new boolean[n];
dfs(ug, root, 0);
int m = euler.size();
segtree = new int[m * 4];
build(1, 0, m - 1);
}
void dfs(UGraph ug, int node, int h) {
visited[node] = true;
height[node] = h;
first[node] = euler.size();
euler.add(node);
for (int adj : ug.adj(node)) {
if (!visited[adj]) {
dfs(ug, adj, h + 1);
euler.add(node);
}
}
}
void build(int node, int b, int e) {
if (b == e) {
segtree[node] = euler.get(b);
} else {
int mid = (b + e) / 2;
build(node << 1, b, mid);
build(node << 1 | 1, mid + 1, e);
int l = segtree[node << 1], r = segtree[node << 1 | 1];
segtree[node] = (height[l] < height[r]) ? l : r;
}
}
int query(int node, int b, int e, int L, int R) {
if (b > R || e < L)
return -1;
if (b >= L && e <= R)
return segtree[node];
int mid = (b + e) >> 1;
int left = query(node << 1, b, mid, L, R);
int right = query(node << 1 | 1, mid + 1, e, L, R);
if (left == -1) return right;
if (right == -1) return left;
return height[left] < height[right] ? left : right;
}
int lca(int u, int v) {
int left = first[u], right = first[v];
if (left > right) {
int temp = left;
left = right;
right = temp;
}
return query(1, 0, euler.size() - 1, left, right);
}
}
static class FenwickTree {
long[] array; // 1-indexed array, In this array We save cumulative information to perform efficient range queries and updates
public FenwickTree(int size) {
array = new long[size + 1];
}
public long rsq(int ind) {
assert ind > 0;
long sum = 0;
while (ind > 0) {
sum += array[ind];
//Extracting the portion up to the first significant one of the binary representation of 'ind' and decrementing ind by that number
ind -= ind & (-ind);
}
return sum;
}
public long rsq(int a, int b) {
assert b >= a && a > 0 && b > 0;
return rsq(b) - rsq(a - 1);
}
public void update(int ind, long value) {
assert ind > 0;
while (ind < array.length) {
array[ind] += value;
//Extracting the portion up to the first significant one of the binary representation of 'ind' and incrementing ind by that number
ind += ind & (-ind);
}
}
public int size() {
return array.length - 1;
}
}
static class MaxFenwickTree {
long[] array; // 1-indexed array, In this array We save cumulative information to perform efficient range queries and updates
public MaxFenwickTree(int size) {
array = new long[size + 1];
}
public long prefixMaxQuery(int upto) {
assert upto > 0;
long max = 0;
while (upto > 0) {
max = Math.max(max, array[upto]);
//Extracting the portion up to the first significant one of the binary representation of 'ind' and decrementing ind by that number
upto -= upto & (-upto);
}
return max;
}
public void update(int ind, long value) {
assert ind > 0;
while (ind < array.length) {
array[ind] = value;
//Extracting the portion up to the first significant one of the binary representation of 'ind' and incrementing ind by that number
ind += ind & (-ind);
}
}
public int size() {
return array.length - 1;
}
}
static class Point implements Comparable<Point> {
long x;
long y;
long z;
long id;
// private int hashCode;
Point() {
x = z = y = 0;
// this.hashCode = Objects.hash(x, y, cost);
}
Point(Point p) {
this.x = p.x;
this.y = p.y;
this.z = p.z;
this.id = p.id;
// this.hashCode = Objects.hash(x, y, cost);
}
Point(long x, long y, long z, long id) {
this.x = x;
this.y = y;
this.z = z;
this.id = id;
// this.hashCode = Objects.hash(x, y, id);
}
Point(long a, long b) {
this.x = a;
this.y = b;
this.z = 0;
// this.hashCode = Objects.hash(a, b);
}
Point(long x, long y, long id) {
this.x = x;
this.y = y;
this.id = id;
}
@Override
public int compareTo(Point o) {
if (this.x < o.x)
return -1;
if (this.x > o.x)
return 1;
if (this.y < o.y)
return -1;
if (this.y > o.y)
return 1;
if (this.z < o.z)
return -1;
if (this.z > o.z)
return 1;
return 0;
}
@Override
public boolean equals(Object that) {
return this.compareTo((Point) that) == 0;
}
}
static class BinaryLift {
// FUNCTIONS: k-th ancestor and LCA in log(n)
int[] parentOf;
int maxJmpPow;
int[][] binAncestorOf;
int n;
int[] lvlOf;
// How this works?
// a. For every node, we store the b-ancestor for b in {1, 2, 4, 8, .. log(n)}.
// b. When we need k-ancestor, we represent 'k' in binary and for each set bit, we
// lift level in the tree.
public BinaryLift(UGraph tree) {
n = tree.V();
maxJmpPow = logk(n, 2) + 1;
parentOf = new int[n];
binAncestorOf = new int[n][maxJmpPow];
lvlOf = new int[n];
for (int i = 0; i < n; i++)
Arrays.fill(binAncestorOf[i], -1);
parentConstruct(0, -1, tree, 0);
binConstruct();
}
// TODO: Implement lvlOf[] initialization
public BinaryLift(int[] parentOf) {
this.parentOf = parentOf;
n = parentOf.length;
maxJmpPow = logk(n, 2) + 1;
binAncestorOf = new int[n][maxJmpPow];
lvlOf = new int[n];
for (int i = 0; i < n; i++)
Arrays.fill(binAncestorOf[i], -1);
UGraph tree = new UGraph(n);
for (int i = 1; i < n; i++)
tree.addEdge(i, parentOf[i]);
binConstruct();
parentConstruct(0, -1, tree, 0);
}
private void parentConstruct(int current, int from, UGraph tree, int depth) {
parentOf[current] = from;
lvlOf[current] = depth;
for (int adj : tree.adj(current))
if (adj != from)
parentConstruct(adj, current, tree, depth + 1);
}
private void binConstruct() {
for (int node = 0; node < n; node++)
for (int lvl = 0; lvl < maxJmpPow; lvl++)
binConstruct(node, lvl);
}
private int binConstruct(int node, int lvl) {
if (node < 0)
return -1;
if (lvl == 0)
return binAncestorOf[node][lvl] = parentOf[node];
if (node == 0)
return binAncestorOf[node][lvl] = -1;
if (binAncestorOf[node][lvl] != -1)
return binAncestorOf[node][lvl];
return binAncestorOf[node][lvl] = binConstruct(binConstruct(node, lvl - 1), lvl - 1);
}
// return ancestor which is 'k' levels above this one
public int ancestor(int node, int k) {
if (node < 0)
return -1;
if (node == 0)
if (k == 0) return node;
else return -1;
if (k > (1 << maxJmpPow) - 1)
return -1;
if (k == 0)
return node;
int ancestor = node;
int highestBit = Integer.highestOneBit(k);
while (k > 0 && ancestor != -1) {
ancestor = binAncestorOf[ancestor][logk(highestBit, 2)];
k -= highestBit;
highestBit = Integer.highestOneBit(k);
}
return ancestor;
}
public int lca(int u, int v) {
if (u == v)
return u;
// The invariant will be that 'u' is below 'v' initially.
if (lvlOf[u] < lvlOf[v]) {
int temp = u;
u = v;
v = temp;
}
// Equalizing the levels.
u = ancestor(u, lvlOf[u] - lvlOf[v]);
if (u == v)
return u;
// We will now raise level by largest fitting power of two until possible.
for (int power = maxJmpPow - 1; power > -1; power--)
if (binAncestorOf[u][power] != binAncestorOf[v][power]) {
u = binAncestorOf[u][power];
v = binAncestorOf[v][power];
}
return ancestor(u, 1);
}
}
static class DFSTree {
// NOTE: The thing is made keeping in mind that the whole
// input graph is connected.
UGraph tree;
UGraph backUG;
int hasBridge;
int n;
Edge backEdge;
DFSTree(UGraph ug) {
this.n = ug.V();
tree = new UGraph(n);
hasBridge = -1;
backUG = new UGraph(n);
treeCalc(0, -1, new boolean[n], ug);
}
private void treeCalc(int current, int from, boolean[] marked, UGraph ug) {
if (marked[current]) {
// This is a backEdge.
backUG.addEdge(from, current);
backEdge = new Edge(from, current, 1, 0);
return;
}
if (from != -1)
tree.addEdge(from, current);
marked[current] = true;
for (int adj : ug.adj(current))
if (adj != from)
treeCalc(adj, current, marked, ug);
}
public boolean hasBridge() {
if (hasBridge != -1)
return (hasBridge == 1);
// We have to determine the bridge.
bridgeFinder();
return (hasBridge == 1);
}
int[] levelOf;
int[] dp;
private void bridgeFinder() {
// Finding the level of each node.
levelOf = new int[n];
levelDFS(0, -1, 0);
// Applying DP solution.
// dp[i] -> Highest level reachable from subtree of 'i' using
// some backEdge.
dp = new int[n];
Arrays.fill(dp, Integer.MAX_VALUE / 100);
dpDFS(0, -1);
// Now, we will check each edge and determine whether its a
// bridge.
for (int i = 0; i < n; i++)
for (int adj : tree.adj(i)) {
// (i -> adj) is the edge.
if (dp[adj] > levelOf[i])
hasBridge = 1;
}
if (hasBridge != 1)
hasBridge = 0;
}
private void levelDFS(int current, int from, int lvl) {
levelOf[current] = lvl;
for (int adj : tree.adj(current))
if (adj != from)
levelDFS(adj, current, lvl + 1);
}
private int dpDFS(int current, int from) {
dp[current] = levelOf[current];
for (int back : backUG.adj(current))
dp[current] = Math.min(dp[current], levelOf[back]);
for (int adj : tree.adj(current))
if (adj != from)
dp[current] = Math.min(dp[current], dpDFS(adj, current));
return dp[current];
}
}
static class UnionFind {
// Uses weighted quick-union with path compression.
private int[] parent; // parent[i] = parent of i
private int[] size; // size[i] = number of sites in tree rooted at i
// Note: not necessarily correct if i is not a root node
private int count; // number of components
public UnionFind(int n) {
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
// Number of connected components.
public int count() {
return count;
}
// Find the root of p.
public int find(int p) {
while (p != parent[p])
p = parent[p];
return p;
}
public boolean connected(int p, int q) {
return find(p) == find(q);
}
public int numConnectedTo(int node) {
return size[find(node)];
}
// Weighted union.
public void union(int p, int q) {
int rootP = find(p);
int rootQ = find(q);
if (rootP == rootQ) return;
// make smaller root point to larger one
if (size[rootP] < size[rootQ]) {
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
else {
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
count--;
}
public static int[] connectedComponents(UnionFind uf) {
// We can do this in nlogn.
int n = uf.size.length;
int[] compoColors = new int[n];
for (int i = 0; i < n; i++)
compoColors[i] = uf.find(i);
HashMap<Integer, Integer> oldToNew = new HashMap<>();
int newCtr = 0;
for (int i = 0; i < n; i++) {
int thisOldColor = compoColors[i];
Integer thisNewColor = oldToNew.get(thisOldColor);
if (thisNewColor == null)
thisNewColor = newCtr++;
oldToNew.put(thisOldColor, thisNewColor);
compoColors[i] = thisNewColor;
}
return compoColors;
}
}
static class UGraph {
// Adjacency list.
private HashSet<Integer>[] adj;
private static final String NEWLINE = "\n";
private int E;
@SuppressWarnings("unchecked")
public UGraph(int V) {
adj = (HashSet<Integer>[]) new HashSet[V];
E = 0;
for (int i = 0; i < V; i++)
adj[i] = new HashSet<Integer>();
}
public void addEdge(int from, int to) {
if (adj[from].contains(to)) return;
E++;
adj[from].add(to);
adj[to].add(from);
}
public HashSet<Integer> adj(int from) {
return adj[from];
}
public int degree(int v) {
return adj[v].size();
}
public int V() {
return adj.length;
}
public int E() {
return E;
}
public String toString() {
StringBuilder s = new StringBuilder();
s.append(V() + " vertices, " + E() + " edges " + NEWLINE);
for (int v = 0; v < V(); v++) {
s.append(v + ": ");
for (int w : adj[v]) {
s.append(w + " ");
}
s.append(NEWLINE);
}
return s.toString();
}
public static void dfsMark(int current, boolean[] marked, UGraph g) {
if (marked[current]) return;
marked[current] = true;
Iterable<Integer> adj = g.adj(current);
for (int adjc : adj)
dfsMark(adjc, marked, g);
}
public static void dfsMark(int current, int from, long[] distTo, boolean[] marked, UGraph g, ArrayList<Integer> endPoints) {
if (marked[current]) return;
marked[current] = true;
if (from != -1)
distTo[current] = distTo[from] + 1;
HashSet<Integer> adj = g.adj(current);
int alreadyMarkedCtr = 0;
for (int adjc : adj) {
if (marked[adjc]) alreadyMarkedCtr++;
dfsMark(adjc, current, distTo, marked, g, endPoints);
}
if (alreadyMarkedCtr == adj.size())
endPoints.add(current);
}
public static void bfsOrder(int current, UGraph g) {
}
public static void dfsMark(int current, int[] colorIds, int color, UGraph g) {
if (colorIds[current] != -1) return;
colorIds[current] = color;
Iterable<Integer> adj = g.adj(current);
for (int adjc : adj)
dfsMark(adjc, colorIds, color, g);
}
public static int[] connectedComponents(UGraph g) {
int n = g.V();
int[] componentId = new int[n];
Arrays.fill(componentId, -1);
int colorCtr = 0;
for (int i = 0; i < n; i++) {
if (componentId[i] != -1) continue;
dfsMark(i, componentId, colorCtr, g);
colorCtr++;
}
return componentId;
}
public static boolean hasCycle(UGraph ug) {
int n = ug.V();
boolean[] marked = new boolean[n];
boolean[] hasCycleFirst = new boolean[1];
for (int i = 0; i < n; i++) {
if (marked[i]) continue;
hcDfsMark(i, ug, marked, hasCycleFirst, -1);
}
return hasCycleFirst[0];
}
// Helper for hasCycle.
private static void hcDfsMark(int current, UGraph ug, boolean[] marked, boolean[] hasCycleFirst, int parent) {
if (marked[current]) return;
if (hasCycleFirst[0]) return;
marked[current] = true;
HashSet<Integer> adjc = ug.adj(current);
for (int adj : adjc) {
if (marked[adj] && adj != parent && parent != -1) {
hasCycleFirst[0] = true;
return;
}
hcDfsMark(adj, ug, marked, hasCycleFirst, current);
}
}
}
static class Digraph {
// Adjacency list.
private HashSet<Integer>[] adj;
private static final String NEWLINE = "\n";
private int E;
@SuppressWarnings("unchecked")
public Digraph(int V) {
adj = (HashSet<Integer>[]) new HashSet[V];
E = 0;
for (int i = 0; i < V; i++)
adj[i] = new HashSet<Integer>();
}
public void addEdge(int from, int to) {
if (adj[from].contains(to)) return;
E++;
adj[from].add(to);
}
public HashSet<Integer> adj(int from) {
return adj[from];
}
public int V() {
return adj.length;
}
public int E() {
return E;
}
public Digraph reversed() {
Digraph dg = new Digraph(V());
for (int i = 0; i < V(); i++)
for (int adjVert : adj(i)) dg.addEdge(adjVert, i);
return dg;
}
public String toString() {
StringBuilder s = new StringBuilder();
s.append(V() + " vertices, " + E() + " edges " + NEWLINE);
for (int v = 0; v < V(); v++) {
s.append(v + ": ");
for (int w : adj[v]) {
s.append(w + " ");
}
s.append(NEWLINE);
}
return s.toString();
}
public static int[] KosarajuSharirSCC(Digraph dg) {
int[] id = new int[dg.V()];
Digraph reversed = dg.reversed();
// Gotta perform topological sort on this one to get the stack.
Stack<Integer> revStack = Digraph.topologicalSort(reversed);
// Initializing id and idCtr.
id = new int[dg.V()];
int idCtr = -1;
// Creating a 'marked' array.
boolean[] marked = new boolean[dg.V()];
while (!revStack.isEmpty()) {
int vertex = revStack.pop();
if (!marked[vertex])
sccDFS(dg, vertex, marked, ++idCtr, id);
}
return id;
}
private static void sccDFS(Digraph dg, int source, boolean[] marked, int idCtr, int[] id) {
marked[source] = true;
id[source] = idCtr;
for (Integer adjVertex : dg.adj(source))
if (!marked[adjVertex]) sccDFS(dg, adjVertex, marked, idCtr, id);
}
public static Stack<Integer> topologicalSort(Digraph dg) {
// dg has to be a directed acyclic graph.
// We'll have to run dfs on the digraph and push the deepest nodes on stack first.
// We'll need a Stack<Integer> and a int[] marked.
Stack<Integer> topologicalStack = new Stack<Integer>();
boolean[] marked = new boolean[dg.V()];
// Calling dfs
for (int i = 0; i < dg.V(); i++)
if (!marked[i])
runDfs(dg, topologicalStack, marked, i);
return topologicalStack;
}
public static Stack<Integer> topologicalSort(Digraph dg, int src) {
// dg has to be a directed acyclic graph.
// We'll have to run dfs on the digraph and push the deepest nodes on stack first.
// We'll need a Stack<Integer> and a int[] marked.
Stack<Integer> topologicalStack = new Stack<Integer>();
boolean[] marked = new boolean[dg.V()];
// Calling dfs
runDfs(dg, topologicalStack, marked, src);
return topologicalStack;
}
static void runDfs(Digraph dg, Stack<Integer> topologicalStack, boolean[] marked, int source) {
marked[source] = true;
for (Integer adjVertex : dg.adj(source))
if (!marked[adjVertex])
runDfs(dg, topologicalStack, marked, adjVertex);
topologicalStack.add(source);
}
}
static class FastReader {
private BufferedReader bfr;
private StringTokenizer st;
public FastReader() {
bfr = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
if (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(bfr.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());
}
char nextChar() {
return next().toCharArray()[0];
}
String nextString() {
return next();
}
int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = nextInt();
return arr;
}
double[] nextDoubleArray(int n) {
double[] arr = new double[n];
for (int i = 0; i < arr.length; i++)
arr[i] = nextDouble();
return arr;
}
long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = nextLong();
return arr;
}
int[][] nextIntGrid(int n, int m) {
int[][] grid = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
grid[i][j] = fr.nextInt();
}
return grid;
}
}
@SuppressWarnings("serial")
static class CountMap<T> extends TreeMap<T, Integer>{
CountMap() {
}
CountMap(Comparator<T> cmp) {
}
CountMap(T[] arr) {
this.putCM(arr);
}
public Integer putCM(T key) {
return super.put(key, super.getOrDefault(key, 0) + 1);
}
public Integer removeCM(T key) {
int count = super.getOrDefault(key, -1);
if (count == -1) return -1;
if (count == 1)
return super.remove(key);
else
return super.put(key, count - 1);
}
public Integer getCM(T key) {
return super.getOrDefault(key, 0);
}
public void putCM(T[] arr) {
for (T l : arr)
this.putCM(l);
}
}
static long dioGCD(long a, long b, long[] x0, long[] y0) {
if (b == 0) {
x0[0] = 1;
y0[0] = 0;
return a;
}
long[] x1 = new long[1], y1 = new long[1];
long d = dioGCD(b, a % b, x1, y1);
x0[0] = y1[0];
y0[0] = x1[0] - y1[0] * (a / b);
return d;
}
static boolean diophantine(long a, long b, long c, long[] x0, long[] y0, long[] g) {
g[0] = dioGCD(Math.abs(a), Math.abs(b), x0, y0);
if (c % g[0] > 0) {
return false;
}
x0[0] *= c / g[0];
y0[0] *= c / g[0];
if (a < 0) x0[0] = -x0[0];
if (b < 0) y0[0] = -y0[0];
return true;
}
static long[][] prod(long[][] mat1, long[][] mat2) {
int n = mat1.length;
long[][] prod = new long[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
// determining prod[i][j]
// it will be the dot product of mat1[i][] and mat2[][i]
for (int k = 0; k < n; k++)
prod[i][j] += mat1[i][k] * mat2[k][j];
return prod;
}
static long[][] matExpo(long[][] mat, long power) {
int n = mat.length;
long[][] ans = new long[n][n];
if (power == 0)
return null;
if (power == 1)
return mat;
long[][] half = matExpo(mat, power / 2);
ans = prod(half, half);
if (power % 2 == 1) {
ans = prod(ans, mat);
}
return ans;
}
static int KMPNumOcc(char[] text, char[] pat) {
int n = text.length;
int m = pat.length;
char[] patPlusText = new char[n + m + 1];
for (int i = 0; i < m; i++)
patPlusText[i] = pat[i];
patPlusText[m] = '^'; // Seperator
for (int i = 0; i < n; i++)
patPlusText[m + i] = text[i];
int[] fullPi = piCalcKMP(patPlusText);
int answer = 0;
for (int i = 0; i < n + m + 1; i++)
if (fullPi[i] == m)
answer++;
return answer;
}
static int[] piCalcKMP(char[] s) {
int n = s.length;
int[] pi = new int[n];
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j])
j = pi[j - 1];
if (s[i] == s[j])
j++;
pi[i] = j;
}
return pi;
}
static boolean[] prefMatchesSuff(char[] s) {
int n = s.length;
boolean[] res = new boolean[n + 1];
int[] pi = prefix_function(s);
res[0] = true;
for (int p = n; p != 0; p = pi[p])
res[p] = true;
return res;
}
static int[] prefix_function(char[] s) {
int n = s.length;
int[] pi = new int[n];
for (int i = 1; i < n; i++) {
int j = pi[i-1];
while (j > 0 && s[i] != s[j])
j = pi[j-1];
if (s[i] == s[j])
j++;
pi[i] = j;
}
return pi;
}
static long hash(long key) {
long h = Long.hashCode(key);
h ^= (h >>> 20) ^ (h >>> 12) ^ (h >>> 7) ^ (h >>> 4);
return h & (gigamod-1);
}
static void Yes() {out.println("Yes");}static void YES() {out.println("YES");}static void yes() {out.println("Yes");}static void No() {out.println("No");}static void NO() {out.println("NO");}static void no() {out.println("no");}
static int mapTo1D(int row, int col, int n, int m) {
// Maps elements in a 2D matrix serially to elements in
// a 1D array.
return row * m + col;
}
static int[] mapTo2D(int idx, int n, int m) {
// Inverse of what the one above does.
int[] rnc = new int[2];
rnc[0] = idx / m;
rnc[1] = idx % m;
return rnc;
}
static long mapTo1D(long row, long col, long n, long m) {
// Maps elements in a 2D matrix serially to elements in
// a 1D array.
return row * m + col;
}
static boolean[] primeGenerator(int upto) {
// Sieve of Eratosthenes:
isPrime = new boolean[upto + 1];
smallestFactorOf = new int[upto + 1];
Arrays.fill(smallestFactorOf, 1);
Arrays.fill(isPrime, true);
isPrime[1] = isPrime[0] = false;
for (long i = 2; i < upto + 1; i++)
if (isPrime[(int) i]) {
smallestFactorOf[(int) i] = (int) i;
// Mark all the multiples greater than or equal
// to the square of i to be false.
for (long j = i; j * i < upto + 1; j++) {
if (isPrime[(int) j * (int) i]) {
isPrime[(int) j * (int) i] = false;
smallestFactorOf[(int) j * (int) i] = (int) i;
}
}
}
return isPrime;
}
static HashMap<Integer, Integer> smolNumPrimeFactorization(int num) {
if (smallestFactorOf == null)
primeGenerator(num + 1);
HashMap<Integer, Integer> fnps = new HashMap<>();
while (num != 1) {
fnps.put(smallestFactorOf[num], fnps.getOrDefault(smallestFactorOf[num], 0) + 1);
num /= smallestFactorOf[num];
}
return fnps;
}
static HashMap<Long, Integer> primeFactorization(long num) {
if (isPrime == null)
smolNumPrimeFactorization((int) 1e5);
// Returns map of factor and its power in the number.
HashMap<Long, Integer> map = new HashMap<>();
while (num % 2 == 0) {
num /= 2;
Integer pwrCnt = map.get(2L);
map.put(2L, pwrCnt != null ? pwrCnt + 1 : 1);
}
for (long i = 3; i * i <= num; i += 2) {
while (num % i == 0 && isPrime[(int) i]) {
num /= i;
Integer pwrCnt = map.get(i);
map.put(i, pwrCnt != null ? pwrCnt + 1 : 1);
}
}
// If the number is prime, we have to add it to the
// map.
if (num != 1)
map.put(num, 1);
return map;
}
static HashSet<Long> divisors(long num) {
HashSet<Long> divisors = new HashSet<Long>();
divisors.add(1L);
divisors.add(num);
for (long i = 2; i * i <= num; i++) {
if (num % i == 0) {
divisors.add(num/i);
divisors.add(i);
}
}
return divisors;
}
static void coprimeGenerator(int m, int n, ArrayList<Point> coprimes, int limit, int numCoprimes) {
if (m > limit) return;
if (m <= limit && n <= limit)
coprimes.add(new Point(m, n));
if (coprimes.size() > numCoprimes) return;
coprimeGenerator(2 * m - n, m, coprimes, limit, numCoprimes);
coprimeGenerator(2 * m + n, m, coprimes, limit, numCoprimes);
coprimeGenerator(m + 2 * n, n, coprimes, limit, numCoprimes);
}
static long nCr(long n, long r, long[] fac) { long p = mod; if (r == 0) return 1; return (fac[(int)n] * modInverse(fac[(int)r], p) % p * modInverse(fac[(int)n - (int)r], p) % p) % p; }
static long modInverse(long n, long p) { return power(n, p - 2, p); }
static long modDiv(long a, long b){return mod(a * power(b, mod - 2, mod), mod);}
static long power(long x, long y, long p) { long res = 1; x = x % p; while (y > 0) { if ((y & 1)==1) res = (res * x) % p; y = y >> 1; x = (x * x) % p; } return res; }
static int logk(long n, long k) { return (int)(Math.log(n) / Math.log(k)); }
static long gcd(long a, long b) { if (b == 0) { return a; } else { return gcd(b, a % b); } } static int gcd(int a, int b) { if (b == 0) { return a; } else { return gcd(b, a % b); } } static long gcd(long[] arr) { int n = arr.length; long gcd = arr[0]; for (int i = 1; i < n; i++) { gcd = gcd(gcd, arr[i]); } return gcd; } static int gcd(int[] arr) { int n = arr.length; int gcd = arr[0]; for (int i = 1; i < n; i++) { gcd = gcd(gcd, arr[i]); } return gcd; } static long lcm(long[] arr) { long lcm = arr[0]; int n = arr.length; for (int i = 1; i < n; i++) { lcm = (lcm * arr[i]) / gcd(lcm, arr[i]); } return lcm; } static long lcm(long a, long b) { return (a * b)/gcd(a, b); } static boolean less(int a, int b) { return a < b ? true : false; } static boolean isSorted(int[] a) { for (int i = 1; i < a.length; i++) { if (less(a[i], a[i - 1])) return false; } return true; } static boolean isSorted(long[] a) { for (int i = 1; i < a.length; i++) { if (a[i] < a[i - 1]) return false; } return true; } static void swap(int[] a, int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } static void swap(long[] a, int i, int j) { long temp = a[i]; a[i] = a[j]; a[j] = temp; } static void swap(double[] a, int i, int j) { double temp = a[i]; a[i] = a[j]; a[j] = temp; } static void swap(char[] a, int i, int j) { char temp = a[i]; a[i] = a[j]; a[j] = temp; }
static void sort(int[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void sort(char[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void sort(long[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void sort(double[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void reverseSort(int[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverseSort(char[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverse(char[] arr) { int n = arr.length; for (int i = 0; i < n / 2; i++) swap(arr, i, n - 1 - i); } static void reverseSort(long[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverseSort(double[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverse(int[] arr) { int n = arr.length; for (int i = 0; i < n / 2; i++) swap(arr, i, n - 1 - i); }
static void shuffleArray(long[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { long tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } } static void shuffleArray(int[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { int tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } }
static void shuffleArray(double[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { double tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } }
static void shuffleArray(char[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { char tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } }
static boolean isPrime(long n) {if (n<=1)return false;if(n<=3)return true;if(n%2==0||n%3==0)return false;for(long i=5;i*i<=n;i=i+6)if(n%i==0||n%(i+2)==0)return false;return true;}
static String toString(int[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+" ");return sb.toString();}
static String toString(boolean[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+" ");return sb.toString();}
static String toString(long[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+" ");return sb.toString();}
static String toString(char[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+"");return sb.toString();}
static String toString(int[][] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++){for(int j=0;j<dp[i].length;j++){sb.append(dp[i][j]+" ");}sb.append('\n');}return sb.toString();}
static String toString(long[][] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++){for(int j=0;j<dp[i].length;j++) {sb.append(dp[i][j]+" ");}sb.append('\n');}return sb.toString();}
static String toString(double[][] dp){StringBuilder sb=new StringBuilder();for(int i = 0;i<dp.length;i++){for(int j = 0;j<dp[i].length;j++){sb.append(dp[i][j]+" ");}sb.append('\n');}return sb.toString();}
static String toString(char[][] dp){StringBuilder sb = new StringBuilder();for(int i = 0;i<dp.length;i++){for(int j = 0;j<dp[i].length;j++){sb.append(dp[i][j]+"");}sb.append('\n');}return sb.toString();}
static long mod(long a, long m){return(a%m+1000000L*m)%m;}
}
/*
*
* int[] arr = new int[] {1810, 1700, 1710, 2320, 2000, 1785, 1780
, 2130, 2185, 1430, 1460, 1740, 1860, 1100, 1905, 1650};
int n = arr.length;
sort(arr);
int bel1700 = 0, bet1700n1900 = 0, abv1900 = 0;
for (int i = 0; i < n; i++)
if (arr[i] < 1700)
bel1700++;
else if (1700 <= arr[i] && arr[i] < 1900)
bet1700n1900++;
else if (arr[i] >= 1900)
abv1900++;
out.println("COUNT: " + n);
out.println("PERFS: " + toString(arr));
out.println("MEDIAN: " + arr[n / 2]);
out.println("AVERAGE: " + Arrays.stream(arr).average().getAsDouble());
out.println("[0, 1700): " + bel1700 + "/" + n);
out.println("[1700, 1900): " + bet1700n1900 + "/" + n);
out.println("[1900, 2400): " + abv1900 + "/" + n);
*
* */
// NOTES:
// ASCII VALUE OF 'A': 65
// ASCII VALUE OF 'a': 97
// Range of long: 9 * 10^18
// ASCII VALUE OF '0': 48
// Primes upto 'n' can be given by (n / (logn)).
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
public final class Main {
static FastReader fr = new FastReader();
static PrintWriter out = new PrintWriter(System.out);
static final int gigamod = 1000000007;
static final int mod = 998244353;
static int t = 1;
static boolean[] isPrime;
static int[] smallestFactorOf;
static final int UP = 0, LEFT = 1, DOWN = 2, RIGHT = 3;
static int cmp;
static long[] twoPow;
static int sz = 5;
@SuppressWarnings({"unused"})
public static void main(String[] args) throws Exception {
OUTER:
for (int tc = 0; tc < t; tc++) {
int n = fr.nextInt();
int[] arr = fr.nextIntArray(n);
Digraph dg = new Digraph(n);
for (int i = 0; i < n; i++)
dg.addEdge(i, arr[i] - 1);
// every node which is the part of some cycle is
// a winning node for us
boolean[] marked = new boolean[n];
boolean[] onStack = new boolean[n];
boolean[] isAns = new boolean[n];
for (int i = 0; i < n; i++)
if (!marked[i])
dfs(i, dg, marked, onStack, isAns, new int[] {-1});
int ans = 0;
for (boolean b : isAns)
if (b)
ans++;
out.println(ans);
}
out.close();
}
static void dfs(int current, Digraph dg, boolean[] marked, boolean[] onStack, boolean[] isAns, int[] curseNode) {
if (onStack[current]) {
// this is the part of some cycle
isAns[current] = true;
curseNode[0] = current;
return;
}
if (marked[current]) return; // this node was processed earlier
marked[current] = true;
onStack[current] = true;
for (int adj : dg.adj(current)) {
dfs(adj, dg, marked, onStack, isAns, curseNode);
if (isAns[adj] && curseNode[0] != -1)
isAns[current] = true;
}
if (curseNode[0] == current)
curseNode[0] = -1;
onStack[current] = false;
}
static int nn;
static int[] arr;
static int[] treeSum;
static int[] treeMinPrefSum;
static int[] lazy;
static void init(int n, int[] brr) {
nn = n;
arr = brr.clone();
treeSum = new int[4 * nn];
lazy = new int[4 * nn];
treeMinPrefSum = new int[4 * nn];
build(1, 0, nn - 1);
}
static void build(int node, int left, int right) {
if (left == right) {
treeSum[node] = arr[left];
treeMinPrefSum[node] = arr[left];
return;
}
int mid = (left + right) >> 1;
build((node<<1), left, mid);
build((node<<1|1), mid + 1, right);
treeSum[node] = treeSum[node<<1] + treeSum[node<<1|1];
}
static void flip(int node, int left, int right, int idx) {
if (left == right) {
treeSum[node] = -treeSum[node];
return;
}
if (idx < left || idx > right) return;
int mid = (left + right) >> 1;
flip((node<<1), left, mid, idx);
flip((node<<1|1), mid + 1, right, idx);
}
/*static int nn;
static int[] arr;
static int[] tree;
static int[] lazy;
static void build(int node, int leftt, int rightt) {
if (leftt == rightt) {
tree[node] = arr[leftt];
return;
}
int mid = (leftt + rightt) >> 1;
build(node << 1, leftt, mid);
build(node << 1 | 1, mid + 1, rightt);
tree[node] = Math.min(tree[node << 1], tree[node << 1 | 1]);
}
static void segAdd(int node, int leftt, int rightt, int segL, int segR, int val) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (leftt != rightt) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
}
lazy[node] = 0;
}
if (segL > rightt || segR < leftt) return;
if (segL <= leftt && rightt <= segR) {
tree[node] += val;
if (leftt != rightt) {
lazy[node << 1] += val;
lazy[node << 1 | 1] += val;
}
lazy[node] = 0;
return;
}
int mid = (leftt + rightt) >> 1;
segAdd(node << 1, leftt, mid, segL, segR, val);
segAdd(node << 1 | 1, mid + 1, rightt, segL, segR, val);
tree[node] = Math.min(tree[node << 1], tree[node << 1 | 1]);
}
static int minQuery(int node, int leftt, int rightt, int segL, int segR) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (leftt != rightt) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
}
lazy[node] = 0;
}
if (segL > rightt || segR < leftt) return Integer.MAX_VALUE / 10;
if (segL <= leftt && rightt <= segR)
return tree[node];
int mid = (leftt + rightt) >> 1;
return Math.min(minQuery(node << 1, leftt, mid, segL, segR),
minQuery(node << 1 | 1, mid + 1, rightt, segL, segR));
}
*/
static void compute_automaton(String s, int[][] aut) {
s += '#';
int n = s.length();
int[] pi = prefix_function(s.toCharArray());
for (int i = 0; i < n; i++) {
for (int c = 0; c < 26; c++) {
int j = i;
while (j > 0 && 'A' + c != s.charAt(j))
j = pi[j-1];
if ('A' + c == s.charAt(j))
j++;
aut[i][c] = j;
}
}
}
static void timeDFS(int current, int from, UGraph ug,
int[] time, int[] tIn, int[] tOut) {
tIn[current] = ++time[0];
for (int adj : ug.adj(current))
if (adj != from)
timeDFS(adj, current, ug, time, tIn, tOut);
tOut[current] = ++time[0];
}
static boolean areCollinear(long x1, long y1, long x2, long y2, long x3, long y3) {
// we will check if c3 lies on line through (c1, c2)
long a = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
return a == 0;
}
static int[] treeDiameter(UGraph ug) {
int n = ug.V();
int farthest = -1;
int[] distTo = new int[n];
diamDFS(0, -1, 0, ug, distTo);
int maxDist = -1;
for (int i = 0; i < n; i++)
if (maxDist < distTo[i]) {
maxDist = distTo[i];
farthest = i;
}
distTo = new int[n + 1];
diamDFS(farthest, -1, 0, ug, distTo);
distTo[n] = farthest;
return distTo;
}
static void diamDFS(int current, int from, int dist, UGraph ug, int[] distTo) {
distTo[current] = dist;
for (int adj : ug.adj(current))
if (adj != from)
diamDFS(adj, current, dist + 1, ug, distTo);
}
static class TreeDistFinder {
UGraph ug;
int n;
int[] depthOf;
LCA lca;
TreeDistFinder(UGraph ug) {
this.ug = ug;
n = ug.V();
depthOf = new int[n];
depthCalc(0, -1, ug, 0, depthOf);
lca = new LCA(ug, 0);
}
TreeDistFinder(UGraph ug, int a) {
this.ug = ug;
n = ug.V();
depthOf = new int[n];
depthCalc(a, -1, ug, 0, depthOf);
lca = new LCA(ug, a);
}
private void depthCalc(int current, int from, UGraph ug, int depth, int[] depthOf) {
depthOf[current] = depth;
for (int adj : ug.adj(current))
if (adj != from)
depthCalc(adj, current, ug, depth + 1, depthOf);
}
public int dist(int a, int b) {
int lc = lca.lca(a, b);
return (depthOf[a] - depthOf[lc] + depthOf[b] - depthOf[lc]);
}
}
public static long[][] GCDSparseTable(long[] a)
{
int n = a.length;
int b = 32-Integer.numberOfLeadingZeros(n);
long[][] ret = new long[b][];
for(int i = 0, l = 1;i < b;i++, l*=2) {
if(i == 0) {
ret[i] = a;
} else {
ret[i] = new long[n-l+1];
for(int j = 0;j < n-l+1;j++) {
ret[i][j] = gcd(ret[i-1][j], ret[i-1][j+l/2]);
}
}
}
return ret;
}
public static long sparseRangeGCDQ(long[][] table, int l, int r)
{
// [a,b)
if(l > r)return 1;
// 1:0, 2:1, 3:1, 4:2, 5:2, 6:2, 7:2, 8:3
int t = 31-Integer.numberOfLeadingZeros(r-l);
return gcd(table[t][l], table[t][r-(1<<t)]);
}
static class Trie {
TrieNode root;
Trie(char[][] strings) {
root = new TrieNode('A', false);
construct(root, strings);
}
public Stack<String> set(TrieNode root) {
Stack<String> set = new Stack<>();
StringBuilder sb = new StringBuilder();
for (TrieNode next : root.next)
collect(sb, next, set);
return set;
}
private void collect(StringBuilder sb, TrieNode node, Stack<String> set) {
if (node == null) return;
sb.append(node.character);
if (node.isTerminal)
set.add(sb.toString());
for (TrieNode next : node.next)
collect(sb, next, set);
if (sb.length() > 0)
sb.setLength(sb.length() - 1);
}
private void construct(TrieNode root, char[][] strings) {
// we have to construct the Trie
for (char[] string : strings) {
if (string.length == 0) continue;
root.next[string[0] - 'a'] = put(root.next[string[0] - 'a'], string, 0);
if (root.next[string[0] - 'a'] != null)
root.isLeaf = false;
}
}
private TrieNode put(TrieNode node, char[] string, int idx) {
boolean isTerminal = (idx == string.length - 1);
if (node == null) node = new TrieNode(string[idx], isTerminal);
node.character = string[idx];
node.isTerminal |= isTerminal;
if (!isTerminal) {
node.isLeaf = false;
node.next[string[idx + 1] - 'a'] = put(node.next[string[idx + 1] - 'a'], string, idx + 1);
}
return node;
}
class TrieNode {
char character;
TrieNode[] next;
boolean isTerminal, isLeaf;
boolean canWin, canLose;
TrieNode(char c, boolean isTerminallll) {
character = c;
isTerminal = isTerminallll;
next = new TrieNode[26];
isLeaf = true;
}
}
}
static class Edge implements Comparable<Edge> {
int from, to;
long weight, ans;
int id;
// int hash;
Edge(int fro, int t, long wt, int i) {
from = fro;
to = t;
id = i;
weight = wt;
// hash = Objects.hash(from, to, weight);
}
/*public int hashCode() {
return hash;
}*/
public int compareTo(Edge that) {
return Long.compare(this.id, that.id);
}
}
public static long[][] minSparseTable(long[] a)
{
int n = a.length;
int b = 32-Integer.numberOfLeadingZeros(n);
long[][] ret = new long[b][];
for(int i = 0, l = 1;i < b;i++, l*=2) {
if(i == 0) {
ret[i] = a;
}else {
ret[i] = new long[n-l+1];
for(int j = 0;j < n-l+1;j++) {
ret[i][j] = Math.min(ret[i-1][j], ret[i-1][j+l/2]);
}
}
}
return ret;
}
public static long sparseRangeMinQ(long[][] table, int l, int r)
{
// [a,b)
if(l >= r)return Integer.MAX_VALUE;
// 1:0, 2:1, 3:1, 4:2, 5:2, 6:2, 7:2, 8:3
int t = 31-Integer.numberOfLeadingZeros(r-l);
return Math.min(table[t][l], table[t][r-(1<<t)]);
}
public static long[][] maxSparseTable(long[] a)
{
int n = a.length;
int b = 32-Integer.numberOfLeadingZeros(n);
long[][] ret = new long[b][];
for(int i = 0, l = 1;i < b;i++, l*=2) {
if(i == 0) {
ret[i] = a;
}else {
ret[i] = new long[n-l+1];
for(int j = 0;j < n-l+1;j++) {
ret[i][j] = Math.max(ret[i-1][j], ret[i-1][j+l/2]);
}
}
}
return ret;
}
public static long sparseRangeMaxQ(long[][] table, int l, int r)
{
// [a,b)
if(l >= r)return Integer.MIN_VALUE;
// 1:0, 2:1, 3:1, 4:2, 5:2, 6:2, 7:2, 8:3
int t = 31-Integer.numberOfLeadingZeros(r-l);
return Math.max(table[t][l], table[t][r-(1<<t)]);
}
static class LCA {
int[] height, first, segtree;
ArrayList<Integer> euler;
boolean[] visited;
int n;
LCA(UGraph ug, int root) {
n = ug.V();
height = new int[n];
first = new int[n];
euler = new ArrayList<>();
visited = new boolean[n];
dfs(ug, root, 0);
int m = euler.size();
segtree = new int[m * 4];
build(1, 0, m - 1);
}
void dfs(UGraph ug, int node, int h) {
visited[node] = true;
height[node] = h;
first[node] = euler.size();
euler.add(node);
for (int adj : ug.adj(node)) {
if (!visited[adj]) {
dfs(ug, adj, h + 1);
euler.add(node);
}
}
}
void build(int node, int b, int e) {
if (b == e) {
segtree[node] = euler.get(b);
} else {
int mid = (b + e) / 2;
build(node << 1, b, mid);
build(node << 1 | 1, mid + 1, e);
int l = segtree[node << 1], r = segtree[node << 1 | 1];
segtree[node] = (height[l] < height[r]) ? l : r;
}
}
int query(int node, int b, int e, int L, int R) {
if (b > R || e < L)
return -1;
if (b >= L && e <= R)
return segtree[node];
int mid = (b + e) >> 1;
int left = query(node << 1, b, mid, L, R);
int right = query(node << 1 | 1, mid + 1, e, L, R);
if (left == -1) return right;
if (right == -1) return left;
return height[left] < height[right] ? left : right;
}
int lca(int u, int v) {
int left = first[u], right = first[v];
if (left > right) {
int temp = left;
left = right;
right = temp;
}
return query(1, 0, euler.size() - 1, left, right);
}
}
static class FenwickTree {
long[] array; // 1-indexed array, In this array We save cumulative information to perform efficient range queries and updates
public FenwickTree(int size) {
array = new long[size + 1];
}
public long rsq(int ind) {
assert ind > 0;
long sum = 0;
while (ind > 0) {
sum += array[ind];
//Extracting the portion up to the first significant one of the binary representation of 'ind' and decrementing ind by that number
ind -= ind & (-ind);
}
return sum;
}
public long rsq(int a, int b) {
assert b >= a && a > 0 && b > 0;
return rsq(b) - rsq(a - 1);
}
public void update(int ind, long value) {
assert ind > 0;
while (ind < array.length) {
array[ind] += value;
//Extracting the portion up to the first significant one of the binary representation of 'ind' and incrementing ind by that number
ind += ind & (-ind);
}
}
public int size() {
return array.length - 1;
}
}
static class MaxFenwickTree {
long[] array; // 1-indexed array, In this array We save cumulative information to perform efficient range queries and updates
public MaxFenwickTree(int size) {
array = new long[size + 1];
}
public long prefixMaxQuery(int upto) {
assert upto > 0;
long max = 0;
while (upto > 0) {
max = Math.max(max, array[upto]);
//Extracting the portion up to the first significant one of the binary representation of 'ind' and decrementing ind by that number
upto -= upto & (-upto);
}
return max;
}
public void update(int ind, long value) {
assert ind > 0;
while (ind < array.length) {
array[ind] = value;
//Extracting the portion up to the first significant one of the binary representation of 'ind' and incrementing ind by that number
ind += ind & (-ind);
}
}
public int size() {
return array.length - 1;
}
}
static class Point implements Comparable<Point> {
long x;
long y;
long z;
long id;
// private int hashCode;
Point() {
x = z = y = 0;
// this.hashCode = Objects.hash(x, y, cost);
}
Point(Point p) {
this.x = p.x;
this.y = p.y;
this.z = p.z;
this.id = p.id;
// this.hashCode = Objects.hash(x, y, cost);
}
Point(long x, long y, long z, long id) {
this.x = x;
this.y = y;
this.z = z;
this.id = id;
// this.hashCode = Objects.hash(x, y, id);
}
Point(long a, long b) {
this.x = a;
this.y = b;
this.z = 0;
// this.hashCode = Objects.hash(a, b);
}
Point(long x, long y, long id) {
this.x = x;
this.y = y;
this.id = id;
}
@Override
public int compareTo(Point o) {
if (this.x < o.x)
return -1;
if (this.x > o.x)
return 1;
if (this.y < o.y)
return -1;
if (this.y > o.y)
return 1;
if (this.z < o.z)
return -1;
if (this.z > o.z)
return 1;
return 0;
}
@Override
public boolean equals(Object that) {
return this.compareTo((Point) that) == 0;
}
}
static class BinaryLift {
// FUNCTIONS: k-th ancestor and LCA in log(n)
int[] parentOf;
int maxJmpPow;
int[][] binAncestorOf;
int n;
int[] lvlOf;
// How this works?
// a. For every node, we store the b-ancestor for b in {1, 2, 4, 8, .. log(n)}.
// b. When we need k-ancestor, we represent 'k' in binary and for each set bit, we
// lift level in the tree.
public BinaryLift(UGraph tree) {
n = tree.V();
maxJmpPow = logk(n, 2) + 1;
parentOf = new int[n];
binAncestorOf = new int[n][maxJmpPow];
lvlOf = new int[n];
for (int i = 0; i < n; i++)
Arrays.fill(binAncestorOf[i], -1);
parentConstruct(0, -1, tree, 0);
binConstruct();
}
// TODO: Implement lvlOf[] initialization
public BinaryLift(int[] parentOf) {
this.parentOf = parentOf;
n = parentOf.length;
maxJmpPow = logk(n, 2) + 1;
binAncestorOf = new int[n][maxJmpPow];
lvlOf = new int[n];
for (int i = 0; i < n; i++)
Arrays.fill(binAncestorOf[i], -1);
UGraph tree = new UGraph(n);
for (int i = 1; i < n; i++)
tree.addEdge(i, parentOf[i]);
binConstruct();
parentConstruct(0, -1, tree, 0);
}
private void parentConstruct(int current, int from, UGraph tree, int depth) {
parentOf[current] = from;
lvlOf[current] = depth;
for (int adj : tree.adj(current))
if (adj != from)
parentConstruct(adj, current, tree, depth + 1);
}
private void binConstruct() {
for (int node = 0; node < n; node++)
for (int lvl = 0; lvl < maxJmpPow; lvl++)
binConstruct(node, lvl);
}
private int binConstruct(int node, int lvl) {
if (node < 0)
return -1;
if (lvl == 0)
return binAncestorOf[node][lvl] = parentOf[node];
if (node == 0)
return binAncestorOf[node][lvl] = -1;
if (binAncestorOf[node][lvl] != -1)
return binAncestorOf[node][lvl];
return binAncestorOf[node][lvl] = binConstruct(binConstruct(node, lvl - 1), lvl - 1);
}
// return ancestor which is 'k' levels above this one
public int ancestor(int node, int k) {
if (node < 0)
return -1;
if (node == 0)
if (k == 0) return node;
else return -1;
if (k > (1 << maxJmpPow) - 1)
return -1;
if (k == 0)
return node;
int ancestor = node;
int highestBit = Integer.highestOneBit(k);
while (k > 0 && ancestor != -1) {
ancestor = binAncestorOf[ancestor][logk(highestBit, 2)];
k -= highestBit;
highestBit = Integer.highestOneBit(k);
}
return ancestor;
}
public int lca(int u, int v) {
if (u == v)
return u;
// The invariant will be that 'u' is below 'v' initially.
if (lvlOf[u] < lvlOf[v]) {
int temp = u;
u = v;
v = temp;
}
// Equalizing the levels.
u = ancestor(u, lvlOf[u] - lvlOf[v]);
if (u == v)
return u;
// We will now raise level by largest fitting power of two until possible.
for (int power = maxJmpPow - 1; power > -1; power--)
if (binAncestorOf[u][power] != binAncestorOf[v][power]) {
u = binAncestorOf[u][power];
v = binAncestorOf[v][power];
}
return ancestor(u, 1);
}
}
static class DFSTree {
// NOTE: The thing is made keeping in mind that the whole
// input graph is connected.
UGraph tree;
UGraph backUG;
int hasBridge;
int n;
Edge backEdge;
DFSTree(UGraph ug) {
this.n = ug.V();
tree = new UGraph(n);
hasBridge = -1;
backUG = new UGraph(n);
treeCalc(0, -1, new boolean[n], ug);
}
private void treeCalc(int current, int from, boolean[] marked, UGraph ug) {
if (marked[current]) {
// This is a backEdge.
backUG.addEdge(from, current);
backEdge = new Edge(from, current, 1, 0);
return;
}
if (from != -1)
tree.addEdge(from, current);
marked[current] = true;
for (int adj : ug.adj(current))
if (adj != from)
treeCalc(adj, current, marked, ug);
}
public boolean hasBridge() {
if (hasBridge != -1)
return (hasBridge == 1);
// We have to determine the bridge.
bridgeFinder();
return (hasBridge == 1);
}
int[] levelOf;
int[] dp;
private void bridgeFinder() {
// Finding the level of each node.
levelOf = new int[n];
levelDFS(0, -1, 0);
// Applying DP solution.
// dp[i] -> Highest level reachable from subtree of 'i' using
// some backEdge.
dp = new int[n];
Arrays.fill(dp, Integer.MAX_VALUE / 100);
dpDFS(0, -1);
// Now, we will check each edge and determine whether its a
// bridge.
for (int i = 0; i < n; i++)
for (int adj : tree.adj(i)) {
// (i -> adj) is the edge.
if (dp[adj] > levelOf[i])
hasBridge = 1;
}
if (hasBridge != 1)
hasBridge = 0;
}
private void levelDFS(int current, int from, int lvl) {
levelOf[current] = lvl;
for (int adj : tree.adj(current))
if (adj != from)
levelDFS(adj, current, lvl + 1);
}
private int dpDFS(int current, int from) {
dp[current] = levelOf[current];
for (int back : backUG.adj(current))
dp[current] = Math.min(dp[current], levelOf[back]);
for (int adj : tree.adj(current))
if (adj != from)
dp[current] = Math.min(dp[current], dpDFS(adj, current));
return dp[current];
}
}
static class UnionFind {
// Uses weighted quick-union with path compression.
private int[] parent; // parent[i] = parent of i
private int[] size; // size[i] = number of sites in tree rooted at i
// Note: not necessarily correct if i is not a root node
private int count; // number of components
public UnionFind(int n) {
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
// Number of connected components.
public int count() {
return count;
}
// Find the root of p.
public int find(int p) {
while (p != parent[p])
p = parent[p];
return p;
}
public boolean connected(int p, int q) {
return find(p) == find(q);
}
public int numConnectedTo(int node) {
return size[find(node)];
}
// Weighted union.
public void union(int p, int q) {
int rootP = find(p);
int rootQ = find(q);
if (rootP == rootQ) return;
// make smaller root point to larger one
if (size[rootP] < size[rootQ]) {
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
else {
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
count--;
}
public static int[] connectedComponents(UnionFind uf) {
// We can do this in nlogn.
int n = uf.size.length;
int[] compoColors = new int[n];
for (int i = 0; i < n; i++)
compoColors[i] = uf.find(i);
HashMap<Integer, Integer> oldToNew = new HashMap<>();
int newCtr = 0;
for (int i = 0; i < n; i++) {
int thisOldColor = compoColors[i];
Integer thisNewColor = oldToNew.get(thisOldColor);
if (thisNewColor == null)
thisNewColor = newCtr++;
oldToNew.put(thisOldColor, thisNewColor);
compoColors[i] = thisNewColor;
}
return compoColors;
}
}
static class UGraph {
// Adjacency list.
private HashSet<Integer>[] adj;
private static final String NEWLINE = "\n";
private int E;
@SuppressWarnings("unchecked")
public UGraph(int V) {
adj = (HashSet<Integer>[]) new HashSet[V];
E = 0;
for (int i = 0; i < V; i++)
adj[i] = new HashSet<Integer>();
}
public void addEdge(int from, int to) {
if (adj[from].contains(to)) return;
E++;
adj[from].add(to);
adj[to].add(from);
}
public HashSet<Integer> adj(int from) {
return adj[from];
}
public int degree(int v) {
return adj[v].size();
}
public int V() {
return adj.length;
}
public int E() {
return E;
}
public String toString() {
StringBuilder s = new StringBuilder();
s.append(V() + " vertices, " + E() + " edges " + NEWLINE);
for (int v = 0; v < V(); v++) {
s.append(v + ": ");
for (int w : adj[v]) {
s.append(w + " ");
}
s.append(NEWLINE);
}
return s.toString();
}
public static void dfsMark(int current, boolean[] marked, UGraph g) {
if (marked[current]) return;
marked[current] = true;
Iterable<Integer> adj = g.adj(current);
for (int adjc : adj)
dfsMark(adjc, marked, g);
}
public static void dfsMark(int current, int from, long[] distTo, boolean[] marked, UGraph g, ArrayList<Integer> endPoints) {
if (marked[current]) return;
marked[current] = true;
if (from != -1)
distTo[current] = distTo[from] + 1;
HashSet<Integer> adj = g.adj(current);
int alreadyMarkedCtr = 0;
for (int adjc : adj) {
if (marked[adjc]) alreadyMarkedCtr++;
dfsMark(adjc, current, distTo, marked, g, endPoints);
}
if (alreadyMarkedCtr == adj.size())
endPoints.add(current);
}
public static void bfsOrder(int current, UGraph g) {
}
public static void dfsMark(int current, int[] colorIds, int color, UGraph g) {
if (colorIds[current] != -1) return;
colorIds[current] = color;
Iterable<Integer> adj = g.adj(current);
for (int adjc : adj)
dfsMark(adjc, colorIds, color, g);
}
public static int[] connectedComponents(UGraph g) {
int n = g.V();
int[] componentId = new int[n];
Arrays.fill(componentId, -1);
int colorCtr = 0;
for (int i = 0; i < n; i++) {
if (componentId[i] != -1) continue;
dfsMark(i, componentId, colorCtr, g);
colorCtr++;
}
return componentId;
}
public static boolean hasCycle(UGraph ug) {
int n = ug.V();
boolean[] marked = new boolean[n];
boolean[] hasCycleFirst = new boolean[1];
for (int i = 0; i < n; i++) {
if (marked[i]) continue;
hcDfsMark(i, ug, marked, hasCycleFirst, -1);
}
return hasCycleFirst[0];
}
// Helper for hasCycle.
private static void hcDfsMark(int current, UGraph ug, boolean[] marked, boolean[] hasCycleFirst, int parent) {
if (marked[current]) return;
if (hasCycleFirst[0]) return;
marked[current] = true;
HashSet<Integer> adjc = ug.adj(current);
for (int adj : adjc) {
if (marked[adj] && adj != parent && parent != -1) {
hasCycleFirst[0] = true;
return;
}
hcDfsMark(adj, ug, marked, hasCycleFirst, current);
}
}
}
static class Digraph {
// Adjacency list.
private HashSet<Integer>[] adj;
private static final String NEWLINE = "\n";
private int E;
@SuppressWarnings("unchecked")
public Digraph(int V) {
adj = (HashSet<Integer>[]) new HashSet[V];
E = 0;
for (int i = 0; i < V; i++)
adj[i] = new HashSet<Integer>();
}
public void addEdge(int from, int to) {
if (adj[from].contains(to)) return;
E++;
adj[from].add(to);
}
public HashSet<Integer> adj(int from) {
return adj[from];
}
public int V() {
return adj.length;
}
public int E() {
return E;
}
public Digraph reversed() {
Digraph dg = new Digraph(V());
for (int i = 0; i < V(); i++)
for (int adjVert : adj(i)) dg.addEdge(adjVert, i);
return dg;
}
public String toString() {
StringBuilder s = new StringBuilder();
s.append(V() + " vertices, " + E() + " edges " + NEWLINE);
for (int v = 0; v < V(); v++) {
s.append(v + ": ");
for (int w : adj[v]) {
s.append(w + " ");
}
s.append(NEWLINE);
}
return s.toString();
}
public static int[] KosarajuSharirSCC(Digraph dg) {
int[] id = new int[dg.V()];
Digraph reversed = dg.reversed();
// Gotta perform topological sort on this one to get the stack.
Stack<Integer> revStack = Digraph.topologicalSort(reversed);
// Initializing id and idCtr.
id = new int[dg.V()];
int idCtr = -1;
// Creating a 'marked' array.
boolean[] marked = new boolean[dg.V()];
while (!revStack.isEmpty()) {
int vertex = revStack.pop();
if (!marked[vertex])
sccDFS(dg, vertex, marked, ++idCtr, id);
}
return id;
}
private static void sccDFS(Digraph dg, int source, boolean[] marked, int idCtr, int[] id) {
marked[source] = true;
id[source] = idCtr;
for (Integer adjVertex : dg.adj(source))
if (!marked[adjVertex]) sccDFS(dg, adjVertex, marked, idCtr, id);
}
public static Stack<Integer> topologicalSort(Digraph dg) {
// dg has to be a directed acyclic graph.
// We'll have to run dfs on the digraph and push the deepest nodes on stack first.
// We'll need a Stack<Integer> and a int[] marked.
Stack<Integer> topologicalStack = new Stack<Integer>();
boolean[] marked = new boolean[dg.V()];
// Calling dfs
for (int i = 0; i < dg.V(); i++)
if (!marked[i])
runDfs(dg, topologicalStack, marked, i);
return topologicalStack;
}
public static Stack<Integer> topologicalSort(Digraph dg, int src) {
// dg has to be a directed acyclic graph.
// We'll have to run dfs on the digraph and push the deepest nodes on stack first.
// We'll need a Stack<Integer> and a int[] marked.
Stack<Integer> topologicalStack = new Stack<Integer>();
boolean[] marked = new boolean[dg.V()];
// Calling dfs
runDfs(dg, topologicalStack, marked, src);
return topologicalStack;
}
static void runDfs(Digraph dg, Stack<Integer> topologicalStack, boolean[] marked, int source) {
marked[source] = true;
for (Integer adjVertex : dg.adj(source))
if (!marked[adjVertex])
runDfs(dg, topologicalStack, marked, adjVertex);
topologicalStack.add(source);
}
}
static class FastReader {
private BufferedReader bfr;
private StringTokenizer st;
public FastReader() {
bfr = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
if (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(bfr.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());
}
char nextChar() {
return next().toCharArray()[0];
}
String nextString() {
return next();
}
int[] nextIntArray(int n) {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = nextInt();
return arr;
}
double[] nextDoubleArray(int n) {
double[] arr = new double[n];
for (int i = 0; i < arr.length; i++)
arr[i] = nextDouble();
return arr;
}
long[] nextLongArray(int n) {
long[] arr = new long[n];
for (int i = 0; i < n; i++)
arr[i] = nextLong();
return arr;
}
int[][] nextIntGrid(int n, int m) {
int[][] grid = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
grid[i][j] = fr.nextInt();
}
return grid;
}
}
@SuppressWarnings("serial")
static class CountMap<T> extends TreeMap<T, Integer>{
CountMap() {
}
CountMap(Comparator<T> cmp) {
}
CountMap(T[] arr) {
this.putCM(arr);
}
public Integer putCM(T key) {
return super.put(key, super.getOrDefault(key, 0) + 1);
}
public Integer removeCM(T key) {
int count = super.getOrDefault(key, -1);
if (count == -1) return -1;
if (count == 1)
return super.remove(key);
else
return super.put(key, count - 1);
}
public Integer getCM(T key) {
return super.getOrDefault(key, 0);
}
public void putCM(T[] arr) {
for (T l : arr)
this.putCM(l);
}
}
static long dioGCD(long a, long b, long[] x0, long[] y0) {
if (b == 0) {
x0[0] = 1;
y0[0] = 0;
return a;
}
long[] x1 = new long[1], y1 = new long[1];
long d = dioGCD(b, a % b, x1, y1);
x0[0] = y1[0];
y0[0] = x1[0] - y1[0] * (a / b);
return d;
}
static boolean diophantine(long a, long b, long c, long[] x0, long[] y0, long[] g) {
g[0] = dioGCD(Math.abs(a), Math.abs(b), x0, y0);
if (c % g[0] > 0) {
return false;
}
x0[0] *= c / g[0];
y0[0] *= c / g[0];
if (a < 0) x0[0] = -x0[0];
if (b < 0) y0[0] = -y0[0];
return true;
}
static long[][] prod(long[][] mat1, long[][] mat2) {
int n = mat1.length;
long[][] prod = new long[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
// determining prod[i][j]
// it will be the dot product of mat1[i][] and mat2[][i]
for (int k = 0; k < n; k++)
prod[i][j] += mat1[i][k] * mat2[k][j];
return prod;
}
static long[][] matExpo(long[][] mat, long power) {
int n = mat.length;
long[][] ans = new long[n][n];
if (power == 0)
return null;
if (power == 1)
return mat;
long[][] half = matExpo(mat, power / 2);
ans = prod(half, half);
if (power % 2 == 1) {
ans = prod(ans, mat);
}
return ans;
}
static int KMPNumOcc(char[] text, char[] pat) {
int n = text.length;
int m = pat.length;
char[] patPlusText = new char[n + m + 1];
for (int i = 0; i < m; i++)
patPlusText[i] = pat[i];
patPlusText[m] = '^'; // Seperator
for (int i = 0; i < n; i++)
patPlusText[m + i] = text[i];
int[] fullPi = piCalcKMP(patPlusText);
int answer = 0;
for (int i = 0; i < n + m + 1; i++)
if (fullPi[i] == m)
answer++;
return answer;
}
static int[] piCalcKMP(char[] s) {
int n = s.length;
int[] pi = new int[n];
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j])
j = pi[j - 1];
if (s[i] == s[j])
j++;
pi[i] = j;
}
return pi;
}
static boolean[] prefMatchesSuff(char[] s) {
int n = s.length;
boolean[] res = new boolean[n + 1];
int[] pi = prefix_function(s);
res[0] = true;
for (int p = n; p != 0; p = pi[p])
res[p] = true;
return res;
}
static int[] prefix_function(char[] s) {
int n = s.length;
int[] pi = new int[n];
for (int i = 1; i < n; i++) {
int j = pi[i-1];
while (j > 0 && s[i] != s[j])
j = pi[j-1];
if (s[i] == s[j])
j++;
pi[i] = j;
}
return pi;
}
static long hash(long key) {
long h = Long.hashCode(key);
h ^= (h >>> 20) ^ (h >>> 12) ^ (h >>> 7) ^ (h >>> 4);
return h & (gigamod-1);
}
static void Yes() {out.println("Yes");}static void YES() {out.println("YES");}static void yes() {out.println("Yes");}static void No() {out.println("No");}static void NO() {out.println("NO");}static void no() {out.println("no");}
static int mapTo1D(int row, int col, int n, int m) {
// Maps elements in a 2D matrix serially to elements in
// a 1D array.
return row * m + col;
}
static int[] mapTo2D(int idx, int n, int m) {
// Inverse of what the one above does.
int[] rnc = new int[2];
rnc[0] = idx / m;
rnc[1] = idx % m;
return rnc;
}
static long mapTo1D(long row, long col, long n, long m) {
// Maps elements in a 2D matrix serially to elements in
// a 1D array.
return row * m + col;
}
static boolean[] primeGenerator(int upto) {
// Sieve of Eratosthenes:
isPrime = new boolean[upto + 1];
smallestFactorOf = new int[upto + 1];
Arrays.fill(smallestFactorOf, 1);
Arrays.fill(isPrime, true);
isPrime[1] = isPrime[0] = false;
for (long i = 2; i < upto + 1; i++)
if (isPrime[(int) i]) {
smallestFactorOf[(int) i] = (int) i;
// Mark all the multiples greater than or equal
// to the square of i to be false.
for (long j = i; j * i < upto + 1; j++) {
if (isPrime[(int) j * (int) i]) {
isPrime[(int) j * (int) i] = false;
smallestFactorOf[(int) j * (int) i] = (int) i;
}
}
}
return isPrime;
}
static HashMap<Integer, Integer> smolNumPrimeFactorization(int num) {
if (smallestFactorOf == null)
primeGenerator(num + 1);
HashMap<Integer, Integer> fnps = new HashMap<>();
while (num != 1) {
fnps.put(smallestFactorOf[num], fnps.getOrDefault(smallestFactorOf[num], 0) + 1);
num /= smallestFactorOf[num];
}
return fnps;
}
static HashMap<Long, Integer> primeFactorization(long num) {
if (isPrime == null)
smolNumPrimeFactorization((int) 1e5);
// Returns map of factor and its power in the number.
HashMap<Long, Integer> map = new HashMap<>();
while (num % 2 == 0) {
num /= 2;
Integer pwrCnt = map.get(2L);
map.put(2L, pwrCnt != null ? pwrCnt + 1 : 1);
}
for (long i = 3; i * i <= num; i += 2) {
while (num % i == 0 && isPrime[(int) i]) {
num /= i;
Integer pwrCnt = map.get(i);
map.put(i, pwrCnt != null ? pwrCnt + 1 : 1);
}
}
// If the number is prime, we have to add it to the
// map.
if (num != 1)
map.put(num, 1);
return map;
}
static HashSet<Long> divisors(long num) {
HashSet<Long> divisors = new HashSet<Long>();
divisors.add(1L);
divisors.add(num);
for (long i = 2; i * i <= num; i++) {
if (num % i == 0) {
divisors.add(num/i);
divisors.add(i);
}
}
return divisors;
}
static void coprimeGenerator(int m, int n, ArrayList<Point> coprimes, int limit, int numCoprimes) {
if (m > limit) return;
if (m <= limit && n <= limit)
coprimes.add(new Point(m, n));
if (coprimes.size() > numCoprimes) return;
coprimeGenerator(2 * m - n, m, coprimes, limit, numCoprimes);
coprimeGenerator(2 * m + n, m, coprimes, limit, numCoprimes);
coprimeGenerator(m + 2 * n, n, coprimes, limit, numCoprimes);
}
static long nCr(long n, long r, long[] fac) { long p = mod; if (r == 0) return 1; return (fac[(int)n] * modInverse(fac[(int)r], p) % p * modInverse(fac[(int)n - (int)r], p) % p) % p; }
static long modInverse(long n, long p) { return power(n, p - 2, p); }
static long modDiv(long a, long b){return mod(a * power(b, mod - 2, mod), mod);}
static long power(long x, long y, long p) { long res = 1; x = x % p; while (y > 0) { if ((y & 1)==1) res = (res * x) % p; y = y >> 1; x = (x * x) % p; } return res; }
static int logk(long n, long k) { return (int)(Math.log(n) / Math.log(k)); }
static long gcd(long a, long b) { if (b == 0) { return a; } else { return gcd(b, a % b); } } static int gcd(int a, int b) { if (b == 0) { return a; } else { return gcd(b, a % b); } } static long gcd(long[] arr) { int n = arr.length; long gcd = arr[0]; for (int i = 1; i < n; i++) { gcd = gcd(gcd, arr[i]); } return gcd; } static int gcd(int[] arr) { int n = arr.length; int gcd = arr[0]; for (int i = 1; i < n; i++) { gcd = gcd(gcd, arr[i]); } return gcd; } static long lcm(long[] arr) { long lcm = arr[0]; int n = arr.length; for (int i = 1; i < n; i++) { lcm = (lcm * arr[i]) / gcd(lcm, arr[i]); } return lcm; } static long lcm(long a, long b) { return (a * b)/gcd(a, b); } static boolean less(int a, int b) { return a < b ? true : false; } static boolean isSorted(int[] a) { for (int i = 1; i < a.length; i++) { if (less(a[i], a[i - 1])) return false; } return true; } static boolean isSorted(long[] a) { for (int i = 1; i < a.length; i++) { if (a[i] < a[i - 1]) return false; } return true; } static void swap(int[] a, int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } static void swap(long[] a, int i, int j) { long temp = a[i]; a[i] = a[j]; a[j] = temp; } static void swap(double[] a, int i, int j) { double temp = a[i]; a[i] = a[j]; a[j] = temp; } static void swap(char[] a, int i, int j) { char temp = a[i]; a[i] = a[j]; a[j] = temp; }
static void sort(int[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void sort(char[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void sort(long[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void sort(double[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); } static void reverseSort(int[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverseSort(char[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverse(char[] arr) { int n = arr.length; for (int i = 0; i < n / 2; i++) swap(arr, i, n - 1 - i); } static void reverseSort(long[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverseSort(double[] arr) { shuffleArray(arr, 0, arr.length - 1); Arrays.sort(arr); int n = arr.length; for (int i = 0; i < n/2; i++) swap(arr, i, n - 1 - i); } static void reverse(int[] arr) { int n = arr.length; for (int i = 0; i < n / 2; i++) swap(arr, i, n - 1 - i); }
static void shuffleArray(long[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { long tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } } static void shuffleArray(int[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { int tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } }
static void shuffleArray(double[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { double tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } }
static void shuffleArray(char[] arr, int startPos, int endPos) { Random rnd = new Random(); for (int i = startPos; i < endPos; ++i) { char tmp = arr[i]; int randomPos = i + rnd.nextInt(endPos - i); arr[i] = arr[randomPos]; arr[randomPos] = tmp; } }
static boolean isPrime(long n) {if (n<=1)return false;if(n<=3)return true;if(n%2==0||n%3==0)return false;for(long i=5;i*i<=n;i=i+6)if(n%i==0||n%(i+2)==0)return false;return true;}
static String toString(int[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+" ");return sb.toString();}
static String toString(boolean[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+" ");return sb.toString();}
static String toString(long[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+" ");return sb.toString();}
static String toString(char[] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++)sb.append(dp[i]+"");return sb.toString();}
static String toString(int[][] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++){for(int j=0;j<dp[i].length;j++){sb.append(dp[i][j]+" ");}sb.append('\n');}return sb.toString();}
static String toString(long[][] dp){StringBuilder sb=new StringBuilder();for(int i=0;i<dp.length;i++){for(int j=0;j<dp[i].length;j++) {sb.append(dp[i][j]+" ");}sb.append('\n');}return sb.toString();}
static String toString(double[][] dp){StringBuilder sb=new StringBuilder();for(int i = 0;i<dp.length;i++){for(int j = 0;j<dp[i].length;j++){sb.append(dp[i][j]+" ");}sb.append('\n');}return sb.toString();}
static String toString(char[][] dp){StringBuilder sb = new StringBuilder();for(int i = 0;i<dp.length;i++){for(int j = 0;j<dp[i].length;j++){sb.append(dp[i][j]+"");}sb.append('\n');}return sb.toString();}
static long mod(long a, long m){return(a%m+1000000L*m)%m;}
}
/*
*
* int[] arr = new int[] {1810, 1700, 1710, 2320, 2000, 1785, 1780
, 2130, 2185, 1430, 1460, 1740, 1860, 1100, 1905, 1650};
int n = arr.length;
sort(arr);
int bel1700 = 0, bet1700n1900 = 0, abv1900 = 0;
for (int i = 0; i < n; i++)
if (arr[i] < 1700)
bel1700++;
else if (1700 <= arr[i] && arr[i] < 1900)
bet1700n1900++;
else if (arr[i] >= 1900)
abv1900++;
out.println("COUNT: " + n);
out.println("PERFS: " + toString(arr));
out.println("MEDIAN: " + arr[n / 2]);
out.println("AVERAGE: " + Arrays.stream(arr).average().getAsDouble());
out.println("[0, 1700): " + bel1700 + "/" + n);
out.println("[1700, 1900): " + bet1700n1900 + "/" + n);
out.println("[1900, 2400): " + abv1900 + "/" + n);
*
* */
// NOTES:
// ASCII VALUE OF 'A': 65
// ASCII VALUE OF 'a': 97
// Range of long: 9 * 10^18
// ASCII VALUE OF '0': 48
// Primes upto 'n' can be given by (n / (logn)).
|
ConDefects/ConDefects/Code/abc296_e/Java/40274411
|
condefects-java_data_560
|
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
public static int psi(String n) {
return Integer.parseInt(n);
}
public static long psl(String n) {
return Long.parseLong(n);
}
public static String str_int(int n) {
return String.valueOf(n);
}
public static String str_lg(long n) {
return String.valueOf(n);
}
public static void main(String[] args) throws java.lang.Exception {
BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
// int t = psi(rd.readLine());
// while (t-- > 0) {
int n = psi(rd.readLine());
String [] a1 = rd.readLine().split(" ");
int [] a = new int[n];
for (int i = 0; i < n; i++) a[i] = psi(a1[i]);
int [] arr = new int[n];
int cnt = 1;
int cnt_cycles = 0;
for (int i = 0; i < n; i++) {
if (arr[i] != 0) continue;
int ind = i;
boolean is_cycle = false;
while (true) {
if (arr[ind] == cnt) {
is_cycle = true;
break;
}
if (arr[ind] != 0) break;
arr[ind] = cnt;
if (a[ind] - 1 == ind) break;
ind = a[ind] - 1;
}
if (!is_cycle) {
cnt++;
continue;
}
while (arr[ind] != -1) {
arr[ind] = -1;
ind = a[ind] - 1;
}
cnt_cycles++;
cnt++;
}
if (cnt_cycles > 0) {
int ans = 0;
for (int i = 0; i< n; i++) {
if (arr[i] == -1) ans++;
if (i + 1 == a[i]) ans++;
}
out.println(ans);
} else {
cnt = 1;
int [] arr1 = new int[n];
for (int i = 0; i < n; i++) {
if (arr1[i] != 0) continue;
int ind = i;
while (arr1[ind] == 0) {
arr1[ind] = cnt;
ind = a[ind] - 1;
}
int color = arr1[ind];
ind = i;
while (arr1[ind] != color) {
arr1[ind] = color;
ind = a[ind] - 1;
}
cnt++;
}
Arrays.sort(arr1);
int cnt_colors = 1;
for (int i = 1; i < n; i++) {
cnt_colors += (arr1[i] != arr[i - 1]) ? 1 : 0;
}
out.println(cnt_colors);
}
// }
out.flush();
}
}
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
public static int psi(String n) {
return Integer.parseInt(n);
}
public static long psl(String n) {
return Long.parseLong(n);
}
public static String str_int(int n) {
return String.valueOf(n);
}
public static String str_lg(long n) {
return String.valueOf(n);
}
public static void main(String[] args) throws java.lang.Exception {
BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
// int t = psi(rd.readLine());
// while (t-- > 0) {
int n = psi(rd.readLine());
String [] a1 = rd.readLine().split(" ");
int [] a = new int[n];
for (int i = 0; i < n; i++) a[i] = psi(a1[i]);
int [] arr = new int[n];
int cnt = 1;
int cnt_cycles = 0;
for (int i = 0; i < n; i++) {
if (arr[i] != 0) continue;
int ind = i;
boolean is_cycle = false;
while (true) {
if (arr[ind] == cnt) {
is_cycle = true;
break;
}
if (arr[ind] != 0) break;
arr[ind] = cnt;
if (a[ind] - 1 == ind) break;
ind = a[ind] - 1;
}
if (!is_cycle) {
cnt++;
continue;
}
while (arr[ind] != -1) {
arr[ind] = -1;
ind = a[ind] - 1;
}
cnt_cycles++;
cnt++;
}
if (cnt_cycles > 0) {
int ans = 0;
for (int i = 0; i< n; i++) {
if (arr[i] == -1) ans++;
if (i + 1 == a[i]) ans++;
}
out.println(ans);
} else {
cnt = 1;
int [] arr1 = new int[n];
for (int i = 0; i < n; i++) {
if (arr1[i] != 0) continue;
int ind = i;
while (arr1[ind] == 0) {
arr1[ind] = cnt;
ind = a[ind] - 1;
}
int color = arr1[ind];
ind = i;
while (arr1[ind] != color) {
arr1[ind] = color;
ind = a[ind] - 1;
}
cnt++;
}
Arrays.sort(arr1);
int cnt_colors = 1;
for (int i = 1; i < n; i++) {
cnt_colors += (arr1[i] != arr1[i - 1]) ? 1 : 0;
}
out.println(cnt_colors);
}
// }
out.flush();
}
}
|
ConDefects/ConDefects/Code/abc296_e/Java/40321886
|
condefects-java_data_561
|
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int M = sc.nextInt();
int D = sc.nextInt();
int y = sc.nextInt();
int m = sc.nextInt();
int d = sc.nextInt();
if(d>=D){
m++;
d = 1;
} else {
d++;
}
if(m>=M){
y++;
m = 1;
}
System.out.println(y + " " + m + " " + d);
}
}
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int M = sc.nextInt();
int D = sc.nextInt();
int y = sc.nextInt();
int m = sc.nextInt();
int d = sc.nextInt();
if(d>=D){
m++;
d = 1;
} else {
d++;
}
if(m>M){
y++;
m = 1;
}
System.out.println(y + " " + m + " " + d);
}
}
|
ConDefects/ConDefects/Code/abc331_a/Java/49383644
|
condefects-java_data_562
|
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int M = sc.nextInt();
int D = sc.nextInt();
int year = sc.nextInt();
int month = sc.nextInt();
int day = sc.nextInt();
day++;
if(day > D){
month++;
if(month > M){
year++;
}
}
System.out.println(year + " " + month + " " + day);
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int M = sc.nextInt();
int D = sc.nextInt();
int year = sc.nextInt();
int month = sc.nextInt();
int day = sc.nextInt();
day++;
if(day > D){
month++;
day = 1;
if(month > M){
year++;
month = 1;
}
}
System.out.println(year + " " + month + " " + day);
}
}
|
ConDefects/ConDefects/Code/abc331_a/Java/50271765
|
condefects-java_data_563
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int d = sc.nextInt();
int y = sc.nextInt();
int month = sc.nextInt();
int day = sc.nextInt();
if (day == d) {
if (month == 12) {
month = 1;
y += 1;
} else {
month += 1;
}
day = 1;
} else {
day += 1;
}
System.out.println(y + " " + month + " " + day);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int d = sc.nextInt();
int y = sc.nextInt();
int month = sc.nextInt();
int day = sc.nextInt();
if (day == d) {
if (month == m) {
month = 1;
y += 1;
} else {
month += 1;
}
day = 1;
} else {
day += 1;
}
System.out.println(y + " " + month + " " + day);
}
}
|
ConDefects/ConDefects/Code/abc331_a/Java/53463032
|
condefects-java_data_564
|
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
int day = sc.nextInt();
int y = sc.nextInt();
int m = sc.nextInt();
int d = sc.nextInt();
if(day == d){
if(month == m){
System.out.println((y + 1) + " " + "1 " + "1");
}else{
System.out.println(y +" " + (m + 1) +" " + "1" );
}
}else{
System.out.println(y + " " + (m + 1) + " " + (d + 1));
}
}
}
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
int day = sc.nextInt();
int y = sc.nextInt();
int m = sc.nextInt();
int d = sc.nextInt();
if(day == d){
if(month == m){
System.out.println((y + 1) + " " + "1 " + "1");
}else{
System.out.println(y +" " + (m + 1) +" " + "1" );
}
}else{
System.out.println(y + " " + m + " " + (d + 1));
}
}
}
|
ConDefects/ConDefects/Code/abc331_a/Java/53716675
|
condefects-java_data_565
|
import java.util.*;
import java.math.*;
class node
{
int x,y;
public node(int x, int y) {
this.x = x;
this.y = y;
}
}
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int n=sc.nextInt(),m=sc.nextInt();
int[] a = new int[n];
Long ans=0L;
for(int i=0;i<n;i++){
a[i]=sc.nextInt();
ans=ans+a[i];
}
int[] b = new int [m];
int[] c = new int [m];
for(int i=0;i<m;i++)
b[i]=sc.nextInt();
for(int i=0;i<m;i++)
c[i]=sc.nextInt();
List<node> li = new ArrayList<>();
for(int i=0;i<m;i++)
li.add(new node(b[i],c[i]));
li.sort((x,y)->{
if(x.x!=y.x)
return y.x-x.x;
else
return y.y-y.x;
});
Arrays.sort(a);
PriorityQueue<Integer> qu= new PriorityQueue<>();
int pos=0;
int p=li.size();
for(int i=n-1;i>=0;i--)
{
if(pos>=p)
break;
int pp=pos;
while(pos<p && li.get(pos).x>a[i])
{
pos++;
}
if(!qu.isEmpty()) {
for (int j = pp; j < pos; j++)
if (li.get(j).y > qu.peek()) {
// ans =ans - (li.get(j).y - qu.peek());
qu.add(li.get(j).y);
qu.poll();
}
}
if(pos==p)
continue;
qu.add(li.get(pos).y);
// ans=ans-li.get(pos).y;
pos++;
}
while(!qu.isEmpty())
{
ans-=qu.peek();
qu.poll();
}
System.out.println(ans);
}
}
/*
10 5
9 7 1 5 2 2 5 5 7 6
7 2 7 8 2
3 2 4 1 2
3 3
4 1 1
4 4 3
2 1 3
3 3
4 1 1
4 2 1
1 2 1
*/
import java.util.*;
import java.math.*;
class node
{
int x,y;
public node(int x, int y) {
this.x = x;
this.y = y;
}
}
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int n=sc.nextInt(),m=sc.nextInt();
int[] a = new int[n];
Long ans=0L;
for(int i=0;i<n;i++){
a[i]=sc.nextInt();
ans=ans+a[i];
}
int[] b = new int [m];
int[] c = new int [m];
for(int i=0;i<m;i++)
b[i]=sc.nextInt();
for(int i=0;i<m;i++)
c[i]=sc.nextInt();
List<node> li = new ArrayList<>();
for(int i=0;i<m;i++)
li.add(new node(b[i],c[i]));
li.sort((x,y)->{
if(x.x!=y.x)
return y.x-x.x;
else
return y.y-x.y;
});
Arrays.sort(a);
PriorityQueue<Integer> qu= new PriorityQueue<>();
int pos=0;
int p=li.size();
for(int i=n-1;i>=0;i--)
{
if(pos>=p)
break;
int pp=pos;
while(pos<p && li.get(pos).x>a[i])
{
pos++;
}
if(!qu.isEmpty()) {
for (int j = pp; j < pos; j++)
if (li.get(j).y > qu.peek()) {
// ans =ans - (li.get(j).y - qu.peek());
qu.add(li.get(j).y);
qu.poll();
}
}
if(pos==p)
continue;
qu.add(li.get(pos).y);
// ans=ans-li.get(pos).y;
pos++;
}
while(!qu.isEmpty())
{
ans-=qu.peek();
qu.poll();
}
System.out.println(ans);
}
}
/*
10 5
9 7 1 5 2 2 5 5 7 6
7 2 7 8 2
3 2 4 1 2
3 3
4 1 1
4 4 3
2 1 3
3 3
4 1 1
4 2 1
1 2 1
*/
|
ConDefects/ConDefects/Code/abc308_f/Java/43950351
|
condefects-java_data_566
|
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
private static boolean DEBUG;
public static void main(final String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
@Override
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
public static final class FastInputStream {
private static final int BUF_SIZE = 1 << 14;
private final InputStream in;
private final byte buf[] = new byte[BUF_SIZE];
private int pos = 0;
private int count = 0;
private static final int TOKEN_SIZE = 1 << 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
public FastInputStream(final InputStream in) {
this.in = in;
}
private final void readBuf() {
pos = 0;
try { count = in.read(buf); }
catch(IOException e) { e.printStackTrace(); }
}
private final boolean hasNextByte() {
if(pos < count) return true;
readBuf();
return count > 0;
}
private final byte read() { if(hasNextByte()) return buf[pos ++]; else throw new NoSuchElementException(); }
private final boolean isPrintableChar(final byte c) { return 33 <= c && c <= 126; }
private final boolean isNumber(final byte c) { return 48 <= c && c <= 57; }
private final void skipUnprintable() {
while(true) {
for(int i = pos; i < count; i ++) {
if(isPrintableChar(buf[i])) { pos = i; return; }
}
readBuf();
if(count <= 0) throw new NoSuchElementException();
}
}
private final boolean readEOL() {
if(!hasNextByte()) return true;
if(buf[pos] == 13) {
pos ++;
if(hasNextByte() && buf[pos] == 10) pos ++;
return true;
}
if(buf[pos] == 10) {
pos ++;
return true;
}
return false;
}
public final char nextChar() {
skipUnprintable();
return (char)buf[pos ++];
}
public final String next() {
skipUnprintable();
int tokenCount = 0;
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
tokenBuf[tokenCount ++] = b;
}
readBuf();
}
return new String(tokenBuf, 0, tokenCount);
}
public final String nextLine() {
readEOL();
if(!hasNextByte()) throw new NoSuchElementException();
int tokenCount = 0;
while(!readEOL()) tokenBuf[tokenCount ++] = read();
return new String(tokenBuf, 0, tokenCount);
}
public final int nextInt() {
skipUnprintable();
int n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 214748364) throw new ArithmeticException("int overflow");
if(n == - 214748364 && b > 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 214748364) throw new ArithmeticException("int overflow");
if(n == 214748364 && b >= 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final long nextLong() {
skipUnprintable();
long n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == - 922337203685477580l && b > 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == 922337203685477580l && b >= 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final double nextDouble() { return Double.parseDouble(next()); }
public final void close() {
try { in.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class FastOutputStream {
private static final int BUF_SIZE = 1 << 13;
private final byte buf[] = new byte[BUF_SIZE];
private final OutputStream out;
private int count = 0;
private static final byte TRUE_BYTES[] = {116, 114, 117, 101};
private static final byte FALSE_BYTES[] = {102, 97, 108, 115, 101};
private static final byte INT_MIN_BYTES[] = {45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 56};
private static final byte LONG_MIN_BYTES[] = {45, 57, 50, 50, 51, 51, 55, 50, 48, 51,
54, 56, 53, 52, 55, 55, 53, 56, 48, 56};
private static final int TOKEN_SIZE = 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
private static final int PRECISION = 10;
public FastOutputStream(OutputStream out) {
this.out = out;
}
public final void print() { }
public final void write(final byte b) {
if(count == BUF_SIZE) internalFlush();
buf[count ++] = b;
}
public final void print(final char c) { write((byte) c); }
public final void print(final boolean b) {
if(b) {
if(count + 4 > BUF_SIZE) internalFlush();
System.arraycopy(TRUE_BYTES, 0, buf, count, TRUE_BYTES.length);
count += TRUE_BYTES.length;
}else {
if(count + 5 > BUF_SIZE) internalFlush();
System.arraycopy(FALSE_BYTES, 0, buf, count, FALSE_BYTES.length);
count += FALSE_BYTES.length;
}
}
public final void print(int x) {
if(count + 11 > BUF_SIZE) internalFlush();
if(x == Integer.MIN_VALUE) {
System.arraycopy(INT_MIN_BYTES, 0, buf, count, INT_MIN_BYTES.length);
count += INT_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 11;
while(x > 0) {
final int y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 11 - tokenCount);
count += 11 - tokenCount;
}
public final void print(long x) {
if(count + 20 > BUF_SIZE) internalFlush();
if(x == Long.MIN_VALUE) {
System.arraycopy(LONG_MIN_BYTES, 0, buf, count, LONG_MIN_BYTES.length);
count += LONG_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 20;
while(x > 0) {
final long y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 20 - tokenCount);
count += 20 - tokenCount;
}
public final void print(final double d) { print(d, PRECISION); }
public final void print(double d, final int precision) {
if(count == BUF_SIZE) internalFlush();
if(d < 0) {
buf[count ++] = 45;
d = - d;
}
d += Math.pow(10, - precision) / 2;
print((long)d);
if(precision == 0) return;
if(count + precision + 1 > BUF_SIZE) internalFlush();
buf[count ++] = 46;
d -= (long)d;
for(int i = 0; i < precision; i ++) {
d *= 10;
buf[count ++] = (byte)((int)d + 48);
d -= (int) d;
}
}
public final void print(final String s) { print(s.getBytes()); }
public final void print(final Object o) { print(o.toString()); }
public final void print(final byte[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
System.arraycopy(a, 0, buf, count, a.length);
count += a.length;
}
public final void print(final char[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
for(int i = 0; i < a.length; i ++) buf[count + i] = (byte)a[i];
count += a.length;
}
public final void println() { print('\n'); }
public final void println(final char c) { print(c); println(); }
public final void println(final boolean b) { print(b); println(); }
public final void println(final int x) { print(x); println(); }
public final void println(final long x) { print(x); println(); }
public final void println(final double d) { print(d); println(); }
public final void println(final double d, final int precision) { print(d, precision); println(); }
public final void println(final String s) { print(s); println(); }
public final void println(final Object o) { print(o); println(); }
public final void println(final char[] a) { print(a); println(); }
public final void println(final int[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final long[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a, final int precision) {
for(int i = 0; i < a.length; i ++) {
print(a[i], precision);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final String[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final Object[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
private final void internalFlush() {
try {
out.write(buf, 0, count);
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void flush() {
try {
out.write(buf, 0, count);
out.flush();
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void close() {
try { out.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class Solver {
private static final FastInputStream in = new FastInputStream(System.in);
public Solver() { }
private static final String nline() { return in.nextLine(); }
private static final String[] nline(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = nline(); return a; }
private static final char nc() { return in.nextChar(); }
private static final char[] nc(int n) {
final String str = ns();
if(n < 0) n = str.length();
final char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
private static final char[][] nc(final int n, final int m) { final char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
private static final boolean[] nb(int n, final char t) {
final char c[] = nc(-1);
if(n < 0) n = c.length;
final boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
private static final boolean[][] nb(final int n, final int m, final char t) { final boolean a[][] = new boolean[n][]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
private static final int ni() { return in.nextInt(); }
private static final int[] ni(final int n) { final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
private static final int[][] ni(final int n, final int m) { final int a[][] = new int[n][]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
private static final long nl() { return in.nextLong(); }
private static final long[] nl(final int n) { final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
private static final long[][] nl(final int n, final int m) { final long a[][] = new long[n][]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
private static final double nd() { return in.nextDouble(); }
private static final double[] nd(final int n) { final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
private static final double[][] nd(final int n, final int m) { final double a[][] = new double[n][]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
private static final String ns() { return in.next(); }
private static final String[] ns(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(); return a; }
private static final String[][] ns(final int n, final int m) { final String a[][] = new String[n][]; for(int i = 0; i < n; i ++) a[i] = ns(m); return a; }
private static final char booleanToChar(final boolean b) { return b ? '#' : '.'; }
private static final char[] booleanToChar(final boolean... a) {
final char c[] = new char[a.length];
for(int i = 0; i < a.length; i ++) c[i] = booleanToChar(a[i]);
return c;
}
private static final FastOutputStream out = new FastOutputStream(System.out);
private static final FastOutputStream err = new FastOutputStream(System.err);
private static final void prt() { out.print(); }
private static final void prt(final char c) { out.print(c); }
private static final void prt(final boolean b) { out.print(b); }
private static final void prt(final int x) { out.print(x); }
private static final void prt(final long x) { out.print(x); }
private static final void prt(final double d) { out.print(d); }
private static final void prt(final String s) { out.print(s); }
private static final void prt(final Object o) { out.print(o); }
private static final void prtln() { out.println(); }
private static final void prtln(final char c) { out.println(c); }
private static final void prtln(final boolean b) { out.println(b); }
private static final void prtln(final int x) { out.println(x); }
private static final void prtln(final long x) { out.println(x); }
private static final void prtln(final double d) { out.println(d); }
private static final void prtln(final String s) { out.println(s); }
private static final void prtln(final Object o) { out.println(o); }
private static final void prtln(final char... a) { out.println(a); }
private static final void prtln(final boolean... a) { out.println(booleanToChar(a)); }
private static final void prtln(final int... a) { out.println(a); }
private static final void prtln(final long... a) { out.println(a); }
private static final void prtln(final double... a) { out.println(a); }
private static final void prtln(final double[] a, int precision) { out.println(a, precision); }
private static final void prtln(final String... a) { out.println(a); }
private static final void prtln(final Object[] a) { out.println(a); }
private static final void prtlns(final char... a) { for(char ele : a) prtln(ele); }
private static final void prtlns(final boolean... a) { for(boolean ele : a) prtln(ele); }
private static final void prtlns(final int... a) { for(int ele : a) prtln(ele); }
private static final void prtlns(final long... a) { for(long ele : a) prtln(ele); }
private static final void prtlns(final double... a) { for(double ele : a) prtln(ele); }
private static final void prtlns(final Object[] a) { for(Object ele : a) prtln(ele); }
private static final void prtln(final char[][] a) { for(char[] ele : a) prtln(ele); }
private static final void prtln(final boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
private static final void prtln(final int[][] a) { for(int[] ele : a) prtln(ele); }
private static final void prtln(final long[][] a) { for(long[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a) { for(double[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a, int precision) { for(double[] ele : a) prtln(ele, precision); }
private static final void prtln(final String[][] a) { for(String[] ele : a) prtln(ele); }
private static final void prtln(final Object[][] a) { for(Object[] ele : a) prtln(ele); }
private static final void errprt() { if(DEBUG) err.print(); }
private static final void errprt(final char c) { if(DEBUG) err.print(c); }
private static final void errprt(final boolean b) { if(DEBUG) err.print(booleanToChar(b)); }
private static final void errprt(final int x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final long x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final double d) { if(DEBUG) err.print(d); }
private static final void errprt(final String s) { if(DEBUG) err.print(s); }
private static final void errprt(final Object o) { if(DEBUG) err.print(o); }
private static final void errprtln() { if(DEBUG) err.println(); }
private static final void errprtln(final char c) { if(DEBUG) err.println(c); }
private static final void errprtln(final boolean b) { if(DEBUG) err.println(booleanToChar(b)); }
private static final void errprtln(final int x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final long x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final double d) { if(DEBUG) err.println(d); }
private static final void errprtln(final String s) { if(DEBUG) err.println(s); }
private static final void errprtln(final Object o) { if(DEBUG) err.println(o); }
private static final void errprtln(final char... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final boolean... a) { if(DEBUG) err.println(booleanToChar(a)); }
private static final void errprtln(final int... a) {
if(DEBUG) {
boolean start = false;
for(int ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final long... a) {
if(DEBUG) {
boolean start = false;
for(long ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final double... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final double[] a, final int precision) { if(DEBUG) err.println(a, precision); }
private static final void errprtln(final String... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final Object[] a) { if(DEBUG) err.println(a); }
private static final void errprtlns(final char... a) { if(DEBUG) for(char ele : a) errprtln(ele); }
private static final void errprtlns(final boolean... a) { if(DEBUG) for(boolean ele : a) errprtln(ele); }
private static final void errprtlns(final int... a) { if(DEBUG) for(int ele : a) errprtln(ele); }
private static final void errprtlns(final long... a) { if(DEBUG) for(long ele : a) errprtln(ele); }
private static final void errprtlns(final double... a) { if(DEBUG) for(double ele : a) errprtln(ele); }
private static final void errprtlns(final Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
private static final void errprtln(final char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
private static final void errprtln(final boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
private static final void errprtln(final int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
private static final void errprtln(final long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a, int precision) { if(DEBUG) for(double[] ele : a) errprtln(ele, precision); }
private static final void errprtln(final String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
private static final void errprtln(final Object[][] a) { if(DEBUG) for(Object[] ele : a) errprtln(ele); }
private static final void errprtlns(final Object[][] a) { if(DEBUG) for(Object[] ele : a) { errprtlns(ele); errprtln(); } }
private static final void reply(final boolean b) { prtln(b ? "Yes" : "No"); }
private static final void REPLY(final boolean b) { prtln(b ? "YES" : "NO"); }
private static final void flush() { out.flush(); if(DEBUG) err.flush(); }
private static final void assertion(final boolean b) { if(!b) { flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char c) { if(!b) { errprtln(c); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean b2) { if(!b) { errprtln(b2); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double d) { if(!b) { errprtln(d); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String s) { if(!b) { errprtln(s); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object o) { if(!b) { errprtln(o); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void inclusiveRangeCheck(final int i, final int max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final int i, final int min, final int max) { rangeCheck(i, min, max + 1); }
private static final void inclusiveRangeCheck(final long i, final long max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final long i, final long min, final long max) { rangeCheck(i, min, max + 1); }
private static final void rangeCheck(final int i, final int max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final int i, final int min, final int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void rangeCheck(final long i, final long max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final long i, final long min, final long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void nonNegativeCheck(final long x) { nonNegativeCheck(x, "the argument"); }
private static final void nonNegativeCheck(final long x, final String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void positiveCheck(final long x) { positiveCheck(x, "the argument"); }
private static final void positiveCheck(final long x, final String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void exit() { flush(); System.exit(0); }
private static final void exit(final char c) { prtln(c); exit(); }
private static final void exit(final boolean b) { prtln(b); exit(); }
private static final void exit(final int x) { prtln(x); exit(); }
private static final void exit(final long x) { prtln(x); exit(); }
private static final void exit(final double d) { prtln(d); exit(); }
private static final void exit(final String s) { prtln(s); exit(); }
private static final void exit(final Object o) { prtln(o); exit(); }
private static final void exit(final char... a) { prtln(a); exit(); }
private static final void exit(final boolean... a) { prtln(a); exit(); }
private static final void exit(final int... a) { prtln(a); exit(); }
private static final void exit(final long... a) { prtln(a); exit(); }
private static final void exit(final double... a) { prtln(a); exit(); }
private static final void exit(final String... a) { prtln(a); exit(); }
private static final void exit(final Object[] a) { prtln(a); exit(); }
private static final void exit(final char[][] a) { prtln(a); exit(); }
private static final void exit(final boolean[][] a) { prtln(a); exit(); }
private static final void exit(final int[][] a) { prtln(a); exit(); }
private static final void exit(final long[][] a) { prtln(a); exit(); }
private static final void exit(final double[][] a) { prtln(a); exit(); }
private static final void exit(final String[][] a) { prtln(a); exit(); }
private static final void exit(final Object[][] a) { prtln(a); exit(); }
private static final long INF = (long)4e18;
private static final boolean isPlusINF(final long x) { return x > INF / 10; }
private static final boolean isMinusINF(final long x) { return isPlusINF(- x); }
private static final boolean isINF(final long x) { return isPlusINF(x) || isMinusINF(x); }
private static final int I_INF = (int)1e9 + 1000;
private static final boolean isPlusINF(final int x) { return x > I_INF / 10; }
private static final boolean isMinusINF(final int x) { return isPlusINF(- x); }
private static final boolean isINF(final int x) { return isPlusINF(x) || isMinusINF(x); }
private static final int min(final int a, final int b) { return Math.min(a, b); }
private static final long min(final long a, final long b) { return Math.min(a, b); }
private static final double min(final double a, final double b) { return Math.min(a, b); }
private static final <T extends Comparable<T>> T min(final T a, final T b) { return a.compareTo(b) <= 0 ? a : b; }
private static final int min(final int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
private static final long min(final long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
private static final double min(final double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
private static final int max(final int a, final int b) { return Math.max(a, b); }
private static final long max(final long a, final long b) { return Math.max(a, b); }
private static final double max(final double a, final double b) { return Math.max(a, b); }
private static final <T extends Comparable<T>> T max(final T a, final T b) { return a.compareTo(b) >= 0 ? a : b; }
private static final int max(final int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
private static final long max(final long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
private static final double max(final double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
private static final <T extends Comparable<T>> T max(final T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
private static final int max(final int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
private static final long max(final long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
private static final double max(final double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
private static final <T extends Comparable<T>> T max(final T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
private static final long sum(final int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
private static final long sum(final long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
private static final double sum(final double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
private static final int sum(final boolean... a) { int sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
private static final long[] sums(final int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final long[] sums(final long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final double[] sums(final double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final int[] sums(final boolean[] a) { int sum[] = new int[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
private static final long[][] sums(final int[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final long[][] sums(final long[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final double[][] sums(final double[][] a) {
final double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final int[][] sums(final boolean[][] a) {
final int sum[][] = new int[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
private static final int constrain(final int x, final int l, final int r) { return min(max(x, min(l, r)), max(l, r)); }
private static final long constrain(final long x, final long l, final long r) { return min(max(x, min(l, r)), max(l, r)); }
private static final double constrain(final double x, final double l, final double r) { return min(max(x, min(l, r)), max(l, r)); }
private static final int abs(final int x) { return x >= 0 ? x : - x; }
private static final long abs(final long x) { return x >= 0 ? x : - x; }
private static final double abs(final double x) { return x >= 0 ? x : - x; }
private static final int signum(final int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final long round(final double x) { return Math.round(x); }
private static final long floor(final double x) { return round(Math.floor(x)); }
private static final int divfloor(final int a, final int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long divfloor(final long a, final long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long ceil(final double x) { return round(Math.ceil(x)); }
private static final int divceil(final int a, final int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final long divceil(final long a, final long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final boolean mulGreater(final long a, final long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
private static final boolean mulGreaterEquals(final long a, final long b, final long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
private static final boolean mulLess(final long a, final long b, final long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
private static final boolean mulLessEquals(final long a, final long b, final long c) { return !mulGreater(a, b, c); } // a * b <= c
private static final double sqrt(final int x) { return Math.sqrt((double)x); }
private static final double sqrt(final long x) { return Math.sqrt((double)x); }
private static final double sqrt(final double x) { return Math.sqrt(x); }
private static final int floorsqrt(final int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final long floorsqrt(final long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final int ceilsqrt(final int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long ceilsqrt(final long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long fact(final int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
private static final long naiveP(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
private static final long naiveC(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
private static final double pow(final double x, final double y) { return Math.pow(x, y); }
private static final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
private static final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
private static final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
private static final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
private static final long lcm(final long a, final long b) { return a / gcd(a, b) * b; }
private static final int gcd(final int... a) { int gcd = 0; for(int ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final long gcd(final long... a) { long gcd = 0; for(long ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final double random() { return Math.random(); }
private static final int random(final int max) { return (int)floor(random() * max); }
private static final long random(final long max) { return floor(random() * max); }
private static final double random(final double max) { return random() * max; }
private static final int random(final int min, final int max) { return random(max - min) + min; }
private static final long random(final long min, final long max) { return random(max - min) + min; }
private static final double random(final double min, final double max) { return random(max - min) + min; }
private static final boolean isUpper(final char c) { return c >= 'A' && c <= 'Z'; }
private static final boolean isLower(final char c) { return c >= 'a' && c <= 'z'; }
private static final int upperToInt(final char c) { return c - 'A'; }
private static final int lowerToInt(final char c) { return c - 'a'; }
private static final int numToInt(final char c) { return c - '0'; }
private static final int charToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) : numToInt(c); }
private static final int alphabetToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) + 26 : 52; }
private static final char intToUpper(final int x) { return (char)(x + 'A'); }
private static final char intToLower(final int x) { return (char)(x + 'a'); }
private static final char intToNum(final int x) { return (char)(x + '0'); }
private static final int[] charToInt(final char[] a) { final int toint[] = new int[a.length]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final int[][] charToInt(final char[][] a) { final int toint[][] = new int[a.length][]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final long[] div(final long x) {
nonNegativeCheck(x);
final List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= x; i ++) if(x % i == 0) { divList.add(i); if(i * i != x) divList.add(x / i); }
final long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
private static final PairLL[] factor(long x) {
nonNegativeCheck(x);
final List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= x; i ++) {
if(x % i == 0) {
long cnt = 0;
while(x % i == 0) { x /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(x > 1) factorList.add(new PairLL(x, 1));
final PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
private static final boolean isPrime(final long x) { if(x <= 1) return false; for(long i = 2; i * i <= x; i ++) if(x % i == 0) return false; return true; }
private static final boolean[] prime(final int n) {
nonNegativeCheck(n);
final boolean prime[] = new boolean[n];
fill(prime, true);
if(n > 0) prime[0] = false;
if(n > 1) prime[1] = false;
for(int i = 2; i < n; i ++) if(prime[i]) for(int j = 2; i * j < n; j ++) prime[i * j] = false;
return prime;
}
private static final PairIL[] countElements(final int[] a, final boolean sort) {
final int len = a.length;
final int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairLL[] countElements(final long[] a, final boolean sort) {
final int len = a.length;
final long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairIL[] countElements(final String s, final boolean sort) {
final int len = s.length();
final char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final long triangular(final long n) { return n * (n + 1) / 2; }
private static final long arctriangularfloor(final long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
private static final long arctriangularceil(final long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
private static final int[] baseConvert(long x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final long x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int[] baseConvert(int x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final int x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
int tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final long[] baseConvert(long x, final long n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final long digit[] = new long[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = x % n; x /= n; }
return digit;
}
private static final long[] baseConvert(final long x, final long n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int numDigits(final long x) { nonNegativeCheck(x); return Long.toString(x).length(); }
private static final long bitFlag(final int i) { nonNegativeCheck(i); return 1L << i; }
private static final boolean isFlagged(final long x, final int i) { nonNegativeCheck(x); nonNegativeCheck(i); return (x >> i & 1) != 0; }
private static final long countString(final String s, final String t) { return (s.length() - s.replace(t, "").length()) / t.length(); }
private static final long countStringAll(final String s, final String t) { return s.length() - s.replaceAll(t, "").length(); }
private static final String reverse(final String s) { return (new StringBuilder(s)).reverse().toString(); }
private static final char[] reverse(final char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final boolean[] reverse(final boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final int[] reverse(final int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final long[] reverse(final long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final double[] reverse(final double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final String[] reverse(final String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final Object[] reverse(final Object[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final void fill(final char[] a, final char x) { Arrays.fill(a, x); }
private static final void fill(final boolean[] a, final boolean x) { Arrays.fill(a, x); }
private static final void fill(final int[] a, final int x) { Arrays.fill(a, x); }
private static final void fill(final long[] a, final long x) { Arrays.fill(a, x); }
private static final void fill(final double[] a, final double x) { Arrays.fill(a, x); }
private static final void fill(final char[][] a, final char x) { for(char[] ele : a) fill(ele, x); }
private static final void fill(final boolean[][] a, final boolean x) { for(boolean[] ele : a) fill(ele, x); }
private static final void fill(final int[][] a, final int x) { for(int[] ele : a) fill(ele, x); }
private static final void fill(final long[][] a, final long x) { for(long[] ele : a) fill(ele, x); }
private static final void fill(final double[][] a, final double x) { for(double[] ele : a) fill(ele, x); }
private static final void fill(final char[][][] a, final char x) { for(char[][] ele : a) fill(ele, x); }
private static final void fill(final boolean[][][] a, final boolean x) { for(boolean[][] ele : a) fill(ele, x); }
private static final void fill(final int[][][] a, final int x) { for(int[][] ele : a) fill(ele, x); }
private static final void fill(final long[][][] a, final long x) { for(long[][] ele : a) fill(ele, x); }
private static final void fill(final double[][][] a, final double x) { for(double[][] ele : a) fill(ele, x); }
private static final char[] resize(final char[] a, final int m, final int x) {
nonNegativeCheck(m);
final char resized[] = new char[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final boolean[] resize(final boolean[] a, final int m, final int x) {
nonNegativeCheck(m);
final boolean resized[] = new boolean[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] resize(final int[] a, final int m, final int x) {
nonNegativeCheck(m);
final int resized[] = new int[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final long[] resize(final long[] a, final int m, final int x) {
nonNegativeCheck(m);
final long resized[] = new long[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final double[] resize(final double[] a, final int m, final int x) {
nonNegativeCheck(m);
final double resized[] = new double[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final String[] resize(final String[] a, final int m, final int x) {
nonNegativeCheck(m);
final String resized[] = new String[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final Object[] resize(final Object[] a, final int m, final int x) {
nonNegativeCheck(m);
final Object resized[] = new Object[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] toIntArray(final List<Integer> list) { final int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
private static final long[] toLongArray(final List<Long> list) { final long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
private static final double[] toDoubleArray(final List<Double> list) { final double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
private static final char[] toCharArray(final List<Character> list) { final char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
private static final boolean[] toBooleanArray(final List<Boolean> list) { final boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
private static final String[] toStringArray(final List<String> list) { final String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
private static final <T> void toArray(final List<T> list, final T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
private static final void shuffleArray(final int[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final long[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final double[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final int[] randomi(final int n, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final long[] randoml(final int n, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final double[] randomd(final int n, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final int[] randomi(final int n, final int min, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final long[] randoml(final int n, final long min, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final double[] randomd(final int n, final double min, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final void swap(final char[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final boolean[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final int[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final long[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final double[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final String[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final Object[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final char[][] rotate(final char[][] a) {
final char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final boolean[][] rotate(final boolean[][] a) {
final boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[][] rotate(final int[][] a) {
final int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final long[][] rotate(final long[][] a) {
final long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final double[][] rotate(final double[][] a) {
final double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final Object[][] rotate(final Object[][] a) {
final Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[] compress(final int[] a) {
final int n = a.length;
final Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final long[] compress(final long[] a) {
final int n = a.length;
final Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final double[] compress(final double[] a) {
final int n = a.length;
final Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
// binary search
private static final int lowerBound(final int[] a, final int key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final int[] a, final int key) { return BS(a, key, true, true, false); }
private static final int upperBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final int[] a, final int key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final int[] a, final int index, final int key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final long[] a, final long key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final long[] a, final long key) { return BS(a, key, true, true, false); }
private static final int upperBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final long[] a, final long key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final long[] a, final int index, final long key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final double[] a, final double key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final double[] a, final double key) { return BS(a, key, true, true, false); }
private static final int upperBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final double[] a, final double key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final double[] a, final int index, final double key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final T[] a, final int index, final T key, final boolean gt, final boolean eq) {
int compare = a[index].compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
private static final <T> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final T[] a, final int index, T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a[index], key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final List<T> a, final int index, T key, final boolean gt, final boolean eq) {
int compare = a.get(index).compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
private static final <T> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final List<T> a, final int index, final T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a.get(index), key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final PairLL binaryRangeSearch(final long left, final long right, final UnaryOperator<Long> op, final boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) >> 1;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) >> 1;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
private static final double ternarySearch(double left, double right, final UnaryOperator<Double> op, final boolean minimize, final int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
private static final class Mod107 extends Mod {
public static final Mod107 md = new Mod107();
public static final long MOD = 1_000_000_007;
private Mod107() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod998 extends Mod {
public static final Mod998 md = new Mod998();
public static final long MOD = 998_244_353;
private Mod998() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod754974721 extends Mod {
public static final Mod754974721 md = new Mod754974721();
public static final long MOD = 754_974_721;
private Mod754974721() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod167772161 extends Mod {
public static final Mod167772161 md = new Mod167772161();
public static final long MOD = 167_772_161;
private Mod167772161() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod469762049 extends Mod {
public static final Mod469762049 md = new Mod469762049();
public static final long MOD = 469_762_049;
private Mod469762049() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class ArbitraryMod extends Mod {
private static final long MASK = 0xffff_ffffl;
private final long MH;
private final long ML;
public ArbitraryMod(long mod) { super(mod); long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
private final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
@Override
public long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return reduce(x);
}
@Override
public long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return reduce(x * y);
x = mod(x);
y = mod(y);
return reduce(x * y);
}
}
private abstract static class Mod {
public final long MOD;
public Mod(long mod) { MOD = mod; }
public abstract long mod(long x);
public final long[] mod(final long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
public final long[][] mod(final long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public final long[][][] mod(final long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public long add(long x, final long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
public final long sum(final long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
public long sub(long x, final long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
public final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
public abstract long mul(long x, long y);
public final long mul(final long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
public final long div(final long x, final long y) { return mul(x, inv(y)); }
public final long[] pows(long x, final int n) {
x = mod(x);
long pow[] = new long[n + 1];
pow[0] = 1;
for(int i = 0; i < n; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
public final long fact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
public final long invFact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
private static final int MAX_INV_SIZE = 100_100;
public final Map<Long, Long> invMap = new HashMap<>();
public final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
private final long calInv(final long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
public final long[] invs(final int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
private long g;
public final long primitiveRoot() { // O(1) or O(M^(1/2))
if(MOD == 2) return 1;
if(MOD == 167772161) return 3;
if(MOD == 469762049) return 3;
if(MOD == 754974721) return 11;
if(MOD == 998244353) return 3;
if(g != 0) return g;
PairLL factor[] = factor(MOD - 1);
outer: for(g = 2; ; g ++) {
for(PairLL p : factor) if(pow(g, (MOD - 1) / p.a) == 1) continue outer;
return g;
}
}
private static final int MAX_FACT1 = 5_000_100;
private static final int MAX_FACT2 = 500_100;
private static final int MAX_FACT_MAP_SIZE = 100;
private long fact[];
private long invFact[];
private boolean isFactPrepared = false;
private final Map<Long, long[]> factMap = new HashMap<>();
private final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
public final long P(final long n, final long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
public final long C(final long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
final int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
public final long H(final long n, final long r) { return C(n - 1 + r, r); }
public final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
private static final long mod(long x, final long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
private static final long pow(long x, long y, final long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
private static class Grids {
public final int h, w;
public final Grid[][] gs;
public final Grid[] gi;
public Grids(final int h, final int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
public final void init(final boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
public final void init(final long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
public final Grid get(final int x, final int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
public final Grid get(final int i) { return get(i / w, i % w); }
public static final int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
public static final int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
public final Grid next(final int x, final int y, final int i) { return next(gs[x][y], i); }
public final Grid next(final Grid g, final int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
private static class Grid implements Comparable<Grid> {
public int x, y, h, w, i; public boolean b; public long val;
public Grid() { }
public Grid(final int x, final int y, final int h, final int w) { init(x, y, h, w, false, 0); }
public Grid(final int x, final int y, final int h, final int w, final boolean b) { init(x, y, h, w, b, 0); }
public Grid(final int x, final int y, final int h, final int w, final long val) { init(x, y, h, w, false, val); }
public Grid(final int x, final int y, final int h, final int w, final boolean b, final long val) { init(x, y, h, w, b, val); }
public final void init(final int x, final int y, final int h, final int w, final boolean b, final long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public final String toString() { return "("+x+", "+y+")"+" "+booleanToChar(b)+" "+val; }
@Override public final int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public final int compareTo(final Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
private static final boolean isValid(final int x, final int y, final int h, final int w) { return x >= 0 && x < h && y >= 0 && y < w; }
private static final boolean isValid(final Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
private static class Graph {
public int numNode, numEdge;
public boolean directed;
public List<Edge> edges = new ArrayList<>();
public Node nodes[];
public Node reversedNodes[];
public Graph(final int numNode, final int numEdge, final boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
public void init(final List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
public void add(final int source, final int target, final long cost) { add(new Edge(source, target, cost)); }
public void add(final Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
public void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
private static class Node extends ArrayList<Edge> {
public final int id;
public Node(final int id) { this.id = id; }
public void add(final int target, final long cost) { add(new Edge(id, target, cost)); }
}
private static class Edge implements Comparable<Edge> {
public int source, target; public long cost;
public Edge(final int source, final int target, final long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public final String toString() { return source+" - "+cost+" -> "+target; }
@Override public final int hashCode() { return Objects.hash(source, target); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public final int compareTo(final Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
private static class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
public T a; public U b;
public Pair() { }
public Pair(final T a, final U b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public final int compareTo(final Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
private static final PairII npii() { return new PairII(ni(), ni()); }
private static final PairII[] npii(final int n) { final PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
private static final PairII[][] npii(final int n, final int m) { final PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
private static class PairII implements Comparable<PairII> {
public int a; public int b;
public PairII() { }
public PairII(final int a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairIL npil() { return new PairIL(ni(), nl()); }
private static final PairIL[] npil(final int n) { final PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
private static final PairIL[][] npil(final int n, final int m) { final PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
private static class PairIL implements Comparable<PairIL> {
public int a; public long b;
public PairIL() { }
public PairIL(final int a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairID npid() { return new PairID(ni(), nd()); }
private static final PairID[] npid(final int n) { final PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
private static final PairID[][] npid(final int n, final int m) { final PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
private static class PairID implements Comparable<PairID> {
public int a; public double b;
public PairID() { }
public PairID(final int a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairLI npli() { return new PairLI(nl(), ni()); }
private static final PairLI[] npli(final int n) { final PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
private static final PairLI[][] npli(final int n, final int m) { final PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
private static class PairLI implements Comparable<PairLI> {
public long a; public int b;
public PairLI() { }
public PairLI(final long a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairLL npll() { return new PairLL(nl(), nl()); }
private static final PairLL[] npll(final int n) { final PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
private static final PairLL[][] npll(final int n, final int m) { final PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
private static class PairLL implements Comparable<PairLL> {
public long a; public long b;
public PairLL() { }
public PairLL(final long a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairLD npld() { return new PairLD(nl(), nd()); }
private static final PairLD[] npld(final int n) { final PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
private static final PairLD[][] npld(final int n, final int m) { final PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
private static class PairLD implements Comparable<PairLD> {
public long a; public double b;
public PairLD() { }
public PairLD(final long a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairDI npdi() { return new PairDI(nd(), ni()); }
private static final PairDI[] npdi(final int n) { final PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
private static final PairDI[][] npdi(final int n, final int m) { final PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
private static class PairDI implements Comparable<PairDI> {
public double a; public int b;
public PairDI() { }
public PairDI(final double a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairDL npdl() { return new PairDL(nd(), nl()); }
private static final PairDL[] npdl(final int n) { final PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
private static final PairDL[][] npdl(final int n, final int m) { final PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
private static class PairDL implements Comparable<PairDL> {
public double a; public long b;
public PairDL() { }
public PairDL(final double a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairDD npdd() { return new PairDD(nd(), nd()); }
private static final PairDD[] npdd(final int n) { final PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
private static final PairDD[][] npdd(final int n, final int m) { final PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
private static class PairDD implements Comparable<PairDD> {
public double a; public double b;
public PairDD() { }
public PairDD(final double a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
// Tuple
private interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
private static class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
public T t; public V a;
public BasicTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public final String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public final int hashCode() { return Objects.hash(t, a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
private static class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
public V a;
public UniqueTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public final String toString() { return "("+a.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
private static class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
public Tuple1() { super(); }
public Tuple1(final T0 a0) { super(); this.a = a0; }
final T0 get0() { return a; }
final void set0(final T0 x) { a = x; }
}
private static class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
public Tuple2() { super(); }
public Tuple2(final T0 a0, final T1 a1) { super(); this.t = new Tuple1<>(a0); this.a = a1; }
final T0 get0() { return t.get0(); }
final T1 get1() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { a = x; }
}
private static class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
public Tuple3() { super(); }
public Tuple3(final T0 a0, final T1 a1, final T2 a2) { super(); this.t = new Tuple2<>(a0, a1); this.a = a2; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { a = x; }
}
private static class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
public Tuple4() { super(); }
public Tuple4(final T0 a0, final T1 a1, final T2 a2, final T3 a3) { super(); this.t = new Tuple3<>(a0, a1, a2); this.a = a3; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { a = x; }
}
private static class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
public Tuple5() { super(); }
public Tuple5(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4) { super(); this.t = new Tuple4<>(a0, a1, a2, a3); this.a = a4; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { a = x; }
}
private static class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
public Tuple6() { super(); }
public Tuple6(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) { super(); this.t = new Tuple5<>(a0, a1, a2, a3, a4); this.a = a5; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { a = x; }
}
private static class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
public Tuple7() { super(); }
public Tuple7(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) { super(); this.t = new Tuple6<>(a0, a1, a2, a3, a4, a5); this.a = a6; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { a = x; }
}
private static class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
public Tuple8() { super(); }
public Tuple8(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) { super(); this.t = new Tuple7<>(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return t.get6(); }
final T7 get7() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { t.set6(x); }
final void set7(final T7 x) { a = x; }
}
// Tuple3
private static class TupleIII implements Comparable<TupleIII> {
public int a; public int b; public int c;
public TupleIII() { }
public TupleIII(final int a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIIL implements Comparable<TupleIIL> {
public int a; public int b; public long c;
public TupleIIL() { }
public TupleIIL(final int a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
private static class TupleIID implements Comparable<TupleIID> {
public int a; public int b; public double c;
public TupleIID() { }
public TupleIID(final int a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleILI implements Comparable<TupleILI> {
public int a; public long b; public int c;
public TupleILI() { }
public TupleILI(final int a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleILL implements Comparable<TupleILL> {
public int a; public long b; public long c;
public TupleILL() { }
public TupleILL(final int a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleILD implements Comparable<TupleILD> {
public int a; public long b; public double c;
public TupleILD() { }
public TupleILD(final int a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleIDI implements Comparable<TupleIDI> {
public int a; public double b; public int c;
public TupleIDI() { }
public TupleIDI(final int a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIDL implements Comparable<TupleIDL> {
public int a; public double b; public long c;
public TupleIDL() { }
public TupleIDL(final int a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleIDD implements Comparable<TupleIDD> {
public int a; public double b; public double c;
public TupleIDD() { }
public TupleIDD(final int a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLII implements Comparable<TupleLII> {
public long a; public int b; public int c;
public TupleLII() { }
public TupleLII(final long a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLIL implements Comparable<TupleLIL> {
public long a; public int b; public long c;
public TupleLIL() { }
public TupleLIL(final long a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLID implements Comparable<TupleLID> {
public long a; public int b; public double c;
public TupleLID() { }
public TupleLID(final long a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLLI implements Comparable<TupleLLI> {
public long a; public long b; public int c;
public TupleLLI() { }
public TupleLLI(final long a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLLL implements Comparable<TupleLLL> {
public long a; public long b; public long c;
public TupleLLL() { }
public TupleLLL(final long a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLLD implements Comparable<TupleLLD> {
public long a; public long b; public double c;
public TupleLLD() { }
public TupleLLD(final long a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLDI implements Comparable<TupleLDI> {
public long a; public double b; public int c;
public TupleLDI() { }
public TupleLDI(final long a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLDL implements Comparable<TupleLDL> {
public long a; public double b; public long c;
public TupleLDL() { }
public TupleLDL(final long a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLDD implements Comparable<TupleLDD> {
public long a; public double b; public double c;
public TupleLDD() { }
public TupleLDD(final long a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDII implements Comparable<TupleDII> {
public double a; public int b; public int c;
public TupleDII() { }
public TupleDII(final double a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDIL implements Comparable<TupleDIL> {
public double a; public int b; public long c;
public TupleDIL() { }
public TupleDIL(final double a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDID implements Comparable<TupleDID> {
public double a; public int b; public double c;
public TupleDID() { }
public TupleDID(final double a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDLI implements Comparable<TupleDLI> {
public double a; public long b; public int c;
public TupleDLI() { }
public TupleDLI(final double a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDLL implements Comparable<TupleDLL> {
public double a; public long b; public long c;
public TupleDLL() { }
public TupleDLL(final double a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDLD implements Comparable<TupleDLD> {
public double a; public long b; public double c;
public TupleDLD() { }
public TupleDLD(final double a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDDI implements Comparable<TupleDDI> {
public double a; public double b; public int c;
public TupleDDI() { }
public TupleDDI(final double a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDDL implements Comparable<TupleDDL> {
public double a; public double b; public long c;
public TupleDDL() { }
public TupleDDL(final double a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDDD implements Comparable<TupleDDD> {
public double a; public double b; public double c;
public TupleDDD() { }
public TupleDDD(final double a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
int n = ni();
String s[] = ns(n);
boolean connected[][] = new boolean[n][n];
for(int i = 0; i < n; i ++) {
for(int j = 0; j < n; j ++) {
connected[i][j] = s[i].charAt(s[i].length() - 1) == s[j].charAt(0);
}
}
int maxBit = 1 << n;
boolean win[][] = new boolean[maxBit][n];
for(int bit = 0; bit < maxBit; bit ++) {
for(int i = 0; i < n; i ++) {
for(int j = 0; j < n; j ++) {
if(isFlagged(bit, j) && connected[i][j]) {
win[bit][i] |= !win[bit ^ (1 << j)][j];
}
}
}
}
boolean ans = false;
for(int i = 0; i < n; i ++) ans |= win[maxBit - 1][i];
prtln(ans ? "First" : "Second");
}
}
}
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
private static boolean DEBUG;
public static void main(final String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
@Override
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
public static final class FastInputStream {
private static final int BUF_SIZE = 1 << 14;
private final InputStream in;
private final byte buf[] = new byte[BUF_SIZE];
private int pos = 0;
private int count = 0;
private static final int TOKEN_SIZE = 1 << 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
public FastInputStream(final InputStream in) {
this.in = in;
}
private final void readBuf() {
pos = 0;
try { count = in.read(buf); }
catch(IOException e) { e.printStackTrace(); }
}
private final boolean hasNextByte() {
if(pos < count) return true;
readBuf();
return count > 0;
}
private final byte read() { if(hasNextByte()) return buf[pos ++]; else throw new NoSuchElementException(); }
private final boolean isPrintableChar(final byte c) { return 33 <= c && c <= 126; }
private final boolean isNumber(final byte c) { return 48 <= c && c <= 57; }
private final void skipUnprintable() {
while(true) {
for(int i = pos; i < count; i ++) {
if(isPrintableChar(buf[i])) { pos = i; return; }
}
readBuf();
if(count <= 0) throw new NoSuchElementException();
}
}
private final boolean readEOL() {
if(!hasNextByte()) return true;
if(buf[pos] == 13) {
pos ++;
if(hasNextByte() && buf[pos] == 10) pos ++;
return true;
}
if(buf[pos] == 10) {
pos ++;
return true;
}
return false;
}
public final char nextChar() {
skipUnprintable();
return (char)buf[pos ++];
}
public final String next() {
skipUnprintable();
int tokenCount = 0;
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
tokenBuf[tokenCount ++] = b;
}
readBuf();
}
return new String(tokenBuf, 0, tokenCount);
}
public final String nextLine() {
readEOL();
if(!hasNextByte()) throw new NoSuchElementException();
int tokenCount = 0;
while(!readEOL()) tokenBuf[tokenCount ++] = read();
return new String(tokenBuf, 0, tokenCount);
}
public final int nextInt() {
skipUnprintable();
int n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 214748364) throw new ArithmeticException("int overflow");
if(n == - 214748364 && b > 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 214748364) throw new ArithmeticException("int overflow");
if(n == 214748364 && b >= 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final long nextLong() {
skipUnprintable();
long n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == - 922337203685477580l && b > 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == 922337203685477580l && b >= 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final double nextDouble() { return Double.parseDouble(next()); }
public final void close() {
try { in.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class FastOutputStream {
private static final int BUF_SIZE = 1 << 13;
private final byte buf[] = new byte[BUF_SIZE];
private final OutputStream out;
private int count = 0;
private static final byte TRUE_BYTES[] = {116, 114, 117, 101};
private static final byte FALSE_BYTES[] = {102, 97, 108, 115, 101};
private static final byte INT_MIN_BYTES[] = {45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 56};
private static final byte LONG_MIN_BYTES[] = {45, 57, 50, 50, 51, 51, 55, 50, 48, 51,
54, 56, 53, 52, 55, 55, 53, 56, 48, 56};
private static final int TOKEN_SIZE = 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
private static final int PRECISION = 10;
public FastOutputStream(OutputStream out) {
this.out = out;
}
public final void print() { }
public final void write(final byte b) {
if(count == BUF_SIZE) internalFlush();
buf[count ++] = b;
}
public final void print(final char c) { write((byte) c); }
public final void print(final boolean b) {
if(b) {
if(count + 4 > BUF_SIZE) internalFlush();
System.arraycopy(TRUE_BYTES, 0, buf, count, TRUE_BYTES.length);
count += TRUE_BYTES.length;
}else {
if(count + 5 > BUF_SIZE) internalFlush();
System.arraycopy(FALSE_BYTES, 0, buf, count, FALSE_BYTES.length);
count += FALSE_BYTES.length;
}
}
public final void print(int x) {
if(count + 11 > BUF_SIZE) internalFlush();
if(x == Integer.MIN_VALUE) {
System.arraycopy(INT_MIN_BYTES, 0, buf, count, INT_MIN_BYTES.length);
count += INT_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 11;
while(x > 0) {
final int y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 11 - tokenCount);
count += 11 - tokenCount;
}
public final void print(long x) {
if(count + 20 > BUF_SIZE) internalFlush();
if(x == Long.MIN_VALUE) {
System.arraycopy(LONG_MIN_BYTES, 0, buf, count, LONG_MIN_BYTES.length);
count += LONG_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 20;
while(x > 0) {
final long y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 20 - tokenCount);
count += 20 - tokenCount;
}
public final void print(final double d) { print(d, PRECISION); }
public final void print(double d, final int precision) {
if(count == BUF_SIZE) internalFlush();
if(d < 0) {
buf[count ++] = 45;
d = - d;
}
d += Math.pow(10, - precision) / 2;
print((long)d);
if(precision == 0) return;
if(count + precision + 1 > BUF_SIZE) internalFlush();
buf[count ++] = 46;
d -= (long)d;
for(int i = 0; i < precision; i ++) {
d *= 10;
buf[count ++] = (byte)((int)d + 48);
d -= (int) d;
}
}
public final void print(final String s) { print(s.getBytes()); }
public final void print(final Object o) { print(o.toString()); }
public final void print(final byte[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
System.arraycopy(a, 0, buf, count, a.length);
count += a.length;
}
public final void print(final char[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
for(int i = 0; i < a.length; i ++) buf[count + i] = (byte)a[i];
count += a.length;
}
public final void println() { print('\n'); }
public final void println(final char c) { print(c); println(); }
public final void println(final boolean b) { print(b); println(); }
public final void println(final int x) { print(x); println(); }
public final void println(final long x) { print(x); println(); }
public final void println(final double d) { print(d); println(); }
public final void println(final double d, final int precision) { print(d, precision); println(); }
public final void println(final String s) { print(s); println(); }
public final void println(final Object o) { print(o); println(); }
public final void println(final char[] a) { print(a); println(); }
public final void println(final int[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final long[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a, final int precision) {
for(int i = 0; i < a.length; i ++) {
print(a[i], precision);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final String[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final Object[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
private final void internalFlush() {
try {
out.write(buf, 0, count);
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void flush() {
try {
out.write(buf, 0, count);
out.flush();
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void close() {
try { out.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class Solver {
private static final FastInputStream in = new FastInputStream(System.in);
public Solver() { }
private static final String nline() { return in.nextLine(); }
private static final String[] nline(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = nline(); return a; }
private static final char nc() { return in.nextChar(); }
private static final char[] nc(int n) {
final String str = ns();
if(n < 0) n = str.length();
final char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
private static final char[][] nc(final int n, final int m) { final char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
private static final boolean[] nb(int n, final char t) {
final char c[] = nc(-1);
if(n < 0) n = c.length;
final boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
private static final boolean[][] nb(final int n, final int m, final char t) { final boolean a[][] = new boolean[n][]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
private static final int ni() { return in.nextInt(); }
private static final int[] ni(final int n) { final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
private static final int[][] ni(final int n, final int m) { final int a[][] = new int[n][]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
private static final long nl() { return in.nextLong(); }
private static final long[] nl(final int n) { final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
private static final long[][] nl(final int n, final int m) { final long a[][] = new long[n][]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
private static final double nd() { return in.nextDouble(); }
private static final double[] nd(final int n) { final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
private static final double[][] nd(final int n, final int m) { final double a[][] = new double[n][]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
private static final String ns() { return in.next(); }
private static final String[] ns(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(); return a; }
private static final String[][] ns(final int n, final int m) { final String a[][] = new String[n][]; for(int i = 0; i < n; i ++) a[i] = ns(m); return a; }
private static final char booleanToChar(final boolean b) { return b ? '#' : '.'; }
private static final char[] booleanToChar(final boolean... a) {
final char c[] = new char[a.length];
for(int i = 0; i < a.length; i ++) c[i] = booleanToChar(a[i]);
return c;
}
private static final FastOutputStream out = new FastOutputStream(System.out);
private static final FastOutputStream err = new FastOutputStream(System.err);
private static final void prt() { out.print(); }
private static final void prt(final char c) { out.print(c); }
private static final void prt(final boolean b) { out.print(b); }
private static final void prt(final int x) { out.print(x); }
private static final void prt(final long x) { out.print(x); }
private static final void prt(final double d) { out.print(d); }
private static final void prt(final String s) { out.print(s); }
private static final void prt(final Object o) { out.print(o); }
private static final void prtln() { out.println(); }
private static final void prtln(final char c) { out.println(c); }
private static final void prtln(final boolean b) { out.println(b); }
private static final void prtln(final int x) { out.println(x); }
private static final void prtln(final long x) { out.println(x); }
private static final void prtln(final double d) { out.println(d); }
private static final void prtln(final String s) { out.println(s); }
private static final void prtln(final Object o) { out.println(o); }
private static final void prtln(final char... a) { out.println(a); }
private static final void prtln(final boolean... a) { out.println(booleanToChar(a)); }
private static final void prtln(final int... a) { out.println(a); }
private static final void prtln(final long... a) { out.println(a); }
private static final void prtln(final double... a) { out.println(a); }
private static final void prtln(final double[] a, int precision) { out.println(a, precision); }
private static final void prtln(final String... a) { out.println(a); }
private static final void prtln(final Object[] a) { out.println(a); }
private static final void prtlns(final char... a) { for(char ele : a) prtln(ele); }
private static final void prtlns(final boolean... a) { for(boolean ele : a) prtln(ele); }
private static final void prtlns(final int... a) { for(int ele : a) prtln(ele); }
private static final void prtlns(final long... a) { for(long ele : a) prtln(ele); }
private static final void prtlns(final double... a) { for(double ele : a) prtln(ele); }
private static final void prtlns(final Object[] a) { for(Object ele : a) prtln(ele); }
private static final void prtln(final char[][] a) { for(char[] ele : a) prtln(ele); }
private static final void prtln(final boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
private static final void prtln(final int[][] a) { for(int[] ele : a) prtln(ele); }
private static final void prtln(final long[][] a) { for(long[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a) { for(double[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a, int precision) { for(double[] ele : a) prtln(ele, precision); }
private static final void prtln(final String[][] a) { for(String[] ele : a) prtln(ele); }
private static final void prtln(final Object[][] a) { for(Object[] ele : a) prtln(ele); }
private static final void errprt() { if(DEBUG) err.print(); }
private static final void errprt(final char c) { if(DEBUG) err.print(c); }
private static final void errprt(final boolean b) { if(DEBUG) err.print(booleanToChar(b)); }
private static final void errprt(final int x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final long x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final double d) { if(DEBUG) err.print(d); }
private static final void errprt(final String s) { if(DEBUG) err.print(s); }
private static final void errprt(final Object o) { if(DEBUG) err.print(o); }
private static final void errprtln() { if(DEBUG) err.println(); }
private static final void errprtln(final char c) { if(DEBUG) err.println(c); }
private static final void errprtln(final boolean b) { if(DEBUG) err.println(booleanToChar(b)); }
private static final void errprtln(final int x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final long x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final double d) { if(DEBUG) err.println(d); }
private static final void errprtln(final String s) { if(DEBUG) err.println(s); }
private static final void errprtln(final Object o) { if(DEBUG) err.println(o); }
private static final void errprtln(final char... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final boolean... a) { if(DEBUG) err.println(booleanToChar(a)); }
private static final void errprtln(final int... a) {
if(DEBUG) {
boolean start = false;
for(int ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final long... a) {
if(DEBUG) {
boolean start = false;
for(long ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final double... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final double[] a, final int precision) { if(DEBUG) err.println(a, precision); }
private static final void errprtln(final String... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final Object[] a) { if(DEBUG) err.println(a); }
private static final void errprtlns(final char... a) { if(DEBUG) for(char ele : a) errprtln(ele); }
private static final void errprtlns(final boolean... a) { if(DEBUG) for(boolean ele : a) errprtln(ele); }
private static final void errprtlns(final int... a) { if(DEBUG) for(int ele : a) errprtln(ele); }
private static final void errprtlns(final long... a) { if(DEBUG) for(long ele : a) errprtln(ele); }
private static final void errprtlns(final double... a) { if(DEBUG) for(double ele : a) errprtln(ele); }
private static final void errprtlns(final Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
private static final void errprtln(final char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
private static final void errprtln(final boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
private static final void errprtln(final int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
private static final void errprtln(final long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a, int precision) { if(DEBUG) for(double[] ele : a) errprtln(ele, precision); }
private static final void errprtln(final String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
private static final void errprtln(final Object[][] a) { if(DEBUG) for(Object[] ele : a) errprtln(ele); }
private static final void errprtlns(final Object[][] a) { if(DEBUG) for(Object[] ele : a) { errprtlns(ele); errprtln(); } }
private static final void reply(final boolean b) { prtln(b ? "Yes" : "No"); }
private static final void REPLY(final boolean b) { prtln(b ? "YES" : "NO"); }
private static final void flush() { out.flush(); if(DEBUG) err.flush(); }
private static final void assertion(final boolean b) { if(!b) { flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char c) { if(!b) { errprtln(c); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean b2) { if(!b) { errprtln(b2); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double d) { if(!b) { errprtln(d); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String s) { if(!b) { errprtln(s); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object o) { if(!b) { errprtln(o); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void inclusiveRangeCheck(final int i, final int max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final int i, final int min, final int max) { rangeCheck(i, min, max + 1); }
private static final void inclusiveRangeCheck(final long i, final long max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final long i, final long min, final long max) { rangeCheck(i, min, max + 1); }
private static final void rangeCheck(final int i, final int max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final int i, final int min, final int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void rangeCheck(final long i, final long max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final long i, final long min, final long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void nonNegativeCheck(final long x) { nonNegativeCheck(x, "the argument"); }
private static final void nonNegativeCheck(final long x, final String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void positiveCheck(final long x) { positiveCheck(x, "the argument"); }
private static final void positiveCheck(final long x, final String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void exit() { flush(); System.exit(0); }
private static final void exit(final char c) { prtln(c); exit(); }
private static final void exit(final boolean b) { prtln(b); exit(); }
private static final void exit(final int x) { prtln(x); exit(); }
private static final void exit(final long x) { prtln(x); exit(); }
private static final void exit(final double d) { prtln(d); exit(); }
private static final void exit(final String s) { prtln(s); exit(); }
private static final void exit(final Object o) { prtln(o); exit(); }
private static final void exit(final char... a) { prtln(a); exit(); }
private static final void exit(final boolean... a) { prtln(a); exit(); }
private static final void exit(final int... a) { prtln(a); exit(); }
private static final void exit(final long... a) { prtln(a); exit(); }
private static final void exit(final double... a) { prtln(a); exit(); }
private static final void exit(final String... a) { prtln(a); exit(); }
private static final void exit(final Object[] a) { prtln(a); exit(); }
private static final void exit(final char[][] a) { prtln(a); exit(); }
private static final void exit(final boolean[][] a) { prtln(a); exit(); }
private static final void exit(final int[][] a) { prtln(a); exit(); }
private static final void exit(final long[][] a) { prtln(a); exit(); }
private static final void exit(final double[][] a) { prtln(a); exit(); }
private static final void exit(final String[][] a) { prtln(a); exit(); }
private static final void exit(final Object[][] a) { prtln(a); exit(); }
private static final long INF = (long)4e18;
private static final boolean isPlusINF(final long x) { return x > INF / 10; }
private static final boolean isMinusINF(final long x) { return isPlusINF(- x); }
private static final boolean isINF(final long x) { return isPlusINF(x) || isMinusINF(x); }
private static final int I_INF = (int)1e9 + 1000;
private static final boolean isPlusINF(final int x) { return x > I_INF / 10; }
private static final boolean isMinusINF(final int x) { return isPlusINF(- x); }
private static final boolean isINF(final int x) { return isPlusINF(x) || isMinusINF(x); }
private static final int min(final int a, final int b) { return Math.min(a, b); }
private static final long min(final long a, final long b) { return Math.min(a, b); }
private static final double min(final double a, final double b) { return Math.min(a, b); }
private static final <T extends Comparable<T>> T min(final T a, final T b) { return a.compareTo(b) <= 0 ? a : b; }
private static final int min(final int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
private static final long min(final long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
private static final double min(final double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
private static final int max(final int a, final int b) { return Math.max(a, b); }
private static final long max(final long a, final long b) { return Math.max(a, b); }
private static final double max(final double a, final double b) { return Math.max(a, b); }
private static final <T extends Comparable<T>> T max(final T a, final T b) { return a.compareTo(b) >= 0 ? a : b; }
private static final int max(final int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
private static final long max(final long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
private static final double max(final double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
private static final <T extends Comparable<T>> T max(final T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
private static final int max(final int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
private static final long max(final long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
private static final double max(final double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
private static final <T extends Comparable<T>> T max(final T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
private static final long sum(final int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
private static final long sum(final long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
private static final double sum(final double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
private static final int sum(final boolean... a) { int sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
private static final long[] sums(final int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final long[] sums(final long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final double[] sums(final double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final int[] sums(final boolean[] a) { int sum[] = new int[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
private static final long[][] sums(final int[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final long[][] sums(final long[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final double[][] sums(final double[][] a) {
final double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final int[][] sums(final boolean[][] a) {
final int sum[][] = new int[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
private static final int constrain(final int x, final int l, final int r) { return min(max(x, min(l, r)), max(l, r)); }
private static final long constrain(final long x, final long l, final long r) { return min(max(x, min(l, r)), max(l, r)); }
private static final double constrain(final double x, final double l, final double r) { return min(max(x, min(l, r)), max(l, r)); }
private static final int abs(final int x) { return x >= 0 ? x : - x; }
private static final long abs(final long x) { return x >= 0 ? x : - x; }
private static final double abs(final double x) { return x >= 0 ? x : - x; }
private static final int signum(final int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final long round(final double x) { return Math.round(x); }
private static final long floor(final double x) { return round(Math.floor(x)); }
private static final int divfloor(final int a, final int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long divfloor(final long a, final long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long ceil(final double x) { return round(Math.ceil(x)); }
private static final int divceil(final int a, final int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final long divceil(final long a, final long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final boolean mulGreater(final long a, final long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
private static final boolean mulGreaterEquals(final long a, final long b, final long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
private static final boolean mulLess(final long a, final long b, final long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
private static final boolean mulLessEquals(final long a, final long b, final long c) { return !mulGreater(a, b, c); } // a * b <= c
private static final double sqrt(final int x) { return Math.sqrt((double)x); }
private static final double sqrt(final long x) { return Math.sqrt((double)x); }
private static final double sqrt(final double x) { return Math.sqrt(x); }
private static final int floorsqrt(final int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final long floorsqrt(final long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final int ceilsqrt(final int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long ceilsqrt(final long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long fact(final int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
private static final long naiveP(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
private static final long naiveC(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
private static final double pow(final double x, final double y) { return Math.pow(x, y); }
private static final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
private static final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
private static final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
private static final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
private static final long lcm(final long a, final long b) { return a / gcd(a, b) * b; }
private static final int gcd(final int... a) { int gcd = 0; for(int ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final long gcd(final long... a) { long gcd = 0; for(long ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final double random() { return Math.random(); }
private static final int random(final int max) { return (int)floor(random() * max); }
private static final long random(final long max) { return floor(random() * max); }
private static final double random(final double max) { return random() * max; }
private static final int random(final int min, final int max) { return random(max - min) + min; }
private static final long random(final long min, final long max) { return random(max - min) + min; }
private static final double random(final double min, final double max) { return random(max - min) + min; }
private static final boolean isUpper(final char c) { return c >= 'A' && c <= 'Z'; }
private static final boolean isLower(final char c) { return c >= 'a' && c <= 'z'; }
private static final int upperToInt(final char c) { return c - 'A'; }
private static final int lowerToInt(final char c) { return c - 'a'; }
private static final int numToInt(final char c) { return c - '0'; }
private static final int charToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) : numToInt(c); }
private static final int alphabetToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) + 26 : 52; }
private static final char intToUpper(final int x) { return (char)(x + 'A'); }
private static final char intToLower(final int x) { return (char)(x + 'a'); }
private static final char intToNum(final int x) { return (char)(x + '0'); }
private static final int[] charToInt(final char[] a) { final int toint[] = new int[a.length]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final int[][] charToInt(final char[][] a) { final int toint[][] = new int[a.length][]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final long[] div(final long x) {
nonNegativeCheck(x);
final List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= x; i ++) if(x % i == 0) { divList.add(i); if(i * i != x) divList.add(x / i); }
final long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
private static final PairLL[] factor(long x) {
nonNegativeCheck(x);
final List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= x; i ++) {
if(x % i == 0) {
long cnt = 0;
while(x % i == 0) { x /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(x > 1) factorList.add(new PairLL(x, 1));
final PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
private static final boolean isPrime(final long x) { if(x <= 1) return false; for(long i = 2; i * i <= x; i ++) if(x % i == 0) return false; return true; }
private static final boolean[] prime(final int n) {
nonNegativeCheck(n);
final boolean prime[] = new boolean[n];
fill(prime, true);
if(n > 0) prime[0] = false;
if(n > 1) prime[1] = false;
for(int i = 2; i < n; i ++) if(prime[i]) for(int j = 2; i * j < n; j ++) prime[i * j] = false;
return prime;
}
private static final PairIL[] countElements(final int[] a, final boolean sort) {
final int len = a.length;
final int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairLL[] countElements(final long[] a, final boolean sort) {
final int len = a.length;
final long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairIL[] countElements(final String s, final boolean sort) {
final int len = s.length();
final char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final long triangular(final long n) { return n * (n + 1) / 2; }
private static final long arctriangularfloor(final long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
private static final long arctriangularceil(final long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
private static final int[] baseConvert(long x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final long x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int[] baseConvert(int x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final int x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
int tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final long[] baseConvert(long x, final long n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final long digit[] = new long[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = x % n; x /= n; }
return digit;
}
private static final long[] baseConvert(final long x, final long n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int numDigits(final long x) { nonNegativeCheck(x); return Long.toString(x).length(); }
private static final long bitFlag(final int i) { nonNegativeCheck(i); return 1L << i; }
private static final boolean isFlagged(final long x, final int i) { nonNegativeCheck(x); nonNegativeCheck(i); return (x >> i & 1) != 0; }
private static final long countString(final String s, final String t) { return (s.length() - s.replace(t, "").length()) / t.length(); }
private static final long countStringAll(final String s, final String t) { return s.length() - s.replaceAll(t, "").length(); }
private static final String reverse(final String s) { return (new StringBuilder(s)).reverse().toString(); }
private static final char[] reverse(final char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final boolean[] reverse(final boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final int[] reverse(final int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final long[] reverse(final long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final double[] reverse(final double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final String[] reverse(final String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final Object[] reverse(final Object[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final void fill(final char[] a, final char x) { Arrays.fill(a, x); }
private static final void fill(final boolean[] a, final boolean x) { Arrays.fill(a, x); }
private static final void fill(final int[] a, final int x) { Arrays.fill(a, x); }
private static final void fill(final long[] a, final long x) { Arrays.fill(a, x); }
private static final void fill(final double[] a, final double x) { Arrays.fill(a, x); }
private static final void fill(final char[][] a, final char x) { for(char[] ele : a) fill(ele, x); }
private static final void fill(final boolean[][] a, final boolean x) { for(boolean[] ele : a) fill(ele, x); }
private static final void fill(final int[][] a, final int x) { for(int[] ele : a) fill(ele, x); }
private static final void fill(final long[][] a, final long x) { for(long[] ele : a) fill(ele, x); }
private static final void fill(final double[][] a, final double x) { for(double[] ele : a) fill(ele, x); }
private static final void fill(final char[][][] a, final char x) { for(char[][] ele : a) fill(ele, x); }
private static final void fill(final boolean[][][] a, final boolean x) { for(boolean[][] ele : a) fill(ele, x); }
private static final void fill(final int[][][] a, final int x) { for(int[][] ele : a) fill(ele, x); }
private static final void fill(final long[][][] a, final long x) { for(long[][] ele : a) fill(ele, x); }
private static final void fill(final double[][][] a, final double x) { for(double[][] ele : a) fill(ele, x); }
private static final char[] resize(final char[] a, final int m, final int x) {
nonNegativeCheck(m);
final char resized[] = new char[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final boolean[] resize(final boolean[] a, final int m, final int x) {
nonNegativeCheck(m);
final boolean resized[] = new boolean[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] resize(final int[] a, final int m, final int x) {
nonNegativeCheck(m);
final int resized[] = new int[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final long[] resize(final long[] a, final int m, final int x) {
nonNegativeCheck(m);
final long resized[] = new long[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final double[] resize(final double[] a, final int m, final int x) {
nonNegativeCheck(m);
final double resized[] = new double[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final String[] resize(final String[] a, final int m, final int x) {
nonNegativeCheck(m);
final String resized[] = new String[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final Object[] resize(final Object[] a, final int m, final int x) {
nonNegativeCheck(m);
final Object resized[] = new Object[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] toIntArray(final List<Integer> list) { final int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
private static final long[] toLongArray(final List<Long> list) { final long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
private static final double[] toDoubleArray(final List<Double> list) { final double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
private static final char[] toCharArray(final List<Character> list) { final char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
private static final boolean[] toBooleanArray(final List<Boolean> list) { final boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
private static final String[] toStringArray(final List<String> list) { final String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
private static final <T> void toArray(final List<T> list, final T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
private static final void shuffleArray(final int[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final long[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final double[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final int[] randomi(final int n, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final long[] randoml(final int n, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final double[] randomd(final int n, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final int[] randomi(final int n, final int min, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final long[] randoml(final int n, final long min, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final double[] randomd(final int n, final double min, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final void swap(final char[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final boolean[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final int[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final long[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final double[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final String[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final Object[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final char[][] rotate(final char[][] a) {
final char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final boolean[][] rotate(final boolean[][] a) {
final boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[][] rotate(final int[][] a) {
final int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final long[][] rotate(final long[][] a) {
final long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final double[][] rotate(final double[][] a) {
final double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final Object[][] rotate(final Object[][] a) {
final Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[] compress(final int[] a) {
final int n = a.length;
final Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final long[] compress(final long[] a) {
final int n = a.length;
final Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final double[] compress(final double[] a) {
final int n = a.length;
final Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
// binary search
private static final int lowerBound(final int[] a, final int key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final int[] a, final int key) { return BS(a, key, true, true, false); }
private static final int upperBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final int[] a, final int key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final int[] a, final int index, final int key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final long[] a, final long key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final long[] a, final long key) { return BS(a, key, true, true, false); }
private static final int upperBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final long[] a, final long key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final long[] a, final int index, final long key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final double[] a, final double key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final double[] a, final double key) { return BS(a, key, true, true, false); }
private static final int upperBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final double[] a, final double key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final double[] a, final int index, final double key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final T[] a, final int index, final T key, final boolean gt, final boolean eq) {
int compare = a[index].compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
private static final <T> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final T[] a, final int index, T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a[index], key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final List<T> a, final int index, T key, final boolean gt, final boolean eq) {
int compare = a.get(index).compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
private static final <T> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final List<T> a, final int index, final T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a.get(index), key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final PairLL binaryRangeSearch(final long left, final long right, final UnaryOperator<Long> op, final boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) >> 1;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) >> 1;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
private static final double ternarySearch(double left, double right, final UnaryOperator<Double> op, final boolean minimize, final int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
private static final class Mod107 extends Mod {
public static final Mod107 md = new Mod107();
public static final long MOD = 1_000_000_007;
private Mod107() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod998 extends Mod {
public static final Mod998 md = new Mod998();
public static final long MOD = 998_244_353;
private Mod998() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod754974721 extends Mod {
public static final Mod754974721 md = new Mod754974721();
public static final long MOD = 754_974_721;
private Mod754974721() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod167772161 extends Mod {
public static final Mod167772161 md = new Mod167772161();
public static final long MOD = 167_772_161;
private Mod167772161() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod469762049 extends Mod {
public static final Mod469762049 md = new Mod469762049();
public static final long MOD = 469_762_049;
private Mod469762049() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class ArbitraryMod extends Mod {
private static final long MASK = 0xffff_ffffl;
private final long MH;
private final long ML;
public ArbitraryMod(long mod) { super(mod); long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
private final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
@Override
public long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return reduce(x);
}
@Override
public long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return reduce(x * y);
x = mod(x);
y = mod(y);
return reduce(x * y);
}
}
private abstract static class Mod {
public final long MOD;
public Mod(long mod) { MOD = mod; }
public abstract long mod(long x);
public final long[] mod(final long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
public final long[][] mod(final long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public final long[][][] mod(final long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public long add(long x, final long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
public final long sum(final long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
public long sub(long x, final long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
public final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
public abstract long mul(long x, long y);
public final long mul(final long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
public final long div(final long x, final long y) { return mul(x, inv(y)); }
public final long[] pows(long x, final int n) {
x = mod(x);
long pow[] = new long[n + 1];
pow[0] = 1;
for(int i = 0; i < n; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
public final long fact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
public final long invFact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
private static final int MAX_INV_SIZE = 100_100;
public final Map<Long, Long> invMap = new HashMap<>();
public final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
private final long calInv(final long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
public final long[] invs(final int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
private long g;
public final long primitiveRoot() { // O(1) or O(M^(1/2))
if(MOD == 2) return 1;
if(MOD == 167772161) return 3;
if(MOD == 469762049) return 3;
if(MOD == 754974721) return 11;
if(MOD == 998244353) return 3;
if(g != 0) return g;
PairLL factor[] = factor(MOD - 1);
outer: for(g = 2; ; g ++) {
for(PairLL p : factor) if(pow(g, (MOD - 1) / p.a) == 1) continue outer;
return g;
}
}
private static final int MAX_FACT1 = 5_000_100;
private static final int MAX_FACT2 = 500_100;
private static final int MAX_FACT_MAP_SIZE = 100;
private long fact[];
private long invFact[];
private boolean isFactPrepared = false;
private final Map<Long, long[]> factMap = new HashMap<>();
private final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
public final long P(final long n, final long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
public final long C(final long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
final int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
public final long H(final long n, final long r) { return C(n - 1 + r, r); }
public final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
private static final long mod(long x, final long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
private static final long pow(long x, long y, final long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
private static class Grids {
public final int h, w;
public final Grid[][] gs;
public final Grid[] gi;
public Grids(final int h, final int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
public final void init(final boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
public final void init(final long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
public final Grid get(final int x, final int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
public final Grid get(final int i) { return get(i / w, i % w); }
public static final int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
public static final int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
public final Grid next(final int x, final int y, final int i) { return next(gs[x][y], i); }
public final Grid next(final Grid g, final int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
private static class Grid implements Comparable<Grid> {
public int x, y, h, w, i; public boolean b; public long val;
public Grid() { }
public Grid(final int x, final int y, final int h, final int w) { init(x, y, h, w, false, 0); }
public Grid(final int x, final int y, final int h, final int w, final boolean b) { init(x, y, h, w, b, 0); }
public Grid(final int x, final int y, final int h, final int w, final long val) { init(x, y, h, w, false, val); }
public Grid(final int x, final int y, final int h, final int w, final boolean b, final long val) { init(x, y, h, w, b, val); }
public final void init(final int x, final int y, final int h, final int w, final boolean b, final long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public final String toString() { return "("+x+", "+y+")"+" "+booleanToChar(b)+" "+val; }
@Override public final int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public final int compareTo(final Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
private static final boolean isValid(final int x, final int y, final int h, final int w) { return x >= 0 && x < h && y >= 0 && y < w; }
private static final boolean isValid(final Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
private static class Graph {
public int numNode, numEdge;
public boolean directed;
public List<Edge> edges = new ArrayList<>();
public Node nodes[];
public Node reversedNodes[];
public Graph(final int numNode, final int numEdge, final boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
public void init(final List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
public void add(final int source, final int target, final long cost) { add(new Edge(source, target, cost)); }
public void add(final Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
public void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
private static class Node extends ArrayList<Edge> {
public final int id;
public Node(final int id) { this.id = id; }
public void add(final int target, final long cost) { add(new Edge(id, target, cost)); }
}
private static class Edge implements Comparable<Edge> {
public int source, target; public long cost;
public Edge(final int source, final int target, final long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public final String toString() { return source+" - "+cost+" -> "+target; }
@Override public final int hashCode() { return Objects.hash(source, target); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public final int compareTo(final Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
private static class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
public T a; public U b;
public Pair() { }
public Pair(final T a, final U b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public final int compareTo(final Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
private static final PairII npii() { return new PairII(ni(), ni()); }
private static final PairII[] npii(final int n) { final PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
private static final PairII[][] npii(final int n, final int m) { final PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
private static class PairII implements Comparable<PairII> {
public int a; public int b;
public PairII() { }
public PairII(final int a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairIL npil() { return new PairIL(ni(), nl()); }
private static final PairIL[] npil(final int n) { final PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
private static final PairIL[][] npil(final int n, final int m) { final PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
private static class PairIL implements Comparable<PairIL> {
public int a; public long b;
public PairIL() { }
public PairIL(final int a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairID npid() { return new PairID(ni(), nd()); }
private static final PairID[] npid(final int n) { final PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
private static final PairID[][] npid(final int n, final int m) { final PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
private static class PairID implements Comparable<PairID> {
public int a; public double b;
public PairID() { }
public PairID(final int a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairLI npli() { return new PairLI(nl(), ni()); }
private static final PairLI[] npli(final int n) { final PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
private static final PairLI[][] npli(final int n, final int m) { final PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
private static class PairLI implements Comparable<PairLI> {
public long a; public int b;
public PairLI() { }
public PairLI(final long a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairLL npll() { return new PairLL(nl(), nl()); }
private static final PairLL[] npll(final int n) { final PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
private static final PairLL[][] npll(final int n, final int m) { final PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
private static class PairLL implements Comparable<PairLL> {
public long a; public long b;
public PairLL() { }
public PairLL(final long a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairLD npld() { return new PairLD(nl(), nd()); }
private static final PairLD[] npld(final int n) { final PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
private static final PairLD[][] npld(final int n, final int m) { final PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
private static class PairLD implements Comparable<PairLD> {
public long a; public double b;
public PairLD() { }
public PairLD(final long a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairDI npdi() { return new PairDI(nd(), ni()); }
private static final PairDI[] npdi(final int n) { final PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
private static final PairDI[][] npdi(final int n, final int m) { final PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
private static class PairDI implements Comparable<PairDI> {
public double a; public int b;
public PairDI() { }
public PairDI(final double a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairDL npdl() { return new PairDL(nd(), nl()); }
private static final PairDL[] npdl(final int n) { final PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
private static final PairDL[][] npdl(final int n, final int m) { final PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
private static class PairDL implements Comparable<PairDL> {
public double a; public long b;
public PairDL() { }
public PairDL(final double a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairDD npdd() { return new PairDD(nd(), nd()); }
private static final PairDD[] npdd(final int n) { final PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
private static final PairDD[][] npdd(final int n, final int m) { final PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
private static class PairDD implements Comparable<PairDD> {
public double a; public double b;
public PairDD() { }
public PairDD(final double a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
// Tuple
private interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
private static class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
public T t; public V a;
public BasicTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public final String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public final int hashCode() { return Objects.hash(t, a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
private static class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
public V a;
public UniqueTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public final String toString() { return "("+a.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
private static class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
public Tuple1() { super(); }
public Tuple1(final T0 a0) { super(); this.a = a0; }
final T0 get0() { return a; }
final void set0(final T0 x) { a = x; }
}
private static class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
public Tuple2() { super(); }
public Tuple2(final T0 a0, final T1 a1) { super(); this.t = new Tuple1<>(a0); this.a = a1; }
final T0 get0() { return t.get0(); }
final T1 get1() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { a = x; }
}
private static class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
public Tuple3() { super(); }
public Tuple3(final T0 a0, final T1 a1, final T2 a2) { super(); this.t = new Tuple2<>(a0, a1); this.a = a2; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { a = x; }
}
private static class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
public Tuple4() { super(); }
public Tuple4(final T0 a0, final T1 a1, final T2 a2, final T3 a3) { super(); this.t = new Tuple3<>(a0, a1, a2); this.a = a3; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { a = x; }
}
private static class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
public Tuple5() { super(); }
public Tuple5(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4) { super(); this.t = new Tuple4<>(a0, a1, a2, a3); this.a = a4; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { a = x; }
}
private static class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
public Tuple6() { super(); }
public Tuple6(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) { super(); this.t = new Tuple5<>(a0, a1, a2, a3, a4); this.a = a5; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { a = x; }
}
private static class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
public Tuple7() { super(); }
public Tuple7(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) { super(); this.t = new Tuple6<>(a0, a1, a2, a3, a4, a5); this.a = a6; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { a = x; }
}
private static class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
public Tuple8() { super(); }
public Tuple8(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) { super(); this.t = new Tuple7<>(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return t.get6(); }
final T7 get7() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { t.set6(x); }
final void set7(final T7 x) { a = x; }
}
// Tuple3
private static class TupleIII implements Comparable<TupleIII> {
public int a; public int b; public int c;
public TupleIII() { }
public TupleIII(final int a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIIL implements Comparable<TupleIIL> {
public int a; public int b; public long c;
public TupleIIL() { }
public TupleIIL(final int a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
private static class TupleIID implements Comparable<TupleIID> {
public int a; public int b; public double c;
public TupleIID() { }
public TupleIID(final int a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleILI implements Comparable<TupleILI> {
public int a; public long b; public int c;
public TupleILI() { }
public TupleILI(final int a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleILL implements Comparable<TupleILL> {
public int a; public long b; public long c;
public TupleILL() { }
public TupleILL(final int a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleILD implements Comparable<TupleILD> {
public int a; public long b; public double c;
public TupleILD() { }
public TupleILD(final int a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleIDI implements Comparable<TupleIDI> {
public int a; public double b; public int c;
public TupleIDI() { }
public TupleIDI(final int a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIDL implements Comparable<TupleIDL> {
public int a; public double b; public long c;
public TupleIDL() { }
public TupleIDL(final int a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleIDD implements Comparable<TupleIDD> {
public int a; public double b; public double c;
public TupleIDD() { }
public TupleIDD(final int a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLII implements Comparable<TupleLII> {
public long a; public int b; public int c;
public TupleLII() { }
public TupleLII(final long a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLIL implements Comparable<TupleLIL> {
public long a; public int b; public long c;
public TupleLIL() { }
public TupleLIL(final long a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLID implements Comparable<TupleLID> {
public long a; public int b; public double c;
public TupleLID() { }
public TupleLID(final long a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLLI implements Comparable<TupleLLI> {
public long a; public long b; public int c;
public TupleLLI() { }
public TupleLLI(final long a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLLL implements Comparable<TupleLLL> {
public long a; public long b; public long c;
public TupleLLL() { }
public TupleLLL(final long a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLLD implements Comparable<TupleLLD> {
public long a; public long b; public double c;
public TupleLLD() { }
public TupleLLD(final long a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLDI implements Comparable<TupleLDI> {
public long a; public double b; public int c;
public TupleLDI() { }
public TupleLDI(final long a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLDL implements Comparable<TupleLDL> {
public long a; public double b; public long c;
public TupleLDL() { }
public TupleLDL(final long a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLDD implements Comparable<TupleLDD> {
public long a; public double b; public double c;
public TupleLDD() { }
public TupleLDD(final long a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDII implements Comparable<TupleDII> {
public double a; public int b; public int c;
public TupleDII() { }
public TupleDII(final double a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDIL implements Comparable<TupleDIL> {
public double a; public int b; public long c;
public TupleDIL() { }
public TupleDIL(final double a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDID implements Comparable<TupleDID> {
public double a; public int b; public double c;
public TupleDID() { }
public TupleDID(final double a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDLI implements Comparable<TupleDLI> {
public double a; public long b; public int c;
public TupleDLI() { }
public TupleDLI(final double a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDLL implements Comparable<TupleDLL> {
public double a; public long b; public long c;
public TupleDLL() { }
public TupleDLL(final double a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDLD implements Comparable<TupleDLD> {
public double a; public long b; public double c;
public TupleDLD() { }
public TupleDLD(final double a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDDI implements Comparable<TupleDDI> {
public double a; public double b; public int c;
public TupleDDI() { }
public TupleDDI(final double a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDDL implements Comparable<TupleDDL> {
public double a; public double b; public long c;
public TupleDDL() { }
public TupleDDL(final double a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDDD implements Comparable<TupleDDD> {
public double a; public double b; public double c;
public TupleDDD() { }
public TupleDDD(final double a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
int n = ni();
String s[] = ns(n);
boolean connected[][] = new boolean[n][n];
for(int i = 0; i < n; i ++) {
for(int j = 0; j < n; j ++) {
connected[i][j] = s[i].charAt(s[i].length() - 1) == s[j].charAt(0);
}
}
int maxBit = 1 << n;
boolean win[][] = new boolean[maxBit][n];
for(int bit = 0; bit < maxBit; bit ++) {
for(int i = 0; i < n; i ++) {
for(int j = 0; j < n; j ++) {
if(isFlagged(bit, j) && connected[i][j]) {
win[bit][i] |= !win[bit ^ (1 << j)][j];
}
}
}
}
boolean ans = false;
for(int i = 0; i < n; i ++) ans |= !win[(maxBit - 1) ^ (1 << i)][i];
prtln(ans ? "First" : "Second");
}
}
}
|
ConDefects/ConDefects/Code/abc278_f/Java/39520611
|
condefects-java_data_567
|
import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
static FastScanner sc ;
static PrintWriter pw ;
static final int inf = Integer.MAX_VALUE / 2 ;
static final long linf = Long.MAX_VALUE / 2L ;
static final String yes = "Yes" ;
static final String no = "No" ;
static final int mod1 = 1000000007 ;
static final int mod = 998244353 ;
public static void solve() {
int N = ni() ;
String[] S = nsa( N ) ;
for ( int i = 0 ; i < N ; i++ ) {
S[i] = S[i].substring( 0 , 1 ) + S[i].substring( S[i].length() - 1 , S[i].length() ) ;
}
char[] w = new char[26] ;
for ( int i = 0 ; i < 26 ; i++ ) w[i] = (char)( 'a' + i ) ;
boolean[][] dp = new boolean[1<<N][26] ;
for ( int i = 1 ; i < ( 1 << N ) ; i++ ) {
for ( int j = 0 ; j < 26 ; j++ ) {
for ( int k = 0 ; k < N ; k++ ) {
if ( ( i & ( 1 << k ) ) == 0 ) continue ;
if ( w[j] != S[k].charAt( 0 ) ) continue ;
if ( Integer.bitCount( i ) == 1 ) dp[i][j] = true ;
else dp[i][j] = !dp[i^(1<<k)][(int)(S[k].charAt( 1 ) - 'a')] ;
}
}
}
for ( int i = 0 ; i < 26 ; i++ ) {
if ( dp[(1<<N)-1][i] ) {
pr( "First" ) ;
return ;
}
}
pr( "Second" ) ;
}
public static void main(String[] args) {
sc = new FastScanner() ;
pw = new PrintWriter( System.out ) ;
solve() ;
pw.flush() ;
pw.close() ;
}
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
}
static class UnionFind{
int[] par ,siz ;
int con ;
public UnionFind( int n ) { init( n ) ; }
public void init( int n ) {
this.par = new int[n] ; this.siz = new int[n] ;
Arrays.setAll( par , i -> i ) ; Arrays.fill( siz , 1 ) ;
con = n ;
}
public int root( int x ) { if ( x == par[x] ) return x ; return par[x] = root( par[x] ) ; }
public boolean same( int x , int y ) { return root( x ) == root( y ) ; }
public int size( int n ) { return siz[root(n)] ; }
public int cnt() { return con ; }
public void unite( int x , int y ) {
if ( same( x , y ) ) return ;
x = root( x ) ; y = root( y ) ;
if ( siz[x] > siz[y] ) { par[y] = x ; siz[x] += siz[y] ; }
else { par[x] = y ; siz[y] += siz[x] ; }
con-- ;
}
}
static class MultiSet<T extends Comparable<T>> {
TreeMap<T,Long> map ; long c ;
MultiSet() { this.map = new TreeMap<T,Long>() ; c = 0L ; }
void add( T x ) { add( x , 1L ) ; }
void add( T x , long c ) { map.put( x , map.getOrDefault( x , 0L ) + c ) ; this.c += c ; }
void removeAll( T x ) { if ( !map.containsKey( x ) ) return ; remove( x , map.get( x ) ) ; }
void remove( T x , long c ) { if ( !map.containsKey( x ) ) return ; this.c -= Main.min( map.get( x ) , c ) ; if ( map.get( x ) <= c ) { map.remove( x ) ; return ; } map.put( x , map.get( x ) - c ) ; }
void remove( T x ) { remove( x , 1 ) ; }
T max() { return map.lastKey() ; }
T min() { return map.firstKey() ; }
T higher( T key ) { return map.higherKey( key ) ; }
T lower( T key ) { return map.lowerKey( key ) ; }
T ceiling( T key ) { return map.ceilingKey( key ) ; }
T floor( T key ) { return map.floorKey( key ) ; }
boolean contains( T key ) { return map.containsKey( key ) ; }
long count( T key ) { return map.getOrDefault( key , 0L ) ; }
int size() { return map.size() ; }
long amount() { return c ; }
Set<T> keySet() { return map.keySet() ; }
void merge( MultiSet<T> S ) { for ( T key : S.keySet() ) add( key , S.count( key ) ) ; this.c += S.amount() ; }
}
static class ModInt{
int mod ; long[] fac , finv , inv ; int size = 200001 ;
ModInt( int mod ) { this.mod = mod ; }
int mod( long a ) { a %= mod ; return a < 0 ? (int)a + mod : (int)a ; }
int add( int a , int b ) { return this.mod( (long)a + (long)b ) ; }
int add( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = this.add( res , x[i] ) ; return res ; }
int add( long a , long b ) { return this.mod( this.mod( a ) + this.mod( b ) ) ; }
int add( long... x ) { int res = this.mod( x[0] ) ; for ( int i = 1 ; i < x.length ; i++ ) res = this.add( res , this.mod( x[i] ) ) ; return res ; }
int time( int a , int b ) { return this.mod( (long)a * (long)b ) ; }
int time( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = this.time( res , x[i] ) ; return res ; }
int time( long a , long b ) { return this.time( this.mod( a ) , this.mod( b ) ) ; }
int time( long... x ) { int res = this.mod( x[0] ) ; for ( int i = 1 ; i < x.length ; i++ ) res = this.time( res , this.mod( x[i] ) ) ; return res ; }
int fact( int a ) { int res = 1 ; for ( int i = 2 ; i <= a ; i++ ) res = this.time( res , i ) ; return res ; }
int inv( int a ) { return this.pow( a , mod - 2 ) ; }
int pow( int a , long b ) { int res = 1 ; while ( b > 0L ) { if ( ( b & 1L ) != 0L ) res = this.time( res , a ) ; b /= 2L ; a = this.time( a , a ) ; } return res ; }
int pow( long a , long b ) { return this.pow( this.mod( a ) , b ) ; }
int nPk( int n , int k ) { if ( n < k || n < 0 || k < 0 ) return 0 ; int res = 1 ; for ( int i = 1 ; i <= k ; i++ ) { res = this.time( res , n + 1 - i ) ; } return res ; }
int nCk( int n , int k ) {
if ( n < k || n < 0 || k < 0 ) return 0 ;
int res = 1 ;
for ( int i = 1 ; i <= k ; i++ ) res = this.time( res , this.time( n + 1 - i , this.inv( i ) ) ) ;
return res ;
}
int nCk2( int n , int k ) { if ( n < k || n < 0 || k < 0 ) return 0 ; comInit( n ) ; return this.time( fac[n] , ( this.time( finv[k] , finv[n-k] ) ) ) ; }
int nHr( int n , int r ) { return nCk2( n + r - 1 , r ) ; }
void comInit() { comInit( this.size ) ; }
void comInit( int n ) {
if ( fac != null && this.size > n ) return ;
this.size = (int)Math.max( n , this.size ) ;
fac = new long[size] ; finv = new long[size] ; inv = new long[size] ;
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1 ;
for ( int i = 2 ; i < size ; i++ ) { fac[i] = this.time( fac[i-1] , i ) ; inv[i] = mod - this.time( inv[mod%i] , mod / i ) ; finv[i] = this.time( finv[i-1] , inv[i] ) ; }
}
}
public static int ni() { return Integer.parseInt( sc.next() ) ;}
public static int[] nia( int N ) { int[] res = new int[N]; Arrays.setAll( res , i -> ni() ) ; return res ; }
public static int[][] nia( int N , int M ) { int[][] res = new int[N][M]; for ( int i = 0 ; i < N ; i++ ) Arrays.setAll( res[i] , j -> ni() ) ; return res ; }
public static long nl() { return Long.parseLong( sc.next() ) ;}
public static long[] nla( int N ) { long[] res = new long[N]; Arrays.setAll( res , i -> nl() ) ; return res ; }
public static long[][] nla( int N , int M ) { long[][] res = new long[N][M]; for ( int i = 0 ; i < N ; i++ ) Arrays.setAll( res[i] , j -> nl() ) ; return res ; }
public static String ns() { return sc.next() ;}
public static String[] nsa( int N ) { String[] res = new String[N]; Arrays.setAll( res , i -> ns() ) ; return res ; }
public static void pr( int... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( long... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( double... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( new BigDecimal( o[i] ).toPlainString() + " " ) ; pw.println( new BigDecimal( o[o.length-1] ).toPlainString() ) ; }
public static void pr( String... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( int o ) { pw.println( o ) ; }
public static void pr( long o ) { pw.println( o ) ; }
public static void pr( double o ) { pw.println( new BigDecimal( o ).toPlainString() ) ; }
public static void pr( String o ) { pw.println( o ) ; }
public static void pr( Object o ) { pw.println( o ) ; }
public static void debug( int... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( o[i] + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( long... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( o[i] + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( double... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( new BigDecimal( o[i] ).toPlainString() + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( String... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( o[i] + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( int o ) { System.err.println( o ) ; }
public static void debug( long o ) { System.err.println( o ) ; }
public static void debug( double o ) { System.err.println( new BigDecimal( o ).toPlainString() ) ; }
public static void debug( String o ) { System.err.println( o ) ; }
public static void debug( Object o ) { System.err.println( o ) ; }
public static int max( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static int min( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long max( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static long min( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long pow( int a , int b ) { long res = 1L ; for ( int i = 0 ; i < b ; i++ ) res *= (long)a ; return res ; }
public static long pow( long a , long b ) { long res = 1L ; for ( long i = 0L ; i < b ; i++ ) res *= a ; return res ; }
public static long[] cumsum( int[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static long[] cumsum( long[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static long gcd( long a, long b ) { if ( b > a ) return gcd( b, a ) ; if ( a % b != 0 ) return gcd( b, a % b ) ; return b ; }
public static int gcd( int a, int b ) { return (int)gcd( (long)a, (long)b ) ; }
public static int gcd( int... a ) { if ( a.length == 1 ) return a[0] ; int result = gcd( a[0], a[1] ) ; for ( int i = 2 ; i < a.length ; i++ ) result = gcd( result, a[i] ) ; return result ; }
public static long gcd( long... a ) { if ( a.length == 1 ) return a[0] ; long result = gcd( a[0], a[1] ) ; for ( int i = 2 ; i < a.length ; i++ ) result = gcd( result, a[i] ) ; return result ; }
public static long lcm( long a, long b ) { return ( a / gcd( a, b ) ) * b ; }
public static long lcm( int a, int b ) { return ( (long)a / gcd( a, b ) ) * (long)b ; }
public static String revStr( String s ) { return new StringBuilder( s ).reverse().toString() ; }
public static String sortStr( String s ) { char[] c = s.toCharArray() ; Arrays.sort( c ) ; return String.valueOf( c ) ; }
public static int[] prevPermutation( int[] A ) {
if ( A == null ) return null ; int N = A.length ;
for ( int i = 0 ; i < N ; i++ ) A[i] = A[i] * -1 ; A = nextPermutation( A ) ; if ( A != null ) for ( int i = 0 ; i < N ; i++ ) A[i] = A[i] * -1 ; return A ; }
public static int[] nextPermutation( int[] A ) {
if ( A == null ) return null ;
for ( int i = A.length - 1 ; i > 0 ; i-- ) {
if ( A[i-1] < A[i] ) { int j = find( A, A[i-1], i, A.length - 1 ) ; int tmp = A[j] ; A[j] = A[i-1] ; A[i-1] = tmp ; Arrays.sort( A, i, A.length ) ; return A ; }
}
return null ;
}
public static int find( int[] A, int dest, int f, int l ) { if ( f == l ) return f ; int m = ( f + l + 1 ) / 2 ; return ( A[m] <= dest ? find( A, dest, f, m - 1 ) : find( A, dest, m, l ) ) ; }
}
import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
static FastScanner sc ;
static PrintWriter pw ;
static final int inf = Integer.MAX_VALUE / 2 ;
static final long linf = Long.MAX_VALUE / 2L ;
static final String yes = "Yes" ;
static final String no = "No" ;
static final int mod1 = 1000000007 ;
static final int mod = 998244353 ;
public static void solve() {
int N = ni() ;
String[] S = nsa( N ) ;
for ( int i = 0 ; i < N ; i++ ) {
S[i] = S[i].substring( 0 , 1 ) + S[i].substring( S[i].length() - 1 , S[i].length() ) ;
}
char[] w = new char[26] ;
for ( int i = 0 ; i < 26 ; i++ ) w[i] = (char)( 'a' + i ) ;
boolean[][] dp = new boolean[1<<N][26] ;
for ( int i = 1 ; i < ( 1 << N ) ; i++ ) {
for ( int j = 0 ; j < 26 ; j++ ) {
for ( int k = 0 ; k < N ; k++ ) {
if ( ( i & ( 1 << k ) ) == 0 ) continue ;
if ( w[j] != S[k].charAt( 0 ) ) continue ;
if ( Integer.bitCount( i ) == 1 ) dp[i][j] = true ;
else dp[i][j] |= !dp[i^(1<<k)][(int)(S[k].charAt( 1 ) - 'a')] ;
}
}
}
for ( int i = 0 ; i < 26 ; i++ ) {
if ( dp[(1<<N)-1][i] ) {
pr( "First" ) ;
return ;
}
}
pr( "Second" ) ;
}
public static void main(String[] args) {
sc = new FastScanner() ;
pw = new PrintWriter( System.out ) ;
solve() ;
pw.flush() ;
pw.close() ;
}
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
}
static class UnionFind{
int[] par ,siz ;
int con ;
public UnionFind( int n ) { init( n ) ; }
public void init( int n ) {
this.par = new int[n] ; this.siz = new int[n] ;
Arrays.setAll( par , i -> i ) ; Arrays.fill( siz , 1 ) ;
con = n ;
}
public int root( int x ) { if ( x == par[x] ) return x ; return par[x] = root( par[x] ) ; }
public boolean same( int x , int y ) { return root( x ) == root( y ) ; }
public int size( int n ) { return siz[root(n)] ; }
public int cnt() { return con ; }
public void unite( int x , int y ) {
if ( same( x , y ) ) return ;
x = root( x ) ; y = root( y ) ;
if ( siz[x] > siz[y] ) { par[y] = x ; siz[x] += siz[y] ; }
else { par[x] = y ; siz[y] += siz[x] ; }
con-- ;
}
}
static class MultiSet<T extends Comparable<T>> {
TreeMap<T,Long> map ; long c ;
MultiSet() { this.map = new TreeMap<T,Long>() ; c = 0L ; }
void add( T x ) { add( x , 1L ) ; }
void add( T x , long c ) { map.put( x , map.getOrDefault( x , 0L ) + c ) ; this.c += c ; }
void removeAll( T x ) { if ( !map.containsKey( x ) ) return ; remove( x , map.get( x ) ) ; }
void remove( T x , long c ) { if ( !map.containsKey( x ) ) return ; this.c -= Main.min( map.get( x ) , c ) ; if ( map.get( x ) <= c ) { map.remove( x ) ; return ; } map.put( x , map.get( x ) - c ) ; }
void remove( T x ) { remove( x , 1 ) ; }
T max() { return map.lastKey() ; }
T min() { return map.firstKey() ; }
T higher( T key ) { return map.higherKey( key ) ; }
T lower( T key ) { return map.lowerKey( key ) ; }
T ceiling( T key ) { return map.ceilingKey( key ) ; }
T floor( T key ) { return map.floorKey( key ) ; }
boolean contains( T key ) { return map.containsKey( key ) ; }
long count( T key ) { return map.getOrDefault( key , 0L ) ; }
int size() { return map.size() ; }
long amount() { return c ; }
Set<T> keySet() { return map.keySet() ; }
void merge( MultiSet<T> S ) { for ( T key : S.keySet() ) add( key , S.count( key ) ) ; this.c += S.amount() ; }
}
static class ModInt{
int mod ; long[] fac , finv , inv ; int size = 200001 ;
ModInt( int mod ) { this.mod = mod ; }
int mod( long a ) { a %= mod ; return a < 0 ? (int)a + mod : (int)a ; }
int add( int a , int b ) { return this.mod( (long)a + (long)b ) ; }
int add( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = this.add( res , x[i] ) ; return res ; }
int add( long a , long b ) { return this.mod( this.mod( a ) + this.mod( b ) ) ; }
int add( long... x ) { int res = this.mod( x[0] ) ; for ( int i = 1 ; i < x.length ; i++ ) res = this.add( res , this.mod( x[i] ) ) ; return res ; }
int time( int a , int b ) { return this.mod( (long)a * (long)b ) ; }
int time( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = this.time( res , x[i] ) ; return res ; }
int time( long a , long b ) { return this.time( this.mod( a ) , this.mod( b ) ) ; }
int time( long... x ) { int res = this.mod( x[0] ) ; for ( int i = 1 ; i < x.length ; i++ ) res = this.time( res , this.mod( x[i] ) ) ; return res ; }
int fact( int a ) { int res = 1 ; for ( int i = 2 ; i <= a ; i++ ) res = this.time( res , i ) ; return res ; }
int inv( int a ) { return this.pow( a , mod - 2 ) ; }
int pow( int a , long b ) { int res = 1 ; while ( b > 0L ) { if ( ( b & 1L ) != 0L ) res = this.time( res , a ) ; b /= 2L ; a = this.time( a , a ) ; } return res ; }
int pow( long a , long b ) { return this.pow( this.mod( a ) , b ) ; }
int nPk( int n , int k ) { if ( n < k || n < 0 || k < 0 ) return 0 ; int res = 1 ; for ( int i = 1 ; i <= k ; i++ ) { res = this.time( res , n + 1 - i ) ; } return res ; }
int nCk( int n , int k ) {
if ( n < k || n < 0 || k < 0 ) return 0 ;
int res = 1 ;
for ( int i = 1 ; i <= k ; i++ ) res = this.time( res , this.time( n + 1 - i , this.inv( i ) ) ) ;
return res ;
}
int nCk2( int n , int k ) { if ( n < k || n < 0 || k < 0 ) return 0 ; comInit( n ) ; return this.time( fac[n] , ( this.time( finv[k] , finv[n-k] ) ) ) ; }
int nHr( int n , int r ) { return nCk2( n + r - 1 , r ) ; }
void comInit() { comInit( this.size ) ; }
void comInit( int n ) {
if ( fac != null && this.size > n ) return ;
this.size = (int)Math.max( n , this.size ) ;
fac = new long[size] ; finv = new long[size] ; inv = new long[size] ;
fac[0] = fac[1] = finv[0] = finv[1] = inv[1] = 1 ;
for ( int i = 2 ; i < size ; i++ ) { fac[i] = this.time( fac[i-1] , i ) ; inv[i] = mod - this.time( inv[mod%i] , mod / i ) ; finv[i] = this.time( finv[i-1] , inv[i] ) ; }
}
}
public static int ni() { return Integer.parseInt( sc.next() ) ;}
public static int[] nia( int N ) { int[] res = new int[N]; Arrays.setAll( res , i -> ni() ) ; return res ; }
public static int[][] nia( int N , int M ) { int[][] res = new int[N][M]; for ( int i = 0 ; i < N ; i++ ) Arrays.setAll( res[i] , j -> ni() ) ; return res ; }
public static long nl() { return Long.parseLong( sc.next() ) ;}
public static long[] nla( int N ) { long[] res = new long[N]; Arrays.setAll( res , i -> nl() ) ; return res ; }
public static long[][] nla( int N , int M ) { long[][] res = new long[N][M]; for ( int i = 0 ; i < N ; i++ ) Arrays.setAll( res[i] , j -> nl() ) ; return res ; }
public static String ns() { return sc.next() ;}
public static String[] nsa( int N ) { String[] res = new String[N]; Arrays.setAll( res , i -> ns() ) ; return res ; }
public static void pr( int... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( long... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( double... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( new BigDecimal( o[i] ).toPlainString() + " " ) ; pw.println( new BigDecimal( o[o.length-1] ).toPlainString() ) ; }
public static void pr( String... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( int o ) { pw.println( o ) ; }
public static void pr( long o ) { pw.println( o ) ; }
public static void pr( double o ) { pw.println( new BigDecimal( o ).toPlainString() ) ; }
public static void pr( String o ) { pw.println( o ) ; }
public static void pr( Object o ) { pw.println( o ) ; }
public static void debug( int... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( o[i] + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( long... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( o[i] + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( double... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( new BigDecimal( o[i] ).toPlainString() + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( String... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) System.err.print( o[i] + " " ) ; System.err.println( o[o.length-1] ) ; }
public static void debug( int o ) { System.err.println( o ) ; }
public static void debug( long o ) { System.err.println( o ) ; }
public static void debug( double o ) { System.err.println( new BigDecimal( o ).toPlainString() ) ; }
public static void debug( String o ) { System.err.println( o ) ; }
public static void debug( Object o ) { System.err.println( o ) ; }
public static int max( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static int min( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long max( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static long min( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long pow( int a , int b ) { long res = 1L ; for ( int i = 0 ; i < b ; i++ ) res *= (long)a ; return res ; }
public static long pow( long a , long b ) { long res = 1L ; for ( long i = 0L ; i < b ; i++ ) res *= a ; return res ; }
public static long[] cumsum( int[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static long[] cumsum( long[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static long gcd( long a, long b ) { if ( b > a ) return gcd( b, a ) ; if ( a % b != 0 ) return gcd( b, a % b ) ; return b ; }
public static int gcd( int a, int b ) { return (int)gcd( (long)a, (long)b ) ; }
public static int gcd( int... a ) { if ( a.length == 1 ) return a[0] ; int result = gcd( a[0], a[1] ) ; for ( int i = 2 ; i < a.length ; i++ ) result = gcd( result, a[i] ) ; return result ; }
public static long gcd( long... a ) { if ( a.length == 1 ) return a[0] ; long result = gcd( a[0], a[1] ) ; for ( int i = 2 ; i < a.length ; i++ ) result = gcd( result, a[i] ) ; return result ; }
public static long lcm( long a, long b ) { return ( a / gcd( a, b ) ) * b ; }
public static long lcm( int a, int b ) { return ( (long)a / gcd( a, b ) ) * (long)b ; }
public static String revStr( String s ) { return new StringBuilder( s ).reverse().toString() ; }
public static String sortStr( String s ) { char[] c = s.toCharArray() ; Arrays.sort( c ) ; return String.valueOf( c ) ; }
public static int[] prevPermutation( int[] A ) {
if ( A == null ) return null ; int N = A.length ;
for ( int i = 0 ; i < N ; i++ ) A[i] = A[i] * -1 ; A = nextPermutation( A ) ; if ( A != null ) for ( int i = 0 ; i < N ; i++ ) A[i] = A[i] * -1 ; return A ; }
public static int[] nextPermutation( int[] A ) {
if ( A == null ) return null ;
for ( int i = A.length - 1 ; i > 0 ; i-- ) {
if ( A[i-1] < A[i] ) { int j = find( A, A[i-1], i, A.length - 1 ) ; int tmp = A[j] ; A[j] = A[i-1] ; A[i-1] = tmp ; Arrays.sort( A, i, A.length ) ; return A ; }
}
return null ;
}
public static int find( int[] A, int dest, int f, int l ) { if ( f == l ) return f ; int m = ( f + l + 1 ) / 2 ; return ( A[m] <= dest ? find( A, dest, f, m - 1 ) : find( A, dest, m, l ) ) ; }
}
|
ConDefects/ConDefects/Code/abc278_f/Java/38545650
|
condefects-java_data_568
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// inputA
Scanner sc = new Scanner(System.in);
String S = sc.next();
int num = Integer.parseInt(S.substring(3,6));
if(num < 350 && num != 316) System.out.println("Yes");
else System.out.println("No");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// inputA
Scanner sc = new Scanner(System.in);
String S = sc.next();
int num = Integer.parseInt(S.substring(3,6));
if(0 < num && num < 350 && num != 316) System.out.println("Yes");
else System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/54728951
|
condefects-java_data_569
|
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.io.*;
import java.lang.reflect.Array;
import java.util.regex.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
String str1 = s.substring(0,2);
String str2 = s.substring(3,6);
if(Integer.parseInt(str2) < 350 && Integer.parseInt(str2) !=316){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.io.*;
import java.lang.reflect.Array;
import java.util.regex.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
String str1 = s.substring(0,2);
String str2 = s.substring(3,6);
if(Integer.parseInt(str2) < 350 && Integer.parseInt(str2) !=316 && Integer.parseInt(str2) != 000){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/54625327
|
condefects-java_data_570
|
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int s = Integer.parseInt(sc.next().substring(3));
if(s > 349 || s == 316) System.out.print("No");
else System.out.print("Yes");
}
}
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int s = Integer.parseInt(sc.next().substring(3));
if(s > 349 || s == 316 || s == 000) System.out.print("No");
else System.out.print("Yes");
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/54880072
|
condefects-java_data_571
|
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
String subS = s.substring(3);
int num = Integer.parseInt(subS);
if (num < 350 && num != 316) {
System.out.println("Yes");
System.exit(0);
}
System.out.println("No");
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
String subS = s.substring(3);
int num = Integer.parseInt(subS);
if (num > 0 && num < 350 && num != 316) {
System.out.println("Yes");
System.exit(0);
}
System.out.println("No");
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/53902495
|
condefects-java_data_572
|
import java.util.*;
public class Main {
public static void main(String[] args) {
// 自分の得意な言語で
// Let's チャレンジ！！
Scanner sc = new Scanner(System.in);
String S = sc.nextLine();
String[] S_N = S.split("C");
int num = Integer.parseInt(S_N[1]);
if (num < 350 && num != 316) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
// 自分の得意な言語で
// Let's チャレンジ！！
Scanner sc = new Scanner(System.in);
String S = sc.nextLine();
String[] S_N = S.split("C");
int num = Integer.parseInt(S_N[1]);
if (num > 1 && num < 350 && num != 316) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/53916582
|
condefects-java_data_573
|
public class Main {
public static void main(String[] args) {
java.util.Scanner sc = new java.util.Scanner(System.in);
String s = sc.next();
int num = Integer.parseInt(s.substring(3));
if(num == 316 || num >= 350) {
System.out.println("No");
} else {
System.out.println("Yes");
}
}
}
public class Main {
public static void main(String[] args) {
java.util.Scanner sc = new java.util.Scanner(System.in);
String s = sc.next();
int num = Integer.parseInt(s.substring(3));
if(num == 316 || num >= 350 || num <= 0) {
System.out.println("No");
} else {
System.out.println("Yes");
}
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/53989926
|
condefects-java_data_574
|
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String S = sc.next();
if(S.substring(3).equals("316")){
System.out.print("No");
}else{
if(Integer.parseInt(S.substring(3))<350){
System.out.print("Yes");
}else{
System.out.print("No");
}
}
sc.close();
}
}
import java.util.*;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String S = sc.next();
if(S.substring(3).equals("316")){
System.out.print("No");
}else{
if(Integer.parseInt(S.substring(3))<350 && Integer.parseInt(S.substring(3))>0){
System.out.print("Yes");
}else{
System.out.print("No");
}
}
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/54516064
|
condefects-java_data_575
|
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
String S = scan.nextLine();
String letters = S.replaceAll("[0-9]", "");
String numbers = S.replaceAll("[^0-9]", "");
int intNum = Integer.parseInt(numbers);
if((intNum == 316) || (intNum >= 350)){
System.out.println("No");
}else{
System.out.println("Yes");
}
scan.close();
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
String S = scan.nextLine();
String letters = S.replaceAll("[0-9]", "");
String numbers = S.replaceAll("[^0-9]", "");
int intNum = Integer.parseInt(numbers);
if((intNum == 316) || (intNum >= 350) || (intNum == 0)){
System.out.println("No");
}else{
System.out.println("Yes");
}
scan.close();
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/54656889
|
condefects-java_data_576
|
import java.util.Scanner;
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
String s = sc.next();
String rep = s.replace("ABC", "");
int castI = Integer.parseInt(rep);
if(castI == 316 || castI >= 350){
System.out.println("No");
}else{
System.out.println("Yes");
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
String s = sc.next();
String rep = s.replace("ABC", "");
int castI = Integer.parseInt(rep);
if(castI == 0 ||castI == 316 || castI >= 350){
System.out.println("No");
}else{
System.out.println("Yes");
}
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/55025638
|
condefects-java_data_577
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
var sc = new Scanner(System.in);
String s = sc.next();
for(int i = 3; i < 6; i ++ ) {
if(s.charAt(i) < '0' || s.charAt(i) > '9') {
System.out.print("No");
return ;
}
}
String s1 = s.substring(0, 3);
if(!s1.equals("ABC")) {
System.out.print("No");
return ;
}
int s2 = Integer.valueOf(s.substring(3));
if(s2 > 349 || s2 == 316) {
System.out.print("No");
return ;
} else {
System.out.print("Yes");
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
var sc = new Scanner(System.in);
String s = sc.next();
for(int i = 3; i < 6; i ++ ) {
if(s.charAt(i) < '0' || s.charAt(i) > '9') {
System.out.print("No");
return ;
}
}
String s1 = s.substring(0, 3);
if(!s1.equals("ABC")) {
System.out.print("No");
return ;
}
int s2 = Integer.valueOf(s.substring(3));
if(s2 > 349 || s2 == 316 || s2 <= 0) {
System.out.print("No");
return ;
} else {
System.out.print("Yes");
}
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/53940360
|
condefects-java_data_578
|
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int sEnd = Integer.parseInt(s.substring(3));
for(int i = 0; i < 350; i++){
if(i == 316) continue;
if(sEnd == i){
System.out.println("Yes");
return;
}
}
System.out.println("No");
return;
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int sEnd = Integer.parseInt(s.substring(3));
for(int i = 1; i < 350; i++){
if(i == 316) continue;
if(sEnd == i){
System.out.println("Yes");
return;
}
}
System.out.println("No");
return;
}
}
|
ConDefects/ConDefects/Code/abc350_a/Java/53817916
|
condefects-java_data_579
|
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
int N = sc.nextInt();
int K = sc.nextInt();
int[] test = new int[N];
int testindex = 0;
if(N/2<K) {
System.out.print(-1);
}else {
//
int fixketa = 0;
int freeketa = N;
while(true) {
if(freeketa-K*2>=K*2) {
for(int i=0; i<K*2;i++) {
test[testindex]=(i+K)%(K*2)+1+fixketa;
testindex++;
}
freeketa -= (K*2);
fixketa += (K*2);
}else {
for(int i=0; i<freeketa;i++) {
test[testindex]=(i+K)%freeketa+1+fixketa;
testindex++;
}
break;
}
}
if(N%K!=0&&fixketa!=0) {
int[] tmpleft = new int[N%K];
int[] tmpright= new int[N%K];
for(int i=0; i<N%K; i++) {
tmpleft[i]=test[N-2*K-(N%K)+i];
tmpright[i]=test[N-K+i];
}
for(int i=0; i<K-(N%K); i++) {
test[N-K+i]=test[N-K+i+(N%K)];
}
for(int i=0; i<N%K; i++) {
test[N-2*K-(N%K)+i]=tmpright[i];
test[N-(N%K)+i]=tmpleft[i];
}
}
for(int i=0; i<N; i++) {
System.out.print(test[i]+" ");
}
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try (Scanner sc = new Scanner(System.in)) {
int N = sc.nextInt();
int K = sc.nextInt();
int[] test = new int[N];
int testindex = 0;
if(N/2<K) {
System.out.print(-1);
}else {
//
int fixketa = 0;
int freeketa = N;
while(true) {
if(freeketa-K*2>=K*2) {
for(int i=0; i<K*2;i++) {
test[testindex]=(i+K)%(K*2)+1+fixketa;
testindex++;
}
freeketa -= (K*2);
fixketa += (K*2);
}else {
for(int i=0; i<freeketa;i++) {
test[testindex]=(i+K)%freeketa+1+fixketa;
testindex++;
}
break;
}
}
if(N%K!=0&&(N/K)%2==1) {
int[] tmpleft = new int[N%K];
int[] tmpright= new int[N%K];
for(int i=0; i<N%K; i++) {
tmpleft[i]=test[N-2*K-(N%K)+i];
tmpright[i]=test[N-K+i];
}
for(int i=0; i<K-(N%K); i++) {
test[N-K+i]=test[N-K+i+(N%K)];
}
for(int i=0; i<N%K; i++) {
test[N-2*K-(N%K)+i]=tmpright[i];
test[N-(N%K)+i]=tmpleft[i];
}
}
for(int i=0; i<N; i++) {
System.out.print(test[i]+" ");
}
}
}
}
}
|
ConDefects/ConDefects/Code/arc144_c/Java/33272197
|
condefects-java_data_580
|
/*
created by krps
本体は634行目あたりのsolve()に書いてあります。
Good Luck!
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
public class Main implements Runnable {
static FastScanner sc = new FastScanner();
static PrintWriter Systemout = new PrintWriter(System.out);
public static class Pair<K, V> extends AbstractMap.SimpleEntry<K, V> implements Comparable<Pair<K, V>> {
public Pair(final K key, final V value) {
super(key, value);
}
@Override
public int compareTo(Pair<K, V> o) {
Comparable key = (Comparable)this.getKey();
Comparable key2 = (Comparable)o.getKey();
/*if (false) {
Comparable key3 = (Comparable) this.getValue();
Comparable key4 = (Comparable) o.getValue();
if (key.compareTo(key2) == 0) {
return key3.compareTo(key4);
}
}*/
return key.compareTo(key2);
}
}
private static boolean isPrime(long t) {
if(t<2)return false;
for(int i=2;i*i<=t;i++) {
if(t%i==0)return false;
}
return true;
}
@SuppressWarnings("unused")
private static long ncr(long n,long r) {
long res=1;
for(int i=0;i<r;i++) {
res*=n-i;
res/=i+1;
}
return res;
}
@SuppressWarnings("unused")
private static int StringCount(String T,String v) {
int res=0;
int t=0;
while(T.indexOf(v,t)>=0) {
//p(t);
res++;
t=T.indexOf(v,t)+1;
}
return res;
}
private static void swap(long V[],int a,int b) {
long temp=V[b];
V[b]=V[a];
V[a]=temp;
}
private static void p(long[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(long[] a) {p(Arrays.toString(a));};
private static void p(int[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(int[] a) {p(Arrays.toString(a));};
//大量にout.println();をすると、自動でout.flush();されるので、出力される順番には気を付けよう
// * out.println()の後にSystem.out.println();をしたいときとかねー
private static <T> void p(T t) {Systemout.println(t);}
private static <T> void p() {Systemout.println();}
private static void p(graph.edge2[] e) {
for (int i = 0; i < e.length; i++) {
Systemout.println(e[i].to+" "+e[i].cost);
}
}
private static void doubleToString(double a) {
System.out.println(BigDecimal.valueOf(a).toPlainString());
}
private static ArrayList<Map<Integer,Integer>> c;
private static int ketawa(String S) {
int res=0;
for(int i=0;i<S.length();i++) {
res+=S.charAt(i)-'0';
}return res;
}
private static int ketawa(int S) {
int res=0;
while(S!=0) {
res+=S%10;
S/=10;
}
return res;
}
private static long X_x[]=new long[1];
private static long kaijou(int x,long mod) {
if(X_x.length!=300000)X_x=new long[300000];
if(x<=1)return X_x[x]=1;
if(X_x[x]!=0)return X_x[x];
return X_x[x]=(x*kaijou(x-1,mod))%mod;
/*long a=1;
for(int i=2;i<=K;i++)a=(a*i)%mod;
return (int)a;*/
}
static class segmentTree{
int n;
long dat[];
long identity;//単位元
segmentTree(int N,long identity) {//setTreeの要素の数,単位元
this.identity =identity;
init(N);
}
void init2() {
Arrays.fill(dat, 0);
}
void init(int n_) {
this.n=1;
while(n<n_)n*=2;
this.dat= new long[2*n-1];
Arrays.fill(dat, identity);
}
void update(int k,long a) {
k+=n-1;
dat[k]=a;
while(k>0) {
k=(k-1)/2;
//System.err.println("update "+k+" "+Cal(this.dat[k*2+1],this.dat[k*2+2]));
dat[k]=Cal(dat[k*2+1],dat[k*2+2]);
}
}
//外から呼び出すときはl=0,r=-1,k=0にする。
void update(int a,int b,int k,int X,int l,int r) {
if(r==-1)r=n;
if(r<=a||b<=l) {
return;
}
if(a<=l&&r<=b) {
dat[k]=min(dat[k],X);
}else {
update(a, b, k*2+1,X, l, (l+r)/2);
update(a, b,k*2+2,X,(l+r)/2,r);
}
}
long get(int k) {//k番目の値を取得 0<=k<N
k+=n-1;
return dat[k];
}
//[a,b]を求める。
//a~bのこと。0-indexed
long getV(int a,int b) {
a=Math.max(0,a);
b=min(n-1,b);
b++;
return query(a, b, 0, 0, n);
}
int getleft(int a,int b,long x) {
return find_leftest_sub(a, b, x, 0, 0, n);
}
int getright(int a,int b,long x) {
return find_rightest_sub(a, b, x, 0, 0, n);
}
//[a,b)の値を求める
//a~b-1のことで、0-indexed
//外から呼び出すときは、a,b,0,0,N
long query(int a,int b,int k,int l,int r) {
if(r<=a||b<=l) {
//l,rが求めたい区間a,bに完全に含まれていない
return identity;
}
if(a<=l&&r<=b) {
//l,rが、求めたい区間a,bに完全に含まれている
return dat[k];
}else {
//l,rが、求めたい区間a,bに一部分だけ含まれている。
long A=query(a, b, k*2+1, l, (l+r)/2);
long B=query(a, b, k*2+2, (l+r)/2, r);
return Cal(A,B);
}
}
//x以下の要素を持つ最も左のもののindexを返す。 *RM(min)Q上でしか動かない
int find_rightest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn a-1
return a - 1;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vr = find_rightest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
if (vr != a - 1) { // 右の部分木を見て a-1 以外ならreturn
return vr;
} else { // 左の部分木を見て値をreturn
return find_rightest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
}
}
}
int find_leftest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn b
return b;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vl = find_leftest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
if (vl != b) { // 左の部分木を見て b 以外ならreturn
return vl;
} else { // 右の部分木を見て値をreturn
return find_leftest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
}
}
}
//RSQ上で動きます。
int query2(long X) {
int k=0;
//ここでは、Σ[0,r]Ai=Xとなる最小のrを求めたい
while(k*2+1<dat.length) {
if(dat[k*2+1]>=X) {
k=k*2+1;
}else {
X-=dat[k*2+1];
k=k*2+2;
}
}
return k-=n-1;
}
long Cal(long a,long b) {
//計算アルゴリズム
return a+b;
//return a|b;
//return max(a,b);
//return gcd(a, b);
//return a^b;
//return Math.min(a, b);
}
int size() {
//Nではないよ、配列の大きさを返す。
return n;
}
//確認事項:Calとidentity
//segmentTreeで宣言、initで初期化する。
void toString(int n) {
for(int i=0;i<n*2;i++) {
System.err.print(dat[i]+" ");
}
System.err.println();
}
}
static char[][] clone(char V[][]) {
char RES[][]=new char[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static int[][] clone(int V[][]) {
int RES[][]=new int[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static long ceil(long a,long b) {
//ceil(a/b)を返す。
//a/bの切り上げ
return (a+b-1)/b;
}
static long floor(long a,long b) {
//floor (a/b)を返す。
//a/bの切り捨て
return a/b;
}
//Math.multiplyExact(T, A[i])
static int keta(long N) {
int a=1;
long b=10;
for(int i=0;i<17;i++) {
if(N<b)return a;
a++;b*=10;
}
return 18;
}
static final long mod7=Pow(10,9)+7,mod9=Pow(10,9)+9;
static long LINF =(1L<<63)-1,count=0,sum=0,max=-LINF,min=LINF,ans=0,temp;
static int i=0,INF=(1<<31)-1,compmax=0;
static long A[];
static final long mod998244353=998244353;
static Random r=new Random();
public static void main(String[] args) {
new Thread(null, new Main(), "", 1024 * 1024 * 1024).start(); //16MBスタックを確保して実行
}
public void run() {
for(int i=0;i<1;i++) {
solver();
Systemout.close();
Systemout.flush();
}
}
static boolean eval(long key) {
Set<Integer> s=new HashSet<>();
return true;
}
static void addMap(Map<Long,Long> f,long key,long size) {
if(f.containsKey(key)) {
f.replace(key, f.get(key)+size);
}else {
f.put(key, size);
}
}
static boolean isOk(int x,int y,int N) {
return x>=0&&y>=0&&x<N&&y<N;
}
static void revse(T A[]) {
for(int i=0;i<A.length/2;i++) {
swap(A, i, A.length-i-1);
}
}
private static void swap(T V[],int a,int b) {
T temp=V[b];
V[b]=V[a];
V[a]=temp;
}
static void comp(int a[]) {
binarySearch bs = new binarySearch();
int b[]=a.clone();//速度重視
//int b[] = Arrays.stream(a).distinct().toArray();
//圧縮サイズ最小化重視
Arrays.parallelSort(b);
for (int i = 0; i < a.length; i++) {
a[i]=bs.lowerBound(b, a[i])+1;
compmax=Math.max(compmax,a[i]);
}
}
static class edge implements Comparable<edge>{
int from,to,dis;
public edge(int from,int to,int dis) {
//v->u->w->vの辺
//count:種類数を表す。
this.from=from;
this.to=to;
this.dis=dis;
}
public int compareTo(edge o) {
Comparable key = (Comparable)this.dis;
Comparable key2 = (Comparable)o.dis;
return key.compareTo(key2);
}
}
/**
* @a
*/
private static void test(){
//are
}
//psv:関数の宣言
//tree:頂点0を根とする木を構築する
//graph:グラフの入力受け取り
//複数行の選択 Shift + ↑ or ↓
//行単位のソースを移動する [Alt + ↑ or ↓]
//指定行の削除をする [Ctrl + d]
//12. 検索画面の表示 : Ctrl + F
//変数名、メソッド名を一括変更する [Alt + Shift + r]
//r連打で画面が表示される(？)
//new int[]{1,2}
private static int partnum(int n,int k){
if (n == 1 || k == 1)return 1;
if (n < 0 || k < 1)return 0;
else return partnum(n - k, k) + partnum(n, k - 1);
}
private static int pn(int n){
return partnum(n, n);
}
static class T implements Comparable<T>{
int v;
long cost;
int index;
public T(int v,long cost,int index) {
this.v=v;
this.cost=cost;
this.index=index;
}
public int compareTo(T o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
/*任意のエディタ上で Ctrl+Shift+D （または右クリック「codic」「クイックルック」）でネーミング生成します。
日本語で検索するとネーミング生成、英語で検索すると英和（Codic English Dictionary) 検索します。
フィードバックには対応していません。Webから行ってください。*/
private static void solver(){
int T=sc.nextInt();
for(int i=0;i<T;i++) {
long L=sc.nextLong(),R=sc.nextLong();
//long L=r.nextInt(10000),R=L+r.nextInt(10000);
long r=0;//Rを全探索する
long ans=0;
for(int t=0;t<10;t++) {
r=r*10+9;
if(r<L)continue;
long temp=query(L, min(r,R));
//System.out.println("ans:"+temp);
ans=max(ans,temp);
if(r>R)break;
}
Systemout.println(ans);
Systemout.flush();
//if(L>R)continue;
//if(query(L, R)==query2(L, R))continue;
//System.out.println(L+";"+R);
//System.out.println(query(L, R)+" "+query2(L, R));
//System.out.println("===========");
}
}
private static long query2(long L,long R){
long a=1;
while(a*10<R) {
a*=10;
}
if(a<=L) {//ここ未チェック
if(a*10==R)return (R-L);
return (R-L+1);
}
//まず、a~Rの区間を%aと/10でmapに入れる。
long ans=0;
Set<Long> s=new HashSet<>();
for(long i=R;i>=a;i--) {
s.add(i%a);
s.add(i/10);
if(s.contains(i))continue;
ans++;
}
for(long i=max(L,a/10);i<a;i++) {
if(s.contains(i))continue;
ans++;
s.add(i);
}
return ans;
}
private static long query(long L,long R){
if(L>R)return 0;
long a=1;
while(a*10<R) {
a*=10;
}
//System.out.println(L+" "+R+" "+a);
if(R==a*10) {
//この場合は難しい
//-1か+0する必要がある。
//L<=aならば-1
//それ以外は+0
long res=query(L, R-1);
if(!(L<=a))res++;
return res;
}
if(a<=L) {
return (R-L+1);
}
if(R>=a*2-1) {
return R-max(L,a)+1;
}
long res=0;
res+=(R-a+1);
//System.out.println("rest::"+res);
long subL=max(L,(R+1)%a,a/10);
long subR=(a*2-1)%a;
if(subR<subL)return res;
//10 11 12 13 14 15 16 17 18と9
//[max(L,(R+1)%a),(a*2-1)%a]で、[a/10,R/10]でないものの数。
//更に、[0,R%a]でないもの。
long trashL=a/10;
long trashR=R/10;
//System.out.println(subL+";"+subR+" ::: "+trashL+";"+trashR);
if(subL<=trashL&&trashR<=subR) {
//完全に含まれる
res+=(subR-subL+1)-(trashR-trashL+1);
}
else if((trashR<=subL)||(subR<=trashL)) {
//全く含まれない
res+=(subR-subL+1);
}else if(subL<=trashR&&trashR<=subR){
//右側だけ含まれる
//[trashR+1,subR]
res+=(subR-trashR);
}else {
//左側だけ含まれる
//[subL,trashL-1]
res+=(trashL-subL);
}
return res;
}
private static long sol(int L,int R){
long ans=0;
long V=1;
while(V*10<=R)V*=10;
//とりあえず一番上の桁のやつは採用するじゃん
//[max(V,L),R]
//次に、[max(V,L),R] % Vについて考える。
//[V/10,V)について、[L,R]の中にあって、
//[max(V,L),R]に出てこない物を数え上げたい
if(L>=V&&R>=V) {
return (R-L+1);
}
ans+=(R-V+1);
//ans>=Vの時、その時点で終わり
if(R>=2*V) {
return ans ;
}
//[V-1 ~ V/10)を考える
//[V-1,max(V/10,T))
ans+=((V-1)-max(V/10,R%V,L-1,min(V/10-1,R%V)+V/10));
return ans;
}
private static String make(char a, char b, char c,int N,int g){
StringBuffer res = new StringBuffer();
for(int i=0;i<N;i++) {
if(i==g)res.append(c);
else res.append(a);
}
res.append(b);
for(int i=0;i<N;i++) {
if(i==0)res.append(a);
else res.append(c);
}
//System.out.println(res.toString());
return res.toString();
}
static boolean temp_flag=false;
private static boolean test(String f,String T,String T2,String T3){
if(unvisible_test(f, T)&&unvisible_test(f, T2)&&unvisible_test(f, T3)&&!temp_flag) {
temp_flag=true;
System.out.println(f);
}
return unvisible_test(f, T)&&unvisible_test(f, T2)&&unvisible_test(f, T3);
}
private static boolean unvisible_test(String f,String T){
//fがTの部分列であるか判定する
int now=0;
int i=0;
while(now<f.length()&&i<T.length()) {
if(f.charAt(now)==T.charAt(i))now++;
i++;
}
return now==f.length();
}
static double tripet(int max,int min,long A[]) {
for(int i=0;i<10;i++){
int c1=(max-min)/3+min;
int c2=(max-min)*2/3+min;
double x1=A[c1]*1.0/2;
double x2=A[c2]*1.0/2;
//System.out.println(max+" "+min);
//System.out.println(F(x1,A)+" "+F(x2,A));
if(F(x1,A)>=F(x2,A)) {
min=c1;
}else{
max=c2;
}
}
//System.out.println((max+min)/2);
return F(A[(max+min)/2]*1.0/2,A);
}
static double F(double x,long A[]) {
//この関数を最小化したい
double res=0;
for(int i=0;i<A.length;i++) {
res+=(x+A[i])-Math.min(2*x,A[i]);
}
return res;
}
static double tripet(double x,double max,double min) {
while(max-min>=0.0000000000001){
double c1=(max-min)/3+min;
double c2=(max-min)*2/3+min;
if(F(x,c1)>=F(x,c2)) {
min=c1;
}else{
max=c2;
}
}
return (max+min)/2;
}
static double F(double x,double y) {
return x+y;
}
private static long f(int now,long cost[],int flag[],ArrayList<ArrayList<Integer>> cc){
long res=0;
for(int to:cc.get(now)) {
if(flag[to]==1)continue;
flag[to]=1;
res+=f(to,cost,flag,cc);
}
return res+cost[now];
}
static void solv2() {
int N=sc.nextInt();
String S[]=new String[N];
for(int i=0;i<N;i++) {
S[i]=sc.next();
}
Scanner sc=new Scanner(System.in);
for(int i=0;i<N;i++) {
if(eval(S[i],S[i].charAt(0)))continue;
for(int j=0;j<N;j++) {
if(i==j)continue;
if(eval(S[j],S[j].charAt(0)))continue;
if(S[i].charAt(0)==S[j].charAt(0)) {
System.out.println("Case #"+(ans++)+": IMPOSSIBLE");
return;
}
if(S[i].charAt(S[i].length()-1)==S[j].charAt(S[j].length()-1)) {
System.out.println("Case #"+(ans++)+": IMPOSSIBLE");
return;
}
}
}
//あとはつなげていって最後に判定する
for(int i=0;i<N;i++) {
if(S[i].length()==0)continue;
if(!eval(S[i],S[i].charAt(0)))continue;
for(int j=0;j<N;j++) {
if(i==j||S[j].length()==0)continue;
if(S[i].charAt(0)==S[j].charAt(S[j].length()-1)) {
S[i]=S[j]+S[i];
S[j]="";
}
}
}
for(int i=0;i<N;i++) {
if(S[i].length()==0)continue;
for(int j=0;j<N;j++) {
if(i==j||S[j].length()==0)continue;
if(S[i].charAt(0)==S[j].charAt(S[j].length()-1)) {
S[i]=S[j]+S[i];
S[j]="";
}
}
}
StringBuffer res = new StringBuffer();
for(int i=0;i<N;i++)res.append(S[i]);
Set<Integer> s=new HashSet<>();
for(int i=0;i<res.length();) {
char V=res.charAt(i);
if(s.contains(V+0)) {
System.out.println("Case #"+(ans++)+": IMPOSSIBLE");
return;
}
s.add(V+0);
while(i<res.length()&&res.charAt(i)==V)i++;
}
System.out.println("Case #"+(ans++)+" "+res.toString());
}
static boolean eval2(String S,char c) {
int s=0;
while(s<S.length()&&S.charAt(s)==c)s++;
if(s==S.length())return false;
while(s<S.length()) {
if(S.charAt(s)==c)return true;
s++;
}
return false;
}
static boolean eval(String S,char c) {
for(int i=0;i<S.length();i++) {
if(S.charAt(i)!=c)return false;
}
return true;
}
static String F(int n) {
StringBuffer S = new StringBuffer();
for(int i=0;i<n;i++) {
S.append("0");
}
return S.toString();
}
static void mol() {
int bit=15;
oneMax O=new oneMax(bit, 100);
int rep=10;
long S=0;
for(int i=0;i<rep;i++) {
long score=O.eval(S);
//System.out.println(S+" score:"+score);
S=O.HC(S);
}
long best=S;
long bestS=O.eval(S);
for(int i=0;i<(1L<<bit);i++) {
long score=O.eval(i);
if(bestS<score) {
System.out.println(bestS+" "+"SCORE:"+score+" "+i);
}
}
}
static class oneMax{
long V[];
int bit;
public oneMax(int bit,int size) {
this.bit=bit;
init(size);
}
private void init(int size) {
V=new long[size];
Random r=new Random();
for(int i=0;i<size;i++) {
long T=Math.abs(r.nextLong());
if(bit!=63) {
T%=(1L<<bit);
}
V[i]=T;
}
System.out.println(Arrays.toString(V));
}
long eval(long A) {
return evalB(A);
}
private long evalA(long A) {
//bit桁の解Aの評価値を返す。
return Long.bitCount(A);
}
private long evalB(long A) {
//bit桁の解Aの評価値を返す。
if(!isPossible(A))return -1;//実行不可能解の場合は-1を返す。
long score=0;
for(int t=0;t<V.length;t++) {
long temp=0;//同じbitの数。
for(int i=0;i<bit;i++) {
if(((V[t]>>i)&1)==((A>>i)&1)) {
temp++;
}
}
score+=temp;
//System.out.println(" "+A+" "+t+" "+temp);
}
return score;
}
long HC(long N) {
//近傍解を取得し、遷移する。
long local_best=N;
long local_best_score=eval(N);
for(int i=0;i<bit;i++) {
//Nのiビット目を反転する。(近傍解の列挙)
long newer=N^(1L<<i);
long score=eval(newer);
//最もスコアの高い近傍を記録する。
if(score>local_best_score) {
local_best_score=score;
local_best=newer;
}
}
return local_best;
}
boolean isPossible(long A) {
//Aが制約を満たすか確かめる。
return A>=0&&(bit==63||A<(1L<<bit));
}
}
static long oneMax_HC_bad2(long N,int bit,Random r,int rMax) {
//悪い山登り法を作ってみる。
//近傍解を適当に定義する。
//randomな値を足した解を近傍解とする。
//rMax:randomに取る値の区間[rMin,rMax)
long local_best=N;
int local_best_score=oneMax_eval(N, bit);
for(int i=0;i<100;i++) {
long V=N^(r.nextInt(rMax));
int score=oneMax_eval(V, bit);
if(score>local_best_score) {
local_best_score=score;
local_best=V;
}
}
return local_best;
}
static long oneMax_HC_bad(long N,int bit,Random r,int rMax) {
//悪い山登り法を作ってみる。
//近傍解を適当に定義する。
//randomな値を足した解を近傍解とする。
//rMax:randomに取る値の区間[rMin,rMax)
long local_best=N;
int local_best_score=oneMax_eval(N, bit);
int t=1;
for(int i=0;i<1000;i++) {
long V=N+t*r.nextInt(rMax);t*=-1;
int score=oneMax_eval(V, bit);
if(score>local_best_score) {
local_best_score=score;
local_best=V;
}
}
return local_best;
}
static boolean isPossible(long N,int bit) {
//実行可能解かチェックする。
return N>=0&&N<(1L<<bit);
}
static long oneMax_HC(long N,int bit) {
//近傍解を取得し、遷移する。
long local_best=N;//best:最もスコアの高い近傍
int local_best_score=oneMax_eval(N, bit);//best_score:最もスコアの高い近傍のスコア
for(int i=0;i<bit;i++) {
//Nのiビット目を反転する。(近傍解の列挙)
//T:近傍解
long newer=N^(1L<<i);
int score=oneMax_eval(newer, bit);
//最もスコアの高い近傍を記録する。
if(score>local_best_score) {
local_best_score=score;
local_best=newer;
}
}
return local_best;
}
static int oneMax_eval(long N,int bit) {
//N:解
//bit:解のビット数
//制約条件:N<(1<<bit) (⇔Nのbit数がbitである)
//-返り値-
//非実行可能解の場合:-1を返す。
if(!isPossible(N, bit))return -1;
return Long.bitCount(N);
}
static int popCount(int n) {
int cnt = (n & 0x55555555) + (n >> 1 & 0x55555555);
cnt = (cnt & 0x33333333) + (cnt >> 2 & 0x33333333);
cnt = (cnt + (cnt >> 4)) & 0x0f0f0f0f;
cnt = cnt + (cnt >> 8);
cnt = cnt + (cnt >> 16);
return cnt & 0x7f;
}
static long eval(int S,int L) {
return modPow(S, L, mod998244353);
}
static void print(int V[][]) {
for(int i=0;i<V.length;i++) {
System.out.println(Arrays.toString(V[i]));
}
}
static String getOrder(int fx,int fy,int tx,int ty,int k,double p) {
StringBuffer res = new StringBuffer();
char V='U';
int count=0;
if(fx==tx) {
count=Math.abs(ty-fy);
if(fy<ty) {
V='R';
}else {
V='L';
}
}
if(fy==ty) {
count=Math.abs(fx-tx);
if(fx<tx) {
V='D';
}else {
V='U';
}
}
int v=count;
for(int i=0;i<k;i++) {
double score=f(p, count, v);
if(score>=0.99)break;
v++;
}
for(int i=0;i<v;i++) {
res.append(V);
}
return res.toString();
}
static double f(double p,int k,int N) {
//試行回数nで、(1-p)の確率で+1でk以上になる確率
double res[]=new double[k+1];
res[0]=1;
for(int i=0;i<N;i++) {
double newer[]=new double[k+1];
for(int t=0;t<k;t++) {
newer[t+1]+=res[t]*(1-p);
newer[t]+=res[t]*p;
}
newer[k]+=res[k];
for(int t=0;t<newer.length;t++) {
res[t]=newer[t];
}
}
return res[k];
}
static class V implements Comparable<V>{
int v,dis,f;
public V(int v,int dis) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.dis=dis;
}
public V(int v,int dis,int f) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.dis=dis;
this.f=f;
}
public int compareTo(V o) {
Comparable key = (Comparable)this.dis;
Comparable key2 = (Comparable)o.dis;
return key.compareTo(key2);
}
}
static long sqrt(long X) {
long s=0,e=3037000499L;
while(true) {
long g=(s+e)/2;
if(g*g<=X) {
s=g;
}else {
e=g;
}
if((s+e)/2==g)break;
}
return (s+e)/2;
}
static long cal(int V[],long F,int N) {
long res=0;
for(int i=0;i<V.length;i++) {
if(((F>>i)&1)==1) {
res+=(1L<<i)*(N-V[i]);
}else {
res+=(1L<<i)*V[i];
}
}
return res;
}
static void show(int V[]) {
StringBuffer S = new StringBuffer();
for(int i=0;i<V.length;i++) {
S.append(V[i]+" ");
}
System.out.println(S.toString());;
}
static long mal(long a,long b,long mod) {
a%=mod;b%=mod;
long f=a*b;
f%=mod;
return f*modinv(2, mod);
}
static long getCost(long hx,long hy) {
if(hx>hy) {
return hx-hy;
}
if(hx==hy) {
return 0;
}
return -2*(hy-hx);
}
static void swap(char a[],int s,int t) {
char temp=a[s];
a[s]=a[t];
a[t]=temp;
}
static boolean g(long a,long b,long mod) {
a=(a%mod+mod)%mod;
b=(b%mod+mod)%mod;
return a==b;
}
static void reverse(int A[]) {
int B[]=new int[A.length];
for(int i=0;i<A.length;i++) {
A[i]=B[A.length-i-1];
}
A=B.clone();
}
static ArrayList<Long> divide(long T){
ArrayList<Long> cc=new ArrayList<>();
for(long i=1;i*i<=T;i++) {
if(T%i==0) {
cc.add(i);
if(T/i!=i)cc.add(T/i);
}
}
return cc;
}
static boolean check(int x,int y,int H,int W) {
if(x>=H||x<0||y<0||y>=W)return false;
return true;
}
static boolean check(char S[][],int X,int Y,int flag[][],int a) {
if(flag[X][Y]!=0||S[X][Y]=='.')return false;
Deque<Integer> x=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
Deque<Integer> y=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
x.add(X);y.add(Y);
int V[]= {0,0,-1,1};
flag[X][Y]=a;
int N=S.length;
while(!x.isEmpty()) {
X=x.poll();
Y=y.poll();
for(int i=0;i<4;i++) {
if(X+V[i]<0||X+V[i]>=N||Y+V[(i+2)%4]<0||Y+V[(i+2)%4]>=N||flag[X+V[i]][Y+V[(i+2)%4]]!=0||S[X+V[i]][Y+V[(i+2)%4]]=='.')continue;
x.add(X+V[i]);y.add(Y+V[(i+2)%4]);
flag[X+V[i]][Y+V[(i+2)%4]]=a;
}
}
return true;
}
static void solv3(int cs[],int ct[]) {
int ninesS[]=new int[10];
int ninesT[]=new int[10];
int s=1,t=8;
while(s<10) {
if(cs[s]<=0||ct[t]<=0) {
s++;t--;continue;
}
ninesS[s]=min(cs[s],ct[t]);
ninesT[t]=min(cs[s],ct[t]);
cs[s]-=min(cs[s],ct[t]);ct[t]-=min(cs[s],ct[t]);
}
int use_s=-1,use_t=-1;
//tの9を使わない場合
s=9;
a:while(s>0) {
t=1;
while(t<9) {
if(cs[s]<=0||ct[t]<=0) {
t++;continue;
}
use_s=s;use_t=t;cs[s]--;ct[t]--;break a;
}
}
//tの9を使う場合
if(use_s==-1) {
if(ct[9]>0) {
s=9;
while(s>0) {
if(cs[s]>0) {
cs[s]--;ct[9]--;
use_s=s;use_t=9;break;
}
}
}
}
//9のペアを崩す場合
if(use_s==-1) {
s=9;
while(s>0&&cs[s]<=0)s--;
use_s=s;
t=10-s;
while(t<10&&ninesT[t]<=0)t++;
use_t=t;
if(s==0||t==10)use_s=-1;
else {
cs[s]--;ninesT[t]--;ninesS[9-t]--;
cs[9-t]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ct[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ct[t]--;ninesS[s]--;ninesT[9-s]--;
ct[9-s]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ninesT[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ninesT[t]--;ninesS[9-t]--;ninesS[s]--;ninesT[9-s]--;
//これ余ったやつ戻さないとじゃね
cs[9-t]++;ct[9-s]++;
}
}
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
//まず、10をくっつける作業
if(use_s!=-1) {
S.append((char)('0'+use_s));
T.append((char)('0'+use_t));
}
//次に9をくっつける作業
int a=1;
while(a<10) {
if(ninesS[a]==0) {
a++;continue;
}
S.append((char)('0'+a));
T.append((char)('0'+9-a));ninesS[a]--;
}
//余ったやつをくっつける作業,ctは少し余るかもしれない
//10のマッチングうまくやって無くない？？？？？？？？？？？？？？
int b=8;a=9;
//優先順位はbの大きいやつ
while(b>0) {
a=10-b;
while(ct[b]>0&&a<10) {
if(cs[a]<=0) {
a++;continue;
}
while(ct[b]>0&&cs[a]>0) {
S.append((char)('0'+a));
T.append((char)('0'+b));
cs[a]--;ct[b]--;
}
}
b--;
}
}
static void secondSolv(int cs[],int ct[],int ans_s[],int ans_t[]) {
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
int a=1,b=1;
while(a<10&&b<10) {
if(cs[a]==0){
a++;continue;
}
if(ct[b]==0) {
b++;
continue;
}
while(cs[a]!=0&&ct[b]!=0) {
S.append((char)(a+'0'));
T.append((char)(b+'0'));
cs[a]--;ct[b]--;
}
}
//とりあえず要らないやつを付け終わったよ
int i=ans_s.length-1;
while(i>=0) {
if(ans_s[i]==0) {
i--;continue;
}
S.append((char)(ans_s[i]+'0'));
T.append((char)(ans_t[i]+'0'));
i--;
}
b=9;
while(b>0) {
while(ct[b]>0) {
ct[b]--;
T.append((char)(b+'0'));
}
b--;
}
//これで後ろも付け終わったよ
System.out.println(S.toString());
System.out.println(T.toString());
}
static void count(String S,int c[]) {
for(int i=0;i<S.length();i++) {
c[S.charAt(i)-'0']++;
}
}
static void rev(char t[]) {
char temp[]=new char[t.length];
int a=0;
for(int i=t.length-1;i>=0;i--) {
temp[a++]=t[i];
}
for(int i=0;i<t.length;i++) {
t[i]=temp[i];
}
}
static int get(int a,int b,int c,int d,int V[][]) {
//(a,b)~(c,d)の区間を求める
return V[c][d]-V[c][b-1]-V[a-1][d]+V[a-1][b-1];
}
static void add(int x,int y,long data,long DP[][],int H,int W,int V[][]) {
if(x<0||y<0||x>=H||y>=W)return;
//System.out.println("add:"+x+" "+y+" ~"+data);
DP[x][y]+=data;
DP[x][y]%=mod998244353;
}
static void opt2(int tourList[],int N,int Dis[][]) {
boolean back=true;
int i0=0;
a:while(back) {
back=false;
for(int i=i0;i<i0+N;i++) {
for(int j=i+2;j<i+N-1;j++) {
int a=tourList[i%N],b=tourList[(i+1)%N],c=tourList[j%N],d=tourList[(j+1)%N];
//if(Dis[a][b]+Dis[c][d]>Dis[a][d]+Dis[b][c]) {
if(Dis[a][b]+Dis[c][d]>Dis[a][c]+Dis[b][d]) {
for (int k = 0; k < (j-i)/2; k++) {
int temp = tourList[(i+1+k)%N];
tourList[(i+1+k)%N] = tourList[(j-k)%N];
tourList[(j-k)%N] = temp;
}
i0=(i+1)%N;
back=true;
continue a;
}
//i->i+1, j->j+1を
//i->j+1,j->i+1につなぎ直す事を考える。
}
}
}
}
static boolean is_swappable(int arrayments[],int a,int b) {
a=arrayments[a];
b=arrayments[b];
if(a==b||a==-b)return false;
//a->bに出来るか。
//1-indexed
int s=index(arrayments, a);
int e=index(arrayments, b);
if(a<0&&e>s)return true;
if(a>0&&s>e)return true;
int target=index(arrayments, -a);
if(a<0&&target<e)return true;
if(a>0&&target>e)return true;
return false;
}
static int index(int arrayments[],int a) {
for(int i=0;i<arrayments.length;i++) {
if(arrayments[i]==a)return i;
}
return -1;
}
static long tsp_solv(int N,long cost[][]) {
int start=0;
long DP[][]=new long[N][1<<N];
for(int i=0;i<N;i++)Arrays.fill(DP[i], LINF);
//スタートの初期化,スタートの位置は本質ではない
DP[start][1<<start]=0;
for(int T=1;T<(1<<N);T++) {
//Tは既に通った頂点の集合を表している。
for(int from=0;from<N;from++) {
if(((T>>from)&1)==0||DP[from][T]==LINF)continue;//まだfromに到達していない
for(int to=0;to<N;to++) {
if(((T>>to)&1)==1)continue;//既にtoに到達している
//from->toへの移動を考える
if(cost[from][to]==LINF)continue;
DP[to][T|1<<to]=Math.min(DP[from][T]+cost[from][to],DP[to][T|1<<to]);
}
}
}
long res=LINF;
for(int i=0;i<N;i++) {
res=Math.min(res,DP[i][(1<<N)-1]+cost[i][start]);
}
return res;
}
static void swap(int A[],int a,int b) {
int temp=A[a];
A[a]=A[b];
A[b]=temp;
}
static int v[]= {0,0,1,-1};
static int sum(int i,int G[]) {
int res=0;
for(int t=0;t<G.length;t++) {
if(((i>>t)&1)==0)continue;
res+=G[t];
}
return res;
}
static boolean check(char V[][],int x,int y,int vx,int vy,int d) {
for(int i=0;i<d;i++) {
if(x<0||y<0||x>=V.length||y>=V[0].length)return false;
if(V[x][y]=='#')return false;
x+=vx;y+=vy;
}
return true;
}
static boolean check(char S[][],char T[][],int a,int b) {
a*=-1;b*=-1;
int N=T.length;
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if((a+i>=N||a+i<0||b+t<0||b+t>=N)&&S[i][t]=='#'){
return false;
}
if((a+i>=N||a+i<0||b+t<0||b+t>=N))continue;
if(S[i][t]!=T[i+a][b+t]&&(S[i][t]=='#'||T[a+i][b+t]=='#')) {
return false;
}
}
}
return true;
}
static void nine(char V[][]) {
char G[][]=clone(V);
int N=V.length;
int a=0,b=0;
for(int i=N-1;i>=0;i--) {
for(int t=0;t<N;t++) {
V[i][t]=G[a++][b];
}
a=0;b++;
}
}
static char[][] idou(char V[][],int a,int b) {
int N=V.length;
char G[][]=new char[N][N];
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if(i+a<N&&t+b<N&&i+a>=0&&t+b>=0)G[i+a][t+b]=V[i][t];
}
}
return G;
}
static ArrayList<ArrayDeque<Integer>> cc = new ArrayList<>();
static Map<Integer, Integer> m = new HashMap<>();;
static void add(int index) {
if(cc.get(index).size()==0)return;
int color=cc.get(index).pollFirst();
if(!m.containsKey(color)) {
m.put(color, index);
}else {
add(m.get(color));
add(index);
}
}
static void makeT(ArrayList<ArrayList<Integer>> cc,int parent[],int root) {
Arrays.fill(parent, -2);
parent[root]=-1;
Queue<Integer> now = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
now.add(root);
while(!now.isEmpty()) {
int FROM=now.poll();
for(int TO:cc.get(FROM)) {
if(parent[TO]!=-2)continue;
parent[TO]=FROM;
now.add(TO);
}
}
}
static class CUM2{
int V[][];
int h,w;
public CUM2(int A[][]) {//1-indexed
init(A);
}
void init(int A[][]) {
this.h=A.length;this.w=A[0].length;
V=new int[h][w];
for (int i = 0; i < h; i++) {
V[i]=A[i].clone();
}
for (int i = 1; i <h; i++) {
for (int t =1; t <w; t++) {
V[i][t]+=V[i][t-1];
}
}
for (int i = 1; i <w; i++) {
for (int t = 1; t <h; t++) {
V[t][i]+=V[t-1][i];
}
}
}
int get_sum(int a,int b,int c,int d) {
//[a,b]~[c,d]の区間和を返す。1-indexed
return V[c][d]+V[a-1][b-1]-V[a-1][d]-V[c][b-1];
}
}
/*long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}*/
//関数Fについて、区間[a,b]の最小値を求める
static long getF(long a,long b,long c,long d) {
//[a,b]と[c,d]の区間数の和
if(b<c||a>d) {
//完全に含まれない。
return (b-a+1)+(d-c+1);
}
if(c<=a&&b<=d) {
//完全に含まれる1
return d-c+1;
}
if(a<=c&&d<=b) {
//完全に含まれる2
return b-a+1;
}
//一部だけ含まれる。
if(c<=b&&b<=d) {
//[c,b]が含まれる。
return d-a+1;
}
if(c<=a&&a<=d) {
return b-c+1;
}
return -1;
}
static boolean check(int HW[][],int i,int t,int W) {
while(t<W) {
if(HW[i][t]%2==1)return true;
t++;
}
return false;
}
static void SCC(Map<Integer,ArrayList<Integer>> m,int N) {
int BACK[]=new int[N];
Arrays.fill(BACK, -1);
for (int i = 0; i < N; i++) {
if(BACK[i]!=-1)continue;
getBackQuery(m, i, BACK);
BACK[BACK_COUNT]=i;
}
Map<Integer,ArrayList<Integer>> reversedm=new HashMap<>();
for(int Vex:m.keySet()) {
for(int TO:m.get(Vex)) {
if(!reversedm.containsKey(TO))reversedm.put(TO, new ArrayList<>());
reversedm.get(TO).add(Vex);
}
}
uf=new unionFind(N);
for (int i = N-1; i>=0;i--) {
//iを始点として、DFSを行う。到達可能マスが同じグループ
if(uf.get(i)!=i)continue;
sccquery(reversedm, i);
}
}
static void sccquery(Map<Integer,ArrayList<Integer>> reversedm,int vex) {
if(!reversedm.containsKey(vex)||reversedm.get(vex).size()==0)return;
for(int TO:reversedm.get(vex)) {
if(uf.find(vex)==uf.find(TO))continue;
uf.union(vex, TO);
sccquery(reversedm, vex);
}
}
static int BACK_COUNT;
static unionFind uf;
static void getBackQuery(Map<Integer,ArrayList<Integer>> m,int Vex,int BACK[]) {
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int TO:m.get(Vex)) {
if(BACK[TO]!=-1)continue;
BACK[TO]=-2;
getBackQuery(m, Vex, BACK);
BACK[BACK_COUNT++]=TO;
}
}
static ArrayList<Integer> Vs;
static void getTopo(Map<Integer,ArrayList<Integer>> m,int N) {
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
Vs=new ArrayList<>();
for(int V:m.keySet()) {
if(flag[V])continue;
flag[V]=true;
topoQuery(m, V, flag);
Vs.add(V);
}
Collections.reverse(Vs);
}
static void topoQuery(Map<Integer,ArrayList<Integer>> m,int Vex, boolean flag[]) {
//Vexからスタート
//これ、閉路がある時に対応できてなくね
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int to:m.get(Vex)) {
if(flag[to])continue;
flag[to]=true;
topoQuery(m, to,flag);
Vs.add(to);
}
}
static class Flow{
static class edge{
int to,cap,rev;
public edge(int to,int cap,int rev) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cap=cap;
this.rev=rev;
}
}
public Flow(int N) {
// TODO 自動生成されたコンストラクター・スタブ
this.N=N;//頂点数
init();
}
void init() {
used=new boolean[N];
G=new ArrayList<>();
for (int i = 0; i < N; i++) {
G.add(new ArrayList<>());
}
}
int N;
ArrayList<ArrayList<edge>> G;//iがfromを意味する 隣接リスト表現
boolean used[];
//from->toへ向かう容量capの辺をグラフに追加する。
void add_edge(int from,int to,int cap) {
G.get(from).add(new edge(to, cap, G.get(to).size()));
G.get(to).add(new edge(from, 0, G.get(from).size()-1));
}
//最大流を求める 最悪計算量はO(F|E|) Fは流量,Eは辺の数?
int max_flow(int s,int t) {
int flow=0;
while(true) {
Arrays.fill(used, false);
int f=dfs(s,t,INF);
if(f==0)return flow;
flow+=f;
}
}
int dfs(int v,int t,int f) {
if(v==t)return f;//tに到着したら終了
used[v]=true;//vに訪れたことを表す
for (int i = 0; i < G.get(v).size(); i++) {
edge e=G.get(v).get(i);
if(used[e.to]||e.cap<=0)continue;
int d=dfs(e.to, t, Math.min(f,e.cap));
if(d>0) {
e.cap-=d;
G.get(e.to).get(e.rev).cap+=d;
return d;
}
}
return 0;
}
//デバッグ用
void get_edges(int T) {
//頂点Tから出る辺を出力する
int cout=0;
for(edge e:G.get(T)) {
System.out.println(cout+++" "+T+"=>"+e.to+" "+e.cap);
}
}
}
static class LCA{
static class edge{
int to;
long cost;
public edge(int to,long cost) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cost=cost;
}
}
int N;//頂点の数(頂点名は、0-indexで命名)
long dist[];//rootから頂点iまでの距離
int root;//木の根
int parents[];//頂点iの親がparents[i]
int doubling[][];
boolean is_built;
ArrayList<ArrayList<edge>> T;
public LCA(int N,int root) {
//頂点数と根を受け取る。
is_built=false;
this.root=root;
this.N=N;
T=new ArrayList<>(N);
for (int i = 0; i < N; i++) {
T.add(new ArrayList<>());
}
}
void add_edge(int u,int v,long cost) {
T.get(u).add(new edge(v,cost));
T.get(v).add(new edge(u,cost));
}
void build() {
init();
is_built=true;
}
void init() {
parents=new int[N];
dist=new long[N];
doubling=new int[31][N];
dfs(T);
init_doubling();
}
void dfs(ArrayList<ArrayList<edge>> T) {
//根からの距離と親を求める。
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
flag[root]=true;
parents[root]=root;
Queue<Integer> qq = new ArrayDeque<>(); //始点を保存
qq.add(root);
while(!qq.isEmpty()) {
int VEX=qq.poll();
if(T.get(VEX).size()==0)continue;
for(edge e:T.get(VEX)) {
if(flag[e.to])continue;
flag[e.to]=true;
parents[e.to]=VEX;
dist[e.to]=dist[VEX]+e.cost;
qq.add(e.to);
}
}
}
void init_doubling() {
//ダブリングによって、2^k先の祖先を前計算する。
//doubling[T][i]=iから2^T個分先
for (int i = 0; i < N; i++) {
doubling[0][i]=parents[i];
}
for (int T = 1; T < doubling.length; T++) {
for (int i = 0; i < N; i++) {
doubling[T][i]=doubling[T-1][doubling[T-1][i]];
}
}
}
int get_doubling(int from,long K) {
//ダブリングによって、fromからK先の祖先を求める。
//longにするときは、doublingの長さも変えないとだから注意
int res=from;
for (int i = 0; i < doubling.length; i++) {
if(((K>>i)&1)==0)continue;
res=doubling[i][res];
}
return res;
}
int query(int u1,int v1) {
//親からの距離を等しくする。(dist[u1]>dist[v1]とする)
//System.out.println(u1+" "+v1+" "+get_doubling(u1, dist[u1]-dist[v1]));
u1=get_doubling(u1, dist[u1]-dist[v1]);
if(u1==v1)return v1;
//二分探索によって、LCAの手前まで移動させる。
int G=30;
while(G>=0) {
int uTO=doubling[G][u1];
int vTO=doubling[G][v1];
if(uTO!=vTO) {
u1=uTO;
v1=vTO;
}
G--;
}
//System.out.println(parents[u1]+" "+parents[v1]+" "+dist[u1]+" "+dist[v1]+" "+u1+" "+v1);
return parents[u1];
}
int get_LCA(int u,int v) {
if(!is_built)build();
//根をrootとした時の、u,vのLCA(最小共通祖先)を返す。(0-indexed)
if(dist[u]<dist[v]) {
int temp=u;u=v;v=temp;
}
//dist[u]>dist[v]とする。
return query(u,v);
}
long get_dist(int u,int v) {
//u-vの距離
if(!is_built)build();
return -2*dist[get_LCA(u, v)]+dist[u]+dist[v];
}
boolean is_on_path(int u,int v,int a) {
//u-vパス上に頂点aがあるか?
//true:ある
//false:ない
return get_dist(u, a)+get_dist(a, v)==get_dist(u, v);
}
int INF=((1<<31)-1);
long dmtr=-LINF;
long get_diameter() {
if(dmtr!=-INF)return dmtr;
int V1=0;
long max_dis=-LINF;
for(int i=0;i<N;i++) {
long d=get_dist(0, i);
if(d>max_dis) {
max_dis=d;
V1=i;
}
}
max_dis=-INF;
//V1->V2への最大距離。
for (int i = 0; i < N; i++) {
max_dis=Math.max(max_dis,get_dist(V1,i));
}
return dmtr=max_dis;
}
}
static class doubling{
int N;
int bits;
int doubling[][];
long COST[][];
public doubling(int A[],int bits) {
this.bits=bits;
this.N=A.length;
init1(A);
}
public doubling(int A[],int bits,long C[]) {
// TODO 自動生成されたコンストラクター・スタブ
//long C[]は、i=>A[i]に行くコスト
//query2は、iからK番先までのコストの和で、i番までのコストが足されないので注意
this.bits=bits;
this.N=A.length;
init1(A);
init2(C);
}
private void init1(int A[]) {
// TODO 自動生成されたメソッド・スタブ
doubling=new int[bits][N];
for (int i = 0; i < N; i++) {
doubling[0][i]=A[i];
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
doubling[t+1][i]=doubling[t][doubling[t][i]];
}
}
}
private void init2(long C[]) {
COST=new long[bits][N];
for (int i = 0; i < N; i++) {
COST[0][i]=C[i];//i番目からA[i]までのコスト
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
COST[t+1][i]=COST[t][doubling[t][i]]+COST[t][i];
}
}
}
//解釈
private int query1(int start,long K) {
//startからK回移動した後の座標を求める。
int now=start;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1)now=doubling[i][now];
}
return now;
}
private long query2(int start,long K,long mod) {
//STARTからK回移動した時のコストを計算する。
int now=start;
long res=0;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1) {
res+=COST[i][now];
now=doubling[i][now];
res%=mod;
}
}
return res;
}
private int query3(int start) {
//startからスタートして、ループに入る時、そのループの長さを返す。
return 1;
}
}
static class DIKSTR{
ArrayList<ArrayList<edge2>> m;
ArrayList<ArrayList<edge2>> rev;
static Map<String,Integer> hash=new HashMap<>();
static int hash_count=0;
long d[];
int V,E;
class edge2{
int to;
long cost;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
}
class pair implements Comparable<pair>{
int VEX;
long cost;
public pair(long cost,int VEX) {
this.VEX=VEX;
this.cost=cost;
}
public int compareTo(pair o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
public DIKSTR(int V,int E) {
this.V=V;//最大の頂点数。
this.E=E;//最大の辺数。
init();
}
public DIKSTR(int V) {
this.V=V;
this.E=0;
init();
}
void init() {
m=new ArrayList<>();
rev=new ArrayList<>();
for (int i = 0; i < V; i++) {
m.add(new ArrayList<>());
rev.add(new ArrayList<>());
}
d=new long[V];
}
void add_edge(int FROM,int TO,long COST) {
m.get(FROM).add(new edge2(TO, COST));
rev.get(TO).add(new edge2(FROM, COST));
}
void add_edge(String FROM,String TO,long COST) {
if(!hash.containsKey(FROM))hash.put(FROM, hash_count++);
if(!hash.containsKey(TO))hash.put(TO, hash_count++);
add_edge(get_hash(FROM), get_hash(TO), COST);
}
int get_hash(String T) {
if(!hash.containsKey(T)) {
hash.put(T, hash_count++);
}
return hash.get(T);
}
long[] dikstr(String r) {
return dikstr(get_hash(r));
}
long[] dikstr(int r) {//rは始点
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<pair> p = new PriorityQueue<>();//add poll
p.add(new pair(0L, r));
int count=0;
while(!p.isEmpty()) {
count++;
if(count>V*V)break;
pair x=p.poll();
int from=x.VEX;
if(x.cost>d[from])continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
long COST=COST(e.cost);
if(d[e.to]>d[from]+COST) {
d[e.to]=d[from]+COST;
p.add(new pair(d[e.to], e.to));
}
}
}
return d.clone();
}
ArrayList<Integer> back(int F,int to){
//両方から辺が生えてる場合しか使えないよ！
ArrayList<Integer> res=new ArrayList<>();
Queue<Integer> q=new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
q.add(F);
res.add(F);
while(!q.isEmpty()) {
count++;
int from=q.poll();
for (int i = 0; i < rev.get(from).size(); i++) {
edge2 e=rev.get(from).get(i);
long COST=COST(e.cost);
if(e.to==from)continue;
if(d[e.to]+COST==d[from]) {
q.add(e.to);
res.add(e.to);
break;
}
}
}
return res;
}
long COST(long e_cost) {
return e_cost;
}
}
static Map<Integer, ArrayList<Integer>> getTree(int N){
Map<Integer, ArrayList<Integer>> m = new HashMap<>();
for (int i = 0; i < N; i++) {
int a = sc.nextInt() - 1, b = sc.nextInt() - 1;
if (!m.containsKey(a))
m.put(a, new ArrayList<Integer>());
if (!m.containsKey(b))
m.put(b, new ArrayList<Integer>());
m.get(a).add(b);
m.get(b).add(a);
}
return m;
}
/*static Map<V,Integer> makeTree(Map<Integer, ArrayList<Integer>> m){
//頂点0を根とした木を構築する。
Queue<Integer> qq = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
Queue<Integer> parent = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
qq.add(0);
Map<V, Integer> T = new HashMap<>();
parent.add(-1);
Queue<Integer> color = new ArrayDeque<>();
color.add(-1);
while (!qq.isEmpty()) {
int from = qq.poll();
int p = parent.poll();
int c=color.poll();
int X=1;
for (int V : m.get(from)) {
if (V == p)continue;
if(X==c)X++;
qq.add(V);
parent.add(from);
color.add(X);
System.out.println(from +" "+V+" "+X);
T.put(new V(from,V), X++);
}
}
return T;
}*/
static boolean isHaveSameBit(int a,int b) {//同じbitを持っているか
int t=0;
while((a>>t)!=0) {
if(((a>>t)&1)==1&&((b>>t)&1)==1)return true;
t++;
}
return false;
}
static boolean isPalindrome(String S) {//回分になってるか
for (int i = 0; i < S.length()/2; i++) {
if(S.charAt(i)!=S.charAt(S.length()-i-1)) {
return false;
}
}
return true;
}
static int G[];
static boolean xl100=false;
static long modinv(long a,long mod) {
if(!xl100) {
G=new int[3000000];
xl100=true;
}
int temp=(int)a;
if(G[(int)a]!=0)return G[(int)a];
long b=mod,u=1,v=0;
while(b!=0) {
long t=a/b;
a-=t*b;long tem=a;a=b;b=tem;
u-=t*v;tem=u;u=v;v=tem;
}
u%=mod;
if(u<0)u+=mod;
return G[temp]=(int)u;
}
static long[] extendedGCD(long a, long b) {
long s = 0, old_s = 1;
long t = 1, old_t = 0;
long r = b, old_r = a;
while(r != 0) {
long q = old_r / r;
long old_s0 = old_s, old_t0 = old_t, old_r0 = old_r;
old_s = s;
s = old_s0 - q * s;
old_t = t;
t = old_t0 - q * t;
old_r = r;
r = old_r0 - q * r;
}
return new long[] {old_s, old_t};
}
static class graph{
public graph() {
// TODO 自動生成されたコンストラクター・スタブ
}
//コンテスト中だけ
static class edge3{
int to;
long cost;
int K;
public edge3(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge3(int to,long cost,int K) {
this.to=to;
this.cost=cost;
this.K=K;
}
}
long costV(long T,int K) {
//T以上の最小のKの倍数を返す。
long V=(T+K-1)/K;
return V*K;
}
long[] adddikstr(int V,int E,int r,Map<Integer, ArrayList<edge3>> m) {
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge3 e=m.get(from).get(i);
if(d[e.to]>costV(d[from],e.K)+e.cost) {
d[e.to]=costV(d[from],e.K)+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d;
}
//
class edge implements Comparable<edge>{
int from,to;
long cost;
public edge(int from,int to,long b) {
this.from=from;
this.to=to;
this.cost=b;
}
@Override
public int compareTo(edge o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
static class edge2{
int to;
long cost;
String FROM,TO;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge2(int to,long cost,String FROM,String TO) {
this.to=to;
this.cost=cost;
this.FROM=FROM;
this.TO=TO;
}
}
//単一始点最短距離問題(ダイクストラ法) 負閉路対策不可 経路復元
long d[];
long[] dikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
//path[e.to]=from;
}
}
}
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return d.clone();
}
long[] additionalDikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m,int banned) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(from==banned&&e.to==0)continue;
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d.clone();
}
int D[];
int[] Intdikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
D=new int[V];
Arrays.fill(D, INF);
D[r]=0;
PriorityQueue<Pair<Integer,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Integer, Integer>(0, r));
while(!p.isEmpty()) {
Pair<Integer,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>D[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(D[e.to]>D[from]+e.cost) {
D[e.to]=(int) (D[from]+e.cost);
p.add(new Pair<Integer, Integer>(D[e.to], e.to));
//path[e.to]=from;
}
}
}
p.clear();
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return D;
}
//単一始点最短距離問題(ベルマンフォード法) 負閉路対策済み
long[] Bellman_Ford(int V,int E,int r,edge e[]) {
long d[]=new long[V]; //0~eのグラフはこれ
//Map<Integer, Integer> d = new HashMap<>();それ以外はこれ
//for(int i=0;i<E;i++) {
// if(!d.containsKey(e[i].to))m.add(new Pair<Integer, Integer>(e[i].to, INF));
// if(!d.containsKey(e[i].from))m.add(new Pair<Integer, Integer>(e[i].from, INF));
//}
//d.replace(r, 0);
Arrays.fill(d, INF);
d[r]=0;
int count=0;
while(true) {
boolean update =false;
for(int i=0;i<E;i++) {
if(d[e[i].from]!=INF&&d[e[i].from]+e[i].cost<d[e[i].to]) {
update=true;
d[e[i].to]=d[e[i].from]+e[i].cost;
}
}
if(!update)break;
if(count==V) {
p("NEGATIVE CYCLE");
return null;
}
count++;
}
return d;
}
//最小全域木問題(クラスカル法)
long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}
}
private static long Pow(long i,long t) {
//iのt乗をO(log t)で返す
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをStringで受け取りたい時用
while(t!=0) {
if((1&t)==1) {
res=res*a;
}
a=a*a;
t=t>>1;
}
return res;
}
private static Map<Long, Integer> primeNumbers(long N) {//素因数列挙
Map<Long, Integer> c = new HashMap<>();
for(long i=2;i*i<=N;i++) {
if(N%i==0) {
int count=0;
while(N%i==0) {
N/=i;
count++;
}
c.put(i, count);
continue;
}
}
if(N!=1) {
c.put(N, 1);
}
return c;
}
//=========================Union Find=============================================
//union idx2 tree to idx1 tree O(a(N))
static class unionFind{
int UNI[],n,graph_s;
int size[];
public unionFind(int N) {
// TODO 自動生成されたコンストラクター・スタブ
n=N;
graph_s=N;
init();
}
void init() {
UNI=new int[n];
size=new int[n];
Arrays.fill(size, 1);
for (int i = 0; i < n; i++) {
UNI[i]=i;
}
}
int get(int idx) {
return UNI[idx];
}
int find(int idx) {//木の根のindexを返す
if(UNI[idx]==idx) return idx;
return UNI[idx] = find(UNI[idx]);
}
void shape() {//木の根に直接つなげる 経路圧縮
for(int i=0;i<n;i++) {
find(i);
}
}
void union(int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(UNI[root2]!=root1) {
graph_s--;
size[root1]+=size[root2];
size[root2]=size[root1];
}
UNI[root2] = root1;
}
int get_size(int idx) {
return size[find(idx)];
}
void breaker(int idx1,int idx2) {
UNI[idx1]=idx1;
}
int MaxSize() {//最も大きい木の頂点数を返す
shape();
int V[]=new int[n];
int max=0;
for(int i=0;i<n;i++) {
V[UNI[i]]++;
max=Math.max(max, V[UNI[i]]);
}
return max;
}
int sum() {//木の数を返す
int res=0;
for(int i=0;i<n;i++) {
if(UNI[i]==i)res++;
}
return res;
}
void union2(int tree[],int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(root1==root2)return;
if(c.get(root1).size()>c.get(root2).size()) {
//root2をroot1に移し替える
for(int a:c.get(root2).keySet()) {
if(!c.get(root1).containsKey(a)) {
c.get(root1).put(a, 0);
}
c.get(root1).replace(a, c.get(root1).get(a)+c.get(root2).get(a));
}
tree[root2] = root1;
}else {
for(int a:c.get(root1).keySet()) {
if(!c.get(root2).containsKey(a)) {
c.get(root2).put(a, 0);
}
c.get(root2).replace(a, c.get(root2).get(a)+c.get(root1).get(a));
}
tree[root1] = root2;
}
}
}
//=========================二分探索=============================================
private static class binarySearch{
public binarySearch() {
// TODO 自動生成されたコンストラクター・スタブ
}
int BinarySearch(int A[],int value) {
int S=0,E=A.length,G=-1;
while(S<=E) {
G=(S+E)/2;
if(A[G]==value)return G;
else if(A[G]>value) {
if(E==G)break;E=G;
}else if(A[G]<value) {
if(S==G)break;S=G;
}
}
return -1;
}
int lowerBound(int A[],int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(value<=A[0])return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(int A[],int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(long A[],long value) {
//A[i-1]<value<=A[i] value以上の最小indexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>=value)return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(long A[],long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Integer> A,int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Integer> A,int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Long> A,long value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Long> A,long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
}
private static long modNcR2(int n,int r,int mod) {
if(r<0||n<r)return 0;
long N=kaijou(n, mod);
long Nr=kaijou(n-r, mod);
long R=kaijou(r, mod);
return (((N*modPow(Nr, mod-2, mod))%mod)*modPow(R, mod-2, mod))%mod;
// n!/(n-r)!/r!
}
private static long modNcR(int n,int r,long mod) {
if(r<0||n<r)return 0;
long res=1;
for(int i=0;i<r;i++) {
res*=n;res%=mod;n--;
}
for(int i=0;i<r;i++) {
res*=modinv(i+1, mod);res%=mod;
}
return res;
// n!/(n-r)!/r!
}
private static long modNcR2(int n,int r,long mod) {
if(r<0||n<r)return 0;
long N=kaijou(n, mod);
long Nr=kaijou(n-r, mod);
long R=kaijou(r, mod);
return (((N*modPow(Nr, mod-2, mod))%mod)*modPow(R, mod-2, mod))%mod;
// n!/(n-r)!/r!
}
private static long modPow(long i,long t,long mod) {
if(t==0)return 1%mod;
if(i==0||t<0)return 0;//0未満乗は未定義で
//iのt乗をO(log t)で返す
i%=mod;
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをbitのStringで受け取った時用？
while(t!=0) {
if((1&t)==1) {
res=res*a%mod;
}
a=a*a%mod;
t=t>>1;
}
return res;
}
private static long min(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int min(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int max(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static long max(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static double min(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static double max(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static int abs(int a) {
return Math.max(a,-a);
}
private static long abs(long a) {
return Math.max(a,-a);
}
private static double abs(double a) {
return Math.max(a,-a);
}
private static String zeroume(String S,int V) {
while(S.length()<V)S='0'+S;
return S;
}
//速度が足りないときは、前計算を1回だけにしたり、longをintに変えたりするといい
//エラストネスの篩風のやつもあり
private static long gcd(long ...nums) {
long res=0;
for (int i = 0; i < nums.length; i++) {
res=gcd(res,nums[i]);
}
return res;
}
private static long lcm(long ...nums) {
long res=1;
for (int i = 0; i < nums.length; i++) {
res=lcm(res,nums[i]);
}
return res;
}
public static long gcd(long num1,long num2) {
if(num2==0) return num1;
else return gcd(num2,num1%num2);
}
public static long lcm(long num1,long num2) {
return num1*num2/gcd(num1,num2);
}
//O(N^0.5)
private static void bubunwa() {
int N=sc.nextInt();
int K=sc.nextInt();
int a[]=sc.nextIntArray(N, false);
boolean dp[] =new boolean[K+1];
Arrays.fill(dp, false);
dp[0]=true;
for(int i=0;i<N;i++) {
for(int x=K-a[i];x>=0;x--) {
if(dp[x])dp[x+a[i]]=true;
}
}
p(dp[K] ? "Yes":"No");
}
static String nextPermutation(String s) {
ArrayList<Character> list=new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
list.add(s.charAt(i));
}
int pivotPos=-1;
char pivot=0;
for(int i=list.size()-2;i>=0;i--) {
if(list.get(i)<list.get(i+1)) {
pivotPos=i;
pivot=list.get(i);
break;
}
}
if(pivotPos==-1&&pivot==0) {
return "Final";
}
int L=pivotPos+1,R=list.size()-1; int minPos=-1;
char min =Character.MAX_VALUE;
for(int i=R;i>=L;i--) {
if(pivot<list.get(i)) {
if(list.get(i)<min) {
min=list.get(i);
minPos=i;
}
}
}
Collections.swap(list, pivotPos, minPos);
Collections.sort(list.subList(L, R+1));
StringBuilder sb=new StringBuilder();
for(int i=0;i<list.size();i++) {
sb.append(list.get(i));
}
return sb.toString();
}
private static long[][] com;
private static void nCr(int mod) {
int MAX = 3001;
com= new long[MAX][MAX];
for(int i = 0; i < MAX; i++)
com[i][0] = 1;
for(int i = 1; i < MAX; i++) {
for(int j = 1; j <= i; j++) {
com[i][j] = com[i-1][j-1] + com[i-1][j];
com[i][j] %= mod;
}
}
}
//https://qiita.com/p_shiki37/items/65c18f88f4d24b2c528b より
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
return (int) nextLong();
}
public double nextDouble(){
return Double.parseDouble(next());
}
public int[] nextIntArray(int N) {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
public int[] nextIntArray(int N, boolean oneBased) {
if (oneBased) {
int[] array = new int[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextInt();
}
return array;
} else {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
}
public long[] nextLongArray(int N, boolean oneBased) {
if (oneBased) {
long[] array = new long[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextLong();
}
return array;
} else {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
}
public int[] nextRandIntArray(int N, boolean oneBased,int max) {
Random r=new Random();
if(oneBased)N++;
int array[]=new int[N];
for(int i=0;i<N;i++) {
array[i]=r.nextInt(max+1);
}
if(oneBased)array[0]=0;
return array;
}
public long[] nextLongArray(int N) {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
public long[][]nextLongDimensionalArray(int H,int W) {
long[][] array = new long[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextLongArray(W);
}
return array;
}
public int[][]nextIntDimensionalArray(int H,int W) {
int[][] array = new int[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextIntArray(W);
}
return array;
}
public String[] nextArray(int N) {
String[] array = new String[N];
for (int i = 0; i < N; i++) {
array[i] = sc.next();
}
return array;
}
public String[][]nextDimensionalArray(int H,int W) {
String[][] array = new String[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextArray(W);
}
return array;
}
public double[] nextDoubleArray(int N) {
double[] array = new double[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextDouble();
}
return array;
}
}
}
/*
created by krps
本体は634行目あたりのsolve()に書いてあります。
Good Luck!
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.AbstractMap;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
public class Main implements Runnable {
static FastScanner sc = new FastScanner();
static PrintWriter Systemout = new PrintWriter(System.out);
public static class Pair<K, V> extends AbstractMap.SimpleEntry<K, V> implements Comparable<Pair<K, V>> {
public Pair(final K key, final V value) {
super(key, value);
}
@Override
public int compareTo(Pair<K, V> o) {
Comparable key = (Comparable)this.getKey();
Comparable key2 = (Comparable)o.getKey();
/*if (false) {
Comparable key3 = (Comparable) this.getValue();
Comparable key4 = (Comparable) o.getValue();
if (key.compareTo(key2) == 0) {
return key3.compareTo(key4);
}
}*/
return key.compareTo(key2);
}
}
private static boolean isPrime(long t) {
if(t<2)return false;
for(int i=2;i*i<=t;i++) {
if(t%i==0)return false;
}
return true;
}
@SuppressWarnings("unused")
private static long ncr(long n,long r) {
long res=1;
for(int i=0;i<r;i++) {
res*=n-i;
res/=i+1;
}
return res;
}
@SuppressWarnings("unused")
private static int StringCount(String T,String v) {
int res=0;
int t=0;
while(T.indexOf(v,t)>=0) {
//p(t);
res++;
t=T.indexOf(v,t)+1;
}
return res;
}
private static void swap(long V[],int a,int b) {
long temp=V[b];
V[b]=V[a];
V[a]=temp;
}
private static void p(long[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(long[] a) {p(Arrays.toString(a));};
private static void p(int[][] a) {for(int i=0;i<a.length;i++)p(a[i]);};
private static void p(int[] a) {p(Arrays.toString(a));};
//大量にout.println();をすると、自動でout.flush();されるので、出力される順番には気を付けよう
// * out.println()の後にSystem.out.println();をしたいときとかねー
private static <T> void p(T t) {Systemout.println(t);}
private static <T> void p() {Systemout.println();}
private static void p(graph.edge2[] e) {
for (int i = 0; i < e.length; i++) {
Systemout.println(e[i].to+" "+e[i].cost);
}
}
private static void doubleToString(double a) {
System.out.println(BigDecimal.valueOf(a).toPlainString());
}
private static ArrayList<Map<Integer,Integer>> c;
private static int ketawa(String S) {
int res=0;
for(int i=0;i<S.length();i++) {
res+=S.charAt(i)-'0';
}return res;
}
private static int ketawa(int S) {
int res=0;
while(S!=0) {
res+=S%10;
S/=10;
}
return res;
}
private static long X_x[]=new long[1];
private static long kaijou(int x,long mod) {
if(X_x.length!=300000)X_x=new long[300000];
if(x<=1)return X_x[x]=1;
if(X_x[x]!=0)return X_x[x];
return X_x[x]=(x*kaijou(x-1,mod))%mod;
/*long a=1;
for(int i=2;i<=K;i++)a=(a*i)%mod;
return (int)a;*/
}
static class segmentTree{
int n;
long dat[];
long identity;//単位元
segmentTree(int N,long identity) {//setTreeの要素の数,単位元
this.identity =identity;
init(N);
}
void init2() {
Arrays.fill(dat, 0);
}
void init(int n_) {
this.n=1;
while(n<n_)n*=2;
this.dat= new long[2*n-1];
Arrays.fill(dat, identity);
}
void update(int k,long a) {
k+=n-1;
dat[k]=a;
while(k>0) {
k=(k-1)/2;
//System.err.println("update "+k+" "+Cal(this.dat[k*2+1],this.dat[k*2+2]));
dat[k]=Cal(dat[k*2+1],dat[k*2+2]);
}
}
//外から呼び出すときはl=0,r=-1,k=0にする。
void update(int a,int b,int k,int X,int l,int r) {
if(r==-1)r=n;
if(r<=a||b<=l) {
return;
}
if(a<=l&&r<=b) {
dat[k]=min(dat[k],X);
}else {
update(a, b, k*2+1,X, l, (l+r)/2);
update(a, b,k*2+2,X,(l+r)/2,r);
}
}
long get(int k) {//k番目の値を取得 0<=k<N
k+=n-1;
return dat[k];
}
//[a,b]を求める。
//a~bのこと。0-indexed
long getV(int a,int b) {
a=Math.max(0,a);
b=min(n-1,b);
b++;
return query(a, b, 0, 0, n);
}
int getleft(int a,int b,long x) {
return find_leftest_sub(a, b, x, 0, 0, n);
}
int getright(int a,int b,long x) {
return find_rightest_sub(a, b, x, 0, 0, n);
}
//[a,b)の値を求める
//a~b-1のことで、0-indexed
//外から呼び出すときは、a,b,0,0,N
long query(int a,int b,int k,int l,int r) {
if(r<=a||b<=l) {
//l,rが求めたい区間a,bに完全に含まれていない
return identity;
}
if(a<=l&&r<=b) {
//l,rが、求めたい区間a,bに完全に含まれている
return dat[k];
}else {
//l,rが、求めたい区間a,bに一部分だけ含まれている。
long A=query(a, b, k*2+1, l, (l+r)/2);
long B=query(a, b, k*2+2, (l+r)/2, r);
return Cal(A,B);
}
}
//x以下の要素を持つ最も左のもののindexを返す。 *RM(min)Q上でしか動かない
int find_rightest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn a-1
return a - 1;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vr = find_rightest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
if (vr != a - 1) { // 右の部分木を見て a-1 以外ならreturn
return vr;
} else { // 左の部分木を見て値をreturn
return find_rightest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
}
}
}
int find_leftest_sub(int a, int b, long x, int k, int l, int r) {
if (dat[k] > x || r <= a || b <= l) { // 自分の値がxより大きい or [a,b)が[l,r)の範囲外ならreturn b
return b;
} else if (k >= n - 1) { // 自分が葉ならその位置をreturn
return (k - (n - 1));
} else {
int vl = find_leftest_sub(a, b, x, 2 * k + 1, l, (l + r) / 2);
if (vl != b) { // 左の部分木を見て b 以外ならreturn
return vl;
} else { // 右の部分木を見て値をreturn
return find_leftest_sub(a, b, x, 2 * k + 2, (l + r) / 2, r);
}
}
}
//RSQ上で動きます。
int query2(long X) {
int k=0;
//ここでは、Σ[0,r]Ai=Xとなる最小のrを求めたい
while(k*2+1<dat.length) {
if(dat[k*2+1]>=X) {
k=k*2+1;
}else {
X-=dat[k*2+1];
k=k*2+2;
}
}
return k-=n-1;
}
long Cal(long a,long b) {
//計算アルゴリズム
return a+b;
//return a|b;
//return max(a,b);
//return gcd(a, b);
//return a^b;
//return Math.min(a, b);
}
int size() {
//Nではないよ、配列の大きさを返す。
return n;
}
//確認事項:Calとidentity
//segmentTreeで宣言、initで初期化する。
void toString(int n) {
for(int i=0;i<n*2;i++) {
System.err.print(dat[i]+" ");
}
System.err.println();
}
}
static char[][] clone(char V[][]) {
char RES[][]=new char[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static int[][] clone(int V[][]) {
int RES[][]=new int[V.length][V[0].length];
for (int i = 0; i < V.length; i++) {
for (int t = 0; t < V[0].length; t++) {
RES[i][t]=V[i][t];
}
}
return RES;
}
static long ceil(long a,long b) {
//ceil(a/b)を返す。
//a/bの切り上げ
return (a+b-1)/b;
}
static long floor(long a,long b) {
//floor (a/b)を返す。
//a/bの切り捨て
return a/b;
}
//Math.multiplyExact(T, A[i])
static int keta(long N) {
int a=1;
long b=10;
for(int i=0;i<17;i++) {
if(N<b)return a;
a++;b*=10;
}
return 18;
}
static final long mod7=Pow(10,9)+7,mod9=Pow(10,9)+9;
static long LINF =(1L<<63)-1,count=0,sum=0,max=-LINF,min=LINF,ans=0,temp;
static int i=0,INF=(1<<31)-1,compmax=0;
static long A[];
static final long mod998244353=998244353;
static Random r=new Random();
public static void main(String[] args) {
new Thread(null, new Main(), "", 1024 * 1024 * 1024).start(); //16MBスタックを確保して実行
}
public void run() {
for(int i=0;i<1;i++) {
solver();
Systemout.close();
Systemout.flush();
}
}
static boolean eval(long key) {
Set<Integer> s=new HashSet<>();
return true;
}
static void addMap(Map<Long,Long> f,long key,long size) {
if(f.containsKey(key)) {
f.replace(key, f.get(key)+size);
}else {
f.put(key, size);
}
}
static boolean isOk(int x,int y,int N) {
return x>=0&&y>=0&&x<N&&y<N;
}
static void revse(T A[]) {
for(int i=0;i<A.length/2;i++) {
swap(A, i, A.length-i-1);
}
}
private static void swap(T V[],int a,int b) {
T temp=V[b];
V[b]=V[a];
V[a]=temp;
}
static void comp(int a[]) {
binarySearch bs = new binarySearch();
int b[]=a.clone();//速度重視
//int b[] = Arrays.stream(a).distinct().toArray();
//圧縮サイズ最小化重視
Arrays.parallelSort(b);
for (int i = 0; i < a.length; i++) {
a[i]=bs.lowerBound(b, a[i])+1;
compmax=Math.max(compmax,a[i]);
}
}
static class edge implements Comparable<edge>{
int from,to,dis;
public edge(int from,int to,int dis) {
//v->u->w->vの辺
//count:種類数を表す。
this.from=from;
this.to=to;
this.dis=dis;
}
public int compareTo(edge o) {
Comparable key = (Comparable)this.dis;
Comparable key2 = (Comparable)o.dis;
return key.compareTo(key2);
}
}
/**
* @a
*/
private static void test(){
//are
}
//psv:関数の宣言
//tree:頂点0を根とする木を構築する
//graph:グラフの入力受け取り
//複数行の選択 Shift + ↑ or ↓
//行単位のソースを移動する [Alt + ↑ or ↓]
//指定行の削除をする [Ctrl + d]
//12. 検索画面の表示 : Ctrl + F
//変数名、メソッド名を一括変更する [Alt + Shift + r]
//r連打で画面が表示される(？)
//new int[]{1,2}
private static int partnum(int n,int k){
if (n == 1 || k == 1)return 1;
if (n < 0 || k < 1)return 0;
else return partnum(n - k, k) + partnum(n, k - 1);
}
private static int pn(int n){
return partnum(n, n);
}
static class T implements Comparable<T>{
int v;
long cost;
int index;
public T(int v,long cost,int index) {
this.v=v;
this.cost=cost;
this.index=index;
}
public int compareTo(T o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
/*任意のエディタ上で Ctrl+Shift+D （または右クリック「codic」「クイックルック」）でネーミング生成します。
日本語で検索するとネーミング生成、英語で検索すると英和（Codic English Dictionary) 検索します。
フィードバックには対応していません。Webから行ってください。*/
private static void solver(){
int T=sc.nextInt();
for(int i=0;i<T;i++) {
long L=sc.nextLong(),R=sc.nextLong();
//long L=r.nextInt(10000),R=L+r.nextInt(10000);
long r=0;//Rを全探索する
long ans=0;
for(int t=0;t<10;t++) {
r=r*10+9;
if(r<L)continue;
long temp=query(L, min(r,R));
//System.out.println("ans:"+temp);
ans=max(ans,temp);
if(r>R)break;
}
Systemout.println(ans);
Systemout.flush();
//if(L>R)continue;
//if(query(L, R)==query2(L, R))continue;
//System.out.println(L+";"+R);
//System.out.println(query(L, R)+" "+query2(L, R));
//System.out.println("===========");
}
}
private static long query2(long L,long R){
long a=1;
while(a*10<R) {
a*=10;
}
if(a<=L) {//ここ未チェック
if(a*10==R)return (R-L);
return (R-L+1);
}
//まず、a~Rの区間を%aと/10でmapに入れる。
long ans=0;
Set<Long> s=new HashSet<>();
for(long i=R;i>=a;i--) {
s.add(i%a);
s.add(i/10);
if(s.contains(i))continue;
ans++;
}
for(long i=max(L,a/10);i<a;i++) {
if(s.contains(i))continue;
ans++;
s.add(i);
}
return ans;
}
private static long query(long L,long R){
if(L>R)return 0;
long a=1;
while(a*10<R) {
a*=10;
}
//System.out.println(L+" "+R+" "+a);
if(R==a*10) {
//この場合は難しい
//-1か+0する必要がある。
//L<=aならば-1
//それ以外は+0
long res=query(L, R-1);
if(!(L<=a))res++;
return res;
}
if(a<=L) {
return (R-L+1);
}
if(R>=a*2-1) {
return R-max(L,a)+1;
}
long res=0;
res+=(R-a+1);
//System.out.println("rest::"+res);
long subL=max(L,(R+1)%a,a/10);
long subR=(a*2-1)%a;
if(subR<subL)return res;
//10 11 12 13 14 15 16 17 18と9
//[max(L,(R+1)%a),(a*2-1)%a]で、[a/10,R/10]でないものの数。
//更に、[0,R%a]でないもの。
long trashL=a/10;
long trashR=R/10;
//System.out.println(subL+";"+subR+" ::: "+trashL+";"+trashR);
if(subL<=trashL&&trashR<=subR) {
//完全に含まれる
res+=(subR-subL+1)-(trashR-trashL+1);
}
else if((trashR<subL)||(subR<trashL)) {
//全く含まれない
res+=(subR-subL+1);
}else if(subL<=trashR&&trashR<=subR){
//右側だけ含まれる
//[trashR+1,subR]
res+=(subR-trashR);
}else {
//左側だけ含まれる
//[subL,trashL-1]
res+=(trashL-subL);
}
return res;
}
private static long sol(int L,int R){
long ans=0;
long V=1;
while(V*10<=R)V*=10;
//とりあえず一番上の桁のやつは採用するじゃん
//[max(V,L),R]
//次に、[max(V,L),R] % Vについて考える。
//[V/10,V)について、[L,R]の中にあって、
//[max(V,L),R]に出てこない物を数え上げたい
if(L>=V&&R>=V) {
return (R-L+1);
}
ans+=(R-V+1);
//ans>=Vの時、その時点で終わり
if(R>=2*V) {
return ans ;
}
//[V-1 ~ V/10)を考える
//[V-1,max(V/10,T))
ans+=((V-1)-max(V/10,R%V,L-1,min(V/10-1,R%V)+V/10));
return ans;
}
private static String make(char a, char b, char c,int N,int g){
StringBuffer res = new StringBuffer();
for(int i=0;i<N;i++) {
if(i==g)res.append(c);
else res.append(a);
}
res.append(b);
for(int i=0;i<N;i++) {
if(i==0)res.append(a);
else res.append(c);
}
//System.out.println(res.toString());
return res.toString();
}
static boolean temp_flag=false;
private static boolean test(String f,String T,String T2,String T3){
if(unvisible_test(f, T)&&unvisible_test(f, T2)&&unvisible_test(f, T3)&&!temp_flag) {
temp_flag=true;
System.out.println(f);
}
return unvisible_test(f, T)&&unvisible_test(f, T2)&&unvisible_test(f, T3);
}
private static boolean unvisible_test(String f,String T){
//fがTの部分列であるか判定する
int now=0;
int i=0;
while(now<f.length()&&i<T.length()) {
if(f.charAt(now)==T.charAt(i))now++;
i++;
}
return now==f.length();
}
static double tripet(int max,int min,long A[]) {
for(int i=0;i<10;i++){
int c1=(max-min)/3+min;
int c2=(max-min)*2/3+min;
double x1=A[c1]*1.0/2;
double x2=A[c2]*1.0/2;
//System.out.println(max+" "+min);
//System.out.println(F(x1,A)+" "+F(x2,A));
if(F(x1,A)>=F(x2,A)) {
min=c1;
}else{
max=c2;
}
}
//System.out.println((max+min)/2);
return F(A[(max+min)/2]*1.0/2,A);
}
static double F(double x,long A[]) {
//この関数を最小化したい
double res=0;
for(int i=0;i<A.length;i++) {
res+=(x+A[i])-Math.min(2*x,A[i]);
}
return res;
}
static double tripet(double x,double max,double min) {
while(max-min>=0.0000000000001){
double c1=(max-min)/3+min;
double c2=(max-min)*2/3+min;
if(F(x,c1)>=F(x,c2)) {
min=c1;
}else{
max=c2;
}
}
return (max+min)/2;
}
static double F(double x,double y) {
return x+y;
}
private static long f(int now,long cost[],int flag[],ArrayList<ArrayList<Integer>> cc){
long res=0;
for(int to:cc.get(now)) {
if(flag[to]==1)continue;
flag[to]=1;
res+=f(to,cost,flag,cc);
}
return res+cost[now];
}
static void solv2() {
int N=sc.nextInt();
String S[]=new String[N];
for(int i=0;i<N;i++) {
S[i]=sc.next();
}
Scanner sc=new Scanner(System.in);
for(int i=0;i<N;i++) {
if(eval(S[i],S[i].charAt(0)))continue;
for(int j=0;j<N;j++) {
if(i==j)continue;
if(eval(S[j],S[j].charAt(0)))continue;
if(S[i].charAt(0)==S[j].charAt(0)) {
System.out.println("Case #"+(ans++)+": IMPOSSIBLE");
return;
}
if(S[i].charAt(S[i].length()-1)==S[j].charAt(S[j].length()-1)) {
System.out.println("Case #"+(ans++)+": IMPOSSIBLE");
return;
}
}
}
//あとはつなげていって最後に判定する
for(int i=0;i<N;i++) {
if(S[i].length()==0)continue;
if(!eval(S[i],S[i].charAt(0)))continue;
for(int j=0;j<N;j++) {
if(i==j||S[j].length()==0)continue;
if(S[i].charAt(0)==S[j].charAt(S[j].length()-1)) {
S[i]=S[j]+S[i];
S[j]="";
}
}
}
for(int i=0;i<N;i++) {
if(S[i].length()==0)continue;
for(int j=0;j<N;j++) {
if(i==j||S[j].length()==0)continue;
if(S[i].charAt(0)==S[j].charAt(S[j].length()-1)) {
S[i]=S[j]+S[i];
S[j]="";
}
}
}
StringBuffer res = new StringBuffer();
for(int i=0;i<N;i++)res.append(S[i]);
Set<Integer> s=new HashSet<>();
for(int i=0;i<res.length();) {
char V=res.charAt(i);
if(s.contains(V+0)) {
System.out.println("Case #"+(ans++)+": IMPOSSIBLE");
return;
}
s.add(V+0);
while(i<res.length()&&res.charAt(i)==V)i++;
}
System.out.println("Case #"+(ans++)+" "+res.toString());
}
static boolean eval2(String S,char c) {
int s=0;
while(s<S.length()&&S.charAt(s)==c)s++;
if(s==S.length())return false;
while(s<S.length()) {
if(S.charAt(s)==c)return true;
s++;
}
return false;
}
static boolean eval(String S,char c) {
for(int i=0;i<S.length();i++) {
if(S.charAt(i)!=c)return false;
}
return true;
}
static String F(int n) {
StringBuffer S = new StringBuffer();
for(int i=0;i<n;i++) {
S.append("0");
}
return S.toString();
}
static void mol() {
int bit=15;
oneMax O=new oneMax(bit, 100);
int rep=10;
long S=0;
for(int i=0;i<rep;i++) {
long score=O.eval(S);
//System.out.println(S+" score:"+score);
S=O.HC(S);
}
long best=S;
long bestS=O.eval(S);
for(int i=0;i<(1L<<bit);i++) {
long score=O.eval(i);
if(bestS<score) {
System.out.println(bestS+" "+"SCORE:"+score+" "+i);
}
}
}
static class oneMax{
long V[];
int bit;
public oneMax(int bit,int size) {
this.bit=bit;
init(size);
}
private void init(int size) {
V=new long[size];
Random r=new Random();
for(int i=0;i<size;i++) {
long T=Math.abs(r.nextLong());
if(bit!=63) {
T%=(1L<<bit);
}
V[i]=T;
}
System.out.println(Arrays.toString(V));
}
long eval(long A) {
return evalB(A);
}
private long evalA(long A) {
//bit桁の解Aの評価値を返す。
return Long.bitCount(A);
}
private long evalB(long A) {
//bit桁の解Aの評価値を返す。
if(!isPossible(A))return -1;//実行不可能解の場合は-1を返す。
long score=0;
for(int t=0;t<V.length;t++) {
long temp=0;//同じbitの数。
for(int i=0;i<bit;i++) {
if(((V[t]>>i)&1)==((A>>i)&1)) {
temp++;
}
}
score+=temp;
//System.out.println(" "+A+" "+t+" "+temp);
}
return score;
}
long HC(long N) {
//近傍解を取得し、遷移する。
long local_best=N;
long local_best_score=eval(N);
for(int i=0;i<bit;i++) {
//Nのiビット目を反転する。(近傍解の列挙)
long newer=N^(1L<<i);
long score=eval(newer);
//最もスコアの高い近傍を記録する。
if(score>local_best_score) {
local_best_score=score;
local_best=newer;
}
}
return local_best;
}
boolean isPossible(long A) {
//Aが制約を満たすか確かめる。
return A>=0&&(bit==63||A<(1L<<bit));
}
}
static long oneMax_HC_bad2(long N,int bit,Random r,int rMax) {
//悪い山登り法を作ってみる。
//近傍解を適当に定義する。
//randomな値を足した解を近傍解とする。
//rMax:randomに取る値の区間[rMin,rMax)
long local_best=N;
int local_best_score=oneMax_eval(N, bit);
for(int i=0;i<100;i++) {
long V=N^(r.nextInt(rMax));
int score=oneMax_eval(V, bit);
if(score>local_best_score) {
local_best_score=score;
local_best=V;
}
}
return local_best;
}
static long oneMax_HC_bad(long N,int bit,Random r,int rMax) {
//悪い山登り法を作ってみる。
//近傍解を適当に定義する。
//randomな値を足した解を近傍解とする。
//rMax:randomに取る値の区間[rMin,rMax)
long local_best=N;
int local_best_score=oneMax_eval(N, bit);
int t=1;
for(int i=0;i<1000;i++) {
long V=N+t*r.nextInt(rMax);t*=-1;
int score=oneMax_eval(V, bit);
if(score>local_best_score) {
local_best_score=score;
local_best=V;
}
}
return local_best;
}
static boolean isPossible(long N,int bit) {
//実行可能解かチェックする。
return N>=0&&N<(1L<<bit);
}
static long oneMax_HC(long N,int bit) {
//近傍解を取得し、遷移する。
long local_best=N;//best:最もスコアの高い近傍
int local_best_score=oneMax_eval(N, bit);//best_score:最もスコアの高い近傍のスコア
for(int i=0;i<bit;i++) {
//Nのiビット目を反転する。(近傍解の列挙)
//T:近傍解
long newer=N^(1L<<i);
int score=oneMax_eval(newer, bit);
//最もスコアの高い近傍を記録する。
if(score>local_best_score) {
local_best_score=score;
local_best=newer;
}
}
return local_best;
}
static int oneMax_eval(long N,int bit) {
//N:解
//bit:解のビット数
//制約条件:N<(1<<bit) (⇔Nのbit数がbitである)
//-返り値-
//非実行可能解の場合:-1を返す。
if(!isPossible(N, bit))return -1;
return Long.bitCount(N);
}
static int popCount(int n) {
int cnt = (n & 0x55555555) + (n >> 1 & 0x55555555);
cnt = (cnt & 0x33333333) + (cnt >> 2 & 0x33333333);
cnt = (cnt + (cnt >> 4)) & 0x0f0f0f0f;
cnt = cnt + (cnt >> 8);
cnt = cnt + (cnt >> 16);
return cnt & 0x7f;
}
static long eval(int S,int L) {
return modPow(S, L, mod998244353);
}
static void print(int V[][]) {
for(int i=0;i<V.length;i++) {
System.out.println(Arrays.toString(V[i]));
}
}
static String getOrder(int fx,int fy,int tx,int ty,int k,double p) {
StringBuffer res = new StringBuffer();
char V='U';
int count=0;
if(fx==tx) {
count=Math.abs(ty-fy);
if(fy<ty) {
V='R';
}else {
V='L';
}
}
if(fy==ty) {
count=Math.abs(fx-tx);
if(fx<tx) {
V='D';
}else {
V='U';
}
}
int v=count;
for(int i=0;i<k;i++) {
double score=f(p, count, v);
if(score>=0.99)break;
v++;
}
for(int i=0;i<v;i++) {
res.append(V);
}
return res.toString();
}
static double f(double p,int k,int N) {
//試行回数nで、(1-p)の確率で+1でk以上になる確率
double res[]=new double[k+1];
res[0]=1;
for(int i=0;i<N;i++) {
double newer[]=new double[k+1];
for(int t=0;t<k;t++) {
newer[t+1]+=res[t]*(1-p);
newer[t]+=res[t]*p;
}
newer[k]+=res[k];
for(int t=0;t<newer.length;t++) {
res[t]=newer[t];
}
}
return res[k];
}
static class V implements Comparable<V>{
int v,dis,f;
public V(int v,int dis) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.dis=dis;
}
public V(int v,int dis,int f) {
//v->u->w->vの辺
//count:種類数を表す。
this.v=v;this.dis=dis;
this.f=f;
}
public int compareTo(V o) {
Comparable key = (Comparable)this.dis;
Comparable key2 = (Comparable)o.dis;
return key.compareTo(key2);
}
}
static long sqrt(long X) {
long s=0,e=3037000499L;
while(true) {
long g=(s+e)/2;
if(g*g<=X) {
s=g;
}else {
e=g;
}
if((s+e)/2==g)break;
}
return (s+e)/2;
}
static long cal(int V[],long F,int N) {
long res=0;
for(int i=0;i<V.length;i++) {
if(((F>>i)&1)==1) {
res+=(1L<<i)*(N-V[i]);
}else {
res+=(1L<<i)*V[i];
}
}
return res;
}
static void show(int V[]) {
StringBuffer S = new StringBuffer();
for(int i=0;i<V.length;i++) {
S.append(V[i]+" ");
}
System.out.println(S.toString());;
}
static long mal(long a,long b,long mod) {
a%=mod;b%=mod;
long f=a*b;
f%=mod;
return f*modinv(2, mod);
}
static long getCost(long hx,long hy) {
if(hx>hy) {
return hx-hy;
}
if(hx==hy) {
return 0;
}
return -2*(hy-hx);
}
static void swap(char a[],int s,int t) {
char temp=a[s];
a[s]=a[t];
a[t]=temp;
}
static boolean g(long a,long b,long mod) {
a=(a%mod+mod)%mod;
b=(b%mod+mod)%mod;
return a==b;
}
static void reverse(int A[]) {
int B[]=new int[A.length];
for(int i=0;i<A.length;i++) {
A[i]=B[A.length-i-1];
}
A=B.clone();
}
static ArrayList<Long> divide(long T){
ArrayList<Long> cc=new ArrayList<>();
for(long i=1;i*i<=T;i++) {
if(T%i==0) {
cc.add(i);
if(T/i!=i)cc.add(T/i);
}
}
return cc;
}
static boolean check(int x,int y,int H,int W) {
if(x>=H||x<0||y<0||y>=W)return false;
return true;
}
static boolean check(char S[][],int X,int Y,int flag[][],int a) {
if(flag[X][Y]!=0||S[X][Y]=='.')return false;
Deque<Integer> x=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
Deque<Integer> y=new ArrayDeque<>();//push後ろに入れる,poll(pop)後ろからとる,peek addは先頭に入るからバグ注意
x.add(X);y.add(Y);
int V[]= {0,0,-1,1};
flag[X][Y]=a;
int N=S.length;
while(!x.isEmpty()) {
X=x.poll();
Y=y.poll();
for(int i=0;i<4;i++) {
if(X+V[i]<0||X+V[i]>=N||Y+V[(i+2)%4]<0||Y+V[(i+2)%4]>=N||flag[X+V[i]][Y+V[(i+2)%4]]!=0||S[X+V[i]][Y+V[(i+2)%4]]=='.')continue;
x.add(X+V[i]);y.add(Y+V[(i+2)%4]);
flag[X+V[i]][Y+V[(i+2)%4]]=a;
}
}
return true;
}
static void solv3(int cs[],int ct[]) {
int ninesS[]=new int[10];
int ninesT[]=new int[10];
int s=1,t=8;
while(s<10) {
if(cs[s]<=0||ct[t]<=0) {
s++;t--;continue;
}
ninesS[s]=min(cs[s],ct[t]);
ninesT[t]=min(cs[s],ct[t]);
cs[s]-=min(cs[s],ct[t]);ct[t]-=min(cs[s],ct[t]);
}
int use_s=-1,use_t=-1;
//tの9を使わない場合
s=9;
a:while(s>0) {
t=1;
while(t<9) {
if(cs[s]<=0||ct[t]<=0) {
t++;continue;
}
use_s=s;use_t=t;cs[s]--;ct[t]--;break a;
}
}
//tの9を使う場合
if(use_s==-1) {
if(ct[9]>0) {
s=9;
while(s>0) {
if(cs[s]>0) {
cs[s]--;ct[9]--;
use_s=s;use_t=9;break;
}
}
}
}
//9のペアを崩す場合
if(use_s==-1) {
s=9;
while(s>0&&cs[s]<=0)s--;
use_s=s;
t=10-s;
while(t<10&&ninesT[t]<=0)t++;
use_t=t;
if(s==0||t==10)use_s=-1;
else {
cs[s]--;ninesT[t]--;ninesS[9-t]--;
cs[9-t]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ct[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ct[t]--;ninesS[s]--;ninesT[9-s]--;
ct[9-s]++;
}
}
if(use_s==-1) {
t=9;
while(t>0&&ninesT[t]<=0)t--;
use_t=t;
s=10-t;
while(s<10&&ninesS[s]<=0)s++;
use_s=s;
if(t==0||s==10)use_s=-1;
else {
ninesT[t]--;ninesS[9-t]--;ninesS[s]--;ninesT[9-s]--;
//これ余ったやつ戻さないとじゃね
cs[9-t]++;ct[9-s]++;
}
}
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
//まず、10をくっつける作業
if(use_s!=-1) {
S.append((char)('0'+use_s));
T.append((char)('0'+use_t));
}
//次に9をくっつける作業
int a=1;
while(a<10) {
if(ninesS[a]==0) {
a++;continue;
}
S.append((char)('0'+a));
T.append((char)('0'+9-a));ninesS[a]--;
}
//余ったやつをくっつける作業,ctは少し余るかもしれない
//10のマッチングうまくやって無くない？？？？？？？？？？？？？？
int b=8;a=9;
//優先順位はbの大きいやつ
while(b>0) {
a=10-b;
while(ct[b]>0&&a<10) {
if(cs[a]<=0) {
a++;continue;
}
while(ct[b]>0&&cs[a]>0) {
S.append((char)('0'+a));
T.append((char)('0'+b));
cs[a]--;ct[b]--;
}
}
b--;
}
}
static void secondSolv(int cs[],int ct[],int ans_s[],int ans_t[]) {
StringBuffer S = new StringBuffer();
StringBuffer T = new StringBuffer();
int a=1,b=1;
while(a<10&&b<10) {
if(cs[a]==0){
a++;continue;
}
if(ct[b]==0) {
b++;
continue;
}
while(cs[a]!=0&&ct[b]!=0) {
S.append((char)(a+'0'));
T.append((char)(b+'0'));
cs[a]--;ct[b]--;
}
}
//とりあえず要らないやつを付け終わったよ
int i=ans_s.length-1;
while(i>=0) {
if(ans_s[i]==0) {
i--;continue;
}
S.append((char)(ans_s[i]+'0'));
T.append((char)(ans_t[i]+'0'));
i--;
}
b=9;
while(b>0) {
while(ct[b]>0) {
ct[b]--;
T.append((char)(b+'0'));
}
b--;
}
//これで後ろも付け終わったよ
System.out.println(S.toString());
System.out.println(T.toString());
}
static void count(String S,int c[]) {
for(int i=0;i<S.length();i++) {
c[S.charAt(i)-'0']++;
}
}
static void rev(char t[]) {
char temp[]=new char[t.length];
int a=0;
for(int i=t.length-1;i>=0;i--) {
temp[a++]=t[i];
}
for(int i=0;i<t.length;i++) {
t[i]=temp[i];
}
}
static int get(int a,int b,int c,int d,int V[][]) {
//(a,b)~(c,d)の区間を求める
return V[c][d]-V[c][b-1]-V[a-1][d]+V[a-1][b-1];
}
static void add(int x,int y,long data,long DP[][],int H,int W,int V[][]) {
if(x<0||y<0||x>=H||y>=W)return;
//System.out.println("add:"+x+" "+y+" ~"+data);
DP[x][y]+=data;
DP[x][y]%=mod998244353;
}
static void opt2(int tourList[],int N,int Dis[][]) {
boolean back=true;
int i0=0;
a:while(back) {
back=false;
for(int i=i0;i<i0+N;i++) {
for(int j=i+2;j<i+N-1;j++) {
int a=tourList[i%N],b=tourList[(i+1)%N],c=tourList[j%N],d=tourList[(j+1)%N];
//if(Dis[a][b]+Dis[c][d]>Dis[a][d]+Dis[b][c]) {
if(Dis[a][b]+Dis[c][d]>Dis[a][c]+Dis[b][d]) {
for (int k = 0; k < (j-i)/2; k++) {
int temp = tourList[(i+1+k)%N];
tourList[(i+1+k)%N] = tourList[(j-k)%N];
tourList[(j-k)%N] = temp;
}
i0=(i+1)%N;
back=true;
continue a;
}
//i->i+1, j->j+1を
//i->j+1,j->i+1につなぎ直す事を考える。
}
}
}
}
static boolean is_swappable(int arrayments[],int a,int b) {
a=arrayments[a];
b=arrayments[b];
if(a==b||a==-b)return false;
//a->bに出来るか。
//1-indexed
int s=index(arrayments, a);
int e=index(arrayments, b);
if(a<0&&e>s)return true;
if(a>0&&s>e)return true;
int target=index(arrayments, -a);
if(a<0&&target<e)return true;
if(a>0&&target>e)return true;
return false;
}
static int index(int arrayments[],int a) {
for(int i=0;i<arrayments.length;i++) {
if(arrayments[i]==a)return i;
}
return -1;
}
static long tsp_solv(int N,long cost[][]) {
int start=0;
long DP[][]=new long[N][1<<N];
for(int i=0;i<N;i++)Arrays.fill(DP[i], LINF);
//スタートの初期化,スタートの位置は本質ではない
DP[start][1<<start]=0;
for(int T=1;T<(1<<N);T++) {
//Tは既に通った頂点の集合を表している。
for(int from=0;from<N;from++) {
if(((T>>from)&1)==0||DP[from][T]==LINF)continue;//まだfromに到達していない
for(int to=0;to<N;to++) {
if(((T>>to)&1)==1)continue;//既にtoに到達している
//from->toへの移動を考える
if(cost[from][to]==LINF)continue;
DP[to][T|1<<to]=Math.min(DP[from][T]+cost[from][to],DP[to][T|1<<to]);
}
}
}
long res=LINF;
for(int i=0;i<N;i++) {
res=Math.min(res,DP[i][(1<<N)-1]+cost[i][start]);
}
return res;
}
static void swap(int A[],int a,int b) {
int temp=A[a];
A[a]=A[b];
A[b]=temp;
}
static int v[]= {0,0,1,-1};
static int sum(int i,int G[]) {
int res=0;
for(int t=0;t<G.length;t++) {
if(((i>>t)&1)==0)continue;
res+=G[t];
}
return res;
}
static boolean check(char V[][],int x,int y,int vx,int vy,int d) {
for(int i=0;i<d;i++) {
if(x<0||y<0||x>=V.length||y>=V[0].length)return false;
if(V[x][y]=='#')return false;
x+=vx;y+=vy;
}
return true;
}
static boolean check(char S[][],char T[][],int a,int b) {
a*=-1;b*=-1;
int N=T.length;
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if((a+i>=N||a+i<0||b+t<0||b+t>=N)&&S[i][t]=='#'){
return false;
}
if((a+i>=N||a+i<0||b+t<0||b+t>=N))continue;
if(S[i][t]!=T[i+a][b+t]&&(S[i][t]=='#'||T[a+i][b+t]=='#')) {
return false;
}
}
}
return true;
}
static void nine(char V[][]) {
char G[][]=clone(V);
int N=V.length;
int a=0,b=0;
for(int i=N-1;i>=0;i--) {
for(int t=0;t<N;t++) {
V[i][t]=G[a++][b];
}
a=0;b++;
}
}
static char[][] idou(char V[][],int a,int b) {
int N=V.length;
char G[][]=new char[N][N];
for(int i=0;i<N;i++) {
for(int t=0;t<N;t++) {
if(i+a<N&&t+b<N&&i+a>=0&&t+b>=0)G[i+a][t+b]=V[i][t];
}
}
return G;
}
static ArrayList<ArrayDeque<Integer>> cc = new ArrayList<>();
static Map<Integer, Integer> m = new HashMap<>();;
static void add(int index) {
if(cc.get(index).size()==0)return;
int color=cc.get(index).pollFirst();
if(!m.containsKey(color)) {
m.put(color, index);
}else {
add(m.get(color));
add(index);
}
}
static void makeT(ArrayList<ArrayList<Integer>> cc,int parent[],int root) {
Arrays.fill(parent, -2);
parent[root]=-1;
Queue<Integer> now = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
now.add(root);
while(!now.isEmpty()) {
int FROM=now.poll();
for(int TO:cc.get(FROM)) {
if(parent[TO]!=-2)continue;
parent[TO]=FROM;
now.add(TO);
}
}
}
static class CUM2{
int V[][];
int h,w;
public CUM2(int A[][]) {//1-indexed
init(A);
}
void init(int A[][]) {
this.h=A.length;this.w=A[0].length;
V=new int[h][w];
for (int i = 0; i < h; i++) {
V[i]=A[i].clone();
}
for (int i = 1; i <h; i++) {
for (int t =1; t <w; t++) {
V[i][t]+=V[i][t-1];
}
}
for (int i = 1; i <w; i++) {
for (int t = 1; t <h; t++) {
V[t][i]+=V[t-1][i];
}
}
}
int get_sum(int a,int b,int c,int d) {
//[a,b]~[c,d]の区間和を返す。1-indexed
return V[c][d]+V[a-1][b-1]-V[a-1][d]-V[c][b-1];
}
}
/*long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}*/
//関数Fについて、区間[a,b]の最小値を求める
static long getF(long a,long b,long c,long d) {
//[a,b]と[c,d]の区間数の和
if(b<c||a>d) {
//完全に含まれない。
return (b-a+1)+(d-c+1);
}
if(c<=a&&b<=d) {
//完全に含まれる1
return d-c+1;
}
if(a<=c&&d<=b) {
//完全に含まれる2
return b-a+1;
}
//一部だけ含まれる。
if(c<=b&&b<=d) {
//[c,b]が含まれる。
return d-a+1;
}
if(c<=a&&a<=d) {
return b-c+1;
}
return -1;
}
static boolean check(int HW[][],int i,int t,int W) {
while(t<W) {
if(HW[i][t]%2==1)return true;
t++;
}
return false;
}
static void SCC(Map<Integer,ArrayList<Integer>> m,int N) {
int BACK[]=new int[N];
Arrays.fill(BACK, -1);
for (int i = 0; i < N; i++) {
if(BACK[i]!=-1)continue;
getBackQuery(m, i, BACK);
BACK[BACK_COUNT]=i;
}
Map<Integer,ArrayList<Integer>> reversedm=new HashMap<>();
for(int Vex:m.keySet()) {
for(int TO:m.get(Vex)) {
if(!reversedm.containsKey(TO))reversedm.put(TO, new ArrayList<>());
reversedm.get(TO).add(Vex);
}
}
uf=new unionFind(N);
for (int i = N-1; i>=0;i--) {
//iを始点として、DFSを行う。到達可能マスが同じグループ
if(uf.get(i)!=i)continue;
sccquery(reversedm, i);
}
}
static void sccquery(Map<Integer,ArrayList<Integer>> reversedm,int vex) {
if(!reversedm.containsKey(vex)||reversedm.get(vex).size()==0)return;
for(int TO:reversedm.get(vex)) {
if(uf.find(vex)==uf.find(TO))continue;
uf.union(vex, TO);
sccquery(reversedm, vex);
}
}
static int BACK_COUNT;
static unionFind uf;
static void getBackQuery(Map<Integer,ArrayList<Integer>> m,int Vex,int BACK[]) {
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int TO:m.get(Vex)) {
if(BACK[TO]!=-1)continue;
BACK[TO]=-2;
getBackQuery(m, Vex, BACK);
BACK[BACK_COUNT++]=TO;
}
}
static ArrayList<Integer> Vs;
static void getTopo(Map<Integer,ArrayList<Integer>> m,int N) {
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
Vs=new ArrayList<>();
for(int V:m.keySet()) {
if(flag[V])continue;
flag[V]=true;
topoQuery(m, V, flag);
Vs.add(V);
}
Collections.reverse(Vs);
}
static void topoQuery(Map<Integer,ArrayList<Integer>> m,int Vex, boolean flag[]) {
//Vexからスタート
//これ、閉路がある時に対応できてなくね
if(!m.containsKey(Vex)||m.get(Vex).size()==0)return;
for(int to:m.get(Vex)) {
if(flag[to])continue;
flag[to]=true;
topoQuery(m, to,flag);
Vs.add(to);
}
}
static class Flow{
static class edge{
int to,cap,rev;
public edge(int to,int cap,int rev) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cap=cap;
this.rev=rev;
}
}
public Flow(int N) {
// TODO 自動生成されたコンストラクター・スタブ
this.N=N;//頂点数
init();
}
void init() {
used=new boolean[N];
G=new ArrayList<>();
for (int i = 0; i < N; i++) {
G.add(new ArrayList<>());
}
}
int N;
ArrayList<ArrayList<edge>> G;//iがfromを意味する 隣接リスト表現
boolean used[];
//from->toへ向かう容量capの辺をグラフに追加する。
void add_edge(int from,int to,int cap) {
G.get(from).add(new edge(to, cap, G.get(to).size()));
G.get(to).add(new edge(from, 0, G.get(from).size()-1));
}
//最大流を求める 最悪計算量はO(F|E|) Fは流量,Eは辺の数?
int max_flow(int s,int t) {
int flow=0;
while(true) {
Arrays.fill(used, false);
int f=dfs(s,t,INF);
if(f==0)return flow;
flow+=f;
}
}
int dfs(int v,int t,int f) {
if(v==t)return f;//tに到着したら終了
used[v]=true;//vに訪れたことを表す
for (int i = 0; i < G.get(v).size(); i++) {
edge e=G.get(v).get(i);
if(used[e.to]||e.cap<=0)continue;
int d=dfs(e.to, t, Math.min(f,e.cap));
if(d>0) {
e.cap-=d;
G.get(e.to).get(e.rev).cap+=d;
return d;
}
}
return 0;
}
//デバッグ用
void get_edges(int T) {
//頂点Tから出る辺を出力する
int cout=0;
for(edge e:G.get(T)) {
System.out.println(cout+++" "+T+"=>"+e.to+" "+e.cap);
}
}
}
static class LCA{
static class edge{
int to;
long cost;
public edge(int to,long cost) {
// TODO 自動生成されたコンストラクター・スタブ
this.to=to;
this.cost=cost;
}
}
int N;//頂点の数(頂点名は、0-indexで命名)
long dist[];//rootから頂点iまでの距離
int root;//木の根
int parents[];//頂点iの親がparents[i]
int doubling[][];
boolean is_built;
ArrayList<ArrayList<edge>> T;
public LCA(int N,int root) {
//頂点数と根を受け取る。
is_built=false;
this.root=root;
this.N=N;
T=new ArrayList<>(N);
for (int i = 0; i < N; i++) {
T.add(new ArrayList<>());
}
}
void add_edge(int u,int v,long cost) {
T.get(u).add(new edge(v,cost));
T.get(v).add(new edge(u,cost));
}
void build() {
init();
is_built=true;
}
void init() {
parents=new int[N];
dist=new long[N];
doubling=new int[31][N];
dfs(T);
init_doubling();
}
void dfs(ArrayList<ArrayList<edge>> T) {
//根からの距離と親を求める。
boolean flag[]=new boolean[N];
Arrays.fill(flag, false);
flag[root]=true;
parents[root]=root;
Queue<Integer> qq = new ArrayDeque<>(); //始点を保存
qq.add(root);
while(!qq.isEmpty()) {
int VEX=qq.poll();
if(T.get(VEX).size()==0)continue;
for(edge e:T.get(VEX)) {
if(flag[e.to])continue;
flag[e.to]=true;
parents[e.to]=VEX;
dist[e.to]=dist[VEX]+e.cost;
qq.add(e.to);
}
}
}
void init_doubling() {
//ダブリングによって、2^k先の祖先を前計算する。
//doubling[T][i]=iから2^T個分先
for (int i = 0; i < N; i++) {
doubling[0][i]=parents[i];
}
for (int T = 1; T < doubling.length; T++) {
for (int i = 0; i < N; i++) {
doubling[T][i]=doubling[T-1][doubling[T-1][i]];
}
}
}
int get_doubling(int from,long K) {
//ダブリングによって、fromからK先の祖先を求める。
//longにするときは、doublingの長さも変えないとだから注意
int res=from;
for (int i = 0; i < doubling.length; i++) {
if(((K>>i)&1)==0)continue;
res=doubling[i][res];
}
return res;
}
int query(int u1,int v1) {
//親からの距離を等しくする。(dist[u1]>dist[v1]とする)
//System.out.println(u1+" "+v1+" "+get_doubling(u1, dist[u1]-dist[v1]));
u1=get_doubling(u1, dist[u1]-dist[v1]);
if(u1==v1)return v1;
//二分探索によって、LCAの手前まで移動させる。
int G=30;
while(G>=0) {
int uTO=doubling[G][u1];
int vTO=doubling[G][v1];
if(uTO!=vTO) {
u1=uTO;
v1=vTO;
}
G--;
}
//System.out.println(parents[u1]+" "+parents[v1]+" "+dist[u1]+" "+dist[v1]+" "+u1+" "+v1);
return parents[u1];
}
int get_LCA(int u,int v) {
if(!is_built)build();
//根をrootとした時の、u,vのLCA(最小共通祖先)を返す。(0-indexed)
if(dist[u]<dist[v]) {
int temp=u;u=v;v=temp;
}
//dist[u]>dist[v]とする。
return query(u,v);
}
long get_dist(int u,int v) {
//u-vの距離
if(!is_built)build();
return -2*dist[get_LCA(u, v)]+dist[u]+dist[v];
}
boolean is_on_path(int u,int v,int a) {
//u-vパス上に頂点aがあるか?
//true:ある
//false:ない
return get_dist(u, a)+get_dist(a, v)==get_dist(u, v);
}
int INF=((1<<31)-1);
long dmtr=-LINF;
long get_diameter() {
if(dmtr!=-INF)return dmtr;
int V1=0;
long max_dis=-LINF;
for(int i=0;i<N;i++) {
long d=get_dist(0, i);
if(d>max_dis) {
max_dis=d;
V1=i;
}
}
max_dis=-INF;
//V1->V2への最大距離。
for (int i = 0; i < N; i++) {
max_dis=Math.max(max_dis,get_dist(V1,i));
}
return dmtr=max_dis;
}
}
static class doubling{
int N;
int bits;
int doubling[][];
long COST[][];
public doubling(int A[],int bits) {
this.bits=bits;
this.N=A.length;
init1(A);
}
public doubling(int A[],int bits,long C[]) {
// TODO 自動生成されたコンストラクター・スタブ
//long C[]は、i=>A[i]に行くコスト
//query2は、iからK番先までのコストの和で、i番までのコストが足されないので注意
this.bits=bits;
this.N=A.length;
init1(A);
init2(C);
}
private void init1(int A[]) {
// TODO 自動生成されたメソッド・スタブ
doubling=new int[bits][N];
for (int i = 0; i < N; i++) {
doubling[0][i]=A[i];
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
doubling[t+1][i]=doubling[t][doubling[t][i]];
}
}
}
private void init2(long C[]) {
COST=new long[bits][N];
for (int i = 0; i < N; i++) {
COST[0][i]=C[i];//i番目からA[i]までのコスト
}
for (int t = 0; t+1 < bits; t++) {
for (int i = 0; i < N; i++) {
COST[t+1][i]=COST[t][doubling[t][i]]+COST[t][i];
}
}
}
//解釈
private int query1(int start,long K) {
//startからK回移動した後の座標を求める。
int now=start;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1)now=doubling[i][now];
}
return now;
}
private long query2(int start,long K,long mod) {
//STARTからK回移動した時のコストを計算する。
int now=start;
long res=0;
for (int i = 0; i < bits; i++) {
if(((K>>i)&1)==1) {
res+=COST[i][now];
now=doubling[i][now];
res%=mod;
}
}
return res;
}
private int query3(int start) {
//startからスタートして、ループに入る時、そのループの長さを返す。
return 1;
}
}
static class DIKSTR{
ArrayList<ArrayList<edge2>> m;
ArrayList<ArrayList<edge2>> rev;
static Map<String,Integer> hash=new HashMap<>();
static int hash_count=0;
long d[];
int V,E;
class edge2{
int to;
long cost;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
}
class pair implements Comparable<pair>{
int VEX;
long cost;
public pair(long cost,int VEX) {
this.VEX=VEX;
this.cost=cost;
}
public int compareTo(pair o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
public DIKSTR(int V,int E) {
this.V=V;//最大の頂点数。
this.E=E;//最大の辺数。
init();
}
public DIKSTR(int V) {
this.V=V;
this.E=0;
init();
}
void init() {
m=new ArrayList<>();
rev=new ArrayList<>();
for (int i = 0; i < V; i++) {
m.add(new ArrayList<>());
rev.add(new ArrayList<>());
}
d=new long[V];
}
void add_edge(int FROM,int TO,long COST) {
m.get(FROM).add(new edge2(TO, COST));
rev.get(TO).add(new edge2(FROM, COST));
}
void add_edge(String FROM,String TO,long COST) {
if(!hash.containsKey(FROM))hash.put(FROM, hash_count++);
if(!hash.containsKey(TO))hash.put(TO, hash_count++);
add_edge(get_hash(FROM), get_hash(TO), COST);
}
int get_hash(String T) {
if(!hash.containsKey(T)) {
hash.put(T, hash_count++);
}
return hash.get(T);
}
long[] dikstr(String r) {
return dikstr(get_hash(r));
}
long[] dikstr(int r) {//rは始点
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<pair> p = new PriorityQueue<>();//add poll
p.add(new pair(0L, r));
int count=0;
while(!p.isEmpty()) {
count++;
if(count>V*V)break;
pair x=p.poll();
int from=x.VEX;
if(x.cost>d[from])continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
long COST=COST(e.cost);
if(d[e.to]>d[from]+COST) {
d[e.to]=d[from]+COST;
p.add(new pair(d[e.to], e.to));
}
}
}
return d.clone();
}
ArrayList<Integer> back(int F,int to){
//両方から辺が生えてる場合しか使えないよ！
ArrayList<Integer> res=new ArrayList<>();
Queue<Integer> q=new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
q.add(F);
res.add(F);
while(!q.isEmpty()) {
count++;
int from=q.poll();
for (int i = 0; i < rev.get(from).size(); i++) {
edge2 e=rev.get(from).get(i);
long COST=COST(e.cost);
if(e.to==from)continue;
if(d[e.to]+COST==d[from]) {
q.add(e.to);
res.add(e.to);
break;
}
}
}
return res;
}
long COST(long e_cost) {
return e_cost;
}
}
static Map<Integer, ArrayList<Integer>> getTree(int N){
Map<Integer, ArrayList<Integer>> m = new HashMap<>();
for (int i = 0; i < N; i++) {
int a = sc.nextInt() - 1, b = sc.nextInt() - 1;
if (!m.containsKey(a))
m.put(a, new ArrayList<Integer>());
if (!m.containsKey(b))
m.put(b, new ArrayList<Integer>());
m.get(a).add(b);
m.get(b).add(a);
}
return m;
}
/*static Map<V,Integer> makeTree(Map<Integer, ArrayList<Integer>> m){
//頂点0を根とした木を構築する。
Queue<Integer> qq = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
Queue<Integer> parent = new ArrayDeque<>(); //add,poll,peek BFSは前から実行される
qq.add(0);
Map<V, Integer> T = new HashMap<>();
parent.add(-1);
Queue<Integer> color = new ArrayDeque<>();
color.add(-1);
while (!qq.isEmpty()) {
int from = qq.poll();
int p = parent.poll();
int c=color.poll();
int X=1;
for (int V : m.get(from)) {
if (V == p)continue;
if(X==c)X++;
qq.add(V);
parent.add(from);
color.add(X);
System.out.println(from +" "+V+" "+X);
T.put(new V(from,V), X++);
}
}
return T;
}*/
static boolean isHaveSameBit(int a,int b) {//同じbitを持っているか
int t=0;
while((a>>t)!=0) {
if(((a>>t)&1)==1&&((b>>t)&1)==1)return true;
t++;
}
return false;
}
static boolean isPalindrome(String S) {//回分になってるか
for (int i = 0; i < S.length()/2; i++) {
if(S.charAt(i)!=S.charAt(S.length()-i-1)) {
return false;
}
}
return true;
}
static int G[];
static boolean xl100=false;
static long modinv(long a,long mod) {
if(!xl100) {
G=new int[3000000];
xl100=true;
}
int temp=(int)a;
if(G[(int)a]!=0)return G[(int)a];
long b=mod,u=1,v=0;
while(b!=0) {
long t=a/b;
a-=t*b;long tem=a;a=b;b=tem;
u-=t*v;tem=u;u=v;v=tem;
}
u%=mod;
if(u<0)u+=mod;
return G[temp]=(int)u;
}
static long[] extendedGCD(long a, long b) {
long s = 0, old_s = 1;
long t = 1, old_t = 0;
long r = b, old_r = a;
while(r != 0) {
long q = old_r / r;
long old_s0 = old_s, old_t0 = old_t, old_r0 = old_r;
old_s = s;
s = old_s0 - q * s;
old_t = t;
t = old_t0 - q * t;
old_r = r;
r = old_r0 - q * r;
}
return new long[] {old_s, old_t};
}
static class graph{
public graph() {
// TODO 自動生成されたコンストラクター・スタブ
}
//コンテスト中だけ
static class edge3{
int to;
long cost;
int K;
public edge3(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge3(int to,long cost,int K) {
this.to=to;
this.cost=cost;
this.K=K;
}
}
long costV(long T,int K) {
//T以上の最小のKの倍数を返す。
long V=(T+K-1)/K;
return V*K;
}
long[] adddikstr(int V,int E,int r,Map<Integer, ArrayList<edge3>> m) {
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge3 e=m.get(from).get(i);
if(d[e.to]>costV(d[from],e.K)+e.cost) {
d[e.to]=costV(d[from],e.K)+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d;
}
//
class edge implements Comparable<edge>{
int from,to;
long cost;
public edge(int from,int to,long b) {
this.from=from;
this.to=to;
this.cost=b;
}
@Override
public int compareTo(edge o) {
Comparable key = (Comparable)this.cost;
Comparable key2 = (Comparable)o.cost;
return key.compareTo(key2);
}
}
static class edge2{
int to;
long cost;
String FROM,TO;
public edge2(int to,long cost) {
this.to=to;
this.cost=cost;
}
public edge2(int to,long cost,String FROM,String TO) {
this.to=to;
this.cost=cost;
this.FROM=FROM;
this.TO=TO;
}
}
//単一始点最短距離問題(ダイクストラ法) 負閉路対策不可 経路復元
long d[];
long[] dikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
//path[e.to]=from;
}
}
}
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return d.clone();
}
long[] additionalDikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m,int banned) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
d=new long[V];
Arrays.fill(d, LINF);
d[r]=0;
PriorityQueue<Pair<Long,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Long, Integer>(0L, r));
while(!p.isEmpty()) {
Pair<Long,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>d[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(from==banned&&e.to==0)continue;
if(d[e.to]>d[from]+e.cost) {
d[e.to]=d[from]+e.cost;
p.add(new Pair<Long, Integer>(d[e.to], e.to));
}
}
}
return d.clone();
}
int D[];
int[] Intdikstr(int V,int E,int r,Map<Integer, ArrayList<edge2>> m) {
//int path[]=new int[V];
//Arrays.fill(path, -1);
D=new int[V];
Arrays.fill(D, INF);
D[r]=0;
PriorityQueue<Pair<Integer,Integer>> p = new PriorityQueue<>();//add poll
p.add(new Pair<Integer, Integer>(0, r));
while(!p.isEmpty()) {
Pair<Integer,Integer> x=p.poll();
int from=x.getValue();
if(x.getKey()>D[from])continue;
if(!m.containsKey(from))continue;
for (int i = 0; i < m.get(from).size(); i++) {
edge2 e=m.get(from).get(i);
if(D[e.to]>D[from]+e.cost) {
D[e.to]=(int) (D[from]+e.cost);
p.add(new Pair<Integer, Integer>(D[e.to], e.to));
//path[e.to]=from;
}
}
}
p.clear();
//経路復元
//複数の経路を考える必要がある時は、pathに複数の同じような最短経路の辺を保存しておく
//ArrayList<Integer> PATHs = new ArrayList<>();
//int t=V-1;//goalから逆算する この場合0=goal
//for(;t!=-1;t=path[t]) {
// PATHs.add(t);
//}
//p(path);
//Collections.reverse(PATHs);
//System.out.println(PATHs);
return D;
}
//単一始点最短距離問題(ベルマンフォード法) 負閉路対策済み
long[] Bellman_Ford(int V,int E,int r,edge e[]) {
long d[]=new long[V]; //0~eのグラフはこれ
//Map<Integer, Integer> d = new HashMap<>();それ以外はこれ
//for(int i=0;i<E;i++) {
// if(!d.containsKey(e[i].to))m.add(new Pair<Integer, Integer>(e[i].to, INF));
// if(!d.containsKey(e[i].from))m.add(new Pair<Integer, Integer>(e[i].from, INF));
//}
//d.replace(r, 0);
Arrays.fill(d, INF);
d[r]=0;
int count=0;
while(true) {
boolean update =false;
for(int i=0;i<E;i++) {
if(d[e[i].from]!=INF&&d[e[i].from]+e[i].cost<d[e[i].to]) {
update=true;
d[e[i].to]=d[e[i].from]+e[i].cost;
}
}
if(!update)break;
if(count==V) {
p("NEGATIVE CYCLE");
return null;
}
count++;
}
return d;
}
//最小全域木問題(クラスカル法)
long kruskal(int V,edge es[]) {
unionFind uf = new unionFind(V);
Arrays.sort(es);
long res=0;
for (int i = 0; i < es.length; i++) {
if(uf.find( es[i].from)!=uf.find( es[i].to)) {
uf.union(es[i].from, es[i].to);
res+=es[i].cost;
}
}
return res;
}
}
private static long Pow(long i,long t) {
//iのt乗をO(log t)で返す
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをStringで受け取りたい時用
while(t!=0) {
if((1&t)==1) {
res=res*a;
}
a=a*a;
t=t>>1;
}
return res;
}
private static Map<Long, Integer> primeNumbers(long N) {//素因数列挙
Map<Long, Integer> c = new HashMap<>();
for(long i=2;i*i<=N;i++) {
if(N%i==0) {
int count=0;
while(N%i==0) {
N/=i;
count++;
}
c.put(i, count);
continue;
}
}
if(N!=1) {
c.put(N, 1);
}
return c;
}
//=========================Union Find=============================================
//union idx2 tree to idx1 tree O(a(N))
static class unionFind{
int UNI[],n,graph_s;
int size[];
public unionFind(int N) {
// TODO 自動生成されたコンストラクター・スタブ
n=N;
graph_s=N;
init();
}
void init() {
UNI=new int[n];
size=new int[n];
Arrays.fill(size, 1);
for (int i = 0; i < n; i++) {
UNI[i]=i;
}
}
int get(int idx) {
return UNI[idx];
}
int find(int idx) {//木の根のindexを返す
if(UNI[idx]==idx) return idx;
return UNI[idx] = find(UNI[idx]);
}
void shape() {//木の根に直接つなげる 経路圧縮
for(int i=0;i<n;i++) {
find(i);
}
}
void union(int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(UNI[root2]!=root1) {
graph_s--;
size[root1]+=size[root2];
size[root2]=size[root1];
}
UNI[root2] = root1;
}
int get_size(int idx) {
return size[find(idx)];
}
void breaker(int idx1,int idx2) {
UNI[idx1]=idx1;
}
int MaxSize() {//最も大きい木の頂点数を返す
shape();
int V[]=new int[n];
int max=0;
for(int i=0;i<n;i++) {
V[UNI[i]]++;
max=Math.max(max, V[UNI[i]]);
}
return max;
}
int sum() {//木の数を返す
int res=0;
for(int i=0;i<n;i++) {
if(UNI[i]==i)res++;
}
return res;
}
void union2(int tree[],int idx1,int idx2) {//idx1の根にidx2をつなげる
int root1 = find(idx1);
int root2 = find(idx2);
if(root1==root2)return;
if(c.get(root1).size()>c.get(root2).size()) {
//root2をroot1に移し替える
for(int a:c.get(root2).keySet()) {
if(!c.get(root1).containsKey(a)) {
c.get(root1).put(a, 0);
}
c.get(root1).replace(a, c.get(root1).get(a)+c.get(root2).get(a));
}
tree[root2] = root1;
}else {
for(int a:c.get(root1).keySet()) {
if(!c.get(root2).containsKey(a)) {
c.get(root2).put(a, 0);
}
c.get(root2).replace(a, c.get(root2).get(a)+c.get(root1).get(a));
}
tree[root1] = root2;
}
}
}
//=========================二分探索=============================================
private static class binarySearch{
public binarySearch() {
// TODO 自動生成されたコンストラクター・スタブ
}
int BinarySearch(int A[],int value) {
int S=0,E=A.length,G=-1;
while(S<=E) {
G=(S+E)/2;
if(A[G]==value)return G;
else if(A[G]>value) {
if(E==G)break;E=G;
}else if(A[G]<value) {
if(S==G)break;S=G;
}
}
return -1;
}
int lowerBound(int A[],int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(value<=A[0])return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(int A[],int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(long A[],long value) {
//A[i-1]<value<=A[i] value以上の最小indexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>=value)return 0;
if(A[A.length-1]<value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>=value&&A[G-1]<value) {
return G;
}else if(A[G]>=value) {
E=G;
}else if(A[G]<value) {
S=G;
}
}
}
int upperBound(long A[],long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.length,G=-1;
if(A[0]>value)return 0;
if(A[A.length-1]<=value)return A.length;
while(true) {
G=(S+E)/2;
if(A[G]>value&&A[G-1]<=value) {
return G;
}else if(A[G]>value) {
E=G;
}else if(A[G]<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Integer> A,int value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Integer> A,int value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
int lowerBound(ArrayList<Long> A,long value) {
//A[i-1]<value<=A[i] value以上のindexを返す
//value未満しかなかったらA.lengthを返す
//value以上の個数は(A.length-i)value未満の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>=value)return 0;
if(A.get(A.size()-1)<value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>=value&&A.get(G-1)<value) {
return G;
}else if(A.get(G)>=value) {
E=G;
}else if(A.get(G)<value) {
S=G;
}
}
}
int upperBound(ArrayList<Long> A,long value) {
//A[i-1]<=value<A[i] valueより大きい数のindexの最小値を返す
//value以下しかなかったらA.lengthを返す
//valueより大きい数の個数は(A.length-i)value以下の個数はiである
int S=0,E=A.size(),G=-1;
if(A.get(0)>value)return 0;
if(A.get(A.size()-1)<=value)return A.size();
while(true) {
G=(S+E)/2;
if(A.get(G)>value&&A.get(G-1)<=value) {
return G;
}else if(A.get(G)>value) {
E=G;
}else if(A.get(G)<=value) {
S=G;
}
}
}
}
private static long modNcR2(int n,int r,int mod) {
if(r<0||n<r)return 0;
long N=kaijou(n, mod);
long Nr=kaijou(n-r, mod);
long R=kaijou(r, mod);
return (((N*modPow(Nr, mod-2, mod))%mod)*modPow(R, mod-2, mod))%mod;
// n!/(n-r)!/r!
}
private static long modNcR(int n,int r,long mod) {
if(r<0||n<r)return 0;
long res=1;
for(int i=0;i<r;i++) {
res*=n;res%=mod;n--;
}
for(int i=0;i<r;i++) {
res*=modinv(i+1, mod);res%=mod;
}
return res;
// n!/(n-r)!/r!
}
private static long modNcR2(int n,int r,long mod) {
if(r<0||n<r)return 0;
long N=kaijou(n, mod);
long Nr=kaijou(n-r, mod);
long R=kaijou(r, mod);
return (((N*modPow(Nr, mod-2, mod))%mod)*modPow(R, mod-2, mod))%mod;
// n!/(n-r)!/r!
}
private static long modPow(long i,long t,long mod) {
if(t==0)return 1%mod;
if(i==0||t<0)return 0;//0未満乗は未定義で
//iのt乗をO(log t)で返す
i%=mod;
long a=i;
long res=1;
//for(int i=0;i<S.length();i++) {if(S.charAt(N-i)=='1') {res=res*a%mod;}
//tをbitのStringで受け取った時用？
while(t!=0) {
if((1&t)==1) {
res=res*a%mod;
}
a=a*a%mod;
t=t>>1;
}
return res;
}
private static long min(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int min(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static int max(int ...a) {
int m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static long max(long ...a) {
long m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static double min(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.min(a[i], m);
}
return m;
}
private static double max(double ...a) {
double m=a[0];
for(int i=0;i<a.length;i++) {
m=Math.max(a[i], m);
}
return m;
}
private static int abs(int a) {
return Math.max(a,-a);
}
private static long abs(long a) {
return Math.max(a,-a);
}
private static double abs(double a) {
return Math.max(a,-a);
}
private static String zeroume(String S,int V) {
while(S.length()<V)S='0'+S;
return S;
}
//速度が足りないときは、前計算を1回だけにしたり、longをintに変えたりするといい
//エラストネスの篩風のやつもあり
private static long gcd(long ...nums) {
long res=0;
for (int i = 0; i < nums.length; i++) {
res=gcd(res,nums[i]);
}
return res;
}
private static long lcm(long ...nums) {
long res=1;
for (int i = 0; i < nums.length; i++) {
res=lcm(res,nums[i]);
}
return res;
}
public static long gcd(long num1,long num2) {
if(num2==0) return num1;
else return gcd(num2,num1%num2);
}
public static long lcm(long num1,long num2) {
return num1*num2/gcd(num1,num2);
}
//O(N^0.5)
private static void bubunwa() {
int N=sc.nextInt();
int K=sc.nextInt();
int a[]=sc.nextIntArray(N, false);
boolean dp[] =new boolean[K+1];
Arrays.fill(dp, false);
dp[0]=true;
for(int i=0;i<N;i++) {
for(int x=K-a[i];x>=0;x--) {
if(dp[x])dp[x+a[i]]=true;
}
}
p(dp[K] ? "Yes":"No");
}
static String nextPermutation(String s) {
ArrayList<Character> list=new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
list.add(s.charAt(i));
}
int pivotPos=-1;
char pivot=0;
for(int i=list.size()-2;i>=0;i--) {
if(list.get(i)<list.get(i+1)) {
pivotPos=i;
pivot=list.get(i);
break;
}
}
if(pivotPos==-1&&pivot==0) {
return "Final";
}
int L=pivotPos+1,R=list.size()-1; int minPos=-1;
char min =Character.MAX_VALUE;
for(int i=R;i>=L;i--) {
if(pivot<list.get(i)) {
if(list.get(i)<min) {
min=list.get(i);
minPos=i;
}
}
}
Collections.swap(list, pivotPos, minPos);
Collections.sort(list.subList(L, R+1));
StringBuilder sb=new StringBuilder();
for(int i=0;i<list.size();i++) {
sb.append(list.get(i));
}
return sb.toString();
}
private static long[][] com;
private static void nCr(int mod) {
int MAX = 3001;
com= new long[MAX][MAX];
for(int i = 0; i < MAX; i++)
com[i][0] = 1;
for(int i = 1; i < MAX; i++) {
for(int j = 1; j <= i; j++) {
com[i][j] = com[i-1][j-1] + com[i-1][j];
com[i][j] %= mod;
}
}
}
//https://qiita.com/p_shiki37/items/65c18f88f4d24b2c528b より
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
return (int) nextLong();
}
public double nextDouble(){
return Double.parseDouble(next());
}
public int[] nextIntArray(int N) {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
public int[] nextIntArray(int N, boolean oneBased) {
if (oneBased) {
int[] array = new int[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextInt();
}
return array;
} else {
int[] array = new int[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextInt();
}
return array;
}
}
public long[] nextLongArray(int N, boolean oneBased) {
if (oneBased) {
long[] array = new long[N + 1];
for (int i = 1; i <= N; i++) {
array[i] = sc.nextLong();
}
return array;
} else {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
}
public int[] nextRandIntArray(int N, boolean oneBased,int max) {
Random r=new Random();
if(oneBased)N++;
int array[]=new int[N];
for(int i=0;i<N;i++) {
array[i]=r.nextInt(max+1);
}
if(oneBased)array[0]=0;
return array;
}
public long[] nextLongArray(int N) {
long[] array = new long[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextLong();
}
return array;
}
public long[][]nextLongDimensionalArray(int H,int W) {
long[][] array = new long[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextLongArray(W);
}
return array;
}
public int[][]nextIntDimensionalArray(int H,int W) {
int[][] array = new int[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextIntArray(W);
}
return array;
}
public String[] nextArray(int N) {
String[] array = new String[N];
for (int i = 0; i < N; i++) {
array[i] = sc.next();
}
return array;
}
public String[][]nextDimensionalArray(int H,int W) {
String[][] array = new String[H][W];
for (int i = 0; i < H; i++) {
array[i] =sc.nextArray(W);
}
return array;
}
public double[] nextDoubleArray(int N) {
double[] array = new double[N];
for (int i = 0; i < N; i++) {
array[i] = sc.nextDouble();
}
return array;
}
}
}
|
ConDefects/ConDefects/Code/agc057_a/Java/33023989
|
condefects-java_data_581
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new In();
static Out out = new Out();
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 1000000007;
void solve() {
int t = in.nextInt();
while (t --> 0) {
long l = in.nextLong();
long r = in.nextLong();
if (Long.toString(l).length() == Long.toString(r).length()) {
out.println(r - l + 1);
continue;
}
long lower = f(r);
if (lower == r) {
out.println(closed(Math.max(l, lower / 10 + 1), r));
continue;
}
long ans = closed(lower, r);
if (lower * 2 <= r) {
out.println(ans);
continue;
}
ans += closed(Math.max(Math.max(r % lower + 1, lower / 10 * 2), l), lower - 1);
ans += closed(Math.max(Math.max(r / 10 + 1, lower / 10 + 1), l), lower / 10 * 2 - 1);
out.println(ans);
}
}
long closed(long l, long r) {
return l <= r ? r - l + 1 : 0;
}
long f(long n) {
long v = 1;
while (v * 10 <= n) {
v *= 10;
}
return v;
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
boolean autoFlush = false;
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
out.flush();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new In();
static Out out = new Out();
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 1000000007;
void solve() {
int t = in.nextInt();
while (t --> 0) {
long l = in.nextLong();
long r = in.nextLong();
if (Long.toString(l).length() == Long.toString(r).length()) {
out.println(r - l + 1);
continue;
}
long lower = f(r);
if (lower == r) {
out.println(closed(Math.max(l, lower / 10 + 1), r));
continue;
}
long ans = closed(lower, r);
if (lower * 2 <= r) {
out.println(ans);
continue;
}
ans += closed(Math.max(Math.max(r % lower + 1, lower / 10 * 2), l), lower - 1);
ans += closed(Math.max(Math.max(Math.max(r / 10 + 1, lower / 10 + 1), l), r % lower + 1), lower / 10 * 2 - 1);
out.println(ans);
}
}
long closed(long l, long r) {
return l <= r ? r - l + 1 : 0;
}
long f(long n) {
long v = 1;
while (v * 10 <= n) {
v *= 10;
}
return v;
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
boolean autoFlush = false;
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
out.flush();
}
}
|
ConDefects/ConDefects/Code/agc057_a/Java/31489192
|
condefects-java_data_582
|
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;
public class Main {
static long MOD = 998244353l;
int min = Integer.MAX_VALUE;
int max = 0;
char result[][];
int count = 0;
int pattern = 0;
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new File("1.txt"));
var sc = new FastScanner();
// var sc = new FastScanner(fis);
// var pw = new FastPrintStream("test_normal_result.csv");
var pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}
public static void solve(FastScanner sc, FastPrintStream pw) {
int t = sc.nextInt();
for (int i = 0; i < t; i++) {
int l = sc.nextInt();
int r = sc.nextInt();
int re = 0;
String sl = String.valueOf(l);
String sr = String.valueOf(r);
if (sl.length() == sr.length()) {
pw.println(r - l + 1);
continue;
}
int min = 1;
for (int j = 0; j < sr.length() - 1; j++) {
min *= 10;
}
re = r - min + 1;
if (r < min * 2) {
re += (min - 1) - Math.max(min / 10 + 1, Math.max(r + 1 - min, l)) + 1;
}
pw.println(re);
}
}
public static Point checkPoint(char ch) {
Point re = new Point(0, 0);
switch (ch) {
case 'N': {
re.x--;
break;
}
case 'S': {
re.x++;
break;
}
case 'E': {
re.y++;
break;
}
case 'W': {
re.y--;
break;
}
}
return re;
}
public char[][] copyArray(char c[][], int n) {
char re[][] = new char[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
re[i][j] = c[i][j];
}
}
return re;
}
public static void swap(int[] s, int i, int j) {
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
public void permutation(int[] s, int from, int to, int a[]) {
if (to <= 1)
return;
if (from == to) {
check(s, a);
} else {
for (int i = from; i <= to; i++) {
swap(s, i, from);
permutation(s, from + 1, to, a);
swap(s, from, i);
}
}
}
public void check(int[] s, int a[]) {
int re = 0;
int b[][] = new int[2][3];
for (int i = 0; i < 6; i++) {
b[i / 3][i % 3] = a[s[i]];
}
int maxx = 0;
int maxy = 0;
int minx = 10000;
int miny = 10000;
for (int i = 0; i < 3; i++) {
maxx = Math.max(maxx, b[0][i]);
minx = Math.min(minx, b[0][i]);
maxy = Math.max(maxy, b[1][i]);
miny = Math.min(miny, b[1][i]);
}
re = (maxx - minx) * (maxy - miny) * 2;
re = re - (Math.abs(b[0][0] - b[0][1]) * Math.abs(b[1][0] - b[1][1]));
re = re - (Math.abs(b[0][0] - b[0][2]) * Math.abs(b[1][0] - b[1][2]));
re = re - (Math.abs(b[0][2] - b[0][1]) * Math.abs(b[1][2] - b[1][1]));
max = Math.max(re, max);
}
public static long anothertoTen(long ano, int another) {
long ten = 0;
long now = 1;
long temp = ano;
while (temp > 0) {
long i = temp % 10;
ten += now * i;
now *= another;
temp /= 10;
}
return ten;
}
public static long tentoAnother(long ten, int another) {
Stack<Long> stack = new Stack<Long>();
while (ten > 0) {
stack.add(ten % another);
ten /= another;
}
long re = 0;
while (!stack.isEmpty()) {
long pop = stack.pop();
re = re * 10 + pop;
}
return re;
}
// 2C5 = 5*4/(2*1)
public static long XCY(long x, long y) {
long temp = 1;
for (int i = 0; i < x; i++) {
temp = (temp * (y - i)) % MOD;
}
long tempx = 1;
for (int i = 2; i <= x; i++) {
tempx = (tempx * i) % MOD;
}
tempx = modpow(tempx, (long) MOD - 2);
temp = (temp * tempx) % MOD;
return temp;
}
static long modpow(long N, Long K) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(MOD)).longValue();
}
static long modpow(long N, Long K, long mod) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(mod)).longValue();
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
public static int gcd(int a, int b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
}
class Range {
long x = 0;
long c = 0;
public Range(long x, long c) {
this.x = x;
this.c = c;
}
}
class Target {
int t;
long c;
boolean bool;
}
class Point implements Comparable {
int x;
int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int compareTo(Object p) {
Point t = (Point) p;
if (this.y < t.y) {
return -1;
}
if (this.y > t.y) {
return 1;
}
if (this.x < t.x) {
return -1;
}
return 1;
}
}
class PointY implements Comparable {
int a;
int b;
public int compareTo(Object p) {
PointY t = (PointY) p;
if (this.a > t.a) {
return -1;
}
if (this.a < t.a) {
return 1;
}
return 0;
}
}
class FastPrintStream implements AutoCloseable {
private static final int BUF_SIZE = 1 << 15;
private final byte[] buf = new byte[BUF_SIZE];
private int ptr = 0;
private final java.lang.reflect.Field strField;
private final java.nio.charset.CharsetEncoder encoder;
private java.io.OutputStream out;
public FastPrintStream(java.io.OutputStream out) {
this.out = out;
java.lang.reflect.Field f;
try {
f = java.lang.String.class.getDeclaredField("value");
f.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
f = null;
}
this.strField = f;
this.encoder = java.nio.charset.StandardCharsets.US_ASCII.newEncoder();
}
public FastPrintStream(java.io.File file) throws java.io.IOException {
this(new java.io.FileOutputStream(file));
}
public FastPrintStream(java.lang.String filename) throws java.io.IOException {
this(new java.io.File(filename));
}
public FastPrintStream() {
this(System.out);
try {
java.lang.reflect.Field f = java.io.PrintStream.class.getDeclaredField("autoFlush");
f.setAccessible(true);
f.set(System.out, false);
} catch (IllegalAccessException | IllegalArgumentException | NoSuchFieldException e) {
// ignore
}
}
public FastPrintStream println() {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) '\n';
return this;
}
public FastPrintStream println(java.lang.Object o) {
return print(o).println();
}
public FastPrintStream println(java.lang.String s) {
return print(s).println();
}
public FastPrintStream println(char[] s) {
return print(s).println();
}
public FastPrintStream println(char c) {
return print(c).println();
}
public FastPrintStream println(int x) {
return print(x).println();
}
public FastPrintStream println(long x) {
return print(x).println();
}
public FastPrintStream println(double d, int precision) {
return print(d, precision).println();
}
private FastPrintStream print(byte[] bytes) {
int n = bytes.length;
if (ptr + n > BUF_SIZE) {
internalFlush();
try {
out.write(bytes);
} catch (java.io.IOException e) {
throw new RuntimeException();
}
} else {
System.arraycopy(bytes, 0, buf, ptr, n);
ptr += n;
}
return this;
}
public FastPrintStream print(java.lang.Object o) {
return print(o.toString());
}
public FastPrintStream print(java.lang.String s) {
if (strField == null) {
return print(s.getBytes());
} else {
try {
return print((byte[]) strField.get(s));
} catch (IllegalAccessException e) {
return print(s.getBytes());
}
}
}
public FastPrintStream print(char[] s) {
try {
return print(encoder.encode(java.nio.CharBuffer.wrap(s)).array());
} catch (java.nio.charset.CharacterCodingException e) {
byte[] bytes = new byte[s.length];
for (int i = 0; i < s.length; i++) {
bytes[i] = (byte) s[i];
}
return print(bytes);
}
}
public FastPrintStream print(char c) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) c;
return this;
}
public FastPrintStream print(int x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(long x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(double d, int precision) {
if (d < 0) {
print('-');
d = -d;
}
d += Math.pow(10, -d) / 2;
print((long) d).print('.');
d -= (long) d;
for (int i = 0; i < precision; i++) {
d *= 10;
print((int) d);
d -= (int) d;
}
return this;
}
private void internalFlush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void flush() {
try {
out.write(buf, 0, ptr);
out.flush();
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void close() {
try {
out.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
private static int len(int x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
int p = -10;
for (int i = 1; i < 10; i++, p *= 10)
if (x > p)
return i + d;
return 10 + d;
}
private static int len(long x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
long p = -10;
for (int i = 1; i < 19; i++, p *= 10)
if (x > p)
return i + d;
return 19 + d;
}
}
class FastScanner implements AutoCloseable {
private final java.io.InputStream in;
private final byte[] buf = new byte[2048];
private int ptr = 0;
private int buflen = 0;
public FastScanner(java.io.InputStream in) {
this.in = in;
}
public FastScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen)
return true;
ptr = 0;
try {
buflen = in.read(buf);
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
return buflen > 0;
}
private int readByte() {
return hasNextByte() ? buf[ptr++] : -1;
}
public boolean hasNext() {
while (hasNextByte() && !(32 < buf[ptr] && buf[ptr] < 127))
ptr++;
return hasNextByte();
}
private StringBuilder nextSequence() {
if (!hasNext())
throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
for (int b = readByte(); 32 < b && b < 127; b = readByte()) {
sb.appendCodePoint(b);
}
return sb;
}
public String next() {
return nextSequence().toString();
}
public String next(int len) {
return new String(nextChars(len));
}
public char nextChar() {
if (!hasNextByte())
throw new java.util.NoSuchElementException();
return (char) readByte();
}
public char[] nextChars() {
StringBuilder sb = nextSequence();
int l = sb.length();
char[] dst = new char[l];
sb.getChars(0, l, dst, 0);
return dst;
}
public char[] nextChars(int len) {
if (!hasNext())
throw new java.util.NoSuchElementException();
char[] s = new char[len];
int i = 0;
int b = readByte();
while (32 < b && b < 127 && i < len) {
s[i++] = (char) b;
b = readByte();
}
if (i != len) {
throw new java.util.NoSuchElementException(
String.format("Next token has smaller length than expected.", len));
}
return s;
}
public long nextLong() {
if (!hasNext())
throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b)
throw new NumberFormatException();
while (true) {
if ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
} else if (b == -1 || !(32 < b && b < 127)) {
return minus ? -n : n;
} else
throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() {
return Math.toIntExact(nextLong());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public void close() {
try {
in.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_j
*/
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Long.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return -1;
}
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return false;
}
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n)) {
return -1;
}
return -parentOrSize[leader(a)];
}
ArrayList<ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < n; i++) {
result.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
return result;
}
}
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Stack;
public class Main {
static long MOD = 998244353l;
int min = Integer.MAX_VALUE;
int max = 0;
char result[][];
int count = 0;
int pattern = 0;
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new File("1.txt"));
var sc = new FastScanner();
// var sc = new FastScanner(fis);
// var pw = new FastPrintStream("test_normal_result.csv");
var pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}
public static void solve(FastScanner sc, FastPrintStream pw) {
int t = sc.nextInt();
for (int i = 0; i < t; i++) {
int l = sc.nextInt();
int r = sc.nextInt();
int re = 0;
String sl = String.valueOf(l);
String sr = String.valueOf(r);
if (sl.length() == sr.length()) {
pw.println(r - l + 1);
continue;
}
int min = 1;
for (int j = 0; j < sr.length() - 1; j++) {
min *= 10;
}
re = r - min + 1;
if (r < min * 2) {
re += (min - 1) - Math.max(r / 10 + 1, Math.max(r + 1 - min, l)) + 1;
}
pw.println(re);
}
}
public static Point checkPoint(char ch) {
Point re = new Point(0, 0);
switch (ch) {
case 'N': {
re.x--;
break;
}
case 'S': {
re.x++;
break;
}
case 'E': {
re.y++;
break;
}
case 'W': {
re.y--;
break;
}
}
return re;
}
public char[][] copyArray(char c[][], int n) {
char re[][] = new char[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
re[i][j] = c[i][j];
}
}
return re;
}
public static void swap(int[] s, int i, int j) {
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
public void permutation(int[] s, int from, int to, int a[]) {
if (to <= 1)
return;
if (from == to) {
check(s, a);
} else {
for (int i = from; i <= to; i++) {
swap(s, i, from);
permutation(s, from + 1, to, a);
swap(s, from, i);
}
}
}
public void check(int[] s, int a[]) {
int re = 0;
int b[][] = new int[2][3];
for (int i = 0; i < 6; i++) {
b[i / 3][i % 3] = a[s[i]];
}
int maxx = 0;
int maxy = 0;
int minx = 10000;
int miny = 10000;
for (int i = 0; i < 3; i++) {
maxx = Math.max(maxx, b[0][i]);
minx = Math.min(minx, b[0][i]);
maxy = Math.max(maxy, b[1][i]);
miny = Math.min(miny, b[1][i]);
}
re = (maxx - minx) * (maxy - miny) * 2;
re = re - (Math.abs(b[0][0] - b[0][1]) * Math.abs(b[1][0] - b[1][1]));
re = re - (Math.abs(b[0][0] - b[0][2]) * Math.abs(b[1][0] - b[1][2]));
re = re - (Math.abs(b[0][2] - b[0][1]) * Math.abs(b[1][2] - b[1][1]));
max = Math.max(re, max);
}
public static long anothertoTen(long ano, int another) {
long ten = 0;
long now = 1;
long temp = ano;
while (temp > 0) {
long i = temp % 10;
ten += now * i;
now *= another;
temp /= 10;
}
return ten;
}
public static long tentoAnother(long ten, int another) {
Stack<Long> stack = new Stack<Long>();
while (ten > 0) {
stack.add(ten % another);
ten /= another;
}
long re = 0;
while (!stack.isEmpty()) {
long pop = stack.pop();
re = re * 10 + pop;
}
return re;
}
// 2C5 = 5*4/(2*1)
public static long XCY(long x, long y) {
long temp = 1;
for (int i = 0; i < x; i++) {
temp = (temp * (y - i)) % MOD;
}
long tempx = 1;
for (int i = 2; i <= x; i++) {
tempx = (tempx * i) % MOD;
}
tempx = modpow(tempx, (long) MOD - 2);
temp = (temp * tempx) % MOD;
return temp;
}
static long modpow(long N, Long K) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(MOD)).longValue();
}
static long modpow(long N, Long K, long mod) {
return BigInteger.valueOf(N).modPow(BigInteger.valueOf(K), BigInteger.valueOf(mod)).longValue();
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
public static int gcd(int a, int b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
}
class Range {
long x = 0;
long c = 0;
public Range(long x, long c) {
this.x = x;
this.c = c;
}
}
class Target {
int t;
long c;
boolean bool;
}
class Point implements Comparable {
int x;
int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int compareTo(Object p) {
Point t = (Point) p;
if (this.y < t.y) {
return -1;
}
if (this.y > t.y) {
return 1;
}
if (this.x < t.x) {
return -1;
}
return 1;
}
}
class PointY implements Comparable {
int a;
int b;
public int compareTo(Object p) {
PointY t = (PointY) p;
if (this.a > t.a) {
return -1;
}
if (this.a < t.a) {
return 1;
}
return 0;
}
}
class FastPrintStream implements AutoCloseable {
private static final int BUF_SIZE = 1 << 15;
private final byte[] buf = new byte[BUF_SIZE];
private int ptr = 0;
private final java.lang.reflect.Field strField;
private final java.nio.charset.CharsetEncoder encoder;
private java.io.OutputStream out;
public FastPrintStream(java.io.OutputStream out) {
this.out = out;
java.lang.reflect.Field f;
try {
f = java.lang.String.class.getDeclaredField("value");
f.setAccessible(true);
} catch (NoSuchFieldException | SecurityException e) {
f = null;
}
this.strField = f;
this.encoder = java.nio.charset.StandardCharsets.US_ASCII.newEncoder();
}
public FastPrintStream(java.io.File file) throws java.io.IOException {
this(new java.io.FileOutputStream(file));
}
public FastPrintStream(java.lang.String filename) throws java.io.IOException {
this(new java.io.File(filename));
}
public FastPrintStream() {
this(System.out);
try {
java.lang.reflect.Field f = java.io.PrintStream.class.getDeclaredField("autoFlush");
f.setAccessible(true);
f.set(System.out, false);
} catch (IllegalAccessException | IllegalArgumentException | NoSuchFieldException e) {
// ignore
}
}
public FastPrintStream println() {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) '\n';
return this;
}
public FastPrintStream println(java.lang.Object o) {
return print(o).println();
}
public FastPrintStream println(java.lang.String s) {
return print(s).println();
}
public FastPrintStream println(char[] s) {
return print(s).println();
}
public FastPrintStream println(char c) {
return print(c).println();
}
public FastPrintStream println(int x) {
return print(x).println();
}
public FastPrintStream println(long x) {
return print(x).println();
}
public FastPrintStream println(double d, int precision) {
return print(d, precision).println();
}
private FastPrintStream print(byte[] bytes) {
int n = bytes.length;
if (ptr + n > BUF_SIZE) {
internalFlush();
try {
out.write(bytes);
} catch (java.io.IOException e) {
throw new RuntimeException();
}
} else {
System.arraycopy(bytes, 0, buf, ptr, n);
ptr += n;
}
return this;
}
public FastPrintStream print(java.lang.Object o) {
return print(o.toString());
}
public FastPrintStream print(java.lang.String s) {
if (strField == null) {
return print(s.getBytes());
} else {
try {
return print((byte[]) strField.get(s));
} catch (IllegalAccessException e) {
return print(s.getBytes());
}
}
}
public FastPrintStream print(char[] s) {
try {
return print(encoder.encode(java.nio.CharBuffer.wrap(s)).array());
} catch (java.nio.charset.CharacterCodingException e) {
byte[] bytes = new byte[s.length];
for (int i = 0; i < s.length; i++) {
bytes[i] = (byte) s[i];
}
return print(bytes);
}
}
public FastPrintStream print(char c) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = (byte) c;
return this;
}
public FastPrintStream print(int x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(long x) {
if (x == 0) {
if (ptr == BUF_SIZE)
internalFlush();
buf[ptr++] = '0';
return this;
}
int d = len(x);
if (ptr + d > BUF_SIZE)
internalFlush();
if (x < 0) {
buf[ptr++] = '-';
x = -x;
d--;
}
int j = ptr += d;
while (x > 0) {
buf[--j] = (byte) ('0' + (x % 10));
x /= 10;
}
return this;
}
public FastPrintStream print(double d, int precision) {
if (d < 0) {
print('-');
d = -d;
}
d += Math.pow(10, -d) / 2;
print((long) d).print('.');
d -= (long) d;
for (int i = 0; i < precision; i++) {
d *= 10;
print((int) d);
d -= (int) d;
}
return this;
}
private void internalFlush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void flush() {
try {
out.write(buf, 0, ptr);
out.flush();
ptr = 0;
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
public void close() {
try {
out.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
private static int len(int x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
int p = -10;
for (int i = 1; i < 10; i++, p *= 10)
if (x > p)
return i + d;
return 10 + d;
}
private static int len(long x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
long p = -10;
for (int i = 1; i < 19; i++, p *= 10)
if (x > p)
return i + d;
return 19 + d;
}
}
class FastScanner implements AutoCloseable {
private final java.io.InputStream in;
private final byte[] buf = new byte[2048];
private int ptr = 0;
private int buflen = 0;
public FastScanner(java.io.InputStream in) {
this.in = in;
}
public FastScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen)
return true;
ptr = 0;
try {
buflen = in.read(buf);
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
return buflen > 0;
}
private int readByte() {
return hasNextByte() ? buf[ptr++] : -1;
}
public boolean hasNext() {
while (hasNextByte() && !(32 < buf[ptr] && buf[ptr] < 127))
ptr++;
return hasNextByte();
}
private StringBuilder nextSequence() {
if (!hasNext())
throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
for (int b = readByte(); 32 < b && b < 127; b = readByte()) {
sb.appendCodePoint(b);
}
return sb;
}
public String next() {
return nextSequence().toString();
}
public String next(int len) {
return new String(nextChars(len));
}
public char nextChar() {
if (!hasNextByte())
throw new java.util.NoSuchElementException();
return (char) readByte();
}
public char[] nextChars() {
StringBuilder sb = nextSequence();
int l = sb.length();
char[] dst = new char[l];
sb.getChars(0, l, dst, 0);
return dst;
}
public char[] nextChars(int len) {
if (!hasNext())
throw new java.util.NoSuchElementException();
char[] s = new char[len];
int i = 0;
int b = readByte();
while (32 < b && b < 127 && i < len) {
s[i++] = (char) b;
b = readByte();
}
if (i != len) {
throw new java.util.NoSuchElementException(
String.format("Next token has smaller length than expected.", len));
}
return s;
}
public long nextLong() {
if (!hasNext())
throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b)
throw new NumberFormatException();
while (true) {
if ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
} else if (b == -1 || !(32 < b && b < 127)) {
return minus ? -n : n;
} else
throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() {
return Math.toIntExact(nextLong());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public void close() {
try {
in.close();
} catch (java.io.IOException e) {
throw new RuntimeException(e);
}
}
}
/**
* @verified https://atcoder.jp/contests/practice2/tasks/practice2_j
*/
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Long.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return -1;
}
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return false;
}
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n)) {
return -1;
}
return -parentOrSize[leader(a)];
}
ArrayList<ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < n; i++) {
result.add(new ArrayList<>());
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
return result;
}
}
|
ConDefects/ConDefects/Code/agc057_a/Java/31489913
|
condefects-java_data_583
|
//package atcoder.agc57;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
static InputReader in;
static PrintWriter out;
public static void main(String[] args) {
//initReaderPrinter(true);
initReaderPrinter(false);
//solve(in.nextInt());
solve(1);
}
/*
General tips
1. It is ok to fail, but it is not ok to fail for the same mistakes over and over!
2. Train smarter, not harder!
3. If you find an answer and want to return immediately, don't forget to flush before return!
*/
/*
Read before practice
1. Set a timer based on a problem's difficulty level: 45 minutes at your current target practice level;
2. During a problem solving session, focus! Do not switch problems or even worse switch to do something else;
3. If fail to solve within timer limit, read editorials to get as little help as possible to get yourself unblocked;
4. If after reading the entire editorial and other people's code but still can not solve, move this problem to to-do list
and re-try in the future.
5. Keep a practice log about new thinking approaches, good tricks, bugs; Review regularly;
6. Also try this new approach suggested by um_nik: Solve with no intention to read editorial.
If getting stuck, skip it and solve other similar level problems.
Wait for 1 week then try to solve again. Only read editorial after you solved a problem.
7. Remember to also submit in the original problem link (if using gym) so that the 1 v 1 bot knows which problems I have solved already.
8. Form the habit of writing down an implementable solution idea before coding! You've taken enough hits during contests because you
rushed to coding!
*/
/*
Read before contests and lockout 1 v 1
Mistakes you've made in the past contests:
1. Tried to solve without going through given test examples -> wasting time on solving a different problem than asked;
2. Rushed to coding without getting a comprehensive sketch of your solution -> implementation bugs and WA; Write down your idea step
by step, no need to rush. It is always better to have all the steps considered before hand! Think about all the past contests that
you have failed because slow implementation and implementation bugs! This will be greatly reduced if you take your time to get a
thorough idea steps!
3. Forgot about possible integer overflow;
When stuck:
1. Understand problem statements? Walked through test examples?
2. Take a step back and think about other approaches?
3. Check rank board to see if you can skip to work on a possibly easier problem?
4. If none of the above works, take a guess?
*/
static void solve(int testCnt) {
for (int testNumber = 0; testNumber < testCnt; testNumber++) {
int t = in.nextInt();
for(int i = 0; i < t; i++) {
int l = in.nextInt(), r = in.nextInt();
out.println(compute(l, r));
}
}
out.close();
}
static int compute(int l, int r) {
int l_cnt = getDigitsCnt(l), r_cnt = getDigitsCnt(r);
if(l_cnt == r_cnt) {
return r - l + 1;
}
int ans = 0;
int msd = r;
List<Integer> d = new ArrayList<>();
while(msd >= 10) {
d.add(msd % 10);
msd /= 10;
}
int sub2 = 0;
for(int i = d.size() - 1; i >= 0; i --) {
sub2 = sub2 * 10 + d.get(i);
}
if(msd > 1) {
int base = msd - 1;
for(int i = 0; i < r_cnt - 1; i++) {
base *= 10;
}
ans = base + sub2 + 1;
}
// else if(l_cnt + 1 < r_cnt) {
// int base = 1;
// for(int i = 0; i < r_cnt - 2; i++) {
// base *= 10;
// }
// ans = 9 * base;
// }
else {
int base = 1;
for(int i = 0; i < r_cnt - 2; i++) {
base *= 10;
}
//ans = 9 * base;
if(l_cnt + 1 < r_cnt) {
ans = r - base + 1 - (max(r / 10, sub2) - base + 1);
}
else {
ans = r - l + 1 - max(0, sub2 - l + 1);
}
}
return ans;
}
static int getDigitsCnt(int v) {
int cnt = 0;
while(v > 0) {
cnt++;
v /= 10;
}
return cnt;
}
static void initReaderPrinter(boolean test) {
if (test) {
try {
in = new InputReader(new FileInputStream("src/input.in"));
out = new PrintWriter(new FileOutputStream("src/output.out"));
} catch (IOException e) {
e.printStackTrace();
}
} else {
in = new InputReader(System.in);
out = new PrintWriter(System.out);
}
}
static class InputReader {
BufferedReader br;
StringTokenizer st;
InputReader(InputStream stream) {
try {
br = new BufferedReader(new InputStreamReader(stream), 32768);
} catch (Exception e) {
e.printStackTrace();
}
}
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();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
Integer[] nextIntArray(int n) {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
int[] nextIntArrayPrimitive(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
int[] nextIntArrayPrimitiveOneIndexed(int n) {
int[] a = new int[n + 1];
for (int i = 1; i <= n; i++) a[i] = nextInt();
return a;
}
Long[] nextLongArray(int n) {
Long[] a = new Long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
long[] nextLongArrayPrimitive(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
long[] nextLongArrayPrimitiveOneIndexed(int n) {
long[] a = new long[n + 1];
for (int i = 1; i <= n; i++) a[i] = nextLong();
return a;
}
String[] nextStringArray(int n) {
String[] g = new String[n];
for (int i = 0; i < n; i++) g[i] = next();
return g;
}
List<Integer>[] readGraphOneIndexed(int n, int m) {
List<Integer>[] adj = new List[n + 1];
for (int i = 0; i <= n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < m; i++) {
int u = nextInt();
int v = nextInt();
adj[u].add(v);
adj[v].add(u);
}
return adj;
}
List<Integer>[] readGraphZeroIndexed(int n, int m) {
List<Integer>[] adj = new List[n];
for (int i = 0; i < n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
adj[u].add(v);
adj[v].add(u);
}
return adj;
}
/*
A more efficient way of building an undirected graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][] buildUndirectedGraph(int nodeCnt, int edgeCnt) {
int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt();
edgeCntForEachNode[u]++;
edgeCntForEachNode[v]++;
end1[i] = u;
end2[i] = v;
}
int[][] adj = new int[nodeCnt + 1][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]];
}
for (int i = 0; i < edgeCnt; i++) {
adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
idxForEachNode[end1[i]]++;
adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
idxForEachNode[end2[i]]++;
}
return adj;
}
/*
A more efficient way of building an undirected weighted graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][][] buildUndirectedWeightedGraph(int nodeCnt, int edgeCnt) {
int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt], weight = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt(), w = in.nextInt();
edgeCntForEachNode[u]++;
edgeCntForEachNode[v]++;
end1[i] = u;
end2[i] = v;
weight[i] = w;
}
int[][][] adj = new int[nodeCnt + 1][][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]][2];
}
for (int i = 0; i < edgeCnt; i++) {
adj[end1[i]][idxForEachNode[end1[i]]][0] = end2[i];
adj[end1[i]][idxForEachNode[end1[i]]][1] = weight[i];
idxForEachNode[end1[i]]++;
adj[end2[i]][idxForEachNode[end2[i]]][0] = end1[i];
adj[end2[i]][idxForEachNode[end2[i]]][1] = weight[i];
idxForEachNode[end2[i]]++;
}
return adj;
}
/*
A more efficient way of building a directed graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][] buildDirectedGraph(int nodeCnt, int edgeCnt) {
int[] from = new int[edgeCnt], to = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
//from u to v: u -> v
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt();
edgeCntForEachNode[u]++;
from[i] = u;
to[i] = v;
}
int[][] adj = new int[nodeCnt + 1][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]];
}
for (int i = 0; i < edgeCnt; i++) {
adj[from[i]][idxForEachNode[from[i]]] = to[i];
idxForEachNode[from[i]]++;
}
return adj;
}
/*
A more efficient way of building a directed weighted graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][][] buildDirectedWeightedGraph(int nodeCnt, int edgeCnt) {
int[] from = new int[edgeCnt], to = new int[edgeCnt], weight = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
//from u to v: u -> v
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt(), w = in.nextInt();
edgeCntForEachNode[u]++;
from[i] = u;
to[i] = v;
weight[i] = w;
}
int[][][] adj = new int[nodeCnt + 1][][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]][2];
}
for (int i = 0; i < edgeCnt; i++) {
adj[from[i]][idxForEachNode[from[i]]][0] = to[i];
adj[from[i]][idxForEachNode[from[i]]][1] = weight[i];
idxForEachNode[from[i]]++;
}
return adj;
}
}
}
//package atcoder.agc57;
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class Main {
static InputReader in;
static PrintWriter out;
public static void main(String[] args) {
//initReaderPrinter(true);
initReaderPrinter(false);
//solve(in.nextInt());
solve(1);
}
/*
General tips
1. It is ok to fail, but it is not ok to fail for the same mistakes over and over!
2. Train smarter, not harder!
3. If you find an answer and want to return immediately, don't forget to flush before return!
*/
/*
Read before practice
1. Set a timer based on a problem's difficulty level: 45 minutes at your current target practice level;
2. During a problem solving session, focus! Do not switch problems or even worse switch to do something else;
3. If fail to solve within timer limit, read editorials to get as little help as possible to get yourself unblocked;
4. If after reading the entire editorial and other people's code but still can not solve, move this problem to to-do list
and re-try in the future.
5. Keep a practice log about new thinking approaches, good tricks, bugs; Review regularly;
6. Also try this new approach suggested by um_nik: Solve with no intention to read editorial.
If getting stuck, skip it and solve other similar level problems.
Wait for 1 week then try to solve again. Only read editorial after you solved a problem.
7. Remember to also submit in the original problem link (if using gym) so that the 1 v 1 bot knows which problems I have solved already.
8. Form the habit of writing down an implementable solution idea before coding! You've taken enough hits during contests because you
rushed to coding!
*/
/*
Read before contests and lockout 1 v 1
Mistakes you've made in the past contests:
1. Tried to solve without going through given test examples -> wasting time on solving a different problem than asked;
2. Rushed to coding without getting a comprehensive sketch of your solution -> implementation bugs and WA; Write down your idea step
by step, no need to rush. It is always better to have all the steps considered before hand! Think about all the past contests that
you have failed because slow implementation and implementation bugs! This will be greatly reduced if you take your time to get a
thorough idea steps!
3. Forgot about possible integer overflow;
When stuck:
1. Understand problem statements? Walked through test examples?
2. Take a step back and think about other approaches?
3. Check rank board to see if you can skip to work on a possibly easier problem?
4. If none of the above works, take a guess?
*/
static void solve(int testCnt) {
for (int testNumber = 0; testNumber < testCnt; testNumber++) {
int t = in.nextInt();
for(int i = 0; i < t; i++) {
int l = in.nextInt(), r = in.nextInt();
out.println(compute(l, r));
}
}
out.close();
}
static int compute(int l, int r) {
int l_cnt = getDigitsCnt(l), r_cnt = getDigitsCnt(r);
if(l_cnt == r_cnt) {
return r - l + 1;
}
int ans = 0;
int msd = r;
List<Integer> d = new ArrayList<>();
while(msd >= 10) {
d.add(msd % 10);
msd /= 10;
}
int sub2 = 0;
for(int i = d.size() - 1; i >= 0; i --) {
sub2 = sub2 * 10 + d.get(i);
}
if(msd > 1) {
int base = msd - 1;
for(int i = 0; i < r_cnt - 1; i++) {
base *= 10;
}
ans = base + sub2 + 1;
}
// else if(l_cnt + 1 < r_cnt) {
// int base = 1;
// for(int i = 0; i < r_cnt - 2; i++) {
// base *= 10;
// }
// ans = 9 * base;
// }
else {
int base = 1;
for(int i = 0; i < r_cnt - 2; i++) {
base *= 10;
}
//ans = 9 * base;
if(l_cnt + 1 < r_cnt) {
ans = r - base + 1 - (max(r / 10, sub2) - base + 1);
}
else {
ans = r - l + 1 - max(0, max(r / 10, sub2) - l + 1);
}
}
return ans;
}
static int getDigitsCnt(int v) {
int cnt = 0;
while(v > 0) {
cnt++;
v /= 10;
}
return cnt;
}
static void initReaderPrinter(boolean test) {
if (test) {
try {
in = new InputReader(new FileInputStream("src/input.in"));
out = new PrintWriter(new FileOutputStream("src/output.out"));
} catch (IOException e) {
e.printStackTrace();
}
} else {
in = new InputReader(System.in);
out = new PrintWriter(System.out);
}
}
static class InputReader {
BufferedReader br;
StringTokenizer st;
InputReader(InputStream stream) {
try {
br = new BufferedReader(new InputStreamReader(stream), 32768);
} catch (Exception e) {
e.printStackTrace();
}
}
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();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
Integer[] nextIntArray(int n) {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
int[] nextIntArrayPrimitive(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = nextInt();
return a;
}
int[] nextIntArrayPrimitiveOneIndexed(int n) {
int[] a = new int[n + 1];
for (int i = 1; i <= n; i++) a[i] = nextInt();
return a;
}
Long[] nextLongArray(int n) {
Long[] a = new Long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
long[] nextLongArrayPrimitive(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) a[i] = nextLong();
return a;
}
long[] nextLongArrayPrimitiveOneIndexed(int n) {
long[] a = new long[n + 1];
for (int i = 1; i <= n; i++) a[i] = nextLong();
return a;
}
String[] nextStringArray(int n) {
String[] g = new String[n];
for (int i = 0; i < n; i++) g[i] = next();
return g;
}
List<Integer>[] readGraphOneIndexed(int n, int m) {
List<Integer>[] adj = new List[n + 1];
for (int i = 0; i <= n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < m; i++) {
int u = nextInt();
int v = nextInt();
adj[u].add(v);
adj[v].add(u);
}
return adj;
}
List<Integer>[] readGraphZeroIndexed(int n, int m) {
List<Integer>[] adj = new List[n];
for (int i = 0; i < n; i++) {
adj[i] = new ArrayList<>();
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
adj[u].add(v);
adj[v].add(u);
}
return adj;
}
/*
A more efficient way of building an undirected graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][] buildUndirectedGraph(int nodeCnt, int edgeCnt) {
int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt();
edgeCntForEachNode[u]++;
edgeCntForEachNode[v]++;
end1[i] = u;
end2[i] = v;
}
int[][] adj = new int[nodeCnt + 1][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]];
}
for (int i = 0; i < edgeCnt; i++) {
adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
idxForEachNode[end1[i]]++;
adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
idxForEachNode[end2[i]]++;
}
return adj;
}
/*
A more efficient way of building an undirected weighted graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][][] buildUndirectedWeightedGraph(int nodeCnt, int edgeCnt) {
int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt], weight = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt(), w = in.nextInt();
edgeCntForEachNode[u]++;
edgeCntForEachNode[v]++;
end1[i] = u;
end2[i] = v;
weight[i] = w;
}
int[][][] adj = new int[nodeCnt + 1][][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]][2];
}
for (int i = 0; i < edgeCnt; i++) {
adj[end1[i]][idxForEachNode[end1[i]]][0] = end2[i];
adj[end1[i]][idxForEachNode[end1[i]]][1] = weight[i];
idxForEachNode[end1[i]]++;
adj[end2[i]][idxForEachNode[end2[i]]][0] = end1[i];
adj[end2[i]][idxForEachNode[end2[i]]][1] = weight[i];
idxForEachNode[end2[i]]++;
}
return adj;
}
/*
A more efficient way of building a directed graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][] buildDirectedGraph(int nodeCnt, int edgeCnt) {
int[] from = new int[edgeCnt], to = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
//from u to v: u -> v
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt();
edgeCntForEachNode[u]++;
from[i] = u;
to[i] = v;
}
int[][] adj = new int[nodeCnt + 1][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]];
}
for (int i = 0; i < edgeCnt; i++) {
adj[from[i]][idxForEachNode[from[i]]] = to[i];
idxForEachNode[from[i]]++;
}
return adj;
}
/*
A more efficient way of building a directed weighted graph using int[] instead of ArrayList to store each node's neighboring nodes.
1-indexed.
*/
int[][][] buildDirectedWeightedGraph(int nodeCnt, int edgeCnt) {
int[] from = new int[edgeCnt], to = new int[edgeCnt], weight = new int[edgeCnt];
int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
//from u to v: u -> v
for (int i = 0; i < edgeCnt; i++) {
int u = in.nextInt(), v = in.nextInt(), w = in.nextInt();
edgeCntForEachNode[u]++;
from[i] = u;
to[i] = v;
weight[i] = w;
}
int[][][] adj = new int[nodeCnt + 1][][];
for (int i = 1; i <= nodeCnt; i++) {
adj[i] = new int[edgeCntForEachNode[i]][2];
}
for (int i = 0; i < edgeCnt; i++) {
adj[from[i]][idxForEachNode[from[i]]][0] = to[i];
adj[from[i]][idxForEachNode[from[i]]][1] = weight[i];
idxForEachNode[from[i]]++;
}
return adj;
}
}
}
|
ConDefects/ConDefects/Code/agc057_a/Java/34256232
|
condefects-java_data_584
|
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 i = 0;i<n;i++)
{
long l = sc.nextLong();
long r = sc.nextLong();
int d1 = Long.toString(l).length();
int d2 = Long.toString(r).length();
long head=r;
while(head>=10)head/=10;
if(d1==d2)
{
System.out.println((r-l+1));
continue;
}
//System.out.println("H " + head);
if(head==1)
{
long lef1 = head;
for(int k=0;k<d2-1;k++)
lef1*=10;
//System.out.println("temp " + lef);
lef1=r-lef1+1;
long lef2=(r/10)+1;
long lef = Math.max(lef1,lef2);
lef = Math.max(l,lef);
System.out.println((r-lef+1));
}
else
{
long lef = head;
for(int k=0;k<d2-1;k++)
lef*=10;
//System.out.println("temp " + lef);
lef = Math.max(l,lef);
System.out.println((r-lef+1));
}
}
}
}
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 i = 0;i<n;i++)
{
long l = sc.nextLong();
long r = sc.nextLong();
int d1 = Long.toString(l).length();
int d2 = Long.toString(r).length();
long head=r;
while(head>=10)head/=10;
if(d1==d2)
{
System.out.println((r-l+1));
continue;
}
//System.out.println("H " + head);
if(head==1)
{
long lef1 = head;
for(int k=0;k<d2-1;k++)
lef1*=10;
//System.out.println("temp " + lef);
lef1=r-lef1+1;
long lef2=(r/10)+1;
long lef = Math.max(lef1,lef2);
lef = Math.max(l,lef);
System.out.println((r-lef+1));
}
else
{
long lef = 1;
for(int k=0;k<d2-1;k++)
lef*=10;
//System.out.println("temp " + lef);
lef = Math.max(l,lef);
System.out.println((r-lef+1));
}
}
}
}
|
ConDefects/ConDefects/Code/agc057_a/Java/33243925
|
condefects-java_data_585
|
import java.util.*;
import java.io.*;
class Main {
// public static box[];
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int n = Integer.parseInt(sc.next());
List<Long> a = new ArrayList<>();
Long ans = 0L;
Map<Long, Long> w = new HashMap<>();
for(int j = 0; j < n; j++) {
a.add(sc.nextLong());
}
for(int i = 0; i < n; i++) {
long temp = sc.nextLong();
if(!w.containsKey(a.get(i))) {
w.put(a.get(i), temp);
} else {
ans += Math.min(w.get(a.get(i)), temp);
w.put(a.get(i), Math.min(w.get(a.get(i)), temp));
}
}
System.out.print(ans);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
}
import java.util.*;
import java.io.*;
class Main {
// public static box[];
public static void main(String[] args) {
FastScanner sc = new FastScanner();
int n = Integer.parseInt(sc.next());
List<Long> a = new ArrayList<>();
Long ans = 0L;
Map<Long, Long> w = new HashMap<>();
for(int j = 0; j < n; j++) {
a.add(sc.nextLong());
}
for(int i = 0; i < n; i++) {
long temp = sc.nextLong();
if(!w.containsKey(a.get(i))) {
w.put(a.get(i), temp);
} else {
ans += Math.min(w.get(a.get(i)), temp);
w.put(a.get(i), Math.max(w.get(a.get(i)), temp));
}
}
System.out.print(ans);
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
}
|
ConDefects/ConDefects/Code/abc360_c/Java/55112112
|
condefects-java_data_586
|
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<String> inputStrings = new ArrayList<>();
while (sc.hasNext()) {
String capture = sc.next();
inputStrings.add(capture);
if (capture.equals("0")) {
break;
}
}
for (int i = inputStrings.size() - 1; i >= 0 ; i--) {
System.out.println("Answer is: " + inputStrings.get(i));
}
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<String> inputStrings = new ArrayList<>();
while (sc.hasNext()) {
String capture = sc.next();
inputStrings.add(capture);
if (capture.equals("0")) {
break;
}
}
for (int i = inputStrings.size() - 1; i >= 0 ; i--) {
System.out.println(inputStrings.get(i));
}
}
}
|
ConDefects/ConDefects/Code/abc344_b/Java/51456601
|
condefects-java_data_587
|
import java.util.*;
import java.io.*;
class Main {
private static final void solve() throws IOException {
final int n = ni(), nn = n << 1, m = ni();
final long inf = (long) 1e13;
var flow = new MaxFlow(nn);
var uu = new int[m];
var vv = new int[m];
for (int i = 0; i < m; i++) {
uu[i] = ni() - 1;
vv[i] = ni() - 1;
flow.addEdge(uu[i] + n, vv[i], inf);
flow.addEdge(uu[i] + n, uu[i], inf);
}
var ty_cnt = new int[n];
for (int i = 0; i < m; i++) {
ty_cnt[uu[i]]++;
ty_cnt[vv[i]]++;
}
var g = new int[n][];
for (int i = 0; i < n; i++)
g[i] = new int[ty_cnt[i]];
Arrays.fill(ty_cnt, 0);
for (int i = 0; i < m; i++) {
g[uu[i]][ty_cnt[uu[i]]++] = vv[i];
g[vv[i]][ty_cnt[vv[i]]++] = uu[i];
}
for (int i = 0; i < n; i++)
flow.addEdge(i, i + n, nl());
final long ans = flow.maxFlow(n, n - 1);
var t = flow.minCut(n);
var q = new ArrayDeque<Integer>();
var u = new boolean[n];
q.add(0);
u[0] = true;
var y = new boolean[n];
l: while (!q.isEmpty()) {
int x = q.remove();
for (int i : g[x]) {
if (u[i])
continue;
if (!t[i]) {
y[x] = true;
continue l;
}
}
for (int i : g[x]) {
if (!u[i])
q.add(i);
u[i] = true;
}
}
var s = new ArrayList<Integer>();
for (int i = 0; i < n; i++)
if (y[i])
s.add(i + 1);
ou.println(ans).println(s.size()).print(s);
}
public static void main(String[] args) throws IOException {
solve();
ou.flush();
}
private static final int ni() throws IOException {
return sc.nextInt();
}
private static final int[] ni(int n) throws IOException {
return sc.nextIntArray(n);
}
private static final long nl() throws IOException {
return sc.nextLong();
}
private static final long[] nl(int n) throws IOException {
return sc.nextLongArray(n);
}
private static final String ns() throws IOException {
return sc.next();
}
private static final ContestInputStream sc = new ContestInputStream();
private static final ContestOutputStream ou = new ContestOutputStream();
}
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;
this.pos = new java.util.ArrayList<>();
this.g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++)
this.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;
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) {
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));
}
}
}
final class ContestInputStream extends FilterInputStream {
protected final byte[] buf;
protected int pos = 0;
protected int lim = 0;
private final char[] cbuf;
public ContestInputStream() {
super(System.in);
this.buf = new byte[1 << 13];
this.cbuf = new char[1 << 20];
}
boolean hasRemaining() throws IOException {
if (pos < lim)
return true;
lim = in.read(buf);
pos = 0;
return lim > 0;
}
final int remaining() throws IOException {
if (pos >= lim) {
lim = in.read(buf);
pos = 0;
}
return lim - pos;
}
@Override
public final int available() throws IOException {
if (pos < lim)
return lim - pos + in.available();
return in.available();
}
@Override
public final long skip(long n) throws IOException {
if (pos < lim) {
int rem = lim - pos;
if (n < rem) {
pos += n;
return n;
}
pos = lim;
return rem;
}
return in.skip(n);
}
@Override
public final int read() throws IOException {
if (hasRemaining())
return buf[pos++];
return -1;
}
@Override
public final int read(byte[] b, int off, int len) throws IOException {
if (pos < lim) {
int rem = Math.min(lim - pos, len);
for (int i = 0; i < rem; i++)
b[off + i] = buf[pos + i];
pos += rem;
return rem;
}
return in.read(b, off, len);
}
public final char[] readToken() throws IOException {
int cpos = 0;
int rem;
byte b;
l: while ((rem = remaining()) > 0) {
for (int i = 0; i < rem; i++) {
b = buf[pos + i];
if (b <= 0x20) {
pos += i + 1;
cpos += i;
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
break l;
}
cbuf[cpos + i] = (char) b;
}
pos += rem;
cpos += rem;
}
char[] arr = new char[cpos];
for (int i = 0; i < cpos; i++)
arr[i] = cbuf[i];
return arr;
}
public final int readToken(char[] cbuf, int off) throws IOException {
int cpos = off;
int rem;
byte b;
l: while ((rem = remaining()) > 0) {
for (int i = 0; i < rem; i++) {
b = buf[pos + i];
if (b <= 0x20) {
pos += i + 1;
cpos += i;
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
break l;
}
cbuf[cpos + i] = (char) b;
}
pos += rem;
cpos += rem;
}
return cpos - off;
}
public final int readToken(char[] cbuf) throws IOException {
return readToken(cbuf, 0);
}
public final String next() throws IOException {
int cpos = 0;
int rem;
byte b;
l: while ((rem = remaining()) > 0) {
for (int i = 0; i < rem; i++) {
b = buf[pos + i];
if (b <= 0x20) {
pos += i + 1;
cpos += i;
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
break l;
}
cbuf[cpos + i] = (char) b;
}
pos += rem;
cpos += rem;
}
return String.valueOf(cbuf, 0, cpos);
}
public final char[] nextCharArray() throws IOException {
return readToken();
}
public final int nextInt() throws IOException {
if (!hasRemaining())
return 0;
int value = 0;
byte b = buf[pos++];
if (b == 0x2d) {
while (hasRemaining() && (b = buf[pos++]) > 0x20)
value = value * 10 - b + 0x30;
} else {
do {
value = value * 10 + b - 0x30;
} while (hasRemaining() && (b = buf[pos++]) > 0x20);
}
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
return value;
}
public final long nextLong() throws IOException {
if (!hasRemaining())
return 0L;
long value = 0L;
byte b = buf[pos++];
if (b == 0x2d) {
while (hasRemaining() && (b = buf[pos++]) > 0x20)
value = value * 10 - b + 0x30;
} else {
do {
value = value * 10 + b - 0x30;
} while (hasRemaining() && (b = buf[pos++]) > 0x20);
}
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
return value;
}
public final char nextChar() throws IOException {
if (!hasRemaining())
throw new EOFException();
final char c = (char) buf[pos++];
if (hasRemaining() && buf[pos++] == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
return c;
}
public final float nextFloat() throws IOException {
return Float.parseFloat(next());
}
public final double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public final boolean[] nextBooleanArray(char ok) throws IOException {
char[] s = readToken();
int n = s.length;
boolean[] t = new boolean[n];
for (int i = 0; i < n; i++)
t[i] = s[i] == ok;
return t;
}
public final boolean[][] nextBooleanMatrix(int h, int w, char ok) throws IOException {
boolean[][] s = new boolean[h][];
for (int i = 0; i < h; i++) {
char[] t = readToken();
int n = t.length;
s[i] = new boolean[n];
for (int j = 0; j < n; j++)
s[i][j] = t[j] == ok;
}
return s;
}
public final String[] nextStringArray(int len) throws IOException {
String[] arr = new String[len];
for (int i = 0; i < len; i++)
arr[i] = next();
return arr;
}
public final int[] nextIntArray(int len) throws IOException {
int[] arr = new int[len];
for (int i = 0; i < len; i++)
arr[i] = nextInt();
return arr;
}
public final int[] nextIntArray(int len, java.util.function.IntUnaryOperator map) throws IOException {
int[] arr = new int[len];
for (int i = 0; i < len; i++)
arr[i] = map.applyAsInt(nextInt());
return arr;
}
public final long[] nextLongArray(int len, java.util.function.LongUnaryOperator map) throws IOException {
long[] arr = new long[len];
for (int i = 0; i < len; i++)
arr[i] = map.applyAsLong(nextLong());
return arr;
}
public final int[][] nextIntMatrix(int h, int w) throws IOException {
int[][] arr = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
arr[i][j] = nextInt();
return arr;
}
public final int[][] nextIntMatrix(int h, int w, java.util.function.IntUnaryOperator map) throws IOException {
int[][] arr = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
arr[i][j] = map.applyAsInt(nextInt());
return arr;
}
public final long[] nextLongArray(int len) throws IOException {
long[] arr = new long[len];
for (int i = 0; i < len; i++)
arr[i] = nextLong();
return arr;
}
public final long[][] nextLongMatrix(int h, int w) throws IOException {
long[][] arr = new long[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
arr[i][j] = nextLong();
return arr;
}
public final float[] nextFloatArray(int len) throws IOException {
float[] arr = new float[len];
for (int i = 0; i < len; i++)
arr[i] = nextFloat();
return arr;
}
public final double[] nextDoubleArray(int len) throws IOException {
double[] arr = new double[len];
for (int i = 0; i < len; i++)
arr[i] = nextDouble();
return arr;
}
public final char[][] nextCharMatrix(int h, int w) throws IOException {
char[][] arr = new char[h][];
for (int i = 0; i < h; i++)
arr[i] = readToken();
return arr;
}
public final void nextThrow() throws IOException {
next();
return;
}
public final void nextThrow(int n) throws IOException {
for (int i = 0; i < n; i++)
nextThrow();
return;
}
}
final class ContestOutputStream extends FilterOutputStream implements Appendable {
protected final byte[] buf;
protected int pos = 0;
public ContestOutputStream() {
super(System.out);
this.buf = new byte[1 << 13];
}
@Override
public void flush() throws IOException {
out.write(buf, 0, pos);
pos = 0;
out.flush();
}
void put(byte b) throws IOException {
if (pos >= buf.length)
flush();
buf[pos++] = b;
}
int remaining() throws IOException {
if (pos >= buf.length)
flush();
return buf.length - pos;
}
@Override
public void write(int b) throws IOException {
put((byte) b);
}
@Override
public void write(byte[] b, int off, int len) throws IOException {
int o = off;
int l = len;
while (l > 0) {
int rem = Math.min(remaining(), l);
for (int i = 0; i < rem; i++)
buf[pos + i] = b[o + i];
pos += rem;
o += rem;
l -= rem;
}
}
@Override
public ContestOutputStream append(char c) throws IOException {
put((byte) c);
return this;
}
@Override
public ContestOutputStream append(CharSequence csq, int start, int end) throws IOException {
int off = start;
int len = end - start;
while (len > 0) {
int rem = Math.min(remaining(), len);
for (int i = 0; i < rem; i++)
buf[pos + i] = (byte) csq.charAt(off + i);
pos += rem;
off += rem;
len -= rem;
}
return this;
}
@Override
public ContestOutputStream append(CharSequence csq) throws IOException {
return append(csq, 0, csq.length());
}
public ContestOutputStream append(char[] arr, int off, int len) throws IOException {
int o = off;
int l = len;
while (l > 0) {
int rem = Math.min(remaining(), l);
for (int i = 0; i < rem; i++)
buf[pos + i] = (byte) arr[o + i];
pos += rem;
o += rem;
l -= rem;
}
return this;
}
public ContestOutputStream print(char[] arr) throws IOException {
return append(arr, 0, arr.length).newLine();
}
public ContestOutputStream print(boolean value) throws IOException {
if (value)
return append("o");
return append("x");
}
public ContestOutputStream println(boolean value) throws IOException {
if (value)
return append("o\n");
return append("x\n");
}
public ContestOutputStream print(boolean[][] value) throws IOException {
final int n = value.length, m = value[0].length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
print(value[i][j]);
newLine();
}
return this;
}
public ContestOutputStream print(int value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(int value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(long value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(long value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(float value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(float value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(double value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(double value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(char value) throws IOException {
return append(value);
}
public ContestOutputStream println(char value) throws IOException {
return append(value).newLine();
}
public ContestOutputStream print(String value) throws IOException {
return append(value);
}
public ContestOutputStream println(String value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(Object value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(Object value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream printYN(boolean yes) throws IOException {
if (yes)
return println("Yes");
return println("No");
}
public ContestOutputStream printAB(boolean yes) throws IOException {
if (yes)
return println("Alice");
return println("Bob");
}
public ContestOutputStream print(CharSequence[] arr) throws IOException {
if (arr.length > 0) {
append(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').append(arr[i]);
}
return this;
}
public ContestOutputStream print(int[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
newLine();
return this;
}
public ContestOutputStream print(int[] arr, int length) throws IOException {
if (length > 0)
print(arr[0]);
for (int i = 1; i < length; i++)
append('\u0020').print(arr[i]);
newLine();
return this;
}
public ContestOutputStream println(int[] arr) throws IOException {
for (int i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream println(int[] arr, int length) throws IOException {
for (int i = 0; i < length; i++)
println(arr[i]);
return this;
}
public ContestOutputStream print(boolean[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
newLine();
return this;
}
public ContestOutputStream print(long[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
newLine();
return this;
}
public ContestOutputStream print(long[] arr, int length) throws IOException {
if (length > 0)
print(arr[0]);
for (int i = 1; i < length; i++)
append('\u0020').print(arr[i]);
newLine();
return this;
}
public ContestOutputStream println(long[] arr, int length) throws IOException {
for (int i = 0; i < length; i++)
println(arr[i]);
return this;
}
public ContestOutputStream println(long[] arr) throws IOException {
for (long i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream print(float[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
return this;
}
public ContestOutputStream println(float[] arr) throws IOException {
for (float i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream print(double[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
return newLine();
}
public ContestOutputStream println(double[] arr) throws IOException {
for (double i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream print(Object[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
return newLine();
}
public ContestOutputStream print(java.util.ArrayList<?> arr) throws IOException {
if (!arr.isEmpty()) {
final int n = arr.size();
print(arr.get(0));
for (int i = 1; i < n; i++)
print(" ").print(arr.get(i));
}
return newLine();
}
public ContestOutputStream println(java.util.ArrayList<?> arr) throws IOException {
final int n = arr.size();
for (int i = 0; i < n; i++)
println(arr.get(i));
return this;
}
public ContestOutputStream println(Object[] arr) throws IOException {
for (Object i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream newLine() throws IOException {
return append(System.lineSeparator());
}
public ContestOutputStream endl() throws IOException {
newLine().flush();
return this;
}
public ContestOutputStream print(int[][] arr) throws IOException {
for (int[] i : arr)
print(i);
return this;
}
public ContestOutputStream print(long[][] arr) throws IOException {
for (long[] i : arr)
print(i);
return this;
}
public ContestOutputStream print(char[][] arr) throws IOException {
for (char[] i : arr)
print(i);
return this;
}
public ContestOutputStream print(Object[][] arr) throws IOException {
for (Object[] i : arr)
print(i);
return this;
}
public ContestOutputStream println() throws IOException {
return newLine();
}
}
import java.util.*;
import java.io.*;
class Main {
private static final void solve() throws IOException {
final int n = ni(), nn = n << 1, m = ni();
final long inf = (long) 1e13;
var flow = new MaxFlow(nn);
var uu = new int[m];
var vv = new int[m];
for (int i = 0; i < m; i++) {
uu[i] = ni() - 1;
vv[i] = ni() - 1;
flow.addEdge(uu[i] + n, vv[i], inf);
flow.addEdge(vv[i] + n, uu[i], inf);
}
var ty_cnt = new int[n];
for (int i = 0; i < m; i++) {
ty_cnt[uu[i]]++;
ty_cnt[vv[i]]++;
}
var g = new int[n][];
for (int i = 0; i < n; i++)
g[i] = new int[ty_cnt[i]];
Arrays.fill(ty_cnt, 0);
for (int i = 0; i < m; i++) {
g[uu[i]][ty_cnt[uu[i]]++] = vv[i];
g[vv[i]][ty_cnt[vv[i]]++] = uu[i];
}
for (int i = 0; i < n; i++)
flow.addEdge(i, i + n, nl());
final long ans = flow.maxFlow(n, n - 1);
var t = flow.minCut(n);
var q = new ArrayDeque<Integer>();
var u = new boolean[n];
q.add(0);
u[0] = true;
var y = new boolean[n];
l: while (!q.isEmpty()) {
int x = q.remove();
for (int i : g[x]) {
if (u[i])
continue;
if (!t[i]) {
y[x] = true;
continue l;
}
}
for (int i : g[x]) {
if (!u[i])
q.add(i);
u[i] = true;
}
}
var s = new ArrayList<Integer>();
for (int i = 0; i < n; i++)
if (y[i])
s.add(i + 1);
ou.println(ans).println(s.size()).print(s);
}
public static void main(String[] args) throws IOException {
solve();
ou.flush();
}
private static final int ni() throws IOException {
return sc.nextInt();
}
private static final int[] ni(int n) throws IOException {
return sc.nextIntArray(n);
}
private static final long nl() throws IOException {
return sc.nextLong();
}
private static final long[] nl(int n) throws IOException {
return sc.nextLongArray(n);
}
private static final String ns() throws IOException {
return sc.next();
}
private static final ContestInputStream sc = new ContestInputStream();
private static final ContestOutputStream ou = new ContestOutputStream();
}
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;
this.pos = new java.util.ArrayList<>();
this.g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++)
this.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;
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) {
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));
}
}
}
final class ContestInputStream extends FilterInputStream {
protected final byte[] buf;
protected int pos = 0;
protected int lim = 0;
private final char[] cbuf;
public ContestInputStream() {
super(System.in);
this.buf = new byte[1 << 13];
this.cbuf = new char[1 << 20];
}
boolean hasRemaining() throws IOException {
if (pos < lim)
return true;
lim = in.read(buf);
pos = 0;
return lim > 0;
}
final int remaining() throws IOException {
if (pos >= lim) {
lim = in.read(buf);
pos = 0;
}
return lim - pos;
}
@Override
public final int available() throws IOException {
if (pos < lim)
return lim - pos + in.available();
return in.available();
}
@Override
public final long skip(long n) throws IOException {
if (pos < lim) {
int rem = lim - pos;
if (n < rem) {
pos += n;
return n;
}
pos = lim;
return rem;
}
return in.skip(n);
}
@Override
public final int read() throws IOException {
if (hasRemaining())
return buf[pos++];
return -1;
}
@Override
public final int read(byte[] b, int off, int len) throws IOException {
if (pos < lim) {
int rem = Math.min(lim - pos, len);
for (int i = 0; i < rem; i++)
b[off + i] = buf[pos + i];
pos += rem;
return rem;
}
return in.read(b, off, len);
}
public final char[] readToken() throws IOException {
int cpos = 0;
int rem;
byte b;
l: while ((rem = remaining()) > 0) {
for (int i = 0; i < rem; i++) {
b = buf[pos + i];
if (b <= 0x20) {
pos += i + 1;
cpos += i;
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
break l;
}
cbuf[cpos + i] = (char) b;
}
pos += rem;
cpos += rem;
}
char[] arr = new char[cpos];
for (int i = 0; i < cpos; i++)
arr[i] = cbuf[i];
return arr;
}
public final int readToken(char[] cbuf, int off) throws IOException {
int cpos = off;
int rem;
byte b;
l: while ((rem = remaining()) > 0) {
for (int i = 0; i < rem; i++) {
b = buf[pos + i];
if (b <= 0x20) {
pos += i + 1;
cpos += i;
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
break l;
}
cbuf[cpos + i] = (char) b;
}
pos += rem;
cpos += rem;
}
return cpos - off;
}
public final int readToken(char[] cbuf) throws IOException {
return readToken(cbuf, 0);
}
public final String next() throws IOException {
int cpos = 0;
int rem;
byte b;
l: while ((rem = remaining()) > 0) {
for (int i = 0; i < rem; i++) {
b = buf[pos + i];
if (b <= 0x20) {
pos += i + 1;
cpos += i;
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
break l;
}
cbuf[cpos + i] = (char) b;
}
pos += rem;
cpos += rem;
}
return String.valueOf(cbuf, 0, cpos);
}
public final char[] nextCharArray() throws IOException {
return readToken();
}
public final int nextInt() throws IOException {
if (!hasRemaining())
return 0;
int value = 0;
byte b = buf[pos++];
if (b == 0x2d) {
while (hasRemaining() && (b = buf[pos++]) > 0x20)
value = value * 10 - b + 0x30;
} else {
do {
value = value * 10 + b - 0x30;
} while (hasRemaining() && (b = buf[pos++]) > 0x20);
}
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
return value;
}
public final long nextLong() throws IOException {
if (!hasRemaining())
return 0L;
long value = 0L;
byte b = buf[pos++];
if (b == 0x2d) {
while (hasRemaining() && (b = buf[pos++]) > 0x20)
value = value * 10 - b + 0x30;
} else {
do {
value = value * 10 + b - 0x30;
} while (hasRemaining() && (b = buf[pos++]) > 0x20);
}
if (b == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
return value;
}
public final char nextChar() throws IOException {
if (!hasRemaining())
throw new EOFException();
final char c = (char) buf[pos++];
if (hasRemaining() && buf[pos++] == 0x0d && hasRemaining() && buf[pos] == 0x0a)
pos++;
return c;
}
public final float nextFloat() throws IOException {
return Float.parseFloat(next());
}
public final double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public final boolean[] nextBooleanArray(char ok) throws IOException {
char[] s = readToken();
int n = s.length;
boolean[] t = new boolean[n];
for (int i = 0; i < n; i++)
t[i] = s[i] == ok;
return t;
}
public final boolean[][] nextBooleanMatrix(int h, int w, char ok) throws IOException {
boolean[][] s = new boolean[h][];
for (int i = 0; i < h; i++) {
char[] t = readToken();
int n = t.length;
s[i] = new boolean[n];
for (int j = 0; j < n; j++)
s[i][j] = t[j] == ok;
}
return s;
}
public final String[] nextStringArray(int len) throws IOException {
String[] arr = new String[len];
for (int i = 0; i < len; i++)
arr[i] = next();
return arr;
}
public final int[] nextIntArray(int len) throws IOException {
int[] arr = new int[len];
for (int i = 0; i < len; i++)
arr[i] = nextInt();
return arr;
}
public final int[] nextIntArray(int len, java.util.function.IntUnaryOperator map) throws IOException {
int[] arr = new int[len];
for (int i = 0; i < len; i++)
arr[i] = map.applyAsInt(nextInt());
return arr;
}
public final long[] nextLongArray(int len, java.util.function.LongUnaryOperator map) throws IOException {
long[] arr = new long[len];
for (int i = 0; i < len; i++)
arr[i] = map.applyAsLong(nextLong());
return arr;
}
public final int[][] nextIntMatrix(int h, int w) throws IOException {
int[][] arr = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
arr[i][j] = nextInt();
return arr;
}
public final int[][] nextIntMatrix(int h, int w, java.util.function.IntUnaryOperator map) throws IOException {
int[][] arr = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
arr[i][j] = map.applyAsInt(nextInt());
return arr;
}
public final long[] nextLongArray(int len) throws IOException {
long[] arr = new long[len];
for (int i = 0; i < len; i++)
arr[i] = nextLong();
return arr;
}
public final long[][] nextLongMatrix(int h, int w) throws IOException {
long[][] arr = new long[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
arr[i][j] = nextLong();
return arr;
}
public final float[] nextFloatArray(int len) throws IOException {
float[] arr = new float[len];
for (int i = 0; i < len; i++)
arr[i] = nextFloat();
return arr;
}
public final double[] nextDoubleArray(int len) throws IOException {
double[] arr = new double[len];
for (int i = 0; i < len; i++)
arr[i] = nextDouble();
return arr;
}
public final char[][] nextCharMatrix(int h, int w) throws IOException {
char[][] arr = new char[h][];
for (int i = 0; i < h; i++)
arr[i] = readToken();
return arr;
}
public final void nextThrow() throws IOException {
next();
return;
}
public final void nextThrow(int n) throws IOException {
for (int i = 0; i < n; i++)
nextThrow();
return;
}
}
final class ContestOutputStream extends FilterOutputStream implements Appendable {
protected final byte[] buf;
protected int pos = 0;
public ContestOutputStream() {
super(System.out);
this.buf = new byte[1 << 13];
}
@Override
public void flush() throws IOException {
out.write(buf, 0, pos);
pos = 0;
out.flush();
}
void put(byte b) throws IOException {
if (pos >= buf.length)
flush();
buf[pos++] = b;
}
int remaining() throws IOException {
if (pos >= buf.length)
flush();
return buf.length - pos;
}
@Override
public void write(int b) throws IOException {
put((byte) b);
}
@Override
public void write(byte[] b, int off, int len) throws IOException {
int o = off;
int l = len;
while (l > 0) {
int rem = Math.min(remaining(), l);
for (int i = 0; i < rem; i++)
buf[pos + i] = b[o + i];
pos += rem;
o += rem;
l -= rem;
}
}
@Override
public ContestOutputStream append(char c) throws IOException {
put((byte) c);
return this;
}
@Override
public ContestOutputStream append(CharSequence csq, int start, int end) throws IOException {
int off = start;
int len = end - start;
while (len > 0) {
int rem = Math.min(remaining(), len);
for (int i = 0; i < rem; i++)
buf[pos + i] = (byte) csq.charAt(off + i);
pos += rem;
off += rem;
len -= rem;
}
return this;
}
@Override
public ContestOutputStream append(CharSequence csq) throws IOException {
return append(csq, 0, csq.length());
}
public ContestOutputStream append(char[] arr, int off, int len) throws IOException {
int o = off;
int l = len;
while (l > 0) {
int rem = Math.min(remaining(), l);
for (int i = 0; i < rem; i++)
buf[pos + i] = (byte) arr[o + i];
pos += rem;
o += rem;
l -= rem;
}
return this;
}
public ContestOutputStream print(char[] arr) throws IOException {
return append(arr, 0, arr.length).newLine();
}
public ContestOutputStream print(boolean value) throws IOException {
if (value)
return append("o");
return append("x");
}
public ContestOutputStream println(boolean value) throws IOException {
if (value)
return append("o\n");
return append("x\n");
}
public ContestOutputStream print(boolean[][] value) throws IOException {
final int n = value.length, m = value[0].length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
print(value[i][j]);
newLine();
}
return this;
}
public ContestOutputStream print(int value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(int value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(long value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(long value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(float value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(float value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(double value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(double value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(char value) throws IOException {
return append(value);
}
public ContestOutputStream println(char value) throws IOException {
return append(value).newLine();
}
public ContestOutputStream print(String value) throws IOException {
return append(value);
}
public ContestOutputStream println(String value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream print(Object value) throws IOException {
return append(String.valueOf(value));
}
public ContestOutputStream println(Object value) throws IOException {
return append(String.valueOf(value)).newLine();
}
public ContestOutputStream printYN(boolean yes) throws IOException {
if (yes)
return println("Yes");
return println("No");
}
public ContestOutputStream printAB(boolean yes) throws IOException {
if (yes)
return println("Alice");
return println("Bob");
}
public ContestOutputStream print(CharSequence[] arr) throws IOException {
if (arr.length > 0) {
append(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').append(arr[i]);
}
return this;
}
public ContestOutputStream print(int[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
newLine();
return this;
}
public ContestOutputStream print(int[] arr, int length) throws IOException {
if (length > 0)
print(arr[0]);
for (int i = 1; i < length; i++)
append('\u0020').print(arr[i]);
newLine();
return this;
}
public ContestOutputStream println(int[] arr) throws IOException {
for (int i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream println(int[] arr, int length) throws IOException {
for (int i = 0; i < length; i++)
println(arr[i]);
return this;
}
public ContestOutputStream print(boolean[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
newLine();
return this;
}
public ContestOutputStream print(long[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
newLine();
return this;
}
public ContestOutputStream print(long[] arr, int length) throws IOException {
if (length > 0)
print(arr[0]);
for (int i = 1; i < length; i++)
append('\u0020').print(arr[i]);
newLine();
return this;
}
public ContestOutputStream println(long[] arr, int length) throws IOException {
for (int i = 0; i < length; i++)
println(arr[i]);
return this;
}
public ContestOutputStream println(long[] arr) throws IOException {
for (long i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream print(float[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
return this;
}
public ContestOutputStream println(float[] arr) throws IOException {
for (float i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream print(double[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
return newLine();
}
public ContestOutputStream println(double[] arr) throws IOException {
for (double i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream print(Object[] arr) throws IOException {
if (arr.length > 0) {
print(arr[0]);
for (int i = 1; i < arr.length; i++)
append('\u0020').print(arr[i]);
}
return newLine();
}
public ContestOutputStream print(java.util.ArrayList<?> arr) throws IOException {
if (!arr.isEmpty()) {
final int n = arr.size();
print(arr.get(0));
for (int i = 1; i < n; i++)
print(" ").print(arr.get(i));
}
return newLine();
}
public ContestOutputStream println(java.util.ArrayList<?> arr) throws IOException {
final int n = arr.size();
for (int i = 0; i < n; i++)
println(arr.get(i));
return this;
}
public ContestOutputStream println(Object[] arr) throws IOException {
for (Object i : arr)
print(i).newLine();
return this;
}
public ContestOutputStream newLine() throws IOException {
return append(System.lineSeparator());
}
public ContestOutputStream endl() throws IOException {
newLine().flush();
return this;
}
public ContestOutputStream print(int[][] arr) throws IOException {
for (int[] i : arr)
print(i);
return this;
}
public ContestOutputStream print(long[][] arr) throws IOException {
for (long[] i : arr)
print(i);
return this;
}
public ContestOutputStream print(char[][] arr) throws IOException {
for (char[] i : arr)
print(i);
return this;
}
public ContestOutputStream print(Object[][] arr) throws IOException {
for (Object[] i : arr)
print(i);
return this;
}
public ContestOutputStream println() throws IOException {
return newLine();
}
}
|
ConDefects/ConDefects/Code/abc239_g/Java/35404826
|
condefects-java_data_588
|
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
HashMap<Integer, Node> map = new HashMap<>();
int N = scanner.nextInt();
Node previousNode = null;
for (int i = 0; i < N; i++) {
Node node = new Node(scanner.nextInt());
map.put(node.value, node);
if(i > 0) {
previousNode.setNext(node);
node.setPrevious(previousNode);
}
previousNode = node;
}
int Q = scanner.nextInt();
for (int i = 0; i < Q; i++) {
if(scanner.nextInt() == 1) {
int X = scanner.nextInt();
int Y = scanner.nextInt();
Node prevNode = map.get(X);
Node nextNode = prevNode.getNext();
Node newNode = new Node(Y);
prevNode.setNext(newNode);
newNode.setPrevious(prevNode);
if(nextNode != null) {
newNode.setNext(nextNode);
nextNode.setPrevious(newNode);
}
map.put(Y, newNode);
} else {
int X = scanner.nextInt();
Node node = map.get(X);
Node prevNode = node.getPrevious();
Node nextNode = node.getNext();
map.remove(node);
if(prevNode == null) {
nextNode.setPrevious(null);
} else if(nextNode == null) {
prevNode.setNext(null);
} else {
prevNode.setNext(nextNode);
nextNode.setPrevious(prevNode);
}
}
}
Node firstNode = null;
for (Node node : map.values()) {
if(node.getPrevious()==null){
firstNode = node;
}
}
Node targetNode = firstNode;
StringBuilder sb = new StringBuilder();
while(true){
sb.append(targetNode.value).append(" ");
targetNode = targetNode.getNext();
if(targetNode == null) {
break;
}
}
System.out.println(sb.toString().trim());
}
public static class Node {
final int value;
public Node next = null;
public Node previous = null;
Node(int value) {
this.value = value;
}
public void setNext(Node next) {
this.next = next;
}
public Node getNext() {
return this.next;
}
public void setPrevious(Node previous) {
this.previous = previous;
}
public Node getPrevious() {
return this.previous;
}
}
}
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
HashMap<Integer, Node> map = new HashMap<>();
int N = scanner.nextInt();
Node previousNode = null;
for (int i = 0; i < N; i++) {
Node node = new Node(scanner.nextInt());
map.put(node.value, node);
if(i > 0) {
previousNode.setNext(node);
node.setPrevious(previousNode);
}
previousNode = node;
}
int Q = scanner.nextInt();
for (int i = 0; i < Q; i++) {
if(scanner.nextInt() == 1) {
int X = scanner.nextInt();
int Y = scanner.nextInt();
Node prevNode = map.get(X);
Node nextNode = prevNode.getNext();
Node newNode = new Node(Y);
prevNode.setNext(newNode);
newNode.setPrevious(prevNode);
if(nextNode != null) {
newNode.setNext(nextNode);
nextNode.setPrevious(newNode);
}
map.put(Y, newNode);
} else {
int X = scanner.nextInt();
Node node = map.get(X);
Node prevNode = node.getPrevious();
Node nextNode = node.getNext();
map.remove(node.value);
if(prevNode == null) {
nextNode.setPrevious(null);
} else if(nextNode == null) {
prevNode.setNext(null);
} else {
prevNode.setNext(nextNode);
nextNode.setPrevious(prevNode);
}
}
}
Node firstNode = null;
for (Node node : map.values()) {
if(node.getPrevious()==null){
firstNode = node;
}
}
Node targetNode = firstNode;
StringBuilder sb = new StringBuilder();
while(true){
sb.append(targetNode.value).append(" ");
targetNode = targetNode.getNext();
if(targetNode == null) {
break;
}
}
System.out.println(sb.toString().trim());
}
public static class Node {
final int value;
public Node next = null;
public Node previous = null;
Node(int value) {
this.value = value;
}
public void setNext(Node next) {
this.next = next;
}
public Node getNext() {
return this.next;
}
public void setPrevious(Node previous) {
this.previous = previous;
}
public Node getPrevious() {
return this.previous;
}
}
}
|
ConDefects/ConDefects/Code/abc344_e/Java/51241918
|
condefects-java_data_589
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import org.w3c.dom.ls.LSException;
public class Main {
static final long MOD1=1000000007;
static long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010l;//10^18
static boolean ok = false;
static long ans = 0;
static final int[] dx = {1, -1, 0, 0};
static final int[] dy = {0, 0, 1, -1};
static final long[] MODS = {998244353, 1000000007, 1000000009, 1000000021};
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int[] a = sc.nextIntArray(n);
int q = sc.nextInt();
HashMap<Integer, Integer> front = new HashMap<>();
HashMap<Integer, Integer> back = new HashMap<>();
for (int i = 0; i < n; i++) {
front.put(a[i], i - 1 >= 0 ? a[i - 1] : -1);
back.put(a[i], i + 1 < n ? a[i + 1] : -1);
}
for (int i = 0; i < q; i++) {
if (sc.nextInt() == 1) {
int x = sc.nextInt();
int y = sc.nextInt();
int x_back = back.get(x);
back.put(x, y);
if (x_back != -1) front.put(x_back, y);
front.put(y, x);
back.put(y, x_back);
}else {
int x = sc.nextInt();
int x_front = front.get(x);
int x_back = back.get(x);
if (x_front != -1) back.put(x_front, x_back);
if (x_back != -1) front.put(x_back, x_front);
}
}
int top = 0;
for (int key : front.keySet()) {
if (front.get(key) == -1) top = key;
}
int now = top;
while (now != -1) {
out.println(now);
now = back.get(now);
}
out.flush();
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import org.w3c.dom.ls.LSException;
public class Main {
static final long MOD1=1000000007;
static long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010l;//10^18
static boolean ok = false;
static long ans = 0;
static final int[] dx = {1, -1, 0, 0};
static final int[] dy = {0, 0, 1, -1};
static final long[] MODS = {998244353, 1000000007, 1000000009, 1000000021};
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int[] a = sc.nextIntArray(n);
int q = sc.nextInt();
HashMap<Integer, Integer> front = new HashMap<>();
HashMap<Integer, Integer> back = new HashMap<>();
for (int i = 0; i < n; i++) {
front.put(a[i], i - 1 >= 0 ? a[i - 1] : -1);
back.put(a[i], i + 1 < n ? a[i + 1] : -1);
}
for (int i = 0; i < q; i++) {
if (sc.nextInt() == 1) {
int x = sc.nextInt();
int y = sc.nextInt();
int x_back = back.get(x);
back.put(x, y);
if (x_back != -1) front.put(x_back, y);
front.put(y, x);
back.put(y, x_back);
}else {
int x = sc.nextInt();
int x_front = front.get(x);
int x_back = back.get(x);
if (x_front != -1) back.put(x_front, x_back);
if (x_back != -1) front.put(x_back, x_front);
front.remove(x);
back.remove(x);
}
}
int top = 0;
for (int key : front.keySet()) {
if (front.get(key) == -1) top = key;
}
int now = top;
while (now != -1) {
out.println(now);
now = back.get(now);
}
out.flush();
}
}
|
ConDefects/ConDefects/Code/abc344_e/Java/53551647
|
condefects-java_data_590
|
import java.util.*;import java.io.*;
public class Main {
static String ss, io[];
static int test, N = 200010, M = 1000000007;
static int n, m, ans, t = 1, v[] = new int[N];
static List<Integer>[] g = new List[N];
static void dfs(int x){
v[x] = t++;
for (int y : g[x]){
if (v[y]==0) dfs(y);
else if (v[y] > v[x]) ans++;
}
}
static void solve() throws Exception{
n = ni(); m = ni();
for (int i = 1;i <= n;i++) g[i] = new ArrayList<>();
for (int i = 0;i < m;i++){
int x = ni(), y = ni();
g[x].add(y);
g[y].add(x);
}
for (int i = 1;i <= n;i++) if (v[i] == 0) dfs(1);
out.println(ans);
}
public static void main(String[] args) throws Exception {
test = 1;
// test = ni(in.readLine());
while (test-- > 0){
solve();
}out.flush();
}
static int ni() throws IOException{input.nextToken();return (int) input.nval;}
static long nl() throws IOException{input.nextToken();return (long) input.nval;}
static int ni(String x) {return Integer.parseInt(x);}
static long nl(String x) {return Long.parseLong(x);}
static int max(int a, int b) {return a > b ? a : b;}
static long max(long a, long b) {return a > b ? a : b;}
static int min(int a, int b) {return a < b ? a : b;}
static long min(long a, long b) {return a < b ? a : b;}
static int lg2(long a) {return (int)Math.ceil((Math.log(a)/Math.log(2)));}
static int abs(int a) {return a > 0?a:-a;}
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer input = new StreamTokenizer(in);
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
}
import java.util.*;import java.io.*;
public class Main {
static String ss, io[];
static int test, N = 200010, M = 1000000007;
static int n, m, ans, t = 1, v[] = new int[N];
static List<Integer>[] g = new List[N];
static void dfs(int x){
v[x] = t++;
for (int y : g[x]){
if (v[y]==0) dfs(y);
else if (v[y] > v[x]) ans++;
}
}
static void solve() throws Exception{
n = ni(); m = ni();
for (int i = 1;i <= n;i++) g[i] = new ArrayList<>();
for (int i = 0;i < m;i++){
int x = ni(), y = ni();
g[x].add(y);
g[y].add(x);
}
for (int i = 1;i <= n;i++) if (v[i] == 0) dfs(i);
out.println(ans);
}
public static void main(String[] args) throws Exception {
test = 1;
// test = ni(in.readLine());
while (test-- > 0){
solve();
}out.flush();
}
static int ni() throws IOException{input.nextToken();return (int) input.nval;}
static long nl() throws IOException{input.nextToken();return (long) input.nval;}
static int ni(String x) {return Integer.parseInt(x);}
static long nl(String x) {return Long.parseLong(x);}
static int max(int a, int b) {return a > b ? a : b;}
static long max(long a, long b) {return a > b ? a : b;}
static int min(int a, int b) {return a < b ? a : b;}
static long min(long a, long b) {return a < b ? a : b;}
static int lg2(long a) {return (int)Math.ceil((Math.log(a)/Math.log(2)));}
static int abs(int a) {return a > 0?a:-a;}
static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
static StreamTokenizer input = new StreamTokenizer(in);
static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
}
|
ConDefects/ConDefects/Code/abc288_c/Java/38941263
|
condefects-java_data_591
|
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
public class Main {
private Map<Long, Double> cached = new HashMap<>();
public static void main(String[] args) throws Throwable {
Main main = new Main();
main.solve();
}
public void solve() throws Throwable {
FastScan scan = new FastScan(System.in);
long N = scan.nextLong();
int A = scan.nextInt();
long X = scan.nextLong();
long Y = scan.nextLong();
double ans = f(N, A, X, Y);
PrintWriter pw = new PrintWriter(System.out);
pw.printf("%.9f\n",ans);
pw.flush();
pw.close();
}
private Double f(long N, int A, long X, long Y) {
if (N == 0) {
return 0.0;
}
if (N == 1) {
return Math.min(X, (double) Y * 6 / 5);
}
if (cached.containsKey(N)) {
return cached.get(N);
}
double f1 = X + f(N/A, A, X, Y);
double f2 = 6 * Y / 5 + (f(N/2, A, X, Y) + f(N/3, A, X, Y) + f(N/4, A, X, Y) + f(N/5, A, X, Y) + f(N/6, A, X, Y)) / 5;
double min = Math.min(f1, f2);
cached.put(N, min);
return min;
}
class FastScan {
BufferedReader br;
StringTokenizer st;
FastScan(InputStream is) {
InputStreamReader isr = new InputStreamReader(is);
this.br = new BufferedReader(isr);
}
String next() throws IOException {
while (this.st == null || !this.st.hasMoreTokens()) {
this.st = new StringTokenizer(br.readLine().trim());
}
return st.nextToken();
}
long nextLong() throws IOException {
return Long.parseLong(this.next());
}
int nextInt() throws IOException {
return Integer.parseInt(this.next());
}
}
}
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
public class Main {
private Map<Long, Double> cached = new HashMap<>();
public static void main(String[] args) throws Throwable {
Main main = new Main();
main.solve();
}
public void solve() throws Throwable {
FastScan scan = new FastScan(System.in);
long N = scan.nextLong();
int A = scan.nextInt();
long X = scan.nextLong();
long Y = scan.nextLong();
double ans = f(N, A, X, Y);
PrintWriter pw = new PrintWriter(System.out);
pw.printf("%.9f\n",ans);
pw.flush();
pw.close();
}
private Double f(long N, int A, long X, long Y) {
if (N == 0) {
return 0.0;
}
if (N == 1) {
return Math.min(X, (double) Y * 6 / 5);
}
if (cached.containsKey(N)) {
return cached.get(N);
}
double f1 = X + f(N/A, A, X, Y);
double f2 = (6 * Y + f(N/2, A, X, Y) + f(N/3, A, X, Y) + f(N/4, A, X, Y) + f(N/5, A, X, Y) + f(N/6, A, X, Y)) / 5;
double min = Math.min(f1, f2);
cached.put(N, min);
return min;
}
class FastScan {
BufferedReader br;
StringTokenizer st;
FastScan(InputStream is) {
InputStreamReader isr = new InputStreamReader(is);
this.br = new BufferedReader(isr);
}
String next() throws IOException {
while (this.st == null || !this.st.hasMoreTokens()) {
this.st = new StringTokenizer(br.readLine().trim());
}
return st.nextToken();
}
long nextLong() throws IOException {
return Long.parseLong(this.next());
}
int nextInt() throws IOException {
return Integer.parseInt(this.next());
}
}
}
|
ConDefects/ConDefects/Code/abc350_e/Java/52619356
|
condefects-java_data_592
|
import java.io.*;
import java.lang.*;
import java.util.*;
public class Main {
static HashMap<Long,Double> hm;
static int dp[][][];
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
// PrintWriter out = new PrintWriter(System.out);
FastReader sc=new FastReader();
int t=1;
while(t--!=0) {
hm=new HashMap<>();
long n=sc.nextLong();
long a=sc.nextInt();
long x=sc.nextInt();
long y=sc.nextInt();
log.write(eval(n,a,x,y)+"\n");
}
log.flush();
// }
}
static double eval(long n,long a,long x,long y) {
if(n==0)return 0;
if(hm.containsKey(n))return hm.get(n);
long sm=6*y;
for(int i=2;i<=6;i++) {
sm+=eval(n/i,a,x,y);
}
double ans=Math.min(x+eval(n/a,a,x,y),sm/(double)5);
hm.put(n,ans);
return ans;
}
static boolean fill(boolean vis[][],int i,int j,int x,int y) {
int c1=0;
for(int l=i;l<=i+x-1;l++) {
for(int r=j;r<=j+y-1;r++) {
if(vis[l][r])c1++;
}
}
if(c1>0 && c1<x*y)return false;
for(int l=i;l<=i+x-1;l++) {
for(int r=j;r<=j+y-1;r++) {
if(vis[l][r])vis[l][r]=false;
else vis[l][r]=true;
}
}
return true;
}
public static class pair{
int a,b;
public pair(int a,int b) {
this.a=a;
this.b=b;
}
}
public static class pairr{
int a,b;
public pairr(int a,int b) {
this.a=a;
this.b=b;
}
}
public static class FastReader {
BufferedReader b;
StringTokenizer s;
public FastReader() {
b=new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while(s==null ||!s.hasMoreElements()) {
try {
s=new StringTokenizer(b.readLine());
}
catch(IOException e) {
e.printStackTrace();
}
}
return s.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str="";
try {
str=b.readLine();
}
catch(IOException e) {
e.printStackTrace();
}
return str;
}
boolean hasNext() {
if (s != null && s.hasMoreTokens()) {
return true;
}
String tmp;
try {
b.mark(1000);
tmp = b.readLine();
if (tmp == null) {
return false;
}
b.reset();
} catch (IOException e) {
return false;
}
return true;
}
}
}
import java.io.*;
import java.lang.*;
import java.util.*;
public class Main {
static HashMap<Long,Double> hm;
static int dp[][][];
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
// PrintWriter out = new PrintWriter(System.out);
FastReader sc=new FastReader();
int t=1;
while(t--!=0) {
hm=new HashMap<>();
long n=sc.nextLong();
long a=sc.nextInt();
long x=sc.nextInt();
long y=sc.nextInt();
log.write(eval(n,a,x,y)+"\n");
}
log.flush();
// }
}
static double eval(long n,long a,long x,long y) {
if(n==0)return 0;
if(hm.containsKey(n))return hm.get(n);
double sm=6*y;
for(int i=2;i<=6;i++) {
sm+=eval(n/i,a,x,y);
}
double ans=Math.min(x+eval(n/a,a,x,y),sm/(double)5);
hm.put(n,ans);
return ans;
}
static boolean fill(boolean vis[][],int i,int j,int x,int y) {
int c1=0;
for(int l=i;l<=i+x-1;l++) {
for(int r=j;r<=j+y-1;r++) {
if(vis[l][r])c1++;
}
}
if(c1>0 && c1<x*y)return false;
for(int l=i;l<=i+x-1;l++) {
for(int r=j;r<=j+y-1;r++) {
if(vis[l][r])vis[l][r]=false;
else vis[l][r]=true;
}
}
return true;
}
public static class pair{
int a,b;
public pair(int a,int b) {
this.a=a;
this.b=b;
}
}
public static class pairr{
int a,b;
public pairr(int a,int b) {
this.a=a;
this.b=b;
}
}
public static class FastReader {
BufferedReader b;
StringTokenizer s;
public FastReader() {
b=new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while(s==null ||!s.hasMoreElements()) {
try {
s=new StringTokenizer(b.readLine());
}
catch(IOException e) {
e.printStackTrace();
}
}
return s.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str="";
try {
str=b.readLine();
}
catch(IOException e) {
e.printStackTrace();
}
return str;
}
boolean hasNext() {
if (s != null && s.hasMoreTokens()) {
return true;
}
String tmp;
try {
b.mark(1000);
tmp = b.readLine();
if (tmp == null) {
return false;
}
b.reset();
} catch (IOException e) {
return false;
}
return true;
}
}
}
|
ConDefects/ConDefects/Code/abc350_e/Java/52629945
|
condefects-java_data_593
|
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 Regular Contest 172 E問題
* 考察メモ
* n^n mod 10^9 = (n mod 10^9)^(n mod 400000000)であることはまず分かって
* このことから、lcm(10^9, 4*10^8)=2*10^9の周期性だよね、は分かる
*
* n=a*10^3+bと定義するとどうだろう？
* 上位項が消えまくって、残るのは500000n(n-1)a^2b^(n-2)+10^6nab^(n-1)+b^nか
* 0≦a<2*10^6、0≦b<1000であり、bを決め打った時にaについては2次の項しか残らない
* Aa^2+Ba+C=Xなるaが存在するか？を判定することを考える
* 明らかにAa^2+Ba=X-C (mod 10^9)にしてよい、後はどうするか
* 平方完成すると(a+B/(2A))^2-B^2/(4A^2)+(C-X)/A≡0 (mod 10^9)なので、そういうことができると嬉しい？
* ただ、/Aが出てくるのでこれが定義されないと終わりだが……どうだ？
* nが2, 5の倍数だった時、明らかに結果も2か5の倍数になるので、bは2でも5でも割れないことは明らか
* また、A, Bともに10^6の倍数なので、aが1000以上だと実質無意味？
* ということは？
* a % 1000およびbを決め打つという手もあるか、すると残るのはAb^(n-2)+Bb^(n-1)+b^n
* n=(a*10^3+b)なので、c=a/1000と定義すると
*
* ん？
* 8000000までは3981511通り、そこから1000000増えるごとに400000通りずつ増えてる
* 規則性あるような？
* あ、等差数列になってるけど
*
* ax+b=X→ax=X-b (mod 10^9)
* まずX-bはgcd(a, 10^9)である必要があり、そうなら両辺を割って求められる
* あ、分かった
* 下の桁から確定できるわ
*
*/
int Q = io.nextInt();
while(Q --> 0) {
int X = io.nextInt();
int n = 0;
for (int i = 0;i < 100;++ i) if (test(i) % 100 == X % 100) n = i;
for (int i = 2;i < 9;++ i) {
int d = pow(10, i), d2 = d * 1000;
for (int j = 0;j < 10;++ j) {
int n2 = n + d * j;
if (test(n2) % d2 == X % d2) n = n2;
}
}
io.println(test(n) == X ? n : -1);
}
}
int test(int n) {
return pow(n, n, 1000000000);
}
/** デバッグ用コードのお供に */
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 Regular Contest 172 E問題
* 考察メモ
* n^n mod 10^9 = (n mod 10^9)^(n mod 400000000)であることはまず分かって
* このことから、lcm(10^9, 4*10^8)=2*10^9の周期性だよね、は分かる
*
* n=a*10^3+bと定義するとどうだろう？
* 上位項が消えまくって、残るのは500000n(n-1)a^2b^(n-2)+10^6nab^(n-1)+b^nか
* 0≦a<2*10^6、0≦b<1000であり、bを決め打った時にaについては2次の項しか残らない
* Aa^2+Ba+C=Xなるaが存在するか？を判定することを考える
* 明らかにAa^2+Ba=X-C (mod 10^9)にしてよい、後はどうするか
* 平方完成すると(a+B/(2A))^2-B^2/(4A^2)+(C-X)/A≡0 (mod 10^9)なので、そういうことができると嬉しい？
* ただ、/Aが出てくるのでこれが定義されないと終わりだが……どうだ？
* nが2, 5の倍数だった時、明らかに結果も2か5の倍数になるので、bは2でも5でも割れないことは明らか
* また、A, Bともに10^6の倍数なので、aが1000以上だと実質無意味？
* ということは？
* a % 1000およびbを決め打つという手もあるか、すると残るのはAb^(n-2)+Bb^(n-1)+b^n
* n=(a*10^3+b)なので、c=a/1000と定義すると
*
* ん？
* 8000000までは3981511通り、そこから1000000増えるごとに400000通りずつ増えてる
* 規則性あるような？
* あ、等差数列になってるけど
*
* ax+b=X→ax=X-b (mod 10^9)
* まずX-bはgcd(a, 10^9)である必要があり、そうなら両辺を割って求められる
* あ、分かった
* 下の桁から確定できるわ
*
*/
int Q = io.nextInt();
while(Q --> 0) {
int X = io.nextInt();
int n = 0;
for (int i = 0;i < 100;++ i) if (test(i) % 100 == X % 100) n = i;
for (int i = 2;i < 9;++ i) {
int d = pow(10, i), d2 = d * 10;
for (int j = 0;j < 10;++ j) {
int n2 = n + d * j;
if (test(n2) % d2 == X % d2) n = n2;
}
}
io.println(test(n) == X ? n : -1);
}
}
int test(int n) {
return pow(n, n, 1000000000);
}
/** デバッグ用コードのお供に */
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/arc172_e/Java/50430070
|
condefects-java_data_594
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
public class Main implements Runnable {
public static void main(String[] args) {
new Thread(null, new Main(), "", Runtime.getRuntime().maxMemory()).start();
}
public void run() {
FastScanner sc = new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
int N = sc.nextInt();
int M = sc.nextInt();
Map<Integer, Integer> mset = new HashMap<>();
int base = 0;
for (int i = 0; i < N; ++i) {
int a = sc.nextInt();
int b= sc.nextInt();
base += a;
int add = b - a;
if (add == 0) continue;
mset.merge(add, 1, Integer::sum);
}
int[] dp = new int[M + 1];
int INF = Integer.MAX_VALUE / 3;
Arrays.fill(dp, INF);
dp[base] = 0;
for (var es : mset.entrySet()) {
int add = es.getKey();
int num = es.getValue();
if (add > 0) {
solve(dp, add, num, M);
} else {
reverse(dp);
add = -add;
solve(dp, add, num, M);
reverse(dp);
}
}
for (int i = 0; i <= M; ++i) {
pw.println(dp[i] == INF ? -1 : dp[i]);
}
pw.close();
}
void reverse(int[] a) {
int s = 0;
int t = a.length - 1;
while (s < t) {
a[s]^=a[t];
a[t]^=a[s];
a[s]^=a[t];
++s;--t;
}
}
void solve(int[] dp, int add, int num, int M) {
for (int src = 0; src < add; ++src) {
Dq val = new Dq(M / add + 1);
Dq off = new Dq(M / add + 1);
for (int i = src, c = 0; i <= M; i += add, ++c) {
if (!val.isEmpty() && c - off.first() > num) {
val.popFirst();
off.popFirst();
}
int nv = dp[i];
if (!val.isEmpty()) {
nv = Math.min(dp[i], val.last() + (c - off.last()));
}
while (!val.isEmpty() && dp[i] - c <= val.last() - off.last()) {
val.popLast();
off.popLast();
}
val.addLast(dp[i]);
off.addLast(c);
dp[i] = nv;
}
}
}
class Dq {
int[] a;
int head = 0;;
int tail = -1;
public Dq(int n) {
a = new int[n];
}
int first() {
return a[head];
}
int last() {
return a[tail];
}
void popFirst() {
++head;
}
void popLast() {
--tail;
}
boolean isEmpty() {
return !(tail - head >= 0);
}
void addLast(int v) {
a[++tail] = v;
}
}
void tr(Object... objects) {
System.err.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.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
public class Main implements Runnable {
public static void main(String[] args) {
new Thread(null, new Main(), "", Runtime.getRuntime().maxMemory()).start();
}
public void run() {
FastScanner sc = new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
int N = sc.nextInt();
int M = sc.nextInt();
Map<Integer, Integer> mset = new HashMap<>();
int base = 0;
for (int i = 0; i < N; ++i) {
int a = sc.nextInt();
int b= sc.nextInt();
base += a;
int add = b - a;
if (add == 0) continue;
mset.merge(add, 1, Integer::sum);
}
int[] dp = new int[M + 1];
int INF = Integer.MAX_VALUE / 3;
Arrays.fill(dp, INF);
dp[base] = 0;
for (var es : mset.entrySet()) {
int add = es.getKey();
int num = es.getValue();
if (add > 0) {
solve(dp, add, num, M);
} else {
reverse(dp);
add = -add;
solve(dp, add, num, M);
reverse(dp);
}
}
for (int i = 0; i <= M; ++i) {
pw.println(dp[i] == INF ? -1 : dp[i]);
}
pw.close();
}
void reverse(int[] a) {
int s = 0;
int t = a.length - 1;
while (s < t) {
a[s]^=a[t];
a[t]^=a[s];
a[s]^=a[t];
++s;--t;
}
}
void solve(int[] dp, int add, int num, int M) {
for (int src = 0; src < add; ++src) {
Dq val = new Dq(M / add + 1);
Dq off = new Dq(M / add + 1);
for (int i = src, c = 0; i <= M; i += add, ++c) {
if (!val.isEmpty() && c - off.first() > num) {
val.popFirst();
off.popFirst();
}
int nv = dp[i];
if (!val.isEmpty()) {
nv = Math.min(dp[i], val.first() + (c - off.first()));
}
while (!val.isEmpty() && dp[i] - c <= val.last() - off.last()) {
val.popLast();
off.popLast();
}
val.addLast(dp[i]);
off.addLast(c);
dp[i] = nv;
}
}
}
class Dq {
int[] a;
int head = 0;;
int tail = -1;
public Dq(int n) {
a = new int[n];
}
int first() {
return a[head];
}
int last() {
return a[tail];
}
void popFirst() {
++head;
}
void popLast() {
--tail;
}
boolean isEmpty() {
return !(tail - head >= 0);
}
void addLast(int v) {
a[++tail] = v;
}
}
void tr(Object... objects) {
System.err.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/abc269_g/Java/34958741
|
condefects-java_data_595
|
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.math.BigInteger;
import java.util.Comparator;
class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long a = (long)1 << 31;
if(n >= a || n <= -a){
System.out.println("No");
}else{
System.out.println("Yes");
}
}
}
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.math.BigInteger;
import java.util.Comparator;
class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long a = (long)1 << 31;
if(n >= a || n < -a){
System.out.println("No");
}else{
System.out.println("Yes");
}
}
}
|
ConDefects/ConDefects/Code/abc237_a/Java/43335381
|
condefects-java_data_596
|
import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
// import java.math.*;
public final class Main {
public static final void main(String[] args) {
final long N = getNextLong();
if(N >= (1L << 31) * (-1L) && N <= (1L << 31)) {
println("Yes");
} else {
println("No");
}
flush();
}
// final int[][] dir = new int[][] {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
// final BiPredicate<Integer, Integer> isInside = (h, w) -> h >= 0 && h < H && w >= 0 && w < W;
// String.format("%.15f", d);
private static Scanner scanner;
private static PrintWriter writer;
// private static final long PRIME = 1000000007;
// private static final long PRIME = 998244353;
static {
scanner = new Scanner(System.in);
writer = new PrintWriter(System.out);
}
private static int[] concat(int[] ary1, int[] ary2) {
final int[] ret = Arrays.copyOf(ary1, ary1.length + ary2.length);
for(int idx = 0; idx < ary2.length; idx++) {
ret[ary1.length + idx] = ary2[idx];
}
return ret;
}
private static <E> List<E> concat(List<E> l1, List<E> l2) {
return Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
}
private static String getNextLine() {
return scanner.nextLine();
}
private static String getNext() {
return scanner.next();
}
private static int[] getCharIntArray() {
return getCharIntArray(v -> v);
}
private static int[] getCharIntArray(IntUnaryOperator mapper) {
return getNext().chars().map(mapper).toArray();
}
private static char[][] get2dCharArray(int rows) {
return Stream.generate(() -> getNext().toCharArray()).limit(rows).toArray(char[][]::new);
}
private static int[][] get2dCharIntArray(int rows) {
return get2dCharIntArray(rows, v -> v);
}
private static int[][] get2dCharIntArray(int rows, IntUnaryOperator mapper) {
return Stream.generate(() -> getNext().chars().map(mapper).toArray()).limit(rows).toArray(int[][]::new);
}
private static int getNextInt() {
return Integer.parseInt(scanner.next());
}
private static long getNextLong() {
return Long.parseLong(scanner.next());
}
private static double getNextDouble() {
return Double.parseDouble(scanner.next());
}
private static int[] getIntArray(int length) {
return getIntArray(length, v -> v);
}
private static int[] getIntArray(int length, IntUnaryOperator mapper) {
return IntStream.generate(() -> getNextInt()).limit(length).map(mapper).toArray();
}
private static List<Integer> getIntList(int length) {
return getIntList(length, v -> v);
}
private static List<Integer> getIntList(int length, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getNextInt()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static long[] getLongArray(int length) {
return getLongArray(length, v -> v);
}
private static long[] getLongArray(int length, LongUnaryOperator mapper) {
return LongStream.generate(() -> getNextLong()).limit(length).map(mapper).toArray();
}
private static List<Long> getLongList(int length) {
return getLongList(length, v -> v);
}
private static List<Long> getLongList(int length, Function<Long, Long> mapper) {
return Stream.generate(() -> getNextLong()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static int[][] get2dIntArray(int rows, int cols) {
return get2dIntArray(rows, cols, v -> v);
}
private static int[][] get2dIntArray(int rows, int cols, IntUnaryOperator mapper) {
return Stream.generate(() -> getIntArray(cols, mapper)).limit(rows).toArray(int[][]::new);
}
private static List<List<Integer>> get2dIntList(int rows, int cols) {
return get2dIntList(rows, cols, v -> v);
}
private static List<List<Integer>> get2dIntList(int rows, int cols, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getIntList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static long[][] get2dLongArray(int rows, int cols) {
return get2dLongArray(rows, cols, v -> v);
}
private static long[][] get2dLongArray(int rows, int cols, LongUnaryOperator mapper) {
return Stream.generate(() -> getLongArray(cols, mapper)).limit(rows).toArray(long[][]::new);
}
private static List<List<Long>> get2dLongList(int rows, int cols) {
return get2dLongList(rows, cols, v -> v);
}
private static List<List<Long>> get2dLongList(int rows, int cols, Function<Long, Long> mapper) {
return Stream.generate(() -> getLongList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static void print(int[] argi) {
Arrays.stream(argi).forEach(i -> print(String.valueOf(i) + " "));
}
private static void print(long[] argl) {
Arrays.stream(argl).forEach(l -> print(String.valueOf(l) + " "));
}
private static void print(char[] argc) {
print(String.valueOf(argc));
}
private static void print(Collection list) {
list.stream().forEach(e -> print(e.toString() + " "));
}
private static void print(Object obj) {
writer.print(obj);
}
private static void print(Object... arg) {
Arrays.stream(arg).forEach(obj -> print(obj));
}
private static void println(int[] argi) {
print(argi);
println();
}
private static void println(long[] argl) {
print(argl);
println();
}
private static void println(char[] argc) {
print(argc);
println();
}
private static void println(char[][] cmap) {
Arrays.stream(cmap).forEach(line -> println(line));
}
private static void println(Collection list) {
print(list);
println();
}
private static void println(Object obj) {
print(obj);
println();
}
private static void println(Object... arg) {
print(arg);
println();
}
private static void println() {
writer.println();
}
private static void flush() {
writer.flush();
}
}
import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
// import java.math.*;
public final class Main {
public static final void main(String[] args) {
final long N = getNextLong();
if(N >= (1L << 31) * (-1L) && N < (1L << 31)) {
println("Yes");
} else {
println("No");
}
flush();
}
// final int[][] dir = new int[][] {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
// final BiPredicate<Integer, Integer> isInside = (h, w) -> h >= 0 && h < H && w >= 0 && w < W;
// String.format("%.15f", d);
private static Scanner scanner;
private static PrintWriter writer;
// private static final long PRIME = 1000000007;
// private static final long PRIME = 998244353;
static {
scanner = new Scanner(System.in);
writer = new PrintWriter(System.out);
}
private static int[] concat(int[] ary1, int[] ary2) {
final int[] ret = Arrays.copyOf(ary1, ary1.length + ary2.length);
for(int idx = 0; idx < ary2.length; idx++) {
ret[ary1.length + idx] = ary2[idx];
}
return ret;
}
private static <E> List<E> concat(List<E> l1, List<E> l2) {
return Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
}
private static String getNextLine() {
return scanner.nextLine();
}
private static String getNext() {
return scanner.next();
}
private static int[] getCharIntArray() {
return getCharIntArray(v -> v);
}
private static int[] getCharIntArray(IntUnaryOperator mapper) {
return getNext().chars().map(mapper).toArray();
}
private static char[][] get2dCharArray(int rows) {
return Stream.generate(() -> getNext().toCharArray()).limit(rows).toArray(char[][]::new);
}
private static int[][] get2dCharIntArray(int rows) {
return get2dCharIntArray(rows, v -> v);
}
private static int[][] get2dCharIntArray(int rows, IntUnaryOperator mapper) {
return Stream.generate(() -> getNext().chars().map(mapper).toArray()).limit(rows).toArray(int[][]::new);
}
private static int getNextInt() {
return Integer.parseInt(scanner.next());
}
private static long getNextLong() {
return Long.parseLong(scanner.next());
}
private static double getNextDouble() {
return Double.parseDouble(scanner.next());
}
private static int[] getIntArray(int length) {
return getIntArray(length, v -> v);
}
private static int[] getIntArray(int length, IntUnaryOperator mapper) {
return IntStream.generate(() -> getNextInt()).limit(length).map(mapper).toArray();
}
private static List<Integer> getIntList(int length) {
return getIntList(length, v -> v);
}
private static List<Integer> getIntList(int length, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getNextInt()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static long[] getLongArray(int length) {
return getLongArray(length, v -> v);
}
private static long[] getLongArray(int length, LongUnaryOperator mapper) {
return LongStream.generate(() -> getNextLong()).limit(length).map(mapper).toArray();
}
private static List<Long> getLongList(int length) {
return getLongList(length, v -> v);
}
private static List<Long> getLongList(int length, Function<Long, Long> mapper) {
return Stream.generate(() -> getNextLong()).limit(length).map(mapper)
.collect(Collectors.toCollection(ArrayList::new));
}
private static int[][] get2dIntArray(int rows, int cols) {
return get2dIntArray(rows, cols, v -> v);
}
private static int[][] get2dIntArray(int rows, int cols, IntUnaryOperator mapper) {
return Stream.generate(() -> getIntArray(cols, mapper)).limit(rows).toArray(int[][]::new);
}
private static List<List<Integer>> get2dIntList(int rows, int cols) {
return get2dIntList(rows, cols, v -> v);
}
private static List<List<Integer>> get2dIntList(int rows, int cols, Function<Integer, Integer> mapper) {
return Stream.generate(() -> getIntList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static long[][] get2dLongArray(int rows, int cols) {
return get2dLongArray(rows, cols, v -> v);
}
private static long[][] get2dLongArray(int rows, int cols, LongUnaryOperator mapper) {
return Stream.generate(() -> getLongArray(cols, mapper)).limit(rows).toArray(long[][]::new);
}
private static List<List<Long>> get2dLongList(int rows, int cols) {
return get2dLongList(rows, cols, v -> v);
}
private static List<List<Long>> get2dLongList(int rows, int cols, Function<Long, Long> mapper) {
return Stream.generate(() -> getLongList(cols, mapper)).limit(rows).collect(Collectors.toCollection(ArrayList::new));
}
private static void print(int[] argi) {
Arrays.stream(argi).forEach(i -> print(String.valueOf(i) + " "));
}
private static void print(long[] argl) {
Arrays.stream(argl).forEach(l -> print(String.valueOf(l) + " "));
}
private static void print(char[] argc) {
print(String.valueOf(argc));
}
private static void print(Collection list) {
list.stream().forEach(e -> print(e.toString() + " "));
}
private static void print(Object obj) {
writer.print(obj);
}
private static void print(Object... arg) {
Arrays.stream(arg).forEach(obj -> print(obj));
}
private static void println(int[] argi) {
print(argi);
println();
}
private static void println(long[] argl) {
print(argl);
println();
}
private static void println(char[] argc) {
print(argc);
println();
}
private static void println(char[][] cmap) {
Arrays.stream(cmap).forEach(line -> println(line));
}
private static void println(Collection list) {
print(list);
println();
}
private static void println(Object obj) {
print(obj);
println();
}
private static void println(Object... arg) {
print(arg);
println();
}
private static void println() {
writer.println();
}
private static void flush() {
writer.flush();
}
}
|
ConDefects/ConDefects/Code/abc237_a/Java/45762900
|
condefects-java_data_597
|
import java.util.*;
class Main {
public static void main(String[] ktr) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
System.out.println(Integer.MIN_VALUE + 1 <= n && n < Integer.MAX_VALUE ? "Yes" : "No");
sc.close();
}
}
import java.util.*;
class Main {
public static void main(String[] ktr) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
System.out.println(Integer.MAX_VALUE + 1 <= n && n <= Integer.MAX_VALUE ? "Yes" : "No");
sc.close();
}
}
|
ConDefects/ConDefects/Code/abc237_a/Java/37785115
|
condefects-java_data_598
|
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scn = new Scanner(System.in);
long num = scn.nextLong();
long num2 = (long) Math.pow(2, 31);
long num3 = (long) Math.pow(2, -31);
if (num3 <= num && num < num2) {
System.out.println("Yes");
} else {
System.out.println("No");
}
scn.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scn = new Scanner(System.in);
long num = scn.nextLong();
long num2 = (long) Math.pow(2, 31);
long num3 = (long) Math.pow(-2, 31);
if (num3 <= num && num < num2) {
System.out.println("Yes");
} else {
System.out.println("No");
}
scn.close();
}
}
|
ConDefects/ConDefects/Code/abc237_a/Java/42097498
|
condefects-java_data_599
|
import java.util.*;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = Long.parseLong(sc.next());
if (Math.pow(-2, 32) <= N && N < Math.pow(2, 32)) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
import java.util.*;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long N = Long.parseLong(sc.next());
if (Math.pow(-2, 31) <= N && N < Math.pow(2, 31)) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc237_a/Java/38766997
|
condefects-java_data_600
|
import java.util.*;
public class Main {
public static void main(String ars[]) {
// 거듭제곱 연산자
Scanner input = new Scanner(System.in);
long N = input.nextLong();
// int형으로 처음부터 받으려면
long result = (long) Math.pow(2, 31);
if (N >= (result * -1) -1 && N <= result-1 ) {
System.out.println("Yes");
}
else {
System.out.println("No");
}
}
}
import java.util.*;
public class Main {
public static void main(String ars[]) {
// 거듭제곱 연산자
Scanner input = new Scanner(System.in);
long N = input.nextLong();
// int형으로 처음부터 받으려면
long result = (long) Math.pow(2, 31);
if (N >= (result * -1) && N <= result-1 ) {
System.out.println("Yes");
}
else {
System.out.println("No");
}
}
}
|
ConDefects/ConDefects/Code/abc237_a/Java/45094512
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.