id stringlengths 22 25 | content stringlengths 327 628k | max_stars_repo_path stringlengths 49 49 |
|---|---|---|
condefects-java_data_1601 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int[] A = in.it(N);
int M = 200_000;
Object solve(){
int[] cnt = new int[M +1];
for (var a:A)
cnt[a]++;
long[] dp = new long[1];
dp[0] = 1;
for (int a = 1;a <= M;a++) {
int N2 = dp.length +cnt[a];
long[] dp2 = new long[N2];
for (int p = 0;p < dp.length;p++) {
dp2[cnt[a]] += dp[p];
if (cnt[a] +p /2 +1 < N2)
dp2[cnt[a] +p /2 +1] += mod -dp[p];
}
dp2[0] %= mod;
for (int i = 0;i +1 < N2;i++) {
dp2[i +1] += dp2[i];
dp2[i +1] %= mod;
}
int l = dp2.length;
while (dp2[l -1] == 0)
l--;
dp = copyOf(dp2,l);
}
long ans = 0;
for (var d:dp)
ans += d;
return ans %= mod;
}
private Object solve(int[] A){
String fir = "First";
String sec = "Second";
int N = A.length;
if (N %2 == 1)
return sec;
Set<Integer> set = new HashSet<>();
for (var a:A)
if (!set.add(a))
set.remove(a);
return set.size() == 0 ? sec : fir;
}
}
class AVLTree<V> {
@Override
public String toString(){
List<String> list = new ArrayList<>();
for (int i = 0;i < size();i++) {
V ee = get(i);
list.add(ee.getClass().isArray() ? Arrays.toString((long[]) ee) : ee.toString());
}
return list.toString();
}
private V e;
private Node nl;
private Comparator<V> cmp;
@SuppressWarnings("unchecked")
AVLTree(V e){ this((Comparator<V>) Comparator.naturalOrder(),e); }
@SuppressWarnings("unchecked")
AVLTree(){ this((Comparator<V>) Comparator.naturalOrder(),null); }
<U extends Comparable<U>> AVLTree(Function<V, U> f,V e){ this(Comparator.comparing(f),e); }
<U extends Comparable<U>> AVLTree(Function<V, U> f){ this(Comparator.comparing(f),null); }
protected AVLTree(Comparator<V> cmp,V e){
this.e = e;
nl = new Node(null);
nl.par = nl.lft = nl.rht = nl;
nl.sz = nl.cnt = nl.rnk = 0;
this.cmp = cmp;
}
void add(V v){
if (nl.rht == nl) {
nl.cld(1,new Node(v));
return;
}
Node nd = nl.rht;
for (int c;true;nd = nd.cld(c))
if ((c = cmp.compare(v,nd.val)) == 0) {
nd.cnt++;
break;
} else if (nd.cld(c) == nl) {
nd.cld(c,new Node(v));
break;
}
balance(nd);
}
V get(int k){
assert k < size();
for (var nd = nl.rht;true;)
if (k < nd.lft.sz)
nd = nd.lft;
else if (k < nd.lft.sz +nd.cnt)
return nd.val;
else {
k -= nd.lft.sz +nd.cnt;
nd = nd.rht;
}
}
V sum(int k){
assert k <= size();
V ret = e;
for (var nd = nl.rht;true;)
if (k == 0)
return ret;
else if (k <= nd.lft.sz)
nd = nd.lft;
else if (k <= nd.lft.sz +nd.cnt)
return sum(sum(ret,nd.lft == nl ? e : nd.lft.sum),pow(nd.val,k -nd.lft.sz));
else {
ret = sum(sum(ret,nd.lft == nl ? e : nd.lft.sum),pow(nd.val,nd.cnt));
k -= nd.lft.sz +nd.cnt;
nd = nd.rht;
}
}
boolean remove(V v){
Node nd;
if ((nd = node(v)) == nl)
return false;
delete(nd);
return true;
}
V peek(){ return first(); }
V first(){ return end(nl.rht,-1).val; }
V last(){ return end(nl.rht,1).val; }
V floor(V v){ return near(nl.rht,v,2,1).val; }
V ceiling(V v){ return near(nl.rht,v,2,-1).val; }
V lower(V v){ return near(nl.rht,v,0,1).val; }
V higher(V v){ return near(nl.rht,v,0,-1).val; }
V poll(){ return pollFirst(); }
V pollFirst(){ return poll(end(nl.rht,-1)); }
V pollLast(){ return poll(end(nl.rht,1)); }
V pollFloor(V v){ return poll(near(nl.rht,v,2,1)); }
V pollCeiling(V v){ return poll(near(nl.rht,v,2,-1)); }
V pollLower(V v){ return poll(near(nl.rht,v,0,1)); }
V pollHigher(V v){ return poll(near(nl.rht,v,0,-1)); }
V poll(Node nd){
V ret = nd.val;
delete(nd);
return ret;
}
int cnt(V v){ return node(v).cnt; }
boolean contains(V v){ return v != null && node(v) != nl; }
int size(){ return nl.rht == nl ? 0 : nl.rht.sz; }
boolean isEmpty(){ return nl.rht == nl; }
int lowerBound(V v){ return bound(v,0); }
int upperBound(V v){ return bound(v,1); }
private int bound(V v,int u){
var nd = nl.rht;
for (int ret = 0,c;true;)
if (nd == nl || (c = cmp.compare(v,nd.val)) == 0)
return ret +u *nd.cnt +nd.lft.sz;
else if (c < 0)
nd = nd.lft;
else if (0 < c) {
ret += nd.lft.sz +nd.cnt;
nd = nd.rht;
}
}
private void delete(Node nd){
if (nd == nl)
return;
if (1 < nd.cnt) {
nd.cnt--;
balance(nd);
return;
}
if (nd.lft != nl && nd.rht != nl) {
Node rep = end(nd.rht,-1);
nd.ovr(rep);
nd = rep;
}
balance(nd.par.cld(nd.par.lft == nd ? -1 : 1,nd.lft != nl ? nd.lft : nd.rht));
}
private Node end(Node nd,int c){
while (nd.cld(c) != nl)
nd = nd.cld(c);
return nd;
}
private Node near(Node nd,V v,int eq,int l){
var ret = nl;
for (int c;nd != nl;nd = nd.cld(c *l))
if ((c = cmp.compare(v,nd.val) *l) >= 0)
if (nd.cld(l) == nl || c == (eq ^2))
return nd;
else
ret = nd;
return ret;
}
private Node node(V v){
assert v != null;
var ret = near(nl.rht,v,2,1);
return Objects.equals(v,ret.val) ? ret : nl;
}
private void balance(Node nd){
while (nd != nl) {
nd.upd();
var par = nd.par;
if (abs(nd.bis) > 1) {
int c = par.lft == nd ? -1 : 1;
nd = nd.bis < 0
? nd.lft.bis > 0 ? rotate2(nd,1) : rotate1(nd,1)
: nd.rht.bis < 0 ? rotate2(nd,-1) : rotate1(nd,-1);
par.cld(c,nd);
}
nd = par;
}
}
private Node rotate1(Node u,int c){
var v = u.cld(-c);
u.cld(-c,v.cld(c)).upd();
v.cld(c,u).upd();
return v;
}
private Node rotate2(Node u,int c){
var v = u.cld(-c);
var w = v.cld(c);
u.cld(-c,w.cld(c)).upd();
v.cld(c,w.cld(-c)).upd();
w.cld(-c,v).cld(c,u).upd();
return w;
}
private class Node{
int sz,cnt,rnk,bis;
V val,sum;
Node par,lft,rht;
Node(V val){
sz = cnt = rnk = 1;
this.val = sum = val;
par = lft = rht = nl;
}
Node cld(int c){ return c < 0 ? lft : rht; }
Node cld(int c,Node nd){
if (c < 0)
lft = nd;
else
rht = nd;
nd.par = this;
return this;
}
void ovr(Node nd){
cnt = nd.cnt;
val = nd.val;
nd.cnt = 1;
}
void upd(){
sz = lft.sz +rht.sz +cnt;
rnk = max(lft.rnk,rht.rnk) +1;
bis = rht.rnk -lft.rnk;
sum = pow(val,cnt);
if (lft != nl)
sum = sum(sum,lft.sum);
if (rht != nl)
sum = sum(sum,rht.sum);
}
}
V pow(V v,int cnt){ return null; }
V sum(V v0,V v1){ return null; }
}
class Node{
Node par;
int c;
int cnt = 0;
Node[] cld = new Node[26];
public Node(Node par,int c){
this.par = par;
this.c = c;
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (Object e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int[] A = in.it(N);
int M = 200_100;
Object solve(){
int[] cnt = new int[M +1];
for (var a:A)
cnt[a]++;
long[] dp = new long[1];
dp[0] = 1;
for (int a = 1;a <= M;a++) {
int N2 = dp.length +cnt[a];
long[] dp2 = new long[N2];
for (int p = 0;p < dp.length;p++) {
dp2[cnt[a]] += dp[p];
if (cnt[a] +p /2 +1 < N2)
dp2[cnt[a] +p /2 +1] += mod -dp[p];
}
dp2[0] %= mod;
for (int i = 0;i +1 < N2;i++) {
dp2[i +1] += dp2[i];
dp2[i +1] %= mod;
}
int l = dp2.length;
while (dp2[l -1] == 0)
l--;
dp = copyOf(dp2,l);
}
long ans = 0;
for (var d:dp)
ans += d;
return ans %= mod;
}
private Object solve(int[] A){
String fir = "First";
String sec = "Second";
int N = A.length;
if (N %2 == 1)
return sec;
Set<Integer> set = new HashSet<>();
for (var a:A)
if (!set.add(a))
set.remove(a);
return set.size() == 0 ? sec : fir;
}
}
class AVLTree<V> {
@Override
public String toString(){
List<String> list = new ArrayList<>();
for (int i = 0;i < size();i++) {
V ee = get(i);
list.add(ee.getClass().isArray() ? Arrays.toString((long[]) ee) : ee.toString());
}
return list.toString();
}
private V e;
private Node nl;
private Comparator<V> cmp;
@SuppressWarnings("unchecked")
AVLTree(V e){ this((Comparator<V>) Comparator.naturalOrder(),e); }
@SuppressWarnings("unchecked")
AVLTree(){ this((Comparator<V>) Comparator.naturalOrder(),null); }
<U extends Comparable<U>> AVLTree(Function<V, U> f,V e){ this(Comparator.comparing(f),e); }
<U extends Comparable<U>> AVLTree(Function<V, U> f){ this(Comparator.comparing(f),null); }
protected AVLTree(Comparator<V> cmp,V e){
this.e = e;
nl = new Node(null);
nl.par = nl.lft = nl.rht = nl;
nl.sz = nl.cnt = nl.rnk = 0;
this.cmp = cmp;
}
void add(V v){
if (nl.rht == nl) {
nl.cld(1,new Node(v));
return;
}
Node nd = nl.rht;
for (int c;true;nd = nd.cld(c))
if ((c = cmp.compare(v,nd.val)) == 0) {
nd.cnt++;
break;
} else if (nd.cld(c) == nl) {
nd.cld(c,new Node(v));
break;
}
balance(nd);
}
V get(int k){
assert k < size();
for (var nd = nl.rht;true;)
if (k < nd.lft.sz)
nd = nd.lft;
else if (k < nd.lft.sz +nd.cnt)
return nd.val;
else {
k -= nd.lft.sz +nd.cnt;
nd = nd.rht;
}
}
V sum(int k){
assert k <= size();
V ret = e;
for (var nd = nl.rht;true;)
if (k == 0)
return ret;
else if (k <= nd.lft.sz)
nd = nd.lft;
else if (k <= nd.lft.sz +nd.cnt)
return sum(sum(ret,nd.lft == nl ? e : nd.lft.sum),pow(nd.val,k -nd.lft.sz));
else {
ret = sum(sum(ret,nd.lft == nl ? e : nd.lft.sum),pow(nd.val,nd.cnt));
k -= nd.lft.sz +nd.cnt;
nd = nd.rht;
}
}
boolean remove(V v){
Node nd;
if ((nd = node(v)) == nl)
return false;
delete(nd);
return true;
}
V peek(){ return first(); }
V first(){ return end(nl.rht,-1).val; }
V last(){ return end(nl.rht,1).val; }
V floor(V v){ return near(nl.rht,v,2,1).val; }
V ceiling(V v){ return near(nl.rht,v,2,-1).val; }
V lower(V v){ return near(nl.rht,v,0,1).val; }
V higher(V v){ return near(nl.rht,v,0,-1).val; }
V poll(){ return pollFirst(); }
V pollFirst(){ return poll(end(nl.rht,-1)); }
V pollLast(){ return poll(end(nl.rht,1)); }
V pollFloor(V v){ return poll(near(nl.rht,v,2,1)); }
V pollCeiling(V v){ return poll(near(nl.rht,v,2,-1)); }
V pollLower(V v){ return poll(near(nl.rht,v,0,1)); }
V pollHigher(V v){ return poll(near(nl.rht,v,0,-1)); }
V poll(Node nd){
V ret = nd.val;
delete(nd);
return ret;
}
int cnt(V v){ return node(v).cnt; }
boolean contains(V v){ return v != null && node(v) != nl; }
int size(){ return nl.rht == nl ? 0 : nl.rht.sz; }
boolean isEmpty(){ return nl.rht == nl; }
int lowerBound(V v){ return bound(v,0); }
int upperBound(V v){ return bound(v,1); }
private int bound(V v,int u){
var nd = nl.rht;
for (int ret = 0,c;true;)
if (nd == nl || (c = cmp.compare(v,nd.val)) == 0)
return ret +u *nd.cnt +nd.lft.sz;
else if (c < 0)
nd = nd.lft;
else if (0 < c) {
ret += nd.lft.sz +nd.cnt;
nd = nd.rht;
}
}
private void delete(Node nd){
if (nd == nl)
return;
if (1 < nd.cnt) {
nd.cnt--;
balance(nd);
return;
}
if (nd.lft != nl && nd.rht != nl) {
Node rep = end(nd.rht,-1);
nd.ovr(rep);
nd = rep;
}
balance(nd.par.cld(nd.par.lft == nd ? -1 : 1,nd.lft != nl ? nd.lft : nd.rht));
}
private Node end(Node nd,int c){
while (nd.cld(c) != nl)
nd = nd.cld(c);
return nd;
}
private Node near(Node nd,V v,int eq,int l){
var ret = nl;
for (int c;nd != nl;nd = nd.cld(c *l))
if ((c = cmp.compare(v,nd.val) *l) >= 0)
if (nd.cld(l) == nl || c == (eq ^2))
return nd;
else
ret = nd;
return ret;
}
private Node node(V v){
assert v != null;
var ret = near(nl.rht,v,2,1);
return Objects.equals(v,ret.val) ? ret : nl;
}
private void balance(Node nd){
while (nd != nl) {
nd.upd();
var par = nd.par;
if (abs(nd.bis) > 1) {
int c = par.lft == nd ? -1 : 1;
nd = nd.bis < 0
? nd.lft.bis > 0 ? rotate2(nd,1) : rotate1(nd,1)
: nd.rht.bis < 0 ? rotate2(nd,-1) : rotate1(nd,-1);
par.cld(c,nd);
}
nd = par;
}
}
private Node rotate1(Node u,int c){
var v = u.cld(-c);
u.cld(-c,v.cld(c)).upd();
v.cld(c,u).upd();
return v;
}
private Node rotate2(Node u,int c){
var v = u.cld(-c);
var w = v.cld(c);
u.cld(-c,w.cld(c)).upd();
v.cld(c,w.cld(-c)).upd();
w.cld(-c,v).cld(c,u).upd();
return w;
}
private class Node{
int sz,cnt,rnk,bis;
V val,sum;
Node par,lft,rht;
Node(V val){
sz = cnt = rnk = 1;
this.val = sum = val;
par = lft = rht = nl;
}
Node cld(int c){ return c < 0 ? lft : rht; }
Node cld(int c,Node nd){
if (c < 0)
lft = nd;
else
rht = nd;
nd.par = this;
return this;
}
void ovr(Node nd){
cnt = nd.cnt;
val = nd.val;
nd.cnt = 1;
}
void upd(){
sz = lft.sz +rht.sz +cnt;
rnk = max(lft.rnk,rht.rnk) +1;
bis = rht.rnk -lft.rnk;
sum = pow(val,cnt);
if (lft != nl)
sum = sum(sum,lft.sum);
if (rht != nl)
sum = sum(sum,rht.sum);
}
}
V pow(V v,int cnt){ return null; }
V sum(V v0,V v1){ return null; }
}
class Node{
Node par;
int c;
int cnt = 0;
Node[] cld = new Node[26];
public Node(Node par,int c){
this.par = par;
this.c = c;
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
int[][] qry(int Q){ return Util.arr(new int[Q][],i -> new int[]{idx(), idx(), i}); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (Object e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
}
| ConDefects/ConDefects/Code/arc160_c/Java/43938671 |
condefects-java_data_1602 | import java.util.*;
@SuppressWarnings("unused")
public class Main {
private static void solve() {
int n = ni();
int[] a = na(n);
Arrays.sort(a);
int m = 2 * 100000 + 10;
int[] cnt = new int[m];
for (int v : a) {
cnt[v]++;
}
long[] dp = { 1 };
int mod = 998244353;
long ret = 1;
for (int i = 1; i <= m; i++) {
if (i == m || (cnt[i] + dp.length - 1) / 2 == 0) {
ret *= Arrays.stream(dp).sum() % mod;
ret %= mod;
dp = new long[] { 1 };
continue;
}
int k = (cnt[i] + dp.length - 1) / 2;
long[] ndp = new long[k + 1];
long s = 0;
int p = dp.length - 1;
for (int j = k; j >= 0; j--) {
int need = Math.max(0, j * 2 - cnt[i]);
while (p >= need) {
s += dp[p];
s %= mod;
p--;
}
ndp[j] = s;
}
dp = ndp;
}
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[] a = na(n);
Arrays.sort(a);
int m = 3 * 100000 + 10;
int[] cnt = new int[m];
for (int v : a) {
cnt[v]++;
}
long[] dp = { 1 };
int mod = 998244353;
long ret = 1;
for (int i = 1; i <= m; i++) {
if (i == m || (cnt[i] + dp.length - 1) / 2 == 0) {
ret *= Arrays.stream(dp).sum() % mod;
ret %= mod;
dp = new long[] { 1 };
continue;
}
int k = (cnt[i] + dp.length - 1) / 2;
long[] ndp = new long[k + 1];
long s = 0;
int p = dp.length - 1;
for (int j = k; j >= 0; j--) {
int need = Math.max(0, j * 2 - cnt[i]);
while (p >= need) {
s += dp[p];
s %= mod;
p--;
}
ndp[j] = s;
}
dp = ndp;
}
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/arc160_c/Java/41431769 |
condefects-java_data_1603 | import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
new Main().run();
}
class SegTree {
int n;
int[] v;
public SegTree(int n_) {
n = Integer.highestOneBit(n_) * 2;
v = new int[2 * n];
}
void set(int k, int val) {
int pos = id(k, k + 1);
v[pos] = val;
while (pos != id(0, n)) {
pos /= 2;
v[pos] = v[2 * pos] + v[2 * pos + 1];
}
}
int id(int a, int b) {
int w = Integer.lowestOneBit(a ^ b);
return n / w + a / w;
}
int query(int a, int b) {
if (b - a <= 0) return 0;
int ma = a + Integer.lowestOneBit(a);
int mb = b - Integer.lowestOneBit(b);
if (a < ma && ma <= b) {
return v[id(a, ma)] + query(ma, b);
} else {
return query(a, mb) + v[id(mb, b)];
}
}
int kth(int k) {
int a = 0;
int b = n;
while (b - a != 1) {
int m = (a + b) /2;
if (v[id(a, m)] >= k) {
b = m;
} else {
k -= v[id(a, m)];
a = m;
}
}
return a;
}
}
long mod = 998244353;
void run() throws FileNotFoundException {
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; ++i) {
A[i] = sc.nextInt();
}
int MAX = 200000;
long[][] dp = new long[MAX + 1][];
int[] cnt = new int[MAX + 1];
for (int i = 0; i < N; ++i) {
cnt[A[i]]++;
}
dp[0] = new long[1];
dp[0][0] = 1;
for (int i = 0; i < MAX; ++i) {
int nz = (dp[i].length + cnt[i]) / 2;
dp[i + 1] = new long[nz + 1];
for (int carry = 0; carry < dp[i].length; ++carry) {
int num = cnt[i] + carry;
dp[i + 1][num / 2] += dp[i][carry];
dp[i + 1][num / 2] %= mod;
}
for (int carry = dp[i + 1].length - 1; carry >= 1; --carry) {
dp[i + 1][carry - 1] += dp[i + 1][carry];
dp[i + 1][carry - 1] %= mod;
}
}
long ans = 0;
for (int i = 0; i < dp[MAX].length; ++i) {
ans += dp[MAX][i];
ans %= mod;
}
System.out.println(ans);
pw.close();
}
void tr(Object... objects) {
System.out.println(Arrays.deepToString(objects));
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
return (int) nextLong();
}
}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
new Main().run();
}
class SegTree {
int n;
int[] v;
public SegTree(int n_) {
n = Integer.highestOneBit(n_) * 2;
v = new int[2 * n];
}
void set(int k, int val) {
int pos = id(k, k + 1);
v[pos] = val;
while (pos != id(0, n)) {
pos /= 2;
v[pos] = v[2 * pos] + v[2 * pos + 1];
}
}
int id(int a, int b) {
int w = Integer.lowestOneBit(a ^ b);
return n / w + a / w;
}
int query(int a, int b) {
if (b - a <= 0) return 0;
int ma = a + Integer.lowestOneBit(a);
int mb = b - Integer.lowestOneBit(b);
if (a < ma && ma <= b) {
return v[id(a, ma)] + query(ma, b);
} else {
return query(a, mb) + v[id(mb, b)];
}
}
int kth(int k) {
int a = 0;
int b = n;
while (b - a != 1) {
int m = (a + b) /2;
if (v[id(a, m)] >= k) {
b = m;
} else {
k -= v[id(a, m)];
a = m;
}
}
return a;
}
}
long mod = 998244353;
void run() throws FileNotFoundException {
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; ++i) {
A[i] = sc.nextInt();
}
int MAX = 200100;
long[][] dp = new long[MAX + 1][];
int[] cnt = new int[MAX + 1];
for (int i = 0; i < N; ++i) {
cnt[A[i]]++;
}
dp[0] = new long[1];
dp[0][0] = 1;
for (int i = 0; i < MAX; ++i) {
int nz = (dp[i].length + cnt[i]) / 2;
dp[i + 1] = new long[nz + 1];
for (int carry = 0; carry < dp[i].length; ++carry) {
int num = cnt[i] + carry;
dp[i + 1][num / 2] += dp[i][carry];
dp[i + 1][num / 2] %= mod;
}
for (int carry = dp[i + 1].length - 1; carry >= 1; --carry) {
dp[i + 1][carry - 1] += dp[i + 1][carry];
dp[i + 1][carry - 1] %= mod;
}
}
long ans = 0;
for (int i = 0; i < dp[MAX].length; ++i) {
ans += dp[MAX][i];
ans %= mod;
}
System.out.println(ans);
pw.close();
}
void tr(Object... objects) {
System.out.println(Arrays.deepToString(objects));
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
return (int) nextLong();
}
} | ConDefects/ConDefects/Code/arc160_c/Java/41420626 |
condefects-java_data_1604 |
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int p[] = Arrays.stream(new int[n]).map(e -> sc.nextInt() - 1).toArray();
String str = sc.next();
int mod = 998244353;
boolean used[] = new boolean[n];
//全員右から取らせる。
long resultR = 1;
for(int i = 0; i < n; i++) {
if(used[right(p[i], n)]) {
resultR = 0;
break;
}
if(str.charAt(i) == '?'){
if(used[left(p[i], n)]) {
resultR *= 2;
resultR %= mod;
}
// else {
// resultR = 0;
// break;
// }
}
if(str.charAt(p[i]) == 'L' && !used[left(p[i], n)]) {
resultR = 0;
break;
}
used[right(p[i], n)] = true;
}
//全員左から取らせる。
long resultL = 1;
Arrays.fill(used, false);
for(int i = 0; i < n; i++) {
if(used[left(p[i], n)]) {
resultL = 0;
break;
}
if(str.charAt(p[i]) == '?' && used[right(p[i], n)]) {
resultL *= 2;
resultL %= mod;
}
if(str.charAt(p[i]) == 'R' && !used[right(p[i], n)]) {
resultL = 0;
break;
}
used[left(p[i], n)] = true;
}
// System.out.println(resultR + " " + resultL);
System.out.println((resultR + resultL) % mod);
}
static int right(int pos, int n) {
return pos;
}
static int left(int pos, int n) {
return (pos + n - 1) % n;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int p[] = Arrays.stream(new int[n]).map(e -> sc.nextInt() - 1).toArray();
String str = sc.next();
int mod = 998244353;
boolean used[] = new boolean[n];
//全員右から取らせる。
long resultR = 1;
for(int i = 0; i < n; i++) {
if(used[right(p[i], n)]) {
resultR = 0;
break;
}
if(str.charAt(p[i]) == '?'){
if(used[left(p[i], n)]) {
resultR *= 2;
resultR %= mod;
}
// else {
// resultR = 0;
// break;
// }
}
if(str.charAt(p[i]) == 'L' && !used[left(p[i], n)]) {
resultR = 0;
break;
}
used[right(p[i], n)] = true;
}
//全員左から取らせる。
long resultL = 1;
Arrays.fill(used, false);
for(int i = 0; i < n; i++) {
if(used[left(p[i], n)]) {
resultL = 0;
break;
}
if(str.charAt(p[i]) == '?' && used[right(p[i], n)]) {
resultL *= 2;
resultL %= mod;
}
if(str.charAt(p[i]) == 'R' && !used[right(p[i], n)]) {
resultL = 0;
break;
}
used[left(p[i], n)] = true;
}
// System.out.println(resultR + " " + resultL);
System.out.println((resultR + resultL) % mod);
}
static int right(int pos, int n) {
return pos;
}
static int left(int pos, int n) {
return (pos + n - 1) % n;
}
}
| ConDefects/ConDefects/Code/arc175_a/Java/52257994 |
condefects-java_data_1605 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
int[] ps = new int[n];
for(int i = 0; i < n; i++) {
ps[i] = Integer.parseInt(sc.next());
ps[i]--;
}
char[] s = sc.next().toCharArray();
final int mod = 998244353;
int ans_left = 1;
int ans_right = 1;
boolean[] took_spoon = new boolean[n];
for(int p : ps) {
if(took_spoon[(p + 1) % n]) {
if(s[p] == '?') ans_left *= 2;
} else {
if(s[p] == 'R') ans_left *= 0;
}
ans_left %= mod;
if(took_spoon[(p + n - 1) % n]) {
if(s[p] == '?') ans_right *= 2;
} else {
if(s[p] == 'L') ans_right *= 0;
}
ans_right %= mod;
took_spoon[p] = true;
}
System.out.println(ans_left + ans_right);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
int[] ps = new int[n];
for(int i = 0; i < n; i++) {
ps[i] = Integer.parseInt(sc.next());
ps[i]--;
}
char[] s = sc.next().toCharArray();
final int mod = 998244353;
int ans_left = 1;
int ans_right = 1;
boolean[] took_spoon = new boolean[n];
for(int p : ps) {
if(took_spoon[(p + 1) % n]) {
if(s[p] == '?') ans_left *= 2;
} else {
if(s[p] == 'R') ans_left *= 0;
}
ans_left %= mod;
if(took_spoon[(p + n - 1) % n]) {
if(s[p] == '?') ans_right *= 2;
} else {
if(s[p] == 'L') ans_right *= 0;
}
ans_right %= mod;
took_spoon[p] = true;
}
System.out.println((ans_left + ans_right) % mod);
}
}
}
| ConDefects/ConDefects/Code/arc175_a/Java/52288441 |
condefects-java_data_1606 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class Main {
static FastReader sc = new FastReader();
static long mod=998244353;
// --------------------------------------start-------------------------------------------//
public static void solve(int tt) {
int n=sc.nextInt();
int arr[]=arrInput(n);
String in=sc.next();
boolean used[]=new boolean[n+1];
long l=1;
long r=1;
for(int i:arr){
if(used[(i+1)%n]){
if(in.charAt(i-1)=='?'){
l=(l%mod*2)%mod;
}
}else{
if(in.charAt(i-1)=='R'){
l=0;
}
}
if(used[(i-1)%n]){
if(in.charAt(i-1)=='?'){
r=(r%mod*2)%mod;
}
}else{
if(in.charAt(i-1)=='L'){
r=0;
}
}
used[i]=true;
}
System.out.println((r%mod+l%mod)%mod);
}
public static void main(String[] args) {
int t= 1;//sc.nextInt();
while(t-->0){
solve(t);
}
}
// public static long getSum(int r){
// long sum=0;
// int pp=r;
// while(pp>0){
// sum+=fenwickTree[pp];
// pp-=pp&-pp;
// }
// return sum;
// }
// public static void update(int k,long v){
// // long value=fenwickTree[k];
// while(k<=n){
// fenwickTree[k]+=(v);
// k+=k&-k;
// }
// }
static long factorial(long n) {
long result = 1;
for (long i = 1; i <= n; i++) {
result *= i;
if (result > 998244353) {
result -= 998244353;
}
}
return result % 998244353;
}
static int modFact(int n, int p) {
if (n >= p)
return 0;
int result = 1;
for (int i = 1; i <= n; i++)
result = (result * i) % p;
return result;
}
// Function to calculate combination
// static long combination(long n, long r) {
// return factorial(n) / (factorial(r) * factorial(n - r));
// }
// public static long binarySearch(ArrayList<Long> arr, long target) {
// int left = 0, right = arr.size() - 1;
// while (left <= right) {
// int mid = left + (right - left) / 2;
// if (arr.get(mid) == target) {
// return 0;
// } else if (arr.get(mid) < target) {
// left = mid + 1;
// } else {
// right = mid - 1;
// }
// }
// if (left == 0) {
// return Math.abs(target - arr.get(0));
// } else if (left == arr.size()) {
// return Math.abs(arr.get(arr.size() - 1) - target);
// } else {
// long diff1 = Math.abs(target - arr.get(left - 1));
// long diff2 = Math.abs(arr.get(left) - target);
// return Math.min(diff1, diff2);
// }
// }
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
if (st.hasMoreTokens()) {
str = st.nextToken("\n");
} else {
str = br.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
// public static int maxFrequencyNumber(int[] arr) {
// if (arr.length == 0)
// return -1;
// int maxFreq = 0;
// int number = -1;
// HashMap<Integer, Integer> map = new HashMap<>();
// for (int j : arr) {
// if (map.containsKey(j)) {
// map.put(j, map.get(j) + 1);
// } else {
// map.put(j, 1);
// }
// }
// // using set data structure
// Set<Integer> keySet = map.keySet();
// for (Integer i : keySet) {
// if (map.get(i) > maxFreq) {
// number = i;
// maxFreq = map.get(i);
// }
// }
// return number;
// }
// public static boolean isPrime(long n) {
// if (n <= 1)
// return false;
// // Check if n=2 or n=3
// if (n == 2 || n == 3)
// return true;
// // Check whether n is divisible by 2 or 3
// if (n % 2 == 0 || n % 3 == 0)
// return false;
// // Check from 5 to square root of n
// // Iterate i by (i+6)
// for (int i = 5; i <= Math.sqrt(n); i = i + 6)
// if (n % i == 0 || n % (i + 2) == 0)
// return false;
// return true;
// }
// public static long lcm(int x, int y) {
// int i;
// int a = Math.max(x, y);
// for (i = a; i <= x * y; i = i + a) {
// if (i % x == 0 && i % y == 0)
// break;
// }
// return i;
// }
static long gcd(long a, long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// static ArrayList<Long> getFactors(long num) {
// ArrayList<Long> factors = new ArrayList<Long>();
// int i;
// boolean flag = false;
// for (i = 1; i <= Math.sqrt(num); i++) {
// if (num % i == 0)
// factors.add((long) i);
// if (i == num / i)
// flag = true;
// }
// if (flag)
// i -= 2;
// // printing pairs
// for (; i >= 1; i--) {
// if (num % i == 0)
// factors.add((long) (num / i));
// }
// return factors;
// }
// static int fact(int number) {
// int f = 1;
// int j = 1;
// while (j <= number) {
// f = f * j;
// j++;
// }
// return f;
// }
public static int[] arrInput(int n) {
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
return arr;
}
public static void arrOutput(int[] arr) {
StringBuilder out = new StringBuilder("");
for (int i = 0; i < arr.length; i++) {
out.append(arr[i] + " ");
}
System.out.println(out);
}
// public static boolean isInt(double d) {
// return d % 1 == 0;
// }
// public static boolean isPowerOfTwo(int n) {
// return (int) (Math.ceil((Math.log(n) / Math.log(2)))) == (int)
// (Math.floor(((Math.log(n) / Math.log(2)))));
// }
public static ArrayList<Integer> primeFactorization(int numbers) {
int n = numbers;
ArrayList<Integer> factors = new ArrayList<Integer>();
for (int i = 2; i <= n / i; i++) {
while (n % i == 0) {
factors.add(i);
n /= i;
}
}
if (n > 1) {
factors.add(n);
}
return factors;
}
public static int calculate(int l, int r, int segTree[], int n) {
l += n - 1;
r += n - 1;
int ans = segTree[r];
while (l <= r) {
if (r % 2 == 0) {
ans &= segTree[r];
r--;
}
if (l % 2 == 1) {
ans &= segTree[l];
l++;
}
r = r >> 1;
l = l >> 1;
}
return ans;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class Main {
static FastReader sc = new FastReader();
static long mod=998244353;
// --------------------------------------start-------------------------------------------//
public static void solve(int tt) {
int n=sc.nextInt();
int arr[]=arrInput(n);
String in=sc.next();
boolean used[]=new boolean[n+1];
long l=1;
long r=1;
for(int i:arr){
if(used[(i+1)%n]){
if(in.charAt(i-1)=='?'){
l=(l%mod*2)%mod;
}
}else{
if(in.charAt(i-1)=='R'){
l=0;
}
}
if(used[(i-1)%n]){
if(in.charAt(i-1)=='?'){
r=(r%mod*2)%mod;
}
}else{
if(in.charAt(i-1)=='L'){
r=0;
}
}
used[i%n]=true;
}
System.out.println((r%mod+l%mod)%mod);
}
public static void main(String[] args) {
int t= 1;//sc.nextInt();
while(t-->0){
solve(t);
}
}
// public static long getSum(int r){
// long sum=0;
// int pp=r;
// while(pp>0){
// sum+=fenwickTree[pp];
// pp-=pp&-pp;
// }
// return sum;
// }
// public static void update(int k,long v){
// // long value=fenwickTree[k];
// while(k<=n){
// fenwickTree[k]+=(v);
// k+=k&-k;
// }
// }
static long factorial(long n) {
long result = 1;
for (long i = 1; i <= n; i++) {
result *= i;
if (result > 998244353) {
result -= 998244353;
}
}
return result % 998244353;
}
static int modFact(int n, int p) {
if (n >= p)
return 0;
int result = 1;
for (int i = 1; i <= n; i++)
result = (result * i) % p;
return result;
}
// Function to calculate combination
// static long combination(long n, long r) {
// return factorial(n) / (factorial(r) * factorial(n - r));
// }
// public static long binarySearch(ArrayList<Long> arr, long target) {
// int left = 0, right = arr.size() - 1;
// while (left <= right) {
// int mid = left + (right - left) / 2;
// if (arr.get(mid) == target) {
// return 0;
// } else if (arr.get(mid) < target) {
// left = mid + 1;
// } else {
// right = mid - 1;
// }
// }
// if (left == 0) {
// return Math.abs(target - arr.get(0));
// } else if (left == arr.size()) {
// return Math.abs(arr.get(arr.size() - 1) - target);
// } else {
// long diff1 = Math.abs(target - arr.get(left - 1));
// long diff2 = Math.abs(arr.get(left) - target);
// return Math.min(diff1, diff2);
// }
// }
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
if (st.hasMoreTokens()) {
str = st.nextToken("\n");
} else {
str = br.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
// public static int maxFrequencyNumber(int[] arr) {
// if (arr.length == 0)
// return -1;
// int maxFreq = 0;
// int number = -1;
// HashMap<Integer, Integer> map = new HashMap<>();
// for (int j : arr) {
// if (map.containsKey(j)) {
// map.put(j, map.get(j) + 1);
// } else {
// map.put(j, 1);
// }
// }
// // using set data structure
// Set<Integer> keySet = map.keySet();
// for (Integer i : keySet) {
// if (map.get(i) > maxFreq) {
// number = i;
// maxFreq = map.get(i);
// }
// }
// return number;
// }
// public static boolean isPrime(long n) {
// if (n <= 1)
// return false;
// // Check if n=2 or n=3
// if (n == 2 || n == 3)
// return true;
// // Check whether n is divisible by 2 or 3
// if (n % 2 == 0 || n % 3 == 0)
// return false;
// // Check from 5 to square root of n
// // Iterate i by (i+6)
// for (int i = 5; i <= Math.sqrt(n); i = i + 6)
// if (n % i == 0 || n % (i + 2) == 0)
// return false;
// return true;
// }
// public static long lcm(int x, int y) {
// int i;
// int a = Math.max(x, y);
// for (i = a; i <= x * y; i = i + a) {
// if (i % x == 0 && i % y == 0)
// break;
// }
// return i;
// }
static long gcd(long a, long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// static ArrayList<Long> getFactors(long num) {
// ArrayList<Long> factors = new ArrayList<Long>();
// int i;
// boolean flag = false;
// for (i = 1; i <= Math.sqrt(num); i++) {
// if (num % i == 0)
// factors.add((long) i);
// if (i == num / i)
// flag = true;
// }
// if (flag)
// i -= 2;
// // printing pairs
// for (; i >= 1; i--) {
// if (num % i == 0)
// factors.add((long) (num / i));
// }
// return factors;
// }
// static int fact(int number) {
// int f = 1;
// int j = 1;
// while (j <= number) {
// f = f * j;
// j++;
// }
// return f;
// }
public static int[] arrInput(int n) {
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
return arr;
}
public static void arrOutput(int[] arr) {
StringBuilder out = new StringBuilder("");
for (int i = 0; i < arr.length; i++) {
out.append(arr[i] + " ");
}
System.out.println(out);
}
// public static boolean isInt(double d) {
// return d % 1 == 0;
// }
// public static boolean isPowerOfTwo(int n) {
// return (int) (Math.ceil((Math.log(n) / Math.log(2)))) == (int)
// (Math.floor(((Math.log(n) / Math.log(2)))));
// }
public static ArrayList<Integer> primeFactorization(int numbers) {
int n = numbers;
ArrayList<Integer> factors = new ArrayList<Integer>();
for (int i = 2; i <= n / i; i++) {
while (n % i == 0) {
factors.add(i);
n /= i;
}
}
if (n > 1) {
factors.add(n);
}
return factors;
}
public static int calculate(int l, int r, int segTree[], int n) {
l += n - 1;
r += n - 1;
int ans = segTree[r];
while (l <= r) {
if (r % 2 == 0) {
ans &= segTree[r];
r--;
}
if (l % 2 == 1) {
ans &= segTree[l];
l++;
}
r = r >> 1;
l = l >> 1;
}
return ans;
}
} | ConDefects/ConDefects/Code/arc175_a/Java/51663025 |
condefects-java_data_1607 | import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.BiFunction;
public class Main{
static Scanner scn = new Scanner(System.in);
static FastScanner sc = new FastScanner();
static CheckingScanner cs = new CheckingScanner();
static Mathplus mp = new Mathplus();
static PrintWriter ot = new PrintWriter(System.out);
static Random rand = new Random();
static StringManager sm = new StringManager(" ");
static int mod = 1000000007;
static long modmod = (long)mod * mod;
static long inf = (long)3e18;
static int[] dx = {0,1,0,-1};
static int[] dy = {1,0,-1,0};
static int[] dx8 = {-1,-1,-1,0,0,1,1,1};
static int[] dy8 = {-1,0,1,-1,1,-1,0,1};
static char[] dc = {'R','D','L','U'};
static BiFunction<Integer,Integer,Integer> fmax = (a,b)-> {return Math.max(a,b);};
static BiFunction<Integer,Integer,Integer> fmin = (a,b)-> {return Math.min(a,b);};
static BiFunction<Integer,Integer,Integer> fsum = (a,b)-> {return a+b;};
static BiFunction<Long,Long,Long> fmaxl = (a,b)-> {return Math.max(a,b);};
static BiFunction<Long,Long,Long> fminl = (a,b)-> {return Math.min(a,b);};
static BiFunction<Long,Long,Long> fsuml = (a,b)-> {return a+b;};
static BiFunction<Integer,Integer,Integer> fadd = fsum;
static BiFunction<Integer,Integer,Integer> fupd = (a,b)-> {return b;};
static BiFunction<Long,Long,Long> faddl = fsuml;
static BiFunction<Long,Long,Long> fupdl = (a,b)-> {return b;};
static BiFunction<Long,Long,Long> fmsuml = (a,b)-> {return (a+b)%mod;};
static BiFunction<Long,Long,Long> fmmull = (a,b)-> {return (a*b)%mod;};
static String sp = " ";
public static void main(String[] args) throws IOException {
mod = 998244353;
mp.mod = mod;
long hf = mp.rev(2);
long[] A = new long[1000002];
long[] B = new long[1000002];
A[2] = 1;
for(int i=3;i<=1000001;i++) {
A[i] = A[i-1] * (2*i-5) % mod * hf % mod;
}
B[2] = 1;
for(int i=3;i<=1000001;i++) {
B[i] = B[i-1] * (i-1) % mod;
}
int T = sc.nextInt();
for(int i=0;i<T;i++) {
int N = sc.nextInt();
long NN = N;
long ans = mp.pow(4, N-2) * (NN * NN - 3) % mod;
ans *= A[N];
ans %= mod;
ans *= mp.rev(B[N]);
ans %= mod;
ot.println(ans);
}
ot.flush();
}
}
class StringLengthComparator implements Comparator<String>{
public int compare(String P, String Q) {
return (int) Math.signum(P.length()-Q.length());
}
}
class Point{
double x;
double y;
Point(double X,double Y){
x = X;
y = Y;
}
double atan(){
return Math.atan2(y,x);
}
double length() {
return Math.sqrt(x*x+y*y);
}
Point add(Point Q) {
return new Point(x+Q.x,y+Q.y);
}
Point sub(Point Q) {
return new Point(x-Q.x,y-Q.y);
}
Point mul(double d) {
return new Point(x*d,y*d);
}
Point div(double d) {
return new Point(x/d,y/d);
}
}
class Triangle{
double eps = 1e-7;
Point A;
Point B;
Point C;
double edgeA;
double edgeB;
double edgeC;
double argA;
double argB;
double argC;
Triangle(Point a,Point b,Point c){
A = a;
B = b;
C = c;
edgeA = b.sub(c).length();
edgeB = c.sub(a).length();
edgeC = a.sub(b).length();
argA = Math.acos(getcos(edgeA,edgeB,edgeC));
argB = Math.acos(getcos(edgeB,edgeC,edgeA));
argC = Math.acos(getcos(edgeC,edgeA,edgeB));
}
double getcos(double a,double b,double c){
return (b*b+c*c-a*a)/(2*b*c);
}
Point outheart() {
return A.mul(Math.sin(2*argA)).add(B.mul(Math.sin(2*argB))).add(C.mul(Math.sin(2*argC))).div(Math.sin(2*argA)+Math.sin(2*argB)+Math.sin(2*argC));
}
}
class Slidemax{
int[] dat;
ArrayDeque<LongIntPair> q = new ArrayDeque<LongIntPair>();
long get() {
if(q.isEmpty()) return (long) -1e17;
return q.peek().a;
}
void remove() {
q.getFirst().b--;
if(q.getFirst().b==0)q.pollFirst();
}
void add(long x) {
int num = 1;
while(!q.isEmpty()&&q.peekLast().a<=x) {
num += q.peekLast().b;
q.pollLast();
}
q.addLast(new LongIntPair(x,num));
}
}
class Slidemin{
int[] dat;
int l = 0;
int r = -1;
ArrayDeque<LongIntPair> q = new ArrayDeque<LongIntPair>();
long get() {
if(q.isEmpty()) return (long)1e17;
return q.peek().a;
}
void remove() {
q.getFirst().b--;
if(q.getFirst().b==0)q.pollFirst();
}
void add(long x) {
int num = 1;
while(!q.isEmpty()&&q.peekLast().a>=x) {
num += q.peekLast().b;
q.pollLast();
}
q.addLast(new LongIntPair(x,num));
}
}
class Counter{
int[] cnt;
Counter(int M){
cnt = new int[M+1];
}
Counter(int M,int[] A){
cnt = new int[M+1];
for(int i=0;i<A.length;i++)add(A[i]);
}
void add(int e) {
cnt[e]++;
}
void remove(int e) {
cnt[e]--;
}
int count(int e) {
return cnt[e];
}
}
class MultiHashSet{
HashMap<Integer,Integer> set;
int size;
long sum;
MultiHashSet(){
set = new HashMap<Integer,Integer>();
size = 0;
sum = 0;
}
void add(int e){
if(set.containsKey(e))set.put(e,set.get(e)+1);
else set.put(e,1);
size++;
sum += e;
}
void remove(int e) {
set.put(e,set.get(e)-1);
if(set.get(e)==0)set.remove(e);
size--;
sum -= e;
}
boolean contains(int e) {
return set.containsKey(e);
}
boolean isEmpty() {
return set.isEmpty();
}
int count(int e) {
if(contains(e))return set.get(e);
else return 0;
}
Set<Integer> keyset(){
return set.keySet();
}
}
class MultiSet{
TreeMap<Integer,Integer> set;
long size;
long sum;
MultiSet(){
set = new TreeMap<Integer,Integer>();
size = 0;
sum = 0;
}
void add(int e){
if(set.containsKey(e))set.put(e,set.get(e)+1);
else set.put(e,1);
size++;
sum += e;
}
void addn(int e,int n){
if(set.containsKey(e))set.put(e,set.get(e)+n);
else set.put(e,n);
size += n;
sum += e*(long)n;
}
void remove(int e) {
set.put(e,set.get(e)-1);
if(set.get(e)==0)set.remove(e);
size--;
sum -= e;
}
void removeall(int e) {
if(!set.containsKey(e))return;
int n = count(e);
set.remove(e);
size -= n;
sum -= e*(long)n;
}
int first() {return set.firstKey();}
int last() {return set.lastKey();}
int lower(int e) {return set.lowerKey(e);}
int higher(int e) {return set.higherKey(e);}
int floor(int e) {return set.floorKey(e);}
int ceil(int e) {return set.ceilingKey(e);}
boolean contains(int e) {return set.containsKey(e);}
boolean isEmpty() {return set.isEmpty();}
int count(int e) {
if(contains(e))return set.get(e);
else return 0;
}
MultiSet marge(MultiSet T) {
if(size>T.size) {
while(!T.isEmpty()) {
add(T.first());
T.remove(T.first());
}
return this;
}else {
while(!isEmpty()) {
T.add(first());
remove(first());
}
return T;
}
}
Set<Integer> keyset(){
return set.keySet();
}
}
class MultiSetL{
TreeMap<Long,Integer> set;
int size;
long sum;
MultiSetL(){
set = new TreeMap<Long,Integer>();
size = 0;
sum = 0;
}
void add(long e){
if(set.containsKey(e))set.put(e,set.get(e)+1);
else set.put(e,1);
size++;
sum += e;
}
void remove(long e) {
set.put(e,set.get(e)-1);
if(set.get(e)==0)set.remove(e);
size--;
sum -= e;
}
long first() {return set.firstKey();}
long last() {return set.lastKey();}
long lower(long e) {return set.lowerKey(e);}
long higher(long e) {return set.higherKey(e);}
long floor(long e) {return set.floorKey(e);}
long ceil(long e) {return set.ceilingKey(e);}
boolean contains(long e) {return set.containsKey(e);}
boolean isEmpty() {return set.isEmpty();}
int count(long e) {
if(contains(e))return set.get(e);
else return 0;
}
MultiSetL marge(MultiSetL T) {
if(size>T.size) {
while(!T.isEmpty()) {
add(T.first());
T.remove(T.first());
}
return this;
}else {
while(!isEmpty()) {
T.add(first());
remove(first());
}
return T;
}
}
Set<Long> keyset(){
return set.keySet();
}
}
class GridGraph extends Graph{
int N;
int M;
String[] S;
HashMap<Character,Integer> map;
GridGraph(int n,int m,String[] s){
super(n*m);
N = n;
M = m;
S = s;
for(int i=0;i<n-1;i++) {
for(int j=0;j<m;j++) {
if(S[i].charAt(j)=='.'&&S[i+1].charAt(j)=='.') {
addWeightedEdge(toint(i,j),toint(i+1,j),1);
addWeightedEdge(toint(i+1,j),toint(i,j),1);
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m-1;j++) {
if(S[i].charAt(j)=='.'&&S[i].charAt(j+1)=='.') {
addWeightedEdge(toint(i,j),toint(i,j+1),1);
addWeightedEdge(toint(i,j+1),toint(i,j),1);
}
}
}
}
GridGraph(int n,int m,String[] s,char[] c){
super(n*m);
N = n;
M = m;
S = s;
map = new HashMap<Character,Integer>();
for(int i=0;i<n-1;i++) {
for(int j=0;j<m;j++) {
if(S[i].charAt(j)!=S[i+1].charAt(j)) {
addWeightedEdge(toint(i,j),toint(i+1,j),1);
addWeightedEdge(toint(i+1,j),toint(i,j),1);
}else {
addWeightedEdge(toint(i,j),toint(i+1,j),0);
addWeightedEdge(toint(i+1,j),toint(i,j),0);
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m-1;j++) {
if(S[i].charAt(j)!=S[i].charAt(j+1)) {
addWeightedEdge(toint(i,j),toint(i,j+1),1);
addWeightedEdge(toint(i,j+1),toint(i,j),1);
}else{
addWeightedEdge(toint(i,j),toint(i,j+1),0);
addWeightedEdge(toint(i,j+1),toint(i,j),0);
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i].charAt(j)==c[k])map.put(c[k],toint(i,j));
}
}
}
}
int toint(int i,int j) {
return i*M+j;
}
}
class StringManager{
ArrayList<Character> S;
static Mathplus mp;
static boolean calced;
static int base;
static long baserev;
ArrayList<Long> l;
StringManager(String s){
S = new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
S.add(s.charAt(i));
}
if(!calced) {
calced = true;
mp = new Mathplus();
base = 1000003;
baserev = mp.rev(base);
mp.buildpow(base,2000050);
mp.buildrevpow(base, 2000050);
}
l = new ArrayList<Long>();
l.add((long)S.get(0));
for(int i=1;i<S.size();i++) {
char c = S.get(i);
l.add((l.get(i-1) + mp.pow[i] * c)%mp.mod);
}
}
StringManager(String s,int b){
S = new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
S.add(s.charAt(i));
}
base = b;
if(!calced) {
calced = true;
mp = new Mathplus();
base = b;
baserev = mp.rev(base);
mp.buildpow(base,2000050);
mp.buildrevpow(base, 2000050);
}
l = new ArrayList<Long>();
l.add((long)S.get(0));
for(int i=1;i<S.size();i++) {
char c = S.get(i);
l.add((l.get(i-1) + mp.pow[i] * c)%mp.mod);
}
}
void add(char C){
int i = S.size();
S.add(C);
l.add((l.get(i-1) + mp.pow[i] * C)%mp.mod);
}
long gethash(int le,int ri) {
long res = l.get(ri);
if(le!=0) {
res -= l.get(le-1);
res += mp.mod;
res %= mp.mod;
res *= mp.revpow[le];
res %= mp.mod;
}
return res;
}
ArrayList<CIPair> runlength(String s){
ArrayList<CIPair> ret = new ArrayList<CIPair>();
s += ' ';
char bef = ' ';
int len = 0;
for(int i=0;i<s.length();i++) {
if(s.charAt(i)!=bef) {
if(bef != ' ')ret.add(new CIPair(bef,len));
len = 1;
}else {
len++;
}
bef = s.charAt(i);
}
return ret;
}
ArrayList<CIPair> runlength(ArrayList<Character> s){
ArrayList<CIPair> ret = new ArrayList<CIPair>();
s.add(' ');
char bef = ' ';
int len = 0;
for(int i=0;i<s.size();i++) {
if(s.get(i)!=bef) {
if(bef != ' ')ret.add(new CIPair(bef,len));
len = 1;
}else {
len++;
}
bef = s.get(i);
}
return ret;
}
boolean isPalindrome(String S) {
boolean b = true;
for(int i=0;i<S.length();i++) {
if(S.charAt(i)!=S.charAt(S.length()-1-i))b = false;
}
return b;
}
}
class BetterGridGraph{
int N;
int M;
char[][] S;
HashMap<Character,ArrayList<Integer>> map;
int[] dx = {0,1,0,-1};
int[] dy = {1,0,-1,0};
int[] dx6 = {0,1,0,-1,-1,1};
int[] dy6 = {1,0,-1,0,1,1};
char w;
char b = '#';
BetterGridGraph(int n,int m,String[] s,char[] c){
N = n;
M = m;
for(int i=0;i<s.length;i++) {
S[i] = s[i].toCharArray();
}
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,char[][] s,char[] c){
N = n;
M = m;
S = s;
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,String[] s,char[] c,char W,char B){
N = n;
M = m;
for(int i=0;i<s.length;i++) {
S[i] = s[i].toCharArray();
}
w = W;
b = B;
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,char[][] s,char[] c,char W,char B){
N = n;
M = m;
S = s;
w = W;
b = B;
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
int toint(int i,int j) {
return i*M+j;
}
ArrayList<Integer> getposlist(char c) {
return map.get(c);
}
int getpos(char c) {
return map.get(c).get(0);
}
int[] bfs(char C) {
int[] L = new int[N*M];
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
for(int i=0;i<N*M;i++){
L[i] = -1;
}
for(int s:map.get(C)) {
L[s] = 0;
Q.add(s);
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
int[] bfs6(char C) {
int[] L = new int[N*M];
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
for(int i=0;i<N*M;i++){
L[i] = -1;
}
for(int s:map.get(C)) {
L[s] = 0;
Q.add(s);
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<6;i++){
int x = v/M;
int y = v%M;
int nx = x+dx6[i];
int ny = y+dy6[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
int[] bfsb(int s) {
int[] L = new int[N*M];
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
for(int i=0;i<N*M;i++){
L[i] = -1;
}
Q.add(s);
L[s] = 0;
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)) {
int w = toint(nx,ny);
if(L[w]==-1){
if(S[x][y]==S[nx][ny]) {
L[w] = L[v];
Q.addFirst(w);
}else {
L[w] = L[v] + 1;
Q.addLast(w);
}
}
}
}
}
return L;
}
int[][] bfs2(char C,int K){
int[][] L = new int[N*M][K+1];
ArrayDeque<IntIntPair> Q = new ArrayDeque<IntIntPair>();
for(int i=0;i<N*M;i++){
for(int j=0;j<=K;j++) {
L[i][j] = 1000000007;
}
}
for(int s:map.get(C)) {
L[s][0] = 0;
Q.add(new IntIntPair(0,s));
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair v = Q.poll();
for(int i=0;i<4;i++){
int x = v.b/M;
int y = v.b%M;
int h = v.a;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int ni = toint(nx,ny);
int nh = S[nx][ny]==w?h+1:h;
if(nh>K) continue;
if(L[ni][nh]==1000000007){
L[ni][nh] = L[v.b][h]+1;
Q.add(new IntIntPair(nh,ni));
}
}
}
}
for(int i=0;i<N*M;i++) {
for(int j=1;j<=K;j++) {
L[i][j] = Math.min(L[i][j],L[i][j-1]);
}
}
return L;
}
int[] dijkstra(char C) {
int[] L = new int[N*M];
PriorityQueue<IntIntPair> Q = new PriorityQueue<IntIntPair>(new IntIntComparator());
for(int i=0;i<N*M;i++){
L[i] = -1;
}
for(int s:map.get(C)) {
L[s] = 0;
Q.add(new IntIntPair(0,s));
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair P = Q.poll();
int v = P.b;
int x = v/M;
int y = v%M;
for(int i=0;i<4;i++){
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1||L[w]>L[v] + (S[nx][ny]!='t'?S[nx][ny]-'0':0)){
L[w] = L[v] + (S[nx][ny]!='t'?S[nx][ny]-'0':0);
Q.add(new IntIntPair(L[w],w));
}
}
}
}
return L;
}
}
class IntGridGraph{
int N;
int M;
int[][] B;
int[] dx = {0,1,0,-1};
int[] dy = {1,0,-1,0};
BiFunction<Integer,Integer,Boolean> F;
IntGridGraph(int n,int m,int[][] b){
N = n;
M = m;
B = b;
}
IntGridGraph(int n,int m,int[][] b,BiFunction<Integer,Integer,Boolean> f){
N = n;
M = m;
B = b;
F = f;
}
int toint(int i,int j) {
return i*M+j;
}
int[] bfs(int s) {
int[] L = new int[N*M];
for(int i=0;i<N*M;i++){
L[i] = -1;
}
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&F.apply(B[x][y],B[nx][ny])) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
void bfs(int s,int[] L) {
if(L[s]!=-1) return;
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&F.apply(B[x][y],B[nx][ny])) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return;
}
int[][] bfs2(int s,int K){
int[][] L = new int[N*M][K+1];
for(int i=0;i<N*M;i++){
for(int j=0;j<=K;j++)
L[i][j] = 1000000007;
}
L[s][0] = 0;
PriorityQueue<IntIntPair> Q = new PriorityQueue<IntIntPair>(new IntIntComparator());
Q.add(new IntIntPair(0,s));
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair v = Q.poll();
for(int i=0;i<4;i++){
int x = v.b/M;
int y = v.b%M;
int h = v.a;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&F.apply(B[x][y],B[nx][ny])) {
int ni = toint(nx,ny);
int nh = h + B[nx][ny];
if(nh>K) continue;
if(L[ni][nh]==1000000007){
L[ni][nh] = L[v.b][h] + 1;
Q.add(new IntIntPair(nh,ni));
}
}
}
}
for(int i=0;i<N*M;i++) {
for(int j=1;j<=K;j++) {
L[i][j] = Math.min(L[i][j],L[i][j-1]);
}
}
return L;
}
}
class Trie{
int nodenumber = 1;
ArrayList<TrieNode> l;
Trie(){
l = new ArrayList<TrieNode>();
l.add(new TrieNode());
}
void add(String S,int W){
int now = 0;
for(int i=0;i<S.length();i++) {
TrieNode n = l.get(now);
char c = S.charAt(i);
if(n.Exist[c-'a']!=-1) {
now = n.Exist[c-'a'];
}else {
l.add(new TrieNode());
n.Exist[c-'a'] = nodenumber;
now = nodenumber;
nodenumber++;
}
}
l.get(now).weight = W;
}
void find(String S,int i,int[] dp) {
int now = 0;
dp[i+1] = Math.max(dp[i],dp[i+1]);
for(int j=0;;j++) {
TrieNode n = l.get(now);
dp[i+j] = Math.max(dp[i+j],dp[i]+n.weight);
int slook = i+j;
if(slook>=S.length())return;
char c = S.charAt(slook);
if(n.Exist[c-'a']==-1)return;
now = n.Exist[c-'a'];
}
}
}
class TrieNode{
int[] Exist = new int[26];
int weight = 0;
TrieNode(){
for(int i=0;i<26;i++) {
Exist[i] = -1;
}
}
}
class SizeComparator implements Comparator<Edge>{
int[] size;
SizeComparator(int[] s) {
size = s;
}
public int compare(Edge o1, Edge o2) {
return size[o1.to]-size[o2.to];
}
}
class ConvexHullTrick {
long[] A, B;
int len;
public ConvexHullTrick(int n) {
A = new long[n];
B = new long[n];
}
private boolean check(long a, long b) {
return (B[len - 2] - B[len - 1]) * (a - A[len - 1]) >= (B[len - 1] - b) * (A[len - 1] - A[len - 2]);
}
public void add(long a, long b) {
while (len >= 2 && check(a, b)) {
len--;
}
A[len] = a;
B[len] = b;
len++;
}
public long query(long x) {
int l = -1, r = len - 1;
while (r - l > 1) {
int mid = (r + l) / 2;
if (get(mid,x)>=get(mid+1,x)) {
l = mid;
} else {
r = mid;
}
}
return get(r,x);
}
private long get(int k, long x) {
return A[k] * x + B[k];
}
}
class Range{
long l;
long r;
long length;
Range(int L,int R){
l = L;
r = R;
length = R-L+1;
}
public Range(long L, long R) {
l = L;
r = R;
length = R-L+1;
}
boolean isIn(int x) {
return (l<=x&&x<=r);
}
long kasanari(Range S) {
if(this.r<S.l||S.r<this.l) return 0;
else return Math.min(this.r,S.r) - Math.max(this.l,S.l)+1;
}
}
class LeftComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return (int) Math.signum(P.l-Q.l);
}
}
class RightComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return (int) Math.signum(P.r-Q.r);
}
}
class LengthComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return (int) Math.signum(P.length-Q.length);
}
}
class SegmentTree<T,E>{
int N;
BiFunction<T,T,T> f;
BiFunction<T,E,T> g;
T d1;
ArrayList<T> dat;
SegmentTree(BiFunction<T,T,T> F,BiFunction<T,E,T> G,T D1,T[] v){
int n = v.length;
f = F;
g = G;
d1 = D1;
init(n);
build(v);
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new ArrayList<T>();
}
void build(T[] v) {
for(int i=0;i<2*N;i++) {
dat.add(d1);
}
for(int i=0;i<v.length;i++) {
dat.set(N+i-1,v[i]);
}
for(int i=N-2;i>=0;i--) {
dat.set(i,f.apply(dat.get(i*2+1),dat.get(i*2+2)));
}
}
void update(int k,E a) {
k += N-1;
dat.set(k,g.apply(dat.get(k),a));
while(k>0){
k = (k-1)/2;
dat.set(k,f.apply(dat.get(k*2+1),dat.get(k*2+2)));
}
}
T query(int a,int b, int k, int l ,int r) {
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
T vl = query(a,b,k*2+1,l,(l+r)/2);
T vr = query(a,b,k*2+2,(l+r)/2,r);
return f.apply(vl,vr);
}
T query(int a,int b){
return query(a,b,0,0,N);
}
}
class LazySegmentTree<T,E> extends SegmentTree<T,E>{
BiFunction<E,E,E> h;
BiFunction<E,Integer,E> p = (E a,Integer b) ->{return a;};
E d0;
ArrayList<E> laz;
LazySegmentTree(BiFunction<T,T,T> F,BiFunction<T,E,T> G,BiFunction<E,E,E> H,T D1,E D0,T[] v){
super(F,G,D1,v);
int n = v.length;
h = H;
d0 = D0;
Init(n);
}
void build() {
}
void Init(int n){
laz = new ArrayList<E>();
for(int i=0;i<2*N;i++) {
laz.add(d0);
}
}
void eval(int len,int k) {
if(laz.get(k).equals(d0)) return;
if(k*2+1<N*2-1) {
laz.set(k*2+1,h.apply(laz.get(k*2+1),laz.get(k)));
laz.set(k*2+2,h.apply(laz.get(k*2+2),laz.get(k)));
}
dat.set(k,g.apply(dat.get(k), p.apply(laz.get(k), len)));
laz.set(k,d0);
}
T update(int a,int b,E x,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) {
return dat.get(k);
}
if(a<=l&&r<=b) {
laz.set(k,h.apply(laz.get(k),x));
return g.apply(dat.get(k),p.apply(laz.get(k),r-l));
}
T vl = update(a,b,x,k*2+1,l,(l+r)/2);
T vr = update(a,b,x,k*2+2,(l+r)/2,r);
dat.set(k,f.apply(vl,vr));
return dat.get(k);
}
T update(int a,int b,E x) {
return update(a,b,x,0,0,N);
}
T query(int a,int b,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
T vl = query(a,b,k*2+1,l,(l+r)/2);
T vr = query(a,b,k*2+2,(l+r)/2,r);
return f.apply(vl, vr);
}
T query(int a,int b){
return query(a,b,0,0,N);
}
}
class AddSumSegmentTree{
int N;
int d1;
ArrayList<Integer> dat;
AddSumSegmentTree(int[] v){
int n = v.length;
init(n);
build(v);
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new ArrayList<Integer>();
}
void build(int[] v) {
for(int i=0;i<2*N;i++) {
dat.add(d1);
}
for(int i=0;i<v.length;i++) {
dat.set(N+i-1,v[i]);
}
for(int i=N-2;i>=0;i--) {
dat.set(i,dat.get(i*2+1)+dat.get(i*2+2));
}
}
void update(int k,int a) {
k += N-1;
dat.set(k,dat.get(k)+a);
while(k>0){
k = (k-1)/2;
dat.set(k,dat.get(k*2+1)+dat.get(k*2+2));
}
}
int query(int a,int b, int k, int l ,int r) {
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
int vl = query(a,b,k*2+1,l,(l+r)/2);
int vr = query(a,b,k*2+2,(l+r)/2,r);
return vl+vr;
}
int query(int a,int b){
return query(a,b,0,0,N);
}
}
class AddSumLazySegmentTree {
int N;
long[] dat;
long[] laz;
AddSumLazySegmentTree(long[] v){
init(v.length);
for(int i=0;i<v.length;i++) {
dat[N+i-1]=v[i];
}
for(int i=N-2;i>=0;i--) {
dat[i]=dat[i*2+1]+dat[i*2+2];
}
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new long[2*N];
laz = new long[2*N];
}
void eval(int len,int k) {
if(laz[k]==0) return;
if(k*2+1<N*2-1) {
laz[k*2+1] += laz[k];
laz[k*2+2] += laz[k];
}
dat[k] += laz[k] * len;
laz[k] = 0;
}
long update(int a,int b,long x,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) {
return dat[k];
}
if(a<=l&&r<=b) {
laz[k] += x;
return dat[k]+laz[k]*(r-l);
}
long vl = update(a,b,x,k*2+1,l,(l+r)/2);
long vr = update(a,b,x,k*2+2,(l+r)/2,r);
return dat[k] = vl+vr;
}
long update(int a,int b,long x) {
return update(a,b,x,0,0,N);
}
long query(int a,int b,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) return 0;
if(a<=l&&r<=b) return dat[k];
long vl = query(a,b,k*2+1,l,(l+r)/2);
long vr = query(a,b,k*2+2,(l+r)/2,r);
return vl+vr;
}
long query(int a,int b){
return query(a,b,0,0,N);
}
}
class BinaryIndexedTree{
long[] val;
BinaryIndexedTree(int N){
val = new long[N+1];
}
long sum(int i) {
if(i==0)return 0;
long s = 0;
while(i>0) {
s += val[i];
i -= i & (-i);
}
return s;
}
void add(int i,int x) {
if(i==0)return;
while(i<val.length){
val[i] += x;
i += i & (-i);
}
}
int kth(int k) {
int ok = 0;
int ng = val.length;
while(ng-ok>1) {
int mid = (ok+ng)/2;
if(sum(mid)<k)ok = mid;
else ng = mid;
}
return ng;
}
}
class UnionFindTree {
int[] root;
int[] rank;
long[] size;
int[] edge;
int num;
UnionFindTree(int N){
root = new int[N];
rank = new int[N];
size = new long[N];
edge = new int[N];
num = N;
for(int i=0;i<N;i++){
root[i] = i;
size[i] = 1;
}
}
public long size(int x) {
return size[find(x)];
}
public boolean isRoot(int x) {
return x==find(x);
}
public long extraEdge(int x) {
int r = find(x);
return edge[r] - size[r] + 1;
}
public int find(int x){
if(root[x]==x){
return x;
}else{
return find(root[x]);
}
}
public boolean unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
edge[x]++;
return false;
}else{
num--;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
edge[y] += edge[x]+1;
}else{
root[y] = x;
size[x] += size[y];
edge[x] += edge[y]+1;
if(rank[x]==rank[y]){
rank[x]++;
}
}
return true;
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class LightUnionFindTree {
int[] par;
int num;
LightUnionFindTree(int N){
par = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return find(par[x]);
}
}
public void unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return;
}else{
num--;
if(par[x]<par[y]){
par[x] += par[y];
par[y] = x;
}else{
par[y] += par[x];
par[x] = y;
}
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class RollbackableUnionFind{
int[] par;
int[] size;
int num;
Stack<Integer> pointx;
Stack<Integer> pointy;
Stack<Integer> befpar;
Stack<Integer> befsz;
RollbackableUnionFind(int N){
par = new int[N];
size = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
size[i] = 1;
}
pointx = new Stack<Integer>();
pointy = new Stack<Integer>();
befpar = new Stack<Integer>();
befsz = new Stack<Integer>();
}
public boolean isRoot(int x) {
return x==find(x);
}
public int size(int x) {
return size[find(x)];
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return find(par[x]);
}
}
public boolean unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return false;
}else{
int xs = size[x];
int ys = size[y];
if(xs<ys) {
int tmp = x;
x = y;
y = tmp;
}
pointx.push(x);
pointy.push(y);
befpar.push(par[y]);
befsz.push(size[x]);
par[y] = x;
size[x] += size[y];
return true;
}
}
public void rollback() {
int x = pointx.pop();
int y = pointy.pop();
par[y] = befpar.pop();
size[x] = befsz.pop();
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class JustCompressUnionFind{
int[] par;
int num;
JustCompressUnionFind(int N){
par = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return par[x] = find(par[x]);
}
}
public boolean unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return false;
}else{
num--;
par[y] = x;
return true;
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class ParticalEternalLastingUnionFindTree extends UnionFindTree{
int[] time;
int now;
ParticalEternalLastingUnionFindTree(int N){
super(N);
time = new int[N];
for(int i=0;i<N;i++) {
time[i] = 1000000007;
}
}
public int find(int t,int i) {
if(time[i]>t) {
return i;
}else {
return find(t,root[i]);
}
}
public void unite(int x,int y,int t) {
now = t;
x = find(t,x);
y = find(t,y);
if(x==y)return;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
time[x] = t;
}else{
root[y] = x;
size[x] += size[y];
if(rank[x]==rank[y]){
rank[x]++;
}
time[y] = t;
}
}
public int sametime(int x,int y) {
if(find(now,x)!=find(now,y)) return -1;
int ok = now;
int ng = 0;
while(ok-ng>1) {
int mid = (ok+ng)/2;
if(find(mid,x)==find(mid,y)) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
}
class FlowEdge{
int to;
long cap;
int rev = 0;
long cost = 0;
FlowEdge(int To,long Cap,int Rev){
to = To;
cap = Cap;
rev = Rev;
}
FlowEdge(int To,long Cap,int Rev, long Cost){
to = To;
cap = Cap;
rev = Rev;
cost = Cost;
}
}
class FlowGraph{
int size;
ArrayList<FlowEdge>[] list;
int[] level;
int[] iter;
long[] h;
long[] dist;
int[] prevv;
int[] preve;
ArrayDeque<Integer> q;
FlowGraph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++) {
list[i] = new ArrayList<FlowEdge>();
}
level = new int[N];
iter = new int[N];
h = new long[N];
dist = new long[N];
prevv = new int[N];
preve = new int[N];
q = new ArrayDeque<Integer>();
}
void addEdge(int i, int to, long cap) {
list[i].add(new FlowEdge(to,cap,list[to].size()));
list[to].add(new FlowEdge(i,0,list[i].size()-1));
}
void addEdge(int i, int to, long cap,long cost) {
list[i].add(new FlowEdge(to,cap,list[to].size(),cost));
list[to].add(new FlowEdge(i,0,list[i].size()-1,-cost));
}
void bfs(int s) {
Arrays.fill(level,-1);
level[s] = 0;
q.add(s);
while(!q.isEmpty()) {
int v = q.poll();
for(FlowEdge e:list[v]) {
if(e.cap>0&&level[e.to]<0) {
level[e.to] = level[v] + 1;
q.add(e.to);
}
}
}
}
long dfs(int v,int t,long f) {
if(v==t) return f;
for(int i = iter[v];i<list[v].size();i++) {
FlowEdge e = list[v].get(i);
if(e.cap>0&&level[v]<level[e.to]) {
long d = dfs(e.to,t,Math.min(f,e.cap));
if(d>0) {
e.cap -= d;
list[e.to].get(e.rev).cap += d;
return d;
}
}
iter[v]++;
}
return 0;
}
long flow(int s,int t,long lim) {
long flow = 0;
while(true) {
bfs(s);
if(level[t]<0||lim==0) return flow;
Arrays.fill(iter,0);
while(true) {
long f = dfs(s,t,lim);
if(f>0) {
flow += f;
lim -= f;
}
else break;
}
}
}
long flow(int s,int t) {
return flow(s,t,1000000007);
}
long mincostflow(int s,int t,long f) {
long res = 0;
while(f>0) {
PriorityQueue<LongIntPair> q = new PriorityQueue<LongIntPair>(new LongIntComparator());
for(int i=0;i<size;i++)dist[i] = (long)1e18;
dist[s] = 0;
q.add(new LongIntPair(0,s));
while(!q.isEmpty()) {
LongIntPair p = q.poll();
int v = p.b;
if(dist[v]<p.a)continue;
for(int i=0;i<list[v].size();i++) {
FlowEdge e = list[v].get(i);
if(e.cap>0&&dist[e.to]>dist[v]+e.cost+h[v]-h[e.to]) {
dist[e.to] = dist[v]+e.cost+h[v]-h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
q.add(new LongIntPair(dist[e.to],e.to));
}
}
}
if(dist[t]==(long)1e18) return -1;
for(int v=0;v<size;v++)h[v]+=dist[v];
long d = f;
for(int v=t;v!=s;v=prevv[v]) {
d = Math.min(d,list[prevv[v]].get(preve[v]).cap);
}
f -= d;
res += d*h[t];
for(int v=t;v!=s;v=prevv[v]) {
FlowEdge e = list[prevv[v]].get(preve[v]);
e.cap -= d;
list[v].get(e.rev).cap += d;
}
}
return res;
}
}
class Graph {
ArrayList<Edge>[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
Graph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++){
list[i] = new ArrayList<Edge>();
}
}
public long[] dicount(int s) {
long[] L = new long[size];
long[] c = new long[size];
int mod = 1000000007;
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
c[s] = 1;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
//System.out.println(C.b +" "+ D.to);
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
c[D.to] = c[C.b];
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}else if(L[D.to]==L[C.b]+D.cost) {
c[D.to] += c[C.b];
}
c[D.to] %= mod;
}
}
}
return c;
}
public long[] roots(int s) {
int[] in = new int[size];
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
long[] N = new long[size];
long mod = 1000000007;
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
N[s] = 1;
while(!q.isEmpty()) {
int v = q.poll();
for(Edge e:list[v]) {
N[e.to] += N[v];
if(N[e.to]>=mod)N[e.to]-= mod;
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
return N;
}
void addEdge(int a,int b){
list[a].add(new Edge(b,1));
}
void addWeightedEdge(int a,int b,long c){
list[a].add(new Edge(b,c));
}
void addEgdes(int[] a,int[] b){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],1));
}
}
void addWeightedEdges(int[] a ,int[] b ,int[] c){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],c[i]));
}
}
long[] bfs(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
long[][] bfswithrev(int s){
long[][] L = new long[2][size];
for(int i=0;i<size;i++){
L[0][i] = -1;
L[1][i] = -1;
}
L[0][s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[0][w]==-1){
L[0][w] = L[0][v] + c;
L[1][w] = v;
Q.add(w);
}
}
}
return L;
}
long[] bfs2(int[] d,int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int p = 0;
L[s] = 0;
d[s] = p;
p++;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
d[w] = p;
p++;
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
boolean bfs3(int s,long[] L, int[] vi){
if(vi[s]==1) return true;
vi[s] = 1;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(vi[e.to]==0) {
L[e.to] = (int)c - L[v];
Q.add(w);
vi[e.to] = 1;
}else {
if(L[e.to]!=(int)c - L[v]) {
return false;
}
}
}
}
return true;
}
int[] isTwoColor(){
int[] L = new int[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[0] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(0);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
return L;
}
void isTwoColor2(int i,int[] L){
L[i] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
}
long[] dijkstra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}
}
}
}
return L;
}
ArrayList<Graph> makeapart(){
ArrayList<Graph> ans = new ArrayList<Graph>();
boolean[] b = new boolean[size];
int[] num = new int[size];
for(int i=0;i<size;i++){
if(b[i])continue;
int sz = 0;
ArrayList<Integer> l = new ArrayList<Integer>();
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
b[i] = true;
while(!Q.isEmpty()){
int v = Q.poll();
num[v] = sz;
sz++;
l.add(v);
for(Edge e:list[v]){
if(!b[e.to]){
Q.add(e.to);
b[e.to] = true;
}
}
}
Graph H = new Graph(sz);
for(int e:l){
for(Edge E:list[e]){
H.addWeightedEdge(num[e],num[E.to],E.cost);
}
}
ans.add(H);
}
return ans;
}
long[] bellmanFord(int s) {
long inf = 1000000000;
inf *= inf;
long[] d = new long[size];
boolean[] n = new boolean[size];
d[s] = 0;
for(int i=1;i<size;i++){
d[i] = inf;
d[i] *= d[i];
}
for(int i=0;i<size-1;i++){
for(int j=0;j<size;j++){
for(Edge E:list[j]){
if(d[j]!=inf&&d[E.to]>d[j]+E.cost){
d[E.to]=d[j]+E.cost;
}
}
}
}
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
for(Edge e:list[j]){
if(d[j]==inf) continue;
if(d[e.to]>d[j]+e.cost) {
d[e.to]=d[j]+e.cost;
n[e.to] = true;
}
if(n[j])n[e.to] = true;
}
}
}
for(int i=0;i<size;i++) {
if(n[i])d[i] = inf;
}
return d;
}
long[][] WarshallFloyd(long[][] a){
int n = a.length;
long[][] ans = new long[n][n];
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = a[i][j]==0?(long)1e16:a[i][j];
if(i==j)ans[i][j]=0;
}
}
for(int k=0;k<n;k++) {
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = Math.min(ans[i][j],ans[i][k]+ans[k][j]);
}
}
}
return ans;
}
long[] maxtra(int s,long l){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = -1;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator());
Q.add(new Pair(l,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.max(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long[] mintra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = s;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator().reversed());
Q.add(new Pair(s,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.min(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long Kruskal(){
long r = 0;
for(int i=0;i<size;i++) {
for(Edge e:list[i]) {
Edges.add(new LinkEdge(e.cost,i,e.to));
}
}
UnionFindTree UF = new UnionFindTree(size);
for(LinkEdge e:Edges){
if(e.a>=0&&e.b>=0) {
if(!UF.same(e.a,e.b)){
r += e.L;
UF.unite(e.a,e.b);
}
}
}
return r;
}
ArrayList<Integer> Kahntsort(){
ArrayList<Integer> ans = new ArrayList<Integer>();
PriorityQueue<Integer> q = new PriorityQueue<Integer>();
int[] in = new int[size];
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
while(!q.isEmpty()) {
int v = q.poll();
ans.add(v);
for(Edge e:list[v]) {
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
for(int i=0;i<size;i++) {
if(in[i]>0)return new ArrayList<Integer>();
}
return ans;
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
for(Edge e:list[i]) {
if(f[e.to]) continue;
if(v[e.to]&&!f[e.to]) {
return true;
}
if(findCycle(e.to,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
RootedTree dfsTree(int i) {
int[] u = new int[size];
RootedTree r = new RootedTree(size);
dfsTree(i,u,r);
return r;
}
private void dfsTree(int i, int[] u, RootedTree r) {
u[i] = 1;
r.trans[r.node] = i;
r.rev[i] = r.node;
r.node++;
for(Edge e:list[i]) {
if(u[e.to]==0) {
r.list[i].add(e);
u[e.to] = 1;
dfsTree(e.to,u,r);
}
}
}
}
class LightGraph {
ArrayList<Integer>[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
LightGraph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++){
list[i] = new ArrayList<Integer>();
}
}
void addEdge(int a,int b){
list[a].add(b);
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
for(int e:list[i]) {
if(f[e]) continue;
if(v[e]&&!f[e]) {
return true;
}
if(findCycle(e,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
}
class FunGraph {
int[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
FunGraph(int N){
size = N;
list = new int[N];
Arrays.fill(list,-1);
}
void addEdge(int a,int b){
list[a] = b;
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
int e = list[i];
if(e!=-1&&!f[e]) {
if(v[e]&&!f[e]) {
return true;
}
if(findCycle(e,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
}
class Tree extends Graph{
static int[][] lcat;
static int[] depth;
public Tree(int N) {
super(N);
}
long[] tyokkei(){
long[] a = bfs(0);
int md = -1;
long m = 0;
for(int i=0;i<size;i++){
if(m<a[i]){
m = a[i];
md = i;
}
}
long[] b = bfs(md);
int md2 = -1;
long m2 = 0;
for(int i=0;i<size;i++){
if(m2<b[i]){
m2 = b[i];
md2 = i;
}
}
long[] r = {m2,md,md2};
return r;
}
int[] size(int r) {
int[] ret = new int[size];
dfssize(r,-1,ret);
return ret;
}
private int dfssize(int i, int rev, int[] ret) {
int sz = 1;
for(Edge e:list[i]) {
if(e.to!=rev) sz += dfssize(e.to,i,ret);
}
return ret[i] = sz;
}
void lcadfs(int i,int rev,int d) {
lcat[0][i] = rev;
depth[i] = d;
for(Edge e:list[i]) {
if(e.to!=rev)lcadfs(e.to,i,d+1);
}
}
void buildlca(int r){
lcat = new int[21][size];
depth = new int[size];
lcadfs(r,-1,0);
for(int i=0;i<20;i++) {
Arrays.fill(lcat[i+1],-1);
for(int j=0;j<size;j++) {
if(lcat[i][j]!=-1)lcat[i+1][j] = lcat[i][lcat[i][j]];
else lcat[i+1][j] = -1;
}
}
}
int lca(int a,int b) {
if(depth[a]>depth[b]) {
int tmp = a;
a = b;
b = tmp;
}
int d = depth[b]-depth[a];
for(int i=0;i<=20;i++) {
if(((d>>i)&1)==1)b = lcat[i][b];
}
if(a==b) return a;
for(int i=20;i>=0;i--) {
if(lcat[i][a]!=lcat[i][b]) {
a = lcat[i][a];
b = lcat[i][b];
}
}
return lcat[0][a];
}
}
class RootedTree extends Graph{
int[] trans;
int[] rev;
int node = 0;
RootedTree(int N){
super(N);
trans = new int[N];
rev = new int[N];
}
public int[] parents() {
int[] ret = new int[size];
for(int i=0;i<size;i++) {
for(Edge e:list[i]) {
ret[rev[e.to]] = rev[i];
}
}
ret[0] = -1;
return ret;
}
}
class LinkEdge{
long L;
int a ;
int b;
int id;
LinkEdge(long l,int A,int B){
L = l;
a = A;
b = B;
}
LinkEdge(long l,int A,int B,int i){
L = l;
a = A;
b = B;
id = i;
}
public boolean equals(Object o){
LinkEdge O = (LinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.L==this.L;
}
public int hashCode(){
return Objects.hash(L,a,b);
}
}
class DoubleLinkEdge{
double D;
int a;
int b;
DoubleLinkEdge(double d,int A,int B){
D = d;
a = A;
b = B;
}
public boolean equals(Object o){
DoubleLinkEdge O = (DoubleLinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.D==this.D;
}
public int hashCode(){
return Objects.hash(D,a,b);
}
}
class Edge{
int to;
long cost;
Edge(int a,long b){
to = a;
cost = b;
}
}
class indexedEdge extends Edge{
int id;
indexedEdge(int a, long b, int c) {
super(a,b);
id = c;
}
}
class DoubleLinkEdgeComparator implements Comparator<DoubleLinkEdge>{
public int compare(DoubleLinkEdge P, DoubleLinkEdge Q) {
return Double.compare(P.D,Q.D);
}
}
class LinkEdgeComparator implements Comparator<LinkEdge>{
public int compare(LinkEdge P, LinkEdge Q) {
if(P.L==Q.L) {
if(P.a==Q.a) return Integer.compare(P.b,Q.b);
return Integer.compare(P.a,Q.a);
}
return Long.compare(P.L,Q.L);
}
}
class Pair{
long a;
long b;
Pair(long p,long q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class SampleComparator implements Comparator<Pair>{
public int compare(Pair P, Pair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b==Q.b)return 0;
return P.b>Q.b?1:-1;
}
return t>=0?1:-1;
}
}
class LongIntPair{
long a;
int b;
LongIntPair(long p,int q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
LongIntPair O = (LongIntPair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class LongIntComparator implements Comparator<LongIntPair>{
public int compare(LongIntPair P, LongIntPair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b>Q.b){
return 1;
}else{
return -1;
}
}
return t>=0?1:-1;
}
}
class IntIntPair{
int a;
int b;
IntIntPair(int p,int q){
this.a = p;
this.b = q;
}
IntIntPair(int p,int q,String s){
if(s.equals("sort")) {
this.a = Math.min(p,q);
this.b = Math.max(p,q);
}
}
public boolean equals(Object o){
IntIntPair O = (IntIntPair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class IntIntComparator implements Comparator<IntIntPair>{
public int compare(IntIntPair P, IntIntPair Q) {
int t = P.a-Q.a;
if(t==0){
return P.b-Q.b;
}
return t;
}
}
class IntIntsecondComparator implements Comparator<IntIntPair>{
public int compare(IntIntPair P, IntIntPair Q) {
int t = P.b-Q.b;
if(t==0){
return P.a-Q.a;
}
return t;
}
}
class CIPair{
char c;
int i;
CIPair(char C,int I){
c = C;
i = I;
}
public boolean equals(Object o){
CIPair O = (CIPair) o;
return O.c==this.c&&O.i==this.i;
}
public int hashCode(){
return Objects.hash(c,i);
}
}
class DoublePair{
double a;
double b;
DoublePair(double p,double q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
DoublePair O = (DoublePair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class Triplet{
long a;
long b;
long c;
Triplet(long p,long q,long r){
a = p;
b = q;
c = r;
}
public boolean equals(Object o){
Triplet O = (Triplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c?true:false;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class Quadraplet{
long a;
long b;
long c;
long d;
Quadraplet(long p,long q,long r,long s){
a = p;
b = q;
c = r;
d = s;
}
public boolean equals(Object o){
Quadraplet O = (Quadraplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c&&O.d==this.d?true:false;
}
public int hashCode(){
return Objects.hash(a,b,c,d);
}
}
class TripletComparator implements Comparator<Triplet>{
public int compare(Triplet P, Triplet Q) {
long t = P.a-Q.a;
if(t==0){
long tt = P.b-Q.b;
if(tt==0) {
if(P.c>Q.c) {
return 1;
}else if(P.c<Q.c){
return -1;
}else {
return 0;
}
}
return tt>0?1:-1;
}
return t>=0?1:-1;
}
}
class DDComparator implements Comparator<DoublePair>{
public int compare(DoublePair P, DoublePair Q) {
return P.a-Q.a>=0?1:-1;
}
}
class DoubleTriplet{
double a;
double b;
double c;
DoubleTriplet(double p,double q,double r){
this.a = p;
this.b = q;
this.c = r;
}
public boolean equals(Object o){
DoubleTriplet O = (DoubleTriplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class DoubleTripletComparator implements Comparator<DoubleTriplet>{
public int compare(DoubleTriplet P, DoubleTriplet Q) {
if(P.a==Q.a) return 0;
return P.a-Q.a>0?1:-1;
}
}
class CheckingScanner {
Scanner sc = new Scanner(System.in);
String[] CheckedLine(int N){
String input = sc.nextLine();
if(input.charAt(input.length()-1)==' ') throw new EndSpaceException();
String[] ret = input.split(" ");
if(ret.length!=N) throw new ListLengthException();
return ret;
}
int[] nextboundedints(int N, int minimum, int maximum) {
String[] input = CheckedLine(N);
int[] ret = new int[N];
for(int i=0;i<N;i++) {
ret[i] = Integer.parseInt(input[i]);
checkbound(ret[i],minimum,maximum);
}
return ret;
}
long[] nextboundedlongs(int N, long minimum, long maximum) {
String[] input = CheckedLine(N);
long[] ret = new long[N];
for(int i=0;i<N;i++) {
ret[i] = Long.parseLong(input[i]);
checkbound(ret[i],minimum,maximum);
}
return ret;
}
void checkbound(long v, long minimum, long maximum) {
if(v<minimum || maximum<v) throw new OutofBoundException();
}
class ListLengthException extends RuntimeException{
}
class EndSpaceException extends RuntimeException{
}
class OutofBoundException extends RuntimeException{
}
}
class FastScanner {
private final java.io.InputStream in = System.in;
private final byte[] b = new byte[1024];
private int p = 0;
private int bl = 0;
private boolean hNB() {
if (p<bl) {
return true;
}else{
p = 0;
try {
bl = in.read(b);
} catch (IOException e) {
e.printStackTrace();
}
if (bl<=0) {
return false;
}
}
return true;
}
private int rB() { if (hNB()) return b[p++]; else return -1;}
private static boolean iPC(int c) { return 33 <= c && c <= 126;}
private void sU() { while(hNB() && !iPC(b[p])) p++;}
public boolean hN() { sU(); return hNB();}
public String next() {
if (!hN()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = rB();
while(iPC(b)) {
sb.appendCodePoint(b);
b = rB();
}
return sb.toString();
}
public char nextChar() {
return next().charAt(0);
}
public long nextLong() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b=='-') {
m=true;
b=rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b - '0';
}else if(b == -1||!iPC(b)){
return (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int nextInt() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b == '-') {
m = true;
b = rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b-'0';
}else if(b==-1||!iPC(b)){
return (int) (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int[] nextInts(int n) {
int[] a = new int[n];
for(int i=0;i<n;i++) {
a[i] = nextInt();
}
return a;
}
public int[] nextInts(int n,int s) {
int[] a = new int[n+s];
for(int i=s;i<n+s;i++) {
a[i] = nextInt();
}
return a;
}
public long[] nextLongs(int n, int s) {
long[] a = new long[n+s];
for(int i=s;i<n+s;i++) {
a[i] = nextLong();
}
return a;
}
public long[] nextLongs(int n) {
long[] a = new long[n];
for(int i=0;i<n;i++) {
a[i] = nextLong();
}
return a;
}
public int[][] nextIntses(int n,int m){
int[][] a = new int[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
a[i][j] = nextInt();
}
}
return a;
}
public String[] nexts(int n) {
String[] a = new String[n];
for(int i=0;i<n;i++) {
a[i] = next();
}
return a;
}
void nextIntses(int n,int[] ...m) {
int l = m[0].length;
for(int i=0;i<l;i++) {
for(int j=0;j<m.length;j++) {
m[j][i] = nextInt();
}
}
}
void nextLongses(int n,long[] ...m) {
int l = m[0].length;
for(int i=0;i<l;i++) {
for(int j=0;j<m.length;j++) {
m[j][i] = nextLong();
}
}
}
Graph nextyukoGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
G.addEdge(a,b);
}
return G;
}
Graph nextGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
G.addEdge(a,b);
G.addEdge(b,a);
}
return G;
}
Graph nextWeightedGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
long c = nextLong();
G.addWeightedEdge(a,b,c);
G.addWeightedEdge(b,a,c);
}
return G;
}
Graph nextWeightedyukoGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
long c = nextLong();
G.addWeightedEdge(a,b,c);
}
return G;
}
Tree nextTree(int n) {
Tree T = new Tree(n);
for(int i=0;i<n-1;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
T.addEdge(a,b);
T.addEdge(b,a);
}
return T;
}
}
class Mathplus{
long mod = 1000000007;
long[] fac;
long[] revfac;
long[][] comb;
long[] pow;
long[] revpow;
boolean isBuild = false;
boolean isBuildc = false;
boolean isBuildp = false;
int mindex = -1;
int maxdex = -1;
int graydiff = 0;
int graymark = 0;
int[] ml_prs = {2,3,5,7,11,13,17,19,23,29,31,37};
void printdecimal(double d,int k) {
BigDecimal A = new BigDecimal(d);
A = A.setScale(k,BigDecimal.ROUND_HALF_UP);
String format = "%." + k + "f";
System.out.printf(format,A);
}
public boolean isdistinct(int[] k) {
HashSet<Integer> s = new HashSet<Integer>();
for(int e:k)s.add(e);
return k.length==s.size();
}
public void printtable(Object[] a) {
for(int i=0;i<a.length-1;i++) {
System.out.print(a[i]+" ");
}
System.out.println(a[a.length-1]);
}
public void printtable(int[] a) {
for(int i=0;i<a.length-1;i++) {
System.out.print(a[i]+" ");
}
System.out.println(a[a.length-1]);
}
int LIS(int N, int[] a) {
int[] dp = new int[N+1];
Arrays.fill(dp,(int)mod);
for(int i=0;i<N;i++) {
int ok = 0;
int ng = N;
while(ng-ok>1) {
int mid = (ok+ng)/2;
if(dp[mid]<a[i])ok = mid;
else ng = mid;
}
dp[ok+1] = a[i];
}
int ok = 0;
for(int i=1;i<=N;i++) {
if(dp[i]<mod)ok=i;
}
return ok;
}
public Integer[] Ints(int n, int i) {
Integer[] ret = new Integer[n];
Arrays.fill(ret,i);
return ret;
}
public Long[] Longs(int n, long i) {
Long[] ret = new Long[n];
Arrays.fill(ret,i);
return ret;
}
public boolean nexperm(int[] p) {
int n = p.length;
for(int i=n-1;i>0;i--) {
if(p[i-1]<p[i]) {
int sw = n;
for(int j=n-1;j>=i;j--) {
if(p[i-1]<p[j]) {
sw = j;
break;
}
}
int tmp = p[i-1];
p[i-1] = p[sw];
p[sw] = tmp;
int[] r = new int[n];
for(int j=i;j<n;j++) {
r[j] = p[n-1-j+i];
}
for(int j=i;j<n;j++) {
p[j] = r[j];
}
return true;
}
}
return false;
}
public int[] shuffledperm(int n) {
int[] ret = makeperm(n);
Random rand = new Random();
for(int i=n-1;i>0;i--) {
int j = rand.nextInt(i+1);
swap(ret,i,j);
}
return ret;
}
public void swap(int[] p, int i, int j) {
if(i==j) return;
int tmp = p[i];
p[i] = p[j];
p[j] = tmp;
}
public int[] makeperm(int n) {
int[] a = new int[n];
for(int i=0;i<n;i++) {
a[i] = i;
}
return a;
}
int color(int[][] diff,int N) {
int[] val = new int[1<<N];
val[0] = 1;
for(int i=0;i<(1<<N);i++) {
for(int j=0;j<N;j++) {
if(contains(i,j)) {
if(val[bitremove(i,j)]==1) {
boolean b = true;
for(int k=0;k<N;k++) {
if(contains(i,k)&&diff[j][k]==1) {
b = false;
}
}
if(b)val[i] = 1;
}
break;
}
}
}
int[] dp = new int[1<<N];
Arrays.fill(dp,N+1);;
dp[0] = 0;
for(int i=0;i<(1<<N);i++) {
for(int j=i;j>0;j=(j-1)&i) {
if(val[j]==1)dp[i]=Math.min(dp[i],dp[i^j]+1);
}
}
return dp[(1<<N)-1];
}
public void timeout() throws InterruptedException {
Thread.sleep(10000);
}
public int gray(int i,int m) {
for(int j=0;j<m;j++) {
if(contains(i,j)) {
graydiff = j;
if(contains(i,j+1))graymark=-1;
else graymark = 1;
break;
}
}
return i ^ (i>>1);
}
public void hakidashi(long[] A) {
Arrays.sort(A);
int N = A.length;
int[] index = new int[61];
for(int i=0;i<=60;i++){
index[i] = -1;
}
int searching = 60;
int [] used = new int[N];
while(searching>=0){
boolean b = true;
for(int i=N-1;i>=0;i--){
for(int j=60;j>searching;j--){
if((A[i]>>j&1)==1){
if(i!=index[j]&&index[j]!=-1){
A[i] ^= A[index[j]];
//System.out.println(i+" changed by " + index[j]);
//System.out.println(A[i]);
}
}
}
if((A[i]>>searching&1)==1&&used[i]==0){
//System.out.println("find " + searching+" is "+i);
index[searching] = i;
searching--;
used[i] = 1;
b = false;
if(searching==-1){
searching = 0;
}
}
}
if(b){
searching--;
}
}
for(int i=N-1;i>=0;i--){
for(int j=60;j>=searching;j--){
if((A[i]>>j&1)==1){
if(i!=index[j]&&index[j]!=-1){
A[i] ^= A[index[j]];
}
}
}
}
Arrays.sort(A);
}
public void printjudge(boolean b, String y, String n) {
System.out.println(b?y:n);
}
public void printYN(boolean b) {
printjudge(b,"Yes","No");
}
public void printyn(boolean b) {
printjudge(b,"yes","no");
}
public void reverse(int[] x) {
int[] r = new int[x.length];
for(int i=0;i<x.length;i++)r[i] = x[x.length-1-i];
for(int i=0;i<x.length;i++)x[i] = r[i];
}
public void reverse(long[] x) {
long[] r = new long[x.length];
for(int i=0;i<x.length;i++)r[i] = x[x.length-1-i];
for(int i=0;i<x.length;i++)x[i] = r[i];
}
public DoubleTriplet Line(double x1,double y1,double x2,double y2) {
double a = y1-y2;
double b = x2-x1;
double c = x1*y2-x2*y1;
return new DoubleTriplet(a,b,c);
}
public double putx(DoubleTriplet T,double x) {
return -(T.a*x+T.c)/T.b;
}
public double puty(DoubleTriplet T,double y) {
return -(T.b*y+T.c)/T.a;
}
public double Distance(DoublePair P,DoublePair Q) {
return Math.sqrt((P.a-Q.a) * (P.a-Q.a) + (P.b-Q.b) * (P.b-Q.b));
}
public double DistanceofPointandLine(DoublePair P,Triplet T) {
return Math.abs(P.a*T.a+P.b*T.b+T.c) / Math.sqrt(T.a*T.a+T.b*T.b);
}
public boolean cross(long ax, long ay, long bx, long by, long cx, long cy, long dx, long dy) {
if((ax-bx)*(cy-dy)==(ay-by)*(cx-dx)) {
if(ax-bx!=0) {
Range A = new Range(ax,bx);
Range B = new Range(cx,dx);
return A.kasanari(B)>0;
}else {
Range A = new Range(ay,by);
Range B = new Range(cy,dy);
return A.kasanari(B)>0;
}
}
long ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
long tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
long tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
long td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
public boolean cross2(long ax, long ay, long bx, long by, long cx, long cy, long dx, long dy) {
long ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
long tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
long tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
long td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>0&&td<0)||(tc<0&&td>0))&&((ta>0&&tb<0)||(ta<0&&tb>0));
}
public boolean dcross(double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
void buildFac(){
fac = new long[10000003];
revfac = new long[10000003];
fac[0] = 1;
for(int i=1;i<=10000002;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[10000002] = rev(fac[10000002])%mod;
for(int i=10000001;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
void buildFacn(int n){
fac = new long[n+1];
revfac = new long[n+1];
fac[0] = 1;
for(int i=1;i<=n;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[n] = rev(fac[n])%mod;
for(int i=n-1;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
public long[] buildrui(int[] a) {
int n = a.length;
long[] ans = new long[n];
ans[0] = a[0];
for(int i=1;i<n;i++) {
ans[i] = ans[i-1] + a[i];
}
return ans;
}
public long[] buildrui(long[] a) {
int n = a.length;
long[] ans = new long[n];
ans[0] = a[0];
for(int i=1;i<n;i++) {
ans[i] = ans[i-1] + a[i];
}
return ans;
}
public int[][] ibuildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
int[][] ans = new int[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
public void buildruin(int[][] a) {
int n = a.length;
int m = a[0].length;
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
a[i][j] += a[i][j-1] + a[i-1][j] - a[i-1][j-1];
}
}
}
public long[][] buildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
long[][] ans = new long[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
public int getrui(int[][] r,int a,int b,int c,int d) {
return r[c][d] - r[a-1][d] - r[c][b-1] + r[a-1][b-1];
}
public long getrui(long[][] r,int a,int b,int c,int d) {
if(a<0||b<0||c>=r.length||d>=r[0].length) return mod;
return r[c][d] - r[a-1][d] - r[c][b-1] + r[a-1][b-1];
}
long divroundup(long n,long d) {
if(n==0)return 0;
return (n-1)/d+1;
}
public long sigma(long i) {
return i*(i+1)/2;
}
public int digit(long i) {
int ans = 1;
while(i>=10) {
i /= 10;
ans++;
}
return ans;
}
public int digitsum(long n) {
int ans = 0;
while(n>0) {
ans += n%10;
n /= 10;
}
return ans;
}
public int popcount(int i) {
int ans = 0;
while(i>0) {
ans += i%2;
i /= 2;
}
return ans;
}
public int popcount(long i) {
int ans = 0;
while(i>0) {
ans += i%2;
i /= 2;
}
return ans;
}
public boolean contains(int S,int i) {return (S>>i&1)==1;}
public int bitremove(int S,int i) {return S&(~(1<<i));}
public int bitadd(int S,int i) {return S|(1<<i);}
public boolean isSubSet(int S,int T) {return (S-T)==(S^T);}
public boolean isDisjoint(int S,int T) {return (S+T)==(S^T);}
public boolean contains(long S,int i) {return (S>>i&1)==1;}
public long bitremove(long S,int i) {return S&(~(1<<i));}
public long bitadd(long S,int i) {return S|(1<<i);}
public boolean isSubSet(long S,long T) {return (S-T)==(S^T);}
public boolean isDisjoint(long S,long T) {return (S+T)==(S^T);}
public int isBigger(int[] d, int i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(int[] d, int i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(long[] d, long i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(long[] d, long i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(ArrayList<Integer> d, int i) {
int ok = d.size();
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(ArrayList<Integer> d, int i) {
int ok = -1;
int ng = d.size();
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(ArrayList<Long> d, long i) {
int ok = d.size();
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(ArrayList<Long> d, long i) {
int ok = -1;
int ng = d.size();
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public HashSet<Integer> primetable(int m) {
HashSet<Integer> pt = new HashSet<Integer>();
for(int i=2;i<=m;i++) {
boolean b = true;
for(int d:pt) {
if(i%d==0) {
b = false;
break;
}
}
if(b) {
pt.add(i);
}
}
return pt;
}
public ArrayList<Integer> primetablearray(int m) {
ArrayList<Integer> al = new ArrayList<Integer>();
Queue<Integer> q = new ArrayDeque<Integer>();
for(int i=2;i<=m;i++) {
q.add(i);
}
boolean[] b = new boolean[m+1];
while(!q.isEmpty()) {
int e = q.poll();
if(!b[e]) {
al.add(e);
for(int j=1;e*j<=m;j++) {
b[e*j] = true;
}
}
}
return al;
}
public boolean isprime(int e) {
if(e==1) return false;
for(int i=2;i*i<=e;i++) {
if(e%i==0) return false;
}
return true;
}
public boolean isprime_ml(long n) {
if(n>2&&n%2==0) return false;
for(int a:ml_prs) {
if(a>=n) continue;
long nn = n-1;
int s = 0;
while(nn%2==0) {
s++;
nn /= 2;
}
long w = pow_mod(a,nn,n);
for(int i=0;i<s;i++) {
long ww = w * w % n;
if(ww==1) {
if(w!=1 && w!=n-1) return false;
}
w = ww;
}
if(w!=1) return false;
}
return true;
}
public long factor_pp(long e) {
if(e==1 || isprime_ml(e)) return e;
else {
while(true) {
long a = 2;
long b = 2;
long d = 1;
long rd1 = new Random().nextInt(100000)%e;
long rd2 = new Random().nextInt(100000)%e;
while(d==1) {
a = (rd1 * a + rd2) % e;
b = (rd1 * b + rd2) % e;
b = (rd1 * b + rd2) % e;
d = gcd(Math.abs(a-b),e);
}
if(d!=e) return factor_pp(d);
}
}
}
public MultiSetL factorization(long e) {
MultiSetL ret = new MultiSetL();
for(long i=2;i*i<=e;i++) {
while(e%i==0) {
ret.add(i);
e /= i;
}
}
if(e!=1)ret.add(e);
return ret;
}
public int[] hipPush(int[] a){
int[] r = new int[a.length];
int[] s = new int[a.length];
for(int i=0;i<a.length;i++) {
s[i] = a[i];
}
Arrays.sort(s);
HashMap<Integer,Integer> m = new HashMap<Integer,Integer>();
for(int i=0;i<a.length;i++) {
if(!m.containsKey(s[i]))m.put(s[i],m.size());
}
for(int i=0;i<a.length;i++) {
r[i] = m.get(a[i]);
}
return r;
}
public HashMap<Integer,Integer> hipPush(ArrayList<Integer> l){
HashMap<Integer,Integer> r = new HashMap<Integer,Integer>();
TreeSet<Integer> s = new TreeSet<Integer>();
for(int e:l)s.add(e);
int p = 0;
for(int e:s) {
r.put(e,p);
p++;
}
return r;
}
public TreeMap<Integer,Integer> thipPush(ArrayList<Integer> l){
TreeMap<Integer,Integer> r = new TreeMap<Integer,Integer>();
Collections.sort(l);
int b = -(1000000007+9393);
int p = 0;
for(int e:l) {
if(b!=e) {
r.put(e,p);
p++;
}
b=e;
}
return r;
}
int[] count(int[] a) {
int[] c = new int[max(a)+1];
for(int i=0;i<a.length;i++) {
c[a[i]]++;
}
return c;
}
int[] count(int[] a, int m) {
int[] c = new int[m+1];
for(int i=0;i<a.length;i++) {
c[a[i]]++;
}
return c;
}
long max(long[] a){
long M = Long.MIN_VALUE;
for(int i=0;i<a.length;i++){
if(M<=a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
int max(int[] a){
int M = Integer.MIN_VALUE;
for(int i=0;i<a.length;i++){
if(M<=a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
long min(long[] a){
long m = Long.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
int min(int[] a){
int m = Integer.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
long sum(long[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long sum(int[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long sum(ArrayList<Integer> l) {
long s = 0;
for(int e:l)s += e;
return s;
}
long gcd(long a, long b){
a = Math.abs(a);
b = Math.abs(b);
if(a==0)return b;
if(b==0)return a;
if(a%b==0) return b;
else return gcd(b,a%b);
}
long gcd(long [] a){
long g = a[0];
for(int i=1;i<a.length;i++) {
g = gcd(g,a[i]);
}
return g;
}
int igcd(int a, int b) {
if(a%b==0) return b;
else return igcd(b,a%b);
}
long lcm(long a, long b) {return a / gcd(a,b) * b;}
public long perm(int a,int num) {
if(!isBuild)buildFac();
return fac[a]*(rev(fac[a-num]))%mod;
}
void buildComb(int N) {
comb = new long[N+1][N+1];
comb[0][0] = 1;
for(int i=1;i<=N;i++) {
comb[i][0] = 1;
for(int j=1;j<N;j++) {
comb[i][j] = comb[i-1][j-1]+comb[i-1][j];
if(comb[i][j]>mod)comb[i][j]-=mod;
}
comb[i][i] = 1;
}
}
public long comb(int a,int num){
if(a-num<0)return 0;
if(num<0)return 0;
if(!isBuild)buildFac();
if(a>10000000) return combN(a,num);
return fac[a] * ((revfac[num]*revfac[a-num])%mod)%mod;
}
long combN(int a,int num) {
long ans = 1;
for(int i=0;i<num;i++) {
ans *= a-i;
ans %= mod;
}
return ans * revfac[num] % mod;
}
long mulchoose(int n,int k) {
if(k==0) return 1;
return comb(n+k-1,k);
}
long rev(long l) {return pow(l,mod-2);}
void buildpow(int l,int i) {
pow = new long[i+1];
pow[0] = 1;
for(int j=1;j<=i;j++) {
pow[j] = pow[j-1]*l;
if(pow[j]>mod)pow[j] %= mod;
}
}
void buildrevpow(int l,int i) {
revpow = new long[i+1];
revpow[0] = 1;
long r = rev(l);
for(int j=1;j<=i;j++) {
revpow[j] = revpow[j-1]*r;
if(revpow[j]>mod) revpow[j] %= mod;
}
}
long pow(long l, long i) {
if(i==0)return 1;
else{
if(i%2==0){
long val = pow(l,i/2);
return val * val % mod;
}
else return pow(l,i-1) * l % mod;
}
}
long pow_mod(long l, long i, long m) {
if(i==0)return 1;
else{
if(i%2==0){
long val = pow_mod(l,i/2,m);
return val * val % m;
}
else return pow_mod(l,i-1,m) * l % m;
}
}
long mon(int i) {
long ans = 0;
for(int k=2;k<=i;k++) {
ans += (k%2==0?1:-1) * revfac[k];
ans += mod;
}
ans %= mod;
ans *= fac[i];
return ans%mod;
}
long tent(int[] a, int l, int r) {
if(l+1==r) return 0;
int mid = (l+r)/2;
long ans = tent(a,l,mid)+tent(a,mid,r);
int[] L = new int[mid-l];
int[] R = new int[r-mid];
for(int i=l;i<mid;i++) {
L[i-l] = a[i];
}
for(int i=mid;i<r;i++) {
R[i-mid] = a[i];
}
Arrays.sort(L);
Arrays.sort(R);
int X = L.length;
int Y = R.length;
int k = -1;
for(int i=0;i<X;i++) {
while(k!=Y-1&&R[k+1]<L[i])k++;
ans += k+1;
}
return ans;
}
long dictnum(int[] A) {
int N = A.length;
long ans = 0;
BinaryIndexedTree bit = new BinaryIndexedTree(N+1);
buildFacn(N);
for(int i=1;i<=N;i++) {
bit.add(i,1);
}
for(int i=1;i<=N;i++) {
int a = A[i-1];
ans += bit.sum(a-1) * fac[N-i] % mod;
bit.add(a,-1);
}
return (ans+1)%mod;
}
}
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.BiFunction;
public class Main{
static Scanner scn = new Scanner(System.in);
static FastScanner sc = new FastScanner();
static CheckingScanner cs = new CheckingScanner();
static Mathplus mp = new Mathplus();
static PrintWriter ot = new PrintWriter(System.out);
static Random rand = new Random();
static StringManager sm = new StringManager(" ");
static int mod = 1000000007;
static long modmod = (long)mod * mod;
static long inf = (long)3e18;
static int[] dx = {0,1,0,-1};
static int[] dy = {1,0,-1,0};
static int[] dx8 = {-1,-1,-1,0,0,1,1,1};
static int[] dy8 = {-1,0,1,-1,1,-1,0,1};
static char[] dc = {'R','D','L','U'};
static BiFunction<Integer,Integer,Integer> fmax = (a,b)-> {return Math.max(a,b);};
static BiFunction<Integer,Integer,Integer> fmin = (a,b)-> {return Math.min(a,b);};
static BiFunction<Integer,Integer,Integer> fsum = (a,b)-> {return a+b;};
static BiFunction<Long,Long,Long> fmaxl = (a,b)-> {return Math.max(a,b);};
static BiFunction<Long,Long,Long> fminl = (a,b)-> {return Math.min(a,b);};
static BiFunction<Long,Long,Long> fsuml = (a,b)-> {return a+b;};
static BiFunction<Integer,Integer,Integer> fadd = fsum;
static BiFunction<Integer,Integer,Integer> fupd = (a,b)-> {return b;};
static BiFunction<Long,Long,Long> faddl = fsuml;
static BiFunction<Long,Long,Long> fupdl = (a,b)-> {return b;};
static BiFunction<Long,Long,Long> fmsuml = (a,b)-> {return (a+b)%mod;};
static BiFunction<Long,Long,Long> fmmull = (a,b)-> {return (a*b)%mod;};
static String sp = " ";
public static void main(String[] args) throws IOException {
mod = 998244353;
mp.mod = mod;
long hf = mp.rev(2);
long[] A = new long[1000002];
long[] B = new long[1000002];
A[2] = 1;
for(int i=3;i<=1000001;i++) {
A[i] = A[i-1] * (2*i-5) % mod * hf % mod;
}
B[2] = 1;
for(int i=3;i<=1000001;i++) {
B[i] = B[i-1] * (i-1) % mod;
}
int T = sc.nextInt();
for(int i=0;i<T;i++) {
int N = sc.nextInt();
long NN = N;
long ans = mp.pow(4, N-2) * ((NN * NN - 3) % mod) % mod;
ans *= A[N];
ans %= mod;
ans *= mp.rev(B[N]);
ans %= mod;
ot.println(ans);
}
ot.flush();
}
}
class StringLengthComparator implements Comparator<String>{
public int compare(String P, String Q) {
return (int) Math.signum(P.length()-Q.length());
}
}
class Point{
double x;
double y;
Point(double X,double Y){
x = X;
y = Y;
}
double atan(){
return Math.atan2(y,x);
}
double length() {
return Math.sqrt(x*x+y*y);
}
Point add(Point Q) {
return new Point(x+Q.x,y+Q.y);
}
Point sub(Point Q) {
return new Point(x-Q.x,y-Q.y);
}
Point mul(double d) {
return new Point(x*d,y*d);
}
Point div(double d) {
return new Point(x/d,y/d);
}
}
class Triangle{
double eps = 1e-7;
Point A;
Point B;
Point C;
double edgeA;
double edgeB;
double edgeC;
double argA;
double argB;
double argC;
Triangle(Point a,Point b,Point c){
A = a;
B = b;
C = c;
edgeA = b.sub(c).length();
edgeB = c.sub(a).length();
edgeC = a.sub(b).length();
argA = Math.acos(getcos(edgeA,edgeB,edgeC));
argB = Math.acos(getcos(edgeB,edgeC,edgeA));
argC = Math.acos(getcos(edgeC,edgeA,edgeB));
}
double getcos(double a,double b,double c){
return (b*b+c*c-a*a)/(2*b*c);
}
Point outheart() {
return A.mul(Math.sin(2*argA)).add(B.mul(Math.sin(2*argB))).add(C.mul(Math.sin(2*argC))).div(Math.sin(2*argA)+Math.sin(2*argB)+Math.sin(2*argC));
}
}
class Slidemax{
int[] dat;
ArrayDeque<LongIntPair> q = new ArrayDeque<LongIntPair>();
long get() {
if(q.isEmpty()) return (long) -1e17;
return q.peek().a;
}
void remove() {
q.getFirst().b--;
if(q.getFirst().b==0)q.pollFirst();
}
void add(long x) {
int num = 1;
while(!q.isEmpty()&&q.peekLast().a<=x) {
num += q.peekLast().b;
q.pollLast();
}
q.addLast(new LongIntPair(x,num));
}
}
class Slidemin{
int[] dat;
int l = 0;
int r = -1;
ArrayDeque<LongIntPair> q = new ArrayDeque<LongIntPair>();
long get() {
if(q.isEmpty()) return (long)1e17;
return q.peek().a;
}
void remove() {
q.getFirst().b--;
if(q.getFirst().b==0)q.pollFirst();
}
void add(long x) {
int num = 1;
while(!q.isEmpty()&&q.peekLast().a>=x) {
num += q.peekLast().b;
q.pollLast();
}
q.addLast(new LongIntPair(x,num));
}
}
class Counter{
int[] cnt;
Counter(int M){
cnt = new int[M+1];
}
Counter(int M,int[] A){
cnt = new int[M+1];
for(int i=0;i<A.length;i++)add(A[i]);
}
void add(int e) {
cnt[e]++;
}
void remove(int e) {
cnt[e]--;
}
int count(int e) {
return cnt[e];
}
}
class MultiHashSet{
HashMap<Integer,Integer> set;
int size;
long sum;
MultiHashSet(){
set = new HashMap<Integer,Integer>();
size = 0;
sum = 0;
}
void add(int e){
if(set.containsKey(e))set.put(e,set.get(e)+1);
else set.put(e,1);
size++;
sum += e;
}
void remove(int e) {
set.put(e,set.get(e)-1);
if(set.get(e)==0)set.remove(e);
size--;
sum -= e;
}
boolean contains(int e) {
return set.containsKey(e);
}
boolean isEmpty() {
return set.isEmpty();
}
int count(int e) {
if(contains(e))return set.get(e);
else return 0;
}
Set<Integer> keyset(){
return set.keySet();
}
}
class MultiSet{
TreeMap<Integer,Integer> set;
long size;
long sum;
MultiSet(){
set = new TreeMap<Integer,Integer>();
size = 0;
sum = 0;
}
void add(int e){
if(set.containsKey(e))set.put(e,set.get(e)+1);
else set.put(e,1);
size++;
sum += e;
}
void addn(int e,int n){
if(set.containsKey(e))set.put(e,set.get(e)+n);
else set.put(e,n);
size += n;
sum += e*(long)n;
}
void remove(int e) {
set.put(e,set.get(e)-1);
if(set.get(e)==0)set.remove(e);
size--;
sum -= e;
}
void removeall(int e) {
if(!set.containsKey(e))return;
int n = count(e);
set.remove(e);
size -= n;
sum -= e*(long)n;
}
int first() {return set.firstKey();}
int last() {return set.lastKey();}
int lower(int e) {return set.lowerKey(e);}
int higher(int e) {return set.higherKey(e);}
int floor(int e) {return set.floorKey(e);}
int ceil(int e) {return set.ceilingKey(e);}
boolean contains(int e) {return set.containsKey(e);}
boolean isEmpty() {return set.isEmpty();}
int count(int e) {
if(contains(e))return set.get(e);
else return 0;
}
MultiSet marge(MultiSet T) {
if(size>T.size) {
while(!T.isEmpty()) {
add(T.first());
T.remove(T.first());
}
return this;
}else {
while(!isEmpty()) {
T.add(first());
remove(first());
}
return T;
}
}
Set<Integer> keyset(){
return set.keySet();
}
}
class MultiSetL{
TreeMap<Long,Integer> set;
int size;
long sum;
MultiSetL(){
set = new TreeMap<Long,Integer>();
size = 0;
sum = 0;
}
void add(long e){
if(set.containsKey(e))set.put(e,set.get(e)+1);
else set.put(e,1);
size++;
sum += e;
}
void remove(long e) {
set.put(e,set.get(e)-1);
if(set.get(e)==0)set.remove(e);
size--;
sum -= e;
}
long first() {return set.firstKey();}
long last() {return set.lastKey();}
long lower(long e) {return set.lowerKey(e);}
long higher(long e) {return set.higherKey(e);}
long floor(long e) {return set.floorKey(e);}
long ceil(long e) {return set.ceilingKey(e);}
boolean contains(long e) {return set.containsKey(e);}
boolean isEmpty() {return set.isEmpty();}
int count(long e) {
if(contains(e))return set.get(e);
else return 0;
}
MultiSetL marge(MultiSetL T) {
if(size>T.size) {
while(!T.isEmpty()) {
add(T.first());
T.remove(T.first());
}
return this;
}else {
while(!isEmpty()) {
T.add(first());
remove(first());
}
return T;
}
}
Set<Long> keyset(){
return set.keySet();
}
}
class GridGraph extends Graph{
int N;
int M;
String[] S;
HashMap<Character,Integer> map;
GridGraph(int n,int m,String[] s){
super(n*m);
N = n;
M = m;
S = s;
for(int i=0;i<n-1;i++) {
for(int j=0;j<m;j++) {
if(S[i].charAt(j)=='.'&&S[i+1].charAt(j)=='.') {
addWeightedEdge(toint(i,j),toint(i+1,j),1);
addWeightedEdge(toint(i+1,j),toint(i,j),1);
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m-1;j++) {
if(S[i].charAt(j)=='.'&&S[i].charAt(j+1)=='.') {
addWeightedEdge(toint(i,j),toint(i,j+1),1);
addWeightedEdge(toint(i,j+1),toint(i,j),1);
}
}
}
}
GridGraph(int n,int m,String[] s,char[] c){
super(n*m);
N = n;
M = m;
S = s;
map = new HashMap<Character,Integer>();
for(int i=0;i<n-1;i++) {
for(int j=0;j<m;j++) {
if(S[i].charAt(j)!=S[i+1].charAt(j)) {
addWeightedEdge(toint(i,j),toint(i+1,j),1);
addWeightedEdge(toint(i+1,j),toint(i,j),1);
}else {
addWeightedEdge(toint(i,j),toint(i+1,j),0);
addWeightedEdge(toint(i+1,j),toint(i,j),0);
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m-1;j++) {
if(S[i].charAt(j)!=S[i].charAt(j+1)) {
addWeightedEdge(toint(i,j),toint(i,j+1),1);
addWeightedEdge(toint(i,j+1),toint(i,j),1);
}else{
addWeightedEdge(toint(i,j),toint(i,j+1),0);
addWeightedEdge(toint(i,j+1),toint(i,j),0);
}
}
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i].charAt(j)==c[k])map.put(c[k],toint(i,j));
}
}
}
}
int toint(int i,int j) {
return i*M+j;
}
}
class StringManager{
ArrayList<Character> S;
static Mathplus mp;
static boolean calced;
static int base;
static long baserev;
ArrayList<Long> l;
StringManager(String s){
S = new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
S.add(s.charAt(i));
}
if(!calced) {
calced = true;
mp = new Mathplus();
base = 1000003;
baserev = mp.rev(base);
mp.buildpow(base,2000050);
mp.buildrevpow(base, 2000050);
}
l = new ArrayList<Long>();
l.add((long)S.get(0));
for(int i=1;i<S.size();i++) {
char c = S.get(i);
l.add((l.get(i-1) + mp.pow[i] * c)%mp.mod);
}
}
StringManager(String s,int b){
S = new ArrayList<Character>();
for(int i=0;i<s.length();i++) {
S.add(s.charAt(i));
}
base = b;
if(!calced) {
calced = true;
mp = new Mathplus();
base = b;
baserev = mp.rev(base);
mp.buildpow(base,2000050);
mp.buildrevpow(base, 2000050);
}
l = new ArrayList<Long>();
l.add((long)S.get(0));
for(int i=1;i<S.size();i++) {
char c = S.get(i);
l.add((l.get(i-1) + mp.pow[i] * c)%mp.mod);
}
}
void add(char C){
int i = S.size();
S.add(C);
l.add((l.get(i-1) + mp.pow[i] * C)%mp.mod);
}
long gethash(int le,int ri) {
long res = l.get(ri);
if(le!=0) {
res -= l.get(le-1);
res += mp.mod;
res %= mp.mod;
res *= mp.revpow[le];
res %= mp.mod;
}
return res;
}
ArrayList<CIPair> runlength(String s){
ArrayList<CIPair> ret = new ArrayList<CIPair>();
s += ' ';
char bef = ' ';
int len = 0;
for(int i=0;i<s.length();i++) {
if(s.charAt(i)!=bef) {
if(bef != ' ')ret.add(new CIPair(bef,len));
len = 1;
}else {
len++;
}
bef = s.charAt(i);
}
return ret;
}
ArrayList<CIPair> runlength(ArrayList<Character> s){
ArrayList<CIPair> ret = new ArrayList<CIPair>();
s.add(' ');
char bef = ' ';
int len = 0;
for(int i=0;i<s.size();i++) {
if(s.get(i)!=bef) {
if(bef != ' ')ret.add(new CIPair(bef,len));
len = 1;
}else {
len++;
}
bef = s.get(i);
}
return ret;
}
boolean isPalindrome(String S) {
boolean b = true;
for(int i=0;i<S.length();i++) {
if(S.charAt(i)!=S.charAt(S.length()-1-i))b = false;
}
return b;
}
}
class BetterGridGraph{
int N;
int M;
char[][] S;
HashMap<Character,ArrayList<Integer>> map;
int[] dx = {0,1,0,-1};
int[] dy = {1,0,-1,0};
int[] dx6 = {0,1,0,-1,-1,1};
int[] dy6 = {1,0,-1,0,1,1};
char w;
char b = '#';
BetterGridGraph(int n,int m,String[] s,char[] c){
N = n;
M = m;
for(int i=0;i<s.length;i++) {
S[i] = s[i].toCharArray();
}
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,char[][] s,char[] c){
N = n;
M = m;
S = s;
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,String[] s,char[] c,char W,char B){
N = n;
M = m;
for(int i=0;i<s.length;i++) {
S[i] = s[i].toCharArray();
}
w = W;
b = B;
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
BetterGridGraph(int n,int m,char[][] s,char[] c,char W,char B){
N = n;
M = m;
S = s;
w = W;
b = B;
map = new HashMap<Character,ArrayList<Integer>>();
for(int i=0;i<c.length;i++) {
map.put(c[i],new ArrayList<Integer>());
}
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
for(int k=0;k<c.length;k++) {
if(S[i][j]==c[k])map.get(c[k]).add(toint(i,j));
}
}
}
}
int toint(int i,int j) {
return i*M+j;
}
ArrayList<Integer> getposlist(char c) {
return map.get(c);
}
int getpos(char c) {
return map.get(c).get(0);
}
int[] bfs(char C) {
int[] L = new int[N*M];
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
for(int i=0;i<N*M;i++){
L[i] = -1;
}
for(int s:map.get(C)) {
L[s] = 0;
Q.add(s);
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
int[] bfs6(char C) {
int[] L = new int[N*M];
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
for(int i=0;i<N*M;i++){
L[i] = -1;
}
for(int s:map.get(C)) {
L[s] = 0;
Q.add(s);
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<6;i++){
int x = v/M;
int y = v%M;
int nx = x+dx6[i];
int ny = y+dy6[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
int[] bfsb(int s) {
int[] L = new int[N*M];
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
for(int i=0;i<N*M;i++){
L[i] = -1;
}
Q.add(s);
L[s] = 0;
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)) {
int w = toint(nx,ny);
if(L[w]==-1){
if(S[x][y]==S[nx][ny]) {
L[w] = L[v];
Q.addFirst(w);
}else {
L[w] = L[v] + 1;
Q.addLast(w);
}
}
}
}
}
return L;
}
int[][] bfs2(char C,int K){
int[][] L = new int[N*M][K+1];
ArrayDeque<IntIntPair> Q = new ArrayDeque<IntIntPair>();
for(int i=0;i<N*M;i++){
for(int j=0;j<=K;j++) {
L[i][j] = 1000000007;
}
}
for(int s:map.get(C)) {
L[s][0] = 0;
Q.add(new IntIntPair(0,s));
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair v = Q.poll();
for(int i=0;i<4;i++){
int x = v.b/M;
int y = v.b%M;
int h = v.a;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int ni = toint(nx,ny);
int nh = S[nx][ny]==w?h+1:h;
if(nh>K) continue;
if(L[ni][nh]==1000000007){
L[ni][nh] = L[v.b][h]+1;
Q.add(new IntIntPair(nh,ni));
}
}
}
}
for(int i=0;i<N*M;i++) {
for(int j=1;j<=K;j++) {
L[i][j] = Math.min(L[i][j],L[i][j-1]);
}
}
return L;
}
int[] dijkstra(char C) {
int[] L = new int[N*M];
PriorityQueue<IntIntPair> Q = new PriorityQueue<IntIntPair>(new IntIntComparator());
for(int i=0;i<N*M;i++){
L[i] = -1;
}
for(int s:map.get(C)) {
L[s] = 0;
Q.add(new IntIntPair(0,s));
}
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair P = Q.poll();
int v = P.b;
int x = v/M;
int y = v%M;
for(int i=0;i<4;i++){
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&S[nx][ny]!=b) {
int w = toint(nx,ny);
if(L[w]==-1||L[w]>L[v] + (S[nx][ny]!='t'?S[nx][ny]-'0':0)){
L[w] = L[v] + (S[nx][ny]!='t'?S[nx][ny]-'0':0);
Q.add(new IntIntPair(L[w],w));
}
}
}
}
return L;
}
}
class IntGridGraph{
int N;
int M;
int[][] B;
int[] dx = {0,1,0,-1};
int[] dy = {1,0,-1,0};
BiFunction<Integer,Integer,Boolean> F;
IntGridGraph(int n,int m,int[][] b){
N = n;
M = m;
B = b;
}
IntGridGraph(int n,int m,int[][] b,BiFunction<Integer,Integer,Boolean> f){
N = n;
M = m;
B = b;
F = f;
}
int toint(int i,int j) {
return i*M+j;
}
int[] bfs(int s) {
int[] L = new int[N*M];
for(int i=0;i<N*M;i++){
L[i] = -1;
}
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&F.apply(B[x][y],B[nx][ny])) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return L;
}
void bfs(int s,int[] L) {
if(L[s]!=-1) return;
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
int v = Q.poll();
for(int i=0;i<4;i++){
int x = v/M;
int y = v%M;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&F.apply(B[x][y],B[nx][ny])) {
int w = toint(nx,ny);
if(L[w]==-1){
L[w] = L[v] + 1;
Q.add(w);
}
}
}
}
return;
}
int[][] bfs2(int s,int K){
int[][] L = new int[N*M][K+1];
for(int i=0;i<N*M;i++){
for(int j=0;j<=K;j++)
L[i][j] = 1000000007;
}
L[s][0] = 0;
PriorityQueue<IntIntPair> Q = new PriorityQueue<IntIntPair>(new IntIntComparator());
Q.add(new IntIntPair(0,s));
Range X = new Range(0,N-1);
Range Y = new Range(0,M-1);
while(!Q.isEmpty()){
IntIntPair v = Q.poll();
for(int i=0;i<4;i++){
int x = v.b/M;
int y = v.b%M;
int h = v.a;
int nx = x+dx[i];
int ny = y+dy[i];
if(X.isIn(nx)&&Y.isIn(ny)&&F.apply(B[x][y],B[nx][ny])) {
int ni = toint(nx,ny);
int nh = h + B[nx][ny];
if(nh>K) continue;
if(L[ni][nh]==1000000007){
L[ni][nh] = L[v.b][h] + 1;
Q.add(new IntIntPair(nh,ni));
}
}
}
}
for(int i=0;i<N*M;i++) {
for(int j=1;j<=K;j++) {
L[i][j] = Math.min(L[i][j],L[i][j-1]);
}
}
return L;
}
}
class Trie{
int nodenumber = 1;
ArrayList<TrieNode> l;
Trie(){
l = new ArrayList<TrieNode>();
l.add(new TrieNode());
}
void add(String S,int W){
int now = 0;
for(int i=0;i<S.length();i++) {
TrieNode n = l.get(now);
char c = S.charAt(i);
if(n.Exist[c-'a']!=-1) {
now = n.Exist[c-'a'];
}else {
l.add(new TrieNode());
n.Exist[c-'a'] = nodenumber;
now = nodenumber;
nodenumber++;
}
}
l.get(now).weight = W;
}
void find(String S,int i,int[] dp) {
int now = 0;
dp[i+1] = Math.max(dp[i],dp[i+1]);
for(int j=0;;j++) {
TrieNode n = l.get(now);
dp[i+j] = Math.max(dp[i+j],dp[i]+n.weight);
int slook = i+j;
if(slook>=S.length())return;
char c = S.charAt(slook);
if(n.Exist[c-'a']==-1)return;
now = n.Exist[c-'a'];
}
}
}
class TrieNode{
int[] Exist = new int[26];
int weight = 0;
TrieNode(){
for(int i=0;i<26;i++) {
Exist[i] = -1;
}
}
}
class SizeComparator implements Comparator<Edge>{
int[] size;
SizeComparator(int[] s) {
size = s;
}
public int compare(Edge o1, Edge o2) {
return size[o1.to]-size[o2.to];
}
}
class ConvexHullTrick {
long[] A, B;
int len;
public ConvexHullTrick(int n) {
A = new long[n];
B = new long[n];
}
private boolean check(long a, long b) {
return (B[len - 2] - B[len - 1]) * (a - A[len - 1]) >= (B[len - 1] - b) * (A[len - 1] - A[len - 2]);
}
public void add(long a, long b) {
while (len >= 2 && check(a, b)) {
len--;
}
A[len] = a;
B[len] = b;
len++;
}
public long query(long x) {
int l = -1, r = len - 1;
while (r - l > 1) {
int mid = (r + l) / 2;
if (get(mid,x)>=get(mid+1,x)) {
l = mid;
} else {
r = mid;
}
}
return get(r,x);
}
private long get(int k, long x) {
return A[k] * x + B[k];
}
}
class Range{
long l;
long r;
long length;
Range(int L,int R){
l = L;
r = R;
length = R-L+1;
}
public Range(long L, long R) {
l = L;
r = R;
length = R-L+1;
}
boolean isIn(int x) {
return (l<=x&&x<=r);
}
long kasanari(Range S) {
if(this.r<S.l||S.r<this.l) return 0;
else return Math.min(this.r,S.r) - Math.max(this.l,S.l)+1;
}
}
class LeftComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return (int) Math.signum(P.l-Q.l);
}
}
class RightComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return (int) Math.signum(P.r-Q.r);
}
}
class LengthComparator implements Comparator<Range>{
public int compare(Range P, Range Q) {
return (int) Math.signum(P.length-Q.length);
}
}
class SegmentTree<T,E>{
int N;
BiFunction<T,T,T> f;
BiFunction<T,E,T> g;
T d1;
ArrayList<T> dat;
SegmentTree(BiFunction<T,T,T> F,BiFunction<T,E,T> G,T D1,T[] v){
int n = v.length;
f = F;
g = G;
d1 = D1;
init(n);
build(v);
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new ArrayList<T>();
}
void build(T[] v) {
for(int i=0;i<2*N;i++) {
dat.add(d1);
}
for(int i=0;i<v.length;i++) {
dat.set(N+i-1,v[i]);
}
for(int i=N-2;i>=0;i--) {
dat.set(i,f.apply(dat.get(i*2+1),dat.get(i*2+2)));
}
}
void update(int k,E a) {
k += N-1;
dat.set(k,g.apply(dat.get(k),a));
while(k>0){
k = (k-1)/2;
dat.set(k,f.apply(dat.get(k*2+1),dat.get(k*2+2)));
}
}
T query(int a,int b, int k, int l ,int r) {
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
T vl = query(a,b,k*2+1,l,(l+r)/2);
T vr = query(a,b,k*2+2,(l+r)/2,r);
return f.apply(vl,vr);
}
T query(int a,int b){
return query(a,b,0,0,N);
}
}
class LazySegmentTree<T,E> extends SegmentTree<T,E>{
BiFunction<E,E,E> h;
BiFunction<E,Integer,E> p = (E a,Integer b) ->{return a;};
E d0;
ArrayList<E> laz;
LazySegmentTree(BiFunction<T,T,T> F,BiFunction<T,E,T> G,BiFunction<E,E,E> H,T D1,E D0,T[] v){
super(F,G,D1,v);
int n = v.length;
h = H;
d0 = D0;
Init(n);
}
void build() {
}
void Init(int n){
laz = new ArrayList<E>();
for(int i=0;i<2*N;i++) {
laz.add(d0);
}
}
void eval(int len,int k) {
if(laz.get(k).equals(d0)) return;
if(k*2+1<N*2-1) {
laz.set(k*2+1,h.apply(laz.get(k*2+1),laz.get(k)));
laz.set(k*2+2,h.apply(laz.get(k*2+2),laz.get(k)));
}
dat.set(k,g.apply(dat.get(k), p.apply(laz.get(k), len)));
laz.set(k,d0);
}
T update(int a,int b,E x,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) {
return dat.get(k);
}
if(a<=l&&r<=b) {
laz.set(k,h.apply(laz.get(k),x));
return g.apply(dat.get(k),p.apply(laz.get(k),r-l));
}
T vl = update(a,b,x,k*2+1,l,(l+r)/2);
T vr = update(a,b,x,k*2+2,(l+r)/2,r);
dat.set(k,f.apply(vl,vr));
return dat.get(k);
}
T update(int a,int b,E x) {
return update(a,b,x,0,0,N);
}
T query(int a,int b,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
T vl = query(a,b,k*2+1,l,(l+r)/2);
T vr = query(a,b,k*2+2,(l+r)/2,r);
return f.apply(vl, vr);
}
T query(int a,int b){
return query(a,b,0,0,N);
}
}
class AddSumSegmentTree{
int N;
int d1;
ArrayList<Integer> dat;
AddSumSegmentTree(int[] v){
int n = v.length;
init(n);
build(v);
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new ArrayList<Integer>();
}
void build(int[] v) {
for(int i=0;i<2*N;i++) {
dat.add(d1);
}
for(int i=0;i<v.length;i++) {
dat.set(N+i-1,v[i]);
}
for(int i=N-2;i>=0;i--) {
dat.set(i,dat.get(i*2+1)+dat.get(i*2+2));
}
}
void update(int k,int a) {
k += N-1;
dat.set(k,dat.get(k)+a);
while(k>0){
k = (k-1)/2;
dat.set(k,dat.get(k*2+1)+dat.get(k*2+2));
}
}
int query(int a,int b, int k, int l ,int r) {
if(r<=a||b<=l) return d1;
if(a<=l&&r<=b) return dat.get(k);
int vl = query(a,b,k*2+1,l,(l+r)/2);
int vr = query(a,b,k*2+2,(l+r)/2,r);
return vl+vr;
}
int query(int a,int b){
return query(a,b,0,0,N);
}
}
class AddSumLazySegmentTree {
int N;
long[] dat;
long[] laz;
AddSumLazySegmentTree(long[] v){
init(v.length);
for(int i=0;i<v.length;i++) {
dat[N+i-1]=v[i];
}
for(int i=N-2;i>=0;i--) {
dat[i]=dat[i*2+1]+dat[i*2+2];
}
}
void init(int n) {
N = 1;
while(N<n)N*=2;
dat = new long[2*N];
laz = new long[2*N];
}
void eval(int len,int k) {
if(laz[k]==0) return;
if(k*2+1<N*2-1) {
laz[k*2+1] += laz[k];
laz[k*2+2] += laz[k];
}
dat[k] += laz[k] * len;
laz[k] = 0;
}
long update(int a,int b,long x,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) {
return dat[k];
}
if(a<=l&&r<=b) {
laz[k] += x;
return dat[k]+laz[k]*(r-l);
}
long vl = update(a,b,x,k*2+1,l,(l+r)/2);
long vr = update(a,b,x,k*2+2,(l+r)/2,r);
return dat[k] = vl+vr;
}
long update(int a,int b,long x) {
return update(a,b,x,0,0,N);
}
long query(int a,int b,int k,int l,int r) {
eval(r-l,k);
if(r<=a||b<=l) return 0;
if(a<=l&&r<=b) return dat[k];
long vl = query(a,b,k*2+1,l,(l+r)/2);
long vr = query(a,b,k*2+2,(l+r)/2,r);
return vl+vr;
}
long query(int a,int b){
return query(a,b,0,0,N);
}
}
class BinaryIndexedTree{
long[] val;
BinaryIndexedTree(int N){
val = new long[N+1];
}
long sum(int i) {
if(i==0)return 0;
long s = 0;
while(i>0) {
s += val[i];
i -= i & (-i);
}
return s;
}
void add(int i,int x) {
if(i==0)return;
while(i<val.length){
val[i] += x;
i += i & (-i);
}
}
int kth(int k) {
int ok = 0;
int ng = val.length;
while(ng-ok>1) {
int mid = (ok+ng)/2;
if(sum(mid)<k)ok = mid;
else ng = mid;
}
return ng;
}
}
class UnionFindTree {
int[] root;
int[] rank;
long[] size;
int[] edge;
int num;
UnionFindTree(int N){
root = new int[N];
rank = new int[N];
size = new long[N];
edge = new int[N];
num = N;
for(int i=0;i<N;i++){
root[i] = i;
size[i] = 1;
}
}
public long size(int x) {
return size[find(x)];
}
public boolean isRoot(int x) {
return x==find(x);
}
public long extraEdge(int x) {
int r = find(x);
return edge[r] - size[r] + 1;
}
public int find(int x){
if(root[x]==x){
return x;
}else{
return find(root[x]);
}
}
public boolean unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
edge[x]++;
return false;
}else{
num--;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
edge[y] += edge[x]+1;
}else{
root[y] = x;
size[x] += size[y];
edge[x] += edge[y]+1;
if(rank[x]==rank[y]){
rank[x]++;
}
}
return true;
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class LightUnionFindTree {
int[] par;
int num;
LightUnionFindTree(int N){
par = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return find(par[x]);
}
}
public void unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return;
}else{
num--;
if(par[x]<par[y]){
par[x] += par[y];
par[y] = x;
}else{
par[y] += par[x];
par[x] = y;
}
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class RollbackableUnionFind{
int[] par;
int[] size;
int num;
Stack<Integer> pointx;
Stack<Integer> pointy;
Stack<Integer> befpar;
Stack<Integer> befsz;
RollbackableUnionFind(int N){
par = new int[N];
size = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
size[i] = 1;
}
pointx = new Stack<Integer>();
pointy = new Stack<Integer>();
befpar = new Stack<Integer>();
befsz = new Stack<Integer>();
}
public boolean isRoot(int x) {
return x==find(x);
}
public int size(int x) {
return size[find(x)];
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return find(par[x]);
}
}
public boolean unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return false;
}else{
int xs = size[x];
int ys = size[y];
if(xs<ys) {
int tmp = x;
x = y;
y = tmp;
}
pointx.push(x);
pointy.push(y);
befpar.push(par[y]);
befsz.push(size[x]);
par[y] = x;
size[x] += size[y];
return true;
}
}
public void rollback() {
int x = pointx.pop();
int y = pointy.pop();
par[y] = befpar.pop();
size[x] = befsz.pop();
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class JustCompressUnionFind{
int[] par;
int num;
JustCompressUnionFind(int N){
par = new int[N];
num = N;
for(int i=0;i<N;i++){
par[i] = -1;
}
}
public boolean isRoot(int x) {
return x==find(x);
}
public int find(int x){
if(par[x]<0){
return x;
}else{
return par[x] = find(par[x]);
}
}
public boolean unite(int x,int y){
x = find(x);
y = find(y);
if(x==y){
return false;
}else{
num--;
par[y] = x;
return true;
}
}
public boolean same(int x,int y){
return find(x)==find(y);
}
}
class ParticalEternalLastingUnionFindTree extends UnionFindTree{
int[] time;
int now;
ParticalEternalLastingUnionFindTree(int N){
super(N);
time = new int[N];
for(int i=0;i<N;i++) {
time[i] = 1000000007;
}
}
public int find(int t,int i) {
if(time[i]>t) {
return i;
}else {
return find(t,root[i]);
}
}
public void unite(int x,int y,int t) {
now = t;
x = find(t,x);
y = find(t,y);
if(x==y)return;
if(rank[x]<rank[y]){
root[x] = y;
size[y] += size[x];
time[x] = t;
}else{
root[y] = x;
size[x] += size[y];
if(rank[x]==rank[y]){
rank[x]++;
}
time[y] = t;
}
}
public int sametime(int x,int y) {
if(find(now,x)!=find(now,y)) return -1;
int ok = now;
int ng = 0;
while(ok-ng>1) {
int mid = (ok+ng)/2;
if(find(mid,x)==find(mid,y)) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
}
class FlowEdge{
int to;
long cap;
int rev = 0;
long cost = 0;
FlowEdge(int To,long Cap,int Rev){
to = To;
cap = Cap;
rev = Rev;
}
FlowEdge(int To,long Cap,int Rev, long Cost){
to = To;
cap = Cap;
rev = Rev;
cost = Cost;
}
}
class FlowGraph{
int size;
ArrayList<FlowEdge>[] list;
int[] level;
int[] iter;
long[] h;
long[] dist;
int[] prevv;
int[] preve;
ArrayDeque<Integer> q;
FlowGraph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++) {
list[i] = new ArrayList<FlowEdge>();
}
level = new int[N];
iter = new int[N];
h = new long[N];
dist = new long[N];
prevv = new int[N];
preve = new int[N];
q = new ArrayDeque<Integer>();
}
void addEdge(int i, int to, long cap) {
list[i].add(new FlowEdge(to,cap,list[to].size()));
list[to].add(new FlowEdge(i,0,list[i].size()-1));
}
void addEdge(int i, int to, long cap,long cost) {
list[i].add(new FlowEdge(to,cap,list[to].size(),cost));
list[to].add(new FlowEdge(i,0,list[i].size()-1,-cost));
}
void bfs(int s) {
Arrays.fill(level,-1);
level[s] = 0;
q.add(s);
while(!q.isEmpty()) {
int v = q.poll();
for(FlowEdge e:list[v]) {
if(e.cap>0&&level[e.to]<0) {
level[e.to] = level[v] + 1;
q.add(e.to);
}
}
}
}
long dfs(int v,int t,long f) {
if(v==t) return f;
for(int i = iter[v];i<list[v].size();i++) {
FlowEdge e = list[v].get(i);
if(e.cap>0&&level[v]<level[e.to]) {
long d = dfs(e.to,t,Math.min(f,e.cap));
if(d>0) {
e.cap -= d;
list[e.to].get(e.rev).cap += d;
return d;
}
}
iter[v]++;
}
return 0;
}
long flow(int s,int t,long lim) {
long flow = 0;
while(true) {
bfs(s);
if(level[t]<0||lim==0) return flow;
Arrays.fill(iter,0);
while(true) {
long f = dfs(s,t,lim);
if(f>0) {
flow += f;
lim -= f;
}
else break;
}
}
}
long flow(int s,int t) {
return flow(s,t,1000000007);
}
long mincostflow(int s,int t,long f) {
long res = 0;
while(f>0) {
PriorityQueue<LongIntPair> q = new PriorityQueue<LongIntPair>(new LongIntComparator());
for(int i=0;i<size;i++)dist[i] = (long)1e18;
dist[s] = 0;
q.add(new LongIntPair(0,s));
while(!q.isEmpty()) {
LongIntPair p = q.poll();
int v = p.b;
if(dist[v]<p.a)continue;
for(int i=0;i<list[v].size();i++) {
FlowEdge e = list[v].get(i);
if(e.cap>0&&dist[e.to]>dist[v]+e.cost+h[v]-h[e.to]) {
dist[e.to] = dist[v]+e.cost+h[v]-h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
q.add(new LongIntPair(dist[e.to],e.to));
}
}
}
if(dist[t]==(long)1e18) return -1;
for(int v=0;v<size;v++)h[v]+=dist[v];
long d = f;
for(int v=t;v!=s;v=prevv[v]) {
d = Math.min(d,list[prevv[v]].get(preve[v]).cap);
}
f -= d;
res += d*h[t];
for(int v=t;v!=s;v=prevv[v]) {
FlowEdge e = list[prevv[v]].get(preve[v]);
e.cap -= d;
list[v].get(e.rev).cap += d;
}
}
return res;
}
}
class Graph {
ArrayList<Edge>[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
Graph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++){
list[i] = new ArrayList<Edge>();
}
}
public long[] dicount(int s) {
long[] L = new long[size];
long[] c = new long[size];
int mod = 1000000007;
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
c[s] = 1;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
//System.out.println(C.b +" "+ D.to);
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
c[D.to] = c[C.b];
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}else if(L[D.to]==L[C.b]+D.cost) {
c[D.to] += c[C.b];
}
c[D.to] %= mod;
}
}
}
return c;
}
public long[] roots(int s) {
int[] in = new int[size];
ArrayDeque<Integer> q = new ArrayDeque<Integer>();
long[] N = new long[size];
long mod = 1000000007;
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
N[s] = 1;
while(!q.isEmpty()) {
int v = q.poll();
for(Edge e:list[v]) {
N[e.to] += N[v];
if(N[e.to]>=mod)N[e.to]-= mod;
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
return N;
}
void addEdge(int a,int b){
list[a].add(new Edge(b,1));
}
void addWeightedEdge(int a,int b,long c){
list[a].add(new Edge(b,c));
}
void addEgdes(int[] a,int[] b){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],1));
}
}
void addWeightedEdges(int[] a ,int[] b ,int[] c){
for(int i=0;i<a.length;i++){
list[a[i]].add(new Edge(b[i],c[i]));
}
}
long[] bfs(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
long[][] bfswithrev(int s){
long[][] L = new long[2][size];
for(int i=0;i<size;i++){
L[0][i] = -1;
L[1][i] = -1;
}
L[0][s] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[0][w]==-1){
L[0][w] = L[0][v] + c;
L[1][w] = v;
Q.add(w);
}
}
}
return L;
}
long[] bfs2(int[] d,int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int p = 0;
L[s] = 0;
d[s] = p;
p++;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(L[w]==-1){
d[w] = p;
p++;
L[w] = L[v] + c;
Q.add(w);
}
}
}
return L;
}
boolean bfs3(int s,long[] L, int[] vi){
if(vi[s]==1) return true;
vi[s] = 1;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(s);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
long c = e.cost;
if(vi[e.to]==0) {
L[e.to] = (int)c - L[v];
Q.add(w);
vi[e.to] = 1;
}else {
if(L[e.to]!=(int)c - L[v]) {
return false;
}
}
}
}
return true;
}
int[] isTwoColor(){
int[] L = new int[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
L[0] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(0);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
return L;
}
void isTwoColor2(int i,int[] L){
L[i] = 0;
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
while(!Q.isEmpty()){
int v = Q.poll();
for(Edge e:list[v]){
int w = e.to;
if(L[w]==-1){
L[w] = 1-L[v];
Q.add(w);
}else{
if(L[v]+L[w]!=1){
L[0] = -2;
}
}
}
}
}
long[] dijkstra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = 0;
PriorityQueue<LongIntPair> Q = new PriorityQueue<LongIntPair>(new LongIntComparator());
Q.add(new LongIntPair(0,s));
while(!Q.isEmpty()){
LongIntPair C = Q.poll();
if(v[C.b]==0){
L[C.b] = C.a;
v[C.b] = 1;
for(Edge D:list[C.b]) {
if(L[D.to]==-1||L[D.to]>L[C.b]+D.cost) {
L[D.to]=L[C.b]+D.cost;
Q.add(new LongIntPair(L[C.b]+D.cost,D.to));
}
}
}
}
return L;
}
ArrayList<Graph> makeapart(){
ArrayList<Graph> ans = new ArrayList<Graph>();
boolean[] b = new boolean[size];
int[] num = new int[size];
for(int i=0;i<size;i++){
if(b[i])continue;
int sz = 0;
ArrayList<Integer> l = new ArrayList<Integer>();
ArrayDeque<Integer> Q = new ArrayDeque<Integer>();
Q.add(i);
b[i] = true;
while(!Q.isEmpty()){
int v = Q.poll();
num[v] = sz;
sz++;
l.add(v);
for(Edge e:list[v]){
if(!b[e.to]){
Q.add(e.to);
b[e.to] = true;
}
}
}
Graph H = new Graph(sz);
for(int e:l){
for(Edge E:list[e]){
H.addWeightedEdge(num[e],num[E.to],E.cost);
}
}
ans.add(H);
}
return ans;
}
long[] bellmanFord(int s) {
long inf = 1000000000;
inf *= inf;
long[] d = new long[size];
boolean[] n = new boolean[size];
d[s] = 0;
for(int i=1;i<size;i++){
d[i] = inf;
d[i] *= d[i];
}
for(int i=0;i<size-1;i++){
for(int j=0;j<size;j++){
for(Edge E:list[j]){
if(d[j]!=inf&&d[E.to]>d[j]+E.cost){
d[E.to]=d[j]+E.cost;
}
}
}
}
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
for(Edge e:list[j]){
if(d[j]==inf) continue;
if(d[e.to]>d[j]+e.cost) {
d[e.to]=d[j]+e.cost;
n[e.to] = true;
}
if(n[j])n[e.to] = true;
}
}
}
for(int i=0;i<size;i++) {
if(n[i])d[i] = inf;
}
return d;
}
long[][] WarshallFloyd(long[][] a){
int n = a.length;
long[][] ans = new long[n][n];
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = a[i][j]==0?(long)1e16:a[i][j];
if(i==j)ans[i][j]=0;
}
}
for(int k=0;k<n;k++) {
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
ans[i][j] = Math.min(ans[i][j],ans[i][k]+ans[k][j]);
}
}
}
return ans;
}
long[] maxtra(int s,long l){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = -1;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator());
Q.add(new Pair(l,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.max(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long[] mintra(int s){
long[] L = new long[size];
for(int i=0;i<size;i++){
L[i] = -1;
}
int[] v = new int[size];
L[s] = s;
PriorityQueue<Pair> Q = new PriorityQueue<Pair>(new SampleComparator().reversed());
Q.add(new Pair(s,s));
while(!Q.isEmpty()){
Pair C = Q.poll();
if(v[(int)C.b]==0){
L[(int)C.b] = C.a;
v[(int) C.b] = 1;
for(Edge D:list[(int) C.b])Q.add(new Pair(Math.min(L[(int)C.b],D.cost),D.to));
}
}
return L;
}
long Kruskal(){
long r = 0;
for(int i=0;i<size;i++) {
for(Edge e:list[i]) {
Edges.add(new LinkEdge(e.cost,i,e.to));
}
}
UnionFindTree UF = new UnionFindTree(size);
for(LinkEdge e:Edges){
if(e.a>=0&&e.b>=0) {
if(!UF.same(e.a,e.b)){
r += e.L;
UF.unite(e.a,e.b);
}
}
}
return r;
}
ArrayList<Integer> Kahntsort(){
ArrayList<Integer> ans = new ArrayList<Integer>();
PriorityQueue<Integer> q = new PriorityQueue<Integer>();
int[] in = new int[size];
for(int i=0;i<size;i++) {
for(Edge e:list[i])in[e.to]++;
}
for(int i=0;i<size;i++) {
if(in[i]==0)q.add(i);
}
while(!q.isEmpty()) {
int v = q.poll();
ans.add(v);
for(Edge e:list[v]) {
in[e.to]--;
if(in[e.to]==0)q.add(e.to);
}
}
for(int i=0;i<size;i++) {
if(in[i]>0)return new ArrayList<Integer>();
}
return ans;
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
for(Edge e:list[i]) {
if(f[e.to]) continue;
if(v[e.to]&&!f[e.to]) {
return true;
}
if(findCycle(e.to,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
RootedTree dfsTree(int i) {
int[] u = new int[size];
RootedTree r = new RootedTree(size);
dfsTree(i,u,r);
return r;
}
private void dfsTree(int i, int[] u, RootedTree r) {
u[i] = 1;
r.trans[r.node] = i;
r.rev[i] = r.node;
r.node++;
for(Edge e:list[i]) {
if(u[e.to]==0) {
r.list[i].add(e);
u[e.to] = 1;
dfsTree(e.to,u,r);
}
}
}
}
class LightGraph {
ArrayList<Integer>[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
LightGraph(int N){
size = N;
list = new ArrayList[N];
for(int i=0;i<N;i++){
list[i] = new ArrayList<Integer>();
}
}
void addEdge(int a,int b){
list[a].add(b);
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
for(int e:list[i]) {
if(f[e]) continue;
if(v[e]&&!f[e]) {
return true;
}
if(findCycle(e,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
}
class FunGraph {
int[] list;
int size;
TreeSet<LinkEdge> Edges = new TreeSet<LinkEdge>(new LinkEdgeComparator());
@SuppressWarnings("unchecked")
FunGraph(int N){
size = N;
list = new int[N];
Arrays.fill(list,-1);
}
void addEdge(int a,int b){
list[a] = b;
}
public Stack<Integer> findCycle() {
Stack<Integer> ans = new Stack<Integer>();
boolean[] v = new boolean[size];
boolean[] f = new boolean[size];
for(int i=0;i<size;i++) {
if(findCycle(i,ans,v,f))break;
}
return ans;
}
private boolean findCycle(int i, Stack<Integer>ans, boolean[] v,boolean[] f) {
v[i] = true;
ans.push(i);
int e = list[i];
if(e!=-1&&!f[e]) {
if(v[e]&&!f[e]) {
return true;
}
if(findCycle(e,ans,v,f))return true;
}
ans.pop();
f[i] = true;
return false;
}
}
class Tree extends Graph{
static int[][] lcat;
static int[] depth;
public Tree(int N) {
super(N);
}
long[] tyokkei(){
long[] a = bfs(0);
int md = -1;
long m = 0;
for(int i=0;i<size;i++){
if(m<a[i]){
m = a[i];
md = i;
}
}
long[] b = bfs(md);
int md2 = -1;
long m2 = 0;
for(int i=0;i<size;i++){
if(m2<b[i]){
m2 = b[i];
md2 = i;
}
}
long[] r = {m2,md,md2};
return r;
}
int[] size(int r) {
int[] ret = new int[size];
dfssize(r,-1,ret);
return ret;
}
private int dfssize(int i, int rev, int[] ret) {
int sz = 1;
for(Edge e:list[i]) {
if(e.to!=rev) sz += dfssize(e.to,i,ret);
}
return ret[i] = sz;
}
void lcadfs(int i,int rev,int d) {
lcat[0][i] = rev;
depth[i] = d;
for(Edge e:list[i]) {
if(e.to!=rev)lcadfs(e.to,i,d+1);
}
}
void buildlca(int r){
lcat = new int[21][size];
depth = new int[size];
lcadfs(r,-1,0);
for(int i=0;i<20;i++) {
Arrays.fill(lcat[i+1],-1);
for(int j=0;j<size;j++) {
if(lcat[i][j]!=-1)lcat[i+1][j] = lcat[i][lcat[i][j]];
else lcat[i+1][j] = -1;
}
}
}
int lca(int a,int b) {
if(depth[a]>depth[b]) {
int tmp = a;
a = b;
b = tmp;
}
int d = depth[b]-depth[a];
for(int i=0;i<=20;i++) {
if(((d>>i)&1)==1)b = lcat[i][b];
}
if(a==b) return a;
for(int i=20;i>=0;i--) {
if(lcat[i][a]!=lcat[i][b]) {
a = lcat[i][a];
b = lcat[i][b];
}
}
return lcat[0][a];
}
}
class RootedTree extends Graph{
int[] trans;
int[] rev;
int node = 0;
RootedTree(int N){
super(N);
trans = new int[N];
rev = new int[N];
}
public int[] parents() {
int[] ret = new int[size];
for(int i=0;i<size;i++) {
for(Edge e:list[i]) {
ret[rev[e.to]] = rev[i];
}
}
ret[0] = -1;
return ret;
}
}
class LinkEdge{
long L;
int a ;
int b;
int id;
LinkEdge(long l,int A,int B){
L = l;
a = A;
b = B;
}
LinkEdge(long l,int A,int B,int i){
L = l;
a = A;
b = B;
id = i;
}
public boolean equals(Object o){
LinkEdge O = (LinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.L==this.L;
}
public int hashCode(){
return Objects.hash(L,a,b);
}
}
class DoubleLinkEdge{
double D;
int a;
int b;
DoubleLinkEdge(double d,int A,int B){
D = d;
a = A;
b = B;
}
public boolean equals(Object o){
DoubleLinkEdge O = (DoubleLinkEdge) o;
return O.a==this.a&&O.b==this.b&&O.D==this.D;
}
public int hashCode(){
return Objects.hash(D,a,b);
}
}
class Edge{
int to;
long cost;
Edge(int a,long b){
to = a;
cost = b;
}
}
class indexedEdge extends Edge{
int id;
indexedEdge(int a, long b, int c) {
super(a,b);
id = c;
}
}
class DoubleLinkEdgeComparator implements Comparator<DoubleLinkEdge>{
public int compare(DoubleLinkEdge P, DoubleLinkEdge Q) {
return Double.compare(P.D,Q.D);
}
}
class LinkEdgeComparator implements Comparator<LinkEdge>{
public int compare(LinkEdge P, LinkEdge Q) {
if(P.L==Q.L) {
if(P.a==Q.a) return Integer.compare(P.b,Q.b);
return Integer.compare(P.a,Q.a);
}
return Long.compare(P.L,Q.L);
}
}
class Pair{
long a;
long b;
Pair(long p,long q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
Pair O = (Pair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class SampleComparator implements Comparator<Pair>{
public int compare(Pair P, Pair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b==Q.b)return 0;
return P.b>Q.b?1:-1;
}
return t>=0?1:-1;
}
}
class LongIntPair{
long a;
int b;
LongIntPair(long p,int q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
LongIntPair O = (LongIntPair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class LongIntComparator implements Comparator<LongIntPair>{
public int compare(LongIntPair P, LongIntPair Q) {
long t = P.a-Q.a;
if(t==0){
if(P.b>Q.b){
return 1;
}else{
return -1;
}
}
return t>=0?1:-1;
}
}
class IntIntPair{
int a;
int b;
IntIntPair(int p,int q){
this.a = p;
this.b = q;
}
IntIntPair(int p,int q,String s){
if(s.equals("sort")) {
this.a = Math.min(p,q);
this.b = Math.max(p,q);
}
}
public boolean equals(Object o){
IntIntPair O = (IntIntPair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class IntIntComparator implements Comparator<IntIntPair>{
public int compare(IntIntPair P, IntIntPair Q) {
int t = P.a-Q.a;
if(t==0){
return P.b-Q.b;
}
return t;
}
}
class IntIntsecondComparator implements Comparator<IntIntPair>{
public int compare(IntIntPair P, IntIntPair Q) {
int t = P.b-Q.b;
if(t==0){
return P.a-Q.a;
}
return t;
}
}
class CIPair{
char c;
int i;
CIPair(char C,int I){
c = C;
i = I;
}
public boolean equals(Object o){
CIPair O = (CIPair) o;
return O.c==this.c&&O.i==this.i;
}
public int hashCode(){
return Objects.hash(c,i);
}
}
class DoublePair{
double a;
double b;
DoublePair(double p,double q){
this.a = p;
this.b = q;
}
public boolean equals(Object o){
DoublePair O = (DoublePair) o;
return O.a==this.a&&O.b==this.b;
}
public int hashCode(){
return Objects.hash(a,b);
}
}
class Triplet{
long a;
long b;
long c;
Triplet(long p,long q,long r){
a = p;
b = q;
c = r;
}
public boolean equals(Object o){
Triplet O = (Triplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c?true:false;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class Quadraplet{
long a;
long b;
long c;
long d;
Quadraplet(long p,long q,long r,long s){
a = p;
b = q;
c = r;
d = s;
}
public boolean equals(Object o){
Quadraplet O = (Quadraplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c&&O.d==this.d?true:false;
}
public int hashCode(){
return Objects.hash(a,b,c,d);
}
}
class TripletComparator implements Comparator<Triplet>{
public int compare(Triplet P, Triplet Q) {
long t = P.a-Q.a;
if(t==0){
long tt = P.b-Q.b;
if(tt==0) {
if(P.c>Q.c) {
return 1;
}else if(P.c<Q.c){
return -1;
}else {
return 0;
}
}
return tt>0?1:-1;
}
return t>=0?1:-1;
}
}
class DDComparator implements Comparator<DoublePair>{
public int compare(DoublePair P, DoublePair Q) {
return P.a-Q.a>=0?1:-1;
}
}
class DoubleTriplet{
double a;
double b;
double c;
DoubleTriplet(double p,double q,double r){
this.a = p;
this.b = q;
this.c = r;
}
public boolean equals(Object o){
DoubleTriplet O = (DoubleTriplet) o;
return O.a==this.a&&O.b==this.b&&O.c==this.c;
}
public int hashCode(){
return Objects.hash(a,b,c);
}
}
class DoubleTripletComparator implements Comparator<DoubleTriplet>{
public int compare(DoubleTriplet P, DoubleTriplet Q) {
if(P.a==Q.a) return 0;
return P.a-Q.a>0?1:-1;
}
}
class CheckingScanner {
Scanner sc = new Scanner(System.in);
String[] CheckedLine(int N){
String input = sc.nextLine();
if(input.charAt(input.length()-1)==' ') throw new EndSpaceException();
String[] ret = input.split(" ");
if(ret.length!=N) throw new ListLengthException();
return ret;
}
int[] nextboundedints(int N, int minimum, int maximum) {
String[] input = CheckedLine(N);
int[] ret = new int[N];
for(int i=0;i<N;i++) {
ret[i] = Integer.parseInt(input[i]);
checkbound(ret[i],minimum,maximum);
}
return ret;
}
long[] nextboundedlongs(int N, long minimum, long maximum) {
String[] input = CheckedLine(N);
long[] ret = new long[N];
for(int i=0;i<N;i++) {
ret[i] = Long.parseLong(input[i]);
checkbound(ret[i],minimum,maximum);
}
return ret;
}
void checkbound(long v, long minimum, long maximum) {
if(v<minimum || maximum<v) throw new OutofBoundException();
}
class ListLengthException extends RuntimeException{
}
class EndSpaceException extends RuntimeException{
}
class OutofBoundException extends RuntimeException{
}
}
class FastScanner {
private final java.io.InputStream in = System.in;
private final byte[] b = new byte[1024];
private int p = 0;
private int bl = 0;
private boolean hNB() {
if (p<bl) {
return true;
}else{
p = 0;
try {
bl = in.read(b);
} catch (IOException e) {
e.printStackTrace();
}
if (bl<=0) {
return false;
}
}
return true;
}
private int rB() { if (hNB()) return b[p++]; else return -1;}
private static boolean iPC(int c) { return 33 <= c && c <= 126;}
private void sU() { while(hNB() && !iPC(b[p])) p++;}
public boolean hN() { sU(); return hNB();}
public String next() {
if (!hN()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = rB();
while(iPC(b)) {
sb.appendCodePoint(b);
b = rB();
}
return sb.toString();
}
public char nextChar() {
return next().charAt(0);
}
public long nextLong() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b=='-') {
m=true;
b=rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b - '0';
}else if(b == -1||!iPC(b)){
return (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int nextInt() {
if (!hN()) throw new NoSuchElementException();
long n = 0;
boolean m = false;
int b = rB();
if (b == '-') {
m = true;
b = rB();
}
if (b<'0'||'9'<b) {
throw new NumberFormatException();
}
while(true){
if ('0'<=b&&b<='9') {
n *= 10;
n += b-'0';
}else if(b==-1||!iPC(b)){
return (int) (m?-n:n);
}else{
throw new NumberFormatException();
}
b = rB();
}
}
public int[] nextInts(int n) {
int[] a = new int[n];
for(int i=0;i<n;i++) {
a[i] = nextInt();
}
return a;
}
public int[] nextInts(int n,int s) {
int[] a = new int[n+s];
for(int i=s;i<n+s;i++) {
a[i] = nextInt();
}
return a;
}
public long[] nextLongs(int n, int s) {
long[] a = new long[n+s];
for(int i=s;i<n+s;i++) {
a[i] = nextLong();
}
return a;
}
public long[] nextLongs(int n) {
long[] a = new long[n];
for(int i=0;i<n;i++) {
a[i] = nextLong();
}
return a;
}
public int[][] nextIntses(int n,int m){
int[][] a = new int[n][m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
a[i][j] = nextInt();
}
}
return a;
}
public String[] nexts(int n) {
String[] a = new String[n];
for(int i=0;i<n;i++) {
a[i] = next();
}
return a;
}
void nextIntses(int n,int[] ...m) {
int l = m[0].length;
for(int i=0;i<l;i++) {
for(int j=0;j<m.length;j++) {
m[j][i] = nextInt();
}
}
}
void nextLongses(int n,long[] ...m) {
int l = m[0].length;
for(int i=0;i<l;i++) {
for(int j=0;j<m.length;j++) {
m[j][i] = nextLong();
}
}
}
Graph nextyukoGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
G.addEdge(a,b);
}
return G;
}
Graph nextGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
G.addEdge(a,b);
G.addEdge(b,a);
}
return G;
}
Graph nextWeightedGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
long c = nextLong();
G.addWeightedEdge(a,b,c);
G.addWeightedEdge(b,a,c);
}
return G;
}
Graph nextWeightedyukoGraph(int n,int m) {
Graph G = new Graph(n);
for(int i=0;i<m;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
long c = nextLong();
G.addWeightedEdge(a,b,c);
}
return G;
}
Tree nextTree(int n) {
Tree T = new Tree(n);
for(int i=0;i<n-1;i++) {
int a = nextInt()-1;
int b = nextInt()-1;
T.addEdge(a,b);
T.addEdge(b,a);
}
return T;
}
}
class Mathplus{
long mod = 1000000007;
long[] fac;
long[] revfac;
long[][] comb;
long[] pow;
long[] revpow;
boolean isBuild = false;
boolean isBuildc = false;
boolean isBuildp = false;
int mindex = -1;
int maxdex = -1;
int graydiff = 0;
int graymark = 0;
int[] ml_prs = {2,3,5,7,11,13,17,19,23,29,31,37};
void printdecimal(double d,int k) {
BigDecimal A = new BigDecimal(d);
A = A.setScale(k,BigDecimal.ROUND_HALF_UP);
String format = "%." + k + "f";
System.out.printf(format,A);
}
public boolean isdistinct(int[] k) {
HashSet<Integer> s = new HashSet<Integer>();
for(int e:k)s.add(e);
return k.length==s.size();
}
public void printtable(Object[] a) {
for(int i=0;i<a.length-1;i++) {
System.out.print(a[i]+" ");
}
System.out.println(a[a.length-1]);
}
public void printtable(int[] a) {
for(int i=0;i<a.length-1;i++) {
System.out.print(a[i]+" ");
}
System.out.println(a[a.length-1]);
}
int LIS(int N, int[] a) {
int[] dp = new int[N+1];
Arrays.fill(dp,(int)mod);
for(int i=0;i<N;i++) {
int ok = 0;
int ng = N;
while(ng-ok>1) {
int mid = (ok+ng)/2;
if(dp[mid]<a[i])ok = mid;
else ng = mid;
}
dp[ok+1] = a[i];
}
int ok = 0;
for(int i=1;i<=N;i++) {
if(dp[i]<mod)ok=i;
}
return ok;
}
public Integer[] Ints(int n, int i) {
Integer[] ret = new Integer[n];
Arrays.fill(ret,i);
return ret;
}
public Long[] Longs(int n, long i) {
Long[] ret = new Long[n];
Arrays.fill(ret,i);
return ret;
}
public boolean nexperm(int[] p) {
int n = p.length;
for(int i=n-1;i>0;i--) {
if(p[i-1]<p[i]) {
int sw = n;
for(int j=n-1;j>=i;j--) {
if(p[i-1]<p[j]) {
sw = j;
break;
}
}
int tmp = p[i-1];
p[i-1] = p[sw];
p[sw] = tmp;
int[] r = new int[n];
for(int j=i;j<n;j++) {
r[j] = p[n-1-j+i];
}
for(int j=i;j<n;j++) {
p[j] = r[j];
}
return true;
}
}
return false;
}
public int[] shuffledperm(int n) {
int[] ret = makeperm(n);
Random rand = new Random();
for(int i=n-1;i>0;i--) {
int j = rand.nextInt(i+1);
swap(ret,i,j);
}
return ret;
}
public void swap(int[] p, int i, int j) {
if(i==j) return;
int tmp = p[i];
p[i] = p[j];
p[j] = tmp;
}
public int[] makeperm(int n) {
int[] a = new int[n];
for(int i=0;i<n;i++) {
a[i] = i;
}
return a;
}
int color(int[][] diff,int N) {
int[] val = new int[1<<N];
val[0] = 1;
for(int i=0;i<(1<<N);i++) {
for(int j=0;j<N;j++) {
if(contains(i,j)) {
if(val[bitremove(i,j)]==1) {
boolean b = true;
for(int k=0;k<N;k++) {
if(contains(i,k)&&diff[j][k]==1) {
b = false;
}
}
if(b)val[i] = 1;
}
break;
}
}
}
int[] dp = new int[1<<N];
Arrays.fill(dp,N+1);;
dp[0] = 0;
for(int i=0;i<(1<<N);i++) {
for(int j=i;j>0;j=(j-1)&i) {
if(val[j]==1)dp[i]=Math.min(dp[i],dp[i^j]+1);
}
}
return dp[(1<<N)-1];
}
public void timeout() throws InterruptedException {
Thread.sleep(10000);
}
public int gray(int i,int m) {
for(int j=0;j<m;j++) {
if(contains(i,j)) {
graydiff = j;
if(contains(i,j+1))graymark=-1;
else graymark = 1;
break;
}
}
return i ^ (i>>1);
}
public void hakidashi(long[] A) {
Arrays.sort(A);
int N = A.length;
int[] index = new int[61];
for(int i=0;i<=60;i++){
index[i] = -1;
}
int searching = 60;
int [] used = new int[N];
while(searching>=0){
boolean b = true;
for(int i=N-1;i>=0;i--){
for(int j=60;j>searching;j--){
if((A[i]>>j&1)==1){
if(i!=index[j]&&index[j]!=-1){
A[i] ^= A[index[j]];
//System.out.println(i+" changed by " + index[j]);
//System.out.println(A[i]);
}
}
}
if((A[i]>>searching&1)==1&&used[i]==0){
//System.out.println("find " + searching+" is "+i);
index[searching] = i;
searching--;
used[i] = 1;
b = false;
if(searching==-1){
searching = 0;
}
}
}
if(b){
searching--;
}
}
for(int i=N-1;i>=0;i--){
for(int j=60;j>=searching;j--){
if((A[i]>>j&1)==1){
if(i!=index[j]&&index[j]!=-1){
A[i] ^= A[index[j]];
}
}
}
}
Arrays.sort(A);
}
public void printjudge(boolean b, String y, String n) {
System.out.println(b?y:n);
}
public void printYN(boolean b) {
printjudge(b,"Yes","No");
}
public void printyn(boolean b) {
printjudge(b,"yes","no");
}
public void reverse(int[] x) {
int[] r = new int[x.length];
for(int i=0;i<x.length;i++)r[i] = x[x.length-1-i];
for(int i=0;i<x.length;i++)x[i] = r[i];
}
public void reverse(long[] x) {
long[] r = new long[x.length];
for(int i=0;i<x.length;i++)r[i] = x[x.length-1-i];
for(int i=0;i<x.length;i++)x[i] = r[i];
}
public DoubleTriplet Line(double x1,double y1,double x2,double y2) {
double a = y1-y2;
double b = x2-x1;
double c = x1*y2-x2*y1;
return new DoubleTriplet(a,b,c);
}
public double putx(DoubleTriplet T,double x) {
return -(T.a*x+T.c)/T.b;
}
public double puty(DoubleTriplet T,double y) {
return -(T.b*y+T.c)/T.a;
}
public double Distance(DoublePair P,DoublePair Q) {
return Math.sqrt((P.a-Q.a) * (P.a-Q.a) + (P.b-Q.b) * (P.b-Q.b));
}
public double DistanceofPointandLine(DoublePair P,Triplet T) {
return Math.abs(P.a*T.a+P.b*T.b+T.c) / Math.sqrt(T.a*T.a+T.b*T.b);
}
public boolean cross(long ax, long ay, long bx, long by, long cx, long cy, long dx, long dy) {
if((ax-bx)*(cy-dy)==(ay-by)*(cx-dx)) {
if(ax-bx!=0) {
Range A = new Range(ax,bx);
Range B = new Range(cx,dx);
return A.kasanari(B)>0;
}else {
Range A = new Range(ay,by);
Range B = new Range(cy,dy);
return A.kasanari(B)>0;
}
}
long ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
long tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
long tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
long td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
public boolean cross2(long ax, long ay, long bx, long by, long cx, long cy, long dx, long dy) {
long ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
long tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
long tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
long td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>0&&td<0)||(tc<0&&td>0))&&((ta>0&&tb<0)||(ta<0&&tb>0));
}
public boolean dcross(double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return((tc>=0&&td<=0)||(tc<=0&&td>=0))&&((ta>=0&&tb<=0)||(ta<=0&&tb>=0));
}
void buildFac(){
fac = new long[10000003];
revfac = new long[10000003];
fac[0] = 1;
for(int i=1;i<=10000002;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[10000002] = rev(fac[10000002])%mod;
for(int i=10000001;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
void buildFacn(int n){
fac = new long[n+1];
revfac = new long[n+1];
fac[0] = 1;
for(int i=1;i<=n;i++){
fac[i] = (fac[i-1] * i)%mod;
}
revfac[n] = rev(fac[n])%mod;
for(int i=n-1;i>=0;i--) {
revfac[i] = (revfac[i+1] * (i+1))%mod;
}
isBuild = true;
}
public long[] buildrui(int[] a) {
int n = a.length;
long[] ans = new long[n];
ans[0] = a[0];
for(int i=1;i<n;i++) {
ans[i] = ans[i-1] + a[i];
}
return ans;
}
public long[] buildrui(long[] a) {
int n = a.length;
long[] ans = new long[n];
ans[0] = a[0];
for(int i=1;i<n;i++) {
ans[i] = ans[i-1] + a[i];
}
return ans;
}
public int[][] ibuildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
int[][] ans = new int[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
public void buildruin(int[][] a) {
int n = a.length;
int m = a[0].length;
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
a[i][j] += a[i][j-1] + a[i-1][j] - a[i-1][j-1];
}
}
}
public long[][] buildrui(int[][] a) {
int n = a.length;
int m = a[0].length;
long[][] ans = new long[n][m];
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] = a[i][j];
}
}
for(int i=1;i<n;i++) {
for(int j=1;j<m;j++) {
ans[i][j] += ans[i][j-1] + ans[i-1][j] - ans[i-1][j-1];
}
}
return ans;
}
public int getrui(int[][] r,int a,int b,int c,int d) {
return r[c][d] - r[a-1][d] - r[c][b-1] + r[a-1][b-1];
}
public long getrui(long[][] r,int a,int b,int c,int d) {
if(a<0||b<0||c>=r.length||d>=r[0].length) return mod;
return r[c][d] - r[a-1][d] - r[c][b-1] + r[a-1][b-1];
}
long divroundup(long n,long d) {
if(n==0)return 0;
return (n-1)/d+1;
}
public long sigma(long i) {
return i*(i+1)/2;
}
public int digit(long i) {
int ans = 1;
while(i>=10) {
i /= 10;
ans++;
}
return ans;
}
public int digitsum(long n) {
int ans = 0;
while(n>0) {
ans += n%10;
n /= 10;
}
return ans;
}
public int popcount(int i) {
int ans = 0;
while(i>0) {
ans += i%2;
i /= 2;
}
return ans;
}
public int popcount(long i) {
int ans = 0;
while(i>0) {
ans += i%2;
i /= 2;
}
return ans;
}
public boolean contains(int S,int i) {return (S>>i&1)==1;}
public int bitremove(int S,int i) {return S&(~(1<<i));}
public int bitadd(int S,int i) {return S|(1<<i);}
public boolean isSubSet(int S,int T) {return (S-T)==(S^T);}
public boolean isDisjoint(int S,int T) {return (S+T)==(S^T);}
public boolean contains(long S,int i) {return (S>>i&1)==1;}
public long bitremove(long S,int i) {return S&(~(1<<i));}
public long bitadd(long S,int i) {return S|(1<<i);}
public boolean isSubSet(long S,long T) {return (S-T)==(S^T);}
public boolean isDisjoint(long S,long T) {return (S+T)==(S^T);}
public int isBigger(int[] d, int i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(int[] d, int i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(long[] d, long i) {
int ok = d.length;
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(long[] d, long i) {
int ok = -1;
int ng = d.length;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d[mid]<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(ArrayList<Integer> d, int i) {
int ok = d.size();
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(ArrayList<Integer> d, int i) {
int ok = -1;
int ng = d.size();
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isBigger(ArrayList<Long> d, long i) {
int ok = d.size();
int ng = -1;
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)>i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public int isSmaller(ArrayList<Long> d, long i) {
int ok = -1;
int ng = d.size();
while(Math.abs(ok-ng)>1) {
int mid = (ok+ng)/2;
if(d.get(mid)<i) {
ok = mid;
}else {
ng = mid;
}
}
return ok;
}
public HashSet<Integer> primetable(int m) {
HashSet<Integer> pt = new HashSet<Integer>();
for(int i=2;i<=m;i++) {
boolean b = true;
for(int d:pt) {
if(i%d==0) {
b = false;
break;
}
}
if(b) {
pt.add(i);
}
}
return pt;
}
public ArrayList<Integer> primetablearray(int m) {
ArrayList<Integer> al = new ArrayList<Integer>();
Queue<Integer> q = new ArrayDeque<Integer>();
for(int i=2;i<=m;i++) {
q.add(i);
}
boolean[] b = new boolean[m+1];
while(!q.isEmpty()) {
int e = q.poll();
if(!b[e]) {
al.add(e);
for(int j=1;e*j<=m;j++) {
b[e*j] = true;
}
}
}
return al;
}
public boolean isprime(int e) {
if(e==1) return false;
for(int i=2;i*i<=e;i++) {
if(e%i==0) return false;
}
return true;
}
public boolean isprime_ml(long n) {
if(n>2&&n%2==0) return false;
for(int a:ml_prs) {
if(a>=n) continue;
long nn = n-1;
int s = 0;
while(nn%2==0) {
s++;
nn /= 2;
}
long w = pow_mod(a,nn,n);
for(int i=0;i<s;i++) {
long ww = w * w % n;
if(ww==1) {
if(w!=1 && w!=n-1) return false;
}
w = ww;
}
if(w!=1) return false;
}
return true;
}
public long factor_pp(long e) {
if(e==1 || isprime_ml(e)) return e;
else {
while(true) {
long a = 2;
long b = 2;
long d = 1;
long rd1 = new Random().nextInt(100000)%e;
long rd2 = new Random().nextInt(100000)%e;
while(d==1) {
a = (rd1 * a + rd2) % e;
b = (rd1 * b + rd2) % e;
b = (rd1 * b + rd2) % e;
d = gcd(Math.abs(a-b),e);
}
if(d!=e) return factor_pp(d);
}
}
}
public MultiSetL factorization(long e) {
MultiSetL ret = new MultiSetL();
for(long i=2;i*i<=e;i++) {
while(e%i==0) {
ret.add(i);
e /= i;
}
}
if(e!=1)ret.add(e);
return ret;
}
public int[] hipPush(int[] a){
int[] r = new int[a.length];
int[] s = new int[a.length];
for(int i=0;i<a.length;i++) {
s[i] = a[i];
}
Arrays.sort(s);
HashMap<Integer,Integer> m = new HashMap<Integer,Integer>();
for(int i=0;i<a.length;i++) {
if(!m.containsKey(s[i]))m.put(s[i],m.size());
}
for(int i=0;i<a.length;i++) {
r[i] = m.get(a[i]);
}
return r;
}
public HashMap<Integer,Integer> hipPush(ArrayList<Integer> l){
HashMap<Integer,Integer> r = new HashMap<Integer,Integer>();
TreeSet<Integer> s = new TreeSet<Integer>();
for(int e:l)s.add(e);
int p = 0;
for(int e:s) {
r.put(e,p);
p++;
}
return r;
}
public TreeMap<Integer,Integer> thipPush(ArrayList<Integer> l){
TreeMap<Integer,Integer> r = new TreeMap<Integer,Integer>();
Collections.sort(l);
int b = -(1000000007+9393);
int p = 0;
for(int e:l) {
if(b!=e) {
r.put(e,p);
p++;
}
b=e;
}
return r;
}
int[] count(int[] a) {
int[] c = new int[max(a)+1];
for(int i=0;i<a.length;i++) {
c[a[i]]++;
}
return c;
}
int[] count(int[] a, int m) {
int[] c = new int[m+1];
for(int i=0;i<a.length;i++) {
c[a[i]]++;
}
return c;
}
long max(long[] a){
long M = Long.MIN_VALUE;
for(int i=0;i<a.length;i++){
if(M<=a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
int max(int[] a){
int M = Integer.MIN_VALUE;
for(int i=0;i<a.length;i++){
if(M<=a[i]){
M =a[i];
maxdex = i;
}
}
return M;
}
long min(long[] a){
long m = Long.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
int min(int[] a){
int m = Integer.MAX_VALUE;
for(int i=0;i<a.length;i++){
if(m>a[i]){
m =a[i];
mindex = i;
}
}
return m;
}
long sum(long[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long sum(int[] a){
long s = 0;
for(int i=0;i<a.length;i++)s += a[i];
return s;
}
long sum(ArrayList<Integer> l) {
long s = 0;
for(int e:l)s += e;
return s;
}
long gcd(long a, long b){
a = Math.abs(a);
b = Math.abs(b);
if(a==0)return b;
if(b==0)return a;
if(a%b==0) return b;
else return gcd(b,a%b);
}
long gcd(long [] a){
long g = a[0];
for(int i=1;i<a.length;i++) {
g = gcd(g,a[i]);
}
return g;
}
int igcd(int a, int b) {
if(a%b==0) return b;
else return igcd(b,a%b);
}
long lcm(long a, long b) {return a / gcd(a,b) * b;}
public long perm(int a,int num) {
if(!isBuild)buildFac();
return fac[a]*(rev(fac[a-num]))%mod;
}
void buildComb(int N) {
comb = new long[N+1][N+1];
comb[0][0] = 1;
for(int i=1;i<=N;i++) {
comb[i][0] = 1;
for(int j=1;j<N;j++) {
comb[i][j] = comb[i-1][j-1]+comb[i-1][j];
if(comb[i][j]>mod)comb[i][j]-=mod;
}
comb[i][i] = 1;
}
}
public long comb(int a,int num){
if(a-num<0)return 0;
if(num<0)return 0;
if(!isBuild)buildFac();
if(a>10000000) return combN(a,num);
return fac[a] * ((revfac[num]*revfac[a-num])%mod)%mod;
}
long combN(int a,int num) {
long ans = 1;
for(int i=0;i<num;i++) {
ans *= a-i;
ans %= mod;
}
return ans * revfac[num] % mod;
}
long mulchoose(int n,int k) {
if(k==0) return 1;
return comb(n+k-1,k);
}
long rev(long l) {return pow(l,mod-2);}
void buildpow(int l,int i) {
pow = new long[i+1];
pow[0] = 1;
for(int j=1;j<=i;j++) {
pow[j] = pow[j-1]*l;
if(pow[j]>mod)pow[j] %= mod;
}
}
void buildrevpow(int l,int i) {
revpow = new long[i+1];
revpow[0] = 1;
long r = rev(l);
for(int j=1;j<=i;j++) {
revpow[j] = revpow[j-1]*r;
if(revpow[j]>mod) revpow[j] %= mod;
}
}
long pow(long l, long i) {
if(i==0)return 1;
else{
if(i%2==0){
long val = pow(l,i/2);
return val * val % mod;
}
else return pow(l,i-1) * l % mod;
}
}
long pow_mod(long l, long i, long m) {
if(i==0)return 1;
else{
if(i%2==0){
long val = pow_mod(l,i/2,m);
return val * val % m;
}
else return pow_mod(l,i-1,m) * l % m;
}
}
long mon(int i) {
long ans = 0;
for(int k=2;k<=i;k++) {
ans += (k%2==0?1:-1) * revfac[k];
ans += mod;
}
ans %= mod;
ans *= fac[i];
return ans%mod;
}
long tent(int[] a, int l, int r) {
if(l+1==r) return 0;
int mid = (l+r)/2;
long ans = tent(a,l,mid)+tent(a,mid,r);
int[] L = new int[mid-l];
int[] R = new int[r-mid];
for(int i=l;i<mid;i++) {
L[i-l] = a[i];
}
for(int i=mid;i<r;i++) {
R[i-mid] = a[i];
}
Arrays.sort(L);
Arrays.sort(R);
int X = L.length;
int Y = R.length;
int k = -1;
for(int i=0;i<X;i++) {
while(k!=Y-1&&R[k+1]<L[i])k++;
ans += k+1;
}
return ans;
}
long dictnum(int[] A) {
int N = A.length;
long ans = 0;
BinaryIndexedTree bit = new BinaryIndexedTree(N+1);
buildFacn(N);
for(int i=1;i<=N;i++) {
bit.add(i,1);
}
for(int i=1;i<=N;i++) {
int a = A[i-1];
ans += bit.sum(a-1) * fac[N-i] % mod;
bit.add(a,-1);
}
return (ans+1)%mod;
}
}
| ConDefects/ConDefects/Code/abc290_f/Java/39037383 |
condefects-java_data_1608 | import java.io.*;
import java.util.*;
public class Main {
static Scanner sc;
static PrintWriter out;
public static void main(String[] args) {
sc = new Scanner(System.in);
out = new PrintWriter(System.out);
new Main().solve();
out.flush();
}
public void solve() {
init(2000010);
int n = sc.nextInt();
for(int i=0; i<n; i++) {
solve2();
}
}
void solve2() {
int n = sc.nextInt();
if(n==2) {
out.println(1);
return;
}
long res = (n-1) % mod * n %mod * n %mod * ((n * n %mod + mod - 3) % mod) % mod * fac[2*n-4] % mod * finv[n] % mod * finv[n] % mod;
res %= mod;
out.println(res);
}
private static long mod = 998244353;
static long[] fac;
static long[] finv;
static long[] inv;
static void init(int max) {
fac = new long[max];
finv = new long[max];
inv = new long[max];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i=2; i<max; i++) {
fac[i] = fac[i-1] * i % mod;
inv[i] = mod - inv[(int)mod%i] * (mod / i) % mod;
finv[i] = finv[i-1] * inv[i] % mod;
}
}
static long conv(int n, int k) {
if(n<k || n<0 || k<0) return 0;
return fac[n] * (finv[k]*finv[n-k]%mod) % mod;
}
}
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc;
static PrintWriter out;
public static void main(String[] args) {
sc = new Scanner(System.in);
out = new PrintWriter(System.out);
new Main().solve();
out.flush();
}
public void solve() {
init(2000010);
int n = sc.nextInt();
for(int i=0; i<n; i++) {
solve2();
}
}
void solve2() {
int n = sc.nextInt();
if(n==2) {
out.println(1);
return;
}
long res = (n-1) % mod * n %mod * n %mod * ((((long)n * n) %mod + mod - 3) % mod) % mod * fac[2*n-4] % mod * finv[n] % mod * finv[n] % mod;
res %= mod;
out.println(res);
}
private static long mod = 998244353;
static long[] fac;
static long[] finv;
static long[] inv;
static void init(int max) {
fac = new long[max];
finv = new long[max];
inv = new long[max];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i=2; i<max; i++) {
fac[i] = fac[i-1] * i % mod;
inv[i] = mod - inv[(int)mod%i] * (mod / i) % mod;
finv[i] = finv[i-1] * inv[i] % mod;
}
}
static long conv(int n, int k) {
if(n<k || n<0 || k<0) return 0;
return fac[n] * (finv[k]*finv[n-k]%mod) % mod;
}
}
| ConDefects/ConDefects/Code/abc290_f/Java/39046488 |
condefects-java_data_1609 | import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
ArrayList<String> list = new ArrayList<>();
int[] price = new int[M];
String[] strs = new String[N];
for(int i = 0; i < N; i++) {
strs[i] = scanner.next();
}
for(int i = 0; i < M; i++) {
String str = scanner.next();
list.add(str);
}
int default_price = scanner.nextInt();
for(int i = 0; i < N - 1; i++) {
price[i] = scanner.nextInt();
}
int result = 0;
for(String key : strs) {
int money = list.contains(key) ? price[list.indexOf(key)] : default_price;
result += money;
}
System.out.println(result);
}
}
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int M = scanner.nextInt();
ArrayList<String> list = new ArrayList<>();
int[] price = new int[M];
String[] strs = new String[N];
for(int i = 0; i < N; i++) {
strs[i] = scanner.next();
}
for(int i = 0; i < M; i++) {
String str = scanner.next();
list.add(str);
}
int default_price = scanner.nextInt();
for(int i = 0; i < M; i++) {
price[i] = scanner.nextInt();
}
int result = 0;
for(String key : strs) {
int money = list.contains(key) ? price[list.indexOf(key)] : default_price;
result += money;
}
System.out.println(result);
}
}
| ConDefects/ConDefects/Code/abc308_b/Java/44890750 |
condefects-java_data_1610 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
int H = sc.nextInt(), W = sc.nextInt();
int R = sc.nextInt(), C = sc.nextInt();
int ans = 4;
if(R==H) ans--;
if(R==0) ans--;
if(C==W) ans--;
if(C==1) ans--;
System.out.println(ans);
}
}
class MyScanner {
public Scanner sc = new Scanner(System.in);
public int nextInt() {
return Integer.parseInt(sc.next());
}
public long nextLong() {
return Long.parseLong(sc.next());
}
public double nextDouble() {
return Double.parseDouble(sc.next());
}
public String next() {
return sc.next();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
int H = sc.nextInt(), W = sc.nextInt();
int R = sc.nextInt(), C = sc.nextInt();
int ans = 4;
if(R==H) ans--;
if(R==1) ans--;
if(C==W) ans--;
if(C==1) ans--;
System.out.println(ans);
}
}
class MyScanner {
public Scanner sc = new Scanner(System.in);
public int nextInt() {
return Integer.parseInt(sc.next());
}
public long nextLong() {
return Long.parseLong(sc.next());
}
public double nextDouble() {
return Double.parseDouble(sc.next());
}
public String next() {
return sc.next();
}
} | ConDefects/ConDefects/Code/abc250_a/Java/54466071 |
condefects-java_data_1611 | import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
public class Main {
static long MOD = 998244353;
int min = Integer.MAX_VALUE;
int max = 0;
int count = 0;
int pattern = 0;
int k = 0;
Map<Long, Long> map = new HashMap<Long, Long>();
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new File("t.a"));
var sc = new FastScanner();
// Scanner sc = new Scanner(System.in);
// var sc = new FastScanner(fis);
// var pw = new FastPrintStream("t.y");
var pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}
static class S {
static final S E = new S(0);
long sum;
public S(long s) {
this.sum = s;
}
public static S op(S l, S r) {
return new S(l.sum);
}
public String toString() {
return String.valueOf(sum);
}
}
static class F {
static final F I = new F(0);
long a;
public F(long a) {
this.a = a;
}
public static F composite(F f, F g) {
return new F(f.a + g.a);
}
}
static S map(F f, S s) {
return new S(f.a + s.sum);
}
public static void solve(FastScanner sc, FastPrintStream pw) throws Exception {
int times = sc.nextInt();
for (int time=0;time<times;time++) {
long a[] = new long[5];
long p[] = new long[5];
Arrays.setAll(a, i->sc.nextLong());
Arrays.setAll(p, i->sc.nextLong());
long now =0;
long count =0;
for (int i=0;i<5;i++) {
now+=a[i]*(i+1);
count += a[i];
}
if (now/count>=3) {
pw.println(0);
continue;
}
long sa = 3*count -now;
if (p[3]>=p[4]/2) {
// a==0
if (sa%2==1) {
long b = sa/2;
pw.println(Math.min(p[3]+p[4]*b, p[4]*(b+1)));
} else {
pw.println(sa*p[4]/2);
}
} else {
pw.println(sa*p[3]);
}
}
}
public static String dfs(Point src, Point tar, int h[][], int v[][], int n) {
int dfs[][] = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dfs[i][j] = Integer.MAX_VALUE;
}
}
dfs[src.x][src.y] = 0;
StringBuffer sb = new StringBuffer();
List<Point> list = new ArrayList<>();
list.add(src);
while (list.size() > 0) {
List<Point> temp = new ArrayList<>();
int access[][] = new int[n][n];
for (Point p : list) {
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0 && dfs[p.x - 1][p.y] > dfs[p.x][p.y] + 1) {
dfs[p.x - 1][p.y] = dfs[p.x][p.y] + 1;
if (access[p.x - 1][p.y] == 0) {
access[p.x - 1][p.y]++;
temp.add(new Point(p.x - 1, p.y));
}
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0 && dfs[p.x + 1][p.y] > dfs[p.x][p.y] + 1) {
dfs[p.x + 1][p.y] = dfs[p.x][p.y] + 1;
if (access[p.x + 1][p.y] == 0) {
access[p.x + 1][p.y]++;
temp.add(new Point(p.x + 1, p.y));
}
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0 && dfs[p.x][p.y - 1] > dfs[p.x][p.y] + 1) {
dfs[p.x][p.y - 1] = dfs[p.x][p.y] + 1;
if (access[p.x][p.y - 1] == 0) {
access[p.x][p.y - 1]++;
temp.add(new Point(p.x, p.y - 1));
}
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0 && dfs[p.x][p.y + 1] > dfs[p.x][p.y] + 1) {
dfs[p.x][p.y + 1] = dfs[p.x][p.y] + 1;
if (access[p.x][p.y + 1] == 0) {
access[p.x][p.y + 1]++;
temp.add(new Point(p.x, p.y + 1));
}
}
}
}
list = temp;
}
Point now = new Point(tar.x, tar.y);
for (int i = dfs[tar.x][tar.y]; i > 0; i--) {
if (now.x - 1 >= 0) {
if (h[now.x - 1][now.y] == 0 && dfs[now.x - 1][now.y] == i - 1) {
now = new Point(now.x - 1, now.y);
sb.append("D");
continue;
}
}
if (now.x + 1 < n) {
if (h[now.x][now.y] == 0 && dfs[now.x + 1][now.y] == i - 1) {
now = new Point(now.x + 1, now.y);
sb.append("U");
continue;
}
}
if (now.y - 1 >= 0) {
if (v[now.x][now.y - 1] == 0 && dfs[now.x][now.y - 1] == i - 1) {
now = new Point(now.x, now.y - 1);
sb.append("R");
continue;
}
}
if (now.y + 1 < n) {
if (v[now.x][now.y] == 0 && dfs[now.x][now.y + 1] == i - 1) {
now = new Point(now.x, now.y + 1);
sb.append("L");
continue;
}
}
}
StringBuffer re = new StringBuffer();
String temp = sb.toString();
for (int i = 0; i < temp.length(); i++) {
re.append(temp.charAt(temp.length() - i - 1));
}
return re.toString();
}
public static void changePosition(int a[][], Point p1, Point p2, Point position[]) {
int temp = a[p1.x][p1.y];
a[p1.x][p1.y] = a[p2.x][p2.y];
a[p2.x][p2.y] = temp;
position[a[p1.x][p1.y] - 1] = new Point(p1.x, p1.y);
position[a[p2.x][p2.y] - 1] = new Point(p2.x, p2.y);
}
public static int countPattern(Point p, int n, int h[][], int v[][]) {
int count = 0;
List<MovePosition> list = new ArrayList();
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0) {
count++;
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0) {
count++;
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0) {
count++;
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0) {
count++;
}
}
return count;
}
public static Point moveNext(Point p, int n, int h[][], int v[][], FastPrintStream pw) {
Random random = new Random();
List<MovePosition> list = new ArrayList();
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0) {
list.add(new MovePosition('U', -1, 0));
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0) {
list.add(new MovePosition('D', 1, 0));
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0) {
list.add(new MovePosition('L', 0, -1));
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0) {
list.add(new MovePosition('R', 0, 1));
}
}
MovePosition next = list.get(random.nextInt(list.size()));
pw.print(next.c + " ");
return new Point(p.x + next.x, p.y + next.y);
}
public static long countPoint(Point p, int n, int v[][], int h[][], long a[][]) {
long re = 0;
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0) {
re += (a[p.x - 1][p.y] - a[p.x][p.y]) + (a[p.x - 1][p.y] - a[p.x][p.y]);
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0) {
re += (a[p.x + 1][p.y] - a[p.x][p.y]) + (a[p.x + 1][p.y] - a[p.x][p.y]);
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0) {
re += (a[p.x][p.y - 1] - a[p.x][p.y]) + (a[p.x][p.y - 1] - a[p.x][p.y]);
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0) {
re += (a[p.x][1 + p.y] - a[p.x][p.y]) + (a[p.x][1 + p.y] - a[p.x][p.y]);
}
}
return re;
}
public static long sum(long first, long count) {
long last = first - count + 1;
return (first + last) * count / 2;
}
public static void searchPass(char c[][], int re[][], Point start, int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
re[i][j] = Integer.MAX_VALUE / 4;
}
}
re[start.x][start.y] = 0;
List<Point> list = new ArrayList<>();
list.add(start);
while (list.size() > 0) {
List<Point> temp = new ArrayList<>();
for (Point tp : list) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (Math.abs(i) == Math.abs(j)) {
continue;
}
if (tp.x + i < n && tp.x + i >= 0 && tp.y + j < n && tp.y + j >= 0
&& c[tp.x + i][tp.y + j] != '#') {
if (re[tp.x + i][tp.y + j] > re[tp.x][tp.y] + 1) {
re[tp.x + i][tp.y + j] = re[tp.x][tp.y] + 1;
temp.add(new Point(tp.x + i, tp.y + j));
}
}
}
}
}
list = temp;
}
}
public static long next(long now, long mod) {
if (now % mod == 0) {
return 0l;
}
return mod - now % mod;
}
public static int countA(int n, int a[], int price) {
int min = 0;
int max = n - 1;
int re = -1;
while (min <= max) {
int mid = (min + max) / 2;
if (a[mid] > price) {
max = mid - 1;
} else {
re = mid;
min = mid + 1;
}
}
return re + 1;
}
public static int countB(int n, int b[], int price) {
int min = 0;
int max = n - 1;
int re = -1;
while (min <= max) {
int mid = (min + max) / 2;
if (b[mid] >= price) {
max = mid - 1;
} else {
re = mid;
min = mid + 1;
}
}
return n - (re + 1);
}
public static String reverseString(String s) {
StringBuffer sb = new StringBuffer();
for (int i = s.length() - 1; i >= 0; i--) {
sb.append(s.charAt(i));
}
return sb.toString();
}
public static boolean check(char c[][], int startx, int starty, int x, int y) {
if (c[startx][starty] == '.') {
return false;
}
char temp = c[startx][starty];
for (int i = 0; i < 3; i++) {
if (c[startx + i * x][starty + i * y] != temp) {
return false;
}
}
return true;
}
public static boolean compareString(String s, int indexb) {
int length = Math.min(indexb, s.length() - indexb);
for (int i = 0; i < length; i++) {
if (s.charAt(i) < s.charAt(i + indexb)) {
return true;
} else if (s.charAt(i) > s.charAt(i + indexb)) {
return false;
}
}
if (indexb < s.length() - indexb) {
return true;
}
return false;
}
public static boolean checkx(char c[][], char x[][], int hc, int wc, int hx, int wx) {
for (int i = 0; i <= hc - hx; i++) {
for (int j = 0; j <= wc - wx; j++) {
boolean bool = true;
for (int l = 0; l < hx; l++) {
for (int m = 0; m < wx; m++) {
if (c[i + l][j + m] == '#' || x[l][m] == '#') {
if (c[i + l][j + m] != x[l][m]) {
bool = false;
}
}
}
}
if (bool) {
return true;
}
}
}
return false;
}
public static void refreshc(char c[][], char a[][], int ha, int wa, int hb, int wb) {
for (int i = 0; i < ha; i++) {
for (int j = 0; j < wa; j++) {
c[i + hb][j + wb] = a[i][j];
}
}
}
public static void updateList(List<Point> list, int p[], int po, int position[]) {
po += 2;
list.add(new Point(po - 1, po - 1));
int temp = p[po];
p[po] = p[po - 1];
p[po - 1] = p[po - 2];
p[po - 2] = temp;
position[p[po] - 1] = po;
position[p[po - 1] - 1] = po - 1;
position[p[po - 2] - 1] = po - 2;
po -= 2;
}
public static void updateSet(Map<Long, Integer> map, Set<Long> set, long n) {
int countM = map.get(n);
countM--;
if (countM == 0) {
map.remove(n);
set.remove(n);
} else {
map.put(n, countM);
}
}
public static void insertSet(Map<Long, Integer> map, Set<Long> set, long n) {
int countM = 0;
if (set.contains(n)) {
countM = map.get(n);
} else {
set.add(n);
}
countM++;
map.put(n, countM);
}
public static int distance(int x1, int y1, int x2, int y2) {
int distance = (int) Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) + 1;
return distance;
}
public static boolean nextPermutation(int[] arr) {
int len = arr.length;
int left = len - 2;
while (left >= 0 && arr[left] >= arr[left + 1])
left--;
if (left < 0)
return false;
int right = len - 1;
while (arr[left] >= arr[right])
right--;
{
int t = arr[left];
arr[left] = arr[right];
arr[right] = t;
}
left++;
right = len - 1;
while (left < right) {
{
int t = arr[left];
arr[left] = arr[right];
arr[right] = t;
}
left++;
right--;
}
return true;
}
public static void testpattern(int n) {
int count = 0;
int re = 0;
for (int x = 1; x * x <= n; x++) {
count++;
}
System.out.println(count);
re += count;
count = 0;
for (int x = 1; x * x <= n; x++) {
for (int y = 1; y * x <= n; y++) {
if (y != x) {
count += 3;
// System.out.println(x+" "+x+" "+y);
}
}
}
re += count;
System.out.println(count);
count = 0;
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
for (int z = 1; z <= n; z++) {
if (x * y <= n && y * z <= n && x * z <= n) {
if (x != y && x != z && y != z) {
count++;
}
}
}
}
}
re += count;
System.out.println(count);
System.out.println(re);
}
public static int distance(char a[][], Point s, Point e, int h, int w) {
int temp[][] = new int[h][w];
List<Point> list = new ArrayList<>();
list.add(s);
temp[s.x][s.y] = 1;
int count = 1;
while (!list.isEmpty()) {
List<Point> t = new ArrayList<>();
for (Point p : list) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (Math.abs(i) != Math.abs(j)) {
if (i + p.x < h && i + p.x >= 0 && j + p.y >= 0 && j + p.y < w) {
if (e.x == i + p.x && e.y == j + p.y) {
return count;
}
if (temp[i + p.x][j + p.y] == 0 && a[i + p.x][j + p.y] != '#') {
t.add(new Point(i + p.x, j + p.y));
temp[i + p.x][j + p.y]++;
}
}
}
}
}
}
count++;
list = t;
}
return Integer.MAX_VALUE / 3;
}
public static int[][] reverse(int n, int a[][]) {
int temp[][] = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
temp[n - 1 - j][i] = a[i][j];
}
}
return temp;
}
public static boolean check(int a[][], int b[][], int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1 && b[i][j] == 0) {
return false;
}
}
}
return true;
}
public static long testMethod(long a, long b) {
if (a < b) {
long t = b;
b = a;
a = t;
}
long re = 0;
// long nowgcd = 1;
while (b > 0) {
if (a == b) {
// pw.println(re + 1);
return re + 1;
}
long gcd = Main.gcd(a, b);
if (gcd == 1) {
long sa = a - b;
if (sa == 1) {
return re + b;
}
long min = a % sa;
for (long i = 2; i * i <= sa; i++) {
if (sa % i == 0) {
min = Math.min(min, a % i);
min = Math.min(min, a % (sa / i));
}
}
re += min;
a -= min;
b -= min;
} else {
// nowgcd = gcd;
re++;
a = a / gcd - 1;
b = b / gcd - 1;
}
}
return re;
}
public static long countNext(long a, long b) {
long re = -1;
long min = 1;
long max = b - 1;
while (min <= max) {
long mid = (min + max) / 2;
if ((a - mid) / (b - mid) > 1) {
re = mid;
min = mid + 1;
} else {
max = mid - 1;
}
}
return re;
}
public static int countTime(int max, int min, int i) {
int times = max / i + i - 1;
if (max % i != 0) {
times++;
}
if (min <= i) {
times++;
} else {
times = times + min / i;
if (min % i != 0) {
times++;
}
}
return times;
}
public static boolean check(long s, long l, long k, long m, long n, long v) {
if ((s - 1) / m != (s + l - 2) / m) {
return false;
}
if (s + (k - 1) * m > n * m) {
return false;
}
long temp = (s + s + (k - 1) * m) * k / 2;
long temp2 = (temp + temp + (l - 1) * k) * l / 2;
if (temp2 != v) {
return false;
}
return true;
}
public static double result(int x[], int x1, int x2, int x3) {
return 1.0 / (x[x1] * x[x2]) + 1.0 / (x[x2] * x[x3]) + 1.0 / (x[x1] * x[x3]);
}
public static int[] toArray(int temp, int n) {
List<Integer> list = new ArrayList<Integer>();
while (temp > 0) {
list.add(temp % 2);
temp /= 2;
}
int re[] = new int[n];
for (int i = 0; i < list.size(); i++) {
re[i] = list.get(i);
}
return re;
}
public static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
public static boolean make_so(long[] as, long[] ms) {
while (true) {
boolean updated = false;
for (int fst = 0; fst < ms.length; fst++) {
for (int snd = fst + 1; snd < ms.length; snd++) {
long gcd = gcd(ms[fst], ms[snd]);
if (gcd == 1) {
continue;
}
updated = true;
if (as[fst] % gcd != as[snd] % gcd) {
return false;
}
ms[fst] /= gcd;
ms[snd] /= gcd;
while (true) {
long gt = gcd(ms[fst], gcd);
if (gt == 1) {
break;
}
ms[fst] *= gt;
gcd /= gt;
}
ms[snd] *= gcd;
as[fst] %= ms[fst];
as[snd] %= ms[snd];
}
}
if (!updated) {
break;
}
}
return true;
}
public static long mulity(long l, int a[]) {
for (int i = 0; i < a.length; i++) {
if (l % a[i] == 0) {
l /= a[i];
a[i] = 1;
}
}
return l;
}
public static int[][] reverse(int a[][]) {
int b[][] = new int[2][2];
b[0][0] = a[1][0];
b[0][1] = a[0][0];
b[1][0] = a[1][1];
b[1][1] = a[0][1];
return b;
}
public static void add(TreeSet<Integer> ts, Map<Integer, Integer> map, int value) {
if (ts.contains(value)) {
map.put(value, map.get(value) + 1);
} else {
ts.add(value);
map.put(value, 1);
}
}
public static void remove(TreeSet<Integer> ts, Map<Integer, Integer> map, int value) {
if (map.get(value) == 1) {
ts.remove(value);
map.remove(value);
} else {
map.put(value, map.get(value) - 1);
}
}
public static int merge(int n, int m, int e) {
int merge = (n * (n - 1) / 2 - 2 * m) * e * 3 / 200;
if ((n - 2 * m) * e % 100 != 0) {
merge++;
}
return Math.max(3, merge);
}
public static boolean isMerge(int n, int m, int e, int count, int now) {
int merge = merge(n, m, e);
if (Math.abs(count - now) <= merge) {
return true;
}
return false;
}
public static void setall(Set<Integer> set, int x) {
if (x < 10) {
set.add(x);
return;
}
int to = 0;
int one[] = new int[4];
while (x > 0) {
one[to] = x % 10;
x /= 10;
to++;
}
Main.permutation(one, 0, to - 1, set);
}
// mod. m での a の逆元 a^{-1} を計算する
public static long modinv(long a, long m) {
long b = m, u = 1, v = 0;
while (b > 0) {
long t = a / b;
a -= t * b;
long temp = a;
a = b;
b = temp;
u -= t * v;
temp = u;
u = v;
v = temp;
}
u %= m;
if (u < 0)
u += m;
return u;
}
public long re(long n) {
if ((n % 6 == 1 || n % 6 == 5) && n > 1) {
n--;
}
if (map.containsKey(n)) {
return map.get(n);
}
long t1 = re(n / 2);
long t2 = re(n / 3);
map.put(n / 2, t1);
map.put(n / 3, t2);
return t1 + t2;
}
public static long distance(Point s, Point e) {
return (s.x - e.x) * (s.x - e.x) + (s.y - e.y) * (s.y - e.y);
}
public static int lowerBound(Integer[] a, int obj) {
int l = 0, r = a.length - 1;
while (r - l >= 0) {
int c = (l + r) / 2;
if (obj <= a[c]) {
r = c - 1;
} else {
l = c + 1;
}
}
return l;
}
public static long countRe(int high, int used[], long now, long min, long b[]) {
long re = Long.MAX_VALUE;
long temp = min;
for (int i = high; i >= 0; i--) {
if (used[i] == 0 && temp < now) {
temp += b[i];
if (temp >= now) {
re = Math.min(re, temp);
temp -= b[i];
}
}
}
if (re == Long.MAX_VALUE) {
re = min;
}
return re;
}
public static void swap(int[] s, int i, int j) {
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
public static void permutation(int[] s, int from, int to, Set<Integer> set) {
if (to <= 0)
return;
if (from == to) {
check(s, set, to);
} else {
for (int i = from; i <= to; i++) {
swap(s, i, from);
permutation(s, from + 1, to, set);
swap(s, from, i);
}
}
}
public static void check(int[] s, Set<Integer> set, int to) {
int temp = 0;
for (int i = 0; i <= to; i++) {
temp *= 10;
temp += s[i];
}
set.add(temp);
}
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 fastXCY(long tempx, long temp) {
tempx = tempx % MOD;
temp %= MOD;
tempx = modpow(tempx, (long) MOD - 2);
temp = (temp * tempx) % MOD;
return temp;
}
// 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 int gcd(int a, int b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
}
class MovePosition {
public char c;
public int x;
public int y;
public MovePosition(char ch, int a, int b) {
c = ch;
x = a;
y = b;
}
}
class PointEx {
long l;
long d;
long k;
long c;
int e;
public PointEx(long x, long y, long z, long a, int b) {
l = x;
d = y;
k = z;
c = a;
e = b;
}
}
class Node implements Comparable<Node> {
int tyoten;
long minDistance;
public Node(int t, long m) {
tyoten = t;
minDistance = m;
}
@Override
public int compareTo(Node o) {
int res = -1;
if (this.minDistance - o.minDistance >= 0) {
res = 1;
}
return res;
}
}
class Vertex {
String key;
Vertex(String key) {
this.key = key;
}
}
class Edge {
Vertex start;
Vertex end;
long key;
Edge(Vertex start, Vertex end, long key) {
this.start = start;
this.end = end;
this.key = key;
}
}
class Point extends Object implements Comparable {
int x;
int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object j) {
Point p = (Point) j;
if (p.x == this.x && p.y == this.y) {
return true;
}
return false;
}
@Override
public int hashCode() {
return (int) this.x + (int) this.y;
}
public int compareTo(Object p) {
Point t = (Point) p;
if (t.x != this.x) {
return this.x - t.x;
}
return this.y - t.y;
}
}
class PointX implements Comparable {
long a;
long b;
public PointX(long x, long y) {
a = x;
b = y;
}
public int compareTo(Object p) {
PointX t = (PointX) p;
if (t.a + t.b > a + b) {
return -1;
}
if (t.a + t.b < a + b) {
return 1;
}
return 0;
}
public boolean equals(Object p) {
PointX t = (PointX) p;
return this.a == t.a && this.b == t.b;
}
}
class PointTemp implements Comparable {
int p1x;
int p1y;
int p2x;
int p2y;
public PointTemp(int x1, int y1, int x2, int y2) {
p1x = x1;
p2x = x2;
p1y = y1;
p2y = y2;
}
public int compareTo(Object p) {
PointTemp t = (PointTemp) p;
if (Math.abs(t.p1x - t.p2x) > Math.abs(p1x - p2x)) {
return 1;
}
if (Math.abs(t.p1x - t.p2x) < Math.abs(p1x - p2x)) {
return -1;
}
return 0;
}
public boolean equals(Object p) {
PointTemp t = (PointTemp) p;
return this.p1x == t.p1x && this.p2x == t.p2x;
}
}
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;
}
}
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();
}
}
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
public class Main {
static long MOD = 998244353;
int min = Integer.MAX_VALUE;
int max = 0;
int count = 0;
int pattern = 0;
int k = 0;
Map<Long, Long> map = new HashMap<Long, Long>();
public static void main(String[] args) throws Exception {
// FileInputStream fis = new FileInputStream(new File("t.a"));
var sc = new FastScanner();
// Scanner sc = new Scanner(System.in);
// var sc = new FastScanner(fis);
// var pw = new FastPrintStream("t.y");
var pw = new FastPrintStream();
solve(sc, pw);
sc.close();
pw.flush();
pw.close();
}
static class S {
static final S E = new S(0);
long sum;
public S(long s) {
this.sum = s;
}
public static S op(S l, S r) {
return new S(l.sum);
}
public String toString() {
return String.valueOf(sum);
}
}
static class F {
static final F I = new F(0);
long a;
public F(long a) {
this.a = a;
}
public static F composite(F f, F g) {
return new F(f.a + g.a);
}
}
static S map(F f, S s) {
return new S(f.a + s.sum);
}
public static void solve(FastScanner sc, FastPrintStream pw) throws Exception {
int times = sc.nextInt();
for (int time=0;time<times;time++) {
long a[] = new long[5];
long p[] = new long[5];
Arrays.setAll(a, i->sc.nextLong());
Arrays.setAll(p, i->sc.nextLong());
long now =0;
long count =0;
for (int i=0;i<5;i++) {
now+=a[i]*(i+1);
count += a[i];
}
if (now/count>=3) {
pw.println(0);
continue;
}
long sa = 3*count -now;
if (p[3]>p[4]/2) {
// a==0
if (sa%2==1) {
long b = sa/2;
pw.println(Math.min(p[3]+p[4]*b, p[4]*(b+1)));
} else {
pw.println(sa*p[4]/2);
}
} else {
pw.println(sa*p[3]);
}
}
}
public static String dfs(Point src, Point tar, int h[][], int v[][], int n) {
int dfs[][] = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dfs[i][j] = Integer.MAX_VALUE;
}
}
dfs[src.x][src.y] = 0;
StringBuffer sb = new StringBuffer();
List<Point> list = new ArrayList<>();
list.add(src);
while (list.size() > 0) {
List<Point> temp = new ArrayList<>();
int access[][] = new int[n][n];
for (Point p : list) {
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0 && dfs[p.x - 1][p.y] > dfs[p.x][p.y] + 1) {
dfs[p.x - 1][p.y] = dfs[p.x][p.y] + 1;
if (access[p.x - 1][p.y] == 0) {
access[p.x - 1][p.y]++;
temp.add(new Point(p.x - 1, p.y));
}
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0 && dfs[p.x + 1][p.y] > dfs[p.x][p.y] + 1) {
dfs[p.x + 1][p.y] = dfs[p.x][p.y] + 1;
if (access[p.x + 1][p.y] == 0) {
access[p.x + 1][p.y]++;
temp.add(new Point(p.x + 1, p.y));
}
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0 && dfs[p.x][p.y - 1] > dfs[p.x][p.y] + 1) {
dfs[p.x][p.y - 1] = dfs[p.x][p.y] + 1;
if (access[p.x][p.y - 1] == 0) {
access[p.x][p.y - 1]++;
temp.add(new Point(p.x, p.y - 1));
}
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0 && dfs[p.x][p.y + 1] > dfs[p.x][p.y] + 1) {
dfs[p.x][p.y + 1] = dfs[p.x][p.y] + 1;
if (access[p.x][p.y + 1] == 0) {
access[p.x][p.y + 1]++;
temp.add(new Point(p.x, p.y + 1));
}
}
}
}
list = temp;
}
Point now = new Point(tar.x, tar.y);
for (int i = dfs[tar.x][tar.y]; i > 0; i--) {
if (now.x - 1 >= 0) {
if (h[now.x - 1][now.y] == 0 && dfs[now.x - 1][now.y] == i - 1) {
now = new Point(now.x - 1, now.y);
sb.append("D");
continue;
}
}
if (now.x + 1 < n) {
if (h[now.x][now.y] == 0 && dfs[now.x + 1][now.y] == i - 1) {
now = new Point(now.x + 1, now.y);
sb.append("U");
continue;
}
}
if (now.y - 1 >= 0) {
if (v[now.x][now.y - 1] == 0 && dfs[now.x][now.y - 1] == i - 1) {
now = new Point(now.x, now.y - 1);
sb.append("R");
continue;
}
}
if (now.y + 1 < n) {
if (v[now.x][now.y] == 0 && dfs[now.x][now.y + 1] == i - 1) {
now = new Point(now.x, now.y + 1);
sb.append("L");
continue;
}
}
}
StringBuffer re = new StringBuffer();
String temp = sb.toString();
for (int i = 0; i < temp.length(); i++) {
re.append(temp.charAt(temp.length() - i - 1));
}
return re.toString();
}
public static void changePosition(int a[][], Point p1, Point p2, Point position[]) {
int temp = a[p1.x][p1.y];
a[p1.x][p1.y] = a[p2.x][p2.y];
a[p2.x][p2.y] = temp;
position[a[p1.x][p1.y] - 1] = new Point(p1.x, p1.y);
position[a[p2.x][p2.y] - 1] = new Point(p2.x, p2.y);
}
public static int countPattern(Point p, int n, int h[][], int v[][]) {
int count = 0;
List<MovePosition> list = new ArrayList();
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0) {
count++;
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0) {
count++;
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0) {
count++;
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0) {
count++;
}
}
return count;
}
public static Point moveNext(Point p, int n, int h[][], int v[][], FastPrintStream pw) {
Random random = new Random();
List<MovePosition> list = new ArrayList();
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0) {
list.add(new MovePosition('U', -1, 0));
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0) {
list.add(new MovePosition('D', 1, 0));
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0) {
list.add(new MovePosition('L', 0, -1));
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0) {
list.add(new MovePosition('R', 0, 1));
}
}
MovePosition next = list.get(random.nextInt(list.size()));
pw.print(next.c + " ");
return new Point(p.x + next.x, p.y + next.y);
}
public static long countPoint(Point p, int n, int v[][], int h[][], long a[][]) {
long re = 0;
if (p.x - 1 >= 0) {
if (h[p.x - 1][p.y] == 0) {
re += (a[p.x - 1][p.y] - a[p.x][p.y]) + (a[p.x - 1][p.y] - a[p.x][p.y]);
}
}
if (p.x + 1 < n) {
if (h[p.x][p.y] == 0) {
re += (a[p.x + 1][p.y] - a[p.x][p.y]) + (a[p.x + 1][p.y] - a[p.x][p.y]);
}
}
if (p.y - 1 >= 0) {
if (v[p.x][p.y - 1] == 0) {
re += (a[p.x][p.y - 1] - a[p.x][p.y]) + (a[p.x][p.y - 1] - a[p.x][p.y]);
}
}
if (p.y + 1 < n) {
if (v[p.x][p.y] == 0) {
re += (a[p.x][1 + p.y] - a[p.x][p.y]) + (a[p.x][1 + p.y] - a[p.x][p.y]);
}
}
return re;
}
public static long sum(long first, long count) {
long last = first - count + 1;
return (first + last) * count / 2;
}
public static void searchPass(char c[][], int re[][], Point start, int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
re[i][j] = Integer.MAX_VALUE / 4;
}
}
re[start.x][start.y] = 0;
List<Point> list = new ArrayList<>();
list.add(start);
while (list.size() > 0) {
List<Point> temp = new ArrayList<>();
for (Point tp : list) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (Math.abs(i) == Math.abs(j)) {
continue;
}
if (tp.x + i < n && tp.x + i >= 0 && tp.y + j < n && tp.y + j >= 0
&& c[tp.x + i][tp.y + j] != '#') {
if (re[tp.x + i][tp.y + j] > re[tp.x][tp.y] + 1) {
re[tp.x + i][tp.y + j] = re[tp.x][tp.y] + 1;
temp.add(new Point(tp.x + i, tp.y + j));
}
}
}
}
}
list = temp;
}
}
public static long next(long now, long mod) {
if (now % mod == 0) {
return 0l;
}
return mod - now % mod;
}
public static int countA(int n, int a[], int price) {
int min = 0;
int max = n - 1;
int re = -1;
while (min <= max) {
int mid = (min + max) / 2;
if (a[mid] > price) {
max = mid - 1;
} else {
re = mid;
min = mid + 1;
}
}
return re + 1;
}
public static int countB(int n, int b[], int price) {
int min = 0;
int max = n - 1;
int re = -1;
while (min <= max) {
int mid = (min + max) / 2;
if (b[mid] >= price) {
max = mid - 1;
} else {
re = mid;
min = mid + 1;
}
}
return n - (re + 1);
}
public static String reverseString(String s) {
StringBuffer sb = new StringBuffer();
for (int i = s.length() - 1; i >= 0; i--) {
sb.append(s.charAt(i));
}
return sb.toString();
}
public static boolean check(char c[][], int startx, int starty, int x, int y) {
if (c[startx][starty] == '.') {
return false;
}
char temp = c[startx][starty];
for (int i = 0; i < 3; i++) {
if (c[startx + i * x][starty + i * y] != temp) {
return false;
}
}
return true;
}
public static boolean compareString(String s, int indexb) {
int length = Math.min(indexb, s.length() - indexb);
for (int i = 0; i < length; i++) {
if (s.charAt(i) < s.charAt(i + indexb)) {
return true;
} else if (s.charAt(i) > s.charAt(i + indexb)) {
return false;
}
}
if (indexb < s.length() - indexb) {
return true;
}
return false;
}
public static boolean checkx(char c[][], char x[][], int hc, int wc, int hx, int wx) {
for (int i = 0; i <= hc - hx; i++) {
for (int j = 0; j <= wc - wx; j++) {
boolean bool = true;
for (int l = 0; l < hx; l++) {
for (int m = 0; m < wx; m++) {
if (c[i + l][j + m] == '#' || x[l][m] == '#') {
if (c[i + l][j + m] != x[l][m]) {
bool = false;
}
}
}
}
if (bool) {
return true;
}
}
}
return false;
}
public static void refreshc(char c[][], char a[][], int ha, int wa, int hb, int wb) {
for (int i = 0; i < ha; i++) {
for (int j = 0; j < wa; j++) {
c[i + hb][j + wb] = a[i][j];
}
}
}
public static void updateList(List<Point> list, int p[], int po, int position[]) {
po += 2;
list.add(new Point(po - 1, po - 1));
int temp = p[po];
p[po] = p[po - 1];
p[po - 1] = p[po - 2];
p[po - 2] = temp;
position[p[po] - 1] = po;
position[p[po - 1] - 1] = po - 1;
position[p[po - 2] - 1] = po - 2;
po -= 2;
}
public static void updateSet(Map<Long, Integer> map, Set<Long> set, long n) {
int countM = map.get(n);
countM--;
if (countM == 0) {
map.remove(n);
set.remove(n);
} else {
map.put(n, countM);
}
}
public static void insertSet(Map<Long, Integer> map, Set<Long> set, long n) {
int countM = 0;
if (set.contains(n)) {
countM = map.get(n);
} else {
set.add(n);
}
countM++;
map.put(n, countM);
}
public static int distance(int x1, int y1, int x2, int y2) {
int distance = (int) Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) + 1;
return distance;
}
public static boolean nextPermutation(int[] arr) {
int len = arr.length;
int left = len - 2;
while (left >= 0 && arr[left] >= arr[left + 1])
left--;
if (left < 0)
return false;
int right = len - 1;
while (arr[left] >= arr[right])
right--;
{
int t = arr[left];
arr[left] = arr[right];
arr[right] = t;
}
left++;
right = len - 1;
while (left < right) {
{
int t = arr[left];
arr[left] = arr[right];
arr[right] = t;
}
left++;
right--;
}
return true;
}
public static void testpattern(int n) {
int count = 0;
int re = 0;
for (int x = 1; x * x <= n; x++) {
count++;
}
System.out.println(count);
re += count;
count = 0;
for (int x = 1; x * x <= n; x++) {
for (int y = 1; y * x <= n; y++) {
if (y != x) {
count += 3;
// System.out.println(x+" "+x+" "+y);
}
}
}
re += count;
System.out.println(count);
count = 0;
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
for (int z = 1; z <= n; z++) {
if (x * y <= n && y * z <= n && x * z <= n) {
if (x != y && x != z && y != z) {
count++;
}
}
}
}
}
re += count;
System.out.println(count);
System.out.println(re);
}
public static int distance(char a[][], Point s, Point e, int h, int w) {
int temp[][] = new int[h][w];
List<Point> list = new ArrayList<>();
list.add(s);
temp[s.x][s.y] = 1;
int count = 1;
while (!list.isEmpty()) {
List<Point> t = new ArrayList<>();
for (Point p : list) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (Math.abs(i) != Math.abs(j)) {
if (i + p.x < h && i + p.x >= 0 && j + p.y >= 0 && j + p.y < w) {
if (e.x == i + p.x && e.y == j + p.y) {
return count;
}
if (temp[i + p.x][j + p.y] == 0 && a[i + p.x][j + p.y] != '#') {
t.add(new Point(i + p.x, j + p.y));
temp[i + p.x][j + p.y]++;
}
}
}
}
}
}
count++;
list = t;
}
return Integer.MAX_VALUE / 3;
}
public static int[][] reverse(int n, int a[][]) {
int temp[][] = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
temp[n - 1 - j][i] = a[i][j];
}
}
return temp;
}
public static boolean check(int a[][], int b[][], int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1 && b[i][j] == 0) {
return false;
}
}
}
return true;
}
public static long testMethod(long a, long b) {
if (a < b) {
long t = b;
b = a;
a = t;
}
long re = 0;
// long nowgcd = 1;
while (b > 0) {
if (a == b) {
// pw.println(re + 1);
return re + 1;
}
long gcd = Main.gcd(a, b);
if (gcd == 1) {
long sa = a - b;
if (sa == 1) {
return re + b;
}
long min = a % sa;
for (long i = 2; i * i <= sa; i++) {
if (sa % i == 0) {
min = Math.min(min, a % i);
min = Math.min(min, a % (sa / i));
}
}
re += min;
a -= min;
b -= min;
} else {
// nowgcd = gcd;
re++;
a = a / gcd - 1;
b = b / gcd - 1;
}
}
return re;
}
public static long countNext(long a, long b) {
long re = -1;
long min = 1;
long max = b - 1;
while (min <= max) {
long mid = (min + max) / 2;
if ((a - mid) / (b - mid) > 1) {
re = mid;
min = mid + 1;
} else {
max = mid - 1;
}
}
return re;
}
public static int countTime(int max, int min, int i) {
int times = max / i + i - 1;
if (max % i != 0) {
times++;
}
if (min <= i) {
times++;
} else {
times = times + min / i;
if (min % i != 0) {
times++;
}
}
return times;
}
public static boolean check(long s, long l, long k, long m, long n, long v) {
if ((s - 1) / m != (s + l - 2) / m) {
return false;
}
if (s + (k - 1) * m > n * m) {
return false;
}
long temp = (s + s + (k - 1) * m) * k / 2;
long temp2 = (temp + temp + (l - 1) * k) * l / 2;
if (temp2 != v) {
return false;
}
return true;
}
public static double result(int x[], int x1, int x2, int x3) {
return 1.0 / (x[x1] * x[x2]) + 1.0 / (x[x2] * x[x3]) + 1.0 / (x[x1] * x[x3]);
}
public static int[] toArray(int temp, int n) {
List<Integer> list = new ArrayList<Integer>();
while (temp > 0) {
list.add(temp % 2);
temp /= 2;
}
int re[] = new int[n];
for (int i = 0; i < list.size(); i++) {
re[i] = list.get(i);
}
return re;
}
public static long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
public static boolean make_so(long[] as, long[] ms) {
while (true) {
boolean updated = false;
for (int fst = 0; fst < ms.length; fst++) {
for (int snd = fst + 1; snd < ms.length; snd++) {
long gcd = gcd(ms[fst], ms[snd]);
if (gcd == 1) {
continue;
}
updated = true;
if (as[fst] % gcd != as[snd] % gcd) {
return false;
}
ms[fst] /= gcd;
ms[snd] /= gcd;
while (true) {
long gt = gcd(ms[fst], gcd);
if (gt == 1) {
break;
}
ms[fst] *= gt;
gcd /= gt;
}
ms[snd] *= gcd;
as[fst] %= ms[fst];
as[snd] %= ms[snd];
}
}
if (!updated) {
break;
}
}
return true;
}
public static long mulity(long l, int a[]) {
for (int i = 0; i < a.length; i++) {
if (l % a[i] == 0) {
l /= a[i];
a[i] = 1;
}
}
return l;
}
public static int[][] reverse(int a[][]) {
int b[][] = new int[2][2];
b[0][0] = a[1][0];
b[0][1] = a[0][0];
b[1][0] = a[1][1];
b[1][1] = a[0][1];
return b;
}
public static void add(TreeSet<Integer> ts, Map<Integer, Integer> map, int value) {
if (ts.contains(value)) {
map.put(value, map.get(value) + 1);
} else {
ts.add(value);
map.put(value, 1);
}
}
public static void remove(TreeSet<Integer> ts, Map<Integer, Integer> map, int value) {
if (map.get(value) == 1) {
ts.remove(value);
map.remove(value);
} else {
map.put(value, map.get(value) - 1);
}
}
public static int merge(int n, int m, int e) {
int merge = (n * (n - 1) / 2 - 2 * m) * e * 3 / 200;
if ((n - 2 * m) * e % 100 != 0) {
merge++;
}
return Math.max(3, merge);
}
public static boolean isMerge(int n, int m, int e, int count, int now) {
int merge = merge(n, m, e);
if (Math.abs(count - now) <= merge) {
return true;
}
return false;
}
public static void setall(Set<Integer> set, int x) {
if (x < 10) {
set.add(x);
return;
}
int to = 0;
int one[] = new int[4];
while (x > 0) {
one[to] = x % 10;
x /= 10;
to++;
}
Main.permutation(one, 0, to - 1, set);
}
// mod. m での a の逆元 a^{-1} を計算する
public static long modinv(long a, long m) {
long b = m, u = 1, v = 0;
while (b > 0) {
long t = a / b;
a -= t * b;
long temp = a;
a = b;
b = temp;
u -= t * v;
temp = u;
u = v;
v = temp;
}
u %= m;
if (u < 0)
u += m;
return u;
}
public long re(long n) {
if ((n % 6 == 1 || n % 6 == 5) && n > 1) {
n--;
}
if (map.containsKey(n)) {
return map.get(n);
}
long t1 = re(n / 2);
long t2 = re(n / 3);
map.put(n / 2, t1);
map.put(n / 3, t2);
return t1 + t2;
}
public static long distance(Point s, Point e) {
return (s.x - e.x) * (s.x - e.x) + (s.y - e.y) * (s.y - e.y);
}
public static int lowerBound(Integer[] a, int obj) {
int l = 0, r = a.length - 1;
while (r - l >= 0) {
int c = (l + r) / 2;
if (obj <= a[c]) {
r = c - 1;
} else {
l = c + 1;
}
}
return l;
}
public static long countRe(int high, int used[], long now, long min, long b[]) {
long re = Long.MAX_VALUE;
long temp = min;
for (int i = high; i >= 0; i--) {
if (used[i] == 0 && temp < now) {
temp += b[i];
if (temp >= now) {
re = Math.min(re, temp);
temp -= b[i];
}
}
}
if (re == Long.MAX_VALUE) {
re = min;
}
return re;
}
public static void swap(int[] s, int i, int j) {
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
public static void permutation(int[] s, int from, int to, Set<Integer> set) {
if (to <= 0)
return;
if (from == to) {
check(s, set, to);
} else {
for (int i = from; i <= to; i++) {
swap(s, i, from);
permutation(s, from + 1, to, set);
swap(s, from, i);
}
}
}
public static void check(int[] s, Set<Integer> set, int to) {
int temp = 0;
for (int i = 0; i <= to; i++) {
temp *= 10;
temp += s[i];
}
set.add(temp);
}
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 fastXCY(long tempx, long temp) {
tempx = tempx % MOD;
temp %= MOD;
tempx = modpow(tempx, (long) MOD - 2);
temp = (temp * tempx) % MOD;
return temp;
}
// 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 int gcd(int a, int b) {
if (b == 0) {
return a;
}
if (a < b) {
return gcd(b, a);
}
return gcd(b, a % b);
}
}
class MovePosition {
public char c;
public int x;
public int y;
public MovePosition(char ch, int a, int b) {
c = ch;
x = a;
y = b;
}
}
class PointEx {
long l;
long d;
long k;
long c;
int e;
public PointEx(long x, long y, long z, long a, int b) {
l = x;
d = y;
k = z;
c = a;
e = b;
}
}
class Node implements Comparable<Node> {
int tyoten;
long minDistance;
public Node(int t, long m) {
tyoten = t;
minDistance = m;
}
@Override
public int compareTo(Node o) {
int res = -1;
if (this.minDistance - o.minDistance >= 0) {
res = 1;
}
return res;
}
}
class Vertex {
String key;
Vertex(String key) {
this.key = key;
}
}
class Edge {
Vertex start;
Vertex end;
long key;
Edge(Vertex start, Vertex end, long key) {
this.start = start;
this.end = end;
this.key = key;
}
}
class Point extends Object implements Comparable {
int x;
int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object j) {
Point p = (Point) j;
if (p.x == this.x && p.y == this.y) {
return true;
}
return false;
}
@Override
public int hashCode() {
return (int) this.x + (int) this.y;
}
public int compareTo(Object p) {
Point t = (Point) p;
if (t.x != this.x) {
return this.x - t.x;
}
return this.y - t.y;
}
}
class PointX implements Comparable {
long a;
long b;
public PointX(long x, long y) {
a = x;
b = y;
}
public int compareTo(Object p) {
PointX t = (PointX) p;
if (t.a + t.b > a + b) {
return -1;
}
if (t.a + t.b < a + b) {
return 1;
}
return 0;
}
public boolean equals(Object p) {
PointX t = (PointX) p;
return this.a == t.a && this.b == t.b;
}
}
class PointTemp implements Comparable {
int p1x;
int p1y;
int p2x;
int p2y;
public PointTemp(int x1, int y1, int x2, int y2) {
p1x = x1;
p2x = x2;
p1y = y1;
p2y = y2;
}
public int compareTo(Object p) {
PointTemp t = (PointTemp) p;
if (Math.abs(t.p1x - t.p2x) > Math.abs(p1x - p2x)) {
return 1;
}
if (Math.abs(t.p1x - t.p2x) < Math.abs(p1x - p2x)) {
return -1;
}
return 0;
}
public boolean equals(Object p) {
PointTemp t = (PointTemp) p;
return this.p1x == t.p1x && this.p2x == t.p2x;
}
}
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;
}
}
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();
}
} | ConDefects/ConDefects/Code/arc174_b/Java/51390730 |
condefects-java_data_1612 | import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
@SuppressWarnings({"unused"})
public final class Main {
// @SuppressWarnings({"unchecked"})
public static final void main(String[] args) {
final int N = getNextInt();
final int M = getNextInt();
final long P = getNextLong();
final long[] A = getLongArray(N);
final long[] B = getLongArray(M);
Arrays.sort(B);
final CumulativeSum cumulB = new CumulativeSum(B);
long sumPrice = 0;
for(int aIdx = 0; aIdx < N; aIdx++) {
final long maxB = Math.max(0, P - A[aIdx]);
final int bIdx = binSearch(B, maxB, (aryData, target) -> aryData >= maxB);
if(bIdx >= 0) {
sumPrice += A[aIdx] * (bIdx + 1) + cumulB.getSum(0, bIdx + 1);
}
if(bIdx < N - 1) {
sumPrice += P * (M - bIdx - 1);
}
}
println(sumPrice);
flush();
}
// 二分探索、predicatorのfalseとtrueの境界線がlとr
static int binSearch(long[] array, long target, BiPredicate<Long, Long> predicator) {
int l = -1;
int r = array.length;
while(r - l > 1) {
final int m = (r + l) / 2;
if(predicator.test(array[m], target)) {
r = m;
} else {
l = m;
}
}
return l;
}
private static class CumulativeSum {
long[] data;
int size;
CumulativeSum(long[] source) {
size = source.length;
data = new long[size];
for(int idx = 0; idx < size; idx++) {
data[idx] = (idx > 0 ? data[idx - 1] : 0) + source[idx];
}
}
long getSum(int st, int ed) {
return data[ed - 1] - (st > 0 ? data[st - 1] : 0);
}
}
// 以下Utility
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static String[] readBuffer = new String[] {};
private static int readBufferCursor = 0;
private static PrintWriter writer = new PrintWriter(System.out);
// private static BufferedReader reader;
// static {
// try {
// reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }
// }
private static int[] concat(int[]... arys) {
IntStream st = Arrays.stream(arys[0]);
for(int idx = 1; idx < arys.length; idx++) {
st = IntStream.concat(st, Arrays.stream(arys[idx]));
}
return st.toArray();
}
@SafeVarargs
private static <E> List<E> concat(List<E>... lists) {
Stream<E> st = lists[0].stream();
for(int idx = 1; idx < lists.length; idx++) {
st = Stream.concat(st, lists[idx].stream());
}
return st.collect(Collectors.toList());
}
private static String getNextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
private static String getNext() {
// return scanner.next();
if(readBuffer.length == readBufferCursor) {
readBuffer = getNextLine().trim().split("\\s");
readBufferCursor = 0;
}
return readBuffer[readBufferCursor++];
}
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(getNext());
}
private static long getNextLong() {
return Long.parseLong(getNext());
}
private static double getNextDouble() {
return Double.parseDouble(getNext());
}
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 int[][] getIntArrayWithSeq(int length) {
return getIntArrayWithSeq(length, v -> v);
}
private static int[][] getIntArrayWithSeq(int length, IntUnaryOperator mapper) {
int[][] array = new int[length][2];
for(int counter = 0; counter < length; counter++) {
array[counter][0] = counter;
array[counter][1] = mapper.applyAsInt(getNextInt());
}
return array;
}
private static int getBitLineInt() {
final int[] line = getCharIntArray(c -> c - '0');
int result = 0;
for(int pos = 0; pos < line.length; pos++) {
result <<= 1;
result |= line[pos];
}
return result;
}
private static int[] getBitLineIntAry(int length) {
final int[] bitAry = new int[length];
for(int idx = 0; idx < length; idx++) {
bitAry[idx] = getBitLineInt();
}
return bitAry;
}
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 double[] getDoubleArray(int length) {
return DoubleStream.generate(() -> getNextDouble()).limit(length).toArray();
}
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... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(long... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(char[] ary) {
print(String.valueOf(ary));
}
private static void print(Collection<?> list) {
for(Iterator<?> itr = list.iterator(); itr.hasNext();) {
print(itr.next() + (itr.hasNext() ? " " : ""));
}
}
private static void print(Object obj) {
writer.print(obj);
}
private static void println(int... ary) {
print(ary);
println();
}
private static void println(long... ary) {
print(ary);
println();
}
private static void println(char[] ary) {
print(ary);
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() {
writer.println();
}
private static void flush() {
writer.flush();
}
}
import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
@SuppressWarnings({"unused"})
public final class Main {
// @SuppressWarnings({"unchecked"})
public static final void main(String[] args) {
final int N = getNextInt();
final int M = getNextInt();
final long P = getNextLong();
final long[] A = getLongArray(N);
final long[] B = getLongArray(M);
Arrays.sort(B);
final CumulativeSum cumulB = new CumulativeSum(B);
long sumPrice = 0;
for(int aIdx = 0; aIdx < N; aIdx++) {
final long maxB = Math.max(0, P - A[aIdx]);
final int bIdx = binSearch(B, maxB, (aryData, target) -> aryData >= maxB);
if(bIdx >= 0) {
sumPrice += A[aIdx] * (bIdx + 1) + cumulB.getSum(0, bIdx + 1);
}
if(bIdx < M - 1) {
sumPrice += P * (M - bIdx - 1);
}
}
println(sumPrice);
flush();
}
// 二分探索、predicatorのfalseとtrueの境界線がlとr
static int binSearch(long[] array, long target, BiPredicate<Long, Long> predicator) {
int l = -1;
int r = array.length;
while(r - l > 1) {
final int m = (r + l) / 2;
if(predicator.test(array[m], target)) {
r = m;
} else {
l = m;
}
}
return l;
}
private static class CumulativeSum {
long[] data;
int size;
CumulativeSum(long[] source) {
size = source.length;
data = new long[size];
for(int idx = 0; idx < size; idx++) {
data[idx] = (idx > 0 ? data[idx - 1] : 0) + source[idx];
}
}
long getSum(int st, int ed) {
return data[ed - 1] - (st > 0 ? data[st - 1] : 0);
}
}
// 以下Utility
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static String[] readBuffer = new String[] {};
private static int readBufferCursor = 0;
private static PrintWriter writer = new PrintWriter(System.out);
// private static BufferedReader reader;
// static {
// try {
// reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt")));
// } catch (FileNotFoundException e) {
// e.printStackTrace();
// }
// }
private static int[] concat(int[]... arys) {
IntStream st = Arrays.stream(arys[0]);
for(int idx = 1; idx < arys.length; idx++) {
st = IntStream.concat(st, Arrays.stream(arys[idx]));
}
return st.toArray();
}
@SafeVarargs
private static <E> List<E> concat(List<E>... lists) {
Stream<E> st = lists[0].stream();
for(int idx = 1; idx < lists.length; idx++) {
st = Stream.concat(st, lists[idx].stream());
}
return st.collect(Collectors.toList());
}
private static String getNextLine() {
try {
return reader.readLine();
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
private static String getNext() {
// return scanner.next();
if(readBuffer.length == readBufferCursor) {
readBuffer = getNextLine().trim().split("\\s");
readBufferCursor = 0;
}
return readBuffer[readBufferCursor++];
}
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(getNext());
}
private static long getNextLong() {
return Long.parseLong(getNext());
}
private static double getNextDouble() {
return Double.parseDouble(getNext());
}
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 int[][] getIntArrayWithSeq(int length) {
return getIntArrayWithSeq(length, v -> v);
}
private static int[][] getIntArrayWithSeq(int length, IntUnaryOperator mapper) {
int[][] array = new int[length][2];
for(int counter = 0; counter < length; counter++) {
array[counter][0] = counter;
array[counter][1] = mapper.applyAsInt(getNextInt());
}
return array;
}
private static int getBitLineInt() {
final int[] line = getCharIntArray(c -> c - '0');
int result = 0;
for(int pos = 0; pos < line.length; pos++) {
result <<= 1;
result |= line[pos];
}
return result;
}
private static int[] getBitLineIntAry(int length) {
final int[] bitAry = new int[length];
for(int idx = 0; idx < length; idx++) {
bitAry[idx] = getBitLineInt();
}
return bitAry;
}
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 double[] getDoubleArray(int length) {
return DoubleStream.generate(() -> getNextDouble()).limit(length).toArray();
}
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... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(long... ary) {
for(int idx = 0; idx < ary.length; idx++) {
print(ary[idx] + (idx < ary.length - 1 ? " " : ""));
}
}
private static void print(char[] ary) {
print(String.valueOf(ary));
}
private static void print(Collection<?> list) {
for(Iterator<?> itr = list.iterator(); itr.hasNext();) {
print(itr.next() + (itr.hasNext() ? " " : ""));
}
}
private static void print(Object obj) {
writer.print(obj);
}
private static void println(int... ary) {
print(ary);
println();
}
private static void println(long... ary) {
print(ary);
println();
}
private static void println(char[] ary) {
print(ary);
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() {
writer.println();
}
private static void flush() {
writer.flush();
}
}
| ConDefects/ConDefects/Code/abc321_d/Java/49270284 |
condefects-java_data_1613 | import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Main main = new Main();
Scanner sc = new Scanner (System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int P = sc.nextInt();
long[] shusai = new long[N];
Long[] fukusai = new Long[M+1];
fukusai[M]=Long.MAX_VALUE;
for (int i=0; i<N; i++) {
shusai[i]=sc.nextLong();
}
for (int j=0; j<M; j++) {
fukusai[j]=sc.nextLong();
}
Arrays.sort(fukusai);
long[] ruisekiwa = new long[M+1];
//index個分の和。
for (int j=0; j<M; j++) {
ruisekiwa[j+1]=ruisekiwa[j]+fukusai[j];
}
long answer = 0;
for (int i=0; i<N; i++) {
int lowerResult = ~Arrays.binarySearch(fukusai, P-shusai[i], (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
long cost = ruisekiwa[lowerResult]+shusai[i]*lowerResult;
cost+=P*(M-lowerResult);
answer+=cost;
}
System.out.println(answer);
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Main main = new Main();
Scanner sc = new Scanner (System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int P = sc.nextInt();
long[] shusai = new long[N];
Long[] fukusai = new Long[M+1];
fukusai[M]=Long.MAX_VALUE;
for (int i=0; i<N; i++) {
shusai[i]=sc.nextLong();
}
for (int j=0; j<M; j++) {
fukusai[j]=sc.nextLong();
}
Arrays.sort(fukusai);
long[] ruisekiwa = new long[M+1];
//index個分の和。
for (int j=0; j<M; j++) {
ruisekiwa[j+1]=ruisekiwa[j]+fukusai[j];
}
long answer = 0;
for (int i=0; i<N; i++) {
int lowerResult = ~Arrays.binarySearch(fukusai, P-shusai[i], (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
long cost = ruisekiwa[lowerResult]+shusai[i]*lowerResult;
cost+=(long)P*(M-lowerResult);
answer+=cost;
}
System.out.println(answer);
}
} | ConDefects/ConDefects/Code/abc321_d/Java/48670049 |
condefects-java_data_1614 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main( String[] args) {
Scanner scn = new Scanner( System.in);
int N = scn.nextInt();
int M = scn.nextInt();
long P = scn.nextLong();
int[] maindishes = new int[N];
int[] sidedishes = new int[M];
for(int h = 0; h < N; h++) {
maindishes[h] = scn.nextInt();
}
for(int i = 0; i < M; i++) {
sidedishes[i] = scn.nextInt();
}
Arrays.sort( maindishes);
Arrays.sort( sidedishes);
long[] cumulativeMain = new long[N];
long[] cumulativeSide = new long[M];
cumulativeMain[0] = maindishes[0];
cumulativeSide[0] = sidedishes[0];
for(int j = 1; j < N; j++) {
cumulativeMain[j] = cumulativeMain[j - 1] + maindishes[j];
}
for(int k = 1; k < M; k++) {
cumulativeSide[k] = cumulativeSide[k - 1] + sidedishes[k];
}
long ans = 0;
for(int mainPrice : maindishes) {
long target = P - mainPrice;
int rightIdx = 0;
int leftIdx = M - 1;
if(target <= sidedishes[0]) {
ans += P * M;
continue;
}else if(sidedishes[M - 1] <= target) {
ans += (long) mainPrice * cumulativeSide[M - 1];
continue;
}
while(leftIdx - rightIdx > 1) {
int mid = (rightIdx + leftIdx) / 2;
if(sidedishes[mid] < target) {
rightIdx = mid;
}else {
leftIdx = mid;
}
}
long leTargetSum = (long)mainPrice * (rightIdx + 1) + cumulativeSide[rightIdx];
long grTargetSum = P * (M - rightIdx - 1);
ans += leTargetSum + grTargetSum;
}
System.out.println(ans);
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main( String[] args) {
Scanner scn = new Scanner( System.in);
int N = scn.nextInt();
int M = scn.nextInt();
long P = scn.nextLong();
int[] maindishes = new int[N];
int[] sidedishes = new int[M];
for(int h = 0; h < N; h++) {
maindishes[h] = scn.nextInt();
}
for(int i = 0; i < M; i++) {
sidedishes[i] = scn.nextInt();
}
Arrays.sort( maindishes);
Arrays.sort( sidedishes);
long[] cumulativeMain = new long[N];
long[] cumulativeSide = new long[M];
cumulativeMain[0] = maindishes[0];
cumulativeSide[0] = sidedishes[0];
for(int j = 1; j < N; j++) {
cumulativeMain[j] = cumulativeMain[j - 1] + maindishes[j];
}
for(int k = 1; k < M; k++) {
cumulativeSide[k] = cumulativeSide[k - 1] + sidedishes[k];
}
long ans = 0;
for(int mainPrice : maindishes) {
long target = P - mainPrice;
int rightIdx = 0;
int leftIdx = M - 1;
if(target <= sidedishes[0]) {
ans += P * M;
continue;
}else if(sidedishes[M - 1] <= target) {
ans += (long) mainPrice * M + cumulativeSide[M - 1];
continue;
}
while(leftIdx - rightIdx > 1) {
int mid = (rightIdx + leftIdx) / 2;
if(sidedishes[mid] < target) {
rightIdx = mid;
}else {
leftIdx = mid;
}
}
long leTargetSum = (long)mainPrice * (rightIdx + 1) + cumulativeSide[rightIdx];
long grTargetSum = P * (M - rightIdx - 1);
ans += leTargetSum + grTargetSum;
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc321_d/Java/46512636 |
condefects-java_data_1615 | import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
PrintWriter output = new PrintWriter(System.out);
int N = sc.nextInt();
int M = sc.nextInt();
long P = sc.nextInt();
int[] A = new int[N];
int[] B = new int[M];
long[] sumA = new long[N+1];
long[] sumB = new long[M+1];
for(int i=0;i<N;i++) {
A[i] = sc.nextInt();
}
for(int i=0;i<M;i++) {
B[i] = sc.nextInt();
}
Arrays.sort(A);
Arrays.sort(B);
for(int i=0;i<N;i++) {
sumA[i+1] = sumA[i]+(long)A[i];
}
for(int i=0;i<M;i++) {
sumB[i+1] = sumB[i]+(long)B[i];
}
long ans = 0;
for(int i=0;i<N;i++) {
int tmpA = A[i];
long lim = P - tmpA;
int x = 0,y = M-1;
while(true) {
if(y - x <= 1) {
break;
}
int next = (x+y)/2;
if(B[next] < lim) {
x = next;
}
else {
y = next;
}
}
if(B[M-1] < lim) {
ans += tmpA*M+sumB[M];
//output.println(ans + " "+x+" "+y+" c");
}
else if(B[0] > lim){
ans += P*M;
//output.println(ans + " "+x+" "+y+" b");
}
else{
ans += tmpA*(x+1)+sumB[x+1];
ans += P*(M-(x+1));
//output.println(sumB[x+1] +" "+P*(M-(x+1)));
//output.println(ans + " "+x+" "+y+" a");
}
}
output.print(ans);
output.flush();
sc.close();
}
}
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
PrintWriter output = new PrintWriter(System.out);
int N = sc.nextInt();
int M = sc.nextInt();
long P = sc.nextInt();
int[] A = new int[N];
int[] B = new int[M];
long[] sumA = new long[N+1];
long[] sumB = new long[M+1];
for(int i=0;i<N;i++) {
A[i] = sc.nextInt();
}
for(int i=0;i<M;i++) {
B[i] = sc.nextInt();
}
Arrays.sort(A);
Arrays.sort(B);
for(int i=0;i<N;i++) {
sumA[i+1] = sumA[i]+(long)A[i];
}
for(int i=0;i<M;i++) {
sumB[i+1] = sumB[i]+(long)B[i];
}
long ans = 0;
for(int i=0;i<N;i++) {
long tmpA = A[i];
long lim = P - tmpA;
int x = 0,y = M-1;
while(true) {
if(y - x <= 1) {
break;
}
int next = (x+y)/2;
if(B[next] < lim) {
x = next;
}
else {
y = next;
}
}
if(B[M-1] < lim) {
ans += tmpA*M+sumB[M];
//output.println(ans + " "+x+" "+y+" c");
}
else if(B[0] > lim){
ans += P*M;
//output.println(ans + " "+x+" "+y+" b");
}
else{
ans += tmpA*(x+1)+sumB[x+1];
ans += P*(M-(x+1));
//output.println(sumB[x+1] +" "+P*(M-(x+1)));
//output.println(ans + " "+x+" "+y+" a");
}
}
output.print(ans);
output.flush();
sc.close();
}
}
| ConDefects/ConDefects/Code/abc321_d/Java/46429274 |
condefects-java_data_1616 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
G_SelectStrings solver = new G_SelectStrings();
solver.solve(1, in, out);
out.close();
}
static class G_SelectStrings {
public void solve(int testNumber, FastScanner in, PrintWriter out) {
int n = in.nextInt();
String[] s = new String[n];
int[] a = new int[n];
for (int i = 0; i < n; i++) {
s[i] = in.next();
}
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
Graph g = new Graph(2 * n + 2);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j && s[i].contains(s[j])) {
g.addEdge(i, j + n, g.infinity);
}
}
}
for (int i = 0; i < n; i++) {
g.addEdge(g.s, i, a[i]);
}
for (int i = 0; i < n; i++) {
g.addEdge(i + n, g.t, a[i]);
}
long sum = 0;
for (long x : a) {
sum += x;
}
out.println(sum - g.maxFlow());
}
class Graph {
final long infinity = (long) 1e15;
int n;
int s;
int t;
int[] firstEdge;
int[] nextEdge;
int[] edgeDst;
long[] edgeCap;
long[] edgeFlow;
int numEdges;
int[] level;
int[] q;
int[] lastEdge;
Graph(int n) {
this.n = n;
s = n - 1;
t = n - 2;
firstEdge = new int[n];
final int initialEdges = 10;
nextEdge = new int[initialEdges];
edgeDst = new int[initialEdges];
edgeCap = new long[initialEdges];
edgeFlow = new long[initialEdges];
numEdges = 0;
level = new int[n];
q = new int[n];
lastEdge = new int[n];
Arrays.fill(firstEdge, -1);
}
void reallocate() {
int k = nextEdge.length * 3 / 2 + 1;
nextEdge = Arrays.copyOf(nextEdge, k);
edgeDst = Arrays.copyOf(edgeDst, k);
edgeCap = Arrays.copyOf(edgeCap, k);
edgeFlow = Arrays.copyOf(edgeFlow, k);
}
void addEdge(int a, int b, long cap) {
if (numEdges + 2 >= nextEdge.length) {
reallocate();
}
int e = numEdges++;
nextEdge[e] = firstEdge[a];
firstEdge[a] = e;
edgeDst[e] = b;
edgeCap[e] = cap;
edgeFlow[e] = 0;
e = numEdges++;
nextEdge[e] = firstEdge[b];
firstEdge[b] = e;
edgeDst[e] = a;
edgeCap[e] = 0;
edgeFlow[e] = 0;
}
long maxFlow() {
long flow = 0;
while (bfs()) {
for (int i = 0; i < n; i++) {
lastEdge[i] = firstEdge[i];
}
while (true) {
long add = dfs(s, infinity);
if (add == 0) {
break;
}
flow += add;
}
}
return flow;
}
long dfs(int v, long delta) {
if (v == t) {
return delta;
}
for (; lastEdge[v] >= 0; lastEdge[v] = nextEdge[lastEdge[v]]) {
int e = lastEdge[v];
int u = edgeDst[e];
if (level[u] != level[v] + 1) {
continue;
}
long x = Math.min(delta, edgeCap[e] - edgeFlow[e]);
if (x <= 0) {
continue;
}
x = dfs(u, x);
if (x > 0) {
edgeFlow[e] += x;
edgeFlow[e ^ 1] -= x;
return x;
}
}
level[v] = -1;
return 0;
}
boolean bfs() {
Arrays.fill(level, -1);
q[0] = s;
level[s] = 0;
int qt = 0;
int qh = 1;
while (qt < qh) {
int v = q[qt++];
for (int e = firstEdge[v]; e >= 0; e = nextEdge[e]) {
int u = edgeDst[e];
if (edgeFlow[e] < edgeCap[e] && level[u] < 0) {
level[u] = level[v] + 1;
q[qh++] = u;
}
}
}
return level[t] >= 0;
}
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
in = new BufferedReader(new InputStreamReader(stream));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(in.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
G_SelectStrings solver = new G_SelectStrings();
solver.solve(1, in, out);
out.close();
}
static class G_SelectStrings {
public void solve(int testNumber, FastScanner in, PrintWriter out) {
int n = in.nextInt();
String[] s = new String[n];
int[] a = new int[n];
for (int i = 0; i < n; i++) {
s[i] = in.next();
}
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
Graph g = new Graph(2 * n + 2);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j && (s[i].equals(s[j]) && i < j || !s[i].equals(s[j]) && s[i].contains(s[j]))) {
g.addEdge(i, j + n, g.infinity);
}
}
}
for (int i = 0; i < n; i++) {
g.addEdge(g.s, i, a[i]);
}
for (int i = 0; i < n; i++) {
g.addEdge(i + n, g.t, a[i]);
}
long sum = 0;
for (long x : a) {
sum += x;
}
out.println(sum - g.maxFlow());
}
class Graph {
final long infinity = (long) 1e15;
int n;
int s;
int t;
int[] firstEdge;
int[] nextEdge;
int[] edgeDst;
long[] edgeCap;
long[] edgeFlow;
int numEdges;
int[] level;
int[] q;
int[] lastEdge;
Graph(int n) {
this.n = n;
s = n - 1;
t = n - 2;
firstEdge = new int[n];
final int initialEdges = 10;
nextEdge = new int[initialEdges];
edgeDst = new int[initialEdges];
edgeCap = new long[initialEdges];
edgeFlow = new long[initialEdges];
numEdges = 0;
level = new int[n];
q = new int[n];
lastEdge = new int[n];
Arrays.fill(firstEdge, -1);
}
void reallocate() {
int k = nextEdge.length * 3 / 2 + 1;
nextEdge = Arrays.copyOf(nextEdge, k);
edgeDst = Arrays.copyOf(edgeDst, k);
edgeCap = Arrays.copyOf(edgeCap, k);
edgeFlow = Arrays.copyOf(edgeFlow, k);
}
void addEdge(int a, int b, long cap) {
if (numEdges + 2 >= nextEdge.length) {
reallocate();
}
int e = numEdges++;
nextEdge[e] = firstEdge[a];
firstEdge[a] = e;
edgeDst[e] = b;
edgeCap[e] = cap;
edgeFlow[e] = 0;
e = numEdges++;
nextEdge[e] = firstEdge[b];
firstEdge[b] = e;
edgeDst[e] = a;
edgeCap[e] = 0;
edgeFlow[e] = 0;
}
long maxFlow() {
long flow = 0;
while (bfs()) {
for (int i = 0; i < n; i++) {
lastEdge[i] = firstEdge[i];
}
while (true) {
long add = dfs(s, infinity);
if (add == 0) {
break;
}
flow += add;
}
}
return flow;
}
long dfs(int v, long delta) {
if (v == t) {
return delta;
}
for (; lastEdge[v] >= 0; lastEdge[v] = nextEdge[lastEdge[v]]) {
int e = lastEdge[v];
int u = edgeDst[e];
if (level[u] != level[v] + 1) {
continue;
}
long x = Math.min(delta, edgeCap[e] - edgeFlow[e]);
if (x <= 0) {
continue;
}
x = dfs(u, x);
if (x > 0) {
edgeFlow[e] += x;
edgeFlow[e ^ 1] -= x;
return x;
}
}
level[v] = -1;
return 0;
}
boolean bfs() {
Arrays.fill(level, -1);
q[0] = s;
level[s] = 0;
int qt = 0;
int qh = 1;
while (qt < qh) {
int v = q[qt++];
for (int e = firstEdge[v]; e >= 0; e = nextEdge[e]) {
int u = edgeDst[e];
if (edgeFlow[e] < edgeCap[e] && level[u] < 0) {
level[u] = level[v] + 1;
q[qh++] = u;
}
}
}
return level[t] >= 0;
}
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
in = new BufferedReader(new InputStreamReader(stream));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(in.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| ConDefects/ConDefects/Code/abc354_g/Java/53637136 |
condefects-java_data_1617 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // 歯の本数
int Q = sc.nextInt(); // 治療の回数
// 歯の状態を管理する配列を初期化 (true: 歯が生えている, false: 歯が生えていない)
boolean[] teeth = new boolean[N + 1]; // インデックス1から使うため、サイズをN+1に設定
// 治療を行う
for (int i = 0; i < Q; i++) {
int hole = sc.nextInt(); // 穴の番号
// 治療内容に応じて穴の状態を更新する
if (teeth[hole]) {
teeth[hole] = false; // 歯が生えている場合は歯を抜く
} else {
teeth[hole] = true; // 歯が生えていない場合は歯を生やす
}
}
// 歯の本数を数える
int count = 0;
for (int i = 1; i <= N; i++) {
if (teeth[i]) { // 歯が生えている場合は本数をカウントする
count++;
}
}
// 答えを出力する
System.out.println(count);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // 歯の本数
int Q = sc.nextInt(); // 治療の回数
// 歯の状態を管理する配列を初期化 (true: 歯が生えている, false: 歯が生えていない)
boolean[] teeth = new boolean[N + 1]; // インデックス1から使うため、サイズをN+1に設定
// 治療を行う
for (int i = 0; i < Q; i++) {
int hole = sc.nextInt(); // 穴の番号
// 治療内容に応じて穴の状態を更新する
if (teeth[hole]) {
teeth[hole] = false; // 歯が生えている場合は歯を抜く
} else {
teeth[hole] = true; // 歯が生えていない場合は歯を生やす
}
}
// 歯の本数を数える
int count = 0;
for (int i = 1; i <= N; i++) {
if (teeth[i]) { // 歯が生えている場合は本数をカウントする
count++;
}
}
// 答えを出力する
System.out.println(N-count);
}
} | ConDefects/ConDefects/Code/abc350_b/Java/53258977 |
condefects-java_data_1618 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
//bは操作回数＝numbersの長さ
int numbers[];
numbers=new int [b];
//ArrrayListは勝手にクラスを指定できる＆要素数が可変
for(int x=0;x<b;x++){
int number = sc.nextInt();
numbers[x]=number;}
int c=0;
int counts=0;
//奇数回治療したやつ 歯がないやつ
for(c=1;c<(a+1);c++){int count=0;
for(int d=0;d<b;d++){
if(c==numbers[d]){
count++;
} }
if(count%2==1){counts++;
}
}
System.out.println(counts);}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
//bは操作回数＝numbersの長さ
int numbers[];
numbers=new int [b];
//ArrrayListは勝手にクラスを指定できる＆要素数が可変
for(int x=0;x<b;x++){
int number = sc.nextInt();
numbers[x]=number;}
int c=0;
int counts=0;
//奇数回治療したやつ 歯がないやつ
for(c=1;c<(a+1);c++){int count=0;
for(int d=0;d<b;d++){
if(c==numbers[d]){
count++;
} }
if(count%2==1){counts++;
}
}
System.out.println(a-counts);}
}
| ConDefects/ConDefects/Code/abc350_b/Java/52935096 |
condefects-java_data_1619 |
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
String s;
char[][] field = new char[9][9];
ArrayList<Integer> koma = new ArrayList<>();
int ans = 0;
int[] c = new int[4];
for(int i = 0; i< 9;i++) {
s =sc.next();
for(int j = 0;j < 9;j++) {
field[i][j] = s.charAt(j);
if(s.charAt(j) == '#') {
koma.add(i * 9 + j);
}
}
}
System.out.print(koma);
for(int i = 0;i < koma.size();i++) {
for(int j = i + 1;j < koma.size();j++) {
for(int k = j + 1;k < koma.size();k++) {
for(int l = k + 1 ;l < koma.size();l++) {
c[0] = koma.get(i);
c[1] = koma.get(j);
c[2] = koma.get(k);
c[3] = koma.get(l);
if((c[1]/9 - c[0]/9) * (c[1]/9 - c[0]/9) + (c[1]%9 - c[0]%9) * (c[1]%9 - c[0]%9)
== (c[0]/9 - c[2]/9) * (c[0]/9 - c[2]/9) + (c[0]%9 - c[2]%9) * (c[0]%9 - c[2]%9)
&& (c[3]/9 - c[2]/9) * (c[3]/9 - c[2]/9) + (c[3]%9 - c[2]%9) * (c[3]%9 - c[2]%9)
== (c[1]/9 - c[3]/9) * (c[1]/9 - c[3]/9) + (c[1]%9 - c[3]%9) * (c[1]%9 - c[3]%9)
&& (c[1]/9 - c[3]/9) * (c[1]/9 - c[3]/9) + (c[3]%9 - c[1]%9) * (c[3]%9 - c[1]%9)
== (c[1]/9 - c[0]/9) * (c[1]/9 - c[0]/9) + (c[1]%9 - c[0]%9) * (c[1]%9 - c[0]%9)
&& (c[3]/9 - c[0]/9) * (c[3]/9 - c[0]/9) + (c[3]%9 - c[0]%9) * (c[3]%9 - c[0]%9)
== (c[2]/9 - c[1]/9) * (c[2]/9 - c[1]/9) + (c[2]%9 - c[1]%9) * (c[2]%9 - c[1]%9)) {
//System.out.println(c[0]+ " " + c[1]+ " " + c[2] +" " +c[3]);
// System.out.println(" " +ans);
ans++;
}
}
}
}
}
System.out.print(ans);
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
String s;
char[][] field = new char[9][9];
ArrayList<Integer> koma = new ArrayList<>();
int ans = 0;
int[] c = new int[4];
for(int i = 0; i< 9;i++) {
s =sc.next();
for(int j = 0;j < 9;j++) {
field[i][j] = s.charAt(j);
if(s.charAt(j) == '#') {
koma.add(i * 9 + j);
}
}
}
//System.out.print(koma);
for(int i = 0;i < koma.size();i++) {
for(int j = i + 1;j < koma.size();j++) {
for(int k = j + 1;k < koma.size();k++) {
for(int l = k + 1 ;l < koma.size();l++) {
c[0] = koma.get(i);
c[1] = koma.get(j);
c[2] = koma.get(k);
c[3] = koma.get(l);
if((c[1]/9 - c[0]/9) * (c[1]/9 - c[0]/9) + (c[1]%9 - c[0]%9) * (c[1]%9 - c[0]%9)
== (c[0]/9 - c[2]/9) * (c[0]/9 - c[2]/9) + (c[0]%9 - c[2]%9) * (c[0]%9 - c[2]%9)
&& (c[3]/9 - c[2]/9) * (c[3]/9 - c[2]/9) + (c[3]%9 - c[2]%9) * (c[3]%9 - c[2]%9)
== (c[1]/9 - c[3]/9) * (c[1]/9 - c[3]/9) + (c[1]%9 - c[3]%9) * (c[1]%9 - c[3]%9)
&& (c[1]/9 - c[3]/9) * (c[1]/9 - c[3]/9) + (c[3]%9 - c[1]%9) * (c[3]%9 - c[1]%9)
== (c[1]/9 - c[0]/9) * (c[1]/9 - c[0]/9) + (c[1]%9 - c[0]%9) * (c[1]%9 - c[0]%9)
&& (c[3]/9 - c[0]/9) * (c[3]/9 - c[0]/9) + (c[3]%9 - c[0]%9) * (c[3]%9 - c[0]%9)
== (c[2]/9 - c[1]/9) * (c[2]/9 - c[1]/9) + (c[2]%9 - c[1]%9) * (c[2]%9 - c[1]%9)) {
//System.out.println(c[0]+ " " + c[1]+ " " + c[2] +" " +c[3]);
// System.out.println(" " +ans);
ans++;
}
}
}
}
}
System.out.print(ans);
}
} | ConDefects/ConDefects/Code/abc275_c/Java/39767771 |
condefects-java_data_1620 | import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
sc.close();
Queue<String> queue = new LinkedList<>();
Map<String,Integer> map = new HashMap<>();
queue.add(S);
map.put(S,0);
while(!queue.isEmpty()){
String str = queue.poll();
System.out.println(str);
int cur = map.get(str);
if(str.equals("atcoder")){
System.out.println(cur);
return;
}
for(int j = 0; j < str.length()-1; j++){
String children = change(str, j, j+1);
if(!map.containsKey(children)){
map.put(children, cur+1);
queue.add(children);
}
}
}
}
public static String change(String str, int a, int b){
char[] c = str.toCharArray();
char tmp = c[a];
c[a] = c[b];
c[b] = tmp;
str = String.valueOf(c);
return str;
}
}
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
sc.close();
Queue<String> queue = new LinkedList<>();
Map<String,Integer> map = new HashMap<>();
queue.add(S);
map.put(S,0);
while(!queue.isEmpty()){
String str = queue.poll();
//System.out.println(str);
int cur = map.get(str);
if(str.equals("atcoder")){
System.out.println(cur);
return;
}
for(int j = 0; j < str.length()-1; j++){
String children = change(str, j, j+1);
if(!map.containsKey(children)){
map.put(children, cur+1);
queue.add(children);
}
}
}
}
public static String change(String str, int a, int b){
char[] c = str.toCharArray();
char tmp = c[a];
c[a] = c[b];
c[b] = tmp;
str = String.valueOf(c);
return str;
}
} | ConDefects/ConDefects/Code/abc264_d/Java/36569376 |
condefects-java_data_1621 | import java.util.Scanner;
class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int var = scanner.nextInt();
int hor = scanner.nextInt();
String check;
int[] ans = new int[hor];
String mark;
for (int i = 0; i < var; i++) {
mark = scanner.next();
for (int j = 0; j < hor; j++) {
check = String.valueOf(mark.charAt(j));
if (check.equals(".")) {
continue;
} else {
ans[j]++;
}
}
}
for (int k = 0; k < hor; k++) {
System.out.print(ans[k]);
if (k != var) {
System.out.print(" ");
}
}
scanner.close();
}
}
import java.util.Scanner;
class Main {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int var = scanner.nextInt();
int hor = scanner.nextInt();
String check;
int[] ans = new int[hor];
String mark;
for (int i = 0; i < var; i++) {
mark = scanner.next();
for (int j = 0; j < hor; j++) {
check = String.valueOf(mark.charAt(j));
if (check.equals(".")) {
continue;
} else {
ans[j]++;
}
}
}
for (int k = 0; k < hor; k++) {
System.out.print(ans[k]);
if (k != hor) {
System.out.print(" ");
}
}
scanner.close();
}
}
| ConDefects/ConDefects/Code/abc274_b/Java/36009120 |
condefects-java_data_1622 | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
for (int i = n; i < 919; i++) {
int h = (i/100)%10;
int t = (i/10)%10;
int o = i%10;
if (h*t == o) {
System.out.println(h*100+t*10+o);
break;
}
}
}
}
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
for (int i = n; i <= 919; i++) {
int h = (i/100)%10;
int t = (i/10)%10;
int o = i%10;
if (h*t == o) {
System.out.println(h*100+t*10+o);
break;
}
}
}
} | ConDefects/ConDefects/Code/abc326_b/Java/50437469 |
condefects-java_data_1623 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int x = scanner.nextInt();
for (int i = x; i < 919; i++) {
int hundreds = i / 100;
int tens = (i / 10) % 10;
int ones = i % 10;
if (hundreds * tens == ones) {
System.out.println(i);
break;
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int x = scanner.nextInt();
for (int i = x; i <= 919; i++) {
int hundreds = i / 100;
int tens = (i / 10) % 10;
int ones = i % 10;
if (hundreds * tens == ones) {
System.out.println(i);
break;
}
}
}
}
| ConDefects/ConDefects/Code/abc326_b/Java/48247152 |
condefects-java_data_1624 | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] car1 = new int[n];
int[] car2 = new int[n]; // 범위 10억
for(int i=0; i<n; i++) {
car1[i] = Integer.parseInt(sc.next());
}
for(int i=0; i<n; i++) {
car2[i] = Integer.parseInt(sc.next());
}
System.out.println(Arrays.toString(car1));
System.out.println(Arrays.toString(car2));
int cnt1 = 0;
int cnt2 = 0;
for(int i=0; i<n; i++) {
if(car1[i]==car2[i]) cnt1++;
}
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
if(car1[i]==car2[j]) {
cnt2++;
break;
}
}
}
System.out.println(cnt1);
System.out.println(cnt2-cnt1);
}// 메인 끝
}
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] car1 = new int[n];
int[] car2 = new int[n]; // 범위 10억
for(int i=0; i<n; i++) {
car1[i] = Integer.parseInt(sc.next());
}
for(int i=0; i<n; i++) {
car2[i] = Integer.parseInt(sc.next());
}
int cnt1 = 0;
int cnt2 = 0;
for(int i=0; i<n; i++) {
if(car1[i]==car2[i]) cnt1++;
}
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
if(car1[i]==car2[j]) {
cnt2++;
break;
}
}
}
System.out.println(cnt1);
System.out.println(cnt2-cnt1);
}// 메인 끝
} | ConDefects/ConDefects/Code/abc243_b/Java/35827670 |
condefects-java_data_1625 | import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
static Scanner sc;
static PrintWriter out;
public static void main(String[] args) {
sc = new Scanner(System.in);
out = new PrintWriter(System.out);
new Main().solve();
out.flush();
}
static long mod = 998244353;
public void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
init(Math.max(n, n + (m-n) / 3) + 10);
long res = 0;
for(int s=0; s<=2; s++) {
for(int b=0; b<=n-1; b++) {
int last = s + (n-1) + b;
if(last > m) break;
int t = (m-last) / 3;
res += conv(n-1, b) * conv(n-1+t, t) % mod;
res %= mod;
// res += n-1 C b * n-1+c C t
}
}
out.println(res);
}
static long[] fac;
static long[] finv;
static long[] inv;
static void init(int max) {
fac = new long[max];
finv = new long[max];
inv = new long[max];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i=2; i<max; i++) {
fac[i] = fac[i-1] * i % mod;
inv[i] = mod - inv[(int)mod%i] * (mod / i) % mod;
finv[i] = finv[i-1] * inv[i] % mod;
}
}
static long conv(int n, int k) {
if(n<k || n<0 || k<0) return 0;
return fac[n] * (finv[k]*finv[n-k]%mod) % mod;
}
}
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
static Scanner sc;
static PrintWriter out;
public static void main(String[] args) {
sc = new Scanner(System.in);
out = new PrintWriter(System.out);
new Main().solve();
out.flush();
}
static long mod = 998244353;
public void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
init(Math.max(n, n + (m-n) / 3) + 10);
long res = 0;
for(int s=0; s<=2; s++) {
for(int b=0; b<=n-1; b++) {
int last = s + (n-1) + b;
if(last > m) break;
int t = (m-last) / 3;
res += conv(n-1, b) * conv(n+t, t) % mod;
res %= mod;
// res += n-1 C b * n-1+c C t
}
}
out.println(res);
}
static long[] fac;
static long[] finv;
static long[] inv;
static void init(int max) {
fac = new long[max];
finv = new long[max];
inv = new long[max];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i=2; i<max; i++) {
fac[i] = fac[i-1] * i % mod;
inv[i] = mod - inv[(int)mod%i] * (mod / i) % mod;
finv[i] = finv[i-1] * inv[i] % mod;
}
}
static long conv(int n, int k) {
if(n<k || n<0 || k<0) return 0;
return fac[n] * (finv[k]*finv[n-k]%mod) % mod;
}
}
| ConDefects/ConDefects/Code/abc276_g/Java/36259872 |
condefects-java_data_1626 | import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main {
static void solve () {
int n = nextInt();
char[][] a = new char[n*3][n*3];
for (int i=0; i<n; i++) {
String s = next();
for (int j=0; j<n; j++) {
a[i][j] = s.charAt(j);
a[i][j+n] = a[i][j];
a[i][j+n*2] = a[i][j];
a[i+n][j] = a[i][j];
a[i+n][j+n] = a[i][j];
a[i+n][j+n*2] = a[i][j];
a[i+n*2][j] = a[i][j];
a[i+n*2][j+n] = a[i][j];
a[i+n*2][j+n*2] = a[i][j];
}
}
int[] sy = {-1, -1, -1, 0, 1, 1, 1, 0};
int[] sx = {-1, 0, 1, 1, 1, 0, -1, -1};
long max = Integer.MIN_VALUE;
for (int i=n; i<2*n; i++) {
for (int j=n; j<2*n; j++) {
for (int k=0; k<8; k++) {
Point p = new Point(i, j);
StringBuilder sb = new StringBuilder();
sb.append(a[p.y][p.x]);
for (int l=0; l<n; l++) {
p.y += sy[k];
p.x += sx[k];
sb.append(a[p.y][p.x]);
}
max = Math.max(max, Long.parseLong(sb.toString()));
}
}
}
println(max);
}
public static String yesno(boolean b) {return b?"Yes":"No";}
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static String next() {return in.next();}
public static char nextChar() {return next().charAt(0);}
public static int nextInt() {return in.nextInt();}
public static Double nextDouble() {return in.nextDouble();}
public static Long nextLong() {return in.nextLong();}
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static String[] nextStringArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static char[] nextCharArray() {
return next().toCharArray();
}
public static char[][] nextCharTable(int h, int w) {
char[][] a = new char[h][w];
for (int i=0; i<h; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
static Scanner in = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
solve();
in.close();
out.close();
}
}
class Point {
int y, x;
Point (int y, int x) {
this.y = y;
this.x = x;
}
public int getY () {return y;}
public int getX () {return x;}
}
import java.io.PrintWriter;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main {
static void solve () {
int n = nextInt();
char[][] a = new char[n*3][n*3];
for (int i=0; i<n; i++) {
String s = next();
for (int j=0; j<n; j++) {
a[i][j] = s.charAt(j);
a[i][j+n] = a[i][j];
a[i][j+n*2] = a[i][j];
a[i+n][j] = a[i][j];
a[i+n][j+n] = a[i][j];
a[i+n][j+n*2] = a[i][j];
a[i+n*2][j] = a[i][j];
a[i+n*2][j+n] = a[i][j];
a[i+n*2][j+n*2] = a[i][j];
}
}
int[] sy = {-1, -1, -1, 0, 1, 1, 1, 0};
int[] sx = {-1, 0, 1, 1, 1, 0, -1, -1};
long max = Integer.MIN_VALUE;
for (int i=n; i<2*n; i++) {
for (int j=n; j<2*n; j++) {
for (int k=0; k<8; k++) {
Point p = new Point(i, j);
StringBuilder sb = new StringBuilder();
sb.append(a[p.y][p.x]);
for (int l=0; l<n-1; l++) {
p.y += sy[k];
p.x += sx[k];
sb.append(a[p.y][p.x]);
}
max = Math.max(max, Long.parseLong(sb.toString()));
}
}
}
println(max);
}
public static String yesno(boolean b) {return b?"Yes":"No";}
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static String next() {return in.next();}
public static char nextChar() {return next().charAt(0);}
public static int nextInt() {return in.nextInt();}
public static Double nextDouble() {return in.nextDouble();}
public static Long nextLong() {return in.nextLong();}
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static String[] nextStringArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static char[] nextCharArray() {
return next().toCharArray();
}
public static char[][] nextCharTable(int h, int w) {
char[][] a = new char[h][w];
for (int i=0; i<h; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
static Scanner in = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) {
solve();
in.close();
out.close();
}
}
class Point {
int y, x;
Point (int y, int x) {
this.y = y;
this.x = x;
}
public int getY () {return y;}
public int getX () {return x;}
} | ConDefects/ConDefects/Code/abc258_b/Java/38104176 |
condefects-java_data_1627 |
import java.util.Scanner;
class Main {
public static void main (String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
//数値ではなく、数字をとる。取り出しは数字で。
char[][] s=new char[n][n];
for(int i=0;i<n;i++) {
s[i]=sc.next().toCharArray();
}
//数値の配列をつくる。表
int[][] map=new int[n][n];
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
map[i][j]=s[i][j]-'0';//数字から数値にかえる
}
}
//八方位（north, northeast, east, southeast, south, southwest, west, northwest）
int[] dx= {0,-1,-1,-1,0,1,1,1};
int[] dy= {-1,-1,0,1,1,1,0,-1};
long ans=0;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
//8方向別れ
for(int k=0;k<8;k++) {
long sum=0;
//n-1回移動を繰り返す
for(int l=0;l<n;l++) {
int y=(i+dy[k]*l+n)%n;
int x=(j+dx[k]*l+n)%n;
//トレース出力
// System.out.print("i="+i+",j="+j+"*");
// System.out.print("x="+x+",y="+y);
// System.out.println();
// sum=sum*10+map[y][x];
// System.out.print("sum="+sum+",");
ans=Math.max(ans, sum);
}
}
}
}
System.out.println(ans);
}
}
import java.util.Scanner;
class Main {
public static void main (String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
//数値ではなく、数字をとる。取り出しは数字で。
char[][] s=new char[n][n];
for(int i=0;i<n;i++) {
s[i]=sc.next().toCharArray();
}
//数値の配列をつくる。表
int[][] map=new int[n][n];
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
map[i][j]=s[i][j]-'0';//数字から数値にかえる
}
}
//八方位（north, northeast, east, southeast, south, southwest, west, northwest）
int[] dx= {0,-1,-1,-1,0,1,1,1};
int[] dy= {-1,-1,0,1,1,1,0,-1};
long ans=0;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
//8方向別れ
for(int k=0;k<8;k++) {
long sum=0;
//n-1回移動を繰り返す
for(int l=0;l<n;l++) {
int y=(i+dy[k]*l+n)%n;
int x=(j+dx[k]*l+n)%n;
//トレース出力
// System.out.print("i="+i+",j="+j+"*");
// System.out.print("x="+x+",y="+y);
// System.out.println();
sum=sum*10+map[y][x];
// System.out.print("sum="+sum+",");
ans=Math.max(ans, sum);
}
}
}
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc258_b/Java/39960192 |
condefects-java_data_1628 | import java.io.PrintWriter;
import java.lang.Character.Subset;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
class Main {
public static int nextInt(Scanner sc) {
return Integer.parseInt(sc.next());
}
public static long nextLong(Scanner sc) {
return Long.parseLong(sc.next());
}
static char[] abcArray = "abcdefghijklmnopqrstuvwxyz".toCharArray();
static char[] ABCArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
static HashMap<Integer, int[]> map = new HashMap<>();
static int H;
static int W;
static int N;
static char[][] figure;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
N = nextInt(sc);
figure = new char[N][N];
for (int i = 0; i < N; i++) {
String line = sc.next();
figure[i] = line.toCharArray();
}
long ans = 0;
for (int i = 0; i < N; i++) {
for (int ii = 0; ii < N; ii++) {
int[] now = { i, ii };
long[] longArray = new long[8];
longArray[0] = solve(now, 1, 0, new StringBuffer());
longArray[1] = solve(now, -1, 0, new StringBuffer());
longArray[2] = solve(now, 0, 1, new StringBuffer());
longArray[3] = solve(now, 0, -1, new StringBuffer());
longArray[4] = solve(now, 1, 1, new StringBuffer());
longArray[5] = solve(now, -1, -1, new StringBuffer());
longArray[6] = solve(now, 1, -1, new StringBuffer());
longArray[7] = solve(now, -1, 1, new StringBuffer());
Arrays.sort(longArray);
ans = Math.max(ans, longArray[7]);
}
}
System.out.println(ans);
}
public static long solve(int[] now, int h, int w, StringBuffer sb) {
if (now[0] < 0) {
now[0] = N - 1;
}
if (N <= now[0]) {
now[0] = 0;
}
if (now[1] < 0) {
now[1] = N - 1;
}
if (N <= now[1]) {
now[1] = 0;
}
sb.append(figure[now[0]][now[1]]);
if (sb.length() < N) {
int[] next = { now[0] + h, now[0] + w };
solve(next, h, w, sb);
}
return Long.parseLong(sb.toString());
}
}
import java.io.PrintWriter;
import java.lang.Character.Subset;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
class Main {
public static int nextInt(Scanner sc) {
return Integer.parseInt(sc.next());
}
public static long nextLong(Scanner sc) {
return Long.parseLong(sc.next());
}
static char[] abcArray = "abcdefghijklmnopqrstuvwxyz".toCharArray();
static char[] ABCArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
static HashMap<Integer, int[]> map = new HashMap<>();
static int H;
static int W;
static int N;
static char[][] figure;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
N = nextInt(sc);
figure = new char[N][N];
for (int i = 0; i < N; i++) {
String line = sc.next();
figure[i] = line.toCharArray();
}
long ans = 0;
for (int i = 0; i < N; i++) {
for (int ii = 0; ii < N; ii++) {
int[] now = { i, ii };
long[] longArray = new long[8];
longArray[0] = solve(now, 1, 0, new StringBuffer());
longArray[1] = solve(now, -1, 0, new StringBuffer());
longArray[2] = solve(now, 0, 1, new StringBuffer());
longArray[3] = solve(now, 0, -1, new StringBuffer());
longArray[4] = solve(now, 1, 1, new StringBuffer());
longArray[5] = solve(now, -1, -1, new StringBuffer());
longArray[6] = solve(now, 1, -1, new StringBuffer());
longArray[7] = solve(now, -1, 1, new StringBuffer());
Arrays.sort(longArray);
ans = Math.max(ans, longArray[7]);
}
}
System.out.println(ans);
}
public static long solve(int[] now, int h, int w, StringBuffer sb) {
if (now[0] < 0) {
now[0] = N - 1;
}
if (N <= now[0]) {
now[0] = 0;
}
if (now[1] < 0) {
now[1] = N - 1;
}
if (N <= now[1]) {
now[1] = 0;
}
sb.append(figure[now[0]][now[1]]);
if (sb.length() < N) {
int[] next = { now[0] + h, now[1] + w };
solve(next, h, w, sb);
}
return Long.parseLong(sb.toString());
}
}
| ConDefects/ConDefects/Code/abc258_b/Java/40147071 |
condefects-java_data_1629 | import java.util.*;
public class Main {
void solve() {
Scanner in = new Scanner(System.in);
long n = in.nextLong();
long s = n + 1 - in.nextLong();
long t = n + 1 - in.nextLong();
long b = in.nextLong();
long a = in.nextLong();
double left = 0;
double right = 10000000000.0;
for (int i = 0; i < 100; i++) {
double mid = (left + right) / 2;
long cSub = Math.min((long)Math.ceil((mid + a) / b), n - t + 1);
double prb = (n - cSub) * (mid + a);
prb += b * cSub * (cSub - 1) / 2;
if (mid * n > prb) {
right = mid;
} else {
left = mid;
}
}
double ans = left + a;
if (t <= s) {
ans = Math.min(ans, (s - t) * b);
}
System.out.println(ans);
}
public static void main(String[] args) {
new Main().solve();
}
}
import java.util.*;
public class Main {
void solve() {
Scanner in = new Scanner(System.in);
long n = in.nextLong();
long s = n + 1 - in.nextLong();
long t = n + 1 - in.nextLong();
long b = in.nextLong();
long a = in.nextLong();
double left = 0;
double right = 10000000000000000000.0;
for (int i = 0; i < 100; i++) {
double mid = (left + right) / 2;
long cSub = Math.min((long)Math.ceil((mid + a) / b), n - t + 1);
double prb = (n - cSub) * (mid + a);
prb += b * cSub * (cSub - 1) / 2;
if (mid * n > prb) {
right = mid;
} else {
left = mid;
}
}
double ans = left + a;
if (t <= s) {
ans = Math.min(ans, (s - t) * b);
}
System.out.println(ans);
}
public static void main(String[] args) {
new Main().solve();
}
}
| ConDefects/ConDefects/Code/abc224_g/Java/26809838 |
condefects-java_data_1630 | import java.util.*;
@SuppressWarnings("unused")
public class Main {
private static void solve() {
double n = ni();
double s = ni();
double t = ni();
double a = ni();
double b = ni();
double ret = s <= t ? (t - s) * a : Double.MAX_VALUE;
double x = Math.sqrt(2 * n * b / a);
x = Math.min(x, t);
for (double y = Math.floor(Math.max(x - 3, 1)); y <= Math.min(t, x + 3); y += 1) {
ret = Math.min(ret, n * b / x + (x - 1) * a / 2);
}
System.out.printf("%.12f\n", 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() {
double n = ni();
double s = ni();
double t = ni();
double a = ni();
double b = ni();
double ret = s <= t ? (t - s) * a : Double.MAX_VALUE;
double x = Math.sqrt(2 * n * b / a);
x = Math.min(x, t);
for (double y = Math.floor(Math.max(x - 3, 1)); y <= Math.min(t, x + 3); y += 1) {
ret = Math.min(ret, n * b / y + (y - 1) * a / 2);
}
System.out.printf("%.12f\n", 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/abc224_g/Java/27511818 |
condefects-java_data_1631 | import java.util.*;
import java.io.*;
class Main{
static ArrayList<ArrayList<Integer>> list;
static FastScanner fs = null;
public static void main(String[] args) {
fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = fs.nextInt();
int a[] = new int[n];
for(int i=0;i<n;i++){
a[i] = fs.nextInt();
}
int flip = 0;
boolean res = true;
int st = 0;
int end = n-1;
while(end>=st){
int d = flip%2;
int c = 0;
while (end>=0 && (d+a[end])%2==1) {
end-=1;
c+=1;
}
if(c>0){
if(end<=st){
res = false;
break;
}
if((a[st]+flip)%2==0){
st+=1;
}
else{
res = false;
break;
}
flip+=1;
}
else{
while (end>=0 && (d+a[end])%2==0) {
end-=1;
}
if(st==end){
res = false;
break;
}
}
}
if(res)
out.println("Yes");
else
out.println("No");
out.close();
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
}
import java.util.*;
import java.io.*;
class Main{
static ArrayList<ArrayList<Integer>> list;
static FastScanner fs = null;
public static void main(String[] args) {
fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = fs.nextInt();
int a[] = new int[n];
for(int i=0;i<n;i++){
a[i] = fs.nextInt();
}
int flip = 0;
boolean res = true;
int st = 0;
int end = n-1;
while(end>=st){
int d = flip%2;
int c = 0;
while (end>=0 && (d+a[end])%2==1) {
end-=1;
c+=1;
}
if(c>0){
if(end<st){
res = false;
break;
}
if((a[st]+flip)%2==0){
st+=1;
}
else{
res = false;
break;
}
flip+=1;
}
else{
while (end>=0 && (d+a[end])%2==0) {
end-=1;
}
if(st==end){
res = false;
break;
}
}
}
if(res)
out.println("Yes");
else
out.println("No");
out.close();
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
} | ConDefects/ConDefects/Code/arc138_b/Java/32429652 |
condefects-java_data_1632 | import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.Scanner;
import java.util.function.IntFunction;
public class Main {
final static long s = System.currentTimeMillis();
public static void main(final String[] args) {
new Main().solve();
pw.flush();
// System.out.println(System.currentTimeMillis() - s);
}
final int N = scInt();
final Integer[] A = scInt(N);
void solve() {
final Deque<Integer> deq = new ArrayDeque<>();
for (int i = 0; i < N; i++)
deq.add(A[i]);
boolean rev = false;
while (!deq.isEmpty()) {
if (deq.getFirst() == 1 && !rev || rev && deq.getLast() == 0) {
out("No");
return;
}
while (!deq.isEmpty() && (deq.getLast() == 0 && !rev || rev && deq.getLast() == 1))
deq.pollLast();
if (deq.isEmpty())
break;
rev = !rev;
deq.poll();
}
out("Yes");
}
/* 入力 */
static Scanner sc = new Scanner(System.in);
Integer scInt() { return Integer.parseInt(sc.next()); }
Integer[] scInt(final int N) { return scArray(new Integer[N], i -> scInt()); }
Integer[][] scInt(final int H, final int W) { return scArray(new Integer[H][], i -> scInt(W)); }
Integer scIdx() { return scInt() - 1; }
Integer[] scIdx(final int N) { return scArray(new Integer[N], i -> scIdx()); }
Long scLong() { return Long.parseLong(sc.next()); }
Long[] scLong(final int N) { return scArray(new Long[N], i -> scLong()); }
Double scDbl() { return Double.parseDouble(sc.next()); }
Double[] scDbl(final int N) { return scArray(new Double[N], i -> scDbl()); }
String scStr() { return sc.next(); }
String[] scStr(final int N) { return scArray(new String[N], i -> scStr()); }
char[] scCh() { return scStr().toCharArray(); }
<T> T[] scArray(final T[] arr, final IntFunction<T> fnc) {
Arrays.setAll(arr, fnc);
return arr;
}
/* 出力 */
static PrintWriter pw = new PrintWriter(System.out);
void out(final Object... ret) {
final StringBuilder sb = new StringBuilder();
sb.append(ret[0]);
for (int i = 1; i < ret.length; i++)
sb.append(' ' + ret[i].toString());
pw.println(sb.toString());
}
}
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.Scanner;
import java.util.function.IntFunction;
public class Main {
final static long s = System.currentTimeMillis();
public static void main(final String[] args) {
new Main().solve();
pw.flush();
// System.out.println(System.currentTimeMillis() - s);
}
final int N = scInt();
final Integer[] A = scInt(N);
void solve() {
final Deque<Integer> deq = new ArrayDeque<>();
for (int i = 0; i < N; i++)
deq.add(A[i]);
boolean rev = false;
while (!deq.isEmpty()) {
if (deq.getFirst() == 1 && !rev || rev && deq.getFirst() == 0) {
out("No");
return;
}
while (!deq.isEmpty() && (deq.getLast() == 0 && !rev || rev && deq.getLast() == 1))
deq.pollLast();
if (deq.isEmpty())
break;
rev = !rev;
deq.poll();
}
out("Yes");
}
/* 入力 */
static Scanner sc = new Scanner(System.in);
Integer scInt() { return Integer.parseInt(sc.next()); }
Integer[] scInt(final int N) { return scArray(new Integer[N], i -> scInt()); }
Integer[][] scInt(final int H, final int W) { return scArray(new Integer[H][], i -> scInt(W)); }
Integer scIdx() { return scInt() - 1; }
Integer[] scIdx(final int N) { return scArray(new Integer[N], i -> scIdx()); }
Long scLong() { return Long.parseLong(sc.next()); }
Long[] scLong(final int N) { return scArray(new Long[N], i -> scLong()); }
Double scDbl() { return Double.parseDouble(sc.next()); }
Double[] scDbl(final int N) { return scArray(new Double[N], i -> scDbl()); }
String scStr() { return sc.next(); }
String[] scStr(final int N) { return scArray(new String[N], i -> scStr()); }
char[] scCh() { return scStr().toCharArray(); }
<T> T[] scArray(final T[] arr, final IntFunction<T> fnc) {
Arrays.setAll(arr, fnc);
return arr;
}
/* 出力 */
static PrintWriter pw = new PrintWriter(System.out);
void out(final Object... ret) {
final StringBuilder sb = new StringBuilder();
sb.append(ret[0]);
for (int i = 1; i < ret.length; i++)
sb.append(' ' + ret[i].toString());
pw.println(sb.toString());
}
} | ConDefects/ConDefects/Code/arc138_b/Java/30832828 |
condefects-java_data_1633 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = Integer.parseInt(sc.next());
List<Integer> odd = new ArrayList<>();
List<Integer> even = new ArrayList<>();
int x;
for(int i = 0; i<N; i++){
x = Integer.parseInt(sc.next());
if(x % 2 == 0){
even.add(x);
}
else{
odd.add(x);
}
}
int max = -1;
if(odd.size() > 1 && even.size() > 1){
max = Math.max(odd.get(odd.size() - 1) + odd.get(odd.size() -2), even.get(even.size()-1) + even.get(even.size() -2));
}
else if(odd.size() > 1 && even.size() <= 1){
max = odd.get(odd.size() -1) + odd.get(odd.size() - 2);
}
else if(odd.size() <= 1 && even.size() > 1){
max = even.get(even.size() -1) + even.get(even.size() -2);
}
else{
}
System.out.println(max);
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = Integer.parseInt(sc.next());
List<Integer> odd = new ArrayList<>();
List<Integer> even = new ArrayList<>();
int x;
for(int i = 0; i<N; i++){
x = Integer.parseInt(sc.next());
if(x % 2 == 0){
even.add(x);
}
else{
odd.add(x);
}
}
Collections.sort(odd);
Collections.sort(even);
int max = -1;
if(odd.size() > 1 && even.size() > 1){
max = Math.max(odd.get(odd.size() - 1) + odd.get(odd.size() -2), even.get(even.size()-1) + even.get(even.size() -2));
}
else if(odd.size() > 1 && even.size() <= 1){
max = odd.get(odd.size() -1) + odd.get(odd.size() - 2);
}
else if(odd.size() <= 1 && even.size() > 1){
max = even.get(even.size() -1) + even.get(even.size() -2);
}
else{
}
System.out.println(max);
}
}
| ConDefects/ConDefects/Code/abc272_c/Java/39993217 |
condefects-java_data_1634 |
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 240 G問題
* 考察メモ
* 行動が6つなので、6に対応する感じの行動を割り当てたい
* 二次元なら45度回転だけど、これは4個→2^2個に上手くできたからいけるだけなので
* ……いや、待てよ？
* 2*3にするのはどうだろうか
* 例えば、x+1,y+1,x-1の3通りができるならどうだろう？
* この操作を用いて座標(X,Y)に行く方法の計算量はどうなるか
* これならYの操作回数は一定だからxの操作回数も一意か
* つまり、この6つの変換に置換したい
* (x+1,y,z+1)
* (x-1,y,z+1)
* (x,y+1,z+1)
* (x+1,y,z-1)
* (x-1,y,z-1)
* (x,y+1,z-1)
* さて、これをどうするか？
* ……いや、違うか
* (x, y, z) -> (x+y, x-y+z, z)みたいなのを考える(これは同型写像)
* このとき、zの回数を決め打つと、残りは45度回転
* これの計算量はO(1)にできる
*/
int N = io.nextInt(), X = io.nextInt(), Y = io.nextInt(), Z = Math.abs(io.nextInt());
if (N % 2 != (X + Y + Z) % 2) {
io.println(0);
return;
}
final ModUtility mod = new ModUtility(new Prime(998_244_353), 11_000_000);
int ans = 0;
int rX = Math.abs(X + Y), rY = Math.abs(X - Y); // 45度回転
for (int z = Z, max = N - Math.max(rX, rY);z <= max;z += 2) {
// z回の操作でZに辿り着く組合せはzC_{(z-Z)/2}で、それをN回の操作中のどこでやるかはNCz
int tmp = mod.multiply(mod.combination(z, (z - Z) / 2), mod.combination(N, z));
int operate = N - z; // 残りの操作回数
tmp = mod.multiply(tmp, mod.combination(operate, (operate - rX) / 2));
tmp = mod.multiply(tmp, mod.combination(operate, (operate - rY) / 2));
ans = mod.add(ans, tmp);
}
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;
}
/**
* 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 240 G問題
* 考察メモ
* 行動が6つなので、6に対応する感じの行動を割り当てたい
* 二次元なら45度回転だけど、これは4個→2^2個に上手くできたからいけるだけなので
* ……いや、待てよ？
* 2*3にするのはどうだろうか
* 例えば、x+1,y+1,x-1の3通りができるならどうだろう？
* この操作を用いて座標(X,Y)に行く方法の計算量はどうなるか
* これならYの操作回数は一定だからxの操作回数も一意か
* つまり、この6つの変換に置換したい
* (x+1,y,z+1)
* (x-1,y,z+1)
* (x,y+1,z+1)
* (x+1,y,z-1)
* (x-1,y,z-1)
* (x,y+1,z-1)
* さて、これをどうするか？
* ……いや、違うか
* (x, y, z) -> (x+y, x-y+z, z)みたいなのを考える(これは同型写像)
* このとき、zの回数を決め打つと、残りは45度回転
* これの計算量はO(1)にできる
*/
int N = io.nextInt(), X = io.nextInt(), Y = io.nextInt(), Z = Math.abs(io.nextInt());
if (N % 2 != Math.abs(X + Y + Z) % 2 || N < Math.abs(X) + Math.abs(Y) + Math.abs(Z)) {
io.println(0);
return;
}
final ModUtility mod = new ModUtility(new Prime(998_244_353), 11_000_000);
int ans = 0;
int rX = Math.abs(X + Y), rY = Math.abs(X - Y); // 45度回転
for (int z = Z, max = N - Math.max(rX, rY);z <= max;z += 2) {
// z回の操作でZに辿り着く組合せはzC_{(z-Z)/2}で、それをN回の操作中のどこでやるかはNCz
int tmp = mod.multiply(mod.combination(z, (z - Z) / 2), mod.combination(N, z));
int operate = N - z; // 残りの操作回数
tmp = mod.multiply(tmp, mod.combination(operate, (operate - rX) / 2));
tmp = mod.multiply(tmp, mod.combination(operate, (operate - rY) / 2));
ans = mod.add(ans, tmp);
}
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;
}
/**
* 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/abc240_g/Java/29541937 |
condefects-java_data_1635 | //Utilities
import java.io.*;
import java.util.*;
public class Main {
static int n, q;
static char[] ch;
static int[] a;
static int cmd, l, r, x, c;
static RangeBIT[] countBIT;
static MinSegmentTree minSeg;
static MaxSegmentTree maxSeg;
static TreeSet<Integer> tset;
public static void main(String[] args) throws IOException {
n = in.iscan();
ch = in.sscan().toCharArray();
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ch[i]-'a';
}
tset = new TreeSet<Integer>();
countBIT = new RangeBIT[26];
minSeg = new MinSegmentTree(n, a);
maxSeg = new MaxSegmentTree(n, a);
for (int i = 0; i < 26; i++) {
countBIT[i] = new RangeBIT(n);
}
for (int i = 0; i < n; i++) {
if (i == 0 || i > 0 && ch[i] != ch[i-1]) {
tset.add(i);
}
countBIT[ch[i]-'a'].range_add(i+1, i+1, 1);
}
q = in.iscan();
outer : while (q-- > 0) {
cmd = in.iscan();
if (cmd == 1) {
x = in.iscan()-1; c = in.sscan().charAt(0) - 'a';
int tmp = ch[x] - 'a';
countBIT[tmp].range_add(x+1, x+1, -1);
minSeg.update(x, c); maxSeg.update(x, c);
countBIT[c].range_add(x+1, x+1, 1);
tset.remove(x); tset.remove(x-1); tset.remove(x+1);
ch[x] = (char)(c+'a');
if (x-1 >= 0 && (x-1 == 0 || x-1 > 0 && ch[x-1] != ch[x-2])) {
tset.add(x-1);
}
if (x == 0 || x > 0 && ch[x] != ch[x-1]) {
tset.add(x);
}
if (x+1 < n && ch[x+1] != ch[x]) {
tset.add(x+1);
}
}
else {
l = in.iscan()-1; r = in.iscan()-1;
boolean isSorted = true;
Integer idx = tset.floor(l);
char prev = ch[idx];
while (true) {
idx = tset.higher(idx);
if (idx == null || idx > r) {
break;
}
char cur = ch[idx];
if (cur < prev) {
isSorted = false;
break;
}
prev = cur;
}
if (!isSorted) {
out.println("No");
continue outer;
}
boolean hasCount = true;
int min = minSeg.query(l, r), max = maxSeg.query(l, r);
for (int i = min+1; i <= max-1; i++) {
long curCount = countBIT[i].range_sum(l+1, r+1);
long totCount = countBIT[i].range_sum(l+1, r+1);
if (curCount != totCount) {
hasCount = false;
break;
}
}
if (!hasCount) {
out.println("No");
}
else {
out.println("Yes");
}
}
}
out.close();
}
static class RangeBIT {
int n;
long[] m, a;
RangeBIT(int n){
this.n = n;
m = new long[n+1];
a = new long[n+1];
}
RangeBIT(int n, long[] b) {
this.n = n;
m = new long[n+1];
a = new long[n+1];
for (int i = 1; i <= n; i++) {
range_add(i, i, b[i]);
}
}
void range_add(int l, int r, long v) { // NOTE: l and r cannot be 0, use one-indexed representation of l and r
add(m, l, v);
add(m, r+1, -v);
add(a, l, v*(l-1));
add(a, r+1, -v*r);
}
void add(long[] a, int idx, long v) {
for (int i = idx; i <= n; i += i&-i) {
a[i] += v;
}
}
long sum(long[] a, int idx) {
long ret = 0;
for (int i = idx; i > 0; i -= i&-i) {
ret += a[i];
}
return ret;
}
long prefix_sum(int idx) {
return sum(m, idx)*idx - sum(a, idx);
}
long range_sum(int l, int r) {
return prefix_sum(r) - prefix_sum(l-1);
}
}
static class MinSegmentTree {
int n;
int[] a, st;
MinSegmentTree(int n){
this.n = n;
a = new int[n];
st = new int[4*n+5];
}
MinSegmentTree(int n, int[] b){
this.n = n;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = b[i];
}
st = new int[4*n+5];
init(1, 0, n-1);
}
void init(int i, int l, int r){
if (l == r) {
st[i] = a[l];
return;
}
int mid = (l+r)/2;
init(2*i, l, mid);
init(2*i+1, mid + 1, r);
st[i] = comb(st[2*i], st[2*i+1]);
}
void update(int idx, int v) {
update(1, 0, n-1, idx, v);
}
void update(int i, int l, int r, int idx, int v){
if (l == r) {
st[i] = v; // NOTE: might want to change this to optimize for speed
return;
}
int mid = (l+r)/2;
if (idx <= mid) {
update(2*i, l, mid, idx, v);
}
else {
update(2*i+1, mid + 1, r, idx, v);
}
st[i] = comb(st[2*i], st[2*i+1]);
}
int query(int ql, int qr) {
return query(1, 0, n-1, ql, qr);
}
int query(int i, int l, int r, int ql, int qr){
if (qr < l || ql > r) return Integer.MAX_VALUE; // NOTE: might need to change this depending on the "comb" method
if (ql <= l && r <= qr) return st[i];
int mid = (l+r) / 2;
return comb(query(2*i, l, mid, ql, qr), query(2*i+1, mid + 1, r, ql, qr));
}
int comb(int a, int b) {
return Math.min(a, b);
}
}
static class MaxSegmentTree {
int n;
int[] a, st;
MaxSegmentTree(int n){
this.n = n;
a = new int[n];
st = new int[4*n+5];
}
MaxSegmentTree(int n, int[] b){
this.n = n;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = b[i];
}
st = new int[4*n+5];
init(1, 0, n-1);
}
void init(int i, int l, int r){
if (l == r) {
st[i] = a[l];
return;
}
int mid = (l+r)/2;
init(2*i, l, mid);
init(2*i+1, mid + 1, r);
st[i] = comb(st[2*i], st[2*i+1]);
}
void update(int idx, int v) {
update(1, 0, n-1, idx, v);
}
void update(int i, int l, int r, int idx, int v){
if (l == r) {
st[i] = v; // NOTE: might want to change this to optimize for speed
return;
}
int mid = (l+r)/2;
if (idx <= mid) {
update(2*i, l, mid, idx, v);
}
else {
update(2*i+1, mid + 1, r, idx, v);
}
st[i] = comb(st[2*i], st[2*i+1]);
}
int query(int ql, int qr) {
return query(1, 0, n-1, ql, qr);
}
int query(int i, int l, int r, int ql, int qr){
if (qr < l || ql > r) return Integer.MIN_VALUE; // NOTE: might need to change this depending on the "comb" method
if (ql <= l && r <= qr) return st[i];
int mid = (l+r) / 2;
return comb(query(2*i, l, mid, ql, qr), query(2*i+1, mid + 1, r, ql, qr));
}
int comb(int a, int b) {
return Math.max(a, b);
}
}
static INPUT in = new INPUT(System.in);
static PrintWriter out = new PrintWriter(System.out);
private static class INPUT {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public INPUT (InputStream stream) {
this.stream = stream;
}
public INPUT (String file) throws IOException {
this.stream = new FileInputStream (file);
}
public int cscan () throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read (buf);
}
if (numChars == -1)
return numChars;
return buf[curChar++];
}
public int iscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
int res = 0;
do {
res = (res << 1) + (res << 3);
res += c - '0';
c = cscan ();
}
while (!space (c));
return res * sgn;
}
public String sscan () throws IOException {
int c = cscan ();
while (space (c))
c = cscan ();
StringBuilder res = new StringBuilder ();
do {
res.appendCodePoint (c);
c = cscan ();
}
while (!space (c));
return res.toString ();
}
public double dscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
double res = 0;
while (!space (c) && c != '.') {
if (c == 'e' || c == 'E')
return res * UTILITIES.fast_pow (10, iscan ());
res *= 10;
res += c - '0';
c = cscan ();
}
if (c == '.') {
c = cscan ();
double m = 1;
while (!space (c)) {
if (c == 'e' || c == 'E')
return res * UTILITIES.fast_pow (10, iscan ());
m /= 10;
res += (c - '0') * m;
c = cscan ();
}
}
return res * sgn;
}
public long lscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
long res = 0;
do {
res = (res << 1) + (res << 3);
res += c - '0';
c = cscan ();
}
while (!space (c));
return res * sgn;
}
public boolean space (int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
public static class UTILITIES {
static final double EPS = 10e-6;
public static void sort(int[] a, boolean increasing) {
ArrayList<Integer> arr = new ArrayList<Integer>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static void sort(long[] a, boolean increasing) {
ArrayList<Long> arr = new ArrayList<Long>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static void sort(double[] a, boolean increasing) {
ArrayList<Double> arr = new ArrayList<Double>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static int lower_bound (int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static int upper_bound (int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static void updateMap(HashMap<Integer, Integer> map, int key, int v) {
if (!map.containsKey(key)) {
map.put(key, v);
}
else {
map.put(key, map.get(key) + v);
}
if (map.get(key) == 0) {
map.remove(key);
}
}
public static long gcd (long a, long b) {
return b == 0 ? a : gcd (b, a % b);
}
public static long lcm (long a, long b) {
return a * b / gcd (a, b);
}
public static long fast_pow_mod (long b, long x, int mod) {
if (x == 0) return 1;
if (x == 1) return b % mod;
if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;
return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
}
public static long fast_pow (long b, long x) {
if (x == 0) return 1;
if (x == 1) return b;
if (x % 2 == 0) return fast_pow (b * b, x / 2);
return b * fast_pow (b * b, x / 2);
}
public static long choose (long n, long k) {
if (k > n || k < 0) {
return 0;
}
k = Math.min (k, n - k);
long val = 1;
for (int i = 0; i < k; ++i)
val = val * (n - i) / (i + 1);
return val;
}
public static long permute (int n, int k) {
if (n < k) return 0;
long val = 1;
for (int i = 0; i < k; ++i)
val = (val * (n - i));
return val;
}
// start of permutation and lower/upper bound template
public static void nextPermutation(int[] nums) {
//find first decreasing digit
int mark = -1;
for (int i = nums.length - 1; i > 0; i--) {
if (nums[i] > nums[i - 1]) {
mark = i - 1;
break;
}
}
if (mark == -1) {
reverse(nums, 0, nums.length - 1);
return;
}
int idx = nums.length-1;
for (int i = nums.length-1; i >= mark+1; i--) {
if (nums[i] > nums[mark]) {
idx = i;
break;
}
}
swap(nums, mark, idx);
reverse(nums, mark + 1, nums.length - 1);
}
public static void swap(int[] nums, int i, int j) {
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
public static void reverse(int[] nums, int i, int j) {
while (i < j) {
swap(nums, i, j);
i++;
j--;
}
}
static int lower_bound (int[] arr, int hi, int cmp) {
int low = 0, high = hi, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= cmp) high = mid;
else low = mid + 1;
}
return low;
}
static int upper_bound (int[] arr, int hi, int cmp) {
int low = 0, high = hi, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > cmp) high = mid;
else low = mid + 1;
}
return low;
}
// end of permutation and lower/upper bound template
}
}
//Utilities
import java.io.*;
import java.util.*;
public class Main {
static int n, q;
static char[] ch;
static int[] a;
static int cmd, l, r, x, c;
static RangeBIT[] countBIT;
static MinSegmentTree minSeg;
static MaxSegmentTree maxSeg;
static TreeSet<Integer> tset;
public static void main(String[] args) throws IOException {
n = in.iscan();
ch = in.sscan().toCharArray();
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = ch[i]-'a';
}
tset = new TreeSet<Integer>();
countBIT = new RangeBIT[26];
minSeg = new MinSegmentTree(n, a);
maxSeg = new MaxSegmentTree(n, a);
for (int i = 0; i < 26; i++) {
countBIT[i] = new RangeBIT(n);
}
for (int i = 0; i < n; i++) {
if (i == 0 || i > 0 && ch[i] != ch[i-1]) {
tset.add(i);
}
countBIT[ch[i]-'a'].range_add(i+1, i+1, 1);
}
q = in.iscan();
outer : while (q-- > 0) {
cmd = in.iscan();
if (cmd == 1) {
x = in.iscan()-1; c = in.sscan().charAt(0) - 'a';
int tmp = ch[x] - 'a';
countBIT[tmp].range_add(x+1, x+1, -1);
minSeg.update(x, c); maxSeg.update(x, c);
countBIT[c].range_add(x+1, x+1, 1);
tset.remove(x); tset.remove(x-1); tset.remove(x+1);
ch[x] = (char)(c+'a');
if (x-1 >= 0 && (x-1 == 0 || x-1 > 0 && ch[x-1] != ch[x-2])) {
tset.add(x-1);
}
if (x == 0 || x > 0 && ch[x] != ch[x-1]) {
tset.add(x);
}
if (x+1 < n && ch[x+1] != ch[x]) {
tset.add(x+1);
}
}
else {
l = in.iscan()-1; r = in.iscan()-1;
boolean isSorted = true;
Integer idx = tset.floor(l);
char prev = ch[idx];
while (true) {
idx = tset.higher(idx);
if (idx == null || idx > r) {
break;
}
char cur = ch[idx];
if (cur < prev) {
isSorted = false;
break;
}
prev = cur;
}
if (!isSorted) {
out.println("No");
continue outer;
}
boolean hasCount = true;
int min = minSeg.query(l, r), max = maxSeg.query(l, r);
for (int i = min+1; i <= max-1; i++) {
long curCount = countBIT[i].range_sum(l+1, r+1);
long totCount = countBIT[i].range_sum(1, n);
if (curCount != totCount) {
hasCount = false;
break;
}
}
if (!hasCount) {
out.println("No");
}
else {
out.println("Yes");
}
}
}
out.close();
}
static class RangeBIT {
int n;
long[] m, a;
RangeBIT(int n){
this.n = n;
m = new long[n+1];
a = new long[n+1];
}
RangeBIT(int n, long[] b) {
this.n = n;
m = new long[n+1];
a = new long[n+1];
for (int i = 1; i <= n; i++) {
range_add(i, i, b[i]);
}
}
void range_add(int l, int r, long v) { // NOTE: l and r cannot be 0, use one-indexed representation of l and r
add(m, l, v);
add(m, r+1, -v);
add(a, l, v*(l-1));
add(a, r+1, -v*r);
}
void add(long[] a, int idx, long v) {
for (int i = idx; i <= n; i += i&-i) {
a[i] += v;
}
}
long sum(long[] a, int idx) {
long ret = 0;
for (int i = idx; i > 0; i -= i&-i) {
ret += a[i];
}
return ret;
}
long prefix_sum(int idx) {
return sum(m, idx)*idx - sum(a, idx);
}
long range_sum(int l, int r) {
return prefix_sum(r) - prefix_sum(l-1);
}
}
static class MinSegmentTree {
int n;
int[] a, st;
MinSegmentTree(int n){
this.n = n;
a = new int[n];
st = new int[4*n+5];
}
MinSegmentTree(int n, int[] b){
this.n = n;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = b[i];
}
st = new int[4*n+5];
init(1, 0, n-1);
}
void init(int i, int l, int r){
if (l == r) {
st[i] = a[l];
return;
}
int mid = (l+r)/2;
init(2*i, l, mid);
init(2*i+1, mid + 1, r);
st[i] = comb(st[2*i], st[2*i+1]);
}
void update(int idx, int v) {
update(1, 0, n-1, idx, v);
}
void update(int i, int l, int r, int idx, int v){
if (l == r) {
st[i] = v; // NOTE: might want to change this to optimize for speed
return;
}
int mid = (l+r)/2;
if (idx <= mid) {
update(2*i, l, mid, idx, v);
}
else {
update(2*i+1, mid + 1, r, idx, v);
}
st[i] = comb(st[2*i], st[2*i+1]);
}
int query(int ql, int qr) {
return query(1, 0, n-1, ql, qr);
}
int query(int i, int l, int r, int ql, int qr){
if (qr < l || ql > r) return Integer.MAX_VALUE; // NOTE: might need to change this depending on the "comb" method
if (ql <= l && r <= qr) return st[i];
int mid = (l+r) / 2;
return comb(query(2*i, l, mid, ql, qr), query(2*i+1, mid + 1, r, ql, qr));
}
int comb(int a, int b) {
return Math.min(a, b);
}
}
static class MaxSegmentTree {
int n;
int[] a, st;
MaxSegmentTree(int n){
this.n = n;
a = new int[n];
st = new int[4*n+5];
}
MaxSegmentTree(int n, int[] b){
this.n = n;
a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = b[i];
}
st = new int[4*n+5];
init(1, 0, n-1);
}
void init(int i, int l, int r){
if (l == r) {
st[i] = a[l];
return;
}
int mid = (l+r)/2;
init(2*i, l, mid);
init(2*i+1, mid + 1, r);
st[i] = comb(st[2*i], st[2*i+1]);
}
void update(int idx, int v) {
update(1, 0, n-1, idx, v);
}
void update(int i, int l, int r, int idx, int v){
if (l == r) {
st[i] = v; // NOTE: might want to change this to optimize for speed
return;
}
int mid = (l+r)/2;
if (idx <= mid) {
update(2*i, l, mid, idx, v);
}
else {
update(2*i+1, mid + 1, r, idx, v);
}
st[i] = comb(st[2*i], st[2*i+1]);
}
int query(int ql, int qr) {
return query(1, 0, n-1, ql, qr);
}
int query(int i, int l, int r, int ql, int qr){
if (qr < l || ql > r) return Integer.MIN_VALUE; // NOTE: might need to change this depending on the "comb" method
if (ql <= l && r <= qr) return st[i];
int mid = (l+r) / 2;
return comb(query(2*i, l, mid, ql, qr), query(2*i+1, mid + 1, r, ql, qr));
}
int comb(int a, int b) {
return Math.max(a, b);
}
}
static INPUT in = new INPUT(System.in);
static PrintWriter out = new PrintWriter(System.out);
private static class INPUT {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public INPUT (InputStream stream) {
this.stream = stream;
}
public INPUT (String file) throws IOException {
this.stream = new FileInputStream (file);
}
public int cscan () throws IOException {
if (curChar >= numChars) {
curChar = 0;
numChars = stream.read (buf);
}
if (numChars == -1)
return numChars;
return buf[curChar++];
}
public int iscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
int res = 0;
do {
res = (res << 1) + (res << 3);
res += c - '0';
c = cscan ();
}
while (!space (c));
return res * sgn;
}
public String sscan () throws IOException {
int c = cscan ();
while (space (c))
c = cscan ();
StringBuilder res = new StringBuilder ();
do {
res.appendCodePoint (c);
c = cscan ();
}
while (!space (c));
return res.toString ();
}
public double dscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
double res = 0;
while (!space (c) && c != '.') {
if (c == 'e' || c == 'E')
return res * UTILITIES.fast_pow (10, iscan ());
res *= 10;
res += c - '0';
c = cscan ();
}
if (c == '.') {
c = cscan ();
double m = 1;
while (!space (c)) {
if (c == 'e' || c == 'E')
return res * UTILITIES.fast_pow (10, iscan ());
m /= 10;
res += (c - '0') * m;
c = cscan ();
}
}
return res * sgn;
}
public long lscan () throws IOException {
int c = cscan (), sgn = 1;
while (space (c))
c = cscan ();
if (c == '-') {
sgn = -1;
c = cscan ();
}
long res = 0;
do {
res = (res << 1) + (res << 3);
res += c - '0';
c = cscan ();
}
while (!space (c));
return res * sgn;
}
public boolean space (int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
public static class UTILITIES {
static final double EPS = 10e-6;
public static void sort(int[] a, boolean increasing) {
ArrayList<Integer> arr = new ArrayList<Integer>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static void sort(long[] a, boolean increasing) {
ArrayList<Long> arr = new ArrayList<Long>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static void sort(double[] a, boolean increasing) {
ArrayList<Double> arr = new ArrayList<Double>();
int n = a.length;
for (int i = 0; i < n; i++) {
arr.add(a[i]);
}
Collections.sort(arr);
for (int i = 0; i < n; i++) {
if (increasing) {
a[i] = arr.get(i);
}
else {
a[i] = arr.get(n-1-i);
}
}
}
public static int lower_bound (int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static int upper_bound (int[] arr, int x) {
int low = 0, high = arr.length, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > x)
high = mid;
else
low = mid + 1;
}
return low;
}
public static void updateMap(HashMap<Integer, Integer> map, int key, int v) {
if (!map.containsKey(key)) {
map.put(key, v);
}
else {
map.put(key, map.get(key) + v);
}
if (map.get(key) == 0) {
map.remove(key);
}
}
public static long gcd (long a, long b) {
return b == 0 ? a : gcd (b, a % b);
}
public static long lcm (long a, long b) {
return a * b / gcd (a, b);
}
public static long fast_pow_mod (long b, long x, int mod) {
if (x == 0) return 1;
if (x == 1) return b % mod;
if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;
return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
}
public static long fast_pow (long b, long x) {
if (x == 0) return 1;
if (x == 1) return b;
if (x % 2 == 0) return fast_pow (b * b, x / 2);
return b * fast_pow (b * b, x / 2);
}
public static long choose (long n, long k) {
if (k > n || k < 0) {
return 0;
}
k = Math.min (k, n - k);
long val = 1;
for (int i = 0; i < k; ++i)
val = val * (n - i) / (i + 1);
return val;
}
public static long permute (int n, int k) {
if (n < k) return 0;
long val = 1;
for (int i = 0; i < k; ++i)
val = (val * (n - i));
return val;
}
// start of permutation and lower/upper bound template
public static void nextPermutation(int[] nums) {
//find first decreasing digit
int mark = -1;
for (int i = nums.length - 1; i > 0; i--) {
if (nums[i] > nums[i - 1]) {
mark = i - 1;
break;
}
}
if (mark == -1) {
reverse(nums, 0, nums.length - 1);
return;
}
int idx = nums.length-1;
for (int i = nums.length-1; i >= mark+1; i--) {
if (nums[i] > nums[mark]) {
idx = i;
break;
}
}
swap(nums, mark, idx);
reverse(nums, mark + 1, nums.length - 1);
}
public static void swap(int[] nums, int i, int j) {
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}
public static void reverse(int[] nums, int i, int j) {
while (i < j) {
swap(nums, i, j);
i++;
j--;
}
}
static int lower_bound (int[] arr, int hi, int cmp) {
int low = 0, high = hi, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] >= cmp) high = mid;
else low = mid + 1;
}
return low;
}
static int upper_bound (int[] arr, int hi, int cmp) {
int low = 0, high = hi, mid = -1;
while (low < high) {
mid = (low + high) / 2;
if (arr[mid] > cmp) high = mid;
else low = mid + 1;
}
return low;
}
// end of permutation and lower/upper bound template
}
}
| ConDefects/ConDefects/Code/abc285_f/Java/41141205 |
condefects-java_data_1636 | import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
static final int NINF = Integer.MIN_VALUE / 2;
public void solve() {
FastScanner sc = new FastScanner(System.in);
int T = sc.nextInt();
StringBuilder ans = new StringBuilder();
for (int t = 0; t < T; t++) {
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
ArrayList<Integer> ret = solve0(N, A);
ans.append(ret.size());
ans.append(LF);
for (int a : ret) {
ans.append(a + 1);
ans.append(SPACE);
}
ans.deleteCharAt(ans.length() - 1);
ans.append(LF);
}
System.out.print(ans.toString());
}
ArrayList<Integer> solve0(int N, int[] A) {
Number[] num = new Number[N];
Number[] num_sorted = new Number[N];
for (int i = 0; i < N; i++) {
num[i] = new Number(A[i], i);
num_sorted[i] = num[i];
}
Arrays.sort(num_sorted);
for (int i = 0; i < N; i++) {
num_sorted[i].ord = i;
}
IntSegmentTree tree = new IntSegmentTree(N + 1);
int[] len = new int[N];
int max = 0;
boolean[] ok = new boolean[N];
for (int i = 0; i < N; i++) {
Number n = num[i];
int v = tree.query(0, n.ord);
v = Math.max(v, 0);
len[n.id] = v + 1;
max = Math.max(max, len[n.id]);
tree.update(n.ord, v + 1);
}
tree = new IntSegmentTree(N + 1);
for (int i = N - 1; i >= 0; i--) {
Number n = num[i];
if ( len[i] == max ) {
ok[i] = true;
} else {
int v = -tree.query(n.ord, N);
if ( len[i] + 1 >= v ) {
ok[i] = true;
}
}
if ( ok[i] ) {
tree.update(n.ord, -len[i]);
}
}
ArrayList<Integer> ret = new ArrayList<>();
for (int i = 0; i < N; i++) {
if ( ok[i] ) ret.add(i);
}
return ret;
}
class Number implements Comparable<Number> {
int A = 0;
int id = 0;
int ord = 0;
Number(int A, int id) {
this.A = A;
this.id = id;
}
@Override
public int compareTo(Number o) {
if ( A != o.A ) {
return A - o.A;
} else {
return id - o.id;
}
}
}
class IntSegmentTree {
// 最下段の個数
int N = 1;
int[] tree = null;
// 演算に影響しない値(加減なら0、最大なら-INF等)
// f(a, e) = f(e, a) = f(a)となるようなe
int IDENTITY = NINF;
// 演算
int f(int a, int b) {
return Math.max(a, b);
}
// 要素1〜maxまで
IntSegmentTree(int max) {
while ( N <= max ) {
N *= 2;
}
tree = new int[2 * N - 1];
Arrays.fill(tree, IDENTITY);
}
// 初期化
void init(int[] arr) {
System.arraycopy(arr, 0, tree, N - 1, arr.length);
// 演算実行
for ( int i = N - 2 ; i >= 0 ; i-- ) {
tree[i] = f(tree[2 * i + 1], tree[2 * i + 2]);
}
}
// i番目(0-indexed)の値
int get(int i) {
return tree[N - 1 + i];
}
// i番目の要素をaに更新
void update(int i, int a) {
int idx = N - 1 + i;
tree[idx] = a;
while ( idx > 0 ) {
idx = (idx - 1) / 2;
tree[idx] = f(tree[2 * idx + 1], tree[2 * idx + 2]);
}
}
// [i, j)の区間(i番目(含む)からj番目(含まない))までの間で演算実行
int query(int i, int j) {
return query(i, j, 0, 0, N);
}
int query(int i, int j, int cur, int l, int r) {
// 入っていない場合
if ( r <= i || j <= l ) {
return IDENTITY;
}
// 完全に入っている場合
if ( i <= l && r <= j ) {
return tree[cur];
}
int val0 = query(i, j, 2 * cur + 1, l, (l + r) / 2);
int val1 = query(i, j, 2 * cur + 2, (l + r) / 2, r);
return f(val0, val1);
}
}
static final char LF = '\n';
static final char SPACE = ' ';
static final String YES = "Yes";
static final String NO = "No";
void print(int[] array, char sep) {
print(array, sep, n -> n, 0, array.length);
}
void print(int[] array, char sep, IntFunction<Integer> conv) {
print(array, sep, conv, 0, array.length);
}
void print(int[] array, char sep, IntFunction<Integer> conv, int start, int end) {
StringBuilder ans = new StringBuilder();
for (int i = start; i < end; i++) {
ans.append(conv.apply(array[i]));
ans.append(sep);
}
ans.deleteCharAt(ans.length() - 1);
System.out.println(ans.toString());
}
void print(long[] array, char sep) {
print(array, sep, n -> n, 0, array.length);
}
void print(long[] array, char sep, LongFunction<Long> conv) {
print(array, sep, conv, 0, array.length);
}
void print(long[] array, char sep, LongFunction<Long> conv, int start, int end) {
StringBuilder ans = new StringBuilder();
for (int i = start; i < end; i++) {
ans.append(conv.apply(array[i]));
ans.append(sep);
}
ans.deleteCharAt(ans.length() - 1);
System.out.println(ans.toString());
}
void printYesNo(boolean yesno) {
System.out.println(yesno ? YES : NO);
}
void printDouble(double val, int digit) {
System.out.println(String.format("%." + digit + "f", val));
}
class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner( InputStream source ) { this.in = source; }
private boolean hasNextByte() {
if ( ptr < buflen ) return true;
else {
ptr = 0;
try { buflen = in.read(buf); } catch (IOException e) { e.printStackTrace(); }
if ( buflen <= 0 ) return false;
}
return true;
}
private int readByte() { if ( hasNextByte() ) return buf[ptr++]; else return -1; }
private boolean isPrintableChar( int c ) { return 33 <= c && c <= 126; }
private boolean isNumeric( int c ) { return '0' <= c && c <= '9'; }
private void skipToNextPrintableChar() { while ( hasNextByte() && !isPrintableChar(buf[ptr]) ) ptr++; }
public boolean hasNext() { skipToNextPrintableChar(); return hasNextByte(); }
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
StringBuilder ret = new StringBuilder();
int b = readByte();
while ( isPrintableChar(b) ) { ret.appendCodePoint(b); b = readByte(); }
return ret.toString();
}
public long nextLong() {
if ( !hasNext() ) throw new NoSuchElementException();
long ret = 0;
int b = readByte();
boolean negative = false;
if ( b == '-' ) { negative = true; if ( hasNextByte() ) b = readByte(); }
if ( !isNumeric(b) ) throw new NumberFormatException();
while ( true ) {
if ( isNumeric(b) ) ret = ret * 10 + b - '0';
else if ( b == -1 || !isPrintableChar(b) ) return negative ? -ret : ret;
else throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() { return (int)nextLong(); }
public double nextDouble() { return Double.parseDouble(next()); }
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
static final int NINF = Integer.MIN_VALUE / 2;
public void solve() {
FastScanner sc = new FastScanner(System.in);
int T = sc.nextInt();
StringBuilder ans = new StringBuilder();
for (int t = 0; t < T; t++) {
int N = sc.nextInt();
int[] A = new int[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextInt();
}
ArrayList<Integer> ret = solve0(N, A);
ans.append(ret.size());
ans.append(LF);
for (int a : ret) {
ans.append(a + 1);
ans.append(SPACE);
}
ans.deleteCharAt(ans.length() - 1);
ans.append(LF);
}
System.out.print(ans.toString());
}
ArrayList<Integer> solve0(int N, int[] A) {
Number[] num = new Number[N];
Number[] num_sorted = new Number[N];
for (int i = 0; i < N; i++) {
num[i] = new Number(A[i], i);
num_sorted[i] = num[i];
}
Arrays.sort(num_sorted);
for (int i = 0; i < N; i++) {
num_sorted[i].ord = i;
}
IntSegmentTree tree = new IntSegmentTree(N + 1);
int[] len = new int[N];
int max = 0;
boolean[] ok = new boolean[N];
for (int i = 0; i < N; i++) {
Number n = num[i];
int v = tree.query(0, n.ord);
v = Math.max(v, 0);
len[n.id] = v + 1;
max = Math.max(max, len[n.id]);
tree.update(n.ord, v + 1);
}
tree = new IntSegmentTree(N + 1);
for (int i = N - 1; i >= 0; i--) {
Number n = num[i];
if ( len[i] == max ) {
ok[i] = true;
} else {
int v = -tree.query(n.ord, N);
if ( len[i] + 1 >= v ) {
ok[i] = true;
}
}
if ( ok[i] ) {
tree.update(n.ord, -len[i]);
}
}
ArrayList<Integer> ret = new ArrayList<>();
for (int i = 0; i < N; i++) {
if ( ok[i] ) ret.add(i);
}
return ret;
}
class Number implements Comparable<Number> {
int A = 0;
int id = 0;
int ord = 0;
Number(int A, int id) {
this.A = A;
this.id = id;
}
@Override
public int compareTo(Number o) {
if ( A != o.A ) {
return A - o.A;
} else {
return -id + o.id;
}
}
}
class IntSegmentTree {
// 最下段の個数
int N = 1;
int[] tree = null;
// 演算に影響しない値(加減なら0、最大なら-INF等)
// f(a, e) = f(e, a) = f(a)となるようなe
int IDENTITY = NINF;
// 演算
int f(int a, int b) {
return Math.max(a, b);
}
// 要素1〜maxまで
IntSegmentTree(int max) {
while ( N <= max ) {
N *= 2;
}
tree = new int[2 * N - 1];
Arrays.fill(tree, IDENTITY);
}
// 初期化
void init(int[] arr) {
System.arraycopy(arr, 0, tree, N - 1, arr.length);
// 演算実行
for ( int i = N - 2 ; i >= 0 ; i-- ) {
tree[i] = f(tree[2 * i + 1], tree[2 * i + 2]);
}
}
// i番目(0-indexed)の値
int get(int i) {
return tree[N - 1 + i];
}
// i番目の要素をaに更新
void update(int i, int a) {
int idx = N - 1 + i;
tree[idx] = a;
while ( idx > 0 ) {
idx = (idx - 1) / 2;
tree[idx] = f(tree[2 * idx + 1], tree[2 * idx + 2]);
}
}
// [i, j)の区間(i番目(含む)からj番目(含まない))までの間で演算実行
int query(int i, int j) {
return query(i, j, 0, 0, N);
}
int query(int i, int j, int cur, int l, int r) {
// 入っていない場合
if ( r <= i || j <= l ) {
return IDENTITY;
}
// 完全に入っている場合
if ( i <= l && r <= j ) {
return tree[cur];
}
int val0 = query(i, j, 2 * cur + 1, l, (l + r) / 2);
int val1 = query(i, j, 2 * cur + 2, (l + r) / 2, r);
return f(val0, val1);
}
}
static final char LF = '\n';
static final char SPACE = ' ';
static final String YES = "Yes";
static final String NO = "No";
void print(int[] array, char sep) {
print(array, sep, n -> n, 0, array.length);
}
void print(int[] array, char sep, IntFunction<Integer> conv) {
print(array, sep, conv, 0, array.length);
}
void print(int[] array, char sep, IntFunction<Integer> conv, int start, int end) {
StringBuilder ans = new StringBuilder();
for (int i = start; i < end; i++) {
ans.append(conv.apply(array[i]));
ans.append(sep);
}
ans.deleteCharAt(ans.length() - 1);
System.out.println(ans.toString());
}
void print(long[] array, char sep) {
print(array, sep, n -> n, 0, array.length);
}
void print(long[] array, char sep, LongFunction<Long> conv) {
print(array, sep, conv, 0, array.length);
}
void print(long[] array, char sep, LongFunction<Long> conv, int start, int end) {
StringBuilder ans = new StringBuilder();
for (int i = start; i < end; i++) {
ans.append(conv.apply(array[i]));
ans.append(sep);
}
ans.deleteCharAt(ans.length() - 1);
System.out.println(ans.toString());
}
void printYesNo(boolean yesno) {
System.out.println(yesno ? YES : NO);
}
void printDouble(double val, int digit) {
System.out.println(String.format("%." + digit + "f", val));
}
class FastScanner {
private final InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner( InputStream source ) { this.in = source; }
private boolean hasNextByte() {
if ( ptr < buflen ) return true;
else {
ptr = 0;
try { buflen = in.read(buf); } catch (IOException e) { e.printStackTrace(); }
if ( buflen <= 0 ) return false;
}
return true;
}
private int readByte() { if ( hasNextByte() ) return buf[ptr++]; else return -1; }
private boolean isPrintableChar( int c ) { return 33 <= c && c <= 126; }
private boolean isNumeric( int c ) { return '0' <= c && c <= '9'; }
private void skipToNextPrintableChar() { while ( hasNextByte() && !isPrintableChar(buf[ptr]) ) ptr++; }
public boolean hasNext() { skipToNextPrintableChar(); return hasNextByte(); }
public String next() {
if ( !hasNext() ) throw new NoSuchElementException();
StringBuilder ret = new StringBuilder();
int b = readByte();
while ( isPrintableChar(b) ) { ret.appendCodePoint(b); b = readByte(); }
return ret.toString();
}
public long nextLong() {
if ( !hasNext() ) throw new NoSuchElementException();
long ret = 0;
int b = readByte();
boolean negative = false;
if ( b == '-' ) { negative = true; if ( hasNextByte() ) b = readByte(); }
if ( !isNumeric(b) ) throw new NumberFormatException();
while ( true ) {
if ( isNumeric(b) ) ret = ret * 10 + b - '0';
else if ( b == -1 || !isPrintableChar(b) ) return negative ? -ret : ret;
else throw new NumberFormatException();
b = readByte();
}
}
public int nextInt() { return (int)nextLong(); }
public double nextDouble() { return Double.parseDouble(next()); }
}
}
| ConDefects/ConDefects/Code/abc354_f/Java/53625665 |
condefects-java_data_1637 | import java.util.*;
import java.io.*;
public class Main {
static ContestScanner sc = new ContestScanner(System.in);
static ContestPrinter pw = new ContestPrinter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
solve();
pw.flush();
}
public static void solve() {
int N = sc.nextInt();
int M = sc.nextInt();
int K = sc.nextInt();
int[] C = sc.nextIntArray(N);
HashMap<Integer,Integer> total = new HashMap<>();
for(int i = 0; i < N; i++){
total.put(C[i],total.getOrDefault(C[i],0)+1);
}
if(K == 1){
for(int i = 0; i < N; i++){
pw.println(N-M);
}
}else{
HashMap<Integer,Integer> firstM = new HashMap<>();
HashMap<Integer,Integer> conBall = new HashMap<>();
HashMap<Integer,Integer> eatBall = new HashMap<>();
int nowM = 0;
int nextC = 0;
int size = 0;
long ans = 0;
while(nowM < M && size < N){
if(!firstM.containsKey(C[nextC]) || firstM.get(C[nextC]) % K == 0){
nowM++;
conBall.put(C[nextC],conBall.getOrDefault(C[nextC],0)+1);
ans -= (conBall.get(C[nextC])-1)*K;
ans += Math.min(total.get(C[nextC]),conBall.get(C[nextC])*K);
}
firstM.put(C[nextC],firstM.getOrDefault(C[nextC],0)+1);
nextC++;
nextC %= N;
size++;
}
pw.println(ans);
for(int i = 0; i < N-1; i++){
//取り消し
firstM.put(C[i],firstM.get(C[i])-1);
size--;
if(firstM.get(C[i]) % K == 0){
nowM--;
ans -= Math.min(total.get(C[i]),conBall.get(C[i])*K);
ans += (conBall.get(C[i])-1)*K;
conBall.put(C[i],conBall.getOrDefault(C[i],0)-1);
}
while(nowM < M && size < N){
if(!firstM.containsKey(C[nextC]) || firstM.get(C[nextC]) % K == 0){
nowM++;
conBall.put(C[nextC],conBall.getOrDefault(C[nextC],0)+1);
ans -= (conBall.get(C[nextC])-1)*K;
ans += Math.min(total.get(C[nextC]),conBall.get(C[nextC])*K);
}
firstM.put(C[nextC],firstM.getOrDefault(C[nextC],0)+1);
nextC++;
nextC %= N;
size++;
}
pw.println(ans);
}
}
}
}
/**
* refercence : https://github.com/NASU41/AtCoderLibraryForJava/blob/master/ContestIO/ContestScanner.java
*/
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(java.io.File file) throws java.io.FileNotFoundException {
this(new java.io.BufferedInputStream(new java.io.FileInputStream(file)));
}
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[] 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;
}
}
class ContestPrinter extends PrintWriter {
public ContestPrinter(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 printlnArray(String[] array) {
for (String i : array)
super.println(i);
}
public void printSpace(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++) {
super.print(o[i]);
super.print(" ");
}
super.println(o[n]);
}
public void println(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.println(o[n]);
}
public void printYN(boolean o) {
super.println(o ? "Yes" : "No");
}
public void print(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.print(o[n]);
}
public void printArray(Object[] array) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(" ");
}
super.println(array[n]);
}
public void printlnArray(Object[] array) {
for (Object i : array)
super.println(i);
}
public void printArray(int[] array, String separator) {
int n = array.length - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(int[] array) {
for (int i : array)
super.println(i);
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n]));
}
public void printlnArray(int[] array, java.util.function.IntUnaryOperator map) {
for (int i : array)
super.println(map.applyAsInt(i));
}
public void printlnArray(long[] array, java.util.function.LongUnaryOperator map) {
for (long i : array)
super.println(map.applyAsLong(i));
}
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 - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printlnArray(long[] array) {
for (long i : array)
super.println(i);
}
public void printArray(double[] array) {
printArray(array, " ");
}
public void printArray(double[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(double[] array) {
for (double i : array)
super.println(i);
}
public void printArray(boolean[] array, String a, String b) {
int n = array.length - 1;
for (int i = 0; i < n; i++)
super.print((array[i] ? a : b) + " ");
super.println(array[n] ? a : b);
}
public void printArray(boolean[] array) {
this.printArray(array, "Y", "N");
}
public void printArray(char[] array) {
for (char c : array)
this.print(c);
this.println();
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(ArrayList<?> array) {
this.printArray(array, " ");
}
public void printArray(ArrayList<?> array, String separator) {
int n = array.size() - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array.get(i).toString());
super.print(separator);
}
super.println(array.get(n).toString());
}
public void printlnArray(ArrayList<?> array) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(array.get(i).toString());
}
public void printlnArray(ArrayList<Integer> array, java.util.function.IntUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsInt(array.get(i)));
}
public void printlnArray(ArrayList<Long> array, java.util.function.LongUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsLong(array.get(i)));
}
public void printArray(int[][] array) {
for (int[] a : array)
this.printArray(a);
}
public void printArray(int[][] array, java.util.function.IntUnaryOperator map) {
for (int[] a : array)
this.printArray(a, map);
}
public void printArray(long[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] + " ");
super.println(array[i][m]);
}
}
public void printArray(long[][] array, java.util.function.LongUnaryOperator map) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
super.print(map.applyAsLong(array[i][j]));
super.print(" ");
}
super.println(map.applyAsLong(array[i][m]));
}
}
public void printArray(boolean[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] ? "○ " : "× ");
super.println(array[i][m] ? "○" : "×");
}
}
public void printArray(char[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j]);
super.println();
}
}
}
import java.util.*;
import java.io.*;
public class Main {
static ContestScanner sc = new ContestScanner(System.in);
static ContestPrinter pw = new ContestPrinter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
solve();
pw.flush();
}
public static void solve() {
int N = sc.nextInt();
int M = sc.nextInt();
int K = sc.nextInt();
int[] C = sc.nextIntArray(N);
HashMap<Integer,Integer> total = new HashMap<>();
for(int i = 0; i < N; i++){
total.put(C[i],total.getOrDefault(C[i],0)+1);
}
if(K == 1){
for(int i = 0; i < N; i++){
pw.println(M);
}
}else{
HashMap<Integer,Integer> firstM = new HashMap<>();
HashMap<Integer,Integer> conBall = new HashMap<>();
HashMap<Integer,Integer> eatBall = new HashMap<>();
int nowM = 0;
int nextC = 0;
int size = 0;
long ans = 0;
while(nowM < M && size < N){
if(!firstM.containsKey(C[nextC]) || firstM.get(C[nextC]) % K == 0){
nowM++;
conBall.put(C[nextC],conBall.getOrDefault(C[nextC],0)+1);
ans -= (conBall.get(C[nextC])-1)*K;
ans += Math.min(total.get(C[nextC]),conBall.get(C[nextC])*K);
}
firstM.put(C[nextC],firstM.getOrDefault(C[nextC],0)+1);
nextC++;
nextC %= N;
size++;
}
pw.println(ans);
for(int i = 0; i < N-1; i++){
//取り消し
firstM.put(C[i],firstM.get(C[i])-1);
size--;
if(firstM.get(C[i]) % K == 0){
nowM--;
ans -= Math.min(total.get(C[i]),conBall.get(C[i])*K);
ans += (conBall.get(C[i])-1)*K;
conBall.put(C[i],conBall.getOrDefault(C[i],0)-1);
}
while(nowM < M && size < N){
if(!firstM.containsKey(C[nextC]) || firstM.get(C[nextC]) % K == 0){
nowM++;
conBall.put(C[nextC],conBall.getOrDefault(C[nextC],0)+1);
ans -= (conBall.get(C[nextC])-1)*K;
ans += Math.min(total.get(C[nextC]),conBall.get(C[nextC])*K);
}
firstM.put(C[nextC],firstM.getOrDefault(C[nextC],0)+1);
nextC++;
nextC %= N;
size++;
}
pw.println(ans);
}
}
}
}
/**
* refercence : https://github.com/NASU41/AtCoderLibraryForJava/blob/master/ContestIO/ContestScanner.java
*/
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(java.io.File file) throws java.io.FileNotFoundException {
this(new java.io.BufferedInputStream(new java.io.FileInputStream(file)));
}
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[] 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;
}
}
class ContestPrinter extends PrintWriter {
public ContestPrinter(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 printlnArray(String[] array) {
for (String i : array)
super.println(i);
}
public void printSpace(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++) {
super.print(o[i]);
super.print(" ");
}
super.println(o[n]);
}
public void println(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.println(o[n]);
}
public void printYN(boolean o) {
super.println(o ? "Yes" : "No");
}
public void print(Object... o) {
int n = o.length - 1;
for (int i = 0; i < n; i++)
super.print(o[i]);
super.print(o[n]);
}
public void printArray(Object[] array) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(" ");
}
super.println(array[n]);
}
public void printlnArray(Object[] array) {
for (Object i : array)
super.println(i);
}
public void printArray(int[] array, String separator) {
int n = array.length - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array) {
this.printArray(array, " ");
}
public void printArray(Integer[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(int[] array) {
for (int i : array)
super.println(i);
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n]));
}
public void printlnArray(int[] array, java.util.function.IntUnaryOperator map) {
for (int i : array)
super.println(map.applyAsInt(i));
}
public void printlnArray(long[] array, java.util.function.LongUnaryOperator map) {
for (long i : array)
super.println(map.applyAsLong(i));
}
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 - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printlnArray(long[] array) {
for (long i : array)
super.println(i);
}
public void printArray(double[] array) {
printArray(array, " ");
}
public void printArray(double[] array, String separator) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n]);
}
public void printlnArray(double[] array) {
for (double i : array)
super.println(i);
}
public void printArray(boolean[] array, String a, String b) {
int n = array.length - 1;
for (int i = 0; i < n; i++)
super.print((array[i] ? a : b) + " ");
super.println(array[n] ? a : b);
}
public void printArray(boolean[] array) {
this.printArray(array, "Y", "N");
}
public void printArray(char[] array) {
for (char c : array)
this.print(c);
this.println();
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length - 1;
for (int i = 0; i < n; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(ArrayList<?> array) {
this.printArray(array, " ");
}
public void printArray(ArrayList<?> array, String separator) {
int n = array.size() - 1;
if (n == -1)
return;
for (int i = 0; i < n; i++) {
super.print(array.get(i).toString());
super.print(separator);
}
super.println(array.get(n).toString());
}
public void printlnArray(ArrayList<?> array) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(array.get(i).toString());
}
public void printlnArray(ArrayList<Integer> array, java.util.function.IntUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsInt(array.get(i)));
}
public void printlnArray(ArrayList<Long> array, java.util.function.LongUnaryOperator map) {
int n = array.size();
for (int i = 0; i < n; i++)
super.println(map.applyAsLong(array.get(i)));
}
public void printArray(int[][] array) {
for (int[] a : array)
this.printArray(a);
}
public void printArray(int[][] array, java.util.function.IntUnaryOperator map) {
for (int[] a : array)
this.printArray(a, map);
}
public void printArray(long[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] + " ");
super.println(array[i][m]);
}
}
public void printArray(long[][] array, java.util.function.LongUnaryOperator map) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
super.print(map.applyAsLong(array[i][j]));
super.print(" ");
}
super.println(map.applyAsLong(array[i][m]));
}
}
public void printArray(boolean[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length - 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j] ? "○ " : "× ");
super.println(array[i][m] ? "○" : "×");
}
}
public void printArray(char[][] array) {
int n = array.length;
if (n == 0)
return;
int m = array[0].length;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
super.print(array[i][j]);
super.println();
}
}
}
| ConDefects/ConDefects/Code/abc337_f/Java/49497730 |
condefects-java_data_1638 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
// int n = 8;
// int k = 3;
int[] a = new int[k];
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextInt();
}
// a[0] = 2;
// a[1] = 6;
// a[2] = 8;
int[][] xy = new int[n][2];
for (int j = 0; j < n; j++) {
for (int i = 0; i < 2; i++) {
xy[j][i] = sc.nextInt();
}
}
sc.close();
// xy[0][0] = -17683;
// xy[0][1] = 17993;
// xy[1][0] = 93038;
// xy[1][1] = 47074;
// xy[2][0] = 58079;
// xy[2][1] = -57520;
// xy[3][0] = -41515;
// xy[3][1] = -89802;
// xy[4][0] = -72739;
// xy[4][1] = 68805;
// xy[5][0] = 24324;
// xy[5][1] = -73073;
// xy[6][0] = 71049;
// xy[6][1] = 72103;
// xy[7][0] = 47863;
// xy[7][1] = 19268;
double[] total = new double[n];
for (int i = 0; i < total.length; i++) {
total[i] = 1000000;
}
for (int i = 0; i < n; i++) {
for (int l: a) {
if ((i + 1) == l) {
for (int j = 0; j < n; j++) {
boolean bo = false;
for (int m : a) {
if (j == (m -1)) {
bo = true;
}
}
if (bo != true) {
double xTotal = xy[i][0] - xy[j][0];
double yTotal = xy[i][1] - xy[j][1];
double totalSub = 0;
totalSub = Math.sqrt((xTotal * xTotal) + (yTotal * yTotal));
System.out.println(i + ":" + j + ":" + totalSub);
if (total[j] > totalSub) {
total[j] = totalSub;
}
}
}
}
}
}
double ans = 0;
for (double i :total) {
System.out.println(i);
if (i < 1000000) {
if (ans < i) {
ans = i;
}
}
}
System.out.println(ans);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
// int n = 8;
// int k = 3;
int[] a = new int[k];
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextInt();
}
// a[0] = 2;
// a[1] = 6;
// a[2] = 8;
int[][] xy = new int[n][2];
for (int j = 0; j < n; j++) {
for (int i = 0; i < 2; i++) {
xy[j][i] = sc.nextInt();
}
}
sc.close();
// xy[0][0] = -17683;
// xy[0][1] = 17993;
// xy[1][0] = 93038;
// xy[1][1] = 47074;
// xy[2][0] = 58079;
// xy[2][1] = -57520;
// xy[3][0] = -41515;
// xy[3][1] = -89802;
// xy[4][0] = -72739;
// xy[4][1] = 68805;
// xy[5][0] = 24324;
// xy[5][1] = -73073;
// xy[6][0] = 71049;
// xy[6][1] = 72103;
// xy[7][0] = 47863;
// xy[7][1] = 19268;
double[] total = new double[n];
for (int i = 0; i < total.length; i++) {
total[i] = 1000000;
}
for (int i = 0; i < n; i++) {
for (int l: a) {
if ((i + 1) == l) {
for (int j = 0; j < n; j++) {
boolean bo = false;
for (int m : a) {
if (j == (m -1)) {
bo = true;
}
}
if (bo != true) {
double xTotal = xy[i][0] - xy[j][0];
double yTotal = xy[i][1] - xy[j][1];
double totalSub = 0;
totalSub = Math.sqrt((xTotal * xTotal) + (yTotal * yTotal));
if (total[j] > totalSub) {
total[j] = totalSub;
}
}
}
}
}
}
double ans = 0;
for (double i :total) {
if (i < 1000000) {
if (ans < i) {
ans = i;
}
}
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc255_b/Java/34133094 |
condefects-java_data_1639 | import java.util.*;
import static java.lang.System.out;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
int A[] = new int[K];
int X[] = new int[N];
int Y[] = new int[N];
for(int i = 0;i < K;i++)A[i] = sc.nextInt();
for(int i = 0;i < N;i++){
X[i] = sc.nextInt();
Y[i] = sc.nextInt();
}
double ans = 0;
for(int i = 0;i < N;i++){
double min = Double.MAX_VALUE;
for(int j = 0;j < K;j++){
double dist = Math.sqrt((1.0 * X[i] - X[A[j] - 1]) * (1.0 * X[i] - X[A[j] - 1]) + (1.0 * Y[i] - Y[A[j] - 1]) * (1.0 * Y[i] - Y[A[j] - 1]));
if(dist != 0.0)min = Math.min(min, dist);
}
if(min != Double.MAX_VALUE)ans = Math.max(min, ans);
}
out.println(ans);
}
}
import java.util.*;
import static java.lang.System.out;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
int A[] = new int[K];
int X[] = new int[N];
int Y[] = new int[N];
for(int i = 0;i < K;i++)A[i] = sc.nextInt();
for(int i = 0;i < N;i++){
X[i] = sc.nextInt();
Y[i] = sc.nextInt();
}
double ans = 0;
for(int i = 0;i < N;i++){
double min = Double.MAX_VALUE;
for(int j = 0;j < K;j++){
double dist = Math.sqrt((1.0 * X[i] - X[A[j] - 1]) * (1.0 * X[i] - X[A[j] - 1]) + (1.0 * Y[i] - Y[A[j] - 1]) * (1.0 * Y[i] - Y[A[j] - 1]));
min = Math.min(min, dist);
}
if(min != Double.MAX_VALUE)ans = Math.max(min, ans);
}
out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc255_b/Java/35061036 |
condefects-java_data_1640 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
boolean isWeakBeats = true;
for (int i = 1; i < s.length() - 1; i+=2) {
if (s.charAt(i) == '1') {
isWeakBeats = false;
break;
}
}
System.out.println(isWeakBeats ? "Yes" : "No");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
boolean isWeakBeats = true;
for (int i = 1; i < s.length(); i+=2) {
if (s.charAt(i) == '1') {
isWeakBeats = false;
break;
}
}
System.out.println(isWeakBeats ? "Yes" : "No");
}
} | ConDefects/ConDefects/Code/abc323_a/Java/50695431 |
condefects-java_data_1641 | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String st = sc.nextLine();
long s = Long.parseLong(st); //16桁：Long
//intは32bit 大体10桁(2^32が42億くらい
//負の数で半分持ってかれて大体-21億~21億)
boolean isZ = true;
for(int i = 0; i<16; i++){ //0番目~15番目
if(i%2 == 1){
if(s%10 != 0){
isZ = false;
System.out.println("No");
return;
}
}
s = s/10;
}
if(isZ){
System.out.println("Yes");
}
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String st = sc.nextLine();
long s = Long.parseLong(st); //16桁：Long
//intは32bit 大体10桁(2^32が42億くらい
//負の数で半分持ってかれて大体-21億~21億)
boolean isZ = true;
for(int i = 1; i<17; i++){ //0番目~15番目
if(i%2 == 1){
if(s%10 != 0){
isZ = false;
System.out.println("No");
return;
}
}
s = s/10;
}
if(isZ){
System.out.println("Yes");
}
}
}
| ConDefects/ConDefects/Code/abc323_a/Java/54941230 |
condefects-java_data_1642 | import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
String n = sc.next();
int count = 0;
for(int i = 1; i < n.length();i = i + 2){
if(n.substring(i,i+1).equals("0")){
count ++;
}else{
break;
}
}
if(count==16){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner sc = new Scanner(System.in);
String n = sc.next();
int count = 0;
for(int i = 1; i < n.length();i = i + 2){
if(n.substring(i,i+1).equals("0")){
count ++;
}else{
break;
}
}
if(count==8){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
} | ConDefects/ConDefects/Code/abc323_a/Java/54779869 |
condefects-java_data_1643 | import java.util.Scanner;
public class Main {
public static void main(String [] args) {
try(Scanner scan = new Scanner(System.in)){
String S = scan.next();
String result = "Yes";
for(int i = 1; i < 16; i++){
if(S.charAt(i) != '0'){
result = "No";
}
}
System.out.println(result);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String [] args) {
try(Scanner scan = new Scanner(System.in)){
String S = scan.next();
String result = "Yes";
for(int i = 1; i <= 16; i+=2){
if(S.charAt(i) != '0'){
result = "No";
}
}
System.out.println(result);
}
}
} | ConDefects/ConDefects/Code/abc323_a/Java/54767553 |
condefects-java_data_1644 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int i = 1;
while(s.charAt(i) == '0' && i != 15) i += 2;
System.out.print(i == 15 ? "Yes" : "No");
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int i = 1;
while(s.charAt(i) == '0' && i != 15) i += 2;
System.out.print(s.charAt(i) == '0' && i == 15 ? "Yes" : "No");
}
} | ConDefects/ConDefects/Code/abc323_a/Java/54917059 |
condefects-java_data_1645 |
import java.io.*;
import java.util.*;
public class Main {
static IOHandler sc = new IOHandler();
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
new Thread(null, new Solution(), "solution", 1 << 26 ).start();
}
private static class Solution implements Runnable {
public void run() {
// TODO Auto-generated method stub
int testCases = 1;
for (int i = 1; i <= testCases; ++i) {
solve(i);
}
out.flush();
}
private void solve(int t) {
// Read question and Test cases thoroughly
// Check for overflow
// Think before solving
// Search for concepts
// expected alg like seg tree, trie, binSearch, sqrt decom ...
int n = sc.nextInt();
int [] arr = sc.readArray2(n);
int q = sc.nextInt();
int [][] ops = new int [q + 1][];
int target = 1;
while (target < n) {
target = target << 1;
}
GroupTemplate gT = new GroupTemplate(n);
int type;
int res;
int [] test;
int l, r, lg, rg, x;
for (int i = 1; i <= n; ++i) {
gT.update(i, i, new int [] {arr[i], 0}, 1);
}
StringBuilder sb = new StringBuilder();
int idx;
for (int i = 1; i <= q; ++i) {
type = sc.nextInt();
if (type == 1) {
l = sc.nextInt();
r = sc.nextInt();
x = sc.nextInt();
ops[i] = new int [] {x, i, l, r};
gT.update(l, r, ops[i], 1);
}else if (type == 2) {
idx = sc.nextInt();
test = ops[idx];
l = test[2];
r = test[3];
gT.update(l, r, ops[idx], 0);
}else {
idx = sc.nextInt();
sb.append(Math.max(arr[idx], gT.retrieve(idx)));
sb.append("\n");
}
}
out.print(sb);
}
}
private static class IOHandler {
BufferedReader br;
StringTokenizer st;
public IOHandler() {
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());
}
int [] readArray(int n) {
int [] res = new int [n];
for (int i = 0; i < n; ++i)
res[i] = nextInt();
return res;
}
int [] readArray2(int n) {
int [] res = new int [n + 1];
for (int i = 1; i <= n; ++i)
res[i] = nextInt();
return res;
}
int [][] readGraph(int n, int m, int c) {
int [][] graph = new int [n + 1][];
int [] count = new int [n + 1];
int [][] arr = new int [m][1 + c];
int a, b;
for (int i = 0; i < m; ++i) {
a = sc.nextInt();
b = sc.nextInt();
arr[i][0] = a;
arr[i][1] = b;
++count[a];
++count[b];
for (int j = 2; j <= c; ++j) {
arr[i][j] = sc.nextInt();
}
}
for (int i = 0; i <= n; ++i) {
graph[i] = new int [count[i] * c];
count[i] = 0;
}
int swap;
for (int [] tArr : arr) {
for (int j = 1; j < tArr.length; ++j) {
graph[tArr[0]][count[tArr[0]]++] = tArr[j];
}
swap = tArr[0];
tArr[0] = tArr[1];
tArr[1] = swap;
for (int j = 1; j < tArr.length; ++j) {
graph[tArr[0]][count[tArr[0]]++] = tArr[j];
}
}
return graph;
}
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;
}
}
}
class GroupTemplate {
List<TreeSet<int []> []> values;
GroupTemplate(int n){
int size = 1;
while (size < n)
size = size << 1;
values = new ArrayList<>();
while (size > 1){
values.add(new TreeSet[size]);
size += 1;
size /= 2;
}
values.add(new TreeSet [1]);
}
void update(TreeSet<int []> [] setArr, int idx, int [] val, int type) {
if (type == 1) {
if (setArr[idx] == null)
setArr[idx] = new TreeSet<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]);
setArr[idx].add(val);
} else {
setArr[idx].remove(val);
}
}
void update(int l, int h, int [] val, int type){
l = Math.max(l, 0);
for (TreeSet<int []> [] arr : values){
//System.out.println(Arrays.toString(arr));
//System.out.println(l + " " + h + " " + arr[l] + " " + arr[h]);
if (l % 2 == 1) {
update(arr, l, val, type);
++l;
}
if (h % 2 == 0) {
update(arr, h, val, type);
--h;
}
if (h == l) break;
l /= 2;
h /= 2;
if (h < l) break;
}
}
int retrieve(int idx){
int result = 0;
for (TreeSet<int []> [] setArr : values){
// arr[idx] = next;
if (setArr[idx] != null && !setArr[idx].isEmpty()) {
int [] first = setArr[idx].first();
result = Math.max(result, first[0]);
}
idx /= 2;
}
return result;
}
}
import java.io.*;
import java.util.*;
public class Main {
static IOHandler sc = new IOHandler();
static PrintWriter out = new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
new Thread(null, new Solution(), "solution", 1 << 26 ).start();
}
private static class Solution implements Runnable {
public void run() {
// TODO Auto-generated method stub
int testCases = 1;
for (int i = 1; i <= testCases; ++i) {
solve(i);
}
out.flush();
}
private void solve(int t) {
// Read question and Test cases thoroughly
// Check for overflow
// Think before solving
// Search for concepts
// expected alg like seg tree, trie, binSearch, sqrt decom ...
int n = sc.nextInt();
int [] arr = sc.readArray2(n);
int q = sc.nextInt();
int [][] ops = new int [q + 1][];
int target = 1;
while (target < n) {
target = target << 1;
}
GroupTemplate gT = new GroupTemplate(n + 1);
int type;
int res;
int [] test;
int l, r, lg, rg, x;
for (int i = 1; i <= n; ++i) {
gT.update(i, i, new int [] {arr[i], 0}, 1);
}
StringBuilder sb = new StringBuilder();
int idx;
for (int i = 1; i <= q; ++i) {
type = sc.nextInt();
if (type == 1) {
l = sc.nextInt();
r = sc.nextInt();
x = sc.nextInt();
ops[i] = new int [] {x, i, l, r};
gT.update(l, r, ops[i], 1);
}else if (type == 2) {
idx = sc.nextInt();
test = ops[idx];
l = test[2];
r = test[3];
gT.update(l, r, ops[idx], 0);
}else {
idx = sc.nextInt();
sb.append(Math.max(arr[idx], gT.retrieve(idx)));
sb.append("\n");
}
}
out.print(sb);
}
}
private static class IOHandler {
BufferedReader br;
StringTokenizer st;
public IOHandler() {
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());
}
int [] readArray(int n) {
int [] res = new int [n];
for (int i = 0; i < n; ++i)
res[i] = nextInt();
return res;
}
int [] readArray2(int n) {
int [] res = new int [n + 1];
for (int i = 1; i <= n; ++i)
res[i] = nextInt();
return res;
}
int [][] readGraph(int n, int m, int c) {
int [][] graph = new int [n + 1][];
int [] count = new int [n + 1];
int [][] arr = new int [m][1 + c];
int a, b;
for (int i = 0; i < m; ++i) {
a = sc.nextInt();
b = sc.nextInt();
arr[i][0] = a;
arr[i][1] = b;
++count[a];
++count[b];
for (int j = 2; j <= c; ++j) {
arr[i][j] = sc.nextInt();
}
}
for (int i = 0; i <= n; ++i) {
graph[i] = new int [count[i] * c];
count[i] = 0;
}
int swap;
for (int [] tArr : arr) {
for (int j = 1; j < tArr.length; ++j) {
graph[tArr[0]][count[tArr[0]]++] = tArr[j];
}
swap = tArr[0];
tArr[0] = tArr[1];
tArr[1] = swap;
for (int j = 1; j < tArr.length; ++j) {
graph[tArr[0]][count[tArr[0]]++] = tArr[j];
}
}
return graph;
}
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;
}
}
}
class GroupTemplate {
List<TreeSet<int []> []> values;
GroupTemplate(int n){
int size = 1;
while (size < n)
size = size << 1;
values = new ArrayList<>();
while (size > 1){
values.add(new TreeSet[size]);
size += 1;
size /= 2;
}
values.add(new TreeSet [1]);
}
void update(TreeSet<int []> [] setArr, int idx, int [] val, int type) {
if (type == 1) {
if (setArr[idx] == null)
setArr[idx] = new TreeSet<>((a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]);
setArr[idx].add(val);
} else {
setArr[idx].remove(val);
}
}
void update(int l, int h, int [] val, int type){
l = Math.max(l, 0);
for (TreeSet<int []> [] arr : values){
//System.out.println(Arrays.toString(arr));
//System.out.println(l + " " + h + " " + arr[l] + " " + arr[h]);
if (l % 2 == 1) {
update(arr, l, val, type);
++l;
}
if (h % 2 == 0) {
update(arr, h, val, type);
--h;
}
if (h == l) break;
l /= 2;
h /= 2;
if (h < l) break;
}
}
int retrieve(int idx){
int result = 0;
for (TreeSet<int []> [] setArr : values){
// arr[idx] = next;
if (setArr[idx] != null && !setArr[idx].isEmpty()) {
int [] first = setArr[idx].first();
result = Math.max(result, first[0]);
}
idx /= 2;
}
return result;
}
} | ConDefects/ConDefects/Code/abc342_g/Java/50887791 |
condefects-java_data_1646 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner (System.in);
int h=scan.nextInt();
int w=scan.nextInt();
int [][]ar2=new int[h][w];
for(int i=0;i<h;i++){
for(int j=0; j<w ;j++){
ar2[i][j]=scan.nextInt();
}
}
String ans="Yes";
for(int i=0;i<h;i++){
for(int j=0; j<w ;j++){
if(i>0){
if(i==j){
if(ar2[i][j]+ar2[i-1][j-1]<ar2[i][j-1]+ar2[i-1][j]){
continue;
}else {
ans="No";
}
}
}
}
}
System.out.println(ans);
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner (System.in);
int h=scan.nextInt();
int w=scan.nextInt();
int [][]ar2=new int[h][w];
for(int i=0;i<h;i++){
for(int j=0; j<w ;j++){
ar2[i][j]=scan.nextInt();
}
}
String ans="Yes";
for(int i=0;i<h;i++){
for(int j=0; j<w ;j++){
if(i>0){
if(i==j){
if(ar2[i][j]+ar2[i-1][j-1]<=ar2[i][j-1]+ar2[i-1][j]){
continue;
}else {
ans="No";
}
}
}
}
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc224_b/Java/36028662 |
condefects-java_data_1647 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.function.BinaryOperator;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
sa = br.readLine().split(" ");
int[] a = new int [n];
for (int i = 0; i < n; i++) {
a[i] = Integer.parseInt(sa[i]);
}
br.close();
PriorityQueue<Obj> que = new PriorityQueue<>((o1, o2) -> o2.a - o1.a);
for (int i = 0; i < n; i++) {
Obj o = new Obj();
o.i = i + 1;
o.a = a[i];
que.add(o);
}
int n1 = n / 2;
int n2 = n * 2;
Integer[] b = new Integer[n2 + 1];
Arrays.fill(b, 0);
long s = 0;
for (int i = 0; i < n1; i++) {
Obj o = que.poll();
b[o.i]++;
b[o.i + n]++;
s += o.a;
}
for (int i = 1; i <= n2; i++) {
b[i] += b[i - 1];
}
int[] c = new int[n2 + 1];
for (int i = 1; i <= n2; i++) {
c[i] = b[i];
b[i] -= (i + 1) / 2;
}
SegTree<Integer> st = new SegTree<>(b, 0, (v1, v2) -> Math.max(v1, v2));
int d1 = 0;
int d2 = 0;
for (int i = 1; i < n; i += 2) {
d1 = c[i - 1];
if (st.prod(i, i + n) - d1 + d2 <= 0) {
System.out.println(i + " " + s);
return;
}
d2++;
}
throw new RuntimeException();
}
static class Obj {
int i, a;
}
}
class SegTree<S> {
private final int n; // 要素数
private final int size; // 葉の数（n以上の最小の2べき）
private final BinaryOperator<S> op; // 二項演算
private final S e; // 単位元
private final S[] data;
/**
* 長さnの配列aを作る。初期値は全て単位元。<br>
* O(n)
*
* @param n 要素数
* @param e 単位元
* @param op 二項演算
*/
@SuppressWarnings("unchecked")
public SegTree(int n, S e, BinaryOperator<S> op) {
this.n = n;
int k = 1;
while (k < n) k <<= 1;
this.size = k;
this.e = e;
this.op = op;
this.data = (S[]) new Object[size << 1];
Arrays.fill(data, e);
}
/**
* 長さdat.lengthの配列aをdatを元に作る。<br>
* O(n)
*
* @param dat 初期データ
* @param e 単位元
* @param op 二項演算
*/
public SegTree(S[] dat, S e, BinaryOperator<S> op) {
this(dat.length, e, op);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, size, l);
for (int i = size - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
/**
* a[p] = xとする。<br>
* O(log n)
*
* @param p 設定位置（0≦p＜n）
* @param x 設定値
*/
void set(int p, S x) {
assert 0 <= p && p < n : "p=" + p;
data[p += size] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
/**
* a[p]を取得する。<br>
* O(1)
*
* @param p 取得位置（0≦p＜n）
*/
S get(int p) {
assert 0 <= p && p < n : "p=" + p;
return data[p + size];
}
/**
* 区間l～(r-1)の計算を行う。<br>
* l＝rのときは単位元を返す。<br>
* O(log n)
*
* @param l 開始位置（含む） （0≦l≦r≦n）
* @param r 終了位置（含まない）（0≦l≦r≦n）
*/
S prod(int l, int r) {
assert 0 <= l && l <= r && r <= n : "l=" + l + ", r=" + r;
S sumLeft = e;
S sumRight = e;
l += size;
r += size;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
/**
* 全区間の計算を行う。<br>
* O(1)
*/
S allProd() {
return data[1];
}
/**
* f(op(l～(r-1)))＝trueとなる最大のrを返す。<br>
* （計算区間にrを追加するとfalseになる）<br>
* O(log n)
*
* @param l 左端（含む）（0≦l≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最大のr
*/
int maxRight(int l, Predicate<S> f) {
assert 0 <= l && l <= n : "l=" + l;
assert f.test(e);
if (l == n) return n;
l += size;
S sum = e;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < size) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - size;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return n;
}
/**
* f(op(l～(r-1)))＝trueとなる最小のlを返す。<br>
* （計算区間に(l-1)を追加するとfalseになる）<br>
* O(log n)
*
* @param r 右端（含まない）（0≦r≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最小のl
*/
int minLeft(int r, Predicate<S> f) {
assert 0 <= r && r <= n : "r=" + r;
assert f.test(e);
if (r == 0) return 0;
r += size;
S sum = e;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < size) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - size;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
// **************** DEBUG **************** //
private int indent = 6;
void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
/**
* セグメント木全体の要素をツリー状に出力。
*/
String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= size) return indent(sp) + data[k];
StringBuilder sb = new StringBuilder();
sb.append(toDetailedString(k << 1 | 1, sp + indent));
sb.append("\n");
sb.append(indent(sp) + data[k]);
sb.append("\n");
sb.append(toDetailedString(k << 1 | 0, sp + indent));
return sb.toString();
}
private String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0) sb.append(' ');
return sb.toString();
}
/**
* n件の要素のみを、配列形式で出力。
*/
String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < size; i++) {
sb.append(data[i + size]);
if (i < size - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.function.BinaryOperator;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
sa = br.readLine().split(" ");
int[] a = new int [n];
for (int i = 0; i < n; i++) {
a[i] = Integer.parseInt(sa[i]);
}
br.close();
PriorityQueue<Obj> que = new PriorityQueue<>((o1, o2) -> o2.a - o1.a);
for (int i = 0; i < n; i++) {
Obj o = new Obj();
o.i = i + 1;
o.a = a[i];
que.add(o);
}
int n1 = n / 2;
int n2 = n * 2;
Integer[] b = new Integer[n2 + 1];
Arrays.fill(b, 0);
long s = 0;
for (int i = 0; i < n1; i++) {
Obj o = que.poll();
b[o.i]++;
b[o.i + n]++;
s += o.a;
}
for (int i = 1; i <= n2; i++) {
b[i] += b[i - 1];
}
int[] c = new int[n2 + 1];
for (int i = 1; i <= n2; i++) {
c[i] = b[i];
b[i] -= (i + 1) / 2;
}
SegTree<Integer> st = new SegTree<>(b, 0, (v1, v2) -> Math.max(v1, v2));
int d1 = 0;
int d2 = 0;
for (int i = 1; i < n; i += 2) {
d1 = c[i - 1];
if (st.prod(i, i + n) - d1 + d2 <= 0) {
System.out.println((i - 1) + " " + s);
return;
}
d2++;
}
throw new RuntimeException();
}
static class Obj {
int i, a;
}
}
class SegTree<S> {
private final int n; // 要素数
private final int size; // 葉の数（n以上の最小の2べき）
private final BinaryOperator<S> op; // 二項演算
private final S e; // 単位元
private final S[] data;
/**
* 長さnの配列aを作る。初期値は全て単位元。<br>
* O(n)
*
* @param n 要素数
* @param e 単位元
* @param op 二項演算
*/
@SuppressWarnings("unchecked")
public SegTree(int n, S e, BinaryOperator<S> op) {
this.n = n;
int k = 1;
while (k < n) k <<= 1;
this.size = k;
this.e = e;
this.op = op;
this.data = (S[]) new Object[size << 1];
Arrays.fill(data, e);
}
/**
* 長さdat.lengthの配列aをdatを元に作る。<br>
* O(n)
*
* @param dat 初期データ
* @param e 単位元
* @param op 二項演算
*/
public SegTree(S[] dat, S e, BinaryOperator<S> op) {
this(dat.length, e, op);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, size, l);
for (int i = size - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
/**
* a[p] = xとする。<br>
* O(log n)
*
* @param p 設定位置（0≦p＜n）
* @param x 設定値
*/
void set(int p, S x) {
assert 0 <= p && p < n : "p=" + p;
data[p += size] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
/**
* a[p]を取得する。<br>
* O(1)
*
* @param p 取得位置（0≦p＜n）
*/
S get(int p) {
assert 0 <= p && p < n : "p=" + p;
return data[p + size];
}
/**
* 区間l～(r-1)の計算を行う。<br>
* l＝rのときは単位元を返す。<br>
* O(log n)
*
* @param l 開始位置（含む） （0≦l≦r≦n）
* @param r 終了位置（含まない）（0≦l≦r≦n）
*/
S prod(int l, int r) {
assert 0 <= l && l <= r && r <= n : "l=" + l + ", r=" + r;
S sumLeft = e;
S sumRight = e;
l += size;
r += size;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
/**
* 全区間の計算を行う。<br>
* O(1)
*/
S allProd() {
return data[1];
}
/**
* f(op(l～(r-1)))＝trueとなる最大のrを返す。<br>
* （計算区間にrを追加するとfalseになる）<br>
* O(log n)
*
* @param l 左端（含む）（0≦l≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最大のr
*/
int maxRight(int l, Predicate<S> f) {
assert 0 <= l && l <= n : "l=" + l;
assert f.test(e);
if (l == n) return n;
l += size;
S sum = e;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < size) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - size;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return n;
}
/**
* f(op(l～(r-1)))＝trueとなる最小のlを返す。<br>
* （計算区間に(l-1)を追加するとfalseになる）<br>
* O(log n)
*
* @param r 右端（含まない）（0≦r≦n）
* @param f 判定関数（f(e)＝true）
* @return 条件を満たす最小のl
*/
int minLeft(int r, Predicate<S> f) {
assert 0 <= r && r <= n : "r=" + r;
assert f.test(e);
if (r == 0) return 0;
r += size;
S sum = e;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < size) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - size;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
// **************** DEBUG **************** //
private int indent = 6;
void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
/**
* セグメント木全体の要素をツリー状に出力。
*/
String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= size) return indent(sp) + data[k];
StringBuilder sb = new StringBuilder();
sb.append(toDetailedString(k << 1 | 1, sp + indent));
sb.append("\n");
sb.append(indent(sp) + data[k]);
sb.append("\n");
sb.append(toDetailedString(k << 1 | 0, sp + indent));
return sb.toString();
}
private String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0) sb.append(' ');
return sb.toString();
}
/**
* n件の要素のみを、配列形式で出力。
*/
String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < size; i++) {
sb.append(data[i + size]);
if (i < size - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
| ConDefects/ConDefects/Code/arc138_c/Java/30817966 |
condefects-java_data_1648 | 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.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
fs = new FastReader();
out = new PrintWriter(System.out);
int n = fs.nextInt();
int ar[] = fs.readArray(n);
int arr[] = Arrays.copyOf(ar, n);
ruffleSort(ar);
int p = 0;
int pn = 0, k = 0;
for (int i = 1; i <= n; ++i) {
p += arr[i - 1] >= ar[n / 2] ? -1 : 1;
if (p < pn) {
pn = p;
k = i;
}
}
out.print(k + " ");
long ans = 0;
for (int i = n / 2; i < n; ++i) {
ans += ar[i];
}
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.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
fs = new FastReader();
out = new PrintWriter(System.out);
int n = fs.nextInt();
int ar[] = fs.readArray(n);
int arr[] = Arrays.copyOf(ar, n);
ruffleSort(ar);
int p = 0;
int pn = 0, k = 0;
for (int i = 1; i <= n; ++i) {
p += arr[i - 1] >= ar[n / 2] ? -1 : 1;
if (p < pn) {
pn = p;
k = i;
}
}
out.print(Math.min(k, n - 1) + " ");
long ans = 0;
for (int i = n / 2; i < n; ++i) {
ans += ar[i];
}
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/arc138_c/Java/30831534 |
condefects-java_data_1649 | import java.util.Scanner;
import java.util.TreeSet;
public class Main {
static int N,W;
static int[] A;
static TreeSet<Integer> set = new TreeSet<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
W = sc.nextInt();
A = new int[N];
for(int i=0; i<N; i++) {
A[i] = sc.nextInt();
set.add(A[i]);
}
sc.close();
for(int i=0; i<N; i++){
for(int j=i+1; j<N; j++){
if(A[i]+A[j]<W+1) set.add(A[i]+A[j]);
}
}
for(int i=0; i<N; i++){
for(int j=i+1; j<N; j++){
for(int k=j+1; k<N; k++){
if(A[i]+A[j]+A[k]<W+1) set.add(A[i]+A[j]+A[k]);
}
}
}
System.out.println(set.size());
}
}
import java.util.Scanner;
import java.util.TreeSet;
public class Main {
static int N,W;
static int[] A;
static TreeSet<Integer> set = new TreeSet<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
W = sc.nextInt();
A = new int[N];
for(int i=0; i<N; i++) {
A[i] = sc.nextInt();
if(A[i]<W+1) set.add(A[i]);
}
sc.close();
for(int i=0; i<N; i++){
for(int j=i+1; j<N; j++){
if(A[i]+A[j]<W+1) set.add(A[i]+A[j]);
}
}
for(int i=0; i<N; i++){
for(int j=i+1; j<N; j++){
for(int k=j+1; k<N; k++){
if(A[i]+A[j]+A[k]<W+1) set.add(A[i]+A[j]+A[k]);
}
}
}
System.out.println(set.size());
}
} | ConDefects/ConDefects/Code/abc251_b/Java/36472839 |
condefects-java_data_1650 | import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
private static Scanner sc = new Scanner(System.in);
private static int firstItem;
private static int seconItem;
public static void main(String[] args) {
try {
int number = stringToInt(getInputItem());
alternating(number);
} catch (NumberFormatException e) {
System.out.println("エラー: 数値形式ではありません");
}
sc.close();
}
// 標準入力から値を取得
public static String getInputItem() {
return sc.next();
}
// 標準入力から複数値を取得
public static void getInputItems() {
firstItem = sc.nextInt();
seconItem = sc.nextInt();
}
// Stringをintに変換
public static int stringToInt(String str) throws NumberFormatException {
return Integer.parseInt(str);
}
// 複数の標準出力をcharで返す
public static char[] readInputsAsCharArray(int num) {
StringBuilder inputString = new StringBuilder();
for (int i = 0; i < num; i++) {
if (sc.hasNext()) {
String input = sc.next();
inputString.append(input); // 文字列を追加
if (i < num - 1) {
inputString.append(' '); // スペースで区切る
}
}
}
return inputString.toString().toCharArray(); // 最終的な文字列をchar[]に変換して返す
}
// 文字列をChar配列に変換する
public static char[] changeToChar(String originalStr) {
return originalStr.toCharArray();
}
// 双方向矢印型の文字列であるか判定
public static String isBidirectionalArrowString(char[] originalChar) {
int length = originalChar.length;
if (length < 3) return "No";
if(originalChar[0] != '<' || originalChar[length - 1] != '>') return "No";
for (int i = 1; i < originalChar.length - 1; i++) {
if( originalChar[i] != '=') return "No";
}
return "Yes";
}
// 2 つの | の間にある文字および | を S から削除した文字列を出力
public static String outputTrimedStr(char[] originalChar) {
StringBuilder sb = new StringBuilder(new String(originalChar));
int firstIndex = sb.indexOf("|");
int secondIndex = sb.indexOf("|");
sb.delete(firstIndex, secondIndex + 1);
return sb.toString();
}
// 0以上9 以下の整数であって A+B と等しくないものをいずれかひとつ出力
public static int outputWrongAnser(int firstItem,int secondItem) {
int referenceNum = firstItem + secondItem;
int countNum = 0;
for (int i = 0; i < 11; i++) {
if( i != referenceNum ){
System.out.println(i);
countNum += 1;
}
if(countNum == 1) {
break;
}
}
return 0;
}
// 頻度分布
public static String yay(char[] originalChar) {
Map<Character, Integer> frequencyMap = new HashMap<>();
Map<Character, Integer> positionMap = new HashMap<>();
for (int i = 0; i < originalChar.length; i++) {
char ch = originalChar[i];
if (!frequencyMap.containsKey(ch)) {
frequencyMap.put(ch, 1);
positionMap.put(ch, i); // 位置を保存
} else {
frequencyMap.put(ch, frequencyMap.get(ch) + 1);
}
}
// 頻度分布を出力
for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
if (entry.getValue() == 1) {
System.out.println(positionMap.get(entry.getKey()));
}
}
return "";
}
// Past ABCs
public static String underNum(char[] originalChar){
StringBuilder sb = new StringBuilder(new String(originalChar));
sb.delete(0, 3);
String refStr = sb.toString();
int refInt = Integer.parseInt(refStr);
if (refInt > 350 && refInt < 0) {
return "No";
}
return "Yes";
}
// Dentist Aoki
// 同じ数字が何個あるのか確かめる。
// その数字が奇数ならN-1,偶数ならN-0
public static int Dentist(char[] originalChar) {
Map<Character, Integer> frequencyMap = new HashMap<>();
for (int i = 0; i < originalChar.length; i++) {
char ch = originalChar[i];
if (!frequencyMap.containsKey(ch)) {
frequencyMap.put(ch, 1);
} else {
frequencyMap.put(ch, frequencyMap.get(ch) + 1);
}
}
// 出現頻度が偶数か奇数かの処理分け
for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
if (entry.getValue() % 2 == 1) {
firstItem -= 1;
}
}
return firstItem;
}
// Print 341
public static void alternating(int num) {
for (int i = 0; i < num; i++) {
System.out.print("1 " + "0 ");;
}
System.out.print("1");
}
}
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
private static Scanner sc = new Scanner(System.in);
private static int firstItem;
private static int seconItem;
public static void main(String[] args) {
try {
int number = stringToInt(getInputItem());
alternating(number);
} catch (NumberFormatException e) {
System.out.println("エラー: 数値形式ではありません");
}
sc.close();
}
// 標準入力から値を取得
public static String getInputItem() {
return sc.next();
}
// 標準入力から複数値を取得
public static void getInputItems() {
firstItem = sc.nextInt();
seconItem = sc.nextInt();
}
// Stringをintに変換
public static int stringToInt(String str) throws NumberFormatException {
return Integer.parseInt(str);
}
// 複数の標準出力をcharで返す
public static char[] readInputsAsCharArray(int num) {
StringBuilder inputString = new StringBuilder();
for (int i = 0; i < num; i++) {
if (sc.hasNext()) {
String input = sc.next();
inputString.append(input); // 文字列を追加
if (i < num - 1) {
inputString.append(' '); // スペースで区切る
}
}
}
return inputString.toString().toCharArray(); // 最終的な文字列をchar[]に変換して返す
}
// 文字列をChar配列に変換する
public static char[] changeToChar(String originalStr) {
return originalStr.toCharArray();
}
// 双方向矢印型の文字列であるか判定
public static String isBidirectionalArrowString(char[] originalChar) {
int length = originalChar.length;
if (length < 3) return "No";
if(originalChar[0] != '<' || originalChar[length - 1] != '>') return "No";
for (int i = 1; i < originalChar.length - 1; i++) {
if( originalChar[i] != '=') return "No";
}
return "Yes";
}
// 2 つの | の間にある文字および | を S から削除した文字列を出力
public static String outputTrimedStr(char[] originalChar) {
StringBuilder sb = new StringBuilder(new String(originalChar));
int firstIndex = sb.indexOf("|");
int secondIndex = sb.indexOf("|");
sb.delete(firstIndex, secondIndex + 1);
return sb.toString();
}
// 0以上9 以下の整数であって A+B と等しくないものをいずれかひとつ出力
public static int outputWrongAnser(int firstItem,int secondItem) {
int referenceNum = firstItem + secondItem;
int countNum = 0;
for (int i = 0; i < 11; i++) {
if( i != referenceNum ){
System.out.println(i);
countNum += 1;
}
if(countNum == 1) {
break;
}
}
return 0;
}
// 頻度分布
public static String yay(char[] originalChar) {
Map<Character, Integer> frequencyMap = new HashMap<>();
Map<Character, Integer> positionMap = new HashMap<>();
for (int i = 0; i < originalChar.length; i++) {
char ch = originalChar[i];
if (!frequencyMap.containsKey(ch)) {
frequencyMap.put(ch, 1);
positionMap.put(ch, i); // 位置を保存
} else {
frequencyMap.put(ch, frequencyMap.get(ch) + 1);
}
}
// 頻度分布を出力
for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
if (entry.getValue() == 1) {
System.out.println(positionMap.get(entry.getKey()));
}
}
return "";
}
// Past ABCs
public static String underNum(char[] originalChar){
StringBuilder sb = new StringBuilder(new String(originalChar));
sb.delete(0, 3);
String refStr = sb.toString();
int refInt = Integer.parseInt(refStr);
if (refInt > 350 && refInt < 0) {
return "No";
}
return "Yes";
}
// Dentist Aoki
// 同じ数字が何個あるのか確かめる。
// その数字が奇数ならN-1,偶数ならN-0
public static int Dentist(char[] originalChar) {
Map<Character, Integer> frequencyMap = new HashMap<>();
for (int i = 0; i < originalChar.length; i++) {
char ch = originalChar[i];
if (!frequencyMap.containsKey(ch)) {
frequencyMap.put(ch, 1);
} else {
frequencyMap.put(ch, frequencyMap.get(ch) + 1);
}
}
// 出現頻度が偶数か奇数かの処理分け
for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
if (entry.getValue() % 2 == 1) {
firstItem -= 1;
}
}
return firstItem;
}
// Print 341
public static void alternating(int num) {
for (int i = 0; i < num; i++) {
System.out.print("1" + "0");;
}
System.out.print("1");
}
}
| ConDefects/ConDefects/Code/abc341_a/Java/52665042 |
condefects-java_data_1651 | import java.io.*;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main {
public static void solve () {
int n = nextInt(), m = nextInt();
String[] s = nextArray(n);
Set<String> set = new HashSet<>();
for (int i=0; i<m; i++) set.add(next());
for (int i=0; i<n; i++) {
println(set.add(s[i])? "Yes" : "No");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static String yesno(boolean b) {return b ? "Yes" : "No";}
public static class CharTable {
int h, w;
Point[][] table;
CharTable(int h, int w) {
table = new Point[h][w];
this.h = h;
this.w = w;
for (int i=0; i<h; i++) {
String s = next();
for (int j=0; j<w; j++) {
table[i][j] = new Point(i, j, s.charAt(j));
}
}
}
public Point getPoint(int y, int x) {
return this.table[y][x];
}
public List<Point> getAround4(int y, int x) {
List<Point> a = new ArrayList<>();
if (y >= 1) a.add(new Point(y-1, x));
if (y <= h-2) a.add(new Point(y+1, x));
if (x >= 1) a.add(new Point(y, x-1));
if (x <= w-2) a.add(new Point(y, x+1));
return a;
}
public List<Point> getAround8(int y, int x) {
List<Point> a = new ArrayList<>();
if (y >= 1) {
a.add(new Point(y-1, x));
if (x >= 1) a.add(new Point(y-1, x-1));
if (x <= w-2) a.add(new Point(y-1, x+1));
}
if (y <= h-2) {
a.add(new Point(y+1, x));
if (x >= 1) a.add(new Point(y+1, x-1));
if (x <= w-2) a.add(new Point(y+1, x+1));
}
if (x >= 1) a.add(new Point(y, x-1));
if (x <= w-2) a.add(new Point(y, x+1));
return a;
}
}
public static class Point {
int y, x;
char c;
Point (int y, int x) {
this.y = y;
this.x = x;
}
Point (int y, int x, char c) {
this.y = y;
this.x = x;
this.c = c;
}
public boolean isEqual(Point p) {
if (this.y == p.y && this.x == p.x) return true;
return false;
}
public int getY() {return this.y;}
public int getX() {return this.x;}
public char getC() {return this.c;}
}
public static class Edge {
int a, b;
Edge(int a, int b) {
this.a = a;
this.b = b;
}
public int getA() {return this.a;}
public int getB() {return this.b;}
}
public static class Section {
int s, e;
Section(int s, int e) {
this.s = s;
this.e = e;
}
public int getS() {return this.s;}
public int getE() {return this.e;}
}
public static class Triple {
int a, b, c;
Triple(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int getA() {return this.a;}
public int getB() {return this.b;}
public int getC() {return this.c;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static List<List<Integer>> nextDirectedGraph(int n, int m) {
List<List<Integer>> g = new ArrayList<>();
for (int i=0; i<n; i++) {
g.add(new ArrayList<>());
}
for (int i=0; i<m; i++) {
int a = nextInt()-1, b = nextInt()-1;
g.get(a).add(b);
g.get(b).add(a);
}
return g;
}
public static List<List<Integer>> nextUndirectedGraph(int n, int m) {
List<List<Integer>> g = new ArrayList<>();
for (int i=0; i<n; i++) {
g.add(new ArrayList<>());
}
for (int i=0; i<m; i++) {
int a = nextInt()-1, b = nextInt()-1;
g.get(a).add(b);
}
return g;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// output
/////////////////////////////////////////////////////////////////////////////////////////////////
static PrintWriter out = new PrintWriter(System.out);
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
solve();
out.close();
}
}
import java.io.*;
import java.math.*;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
class Main {
public static void solve () {
int n = nextInt(), m = nextInt();
String[] s = nextArray(n);
Set<String> set = new HashSet<>();
for (int i=0; i<m; i++) set.add(next());
for (int i=0; i<n; i++) {
println(set.contains(s[i])? "Yes" : "No");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static String yesno(boolean b) {return b ? "Yes" : "No";}
public static class CharTable {
int h, w;
Point[][] table;
CharTable(int h, int w) {
table = new Point[h][w];
this.h = h;
this.w = w;
for (int i=0; i<h; i++) {
String s = next();
for (int j=0; j<w; j++) {
table[i][j] = new Point(i, j, s.charAt(j));
}
}
}
public Point getPoint(int y, int x) {
return this.table[y][x];
}
public List<Point> getAround4(int y, int x) {
List<Point> a = new ArrayList<>();
if (y >= 1) a.add(new Point(y-1, x));
if (y <= h-2) a.add(new Point(y+1, x));
if (x >= 1) a.add(new Point(y, x-1));
if (x <= w-2) a.add(new Point(y, x+1));
return a;
}
public List<Point> getAround8(int y, int x) {
List<Point> a = new ArrayList<>();
if (y >= 1) {
a.add(new Point(y-1, x));
if (x >= 1) a.add(new Point(y-1, x-1));
if (x <= w-2) a.add(new Point(y-1, x+1));
}
if (y <= h-2) {
a.add(new Point(y+1, x));
if (x >= 1) a.add(new Point(y+1, x-1));
if (x <= w-2) a.add(new Point(y+1, x+1));
}
if (x >= 1) a.add(new Point(y, x-1));
if (x <= w-2) a.add(new Point(y, x+1));
return a;
}
}
public static class Point {
int y, x;
char c;
Point (int y, int x) {
this.y = y;
this.x = x;
}
Point (int y, int x, char c) {
this.y = y;
this.x = x;
this.c = c;
}
public boolean isEqual(Point p) {
if (this.y == p.y && this.x == p.x) return true;
return false;
}
public int getY() {return this.y;}
public int getX() {return this.x;}
public char getC() {return this.c;}
}
public static class Edge {
int a, b;
Edge(int a, int b) {
this.a = a;
this.b = b;
}
public int getA() {return this.a;}
public int getB() {return this.b;}
}
public static class Section {
int s, e;
Section(int s, int e) {
this.s = s;
this.e = e;
}
public int getS() {return this.s;}
public int getE() {return this.e;}
}
public static class Triple {
int a, b, c;
Triple(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public int getA() {return this.a;}
public int getB() {return this.b;}
public int getC() {return this.c;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
public static List<List<Integer>> nextDirectedGraph(int n, int m) {
List<List<Integer>> g = new ArrayList<>();
for (int i=0; i<n; i++) {
g.add(new ArrayList<>());
}
for (int i=0; i<m; i++) {
int a = nextInt()-1, b = nextInt()-1;
g.get(a).add(b);
g.get(b).add(a);
}
return g;
}
public static List<List<Integer>> nextUndirectedGraph(int n, int m) {
List<List<Integer>> g = new ArrayList<>();
for (int i=0; i<n; i++) {
g.add(new ArrayList<>());
}
for (int i=0; i<m; i++) {
int a = nextInt()-1, b = nextInt()-1;
g.get(a).add(b);
}
return g;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// output
/////////////////////////////////////////////////////////////////////////////////////////////////
static PrintWriter out = new PrintWriter(System.out);
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
public static void printStringArray(String[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printIntArray(int[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc236_c/Java/38627436 |
condefects-java_data_1652 | import java.io.PrintWriter;
import java.util.*;
public class Main {
private static final Scanner sc = new Scanner(System.in);
private static final PrintWriter out = new PrintWriter(System.out, false);
private static final Set<String> stopLineName = new HashSet<>();
public static void main(String[] args) {
sc.nextLine();
String[] lineName = sc.nextLine().split(" ");
stopLineName.addAll(Arrays.asList(sc.nextLine().split(" ")));
for (String line: lineName) {
out.println(stopLineName.contains(line) ? "YES" : "No");
}
out.flush();
}
}
import java.io.PrintWriter;
import java.util.*;
public class Main {
private static final Scanner sc = new Scanner(System.in);
private static final PrintWriter out = new PrintWriter(System.out, false);
private static final Set<String> stopLineName = new HashSet<>();
public static void main(String[] args) {
sc.nextLine();
String[] lineName = sc.nextLine().split(" ");
stopLineName.addAll(Arrays.asList(sc.nextLine().split(" ")));
for (String line: lineName) {
out.println(stopLineName.contains(line) ? "Yes" : "No");
}
out.flush();
}
} | ConDefects/ConDefects/Code/abc236_c/Java/31791952 |
condefects-java_data_1653 | import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt();
int m = sc.nextInt();
String[] s = new String[n];
String[] t = new String[m];
for (int i = 0; i < n; i++) {
s[i] = sc.next();
}
for (int i = 0; i < m; i++) {
t[i] = sc.next();
}
pw.println(Arrays.toString(s));
pw.println(Arrays.toString(t));
sc.close();
int crtT = 0;
for (int i = 0; i < n; i++) {
if (s[i].equals(t[crtT])) {
pw.println("Yes");
crtT++;
} else {
pw.println("No");
}
}
pw.close();
}
// ワーシャルフロイド法 町の個数 合計距離P以下 距離の長さ 距離のまとまり 合計距離
// https://atcoder.jp/contests/typical90/tasks/typical90_ci
public static int worshallFloyd(long N, long P, long lens, long[][] dist, long[][] A) {
// 初期値を値の長さにする
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (A[i][j] == -1) {
dist[i][j] = lens;
}
if (A[i][j] != -1) {
dist[i][j] = A[i][j];
}
}
}
// 最短距離を更新
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
for (int k = 1; k <= N; k++) {
dist[j][k] = Math.min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
// 該当する値をカウント
int cnt = 0;
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
if (dist[i][j] <= P) {
cnt++;
}
}
}
return cnt;
}
// ダイクストラ法 個数 町1 町2 距離 スタート地点
public static int[] Dijkstra(int n, int[] a, int[] b, int[] c, int start) {
int m = a.length;
int[] dist = new int[n];
boolean[] checked = new boolean[n];
PriorityQueue<Pair> queue = new PriorityQueue<>((p0, p1) -> p0.b - p1.b); // 昇順にソート
List<ArrayList<Integer>> edge = new ArrayList<>();
for( int i = 0; i < n; i++ ) {
edge.add(new ArrayList<>());
dist[i] = Integer.MAX_VALUE;
}
for( int i = 0; i < m; i++ ) {
edge.get(a[i]).add(i);
edge.get(b[i]).add(i);
}
dist[start] = 0;
queue.add(new Pair(start, 0));
while(!queue.isEmpty()) {
Pair p = queue.remove();
int cur = p.a;
if (checked[cur]) {
continue;
}
checked[cur] = true;
for(int i : edge.get(cur)) {
int next;
if (a[i] == cur) {
next = b[i];
} else {
next = a[i];
}
if(!checked[next] && dist[next] > dist[cur] + c[i]) {
dist[next] = dist[cur] + c[i];
queue.add(new Pair(next, dist[next]));
}
}
}
return dist;
}
// 深さ優先探索 1, -1 漸化式 隣接リスト 頂点番号(1 or 0) mod
public static void dfs(int pos, int pre, long[][] dp, List<List<Integer>> g, int[] c, int mod) {
long val1 = 1;
long val2 = 1;
for (int i : g.get(pos)) {
if (i == pre) {
continue;
}
dfs(i, pos, dp, g, c, mod);
if (c[pos] == 0) {
val1 *= (dp[i][0] + dp[i][2]);
val2 *= (dp[i][0] + dp[i][1] + 2 * dp[i][2]);
} else {
val1 *= (dp[i][1] + dp[i][2]);
val2 *= (dp[i][0] + dp[i][1] + 2 * dp[i][2]);
}
val1 %= mod;
val2 %= mod;
}
if(c[pos] == 0) {
dp[pos][0] = val1;
dp[pos][2] = (val2 - val1 + mod) % mod;
} else {
dp[pos][1] = val1;
dp[pos][2] = (val2 - val1 + mod) % mod;
}
}
// 幅優先探索
public static int[] bfs(int start, int n, ArrayList<Integer>[] g) {
// 初期化 (dist[i] = -1 のとき、未到達の頂点である）
int[] dist = new int[n + 1];
for (int j = 1; j <= n; j++) {
dist[j] = -1;
}
dist[start] = 0;
Queue<Integer> q = new LinkedList<>();
q.add(start); // q にスタート地点を追加
while (q.size() >= 1) {
int pos = q.remove(); // Q の先頭を調べ、これを取り出す
for (int j = 0; j < g[pos].size(); j++) {
int nex = g[pos].get(j);
if (dist[nex] == -1) {
dist[nex] = dist[pos] + 1;
q.add(nex);
}
}
}
// スタート地点から最長距離を出力
return dist;
}
// 累積和
public static long cumulativeSum(int n, String s){
long ans = 0;
int countA = 0;
int countB = 0;
for (int i = 0; i < n; i++) {
if (s.charAt(i) == 'o') {
countA = Math.max(countA, countB) + 1;
ans += Math.min(countA, countB);
} else {
countB = Math.max(countA, countB) + 1;
ans += Math.min(countA, countB);
}
}
return ans;
}
// 等差数列
public static long arithmeticProgression(Long l,long r, int mod){
int count = 0;
String L = l + "";
String R = r + "";
long a = L.length(); //桁数取得
long b = R.length(); //桁数取得
for (long i = a; i <= b; i++) {
long x = Math.max(l, (long)Math.pow(10, i - 1));
long y = Math.min(r, (long)Math.pow(10, i) - 1);
// 1/2 * 項数 * (初項 + 末項)
long ans = (((i * ((y - x + 1) % mod)) % mod) * ((x + y) % mod)) % mod;
if (ans % 2 == 0) {
ans = ans / 2;
} else {
ans = (ans + mod) / 2;
}
count += ans;
count = count % mod;
}
return count;
}
// 素因数分解（個数カウント）
public static int primeFactorization(Long n, int c){
for (long i = 2; i * i <= n; i++) {
while (n % i == 0) {
c++;
n /= i;
}
}
if (n != 1) {
c++;
}
return c;
}
// 繰り返し二乗法 ビット計算に変更可能性あり
public static long power(long k, long n, int m) {
if (n == 0) {
return 1;
}
long val = power(k, n / 2, m);
val = val * val % m;
if (n % 2 == 1) {
val = val * k % m;
}
return val;
}
// 順列全探索
// 参考：https://atcoder.jp/contests/typical90/tasks/typical90_af
/*
static int n;
static int[][] a;
static boolean[][] bad;
static boolean[] used;
static int ans;
public static void perm(int where, int sum, int form) {
if (where == n && sum < ans) {
ans = sum;
} else {
for (int i = 0; i < n; i++) {
if (used[i]) {
continue;
} else if (where > 0) {
if (bad[form][i]) {
continue;
}
}
used[i] = true;
perm (where + 1, sum + a[i][where], i);
used[i] = false;
}
}
}
*/
}
class SegmentTree {
public int n;
public long[] tree;
public int[] lazyTree;
public SegmentTree(long[] original) {
int size = original.length;
n = 1;
while (n < size) {
n *= 2;
}
tree = new long[n * 2 - 1];
for (int i = 0; i < n * 2 - 1; i++) {
tree[i] = 0;
}
for (int i = 0; i < size; i++) {
update(i, original[i]);
}
}
//i番目の値をxに更新
void update(int i, long x) {
i = n + i - 1;
tree[i] = x;
while (i > 0) {
i = (i - 1) / 2;
tree[i] = Math.min(tree[i * 2 + 1], tree[i * 2 + 2]);
}
}
long getMin(int start, int end) {
return getMin(start, end, 0, 0, n);
}
//[a, b)の最小値、l, rにはノードkに対応する区間を与える
private long getMin(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return Long.MAX_VALUE;
if (a <= l && r <= b) {
return tree[k];
} else {
long lv = getMin(a, b, 2*k+1, l, (l+r)/2);
long rb = getMin(a, b, 2*k+2, (l+r)/2, r);
return Math.min(lv, rb);
}
}
}
class Pair{
int a;
int b;
public Pair(int a, int b) {
this.a = a;
this.b = b;
}
}
// Union-Find
class UFT {
int[] parent;
long[] rank;
// 初期化
public UFT(int n){
this.parent = new int[n];
this.rank = new long[n];
//初期値は自身が根&サイズ(繋がっている要素の数)とランク(木の高さ)は0
// 最初はすべてが根
for(int i = 0; i < n; i++){
parent[i] = i;
}
}
/**
* 要素の根を返す。
* 経路圧縮付き。（1→3→2となっていて2をfindした際、1→3,2と木の深さを浅くする。）
*
* @param x
* @return 要素xの根
*/
//引数の属する木のルートのidを返す
public int root(int x){
if(x == parent[x]) {
rank[x] = 0;
return x;
} else {
int d = root(parent[x]);
if ( (x - parent[x]) % 2 == 0 ) {
rank[x] = rank[x] + rank[parent[x]];
} else {
rank[x] = rank[x] - rank[parent[x]];
}
parent[x] = d;
return parent[x];
}
}
// unite i and i + 1 with V
public void unite(int x, long V) {
int rx = root(x);
int ry = root(x + 1);
if ( rx == ry ) {
return;
} else {
parent[x + 1] = rx;
rank[x + 1] = V - rank[x];
}
}
/**
* 要素xが属する集合と要素yが属する集合を連結する。
* 木の高さ（ランク）を気にして、低い方に高い方をつなげる。（高い方の根を全体の根とする。）
*
* @param x
* @param y
*/
public void merge(int x, int y){
int xRoot = root(x);
int yRoot = root(y);
//そもそも同じ木だったら何もしない
if (xRoot == yRoot) {
return;
}
// rankを比較して共通の根を決定する。
// ※find時の経路圧縮はrank考慮しない
if (rank[xRoot] > rank[yRoot]){
// xRootのrankのほうが大きければ、共通の根をxRootにする
parent[yRoot] = xRoot;
} else if (rank[xRoot] < rank[yRoot]) {
// yRootのrankのほうが大きければ、共通の根をyRootにする
parent[xRoot] = yRoot;
} else {
// rankが同じであれば、どちらかを根として、rankを一つ上げる。
parent[xRoot] = yRoot;
rank[xRoot]++;
}
}
}
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt();
int m = sc.nextInt();
String[] s = new String[n];
String[] t = new String[m];
for (int i = 0; i < n; i++) {
s[i] = sc.next();
}
for (int i = 0; i < m; i++) {
t[i] = sc.next();
}
sc.close();
int crtT = 0;
for (int i = 0; i < n; i++) {
if (s[i].equals(t[crtT])) {
pw.println("Yes");
crtT++;
} else {
pw.println("No");
}
}
pw.close();
}
// ワーシャルフロイド法 町の個数 合計距離P以下 距離の長さ 距離のまとまり 合計距離
// https://atcoder.jp/contests/typical90/tasks/typical90_ci
public static int worshallFloyd(long N, long P, long lens, long[][] dist, long[][] A) {
// 初期値を値の長さにする
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (A[i][j] == -1) {
dist[i][j] = lens;
}
if (A[i][j] != -1) {
dist[i][j] = A[i][j];
}
}
}
// 最短距離を更新
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
for (int k = 1; k <= N; k++) {
dist[j][k] = Math.min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
// 該当する値をカウント
int cnt = 0;
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
if (dist[i][j] <= P) {
cnt++;
}
}
}
return cnt;
}
// ダイクストラ法 個数 町1 町2 距離 スタート地点
public static int[] Dijkstra(int n, int[] a, int[] b, int[] c, int start) {
int m = a.length;
int[] dist = new int[n];
boolean[] checked = new boolean[n];
PriorityQueue<Pair> queue = new PriorityQueue<>((p0, p1) -> p0.b - p1.b); // 昇順にソート
List<ArrayList<Integer>> edge = new ArrayList<>();
for( int i = 0; i < n; i++ ) {
edge.add(new ArrayList<>());
dist[i] = Integer.MAX_VALUE;
}
for( int i = 0; i < m; i++ ) {
edge.get(a[i]).add(i);
edge.get(b[i]).add(i);
}
dist[start] = 0;
queue.add(new Pair(start, 0));
while(!queue.isEmpty()) {
Pair p = queue.remove();
int cur = p.a;
if (checked[cur]) {
continue;
}
checked[cur] = true;
for(int i : edge.get(cur)) {
int next;
if (a[i] == cur) {
next = b[i];
} else {
next = a[i];
}
if(!checked[next] && dist[next] > dist[cur] + c[i]) {
dist[next] = dist[cur] + c[i];
queue.add(new Pair(next, dist[next]));
}
}
}
return dist;
}
// 深さ優先探索 1, -1 漸化式 隣接リスト 頂点番号(1 or 0) mod
public static void dfs(int pos, int pre, long[][] dp, List<List<Integer>> g, int[] c, int mod) {
long val1 = 1;
long val2 = 1;
for (int i : g.get(pos)) {
if (i == pre) {
continue;
}
dfs(i, pos, dp, g, c, mod);
if (c[pos] == 0) {
val1 *= (dp[i][0] + dp[i][2]);
val2 *= (dp[i][0] + dp[i][1] + 2 * dp[i][2]);
} else {
val1 *= (dp[i][1] + dp[i][2]);
val2 *= (dp[i][0] + dp[i][1] + 2 * dp[i][2]);
}
val1 %= mod;
val2 %= mod;
}
if(c[pos] == 0) {
dp[pos][0] = val1;
dp[pos][2] = (val2 - val1 + mod) % mod;
} else {
dp[pos][1] = val1;
dp[pos][2] = (val2 - val1 + mod) % mod;
}
}
// 幅優先探索
public static int[] bfs(int start, int n, ArrayList<Integer>[] g) {
// 初期化 (dist[i] = -1 のとき、未到達の頂点である）
int[] dist = new int[n + 1];
for (int j = 1; j <= n; j++) {
dist[j] = -1;
}
dist[start] = 0;
Queue<Integer> q = new LinkedList<>();
q.add(start); // q にスタート地点を追加
while (q.size() >= 1) {
int pos = q.remove(); // Q の先頭を調べ、これを取り出す
for (int j = 0; j < g[pos].size(); j++) {
int nex = g[pos].get(j);
if (dist[nex] == -1) {
dist[nex] = dist[pos] + 1;
q.add(nex);
}
}
}
// スタート地点から最長距離を出力
return dist;
}
// 累積和
public static long cumulativeSum(int n, String s){
long ans = 0;
int countA = 0;
int countB = 0;
for (int i = 0; i < n; i++) {
if (s.charAt(i) == 'o') {
countA = Math.max(countA, countB) + 1;
ans += Math.min(countA, countB);
} else {
countB = Math.max(countA, countB) + 1;
ans += Math.min(countA, countB);
}
}
return ans;
}
// 等差数列
public static long arithmeticProgression(Long l,long r, int mod){
int count = 0;
String L = l + "";
String R = r + "";
long a = L.length(); //桁数取得
long b = R.length(); //桁数取得
for (long i = a; i <= b; i++) {
long x = Math.max(l, (long)Math.pow(10, i - 1));
long y = Math.min(r, (long)Math.pow(10, i) - 1);
// 1/2 * 項数 * (初項 + 末項)
long ans = (((i * ((y - x + 1) % mod)) % mod) * ((x + y) % mod)) % mod;
if (ans % 2 == 0) {
ans = ans / 2;
} else {
ans = (ans + mod) / 2;
}
count += ans;
count = count % mod;
}
return count;
}
// 素因数分解（個数カウント）
public static int primeFactorization(Long n, int c){
for (long i = 2; i * i <= n; i++) {
while (n % i == 0) {
c++;
n /= i;
}
}
if (n != 1) {
c++;
}
return c;
}
// 繰り返し二乗法 ビット計算に変更可能性あり
public static long power(long k, long n, int m) {
if (n == 0) {
return 1;
}
long val = power(k, n / 2, m);
val = val * val % m;
if (n % 2 == 1) {
val = val * k % m;
}
return val;
}
// 順列全探索
// 参考：https://atcoder.jp/contests/typical90/tasks/typical90_af
/*
static int n;
static int[][] a;
static boolean[][] bad;
static boolean[] used;
static int ans;
public static void perm(int where, int sum, int form) {
if (where == n && sum < ans) {
ans = sum;
} else {
for (int i = 0; i < n; i++) {
if (used[i]) {
continue;
} else if (where > 0) {
if (bad[form][i]) {
continue;
}
}
used[i] = true;
perm (where + 1, sum + a[i][where], i);
used[i] = false;
}
}
}
*/
}
class SegmentTree {
public int n;
public long[] tree;
public int[] lazyTree;
public SegmentTree(long[] original) {
int size = original.length;
n = 1;
while (n < size) {
n *= 2;
}
tree = new long[n * 2 - 1];
for (int i = 0; i < n * 2 - 1; i++) {
tree[i] = 0;
}
for (int i = 0; i < size; i++) {
update(i, original[i]);
}
}
//i番目の値をxに更新
void update(int i, long x) {
i = n + i - 1;
tree[i] = x;
while (i > 0) {
i = (i - 1) / 2;
tree[i] = Math.min(tree[i * 2 + 1], tree[i * 2 + 2]);
}
}
long getMin(int start, int end) {
return getMin(start, end, 0, 0, n);
}
//[a, b)の最小値、l, rにはノードkに対応する区間を与える
private long getMin(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return Long.MAX_VALUE;
if (a <= l && r <= b) {
return tree[k];
} else {
long lv = getMin(a, b, 2*k+1, l, (l+r)/2);
long rb = getMin(a, b, 2*k+2, (l+r)/2, r);
return Math.min(lv, rb);
}
}
}
class Pair{
int a;
int b;
public Pair(int a, int b) {
this.a = a;
this.b = b;
}
}
// Union-Find
class UFT {
int[] parent;
long[] rank;
// 初期化
public UFT(int n){
this.parent = new int[n];
this.rank = new long[n];
//初期値は自身が根&サイズ(繋がっている要素の数)とランク(木の高さ)は0
// 最初はすべてが根
for(int i = 0; i < n; i++){
parent[i] = i;
}
}
/**
* 要素の根を返す。
* 経路圧縮付き。（1→3→2となっていて2をfindした際、1→3,2と木の深さを浅くする。）
*
* @param x
* @return 要素xの根
*/
//引数の属する木のルートのidを返す
public int root(int x){
if(x == parent[x]) {
rank[x] = 0;
return x;
} else {
int d = root(parent[x]);
if ( (x - parent[x]) % 2 == 0 ) {
rank[x] = rank[x] + rank[parent[x]];
} else {
rank[x] = rank[x] - rank[parent[x]];
}
parent[x] = d;
return parent[x];
}
}
// unite i and i + 1 with V
public void unite(int x, long V) {
int rx = root(x);
int ry = root(x + 1);
if ( rx == ry ) {
return;
} else {
parent[x + 1] = rx;
rank[x + 1] = V - rank[x];
}
}
/**
* 要素xが属する集合と要素yが属する集合を連結する。
* 木の高さ（ランク）を気にして、低い方に高い方をつなげる。（高い方の根を全体の根とする。）
*
* @param x
* @param y
*/
public void merge(int x, int y){
int xRoot = root(x);
int yRoot = root(y);
//そもそも同じ木だったら何もしない
if (xRoot == yRoot) {
return;
}
// rankを比較して共通の根を決定する。
// ※find時の経路圧縮はrank考慮しない
if (rank[xRoot] > rank[yRoot]){
// xRootのrankのほうが大きければ、共通の根をxRootにする
parent[yRoot] = xRoot;
} else if (rank[xRoot] < rank[yRoot]) {
// yRootのrankのほうが大きければ、共通の根をyRootにする
parent[xRoot] = yRoot;
} else {
// rankが同じであれば、どちらかを根として、rankを一つ上げる。
parent[xRoot] = yRoot;
rank[xRoot]++;
}
}
} | ConDefects/ConDefects/Code/abc236_c/Java/31463845 |
condefects-java_data_1654 | public class Main{
public static void main(String[] args){
var sc=new java.util.Scanner(System.in);
long N=sc.nextLong();
long M=sc.nextLong();
solve(N,M);
}
static void solve(long N,long M){
long t=1;
long ans=0;
int div=998244353;
while(t<N){
if((M&t)>0){
ans+=(N/(t*2))*t;
ans+=Math.max(0,N%(t*2)-t+1);
}
ans%=div;
t*=2;
}
System.out.println(ans);
}
}
public class Main{
public static void main(String[] args){
var sc=new java.util.Scanner(System.in);
long N=sc.nextLong();
long M=sc.nextLong();
solve(N,M);
}
static void solve(long N,long M){
long t=1;
long ans=0;
int div=998244353;
while(t<=N){
if((M&t)>0){
ans+=(N/(t*2))*t;
ans+=Math.max(0,N%(t*2)-t+1);
}
ans%=div;
t*=2;
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc356_d/Java/54136344 |
condefects-java_data_1655 | import java.util.*;
import java.io.*;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.math.BigInteger;
// https://leetcode.com/contest/weekly-contest-176/
class A {
int a;
A(int a) {
this.a = a;
return;
}
}
public class Main {
static class P {
String g;
int x , y;
P(String g, int x , int y) {
this.x = x;
this.y = y;
this.g = g;
}
}
static class Node {
long sum, pre;
Node(long a, long b) {
this.sum = a;
this.pre = b;
}
}
// static class SegmentTree {
// int l , r; // range responsible for
// SegmentTree left , right;
// List<Integer> list;
// List<Long> ps;
// long val;
// long lazy = 0;
// SegmentTree(int l,int r,int a[]) {
// this.l = l;
// this.r = r;
// list = new ArrayList<>();
// ps = new ArrayList<>();
// if(l == r) {
// list.add(a[l]);
// ps.add(a[l]*1l);
// this.val = a[l];
// return;
// }
// int mid = l + (r-l)/2;
// this.left = new SegmentTree(l ,mid , a);
// this.right = new SegmentTree(mid + 1 , r,a);
// // this.val = (this.left.val + this.right.val);
// merge(this.list , this.left.list , this.right.list,this.ps);
// }
// public static void merge(List<Integer> A , List<Integer> B , List<Integer>C,List <Long> ps) {
// int i = 0, j = 0;
// while(i < B.size() && j < C.size()) {
// if(B.get(i) <= C.get(j)) A.add(B.get(i++));
// else A.add(C.get(j++));
// }
// while(i < B.size()) A.add(B.get(i++));
// while(j < C.size()) A.add(C.get(j++));
// for(int index = 0;index < A.size();index++) {
// if(index > 0) ps.add(ps.get(index-1) + A.get(index));
// else ps.add(A.get(index)*1l);
// }
// }
// public long query(int left ,int right,int x) {
// if(right < left) return 0l;
// // if(this.lazy != 0) {
// // this.val += (this.r - this.l + 1)*this.lazy;
// // if(this.left != null)this.left.lazy += this.lazy;
// // if(this.right != null) this.right.lazy += this.lazy;
// // this.lazy = 0;
// // }
// if(this.l > right || this.r < left) return 0l;
// if(this.l >= left && this.r <= right) {
// int L =0 , R = this.list.size()-1;
// long ans1 = 0 , ans2 = 0;
// while(L <= R) {
// int mid = (R-L)/2 + L;
// if(this.list.get(mid) >= x) R = mid -1;
// else {
// long elem = mid + 1;
// ans1 = elem*x - this.ps.get(mid);
// L = mid + 1;
// }
// }
// L = 0;R = this.ps.size()-1;
// while(L <= R) {
// int mid = (R-L)/2 + L;
// if(this.ps.get(mid) <= x) L = mid + 1;
// else {
// long elem = this.ps.size()-mid;
// long cut = mid>0?this.ps.get(mid-1):0;
// ans2 = this.ps.get(this.ps.size()-1) - cut - elem*x;
// R = mid - 1;
// }
// }
// return ans1 + ans2;
// }
// return (this.left.query(left , right,x) + this.right.query( left , right,x)) ;
// }
// public void pointUpdate(int index ,int val) {
// if(this.l > index || this.r < index) return;
// if(this.l == this.r && this.l == index) {
// this.val = val;
// return ;
// }
// this.left.pointUpdate(index ,val );
// this.right.pointUpdate(index , val);
// this.val = Math.min(this.left.val , this.right.val);
// }
// public void rangeUpdate(int left , int right, int x) {
// if(left > right) return ;
// if(this.lazy != 0) {
// this.val += 1l*(this.r - this.l + 1)*this.lazy;
// if(this.left != null) this.left.lazy += this.lazy;
// if(this.right != null) this.right.lazy += this.lazy;
// this.lazy = 0;
// }
// if(this.l > right || this.r < left) return;
// if(this.l >= left && this.r <= right) {
// this.val += (this.r - this.l + 1)*x;
// if(this.left != null) this.left.lazy += x;
// if(this.right != null) this.right.lazy += x;
// return;
// }
// this.left.rangeUpdate(left , right , x);
// this.right.rangeUpdate(left , right , x);
// this.val = this.left.val + this.right.val;
// }
// // public long valueAtK(int k) {
// // if(this.l > k || this.r < k) return 0;
// // if(this.l == this.r && this.l == k) {
// // return this.val;
// // }
// // return join(this.left.valueAtK(k) , this.right.valueAtK(k));
// // }
// public int join(int a ,int b) {
// return a + b;
// }
// }
// Proactively collaborate with cross-functional teams, including backend developers and web designers, to optimize usability and deliver exceptional user experiences.
static class SegmentTree2 {
int l , r; // range responsible for
SegmentTree2 left , right;
List<Integer> list;
int val;
SegmentTree2(int l, int r, int a[]) {
// System.out.println("at " + l + " " + r);
this.l = l;
this.r = r;
if (l == r) {
// list.add(a[l]);
this.val = a[l];
return;
}
int mid = l + (r - l) / 2;
this.left = new SegmentTree2(l , mid , a);
this.right = new SegmentTree2(mid + 1 , r, a);
this.val = Math.min(this.left.val , this.right.val);
}
public int query(int left , int right) {
if (this.l > right || this.r < left) return Integer.MAX_VALUE;
if (this.l >= left && this.r <= right) {
return this.val;
}
return Math.min(this.left.query(left , right) , this.right.query(left , right));
}
public void pointUpdate(int index , int val) {
if (this.l > index || this.r < index) return;
if (this.l == this.r && this.l == index) {
this.val = val;
return ;
}
this.left.pointUpdate(index , val );
this.right.pointUpdate(index , val);
this.val = Math.min(this.left.val , this.right.val);
}
// public void rangeUpdate(int left , int right) {
// if(this.l > right || this.r < left) return;
// if(this.l >= left && this.r <= right) {
// this.val += this.r-this.l + 1;
// System.out.println(" now " + this.val);
// return ;
// }
// this.left.rangeUpdate(left , right );
// this.right.rangeUpdate(left , right );
// this.val = this.left.val + this.right.val;
// }
// public long valueAtK(int k) {
// if(this.l > k || this.r < k) return 0;
// if(this.l == this.r && this.l == k) {
// return this.val;
// }
// return join(this.left.valueAtK(k) , this.right.valueAtK(k));
// }
public int join(int a , int b) {
return a + b;
}
}
static class Hash {
long hash[] , mod = (long)1e9 + 7 , powT[] , prime , inverse[];
Hash(char []s) {
prime = 131;
int n = s.length;
powT = new long[n];
hash = new long[n];
inverse = new long[n];
powT[0] = 1;
inverse[n - 1] = pow(pow(prime , n - 1 , mod), mod - 2 , mod);
for (int i = 1; i < n; i++ ) {
powT[i] = (powT[i - 1] * prime) % mod;
}
for (int i = n - 2; i >= 0; i -= 1) {
inverse[i] = (inverse[i + 1] * prime) % mod;
}
hash[0] = (s[0] - 'a' + 1);
for (int i = 1; i < n; i++ ) {
hash[i] = hash[i - 1] + ((s[i] - 'a' + 1) * powT[i]) % mod;
hash[i] %= mod;
}
}
public long hashValue(int l , int r) {
if (l == 0) return hash[r] % mod;
long ans = hash[r] - hash[l - 1] + mod;
ans %= mod;
ans *= inverse[l];
ans %= mod;
return ans;
}
}
static class ConvexHull {
Stack<Integer>stack;
Stack<Integer>stack1;
int n;
Point arr[];
ConvexHull(Point arr[]) {
n = arr.length;
this.arr = arr;
Arrays.sort(arr , (a , b)-> {
if (a.x == b.x) return (int)(b.y - a.y);
return (int)(a.x - b.x);
});
Point min = arr[0];
stack = new Stack<>();
stack1 = new Stack<>();
stack.push(0);
stack1.push(0);
Point ob = new Point(2, 2);
for (int i = 1; i < n; i++) {
if (stack.size() < 2) stack.push(i);
else {
while (stack.size() >= 2) {
int a = stack.pop() , b = stack.pop() , c = i;
int dir = ob.cross(arr[b] , arr[a] , arr[c]);
if (dir < 0) {
stack.push(b);
stack.push(a);
stack.push(c);
break;
}
stack.push(b);
}
if (stack.size() < 2) {
stack.push(i);
}
}
}
for (int i = 1; i < n; i++) {
if (stack1.size() < 2) stack1.push(i);
else {
while (stack1.size() >= 2) {
int a = stack1.pop() , b = stack1.pop() , c = i;
int dir = ob.cross(arr[b] , arr[a] , arr[c]);
if (dir > 0) {
stack1.push(b);
stack1.push(a);
stack1.push(c);
break;
}
stack1.push(b);
}
if (stack1.size() < 2) {
stack1.push(i);
}
}
}
}
public List<Point> getPoints() {
boolean vis[] = new boolean[n];
List<Point> list = new ArrayList<>();
// for(int x : stack) {
// list.add(arr[x]);
// vis[x] = true;
// }
for (int x : stack1) {
// if(vis[x]) continue;
list.add(arr[x]);
}
return list;
}
}
public static class Suffix implements Comparable<Suffix> {
int index;
int rank;
int next;
public Suffix(int ind, int r, int nr) {
index = ind;
rank = r;
next = nr;
}
public int compareTo(Suffix s) {
if (rank != s.rank) return Integer.compare(rank, s.rank);
return Integer.compare(next, s.next);
}
}
static class Point {
long x , y;
Point(long x , long y) {
this.x = x;
this.y = y;
}
public Point sub(Point a, Point b) {
return new Point(a.x - b.x , a.y - b.y);
}
public int cross(Point a , Point b , Point c) {
Point g = sub(b, a) , l = sub(c, b);
long ans = g.y * l.x - g.x * l.y;
if (ans == 0) return 0;
if (ans < 0) return -1;
return 1;
}
}
static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// standard input
public Kattio() { this(System.in, System.out); }
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// USACO-style file input
public Kattio(String problemName) throws IOException {
super(new FileWriter(problemName + ".out"));
r = new BufferedReader(new FileReader(problemName + ".in"));
}
// returns null if no more input
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) { }
return null;
}
public int nextInt() { return Integer.parseInt(next()); }
public double nextDouble() { return Double.parseDouble(next()); }
public long nextLong() { return Long.parseLong(next()); }
}
static HashMap<Integer , List<Integer>> graph;
static Kattio sc = new Kattio();
static long mod = (long)1e9 + 7;
static String endl = "\n" , gap = " ";
static HashMap<Integer , Long> value;
static int size[];
static int parent[] , strength[];
// static long fac[];
static long inv[];
static boolean vis[];
static HashSet<String> guess;
static long primePow[];
static int N;
// static int dis[];
static long p[];
static int endTime[];
static int colx[] = {1, -1, 0, 0};
static int coly[] = {0, 0, 1, -1};
// static int time;
// static Integer dp[][];
// static HashMap<String , Long> dmap;
static long dirpair[][];
static HashSet<String> not;
// static SegmetTree tree;
// static long dis[];
static int gg[];
static long fac[];
static long finv[];
public static void main(String[] args)throws IOException {
int t = 1;
// HashSet<Integer> list = new HashSet<>();
// int MAK = (int)1e5 + 1;
// boolean seive[] = new boolean[MAK];
// Arrays.fill(seive , true);
// seive[1] = false;
// seive[0] = false;
// for (int i = 1; i < MAK; i++) {
// if(seive[i]) {
// for (int j = i+i; j < MAK; j+=i) {
// seive[j] = false;
// }
// }
// }
// for(int i = 2;i < MAK;i++) {
// if(seive[i]) list.add(i);
// }
int test_case = 1;
while (t-- > 0) {
// sc.print("Case #"+(test_case++)+": ");
solve();
}
sc.close();
}
static Boolean dp[];
static String rev(String x) {
return new StringBuilder(x).reverse().toString();
}
static int height[],lca[][];
static long g[];
static long g(long j , long n) {
long res=((n>>(j+1))<<j);
if((n&(1l<<j)) > 0){
res+=((n&((1l<<j)-1))+1);
}
return res;
}
static void solve() throws IOException {
long n = rl() , m = rl();
long ans = 0 , mod = 998244353L;
for(long j = 0;j <= 60;j++) {
if((m&(1l<<j))!=0) {
ans += g(j , n + 1);
ans %= mod;
}
}
System.out.println(ans);
}
// static void dfsLCA(int node, int par,int cur,int a[]) {
// vis[node] = true;
// Queue<Integer> q = new LinkedList<>();
// q.add(node);
// size[node]++;
// lca[node][0] = node;
// while(q.size() > 0) {
// int s = q.size();
// while(s-- > 0) {
// int tp = q.poll();
// for(int j = 0;j <= 30;j++) {
// if((a[tp-1]&(1<<j)) != 0) B[tp][j]++;
// }
// size[tp]++;
// height[tp] = cur;
// for(int next : graph.get(tp)) {
// if(vis[next]) continue;
// lca[next][0] = tp;
// size[next] += size[tp];
// for(int i = 0;i <= 30;i++) {
// if(i > 0)lca[next][i] = lca[lca[next][i-1]][i-1];
// if(B[next][i] = B[tp][i];
// }
// q.add(next);
// vis[next] = true;
// }
// }
// cur++;
// }
// }
static int up(int node , int x,int lca[][]) {
for(int j = 0;j <= 30;j++) {
if((x&(1<<j))!=0) node = lca[node][j];
}
return node;
}
static int getLCA(int a, int b , int height[]) {
if(a == b) return a;
int ha = height[a] , hb = height[b];
// consedireing a as below to b;
int log = 30;
if(hb > ha) {
int tmp = a;
a = b;
b = tmp;
}
int dif = Math.abs(ha - hb);
for(int i = 0;i <= log;i++) {
if((dif&(1<<i)) != 0) {
a = lca[a][i];
}
}
if(a == b) return a;
for(int i = log;i >= 0;i--) {
if(lca[a][i] != lca[b][i]) {
a = lca[a][i];
b = lca[b][i];
}
}
return lca[a][0];
}
public static long lcm(long x , long y) {
return x / gcd(x , y) * y;
}
public static long ncr(int a , int b, long mod) {
if (a == b) return 1l;
return (((fac[a] * inv[b]) % mod) * inv[a - b]) % mod;
}
static long turnOffK(long n, long k) {
return (n & ~(1l << (k)));
}
public static void swap(int i, int j, int arr[]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static long max(long ...a) {
return maxArray(a);
}
public static void swap(int i, int j, long arr[]) {
long temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void swap(int i, int j, char arr[]) {
char temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static String slope(Point a , Point b) {
if ((a.x - b.x) == 0) return "inf";
long n = a.y - b.y;
if (n == 0) return "0";
long m = a.x - b.x;
boolean neg = (n * m < 0 ? true : false);
n = Math.abs(n);
m = Math.abs(m);
long g = gcd(Math.abs(n), Math.abs(m));
n /= g;
m /= g;
String ans = n + "/" + m;
if (neg) ans = "-" + ans;
return ans;
}
public static int lis(int A[], int size) {
int[] tailTable = new int[size];
int len;
tailTable[0] = A[0];
len = 1;
for (int i = 1; i < size; i++) {
if (A[i] < tailTable[0]) tailTable[0] = A[i];
else if (A[i] > tailTable[len - 1]) tailTable[len++] = A[i];
else tailTable[CeilIndex(tailTable, -1, len - 1, A[i])] = A[i];
}
return len;
}
public static int CeilIndex(int A[], int l, int r, int key) {
while (r - l > 1) {
int m = l + (r - l) / 2;
if (A[m] >= key) r = m;
else l = m;
}
return r;
}
public static int find(int node) {
if (node == parent[node]) return node;
return parent[node] = find(parent[node]);
}
public static void merge(int a , int b ) {
a = find(a);
b = find(b);
if (a == b) return;
long mod = (long)1e9 + 7;
if (size[a] >= size[b]) {
parent[b] = a;
size[a] += size[b];
} else {
parent[a] = b;
size[b] += size[a];
}
}
public static void processPowerOfP(long arr[]) {
int n = arr.length;
arr[0] = 1;
long mod = (long)1e9 + 7;
for (int i = 1; i < n; i++) {
arr[i] = arr[i - 1] * 51;
arr[i] %= mod;
}
}
public static long hashValue(char s[]) {
int n = s.length;
long powerOfP[] = new long[n];
processPowerOfP(powerOfP);
long ans = 0;
long mod = (long)1e9 + 7;
for (int i = 0; i < n; i++) {
ans += (s[i] - 'a' + 1) * powerOfP[i];
ans %= mod;
}
return ans;
}
public static String getSlope(int a , int b, int x, int y) {
if (a - x == 0) return "inf";
if (b - y == 0) return "0";
int n = b - y , d = a - x;
boolean neg = (n * d < 0);
n = Math.abs(n);
d = Math.abs(d);
return (neg ? "-" : "") + ((n / gcd(n , d)) + "/" + (d / gcd(n , d)));
}
public static boolean collinearr(long a[] , long b[] , long c[]) {
return (b[1] - a[1]) * (b[0] - c[0]) == (b[0] - a[0]) * (b[1] - c[1]);
}
public static boolean isSquare(long sum) {
long root = (int)Math.sqrt(sum);
return root * root == sum;
}
public static int[] suffixArray(String s) {
int n = s.length();
Suffix[] su = new Suffix[n];
for (int i = 0; i < n; i++) {
su[i] = new Suffix(i, s.charAt(i) - '$', 0);
}
for (int i = 0; i < n; i++)
su[i].next = (i + 1 < n ? su[i + 1].rank : -1);
Arrays.sort(su);
int[] ind = new int[n];
for (int length = 4; length < 2 * n; length <<= 1) {
int rank = 0, prev = su[0].rank;
su[0].rank = rank;
ind[su[0].index] = 0;
for (int i = 1; i < n; i++) {
if (su[i].rank == prev && su[i].next == su[i - 1].next) {
prev = su[i].rank;
su[i].rank = rank;
} else {
prev = su[i].rank;
su[i].rank = ++rank;
}
ind[su[i].index] = i;
}
for (int i = 0; i < n; i++) {
int nextP = su[i].index + length / 2;
su[i].next = nextP < n ?
su[ind[nextP]].rank : -1;
}
Arrays.sort(su);
}
int[] suf = new int[n];
for (int i = 0; i < n; i++)
suf[i] = su[i].index;
return suf;
}
public static boolean isPalindrome(String s) {
int i = 0 , j = s.length() - 1;
while (i <= j && s.charAt(i) == s.charAt(j)) {
i++;
j--;
}
return i > j;
}
public static void getPerm(int n , char arr[] , String s , List<String>list) {
if (n == 0) {
list.add(s);
return;
}
for (char ch : arr) {
getPerm(n - 1 , arr , s + ch, list);
}
}
public static double getDis(int arr[][] , int x, int y) {
double ans = 0.0;
for (int a[] : arr) {
int x1 = a[0] , y1 = a[1];
ans += Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}
return ans;
}
public static void primeDivisor(HashMap<Long , Long >cnt , long num) {
for (long i = 2; i * i <= num; i++) {
while (num % i == 0) {
cnt.put(i , (cnt.getOrDefault(i, 0l) + 1));
num /= i;
}
}
if (num > 2) {
cnt.put(num , (cnt.getOrDefault(num, 0l) + 1));
}
}
public static boolean isSubsequene(char a[], char b[] ) {
int i = 0 , j = 0;
while (i < a.length && j < b.length) {
if (a[i] == b[j]) {
j++;
}
i++;
}
return j >= b.length;
}
public static long fib(int n , long M) {
if (n == 0) {
return 0;
} else if (n == 1) {
return 1;
} else {
long[][] mat = {{1, 1}, {1, 0}};
mat = pow(mat, n - 1 , M);
return mat[0][0];
}
}
public static long[][] pow(long[][] mat, int n , long M) {
if (n == 1) return mat;
else if (n % 2 == 0) return pow(mul(mat, mat , M), n / 2 , M);
else return mul(pow(mul(mat, mat, M), n / 2, M), mat , M);
}
static long[][] mul(long[][] p, long[][] q, long M) {
long a = (p[0][0] * q[0][0] + p[0][1] * q[1][0]) % M;
long b = (p[0][0] * q[0][1] + p[0][1] * q[1][1]) % M;
long c = (p[1][0] * q[0][0] + p[1][1] * q[1][0]) % M;
long d = (p[1][0] * q[0][1] + p[1][1] * q[1][1]) % M;
return new long[][] {{a, b}, {c, d}};
}
public static long[] kdane(long arr[]) {
int n = arr.length;
long dp[] = new long[n];
dp[0] = arr[0];
long ans = dp[0];
for (int i = 1; i < n; i++) {
dp[i] = Math.max(dp[i - 1] + arr[i] , arr[i]);
ans = Math.max(ans , dp[i]);
}
return dp;
}
public static void reverse(long arr[]) {
int i = 0 , j = arr.length - 1;
while (i < j) {
swap(i , j , arr);
i++;
j--;
}
}
public static void reverse(int arr[]) {
int i = 0 , j = arr.length - 1;
while (i < j) {
swap(i , j , arr);
i++;
j--;
}
}
public static int maxArray(int arr[]) {
int ans = arr[0] , n = arr.length;
for (int i = 1; i < n; i++) {
ans = Math.max(ans , arr[i]);
}
return ans;
}
public static long maxArray(long arr[]) {
long ans = arr[0];
int n = arr.length;
for (int i = 1; i < n; i++) {
ans = Math.max(ans , arr[i]);
}
return ans;
}
public static int minArray(int arr[]) {
int ans = arr[0] , n = arr.length;
for (int i = 0; i < n; i++ ) {
ans = Math.min(ans , arr[i]);
}
return ans;
}
public static long minArray(long arr[]) {
long ans = arr[0];
int n = arr.length;
for (int i = 0; i < n; i++ ) {
ans = Math.min(ans , arr[i]);
}
return ans;
}
public static int sumArray(int arr[]) {
int ans = 0;
for (int x : arr) {
ans += x;
}
return ans;
}
public static long sumArray(long arr[]) {
long ans = 0;
for (long x : arr) {
ans += x;
}
return ans;
}
public static long rl() {
return sc.nextLong();
}
public static char[] rac() {
return sc.next().toCharArray();
}
public static String rs() {
return sc.next();
}
public static char rc() {
return sc.next().charAt(0);
}
public static int [] rai(int n) {
int ans[] = new int[n];
for (int i = 0; i < n; i++) {
ans[i] = sc.nextInt();
}
return ans;
}
public static long [] ral(int n) {
long ans[] = new long[n];
for (int i = 0; i < n; i++) {
ans[i] = sc.nextLong();
}
return ans;
}
public static int ri() {
return sc.nextInt();
}
public static int getValue(int num ) {
int ans = 0;
while (num > 0) {
ans++;
num = num & (num - 1);
}
return ans;
}
public static boolean isValid(int x , int y , int n, char arr[][], boolean visited[][][][]) {
return x >= 0 && x < n && y >= 0 && y < n && !(arr[x][y] == '#');
}
// for calculation set bits from 1 to N
// ith bit = n/(2^(i + 1))*(2^(i))
// n%(1<<(i+1)) >= 2^i: ans += mod + 1 - 2^i
static long inverse(long a , long mod) {
return pow(a , mod - 2 , mod);
}
public static long pow(long a , long b , long mod) {
if (b == 1) return a;
if (b == 0) return 1;
long ans = pow(a , b / 2 , mod) % mod;
if (b % 2 == 0) {
return (ans * ans) % mod;
} else {
return ((ans * ans) % mod * a) % mod;
}
}
public static long pow(long a , long b ) {
if (b == 1) return a;
if (b == 0) return 1;
long ans = pow(a , b / 2);
if (b % 2 == 0) {
return (ans * ans);
} else {
return ((ans * ans) * a);
}
}
public static boolean isVowel(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') return true;
if ((ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U')) return true;
return false;
}
public static int[] readarr()throws IOException {
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
return arr;
}
public static boolean isPowerOfTwo (long x) {
return x != 0 && ((x & (x - 1)) == 0);
}
public static boolean isPrime(long num) {
if (num == 1) return false;
if (num <= 3) return true;
if (num % 2 == 0 || num % 3 == 0) return false;
for (long i = 5; i * i <= num; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) return false;
}
return true;
}
public static boolean isPrime(int num) {
// System.out.println("At pr " + num);
if (num == 1) return false;
if (num <= 3) return true;
if (num % 2 == 0 || num % 3 == 0) return false;
for (int i = 5; i * i <= num; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) return false;
}
return true;
}
static long getSum(int a , int b , long arr[]) {
if(b < a) return 0;
long ans = arr[b];
if(a > 0)ans -= arr[a-1];
return ans;
}
public static long gcd(long a , long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static int gcd(int a , int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static int get_gcd(int a , int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static long get_gcd(long a , long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
// Fenwick tree for range update and range sum
class Fenwick {
public int[] initalize(int n) {
int[] BITree = new int[n + 1];
for (int i = 1; i <= n; i++) BITree[i] = 0;
return BITree;
}
public long getSum(int BITree[], int index) {
long sum = 0;
index = index + 1;
while (index > 0) {
sum += BITree[index];
index -= index & (-index);
}
return sum;
}
public void updateBIT(int BITree[], int n, int index, int val) {
index = index + 1;
while (index <= n) {
BITree[index] += val;
index += index & (-index);
}
}
public long sum(int x, int BITTree1[], int BITTree2[]) {
return (getSum(BITTree1, x) * x) - getSum(BITTree2, x);
}
public void updateRange(int BITTree1[], int BITTree2[], int n, int val, int l, int r) {
updateBIT(BITTree1, n, l, val);
updateBIT(BITTree1, n, r + 1, -val);
updateBIT(BITTree2, n, l, val * (l - 1));
updateBIT(BITTree2, n, r + 1, -val * r);
}
public long rangeSum(int l, int r, int BITTree1[], int BITTree2[]) {
return sum(r, BITTree1, BITTree2) - sum(l - 1, BITTree1, BITTree2);
}
public int[] constructBITree(int n) {
int[] BITree = new int[n + 1];
for (int i = 1; i <= n; i++) BITree[i] = 0;
return BITree;
}
}
import java.util.*;
import java.io.*;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.math.BigInteger;
// https://leetcode.com/contest/weekly-contest-176/
class A {
int a;
A(int a) {
this.a = a;
return;
}
}
public class Main {
static class P {
String g;
int x , y;
P(String g, int x , int y) {
this.x = x;
this.y = y;
this.g = g;
}
}
static class Node {
long sum, pre;
Node(long a, long b) {
this.sum = a;
this.pre = b;
}
}
// static class SegmentTree {
// int l , r; // range responsible for
// SegmentTree left , right;
// List<Integer> list;
// List<Long> ps;
// long val;
// long lazy = 0;
// SegmentTree(int l,int r,int a[]) {
// this.l = l;
// this.r = r;
// list = new ArrayList<>();
// ps = new ArrayList<>();
// if(l == r) {
// list.add(a[l]);
// ps.add(a[l]*1l);
// this.val = a[l];
// return;
// }
// int mid = l + (r-l)/2;
// this.left = new SegmentTree(l ,mid , a);
// this.right = new SegmentTree(mid + 1 , r,a);
// // this.val = (this.left.val + this.right.val);
// merge(this.list , this.left.list , this.right.list,this.ps);
// }
// public static void merge(List<Integer> A , List<Integer> B , List<Integer>C,List <Long> ps) {
// int i = 0, j = 0;
// while(i < B.size() && j < C.size()) {
// if(B.get(i) <= C.get(j)) A.add(B.get(i++));
// else A.add(C.get(j++));
// }
// while(i < B.size()) A.add(B.get(i++));
// while(j < C.size()) A.add(C.get(j++));
// for(int index = 0;index < A.size();index++) {
// if(index > 0) ps.add(ps.get(index-1) + A.get(index));
// else ps.add(A.get(index)*1l);
// }
// }
// public long query(int left ,int right,int x) {
// if(right < left) return 0l;
// // if(this.lazy != 0) {
// // this.val += (this.r - this.l + 1)*this.lazy;
// // if(this.left != null)this.left.lazy += this.lazy;
// // if(this.right != null) this.right.lazy += this.lazy;
// // this.lazy = 0;
// // }
// if(this.l > right || this.r < left) return 0l;
// if(this.l >= left && this.r <= right) {
// int L =0 , R = this.list.size()-1;
// long ans1 = 0 , ans2 = 0;
// while(L <= R) {
// int mid = (R-L)/2 + L;
// if(this.list.get(mid) >= x) R = mid -1;
// else {
// long elem = mid + 1;
// ans1 = elem*x - this.ps.get(mid);
// L = mid + 1;
// }
// }
// L = 0;R = this.ps.size()-1;
// while(L <= R) {
// int mid = (R-L)/2 + L;
// if(this.ps.get(mid) <= x) L = mid + 1;
// else {
// long elem = this.ps.size()-mid;
// long cut = mid>0?this.ps.get(mid-1):0;
// ans2 = this.ps.get(this.ps.size()-1) - cut - elem*x;
// R = mid - 1;
// }
// }
// return ans1 + ans2;
// }
// return (this.left.query(left , right,x) + this.right.query( left , right,x)) ;
// }
// public void pointUpdate(int index ,int val) {
// if(this.l > index || this.r < index) return;
// if(this.l == this.r && this.l == index) {
// this.val = val;
// return ;
// }
// this.left.pointUpdate(index ,val );
// this.right.pointUpdate(index , val);
// this.val = Math.min(this.left.val , this.right.val);
// }
// public void rangeUpdate(int left , int right, int x) {
// if(left > right) return ;
// if(this.lazy != 0) {
// this.val += 1l*(this.r - this.l + 1)*this.lazy;
// if(this.left != null) this.left.lazy += this.lazy;
// if(this.right != null) this.right.lazy += this.lazy;
// this.lazy = 0;
// }
// if(this.l > right || this.r < left) return;
// if(this.l >= left && this.r <= right) {
// this.val += (this.r - this.l + 1)*x;
// if(this.left != null) this.left.lazy += x;
// if(this.right != null) this.right.lazy += x;
// return;
// }
// this.left.rangeUpdate(left , right , x);
// this.right.rangeUpdate(left , right , x);
// this.val = this.left.val + this.right.val;
// }
// // public long valueAtK(int k) {
// // if(this.l > k || this.r < k) return 0;
// // if(this.l == this.r && this.l == k) {
// // return this.val;
// // }
// // return join(this.left.valueAtK(k) , this.right.valueAtK(k));
// // }
// public int join(int a ,int b) {
// return a + b;
// }
// }
// Proactively collaborate with cross-functional teams, including backend developers and web designers, to optimize usability and deliver exceptional user experiences.
static class SegmentTree2 {
int l , r; // range responsible for
SegmentTree2 left , right;
List<Integer> list;
int val;
SegmentTree2(int l, int r, int a[]) {
// System.out.println("at " + l + " " + r);
this.l = l;
this.r = r;
if (l == r) {
// list.add(a[l]);
this.val = a[l];
return;
}
int mid = l + (r - l) / 2;
this.left = new SegmentTree2(l , mid , a);
this.right = new SegmentTree2(mid + 1 , r, a);
this.val = Math.min(this.left.val , this.right.val);
}
public int query(int left , int right) {
if (this.l > right || this.r < left) return Integer.MAX_VALUE;
if (this.l >= left && this.r <= right) {
return this.val;
}
return Math.min(this.left.query(left , right) , this.right.query(left , right));
}
public void pointUpdate(int index , int val) {
if (this.l > index || this.r < index) return;
if (this.l == this.r && this.l == index) {
this.val = val;
return ;
}
this.left.pointUpdate(index , val );
this.right.pointUpdate(index , val);
this.val = Math.min(this.left.val , this.right.val);
}
// public void rangeUpdate(int left , int right) {
// if(this.l > right || this.r < left) return;
// if(this.l >= left && this.r <= right) {
// this.val += this.r-this.l + 1;
// System.out.println(" now " + this.val);
// return ;
// }
// this.left.rangeUpdate(left , right );
// this.right.rangeUpdate(left , right );
// this.val = this.left.val + this.right.val;
// }
// public long valueAtK(int k) {
// if(this.l > k || this.r < k) return 0;
// if(this.l == this.r && this.l == k) {
// return this.val;
// }
// return join(this.left.valueAtK(k) , this.right.valueAtK(k));
// }
public int join(int a , int b) {
return a + b;
}
}
static class Hash {
long hash[] , mod = (long)1e9 + 7 , powT[] , prime , inverse[];
Hash(char []s) {
prime = 131;
int n = s.length;
powT = new long[n];
hash = new long[n];
inverse = new long[n];
powT[0] = 1;
inverse[n - 1] = pow(pow(prime , n - 1 , mod), mod - 2 , mod);
for (int i = 1; i < n; i++ ) {
powT[i] = (powT[i - 1] * prime) % mod;
}
for (int i = n - 2; i >= 0; i -= 1) {
inverse[i] = (inverse[i + 1] * prime) % mod;
}
hash[0] = (s[0] - 'a' + 1);
for (int i = 1; i < n; i++ ) {
hash[i] = hash[i - 1] + ((s[i] - 'a' + 1) * powT[i]) % mod;
hash[i] %= mod;
}
}
public long hashValue(int l , int r) {
if (l == 0) return hash[r] % mod;
long ans = hash[r] - hash[l - 1] + mod;
ans %= mod;
ans *= inverse[l];
ans %= mod;
return ans;
}
}
static class ConvexHull {
Stack<Integer>stack;
Stack<Integer>stack1;
int n;
Point arr[];
ConvexHull(Point arr[]) {
n = arr.length;
this.arr = arr;
Arrays.sort(arr , (a , b)-> {
if (a.x == b.x) return (int)(b.y - a.y);
return (int)(a.x - b.x);
});
Point min = arr[0];
stack = new Stack<>();
stack1 = new Stack<>();
stack.push(0);
stack1.push(0);
Point ob = new Point(2, 2);
for (int i = 1; i < n; i++) {
if (stack.size() < 2) stack.push(i);
else {
while (stack.size() >= 2) {
int a = stack.pop() , b = stack.pop() , c = i;
int dir = ob.cross(arr[b] , arr[a] , arr[c]);
if (dir < 0) {
stack.push(b);
stack.push(a);
stack.push(c);
break;
}
stack.push(b);
}
if (stack.size() < 2) {
stack.push(i);
}
}
}
for (int i = 1; i < n; i++) {
if (stack1.size() < 2) stack1.push(i);
else {
while (stack1.size() >= 2) {
int a = stack1.pop() , b = stack1.pop() , c = i;
int dir = ob.cross(arr[b] , arr[a] , arr[c]);
if (dir > 0) {
stack1.push(b);
stack1.push(a);
stack1.push(c);
break;
}
stack1.push(b);
}
if (stack1.size() < 2) {
stack1.push(i);
}
}
}
}
public List<Point> getPoints() {
boolean vis[] = new boolean[n];
List<Point> list = new ArrayList<>();
// for(int x : stack) {
// list.add(arr[x]);
// vis[x] = true;
// }
for (int x : stack1) {
// if(vis[x]) continue;
list.add(arr[x]);
}
return list;
}
}
public static class Suffix implements Comparable<Suffix> {
int index;
int rank;
int next;
public Suffix(int ind, int r, int nr) {
index = ind;
rank = r;
next = nr;
}
public int compareTo(Suffix s) {
if (rank != s.rank) return Integer.compare(rank, s.rank);
return Integer.compare(next, s.next);
}
}
static class Point {
long x , y;
Point(long x , long y) {
this.x = x;
this.y = y;
}
public Point sub(Point a, Point b) {
return new Point(a.x - b.x , a.y - b.y);
}
public int cross(Point a , Point b , Point c) {
Point g = sub(b, a) , l = sub(c, b);
long ans = g.y * l.x - g.x * l.y;
if (ans == 0) return 0;
if (ans < 0) return -1;
return 1;
}
}
static class Kattio extends PrintWriter {
private BufferedReader r;
private StringTokenizer st;
// standard input
public Kattio() { this(System.in, System.out); }
public Kattio(InputStream i, OutputStream o) {
super(o);
r = new BufferedReader(new InputStreamReader(i));
}
// USACO-style file input
public Kattio(String problemName) throws IOException {
super(new FileWriter(problemName + ".out"));
r = new BufferedReader(new FileReader(problemName + ".in"));
}
// returns null if no more input
public String next() {
try {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(r.readLine());
return st.nextToken();
} catch (Exception e) { }
return null;
}
public int nextInt() { return Integer.parseInt(next()); }
public double nextDouble() { return Double.parseDouble(next()); }
public long nextLong() { return Long.parseLong(next()); }
}
static HashMap<Integer , List<Integer>> graph;
static Kattio sc = new Kattio();
static long mod = (long)1e9 + 7;
static String endl = "\n" , gap = " ";
static HashMap<Integer , Long> value;
static int size[];
static int parent[] , strength[];
// static long fac[];
static long inv[];
static boolean vis[];
static HashSet<String> guess;
static long primePow[];
static int N;
// static int dis[];
static long p[];
static int endTime[];
static int colx[] = {1, -1, 0, 0};
static int coly[] = {0, 0, 1, -1};
// static int time;
// static Integer dp[][];
// static HashMap<String , Long> dmap;
static long dirpair[][];
static HashSet<String> not;
// static SegmetTree tree;
// static long dis[];
static int gg[];
static long fac[];
static long finv[];
public static void main(String[] args)throws IOException {
int t = 1;
// HashSet<Integer> list = new HashSet<>();
// int MAK = (int)1e5 + 1;
// boolean seive[] = new boolean[MAK];
// Arrays.fill(seive , true);
// seive[1] = false;
// seive[0] = false;
// for (int i = 1; i < MAK; i++) {
// if(seive[i]) {
// for (int j = i+i; j < MAK; j+=i) {
// seive[j] = false;
// }
// }
// }
// for(int i = 2;i < MAK;i++) {
// if(seive[i]) list.add(i);
// }
int test_case = 1;
while (t-- > 0) {
// sc.print("Case #"+(test_case++)+": ");
solve();
}
sc.close();
}
static Boolean dp[];
static String rev(String x) {
return new StringBuilder(x).reverse().toString();
}
static int height[],lca[][];
static long g[];
static long g(long j , long n) {
long res=((n>>(j+1))<<j);
if((n&(1l<<j)) > 0){
res+=((n&((1l<<j)-1))+1);
}
return res;
}
static void solve() throws IOException {
long n = rl() , m = rl();
long ans = 0 , mod = 998244353L;
for(long j = 0;j <= 60;j++) {
if((m&(1l<<j))!=0) {
ans += g(j , n);
ans %= mod;
}
}
System.out.println(ans);
}
// static void dfsLCA(int node, int par,int cur,int a[]) {
// vis[node] = true;
// Queue<Integer> q = new LinkedList<>();
// q.add(node);
// size[node]++;
// lca[node][0] = node;
// while(q.size() > 0) {
// int s = q.size();
// while(s-- > 0) {
// int tp = q.poll();
// for(int j = 0;j <= 30;j++) {
// if((a[tp-1]&(1<<j)) != 0) B[tp][j]++;
// }
// size[tp]++;
// height[tp] = cur;
// for(int next : graph.get(tp)) {
// if(vis[next]) continue;
// lca[next][0] = tp;
// size[next] += size[tp];
// for(int i = 0;i <= 30;i++) {
// if(i > 0)lca[next][i] = lca[lca[next][i-1]][i-1];
// if(B[next][i] = B[tp][i];
// }
// q.add(next);
// vis[next] = true;
// }
// }
// cur++;
// }
// }
static int up(int node , int x,int lca[][]) {
for(int j = 0;j <= 30;j++) {
if((x&(1<<j))!=0) node = lca[node][j];
}
return node;
}
static int getLCA(int a, int b , int height[]) {
if(a == b) return a;
int ha = height[a] , hb = height[b];
// consedireing a as below to b;
int log = 30;
if(hb > ha) {
int tmp = a;
a = b;
b = tmp;
}
int dif = Math.abs(ha - hb);
for(int i = 0;i <= log;i++) {
if((dif&(1<<i)) != 0) {
a = lca[a][i];
}
}
if(a == b) return a;
for(int i = log;i >= 0;i--) {
if(lca[a][i] != lca[b][i]) {
a = lca[a][i];
b = lca[b][i];
}
}
return lca[a][0];
}
public static long lcm(long x , long y) {
return x / gcd(x , y) * y;
}
public static long ncr(int a , int b, long mod) {
if (a == b) return 1l;
return (((fac[a] * inv[b]) % mod) * inv[a - b]) % mod;
}
static long turnOffK(long n, long k) {
return (n & ~(1l << (k)));
}
public static void swap(int i, int j, int arr[]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static long max(long ...a) {
return maxArray(a);
}
public static void swap(int i, int j, long arr[]) {
long temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void swap(int i, int j, char arr[]) {
char temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static String slope(Point a , Point b) {
if ((a.x - b.x) == 0) return "inf";
long n = a.y - b.y;
if (n == 0) return "0";
long m = a.x - b.x;
boolean neg = (n * m < 0 ? true : false);
n = Math.abs(n);
m = Math.abs(m);
long g = gcd(Math.abs(n), Math.abs(m));
n /= g;
m /= g;
String ans = n + "/" + m;
if (neg) ans = "-" + ans;
return ans;
}
public static int lis(int A[], int size) {
int[] tailTable = new int[size];
int len;
tailTable[0] = A[0];
len = 1;
for (int i = 1; i < size; i++) {
if (A[i] < tailTable[0]) tailTable[0] = A[i];
else if (A[i] > tailTable[len - 1]) tailTable[len++] = A[i];
else tailTable[CeilIndex(tailTable, -1, len - 1, A[i])] = A[i];
}
return len;
}
public static int CeilIndex(int A[], int l, int r, int key) {
while (r - l > 1) {
int m = l + (r - l) / 2;
if (A[m] >= key) r = m;
else l = m;
}
return r;
}
public static int find(int node) {
if (node == parent[node]) return node;
return parent[node] = find(parent[node]);
}
public static void merge(int a , int b ) {
a = find(a);
b = find(b);
if (a == b) return;
long mod = (long)1e9 + 7;
if (size[a] >= size[b]) {
parent[b] = a;
size[a] += size[b];
} else {
parent[a] = b;
size[b] += size[a];
}
}
public static void processPowerOfP(long arr[]) {
int n = arr.length;
arr[0] = 1;
long mod = (long)1e9 + 7;
for (int i = 1; i < n; i++) {
arr[i] = arr[i - 1] * 51;
arr[i] %= mod;
}
}
public static long hashValue(char s[]) {
int n = s.length;
long powerOfP[] = new long[n];
processPowerOfP(powerOfP);
long ans = 0;
long mod = (long)1e9 + 7;
for (int i = 0; i < n; i++) {
ans += (s[i] - 'a' + 1) * powerOfP[i];
ans %= mod;
}
return ans;
}
public static String getSlope(int a , int b, int x, int y) {
if (a - x == 0) return "inf";
if (b - y == 0) return "0";
int n = b - y , d = a - x;
boolean neg = (n * d < 0);
n = Math.abs(n);
d = Math.abs(d);
return (neg ? "-" : "") + ((n / gcd(n , d)) + "/" + (d / gcd(n , d)));
}
public static boolean collinearr(long a[] , long b[] , long c[]) {
return (b[1] - a[1]) * (b[0] - c[0]) == (b[0] - a[0]) * (b[1] - c[1]);
}
public static boolean isSquare(long sum) {
long root = (int)Math.sqrt(sum);
return root * root == sum;
}
public static int[] suffixArray(String s) {
int n = s.length();
Suffix[] su = new Suffix[n];
for (int i = 0; i < n; i++) {
su[i] = new Suffix(i, s.charAt(i) - '$', 0);
}
for (int i = 0; i < n; i++)
su[i].next = (i + 1 < n ? su[i + 1].rank : -1);
Arrays.sort(su);
int[] ind = new int[n];
for (int length = 4; length < 2 * n; length <<= 1) {
int rank = 0, prev = su[0].rank;
su[0].rank = rank;
ind[su[0].index] = 0;
for (int i = 1; i < n; i++) {
if (su[i].rank == prev && su[i].next == su[i - 1].next) {
prev = su[i].rank;
su[i].rank = rank;
} else {
prev = su[i].rank;
su[i].rank = ++rank;
}
ind[su[i].index] = i;
}
for (int i = 0; i < n; i++) {
int nextP = su[i].index + length / 2;
su[i].next = nextP < n ?
su[ind[nextP]].rank : -1;
}
Arrays.sort(su);
}
int[] suf = new int[n];
for (int i = 0; i < n; i++)
suf[i] = su[i].index;
return suf;
}
public static boolean isPalindrome(String s) {
int i = 0 , j = s.length() - 1;
while (i <= j && s.charAt(i) == s.charAt(j)) {
i++;
j--;
}
return i > j;
}
public static void getPerm(int n , char arr[] , String s , List<String>list) {
if (n == 0) {
list.add(s);
return;
}
for (char ch : arr) {
getPerm(n - 1 , arr , s + ch, list);
}
}
public static double getDis(int arr[][] , int x, int y) {
double ans = 0.0;
for (int a[] : arr) {
int x1 = a[0] , y1 = a[1];
ans += Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
}
return ans;
}
public static void primeDivisor(HashMap<Long , Long >cnt , long num) {
for (long i = 2; i * i <= num; i++) {
while (num % i == 0) {
cnt.put(i , (cnt.getOrDefault(i, 0l) + 1));
num /= i;
}
}
if (num > 2) {
cnt.put(num , (cnt.getOrDefault(num, 0l) + 1));
}
}
public static boolean isSubsequene(char a[], char b[] ) {
int i = 0 , j = 0;
while (i < a.length && j < b.length) {
if (a[i] == b[j]) {
j++;
}
i++;
}
return j >= b.length;
}
public static long fib(int n , long M) {
if (n == 0) {
return 0;
} else if (n == 1) {
return 1;
} else {
long[][] mat = {{1, 1}, {1, 0}};
mat = pow(mat, n - 1 , M);
return mat[0][0];
}
}
public static long[][] pow(long[][] mat, int n , long M) {
if (n == 1) return mat;
else if (n % 2 == 0) return pow(mul(mat, mat , M), n / 2 , M);
else return mul(pow(mul(mat, mat, M), n / 2, M), mat , M);
}
static long[][] mul(long[][] p, long[][] q, long M) {
long a = (p[0][0] * q[0][0] + p[0][1] * q[1][0]) % M;
long b = (p[0][0] * q[0][1] + p[0][1] * q[1][1]) % M;
long c = (p[1][0] * q[0][0] + p[1][1] * q[1][0]) % M;
long d = (p[1][0] * q[0][1] + p[1][1] * q[1][1]) % M;
return new long[][] {{a, b}, {c, d}};
}
public static long[] kdane(long arr[]) {
int n = arr.length;
long dp[] = new long[n];
dp[0] = arr[0];
long ans = dp[0];
for (int i = 1; i < n; i++) {
dp[i] = Math.max(dp[i - 1] + arr[i] , arr[i]);
ans = Math.max(ans , dp[i]);
}
return dp;
}
public static void reverse(long arr[]) {
int i = 0 , j = arr.length - 1;
while (i < j) {
swap(i , j , arr);
i++;
j--;
}
}
public static void reverse(int arr[]) {
int i = 0 , j = arr.length - 1;
while (i < j) {
swap(i , j , arr);
i++;
j--;
}
}
public static int maxArray(int arr[]) {
int ans = arr[0] , n = arr.length;
for (int i = 1; i < n; i++) {
ans = Math.max(ans , arr[i]);
}
return ans;
}
public static long maxArray(long arr[]) {
long ans = arr[0];
int n = arr.length;
for (int i = 1; i < n; i++) {
ans = Math.max(ans , arr[i]);
}
return ans;
}
public static int minArray(int arr[]) {
int ans = arr[0] , n = arr.length;
for (int i = 0; i < n; i++ ) {
ans = Math.min(ans , arr[i]);
}
return ans;
}
public static long minArray(long arr[]) {
long ans = arr[0];
int n = arr.length;
for (int i = 0; i < n; i++ ) {
ans = Math.min(ans , arr[i]);
}
return ans;
}
public static int sumArray(int arr[]) {
int ans = 0;
for (int x : arr) {
ans += x;
}
return ans;
}
public static long sumArray(long arr[]) {
long ans = 0;
for (long x : arr) {
ans += x;
}
return ans;
}
public static long rl() {
return sc.nextLong();
}
public static char[] rac() {
return sc.next().toCharArray();
}
public static String rs() {
return sc.next();
}
public static char rc() {
return sc.next().charAt(0);
}
public static int [] rai(int n) {
int ans[] = new int[n];
for (int i = 0; i < n; i++) {
ans[i] = sc.nextInt();
}
return ans;
}
public static long [] ral(int n) {
long ans[] = new long[n];
for (int i = 0; i < n; i++) {
ans[i] = sc.nextLong();
}
return ans;
}
public static int ri() {
return sc.nextInt();
}
public static int getValue(int num ) {
int ans = 0;
while (num > 0) {
ans++;
num = num & (num - 1);
}
return ans;
}
public static boolean isValid(int x , int y , int n, char arr[][], boolean visited[][][][]) {
return x >= 0 && x < n && y >= 0 && y < n && !(arr[x][y] == '#');
}
// for calculation set bits from 1 to N
// ith bit = n/(2^(i + 1))*(2^(i))
// n%(1<<(i+1)) >= 2^i: ans += mod + 1 - 2^i
static long inverse(long a , long mod) {
return pow(a , mod - 2 , mod);
}
public static long pow(long a , long b , long mod) {
if (b == 1) return a;
if (b == 0) return 1;
long ans = pow(a , b / 2 , mod) % mod;
if (b % 2 == 0) {
return (ans * ans) % mod;
} else {
return ((ans * ans) % mod * a) % mod;
}
}
public static long pow(long a , long b ) {
if (b == 1) return a;
if (b == 0) return 1;
long ans = pow(a , b / 2);
if (b % 2 == 0) {
return (ans * ans);
} else {
return ((ans * ans) * a);
}
}
public static boolean isVowel(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') return true;
if ((ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U')) return true;
return false;
}
public static int[] readarr()throws IOException {
int n = sc.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
return arr;
}
public static boolean isPowerOfTwo (long x) {
return x != 0 && ((x & (x - 1)) == 0);
}
public static boolean isPrime(long num) {
if (num == 1) return false;
if (num <= 3) return true;
if (num % 2 == 0 || num % 3 == 0) return false;
for (long i = 5; i * i <= num; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) return false;
}
return true;
}
public static boolean isPrime(int num) {
// System.out.println("At pr " + num);
if (num == 1) return false;
if (num <= 3) return true;
if (num % 2 == 0 || num % 3 == 0) return false;
for (int i = 5; i * i <= num; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) return false;
}
return true;
}
static long getSum(int a , int b , long arr[]) {
if(b < a) return 0;
long ans = arr[b];
if(a > 0)ans -= arr[a-1];
return ans;
}
public static long gcd(long a , long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static int gcd(int a , int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static int get_gcd(int a , int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static long get_gcd(long a , long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
}
// Fenwick tree for range update and range sum
class Fenwick {
public int[] initalize(int n) {
int[] BITree = new int[n + 1];
for (int i = 1; i <= n; i++) BITree[i] = 0;
return BITree;
}
public long getSum(int BITree[], int index) {
long sum = 0;
index = index + 1;
while (index > 0) {
sum += BITree[index];
index -= index & (-index);
}
return sum;
}
public void updateBIT(int BITree[], int n, int index, int val) {
index = index + 1;
while (index <= n) {
BITree[index] += val;
index += index & (-index);
}
}
public long sum(int x, int BITTree1[], int BITTree2[]) {
return (getSum(BITTree1, x) * x) - getSum(BITTree2, x);
}
public void updateRange(int BITTree1[], int BITTree2[], int n, int val, int l, int r) {
updateBIT(BITTree1, n, l, val);
updateBIT(BITTree1, n, r + 1, -val);
updateBIT(BITTree2, n, l, val * (l - 1));
updateBIT(BITTree2, n, r + 1, -val * r);
}
public long rangeSum(int l, int r, int BITTree1[], int BITTree2[]) {
return sum(r, BITTree1, BITTree2) - sum(l - 1, BITTree1, BITTree2);
}
public int[] constructBITree(int n) {
int[] BITree = new int[n + 1];
for (int i = 1; i <= n; i++) BITree[i] = 0;
return BITree;
}
} | ConDefects/ConDefects/Code/abc356_d/Java/54154725 |
condefects-java_data_1656 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
long n = sc.nextLong();
long m = sc.nextLong();
long l = 60;
long mod = 998244353;
long ans = 0;
for(long i = 0; i < l; i++) {
if((m >> i & 1) > 0) {
long k = (n + 1) / (2L << i);
long r = (n + 1) % (2L << i);
ans += k << i;
ans += Math.max(r - 1L << i, 0);
ans %= mod;
}
}
System.out.println(ans);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
long n = sc.nextLong();
long m = sc.nextLong();
long l = 60;
long mod = 998244353;
long ans = 0;
for(long i = 0; i < l; i++) {
if((m >> i & 1) > 0) {
long k = (n + 1) / (2L << i);
long r = (n + 1) % (2L << i);
ans += k << i;
ans += Math.max(r - (1L << i), 0);
ans %= mod;
}
}
System.out.println(ans);
}
}
}
| ConDefects/ConDefects/Code/abc356_d/Java/54234617 |
condefects-java_data_1657 | import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = l(sc);
long m = l(sc);
sc.close();
long p = 998244353L;
long count = 0L;
long base = 1;
while (m > 0) {
if (m % 2 == 1) {
count += n / (2 * base) * base + (long)Math.max(0, (n % (2 * base) - base));
}
m /= 2;
count %= p;
base *= 2;
}
p(count);
}
public static String s(Scanner sc) {
return sc.next();
}
public static int i(Scanner sc) {
return Integer.parseInt(sc.next());
}
public static long l(Scanner sc) {
return Long.parseLong(sc.next());
}
public static void p(Object o) {
System.out.print(o);
}
public static void pl(Object o) {
System.out.println(o);
}
public static void sortI(List<Integer>... list) {
for (List<Integer> c : list) {
Collections.sort(c);
}
}
public static void sortL(List<Long>... list) {
for (List<Long> c : list) {
Collections.sort(c);
}
}
public static void reverseI(List<Integer>... list) {
for (List<Integer> c : list) {
Collections.reverse(c);
}
}
public static void reverseL(List<Long>... list) {
for (List<Long> c : list) {
Collections.reverse(c);
}
}
public static int gcd(int n, int m) {
int a = Math.abs(n);
int b = Math.abs(m);
if (a < b) {
int c = a;
a = b;
b = c;
}
int r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
public static long gcd(long n, long m) {
long a = Math.abs(n);
long b = Math.abs(m);
if (a < b) {
long c = a;
a = b;
b = c;
}
long r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
//base^index mod p を返す
public static long powMod(long base, long index, long p) {
long ans = 1;
long a = base;
while (index >= 1) {
if (index % 2 == 1) {
ans *= a;
ans %= p;
}
a *= a;
a %= p;
index /= 2;
}
return ans % p;
}
}
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = l(sc);
long m = l(sc);
sc.close();
long p = 998244353L;
long count = 0L;
long base = 1;
while (m > 0) {
if (m % 2 == 1) {
count += n / (2 * base) * base + (long)Math.max(0, (n % (2 * base) - base + 1));
}
m /= 2;
count %= p;
base *= 2;
}
p(count);
}
public static String s(Scanner sc) {
return sc.next();
}
public static int i(Scanner sc) {
return Integer.parseInt(sc.next());
}
public static long l(Scanner sc) {
return Long.parseLong(sc.next());
}
public static void p(Object o) {
System.out.print(o);
}
public static void pl(Object o) {
System.out.println(o);
}
public static void sortI(List<Integer>... list) {
for (List<Integer> c : list) {
Collections.sort(c);
}
}
public static void sortL(List<Long>... list) {
for (List<Long> c : list) {
Collections.sort(c);
}
}
public static void reverseI(List<Integer>... list) {
for (List<Integer> c : list) {
Collections.reverse(c);
}
}
public static void reverseL(List<Long>... list) {
for (List<Long> c : list) {
Collections.reverse(c);
}
}
public static int gcd(int n, int m) {
int a = Math.abs(n);
int b = Math.abs(m);
if (a < b) {
int c = a;
a = b;
b = c;
}
int r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
public static long gcd(long n, long m) {
long a = Math.abs(n);
long b = Math.abs(m);
if (a < b) {
long c = a;
a = b;
b = c;
}
long r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
//base^index mod p を返す
public static long powMod(long base, long index, long p) {
long ans = 1;
long a = base;
while (index >= 1) {
if (index % 2 == 1) {
ans *= a;
ans %= p;
}
a *= a;
a %= p;
index /= 2;
}
return ans % p;
}
}
| ConDefects/ConDefects/Code/abc356_d/Java/55006049 |
condefects-java_data_1658 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
long n = sc.nextLong();
long m = sc.nextLong();
long res = 0;
final long mod = 998244353;
for(long i = 0; i < 60; i++) {
if((m & 1 << i) > 0) {
res += f(i, n);
res %= mod;
}
}
System.out.println(res);
}
}
static long f(long j, long n) {
long p2 = 1L << j;
long k = n /(2 * p2);
long res = k * p2;
long l = n % (2 * p2);
if(l >= p2) {
res += (l - p2 + 1);
}
return res;
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
long n = sc.nextLong();
long m = sc.nextLong();
long res = 0;
final long mod = 998244353;
for(long i = 0; i < 60; i++) {
if((m & 1L << i) > 0) {
res += f(i, n);
res %= mod;
}
}
System.out.println(res);
}
}
static long f(long j, long n) {
long p2 = 1L << j;
long k = n /(2 * p2);
long res = k * p2;
long l = n % (2 * p2);
if(l >= p2) {
res += (l - p2 + 1);
}
return res;
}
}
| ConDefects/ConDefects/Code/abc356_d/Java/54156635 |
condefects-java_data_1659 | import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
static long mod = 1000000007;
static long INF = Long.MAX_VALUE;
static String Yes = "Yes";
static String No = "No";
static String LF = "\n";
static String Grid[];
static Queue<Long> AD = new ArrayDeque<Long>();
static Queue<Long> PQ = new PriorityQueue<Long>();
static TreeSet<Integer> TS = new TreeSet<Integer>();
static LinkedHashMap<Long, Long> LHM = new LinkedHashMap<Long, Long>();
static TreeMap<Long, Long> Imos = new TreeMap<Long, Long>();
static class oneNodeList extends HashMap<Integer, Integer>{}
static oneNodeList[] edgeList;
static long DPDistance[];
static StringBuffer sb = new StringBuffer();
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
// AtCoder_Temp
int N = Integer.parseInt(sc.next());
int A[] = new int[N+1];
for(int i=1; i<=N; i++) {
A[i] = Integer.parseInt(sc.next());
}
int cnt = 0;
long Ans = 0;
// 一致の組
for(int i=1; i<=N; i++) {
if(A[i] == i) {
cnt++;
A[i] = 0;
}
}
Ans += (cnt*(cnt-1))/2;
// ペアの組
for(int i=1; i<=N; i++) {
if(A[i] != 0) {
if(A[A[i]] == i) {
Ans++;
A[A[i]] = 0;
A[i] = 0;
}
}
}
System.out.println(Ans);
// Scannerクラスのインスタンスをクローズ
sc.close();
}
/**
* 素因数分解
* @param N 合成数
*/
static void PrimeFactorization() {
// AtCoder_Temp
long N = Long.parseLong(sc.next());
Double NSqrt = Math.sqrt(N);
HashMap<Long, Long> HM = new HashMap<Long, Long>();
for(long i=2; i<=NSqrt; i++) {
while(N%i == 0) {
if(HM.containsKey(i)) {
HM.put(i, HM.get(i)+1);
} else {
HM.put(i, (long) 1);
}
N /= i;
}
}
if(N != 1) {
if(HM.containsKey(N)) {
HM.put(N, HM.get(N)+1);
} else {
HM.put(N, (long) 1);
}
}
long Ans = 1;
/*
for(Entry<Long, Long> e : HM.entrySet() ) {
long K = e.getKey();
long V = e.getValue();
}
*/
System.out.println(Ans);
}
/**
* HashMap in HashMap
* @param N 要素数
*/
static void MapInMap(int N) {
HashMap<Integer, HashMap<Integer, Integer>> B = new HashMap<Integer, HashMap<Integer, Integer>>();
for(int i=0; i<N; i++) {
int AWk = Integer.parseInt(sc.next());
if(B.containsKey(AWk)) {
HashMap<Integer, Integer> HM = B.get(AWk);
HM.put(HM.size()+1, i+1);
B.put(AWk, HM);
} else {
HashMap<Integer, Integer> HM = new HashMap<Integer, Integer>();
HM.put(1, i+1);
B.put(AWk, HM);
}
}
}
/**
* 順列全探索
* @param N 要素数
*/
static void SearchPermutation(int N) {
/* 順列格納用配列 */
var arr = new int[N];
for (int i=0; i<N; i++) {
arr[i] = i;
}
/* 順列全探索 */
do {
// ここにロジックを追加
} while (nextPermutation(arr));
}
/* 順列 */
public static boolean nextPermutation(int[] arr) {
int len = arr.length;
int left = len - 2;
while (left >= 0 && arr[left] >= arr[left+1]) left--;
if (left < 0) return false;
int right = len - 1;
while (arr[left] >= arr[right]) right--;
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right = len - 1;
while (left < right) {
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right--;
}
return true;
}
/**
* 三角形の面積
*/
static double GetTriangleArea(double AX,double AY,double BX,double BY,double CX,double CY) {
return (((CX-BX)*(AY-BY))-((AX-BX)*(CY-BY)))*0.5;
}
/**
* いもす法（1次元）セットアップ
* @param N 要素数
*/
static void ImosSetUp1D(int N) {
for(int i=0; i<N; i++) {
long A = Long.parseLong(sc.next());
long B = Long.parseLong(sc.next());
long P = Long.parseLong(sc.next());
if(Imos.containsKey(A)) {
Imos.put(A, Imos.get(A)+P);
} else {
Imos.put(A, P);
}
if(Imos.containsKey(B)) {
Imos.put(B, Imos.get(B)-P);
} else {
Imos.put(B, -P);
}
}
}
/**
* いもす法（1次元）シミュレートロジック
*/
static void ImosSimulate1D() {
/*
long nowD = 1;
long nowP = 0;
for(Entry<Long, Long> e : Imos.entrySet() ) {
long nextD = e.getKey();
long addP = e.getValue();
// 何かしらのロジック
nowD = nextD;
nowP += addP;
}
*/
}
/**
* グラフの生成（隣接リスト）
* @param N 頂点数
* @param M 辺の数
*/
static void makeGraph2(int N, long M) {
edgeList = new oneNodeList[N];
for(int i=0; i<N; i++) {
edgeList[i] = new oneNodeList();
}
for(long i=0; i<M; i++) {
int A = Integer.parseInt(sc.next())-1;
int B = Integer.parseInt(sc.next())-1;
edgeList[A].put(B, 1);
edgeList[B].put(A, 1); // 無向グラフの場合、逆方向にも張る
}
}
/**
* DFS（深さ優先探索）（隣接リスト）
* @param v チェック対象の座標
*/
static void DFS2(int v) {
for(Map.Entry<Integer, Integer> entry : edgeList[v].entrySet()) {
if(DPDistance[entry.getKey()] < 0) {
DPDistance[entry.getKey()] = DPDistance[v] + entry.getValue();
DFS2(entry.getKey());
}
}
}
/**
* BFS（幅優先探索）（隣接リスト）
* @param S 開始座標
*/
static void BFS2(int N, int S) {
Deque<Integer> q = new ArrayDeque<>();
DPDistance = new long[N];
Arrays.fill(DPDistance, INF);
DPDistance[S] = 0;
q.add(S);
while(q.size() > 0) {
int now = q.poll();
for(Map.Entry<Integer, Integer> entry : edgeList[now].entrySet()) {
DPDistance[entry.getKey()] = Math.min(DPDistance[entry.getKey()], DPDistance[now] + entry.getValue());
q.add(entry.getKey());
}
edgeList[now].clear();
}
}
/**
* ダイクストラ法（隣接リスト）
* ※頂点の距離のみ実装済み
* ※辺の重み未対応
*
* @param N 頂点数
* @param S 開始頂点
*/
static void dijkstra(int N, int S) {
DPDistance = new long[N];
boolean FIX[] = new boolean[N];
Arrays.fill(DPDistance, INF);
Arrays.fill(FIX, false);
DPDistance[S] = 0;
for(;;) {
long min = INF; // 最小の重み
int now = -1; // 今回処理する頂点
// 処理対象の頂点を決める
for(int i=0; i<N; i++) {
if(!FIX[i]) {
if(min > DPDistance[i]) {
min = DPDistance[i];
now = i;
}
}
}
// 頂点が決まらなかったら処理終了
if(now < 0) {
break;
}
// 処理対象の頂点を確定済み状態にする
FIX[now] = true;
for(int i=0; i < edgeList[now].size(); i++) {
int next = edgeList[now].get(i);
if(!FIX[next]) {
DPDistance[next] = Math.min(DPDistance[next], DPDistance[now] + 1);
}
}
}
}
/**
* bit全探索
* @param N 要素数
*/
static long bitSearch(int N) {
long DP = INF;
// 全探索パターン数
long Pattern = (long) Math.pow(2, N);
// 全探索パターン数分ループ
for(long i=0; i<Pattern; i++) {
// j番目の要素のbit判定
for(long j=0; j<N; j++) {
if((1&i>>j) == 1) {
// j番目の要素がONの場合
// TODO ONの場合のコードを実装
} else {
// TODO OFFの場合のコードを実装
}
}
// TODO DPの判定を実装
}
// 求めたDPの返却
return DP;
}
/**
* ビット演算(AND)
* @param A
* @param B
* @return
*/
static long bitAND(long A, long B) {
return A&B;
}
/**
* ビット演算(OR)
* @param A
* @param B
* @return
*/
static long bitOR(long A, long B) {
return A|B;
}
/**
* ビット演算(XOR)
* @param A
* @param B
* @return
*/
static long bitXOR(long A, long B) {
return A^B;
}
/**
* ビット演算(NOT)
* @param A
* @param B
* @return
*/
static long bitNOT(long A) {
return ~A;
}
/**
* 小さい順に約数を列挙する
* @param N 約数を求めたい数値
* @param sqrtN Nの平方根（あらかじめsqrtで求めておくこと）
* @param Start 集計を開始する値（1を設定して呼び出す）
*/
static void makeDivisors(long N, double sqrtN, long Start) {
while(Start <= sqrtN) {
if(N%Start == 0) {
System.out.println(Start);
makeDivisors(N,sqrtN,Start+1);
if(Start * Start != N) {
System.out.println(N/Start);
}
break;
}
Start++;
}
}
/**
* 壁座標が与えられるパターンのとき、グリッドを作成する
* @param H
* @param W
* @param N
* @return なし
*/
public static void makeGrid(int H, int W, int N) {
Grid = new String[H+2];
// グリッドの初期化
for(int i=0; i<H+1; i++) {
Grid[i] = "#";
}
for(int i=1; i<W+2; i++) {
Grid[0] += "#";
for(int j=1; j<H+1; j++) {
Grid[j] += ".";
}
Grid[H+1] += "#";
}
for(int i=0; i<H+1; i++) {
Grid[i] += "#";
}
// 与えられた座標を壁にする
for(int i=0; i<N; i++) {
int r = sc.nextInt();
int c = sc.nextInt();
Grid[r] = Grid[r].substring(0, c) + "#" + Grid[r].substring(c+2);
}
}
/**
* 最小公倍数を求める
* @param A
* @param B
* @return lcm
*/
public static long lcm(long A, long B) {
return A * B / gcd(A,B);
}
/**
* 最大公約数を求める
* @param A
* @param B
* @return gcd
*/
public static long gcd(long A, long B) {
return gcdMain(Math.max(A, B), Math.min(A, B));
}
public static long gcdMain(long numBig, long numSmall) {
if(numSmall==0) return numBig;
else return gcd(numSmall, numBig%numSmall);
}
/**
* 組み合わせの数を求める
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk
*/
public static long nCk(long n,long k) {
long ret = 1;
long min = Math.min(k, n-k);
for(long i=1; i<=min; i++) {
ret *= n+1-i;
ret /= i;
}
return ret;
}
/**
* 組み合わせの数を求める（MOD処理含む）
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk mod M (M must be prime number) O(min(k,n-k)*logM)
*/
public static int nCk(int n,int k,int M) {
long ret = 1;
int min = Math.min(k, n-k);
for(int i=1;i<=min;i++) {
ret = (ret * modPow(i,M-2,M)) % M;
}
for(int i=n-min+1;i<=n;i++) {
ret = (ret * i) % M;
}
return (int)ret;
}
/**
* 累乗計算（MOD処理含む）
* @param a
* @param b
* @param M
* @return a^b mod M O(logB)
*/
public static long modPow(long a,long b,int M) {
long ret = 1;
if(b > 0) {
TreeMap<Long, Long> memo = new TreeMap<Long, Long>(Collections.reverseOrder());
memo.put((long) 1, a%M);
long PowTmp = 1;
while(PowTmp < b) {
memo.put(PowTmp*2, (memo.get(PowTmp)*memo.get(PowTmp))%M);
PowTmp *= 2;
}
ret = a;
b--;
for(Entry<Long, Long> e : memo.entrySet() ) {
long nowB = e.getKey();
long nowA = e.getValue();
while(b - nowB >= 0) {
ret *= nowA;
ret %= M;
b -= nowB;
}
}
}
return ret;
}
}
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
static long mod = 1000000007;
static long INF = Long.MAX_VALUE;
static String Yes = "Yes";
static String No = "No";
static String LF = "\n";
static String Grid[];
static Queue<Long> AD = new ArrayDeque<Long>();
static Queue<Long> PQ = new PriorityQueue<Long>();
static TreeSet<Integer> TS = new TreeSet<Integer>();
static LinkedHashMap<Long, Long> LHM = new LinkedHashMap<Long, Long>();
static TreeMap<Long, Long> Imos = new TreeMap<Long, Long>();
static class oneNodeList extends HashMap<Integer, Integer>{}
static oneNodeList[] edgeList;
static long DPDistance[];
static StringBuffer sb = new StringBuffer();
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
// AtCoder_Temp
int N = Integer.parseInt(sc.next());
int A[] = new int[N+1];
for(int i=1; i<=N; i++) {
A[i] = Integer.parseInt(sc.next());
}
long cnt = 0;
long Ans = 0;
// 一致の組
for(int i=1; i<=N; i++) {
if(A[i] == i) {
cnt++;
A[i] = 0;
}
}
Ans += (cnt*(cnt-1))/2;
// ペアの組
for(int i=1; i<=N; i++) {
if(A[i] != 0) {
if(A[A[i]] == i) {
Ans++;
A[A[i]] = 0;
A[i] = 0;
}
}
}
System.out.println(Ans);
// Scannerクラスのインスタンスをクローズ
sc.close();
}
/**
* 素因数分解
* @param N 合成数
*/
static void PrimeFactorization() {
// AtCoder_Temp
long N = Long.parseLong(sc.next());
Double NSqrt = Math.sqrt(N);
HashMap<Long, Long> HM = new HashMap<Long, Long>();
for(long i=2; i<=NSqrt; i++) {
while(N%i == 0) {
if(HM.containsKey(i)) {
HM.put(i, HM.get(i)+1);
} else {
HM.put(i, (long) 1);
}
N /= i;
}
}
if(N != 1) {
if(HM.containsKey(N)) {
HM.put(N, HM.get(N)+1);
} else {
HM.put(N, (long) 1);
}
}
long Ans = 1;
/*
for(Entry<Long, Long> e : HM.entrySet() ) {
long K = e.getKey();
long V = e.getValue();
}
*/
System.out.println(Ans);
}
/**
* HashMap in HashMap
* @param N 要素数
*/
static void MapInMap(int N) {
HashMap<Integer, HashMap<Integer, Integer>> B = new HashMap<Integer, HashMap<Integer, Integer>>();
for(int i=0; i<N; i++) {
int AWk = Integer.parseInt(sc.next());
if(B.containsKey(AWk)) {
HashMap<Integer, Integer> HM = B.get(AWk);
HM.put(HM.size()+1, i+1);
B.put(AWk, HM);
} else {
HashMap<Integer, Integer> HM = new HashMap<Integer, Integer>();
HM.put(1, i+1);
B.put(AWk, HM);
}
}
}
/**
* 順列全探索
* @param N 要素数
*/
static void SearchPermutation(int N) {
/* 順列格納用配列 */
var arr = new int[N];
for (int i=0; i<N; i++) {
arr[i] = i;
}
/* 順列全探索 */
do {
// ここにロジックを追加
} while (nextPermutation(arr));
}
/* 順列 */
public static boolean nextPermutation(int[] arr) {
int len = arr.length;
int left = len - 2;
while (left >= 0 && arr[left] >= arr[left+1]) left--;
if (left < 0) return false;
int right = len - 1;
while (arr[left] >= arr[right]) right--;
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right = len - 1;
while (left < right) {
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right--;
}
return true;
}
/**
* 三角形の面積
*/
static double GetTriangleArea(double AX,double AY,double BX,double BY,double CX,double CY) {
return (((CX-BX)*(AY-BY))-((AX-BX)*(CY-BY)))*0.5;
}
/**
* いもす法（1次元）セットアップ
* @param N 要素数
*/
static void ImosSetUp1D(int N) {
for(int i=0; i<N; i++) {
long A = Long.parseLong(sc.next());
long B = Long.parseLong(sc.next());
long P = Long.parseLong(sc.next());
if(Imos.containsKey(A)) {
Imos.put(A, Imos.get(A)+P);
} else {
Imos.put(A, P);
}
if(Imos.containsKey(B)) {
Imos.put(B, Imos.get(B)-P);
} else {
Imos.put(B, -P);
}
}
}
/**
* いもす法（1次元）シミュレートロジック
*/
static void ImosSimulate1D() {
/*
long nowD = 1;
long nowP = 0;
for(Entry<Long, Long> e : Imos.entrySet() ) {
long nextD = e.getKey();
long addP = e.getValue();
// 何かしらのロジック
nowD = nextD;
nowP += addP;
}
*/
}
/**
* グラフの生成（隣接リスト）
* @param N 頂点数
* @param M 辺の数
*/
static void makeGraph2(int N, long M) {
edgeList = new oneNodeList[N];
for(int i=0; i<N; i++) {
edgeList[i] = new oneNodeList();
}
for(long i=0; i<M; i++) {
int A = Integer.parseInt(sc.next())-1;
int B = Integer.parseInt(sc.next())-1;
edgeList[A].put(B, 1);
edgeList[B].put(A, 1); // 無向グラフの場合、逆方向にも張る
}
}
/**
* DFS（深さ優先探索）（隣接リスト）
* @param v チェック対象の座標
*/
static void DFS2(int v) {
for(Map.Entry<Integer, Integer> entry : edgeList[v].entrySet()) {
if(DPDistance[entry.getKey()] < 0) {
DPDistance[entry.getKey()] = DPDistance[v] + entry.getValue();
DFS2(entry.getKey());
}
}
}
/**
* BFS（幅優先探索）（隣接リスト）
* @param S 開始座標
*/
static void BFS2(int N, int S) {
Deque<Integer> q = new ArrayDeque<>();
DPDistance = new long[N];
Arrays.fill(DPDistance, INF);
DPDistance[S] = 0;
q.add(S);
while(q.size() > 0) {
int now = q.poll();
for(Map.Entry<Integer, Integer> entry : edgeList[now].entrySet()) {
DPDistance[entry.getKey()] = Math.min(DPDistance[entry.getKey()], DPDistance[now] + entry.getValue());
q.add(entry.getKey());
}
edgeList[now].clear();
}
}
/**
* ダイクストラ法（隣接リスト）
* ※頂点の距離のみ実装済み
* ※辺の重み未対応
*
* @param N 頂点数
* @param S 開始頂点
*/
static void dijkstra(int N, int S) {
DPDistance = new long[N];
boolean FIX[] = new boolean[N];
Arrays.fill(DPDistance, INF);
Arrays.fill(FIX, false);
DPDistance[S] = 0;
for(;;) {
long min = INF; // 最小の重み
int now = -1; // 今回処理する頂点
// 処理対象の頂点を決める
for(int i=0; i<N; i++) {
if(!FIX[i]) {
if(min > DPDistance[i]) {
min = DPDistance[i];
now = i;
}
}
}
// 頂点が決まらなかったら処理終了
if(now < 0) {
break;
}
// 処理対象の頂点を確定済み状態にする
FIX[now] = true;
for(int i=0; i < edgeList[now].size(); i++) {
int next = edgeList[now].get(i);
if(!FIX[next]) {
DPDistance[next] = Math.min(DPDistance[next], DPDistance[now] + 1);
}
}
}
}
/**
* bit全探索
* @param N 要素数
*/
static long bitSearch(int N) {
long DP = INF;
// 全探索パターン数
long Pattern = (long) Math.pow(2, N);
// 全探索パターン数分ループ
for(long i=0; i<Pattern; i++) {
// j番目の要素のbit判定
for(long j=0; j<N; j++) {
if((1&i>>j) == 1) {
// j番目の要素がONの場合
// TODO ONの場合のコードを実装
} else {
// TODO OFFの場合のコードを実装
}
}
// TODO DPの判定を実装
}
// 求めたDPの返却
return DP;
}
/**
* ビット演算(AND)
* @param A
* @param B
* @return
*/
static long bitAND(long A, long B) {
return A&B;
}
/**
* ビット演算(OR)
* @param A
* @param B
* @return
*/
static long bitOR(long A, long B) {
return A|B;
}
/**
* ビット演算(XOR)
* @param A
* @param B
* @return
*/
static long bitXOR(long A, long B) {
return A^B;
}
/**
* ビット演算(NOT)
* @param A
* @param B
* @return
*/
static long bitNOT(long A) {
return ~A;
}
/**
* 小さい順に約数を列挙する
* @param N 約数を求めたい数値
* @param sqrtN Nの平方根（あらかじめsqrtで求めておくこと）
* @param Start 集計を開始する値（1を設定して呼び出す）
*/
static void makeDivisors(long N, double sqrtN, long Start) {
while(Start <= sqrtN) {
if(N%Start == 0) {
System.out.println(Start);
makeDivisors(N,sqrtN,Start+1);
if(Start * Start != N) {
System.out.println(N/Start);
}
break;
}
Start++;
}
}
/**
* 壁座標が与えられるパターンのとき、グリッドを作成する
* @param H
* @param W
* @param N
* @return なし
*/
public static void makeGrid(int H, int W, int N) {
Grid = new String[H+2];
// グリッドの初期化
for(int i=0; i<H+1; i++) {
Grid[i] = "#";
}
for(int i=1; i<W+2; i++) {
Grid[0] += "#";
for(int j=1; j<H+1; j++) {
Grid[j] += ".";
}
Grid[H+1] += "#";
}
for(int i=0; i<H+1; i++) {
Grid[i] += "#";
}
// 与えられた座標を壁にする
for(int i=0; i<N; i++) {
int r = sc.nextInt();
int c = sc.nextInt();
Grid[r] = Grid[r].substring(0, c) + "#" + Grid[r].substring(c+2);
}
}
/**
* 最小公倍数を求める
* @param A
* @param B
* @return lcm
*/
public static long lcm(long A, long B) {
return A * B / gcd(A,B);
}
/**
* 最大公約数を求める
* @param A
* @param B
* @return gcd
*/
public static long gcd(long A, long B) {
return gcdMain(Math.max(A, B), Math.min(A, B));
}
public static long gcdMain(long numBig, long numSmall) {
if(numSmall==0) return numBig;
else return gcd(numSmall, numBig%numSmall);
}
/**
* 組み合わせの数を求める
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk
*/
public static long nCk(long n,long k) {
long ret = 1;
long min = Math.min(k, n-k);
for(long i=1; i<=min; i++) {
ret *= n+1-i;
ret /= i;
}
return ret;
}
/**
* 組み合わせの数を求める（MOD処理含む）
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk mod M (M must be prime number) O(min(k,n-k)*logM)
*/
public static int nCk(int n,int k,int M) {
long ret = 1;
int min = Math.min(k, n-k);
for(int i=1;i<=min;i++) {
ret = (ret * modPow(i,M-2,M)) % M;
}
for(int i=n-min+1;i<=n;i++) {
ret = (ret * i) % M;
}
return (int)ret;
}
/**
* 累乗計算（MOD処理含む）
* @param a
* @param b
* @param M
* @return a^b mod M O(logB)
*/
public static long modPow(long a,long b,int M) {
long ret = 1;
if(b > 0) {
TreeMap<Long, Long> memo = new TreeMap<Long, Long>(Collections.reverseOrder());
memo.put((long) 1, a%M);
long PowTmp = 1;
while(PowTmp < b) {
memo.put(PowTmp*2, (memo.get(PowTmp)*memo.get(PowTmp))%M);
PowTmp *= 2;
}
ret = a;
b--;
for(Entry<Long, Long> e : memo.entrySet() ) {
long nowB = e.getKey();
long nowA = e.getValue();
while(b - nowB >= 0) {
ret *= nowA;
ret %= M;
b -= nowB;
}
}
}
return ret;
}
} | ConDefects/ConDefects/Code/abc262_c/Java/39321670 |
condefects-java_data_1660 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int size = scanner.nextInt();
int[] array = new int[size];
for(int i=0; i<size; i++)
{
array[i] = scanner.nextInt();
}
int alternate = 0;
int num_position = 0;
long res = 0;
for(int i=0; i<size; i++)
{
if(array[i]==i+1)
{
num_position += 1;
}
else
{
if(array[array[i]-1] == i+1)
{
alternate += 1;
}
}
}
res = (alternate/2) + (num_position-1)*(num_position)/2;
System.out.println(res);
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int size = scanner.nextInt();
int[] array = new int[size];
for(int i=0; i<size; i++)
{
array[i] = scanner.nextInt();
}
int alternate = 0;
int num_position = 0;
long res = 0;
for(int i=0; i<size; i++)
{
if(array[i]==i+1)
{
num_position += 1;
}
else
{
if(array[array[i]-1] == i+1)
{
alternate += 1;
}
}
}
res = (alternate/2) + (1L)*(num_position-1)*(num_position)/2;
System.out.println(res);
}
}
| ConDefects/ConDefects/Code/abc262_c/Java/38900447 |
condefects-java_data_1661 | 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+1];
int same = 0;
for(int i = 1; i <= N; i++){
A[i] = sc.nextInt();
if(A[i] == i){
same++;
}
}
sc.close();
long ans = same*(same-1)/2;
for(int i = 1; i <= N; i++){
if(A[i] > i){
int j = A[i];
if(A[j] == i){
ans++;
}
}
}
System.out.println(ans);
}
}
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+1];
long same = 0;
for(int i = 1; i <= N; i++){
A[i] = sc.nextInt();
if(A[i] == i){
same++;
}
}
sc.close();
long ans = same*(same-1)/2;
for(int i = 1; i <= N; i++){
if(A[i] > i){
int j = A[i];
if(A[j] == i){
ans++;
}
}
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc262_c/Java/36552375 |
condefects-java_data_1662 | import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int same = 0;
int[] a = new int[n + 1];
long ans = 0;
for(int i = 1;i <= n;i++) {
int p = sc.nextInt();
if(p == i) {
same++;
}a[i] = p;
}ans += (same - 1) * same/2;
long other = 0;
for(int i = 1;i<= n;i++) {
if(a[i] == i) {
continue;
}if(a[a[i]] == i) {
other++;
}
}System.out.print(ans + other/2);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long same = 0;
int[] a = new int[n + 1];
long ans = 0;
for(int i = 1;i <= n;i++) {
int p = sc.nextInt();
if(p == i) {
same++;
}a[i] = p;
}ans += (same - 1) * same/2;
long other = 0;
for(int i = 1;i<= n;i++) {
if(a[i] == i) {
continue;
}if(a[a[i]] == i) {
other++;
}
}System.out.print(ans + other/2);
}
} | ConDefects/ConDefects/Code/abc262_c/Java/45324992 |
condefects-java_data_1663 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
static long MOD = 998244353L;
static Set<Character>[] S ;
static long L;
static long sum;
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String[] sp = reader.readLine().split(" ");
int N = Integer.parseInt(sp[0]);
L = Long.parseLong(sp[1]);
sum = 0;
S = new Set[N];
for(int i=0; i<N; i++) {
String s = reader.readLine();
S[i] = new HashSet<Character>();
for(char ch : s.toCharArray()) {
S[i].add(ch);
}
sum += modPow(S[i].size(),L);
if(sum > 0) {
sum -= MOD;
}
sum(false,i,S[i]);
}
System.out.println(sum);
}
static void sum(boolean f,int n, Set<Character> src) {
for(int i=0; i<n; i++) {
Set<Character> intersection = new HashSet<Character>(src);
intersection.retainAll(S[i]);
if(f) {
sum += modPow(intersection.size(),L);
if(sum >= MOD) {
sum -= MOD;
}
} else {
sum -= modPow(intersection.size(),L);
if(sum < 0) {
sum += MOD;
}
}
sum(!f,i,intersection);
}
}
static long modPow(long base, long exponent) {
long result = 1;
long current = base;
while (exponent > 0) {
if ((exponent & 1) == 1) {
result = (result * current) % MOD;
}
current = (current * current) % MOD;
exponent >>= 1;
}
return result;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
static long MOD = 998244353L;
static Set<Character>[] S ;
static long L;
static long sum;
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String[] sp = reader.readLine().split(" ");
int N = Integer.parseInt(sp[0]);
L = Long.parseLong(sp[1]);
sum = 0;
S = new Set[N];
for(int i=0; i<N; i++) {
String s = reader.readLine();
S[i] = new HashSet<Character>();
for(char ch : s.toCharArray()) {
S[i].add(ch);
}
sum += modPow(S[i].size(),L);
if(sum > MOD) {
sum -= MOD;
}
sum(false,i,S[i]);
}
System.out.println(sum);
}
static void sum(boolean f,int n, Set<Character> src) {
for(int i=0; i<n; i++) {
Set<Character> intersection = new HashSet<Character>(src);
intersection.retainAll(S[i]);
if(f) {
sum += modPow(intersection.size(),L);
if(sum >= MOD) {
sum -= MOD;
}
} else {
sum -= modPow(intersection.size(),L);
if(sum < 0) {
sum += MOD;
}
}
sum(!f,i,intersection);
}
}
static long modPow(long base, long exponent) {
long result = 1;
long current = base;
while (exponent > 0) {
if ((exponent & 1) == 1) {
result = (result * current) % MOD;
}
current = (current * current) % MOD;
exponent >>= 1;
}
return result;
}
}
| ConDefects/ConDefects/Code/abc246_f/Java/40807993 |
condefects-java_data_1664 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = sc.nextLine();
a = a.substring(0,5);
String b = sc.nextLine();
b = b.substring(0,5);
boolean c = false;
boolean d = false;
if(a.equals("R G B")||a.equals("G B R")||a.equals("B R G")){
c = true;
}
if(b.equals("R G B")||b.equals("G B R")||b.equals("B R G")){
d = true;
}
if(c&&d){
System.out.println("Yes");
}
else{
System.out.println("No");
}
sc.close();
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a = sc.nextLine();
a = a.substring(0,5);
String b = sc.nextLine();
b = b.substring(0,5);
boolean c = false;
boolean d = false;
if(a.equals("R G B")||a.equals("G B R")||a.equals("B R G")){
c = true;
}
if(b.equals("R G B")||b.equals("G B R")||b.equals("B R G")){
d = true;
}
if(c&&d||c==false&&d==false){
System.out.println("Yes");
}
else{
System.out.println("No");
}
sc.close();
}
} | ConDefects/ConDefects/Code/abc244_d/Java/40066675 |
condefects-java_data_1665 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] S = new String[3];
String[] T = new String[3];
String[][] rgb = new String[3][2];
for (int i = 0; i < 3; i++) {
S[i] = sc.next();
rgb[i][0] = S[i];
}
for (int i = 0; i < 3; i++) {
T[i] = sc.next();
rgb[i][1] = T[i];
}
int dcnt = 0;
for (int i = 0; i < 3; i++) {
if (!rgb[i][0].equals(rgb[i][1])) {
dcnt++;
}
}
String result = dcnt % 2 == 0 ? "Yes" : "No";
System.out.println(result);
sc.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] S = new String[3];
String[] T = new String[3];
String[][] rgb = new String[3][2];
for (int i = 0; i < 3; i++) {
S[i] = sc.next();
rgb[i][0] = S[i];
}
for (int i = 0; i < 3; i++) {
T[i] = sc.next();
rgb[i][1] = T[i];
}
int dcnt = 0;
for (int i = 0; i < 3; i++) {
if (!rgb[i][0].equals(rgb[i][1])) {
dcnt++;
}
}
String result = dcnt % 3 == 0 ? "Yes" : "No";
System.out.println(result);
sc.close();
}
}
| ConDefects/ConDefects/Code/abc244_d/Java/45548957 |
condefects-java_data_1666 | import java.io.*;
import java.util.*;
public class Main {
static class twodarray implements Comparator<twodarray> {
int first, second;
// boolean state;
public twodarray() {
}
public twodarray(int first, int second) {
this.first = first;
this.second = second;
// this.state=state;
}
@Override
public int compare(twodarray o1, twodarray o2) {
if (o1.first < o2.first || (o1.first == o2.first && o1.second > o2.second))
return 1;
return -1;
}
@Override
public boolean equals(Object other) {
if (other instanceof twodarray) {
twodarray casted = (twodarray) other;
return casted.first == this.first && casted.second == this.second;
}
return false;
}
@Override
public int hashCode() {
String unique = this.first + "_" + this.second;
return unique.hashCode();
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() //considers white spaces also
{
String str = "";
try {
str = br.readLine().trim();//used to eliminate trailing and leading spaces
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static FastReader in = new FastReader();
static FastWriter out = new FastWriter();
public static void main(String[] args) throws IOException {
try {
// int testCases = in.nextInt();
// while (testCases-- > 0) {
solve();
// }
out.close();
} catch (Exception e) {
e.printStackTrace();
out.print(e);
return;
}
}
static void solve() throws IOException
{
String s1=in.next();
String s2=in.next();
String s3=in.next();
String t1=in.next();
String t2=in.next();
String t3=in.next();
String s=s1+s2+s3;
String t=t1+t2+t3;
int count=0;
for(int i=0;i<3;i++)
{
if(s.charAt(i)!=t.charAt(i))
count++;
}
if(count==0 || count==2)
{
out.println("Yes");
}
else{
out.println("No");
}
}
static void reverse(int a[], int n){
int i, k, t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static int[] fillInstArray(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = in.nextInt();
// for(int i=0;i<n;i++)
// out.print(arr[i]+" ");
return arr;
}
static void merge(int arr[], int l, int m, int r)
{
int n1 = m - l + 1;
int n2 = r - m;
int L[] = new int[n1];
int R[] = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
static void sort(int arr[], int l, int r)
{
if (l < r) {
int m =l+ (r-l)/2;
sort(arr, l, m);
sort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
}
//hashmap code for getting key with freq of only one
//public int singleNumber(int[] nums) {
// Map<Integer, Integer> freq = new HashMap<>();
//
// for (int i : nums) {
// if (freq.get(i) == null) {
// freq.put(i, 1);
// } else {
// freq.put(i, freq.get(i) + 1);
// }
// }
//
// for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
// if (entry.getValue() == 1) {
// return entry.getKey();
// }
// }
//
// return 0;
//}
//building a heap is O(n) by using heapify method bottom to top
// Note:- In order to take mod of negative number use (i % K + K)%K;
//codechef template
/* package codechef; // don't place package name! */
//
//import java.util.*;
// import java.lang.*;
// import java.io.*;
//
///* Name of the class has to be "Main" only if the class is public. */
//class Codechef
//{
// public static void main (String[] args) throws java.lang.Exception
// {
// Scanner sc=new Scanner(System.in);
// int t=sc.nextInt();
// while(t-->0)
// {
// int n=sc.nextInt();
// int[] arr=new int[n];
//
//
// }
//
// }
//
//}
import java.io.*;
import java.util.*;
public class Main {
static class twodarray implements Comparator<twodarray> {
int first, second;
// boolean state;
public twodarray() {
}
public twodarray(int first, int second) {
this.first = first;
this.second = second;
// this.state=state;
}
@Override
public int compare(twodarray o1, twodarray o2) {
if (o1.first < o2.first || (o1.first == o2.first && o1.second > o2.second))
return 1;
return -1;
}
@Override
public boolean equals(Object other) {
if (other instanceof twodarray) {
twodarray casted = (twodarray) other;
return casted.first == this.first && casted.second == this.second;
}
return false;
}
@Override
public int hashCode() {
String unique = this.first + "_" + this.second;
return unique.hashCode();
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() //considers white spaces also
{
String str = "";
try {
str = br.readLine().trim();//used to eliminate trailing and leading spaces
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static FastReader in = new FastReader();
static FastWriter out = new FastWriter();
public static void main(String[] args) throws IOException {
try {
// int testCases = in.nextInt();
// while (testCases-- > 0) {
solve();
// }
out.close();
} catch (Exception e) {
e.printStackTrace();
out.print(e);
return;
}
}
static void solve() throws IOException
{
String s1=in.next();
String s2=in.next();
String s3=in.next();
String t1=in.next();
String t2=in.next();
String t3=in.next();
String s=s1+s2+s3;
String t=t1+t2+t3;
int count=0;
for(int i=0;i<3;i++)
{
if(s.charAt(i)!=t.charAt(i))
count++;
}
if(count==0 || count==3)
{
out.println("Yes");
}
else{
out.println("No");
}
}
static void reverse(int a[], int n){
int i, k, t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static int[] fillInstArray(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = in.nextInt();
// for(int i=0;i<n;i++)
// out.print(arr[i]+" ");
return arr;
}
static void merge(int arr[], int l, int m, int r)
{
int n1 = m - l + 1;
int n2 = r - m;
int L[] = new int[n1];
int R[] = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
static void sort(int arr[], int l, int r)
{
if (l < r) {
int m =l+ (r-l)/2;
sort(arr, l, m);
sort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
}
//hashmap code for getting key with freq of only one
//public int singleNumber(int[] nums) {
// Map<Integer, Integer> freq = new HashMap<>();
//
// for (int i : nums) {
// if (freq.get(i) == null) {
// freq.put(i, 1);
// } else {
// freq.put(i, freq.get(i) + 1);
// }
// }
//
// for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
// if (entry.getValue() == 1) {
// return entry.getKey();
// }
// }
//
// return 0;
//}
//building a heap is O(n) by using heapify method bottom to top
// Note:- In order to take mod of negative number use (i % K + K)%K;
//codechef template
/* package codechef; // don't place package name! */
//
//import java.util.*;
// import java.lang.*;
// import java.io.*;
//
///* Name of the class has to be "Main" only if the class is public. */
//class Codechef
//{
// public static void main (String[] args) throws java.lang.Exception
// {
// Scanner sc=new Scanner(System.in);
// int t=sc.nextInt();
// while(t-->0)
// {
// int n=sc.nextInt();
// int[] arr=new int[n];
//
//
// }
//
// }
//
//}
| ConDefects/ConDefects/Code/abc244_d/Java/35449650 |
condefects-java_data_1667 | import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.*;
class Main{
static Library System = new Library(java.lang.System.in,java.lang.System.out);
public static void main(String[] args){
/*メモ////////
*/////////////
long N = System.in.nextLong();
long L = System.in.nextLong();
long R = System.in.nextLong();
long sum = 0;
for(int i=0;i<60;i++)
if((N&1L<<i)>0)
sum += Math.min(R,(1L<<i+1)-1)-Math.max(L,1L<<i)+1;
System.out.println(sum);
System.out.close();
}
}
/*////////////////////////////////////////////////
* My Library *
@auther viral
*/////////////////////////////////////////////////
class Library{
SimpleScanner in;
SimplePrinter out;
OutputStream err;
private long[] Factorials,InFactorials;
public long mod = 0;
public Library(InputStream in,OutputStream out){
this.in = new SimpleScanner(in);
this.out = new SimplePrinter(out);
this.err = System.err;
}
public Library(InputStream in,OutputStream out,boolean bool){
this.in = new SimpleScanner(in);
this.out = new SimplePrinter(out,bool);
this.err = System.err;
}
public Library(InputStream in,OutputStream out,int fac,long mod){
this(in,out);
Factorials=new long[fac+1];
Factorials[1]=1;
for(int i=2;i<=fac;i++)Factorials[i]=Factorials[i-1]*i%mod;
InFactorials=new long[fac+1];
InFactorials[fac]=modPow(Factorials[fac],mod-2,mod);
for(int i=fac;i>1;i--)InFactorials[i-1]=InFactorials[i]*i%mod;
this.mod = mod;
}
public Library(int fac,long mod){
Factorials=new long[fac+1];
Factorials[1]=1;
for(int i=2;i<=fac;i++)Factorials[i]=Factorials[i-1]*i%mod;
InFactorials=new long[fac+1];
InFactorials[fac]=modPow(Factorials[fac],mod-2,mod);
for(int i=fac;i>1;i--)InFactorials[i-1]=InFactorials[i]*i%mod;
this.mod = mod;
}
/**
* コンストラクタで渡された値までの
* num!、aCbをmodで割ったあまりを返します。
*/
public long getFact(int num){
return Factorials[num];
}
public long getCombi(int a,int b){
return (Factorials[a]*InFactorials[a-b]%mod)*InFactorials[b]%mod;
}
/**
* factではa!を、
* modFactでは引数のmodかコンストラクタで渡されたmodで
* 割ったあまりを返します。
*/
public static long fact(long a){
long ans=1;
for(long i=2;i<=a;i++)ans*=i;
return ans;
}
public static long modFact(long a,long mod){
long ans=1;
for(long i=2;i<=a;i++){
ans*=i%mod;
ans%=mod;
}
return ans;
}
public long modFact(long a){
if(mod==0){
System.err.println("\u001b[00;31m"+"#mod is not defined#");
System.exit(1);
}
long ans=1;
for(long i=2;i<=a;i++){
ans*=i%mod;
ans%=mod;
}
return ans;
}
/**
* CombiではaCb、
* modCombiでは引数のmodかコンストラクタで渡されたmodで
* 割ったあまりを返します。
*/
public static long combi(long a,long b){
long ans=1;
if(b==0||b==a)return 1;
if(b<0||b>a)return 0;
b=Math.min(a-b,b);
for(long i=1;i<=b;i++){
ans*=a--;
ans/=i;
}
return ans;
}
public static long modCombi(long a,long b,long mod){
long ans=1;
if(b==0||b==a)return 1;
if(b<0||b>a)return 0;
b=Math.min(a-b,b);
for(long i=1;i<=b;i++){
ans*=a--;
ans%=mod;
ans*=modPow(i,mod-2,mod);
ans%=mod;
}
return ans;
}
public long modCombi(long a,long b){
if(mod==0){
System.err.println("\u001b[00;31m"+"#mod is not defined#");
System.exit(1);
}
long ans=1;
if(b==0||b==a)return 1;
if(b<0||b>a)return 0;
b=Math.min(a-b,b);
for(long i=1;i<=b;i++){
ans*=a--;
ans%=mod;
ans*=modPow(i,mod-2,mod);
ans%=mod;
}
return ans;
}
/**
* int、long型配列をソートします。
* 二次元配列の場合は[i][0]と[i][1]の大きさで
* 昇順に並べ替えます。
*/
public static void sort(int[] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&list[(j-1)/2]<list[j]){
int temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
int temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&list[j]<list[2*j+1])||(2*j+2<i-1&&list[j]<list[2*j+2])){
if(2*j+2==i-1||list[2*j+1]>list[2*j+2]){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
public static void sort(int[][] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&(list[(j-1)/2][0]<list[j][0]||(list[(j-1)/2][0]==list[j][0]&&list[(j-1)/2][1]<list[j][1]))){
int[] temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
int[] temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&(list[j][0]<list[2*j+1][0]||(list[j][0]==list[2*j+1][0]&&list[j][1]<list[2*j+1][1])))||
(2*j+2<i-1&&(list[j][0]<list[2*j+2][0]||(list[j][0]==list[2*j+2][0]&&list[j][1]<list[2*j+2][1])))){
if(2*j+2==i-1||(list[2*j+1][0]>list[2*j+2][0]||(list[2*j+1][0]==list[2*j+2][0]&&list[2*j+1][1]>list[2*j+2][1]))){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
public static void sort(long[] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&list[(j-1)/2]<list[j]){
long temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
long temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&list[j]<list[2*j+1])||(2*j+2<i-1&&list[j]<list[2*j+2])){
if(2*j+2==i-1||list[2*j+1]>list[2*j+2]){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
public static void sort(long[][] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&(list[(j-1)/2][0]<list[j][0]||(list[(j-1)/2][0]==list[j][0]&&list[(j-1)/2][1]<list[j][1]))){
long[] temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
long[] temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&(list[j][0]<list[2*j+1][0]||(list[j][0]==list[2*j+1][0]&&list[j][1]<list[2*j+1][1])))||
(2*j+2<i-1&&(list[j][0]<list[2*j+2][0]||(list[j][0]==list[2*j+2][0]&&list[j][1]<list[2*j+2][1])))){
if(2*j+2==i-1||(list[2*j+1][0]>list[2*j+2][0]||(list[2*j+1][0]==list[2*j+2][0]&&list[2*j+1][1]>list[2*j+2][1]))){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
/**
* int型配列をソートします。
* 最大値が小さい場合は有効です。
*/
public static void countSort(int[] nums,int limit){
int[] list=new int[limit+1];
for(int i=0;i<nums.length;i++)list[nums[i]]++;
int temp=0;
for(int i=0;i<list.length;i++)for(int j=0;j<list[i];j++)nums[temp++]=i;
}
/**
* gcdは最大公約数を、
* lcmは最小公倍数を返します。
* lcmはオーバーフローの可能性があるのでご注意を。
* 戻り値はlong型です。
*/
public static long gcd(long a,long b){
if(a==0||b==0)
return Math.max(a,b);
long temp;
while((temp=a%b)!=0){
a=b;
b=temp;
}
return b;
}
public static long lcm(long a,long b){
if(a==0||b==0)
return 0;
long mult=a*b,temp;
while((temp=a%b)!=0){
a=b;
b=temp;
}
return mult/b;
}
/**
* BigIntegerクラスのものを使用します。
* 素数である確率が高いならtrue、
* 確実に合成数ならfalseを返します。
* 誤判定の確率は1/2^20以下です。
*/
public static boolean isPrime(long num){
return BigInteger.valueOf(num).isProbablePrime(20);
}
/**
* 引数まで(引数含む)の素数を返します。
* 2^30以上の素数列挙はできないのでご注意を。
*/
public static int[] primes(int num){
BitSet nums=new BitSet(num+1);
nums.set(2,num+1);
for(int i=2;i<=Math.sqrt(num);i++)if(nums.get(i))for(int j=i*i;j<=num;j+=i)nums.clear(j);
int[] answer=new int[nums.cardinality()];
int i=2,index=0;
while(true){
i=nums.nextSetBit(i);
answer[index++]=i++;
if(index==answer.length)break;
}
return answer;
}
/**
* powではそのままの結果を、
* modPowでは引数のmodかコンストラクタで渡されたmodで
* 割ったあまりを返します。
*/
public static long pow(long a,long b){
long ans=1;
while(b>0){
if((b&1)==1)ans*=a;
a*=a;
b>>=1;
}
return ans;
}
public static long modPow(long a,long b,long mod){
long ans=1;
a%=mod;
while(b>0){
if((b&1)==1)ans*=a;
ans%=mod;
a*=a;
a%=mod;
b>>=1;
}
return ans;
}
public long modPow(long a,long b){
if(mod==0){
System.err.println("\u001b[00;31m"+"#mod is not defined#");
System.exit(1);
}
long ans=1;
a%=mod;
while(b>0){
if((b&1)==1)ans*=a;
ans%=mod;
a*=a;
a%=mod;
b>>=1;
}
return ans;
}
/**
* Stringをint、longに変換します。
* 数値以外の文字であっても無理矢理数値変換してしまうので
* 使用の際はご注意を。
*/
public static int parseInt(String str){
char[] nums=str.toCharArray();
int ans=0;
boolean plus=true;
if(nums[0]=='-'){
plus=!plus;
nums[0]='0';
}
for(int i=0;i<nums.length;i++)ans=ans*10+nums[i]-'0';
return plus?ans:-ans;
}
public static long parseLong(String str){
char[] nums=str.toCharArray();
long ans=0;
boolean plus=true;
if(nums[0]=='-'){
plus=!plus;
nums[0]='0';
}
for(int i=0;i<nums.length;i++)ans=ans*10+nums[i]-'0';
return plus?ans:-ans;
}
/**
* downSearchではnum以下で最大の要素を、
* upSearchではnum以上で最小の要素を探します。
* 同様にunderSearchではnum未満で最大の要素を、
* overSearchではnumより大きい最小の要素を探します。
* なお、underとdownは条件を満たす最大のindexを、
* upとoverは条件を満たす最小のindexを返します。
* 戻り値は引数の配列(List)のindexです。
*/
//downSearch
public static int downSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(List<Integer> nums,Integer num){
int a=0,b=nums.size()-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
//upSearch
public static int upSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=nums.length,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=nums.length,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=nums.length,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(List<Integer> nums,int num){
int a=0,b=nums.size()-1,ans=nums.size(),c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=nums.size(),c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
//underSearch
public static int underSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(List<Integer> nums,Integer num){
int a=0,b=nums.size()-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
//overSearch
public static int overSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(List<Integer> nums,Integer num){
int a=0,b=nums.size()-1,ans=nums.size(),c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=nums.size(),c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
/**
* 最長増加部分列の長さを返します。
* 引数にboolean型変数を渡すと
* 同じ値も増加と判定するか指定できます。
* デフォルトでは増加と判定しません。
*/
public static int lis(int[] nums){
return lis(nums,false);
}
public static int lis(int[][] nums,int p){
return lis(nums,p,false);
}
public static int lis(int[] nums,boolean include){
int[] list = new int[nums.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int i=0;i<nums.length;i++){
int index = include ? overSearch(list,nums[i]) : upSearch(list,nums[i]);
list[index] = Math.min(list[index],nums[i]);
}
int answer = underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
public static int lis(int[][] nums,int p,boolean include){
int[] list = new int[nums.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int i=0;i<nums.length;i++){
int index = include ? overSearch(list,nums[i][p]) : upSearch(list,nums[i][p]);
list[index] = Math.min(list[index],nums[i][p]);
}
int answer = underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length){
System.arraycopy(src,srcPos,dest,destPos,length);
}
public static long nanoTime(){
return System.nanoTime();
}
public static long currentTimeMillis(){
return System.currentTimeMillis();
}
public void exit(int num){
in.close();
out.close();
System.exit(num);
}
}
//SegmentTree
abstract class SegmentTree<E>{
int N,size;
E def;
Object[] node;
public SegmentTree(int n,E defa,boolean include){
N = 2;
size = 1;
while(N<n<<1){
N <<= 1;
size <<= 1;
}
size -= include?1:0;
node = new Object[N];
def = defa;
Arrays.fill(node,def);
}
public SegmentTree(int n,E defa){
this(n,defa,false);
}
@SuppressWarnings("unchecked")
public void update(int n,E value){
n += size;
node[n] = value;
n >>= 1;
while(n>0){
node[n] = function((E)node[n<<1],(E)node[(n<<1)+1]);
n >>= 1;
}
}
@SuppressWarnings("unchecked")
public E get(int a){
return (E)node[a+size];
}
@SuppressWarnings("unchecked")
public E answer(int a){
return (E)node[1];
}
@SuppressWarnings("unchecked")
public E query(int l,int r){
l += size;
r += size;
E answer = def;
while(l>0&&r>0&&l<=r){
if(l%2==1)
answer = function((E)node[l++],answer);
l >>= 1;
if(r%2==0)
answer = function(answer,(E)node[r--]);
r >>= 1;
}
return answer;
}
@SuppressWarnings("unchecked")
abstract public E function(E a,E b);
}
//Union-Find
class UnionFind{
private int[] par,rank,size;
private ArrayList<HashSet<Integer>> groupList;
private int N,count;
public UnionFind(int N){
this.N = N;
count = N;
par = new int[N];
rank = new int[N];
size = new int[N];
groupList = new ArrayList<HashSet<Integer>>();
for(int i=0;i<N;i++){
HashSet<Integer> temp = new HashSet<Integer>();
temp.add(i);
groupList.add(temp);
}
Arrays.fill(par,-1);
Arrays.fill(size,1);
}
public int root(int x){
if(par[x]==-1)
return x;
else
return par[x] = root(par[x]);
}
public boolean isSame(int x,int y){
return root(x)==root(y);
}
public boolean unite(int x,int y){
int rx = root(x);
int ry = root(y);
if(rx==ry)
return false;
if(rank[rx]<rank[ry]){
int temp = rx;
rx = ry;
ry = temp;
}
par[ry] = rx;
if(rank[rx]==rank[ry])
++rank[rx];
size[rx] += size[ry];
groupList.get(rx).addAll(groupList.get(ry));
groupList.set(ry,null);
--count;
return true;
}
public HashSet<Integer> getMember(int x){
int r = root(x);
return groupList.get(r);
}
public ArrayList<HashSet<Integer>> getAllGroup(){
final ArrayList<HashSet<Integer>> ans = new ArrayList<HashSet<Integer>>();
for(int i=0;i<N;i++){
HashSet<Integer> temp = groupList.get(i);
if(temp!=null)
ans.add(temp);
}
return ans;
}
public int groupCount(){
return count;
}
public int size(int x){
return size[root(x)];
}
}
//Pair
class Pair<K extends Comparable<K>,V extends Comparable<V>>
implements Comparable<Pair<K,V>>{
private AbstractMap.SimpleEntry<K,V> map;
public Pair(K key,V value){
map = new AbstractMap.SimpleEntry<K,V>(key,value);
}
public K getKey(){
return map.getKey();
}
public V getValue(){
return map.getValue();
}
public K setKey(K key){
K oldKey = map.getKey();
V value = map.getValue();
map = new AbstractMap.SimpleEntry<K,V>(key,value);
return oldKey;
}
public V setValue(V value){
return map.setValue(value);
}
@Override
public int compareTo(Pair<K,V> pair){
int com = getKey().compareTo(pair.getKey());
return com!=0?com:getValue().compareTo(pair.getValue());
}
@Override
public boolean equals(Object o){
if(!(o instanceof Map.Entry))
return false;
Pair<?,?> pair = (Pair<?,?>)o;
return getKey()==pair.getKey()&&getValue()==pair.getValue();
}
@Override
public String toString(){
return getKey()+"="+getValue();
}
}
/*////////////////////////////////////////////////
* My Scanner *
@auther viral
*/////////////////////////////////////////////////
class SimpleScanner{
final private int buff_size = 1<<15;
private InputStream is;
private byte[] buff;
private int point,length;
public SimpleScanner(InputStream is){
this.is = is;
buff = new byte[buff_size];
point = length = 0;
}
private void reload(){
do{
try{
length = is.read(buff,point = 0,buff_size);
}catch(IOException e){
e.printStackTrace();
System.exit(1);
}
}while(length==-1);
}
private byte read(){
if(point==length)reload();
return buff[point++];
}
public byte nextByte(){
byte c = read();
while(c<=' ')c = read();
return c;
}
public int nextInt(){
int ans = 0;
byte c = read();
while(c<=' ')c = read();
boolean negate = c == '-';
if(c=='-')c = read();
while('0'<=c&&c<='9'){
ans = ans*10+c-'0';
c = read();
}
return negate ? -ans : ans;
}
public long nextLong(){
long ans = 0;
byte c = read();
while(c<=' ')c = read();
boolean negate = c == '-';
if(c=='-')c = read();
while('0'<=c&&c<='9'){
ans = ans*10+c-'0';
c = read();
}
return negate ? -ans : ans;
}
public char nextChar(){
byte c = read();
while(c<=' ')c = read();
return (char)c;
}
public String next(){
StringBuilder ans = new StringBuilder();
byte c = read();
while(c<=' ')c = read();
while(c>' '){
ans.append((char)c);
c = read();
}
return ans.toString();
}
public byte[] nextByte(int n){
byte[] ans = new byte[n];
for(int i=0;i<n;i++){
ans[i] = nextByte();
}
return ans;
}
public int[] nextInt(int n){
int[] ans = new int[n];
for(int i=0;i<n;i++){
ans[i] = nextInt();
}
return ans;
}
public long[] nextLong(int n){
long[] ans = new long[n];
for(int i=0;i<n;i++){
ans[i] = nextLong();
}
return ans;
}
public String[] next(int n){
String[] ans = new String[n];
for(int i=0;i<n;i++){
ans[i] = next();
}
return ans;
}
public byte[][] nextByte(int n,int m){
byte[][] ans = new byte[n][];
for(int i=0;i<n;i++){
ans[i] = nextByte(m);
}
return ans;
}
public int[][] nextInt(int n,int m){
int[][] ans = new int[n][];
for(int i=0;i<n;i++){
ans[i] = nextInt(m);
}
return ans;
}
public long[][] nextLong(int n,int m){
long[][] ans = new long[n][];
for(int i=0;i<n;i++){
ans[i] = nextLong(m);
}
return ans;
}
public String[][] next(int n,int m){
String[][] ans = new String[n][];
for(int i=0;i<n;i++){
ans[i] = next(m);
}
return ans;
}
public char[] nextCharArray(){
return next().toCharArray();
}
public char[][] nextCharArray(int n){
char[][] ans = new char[n][];
for(int i=0;i<n;i++){
ans[i] = next().toCharArray();
}
return ans;
}
public void close(){
try{
is.close();
}catch(IOException e){
e.printStackTrace();
System.exit(1);
}
}
}
/*////////////////////////////////////////////////
* My Printer *
@auther viral
*/////////////////////////////////////////////////
class SimplePrinter extends PrintWriter{
public SimplePrinter(OutputStream os){
super(os);
}
public SimplePrinter(OutputStream os,boolean bool){
super(os,bool);
}
public void println(byte[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(byte[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(byte[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(byte[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(int[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(int[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(int[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(int[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(long[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(long[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(long[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(long[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(Byte[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(Byte[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(Byte[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(Byte[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(Integer[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(Integer[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(Integer[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(Integer[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(Long[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(Long[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(Long[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(Long[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(String[] strs,String str){
println(String.join(str,strs));
}
public void println(String[] strs,char c){
String str = String.valueOf(c);
println(String.join(str,strs));
}
public void println(String[][] strs,String str){
for(int i=0;i<strs.length;i++){
println(String.join(str,strs[i]));
}
}
public void println(String[][] strs,char c){
String str = String.valueOf(c);
for(int i=0;i<strs.length;i++){
println(String.join(str,strs[i]));
}
}
public void println(char[] cs,String str){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(str);
print(cs[i]);
}
println();
}
public void println(char[] cs,char c){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(c);
print(cs[i]);
}
println();
}
public void println(char[][] cs){
for(int i=0;i<cs.length;i++){
println(cs[i]);
}
}
public void println(char[][] cs,String str){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(str);
print(cs[i]);
}
println();
}
public void println(char[][] cs,char c){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(c);
print(cs[i]);
}
println();
}
}
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.*;
class Main{
static Library System = new Library(java.lang.System.in,java.lang.System.out);
public static void main(String[] args){
/*メモ////////
*/////////////
long N = System.in.nextLong();
long L = System.in.nextLong();
long R = System.in.nextLong();
long sum = 0;
for(int i=0;i<60;i++)
if((N&1L<<i)>0)
sum += Math.max(0,Math.min(R,(1L<<i+1)-1)-Math.max(L,1L<<i)+1);
System.out.println(sum);
System.out.close();
}
}
/*////////////////////////////////////////////////
* My Library *
@auther viral
*/////////////////////////////////////////////////
class Library{
SimpleScanner in;
SimplePrinter out;
OutputStream err;
private long[] Factorials,InFactorials;
public long mod = 0;
public Library(InputStream in,OutputStream out){
this.in = new SimpleScanner(in);
this.out = new SimplePrinter(out);
this.err = System.err;
}
public Library(InputStream in,OutputStream out,boolean bool){
this.in = new SimpleScanner(in);
this.out = new SimplePrinter(out,bool);
this.err = System.err;
}
public Library(InputStream in,OutputStream out,int fac,long mod){
this(in,out);
Factorials=new long[fac+1];
Factorials[1]=1;
for(int i=2;i<=fac;i++)Factorials[i]=Factorials[i-1]*i%mod;
InFactorials=new long[fac+1];
InFactorials[fac]=modPow(Factorials[fac],mod-2,mod);
for(int i=fac;i>1;i--)InFactorials[i-1]=InFactorials[i]*i%mod;
this.mod = mod;
}
public Library(int fac,long mod){
Factorials=new long[fac+1];
Factorials[1]=1;
for(int i=2;i<=fac;i++)Factorials[i]=Factorials[i-1]*i%mod;
InFactorials=new long[fac+1];
InFactorials[fac]=modPow(Factorials[fac],mod-2,mod);
for(int i=fac;i>1;i--)InFactorials[i-1]=InFactorials[i]*i%mod;
this.mod = mod;
}
/**
* コンストラクタで渡された値までの
* num!、aCbをmodで割ったあまりを返します。
*/
public long getFact(int num){
return Factorials[num];
}
public long getCombi(int a,int b){
return (Factorials[a]*InFactorials[a-b]%mod)*InFactorials[b]%mod;
}
/**
* factではa!を、
* modFactでは引数のmodかコンストラクタで渡されたmodで
* 割ったあまりを返します。
*/
public static long fact(long a){
long ans=1;
for(long i=2;i<=a;i++)ans*=i;
return ans;
}
public static long modFact(long a,long mod){
long ans=1;
for(long i=2;i<=a;i++){
ans*=i%mod;
ans%=mod;
}
return ans;
}
public long modFact(long a){
if(mod==0){
System.err.println("\u001b[00;31m"+"#mod is not defined#");
System.exit(1);
}
long ans=1;
for(long i=2;i<=a;i++){
ans*=i%mod;
ans%=mod;
}
return ans;
}
/**
* CombiではaCb、
* modCombiでは引数のmodかコンストラクタで渡されたmodで
* 割ったあまりを返します。
*/
public static long combi(long a,long b){
long ans=1;
if(b==0||b==a)return 1;
if(b<0||b>a)return 0;
b=Math.min(a-b,b);
for(long i=1;i<=b;i++){
ans*=a--;
ans/=i;
}
return ans;
}
public static long modCombi(long a,long b,long mod){
long ans=1;
if(b==0||b==a)return 1;
if(b<0||b>a)return 0;
b=Math.min(a-b,b);
for(long i=1;i<=b;i++){
ans*=a--;
ans%=mod;
ans*=modPow(i,mod-2,mod);
ans%=mod;
}
return ans;
}
public long modCombi(long a,long b){
if(mod==0){
System.err.println("\u001b[00;31m"+"#mod is not defined#");
System.exit(1);
}
long ans=1;
if(b==0||b==a)return 1;
if(b<0||b>a)return 0;
b=Math.min(a-b,b);
for(long i=1;i<=b;i++){
ans*=a--;
ans%=mod;
ans*=modPow(i,mod-2,mod);
ans%=mod;
}
return ans;
}
/**
* int、long型配列をソートします。
* 二次元配列の場合は[i][0]と[i][1]の大きさで
* 昇順に並べ替えます。
*/
public static void sort(int[] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&list[(j-1)/2]<list[j]){
int temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
int temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&list[j]<list[2*j+1])||(2*j+2<i-1&&list[j]<list[2*j+2])){
if(2*j+2==i-1||list[2*j+1]>list[2*j+2]){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
public static void sort(int[][] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&(list[(j-1)/2][0]<list[j][0]||(list[(j-1)/2][0]==list[j][0]&&list[(j-1)/2][1]<list[j][1]))){
int[] temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
int[] temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&(list[j][0]<list[2*j+1][0]||(list[j][0]==list[2*j+1][0]&&list[j][1]<list[2*j+1][1])))||
(2*j+2<i-1&&(list[j][0]<list[2*j+2][0]||(list[j][0]==list[2*j+2][0]&&list[j][1]<list[2*j+2][1])))){
if(2*j+2==i-1||(list[2*j+1][0]>list[2*j+2][0]||(list[2*j+1][0]==list[2*j+2][0]&&list[2*j+1][1]>list[2*j+2][1]))){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
public static void sort(long[] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&list[(j-1)/2]<list[j]){
long temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
long temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&list[j]<list[2*j+1])||(2*j+2<i-1&&list[j]<list[2*j+2])){
if(2*j+2==i-1||list[2*j+1]>list[2*j+2]){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
public static void sort(long[][] list){
for(int i=0;i<list.length;i++){
int j=i;
while(j>0&&(list[(j-1)/2][0]<list[j][0]||(list[(j-1)/2][0]==list[j][0]&&list[(j-1)/2][1]<list[j][1]))){
long[] temp=list[(j-1)/2];
list[(j-1)/2]=list[j];
list[j]=temp;
j=(j-1)/2;
}
}
for(int i=list.length;i>0;i--){
long[] temp=list[i-1];
list[i-1]=list[0];
list[0]=temp;
int j=0;
while((2*j+1<i-1&&(list[j][0]<list[2*j+1][0]||(list[j][0]==list[2*j+1][0]&&list[j][1]<list[2*j+1][1])))||
(2*j+2<i-1&&(list[j][0]<list[2*j+2][0]||(list[j][0]==list[2*j+2][0]&&list[j][1]<list[2*j+2][1])))){
if(2*j+2==i-1||(list[2*j+1][0]>list[2*j+2][0]||(list[2*j+1][0]==list[2*j+2][0]&&list[2*j+1][1]>list[2*j+2][1]))){
temp=list[2*j+1];
list[2*j+1]=list[j];
list[j]=temp;
j<<=1;
j++;
}
else{
temp=list[2*j+2];
list[2*j+2]=list[j];
list[j]=temp;
j<<=1;
j+=2;
}
}
}
}
/**
* int型配列をソートします。
* 最大値が小さい場合は有効です。
*/
public static void countSort(int[] nums,int limit){
int[] list=new int[limit+1];
for(int i=0;i<nums.length;i++)list[nums[i]]++;
int temp=0;
for(int i=0;i<list.length;i++)for(int j=0;j<list[i];j++)nums[temp++]=i;
}
/**
* gcdは最大公約数を、
* lcmは最小公倍数を返します。
* lcmはオーバーフローの可能性があるのでご注意を。
* 戻り値はlong型です。
*/
public static long gcd(long a,long b){
if(a==0||b==0)
return Math.max(a,b);
long temp;
while((temp=a%b)!=0){
a=b;
b=temp;
}
return b;
}
public static long lcm(long a,long b){
if(a==0||b==0)
return 0;
long mult=a*b,temp;
while((temp=a%b)!=0){
a=b;
b=temp;
}
return mult/b;
}
/**
* BigIntegerクラスのものを使用します。
* 素数である確率が高いならtrue、
* 確実に合成数ならfalseを返します。
* 誤判定の確率は1/2^20以下です。
*/
public static boolean isPrime(long num){
return BigInteger.valueOf(num).isProbablePrime(20);
}
/**
* 引数まで(引数含む)の素数を返します。
* 2^30以上の素数列挙はできないのでご注意を。
*/
public static int[] primes(int num){
BitSet nums=new BitSet(num+1);
nums.set(2,num+1);
for(int i=2;i<=Math.sqrt(num);i++)if(nums.get(i))for(int j=i*i;j<=num;j+=i)nums.clear(j);
int[] answer=new int[nums.cardinality()];
int i=2,index=0;
while(true){
i=nums.nextSetBit(i);
answer[index++]=i++;
if(index==answer.length)break;
}
return answer;
}
/**
* powではそのままの結果を、
* modPowでは引数のmodかコンストラクタで渡されたmodで
* 割ったあまりを返します。
*/
public static long pow(long a,long b){
long ans=1;
while(b>0){
if((b&1)==1)ans*=a;
a*=a;
b>>=1;
}
return ans;
}
public static long modPow(long a,long b,long mod){
long ans=1;
a%=mod;
while(b>0){
if((b&1)==1)ans*=a;
ans%=mod;
a*=a;
a%=mod;
b>>=1;
}
return ans;
}
public long modPow(long a,long b){
if(mod==0){
System.err.println("\u001b[00;31m"+"#mod is not defined#");
System.exit(1);
}
long ans=1;
a%=mod;
while(b>0){
if((b&1)==1)ans*=a;
ans%=mod;
a*=a;
a%=mod;
b>>=1;
}
return ans;
}
/**
* Stringをint、longに変換します。
* 数値以外の文字であっても無理矢理数値変換してしまうので
* 使用の際はご注意を。
*/
public static int parseInt(String str){
char[] nums=str.toCharArray();
int ans=0;
boolean plus=true;
if(nums[0]=='-'){
plus=!plus;
nums[0]='0';
}
for(int i=0;i<nums.length;i++)ans=ans*10+nums[i]-'0';
return plus?ans:-ans;
}
public static long parseLong(String str){
char[] nums=str.toCharArray();
long ans=0;
boolean plus=true;
if(nums[0]=='-'){
plus=!plus;
nums[0]='0';
}
for(int i=0;i<nums.length;i++)ans=ans*10+nums[i]-'0';
return plus?ans:-ans;
}
/**
* downSearchではnum以下で最大の要素を、
* upSearchではnum以上で最小の要素を探します。
* 同様にunderSearchではnum未満で最大の要素を、
* overSearchではnumより大きい最小の要素を探します。
* なお、underとdownは条件を満たす最大のindexを、
* upとoverは条件を満たす最小のindexを返します。
* 戻り値は引数の配列(List)のindexです。
*/
//downSearch
public static int downSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(List<Integer> nums,Integer num){
int a=0,b=nums.size()-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int downSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=-1,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
//upSearch
public static int upSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=nums.length,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=nums.length,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=nums.length,c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(List<Integer> nums,int num){
int a=0,b=nums.size()-1,ans=nums.size(),c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int upSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=nums.size(),c=-1;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
//underSearch
public static int underSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>=num)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(List<Integer> nums,Integer num){
int a=0,b=nums.size()-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
public static int underSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=-1,c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>=0)b=c-1;
else a=(ans=c)+1;
}
return ans;
}
//overSearch
public static int overSearch(int[] nums,int num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(long[] nums,long num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c]>num)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(Integer[] nums,Integer num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(Long[] nums,Long num){
int a=0,b=nums.length-1,ans=nums.length,c;
while(a-b<1){
c=(a+b)/2;
if(nums[c].compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(List<Integer> nums,Integer num){
int a=0,b=nums.size()-1,ans=nums.size(),c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
public static int overSearch(List<Long> nums,Long num){
int a=0,b=nums.size()-1,ans=nums.size(),c;
while(a-b<1){
c=(a+b)/2;
if(nums.get(c).compareTo(num)>0)b=(ans=c)-1;
else a=c+1;
}
return ans;
}
/**
* 最長増加部分列の長さを返します。
* 引数にboolean型変数を渡すと
* 同じ値も増加と判定するか指定できます。
* デフォルトでは増加と判定しません。
*/
public static int lis(int[] nums){
return lis(nums,false);
}
public static int lis(int[][] nums,int p){
return lis(nums,p,false);
}
public static int lis(int[] nums,boolean include){
int[] list = new int[nums.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int i=0;i<nums.length;i++){
int index = include ? overSearch(list,nums[i]) : upSearch(list,nums[i]);
list[index] = Math.min(list[index],nums[i]);
}
int answer = underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
public static int lis(int[][] nums,int p,boolean include){
int[] list = new int[nums.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int i=0;i<nums.length;i++){
int index = include ? overSearch(list,nums[i][p]) : upSearch(list,nums[i][p]);
list[index] = Math.min(list[index],nums[i][p]);
}
int answer = underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length){
System.arraycopy(src,srcPos,dest,destPos,length);
}
public static long nanoTime(){
return System.nanoTime();
}
public static long currentTimeMillis(){
return System.currentTimeMillis();
}
public void exit(int num){
in.close();
out.close();
System.exit(num);
}
}
//SegmentTree
abstract class SegmentTree<E>{
int N,size;
E def;
Object[] node;
public SegmentTree(int n,E defa,boolean include){
N = 2;
size = 1;
while(N<n<<1){
N <<= 1;
size <<= 1;
}
size -= include?1:0;
node = new Object[N];
def = defa;
Arrays.fill(node,def);
}
public SegmentTree(int n,E defa){
this(n,defa,false);
}
@SuppressWarnings("unchecked")
public void update(int n,E value){
n += size;
node[n] = value;
n >>= 1;
while(n>0){
node[n] = function((E)node[n<<1],(E)node[(n<<1)+1]);
n >>= 1;
}
}
@SuppressWarnings("unchecked")
public E get(int a){
return (E)node[a+size];
}
@SuppressWarnings("unchecked")
public E answer(int a){
return (E)node[1];
}
@SuppressWarnings("unchecked")
public E query(int l,int r){
l += size;
r += size;
E answer = def;
while(l>0&&r>0&&l<=r){
if(l%2==1)
answer = function((E)node[l++],answer);
l >>= 1;
if(r%2==0)
answer = function(answer,(E)node[r--]);
r >>= 1;
}
return answer;
}
@SuppressWarnings("unchecked")
abstract public E function(E a,E b);
}
//Union-Find
class UnionFind{
private int[] par,rank,size;
private ArrayList<HashSet<Integer>> groupList;
private int N,count;
public UnionFind(int N){
this.N = N;
count = N;
par = new int[N];
rank = new int[N];
size = new int[N];
groupList = new ArrayList<HashSet<Integer>>();
for(int i=0;i<N;i++){
HashSet<Integer> temp = new HashSet<Integer>();
temp.add(i);
groupList.add(temp);
}
Arrays.fill(par,-1);
Arrays.fill(size,1);
}
public int root(int x){
if(par[x]==-1)
return x;
else
return par[x] = root(par[x]);
}
public boolean isSame(int x,int y){
return root(x)==root(y);
}
public boolean unite(int x,int y){
int rx = root(x);
int ry = root(y);
if(rx==ry)
return false;
if(rank[rx]<rank[ry]){
int temp = rx;
rx = ry;
ry = temp;
}
par[ry] = rx;
if(rank[rx]==rank[ry])
++rank[rx];
size[rx] += size[ry];
groupList.get(rx).addAll(groupList.get(ry));
groupList.set(ry,null);
--count;
return true;
}
public HashSet<Integer> getMember(int x){
int r = root(x);
return groupList.get(r);
}
public ArrayList<HashSet<Integer>> getAllGroup(){
final ArrayList<HashSet<Integer>> ans = new ArrayList<HashSet<Integer>>();
for(int i=0;i<N;i++){
HashSet<Integer> temp = groupList.get(i);
if(temp!=null)
ans.add(temp);
}
return ans;
}
public int groupCount(){
return count;
}
public int size(int x){
return size[root(x)];
}
}
//Pair
class Pair<K extends Comparable<K>,V extends Comparable<V>>
implements Comparable<Pair<K,V>>{
private AbstractMap.SimpleEntry<K,V> map;
public Pair(K key,V value){
map = new AbstractMap.SimpleEntry<K,V>(key,value);
}
public K getKey(){
return map.getKey();
}
public V getValue(){
return map.getValue();
}
public K setKey(K key){
K oldKey = map.getKey();
V value = map.getValue();
map = new AbstractMap.SimpleEntry<K,V>(key,value);
return oldKey;
}
public V setValue(V value){
return map.setValue(value);
}
@Override
public int compareTo(Pair<K,V> pair){
int com = getKey().compareTo(pair.getKey());
return com!=0?com:getValue().compareTo(pair.getValue());
}
@Override
public boolean equals(Object o){
if(!(o instanceof Map.Entry))
return false;
Pair<?,?> pair = (Pair<?,?>)o;
return getKey()==pair.getKey()&&getValue()==pair.getValue();
}
@Override
public String toString(){
return getKey()+"="+getValue();
}
}
/*////////////////////////////////////////////////
* My Scanner *
@auther viral
*/////////////////////////////////////////////////
class SimpleScanner{
final private int buff_size = 1<<15;
private InputStream is;
private byte[] buff;
private int point,length;
public SimpleScanner(InputStream is){
this.is = is;
buff = new byte[buff_size];
point = length = 0;
}
private void reload(){
do{
try{
length = is.read(buff,point = 0,buff_size);
}catch(IOException e){
e.printStackTrace();
System.exit(1);
}
}while(length==-1);
}
private byte read(){
if(point==length)reload();
return buff[point++];
}
public byte nextByte(){
byte c = read();
while(c<=' ')c = read();
return c;
}
public int nextInt(){
int ans = 0;
byte c = read();
while(c<=' ')c = read();
boolean negate = c == '-';
if(c=='-')c = read();
while('0'<=c&&c<='9'){
ans = ans*10+c-'0';
c = read();
}
return negate ? -ans : ans;
}
public long nextLong(){
long ans = 0;
byte c = read();
while(c<=' ')c = read();
boolean negate = c == '-';
if(c=='-')c = read();
while('0'<=c&&c<='9'){
ans = ans*10+c-'0';
c = read();
}
return negate ? -ans : ans;
}
public char nextChar(){
byte c = read();
while(c<=' ')c = read();
return (char)c;
}
public String next(){
StringBuilder ans = new StringBuilder();
byte c = read();
while(c<=' ')c = read();
while(c>' '){
ans.append((char)c);
c = read();
}
return ans.toString();
}
public byte[] nextByte(int n){
byte[] ans = new byte[n];
for(int i=0;i<n;i++){
ans[i] = nextByte();
}
return ans;
}
public int[] nextInt(int n){
int[] ans = new int[n];
for(int i=0;i<n;i++){
ans[i] = nextInt();
}
return ans;
}
public long[] nextLong(int n){
long[] ans = new long[n];
for(int i=0;i<n;i++){
ans[i] = nextLong();
}
return ans;
}
public String[] next(int n){
String[] ans = new String[n];
for(int i=0;i<n;i++){
ans[i] = next();
}
return ans;
}
public byte[][] nextByte(int n,int m){
byte[][] ans = new byte[n][];
for(int i=0;i<n;i++){
ans[i] = nextByte(m);
}
return ans;
}
public int[][] nextInt(int n,int m){
int[][] ans = new int[n][];
for(int i=0;i<n;i++){
ans[i] = nextInt(m);
}
return ans;
}
public long[][] nextLong(int n,int m){
long[][] ans = new long[n][];
for(int i=0;i<n;i++){
ans[i] = nextLong(m);
}
return ans;
}
public String[][] next(int n,int m){
String[][] ans = new String[n][];
for(int i=0;i<n;i++){
ans[i] = next(m);
}
return ans;
}
public char[] nextCharArray(){
return next().toCharArray();
}
public char[][] nextCharArray(int n){
char[][] ans = new char[n][];
for(int i=0;i<n;i++){
ans[i] = next().toCharArray();
}
return ans;
}
public void close(){
try{
is.close();
}catch(IOException e){
e.printStackTrace();
System.exit(1);
}
}
}
/*////////////////////////////////////////////////
* My Printer *
@auther viral
*/////////////////////////////////////////////////
class SimplePrinter extends PrintWriter{
public SimplePrinter(OutputStream os){
super(os);
}
public SimplePrinter(OutputStream os,boolean bool){
super(os,bool);
}
public void println(byte[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(byte[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(byte[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(byte[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(int[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(int[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(int[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(int[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(long[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(long[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(long[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(long[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(Byte[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(Byte[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(Byte[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(Byte[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(Integer[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(Integer[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(Integer[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(Integer[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(Long[] nums,String str){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(str);
print(nums[i]);
}
println();
}
public void println(Long[] nums,char c){
print(nums[0]);
for(int i=1;i<nums.length;i++){
print(c);
print(nums[i]);
}
println();
}
public void println(Long[][] nums,String str){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(str);
print(nums[i][j]);
}
println();
}
}
public void println(Long[][] nums,char c){
for(int i=0;i<nums.length;i++){
print(nums[i][0]);
for(int j=1;j<nums[i].length;j++){
print(c);
print(nums[i][j]);
}
println();
}
}
public void println(String[] strs,String str){
println(String.join(str,strs));
}
public void println(String[] strs,char c){
String str = String.valueOf(c);
println(String.join(str,strs));
}
public void println(String[][] strs,String str){
for(int i=0;i<strs.length;i++){
println(String.join(str,strs[i]));
}
}
public void println(String[][] strs,char c){
String str = String.valueOf(c);
for(int i=0;i<strs.length;i++){
println(String.join(str,strs[i]));
}
}
public void println(char[] cs,String str){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(str);
print(cs[i]);
}
println();
}
public void println(char[] cs,char c){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(c);
print(cs[i]);
}
println();
}
public void println(char[][] cs){
for(int i=0;i<cs.length;i++){
println(cs[i]);
}
}
public void println(char[][] cs,String str){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(str);
print(cs[i]);
}
println();
}
public void println(char[][] cs,char c){
print(cs[0]);
for(int i=1;i<cs.length;i++){
print(c);
print(cs[i]);
}
println();
}
}
| ConDefects/ConDefects/Code/arc129_a/Java/36023728 |
condefects-java_data_1668 | import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
long L = sc.nextLong();
long R = sc.nextLong();
char[] s = Long.toString(N,2).toCharArray();
int X = s.length;
long ans = 0;
for( int i = 0; i < X; i++ ) {
if( s[i] == '0' ) continue;
long high = Math.min((long)Math.pow(2,X-i)-1,R);
long low = Math.max((long)Math.pow(2,X-i-1),L);
if( high < L || low > R ) break;
ans += high-low+1;
}
System.out.println(ans);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
long N = sc.nextLong();
long L = sc.nextLong();
long R = sc.nextLong();
char[] s = Long.toString(N,2).toCharArray();
int X = s.length;
long ans = 0;
for( int i = 0; i < X; i++ ) {
if( s[i] == '0' ) continue;
long high = Math.min((long)Math.pow(2,X-i)-1,R);
long low = Math.max((long)Math.pow(2,X-i-1),L);
if( high < L || low > R ) continue;
ans += high-low+1;
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/arc129_a/Java/27446653 |
condefects-java_data_1669 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] input = br.readLine().split(" ");
br.close();
long n = Long.parseLong(input[0]);
long l = Long.parseLong(input[1]);
long r = Long.parseLong(input[2]);
long x = 1;
long ans = 0;
while (r >= x) {
if ((n ^ x) < n) {
long range_min = x;
long range_max = (x << 1) - 1;
ans += Math.min(range_max, r) - Math.max(range_min, l) + 1;
}
x = x << 1;
}
System.out.println(ans);
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] input = br.readLine().split(" ");
br.close();
long n = Long.parseLong(input[0]);
long l = Long.parseLong(input[1]);
long r = Long.parseLong(input[2]);
long x = 1;
long ans = 0;
while (r >= x) {
if ((n ^ x) < n) {
long range_min = x;
long range_max = (x << 1) - 1;
ans += Math.max(Math.min(range_max, r) - Math.max(range_min, l) + 1, 0);
}
x = x << 1;
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/arc129_a/Java/27482657 |
condefects-java_data_1670 | import javax.sql.rowset.spi.SyncResolver;
import javax.swing.*;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.BinaryOperator;
public class Main {
public static int[] dijkstraDistance;
public static void main(String[] args) {
ContestScanner scan = new ContestScanner();
long N = scan.nextLong();
List<Long> primes = new ArrayList<>();
boolean[] f = new boolean[(int) Math.ceil(Math.pow(N, 1D / 3D)) + 10];
for (long i = 2; i * i * i <= N; i++) {
if (f[(int) i]) continue;
primes.add(i);
for (long k = i; k * k * k <= N ; k += i) {
f[(int) k] = true;
}
}
long count = 0;
for (int i = 0; i < primes.size(); i++) {
long p = primes.get(i);
int ok = -1;
int ng = i;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (p * p * p * primes.get(mid) <= N) ok = mid;
else ng = mid;
}
count += ok + 1;
}
print(count);
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static long gcd(long l, long r) {
if (r == 0) return l;
return gcd(r, l % r);
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
public static <T extends Comparable<T>> T max(Collection<T> values) {
return Collections.max(values);
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> T min(Collection<T> values) {
return Collections.min(values);
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? -1 : 1);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static <T extends Comparable<T>> int[] lis(List<T> array) {
int N = array.size();
int[] result = new int[N];
List<T> B = new ArrayList<>();
for (int i = 0; i < N; i++) {
int k = lowerBound(B, array.get(i));
if (k == B.size()) B.add(array.get(i));
else B.set(k, array.get(i));
result[i] = k + 1;
}
return result;
}
public static long lsqrt(long x) {
long b = (long) Math.sqrt(x);
if (b * b > x) b--;
if (b * b < x) b++;
return b;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class DijkstraComparator<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return Integer.compare(Main.dijkstraDistance[(int) o1], Main.dijkstraDistance[(int) o2]);
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject> {
int i;
T value;
public IndexedObject(int i, T value) {
this.i = i;
this.value = value;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.value.equals(((IndexedObject<?>)o).value);
}
@Override
public int compareTo(IndexedObject o) {
if (o.value.getClass() != this.value.getClass()) throw new IllegalArgumentException();
return value.compareTo((T) o.value);
}
@Override
public int hashCode() {
return this.i + this.value.hashCode();
}
@Override
public String toString() {
return "IndexedObject{" +
"i=" + i +
", value=" + value +
'}';
}
}
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
return this.x == ((Point)o).x && this.y == ((Point)o).y;
}
@Override
public int hashCode() {
return Integer.hashCode(x) * 524287 + Integer.hashCode(y);
}
}
class GraphBuilder {
private Map<Integer, List<Integer>> edges = new HashMap<>();
private final int N;
private final boolean isDirected;
public GraphBuilder(int N, boolean isDirected) {
this.isDirected = isDirected;
this.N = N;
for (int i = 0; i < N; i++) {
edges.put(i, new ArrayList<>());
}
}
public GraphBuilder(int N) {
this(N, false);
}
public void addEdge(int u, int v) {
edges.get(u).add(v);
if (!isDirected) edges.get(v).add(u);
}
public Map<Integer, List<Integer>> getEdges() {
return edges;
}
public int getN() {
return N;
}
}
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(java.io.File file) throws java.io.FileNotFoundException {
this(new java.io.BufferedInputStream(new java.io.FileInputStream(file)));
}
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[] 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;
}
}
class ContestPrinter extends java.io.PrintWriter{
public ContestPrinter(java.io.PrintStream stream){
super(stream);
}
public ContestPrinter(java.io.File file) throws java.io.FileNotFoundException{
super(new java.io.PrintStream(file));
}
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;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(array[i]);
super.print(separator);
}
super.println(array[n-1]);
}
public void printArray(int[] array){
this.printArray(array, " ");
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n-1]));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map){
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(array[i]);
super.print(separator);
}
super.println(array[n-1]);
}
public void printArray(long[] array){
this.printArray(array, " ");
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n-1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map){
this.printArray(array, " ", map);
}
public <T> void printArray(T[] array, String separator){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(array[i]);
super.print(separator);
}
super.println(array[n-1]);
}
public <T> void printArray(T[] array){
this.printArray(array, " ");
}
public <T> void printArray(T[] array, String separator, java.util.function.UnaryOperator<T> map){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(map.apply(array[i]));
super.print(separator);
}
super.println(map.apply(array[n-1]));
}
public <T> void printArray(T[] array, java.util.function.UnaryOperator<T> map){
this.printArray(array, " ", map);
}
}
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;
}
}
class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
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<>();
}
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);
if (usesMontgomery) {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), maMontgomery.generate(i)));
}
} else {
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);
return create(ma.div(factorial.get(n), factorial.get(r)));
}
public ModInt combination(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r),factorial.get(n-r))));
}
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 (usesMontgomery) {
return maMontgomery.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);
}
}
}
}
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)
);
}
}
}
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();
}
}
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;
}
}
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();
}
}
class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>>{
S first;
T second;
public Pair(S s, T t){
first = s;
second = t;
}
public S getFirst(){return first;}
public T getSecond(){return second;}
public boolean equals(Object another){
if(this==another) return true;
if(!(another instanceof Pair)) return false;
Pair otherPair = (Pair)another;
return this.first.equals(otherPair.first) && this.second.equals(otherPair.second);
}
public int compareTo(Pair<S,T> another){
java.util.Comparator<Pair<S,T>> comp1 = java.util.Comparator.comparing(Pair::getFirst);
java.util.Comparator<Pair<S,T>> comp2 = comp1.thenComparing(Pair::getSecond);
return comp2.compare(this, another);
}
public int hashCode(){
return first.hashCode() * 10007 + second.hashCode();
}
public String toString(){
return String.format("(%s, %s)", first, second);
}
}
import javax.sql.rowset.spi.SyncResolver;
import javax.swing.*;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.BinaryOperator;
public class Main {
public static int[] dijkstraDistance;
public static void main(String[] args) {
ContestScanner scan = new ContestScanner();
long N = scan.nextLong();
List<Long> primes = new ArrayList<>();
boolean[] f = new boolean[(int) Math.ceil(Math.pow(N, 1D / 3D)) + 10];
for (long i = 2; i * i * i <= N; i++) {
if (f[(int) i]) continue;
primes.add(i);
for (long k = i; k * k * k <= N ; k += i) {
f[(int) k] = true;
}
}
long count = 0;
for (int i = 0; i < primes.size(); i++) {
long p = primes.get(i);
int ok = -1;
int ng = i;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (primes.get(mid) <= N / p / p / p) ok = mid;
else ng = mid;
}
count += ok + 1;
}
print(count);
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static long gcd(long l, long r) {
if (r == 0) return l;
return gcd(r, l % r);
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
public static <T extends Comparable<T>> T max(Collection<T> values) {
return Collections.max(values);
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> T min(Collection<T> values) {
return Collections.min(values);
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? -1 : 1);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static <T extends Comparable<T>> int[] lis(List<T> array) {
int N = array.size();
int[] result = new int[N];
List<T> B = new ArrayList<>();
for (int i = 0; i < N; i++) {
int k = lowerBound(B, array.get(i));
if (k == B.size()) B.add(array.get(i));
else B.set(k, array.get(i));
result[i] = k + 1;
}
return result;
}
public static long lsqrt(long x) {
long b = (long) Math.sqrt(x);
if (b * b > x) b--;
if (b * b < x) b++;
return b;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class DijkstraComparator<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return Integer.compare(Main.dijkstraDistance[(int) o1], Main.dijkstraDistance[(int) o2]);
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject> {
int i;
T value;
public IndexedObject(int i, T value) {
this.i = i;
this.value = value;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.value.equals(((IndexedObject<?>)o).value);
}
@Override
public int compareTo(IndexedObject o) {
if (o.value.getClass() != this.value.getClass()) throw new IllegalArgumentException();
return value.compareTo((T) o.value);
}
@Override
public int hashCode() {
return this.i + this.value.hashCode();
}
@Override
public String toString() {
return "IndexedObject{" +
"i=" + i +
", value=" + value +
'}';
}
}
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
return this.x == ((Point)o).x && this.y == ((Point)o).y;
}
@Override
public int hashCode() {
return Integer.hashCode(x) * 524287 + Integer.hashCode(y);
}
}
class GraphBuilder {
private Map<Integer, List<Integer>> edges = new HashMap<>();
private final int N;
private final boolean isDirected;
public GraphBuilder(int N, boolean isDirected) {
this.isDirected = isDirected;
this.N = N;
for (int i = 0; i < N; i++) {
edges.put(i, new ArrayList<>());
}
}
public GraphBuilder(int N) {
this(N, false);
}
public void addEdge(int u, int v) {
edges.get(u).add(v);
if (!isDirected) edges.get(v).add(u);
}
public Map<Integer, List<Integer>> getEdges() {
return edges;
}
public int getN() {
return N;
}
}
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(java.io.File file) throws java.io.FileNotFoundException {
this(new java.io.BufferedInputStream(new java.io.FileInputStream(file)));
}
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[] 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;
}
}
class ContestPrinter extends java.io.PrintWriter{
public ContestPrinter(java.io.PrintStream stream){
super(stream);
}
public ContestPrinter(java.io.File file) throws java.io.FileNotFoundException{
super(new java.io.PrintStream(file));
}
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;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(array[i]);
super.print(separator);
}
super.println(array[n-1]);
}
public void printArray(int[] array){
this.printArray(array, " ");
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n-1]));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map){
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(array[i]);
super.print(separator);
}
super.println(array[n-1]);
}
public void printArray(long[] array){
this.printArray(array, " ");
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n-1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map){
this.printArray(array, " ", map);
}
public <T> void printArray(T[] array, String separator){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(array[i]);
super.print(separator);
}
super.println(array[n-1]);
}
public <T> void printArray(T[] array){
this.printArray(array, " ");
}
public <T> void printArray(T[] array, String separator, java.util.function.UnaryOperator<T> map){
int n = array.length;
if(n==0){
super.println();
return;
}
for(int i=0; i<n-1; i++){
super.print(map.apply(array[i]));
super.print(separator);
}
super.println(map.apply(array[n-1]));
}
public <T> void printArray(T[] array, java.util.function.UnaryOperator<T> map){
this.printArray(array, " ", map);
}
}
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;
}
}
class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
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<>();
}
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);
if (usesMontgomery) {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), maMontgomery.generate(i)));
}
} else {
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);
return create(ma.div(factorial.get(n), factorial.get(r)));
}
public ModInt combination(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r),factorial.get(n-r))));
}
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 (usesMontgomery) {
return maMontgomery.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);
}
}
}
}
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)
);
}
}
}
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();
}
}
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;
}
}
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();
}
}
class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>>{
S first;
T second;
public Pair(S s, T t){
first = s;
second = t;
}
public S getFirst(){return first;}
public T getSecond(){return second;}
public boolean equals(Object another){
if(this==another) return true;
if(!(another instanceof Pair)) return false;
Pair otherPair = (Pair)another;
return this.first.equals(otherPair.first) && this.second.equals(otherPair.second);
}
public int compareTo(Pair<S,T> another){
java.util.Comparator<Pair<S,T>> comp1 = java.util.Comparator.comparing(Pair::getFirst);
java.util.Comparator<Pair<S,T>> comp2 = comp1.thenComparing(Pair::getSecond);
return comp2.compare(this, another);
}
public int hashCode(){
return first.hashCode() * 10007 + second.hashCode();
}
public String toString(){
return String.format("(%s, %s)", first, second);
}
} | ConDefects/ConDefects/Code/abc250_d/Java/44422871 |
condefects-java_data_1671 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Read input
int N = scanner.nextInt();
// Initialize result string
StringBuilder result = new StringBuilder();
for (int i = 0; i <= N; i++) {
boolean found = false;
for (int j = 9; j >= 1; j--) {
if (N % j == 0 && i % (N / j) == 0) {
result.append(j);
found = true;
break;
}
}
if (!found) {
result.append("-");
}
}
// Print the result
System.out.println(result.toString());
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Read input
int N = scanner.nextInt();
// Initialize result string
StringBuilder result = new StringBuilder();
for (int i = 0; i <= N; i++) {
boolean found = false;
for (int j = 1; j <= 9; j++) {
if (N % j == 0 && i % (N / j) == 0) {
result.append(j);
found = true;
break;
}
}
if (!found) {
result.append("-");
}
}
// Print the result
System.out.println(result.toString());
}
} | ConDefects/ConDefects/Code/abc319_b/Java/45401621 |
condefects-java_data_1672 | import java.util.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
@SuppressWarnings("unchecked")
public class Main {
public static PrintWriter pw = new PrintWriter(System.out);
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static int[][] dirs = {{0,1},{1,0},{0,-1},{-1,0}};
public static class Tree
{
Node root;
}
public static class Node
{
int v;
ArrayList<Node> children;
Node(int v, ArrayList<Node> children)
{
this.v = v;
this.children = children;
}
}
public static void dfs(int v , Set<Integer> ss)
{
ss.add(v);
ans++;
for(int x : graph[v])
{
if(!ss.contains(x))
{
dfs(x,ss);
}
}
ss.remove(v);
}
public static void sieveOfEratosthenes(int n)
{
// Create a boolean array "prime[0..n]" and initialize
// all entries it as true. A value in prime[i] will
// finally be false if i is Not a prime, else true.
boolean prime[] = new boolean[n+1];
for(int i=0;i<=n;i++)
prime[i] = true;
for(int p = 2; p*p <=n; p++)
{
// If prime[p] is not changed, then it is a prime
if(prime[p] == true)
{
// Update all multiples of p
for(int i = p*p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for(int i = 2; i <= n; i++)
{
if(prime[i] == true)
System.out.print(i + " ");
}
}
public static ArrayList<Integer> prime_fast()
{
ArrayList<Integer>P=new ArrayList();
boolean[]F=new boolean[32000];
P.add(2);
for(int i=3;i<32000;i+=2) {
if (F[i]) continue;
P.add(i);
for (int j=i*2;j<32000;j+=i) F[j]=true;
}
return P;
}
// dsu
public static int find(int x)
{
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
public static void union(int x, int y)
{
// Find representatives of two sets
int xRoot = find(x), yRoot = find(y);
// Elements are in the same set, no need
// to unite anything.
if (xRoot == yRoot)
return;
// If x's rank is less than y's rank
if (rank[xRoot] < rank[yRoot])
{// Then move x under y so that depth
// of tree remains less
parent[xRoot] = yRoot;
rank[yRoot] +=rank[xRoot];
rank[xRoot]=1;
}
// Else if y's rank is less than x's rank
else if (rank[yRoot] < rank[xRoot])
{
// Then move y under x so that depth of
// tree remains less
parent[yRoot] = xRoot;
rank[xRoot] +=rank[yRoot];
rank[yRoot]=1;
}
else // if ranks are the same
{
// Then move y under x (doesn't matter
// which one goes where)
parent[yRoot] = xRoot;
// And increment the result tree's
// rank by 1
rank[xRoot] = rank[xRoot] + rank[yRoot];
rank[yRoot]=1;
}
}
public static void makegraph(int n , int m)
{
for(int a=0;a<n;a++)
{
graph[a] = new ArrayList<>();
}
for(int a=0;a<m;a++)
{
int v1 = scn.nextInt()-1;
int v2 = scn.nextInt()-1;
graph[v1].add(v2);
graph[v2].add(v1);
}
}
public static int[] arrInt(int n)
{
int [] arr = new int[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextInt();}
return arr;
}
public static long[] arrLong(int n)
{
long [] arr = new long[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextLong();}
return arr;
}
public static int[] arrInt()
{
int n = scn.nextInt();
int [] arr = new int[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextInt();}
return arr;
}
public static long[] arrLong()
{
int n = scn.nextInt();
long [] arr = new long[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextLong();}
return arr;
}
public static void display(int [] arr)
{
for(int i : arr)
{pw.print(i+" ");}
pw.println();
}
public static void display(long [] arr)
{
for(long i : arr)
{pw.print(i+" ");}
pw.println();
}
// ==================== MATHEMATICAL FUNCTIONS ===========================
private static int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
private static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
private static int lcm(int a, int b) {
return (a / gcd(a, b)) * b;
}
private static long lcm(long a, long b) {
return (a / gcd(a, b)) * b;
}
private static int mod_pow(long a, long b, long mod) {
if (b == 0)
return 1;
int temp = mod_pow(a, b >> 1, mod);
temp %= mod;
temp = (int) ((1L * temp * temp) % mod);
if ((b & 1) == 1)
temp = (int) ((1L * temp * a) % mod);
return temp;
}
private static long multiply(long a, long b) {
return (((a % mod) * (b % mod)) % mod);
}
private static long divide(long a, long b) {
return multiply(a, mod_pow(b, mod - 2,mod));
}
private static boolean isPrime(long n) {
for (long i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
public static long fact(long n)
{
return (n == 1 || n == 0) ? 1 : n * fact(n - 1);
}
public static long ncr(long n, long k)
{
long res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of
// [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
public static long power(long x, long y, long p)
{
// Initialize result
long res = 1;
// Update x if it is more than or
// equal to p
x = x % p;
while (y > 0) {
// If y is odd, multiply x
// with result
if (y % 2 == 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
// Returns n^(-1) mod p
public static long modInverse(long n, long p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's
// little theorem.
public static long nCrModPFermat(long n, long r,
long p)
{
if (n<r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
long[] fac = new long[(int)(n + 1)];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[(int)n] * modInverse(fac[(int)r], p)
% p * modInverse(fac[(int)(n - r)], p)
% p)
% p;
}
private static List<Integer> factors(int n) {
List<Integer> list = new ArrayList<>();
for (int i = 1; 1L * i * i <= n; i++)
if (n % i == 0) {
list.add(i);
if (i != n / i)
list.add(n / i);
}
return list;
}
private static List<Long> factors(long n) {
List<Long> list = new ArrayList<>();
for (long i = 1; i * i <= n; i++)
if (n % i == 0) {
list.add(i);
if (i != n / i)
list.add(n / i);
}
return list;
}
// gp sum
// starting from a^0 common factor = a , no. of terms = n, modulo m
private static long gp_sum(long a, long n, long m) {
if (n == 0) {
return 0;
}
if (n % 2 != 0) {
return (power(a, n - 1, m) + gp_sum(a, n - 1, m)) % m;
}
long t = gp_sum(a, n / 2, m);
long b = power(a, n / 2, m);
return (b + 1) * t % m;
}
// trie
static class Trie {
static class Node {
public Node[] children;
public int sz = 0;
Node() {
children = new Node[26];
}
}
private Node head;
public Trie() {
head = new Node();
}
public int query(String word) {
Node curr = head;
int n = word.length();
for (int i = 0; i < n; ++i) {
int ch = word.charAt(i) - 'a';
if (curr.children[ch] != null && curr.children[ch].sz > 0) {
curr = curr.children[ch];
} else {
return i;
}
}
return n;
}
public void insert(String word) {
Node curr = head;
int n = word.length();
for (int i = 0; i < n; ++i) {
int ch = word.charAt(i) - 'a';
if (curr.children[ch] == null) {
curr.children[ch] = new Node();
}
curr = curr.children[ch];
curr.sz++;
}
}
public void erase(String word) {
Node curr = head;
int idx = 0, n = word.length();
while (idx < n) {
int ch = word.charAt(idx) - 'a';
curr = curr.children[ch];
curr.sz--;
++idx;
}
}
}
static class LazyRangeSumSegmentTree {
int n;
int tree[];
int lazy[];
LazyRangeSumSegmentTree(int[] arr) {
this.n = arr.length;
int m = nextPowerOf2(n);
this.tree = new int[m * 2 - 1];
this.lazy = new int[m * 2 - 1];
constructSegTree(arr, 0, n - 1, 0);
}
void constructSegTree(int arr[], int lo, int hi, int idx) {
if (lo > hi) {
return;
}
if (lo == hi) {
tree[idx] = arr[lo];
return;
}
int mid = (lo + hi) / 2;
constructSegTree(arr, lo, mid, idx * 2 + 1);
constructSegTree(arr, mid + 1, hi, idx * 2 + 2);
tree[idx] = tree[idx * 2 + 1] + tree[idx * 2 + 2];
}
// Update by adding inc to all values in [b, e]
public void updateRange(int b, int e, int inc) {
if (b > e) {
return;
}
updateRangeInner(0, 0, n - 1, b, e, inc);
}
// Set value at a specific index.
public void set(int index, int value) {
checkIndex(index);
int vcurr = getRangeSum(index, index);
int inc = value - vcurr;
updateRange(index, index, inc);
}
// Gets value at the specific index
public int getAt(int index) {
checkIndex(index);
return getRangeSum(0, 0, n - 1, index, index);
}
// Get sum in range [b, e]
public int getRangeSum(int b, int e) {
if (b < 0 || e > n - 1 || b > e) {
return 0;
}
return getRangeSum(0, 0, n - 1, b, e);
}
private void checkIndex(int index) {
if (index < 0 || index >= n) {
throw new RuntimeException("Invalid index " + index);
}
}
private void updateRangeInner(int idx, int lo, int hi, int b, int e, int inc) {
applyLazy(idx, lo, hi);
if (lo > hi || lo > e || hi < b) {
return;
}
if (lo >= b && hi <= e) {
tree[idx] += inc * (hi - lo + 1);
if (lo != hi) {
lazy[idx * 2 + 1] += inc;
lazy[idx * 2 + 2] += inc;
}
return;
}
int mid = (lo + hi) / 2;
updateRangeInner(idx * 2 + 1, lo, mid, b, e, inc);
updateRangeInner(idx * 2 + 2, mid + 1, hi, b, e, inc);
tree[idx] = tree[idx * 2 + 1] + tree[idx * 2 + 2];
}
private int getRangeSum(int idx, int lo, int hi, int b, int e) {
applyLazy(idx, lo, hi);
if (lo > hi || lo > e || hi < b) {
return 0;
}
if (lo >= b && hi <= e) {
return tree[idx];
}
int mid = (lo + hi) / 2;
return getRangeSum(2 * idx + 1, lo, mid, b, e) +
getRangeSum(2 * idx + 2, mid + 1, hi, b, e);
}
private void applyLazy(int idx, int lo, int hi) {
if (lazy[idx] != 0) {
tree[idx] += lazy[idx] * (hi - lo + 1);
if (lo != hi) {
lazy[idx * 2 + 1] += lazy[idx];
lazy[idx * 2 + 2] += lazy[idx];
}
lazy[idx] = 0;
}
}
public static int nextPowerOf2(int num){
if (num == 0) {
return 1;
}
if (num > 0 && (num & (num-1)) == 0) {
return num;
}
while ((num & (num-1)) > 0) {
num = num & (num - 1);
}
return num << 1;
}
}
//public static ArrayList<ArrayList<Integer>> fans = new ArrayList<>();
public static int [] parent = null;
public static int [] rank = null;
public static ArrayList<Integer>[] graph = null;
public static int ans = 0;
public static FastReader scn = new FastReader();
public static long c = 1000000007;
public static long mod = 1000000007;
// use Collections.sort() instead of Arrays.sort()
public static void main(String[] args)
{
scn = new FastReader();
//graph = new ArrayList[n];
//LazyRangeSumSegmentTree st = new LazyRangeSumSegmentTree(new int[n+1]);
int n = scn.nextInt();
int [] ans = new int[n+1];
Arrays.fill(ans,-1);
TreeSet<Integer> ss = new TreeSet<>();
for(int a=1;a<=9;a++)
{
if(n%a==0)ss.add(a);
}
ans[0] = 1;
for(int a=1;a<=n;a++)
{
for(int val : ss)
{
int v = n/val;
if(a%v==0)
{
ans[a] = val;
break;
}
}
}
for(int i : ans)
{
if(i==-1)
{pw.print("_");}
else
{pw.print(i);}
}
pw.println();
pw.close();}
}
import java.util.*;
import java.io.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
@SuppressWarnings("unchecked")
public class Main {
public static PrintWriter pw = new PrintWriter(System.out);
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(
new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
}
catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() { return Integer.parseInt(next()); }
long nextLong() { return Long.parseLong(next()); }
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try {
str = br.readLine();
}
catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
public static int[][] dirs = {{0,1},{1,0},{0,-1},{-1,0}};
public static class Tree
{
Node root;
}
public static class Node
{
int v;
ArrayList<Node> children;
Node(int v, ArrayList<Node> children)
{
this.v = v;
this.children = children;
}
}
public static void dfs(int v , Set<Integer> ss)
{
ss.add(v);
ans++;
for(int x : graph[v])
{
if(!ss.contains(x))
{
dfs(x,ss);
}
}
ss.remove(v);
}
public static void sieveOfEratosthenes(int n)
{
// Create a boolean array "prime[0..n]" and initialize
// all entries it as true. A value in prime[i] will
// finally be false if i is Not a prime, else true.
boolean prime[] = new boolean[n+1];
for(int i=0;i<=n;i++)
prime[i] = true;
for(int p = 2; p*p <=n; p++)
{
// If prime[p] is not changed, then it is a prime
if(prime[p] == true)
{
// Update all multiples of p
for(int i = p*p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for(int i = 2; i <= n; i++)
{
if(prime[i] == true)
System.out.print(i + " ");
}
}
public static ArrayList<Integer> prime_fast()
{
ArrayList<Integer>P=new ArrayList();
boolean[]F=new boolean[32000];
P.add(2);
for(int i=3;i<32000;i+=2) {
if (F[i]) continue;
P.add(i);
for (int j=i*2;j<32000;j+=i) F[j]=true;
}
return P;
}
// dsu
public static int find(int x)
{
if (parent[x] != x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
public static void union(int x, int y)
{
// Find representatives of two sets
int xRoot = find(x), yRoot = find(y);
// Elements are in the same set, no need
// to unite anything.
if (xRoot == yRoot)
return;
// If x's rank is less than y's rank
if (rank[xRoot] < rank[yRoot])
{// Then move x under y so that depth
// of tree remains less
parent[xRoot] = yRoot;
rank[yRoot] +=rank[xRoot];
rank[xRoot]=1;
}
// Else if y's rank is less than x's rank
else if (rank[yRoot] < rank[xRoot])
{
// Then move y under x so that depth of
// tree remains less
parent[yRoot] = xRoot;
rank[xRoot] +=rank[yRoot];
rank[yRoot]=1;
}
else // if ranks are the same
{
// Then move y under x (doesn't matter
// which one goes where)
parent[yRoot] = xRoot;
// And increment the result tree's
// rank by 1
rank[xRoot] = rank[xRoot] + rank[yRoot];
rank[yRoot]=1;
}
}
public static void makegraph(int n , int m)
{
for(int a=0;a<n;a++)
{
graph[a] = new ArrayList<>();
}
for(int a=0;a<m;a++)
{
int v1 = scn.nextInt()-1;
int v2 = scn.nextInt()-1;
graph[v1].add(v2);
graph[v2].add(v1);
}
}
public static int[] arrInt(int n)
{
int [] arr = new int[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextInt();}
return arr;
}
public static long[] arrLong(int n)
{
long [] arr = new long[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextLong();}
return arr;
}
public static int[] arrInt()
{
int n = scn.nextInt();
int [] arr = new int[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextInt();}
return arr;
}
public static long[] arrLong()
{
int n = scn.nextInt();
long [] arr = new long[n];
for(int a=0;a<n;a++)
{arr[a] = scn.nextLong();}
return arr;
}
public static void display(int [] arr)
{
for(int i : arr)
{pw.print(i+" ");}
pw.println();
}
public static void display(long [] arr)
{
for(long i : arr)
{pw.print(i+" ");}
pw.println();
}
// ==================== MATHEMATICAL FUNCTIONS ===========================
private static int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
private static long gcd(long a, long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
private static int lcm(int a, int b) {
return (a / gcd(a, b)) * b;
}
private static long lcm(long a, long b) {
return (a / gcd(a, b)) * b;
}
private static int mod_pow(long a, long b, long mod) {
if (b == 0)
return 1;
int temp = mod_pow(a, b >> 1, mod);
temp %= mod;
temp = (int) ((1L * temp * temp) % mod);
if ((b & 1) == 1)
temp = (int) ((1L * temp * a) % mod);
return temp;
}
private static long multiply(long a, long b) {
return (((a % mod) * (b % mod)) % mod);
}
private static long divide(long a, long b) {
return multiply(a, mod_pow(b, mod - 2,mod));
}
private static boolean isPrime(long n) {
for (long i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
public static long fact(long n)
{
return (n == 1 || n == 0) ? 1 : n * fact(n - 1);
}
public static long ncr(long n, long k)
{
long res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of
// [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
for (long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
public static long power(long x, long y, long p)
{
// Initialize result
long res = 1;
// Update x if it is more than or
// equal to p
x = x % p;
while (y > 0) {
// If y is odd, multiply x
// with result
if (y % 2 == 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
// Returns n^(-1) mod p
public static long modInverse(long n, long p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's
// little theorem.
public static long nCrModPFermat(long n, long r,
long p)
{
if (n<r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
long[] fac = new long[(int)(n + 1)];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[(int)n] * modInverse(fac[(int)r], p)
% p * modInverse(fac[(int)(n - r)], p)
% p)
% p;
}
private static List<Integer> factors(int n) {
List<Integer> list = new ArrayList<>();
for (int i = 1; 1L * i * i <= n; i++)
if (n % i == 0) {
list.add(i);
if (i != n / i)
list.add(n / i);
}
return list;
}
private static List<Long> factors(long n) {
List<Long> list = new ArrayList<>();
for (long i = 1; i * i <= n; i++)
if (n % i == 0) {
list.add(i);
if (i != n / i)
list.add(n / i);
}
return list;
}
// gp sum
// starting from a^0 common factor = a , no. of terms = n, modulo m
private static long gp_sum(long a, long n, long m) {
if (n == 0) {
return 0;
}
if (n % 2 != 0) {
return (power(a, n - 1, m) + gp_sum(a, n - 1, m)) % m;
}
long t = gp_sum(a, n / 2, m);
long b = power(a, n / 2, m);
return (b + 1) * t % m;
}
// trie
static class Trie {
static class Node {
public Node[] children;
public int sz = 0;
Node() {
children = new Node[26];
}
}
private Node head;
public Trie() {
head = new Node();
}
public int query(String word) {
Node curr = head;
int n = word.length();
for (int i = 0; i < n; ++i) {
int ch = word.charAt(i) - 'a';
if (curr.children[ch] != null && curr.children[ch].sz > 0) {
curr = curr.children[ch];
} else {
return i;
}
}
return n;
}
public void insert(String word) {
Node curr = head;
int n = word.length();
for (int i = 0; i < n; ++i) {
int ch = word.charAt(i) - 'a';
if (curr.children[ch] == null) {
curr.children[ch] = new Node();
}
curr = curr.children[ch];
curr.sz++;
}
}
public void erase(String word) {
Node curr = head;
int idx = 0, n = word.length();
while (idx < n) {
int ch = word.charAt(idx) - 'a';
curr = curr.children[ch];
curr.sz--;
++idx;
}
}
}
static class LazyRangeSumSegmentTree {
int n;
int tree[];
int lazy[];
LazyRangeSumSegmentTree(int[] arr) {
this.n = arr.length;
int m = nextPowerOf2(n);
this.tree = new int[m * 2 - 1];
this.lazy = new int[m * 2 - 1];
constructSegTree(arr, 0, n - 1, 0);
}
void constructSegTree(int arr[], int lo, int hi, int idx) {
if (lo > hi) {
return;
}
if (lo == hi) {
tree[idx] = arr[lo];
return;
}
int mid = (lo + hi) / 2;
constructSegTree(arr, lo, mid, idx * 2 + 1);
constructSegTree(arr, mid + 1, hi, idx * 2 + 2);
tree[idx] = tree[idx * 2 + 1] + tree[idx * 2 + 2];
}
// Update by adding inc to all values in [b, e]
public void updateRange(int b, int e, int inc) {
if (b > e) {
return;
}
updateRangeInner(0, 0, n - 1, b, e, inc);
}
// Set value at a specific index.
public void set(int index, int value) {
checkIndex(index);
int vcurr = getRangeSum(index, index);
int inc = value - vcurr;
updateRange(index, index, inc);
}
// Gets value at the specific index
public int getAt(int index) {
checkIndex(index);
return getRangeSum(0, 0, n - 1, index, index);
}
// Get sum in range [b, e]
public int getRangeSum(int b, int e) {
if (b < 0 || e > n - 1 || b > e) {
return 0;
}
return getRangeSum(0, 0, n - 1, b, e);
}
private void checkIndex(int index) {
if (index < 0 || index >= n) {
throw new RuntimeException("Invalid index " + index);
}
}
private void updateRangeInner(int idx, int lo, int hi, int b, int e, int inc) {
applyLazy(idx, lo, hi);
if (lo > hi || lo > e || hi < b) {
return;
}
if (lo >= b && hi <= e) {
tree[idx] += inc * (hi - lo + 1);
if (lo != hi) {
lazy[idx * 2 + 1] += inc;
lazy[idx * 2 + 2] += inc;
}
return;
}
int mid = (lo + hi) / 2;
updateRangeInner(idx * 2 + 1, lo, mid, b, e, inc);
updateRangeInner(idx * 2 + 2, mid + 1, hi, b, e, inc);
tree[idx] = tree[idx * 2 + 1] + tree[idx * 2 + 2];
}
private int getRangeSum(int idx, int lo, int hi, int b, int e) {
applyLazy(idx, lo, hi);
if (lo > hi || lo > e || hi < b) {
return 0;
}
if (lo >= b && hi <= e) {
return tree[idx];
}
int mid = (lo + hi) / 2;
return getRangeSum(2 * idx + 1, lo, mid, b, e) +
getRangeSum(2 * idx + 2, mid + 1, hi, b, e);
}
private void applyLazy(int idx, int lo, int hi) {
if (lazy[idx] != 0) {
tree[idx] += lazy[idx] * (hi - lo + 1);
if (lo != hi) {
lazy[idx * 2 + 1] += lazy[idx];
lazy[idx * 2 + 2] += lazy[idx];
}
lazy[idx] = 0;
}
}
public static int nextPowerOf2(int num){
if (num == 0) {
return 1;
}
if (num > 0 && (num & (num-1)) == 0) {
return num;
}
while ((num & (num-1)) > 0) {
num = num & (num - 1);
}
return num << 1;
}
}
//public static ArrayList<ArrayList<Integer>> fans = new ArrayList<>();
public static int [] parent = null;
public static int [] rank = null;
public static ArrayList<Integer>[] graph = null;
public static int ans = 0;
public static FastReader scn = new FastReader();
public static long c = 1000000007;
public static long mod = 1000000007;
// use Collections.sort() instead of Arrays.sort()
public static void main(String[] args)
{
scn = new FastReader();
//graph = new ArrayList[n];
//LazyRangeSumSegmentTree st = new LazyRangeSumSegmentTree(new int[n+1]);
int n = scn.nextInt();
int [] ans = new int[n+1];
Arrays.fill(ans,-1);
TreeSet<Integer> ss = new TreeSet<>();
for(int a=1;a<=9;a++)
{
if(n%a==0)ss.add(a);
}
ans[0] = 1;
for(int a=1;a<=n;a++)
{
for(int val : ss)
{
int v = n/val;
if(a%v==0)
{
ans[a] = val;
break;
}
}
}
for(int i : ans)
{
if(i==-1)
{pw.print("-");}
else
{pw.print(i);}
}
pw.println();
pw.close();}
}
| ConDefects/ConDefects/Code/abc319_b/Java/45576231 |
condefects-java_data_1673 | import java.util.*;
public class Main{
public static void main(String[]args){
Scanner s=new Scanner(System.in);
int n=s.nextInt();
StringBuilder sb=new StringBuilder();
for(int i=1;i<=n;i++){
boolean find=false;
for(int j=1;j<=9;j++ ){
if(n%j==0 && i%(n/j)==0){
sb.append(j);
find=true;
break;
}
}
if(!find)
sb.append("-");
}
System.out.println(sb.toString());
}
}
import java.util.*;
public class Main{
public static void main(String[]args){
Scanner s=new Scanner(System.in);
int n=s.nextInt();
StringBuilder sb=new StringBuilder();
for(int i=0;i<=n;i++){
boolean find=false;
for(int j=1;j<=9;j++ ){
if(n%j==0 && i%(n/j)==0){
sb.append(j);
find=true;
break;
}
}
if(!find)
sb.append("-");
}
System.out.println(sb.toString());
}
} | ConDefects/ConDefects/Code/abc319_b/Java/45393196 |
condefects-java_data_1674 | import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
public static FastScanner sc = new FastScanner(System.in);
public static void main(String[] args){
// 自動フラッシュオフ
PrintWriter out = new PrintWriter(System.out);
// 入力
int N = ini();
int M = ini();
int[] A = inia(N);
int[] B = inia(M);
Arrays.sort(A);
Arrays.sort(B);
int Amin = A[0];
int Bmax = B[M-1];
int ans = 0;
// 算出
TreeSet<Integer> numSet = new TreeSet<>();
for(int i = 0; i < N; i++){
numSet.add(A[i]);
}
for(int i = 0; i < M; i++){
numSet.add(B[i]+1);
}
//out.println(numSet);
for(int num : numSet){
/*
int sell = getLower(A,num-1);
int buy = getHigher(B,num-1);
//out.print(num-1);
//out.println(": sell:" + sell + " buy:" + buy);
if(sell >= buy){
ans = num-1;
break;
}
*/
int sell = getLower(A,num);
int buy = getHigher(B,num);
//out.print(num);
//out.println(": sell:" + sell + " buy:" + buy);
if(sell >= buy){
ans = num;
break;
}
/*
sell = getLower(A,num+1);
buy = getHigher(B,num+1);
//out.print(num+1);
//out.println(": sell:" + sell + " buy:" + buy);
if(sell >= buy){
ans = num+1;
break;
}
*/
}
// debug
/*
out.println(getLower(B, 79));
out.println(getLower(B, 80));
out.println(getLower(B, 81));
out.println(getLower(B, 99));
out.println(getLower(B, 100));
out.println(getLower(B, 101));
out.println(getLower(B, 119));
out.println(getLower(B, 120));
out.println(getLower(B, 121));
out.println(getLower(B, 9999));
out.println(getLower(B, 10000));
out.println(getLower(B, 10001));
*/
// 出力
out.println(ans);
// フラッシュ
out.flush();
}
// 配列Aの中にX以下がいくつあるか数える関数
public static int getLower(int[] A, int X){
int res = 0;
int L = A.length;
if(X < A[0]){
res = 0;
}
else if(A[L-1] <= X){
res = L;
}
else{
int left = 0;
int right = L-1;
while(right - left > 1){
int center = (left + right) / 2;
if(A[center] < X){
left = center;
}
else{
right = center;
}
}
if(X < A[left]){
res = left;
}
else if(X < A[right]){
res = right;
}
else{
res = right+1;
}
}
return res;
}
// 配列Aの中にX以上がいくつあるか数える関数
public static int getHigher(int[] A, int X){
int res = 0;
int L = A.length;
if(X <= A[0]){
res = L;
}
else if(A[L-1] < X){
res = 0;
}
else{
int left = 0;
int right = L-1;
while(right - left > 1){
int center = (left + right) / 2;
if(A[center] < X){
left = center;
}
else{
right = center;
}
}
if(A[right] < X){
res = L - right - 1;
}
else if(A[left] < X){
res = L - left - 1;
}
else{
res = L - left;
}
}
return res;
}
// インプット関数
public static int ini(){
return sc.nextInt();
}
public static long inl(){
return sc.nextLong();
}
public static double ind(){
return sc.nextDouble();
}
public static String ins(){
return sc.next();
}
public static int[] inia(int N){
int[] A = new int[N];
for(int i = 0; i < N; i++){
A[i] = ini();
}
return A;
}
public static void inia(int[] A, int[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ini();
B[i] = ini();
}
}
public static void inia(int[] A, int[] B, int[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ini();
B[i] = ini();
C[i] = ini();
}
}
public static long[] inla(int N){
long[] A = new long[N];
for(int i = 0; i < N; i++){
A[i] = inl();
}
return A;
}
public static void inla(long[] A, long[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = inl();
B[i] = inl();
}
}
public static void inla(long[] A, long[] B, long[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = inl();
B[i] = inl();
C[i] = inl();
}
}
public static double[] inda(int N){
double[] A = new double[N];
for(int i = 0; i < N; i++){
A[i] = ind();
}
return A;
}
public static void inda(double[] A, double[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ind();
B[i] = ind();
}
}
public static void inda(double[] A, double[] B, double[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ind();
B[i] = ind();
C[i] = ind();
}
}
public static String[] insa(int N){
String[] A = new String[N];
for(int i = 0; i < N; i++){
A[i] = ins();
}
return A;
}
public static void insa(String[] A, String[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ins();
B[i] = ins();
}
}
public static void insa(String[] A, String[] B, String[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ins();
B[i] = ins();
C[i] = ins();
}
}
public static char[] inca(){
return ins().toCharArray();
}
// 高速スキャナー
static class FastScanner {
private BufferedReader reader = null;
private StringTokenizer tokenizer = null;
public FastScanner(InputStream in) {
reader = new BufferedReader(new InputStreamReader(in));
tokenizer = null;
}
public String next() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken("\n");
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
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 long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
}
}
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
public static FastScanner sc = new FastScanner(System.in);
public static void main(String[] args){
// 自動フラッシュオフ
PrintWriter out = new PrintWriter(System.out);
// 入力
int N = ini();
int M = ini();
int[] A = inia(N);
int[] B = inia(M);
Arrays.sort(A);
Arrays.sort(B);
int Amin = A[0];
int Bmax = B[M-1];
int ans = 0;
// 算出
TreeSet<Integer> numSet = new TreeSet<>();
for(int i = 0; i < N; i++){
numSet.add(A[i]);
}
for(int i = 0; i < M; i++){
numSet.add(B[i]+1);
}
//out.println(numSet);
for(int num : numSet){
/*
int sell = getLower(A,num-1);
int buy = getHigher(B,num-1);
//out.print(num-1);
//out.println(": sell:" + sell + " buy:" + buy);
if(sell >= buy){
ans = num-1;
break;
}
*/
int sell = getLower(A,num);
int buy = getHigher(B,num);
//out.print(num);
//out.println(": sell:" + sell + " buy:" + buy);
if(sell >= buy){
ans = num;
break;
}
/*
sell = getLower(A,num+1);
buy = getHigher(B,num+1);
//out.print(num+1);
//out.println(": sell:" + sell + " buy:" + buy);
if(sell >= buy){
ans = num+1;
break;
}
*/
}
// debug
/*
out.println(getLower(B, 79));
out.println(getLower(B, 80));
out.println(getLower(B, 81));
out.println(getLower(B, 99));
out.println(getLower(B, 100));
out.println(getLower(B, 101));
out.println(getLower(B, 119));
out.println(getLower(B, 120));
out.println(getLower(B, 121));
out.println(getLower(B, 9999));
out.println(getLower(B, 10000));
out.println(getLower(B, 10001));
*/
// 出力
out.println(ans);
// フラッシュ
out.flush();
}
// 配列Aの中にX以下がいくつあるか数える関数
public static int getLower(int[] A, int X){
int res = 0;
int L = A.length;
if(X < A[0]){
res = 0;
}
else if(A[L-1] <= X){
res = L;
}
else{
int left = 0;
int right = L-1;
while(right - left > 1){
int center = (left + right) / 2;
if(A[center] <= X){
left = center;
}
else{
right = center;
}
}
if(X < A[left]){
res = left;
}
else if(X < A[right]){
res = right;
}
else{
res = right+1;
}
}
return res;
}
// 配列Aの中にX以上がいくつあるか数える関数
public static int getHigher(int[] A, int X){
int res = 0;
int L = A.length;
if(X <= A[0]){
res = L;
}
else if(A[L-1] < X){
res = 0;
}
else{
int left = 0;
int right = L-1;
while(right - left > 1){
int center = (left + right) / 2;
if(A[center] < X){
left = center;
}
else{
right = center;
}
}
if(A[right] < X){
res = L - right - 1;
}
else if(A[left] < X){
res = L - left - 1;
}
else{
res = L - left;
}
}
return res;
}
// インプット関数
public static int ini(){
return sc.nextInt();
}
public static long inl(){
return sc.nextLong();
}
public static double ind(){
return sc.nextDouble();
}
public static String ins(){
return sc.next();
}
public static int[] inia(int N){
int[] A = new int[N];
for(int i = 0; i < N; i++){
A[i] = ini();
}
return A;
}
public static void inia(int[] A, int[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ini();
B[i] = ini();
}
}
public static void inia(int[] A, int[] B, int[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ini();
B[i] = ini();
C[i] = ini();
}
}
public static long[] inla(int N){
long[] A = new long[N];
for(int i = 0; i < N; i++){
A[i] = inl();
}
return A;
}
public static void inla(long[] A, long[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = inl();
B[i] = inl();
}
}
public static void inla(long[] A, long[] B, long[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = inl();
B[i] = inl();
C[i] = inl();
}
}
public static double[] inda(int N){
double[] A = new double[N];
for(int i = 0; i < N; i++){
A[i] = ind();
}
return A;
}
public static void inda(double[] A, double[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ind();
B[i] = ind();
}
}
public static void inda(double[] A, double[] B, double[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ind();
B[i] = ind();
C[i] = ind();
}
}
public static String[] insa(int N){
String[] A = new String[N];
for(int i = 0; i < N; i++){
A[i] = ins();
}
return A;
}
public static void insa(String[] A, String[] B){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ins();
B[i] = ins();
}
}
public static void insa(String[] A, String[] B, String[] C){
int n = A.length;
for(int i = 0; i < n; i++){
A[i] = ins();
B[i] = ins();
C[i] = ins();
}
}
public static char[] inca(){
return ins().toCharArray();
}
// 高速スキャナー
static class FastScanner {
private BufferedReader reader = null;
private StringTokenizer tokenizer = null;
public FastScanner(InputStream in) {
reader = new BufferedReader(new InputStreamReader(in));
tokenizer = null;
}
public String next() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
if (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
return reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken("\n");
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
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 long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
}
} | ConDefects/ConDefects/Code/abc312_c/Java/44604401 |
condefects-java_data_1675 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[]a=new int[n];
int[]b=new int[m];
for(int i=0;i<n;i++){
a[i]=sc.nextInt();
}
for(int i=0;i<m;i++){
b[i]=sc.nextInt();
}
Arrays.sort(a);
Arrays.sort(b);
int left=0;
int right=10000001;
while(right-left>1){
int mid=(left+right)/2;
int ac=0;
int bc=0;
for(int i=0;i<n;i++){
if(a[i]<=mid){
ac++;
}
}
for(int i=0;i<m;i++){
if(b[i]>=mid){
bc++;
}
}
if(ac<bc){
left=mid;
} else{
right=mid;
}
}
System.out.println(left+1);
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int[]a=new int[n];
int[]b=new int[m];
for(int i=0;i<n;i++){
a[i]=sc.nextInt();
}
for(int i=0;i<m;i++){
b[i]=sc.nextInt();
}
Arrays.sort(a);
Arrays.sort(b);
int left=0;
int right=1000000001;
while(right-left>1){
int mid=(left+right)/2;
int ac=0;
int bc=0;
for(int i=0;i<n;i++){
if(a[i]<=mid){
ac++;
}
}
for(int i=0;i<m;i++){
if(b[i]>=mid){
bc++;
}
}
if(ac<bc){
left=mid;
} else{
right=mid;
}
}
System.out.println(left+1);
}
} | ConDefects/ConDefects/Code/abc312_c/Java/44387408 |
condefects-java_data_1676 | import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
FastScanner str=new FastScanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=str.nextInt();
int m=str.nextInt();
int[] a=new int[n];
int[] b=new int[m];
for(int i=0;i<n;i++){
a[i]=str.nextInt();
}
for(int i=0;i<m;i++){
b[i]=str.nextInt();
}
int l=0,r=1000000000;
while(r-l>1){
int han=(r+l)/2;
int na=0;
int nb=0;
for(int i=0;i<n;i++){
if(a[i]<=han)na++;
}
for(int j=0;j<m;j++){
if(b[j]>=han)nb++;
}
if(na>=nb){
r=han;
}else{
l=han;
}
}
out.println(r);
out.flush();
}
}
class FastScanner implements Closeable {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public FastScanner(InputStream in) {
this.in = in;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() { return Double.parseDouble(next());}
public void close() {
try {
in.close();
} catch (IOException e) {
}
}
}
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args) {
FastScanner str=new FastScanner(System.in);
PrintWriter out=new PrintWriter(System.out);
int n=str.nextInt();
int m=str.nextInt();
int[] a=new int[n];
int[] b=new int[m];
for(int i=0;i<n;i++){
a[i]=str.nextInt();
}
for(int i=0;i<m;i++){
b[i]=str.nextInt();
}
int l=0,r=Integer.MAX_VALUE;
while(r-l>1){
int han=(r+l)/2;
int na=0;
int nb=0;
for(int i=0;i<n;i++){
if(a[i]<=han)na++;
}
for(int j=0;j<m;j++){
if(b[j]>=han)nb++;
}
if(na>=nb){
r=han;
}else{
l=han;
}
}
out.println(r);
out.flush();
}
}
class FastScanner implements Closeable {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public FastScanner(InputStream in) {
this.in = in;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() { return Double.parseDouble(next());}
public void close() {
try {
in.close();
} catch (IOException e) {
}
}
}
| ConDefects/ConDefects/Code/abc312_c/Java/44104800 |
condefects-java_data_1677 | import java.util.*;
import java.util.function.Function;
public class Main{
public static void main(String...args) {
Scanner sc = new Scanner(System.in);
final int N=sc.nextInt(),M=sc.nextInt();
ArrayList<Integer> A=new ArrayList<>(),B=new ArrayList<>();
for(int i=0;i<N;i++)A.add(sc.nextInt());
for(int i=0;i<M;i++)B.add(sc.nextInt());
A.sort(Comparator.naturalOrder());
B.sort(Comparator.reverseOrder());
Function<Integer,Integer> sell=i->{
if(A.get(N-1)<=i)return N;
else if(i<A.get(0))return 0;
int min=0,max=N-1;
while(max-min>1){
int index=(max+min)/2;
if(A.get(index)<=i){
min=index;
}else {
max=index;
}
}
return min+1;
};
Function<Integer,Integer> buy=i->{
if(i<=B.get(M-1))return M;
else if(B.get(0)<i)return 0;
int min=0,max=M-1;
while (max-min>1){
int index=(max+min)/2;
if(B.get(index)>=i){
min=index;
}else {
max=index;
}
}
return min+1;
};
int min=0,max=A.get(N-1);
while (max-min>1){
int a=(max+min)/2;
int seller=sell.apply(a);
int buyer= buy.apply(a);
if(seller>=buyer){
max=a;
}else {
min=a;
}
}
System.out.println(max);
}
}
import java.util.*;
import java.util.function.Function;
public class Main{
public static void main(String...args) {
Scanner sc = new Scanner(System.in);
final int N=sc.nextInt(),M=sc.nextInt();
ArrayList<Integer> A=new ArrayList<>(),B=new ArrayList<>();
for(int i=0;i<N;i++)A.add(sc.nextInt());
for(int i=0;i<M;i++)B.add(sc.nextInt());
A.sort(Comparator.naturalOrder());
B.sort(Comparator.reverseOrder());
Function<Integer,Integer> sell=i->{
if(A.get(N-1)<=i)return N;
else if(i<A.get(0))return 0;
int min=0,max=N-1;
while(max-min>1){
int index=(max+min)/2;
if(A.get(index)<=i){
min=index;
}else {
max=index;
}
}
return min+1;
};
Function<Integer,Integer> buy=i->{
if(i<=B.get(M-1))return M;
else if(B.get(0)<i)return 0;
int min=0,max=M-1;
while (max-min>1){
int index=(max+min)/2;
if(B.get(index)>=i){
min=index;
}else {
max=index;
}
}
return min+1;
};
int min=0,max=Math.max(A.get(N-1),B.get(0)+1);
while (max-min>1){
int a=(max+min)/2;
int seller=sell.apply(a);
int buyer= buy.apply(a);
if(seller>=buyer){
max=a;
}else {
min=a;
}
}
System.out.println(max);
}
}
| ConDefects/ConDefects/Code/abc312_c/Java/45267124 |
condefects-java_data_1678 | import java.util.Arrays;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // 売り手の数
int M = sc.nextInt(); // 買い手の数
int[] A = new int[N];
int[] B = new int[M];
for (int i = 0; i < N; i++)
{
A[i] = sc.nextInt(); // これ以上で売りたい
}
for (int i = 0; i < M; i++)
{
B[i] = sc.nextInt(); // これ以下で買いたい
}
Arrays.sort(A); // 昇順に
Arrays.sort(B); // 昇順に
int ng = 0, ok = A[A.length - 1] + 1;
while (Math.abs(ok - ng) > 1)
{
int middle = (ok + ng) / 2;
int numSeller = countSeller(A, middle), numBuyer = countBuyer(B, middle);
if (numSeller >= numBuyer)
{
ok = middle;
}
else
{
ng = middle;
}
}
System.out.println(ok);
}
// sellPlacesの要素のうちplace以下である数
// sellPlacesが昇順に並んでいる前提
public static int countSeller(int[] sellPlaces, int place)
{
int count = 0;
for (int i = 0; i < sellPlaces.length; i++)
{
if (sellPlaces[i] <= place)
{
count++;
}
else
{
break;
}
}
return count;
}
// buyPlacesの要素のうちplace以上である数
// buyPlacesが昇順に並んでいる前提
public static int countBuyer(int[] buyPlaces, int place)
{
int count = 0;
for (int i = buyPlaces.length - 1; i >= 0; i--)
{
if (place <= buyPlaces[i])
{
count++;
}
else
{
break;
}
}
return count;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); // 売り手の数
int M = sc.nextInt(); // 買い手の数
int[] A = new int[N];
int[] B = new int[M];
for (int i = 0; i < N; i++)
{
A[i] = sc.nextInt(); // これ以上で売りたい
}
for (int i = 0; i < M; i++)
{
B[i] = sc.nextInt(); // これ以下で買いたい
}
Arrays.sort(A); // 昇順に
Arrays.sort(B); // 昇順に
int ng = 0, ok = Integer.MAX_VALUE;
while (Math.abs(ok - ng) > 1)
{
int middle = (ok + ng) / 2;
int numSeller = countSeller(A, middle), numBuyer = countBuyer(B, middle);
if (numSeller >= numBuyer)
{
ok = middle;
}
else
{
ng = middle;
}
}
System.out.println(ok);
}
// sellPlacesの要素のうちplace以下である数
// sellPlacesが昇順に並んでいる前提
public static int countSeller(int[] sellPlaces, int place)
{
int count = 0;
for (int i = 0; i < sellPlaces.length; i++)
{
if (sellPlaces[i] <= place)
{
count++;
}
else
{
break;
}
}
return count;
}
// buyPlacesの要素のうちplace以上である数
// buyPlacesが昇順に並んでいる前提
public static int countBuyer(int[] buyPlaces, int place)
{
int count = 0;
for (int i = buyPlaces.length - 1; i >= 0; i--)
{
if (place <= buyPlaces[i])
{
count++;
}
else
{
break;
}
}
return count;
}
}
| ConDefects/ConDefects/Code/abc312_c/Java/45061149 |
condefects-java_data_1679 | import java.io.*;
import java.util.*;
class Main {
int N, M;
int[] A, B, C;
void calc() {
int[] ns = nextInts();
N = ns[0]; M = ns[1];
A = nextInts(); B = nextInts();
Arrays.sort(A); Arrays.sort(B);
C = Arrays.copyOf(A, N+M);
for (int i = 0; i < M; i++) C[i+N] = B[i] + 1;
Arrays.sort(C);
System.out.println(solve());
}
int solve() {
int ai = 0, bi = 0;
for (int i = 0; i < N+M; i++) {
while (i < N+M-1 && C[i] == C[i+1]) i++;
int x = C[i];
while (ai < N && A[ai] <= x) ai++;
while (bi < M && B[bi] <= x) bi++;
if (ai >= M-bi) return x;
}
return -1;
}
// ---
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String next() { try { return br.readLine(); } catch (Exception e) { return null; } }
String[] nexts() { return next().split(" "); }
static int i(String s) { return Integer.parseInt(s); }
int nextInt() { return i(next()); }
int[] nextInts() { return Arrays.stream(nexts()).mapToInt(Main::i).toArray(); }
public static void main(String[] args) {
new Main().calc();
}
}
import java.io.*;
import java.util.*;
class Main {
int N, M;
int[] A, B, C;
void calc() {
int[] ns = nextInts();
N = ns[0]; M = ns[1];
A = nextInts(); B = nextInts();
Arrays.sort(A); Arrays.sort(B);
C = Arrays.copyOf(A, N+M);
for (int i = 0; i < M; i++) C[i+N] = B[i] + 1;
Arrays.sort(C);
System.out.println(solve());
}
int solve() {
int ai = 0, bi = 0;
for (int i = 0; i < N+M; i++) {
while (i < N+M-1 && C[i] == C[i+1]) i++;
int x = C[i];
while (ai < N && A[ai] <= x) ai++;
while (bi < M && B[bi] < x) bi++;
if (ai >= M-bi) return x;
}
return -1;
}
// ---
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String next() { try { return br.readLine(); } catch (Exception e) { return null; } }
String[] nexts() { return next().split(" "); }
static int i(String s) { return Integer.parseInt(s); }
int nextInt() { return i(next()); }
int[] nextInts() { return Arrays.stream(nexts()).mapToInt(Main::i).toArray(); }
public static void main(String[] args) {
new Main().calc();
}
}
| ConDefects/ConDefects/Code/abc312_c/Java/45211343 |
condefects-java_data_1680 | import java.util.*;
public class Main {
public static void main(String[] args) {
IOHandler io = new IOHandler();
int n = io.nextInt();
int m = io.nextInt();
int[] a = io.nextIntArray(n);
int[] b = io.nextIntArray(m);
io.close();
Arrays.sort(a);
Arrays.sort(b);
// 1~100,000,001 の範囲で2分探査
int right = 0, left = 1_000_000_000;
while (right+1 < left) {
int center = (right+left)/2;
int ai = 0, bi = 0;
for (int i = 0; i < n; i++) if (a[i] <= center) ai++;
for (int i = 0; i < m; i++) if (b[i] >= center) bi++;
if (ai >= bi) left = center; else right = center;
}
io.output(left);
}
private static class IOHandler {
private Scanner sc = new Scanner(System.in);
private void close() {this.sc.close();}
private int nextInt() {return this.sc.nextInt();}
private int[] nextIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) array[i] = this.sc.nextInt();
return array;
}
private void output(int result) {System.out.println(result);}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
IOHandler io = new IOHandler();
int n = io.nextInt();
int m = io.nextInt();
int[] a = io.nextIntArray(n);
int[] b = io.nextIntArray(m);
io.close();
Arrays.sort(a);
Arrays.sort(b);
// 1~100,000,001 の範囲で2分探査
int right = 0, left = 1_000_000_001;
while (right+1 < left) {
int center = (right+left)/2;
int ai = 0, bi = 0;
for (int i = 0; i < n; i++) if (a[i] <= center) ai++;
for (int i = 0; i < m; i++) if (b[i] >= center) bi++;
if (ai >= bi) left = center; else right = center;
}
io.output(left);
}
private static class IOHandler {
private Scanner sc = new Scanner(System.in);
private void close() {this.sc.close();}
private int nextInt() {return this.sc.nextInt();}
private int[] nextIntArray(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++) array[i] = this.sc.nextInt();
return array;
}
private void output(int result) {System.out.println(result);}
}
} | ConDefects/ConDefects/Code/abc312_c/Java/45687623 |
condefects-java_data_1681 |
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
public final class Main {
public static void main(String[] args) throws IOException {
final FastReader fs = new FastReader();
final int n = fs.nextInt();
final int m = fs.nextInt();
final int[] l = fs.nextIntArray(n);
final int[] r = fs.nextIntArray(m);
int lo = 1;
int hi = (int) 1e9;
while (lo < hi) {
final int mid = lo + hi >>> 1;
int d = 0;
for (int num : l) {
if (num <= mid) {
d++;
}
}
for (int num : r) {
if (num >= mid) {
d--;
}
}
if (d < 0) {
lo = mid + 1;
} else {
hi = mid;
}
}
System.out.println(lo);
}
static final class Utils {
private static class Shuffler {
private static void shuffle(int[] x) {
final Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
final int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
private static void shuffle(long[] x) {
final Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
final int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
private static void swap(int[] x, int i, int j) {
final int t = x[i];
x[i] = x[j];
x[j] = t;
}
private static void swap(long[] x, int i, int j) {
final long t = x[i];
x[i] = x[j];
x[j] = t;
}
}
public static void shuffleSort(int[] arr) {
Shuffler.shuffle(arr);
Arrays.sort(arr);
}
public static void shuffleSort(long[] arr) {
Shuffler.shuffle(arr);
Arrays.sort(arr);
}
private Utils() {}
}
static class FastReader {
private static final int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
private int bufferPointer, bytesRead;
FastReader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
FastReader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
final byte[] buf = new byte[1024]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
break;
}
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int readSign() throws IOException {
byte c = read();
while ('+' != c && '-' != c) {
c = read();
}
return '+' == c ? 0 : 1;
}
private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() throws IOException {
int b;
//noinspection StatementWithEmptyBody
while ((b = read()) != -1 && isSpaceChar(b)) {}
return b;
}
public char nc() throws IOException {
return (char) skip();
}
public String next() throws IOException {
int b = skip();
final StringBuilder sb = new StringBuilder();
while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = read();
}
return sb.toString();
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
final boolean neg = c == '-';
if (neg) { c = read(); }
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg) { return -ret; }
return ret;
}
public int[] nextIntArray(int n) throws IOException {
final int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = nextInt();
}
return res;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') { c = read(); }
final boolean neg = c == '-';
if (neg) { c = read(); }
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg) { return -ret; }
return ret;
}
public long[] nextLongArray(int n) throws IOException {
final long[] res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = nextLong();
}
return res;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') { c = read(); }
final boolean neg = c == '-';
if (neg) { c = read(); }
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg) { return -ret; }
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) { buffer[0] = -1; }
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) { fillBuffer(); }
return buffer[bufferPointer++];
}
public void close() throws IOException {
din.close();
}
}
}
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
public final class Main {
public static void main(String[] args) throws IOException {
final FastReader fs = new FastReader();
final int n = fs.nextInt();
final int m = fs.nextInt();
final int[] l = fs.nextIntArray(n);
final int[] r = fs.nextIntArray(m);
int lo = 1;
int hi = (int) 2e9;
while (lo < hi) {
final int mid = lo + hi >>> 1;
int d = 0;
for (int num : l) {
if (num <= mid) {
d++;
}
}
for (int num : r) {
if (num >= mid) {
d--;
}
}
if (d < 0) {
lo = mid + 1;
} else {
hi = mid;
}
}
System.out.println(lo);
}
static final class Utils {
private static class Shuffler {
private static void shuffle(int[] x) {
final Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
final int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
private static void shuffle(long[] x) {
final Random r = new Random();
for (int i = 0; i <= x.length - 2; i++) {
final int j = i + r.nextInt(x.length - i);
swap(x, i, j);
}
}
private static void swap(int[] x, int i, int j) {
final int t = x[i];
x[i] = x[j];
x[j] = t;
}
private static void swap(long[] x, int i, int j) {
final long t = x[i];
x[i] = x[j];
x[j] = t;
}
}
public static void shuffleSort(int[] arr) {
Shuffler.shuffle(arr);
Arrays.sort(arr);
}
public static void shuffleSort(long[] arr) {
Shuffler.shuffle(arr);
Arrays.sort(arr);
}
private Utils() {}
}
static class FastReader {
private static final int BUFFER_SIZE = 1 << 16;
private final DataInputStream din;
private final byte[] buffer;
private int bufferPointer, bytesRead;
FastReader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
FastReader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
final byte[] buf = new byte[1024]; // line length
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') {
break;
}
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int readSign() throws IOException {
byte c = read();
while ('+' != c && '-' != c) {
c = read();
}
return '+' == c ? 0 : 1;
}
private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() throws IOException {
int b;
//noinspection StatementWithEmptyBody
while ((b = read()) != -1 && isSpaceChar(b)) {}
return b;
}
public char nc() throws IOException {
return (char) skip();
}
public String next() throws IOException {
int b = skip();
final StringBuilder sb = new StringBuilder();
while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = read();
}
return sb.toString();
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') {
c = read();
}
final boolean neg = c == '-';
if (neg) { c = read(); }
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg) { return -ret; }
return ret;
}
public int[] nextIntArray(int n) throws IOException {
final int[] res = new int[n];
for (int i = 0; i < n; i++) {
res[i] = nextInt();
}
return res;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') { c = read(); }
final boolean neg = c == '-';
if (neg) { c = read(); }
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg) { return -ret; }
return ret;
}
public long[] nextLongArray(int n) throws IOException {
final long[] res = new long[n];
for (int i = 0; i < n; i++) {
res[i] = nextLong();
}
return res;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') { c = read(); }
final boolean neg = c == '-';
if (neg) { c = read(); }
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
ret += (c - '0') / (div *= 10);
}
}
if (neg) { return -ret; }
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) { buffer[0] = -1; }
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) { fillBuffer(); }
return buffer[bufferPointer++];
}
public void close() throws IOException {
din.close();
}
}
}
| ConDefects/ConDefects/Code/abc312_c/Java/44671893 |
condefects-java_data_1682 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(b - a < 1 || b - a == 9 ? "Yes" : "No");
sc.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(b - a == 1 || b - a == 9 ? "Yes" : "No");
sc.close();
}
}
| ConDefects/ConDefects/Code/abc240_a/Java/37053258 |
condefects-java_data_1683 | import java.util.*;
public class Main {
public static void main (String[]args) {
Scanner scan = new Scanner(System.in);
int a=scan.nextInt();
int b=scan.nextInt();
scan.close();
if((b-a)==1){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
import java.util.*;
public class Main {
public static void main (String[]args) {
Scanner scan = new Scanner(System.in);
int a=scan.nextInt();
int b=scan.nextInt();
scan.close();
if((b-a)==1){
System.out.println("Yes");
}else if((b-a)==9){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
} | ConDefects/ConDefects/Code/abc240_a/Java/35383697 |
condefects-java_data_1684 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n =scan.nextInt();
int a = scan.nextInt();
if(Math.abs(a%10-n%10)<=1) System.out.println("Yes");
else System.out.println("No");
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n =scan.nextInt();
int a = scan.nextInt();
if(Math.abs(a%10-n%10)<=1 || Math.abs(a-n)<=1) System.out.println("Yes");
else System.out.println("No");
}
}
| ConDefects/ConDefects/Code/abc240_a/Java/38236036 |
condefects-java_data_1685 | import java.util.*;
class Main {
public static void main(String[] ktr) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println((a % 2 + b % 2) % 2 == 1 ? "Yes" : "No");
}
}
import java.util.*;
class Main {
public static void main(String[] ktr) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(Math.abs(a - b) == 1 || Math.abs(a - b) == 9 ? "Yes" : "No");
}
} | ConDefects/ConDefects/Code/abc240_a/Java/37788123 |
condefects-java_data_1686 | import static java.lang.System.*;
import java.util.*;
public class Main{
public static void solve(){
Scanner sc = new Scanner(in);
int a = sc.nextInt();
int b = sc.nextInt();
if(a == 1 && b == 10){
out.println("Yes");
return;
}
if(a == b + 1) out.println("Yes");
else out.println("No");
}
public static void main(String[] args) {
solve();
}
}
import static java.lang.System.*;
import java.util.*;
public class Main{
public static void solve(){
Scanner sc = new Scanner(in);
int a = sc.nextInt();
int b = sc.nextInt();
if(a == 1 && b == 10){
out.println("Yes");
return;
}
if(b == a + 1) out.println("Yes");
else out.println("No");
}
public static void main(String[] args) {
solve();
}
} | ConDefects/ConDefects/Code/abc240_a/Java/38950876 |
condefects-java_data_1687 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
short a = in.nextShort();
short b = in.nextShort();
if(Math.abs(a%10-b%10)==1)System.out.println("Yes");
else System.out.println("No");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
short a = in.nextShort();
short b = in.nextShort();
if(Math.abs(a%10-b%10)==1||Math.abs(a%10-b%10)==9 )System.out.println("Yes");
else System.out.println("No");
}
} | ConDefects/ConDefects/Code/abc240_a/Java/45295076 |
condefects-java_data_1688 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int m = Integer.parseInt(sc.next());
String[] s = new String[3];
for(int i = 0; i < 3; i++) {
s[i] = sc.next();
s[i] = s[i] + s[i];
}
int ans = 1000;
for(int i = 0; i < 10; i++) {
char r = (char) (i + '0');
int[] arr = new int[3];
for(int j = 0; j < 3; j++) arr[j] = j;
do {
int cur = 0;
boolean ok = true;
for(int j = 0; j < 3; j++) {
if(s[arr[j]].indexOf(r) == -1) ok = false;
}
if(!ok) continue;
for(int j = 0; j < 3; j++) {
cur = s[arr[j]].indexOf(r, cur);
cur++;
}
cur--;
ans = Math.min(ans, cur);
}while(nextPermutation(arr));
}
if(ans == 1000) System.out.println(-1);
else System.out.println(ans);
}
}
static boolean nextPermutation(int[] arr) {
int len = arr.length;
int index = len - 2;
while(index >= 0 && arr[index] >= arr[index + 1]) index--;
if(index < 0) return false;
int target = index + 1;
for(int i = target; i < arr.length; i++) {
if(arr[i] > arr[index]) target = i;
}
int tmp = arr[index];
arr[index] = arr[target];
arr[target] = tmp;
Arrays.sort(arr, index + 1, arr.length);
return true;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int m = Integer.parseInt(sc.next());
String[] s = new String[3];
for(int i = 0; i < 3; i++) {
s[i] = sc.next();
s[i] = s[i] + s[i] + s[i];
}
int ans = 1000;
for(int i = 0; i < 10; i++) {
char r = (char) (i + '0');
int[] arr = new int[3];
for(int j = 0; j < 3; j++) arr[j] = j;
do {
int cur = 0;
boolean ok = true;
for(int j = 0; j < 3; j++) {
if(s[arr[j]].indexOf(r) == -1) ok = false;
}
if(!ok) continue;
for(int j = 0; j < 3; j++) {
cur = s[arr[j]].indexOf(r, cur);
cur++;
}
cur--;
ans = Math.min(ans, cur);
}while(nextPermutation(arr));
}
if(ans == 1000) System.out.println(-1);
else System.out.println(ans);
}
}
static boolean nextPermutation(int[] arr) {
int len = arr.length;
int index = len - 2;
while(index >= 0 && arr[index] >= arr[index + 1]) index--;
if(index < 0) return false;
int target = index + 1;
for(int i = target; i < arr.length; i++) {
if(arr[i] > arr[index]) target = i;
}
int tmp = arr[index];
arr[index] = arr[target];
arr[target] = tmp;
Arrays.sort(arr, index + 1, arr.length);
return true;
}
} | ConDefects/ConDefects/Code/abc320_c/Java/45734248 |
condefects-java_data_1689 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static int f(char[] s, char[] t, char[] u, int i, int j,int k) {
if (s[i]==t[j]&&t[j]==u[k]) {
int kk = k;
if (i >= j){
kk += s.length;
}
if (j >= k){
kk+=s.length;
}
return kk;
}
return INF;
}
static void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
char[] s = scanner.next().toCharArray();
char[] t = scanner.next().toCharArray();
char[] u = scanner.next().toCharArray();
int ans = INF;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
ans = Math.min(ans, f(s,t,u,i,j,k));
ans = Math.min(ans, f(s,u,u,i,j,k));
ans = Math.min(ans, f(t,s,u,i,j,k));
ans = Math.min(ans, f(t,u,s,i,j,k));
ans = Math.min(ans, f(u,t,s,i,j,k));
ans = Math.min(ans, f(u,s,t,i,j,k));
}
}
}
if (ans==INF) {
System.out.println(-1);
} else {
System.out.println(ans);
}
}
public static void main(final String[] args) {
PrintWriter out = new PrintWriter(System.out);
FastScanner scanner = new FastScanner();
try {
run(scanner, out);
} catch (Throwable e) {
throw e;
} finally {
out.flush();
}
}
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() { return Double.parseDouble(next());}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static int f(char[] s, char[] t, char[] u, int i, int j,int k) {
if (s[i]==t[j]&&t[j]==u[k]) {
int kk = k;
if (i >= j){
kk += s.length;
}
if (j >= k){
kk+=s.length;
}
return kk;
}
return INF;
}
static void run (final FastScanner scanner, final PrintWriter out) {
int N = scanner.nextInt();
char[] s = scanner.next().toCharArray();
char[] t = scanner.next().toCharArray();
char[] u = scanner.next().toCharArray();
int ans = INF;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
ans = Math.min(ans, f(s,t,u,i,j,k));
ans = Math.min(ans, f(s,u,t,i,j,k));
ans = Math.min(ans, f(t,s,u,i,j,k));
ans = Math.min(ans, f(t,u,s,i,j,k));
ans = Math.min(ans, f(u,t,s,i,j,k));
ans = Math.min(ans, f(u,s,t,i,j,k));
}
}
}
if (ans==INF) {
System.out.println(-1);
} else {
System.out.println(ans);
}
}
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/abc320_c/Java/53040731 |
condefects-java_data_1690 | import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
var sc = new Scanner(System.in);
var n = sc.nextInt();
var m = sc.nextInt();
var a = IntStream.range(0, n).map(i -> sc.nextInt()).toArray();
var c = IntStream.range(0, n).map(i -> sc.nextInt()).toArray();
var x = IntStream.range(0, m).map(i -> sc.nextInt()).toArray();
sc.close();
var seg = new Main().new SegmentTree(n);
for (var i = 0; i < n; i++) {
seg.update(i, c[i]);
}
var set = Arrays.stream(x).boxed().collect(Collectors.toSet());
var dp = new long[n + 1][n + 1];
for (var i = 0; i <= n; i++) {
for (var j = 0; j <= n; j++) {
dp[i][j] = Long.MAX_VALUE;
}
}
dp[0][0] = 0L;
for (var i = 0; i < n; i++) {
for (var j = 0; j <= i; j++) {
if (dp[i][j] == Long.MAX_VALUE) {
continue;
}
var v = dp[i][j] + a[i] + seg.get(i - j, i + 1);
//System.out.printf("%d %d %d\r\n", i, j, v);
if (set.contains(i + 1)) {
dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], v);
} else {
dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], v);
}
}
}
var result = Long.MAX_VALUE;
for (var i = 0; i < n; i++) {
result = Math.min(result, dp[n][i]);
}
System.out.print(result);
}
public class SegmentTree {
private int n;
private long[] values;
public SegmentTree(int n) {
this.n = (int) Math.pow(2, Math.ceil(Math.log10(n) / Math.log10(2)));
this.values = new long[2 * this.n];
}
public void update(int i, long v) {
var index = i + n - 1;
values[index] = v;
while (index > 0) {
index = (index - 1) / 2;
values[index] = func(values[index * 2 + 1], values[index * 2 + 2]);
}
}
public long get(int i) {
return get(i, i + 1, 0, 0, n);
}
public long get(int l, int r) {
return get(l, r, 0, 0, n);
}
private long get(int l, int r, int k, int l2, int r2) {
if (r2 <= l || r <= l2) {
return init();
} else if (l <= l2 && r2 <= r) {
return values[k];
} else {
var v1 = get(l, r, k * 2 + 1, l2, (l2 + r2) / 2);
var v2 = get(l, r, k * 2 + 2, (l2 + r2) / 2, r2);
return func(v1, v2);
}
}
private long func(long a, long b) {
return Math.min(a, b);
}
private long init() {
return Long.MAX_VALUE;
}
}
}
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
var sc = new Scanner(System.in);
var n = sc.nextInt();
var m = sc.nextInt();
var a = IntStream.range(0, n).map(i -> sc.nextInt()).toArray();
var c = IntStream.range(0, n).map(i -> sc.nextInt()).toArray();
var x = IntStream.range(0, m).map(i -> sc.nextInt()).toArray();
sc.close();
var seg = new Main().new SegmentTree(n);
for (var i = 0; i < n; i++) {
seg.update(i, c[i]);
}
var set = Arrays.stream(x).boxed().collect(Collectors.toSet());
var dp = new long[n + 1][n + 1];
for (var i = 0; i <= n; i++) {
for (var j = 0; j <= n; j++) {
dp[i][j] = Long.MAX_VALUE;
}
}
dp[0][0] = 0L;
for (var i = 0; i < n; i++) {
for (var j = 0; j <= i; j++) {
if (dp[i][j] == Long.MAX_VALUE) {
continue;
}
var v = dp[i][j] + a[i] + seg.get(i - j, i + 1);
//System.out.printf("%d %d %d\r\n", i, j, v);
if (set.contains(i + 1)) {
dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], v);
} else {
dp[i + 1][j] = Math.min(dp[i + 1][j], dp[i][j]);
dp[i + 1][j + 1] = Math.min(dp[i + 1][j + 1], v);
}
}
}
var result = Long.MAX_VALUE;
for (var i = 0; i <= n; i++) {
result = Math.min(result, dp[n][i]);
}
System.out.print(result);
}
public class SegmentTree {
private int n;
private long[] values;
public SegmentTree(int n) {
this.n = (int) Math.pow(2, Math.ceil(Math.log10(n) / Math.log10(2)));
this.values = new long[2 * this.n];
}
public void update(int i, long v) {
var index = i + n - 1;
values[index] = v;
while (index > 0) {
index = (index - 1) / 2;
values[index] = func(values[index * 2 + 1], values[index * 2 + 2]);
}
}
public long get(int i) {
return get(i, i + 1, 0, 0, n);
}
public long get(int l, int r) {
return get(l, r, 0, 0, n);
}
private long get(int l, int r, int k, int l2, int r2) {
if (r2 <= l || r <= l2) {
return init();
} else if (l <= l2 && r2 <= r) {
return values[k];
} else {
var v1 = get(l, r, k * 2 + 1, l2, (l2 + r2) / 2);
var v2 = get(l, r, k * 2 + 2, (l2 + r2) / 2, r2);
return func(v1, v2);
}
}
private long func(long a, long b) {
return Math.min(a, b);
}
private long init() {
return Long.MAX_VALUE;
}
}
}
| ConDefects/ConDefects/Code/abc288_e/Java/38626683 |
condefects-java_data_1691 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.ArrayList;
import java.util.concurrent.*;
import java.util.function.*;
public final class Main{
public static void main(String[] args) throws Exception{
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out,false),log = new MyWriter(System.err,true);
int T = Solver.multi ? in.it() : 1;
while (T-- > 0)
Optional.ofNullable(new Solver(in,out,log).solve()).ifPresent(out::println);
out.flush();
}
}
class Solver extends BaseSolver{
public Solver(MyReader in,MyWriter out,MyWriter log){ super(in,out,log); }
public static boolean multi = false;
int N = in.it();
char[][] S = in.ch(N);
public Object solve(){
return calc('R') +calc('B');
}
private int calc(char c){
int[][] len = new int[N][N];
for (var is:len)
fill(is,infI);
Deque<int[]> que = new ArrayDeque<>();
if (c == 'R') {
if (S[0][0] == c) {
len[0][0] = 0;
que.add(new int[]{0, 0, 0});
} else {
len[0][0] = 1;
que.add(new int[]{0, 0, 1});
}
} else if (S[0][0] == c) {
len[0][N -1] = 0;
que.add(new int[]{0, N -1, 0});
} else {
len[0][N -1] = 1;
que.add(new int[]{0, N -1, 1});
}
while (!que.isEmpty()) {
var cur = que.poll();
int i = cur[0];
int j = cur[1];
List<int[]> sur = new ArrayList<>();
if (0 < i)
sur.add(new int[]{i -1, j});
if (0 < j)
sur.add(new int[]{i, j -1});
if (i +1 < N)
sur.add(new int[]{i +1, j});
if (j +1 < N)
sur.add(new int[]{i, j +1});
for (var s:sur) {
int l = S[s[0]][s[1]] == c ? 0 : 1;
if (len[s[0]][s[1]] > cur[2] +l) {
len[s[0]][s[1]] = cur[2] +l;
if (l == 0)
que.addFirst(new int[]{s[0], s[1], len[s[0]][s[1]]});
else
que.addLast(new int[]{s[0], s[1], len[s[0]][s[1]]});
}
}
}
return c == 'R' ? len[N -1][N -1] : len[N -1][0];
}
}
class Data extends BaseV{
long v;
public Data(long v){ this.v = v; }
}
abstract class AVLSegmentTree<V extends BaseV, F> {
private V e = e();
private Node root;
private V[] ret = Util.cast(new BaseV[2]);
private int ri;
public AVLSegmentTree(int n){
this();
root = new Node(e(),n);
}
public AVLSegmentTree(){
ret[ri] = e();
ri = 1;
}
public void build(int n,IntFunction<V> init){ root = build(0,n,init); }
private Node build(int l,int r,IntFunction<V> init){
if (r -l == 1)
return new Node(init.apply(l),1);
var ret = new Node(e(),r -l);
ret.lft = build(l,l +r >>1,init);
ret.rht = build(l +r >>1,r,init);
return ret.update();
}
public void add(V v){ add(v,1); }
public void add(V v,int k){ ins(size(),v,k); }
public void ins(int i,V v){ ins(i,v,1); }
public void ins(int i,V v,int k){ root = root == null ? new Node(v,k) : ins(root,i,v,k); }
private Node ins(Node nd,int i,V v,int k){
if (nd.lft == null && (i == 0 || i == nd.sz))
split(nd,i == 0 ? 1 : -1,v,k,nd.sz +k);
else {
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else
nd.push();
if (i < nd.lft.sz)
nd.lft = ins(nd.lft,i,v,k);
else
nd.rht = ins(nd.rht,i -nd.lft.sz,v,k);
}
return balance(nd);
}
public void del(int i){ root = del(root,i); }
private Node del(Node nd,int i){
if (nd.lft == null)
return 0 < --nd.sz ? nd : null;
nd.push();
int c = i < nd.lft.sz ? -1 : 1;
Node del = c < 0 ? del(nd.lft,i) : del(nd.rht,i -nd.lft.sz);
if (del == null)
return nd.cld(-c);
nd.cld(c,del);
return balance(nd);
}
public void upd(int i,F f){ upd(i,i +1,f); }
public void upd(int l,int r,F f){
if (size() < r)
add(e(),r -size());
root = upd(root,l,r,f);
}
private Node upd(Node nd,int l,int r,F f){
if (l == 0 && r == nd.sz)
nd.prop(f);
else if (l < r) {
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),0 < l ? l : r,nd.sz);
else
nd.push();
if (l < nd.lft.sz)
nd.lft = upd(nd.lft,l,min(nd.lft.sz,r),f);
if (nd.lft.sz < r)
nd.rht = upd(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz,f);
nd = balance(nd);
}
return nd;
}
public void toggle(int l,int r){ root = l < r ? toggle(root,l,r) : root; }
private Node toggle(Node nd,int l,int r){
nd.push();
if (0 < l) {
split(nd,l);
nd = merge(nd.lft,nd,toggle(nd.rht,0,r -l));
} else if (r < nd.sz) {
split(nd,r);
nd = merge(toggle(nd.lft,l,r),nd,nd.rht);
} else
nd.toggle();
return nd;
}
private void split(Node nd,int i){
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else {
nd.push();
Node tmp;
if (i < nd.lft.sz) {
split(tmp = nd.lft,i);
nd.lft = tmp.lft;
nd.rht = merge(tmp.rht,tmp,nd.rht);
} else if (nd.lft.sz < i) {
split(tmp = nd.rht,i -nd.lft.sz);
nd.rht = tmp.rht;
nd.lft = merge(nd.lft,tmp,tmp.lft);
}
}
}
private Node merge(Node lft,Node nd,Node rht){
if (abs(lft.rnk -rht.rnk) < 2) {
nd.lft = lft;
nd.rht = rht;
} else if (lft.rnk > rht.rnk) {
lft.push();
lft.rht = merge(lft.rht,nd,rht);
nd = lft;
} else if (lft.rnk < rht.rnk) {
rht.push();
rht.lft = merge(lft,nd,rht.lft);
nd = rht;
}
return balance(nd);
}
public V get(int i){ return get(root,i); }
private V get(Node nd,int i){
if (nd.lft == null)
return nd.val;
nd.push();
return i < nd.lft.sz ? get(nd.lft,i) : get(nd.rht,i -nd.lft.sz);
}
public V get(int l,int r){
ret[ri] = e();
ri ^= 1;
if (root != null)
get(root,l,min(r,size()));
return ret[ri ^= 1];
}
private void get(Node nd,int l,int r){
if (0 == l && r == nd.sz)
ag(ret[ri],ret[ri ^= 1],nd.val());
else if (nd.lft == null)
ag(ret[ri],ret[ri ^= 1],pw(nd.val,r -l));
else {
nd.push();
if (l < nd.lft.sz)
get(nd.lft,l,min(nd.lft.sz,r));
if (nd.lft.sz < r)
get(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz);
}
}
public V all(){ return root == null ? e : root.val(); }
public int size(){ return root == null ? 0 : root.sz; }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected abstract void tog(V v);
private V ag(V v,V a,V b){
agg(v,a,b);
v.sz = a.sz +b.sz;
return v;
}
protected V pow(V a,int n){
V ret = e();
for (V t = ag(e(),e,a);0 < n;n >>= 1,t = ag(e(),t,t))
if (0 < (n &1))
ret = ag(e(),ret,t);
return ret;
}
private V pw(V a,int n){
V ret = pow(a,n);
ret.sz = n;
return ret;
}
private void split(Node nd,int c,V vl,int i,int sz){
nd.cld(-c,new Node(vl,i));
nd.cld(c,new Node(nd.val,sz -i));
nd.val = e();
}
private Node balance(Node nd){ return (1 < abs(nd.bis = nd.rht.rnk -nd.lft.rnk) ? rotate(nd) : nd).update(); }
private Node rotate(Node u){
var v = u.cld(u.bis);
v.push();
if (u.bis *v.bis < -1)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.update();
return v;
}
private class Node{
private int sz,bis,rnk,tog;
private V val;
private F laz;
private Node lft,rht;
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node update(){
bis = rht.rnk -lft.rnk;
rnk = max(lft.rnk,rht.rnk) +1;
ag(val,lft.val(),rht.val());
sz = val.sz;
return this;
}
private void push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
if (0 < tog) {
lft.toggle();
rht.toggle();
tog = 0;
}
}
private void prop(F f){
map(val,f);
if (lft != null)
laz = laz == null ? f : comp(laz,f);
}
private void toggle(){
bis *= -1;
var tn = lft;
lft = rht;
rht = tn;
tog(val);
if (lft != null)
tog ^= 1;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){ nd = c < 0 ? (lft = nd) : (rht = nd); }
private V val(){ return lft == null && 1 < sz ? pw(val,sz) : val; }
}
}
abstract class BaseV{
public int sz;
public boolean fail;
}
class MyStack<T> extends MyList<T>{
public T pop(){ return remove(size() -1); }
public T peek(){ return get(size() -1); }
}
class MyList<T> implements Iterable<T>{
private T[] arr;
private int sz;
public MyList(){ this(16); }
public MyList(int n){ arr = Util.cast(new Object[n]); }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public T get(int i){ return arr[i]; }
public void add(T t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public T remove(int i){
var ret = arr[i];
sz--;
for (int j = i;j < sz;j++)
arr[j] = arr[j +1];
return ret;
}
public T removeFast(int i){
var ret = arr[i];
arr[i] = arr[--sz];
return ret;
}
public void sort(){ sort(Util.cast(Comparator.naturalOrder())); }
public void sort(Comparator<T> cmp){ Arrays.sort(arr,0,sz,cmp); }
@Override
public Iterator<T> iterator(){
return new Iterator<>(){
int i = 0;
@Override
public boolean hasNext(){ return i < sz; }
@Override
public T next(){ return arr[i++]; }
};
}
public <U> MyList<U> map(Function<T, U> func){
MyList<U> ret = new MyList<>(sz);
forEach(t -> ret.add(func.apply(t)));
return ret;
}
public T[] toArray(){
if (sz == 0)
return Util.cast(new Object[0]);
T[] ret = Util.cast(Array.newInstance(arr[0].getClass(),sz));
for (int i = 0;i < sz;i++)
ret[i] = arr[i];
return ret;
}
public void swap(int i,int j){
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
public void set(int i,T t){ arr[i] = t; }
}
class BaseSolver extends Util{
public MyReader in;
public MyWriter out,log;
public BaseSolver(MyReader in,MyWriter out,MyWriter log){
this.in = in;
this.out = out;
this.log = log;
}
protected long inv(long x){ return pow(x,mod -2); }
protected long pow(long x,long n){ return pow(x,n,Util.mod); }
protected long pow(long x,long n,long mod){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
protected int bSearchI(int o,int n,IntPredicate judge){
if (!judge.test(o))
return o -Integer.signum(n -o);
for (int m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected long bSearchL(long o,long n,LongPredicate judge){
for (long m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected double bSearchD(double o,double n,DoublePredicate judge){
for (double m,c = 0;c < 100;c++)
m = judge.test(m = (o +n) /2) ? (o = m) : (n = m);
return o;
}
protected long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
public long lcm(long a,long b){ return b /gcd(a,b) *a; }
protected long ceil(long a,long b){ return (a +b -1) /b; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<61 |1 <<30) -1,
mod = 998244353;
public static Random rd = ThreadLocalRandom.current();
private long st = System.currentTimeMillis();
protected long elapsed(){ return System.currentTimeMillis() -st; }
protected void reset(){ st = System.currentTimeMillis(); }
public static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
public static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
public static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
public static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
public int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj){ return (T) obj; }
}
class MyReader{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
public MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
public int it(){ return toIntExact(lg()); }
public int[] it(int N){ return Util.arrI(N,i -> it()); }
public int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
public int idx(){ return it() -1; }
public int[] idx(int N){ return Util.arrI(N,i -> idx()); }
public int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
public long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
public long[] lg(int N){ return Util.arrL(N,i -> lg()); }
public long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
public double dbl(){ return Double.parseDouble(str()); }
public double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
public double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
public char[] ch(){ return str().toCharArray(); }
public char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
public String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
public String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
public String[] str(int N){ return Util.arr(new String[N],i -> str()); }
public String[][] str(int H,int W){ return Util.arr(new String[H][],i -> str(W)); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
private boolean autoflush;
public MyWriter(OutputStream out,boolean autoflush){
this.out = out;
this.autoflush = autoflush;
}
public void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
private void ln(){
write((byte) '\n');
if (autoflush)
flush();
}
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
while (i < ibuf.length)
write(ibuf[i++]);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
public void println(Object obj){
if (obj == null)
obj = "null";
if (obj instanceof Iterable<?>)
for (Object e:(Iterable<?>) obj)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
public void printlns(Object... o){
print(o);
ln();
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.ArrayList;
import java.util.concurrent.*;
import java.util.function.*;
public final class Main{
public static void main(String[] args) throws Exception{
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out,false),log = new MyWriter(System.err,true);
int T = Solver.multi ? in.it() : 1;
while (T-- > 0)
Optional.ofNullable(new Solver(in,out,log).solve()).ifPresent(out::println);
out.flush();
}
}
class Solver extends BaseSolver{
public Solver(MyReader in,MyWriter out,MyWriter log){ super(in,out,log); }
public static boolean multi = false;
int N = in.it();
char[][] S = in.ch(N);
public Object solve(){
return calc('R') +calc('B');
}
private int calc(char c){
int[][] len = new int[N][N];
for (var is:len)
fill(is,infI);
Deque<int[]> que = new ArrayDeque<>();
if (c == 'R') {
if (S[0][0] == c) {
len[0][0] = 0;
que.add(new int[]{0, 0, 0});
} else {
len[0][0] = 1;
que.add(new int[]{0, 0, 1});
}
} else if (S[0][N -1] == c) {
len[0][N -1] = 0;
que.add(new int[]{0, N -1, 0});
} else {
len[0][N -1] = 1;
que.add(new int[]{0, N -1, 1});
}
while (!que.isEmpty()) {
var cur = que.poll();
int i = cur[0];
int j = cur[1];
List<int[]> sur = new ArrayList<>();
if (0 < i)
sur.add(new int[]{i -1, j});
if (0 < j)
sur.add(new int[]{i, j -1});
if (i +1 < N)
sur.add(new int[]{i +1, j});
if (j +1 < N)
sur.add(new int[]{i, j +1});
for (var s:sur) {
int l = S[s[0]][s[1]] == c ? 0 : 1;
if (len[s[0]][s[1]] > cur[2] +l) {
len[s[0]][s[1]] = cur[2] +l;
if (l == 0)
que.addFirst(new int[]{s[0], s[1], len[s[0]][s[1]]});
else
que.addLast(new int[]{s[0], s[1], len[s[0]][s[1]]});
}
}
}
return c == 'R' ? len[N -1][N -1] : len[N -1][0];
}
}
class Data extends BaseV{
long v;
public Data(long v){ this.v = v; }
}
abstract class AVLSegmentTree<V extends BaseV, F> {
private V e = e();
private Node root;
private V[] ret = Util.cast(new BaseV[2]);
private int ri;
public AVLSegmentTree(int n){
this();
root = new Node(e(),n);
}
public AVLSegmentTree(){
ret[ri] = e();
ri = 1;
}
public void build(int n,IntFunction<V> init){ root = build(0,n,init); }
private Node build(int l,int r,IntFunction<V> init){
if (r -l == 1)
return new Node(init.apply(l),1);
var ret = new Node(e(),r -l);
ret.lft = build(l,l +r >>1,init);
ret.rht = build(l +r >>1,r,init);
return ret.update();
}
public void add(V v){ add(v,1); }
public void add(V v,int k){ ins(size(),v,k); }
public void ins(int i,V v){ ins(i,v,1); }
public void ins(int i,V v,int k){ root = root == null ? new Node(v,k) : ins(root,i,v,k); }
private Node ins(Node nd,int i,V v,int k){
if (nd.lft == null && (i == 0 || i == nd.sz))
split(nd,i == 0 ? 1 : -1,v,k,nd.sz +k);
else {
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else
nd.push();
if (i < nd.lft.sz)
nd.lft = ins(nd.lft,i,v,k);
else
nd.rht = ins(nd.rht,i -nd.lft.sz,v,k);
}
return balance(nd);
}
public void del(int i){ root = del(root,i); }
private Node del(Node nd,int i){
if (nd.lft == null)
return 0 < --nd.sz ? nd : null;
nd.push();
int c = i < nd.lft.sz ? -1 : 1;
Node del = c < 0 ? del(nd.lft,i) : del(nd.rht,i -nd.lft.sz);
if (del == null)
return nd.cld(-c);
nd.cld(c,del);
return balance(nd);
}
public void upd(int i,F f){ upd(i,i +1,f); }
public void upd(int l,int r,F f){
if (size() < r)
add(e(),r -size());
root = upd(root,l,r,f);
}
private Node upd(Node nd,int l,int r,F f){
if (l == 0 && r == nd.sz)
nd.prop(f);
else if (l < r) {
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),0 < l ? l : r,nd.sz);
else
nd.push();
if (l < nd.lft.sz)
nd.lft = upd(nd.lft,l,min(nd.lft.sz,r),f);
if (nd.lft.sz < r)
nd.rht = upd(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz,f);
nd = balance(nd);
}
return nd;
}
public void toggle(int l,int r){ root = l < r ? toggle(root,l,r) : root; }
private Node toggle(Node nd,int l,int r){
nd.push();
if (0 < l) {
split(nd,l);
nd = merge(nd.lft,nd,toggle(nd.rht,0,r -l));
} else if (r < nd.sz) {
split(nd,r);
nd = merge(toggle(nd.lft,l,r),nd,nd.rht);
} else
nd.toggle();
return nd;
}
private void split(Node nd,int i){
if (nd.lft == null)
split(nd,1,ag(e(),e,nd.val),i,nd.sz);
else {
nd.push();
Node tmp;
if (i < nd.lft.sz) {
split(tmp = nd.lft,i);
nd.lft = tmp.lft;
nd.rht = merge(tmp.rht,tmp,nd.rht);
} else if (nd.lft.sz < i) {
split(tmp = nd.rht,i -nd.lft.sz);
nd.rht = tmp.rht;
nd.lft = merge(nd.lft,tmp,tmp.lft);
}
}
}
private Node merge(Node lft,Node nd,Node rht){
if (abs(lft.rnk -rht.rnk) < 2) {
nd.lft = lft;
nd.rht = rht;
} else if (lft.rnk > rht.rnk) {
lft.push();
lft.rht = merge(lft.rht,nd,rht);
nd = lft;
} else if (lft.rnk < rht.rnk) {
rht.push();
rht.lft = merge(lft,nd,rht.lft);
nd = rht;
}
return balance(nd);
}
public V get(int i){ return get(root,i); }
private V get(Node nd,int i){
if (nd.lft == null)
return nd.val;
nd.push();
return i < nd.lft.sz ? get(nd.lft,i) : get(nd.rht,i -nd.lft.sz);
}
public V get(int l,int r){
ret[ri] = e();
ri ^= 1;
if (root != null)
get(root,l,min(r,size()));
return ret[ri ^= 1];
}
private void get(Node nd,int l,int r){
if (0 == l && r == nd.sz)
ag(ret[ri],ret[ri ^= 1],nd.val());
else if (nd.lft == null)
ag(ret[ri],ret[ri ^= 1],pw(nd.val,r -l));
else {
nd.push();
if (l < nd.lft.sz)
get(nd.lft,l,min(nd.lft.sz,r));
if (nd.lft.sz < r)
get(nd.rht,max(0,l -nd.lft.sz),r -nd.lft.sz);
}
}
public V all(){ return root == null ? e : root.val(); }
public int size(){ return root == null ? 0 : root.sz; }
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected abstract F comp(F f,F g);
protected abstract void tog(V v);
private V ag(V v,V a,V b){
agg(v,a,b);
v.sz = a.sz +b.sz;
return v;
}
protected V pow(V a,int n){
V ret = e();
for (V t = ag(e(),e,a);0 < n;n >>= 1,t = ag(e(),t,t))
if (0 < (n &1))
ret = ag(e(),ret,t);
return ret;
}
private V pw(V a,int n){
V ret = pow(a,n);
ret.sz = n;
return ret;
}
private void split(Node nd,int c,V vl,int i,int sz){
nd.cld(-c,new Node(vl,i));
nd.cld(c,new Node(nd.val,sz -i));
nd.val = e();
}
private Node balance(Node nd){ return (1 < abs(nd.bis = nd.rht.rnk -nd.lft.rnk) ? rotate(nd) : nd).update(); }
private Node rotate(Node u){
var v = u.cld(u.bis);
v.push();
if (u.bis *v.bis < -1)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.update();
return v;
}
private class Node{
private int sz,bis,rnk,tog;
private V val;
private F laz;
private Node lft,rht;
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node update(){
bis = rht.rnk -lft.rnk;
rnk = max(lft.rnk,rht.rnk) +1;
ag(val,lft.val(),rht.val());
sz = val.sz;
return this;
}
private void push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
if (0 < tog) {
lft.toggle();
rht.toggle();
tog = 0;
}
}
private void prop(F f){
map(val,f);
if (lft != null)
laz = laz == null ? f : comp(laz,f);
}
private void toggle(){
bis *= -1;
var tn = lft;
lft = rht;
rht = tn;
tog(val);
if (lft != null)
tog ^= 1;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){ nd = c < 0 ? (lft = nd) : (rht = nd); }
private V val(){ return lft == null && 1 < sz ? pw(val,sz) : val; }
}
}
abstract class BaseV{
public int sz;
public boolean fail;
}
class MyStack<T> extends MyList<T>{
public T pop(){ return remove(size() -1); }
public T peek(){ return get(size() -1); }
}
class MyList<T> implements Iterable<T>{
private T[] arr;
private int sz;
public MyList(){ this(16); }
public MyList(int n){ arr = Util.cast(new Object[n]); }
public boolean isEmpty(){ return sz == 0; }
public int size(){ return sz; }
public T get(int i){ return arr[i]; }
public void add(T t){ (arr = sz < arr.length ? arr : copyOf(arr,sz *5 >>2))[sz++] = t; }
public T remove(int i){
var ret = arr[i];
sz--;
for (int j = i;j < sz;j++)
arr[j] = arr[j +1];
return ret;
}
public T removeFast(int i){
var ret = arr[i];
arr[i] = arr[--sz];
return ret;
}
public void sort(){ sort(Util.cast(Comparator.naturalOrder())); }
public void sort(Comparator<T> cmp){ Arrays.sort(arr,0,sz,cmp); }
@Override
public Iterator<T> iterator(){
return new Iterator<>(){
int i = 0;
@Override
public boolean hasNext(){ return i < sz; }
@Override
public T next(){ return arr[i++]; }
};
}
public <U> MyList<U> map(Function<T, U> func){
MyList<U> ret = new MyList<>(sz);
forEach(t -> ret.add(func.apply(t)));
return ret;
}
public T[] toArray(){
if (sz == 0)
return Util.cast(new Object[0]);
T[] ret = Util.cast(Array.newInstance(arr[0].getClass(),sz));
for (int i = 0;i < sz;i++)
ret[i] = arr[i];
return ret;
}
public void swap(int i,int j){
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
public void set(int i,T t){ arr[i] = t; }
}
class BaseSolver extends Util{
public MyReader in;
public MyWriter out,log;
public BaseSolver(MyReader in,MyWriter out,MyWriter log){
this.in = in;
this.out = out;
this.log = log;
}
protected long inv(long x){ return pow(x,mod -2); }
protected long pow(long x,long n){ return pow(x,n,Util.mod); }
protected long pow(long x,long n,long mod){
long ret = 1;
for (x %= mod;0 < n;x = x *x %mod,n >>= 1)
if ((n &1) == 1)
ret = ret *x %mod;
return ret;
}
protected int bSearchI(int o,int n,IntPredicate judge){
if (!judge.test(o))
return o -Integer.signum(n -o);
for (int m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected long bSearchL(long o,long n,LongPredicate judge){
for (long m = 0;1 < abs(n -o);)
m = judge.test(m = o +n >>1) ? (o = m) : (n = m);
return o;
}
protected double bSearchD(double o,double n,DoublePredicate judge){
for (double m,c = 0;c < 100;c++)
m = judge.test(m = (o +n) /2) ? (o = m) : (n = m);
return o;
}
protected long gcd(long a,long b){
while (0 < b) {
long t = a;
a = b;
b = t %b;
}
return a;
}
public long lcm(long a,long b){ return b /gcd(a,b) *a; }
protected long ceil(long a,long b){ return (a +b -1) /b; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<61 |1 <<30) -1,
mod = 998244353;
public static Random rd = ThreadLocalRandom.current();
private long st = System.currentTimeMillis();
protected long elapsed(){ return System.currentTimeMillis() -st; }
protected void reset(){ st = System.currentTimeMillis(); }
public static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
public static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
public static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
public static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
public int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj){ return (T) obj; }
}
class MyReader{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
public MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
public int it(){ return toIntExact(lg()); }
public int[] it(int N){ return Util.arrI(N,i -> it()); }
public int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
public int idx(){ return it() -1; }
public int[] idx(int N){ return Util.arrI(N,i -> idx()); }
public int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
public long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
public long[] lg(int N){ return Util.arrL(N,i -> lg()); }
public long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
public double dbl(){ return Double.parseDouble(str()); }
public double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
public double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
public char[] ch(){ return str().toCharArray(); }
public char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
public String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
public String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
public String[] str(int N){ return Util.arr(new String[N],i -> str()); }
public String[][] str(int H,int W){ return Util.arr(new String[H][],i -> str(W)); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
private boolean autoflush;
public MyWriter(OutputStream out,boolean autoflush){
this.out = out;
this.autoflush = autoflush;
}
public void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
private void ln(){
write((byte) '\n');
if (autoflush)
flush();
}
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
while (i < ibuf.length)
write(ibuf[i++]);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
public void println(Object obj){
if (obj == null)
obj = "null";
if (obj instanceof Iterable<?>)
for (Object e:(Iterable<?>) obj)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
public void printlns(Object... o){
print(o);
ln();
}
}
| ConDefects/ConDefects/Code/arc177_c/Java/53419632 |
condefects-java_data_1692 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (1 <<30) -1;
static long infL = 1L <<60;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
char[][] A = in.ch(N);
Object solve(){
BitSet[] S = new BitSet[N];
for (int i = 0;i < N;i++) {
S[i] = new BitSet(N);
for (int j = 0;j < N;j++)
if (A[i][j] == '1')
S[i].set(j);
}
long ans = 0;
for (int i = 0;i < N;i++)
for (int k = i +1;k < N;k++)
if (S[i].get(k)) {
BitSet tmp = S[i].get(i +1,k);
tmp.and(S[k]);
ans += tmp.cardinality();
}
return ans;
}
void loga(Seg<?, ?> seg){
Object[] a = new Object[N];
for (int i = 0;i < N;i++) {
long[] t = (long[]) seg.get(i);
a[i] = t[0] *i +t[1];
}
log.println(a);
log.println("");
}
void log(Seg<?, ?> seg){
Object[] a = new Object[N];
for (int i = 0;i < N;i++)
a[i] = seg.get(i);
log.println(a);
log.println("");
}
}
abstract class Seg<V, F> {
protected int n;
private V e;
private V[] val;
private F[] lazy;
private int[] rg;
private int[] stk = new int[100];
@SuppressWarnings("unchecked")
Seg(int n,V e,IntFunction<V> sup){
this.n = n;
this.e = e;
val = (V[]) new Object[n <<1];
lazy = (F[]) new Object[n];
rg = new int[n <<1];
for (int i = n <<1;--i > 0;)
rg[i] = i < n ? rg[i <<1] : 1;
build(sup);
}
void build(IntFunction<V> sup){
for (int i = 0;i < n;i++) {
val[i] = e;
val[i +n] = sup.apply(i);
}
}
V agg(V v0,V v1){ throw new UnsupportedOperationException("agg"); }
V map(V v,F f){ throw new UnsupportedOperationException("map"); }
F comp(F f0,F f1){ throw new UnsupportedOperationException("comp"); }
F powF(F f,int rg){ throw new UnsupportedOperationException("powF"); }
void merge(int i){ val[i] = agg(eval(i <<1),eval(i <<1 |1)); }
void up(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
while (l != r)
if (l > r)
merge(l >>= 1);
else
merge(r >>= 1);
while (1 < l)
merge(l >>= 1);
}
private void comp(int i,F f){
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i],f) : f;
else
val[i] = map(val[i],f);
}
private V eval(int i){
if (i < n && lazy[i] != null) {
val[i] = map(val[i],powF(lazy[i],rg[i]));
comp(i <<1,lazy[i]);
comp(i <<1 |1,lazy[i]);
lazy[i] = null;
}
return val[i];
}
protected void down(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
int s = 0;
while (0 < r) {
while (l > r) {
stk[++s] = l;
l >>= 1;
}
stk[++s] = r;
if (l == r)
l >>= 1;
r >>= 1;
}
while (0 < s)
eval(stk[s--]);
}
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
l += n;
r += n;
do {
if ((l &1) == 1)
comp(l++,f);
if ((r &1) == 1)
comp(--r,f);
} while ((l >>= 1) < (r >>= 1));
}
V get(int i){ return eval(i +n); }
V get(int l,int r){
l += n;
r += n;
V vl = e;
V vr = e;
while (l < r) {
if ((l &1) == 1)
vl = agg(vl,eval(l++));
if ((r &1) == 1)
vr = agg(eval(--r),vr);
l >>= 1;
r >>= 1;
}
return agg(vl,vr);
}
}
class DualSegmentTree<V, F> extends Seg<V, F>{
DualSegmentTree(int n,V e){ this(n,e,i -> e); }
DualSegmentTree(int n,V e,IntFunction<V> sup){ super(n,e,sup); }
@Override
F powF(F f,int rg){ return f; }
@Override
protected void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
V get(int i){
down(i,i +1);
return super.get(i);
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object... o){
print(Util.arr(new Object[o.length],i -> o[i]));
ln();
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (Object e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (1 <<30) -1;
static long infL = 1L <<60;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
char[][] A = in.ch(N);
Object solve(){
BitSet[] S = new BitSet[N];
for (int i = 0;i < N;i++) {
S[i] = new BitSet(N);
for (int j = 0;j < N;j++)
if (A[i][j] == '1')
S[i].set(j);
}
long ans = 0;
for (int i = 0;i < N;i++)
for (int k = i +1;k < N;k++)
if (S[i].get(k)) {
BitSet tmp = S[i].get(i +1,k);
tmp.and(S[k].get(i +1,k));
ans += tmp.cardinality();
}
return ans;
}
void loga(Seg<?, ?> seg){
Object[] a = new Object[N];
for (int i = 0;i < N;i++) {
long[] t = (long[]) seg.get(i);
a[i] = t[0] *i +t[1];
}
log.println(a);
log.println("");
}
void log(Seg<?, ?> seg){
Object[] a = new Object[N];
for (int i = 0;i < N;i++)
a[i] = seg.get(i);
log.println(a);
log.println("");
}
}
abstract class Seg<V, F> {
protected int n;
private V e;
private V[] val;
private F[] lazy;
private int[] rg;
private int[] stk = new int[100];
@SuppressWarnings("unchecked")
Seg(int n,V e,IntFunction<V> sup){
this.n = n;
this.e = e;
val = (V[]) new Object[n <<1];
lazy = (F[]) new Object[n];
rg = new int[n <<1];
for (int i = n <<1;--i > 0;)
rg[i] = i < n ? rg[i <<1] : 1;
build(sup);
}
void build(IntFunction<V> sup){
for (int i = 0;i < n;i++) {
val[i] = e;
val[i +n] = sup.apply(i);
}
}
V agg(V v0,V v1){ throw new UnsupportedOperationException("agg"); }
V map(V v,F f){ throw new UnsupportedOperationException("map"); }
F comp(F f0,F f1){ throw new UnsupportedOperationException("comp"); }
F powF(F f,int rg){ throw new UnsupportedOperationException("powF"); }
void merge(int i){ val[i] = agg(eval(i <<1),eval(i <<1 |1)); }
void up(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
while (l != r)
if (l > r)
merge(l >>= 1);
else
merge(r >>= 1);
while (1 < l)
merge(l >>= 1);
}
private void comp(int i,F f){
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i],f) : f;
else
val[i] = map(val[i],f);
}
private V eval(int i){
if (i < n && lazy[i] != null) {
val[i] = map(val[i],powF(lazy[i],rg[i]));
comp(i <<1,lazy[i]);
comp(i <<1 |1,lazy[i]);
lazy[i] = null;
}
return val[i];
}
protected void down(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
int s = 0;
while (0 < r) {
while (l > r) {
stk[++s] = l;
l >>= 1;
}
stk[++s] = r;
if (l == r)
l >>= 1;
r >>= 1;
}
while (0 < s)
eval(stk[s--]);
}
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
l += n;
r += n;
do {
if ((l &1) == 1)
comp(l++,f);
if ((r &1) == 1)
comp(--r,f);
} while ((l >>= 1) < (r >>= 1));
}
V get(int i){ return eval(i +n); }
V get(int l,int r){
l += n;
r += n;
V vl = e;
V vr = e;
while (l < r) {
if ((l &1) == 1)
vl = agg(vl,eval(l++));
if ((r &1) == 1)
vr = agg(eval(--r),vr);
l >>= 1;
r >>= 1;
}
return agg(vl,vr);
}
}
class DualSegmentTree<V, F> extends Seg<V, F>{
DualSegmentTree(int n,V e){ this(n,e,i -> e); }
DualSegmentTree(int n,V e,IntFunction<V> sup){ super(n,e,sup); }
@Override
F powF(F f,int rg){ return f; }
@Override
protected void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
V get(int i){
down(i,i +1);
return super.get(i);
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
protected void ln(){ write((byte) '\n'); }
private void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
private void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
private void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
private void print(Object obj){
if (obj instanceof Boolean)
print((boolean) obj ? Solver.yes : Solver.no);
else if (obj instanceof Character)
write((byte) (char) obj);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[])
for (char b:(char[]) obj)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object... o){
print(Util.arr(new Object[o.length],i -> o[i]));
ln();
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Collection<?>)
for (Object e:(Collection<?>) obj)
println(e);
else if (obj.getClass().isArray()
&& Array.getLength(obj) > 0
&& !(Array.get(obj,0) instanceof char[])
&& Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
}
class Main{
public static void main(String[] args) throws Exception{
Solver solver = new Solver();
Optional.ofNullable(solver.solve()).ifPresent(solver.out::println);
solver.out.flush();
solver.log.println(solver.elapsed());
}
}
| ConDefects/ConDefects/Code/abc258_g/Java/44851773 |
condefects-java_data_1693 | import java.io.*;
import java.util.*;
public class Main {
public static int INF = 0x3f3f3f3f, mod = 1000000007, mod9 = 998244353;
public static void main(String args[]){
try {
PrintWriter o = new PrintWriter(System.out);
boolean multiTest = false;
// init
if(multiTest) {
int t = fReader.nextInt(), loop = 0;
while (loop < t) {loop++;solve(o);}
} else solve(o);
o.close();
} catch (Exception e) {e.printStackTrace();}
}
static void solve(PrintWriter o) {
try {
int n = fReader.nextInt();
String T = fReader.nextString();
String[] s = new String[n];
for(int i=0;i<n;i++) s[i] = fReader.nextString();
int[] preLen = new int[n];
int[] sufLen = new int[n];
FenWick fen = new FenWick(n+1);
for(int i=0;i<n;i++) {
int j = 0, k = 0;
for(;j<s[i].length();j++) {
if(k == T.length()) break;
if(s[i].charAt(j) == T.charAt(k)) k++;
}
preLen[i] = k;
j = s[i].length()-1;
k = T.length()-1;
for(;j>=0;j--) {
if(k < 0) break;
if(s[i].charAt(j) == T.charAt(k)) k--;
}
sufLen[i] = T.length()-1-k;
fen.add(T.length()-k, 1);
}
long res = 0l;
for(int i=0;i<n;i++) res += n-fen.query(T.length()-preLen[i]);
o.println(res);
} catch (Exception e) {
e.printStackTrace();
}
}
public static int upper_bound(List<Integer> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid) <= val) l = mid + 1;
else r = mid;
}
return l;
}
public static int lower_bound(List<Integer> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid) < val) l = mid + 1;
else r = mid;
}
return l;
}
public static long gcd(long a, long b){
return b == 0 ? a : gcd(b, a%b);
}
public static long lcm(long a, long b){
return a / gcd(a,b)*b;
}
public static long qpow(long a, long n, int md){
a %= md;
long ret = 1l;
while(n > 0){
if((n & 1) == 1){
ret = ret * a % md;
}
n >>= 1;
a = a * a % md;
}
return ret;
}
public static class DSU {
int[] parent;
int[] size;
int n;
public DSU(int n){
this.n = n;
parent = new int[n];
size = new int[n];
for(int i=0;i<n;i++){
parent[i] = i;
size[i] = 1;
}
}
public int find(int p){
while(parent[p] != p){
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
public void union(int p, int q){
int root_p = find(p);
int root_q = find(q);
if(root_p == root_q) return;
if(size[root_p] >= size[root_q]){
parent[root_q] = root_p;
size[root_p] += size[root_q];
size[root_q] = 0;
}
else{
parent[root_p] = root_q;
size[root_q] += size[root_p];
size[root_p] = 0;
}
n--;
}
public int getTotalComNum(){
return n;
}
public int getSize(int i){
return size[find(i)];
}
}
public static class FenWick {
int n;
long[] a;
long[] tree;
public FenWick(int n){
this.n = n;
a = new long[n+1];
tree = new long[n+1];
}
private void add(int x, long val){
while(x <= n){
tree[x] += val;
x += x&-x;
}
}
private void addMx(int x, long val) {
a[x] += val;
tree[x] = a[x];
while(x <= n) {
for(int i=1;i<(x&-x);i<<=1) {
tree[x] = Math.max(tree[x], tree[x-i]);
}
x += x&-x;
}
}
private long query(int x){
long ret = 0l;
while(x > 0){
ret += tree[x];
x -= x&-x;
}
return ret;
}
private long queryMx(int l, int r) {
long res = 0l;
while(l <= r) {
if(r-(r&-r) >= l) {
res = Math.max(res, tree[r]);
r -= r&-r;
}
else {
res = Math.max(res, a[r]);
r--;
}
}
return res;
}
}
public static class Pair{
Integer c1;
Integer c2;
Integer c3;
Integer c4;
public Pair(Integer c1, Integer c2, Integer c3, Integer c4) {
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
this.c4 = c4;
}
@Override
public int hashCode() {
int prime = 31, ret = 1;
ret = ret*prime + c1.hashCode();
ret = ret*prime + c2.hashCode();
ret = ret*prime + c3.hashCode();
ret = ret*prime + c4.hashCode();
return ret;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Pair) {
return c1.equals(((Pair) obj).c1) && c2.equals(((Pair) obj).c2) && c3.equals(((Pair) obj).c3) && c4.equals(((Pair) obj).c4);
}
return false;
}
}
public static class fReader {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static StringTokenizer tokenizer = new StringTokenizer("");
private static String next() throws IOException{
while(!tokenizer.hasMoreTokens()){tokenizer = new StringTokenizer(reader.readLine());}
return tokenizer.nextToken();
}
public static int nextInt() throws IOException {return Integer.parseInt(next());}
public static Long nextLong() throws IOException {return Long.parseLong(next());}
public static double nextDouble() throws IOException {return Double.parseDouble(next());}
public static char nextChar() throws IOException {return next().toCharArray()[0];}
public static String nextString() throws IOException {return next();}
public static String nextLine() throws IOException {return reader.readLine();}
}
}
import java.io.*;
import java.util.*;
public class Main {
public static int INF = 0x3f3f3f3f, mod = 1000000007, mod9 = 998244353;
public static void main(String args[]){
try {
PrintWriter o = new PrintWriter(System.out);
boolean multiTest = false;
// init
if(multiTest) {
int t = fReader.nextInt(), loop = 0;
while (loop < t) {loop++;solve(o);}
} else solve(o);
o.close();
} catch (Exception e) {e.printStackTrace();}
}
static void solve(PrintWriter o) {
try {
int n = fReader.nextInt();
String T = fReader.nextString();
String[] s = new String[n];
for(int i=0;i<n;i++) s[i] = fReader.nextString();
int[] preLen = new int[n];
int[] sufLen = new int[n];
FenWick fen = new FenWick(T.length());
for(int i=0;i<n;i++) {
int j = 0, k = 0;
for(;j<s[i].length();j++) {
if(k == T.length()) break;
if(s[i].charAt(j) == T.charAt(k)) k++;
}
preLen[i] = k;
j = s[i].length()-1;
k = T.length()-1;
for(;j>=0;j--) {
if(k < 0) break;
if(s[i].charAt(j) == T.charAt(k)) k--;
}
sufLen[i] = T.length()-1-k;
fen.add(T.length()-k, 1);
}
long res = 0l;
for(int i=0;i<n;i++) res += n-fen.query(T.length()-preLen[i]);
o.println(res);
} catch (Exception e) {
e.printStackTrace();
}
}
public static int upper_bound(List<Integer> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid) <= val) l = mid + 1;
else r = mid;
}
return l;
}
public static int lower_bound(List<Integer> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid) < val) l = mid + 1;
else r = mid;
}
return l;
}
public static long gcd(long a, long b){
return b == 0 ? a : gcd(b, a%b);
}
public static long lcm(long a, long b){
return a / gcd(a,b)*b;
}
public static long qpow(long a, long n, int md){
a %= md;
long ret = 1l;
while(n > 0){
if((n & 1) == 1){
ret = ret * a % md;
}
n >>= 1;
a = a * a % md;
}
return ret;
}
public static class DSU {
int[] parent;
int[] size;
int n;
public DSU(int n){
this.n = n;
parent = new int[n];
size = new int[n];
for(int i=0;i<n;i++){
parent[i] = i;
size[i] = 1;
}
}
public int find(int p){
while(parent[p] != p){
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
public void union(int p, int q){
int root_p = find(p);
int root_q = find(q);
if(root_p == root_q) return;
if(size[root_p] >= size[root_q]){
parent[root_q] = root_p;
size[root_p] += size[root_q];
size[root_q] = 0;
}
else{
parent[root_p] = root_q;
size[root_q] += size[root_p];
size[root_p] = 0;
}
n--;
}
public int getTotalComNum(){
return n;
}
public int getSize(int i){
return size[find(i)];
}
}
public static class FenWick {
int n;
long[] a;
long[] tree;
public FenWick(int n){
this.n = n;
a = new long[n+1];
tree = new long[n+1];
}
private void add(int x, long val){
while(x <= n){
tree[x] += val;
x += x&-x;
}
}
private void addMx(int x, long val) {
a[x] += val;
tree[x] = a[x];
while(x <= n) {
for(int i=1;i<(x&-x);i<<=1) {
tree[x] = Math.max(tree[x], tree[x-i]);
}
x += x&-x;
}
}
private long query(int x){
long ret = 0l;
while(x > 0){
ret += tree[x];
x -= x&-x;
}
return ret;
}
private long queryMx(int l, int r) {
long res = 0l;
while(l <= r) {
if(r-(r&-r) >= l) {
res = Math.max(res, tree[r]);
r -= r&-r;
}
else {
res = Math.max(res, a[r]);
r--;
}
}
return res;
}
}
public static class Pair{
Integer c1;
Integer c2;
Integer c3;
Integer c4;
public Pair(Integer c1, Integer c2, Integer c3, Integer c4) {
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
this.c4 = c4;
}
@Override
public int hashCode() {
int prime = 31, ret = 1;
ret = ret*prime + c1.hashCode();
ret = ret*prime + c2.hashCode();
ret = ret*prime + c3.hashCode();
ret = ret*prime + c4.hashCode();
return ret;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Pair) {
return c1.equals(((Pair) obj).c1) && c2.equals(((Pair) obj).c2) && c3.equals(((Pair) obj).c3) && c4.equals(((Pair) obj).c4);
}
return false;
}
}
public static class fReader {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static StringTokenizer tokenizer = new StringTokenizer("");
private static String next() throws IOException{
while(!tokenizer.hasMoreTokens()){tokenizer = new StringTokenizer(reader.readLine());}
return tokenizer.nextToken();
}
public static int nextInt() throws IOException {return Integer.parseInt(next());}
public static Long nextLong() throws IOException {return Long.parseLong(next());}
public static double nextDouble() throws IOException {return Double.parseDouble(next());}
public static char nextChar() throws IOException {return next().toCharArray()[0];}
public static String nextString() throws IOException {return next();}
public static String nextLine() throws IOException {return reader.readLine();}
}
} | ConDefects/ConDefects/Code/abc324_e/Java/46709872 |
condefects-java_data_1694 |
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String t = sc.next();
String s[] = new String[n];
int maxLen = 500001;
int preCount[] = new int[maxLen];
int sufCount[] = new int[maxLen];
for(int i = 0; i < n; i++) {
s[i] = sc.next();
int tmpIndex = 0;
for(int j = 0; j < s[i].length(); j++) {
if(s[i].charAt(j) == t.charAt(tmpIndex)) {
tmpIndex++;
if(tmpIndex == t.length()) {
break;
}
}
}
preCount[tmpIndex]++;
tmpIndex = t.length() - 1;
for(int j = s[i].length() - 1; j >= 0; j--) {
if(s[i].charAt(j) == t.charAt(tmpIndex)) {
// System.out.println("Hit : j = " + j + " in " + s[i]);
tmpIndex--;
if(tmpIndex == -1) {
break;
}
}
}
sufCount[t.length() - tmpIndex - 1]++;
}
int sufSum[] = new int[maxLen];
sufSum[0] = sufCount[0];
for(int i = 1; i < maxLen; i++) {
sufSum[i] = sufSum[i - 1] + sufCount[i];
}
// for (int i = 0; i < 10; i++) {
// System.out.println("i = " + i + " preCount " + preCount[i] + " sufCount " + sufCount[i]);
//
// }
long result = 0;
for(int i = 0; i < maxLen; i++) {
if(preCount[i] == 0) {
continue;
}
// System.out.println("i = " + i);
int tmp = t.length() - i - 1;
if(tmp >= 0) {
result += (long) (n - sufSum[tmp]) * preCount[i];
}
else {
result += n * preCount[i];
}
}
System.out.println(result);
}
}
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String t = sc.next();
String s[] = new String[n];
int maxLen = 500001;
int preCount[] = new int[maxLen];
int sufCount[] = new int[maxLen];
for(int i = 0; i < n; i++) {
s[i] = sc.next();
int tmpIndex = 0;
for(int j = 0; j < s[i].length(); j++) {
if(s[i].charAt(j) == t.charAt(tmpIndex)) {
tmpIndex++;
if(tmpIndex == t.length()) {
break;
}
}
}
preCount[tmpIndex]++;
tmpIndex = t.length() - 1;
for(int j = s[i].length() - 1; j >= 0; j--) {
if(s[i].charAt(j) == t.charAt(tmpIndex)) {
// System.out.println("Hit : j = " + j + " in " + s[i]);
tmpIndex--;
if(tmpIndex == -1) {
break;
}
}
}
sufCount[t.length() - tmpIndex - 1]++;
}
int sufSum[] = new int[maxLen];
sufSum[0] = sufCount[0];
for(int i = 1; i < maxLen; i++) {
sufSum[i] = sufSum[i - 1] + sufCount[i];
}
// for (int i = 0; i < 10; i++) {
// System.out.println("i = " + i + " preCount " + preCount[i] + " sufCount " + sufCount[i]);
//
// }
long result = 0;
for(int i = 0; i < maxLen; i++) {
if(preCount[i] == 0) {
continue;
}
// System.out.println("i = " + i);
int tmp = t.length() - i - 1;
if(tmp >= 0) {
result += (long) (n - sufSum[tmp]) * preCount[i];
}
else {
result += (long)n * preCount[i];
}
}
System.out.println(result);
}
}
| ConDefects/ConDefects/Code/abc324_e/Java/47796252 |
condefects-java_data_1695 | //package atcoder.abc324;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO edit this code, this code is for
// https://atcoder.jp/contests/practice/tasks/practice_1
// param
Scanner sc = new Scanner(System.in);
int N = Integer.parseInt(sc.next());
String T = sc.next();
int[] firstLet=new int[N];
int[] lastLet=new int[N];
int Tl=T.length();
for(int i=0;i<N;i++){
String S=sc.next();
int L=S.length();
for(int d=0;d<L;d++){
if(firstLet[i]<Tl){
if(S.charAt(d)==(T.charAt(firstLet[i]))){
firstLet[i]++;
}
}
if(lastLet[i]<Tl){
if(S.charAt(L-d-1)==T.charAt(Tl-lastLet[i]-1)){
lastLet[i]++;
}
}
}
//System.out.println(firstLet[i]);
//System.out.println(lastLet[i]);
}
Arrays.sort(firstLet);
Arrays.sort(lastLet);
sc.close();
int count=0;
int now=0;
for(int i=N-1;i>=0;i--){
while(now<N&&firstLet[i]+lastLet[now]<Tl){
now++;
}
count=count+N-now;
}
System.out.println(count);
// resolve
// answer
}
}
//package atcoder.abc324;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO edit this code, this code is for
// https://atcoder.jp/contests/practice/tasks/practice_1
// param
Scanner sc = new Scanner(System.in);
int N = Integer.parseInt(sc.next());
String T = sc.next();
int[] firstLet=new int[N];
int[] lastLet=new int[N];
int Tl=T.length();
for(int i=0;i<N;i++){
String S=sc.next();
int L=S.length();
for(int d=0;d<L;d++){
if(firstLet[i]<Tl){
if(S.charAt(d)==(T.charAt(firstLet[i]))){
firstLet[i]++;
}
}
if(lastLet[i]<Tl){
if(S.charAt(L-d-1)==T.charAt(Tl-lastLet[i]-1)){
lastLet[i]++;
}
}
}
//System.out.println(firstLet[i]);
//System.out.println(lastLet[i]);
}
Arrays.sort(firstLet);
Arrays.sort(lastLet);
sc.close();
long count=0;
int now=0;
for(int i=N-1;i>=0;i--){
while(now<N&&firstLet[i]+lastLet[now]<Tl){
now++;
}
count=count+N-now;
}
System.out.println(count);
// resolve
// answer
}
} | ConDefects/ConDefects/Code/abc324_e/Java/46586707 |
condefects-java_data_1696 | import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import java.io.*;
class Solve extends Util {
void solve() {
int n = in.i();
String t = in.s();
char[] ts = t.toCharArray();
String[] ss = new String[n];
char[][] sss = new char[n][];
for (int i = 0; i < n; i++) {
ss[i] = in.s();
sss[i] = ss[i].toCharArray();
}
// 前a文字、後b文字の部分列を持って、合わせてtの長さ以上なら連結したものは合格
// それでも計算が間に合わない？
int[] head = new int[n];
int[] tail = new int[n];
HashMap<Integer, Integer> headmap = new HashMap<>(n);
HashMap<Integer, Integer> tailmap = new HashMap<>(n);
for (int i = 0; i < n; i++) {
{
int tsi = 0;
for (int j = 0; j < sss[i].length && tsi < ts.length; j++) {
if (sss[i][j] == ts[tsi]) {
tsi++;
}
}
head[i] = tsi;
headmap.put(tsi, headmap.getOrDefault(tsi, 0) + 1);
}
{
int tsi = 0;
for (int j = 0; j < sss[i].length && tsi < ts.length; j++) {
if (sss[i][sss[i].length - j - 1] == ts[ts.length - tsi - 1]) {
tsi++;
}
}
tail[i] = tsi;
tailmap.put(tsi, tailmap.getOrDefault(tsi, 0) + 1);
}
}
long ans = 0;
var headset = headmap.entrySet();
var tailset = tailmap.entrySet();
for (var hd : headset) {
for (var td : tailset) {
if (hd.getKey() + td.getKey() >= ts.length) ans += hd.getValue() * td.getValue();
}
}
out.an(ans);
}
}
// My Library
// Version: 2023.07.01
// =================================================================================================
// TODO:
// * end を半開区間にする
public class Main extends Util {
public static void main(String[] args) {
try {
new Solve().solve();
} catch (Exception e) {
throw e;
} finally {
out.flush();
}
}
}
@FunctionalInterface
interface F1<T, R> extends Function<T, R> {
default R x(T t) { return apply(t); }
}
@FunctionalInterface
interface F2<T, U, R> extends BiFunction<T, U, R> {
default F1<U, R> x(T p1) { return p2 -> apply(p1, p2); }
default F1<T, F1<U, R>> currying() { return p1 -> p2 -> apply(p1, p2); }
default F2<U, T, R> flip() { return (p1, p2) -> apply(p2, p1); }
}
@FunctionalInterface
interface F3<T, U, V, R> {
R apply(T t, U u, V v);
default F2<U, V, R> x(T p1) { return (p2, p3) -> apply(p1, p2, p3); }
default F1<V, R> x(T p1, U p2) { return p3 -> apply(p1, p2, p3); }
default F1<T, F1<U, F1<V, R>>> currying() { return p1 -> p2 -> p3 -> apply(p1, p2, p3); }
default F3<V, U, T, R> flip() { return (p1, p2, p3) -> apply(p3, p2, p1); }
}
@FunctionalInterface
interface F4<T, U, V, W, R> {
R apply(T t, U u, V v, W w);
default F3<U, V, W, R> x(T p1) { return (p2, p3, p4) -> apply(p1, p2, p3, p4); }
default F2<V, W, R> x(T p1, U p2) { return (p3, p4) -> apply(p1, p2, p3, p4); }
default F1<W, R> x(T p1, U p2, V p3) { return p4 -> apply(p1, p2, p3, p4); }
default F1<T, F1<U, F1<V, F1<W, R>>>> currying() { return p1 -> p2 -> p3 -> p4 -> apply(p1, p2, p3, p4); }
default F4<W, V, U, T, R> flip() { return (p1, p2, p3, p4) -> apply(p4, p3, p2, p1); }
}
@FunctionalInterface
interface F5<T, U, V, W, X, R> {
R apply(T t, U u, V v, W w, X x);
default F4<U, V, W, X, R> x(T p1) { return (p2, p3, p4, p5) -> apply(p1, p2, p3, p4, p5); }
default F3<V, W, X, R> x(T p1, U p2) { return (p3, p4, p5) -> apply(p1, p2, p3, p4, p5); }
default F2<W, X, R> x(T p1, U p2, V p3) { return (p4, p5) -> apply(p1, p2, p3, p4, p5); }
default F1<X, R> x(T p1, U p2, V p3, W p4) { return p5 -> apply(p1, p2, p3, p4, p5); }
default F1<T, F1<U, F1<V, F1<W, F1<X, R>>>>> currying() { return p1 -> p2 -> p3 -> p4 -> p5 -> apply(p1, p2, p3, p4, p5); }
default F5<X, W, V, U, T, R> flip() { return (p1, p2, p3, p4, p5) -> apply(p5, p4, p3, p2, p1); }
}
@FunctionalInterface
interface F6<T, U, V, W, X, Y, R> {
R apply(T t, U u, V v, W w, X x, Y y);
default F5<U, V, W, X, Y, R> x(T p1) { return (p2, p3, p4, p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F4<V, W, X, Y, R> x(T p1, U p2) { return (p3, p4, p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F3<W, X, Y, R> x(T p1, U p2, V p3) { return (p4, p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F2<X, Y, R> x(T p1, U p2, V p3, W p4) { return (p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F1<Y, R> x(T p1, U p2, V p3, W p4, X p5) { return p6 -> apply(p1, p2, p3, p4, p5, p6); }
default F1<T, F1<U, F1<V, F1<W, F1<X, F1<Y, R>>>>>> currying() { return p1 -> p2 -> p3 -> p4 -> p5 -> p6 -> apply(p1, p2, p3, p4, p5, p6); }
default F6<Y, X, W, V, U, T, R> flip() { return (p1, p2, p3, p4, p5, p6) -> apply(p6, p5, p4, p3, p2, p1); }
}
@FunctionalInterface
interface F7<T, U, V, W, X, Y, Z, R> {
R apply(T t, U u, V v, W w, X x, Y y, Z z);
default F6<U, V, W, X, Y, Z, R> x(T p1) { return (p2, p3, p4, p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F5<V, W, X, Y, Z, R> x(T p1, U p2) { return (p3, p4, p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F4<W, X, Y, Z, R> x(T p1, U p2, V p3) { return (p4, p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F3<X, Y, Z, R> x(T p1, U p2, V p3, W p4) { return (p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F2<Y, Z, R> x(T p1, U p2, V p3, W p4, X p5) { return (p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F1<Z, R> x(T p1, U p2, V p3, W p4, X p5, Y p6) { return p7 -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F1<T, F1<U, F1<V, F1<W, F1<X, F1<Y, F1<Z, R>>>>>>> currying() { return p1 -> p2 -> p3 -> p4 -> p5 -> p6 -> p7 -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F7<Z, Y, X, W, V, U, T, R> flip() { return (p1, p2, p3, p4, p5, p6, p7) -> apply(p7, p6, p5, p4, p3, p2, p1); }
}
class RLENode<T> {
T val;
int len;
RLENode(T val, int len) {
this.val = val;
this.len = len;
}
}
// FIXME:
class RLE<T> {
RLENode<T>[] values;
public RLE(T[] target) {
if (target.length == 0) {
@SuppressWarnings("unchecked")
RLENode<T>[] array = new RLENode[0];
values = array;
return;
}
List<RLENode<T>> list = new ArrayList<>();
T cur = target[0];
int cnt = 1;
for (int i = 1; i < target.length; i++) {
if (target[i].equals(cur)) { // NOTE: 参照比較をしないように注意
cnt++;
} else {
list.add(new RLENode<T>(cur, cnt));
cur = target[i];
cnt = 1;
}
}
list.add(new RLENode<T>(cur, cnt));
@SuppressWarnings("unchecked")
RLENode<T>[] array = list.toArray(RLENode[]::new);
values = array;
}
void print() {
for (int i = 0; i < values.length; i++) {
System.out.println(values[i].val + " " + values[i].len);
}
}
HashMap<T, Integer> toMap() {
HashMap<T, Integer> map = new HashMap<>();
for (int i = 0; i < values.length; i++) {
map.put(values[i].val, values[i].len);
}
return map;
}
}
class Graph {
List<Integer>[] edges;
int[] weights;
int n;
boolean sortedEdges;
boolean isDirected;
@SuppressWarnings("unchecked")
Graph(int n, boolean isDirected, boolean sortEdges) {
this.n = n;
this.edges = new ArrayList[n+1];
for (int i = 1; i <= n; i++) {
edges[i] = new ArrayList<Integer>();
}
this.weights = new int[n+1];
this.sortedEdges = !sortEdges;
this.isDirected = isDirected;
}
Graph(int n, boolean isDirected) {
this(n, isDirected, false);
}
public void addEdge(int u, int v) {
assert 1 <= u && u <= n;
assert 1 <= v && v <= n;
edges[u].add(v);
if (!isDirected) edges[v].add(u);
sortedEdges = false;
}
public void addEdge(int[] u, int[] v) {
assert u != null && v != null;
assert u.length == v.length;
for (int i = 0; i < u.length; i++) addEdge(u[i], v[i]);
}
private void sortEdges() {
for (int i = 1; i <= n; i++) Collections.sort(this.edges[i]);
sortedEdges = true;
}
public List<Integer> bfs(Graph g, int s) {
int[] ps = new int[this.n+1];
int[] ds = new int[this.n+1];
int[] cs = new int[this.n+1];
List<Integer> path = new ArrayList<Integer>();
Arrays.fill(ds, Integer.MAX_VALUE);
ds[s] = 0;
Deque<Integer> q = new ArrayDeque<Integer>();
q.add(s);
cs[s] = 1;
while (!q.isEmpty()) {
int u = q.remove();
path.add(u);
for (int v : g.edges[u]) {
if (cs[v] == 0) {
ps[v] = u;
ds[v] = ds[u] + 1;
cs[v] = 1;
q.add(v);
}
}
cs[u] = 2;
}
return path;
}
public int[] dfs(int s, int g) {
int[] ds = new int[n+1]; // depth
int[] fs = new int[n+1]; // first discovered
int[] cs = new int[n+1]; // color (0: white, 1: gray, 2: black)
int[] pi = new int[n+1]; // parent index
List<Integer> path = new ArrayList<Integer>();
int time = 0;
sortEdges();
dfs(ds, fs, cs, pi, path, time, s, g);
int[] res = Util.toIntArray(path);
Util.reverse(res);
return res;
}
public boolean dfs(int[] ds, int[] fs, int[] cs, int[] pi, List<Integer> path, int time, int u, int g) {
time++;
ds[u] = time;
cs[u] = 1;
if (u == g) {
path.add(u);
return true;
}
for (int v : this.edges[u]) {
if (pi[u] != v) {
pi[v] = u;
boolean res = dfs(ds, fs, cs, pi, path, time, v, g);
if (res) {
path.add(u);
return true;
}
}
}
cs[u] = 2;
time++;
fs[u] = time;
return false;
}
}
// convert list, array, map, set, queue, stack
class Test {
public static long pow(long a, long b, long mod) {
if (b == 0) return 1;
if (b == 1) return a;
if (b % 2 == 0) return pow(a * a % mod, b / 2, mod);
return a * pow(a * a % mod, b / 2, mod) % mod;
}
public static void sortSome(long[] key, long[]... value) {
long[][] array = new long[key.length][1+value.length];
for (int i = 0; i < key.length; i++) {
array[0][i] = key[i];
for (int j = 1; j < array[i].length; j++) {
array[j][i] = value[j-1][i];
}
}
Arrays.sort(array, Comparator.comparingLong(a -> a[0]));
}
public static long[] primeFact(long n, boolean allow_dup) {
List<Long> list = new ArrayList<>();
int upper = (int)Math.sqrt(n) + 1;
for (long i = 2; i <= upper; i++) {
if (n % i != 0) continue;
list.add(i);
n /= i;
while (n % i == 0) {
if (allow_dup) list.add(i);
n /= i;
}
}
if (n != 1) list.add(n);
return list.stream().mapToLong(i -> i).toArray();
}
static List<long[]> permutation(long[] seed) {
List<long[]> list = new ArrayList<>();
long[] perm = new long[seed.length];
boolean[] used = new boolean[seed.length];
buildPerm(list, seed, perm, used, 0);
return list;
}
static void buildPerm(List<long[]> list, long[] seed, long[] perm, boolean[] used, int index) {
if (index == seed.length) {
list.add(perm.clone());
return;
}
for (int i = 0; i < seed.length; i++) {
if (used[i]) continue;
perm[index] = seed[i];
used[i] = true;
buildPerm(list, seed, perm, used, index + 1);
used[i] = false;
}
}
static void combInternal(List<int[]> res, int input[], int empty[], int start, int end, int index, int r) {
if (index == r) {
res.add(Arrays.copyOf(empty, r));
return;
}
for (int y = start; y <= end && end - y + 1 >= r - index; y++) {
empty[index] = input[y];
combInternal(res, input, empty, y + 1, end, index + 1, r);
}
}
static List<int[]> combination(int input[], int n, int r) {
int empty[] = new int[r];
List<int[]> list = new ArrayList<>();
combInternal(list, input, empty, 0, n-1, 0, r);
return list;
}
}
class Util {
static In in = new In();
static Out out = new Out();
public static final int N10_9 = 1000000000;
public static final int N10_9_7 = 1000000007;
public static final char[] abc = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
public static final char[] ABC = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
public static void sort(Object[] a) {
Arrays.sort(a);
}
public static <T> void sort(T[] a, Comparator<? super T> c) {
Arrays.sort(a, c);
}
public static void sort(int[] a) {
Arrays.sort(a);
}
public static void sort(int[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static void sort(long[] a) {
Arrays.sort(a);
}
public static void sort(long[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static void sort(double[] a) {
Arrays.sort(a);
}
public static void sort(double[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static void sort(char[] a) {
Arrays.sort(a);
}
public static void sort(char[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static int gcd(int a, int b) {
return MyMath.gcd(a, b);
}
public static long gcd(long a, long b) {
return MyMath.gcd(a, b);
}
public static int lcm(int a, int b) {
return MyMath.lcm(a, b);
}
public static long lcm(long a, long b) {
return MyMath.lcm(a, b);
}
public static int sum(int[] a, int start, int end) {
int sum = 0;
for (int i = start; i < end; i++) sum += a[i];
return sum;
}
public static long sum(long[] a, int start, int end) {
long sum = 0;
for (int i = start; i < end; i++) sum += a[i];
return sum;
}
public static double sum(double[] a, int start, int end) {
double sum = 0;
for (int i = start; i < end; i++) sum += a[i];
return sum;
}
public static int sum(int[] a) {
return sum(a, 0, a.length);
}
public static long sum(long[] a) {
return sum(a, 0, a.length);
}
public static double sum(double[] a) {
return sum(a, 0, a.length);
}
public static int sum(int a, int ... b) {
return a + sum(b);
}
public static long sum(long a, long ... b) {
return a + sum(b);
}
public static double sum(double a, double ... b) {
return a + sum(b);
}
public static int lower_bound(List<Integer> list, int target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static int upper_bound(List<Integer> list, int target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) > 0 ? 1 : -1);
}
public static int lower_bound(List<Long> list, long target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static int upper_bound(List<Long> list, long target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) > 0 ? 1 : -1);
}
// ビット全探索
public static boolean[][] bitAll(int n) {
boolean[][] res = new boolean[1 << n][n];
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
res[i][j] = (i >> j & 1) == 1;
}
}
return res;
}
public static boolean[][] bitAll(int n, int bitCount) {
List<boolean[]> res = new ArrayList<>();
boolean[] b = new boolean[n];
for (int i = (1 << bitCount) - 1; i < 1 << n;) {
assert Integer.bitCount(i) == bitCount;
for (int j = 0; j < n; j++) b[j] = (i >> j & 1) == 1;
res.add(b.clone());
int t = i | i - 1;
i = t + 1 | (~t & -~t) - 1 >> Integer.numberOfTrailingZeros(i) + 1;
}
return toBooleanArrayArray(res);
}
public static int[][] bitAllFilter(boolean[][] use, int[] array) {
int[][] res = new int[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new int[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static long[][] bitAllFilter(boolean[][] use, long[] array) {
long[][] res = new long[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new long[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static double[][] bitAllFilter(boolean[][] use, double[] array) {
double[][] res = new double[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new double[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static Object[][] bitAllFilter(boolean[][] use, Object[] array) {
Object[][] res = new Object[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new Object[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static int[][][] bitAllFilter(boolean[][] use, int[][] array) {
int[][][] res = new int[use.length][][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new int[size][];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static long[][][] bitAllFilter(boolean[][] use, long[][] array) {
long[][][] res = new long[use.length][][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new long[size][];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static int[] arrayRange(int start, int end, int headspace, int tailspace) {
int n = end - start + 1;
int[] res = new int[n + headspace + tailspace];
int cur = start;
for (int i = headspace; i < n + headspace; i++) res[i] = cur++;
return res;
}
public static int[] arrayRange(int start, int end) {
return arrayRange(start, end, 0, 0);
}
public static long[] arrayRange(long start, long end, int headspace, int tailspace) {
long n = end - start + 1;
long[] res = new long[(int)n + headspace + tailspace];
long cur = start;
for (int i = headspace; i < n + headspace; i++) res[i] = cur++;
return res;
}
public static long[] arrayRange(long start, long end) {
return arrayRange(start, end, 0, 0);
}
public static long[] toLongArray(Collection<?> list) {
return list.stream().mapToLong(i -> (long)i).toArray();
}
public static int[] toIntArray(Collection<?> list) {
return list.stream().mapToInt(i -> (int)i).toArray();
}
public static double[] toDoubleArray(Collection<?> list) {
return list.stream().mapToDouble(i -> (double)i).toArray();
}
public static boolean[] toBooleanArray(Collection<?> list) {
Object[] a = list.toArray();
boolean[] b = new boolean[a.length];
for (int i = 0; i < b.length; i++) {
b[i] = (boolean)a[i];
}
return b;
}
public static String[] toStringArray(Collection<?> list) {
return list.stream().map(i -> i.toString()).toArray(String[]::new);
}
public static long[][] toLongArrayArray(Collection<?> list) {
return list.toArray(long[][]::new);
}
public static int[][] toIntArrayArray(Collection<?> list) {
return list.toArray(int[][]::new);
}
public static double[][] toDoubleArrayArray(Collection<?> list) {
return list.toArray(double[][]::new);
}
public static boolean[][] toBooleanArrayArray(Collection<?> list) {
return list.toArray(boolean[][]::new);
}
public static String[][] toStringArrayArray(Collection<?> list) {
return list.toArray(String[][]::new);
}
public static <T> void reverse(T[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(boolean[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(int[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(long[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(double[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(float[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(byte[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(char[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static int[] distinct(int[] a) {
return Arrays.stream(a).distinct().toArray();
}
public static long[] distinct(long[] a) {
return Arrays.stream(a).distinct().toArray();
}
public static double[] distinct(double[] a) {
return Arrays.stream(a).distinct().toArray();
}
public static void fill(int[] a, int v) {
Arrays.fill(a, v);
}
public static void fill(long[] a, long v) {
Arrays.fill(a, v);
}
public static void fill(double[] a, double v) {
Arrays.fill(a, v);
}
public static void fill(boolean[] a, boolean v) {
Arrays.fill(a, v);
}
public static void fill(char[] a, char v) {
Arrays.fill(a, v);
}
public static void fill(int[][] a, int v) {
for (int[] i : a) fill(i, v);
}
public static void fill(long[][] a, long v) {
for (long[] i : a) fill(i, v);
}
public static void fill(double[][] a, double v) {
for (double[] i : a) fill(i, v);
}
public static void fill(boolean[][] a, boolean v) {
for (boolean[] i : a) fill(i, v);
}
public static void fill(char[][] a, char v) {
for (char[] i : a) fill(i, v);
}
public static void fill(int[][][] a, int v) {
for (int[][] i : a) fill(i, v);
}
public static void fill(long[][][] a, long v) {
for (long[][] i : a) fill(i, v);
}
public static void fill(double[][][] a, double v) {
for (double[][] i : a) fill(i, v);
}
public static void fill(boolean[][][] a, boolean v) {
for (boolean[][] i : a) fill(i, v);
}
public static void fill(char[][][] a, char v) {
for (char[][] i : a) fill(i, v);
}
public static void fill(int[][][][] a, int v) {
for (int[][][] i : a) fill(i, v);
}
public static void fill(long[][][][] a, long v) {
for (long[][][] i : a) fill(i, v);
}
public static void fill(double[][][][] a, double v) {
for (double[][][] i : a) fill(i, v);
}
public static void fill(boolean[][][][] a, boolean v) {
for (boolean[][][] i : a) fill(i, v);
}
public static void fill(char[][][][] a, char v) {
for (char[][][] i : a) fill(i, v);
}
// NOTE: These methods require Java 16 or higher.
public static List<Long> arrayToList(long[] array) {
return Arrays.stream(array).boxed().collect(Collectors.toList());
//return Arrays.stream(array).boxed().toList();
}
public static List<Integer> arrayToList(int[] array) {
return Arrays.stream(array).boxed().collect(Collectors.toList());
//return Arrays.stream(array).boxed().toList();
}
public static List<Double> arrayToList(double[] array) {
return Arrays.stream(array).boxed().collect(Collectors.toList());
//return Arrays.stream(array).boxed().toList();
}
public static List<Boolean> arrayToList(boolean[] array) {
Boolean[] a = new Boolean[array.length];
for (int i = 0; i < a.length; i++) a[i] = array[i];
return Arrays.stream(a).collect(Collectors.toList());
//return Arrays.stream(a).toList();
}
public static List<Character> arrayToList(char[] array) {
return Arrays.stream(arrayBoxed(array)).collect(Collectors.toList());
}
public static <T> List<T> arrayToList(T[] array) {
return Arrays.stream(array).collect(Collectors.toList());
//return Arrays.stream(array).toList();
}
public static Long[] arrayBoxed(long[] array) {
return Arrays.stream(array).boxed().toArray(Long[]::new);
}
public static Integer[] arrayBoxed(int[] array) {
return Arrays.stream(array).boxed().toArray(Integer[]::new);
}
public static Double[] arrayBoxed(double[] array) {
return Arrays.stream(array).boxed().toArray(Double[]::new);
}
public static Boolean[] arrayBoxed(boolean[] array) {
Boolean[] a = new Boolean[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
public static Character[] arrayBoxed(char[] array) {
Character[] a = new Character[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
public static long[] arrayUnboxed(Long[] array) {
return Arrays.stream(array).mapToLong(i -> i).toArray();
}
public static int[] arrayUnboxed(Integer[] array) {
return Arrays.stream(array).mapToInt(i -> i).toArray();
}
public static double[] arrayUnboxed(Double[] array) {
return Arrays.stream(array).mapToDouble(i -> i).toArray();
}
public static boolean[] arrayUnboxed(Boolean[] array) {
boolean[] a = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
public static char[] arrayUnboxed(Character[] array) {
char[] a = new char[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
// 最大値 (int)
public static int max(int a, int b) {
return Math.max(a, b);
}
public static int max(int a, int ... nums) {
return max(a, max(nums));
}
public static int max(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = a[0];
for (int i = start; i <= end; i++) res = Math.max(res, a[i]);
return res;
}
public static int max(int[] a, int start) {
return max(a, start, a.length - 1);
}
public static int max(int[] a) {
return max(a, 0, a.length - 1);
}
public static int maxIndex(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] > a[res]) res = i;
}
return res;
}
public static int maxIndex(int[] a, int start) {
return maxIndex(a, start, a.length - 1);
}
public static int maxIndex(int[] a) {
return maxIndex(a, 0, a.length - 1);
}
// 最小値 (int)
public static int min(int a, int b) {
return Math.min(a, b);
}
public static int min(int a, int ... nums) {
return min(a, min(nums));
}
public static int min(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = a[0];
for (int i = start; i <= end; i++) res = Math.min(res, a[i]);
return res;
}
public static int min(int[] a, int start) {
return min(a, start, a.length - 1);
}
public static int min(int[] a) {
return min(a, 0, a.length - 1);
}
public static int minIndex(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] < a[res]) res = i;
}
return res;
}
public static int minIndex(int[] a, int start) {
return minIndex(a, start, a.length - 1);
}
public static int minIndex(int[] a) {
return minIndex(a, 0, a.length - 1);
}
// 最大値 (long)
public static long max(long a, long b) {
return Math.max(a, b);
}
public static long max(long a, long ... nums) {
return max(a, max(nums));
}
public static long max(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
long res = a[0];
for (int i = start; i <= end; i++) res = Math.max(res, a[i]);
return res;
}
public static long max(long[] a, int start) {
return max(a, start, a.length - 1);
}
public static long max(long[] a) {
return max(a, 0, a.length - 1);
}
public static int maxIndex(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] > a[res]) res = i;
}
return res;
}
public static int maxIndex(long[] a, int start) {
return maxIndex(a, start, a.length - 1);
}
public static int maxIndex(long[] a) {
return maxIndex(a, 0, a.length - 1);
}
// 最小値 (long)
public static long min(long a, long b) {
return Math.min(a, b);
}
public static long min(long a, long ... nums) {
return min(a, min(nums));
}
public static long min(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
long res = a[0];
for (int i = start; i <= end; i++) res = Math.min(res, a[i]);
return res;
}
public static long min(long[] a, int start) {
return min(a, start, a.length - 1);
}
public static long min(long[] a) {
return min(a, 0, a.length - 1);
}
public static int minIndex(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] < a[res]) res = i;
}
return res;
}
public static int minIndex(long[] a, int start) {
return minIndex(a, start, a.length - 1);
}
public static int minIndex(long[] a) {
return minIndex(a, 0, a.length - 1);
}
// 最大値 (double)
public static double max(double a, double b) {
return Math.max(a, b);
}
public static double max(double a, double ... nums) {
return max(a, max(nums));
}
public static double max(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
double res = a[0];
for (int i = start; i <= end; i++) res = Math.max(res, a[i]);
return res;
}
public static double max(double[] a, int start) {
return max(a, start, a.length - 1);
}
public static double max(double[] a) {
return max(a, 0, a.length - 1);
}
public static int maxIndex(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] > a[res]) res = i;
}
return res;
}
public static int maxIndex(double[] a, int start) {
return maxIndex(a, start, a.length - 1);
}
public static int maxIndex(double[] a) {
return maxIndex(a, 0, a.length - 1);
}
// 最小値 (double)
public static double min(double a, double b) {
return Math.min(a, b);
}
public static double min(double a, double ... nums) {
return min(a, min(nums));
}
public static double min(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
double res = a[0];
for (int i = start; i <= end; i++) res = Math.min(res, a[i]);
return res;
}
public static double min(double[] a, int start) {
return min(a, start, a.length - 1);
}
public static double min(double[] a) {
return min(a, 0, a.length - 1);
}
public static int minIndex(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] < a[res]) res = i;
}
return res;
}
public static int minIndex(double[] a, int start) {
return minIndex(a, start, a.length - 1);
}
public static int minIndex(double[] a) {
return minIndex(a, 0, a.length - 1);
}
// 絶対値
public static int abs(int a) {
return Math.abs(a);
}
public static long abs(long a) {
return Math.abs(a);
}
public static double abs(double a) {
return Math.abs(a);
}
// チェビシェフ距離（チェス盤距離）
public static long chebyshevDistance(long x1, long y1, long x2, long y2) {
return max(abs(x1 - x2), abs(y1 - y2));
}
public static int chebyshevDistance(int x1, int y1, int x2, int y2) {
return max(abs(x1 - x2), abs(y1 - y2));
}
// マンハッタン距離
public static long manhattanDistance(long x1, long y1, long x2, long y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
public static int manhattanDistance(int x1, int y1, int x2, int y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
// ユークリッド距離
public static int euclideanDistance(int x1, int y1, int x2, int y2) {
return (int) Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
}
public static long euclideanDistance(long x1, long y1, long x2, long y2) {
return (long) Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
}
// 外積
public static long cross(long ox, long oy, long ax, long ay, long bx, long by) {
// 外積: |a||b|sinθ = axby - bxay
return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy);
}
public static long cross(long ax, long xy, long bx, long by) {
// 外積: |a||b|sinθ = axby - bxay
return cross(0, 0, ax, xy, bx, by);
}
// 内積
public static long dot(long ox, long oy, long ax, long ay, long bx, long by) {
// 内積: |a||b|cosθ = axbx + ayby
return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy);
}
public static long dot(long ax, long xy, long bx, long by) {
// 内積: |a||b|cosθ = axbx + ayby
return dot(0, 0, ax, xy, bx, by);
}
// swap
public static String swap(String s, int i, int j) {
char[] cs = s.toCharArray();
char tmp = cs[i]; cs[i] = cs[j]; cs[j] = tmp;
return String.valueOf(cs);
}
public static void swap(boolean[] a, int i, int j) {
boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(int[] a, int i, int j) {
int tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(long[] a, int i, int j) {
long tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(double[] a, int i, int j) {
double tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(float[] a, int i, int j) {
float tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(byte[] a, int i, int j) {
byte tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(char[] a, int i, int j) {
char tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static <T> void swap(T[] a, int i, int j) {
T tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static <T> void swap(List<T> a, int i, int j) {
T tmp = a.get(i); a.set(i, a.get(j)); a.set(j, tmp);
}
// 間にあるかどうか
public static boolean between(int a, int x, int b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(long a, long x, long b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(double a, double x, double b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(float a, float x, float b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(byte a, byte x, byte b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(char a, char x, char b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
// modpow (a^b mod m) 繰り返し二乗法
public static long modpow(long a, long b, long m) {
long res = 1;
while (b > 0) {
if ((b & 1) == 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
public static long modadd(long a, long b, long m) {
return (a + b) % m;
}
public static long modsub(long a, long b, long m) {
return (a - b + m) % m;
}
public static long modmul(long a, long b, long m) {
return (a * b) % m;
}
public static long moddiv(long a, long b, long m) {
return (a * modpow(b, m - 2, m)) % m;
}
}
class ModInt {
private long mod;
private long val;
public ModInt(long val, long mod) {
this.mod = mod;
this.val = val % mod;
}
public long toLong() {
return val;
}
public String toString() {
return String.valueOf(val);
}
// modpow (a^b mod m) 繰り返し二乗法
public long pow(long x) {
long res = 1;
while (x > 0) {
if ((x & 1) == 1) res = res * val % mod;
val = val * val % mod;
x >>= 1;
}
return res;
}
public long pow(long x, long m) {
long res = 1;
while (x > 0) {
if ((x & 1) == 1) res = res * val % m;
val = val * val % m;
x >>= 1;
}
return res;
}
public long add(long x) {
val += x;
val %= mod;
return val;
}
public long sub(long x) {
val -= x;
val += mod;
val %= mod;
return val;
}
public long mul(long x) {
val *= x;
val %= mod;
return val;
}
public long div(long x) {
val *= pow(x, mod - 2);
val %= mod;
return val;
}
}
class MyMath {
// 最大公約数 (Greatest Common Divisor)
public static long gcd(long a, long b) {
if (a < b) {
long tmp = a; a = b; b = tmp;
}
while (b != 0) {
long tmp = a % b; a = b; b = tmp;
}
return a;
}
public static int gcd(int a, int b) {
if (a < b) {
int tmp = a; a = b; b = tmp;
}
while (b != 0) {
int tmp = a % b; a = b; b = tmp;
}
return a;
}
// 最小公倍数 (Least Common Multiple)
public static long lcm(long a, long b) {
return a * b / gcd(a, b);
}
public static int lcm(int a, int b) {
return a * b / gcd(a, b);
}
// 素数列挙 (Prime enumeration)
public static int[] primes(int max) {
return primes_base((int)Math.sqrt(max) + 1);
}
public static int[] primes_base(int max) {
boolean[] is_prime = new boolean[max];
for (int i = 0; i < max; i++) {
is_prime[i] = true;
}
for (int i = 2; i < max; i++) {
if (is_prime[i]) {
for (int j = i * 2; j < max; j += i) {
is_prime[j] = false;
}
}
}
int cnt = 0;
for (int i = 2; i < max; i++) {
if (is_prime[i]) cnt++;
}
int[] primes = new int[cnt];
int index = 0;
for (int i = 2; i < max && index < cnt; i++) {
if (is_prime[i]) primes[index++] = i;
}
return primes;
}
// TODO:
public static int[] primes_base_bit(int max) {
long[] is_prime = new long[max/64+1];
for (int i = 0; i < max; i++) {
is_prime[i/64] = is_prime[i/64] | (1 << (i%64)); // is_prime[i] = true
}
for (int i = 2; i < max; i++) {
if ((is_prime[i/64] & (1 << (i%64))) != 0) { // is_prime[i]
for (int j = i * 2; j < max; j += i) {
is_prime[j/64] = is_prime[j/64] & (~(1 << (j%64))); // is_prime[j] = false
}
}
}
int cnt = 0;
for (int i = 2; i < max; i++) {
if ((is_prime[i/64] & (1 << (i%64))) != 0) cnt++; // is_prime[i]
}
int[] primes = new int[cnt];
int index = 0;
for (int i = 2; i < max && index < cnt; i++) {
if ((is_prime[i/64] & (1 << (i%64))) != 0) primes[index++] = i; // is_prime[i]
}
return primes;
}
}
class In {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public In(InputStream in) {
this.in = in;
}
public In() {
this.in = System.in;
}
private final boolean hasNextByte() {
if (ptr < buflen) return true;
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) return false;
return true;
}
private final int readByte() {
return hasNextByte() ? buffer[ptr++] : -1;
}
private static final boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public final boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
public final String s() {
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public final void nextThrow(int n) {
for (int i = 0; i < n; i++) this.s();
}
public final void nextThrow() {
this.nextThrow(1);
}
public final long l() {
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
assert '0' <= b && b <= '9' : "NumberFormatException";
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
//assert b == ' ' || b == '\n' : "NumberFormatException";
return minus ? -n : n;
}
b = readByte();
}
}
public long[] la(int n, int headspace, int tailspace) {
long[] result = new long[n + headspace + tailspace];
for (int i = headspace; i < n + headspace; i++) result[i] = l();
return result;
}
public long[] la(int n, int headspace) {
return la(n, headspace, 0);
}
public long[] la(int n) {
return la(n, 0, 0);
}
// TODO:
public long[][] laa(int n, int m) {
long[][] result = new long[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) result[i][j] = l();
}
return result;
}
public final int i() {
long nl = l();
assert (Integer.MIN_VALUE <= nl || nl <= Integer.MAX_VALUE) : "NumberFormatException";
return (int)nl;
}
public int[] ia(int n, int headspace, int tailspace) {
int[] result = new int[n + headspace + tailspace];
for (int i = headspace; i < n + headspace; i++) result[i] = i();
return result;
}
public int[] ia(int n, int headspace) {
return ia(n, headspace, 0);
}
public int[] ia(int n) {
return ia(n, 0, 0);
}
// TODO:
public int[][] iaa(int n, int m) {
int[][] result = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) result[i][j] = i();
}
return result;
}
public int[][] ias(int ncol, int n) {
int[][] result = new int[ncol][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < ncol; j++) result[j][i] = i();
}
return result;
}
public double d() {
return Double.parseDouble(s());
}
public boolean[] b(char True) {
String s = this.s();
int n = s.length();
boolean[] array = new boolean[n];
for (int i = 0; i < n; i++)
array[i] = s.charAt(i) == True;
return array;
}
}
class Out {
PrintWriter out;
Out() {
this.out = new PrintWriter(System.out);
}
public final void as() {
out.print(' ');
}
public final void an() {
out.print('\n');
}
public final <T> void a(T n) {
out.print(n);
}
public final <T> void as(T n) {
out.print(n);
out.print(' ');
}
public final <T> void an(T n) {
out.println(n);
}
public final void yesno(boolean b) {
out.println(b ? "Yes" : "No");
}
public final void aas(int[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.print(n[i]);
out.print(' ');
}
out.println(n[nm]);
}
public final void aan(int[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.println(n[i]);
}
out.println(n[nm]);
}
public final void aas(int[][] n) {
int nm = n.length;
for (int i = 0; i < nm; i++) {
aas(n[i]);
}
}
public final void aas(long[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.print(n[i]);
out.print(' ');
}
out.println(n[nm]);
}
public final void aan(long[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.println(n[i]);
}
out.println(n[nm]);
}
public final void aas(long[][] n) {
int nm = n.length;
for (int i = 0; i < nm; i++) {
aas(n[i]);
}
}
public final void flush() {
out.flush();
}
public final void flushln() {
out.print('\n');
out.flush();
}
}
// Edge
class E {
int u;
int v;
int w;
public E(int u, int v, int w) {
this.u = u;
this.v = v;
this.w = w;
}
public E(int u, int v) {
this(u, v, 0);
}
}
// Union-Find
class UF {
int[] parent;
int[] rank;
int[] size;
public UF(int n) {
parent = new int[n+1];
rank = new int[n+1];
size = new int[n+1];
for (int i = 1; i <= n; i++) {
parent[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
public int find(int x) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
if (parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
public void union(int x, int y) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
assert (0 < y && y < parent.length) : "IndexOutOfBoundsException";
x = find(x);
y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) {
parent[x] = y;
size[y] += size[x];
} else {
parent[y] = x;
size[x] += size[y];
if (rank[x] == rank[y]) rank[x]++;
}
}
public boolean same(int x, int y) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
assert (0 < y && y < parent.length) : "IndexOutOfBoundsException";
return find(x) == find(y);
}
public int size(int x) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
return size[find(x)];
}
}
class MyComparator {
private static Comparator<int[]> dictIntArray = null;
static Comparator<int[]> dictIntArray() {
if (dictIntArray == null) dictIntArray = (a, b) -> Arrays.compare(a, b);
return dictIntArray;
}
private static Comparator<int[][]> dictIntArrayArray = null;
static Comparator<int[][]> dictIntArrayArray() {
if (dictIntArrayArray == null) dictIntArrayArray = (a, b) -> {
for (int i = 0; i < a.length; i++) {
int c = Arrays.compare(a[i], b[i]);
if (c != 0) return c;
}
return 0;
};
return dictIntArrayArray;
}
}
// 有理数クラス
class Rational implements Comparable<Rational> {
long num;
long den;
public Rational(long num, long den) {
assert den != 0 : "denominator is zero";
if (den < 0) {
num *= -1;
den *= -1;
}
long g = Util.gcd(Math.abs(num), den);
this.num = num / g;
this.den = den / g;
}
public Rational(long num) {
this(num, 1);
}
public static Rational of(long num, long den) {
return new Rational(num, den);
}
public static Rational of(long num) {
return new Rational(num);
}
public int compareTo(Rational r) {
return Long.compare(num * r.den, den * r.num);
}
// toString
public String toString() {
return num + "/" + den;
}
// double
public double doubleValue() {
return (double) num / den;
}
// float
public float floatValue() {
return (float) num / den;
}
// long
public long longValue() {
return num / den;
}
// int
public int intValue() {
return (int) (num / den);
}
// 約分
public Rational reduce() {
long g = Util.gcd(Math.abs(num), den);
return new Rational(num / g, den / g);
}
// 四則演算
public Rational add(Rational r) {
return new Rational(num * r.den + den * r.num, den * r.den);
}
public Rational sub(Rational r) {
return new Rational(num * r.den - den * r.num, den * r.den);
}
public Rational mul(Rational r) {
return new Rational(num * r.num, den * r.den);
}
public Rational div(Rational r) {
return new Rational(num * r.den, den * r.num);
}
// 逆数
public Rational inv() {
return new Rational(den, num);
}
// 符号反転
public Rational neg() {
return new Rational(-num, den);
}
// 絶対値
public Rational abs() {
return new Rational(Math.abs(num), den);
}
// 累乗
public Rational pow(long n) {
return new Rational((long)Math.pow(num, n), (long)Math.pow(den, n));
}
public Rational pow(Rational r) {
return new Rational((long)Math.pow(num, r.num), (long)Math.pow(den, r.num));
}
// 平方根
public Rational sqrt() {
return new Rational((long)Math.sqrt(num), (long)Math.sqrt(den));
}
// 立方根
public Rational cbrt() {
return new Rational((long)Math.cbrt(num), (long)Math.cbrt(den));
}
// 指数関数
public Rational exp() {
return new Rational((long)Math.exp(num), (long)Math.exp(den));
}
// 対数関数
public Rational log() {
return new Rational((long)Math.log(num), (long)Math.log(den));
}
// 三角関数
public Rational sin() {
return new Rational((long)Math.sin(num), (long)Math.sin(den));
}
public Rational cos() {
return new Rational((long)Math.cos(num), (long)Math.cos(den));
}
public Rational tan() {
return new Rational((long)Math.tan(num), (long)Math.tan(den));
}
}
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import java.io.*;
class Solve extends Util {
void solve() {
int n = in.i();
String t = in.s();
char[] ts = t.toCharArray();
String[] ss = new String[n];
char[][] sss = new char[n][];
for (int i = 0; i < n; i++) {
ss[i] = in.s();
sss[i] = ss[i].toCharArray();
}
// 前a文字、後b文字の部分列を持って、合わせてtの長さ以上なら連結したものは合格
// それでも計算が間に合わない？
int[] head = new int[n];
int[] tail = new int[n];
HashMap<Integer, Integer> headmap = new HashMap<>(n);
HashMap<Integer, Integer> tailmap = new HashMap<>(n);
for (int i = 0; i < n; i++) {
{
int tsi = 0;
for (int j = 0; j < sss[i].length && tsi < ts.length; j++) {
if (sss[i][j] == ts[tsi]) {
tsi++;
}
}
head[i] = tsi;
headmap.put(tsi, headmap.getOrDefault(tsi, 0) + 1);
}
{
int tsi = 0;
for (int j = 0; j < sss[i].length && tsi < ts.length; j++) {
if (sss[i][sss[i].length - j - 1] == ts[ts.length - tsi - 1]) {
tsi++;
}
}
tail[i] = tsi;
tailmap.put(tsi, tailmap.getOrDefault(tsi, 0) + 1);
}
}
long ans = 0;
var headset = headmap.entrySet();
var tailset = tailmap.entrySet();
for (var hd : headset) {
for (var td : tailset) {
if ((long)hd.getKey() + (long)td.getKey() >= ts.length) ans += (long)hd.getValue() * (long)td.getValue();
}
}
out.an(ans);
}
}
// My Library
// Version: 2023.07.01
// =================================================================================================
// TODO:
// * end を半開区間にする
public class Main extends Util {
public static void main(String[] args) {
try {
new Solve().solve();
} catch (Exception e) {
throw e;
} finally {
out.flush();
}
}
}
@FunctionalInterface
interface F1<T, R> extends Function<T, R> {
default R x(T t) { return apply(t); }
}
@FunctionalInterface
interface F2<T, U, R> extends BiFunction<T, U, R> {
default F1<U, R> x(T p1) { return p2 -> apply(p1, p2); }
default F1<T, F1<U, R>> currying() { return p1 -> p2 -> apply(p1, p2); }
default F2<U, T, R> flip() { return (p1, p2) -> apply(p2, p1); }
}
@FunctionalInterface
interface F3<T, U, V, R> {
R apply(T t, U u, V v);
default F2<U, V, R> x(T p1) { return (p2, p3) -> apply(p1, p2, p3); }
default F1<V, R> x(T p1, U p2) { return p3 -> apply(p1, p2, p3); }
default F1<T, F1<U, F1<V, R>>> currying() { return p1 -> p2 -> p3 -> apply(p1, p2, p3); }
default F3<V, U, T, R> flip() { return (p1, p2, p3) -> apply(p3, p2, p1); }
}
@FunctionalInterface
interface F4<T, U, V, W, R> {
R apply(T t, U u, V v, W w);
default F3<U, V, W, R> x(T p1) { return (p2, p3, p4) -> apply(p1, p2, p3, p4); }
default F2<V, W, R> x(T p1, U p2) { return (p3, p4) -> apply(p1, p2, p3, p4); }
default F1<W, R> x(T p1, U p2, V p3) { return p4 -> apply(p1, p2, p3, p4); }
default F1<T, F1<U, F1<V, F1<W, R>>>> currying() { return p1 -> p2 -> p3 -> p4 -> apply(p1, p2, p3, p4); }
default F4<W, V, U, T, R> flip() { return (p1, p2, p3, p4) -> apply(p4, p3, p2, p1); }
}
@FunctionalInterface
interface F5<T, U, V, W, X, R> {
R apply(T t, U u, V v, W w, X x);
default F4<U, V, W, X, R> x(T p1) { return (p2, p3, p4, p5) -> apply(p1, p2, p3, p4, p5); }
default F3<V, W, X, R> x(T p1, U p2) { return (p3, p4, p5) -> apply(p1, p2, p3, p4, p5); }
default F2<W, X, R> x(T p1, U p2, V p3) { return (p4, p5) -> apply(p1, p2, p3, p4, p5); }
default F1<X, R> x(T p1, U p2, V p3, W p4) { return p5 -> apply(p1, p2, p3, p4, p5); }
default F1<T, F1<U, F1<V, F1<W, F1<X, R>>>>> currying() { return p1 -> p2 -> p3 -> p4 -> p5 -> apply(p1, p2, p3, p4, p5); }
default F5<X, W, V, U, T, R> flip() { return (p1, p2, p3, p4, p5) -> apply(p5, p4, p3, p2, p1); }
}
@FunctionalInterface
interface F6<T, U, V, W, X, Y, R> {
R apply(T t, U u, V v, W w, X x, Y y);
default F5<U, V, W, X, Y, R> x(T p1) { return (p2, p3, p4, p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F4<V, W, X, Y, R> x(T p1, U p2) { return (p3, p4, p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F3<W, X, Y, R> x(T p1, U p2, V p3) { return (p4, p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F2<X, Y, R> x(T p1, U p2, V p3, W p4) { return (p5, p6) -> apply(p1, p2, p3, p4, p5, p6); }
default F1<Y, R> x(T p1, U p2, V p3, W p4, X p5) { return p6 -> apply(p1, p2, p3, p4, p5, p6); }
default F1<T, F1<U, F1<V, F1<W, F1<X, F1<Y, R>>>>>> currying() { return p1 -> p2 -> p3 -> p4 -> p5 -> p6 -> apply(p1, p2, p3, p4, p5, p6); }
default F6<Y, X, W, V, U, T, R> flip() { return (p1, p2, p3, p4, p5, p6) -> apply(p6, p5, p4, p3, p2, p1); }
}
@FunctionalInterface
interface F7<T, U, V, W, X, Y, Z, R> {
R apply(T t, U u, V v, W w, X x, Y y, Z z);
default F6<U, V, W, X, Y, Z, R> x(T p1) { return (p2, p3, p4, p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F5<V, W, X, Y, Z, R> x(T p1, U p2) { return (p3, p4, p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F4<W, X, Y, Z, R> x(T p1, U p2, V p3) { return (p4, p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F3<X, Y, Z, R> x(T p1, U p2, V p3, W p4) { return (p5, p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F2<Y, Z, R> x(T p1, U p2, V p3, W p4, X p5) { return (p6, p7) -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F1<Z, R> x(T p1, U p2, V p3, W p4, X p5, Y p6) { return p7 -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F1<T, F1<U, F1<V, F1<W, F1<X, F1<Y, F1<Z, R>>>>>>> currying() { return p1 -> p2 -> p3 -> p4 -> p5 -> p6 -> p7 -> apply(p1, p2, p3, p4, p5, p6, p7); }
default F7<Z, Y, X, W, V, U, T, R> flip() { return (p1, p2, p3, p4, p5, p6, p7) -> apply(p7, p6, p5, p4, p3, p2, p1); }
}
class RLENode<T> {
T val;
int len;
RLENode(T val, int len) {
this.val = val;
this.len = len;
}
}
// FIXME:
class RLE<T> {
RLENode<T>[] values;
public RLE(T[] target) {
if (target.length == 0) {
@SuppressWarnings("unchecked")
RLENode<T>[] array = new RLENode[0];
values = array;
return;
}
List<RLENode<T>> list = new ArrayList<>();
T cur = target[0];
int cnt = 1;
for (int i = 1; i < target.length; i++) {
if (target[i].equals(cur)) { // NOTE: 参照比較をしないように注意
cnt++;
} else {
list.add(new RLENode<T>(cur, cnt));
cur = target[i];
cnt = 1;
}
}
list.add(new RLENode<T>(cur, cnt));
@SuppressWarnings("unchecked")
RLENode<T>[] array = list.toArray(RLENode[]::new);
values = array;
}
void print() {
for (int i = 0; i < values.length; i++) {
System.out.println(values[i].val + " " + values[i].len);
}
}
HashMap<T, Integer> toMap() {
HashMap<T, Integer> map = new HashMap<>();
for (int i = 0; i < values.length; i++) {
map.put(values[i].val, values[i].len);
}
return map;
}
}
class Graph {
List<Integer>[] edges;
int[] weights;
int n;
boolean sortedEdges;
boolean isDirected;
@SuppressWarnings("unchecked")
Graph(int n, boolean isDirected, boolean sortEdges) {
this.n = n;
this.edges = new ArrayList[n+1];
for (int i = 1; i <= n; i++) {
edges[i] = new ArrayList<Integer>();
}
this.weights = new int[n+1];
this.sortedEdges = !sortEdges;
this.isDirected = isDirected;
}
Graph(int n, boolean isDirected) {
this(n, isDirected, false);
}
public void addEdge(int u, int v) {
assert 1 <= u && u <= n;
assert 1 <= v && v <= n;
edges[u].add(v);
if (!isDirected) edges[v].add(u);
sortedEdges = false;
}
public void addEdge(int[] u, int[] v) {
assert u != null && v != null;
assert u.length == v.length;
for (int i = 0; i < u.length; i++) addEdge(u[i], v[i]);
}
private void sortEdges() {
for (int i = 1; i <= n; i++) Collections.sort(this.edges[i]);
sortedEdges = true;
}
public List<Integer> bfs(Graph g, int s) {
int[] ps = new int[this.n+1];
int[] ds = new int[this.n+1];
int[] cs = new int[this.n+1];
List<Integer> path = new ArrayList<Integer>();
Arrays.fill(ds, Integer.MAX_VALUE);
ds[s] = 0;
Deque<Integer> q = new ArrayDeque<Integer>();
q.add(s);
cs[s] = 1;
while (!q.isEmpty()) {
int u = q.remove();
path.add(u);
for (int v : g.edges[u]) {
if (cs[v] == 0) {
ps[v] = u;
ds[v] = ds[u] + 1;
cs[v] = 1;
q.add(v);
}
}
cs[u] = 2;
}
return path;
}
public int[] dfs(int s, int g) {
int[] ds = new int[n+1]; // depth
int[] fs = new int[n+1]; // first discovered
int[] cs = new int[n+1]; // color (0: white, 1: gray, 2: black)
int[] pi = new int[n+1]; // parent index
List<Integer> path = new ArrayList<Integer>();
int time = 0;
sortEdges();
dfs(ds, fs, cs, pi, path, time, s, g);
int[] res = Util.toIntArray(path);
Util.reverse(res);
return res;
}
public boolean dfs(int[] ds, int[] fs, int[] cs, int[] pi, List<Integer> path, int time, int u, int g) {
time++;
ds[u] = time;
cs[u] = 1;
if (u == g) {
path.add(u);
return true;
}
for (int v : this.edges[u]) {
if (pi[u] != v) {
pi[v] = u;
boolean res = dfs(ds, fs, cs, pi, path, time, v, g);
if (res) {
path.add(u);
return true;
}
}
}
cs[u] = 2;
time++;
fs[u] = time;
return false;
}
}
// convert list, array, map, set, queue, stack
class Test {
public static long pow(long a, long b, long mod) {
if (b == 0) return 1;
if (b == 1) return a;
if (b % 2 == 0) return pow(a * a % mod, b / 2, mod);
return a * pow(a * a % mod, b / 2, mod) % mod;
}
public static void sortSome(long[] key, long[]... value) {
long[][] array = new long[key.length][1+value.length];
for (int i = 0; i < key.length; i++) {
array[0][i] = key[i];
for (int j = 1; j < array[i].length; j++) {
array[j][i] = value[j-1][i];
}
}
Arrays.sort(array, Comparator.comparingLong(a -> a[0]));
}
public static long[] primeFact(long n, boolean allow_dup) {
List<Long> list = new ArrayList<>();
int upper = (int)Math.sqrt(n) + 1;
for (long i = 2; i <= upper; i++) {
if (n % i != 0) continue;
list.add(i);
n /= i;
while (n % i == 0) {
if (allow_dup) list.add(i);
n /= i;
}
}
if (n != 1) list.add(n);
return list.stream().mapToLong(i -> i).toArray();
}
static List<long[]> permutation(long[] seed) {
List<long[]> list = new ArrayList<>();
long[] perm = new long[seed.length];
boolean[] used = new boolean[seed.length];
buildPerm(list, seed, perm, used, 0);
return list;
}
static void buildPerm(List<long[]> list, long[] seed, long[] perm, boolean[] used, int index) {
if (index == seed.length) {
list.add(perm.clone());
return;
}
for (int i = 0; i < seed.length; i++) {
if (used[i]) continue;
perm[index] = seed[i];
used[i] = true;
buildPerm(list, seed, perm, used, index + 1);
used[i] = false;
}
}
static void combInternal(List<int[]> res, int input[], int empty[], int start, int end, int index, int r) {
if (index == r) {
res.add(Arrays.copyOf(empty, r));
return;
}
for (int y = start; y <= end && end - y + 1 >= r - index; y++) {
empty[index] = input[y];
combInternal(res, input, empty, y + 1, end, index + 1, r);
}
}
static List<int[]> combination(int input[], int n, int r) {
int empty[] = new int[r];
List<int[]> list = new ArrayList<>();
combInternal(list, input, empty, 0, n-1, 0, r);
return list;
}
}
class Util {
static In in = new In();
static Out out = new Out();
public static final int N10_9 = 1000000000;
public static final int N10_9_7 = 1000000007;
public static final char[] abc = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
public static final char[] ABC = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
public static void sort(Object[] a) {
Arrays.sort(a);
}
public static <T> void sort(T[] a, Comparator<? super T> c) {
Arrays.sort(a, c);
}
public static void sort(int[] a) {
Arrays.sort(a);
}
public static void sort(int[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static void sort(long[] a) {
Arrays.sort(a);
}
public static void sort(long[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static void sort(double[] a) {
Arrays.sort(a);
}
public static void sort(double[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static void sort(char[] a) {
Arrays.sort(a);
}
public static void sort(char[] a, int from, int to) {
Arrays.sort(a, from, to);
}
public static int gcd(int a, int b) {
return MyMath.gcd(a, b);
}
public static long gcd(long a, long b) {
return MyMath.gcd(a, b);
}
public static int lcm(int a, int b) {
return MyMath.lcm(a, b);
}
public static long lcm(long a, long b) {
return MyMath.lcm(a, b);
}
public static int sum(int[] a, int start, int end) {
int sum = 0;
for (int i = start; i < end; i++) sum += a[i];
return sum;
}
public static long sum(long[] a, int start, int end) {
long sum = 0;
for (int i = start; i < end; i++) sum += a[i];
return sum;
}
public static double sum(double[] a, int start, int end) {
double sum = 0;
for (int i = start; i < end; i++) sum += a[i];
return sum;
}
public static int sum(int[] a) {
return sum(a, 0, a.length);
}
public static long sum(long[] a) {
return sum(a, 0, a.length);
}
public static double sum(double[] a) {
return sum(a, 0, a.length);
}
public static int sum(int a, int ... b) {
return a + sum(b);
}
public static long sum(long a, long ... b) {
return a + sum(b);
}
public static double sum(double a, double ... b) {
return a + sum(b);
}
public static int lower_bound(List<Integer> list, int target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static int upper_bound(List<Integer> list, int target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) > 0 ? 1 : -1);
}
public static int lower_bound(List<Long> list, long target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static int upper_bound(List<Long> list, long target) {
return ~Collections.binarySearch(list, target, (x, y) -> x.compareTo(y) > 0 ? 1 : -1);
}
// ビット全探索
public static boolean[][] bitAll(int n) {
boolean[][] res = new boolean[1 << n][n];
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
res[i][j] = (i >> j & 1) == 1;
}
}
return res;
}
public static boolean[][] bitAll(int n, int bitCount) {
List<boolean[]> res = new ArrayList<>();
boolean[] b = new boolean[n];
for (int i = (1 << bitCount) - 1; i < 1 << n;) {
assert Integer.bitCount(i) == bitCount;
for (int j = 0; j < n; j++) b[j] = (i >> j & 1) == 1;
res.add(b.clone());
int t = i | i - 1;
i = t + 1 | (~t & -~t) - 1 >> Integer.numberOfTrailingZeros(i) + 1;
}
return toBooleanArrayArray(res);
}
public static int[][] bitAllFilter(boolean[][] use, int[] array) {
int[][] res = new int[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new int[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static long[][] bitAllFilter(boolean[][] use, long[] array) {
long[][] res = new long[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new long[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static double[][] bitAllFilter(boolean[][] use, double[] array) {
double[][] res = new double[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new double[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static Object[][] bitAllFilter(boolean[][] use, Object[] array) {
Object[][] res = new Object[use.length][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new Object[size];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static int[][][] bitAllFilter(boolean[][] use, int[][] array) {
int[][][] res = new int[use.length][][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new int[size][];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static long[][][] bitAllFilter(boolean[][] use, long[][] array) {
long[][][] res = new long[use.length][][];
for (int i = 0; i < use.length; i++) {
int size = 0;
for (int j = 0; j < use[i].length; j++) if (use[i][j]) size++;
res[i] = new long[size][];
int index = 0;
for (int j = 0; j < array.length; j++)
if (use[i][j]) res[i][index++] = array[j];
}
return res;
}
public static int[] arrayRange(int start, int end, int headspace, int tailspace) {
int n = end - start + 1;
int[] res = new int[n + headspace + tailspace];
int cur = start;
for (int i = headspace; i < n + headspace; i++) res[i] = cur++;
return res;
}
public static int[] arrayRange(int start, int end) {
return arrayRange(start, end, 0, 0);
}
public static long[] arrayRange(long start, long end, int headspace, int tailspace) {
long n = end - start + 1;
long[] res = new long[(int)n + headspace + tailspace];
long cur = start;
for (int i = headspace; i < n + headspace; i++) res[i] = cur++;
return res;
}
public static long[] arrayRange(long start, long end) {
return arrayRange(start, end, 0, 0);
}
public static long[] toLongArray(Collection<?> list) {
return list.stream().mapToLong(i -> (long)i).toArray();
}
public static int[] toIntArray(Collection<?> list) {
return list.stream().mapToInt(i -> (int)i).toArray();
}
public static double[] toDoubleArray(Collection<?> list) {
return list.stream().mapToDouble(i -> (double)i).toArray();
}
public static boolean[] toBooleanArray(Collection<?> list) {
Object[] a = list.toArray();
boolean[] b = new boolean[a.length];
for (int i = 0; i < b.length; i++) {
b[i] = (boolean)a[i];
}
return b;
}
public static String[] toStringArray(Collection<?> list) {
return list.stream().map(i -> i.toString()).toArray(String[]::new);
}
public static long[][] toLongArrayArray(Collection<?> list) {
return list.toArray(long[][]::new);
}
public static int[][] toIntArrayArray(Collection<?> list) {
return list.toArray(int[][]::new);
}
public static double[][] toDoubleArrayArray(Collection<?> list) {
return list.toArray(double[][]::new);
}
public static boolean[][] toBooleanArrayArray(Collection<?> list) {
return list.toArray(boolean[][]::new);
}
public static String[][] toStringArrayArray(Collection<?> list) {
return list.toArray(String[][]::new);
}
public static <T> void reverse(T[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(boolean[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(int[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(long[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(double[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(float[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(byte[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static void reverse(char[] array) {
int len = array.length;
for (int i = 0; i < len / 2; i++) swap(array, i, len - i - 1);
}
public static int[] distinct(int[] a) {
return Arrays.stream(a).distinct().toArray();
}
public static long[] distinct(long[] a) {
return Arrays.stream(a).distinct().toArray();
}
public static double[] distinct(double[] a) {
return Arrays.stream(a).distinct().toArray();
}
public static void fill(int[] a, int v) {
Arrays.fill(a, v);
}
public static void fill(long[] a, long v) {
Arrays.fill(a, v);
}
public static void fill(double[] a, double v) {
Arrays.fill(a, v);
}
public static void fill(boolean[] a, boolean v) {
Arrays.fill(a, v);
}
public static void fill(char[] a, char v) {
Arrays.fill(a, v);
}
public static void fill(int[][] a, int v) {
for (int[] i : a) fill(i, v);
}
public static void fill(long[][] a, long v) {
for (long[] i : a) fill(i, v);
}
public static void fill(double[][] a, double v) {
for (double[] i : a) fill(i, v);
}
public static void fill(boolean[][] a, boolean v) {
for (boolean[] i : a) fill(i, v);
}
public static void fill(char[][] a, char v) {
for (char[] i : a) fill(i, v);
}
public static void fill(int[][][] a, int v) {
for (int[][] i : a) fill(i, v);
}
public static void fill(long[][][] a, long v) {
for (long[][] i : a) fill(i, v);
}
public static void fill(double[][][] a, double v) {
for (double[][] i : a) fill(i, v);
}
public static void fill(boolean[][][] a, boolean v) {
for (boolean[][] i : a) fill(i, v);
}
public static void fill(char[][][] a, char v) {
for (char[][] i : a) fill(i, v);
}
public static void fill(int[][][][] a, int v) {
for (int[][][] i : a) fill(i, v);
}
public static void fill(long[][][][] a, long v) {
for (long[][][] i : a) fill(i, v);
}
public static void fill(double[][][][] a, double v) {
for (double[][][] i : a) fill(i, v);
}
public static void fill(boolean[][][][] a, boolean v) {
for (boolean[][][] i : a) fill(i, v);
}
public static void fill(char[][][][] a, char v) {
for (char[][][] i : a) fill(i, v);
}
// NOTE: These methods require Java 16 or higher.
public static List<Long> arrayToList(long[] array) {
return Arrays.stream(array).boxed().collect(Collectors.toList());
//return Arrays.stream(array).boxed().toList();
}
public static List<Integer> arrayToList(int[] array) {
return Arrays.stream(array).boxed().collect(Collectors.toList());
//return Arrays.stream(array).boxed().toList();
}
public static List<Double> arrayToList(double[] array) {
return Arrays.stream(array).boxed().collect(Collectors.toList());
//return Arrays.stream(array).boxed().toList();
}
public static List<Boolean> arrayToList(boolean[] array) {
Boolean[] a = new Boolean[array.length];
for (int i = 0; i < a.length; i++) a[i] = array[i];
return Arrays.stream(a).collect(Collectors.toList());
//return Arrays.stream(a).toList();
}
public static List<Character> arrayToList(char[] array) {
return Arrays.stream(arrayBoxed(array)).collect(Collectors.toList());
}
public static <T> List<T> arrayToList(T[] array) {
return Arrays.stream(array).collect(Collectors.toList());
//return Arrays.stream(array).toList();
}
public static Long[] arrayBoxed(long[] array) {
return Arrays.stream(array).boxed().toArray(Long[]::new);
}
public static Integer[] arrayBoxed(int[] array) {
return Arrays.stream(array).boxed().toArray(Integer[]::new);
}
public static Double[] arrayBoxed(double[] array) {
return Arrays.stream(array).boxed().toArray(Double[]::new);
}
public static Boolean[] arrayBoxed(boolean[] array) {
Boolean[] a = new Boolean[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
public static Character[] arrayBoxed(char[] array) {
Character[] a = new Character[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
public static long[] arrayUnboxed(Long[] array) {
return Arrays.stream(array).mapToLong(i -> i).toArray();
}
public static int[] arrayUnboxed(Integer[] array) {
return Arrays.stream(array).mapToInt(i -> i).toArray();
}
public static double[] arrayUnboxed(Double[] array) {
return Arrays.stream(array).mapToDouble(i -> i).toArray();
}
public static boolean[] arrayUnboxed(Boolean[] array) {
boolean[] a = new boolean[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
public static char[] arrayUnboxed(Character[] array) {
char[] a = new char[array.length];
for (int i = 0; i < array.length; i++) {
a[i] = array[i];
}
return a;
}
// 最大値 (int)
public static int max(int a, int b) {
return Math.max(a, b);
}
public static int max(int a, int ... nums) {
return max(a, max(nums));
}
public static int max(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = a[0];
for (int i = start; i <= end; i++) res = Math.max(res, a[i]);
return res;
}
public static int max(int[] a, int start) {
return max(a, start, a.length - 1);
}
public static int max(int[] a) {
return max(a, 0, a.length - 1);
}
public static int maxIndex(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] > a[res]) res = i;
}
return res;
}
public static int maxIndex(int[] a, int start) {
return maxIndex(a, start, a.length - 1);
}
public static int maxIndex(int[] a) {
return maxIndex(a, 0, a.length - 1);
}
// 最小値 (int)
public static int min(int a, int b) {
return Math.min(a, b);
}
public static int min(int a, int ... nums) {
return min(a, min(nums));
}
public static int min(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = a[0];
for (int i = start; i <= end; i++) res = Math.min(res, a[i]);
return res;
}
public static int min(int[] a, int start) {
return min(a, start, a.length - 1);
}
public static int min(int[] a) {
return min(a, 0, a.length - 1);
}
public static int minIndex(int[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] < a[res]) res = i;
}
return res;
}
public static int minIndex(int[] a, int start) {
return minIndex(a, start, a.length - 1);
}
public static int minIndex(int[] a) {
return minIndex(a, 0, a.length - 1);
}
// 最大値 (long)
public static long max(long a, long b) {
return Math.max(a, b);
}
public static long max(long a, long ... nums) {
return max(a, max(nums));
}
public static long max(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
long res = a[0];
for (int i = start; i <= end; i++) res = Math.max(res, a[i]);
return res;
}
public static long max(long[] a, int start) {
return max(a, start, a.length - 1);
}
public static long max(long[] a) {
return max(a, 0, a.length - 1);
}
public static int maxIndex(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] > a[res]) res = i;
}
return res;
}
public static int maxIndex(long[] a, int start) {
return maxIndex(a, start, a.length - 1);
}
public static int maxIndex(long[] a) {
return maxIndex(a, 0, a.length - 1);
}
// 最小値 (long)
public static long min(long a, long b) {
return Math.min(a, b);
}
public static long min(long a, long ... nums) {
return min(a, min(nums));
}
public static long min(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
long res = a[0];
for (int i = start; i <= end; i++) res = Math.min(res, a[i]);
return res;
}
public static long min(long[] a, int start) {
return min(a, start, a.length - 1);
}
public static long min(long[] a) {
return min(a, 0, a.length - 1);
}
public static int minIndex(long[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] < a[res]) res = i;
}
return res;
}
public static int minIndex(long[] a, int start) {
return minIndex(a, start, a.length - 1);
}
public static int minIndex(long[] a) {
return minIndex(a, 0, a.length - 1);
}
// 最大値 (double)
public static double max(double a, double b) {
return Math.max(a, b);
}
public static double max(double a, double ... nums) {
return max(a, max(nums));
}
public static double max(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
double res = a[0];
for (int i = start; i <= end; i++) res = Math.max(res, a[i]);
return res;
}
public static double max(double[] a, int start) {
return max(a, start, a.length - 1);
}
public static double max(double[] a) {
return max(a, 0, a.length - 1);
}
public static int maxIndex(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] > a[res]) res = i;
}
return res;
}
public static int maxIndex(double[] a, int start) {
return maxIndex(a, start, a.length - 1);
}
public static int maxIndex(double[] a) {
return maxIndex(a, 0, a.length - 1);
}
// 最小値 (double)
public static double min(double a, double b) {
return Math.min(a, b);
}
public static double min(double a, double ... nums) {
return min(a, min(nums));
}
public static double min(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
double res = a[0];
for (int i = start; i <= end; i++) res = Math.min(res, a[i]);
return res;
}
public static double min(double[] a, int start) {
return min(a, start, a.length - 1);
}
public static double min(double[] a) {
return min(a, 0, a.length - 1);
}
public static int minIndex(double[] a, int start, int end) {
assert start >= 0 && end < a.length && start <= end;
int res = start;
for (int i = start; i <= end; i++) {
if (a[i] < a[res]) res = i;
}
return res;
}
public static int minIndex(double[] a, int start) {
return minIndex(a, start, a.length - 1);
}
public static int minIndex(double[] a) {
return minIndex(a, 0, a.length - 1);
}
// 絶対値
public static int abs(int a) {
return Math.abs(a);
}
public static long abs(long a) {
return Math.abs(a);
}
public static double abs(double a) {
return Math.abs(a);
}
// チェビシェフ距離（チェス盤距離）
public static long chebyshevDistance(long x1, long y1, long x2, long y2) {
return max(abs(x1 - x2), abs(y1 - y2));
}
public static int chebyshevDistance(int x1, int y1, int x2, int y2) {
return max(abs(x1 - x2), abs(y1 - y2));
}
// マンハッタン距離
public static long manhattanDistance(long x1, long y1, long x2, long y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
public static int manhattanDistance(int x1, int y1, int x2, int y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
// ユークリッド距離
public static int euclideanDistance(int x1, int y1, int x2, int y2) {
return (int) Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
}
public static long euclideanDistance(long x1, long y1, long x2, long y2) {
return (long) Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
}
// 外積
public static long cross(long ox, long oy, long ax, long ay, long bx, long by) {
// 外積: |a||b|sinθ = axby - bxay
return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy);
}
public static long cross(long ax, long xy, long bx, long by) {
// 外積: |a||b|sinθ = axby - bxay
return cross(0, 0, ax, xy, bx, by);
}
// 内積
public static long dot(long ox, long oy, long ax, long ay, long bx, long by) {
// 内積: |a||b|cosθ = axbx + ayby
return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy);
}
public static long dot(long ax, long xy, long bx, long by) {
// 内積: |a||b|cosθ = axbx + ayby
return dot(0, 0, ax, xy, bx, by);
}
// swap
public static String swap(String s, int i, int j) {
char[] cs = s.toCharArray();
char tmp = cs[i]; cs[i] = cs[j]; cs[j] = tmp;
return String.valueOf(cs);
}
public static void swap(boolean[] a, int i, int j) {
boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(int[] a, int i, int j) {
int tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(long[] a, int i, int j) {
long tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(double[] a, int i, int j) {
double tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(float[] a, int i, int j) {
float tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(byte[] a, int i, int j) {
byte tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static void swap(char[] a, int i, int j) {
char tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static <T> void swap(T[] a, int i, int j) {
T tmp = a[i]; a[i] = a[j]; a[j] = tmp;
}
public static <T> void swap(List<T> a, int i, int j) {
T tmp = a.get(i); a.set(i, a.get(j)); a.set(j, tmp);
}
// 間にあるかどうか
public static boolean between(int a, int x, int b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(long a, long x, long b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(double a, double x, double b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(float a, float x, float b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(byte a, byte x, byte b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
public static boolean between(char a, char x, char b) {
if (a > b) return between(b, x, a);
return a <= x && x <= b;
}
// modpow (a^b mod m) 繰り返し二乗法
public static long modpow(long a, long b, long m) {
long res = 1;
while (b > 0) {
if ((b & 1) == 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
public static long modadd(long a, long b, long m) {
return (a + b) % m;
}
public static long modsub(long a, long b, long m) {
return (a - b + m) % m;
}
public static long modmul(long a, long b, long m) {
return (a * b) % m;
}
public static long moddiv(long a, long b, long m) {
return (a * modpow(b, m - 2, m)) % m;
}
}
class ModInt {
private long mod;
private long val;
public ModInt(long val, long mod) {
this.mod = mod;
this.val = val % mod;
}
public long toLong() {
return val;
}
public String toString() {
return String.valueOf(val);
}
// modpow (a^b mod m) 繰り返し二乗法
public long pow(long x) {
long res = 1;
while (x > 0) {
if ((x & 1) == 1) res = res * val % mod;
val = val * val % mod;
x >>= 1;
}
return res;
}
public long pow(long x, long m) {
long res = 1;
while (x > 0) {
if ((x & 1) == 1) res = res * val % m;
val = val * val % m;
x >>= 1;
}
return res;
}
public long add(long x) {
val += x;
val %= mod;
return val;
}
public long sub(long x) {
val -= x;
val += mod;
val %= mod;
return val;
}
public long mul(long x) {
val *= x;
val %= mod;
return val;
}
public long div(long x) {
val *= pow(x, mod - 2);
val %= mod;
return val;
}
}
class MyMath {
// 最大公約数 (Greatest Common Divisor)
public static long gcd(long a, long b) {
if (a < b) {
long tmp = a; a = b; b = tmp;
}
while (b != 0) {
long tmp = a % b; a = b; b = tmp;
}
return a;
}
public static int gcd(int a, int b) {
if (a < b) {
int tmp = a; a = b; b = tmp;
}
while (b != 0) {
int tmp = a % b; a = b; b = tmp;
}
return a;
}
// 最小公倍数 (Least Common Multiple)
public static long lcm(long a, long b) {
return a * b / gcd(a, b);
}
public static int lcm(int a, int b) {
return a * b / gcd(a, b);
}
// 素数列挙 (Prime enumeration)
public static int[] primes(int max) {
return primes_base((int)Math.sqrt(max) + 1);
}
public static int[] primes_base(int max) {
boolean[] is_prime = new boolean[max];
for (int i = 0; i < max; i++) {
is_prime[i] = true;
}
for (int i = 2; i < max; i++) {
if (is_prime[i]) {
for (int j = i * 2; j < max; j += i) {
is_prime[j] = false;
}
}
}
int cnt = 0;
for (int i = 2; i < max; i++) {
if (is_prime[i]) cnt++;
}
int[] primes = new int[cnt];
int index = 0;
for (int i = 2; i < max && index < cnt; i++) {
if (is_prime[i]) primes[index++] = i;
}
return primes;
}
// TODO:
public static int[] primes_base_bit(int max) {
long[] is_prime = new long[max/64+1];
for (int i = 0; i < max; i++) {
is_prime[i/64] = is_prime[i/64] | (1 << (i%64)); // is_prime[i] = true
}
for (int i = 2; i < max; i++) {
if ((is_prime[i/64] & (1 << (i%64))) != 0) { // is_prime[i]
for (int j = i * 2; j < max; j += i) {
is_prime[j/64] = is_prime[j/64] & (~(1 << (j%64))); // is_prime[j] = false
}
}
}
int cnt = 0;
for (int i = 2; i < max; i++) {
if ((is_prime[i/64] & (1 << (i%64))) != 0) cnt++; // is_prime[i]
}
int[] primes = new int[cnt];
int index = 0;
for (int i = 2; i < max && index < cnt; i++) {
if ((is_prime[i/64] & (1 << (i%64))) != 0) primes[index++] = i; // is_prime[i]
}
return primes;
}
}
class In {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public In(InputStream in) {
this.in = in;
}
public In() {
this.in = System.in;
}
private final boolean hasNextByte() {
if (ptr < buflen) return true;
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) return false;
return true;
}
private final int readByte() {
return hasNextByte() ? buffer[ptr++] : -1;
}
private static final boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public final boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) {
ptr++;
}
return hasNextByte();
}
public final String s() {
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public final void nextThrow(int n) {
for (int i = 0; i < n; i++) this.s();
}
public final void nextThrow() {
this.nextThrow(1);
}
public final long l() {
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
assert '0' <= b && b <= '9' : "NumberFormatException";
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
//assert b == ' ' || b == '\n' : "NumberFormatException";
return minus ? -n : n;
}
b = readByte();
}
}
public long[] la(int n, int headspace, int tailspace) {
long[] result = new long[n + headspace + tailspace];
for (int i = headspace; i < n + headspace; i++) result[i] = l();
return result;
}
public long[] la(int n, int headspace) {
return la(n, headspace, 0);
}
public long[] la(int n) {
return la(n, 0, 0);
}
// TODO:
public long[][] laa(int n, int m) {
long[][] result = new long[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) result[i][j] = l();
}
return result;
}
public final int i() {
long nl = l();
assert (Integer.MIN_VALUE <= nl || nl <= Integer.MAX_VALUE) : "NumberFormatException";
return (int)nl;
}
public int[] ia(int n, int headspace, int tailspace) {
int[] result = new int[n + headspace + tailspace];
for (int i = headspace; i < n + headspace; i++) result[i] = i();
return result;
}
public int[] ia(int n, int headspace) {
return ia(n, headspace, 0);
}
public int[] ia(int n) {
return ia(n, 0, 0);
}
// TODO:
public int[][] iaa(int n, int m) {
int[][] result = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) result[i][j] = i();
}
return result;
}
public int[][] ias(int ncol, int n) {
int[][] result = new int[ncol][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < ncol; j++) result[j][i] = i();
}
return result;
}
public double d() {
return Double.parseDouble(s());
}
public boolean[] b(char True) {
String s = this.s();
int n = s.length();
boolean[] array = new boolean[n];
for (int i = 0; i < n; i++)
array[i] = s.charAt(i) == True;
return array;
}
}
class Out {
PrintWriter out;
Out() {
this.out = new PrintWriter(System.out);
}
public final void as() {
out.print(' ');
}
public final void an() {
out.print('\n');
}
public final <T> void a(T n) {
out.print(n);
}
public final <T> void as(T n) {
out.print(n);
out.print(' ');
}
public final <T> void an(T n) {
out.println(n);
}
public final void yesno(boolean b) {
out.println(b ? "Yes" : "No");
}
public final void aas(int[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.print(n[i]);
out.print(' ');
}
out.println(n[nm]);
}
public final void aan(int[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.println(n[i]);
}
out.println(n[nm]);
}
public final void aas(int[][] n) {
int nm = n.length;
for (int i = 0; i < nm; i++) {
aas(n[i]);
}
}
public final void aas(long[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.print(n[i]);
out.print(' ');
}
out.println(n[nm]);
}
public final void aan(long[] n) {
int nm = n.length-1;
for (int i = 0; i < nm; i++) {
out.println(n[i]);
}
out.println(n[nm]);
}
public final void aas(long[][] n) {
int nm = n.length;
for (int i = 0; i < nm; i++) {
aas(n[i]);
}
}
public final void flush() {
out.flush();
}
public final void flushln() {
out.print('\n');
out.flush();
}
}
// Edge
class E {
int u;
int v;
int w;
public E(int u, int v, int w) {
this.u = u;
this.v = v;
this.w = w;
}
public E(int u, int v) {
this(u, v, 0);
}
}
// Union-Find
class UF {
int[] parent;
int[] rank;
int[] size;
public UF(int n) {
parent = new int[n+1];
rank = new int[n+1];
size = new int[n+1];
for (int i = 1; i <= n; i++) {
parent[i] = i;
rank[i] = 0;
size[i] = 1;
}
}
public int find(int x) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
if (parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
public void union(int x, int y) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
assert (0 < y && y < parent.length) : "IndexOutOfBoundsException";
x = find(x);
y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) {
parent[x] = y;
size[y] += size[x];
} else {
parent[y] = x;
size[x] += size[y];
if (rank[x] == rank[y]) rank[x]++;
}
}
public boolean same(int x, int y) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
assert (0 < y && y < parent.length) : "IndexOutOfBoundsException";
return find(x) == find(y);
}
public int size(int x) {
assert (0 < x && x < parent.length) : "IndexOutOfBoundsException";
return size[find(x)];
}
}
class MyComparator {
private static Comparator<int[]> dictIntArray = null;
static Comparator<int[]> dictIntArray() {
if (dictIntArray == null) dictIntArray = (a, b) -> Arrays.compare(a, b);
return dictIntArray;
}
private static Comparator<int[][]> dictIntArrayArray = null;
static Comparator<int[][]> dictIntArrayArray() {
if (dictIntArrayArray == null) dictIntArrayArray = (a, b) -> {
for (int i = 0; i < a.length; i++) {
int c = Arrays.compare(a[i], b[i]);
if (c != 0) return c;
}
return 0;
};
return dictIntArrayArray;
}
}
// 有理数クラス
class Rational implements Comparable<Rational> {
long num;
long den;
public Rational(long num, long den) {
assert den != 0 : "denominator is zero";
if (den < 0) {
num *= -1;
den *= -1;
}
long g = Util.gcd(Math.abs(num), den);
this.num = num / g;
this.den = den / g;
}
public Rational(long num) {
this(num, 1);
}
public static Rational of(long num, long den) {
return new Rational(num, den);
}
public static Rational of(long num) {
return new Rational(num);
}
public int compareTo(Rational r) {
return Long.compare(num * r.den, den * r.num);
}
// toString
public String toString() {
return num + "/" + den;
}
// double
public double doubleValue() {
return (double) num / den;
}
// float
public float floatValue() {
return (float) num / den;
}
// long
public long longValue() {
return num / den;
}
// int
public int intValue() {
return (int) (num / den);
}
// 約分
public Rational reduce() {
long g = Util.gcd(Math.abs(num), den);
return new Rational(num / g, den / g);
}
// 四則演算
public Rational add(Rational r) {
return new Rational(num * r.den + den * r.num, den * r.den);
}
public Rational sub(Rational r) {
return new Rational(num * r.den - den * r.num, den * r.den);
}
public Rational mul(Rational r) {
return new Rational(num * r.num, den * r.den);
}
public Rational div(Rational r) {
return new Rational(num * r.den, den * r.num);
}
// 逆数
public Rational inv() {
return new Rational(den, num);
}
// 符号反転
public Rational neg() {
return new Rational(-num, den);
}
// 絶対値
public Rational abs() {
return new Rational(Math.abs(num), den);
}
// 累乗
public Rational pow(long n) {
return new Rational((long)Math.pow(num, n), (long)Math.pow(den, n));
}
public Rational pow(Rational r) {
return new Rational((long)Math.pow(num, r.num), (long)Math.pow(den, r.num));
}
// 平方根
public Rational sqrt() {
return new Rational((long)Math.sqrt(num), (long)Math.sqrt(den));
}
// 立方根
public Rational cbrt() {
return new Rational((long)Math.cbrt(num), (long)Math.cbrt(den));
}
// 指数関数
public Rational exp() {
return new Rational((long)Math.exp(num), (long)Math.exp(den));
}
// 対数関数
public Rational log() {
return new Rational((long)Math.log(num), (long)Math.log(den));
}
// 三角関数
public Rational sin() {
return new Rational((long)Math.sin(num), (long)Math.sin(den));
}
public Rational cos() {
return new Rational((long)Math.cos(num), (long)Math.cos(den));
}
public Rational tan() {
return new Rational((long)Math.tan(num), (long)Math.tan(den));
}
}
| ConDefects/ConDefects/Code/abc324_e/Java/46585821 |
condefects-java_data_1697 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
String t = sc.next();
List<String> s = new ArrayList<String>();
for(int i = 0; i < n; i++) s.add(sc.next());
int[] pre = new int[n];
for(int i = 0; i < n; i++) pre[i] = calc(s.get(i), t);
int[] suf = new int[n];
int[] cnt = new int[t.length() + 1];
StringBuilder sb = new StringBuilder();
String rt = sb.append(t).reverse().toString();
for(int i = 0; i < n; i++) {
sb.setLength(0);
String rs = sb.append(s.get(i)).reverse().toString();
suf[i] = calc(rs, rt);
cnt[suf[i]]++;
}
int ans = 0;
for(int i = 0; i < n; i++) {
int l = t.length() - pre[i];
for(int j = l; j <= t.length(); j++) ans += cnt[j];
}
System.out.println(ans);
}
}
static int calc(String s, String t) {
int g = 0;
for(int i = 0; i < s.length(); i++) {
if(g >= t.length()) break;
if(s.charAt(i) == t.charAt(g)) g++;
}
return g;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
String t = sc.next();
List<String> s = new ArrayList<String>();
for(int i = 0; i < n; i++) s.add(sc.next());
int[] pre = new int[n];
for(int i = 0; i < n; i++) pre[i] = calc(s.get(i), t);
int[] suf = new int[n];
int[] cnt = new int[t.length() + 1];
StringBuilder sb = new StringBuilder();
String rt = sb.append(t).reverse().toString();
for(int i = 0; i < n; i++) {
sb.setLength(0);
String rs = sb.append(s.get(i)).reverse().toString();
suf[i] = calc(rs, rt);
cnt[suf[i]]++;
}
long ans = 0;
for(int i = 0; i < n; i++) {
int l = t.length() - pre[i];
for(int j = l; j <= t.length(); j++) ans += cnt[j];
}
System.out.println(ans);
}
}
static int calc(String s, String t) {
int g = 0;
for(int i = 0; i < s.length(); i++) {
if(g >= t.length()) break;
if(s.charAt(i) == t.charAt(g)) g++;
}
return g;
}
} | ConDefects/ConDefects/Code/abc324_e/Java/49628900 |
condefects-java_data_1698 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
char[] t = sc.next().toCharArray();
char[][] s = new char[n][];
int[] l = new int[n];
int[] ll = new int[t.length+1];
for (int i = 0; i < n; i++) {
s[i] = sc.next().toCharArray();
int k = 0;
char tg = t[k];
for (int j = 0; j < s[i].length; j++) {
if(s[i][j] == tg) {
k++;
if(k==t.length)break;
tg = t[k];
}
}
l[i] = k;
ll[k]++;
}
int[] r = new int[n];
int[] rr = new int[t.length+1];
revChar(t);
for (int i = 0; i < n; i++) {
revChar(s[i]);
int k = 0;
char tg = t[k];
for (int j = 0; j < s[i].length; j++) {
if(s[i][j] == tg) {
k++;
if(k==t.length)break;
tg = t[k];
}
}
r[i] = k;
rr[k]++;
}
for (int i = rr.length-2; i >= 0 ; i--) {
rr[i] += rr[i+1];
}
long ans = 0;
for (int i = 0; i < ll.length; i++) {
ans += ll[i]*rr[t.length-i];
}
System.out.println(ans);
}
static void revChar(char[] array) {
int start = 0;
int end = array.length-1;
while(start < end) {
char tmp = array[start];
array[start] = array[end];
array[end] = tmp;
start++;
end--;
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
char[] t = sc.next().toCharArray();
char[][] s = new char[n][];
int[] l = new int[n];
int[] ll = new int[t.length+1];
for (int i = 0; i < n; i++) {
s[i] = sc.next().toCharArray();
int k = 0;
char tg = t[k];
for (int j = 0; j < s[i].length; j++) {
if(s[i][j] == tg) {
k++;
if(k==t.length)break;
tg = t[k];
}
}
l[i] = k;
ll[k]++;
}
int[] r = new int[n];
int[] rr = new int[t.length+1];
revChar(t);
for (int i = 0; i < n; i++) {
revChar(s[i]);
int k = 0;
char tg = t[k];
for (int j = 0; j < s[i].length; j++) {
if(s[i][j] == tg) {
k++;
if(k==t.length)break;
tg = t[k];
}
}
r[i] = k;
rr[k]++;
}
for (int i = rr.length-2; i >= 0 ; i--) {
rr[i] += rr[i+1];
}
long ans = 0;
for (int i = 0; i < ll.length; i++) {
ans += (long)ll[i]*rr[t.length-i];
}
System.out.println(ans);
}
static void revChar(char[] array) {
int start = 0;
int end = array.length-1;
while(start < end) {
char tmp = array[start];
array[start] = array[end];
array[end] = tmp;
start++;
end--;
}
}
}
| ConDefects/ConDefects/Code/abc324_e/Java/48654805 |
condefects-java_data_1699 |
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static Utils utils = new Utils();
public static void main(String[] args) throws IOException {
// int o = readInt();
// while (o-- > 0)
solve();
closeAndFlush();
}
static class Edge {
int to, pe, w;
public Edge(int to, int pe) {
this.to = to;
this.pe = pe;
}
public Edge(int to, int pe, int w) {
this.to = to;
this.pe = pe;
this.w = w;
}
}
static class Pair {
long first;
int second;
public Pair() {
}
public Pair(long first, int second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pair = (Pair) o;
return first == pair.first && second == pair.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public String toString() {
return first + " " + second;
}
}
static int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};//上右下左
static int n, m, idx = 1;
static int[] head;
static Edge[] edges;
public static void solve() throws IOException{
int n = readInt(), m = readInt();
PriorityQueue<Integer> people = new PriorityQueue<>();
PriorityQueue<Pair> back = new PriorityQueue<>(new Comparator<Pair>() {
@Override
public int compare(Pair o1, Pair o2) {
return o1.first < o2.first ? -1 : 1;
}
});
for (int i = 1; i <= n; i++) people.offer(i);
int[] total = new int[n + 1];
for (int i = 1; i <= m; i++) {
int t = readInt(), w = readInt(), s = readInt();
while (back.size() > 0 && back.peek().first <= t) {
people.offer(back.poll().second);
}
if (people.size() > 0) {
int p = people.poll();
total[p] += w;
back.offer(new Pair(t + s, p));
}
}
for (int i = 1; i <= n; i++) {
printWriter.println(total[i]);
}
}
public static void add(int a, int b) {
edges[idx] = new Edge(b, head[a]);
head[a] = idx++;
}
public static void add(int a, int b, int c) {
edges[idx] = new Edge(b, head[a], c);
head[a] = idx++;
}
public static int readInt() throws IOException {
return sc.nextInt();
}
public static long readLong() throws IOException {
return sc.nextLong();
}
public static String readString() throws IOException {
return sc.next();
// return sc.nextLine();
}
public static void closeAndFlush() throws IOException {
printWriter.flush();
printWriter.close();
sc.close();
}
public static void arrayToString(int[] arr) {
for (int i = 0; i < arr.length; i++) {
printWriter.print(arr[i] + " ");
}
printWriter.println();
}
public static void arrayToString(int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
printWriter.print(arr[i][j] + " ");
}
printWriter.println();
}
}
}
class Utils {
public static int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readInt();
}
return arr;
}
public static int[][] nextIntArray(int n, int m) throws IOException {
int[][] arr = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readInt();
}
}
return arr;
}
public static long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readLong();
}
return arr;
}
public static long[][] nextLongArray(int n, int m) throws IOException {
long[][] arr = new long[n + 1][];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readLong();
}
}
return arr;
}
public static String[] nextStringArray(int n) throws IOException {
String[] strings = new String[n + 1];
for (int i = 1; i <= n; i++) {
strings[i] = " " + Main.readString();
}
return strings;
}
public static char[][] nextCharArray(int n, int m) throws IOException {
char[][] chars = new char[n + 5][m + 5];
for (int i = 1; i <= n; i++) {
chars[i] = (" " + Main.readString()).toCharArray();
}
return chars;
}
public static int forceInt(long n) {
return (int) n;
}
public static int forceInt(double n) {
return (int) n;
}
public static long forceLong(int n) {
return n;
}
public static long forceLong(double n) {
return (long) n;
}
public static int max(int a, int b, int c) {
return Math.max(a, Math.max(b, c));
}
public static int min(int a, int b, int c) {
return Math.min(a, Math.min(b, c));
}
}
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static Utils utils = new Utils();
public static void main(String[] args) throws IOException {
// int o = readInt();
// while (o-- > 0)
solve();
closeAndFlush();
}
static class Edge {
int to, pe, w;
public Edge(int to, int pe) {
this.to = to;
this.pe = pe;
}
public Edge(int to, int pe, int w) {
this.to = to;
this.pe = pe;
this.w = w;
}
}
static class Pair {
long first;
int second;
public Pair() {
}
public Pair(long first, int second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pair = (Pair) o;
return first == pair.first && second == pair.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public String toString() {
return first + " " + second;
}
}
static int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};//上右下左
static int n, m, idx = 1;
static int[] head;
static Edge[] edges;
public static void solve() throws IOException{
int n = readInt(), m = readInt();
PriorityQueue<Integer> people = new PriorityQueue<>();
PriorityQueue<Pair> back = new PriorityQueue<>(new Comparator<Pair>() {
@Override
public int compare(Pair o1, Pair o2) {
return o1.first < o2.first ? -1 : 1;
}
});
for (int i = 1; i <= n; i++) people.offer(i);
long[] total = new long[n + 1];
for (int i = 1; i <= m; i++) {
int t = readInt(), w = readInt(), s = readInt();
while (back.size() > 0 && back.peek().first <= t) {
people.offer(back.poll().second);
}
if (people.size() > 0) {
int p = people.poll();
total[p] += w;
back.offer(new Pair(t + s, p));
}
}
for (int i = 1; i <= n; i++) {
printWriter.println(total[i]);
}
}
public static void add(int a, int b) {
edges[idx] = new Edge(b, head[a]);
head[a] = idx++;
}
public static void add(int a, int b, int c) {
edges[idx] = new Edge(b, head[a], c);
head[a] = idx++;
}
public static int readInt() throws IOException {
return sc.nextInt();
}
public static long readLong() throws IOException {
return sc.nextLong();
}
public static String readString() throws IOException {
return sc.next();
// return sc.nextLine();
}
public static void closeAndFlush() throws IOException {
printWriter.flush();
printWriter.close();
sc.close();
}
public static void arrayToString(int[] arr) {
for (int i = 0; i < arr.length; i++) {
printWriter.print(arr[i] + " ");
}
printWriter.println();
}
public static void arrayToString(int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
printWriter.print(arr[i][j] + " ");
}
printWriter.println();
}
}
}
class Utils {
public static int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readInt();
}
return arr;
}
public static int[][] nextIntArray(int n, int m) throws IOException {
int[][] arr = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readInt();
}
}
return arr;
}
public static long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readLong();
}
return arr;
}
public static long[][] nextLongArray(int n, int m) throws IOException {
long[][] arr = new long[n + 1][];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readLong();
}
}
return arr;
}
public static String[] nextStringArray(int n) throws IOException {
String[] strings = new String[n + 1];
for (int i = 1; i <= n; i++) {
strings[i] = " " + Main.readString();
}
return strings;
}
public static char[][] nextCharArray(int n, int m) throws IOException {
char[][] chars = new char[n + 5][m + 5];
for (int i = 1; i <= n; i++) {
chars[i] = (" " + Main.readString()).toCharArray();
}
return chars;
}
public static int forceInt(long n) {
return (int) n;
}
public static int forceInt(double n) {
return (int) n;
}
public static long forceLong(int n) {
return n;
}
public static long forceLong(double n) {
return (long) n;
}
public static int max(int a, int b, int c) {
return Math.max(a, Math.max(b, c));
}
public static int min(int a, int b, int c) {
return Math.min(a, Math.min(b, c));
}
}
| ConDefects/ConDefects/Code/abc320_e/Java/45650712 |
condefects-java_data_1700 |
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws java.lang.Exception {
PrintWriter out = new PrintWriter(System.out);
FastReader sc = new FastReader();
int testCases = 1;
// testCases = sc.nextInt();
while (testCases-- > 0) {
int n=sc.nextInt();
int m=sc.nextInt();
PriorityQueue<Integer>free=new PriorityQueue<>((a,b)->a-b);
PriorityQueue<int[]>pq=new PriorityQueue<>((a,b)->a[0]-b[0]);
int ans[]=new int[n];
int p=0;
for(int i=0;i<n;i++) free.add(i);
for(int i=0;i<m;i++) {
int t=sc.nextInt();
int w=sc.nextInt();
int s=sc.nextInt();
while(!pq.isEmpty()&&pq.peek()[0]<=t) {
free.add(pq.poll()[1]);
}
if(free.isEmpty()) continue;
int u=free.poll();
ans[u]+=w;
pq.add(new int[] {t+s,u});
}
for(int i=0;i<n;i++) out.println(ans[i]);
}
out.close();
}
public static long power(long a, long b) {
long res = 1;
long mod = (long) 1e18 + 7;
while (b > 0) {
if ((b & 1) > 0)
res = (res * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return res;
}
public static boolean isPallindrome(String a, String b) {
int n = a.length();
for (int i = 0; i < n; i++)
if (a.charAt(i) != b.charAt(i))
return false;
return true;
}
public static long gcd(long a, long b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
public static int[] EEA(int a, int b) {
if (a == 0)
return new int[] { b, 0, 1 };
int out[] = EEA(b % a, a);
return new int[] { out[0], out[2] - (b / a) * (out[1]), out[1] };
}
private static long lcm(long a, long b) {
return (a * b) / gcd(a, b);
}
static class FenWick {
int n;
long tree[];
int mod = 1000000007;
public FenWick(int n) {
this.n = n;
tree = new long[n];
}
public void add(int idx, long d) {
while (idx < n) {
tree[idx] += d;
tree[idx] += mod;
tree[idx] %= mod;
idx += (idx & (-idx));
}
}
public long find(int idx) {
long sum = 0;
while (idx > 0) {
sum += tree[idx];
sum %= mod;
idx -= (idx & (-idx));
}
return sum;
}
}
static class DSU {
int parent[];
int rank[];
int size[];
public DSU(int n) {
this.parent = new int[n];
this.rank = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
size[i] = 1;
for (int i = 0; i < n; i++)
parent[i] = i;
}
public int find(int x) {
if (parent[x] == x)
return x;
return parent[x] = find(parent[x]);
}
public boolean union(int x, int y) {
int px = find(x);
int py = find(y);
if (px == py) {
return false;
}
if (rank[px] > rank[py]) {
parent[py] = px;
size[px] += size[py];
} else if (rank[py] > rank[px]) {
parent[px] = py;
size[py] += size[px];
} else {
rank[px]++;
parent[py] = px;
size[px] += size[py];
}
return true;
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws java.lang.Exception {
PrintWriter out = new PrintWriter(System.out);
FastReader sc = new FastReader();
int testCases = 1;
// testCases = sc.nextInt();
while (testCases-- > 0) {
int n=sc.nextInt();
int m=sc.nextInt();
PriorityQueue<Integer>free=new PriorityQueue<>((a,b)->a-b);
PriorityQueue<int[]>pq=new PriorityQueue<>((a,b)->a[0]-b[0]);
long ans[]=new long[n];
int p=0;
for(int i=0;i<n;i++) free.add(i);
for(int i=0;i<m;i++) {
int t=sc.nextInt();
int w=sc.nextInt();
int s=sc.nextInt();
while(!pq.isEmpty()&&pq.peek()[0]<=t) {
free.add(pq.poll()[1]);
}
if(free.isEmpty()) continue;
int u=free.poll();
ans[u]+=w;
pq.add(new int[] {t+s,u});
}
for(int i=0;i<n;i++) out.println(ans[i]);
}
out.close();
}
public static long power(long a, long b) {
long res = 1;
long mod = (long) 1e18 + 7;
while (b > 0) {
if ((b & 1) > 0)
res = (res * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return res;
}
public static boolean isPallindrome(String a, String b) {
int n = a.length();
for (int i = 0; i < n; i++)
if (a.charAt(i) != b.charAt(i))
return false;
return true;
}
public static long gcd(long a, long b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
public static int[] EEA(int a, int b) {
if (a == 0)
return new int[] { b, 0, 1 };
int out[] = EEA(b % a, a);
return new int[] { out[0], out[2] - (b / a) * (out[1]), out[1] };
}
private static long lcm(long a, long b) {
return (a * b) / gcd(a, b);
}
static class FenWick {
int n;
long tree[];
int mod = 1000000007;
public FenWick(int n) {
this.n = n;
tree = new long[n];
}
public void add(int idx, long d) {
while (idx < n) {
tree[idx] += d;
tree[idx] += mod;
tree[idx] %= mod;
idx += (idx & (-idx));
}
}
public long find(int idx) {
long sum = 0;
while (idx > 0) {
sum += tree[idx];
sum %= mod;
idx -= (idx & (-idx));
}
return sum;
}
}
static class DSU {
int parent[];
int rank[];
int size[];
public DSU(int n) {
this.parent = new int[n];
this.rank = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
size[i] = 1;
for (int i = 0; i < n; i++)
parent[i] = i;
}
public int find(int x) {
if (parent[x] == x)
return x;
return parent[x] = find(parent[x]);
}
public boolean union(int x, int y) {
int px = find(x);
int py = find(y);
if (px == py) {
return false;
}
if (rank[px] > rank[py]) {
parent[py] = px;
size[px] += size[py];
} else if (rank[py] > rank[px]) {
parent[px] = py;
size[py] += size[px];
} else {
rank[px]++;
parent[py] = px;
size[px] += size[py];
}
return true;
}
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
} | ConDefects/ConDefects/Code/abc320_e/Java/45720587 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.