id stringlengths 22 25 | content stringlengths 327 628k | max_stars_repo_path stringlengths 49 49 |
|---|---|---|
condefects-java_data_1101 | import java.io.*;
import java.util.*;
public class Main {
public static int INF = 0x3f3f3f3f;
public static int mod = 1000000007;
public static int mod9 = 998244353;
public static long MAX = (long)1e12;
public static void main(String args[]){
try {
PrintWriter o = new PrintWriter(System.out);
FastScanner sc = new FastScanner();
boolean multiTest = false;
if(multiTest) {
int t = fReader.nextInt(), loop = 0;
while (loop < t) {
loop++;
solve(o, sc);
}
} else solve(o, sc);
o.close();
} catch (Exception e){
e.printStackTrace();
}
}
static void solve(PrintWriter o, FastScanner sc){
try {
int N = sc.nextInt();
int[] arr = new int[N];
for(int i=0;i<N;i++){
arr[i] = sc.nextInt();
}
int Q = sc.nextInt();
int d = Math.max(1, (int)(N / Math.sqrt(N)));
int cur = 0;
int nl = 0, nr = -1;
int[] res = new int[Q];
int[] count = new int[N];
int[][] qq = new int[Q][4];
for(int i=0;i<Q;i++){
int l = sc.nextInt()-1, r = sc.nextInt()-1;
qq[i] = new int[]{l, r, i, r/d};
}
Arrays.sort(qq, (a,b) -> a[3] == b[3] ? ((a[3] & 1) == 1 ? a[0] - b[0] : b[0] - a[0]) : a[3] - b[3]);
for(int[] q: qq){
while(nl < q[0]){
cur = addAndRemove(nl++, cur, arr, count, -1);
}
while(nl > q[0]){
cur = addAndRemove(--nl, cur, arr, count, +1);
}
while(nr < q[1]){
cur = addAndRemove(++nr, cur, arr, count, +1);
}
while(nr > q[1]){
cur = addAndRemove(nr--, cur, arr, count, -1);
}
res[q[2]] = cur;
}
for(int i=0;i<Q;i++){
o.println(res[i]);
}
} catch (Exception e){
e.printStackTrace();
}
}
static int addAndRemove(int x, int cur, int[] arr, int[] count, int val){
cur -= count[arr[x]] / 2;
count[arr[x]] += val;
cur += count[arr[x]] / 2;
return cur;
}
public static int get_first_bit(long x){
for(int i=63;i>=0;i--){
if((x & 1l << i) > 0){
return i;
}
}
return -1;
}
public static int countOne(long x){
int count = 0;
for(int i=0;i<64;i++){
if((x & 1l << i) > 0){
count++;
}
}
return count;
}
public static int gcd(int a, int b){
return b == 0 ? a : gcd(b, a%b);
}
public static void reverse(int[] array){
reverse(array, 0 , array.length-1);
}
public static void reverse(int[] array, int left, int right) {
if (array != null) {
int i = left;
for(int j = right; j > i; ++i) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
--j;
}
}
}
public static boolean doubleEqual(double d1, double d2){
if(Math.abs(d1-d2) < 1e-6){
return true;
}
return false;
}
public static long fac(int n){
long ret = 1;
while(n > 0){
ret = ret * n % mod;
n--;
}
return ret;
}
public static long qpow(int n, int m){
long n_ = n, ret = 1;
while(m > 0){
if((m&1) == 1){
ret = ret * n_ % mod;
}
m >>= 1;
n_ = n_ * n_ % mod;
}
return ret;
}
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());}
}
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 String nextLine() throws IOException{
return reader.readLine();
}
}
}
import java.io.*;
import java.util.*;
public class Main {
public static int INF = 0x3f3f3f3f;
public static int mod = 1000000007;
public static int mod9 = 998244353;
public static long MAX = (long)1e12;
public static void main(String args[]){
try {
PrintWriter o = new PrintWriter(System.out);
FastScanner sc = new FastScanner();
boolean multiTest = false;
if(multiTest) {
int t = fReader.nextInt(), loop = 0;
while (loop < t) {
loop++;
solve(o, sc);
}
} else solve(o, sc);
o.close();
} catch (Exception e){
e.printStackTrace();
}
}
static void solve(PrintWriter o, FastScanner sc){
try {
int N = sc.nextInt();
int[] arr = new int[N];
for(int i=0;i<N;i++){
arr[i] = sc.nextInt()-1;
}
int Q = sc.nextInt();
int d = Math.max(1, (int)(N / Math.sqrt(N)));
int cur = 0;
int nl = 0, nr = -1;
int[] res = new int[Q];
int[] count = new int[N];
int[][] qq = new int[Q][4];
for(int i=0;i<Q;i++){
int l = sc.nextInt()-1, r = sc.nextInt()-1;
qq[i] = new int[]{l, r, i, r/d};
}
Arrays.sort(qq, (a,b) -> a[3] == b[3] ? ((a[3] & 1) == 1 ? a[0] - b[0] : b[0] - a[0]) : a[3] - b[3]);
for(int[] q: qq){
while(nl < q[0]){
cur = addAndRemove(nl++, cur, arr, count, -1);
}
while(nl > q[0]){
cur = addAndRemove(--nl, cur, arr, count, +1);
}
while(nr < q[1]){
cur = addAndRemove(++nr, cur, arr, count, +1);
}
while(nr > q[1]){
cur = addAndRemove(nr--, cur, arr, count, -1);
}
res[q[2]] = cur;
}
for(int i=0;i<Q;i++){
o.println(res[i]);
}
} catch (Exception e){
e.printStackTrace();
}
}
static int addAndRemove(int x, int cur, int[] arr, int[] count, int val){
cur -= count[arr[x]] / 2;
count[arr[x]] += val;
cur += count[arr[x]] / 2;
return cur;
}
public static int get_first_bit(long x){
for(int i=63;i>=0;i--){
if((x & 1l << i) > 0){
return i;
}
}
return -1;
}
public static int countOne(long x){
int count = 0;
for(int i=0;i<64;i++){
if((x & 1l << i) > 0){
count++;
}
}
return count;
}
public static int gcd(int a, int b){
return b == 0 ? a : gcd(b, a%b);
}
public static void reverse(int[] array){
reverse(array, 0 , array.length-1);
}
public static void reverse(int[] array, int left, int right) {
if (array != null) {
int i = left;
for(int j = right; j > i; ++i) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
--j;
}
}
}
public static boolean doubleEqual(double d1, double d2){
if(Math.abs(d1-d2) < 1e-6){
return true;
}
return false;
}
public static long fac(int n){
long ret = 1;
while(n > 0){
ret = ret * n % mod;
n--;
}
return ret;
}
public static long qpow(int n, int m){
long n_ = n, ret = 1;
while(m > 0){
if((m&1) == 1){
ret = ret * n_ % mod;
}
m >>= 1;
n_ = n_ * n_ % mod;
}
return ret;
}
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());}
}
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 String nextLine() throws IOException{
return reader.readLine();
}
}
} | ConDefects/ConDefects/Code/abc242_g/Java/30159397 |
condefects-java_data_1102 | import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Map.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.System.*;
public class Main
{
public void tq() throws Exception
{
st=new StringTokenizer(bq.readLine());
//sb=new StringBuilder(2000000);
int n=i();
int ar[]=ari(n);
int b[]=new int[n+1];
int bb=sq(n);
int q=i();
int qq[][]=ari(q,2);
int r[][]=new int[q][3];
for(int x=0;x<q;x++)
{
r[x][0]=qq[x][0]-1;
r[x][1]=qq[x][1]-1;
r[x][2]=x;
}
pl(-1);
System.exit(0);
sort(r,(x,y)->
{
if (x[0]/bb != y[0]/bb) return Integer.compare(x[0],y[0]);
return Integer.compare(x[1] , y[1]);
});
int cur_l = 0;
int cur_r = -1;
int cc=0;
int p[]=new int[q];
for (int e[] : r) {
int l=e[0];
int rr=e[1];
while (cur_l > l) {
cur_l--;
b[ar[cur_l]]++;
if(b[ar[cur_l]]%2==0)cc++;
}
while (cur_r < rr) {
cur_r++;
b[ar[cur_r]]++;
if(b[ar[cur_r]]%2==0)cc++;
}
while (cur_l < l) {
b[ar[cur_l]]--;
if(b[ar[cur_l]]%2!=0)cc--;
cur_l++;
}
while (cur_r > rr) {
b[ar[cur_r]]--;
if(b[ar[cur_r]]%2!=0)cc--;
cur_r--;
}
p[e[2]]=cc;
}
sb=new StringBuilder(2000000);
for(int e:p)sl(e);
p(sb);
}
long mod=998244353l;
int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
BufferedReader bq = new BufferedReader(new InputStreamReader(in));StringTokenizer st;StringBuilder sb;
public static void main(String[] a)throws Exception{new Main().tq();}
int di[][]={{-1,0},{1,0},{0,-1},{0,1}};
int de[][]={{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{1,1},{-1,1},{1,-1}};
void f(){out.flush();}
int p(int i,int p[]){return p[i]<0?i:(p[i]=p(p[i],p));}
boolean c(int x,int y,int n,int m){return x>=0&&x<n&&y>=0&&y<m;}
int[] so(int ar[])
{
Integer r[] = new Integer[ar.length];
for (int x = 0; x < ar.length; x++) r[x] = ar[x];
sort(r);
for (int x = 0; x < ar.length; x++) ar[x] = r[x];
return ar;
}
long[] so(long ar[])
{
Long r[] = new Long[ar.length];
for (int x = 0; x < ar.length; x++) r[x] = ar[x];
sort(r);
for (int x = 0; x < ar.length; x++) ar[x] = r[x];
return ar;
}
char[] so(char ar[])
{
Character r[] = new Character[ar.length];
for (int x = 0; x < ar.length; x++) r[x] = ar[x];
sort(r);
for (int x = 0; x < ar.length; x++) ar[x] = r[x];
return ar;
}
void p(Object p) {out.print(p);}void pl(Object p) {out.println(p);}void pl() {out.println();}
void s(String s) {sb.append(s);}
void s(int s) {sb.append(s);}
void s(long s) {sb.append(s);}
void s(char s) {sb.append(s);}
void s(double s) {sb.append(s);}
void ss() {sb.append(' ');}
void sl(String s) {s(s);sb.append("\n");}
void sl(int s) {s(s);sb.append("\n");}
void sl(long s) {s(s);sb.append("\n");}
void sl(char s) {s(s);sb.append("\n");}
void sl(double s) {s(s);sb.append("\n");}
void sl() {sb.append("\n");}
int l(int v) {return 31 - Integer.numberOfLeadingZeros(v);}
long l(long v) {return 63 - Long.numberOfLeadingZeros(v);}
int sq(int a) {return (int) sqrt(a);}
long sq(long a) {return (long) sqrt(a);}
int gcd(int a, int b)
{
while (b > 0)
{
int c = a % b;
a = b;
b = c;
}
return a;
}
long gcd(long a, long b)
{
while (b > 0l)
{
long c = a % b;
a = b;
b = c;
}
return a;
}
boolean p(String s, int i, int j)
{
while (i < j) if (s.charAt(i++) != s.charAt(j--)) return false;
return true;
}
boolean[] si(int n)
{
boolean bo[] = new boolean[n + 1];
bo[0] = bo[1] = true;
for (int x = 4; x <= n; x += 2) bo[x] = true;
for (int x = 3; x * x <= n; x += 2)
{
if (!bo[x])
{
int vv = (x << 1);
for (int y = x * x; y <= n; y += vv) bo[y] = true;
}
}
return bo;
}
long mul(long a, long b, long m)
{
long r = 1l;
a %= m;
while (b > 0)
{
if ((b & 1) == 1) r = (r * a) % m;
b >>= 1;
a = (a * a) % m;
}
return r;
}
int i() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return Integer.parseInt(st.nextToken());
}
long l() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return Long.parseLong(st.nextToken());
}
String s() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return st.nextToken();
}
double d() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return Double.parseDouble(st.nextToken());
}
void s(int a[])
{
for (int e : a){sb.append(e);sb.append(' ');}
sb.append("\n");
}
void s(long a[])
{
for (long e : a){sb.append(e);sb.append(' ');}
sb.append("\n");
}
void s(char a[])
{
for (char e : a){sb.append(e);sb.append(' ');}
sb.append("\n");
}
void s(int ar[][]) {for (int a[] : ar) s(a);}
void s(long ar[][]) {for (long a[] : ar) s(a);}
void s(char ar[][]) {for (char a[] : ar) s(a);}
int[] ari(int n) throws IOException
{
int ar[] = new int[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = Integer.parseInt(st.nextToken());
return ar;
}
long[] arl(int n) throws IOException
{
long ar[] = new long[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = Long.parseLong(st.nextToken());
return ar;
}
char[] arc(int n) throws IOException
{
char ar[] = new char[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = st.nextToken().charAt(0);
return ar;
}
double[] ard(int n) throws IOException
{
double ar[] = new double[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = Double.parseDouble(st.nextToken());
return ar;
}
String[] ars(int n) throws IOException
{
String ar[] = new String[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = st.nextToken();
return ar;
}
int[][] ari(int n, int m) throws IOException
{
int ar[][] = new int[n][m];
for (int x = 0; x < n; x++)ar[x]=ari(m);
return ar;
}
long[][] arl(int n, int m) throws IOException
{
long ar[][] = new long[n][m];
for (int x = 0; x < n; x++)ar[x]=arl(m);
return ar;
}
char[][] arc(int n, int m) throws IOException
{
char ar[][] = new char[n][m];
for (int x = 0; x < n; x++)ar[x]=arc(m);
return ar;
}
double[][] ard(int n, int m) throws IOException
{
double ar[][] = new double[n][m];
for (int x = 0; x < n; x++)ar[x]=ard(m);
return ar;
}
void p(int ar[])
{
sb = new StringBuilder(11 * ar.length);
for (int a : ar) {sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(long ar[])
{
StringBuilder sb = new StringBuilder(20 * ar.length);
for (long a : ar){sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(double ar[])
{
StringBuilder sb = new StringBuilder(22 * ar.length);
for (double a : ar){sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(char ar[])
{
StringBuilder sb = new StringBuilder(2 * ar.length);
for (char aa : ar){sb.append(aa);sb.append(' ');}
out.println(sb);
}
void p(String ar[])
{
int c = 0;
for (String s : ar) c += s.length() + 1;
StringBuilder sb = new StringBuilder(c);
for (String a : ar){sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(int ar[][])
{
StringBuilder sb = new StringBuilder(11 * ar.length * ar[0].length);
for (int a[] : ar)
{
for (int aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void p(long ar[][])
{
StringBuilder sb = new StringBuilder(20 * ar.length * ar[0].length);
for (long a[] : ar)
{
for (long aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void p(double ar[][])
{
StringBuilder sb = new StringBuilder(22 * ar.length * ar[0].length);
for (double a[] : ar)
{
for (double aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void p(char ar[][])
{
StringBuilder sb = new StringBuilder(2 * ar.length * ar[0].length);
for (char a[] : ar)
{
for (char aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void pl(Object... ar) {for (Object e : ar) p(e + " ");pl();}
}
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Map.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.lang.System.*;
public class Main
{
public void tq() throws Exception
{
st=new StringTokenizer(bq.readLine());
//sb=new StringBuilder(2000000);
int n=i();
int ar[]=ari(n);
int b[]=new int[n+1];
int bb=sq(n);
int q=i();
int qq[][]=ari(q,2);
int r[][]=new int[q][3];
for(int x=0;x<q;x++)
{
r[x][0]=qq[x][0]-1;
r[x][1]=qq[x][1]-1;
r[x][2]=x;
}
sort(r,(x,y)->
{
if (x[0]/bb != y[0]/bb) return Integer.compare(x[0],y[0]);
return Integer.compare(x[1] , y[1]);
});
int cur_l = 0;
int cur_r = -1;
int cc=0;
int p[]=new int[q];
for (int e[] : r) {
int l=e[0];
int rr=e[1];
while (cur_l > l) {
cur_l--;
b[ar[cur_l]]++;
if(b[ar[cur_l]]%2==0)cc++;
}
while (cur_r < rr) {
cur_r++;
b[ar[cur_r]]++;
if(b[ar[cur_r]]%2==0)cc++;
}
while (cur_l < l) {
b[ar[cur_l]]--;
if(b[ar[cur_l]]%2!=0)cc--;
cur_l++;
}
while (cur_r > rr) {
b[ar[cur_r]]--;
if(b[ar[cur_r]]%2!=0)cc--;
cur_r--;
}
p[e[2]]=cc;
}
sb=new StringBuilder(2000000);
for(int e:p)sl(e);
p(sb);
}
long mod=998244353l;
int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
BufferedReader bq = new BufferedReader(new InputStreamReader(in));StringTokenizer st;StringBuilder sb;
public static void main(String[] a)throws Exception{new Main().tq();}
int di[][]={{-1,0},{1,0},{0,-1},{0,1}};
int de[][]={{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{1,1},{-1,1},{1,-1}};
void f(){out.flush();}
int p(int i,int p[]){return p[i]<0?i:(p[i]=p(p[i],p));}
boolean c(int x,int y,int n,int m){return x>=0&&x<n&&y>=0&&y<m;}
int[] so(int ar[])
{
Integer r[] = new Integer[ar.length];
for (int x = 0; x < ar.length; x++) r[x] = ar[x];
sort(r);
for (int x = 0; x < ar.length; x++) ar[x] = r[x];
return ar;
}
long[] so(long ar[])
{
Long r[] = new Long[ar.length];
for (int x = 0; x < ar.length; x++) r[x] = ar[x];
sort(r);
for (int x = 0; x < ar.length; x++) ar[x] = r[x];
return ar;
}
char[] so(char ar[])
{
Character r[] = new Character[ar.length];
for (int x = 0; x < ar.length; x++) r[x] = ar[x];
sort(r);
for (int x = 0; x < ar.length; x++) ar[x] = r[x];
return ar;
}
void p(Object p) {out.print(p);}void pl(Object p) {out.println(p);}void pl() {out.println();}
void s(String s) {sb.append(s);}
void s(int s) {sb.append(s);}
void s(long s) {sb.append(s);}
void s(char s) {sb.append(s);}
void s(double s) {sb.append(s);}
void ss() {sb.append(' ');}
void sl(String s) {s(s);sb.append("\n");}
void sl(int s) {s(s);sb.append("\n");}
void sl(long s) {s(s);sb.append("\n");}
void sl(char s) {s(s);sb.append("\n");}
void sl(double s) {s(s);sb.append("\n");}
void sl() {sb.append("\n");}
int l(int v) {return 31 - Integer.numberOfLeadingZeros(v);}
long l(long v) {return 63 - Long.numberOfLeadingZeros(v);}
int sq(int a) {return (int) sqrt(a);}
long sq(long a) {return (long) sqrt(a);}
int gcd(int a, int b)
{
while (b > 0)
{
int c = a % b;
a = b;
b = c;
}
return a;
}
long gcd(long a, long b)
{
while (b > 0l)
{
long c = a % b;
a = b;
b = c;
}
return a;
}
boolean p(String s, int i, int j)
{
while (i < j) if (s.charAt(i++) != s.charAt(j--)) return false;
return true;
}
boolean[] si(int n)
{
boolean bo[] = new boolean[n + 1];
bo[0] = bo[1] = true;
for (int x = 4; x <= n; x += 2) bo[x] = true;
for (int x = 3; x * x <= n; x += 2)
{
if (!bo[x])
{
int vv = (x << 1);
for (int y = x * x; y <= n; y += vv) bo[y] = true;
}
}
return bo;
}
long mul(long a, long b, long m)
{
long r = 1l;
a %= m;
while (b > 0)
{
if ((b & 1) == 1) r = (r * a) % m;
b >>= 1;
a = (a * a) % m;
}
return r;
}
int i() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return Integer.parseInt(st.nextToken());
}
long l() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return Long.parseLong(st.nextToken());
}
String s() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return st.nextToken();
}
double d() throws IOException
{
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
return Double.parseDouble(st.nextToken());
}
void s(int a[])
{
for (int e : a){sb.append(e);sb.append(' ');}
sb.append("\n");
}
void s(long a[])
{
for (long e : a){sb.append(e);sb.append(' ');}
sb.append("\n");
}
void s(char a[])
{
for (char e : a){sb.append(e);sb.append(' ');}
sb.append("\n");
}
void s(int ar[][]) {for (int a[] : ar) s(a);}
void s(long ar[][]) {for (long a[] : ar) s(a);}
void s(char ar[][]) {for (char a[] : ar) s(a);}
int[] ari(int n) throws IOException
{
int ar[] = new int[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = Integer.parseInt(st.nextToken());
return ar;
}
long[] arl(int n) throws IOException
{
long ar[] = new long[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = Long.parseLong(st.nextToken());
return ar;
}
char[] arc(int n) throws IOException
{
char ar[] = new char[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = st.nextToken().charAt(0);
return ar;
}
double[] ard(int n) throws IOException
{
double ar[] = new double[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = Double.parseDouble(st.nextToken());
return ar;
}
String[] ars(int n) throws IOException
{
String ar[] = new String[n];
if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
for (int x = 0; x < n; x++) ar[x] = st.nextToken();
return ar;
}
int[][] ari(int n, int m) throws IOException
{
int ar[][] = new int[n][m];
for (int x = 0; x < n; x++)ar[x]=ari(m);
return ar;
}
long[][] arl(int n, int m) throws IOException
{
long ar[][] = new long[n][m];
for (int x = 0; x < n; x++)ar[x]=arl(m);
return ar;
}
char[][] arc(int n, int m) throws IOException
{
char ar[][] = new char[n][m];
for (int x = 0; x < n; x++)ar[x]=arc(m);
return ar;
}
double[][] ard(int n, int m) throws IOException
{
double ar[][] = new double[n][m];
for (int x = 0; x < n; x++)ar[x]=ard(m);
return ar;
}
void p(int ar[])
{
sb = new StringBuilder(11 * ar.length);
for (int a : ar) {sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(long ar[])
{
StringBuilder sb = new StringBuilder(20 * ar.length);
for (long a : ar){sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(double ar[])
{
StringBuilder sb = new StringBuilder(22 * ar.length);
for (double a : ar){sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(char ar[])
{
StringBuilder sb = new StringBuilder(2 * ar.length);
for (char aa : ar){sb.append(aa);sb.append(' ');}
out.println(sb);
}
void p(String ar[])
{
int c = 0;
for (String s : ar) c += s.length() + 1;
StringBuilder sb = new StringBuilder(c);
for (String a : ar){sb.append(a);sb.append(' ');}
out.println(sb);
}
void p(int ar[][])
{
StringBuilder sb = new StringBuilder(11 * ar.length * ar[0].length);
for (int a[] : ar)
{
for (int aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void p(long ar[][])
{
StringBuilder sb = new StringBuilder(20 * ar.length * ar[0].length);
for (long a[] : ar)
{
for (long aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void p(double ar[][])
{
StringBuilder sb = new StringBuilder(22 * ar.length * ar[0].length);
for (double a[] : ar)
{
for (double aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void p(char ar[][])
{
StringBuilder sb = new StringBuilder(2 * ar.length * ar[0].length);
for (char a[] : ar)
{
for (char aa : a){sb.append(aa);sb.append(' ');}
sb.append("\n");
}
p(sb);
}
void pl(Object... ar) {for (Object e : ar) p(e + " ");pl();}
} | ConDefects/ConDefects/Code/abc242_g/Java/29900600 |
condefects-java_data_1103 | import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
sc.close();
Arrays.sort(a);
int[] d = new int[n];
PriorityQueue<Obj> que = new PriorityQueue<>((o1, o2) -> Long.compare(o1.v, o2.v));
for (int i = 0; i < 2; i++) {
Obj o = new Obj();
o.i = i;
o.v = a[i] * 3;
que.add(o);
d[i] = 1;
}
for (int i = 2; i < n; i++) {
Obj o = que.poll();
long d0 = d[o.i];
long d1 = d0 + 1;
long d2 = d1 * d1 - d0 * d0;
o.v = a[o.i] * d2;
que.add(o);
d[o.i]++;
o = new Obj();
o.i = i;
o.v = a[i] * 3;
que.add(o);
d[i] = 1;
}
long ans = 0;
for (int i = 0; i < n; i++) {
long di = d[i];
ans += a[i] * di * di;
}
System.out.println(ans);
}
static class Obj {
int i;
long v;
}
}
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
sc.close();
Arrays.sort(a);
int[] d = new int[n];
PriorityQueue<Obj> que = new PriorityQueue<>((o1, o2) -> Long.compare(o1.v, o2.v));
for (int i = 0; i < 2; i++) {
Obj o = new Obj();
o.i = i;
o.v = a[i] * 3;
que.add(o);
d[i] = 1;
}
for (int i = 2; i < n; i++) {
Obj o = que.poll();
d[o.i]++;
long d0 = d[o.i];
long d1 = d0 + 1;
long d2 = d1 * d1 - d0 * d0;
o.v = a[o.i] * d2;
que.add(o);
o = new Obj();
o.i = i;
o.v = a[i] * 3;
que.add(o);
d[i] = 1;
}
long ans = 0;
for (int i = 0; i < n; i++) {
long di = d[i];
ans += a[i] * di * di;
}
System.out.println(ans);
}
static class Obj {
int i;
long v;
}
}
| ConDefects/ConDefects/Code/abc359_f/Java/54834430 |
condefects-java_data_1104 | import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
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 a = IntStream.range(0, n).map(x -> sc.nextInt()).toArray();
Arrays.sort(a);
sc.close();
var pq = new PriorityQueue<Item2>();
var result = 0L;
for (var i = 0; i < n; i++) {
result += a[i];
pq.add(new Main().new Item2(a[i], 1));
}
for (var i = 0; i < n - 2; i++) {
var item = pq.poll();
result += item.value;
pq.add(new Main().new Item2(item.key, item.c + 1));
}
System.out.print(result);
}
public class Item2 implements Comparable<Item2> {
private int key;
private int c;
private long value;
public Item2(int key, int c) {
this.key = key;
this.c = c;
this.value = ((c + 1) * (c + 1) - c * c) * key;
}
@Override
public int compareTo(Item2 target) {
if (this.value - target.value > 0) {
return 1;
} else if (this.value - target.value < 0) {
return -1;
}
if (this.key - target.key > 0) {
return 1;
} else if (this.key - target.key < 0) {
return -1;
}
return 0;
}
}
}
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
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 a = IntStream.range(0, n).map(x -> sc.nextInt()).toArray();
Arrays.sort(a);
sc.close();
var pq = new PriorityQueue<Item2>();
var result = 0L;
for (var i = 0; i < n; i++) {
result += a[i];
pq.add(new Main().new Item2(a[i], 1));
}
for (var i = 0; i < n - 2; i++) {
var item = pq.poll();
result += item.value;
pq.add(new Main().new Item2(item.key, item.c + 1));
}
System.out.print(result);
}
public class Item2 implements Comparable<Item2> {
private int key;
private int c;
private long value;
public Item2(int key, int c) {
this.key = key;
this.c = c;
this.value = ((long)(c + 1) * (c + 1) - (long)c * c) * key;
}
@Override
public int compareTo(Item2 target) {
if (this.value - target.value > 0) {
return 1;
} else if (this.value - target.value < 0) {
return -1;
}
if (this.key - target.key > 0) {
return 1;
} else if (this.key - target.key < 0) {
return -1;
}
return 0;
}
}
}
| ConDefects/ConDefects/Code/abc359_f/Java/54846225 |
condefects-java_data_1105 | 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() {
long n = sc.nextLong();
int a0 = sc.nextInt();
int a1 = sc.nextInt();
int a2 = sc.nextInt();
long mod = 998244353;
long[][][][][][][] dp = new long[63][a0][a1][a2][2][2][2];
long[][] pow = new long[11][63];
for(int i=1; i<=10; i++) {
pow[i][0] = 1;
for(int j=1; j<63; j++) {
pow[i][j] = pow[i][j-1] * i % mod;
}
}
dp[62][0][0][0][0][0][0] = 1;
for(int i=61; i>=0; i--) {
int b = (int)((n>>i)&1);
for(int i0 = 0 ; i0 < a0; i0++) {
for(int i1 = 0; i1 < a1; i1++) {
for (int i2 = 0; i2 < a2; i2++) {
for (int j0 = 0; j0 < 2; j0++) {
for (int j1 = 0; j1 < 2; j1++) {
int j2 = j0 ^ j1;
int ni0 = (int) ((i0 + (j0 * pow[2][i])) % a0);
int ni1 = (int) ((i1 + (j1 * pow[2][i])) % a1);
int ni2 = (int) ((i2 + (j2 * pow[2][i])) % a2);
if (b == 0) {
if (j0 == 1 && j1 == 1) {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][1][0] += dp[i + 1][i0][i1][i2][1][1][0];
} else if (j0 == 1 && j2 == 1) {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][0][1] += dp[i + 1][i0][i1][i2][1][0][1];
} else if (j1 == 1 && j2 == 1) {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][0][1][1] += dp[i + 1][i0][i1][i2][0][1][1];
} else {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][1][0] += dp[i + 1][i0][i1][i2][1][1][0];
dp[i][ni0][ni1][ni2][1][0][1] += dp[i + 1][i0][i1][i2][1][0][1];
dp[i][ni0][ni1][ni2][1][0][0] += dp[i + 1][i0][i1][i2][1][0][0];
dp[i][ni0][ni1][ni2][0][1][1] += dp[i + 1][i0][i1][i2][0][1][1];
dp[i][ni0][ni1][ni2][0][1][0] += dp[i + 1][i0][i1][i2][0][1][0];
dp[i][ni0][ni1][ni2][0][0][1] += dp[i + 1][i0][i1][i2][0][0][1];
dp[i][ni0][ni1][ni2][0][0][0] += dp[i + 1][i0][i1][i2][0][0][0];
}
} else {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][1][1 - j2] += dp[i + 1][i0][i1][i2][1][1][0];
dp[i][ni0][ni1][ni2][1][1 - j1][1] += dp[i + 1][i0][i1][i2][1][0][1];
dp[i][ni0][ni1][ni2][1][1 - j1][1 - j2] += dp[i + 1][i0][i1][i2][1][0][0];
dp[i][ni0][ni1][ni2][1 - j0][1][1] += dp[i + 1][i0][i1][i2][0][1][1];
dp[i][ni0][ni1][ni2][1 - j0][1][1 - j2] += dp[i + 1][i0][i1][i2][0][1][0];
dp[i][ni0][ni1][ni2][1 - j0][1 - j1][1] += dp[i + 1][i0][i1][i2][0][0][1];
dp[i][ni0][ni1][ni2][1 - j0][1 - j1][1 - j2] += dp[i + 1][i0][i1][i2][0][0][0];
}
dp[i][ni0][ni1][ni2][1][1][1] %= mod;
dp[i][ni0][ni1][ni2][1][1][0] %= mod;
dp[i][ni0][ni1][ni2][1][0][1] %= mod;
dp[i][ni0][ni1][ni2][1][0][0] %= mod;
dp[i][ni0][ni1][ni2][0][1][1] %= mod;
dp[i][ni0][ni1][ni2][0][1][0] %= mod;
dp[i][ni0][ni1][ni2][0][0][1] %= mod;
dp[i][ni0][ni1][ni2][0][0][0] %= mod;
}
}
}
}
}
}
long res = 0;
res += dp[0][0][0][0][1][1][1];
res += dp[0][0][0][0][1][1][0];
res += dp[0][0][0][0][1][0][1];
res += dp[0][0][0][0][1][0][0];
res += dp[0][0][0][0][0][1][1];
res += dp[0][0][0][0][0][1][0];
res += dp[0][0][0][0][0][0][1];
res += dp[0][0][0][0][0][0][0];
res += mod - n / lcm(a0, a1) % mod;
res += mod - n / lcm(a0, a2) % mod;
res += mod - n / lcm(a1, a2) % mod;
res += mod - 1;
res %= mod;
out.println(res);
}
static int lcm(int m, int n) {
return m / gcd(m, n) * n;
}
static int gcd(int m, int n) {
if(m < n) return gcd(n, m);
if(n == 0) return m;
return gcd(n, m % n);
}
}
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() {
long n = sc.nextLong();
int a0 = sc.nextInt();
int a1 = sc.nextInt();
int a2 = sc.nextInt();
long mod = 998244353;
long[][][][][][][] dp = new long[63][a0][a1][a2][2][2][2];
long[][] pow = new long[11][63];
for(int i=1; i<=10; i++) {
pow[i][0] = 1;
for(int j=1; j<63; j++) {
pow[i][j] = pow[i][j-1] * i;
}
}
dp[62][0][0][0][0][0][0] = 1;
for(int i=61; i>=0; i--) {
int b = (int)((n>>i)&1);
for(int i0 = 0 ; i0 < a0; i0++) {
for(int i1 = 0; i1 < a1; i1++) {
for (int i2 = 0; i2 < a2; i2++) {
for (int j0 = 0; j0 < 2; j0++) {
for (int j1 = 0; j1 < 2; j1++) {
int j2 = j0 ^ j1;
int ni0 = (int) ((i0 + (j0 * pow[2][i])) % a0);
int ni1 = (int) ((i1 + (j1 * pow[2][i])) % a1);
int ni2 = (int) ((i2 + (j2 * pow[2][i])) % a2);
if (b == 0) {
if (j0 == 1 && j1 == 1) {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][1][0] += dp[i + 1][i0][i1][i2][1][1][0];
} else if (j0 == 1 && j2 == 1) {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][0][1] += dp[i + 1][i0][i1][i2][1][0][1];
} else if (j1 == 1 && j2 == 1) {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][0][1][1] += dp[i + 1][i0][i1][i2][0][1][1];
} else {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][1][0] += dp[i + 1][i0][i1][i2][1][1][0];
dp[i][ni0][ni1][ni2][1][0][1] += dp[i + 1][i0][i1][i2][1][0][1];
dp[i][ni0][ni1][ni2][1][0][0] += dp[i + 1][i0][i1][i2][1][0][0];
dp[i][ni0][ni1][ni2][0][1][1] += dp[i + 1][i0][i1][i2][0][1][1];
dp[i][ni0][ni1][ni2][0][1][0] += dp[i + 1][i0][i1][i2][0][1][0];
dp[i][ni0][ni1][ni2][0][0][1] += dp[i + 1][i0][i1][i2][0][0][1];
dp[i][ni0][ni1][ni2][0][0][0] += dp[i + 1][i0][i1][i2][0][0][0];
}
} else {
dp[i][ni0][ni1][ni2][1][1][1] += dp[i + 1][i0][i1][i2][1][1][1];
dp[i][ni0][ni1][ni2][1][1][1 - j2] += dp[i + 1][i0][i1][i2][1][1][0];
dp[i][ni0][ni1][ni2][1][1 - j1][1] += dp[i + 1][i0][i1][i2][1][0][1];
dp[i][ni0][ni1][ni2][1][1 - j1][1 - j2] += dp[i + 1][i0][i1][i2][1][0][0];
dp[i][ni0][ni1][ni2][1 - j0][1][1] += dp[i + 1][i0][i1][i2][0][1][1];
dp[i][ni0][ni1][ni2][1 - j0][1][1 - j2] += dp[i + 1][i0][i1][i2][0][1][0];
dp[i][ni0][ni1][ni2][1 - j0][1 - j1][1] += dp[i + 1][i0][i1][i2][0][0][1];
dp[i][ni0][ni1][ni2][1 - j0][1 - j1][1 - j2] += dp[i + 1][i0][i1][i2][0][0][0];
}
dp[i][ni0][ni1][ni2][1][1][1] %= mod;
dp[i][ni0][ni1][ni2][1][1][0] %= mod;
dp[i][ni0][ni1][ni2][1][0][1] %= mod;
dp[i][ni0][ni1][ni2][1][0][0] %= mod;
dp[i][ni0][ni1][ni2][0][1][1] %= mod;
dp[i][ni0][ni1][ni2][0][1][0] %= mod;
dp[i][ni0][ni1][ni2][0][0][1] %= mod;
dp[i][ni0][ni1][ni2][0][0][0] %= mod;
}
}
}
}
}
}
long res = 0;
res += dp[0][0][0][0][1][1][1];
res += dp[0][0][0][0][1][1][0];
res += dp[0][0][0][0][1][0][1];
res += dp[0][0][0][0][1][0][0];
res += dp[0][0][0][0][0][1][1];
res += dp[0][0][0][0][0][1][0];
res += dp[0][0][0][0][0][0][1];
res += dp[0][0][0][0][0][0][0];
res += mod - n / lcm(a0, a1) % mod;
res += mod - n / lcm(a0, a2) % mod;
res += mod - n / lcm(a1, a2) % mod;
res += mod - 1;
res %= mod;
out.println(res);
}
static int lcm(int m, int n) {
return m / gcd(m, n) * n;
}
static int gcd(int m, int n) {
if(m < n) return gcd(n, m);
if(n == 0) return m;
return gcd(n, m % n);
}
}
| ConDefects/ConDefects/Code/abc317_f/Java/45004584 |
condefects-java_data_1106 | import java.io.*;
import java.util.*;
import java.util.stream.*;
class Main {
static final int MOD = 998244353;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N;
int[] A;
long[] es;
static int i(String s) { return Integer.parseInt(s); }
void calc() throws Exception {
N = i(br.readLine());
String[] as = br.readLine().split(" ");
A = Arrays.stream(as).mapToInt(a -> i(a)).toArray();
es = new long[N+1];
for (int i = N-2; i >= 0; i--) {
long p = inv(A[i] + 1);
long e = inv( (1-p+MOD) %MOD );
e = e * p %MOD;
e = e * ((es[i+1] - es[i+A[i]+1] + MOD) %MOD + A[i] + 1) %MOD;
es[i] = (es[i+1] + e) %MOD;
}
System.out.println(es[0] - es[1]);
}
public static void main(String[] args) throws Exception {
new Main().calc();
}
static final long inv(long a) {
long b = MOD;
long aa = a, bb = b;
long x0 = 1, x1 = 0;
long y0 = 0, y1 = 1;
while (b != 0) {
long q = a / b;
long r = a % b;
long x2 = x0 - q * x1;
long y2 = y0 - q * y1;
a = b; b = r;
x0 = x1; x1 = x2;
y0 = y1; y1 = y2;
}
if (bb > 0 && x0 < 0) {
long n = -x0/bb;
if (-x0%bb != 0) n++;
x0 += n*bb; y0 -= n*aa;
}
return x0;
}
}
import java.io.*;
import java.util.*;
import java.util.stream.*;
class Main {
static final int MOD = 998244353;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int N;
int[] A;
long[] es;
static int i(String s) { return Integer.parseInt(s); }
void calc() throws Exception {
N = i(br.readLine());
String[] as = br.readLine().split(" ");
A = Arrays.stream(as).mapToInt(a -> i(a)).toArray();
es = new long[N+1];
for (int i = N-2; i >= 0; i--) {
long p = inv(A[i] + 1);
long e = inv( (1-p+MOD) %MOD );
e = e * p %MOD;
e = e * ((es[i+1] - es[i+A[i]+1] + MOD) %MOD + A[i] + 1) %MOD;
es[i] = (es[i+1] + e) %MOD;
}
System.out.println( (es[0] - es[1] + MOD) %MOD);
}
public static void main(String[] args) throws Exception {
new Main().calc();
}
static final long inv(long a) {
long b = MOD;
long aa = a, bb = b;
long x0 = 1, x1 = 0;
long y0 = 0, y1 = 1;
while (b != 0) {
long q = a / b;
long r = a % b;
long x2 = x0 - q * x1;
long y2 = y0 - q * y1;
a = b; b = r;
x0 = x1; x1 = x2;
y0 = y1; y1 = y2;
}
if (bb > 0 && x0 < 0) {
long n = -x0/bb;
if (-x0%bb != 0) n++;
x0 += n*bb; y0 -= n*aa;
}
return x0;
}
}
| ConDefects/ConDefects/Code/abc263_e/Java/38682048 |
condefects-java_data_1107 | import java.util.*;
public class Main {
private static int dfs(int v, int[] vis, int[] g) {
vis[v] = 1;
int res = -1;
if (vis[g[v]] == 0)
res = dfs(g[v], vis, g);
vis[v] = 2;
if (vis[g[v]] == 1)
res = v;
return res;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] g = new int[n];
for (int i = 0; i < n; i++) {
g[i] = sc.nextInt() - 1;
}
int [] cost = new int[n];
for (int i = 0; i < n; i++)
cost[i] = sc.nextInt();
int[] vis = new int[n];
int ans = 0;
for (int i = 0; i < n; i++) {
int cycleStart = -1;
if (vis[i] == 0) {
cycleStart = dfs(i, vis, g);
if (cycleStart != -1) {
int c = Integer.MAX_VALUE;
int st = cycleStart;
do {
c = Math.min(c, cost[st]);
st = g[st];
} while (st != cycleStart);
ans += c;
}
}
}
System.out.println(ans);
}
}
import java.util.*;
public class Main {
private static int dfs(int v, int[] vis, int[] g) {
vis[v] = 1;
int res = -1;
if (vis[g[v]] == 0)
res = dfs(g[v], vis, g);
vis[v] = 2;
if (vis[g[v]] == 1)
res = v;
return res;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] g = new int[n];
for (int i = 0; i < n; i++) {
g[i] = sc.nextInt() - 1;
}
int [] cost = new int[n];
for (int i = 0; i < n; i++)
cost[i] = sc.nextInt();
int[] vis = new int[n];
long ans = 0;
for (int i = 0; i < n; i++) {
int cycleStart = -1;
if (vis[i] == 0) {
cycleStart = dfs(i, vis, g);
if (cycleStart != -1) {
int c = Integer.MAX_VALUE;
int st = cycleStart;
do {
c = Math.min(c, cost[st]);
st = g[st];
} while (st != cycleStart);
ans += c;
}
}
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc256_e/Java/32678976 |
condefects-java_data_1108 | import java.util.*;
class Main{
static class DisjointSet{
private int[] rank, root;
private int n;
public DisjointSet(int n) {
this.n = n;
this.rank = new int[n];
this.root = new int[n];
initroot();
}
private void initroot(){
for(int i =0; i<n; ++i){
root[i] = i;
}
}
public int find(int x){
if(root[x] != x){
return root[x] = find(root[x]);
}
return root[x];
}
public void union(int x, int y){
int xRoot = find(x);
int yRoot = find(y);
if(xRoot == yRoot){
return;
}
if(rank[xRoot] < rank[yRoot]){
root[xRoot] = yRoot;
}else if(rank[xRoot] > rank[yRoot]){
root[yRoot] = xRoot;
}else{
root[yRoot] = xRoot;
rank[xRoot]++;
}
}
public boolean isSame(int x, int y){
return find(x) == find(y);
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
DisjointSet dsj = new DisjointSet(N);
HashMap<Integer, Map.Entry<Integer, Integer>> m = new HashMap<>();
ArrayList<Integer> X = new ArrayList<>();
ArrayList<Integer> C = new ArrayList<>();
for(int i=0; i<N; ++i) X.add(sc.nextInt()-1);
for(int i=0; i<N; ++i) C.add(sc.nextInt());
for(int i=0; i<N; ++i){
Map.Entry<Integer, Integer> e = Map.entry( X.get(i), C.get(i) );
m.put( i, e);
}
int ans = 0;
for(Integer k : m.keySet()){
int from = k;
int to = m.get(k).getKey();
if(dsj.isSame(from, to)){
//looping the hashmap and get the minimum value
int tmp = Integer.MAX_VALUE;
HashSet<Integer> set = new HashSet<>();
while(!set.contains(from)){
set.add(from);
from = to;
to = m.get(from).getKey();
tmp = Math.min(tmp, m.get(from).getValue());
}
ans += tmp;
}else {
dsj.union(from, to);
}
}
System.out.println(ans);
}
}
import java.util.*;
class Main{
static class DisjointSet{
private int[] rank, root;
private int n;
public DisjointSet(int n) {
this.n = n;
this.rank = new int[n];
this.root = new int[n];
initroot();
}
private void initroot(){
for(int i =0; i<n; ++i){
root[i] = i;
}
}
public int find(int x){
if(root[x] != x){
return root[x] = find(root[x]);
}
return root[x];
}
public void union(int x, int y){
int xRoot = find(x);
int yRoot = find(y);
if(xRoot == yRoot){
return;
}
if(rank[xRoot] < rank[yRoot]){
root[xRoot] = yRoot;
}else if(rank[xRoot] > rank[yRoot]){
root[yRoot] = xRoot;
}else{
root[yRoot] = xRoot;
rank[xRoot]++;
}
}
public boolean isSame(int x, int y){
return find(x) == find(y);
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
DisjointSet dsj = new DisjointSet(N);
HashMap<Integer, Map.Entry<Integer, Integer>> m = new HashMap<>();
ArrayList<Integer> X = new ArrayList<>();
ArrayList<Integer> C = new ArrayList<>();
for(int i=0; i<N; ++i) X.add(sc.nextInt()-1);
for(int i=0; i<N; ++i) C.add(sc.nextInt());
for(int i=0; i<N; ++i){
Map.Entry<Integer, Integer> e = Map.entry( X.get(i), C.get(i) );
m.put( i, e);
}
long ans = 0;
for(Integer k : m.keySet()){
int from = k;
int to = m.get(k).getKey();
if(dsj.isSame(from, to)){
//looping the hashmap and get the minimum value
int tmp = Integer.MAX_VALUE;
HashSet<Integer> set = new HashSet<>();
while(!set.contains(from)){
set.add(from);
from = to;
to = m.get(from).getKey();
tmp = Math.min(tmp, m.get(from).getValue());
}
ans += tmp;
}else {
dsj.union(from, to);
}
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/abc256_e/Java/32577408 |
condefects-java_data_1109 |
import java.util.Scanner;
import java.util.TreeSet;
public class Main {
//
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int k = scan.nextInt();
int[] p = new int[n+1];
TreeSet<Integer> pSet = new TreeSet<Integer>();
for (int i = 0; i < n; i++) {
p[scan.nextInt()] = i;
}
scan.close();
for (int i = 1; i < k; i++) {
pSet.add(p[i]);
}
int ans = n;
for (int j = 1; j <= n-k+1; j++) {
pSet.add( p[j+k-1]);
System.out.println(pSet.last() +" "+ pSet.first());
ans=Math.min(ans, pSet.last() - pSet.first());
pSet.remove(p[j]);
}
System.out.println(ans);
}
}
import java.util.Scanner;
import java.util.TreeSet;
public class Main {
//
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int k = scan.nextInt();
int[] p = new int[n+1];
TreeSet<Integer> pSet = new TreeSet<Integer>();
for (int i = 0; i < n; i++) {
p[scan.nextInt()] = i;
}
scan.close();
for (int i = 1; i < k; i++) {
pSet.add(p[i]);
}
int ans = n;
for (int j = 1; j <= n-k+1; j++) {
pSet.add( p[j+k-1]);
// System.out.println(pSet.last() +" "+ pSet.first());
ans=Math.min(ans, pSet.last() - pSet.first());
pSet.remove(p[j]);
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc352_d/Java/53191350 |
condefects-java_data_1110 | import java.io.*;
import java.util.*;
import java.util.function.*;
class Main{
/* 定数 */
static int infI = (int) 1e9;
static long infL = (long) 1e18;
static long mod = (int) 1e9 +7;
// static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
static boolean local = false;
/* 入出力とか */
static InputStream is;
MyReader in = new MyReader(is);
MyWriter out = new MyWriter(System.out);
MyLogger log = new MyLogger();
long st = System.currentTimeMillis();
void local(){}
int N = in.it() <<1;
int M = in.it();
char[][] A = in.ch(N);
int[] solve(){
int[][] T = new int[N][2];
for (int i = 0;i < N;i++)
T[i][0] = i;
for (int j = 0;j < M;j++) {
for (int i = 0;i < N;i += 2) {
char a = A[T[i][0]][j];
char b = A[T[i +1][0]][j];
if (win(a,b))
T[i][1]++;
if (win(b,a))
T[i +1][1]++;
}
Arrays.sort(T,Comparator.comparing(t -> (-t[1] <<10) +t[0]));
}
int[] ans = new int[N];
for (int i = 0;i < N;i++)
ans[T[i][0]] = i +1;
return ans;
}
private boolean win(char a,char b){
if (a == 'G' && b == 'C')
return true;
if (a == 'C' && b == 'P')
return true;
if (a == 'P' && b == 'G')
return true;
return false;
}
static class SegmentTree<V> {
Seg<V, V> seg;
SegmentTree(Seg<V, V> seg){ this.seg = seg; }
void upd(int i,V f){
seg.upd(i,i +1,f);
seg.up(i,i +1);
}
void set(int i,V v){
seg.set(i,i +1,v);
seg.up(i,i +1);
}
V get(int i){ return get(i,i +1); }
V get(int l,int r){ return seg.get(l,r); }
}
static class DualSegmentTree<V, F> {
Seg<V, F> seg;
DualSegmentTree(Seg<V, F> seg){ this.seg = seg; }
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
seg.down(l,r);
seg.upd(l,r,f);
}
void set(int i,V v){ set(i,i +1,v); }
void set(int l,int r,V v){
seg.down(l,r);
seg.set(l,r,v);
}
V get(int i){
seg.down(i,i +1);
return seg.get(i,i +1);
}
}
static class LazySegmentTree<V, F> {
Seg<V, F> seg;
LazySegmentTree(Seg<V, F> seg){ this.seg = seg; }
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
seg.down(l,r);
seg.upd(l,r,f);
seg.up(l,r);
}
void set(int i,V v){ set(i,i +1,v); }
void set(int l,int r,V v){
seg.down(l,r);
seg.set(l,r,v);
seg.up(l,r);
}
V get(int i){ return get(i,i +1); }
V get(int l,int r){
seg.down(l,r);
return seg.get(l,r);
}
}
abstract class Seg<V, F> {
int n;
V e;
V[] val;
F[] lazy;
V[] over;
int[][] lr;
@SuppressWarnings("unchecked")
Seg(int n,V e){
this.n = n;
this.e = e;
val = (V[]) new Object[n <<1];
lazy = (F[]) new Object[n];
over = (V[]) new Object[n];
lr = new int[n <<1][];
for (int i = n <<1;--i > 0;)
lr[i] = new int[]{i < n ? lr[i <<1][0] : i, i < n ? lr[i <<1 |1][1] : i +1};
}
abstract V agg(V v0,V v1);
abstract V map(V v,F f);
abstract F comp(F f0,F f1);
abstract F powF(F f,int[] lr);
abstract V powV(V v,int[] lr);
void merge(int i){ val[i] = agg(eval(i <<1),eval(i <<1 |1)); }
void uprec(int l,int r){
if (l == r) {
while (0 < (l >>= 1))
merge(l);
return;
}
if (l < r)
merge(r >>= 1);
uprec(r,l);
}
void up(int l,int r){
l += n;
r += n;
uprec(l /(l &-l),r /(r &-r));
}
void over(int i,V v){
if (i < n) {
over[i] = v;
lazy[i] = null;
} else
val[i] = v;
}
void comp(int i,F f){
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i],f) : f;
else
val[i] = map(val[i],f);
}
V eval(int i){
if (i < n && over[i] != null) {
val[i] = powV(over[i],lr[i]);
for (int c = 0;c < 2;c++)
over(i <<1 |c,over[i]);
over[i] = null;
}
if (i < n && lazy[i] != null) {
val[i] = map(val[i],powF(lazy[i],lr[i]));
for (int c = 0;c < 2;c++)
comp(i <<1 |c,lazy[i]);
lazy[i] = null;
}
return val[i] != null ? val[i] : e;
}
void downrec(int l,int r){
if (l > r) {
downrec(r,l);
return;
}
if (1 < r)
downrec(r >>1,l);
eval(r);
if (l < r)
eval(l);
}
void down(int l,int r){
l += n;
r += n;
downrec(l /(l &-l),r /(r &-r));
}
void upd(int l,int r,F f){
l += n;
r += n;
do {
if ((l &1) == 1)
comp(l++,f);
if ((r &1) == 1)
comp(--r,f);
} while ((l >>= 1) < (r >>= 1));
}
void set(int l,int r,V v){
v = v == null ? e : v;
l += n;
r += n;
do {
if ((l &1) == 1)
over(l++,v);
if ((r &1) == 1)
over(--r,v);
} while ((l >>= 1) < (r >>= 1));
}
V get(int l,int r){
l += n;
r += n;
V vl = e;
V vr = e;
do {
if ((l &1) == 1)
vl = agg(vl,val[l++]);
if ((r &1) == 1)
vr = agg(val[--r],vr);
} while ((l >>= 1) < (r >>= 1));
return agg(vl,vr);
}
}
/* Util */
static long mod(long n){ return (n %mod +mod) %mod; }
static int[][] trans(int[][] M){
int[][] ret = new int[M[0].length][M.length];
for (int i = 0;i < M.length;i++)
for (int j = 0;j < M[0].length;j++)
ret[j][i] = M[i][j];
return ret;
}
static long[][] trans(long[][] M){
long[][] ret = new long[M[0].length][M.length];
for (int i = 0;i < M.length;i++)
for (int j = 0;j < M[0].length;j++)
ret[j][i] = M[i][j];
return ret;
}
/* 実行 */
public static void main(String[] args) throws Exception{
assert local = true;
is = local ? new FileInputStream("src/input.txt") : System.in;
new Main().exe();
}
long elapsed(){ return System.currentTimeMillis() -st; }
void exe(){
if (local)
local();
Optional.ofNullable(solve()).ifPresent(out::println);
out.flush();
log.println(elapsed());
}
/* 入力 */
static class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return (int) lg(); }
int[] it(int N){
int[] a = new int[N];
Arrays.setAll(a,i -> it());
return a;
}
int[][] it(int H,int W){ return arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){
int[] a = new int[N];
Arrays.setAll(a,i -> idx());
return a;
}
int[][] idx(int H,int W){ return arr(new int[H][],i -> idx(W)); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){
long[] a = new long[N];
Arrays.setAll(a,i -> lg());
return a;
}
long[][] lg(int H,int W){ return arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){
double[] a = new double[N];
Arrays.setAll(a,i -> dbl());
return a;
}
double[][] dbl(int H,int W){ return arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return arr(new char[H][],i -> ch()); }
int[] chi(){ return toi(ch()); }
int[][] chi(int H){ return arr(new int[H][],i -> chi()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;isPrintable(c = read()) || c == ' ';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return arr(new String[N],i -> str()); }
<T> T[] arr(T[] arr,IntFunction<T> f){
Arrays.setAll(arr,f);
return arr;
}
int[] toi(char[] s){
int[] ret = new int[s.length];
Arrays.setAll(ret,i -> toi(s[i]));
return ret;
}
int toi(char c){
if (c == '.')
return 0;
if (c == '#')
return 1;
if ('a' <= c && c <= 'z')
return c -'a';
if ('A' <= c && c <= 'Z')
return c -'A';
if ('0' <= c && c <= '9')
return c -'0';
return c;
}
}
/* 出力 */
static class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void sp(){ write((byte) ' '); }
void ln(){ write((byte) '\n'); }
void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
void println(boolean b){ println(b ? yes : no); }
void println(long n){
write(n);
ln();
}
void println(double d){ println(String.valueOf(d)); }
void println(String s){ println(s.toCharArray()); }
void println(char[] s){
for (char b:s)
write((byte) b);
ln();
}
void println(int[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(long[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(double[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
for (char b:String.valueOf(a[i]).toCharArray())
write((byte) b);
}
ln();
}
}
/* デバッグ用 */
static class MyLogger{
MyWriter org = new MyWriter(System.err);
void println(Object obj){
if (!local)
return;
if (obj instanceof Boolean)
org.println((boolean) obj);
else if (obj instanceof char[])
org.println((char[]) obj);
else if (obj instanceof int[])
org.println((int[]) obj);
else if (obj instanceof long[])
org.println((long[]) obj);
else if (obj instanceof double[])
org.println((double[]) obj);
else
org.println(Objects.toString(obj));
org.flush();
}
}
}
import java.io.*;
import java.util.*;
import java.util.function.*;
class Main{
/* 定数 */
static int infI = (int) 1e9;
static long infL = (long) 1e18;
static long mod = (int) 1e9 +7;
// static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
static boolean local = false;
/* 入出力とか */
static InputStream is;
MyReader in = new MyReader(is);
MyWriter out = new MyWriter(System.out);
MyLogger log = new MyLogger();
long st = System.currentTimeMillis();
void local(){}
int N = in.it() <<1;
int M = in.it();
char[][] A = in.ch(N);
int[] solve(){
int[][] T = new int[N][2];
for (int i = 0;i < N;i++)
T[i][0] = i;
for (int j = 0;j < M;j++) {
for (int i = 0;i < N;i += 2) {
char a = A[T[i][0]][j];
char b = A[T[i +1][0]][j];
if (win(a,b))
T[i][1]++;
if (win(b,a))
T[i +1][1]++;
}
Arrays.sort(T,Comparator.comparing(t -> (-t[1] <<10) +t[0]));
}
int[] ans = new int[N];
for (int i = 0;i < N;i++)
ans[i] = T[i][0] +1;
return ans;
}
private boolean win(char a,char b){
if (a == 'G' && b == 'C')
return true;
if (a == 'C' && b == 'P')
return true;
if (a == 'P' && b == 'G')
return true;
return false;
}
static class SegmentTree<V> {
Seg<V, V> seg;
SegmentTree(Seg<V, V> seg){ this.seg = seg; }
void upd(int i,V f){
seg.upd(i,i +1,f);
seg.up(i,i +1);
}
void set(int i,V v){
seg.set(i,i +1,v);
seg.up(i,i +1);
}
V get(int i){ return get(i,i +1); }
V get(int l,int r){ return seg.get(l,r); }
}
static class DualSegmentTree<V, F> {
Seg<V, F> seg;
DualSegmentTree(Seg<V, F> seg){ this.seg = seg; }
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
seg.down(l,r);
seg.upd(l,r,f);
}
void set(int i,V v){ set(i,i +1,v); }
void set(int l,int r,V v){
seg.down(l,r);
seg.set(l,r,v);
}
V get(int i){
seg.down(i,i +1);
return seg.get(i,i +1);
}
}
static class LazySegmentTree<V, F> {
Seg<V, F> seg;
LazySegmentTree(Seg<V, F> seg){ this.seg = seg; }
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
seg.down(l,r);
seg.upd(l,r,f);
seg.up(l,r);
}
void set(int i,V v){ set(i,i +1,v); }
void set(int l,int r,V v){
seg.down(l,r);
seg.set(l,r,v);
seg.up(l,r);
}
V get(int i){ return get(i,i +1); }
V get(int l,int r){
seg.down(l,r);
return seg.get(l,r);
}
}
abstract class Seg<V, F> {
int n;
V e;
V[] val;
F[] lazy;
V[] over;
int[][] lr;
@SuppressWarnings("unchecked")
Seg(int n,V e){
this.n = n;
this.e = e;
val = (V[]) new Object[n <<1];
lazy = (F[]) new Object[n];
over = (V[]) new Object[n];
lr = new int[n <<1][];
for (int i = n <<1;--i > 0;)
lr[i] = new int[]{i < n ? lr[i <<1][0] : i, i < n ? lr[i <<1 |1][1] : i +1};
}
abstract V agg(V v0,V v1);
abstract V map(V v,F f);
abstract F comp(F f0,F f1);
abstract F powF(F f,int[] lr);
abstract V powV(V v,int[] lr);
void merge(int i){ val[i] = agg(eval(i <<1),eval(i <<1 |1)); }
void uprec(int l,int r){
if (l == r) {
while (0 < (l >>= 1))
merge(l);
return;
}
if (l < r)
merge(r >>= 1);
uprec(r,l);
}
void up(int l,int r){
l += n;
r += n;
uprec(l /(l &-l),r /(r &-r));
}
void over(int i,V v){
if (i < n) {
over[i] = v;
lazy[i] = null;
} else
val[i] = v;
}
void comp(int i,F f){
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i],f) : f;
else
val[i] = map(val[i],f);
}
V eval(int i){
if (i < n && over[i] != null) {
val[i] = powV(over[i],lr[i]);
for (int c = 0;c < 2;c++)
over(i <<1 |c,over[i]);
over[i] = null;
}
if (i < n && lazy[i] != null) {
val[i] = map(val[i],powF(lazy[i],lr[i]));
for (int c = 0;c < 2;c++)
comp(i <<1 |c,lazy[i]);
lazy[i] = null;
}
return val[i] != null ? val[i] : e;
}
void downrec(int l,int r){
if (l > r) {
downrec(r,l);
return;
}
if (1 < r)
downrec(r >>1,l);
eval(r);
if (l < r)
eval(l);
}
void down(int l,int r){
l += n;
r += n;
downrec(l /(l &-l),r /(r &-r));
}
void upd(int l,int r,F f){
l += n;
r += n;
do {
if ((l &1) == 1)
comp(l++,f);
if ((r &1) == 1)
comp(--r,f);
} while ((l >>= 1) < (r >>= 1));
}
void set(int l,int r,V v){
v = v == null ? e : v;
l += n;
r += n;
do {
if ((l &1) == 1)
over(l++,v);
if ((r &1) == 1)
over(--r,v);
} while ((l >>= 1) < (r >>= 1));
}
V get(int l,int r){
l += n;
r += n;
V vl = e;
V vr = e;
do {
if ((l &1) == 1)
vl = agg(vl,val[l++]);
if ((r &1) == 1)
vr = agg(val[--r],vr);
} while ((l >>= 1) < (r >>= 1));
return agg(vl,vr);
}
}
/* Util */
static long mod(long n){ return (n %mod +mod) %mod; }
static int[][] trans(int[][] M){
int[][] ret = new int[M[0].length][M.length];
for (int i = 0;i < M.length;i++)
for (int j = 0;j < M[0].length;j++)
ret[j][i] = M[i][j];
return ret;
}
static long[][] trans(long[][] M){
long[][] ret = new long[M[0].length][M.length];
for (int i = 0;i < M.length;i++)
for (int j = 0;j < M[0].length;j++)
ret[j][i] = M[i][j];
return ret;
}
/* 実行 */
public static void main(String[] args) throws Exception{
assert local = true;
is = local ? new FileInputStream("src/input.txt") : System.in;
new Main().exe();
}
long elapsed(){ return System.currentTimeMillis() -st; }
void exe(){
if (local)
local();
Optional.ofNullable(solve()).ifPresent(out::println);
out.flush();
log.println(elapsed());
}
/* 入力 */
static class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return (int) lg(); }
int[] it(int N){
int[] a = new int[N];
Arrays.setAll(a,i -> it());
return a;
}
int[][] it(int H,int W){ return arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){
int[] a = new int[N];
Arrays.setAll(a,i -> idx());
return a;
}
int[][] idx(int H,int W){ return arr(new int[H][],i -> idx(W)); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){
long[] a = new long[N];
Arrays.setAll(a,i -> lg());
return a;
}
long[][] lg(int H,int W){ return arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){
double[] a = new double[N];
Arrays.setAll(a,i -> dbl());
return a;
}
double[][] dbl(int H,int W){ return arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return arr(new char[H][],i -> ch()); }
int[] chi(){ return toi(ch()); }
int[][] chi(int H){ return arr(new int[H][],i -> chi()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;isPrintable(c = read()) || c == ' ';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return arr(new String[N],i -> str()); }
<T> T[] arr(T[] arr,IntFunction<T> f){
Arrays.setAll(arr,f);
return arr;
}
int[] toi(char[] s){
int[] ret = new int[s.length];
Arrays.setAll(ret,i -> toi(s[i]));
return ret;
}
int toi(char c){
if (c == '.')
return 0;
if (c == '#')
return 1;
if ('a' <= c && c <= 'z')
return c -'a';
if ('A' <= c && c <= 'Z')
return c -'A';
if ('0' <= c && c <= '9')
return c -'0';
return c;
}
}
/* 出力 */
static class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
MyWriter(OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void sp(){ write((byte) ' '); }
void ln(){ write((byte) '\n'); }
void write(byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
void write(byte[] b,int off,int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
void println(boolean b){ println(b ? yes : no); }
void println(long n){
write(n);
ln();
}
void println(double d){ println(String.valueOf(d)); }
void println(String s){ println(s.toCharArray()); }
void println(char[] s){
for (char b:s)
write((byte) b);
ln();
}
void println(int[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(long[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(double[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
for (char b:String.valueOf(a[i]).toCharArray())
write((byte) b);
}
ln();
}
}
/* デバッグ用 */
static class MyLogger{
MyWriter org = new MyWriter(System.err);
void println(Object obj){
if (!local)
return;
if (obj instanceof Boolean)
org.println((boolean) obj);
else if (obj instanceof char[])
org.println((char[]) obj);
else if (obj instanceof int[])
org.println((int[]) obj);
else if (obj instanceof long[])
org.println((long[]) obj);
else if (obj instanceof double[])
org.println((double[]) obj);
else
org.println(Objects.toString(obj));
org.flush();
}
}
} | ConDefects/ConDefects/Code/abc222_c/Java/38739262 |
condefects-java_data_1111 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
long S = 0, T = 0 , num = 0;
long[] money = new long[N];
for(int i=0; i<N; i++) {
money[i] = sc.nextLong();
}
for(int i=0; i<N-1; i++) {
S = sc.nextLong();
T = sc.nextLong();
if(money[i] > S) {
num = money[i] / S;
money[i+1] += num * T;
}
}
System.out.println(money[N-1]);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
long S = 0, T = 0 , num = 0;
long[] money = new long[N];
for(int i=0; i<N; i++) {
money[i] = sc.nextLong();
}
for(int i=0; i<N-1; i++) {
S = sc.nextLong();
T = sc.nextLong();
num = money[i] / S;
money[i+1] += num * T;
}
System.out.println(money[N-1]);
}
} | ConDefects/ConDefects/Code/abc341_b/Java/54951704 |
condefects-java_data_1112 | import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashSet;
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();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
ArrayList<Edge>[] edge = new ArrayList[N];
Edge[] earr = new Edge[M];
for (int i = 0; i < N; i++) edge[i] = new ArrayList<>();
for (int i = 0; i < M; i++) {
int U = sc.nextInt() - 1;
int V = sc.nextInt() - 1;
earr[i] = new Edge(U, V, i);
edge[U].add(new Edge(V, U, i));
edge[V].add(earr[i]);
}
int K = sc.nextInt();
int[] x = new int[K];
HashSet<Integer> S = new HashSet<>();
for (int i = 0; i < K; i++) {
x[i] = sc.nextInt() - 1;
S.add(x[i]);
}
UnionFind uf = new UnionFind(N);
for (int i = 0; i < N; i++) {
if ( uf.size(i) != 1 ) continue;
ArrayDeque<Integer> queue = new ArrayDeque<>();
queue.add(i);
while ( queue.size() > 0 ) {
int pos = queue.pollFirst();
for ( Edge e : edge[i] ) {
if ( S.contains(e.id) ) continue;
if ( uf.isSame(pos, e.to) ) continue;
uf.unite(pos, e.to);
queue.add(e.to);
}
}
}
int[] cnt = new int[N];
for (int i = 0; i < K; i++) {
cnt[uf.root(earr[x[i]].from)]++;
cnt[uf.root(earr[x[i]].to)]++;
}
int ocnt = 0;
for (int i = 0; i < N; i++) {
if ( cnt[i] % 2 == 1 ) ocnt++;
}
printYesNo(ocnt <= 2);
}
class Edge {
int id = 0;
int to = 0;
int from = 0;
Edge(int to, int from, int id) {
this.to = to;
this.from = from;
this.id = id;
}
}
class UnionFind {
int[] parent = null;
int[] size = null;
UnionFind(int N) {
parent = new int[N];
size = new int[N];
for ( int i = 0 ; i < N ; i++ ) {
parent[i] = i;
size[i] = 1;
}
}
int root(int i) {
return parent[i] == i ? i : (parent[i] = root(parent[i]));
}
int size(int i) {
return size[root(i)];
}
void unite(int i, int j) {
int ri = root(i);
int rj = root(j);
if ( ri == rj ) {
return;
} else {
if ( size[ri] < size[rj] ) {
parent[ri] = rj;
size[rj] += size[ri];
} else {
parent[rj] = ri;
size[ri] += size[rj];
}
}
}
boolean isSame(int i, int j) {
return root(i) == root(j);
}
}
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.ArrayDeque;
import java.util.ArrayList;
import java.util.HashSet;
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();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
ArrayList<Edge>[] edge = new ArrayList[N];
Edge[] earr = new Edge[M];
for (int i = 0; i < N; i++) edge[i] = new ArrayList<>();
for (int i = 0; i < M; i++) {
int U = sc.nextInt() - 1;
int V = sc.nextInt() - 1;
earr[i] = new Edge(U, V, i);
edge[U].add(new Edge(V, U, i));
edge[V].add(earr[i]);
}
int K = sc.nextInt();
int[] x = new int[K];
HashSet<Integer> S = new HashSet<>();
for (int i = 0; i < K; i++) {
x[i] = sc.nextInt() - 1;
S.add(x[i]);
}
UnionFind uf = new UnionFind(N);
for (int i = 0; i < N; i++) {
if ( uf.size(i) != 1 ) continue;
ArrayDeque<Integer> queue = new ArrayDeque<>();
queue.add(i);
while ( queue.size() > 0 ) {
int pos = queue.pollFirst();
for ( Edge e : edge[pos] ) {
if ( S.contains(e.id) ) continue;
if ( uf.isSame(pos, e.to) ) continue;
uf.unite(pos, e.to);
queue.add(e.to);
}
}
}
int[] cnt = new int[N];
for (int i = 0; i < K; i++) {
cnt[uf.root(earr[x[i]].from)]++;
cnt[uf.root(earr[x[i]].to)]++;
}
int ocnt = 0;
for (int i = 0; i < N; i++) {
if ( cnt[i] % 2 == 1 ) ocnt++;
}
printYesNo(ocnt <= 2);
}
class Edge {
int id = 0;
int to = 0;
int from = 0;
Edge(int to, int from, int id) {
this.to = to;
this.from = from;
this.id = id;
}
}
class UnionFind {
int[] parent = null;
int[] size = null;
UnionFind(int N) {
parent = new int[N];
size = new int[N];
for ( int i = 0 ; i < N ; i++ ) {
parent[i] = i;
size[i] = 1;
}
}
int root(int i) {
return parent[i] == i ? i : (parent[i] = root(parent[i]));
}
int size(int i) {
return size[root(i)];
}
void unite(int i, int j) {
int ri = root(i);
int rj = root(j);
if ( ri == rj ) {
return;
} else {
if ( size[ri] < size[rj] ) {
parent[ri] = rj;
size[rj] += size[ri];
} else {
parent[rj] = ri;
size[ri] += size[rj];
}
}
}
boolean isSame(int i, int j) {
return root(i) == root(j);
}
}
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/abc286_g/Java/46903427 |
condefects-java_data_1113 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();
ArrayList<Long> list = new ArrayList<>();
for(int mask = 0; mask <= Math.log(n) + 1; mask++) {
if(((n >> mask) & 1) >= 1 ) list.add((long)mask);
}
long max_mask = 1 << list.size();
for(int mask = 0; mask < max_mask; mask++){
long res = 0;
for(int i = 0; i < list.size(); i++){
if((mask & (1 << i)) > 0) res += 1L << list.get(i);
}
System.out.println(res);
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
long n = scan.nextLong();
ArrayList<Long> list = new ArrayList<>();
for(int mask = 0; mask < 60; mask++) {
if(((n >> mask) & 1) >= 1 ) list.add((long)mask);
}
long max_mask = 1 << list.size();
for(int mask = 0; mask < max_mask; mask++){
long res = 0;
for(int i = 0; i < list.size(); i++){
if((mask & (1 << i)) > 0) res += 1L << list.get(i);
}
System.out.println(res);
}
}
}
| ConDefects/ConDefects/Code/abc269_c/Java/38909344 |
condefects-java_data_1114 | import java.io.*;
import java.util.*;
public class Main {
static long MOD = 998244353;
static long[] degrees;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
HashMap<Integer, HashSet<Integer>> map = new HashMap<Integer, HashSet<Integer>>();
PriorityQueue<Pair> pq = new PriorityQueue<Pair>(new Comp());
int remaining = n;
boolean[] vis = new boolean[n];
degrees = new long[n];
for(int i = 0; i < m; i++) {
st = new StringTokenizer(br.readLine());
int u = Integer.parseInt(st.nextToken())-1;
int v = Integer.parseInt(st.nextToken())-1;
degrees[u]++;
degrees[v]++;
if(!map.containsKey(u))
map.put(u, new HashSet<Integer>());
if(!map.containsKey(v))
map.put(v, new HashSet<Integer>());
map.get(u).add(v);
map.get(v).add(u);
}
for(int i = 0; i < n; i++)
pq.add(new Pair(i, degrees[i]));
long val = 1;
while(pq.size() > 0) {
Integer next = pq.poll().ind;
if(!vis[next]) {
vis[next] = true;
remaining--;
if(!map.containsKey(next) || degrees[next] == 0) {
val = 0;
break;
}
Iterator<Integer> it = map.get(next).iterator();
boolean found = false;
while(it.hasNext()) {
int i = it.next();
if(!vis[i]) {
if(degrees[i] > 1) {
degrees[i]--;
map.get(i).remove(next);
pq.add(new Pair(i, degrees[i]));
found = true;
break;
}else {
val = 0;
break;
}
}else {
if(degrees[i] > 1) {
degrees[i]--;
found = true;
break;
}
}
}
if(found) {
val = (val * degrees[next]) % MOD;
degrees[next]--;
}else {
val = 0;
break;
}
}
}
for(int i = 0; i < n; i++)
if(degrees[i] > 0)
remaining = 1;
if(remaining > 0)
val = 0;
System.out.println(val);
}
static class Pair{
int ind;
long degree;
public Pair(int i, long d) {
ind = i;
degree = d;
}
}
static class Comp implements Comparator<Pair>{
@Override
public int compare(Pair a, Pair b) {
// TODO Auto-generated method stub
return Long.compare(a.degree, b.degree);
}
}
}
import java.io.*;
import java.util.*;
public class Main {
static long MOD = 998244353;
static long[] degrees;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
HashMap<Integer, HashSet<Integer>> map = new HashMap<Integer, HashSet<Integer>>();
PriorityQueue<Pair> pq = new PriorityQueue<Pair>(new Comp());
int remaining = n;
boolean[] vis = new boolean[n];
degrees = new long[n];
for(int i = 0; i < m; i++) {
st = new StringTokenizer(br.readLine());
int u = Integer.parseInt(st.nextToken())-1;
int v = Integer.parseInt(st.nextToken())-1;
degrees[u]++;
degrees[v]++;
if(!map.containsKey(u))
map.put(u, new HashSet<Integer>());
if(!map.containsKey(v))
map.put(v, new HashSet<Integer>());
map.get(u).add(v);
map.get(v).add(u);
}
for(int i = 0; i < n; i++)
pq.add(new Pair(i, degrees[i]));
long val = 1;
while(pq.size() > 0) {
Integer next = pq.poll().ind;
if(!vis[next]) {
vis[next] = true;
remaining--;
if(!map.containsKey(next) || degrees[next] == 0) {
val = 0;
break;
}
Iterator<Integer> it = map.get(next).iterator();
boolean found = false;
while(it.hasNext()) {
int i = it.next();
if(!vis[i]) {
if(degrees[i] > 1) {
degrees[i]--;
map.get(i).remove(next);
pq.add(new Pair(i, degrees[i]));
found = true;
break;
}else {
val = 0;
break;
}
}else {
if(degrees[i] > 0) {
degrees[i]--;
found = true;
break;
}
}
}
if(found) {
val = (val * degrees[next]) % MOD;
degrees[next]--;
}else {
val = 0;
break;
}
}
}
for(int i = 0; i < n; i++)
if(degrees[i] > 0)
remaining = 1;
if(remaining > 0)
val = 0;
System.out.println(val);
}
static class Pair{
int ind;
long degree;
public Pair(int i, long d) {
ind = i;
degree = d;
}
}
static class Comp implements Comparator<Pair>{
@Override
public int compare(Pair a, Pair b) {
// TODO Auto-generated method stub
return Long.compare(a.degree, b.degree);
}
}
}
| ConDefects/ConDefects/Code/abc226_e/Java/27130108 |
condefects-java_data_1115 |
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
public final class Main {
private static final class UnionFind {
private final int[] parent;
private final int[] size;
private int count;
private UnionFind(int n) {
parent = new int[n];
size = new int[n];
count = n;
for (int i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
public int find(int p) {
// path compression
while (p != parent[p]) {
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
public void union(int p, int q) {
final int rootP = find(p);
final int rootQ = find(q);
if (rootP == rootQ) {
return;
}
// union by size
if (size[rootP] > size[rootQ]) {
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
size[rootQ] = 0;
} else {
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
size[rootP] = 0;
}
count--;
}
public int count() { return count; }
public int[] size() { return size; }
}
private static final int MOD = 998244353;
public static void main(String[] args) throws IOException {
final FastReader fs = new FastReader();
final int n = fs.nextInt();
final int m = fs.nextInt();
final UnionFind uf = new UnionFind(n);
final int[] e = new int[n];
final int[][] edges = new int[m][2];
for (int i = 0; i < m; i++) {
final int u = fs.nextInt() - 1;
final int v = fs.nextInt() - 1;
uf.union(u, v);
edges[i] = new int[] { u, v };
}
for (int i = 0; i < m; i++) {
e[uf.find(edges[i][0])]++;
}
long res = 0;
for (int i = 0; i < n; i++) {
if (e[i] > 0) {
if (e[i] == uf.size[i]) {
if (res == 0) {
res = 2;
} else {
res = (res * 2) % MOD;
}
} else {
System.out.println(0);
return;
}
}
}
System.out.println(res);
}
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 nextSign() 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 {
private static final class UnionFind {
private final int[] parent;
private final int[] size;
private int count;
private UnionFind(int n) {
parent = new int[n];
size = new int[n];
count = n;
for (int i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
public int find(int p) {
// path compression
while (p != parent[p]) {
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
public void union(int p, int q) {
final int rootP = find(p);
final int rootQ = find(q);
if (rootP == rootQ) {
return;
}
// union by size
if (size[rootP] > size[rootQ]) {
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
size[rootQ] = 0;
} else {
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
size[rootP] = 0;
}
count--;
}
public int count() { return count; }
public int[] size() { return size; }
}
private static final int MOD = 998244353;
public static void main(String[] args) throws IOException {
final FastReader fs = new FastReader();
final int n = fs.nextInt();
final int m = fs.nextInt();
final UnionFind uf = new UnionFind(n);
final int[] e = new int[n];
final int[][] edges = new int[m][2];
for (int i = 0; i < m; i++) {
final int u = fs.nextInt() - 1;
final int v = fs.nextInt() - 1;
uf.union(u, v);
edges[i] = new int[] { u, v };
}
for (int i = 0; i < m; i++) {
e[uf.find(edges[i][0])]++;
}
long res = 0;
for (int i = 0; i < n; i++) {
if (uf.size[i] > 0) {
if (e[i] == uf.size[i]) {
if (res == 0) {
res = 2;
} else {
res = (res * 2) % MOD;
}
} else {
System.out.println(0);
return;
}
}
}
System.out.println(res);
}
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 nextSign() 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/abc226_e/Java/29208094 |
condefects-java_data_1116 | import java.io.*;
import java.util.*;
public class Main
{
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
String next() { // reads in the next string
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() { // reads in the next int
return Integer.parseInt(next());
}
public long nextLong() { // reads in the next long
return Long.parseLong(next());
}
public double nextDouble() { // reads in the next double
return Double.parseDouble(next());
}
}
static InputReader r = new InputReader(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static boolean[] visit;static ArrayList<Integer>[] adj; static int n,m, count, vertices, edges;
public static void main(String[] args)
{
n = r.nextInt();
m = r.nextInt();
adj = new ArrayList[n];
for (int i = 0; i < n; i ++)
{
adj[i] = new ArrayList<Integer>();
}
visit = new boolean[n];
count = 0;
boolean flag = false;
for (int i = 0; i < m; i ++)
{
int a = r.nextInt() - 1; int b = r.nextInt()-1;
adj[a].add(b);
adj[b].add(a);
}
for (int i = 0; i < n; i ++)
{
edges = 0;
vertices = 0;
if (!visit[i])
{
count ++;
dfs(i);
if (edges!=2*vertices)
{
flag = true;
}
}
}
pw.println(flag ? 0: binpow(2,count,1000000007));
pw.close();
}
static void dfs(int node)
{
vertices ++;
visit[node] = true;
for (int i : adj[node])
{
if (!visit[i])
{
dfs(i);
}
}
edges += adj[node].size();
}
public static long binpow(long x, long n, long m) {
assert(n >= 0);
x %= m; // note: m * m must be less than 2^63 to avoid ll overflow
long res = 1;
while (n > 0) {
if (n % 2 == 1) // if n is odd
res = res * x % m;
x = x * x % m;
n /= 2; // divide by two
}
return res;
}
}
import java.io.*;
import java.util.*;
public class Main
{
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
String next() { // reads in the next string
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() { // reads in the next int
return Integer.parseInt(next());
}
public long nextLong() { // reads in the next long
return Long.parseLong(next());
}
public double nextDouble() { // reads in the next double
return Double.parseDouble(next());
}
}
static InputReader r = new InputReader(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static boolean[] visit;static ArrayList<Integer>[] adj; static int n,m, count, vertices, edges;
public static void main(String[] args)
{
n = r.nextInt();
m = r.nextInt();
adj = new ArrayList[n];
for (int i = 0; i < n; i ++)
{
adj[i] = new ArrayList<Integer>();
}
visit = new boolean[n];
count = 0;
boolean flag = false;
for (int i = 0; i < m; i ++)
{
int a = r.nextInt() - 1; int b = r.nextInt()-1;
adj[a].add(b);
adj[b].add(a);
}
for (int i = 0; i < n; i ++)
{
edges = 0;
vertices = 0;
if (!visit[i])
{
count ++;
dfs(i);
if (edges!=2*vertices)
{
flag = true;
}
}
}
pw.println(flag ? 0: binpow(2,count,998244353));
pw.close();
}
static void dfs(int node)
{
vertices ++;
visit[node] = true;
for (int i : adj[node])
{
if (!visit[i])
{
dfs(i);
}
}
edges += adj[node].size();
}
public static long binpow(long x, long n, long m) {
assert(n >= 0);
x %= m; // note: m * m must be less than 2^63 to avoid ll overflow
long res = 1;
while (n > 0) {
if (n % 2 == 1) // if n is odd
res = res * x % m;
x = x * x % m;
n /= 2; // divide by two
}
return res;
}
} | ConDefects/ConDefects/Code/abc226_e/Java/27483977 |
condefects-java_data_1117 | import java.util.Scanner;
public class Main {
// int の 範囲 |2,147,483,647|
private static final int FAILURE = -1;
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int n = sc.nextInt();
if (n < 2) {
sc.close();
System.out.println(FAILURE);
return;
}
int d = sc.nextInt();
int t1 = sc.nextInt();
while(sc.hasNext()) {
int t2 = sc.nextInt();
if (t2 - t1 < d) {
sc.close();
System.out.println(t2);
return;
}
t1 = t2;
}
sc.close();
System.out.println(FAILURE);
}
}
import java.util.Scanner;
public class Main {
// int の 範囲 |2,147,483,647|
private static final int FAILURE = -1;
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int n = sc.nextInt();
if (n < 2) {
sc.close();
System.out.println(FAILURE);
return;
}
int d = sc.nextInt();
int t1 = sc.nextInt();
while(sc.hasNext()) {
int t2 = sc.nextInt();
if (t2 - t1 <= d) {
sc.close();
System.out.println(t2);
return;
}
t1 = t2;
}
sc.close();
System.out.println(FAILURE);
}
}
| ConDefects/ConDefects/Code/abc297_a/Java/42755035 |
condefects-java_data_1118 | import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scn = new Scanner(System.in);
int num1 = scn.nextInt();
int num2 = scn.nextInt();
int[] array = new int[num1];
int cnt =0;
for(int i =0; i<array.length; i++) {
array[i] = scn.nextInt();
}
for(int i =0; i<array.length-1; i++) {
if((array[i+1]-array[i])<=num2) {
System.out.println(array[i+1]);
break;
}else {
return;
}
}
System.out.println("-1");
scn.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner scn = new Scanner(System.in);
int num1 = scn.nextInt();
int num2 = scn.nextInt();
int[] array = new int[num1];
int cnt =0;
for(int i =0; i<array.length; i++) {
array[i] = scn.nextInt();
}
for(int i =0; i<array.length-1; i++) {
if((array[i+1]-array[i])<=num2) {
System.out.println(array[i+1]);
return;
}
}
System.out.println("-1");
scn.close();
}
} | ConDefects/ConDefects/Code/abc297_a/Java/43531382 |
condefects-java_data_1119 | import java.util.*;
import java.io.*;
public class Main {
public static Scanner sc = new Scanner(System.in);
public static PrintWriter pw = new PrintWriter(System.out);
public static void main(String[] args) {
int t = 1;
while( t > 0 ) {
solve();
t--;
}
pw.flush();
}
static void solve() {
long x = sc.nextLong();
long y = sc.nextLong();
long a = sc.nextLong();
long b = sc.nextLong();
long c = sc.nextLong();
if( allVertical(x,y,a,b,c) || oneHorizonal(x,y,a,b,c) || oneHorizonal(x,y,b,a,c) || oneHorizonal(x,y,c,a,b) ) pw.println("Yes");
else pw.println("No");
}
static boolean allVertical(long x, long y, long a, long b, long c) {
long xsum = 0;
xsum += (a+y-1)/y;
xsum += (b+y-1)/y;
xsum += (c+y-1)/y;
return xsum <= x;
}
static boolean oneHorizonal(long x, long y, long a, long b, long c) {
long xsum = 0;
y -= (a+x-1)/x;
if( y <= 0 ) return false;
xsum += (b+y-1)/y;
xsum += (c+y-1)/y;
return xsum <= x;
}
}
import java.util.*;
import java.io.*;
public class Main {
public static Scanner sc = new Scanner(System.in);
public static PrintWriter pw = new PrintWriter(System.out);
public static void main(String[] args) {
int t = 1;
while( t > 0 ) {
solve();
t--;
}
pw.flush();
}
static void solve() {
long x = sc.nextLong();
long y = sc.nextLong();
long a = sc.nextLong();
long b = sc.nextLong();
long c = sc.nextLong();
if( allVertical(x,y,a,b,c) || allVertical(y,x,a,b,c) || oneHorizonal(x,y,a,b,c) || oneHorizonal(x,y,b,a,c) || oneHorizonal(x,y,c,a,b) || oneHorizonal(y,x,a,b,c) || oneHorizonal(y,x,b,a,c) || oneHorizonal(y,x,c,a,b) ) pw.println("Yes");
else pw.println("No");
}
static boolean allVertical(long x, long y, long a, long b, long c) {
long xsum = 0;
xsum += (a+y-1)/y;
xsum += (b+y-1)/y;
xsum += (c+y-1)/y;
return xsum <= x;
}
static boolean oneHorizonal(long x, long y, long a, long b, long c) {
long xsum = 0;
y -= (a+x-1)/x;
if( y <= 0 ) return false;
xsum += (b+y-1)/y;
xsum += (c+y-1)/y;
return xsum <= x;
}
} | ConDefects/ConDefects/Code/abc223_e/Java/29839067 |
condefects-java_data_1120 | import java.util.*;
public class Main {
public static final int MOD998 = 998244353;
public static final int MOD100 = 1000000007;
public static void main(String[] args) throws Exception {
ContestScanner sc = new ContestScanner();
ContestPrinter cp = new ContestPrinter();
long X = sc.nextLong();
long Y = sc.nextLong();
long A = sc.nextLong();
long B = sc.nextLong();
long C = sc.nextLong();
boolean ans = false;
ans = ans || placeTwo(X, Y - (A + X - 1) / X, B, C);
ans = ans || placeTwo(X - (A + Y - 1) / Y, Y, B, C);
ans = ans || placeTwo(X, Y - (B + X - 1) / X, A, C);
ans = ans || placeTwo(X - (B + Y - 1) / Y, Y, A, C);
ans = ans || placeTwo(X, Y - (C + X - 1) / X, B, A);
ans = ans || placeTwo(X - (C + Y - 1) / Y, Y, B, A);
cp.println(ans ? "Yes" : "No");
cp.close();
}
static boolean placeTwo(long x, long y, long a, long b) {
if (x == 0 || y == 0) {
return false;
}
return (a + x - 1) / x + (b + x - 1) / x <= y || (a + y - 1) / y + (b + y - 1) / y <= x;
}
//////////////////
// My Library //
//////////////////
public static class SlopeTrick {
private PriorityQueue<Long> lq = new PriorityQueue<>(Comparator.reverseOrder());
private PriorityQueue<Long> rq = new PriorityQueue<>();
private long lshift = 0;
private long rshift = 0;
private long min = 0;
public long getMin() {
return min;
}
public long get(long x) {
long val = min;
for (long l : lq) {
if (l - x > 0) {
val += l - x;
}
}
for (long r : rq) {
if (x - r > 0) {
val += x - r;
}
}
return val;
}
public long getMinPosLeft() {
return lq.isEmpty() ? Long.MIN_VALUE : lq.peek() + lshift;
}
public long getMinPosRight() {
return rq.isEmpty() ? Long.MAX_VALUE : rq.peek() + rshift;
}
public void addConst(long a) {
min += a;
}
public void addSlopeRight(long a) {
if (!lq.isEmpty() && lq.peek() + lshift > a) {
min += lq.peek() + lshift - a;
lq.add(a - lshift);
rq.add(lq.poll() + lshift - rshift);
} else {
rq.add(a - rshift);
}
}
public void addSlopeLeft(long a) {
if (!rq.isEmpty() && rq.peek() < a) {
min += a - rq.peek() - rshift;
rq.add(a - rshift);
lq.add(rq.poll() + rshift - lshift);
} else {
lq.add(a - lshift);
}
}
public void addAbs(long a) {
addSlopeLeft(a);
addSlopeRight(a);
}
public void shift(long a) {
lshift += a;
rshift += a;
}
public void slideLeft(long a) {
lshift += a;
}
public void slideRight(long a) {
rshift += a;
}
public void clearLeft() {
lq.clear();
}
public void clearRight() {
rq.clear();
}
public void clearMin() {
min = 0;
}
}
public static int zeroOneBFS(int[][][] weighted_graph, int start, int goal) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
if (now == goal) {
return dist[goal];
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return -1;
}
public static int[] zeroOneBFSAll(int[][][] weighted_graph, int start) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return dist;
}
public static long dijkstra(int[][][] weighted_graph, int start, int goal) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (now == goal) {
return dist[goal];
}
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return -1;
}
public static long[] dijkstraAll(int[][][] weighted_graph, int start) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return dist;
}
public static long countLatticePoint(int[] p1, int[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
public static long countLatticePoint(long[] p1, long[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
// Don't contain same points!
public static long countLatticePoint(int[] p1, int[] p2, int[] p3, boolean include_edge) {
int[][] arr = new int[][] { p1, p2, p3 };
Arrays.sort(arr, Comparator.comparingInt(p -> ((int[]) p)[0]).thenComparingInt(p -> ((int[]) p)[1]));
if ((p2[0] - p1[0]) * (long) (p3[1] - p2[1]) == (p2[1] - p1[1]) * (long) (p3[0] - p2[0])) {
return countLatticePoint(arr[0], arr[2], true) - (include_edge ? 0 : 3);
}
long b = countLatticePoint(p1, p2, true) + countLatticePoint(p2, p3, true) + countLatticePoint(p3, p1, true)
- 3;
long i = (getAreaTriangle(p1, p2, p3) - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static long getAreaTriangle(int[] p1, int[] p2, int[] p3) {
int x1 = p2[0] - p1[0];
int x2 = p3[0] - p2[0];
int y1 = p2[1] - p1[1];
int y2 = p3[1] - p2[1];
return Math.abs((long) x1 * y2 - (long) x2 * y1);
}
// Don't contain same points!
public static long countLatticePointConvex(int[][] points, boolean include_edge) {
if (points.length == 1) {
return include_edge ? 1 : 0;
}
if (points.length == 2) {
return countLatticePoint(points[0], points[1], include_edge);
}
long s = 0;
for (int n = 1; n < points.length - 1; n++) {
s += getAreaTriangle(points[0], points[n], points[n + 1]);
}
long b = countLatticePoint(points[points.length - 1], points[0], true) - points.length;
for (int n = 0; n < points.length - 1; n++) {
b += countLatticePoint(points[n], points[n + 1], true);
}
long i = (s - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static class RationalAngle implements Comparable<RationalAngle> {
public long x;
public long y;
public static boolean include_pi_to_minus = true;
public RationalAngle(long x, long y) {
if (x == 0) {
this.x = x;
if (y == 0) {
throw new UnsupportedOperationException("Angle to (0, 0) is invalid.");
} else {
this.y = y > 0 ? 1 : -1;
}
} else if (y == 0) {
this.x = x > 0 ? 1 : -1;
this.y = 0;
} else {
long gcd = MathLib.gcd(x, y);
this.x = x / gcd;
this.y = y / gcd;
}
}
public RationalAngle copy() {
return new RationalAngle(x, y);
}
public RationalAngle add(RationalAngle a) {
RationalAngle res = copy();
res.addArg(a);
return res;
}
public void addArg(RationalAngle a) {
long nx = x * a.x - y * a.y;
long ny = y * a.x + x * a.y;
x = nx;
y = ny;
}
public RationalAngle sub(RationalAngle a) {
RationalAngle res = copy();
res.subArg(a);
return res;
}
public void subArg(RationalAngle a) {
long nx = x * a.x + y * a.y;
long ny = y * a.x - x * a.y;
x = nx;
y = ny;
}
public boolean equals(RationalAngle a) {
return x == a.x && y == a.y;
}
public boolean parallel(RationalAngle a) {
return x == a.x && y == a.y || x == -a.x && y == -a.y;
}
public int rotDirection(RationalAngle trg) {
if (parallel(trg)) {
return 0;
} else if (trg.sub(this).y > 0) {
return 1;
} else {
return -1;
}
}
public RationalAngle minus() {
return new RationalAngle(x, -y);
}
public RationalAngle rev() {
return new RationalAngle(-x, -y);
}
public double toRadian() {
return Math.atan2(y, x);
}
private int toQuad() {
if (x == 0) {
if (y > 0) {
return 2;
} else {
return -2;
}
} else if (x > 0) {
if (y == 0) {
return 0;
} else if (y > 0) {
return 1;
} else {
return -1;
}
} else {
if (y == 0) {
return include_pi_to_minus ? -4 : 4;
} else if (y > 0) {
return 3;
} else {
return -3;
}
}
}
@Override
public int compareTo(RationalAngle ra) {
if (ra == null) {
throw new NullPointerException();
}
int me = toQuad();
int you = ra.toQuad();
if (me > you) {
return 1;
} else if (me < you) {
return -1;
}
long sub = sub(ra).y;
if (sub == 0) {
return 0;
} else if (sub > 0) {
return 1;
} else {
return -1;
}
}
}
public static class Pair<A, B> {
public final A car;
public final B cdr;
public Pair(A car_, B cdr_) {
car = car_;
cdr = cdr_;
}
private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);
}
private static int hc(Object o) {
return o == null ? 0 : o.hashCode();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair))
return false;
Pair<?, ?> rhs = (Pair<?, ?>) o;
return eq(car, rhs.car) && eq(cdr, rhs.cdr);
}
@Override
public int hashCode() {
return hc(car) ^ hc(cdr);
}
}
public static class Tuple1<A> extends Pair<A, Object> {
public Tuple1(A a) {
super(a, null);
}
}
public static class Tuple2<A, B> extends Pair<A, Tuple1<B>> {
public Tuple2(A a, B b) {
super(a, new Tuple1<>(b));
}
}
public static class Tuple3<A, B, C> extends Pair<A, Tuple2<B, C>> {
public Tuple3(A a, B b, C c) {
super(a, new Tuple2<>(b, c));
}
}
public static class Tuple4<A, B, C, D> extends Pair<A, Tuple3<B, C, D>> {
public Tuple4(A a, B b, C c, D d) {
super(a, new Tuple3<>(b, c, d));
}
}
public static class Tuple5<A, B, C, D, E> extends Pair<A, Tuple4<B, C, D, E>> {
public Tuple5(A a, B b, C c, D d, E e) {
super(a, new Tuple4<>(b, c, d, e));
}
}
public static class PriorityQueueLogTime<T> {
private PriorityQueue<T> queue;
private Multiset<T> total;
private int size = 0;
public PriorityQueueLogTime() {
queue = new PriorityQueue<>();
total = new Multiset<>();
}
public PriorityQueueLogTime(Comparator<T> c) {
queue = new PriorityQueue<>(c);
total = new Multiset<>();
}
public void clear() {
queue.clear();
total.clear();
size = 0;
}
public boolean contains(T e) {
return total.count(e) > 0;
}
public boolean isEmpty() {
return size == 0;
}
public boolean offer(T e) {
total.addOne(e);
size++;
return queue.offer(e);
}
public T peek() {
if (total.isEmpty()) {
return null;
}
simplify();
return queue.peek();
}
public T poll() {
if (total.isEmpty()) {
return null;
}
simplify();
size--;
T res = queue.poll();
total.removeOne(res);
return res;
}
public void remove(T e) {
total.removeOne(e);
size--;
}
public int size() {
return size;
}
private void simplify() {
while (total.count(queue.peek()) == 0) {
queue.poll();
}
}
}
static int[][] scanGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 2);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraph(node, edge, arr[0], arr[1], undirected);
}
static int[][][] scanWeightedGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 3);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraphWithWeight(node, edge, arr[0], arr[1], arr[2], undirected);
}
static class EdgeData {
private int capacity;
private int[] from, to, weight;
private int p = 0;
private boolean weighted;
public EdgeData(boolean weighted) {
this(weighted, 500000);
}
public EdgeData(boolean weighted, int initial_capacity) {
capacity = initial_capacity;
from = new int[capacity];
to = new int[capacity];
weight = new int[capacity];
this.weighted = weighted;
}
public void addEdge(int u, int v) {
if (weighted) {
System.err.println("The graph is weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
capacity *= 2;
}
from[p] = u;
to[p] = v;
p++;
}
public void addEdge(int u, int v, int w) {
if (!weighted) {
System.err.println("The graph is NOT weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
int[] newweight = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
System.arraycopy(weight, 0, newweight, 0, capacity);
capacity *= 2;
}
from[p] = u;
to[p] = v;
weight[p] = w;
p++;
}
public int[] getFrom() {
int[] result = new int[p];
System.arraycopy(from, 0, result, 0, p);
return result;
}
public int[] getTo() {
int[] result = new int[p];
System.arraycopy(to, 0, result, 0, p);
return result;
}
public int[] getWeight() {
int[] result = new int[p];
System.arraycopy(weight, 0, result, 0, p);
return result;
}
public int size() {
return p;
}
}
////////////////////////////////
// Atcoder Library for Java //
////////////////////////////////
static class MathLib {
private static long safe_mod(long x, long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
private static long[] inv_gcd(long a, long b) {
a = safe_mod(a, b);
if (a == 0)
return new long[] { b, 0 };
long s = b, t = a;
long m0 = 0, m1 = 1;
while (t > 0) {
long u = s / t;
s -= t * u;
m0 -= m1 * u;
long tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 < 0)
m0 += b / s;
return new long[] { s, m0 };
}
public static long gcd(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return inv_gcd(a, b)[0];
}
public static long lcm(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return a / gcd(a, b) * b;
}
public static long pow_mod(long x, long n, int m) {
assert n >= 0;
assert m >= 1;
if (m == 1)
return 0L;
x = safe_mod(x, m);
long ans = 1L;
while (n > 0) {
if ((n & 1) == 1)
ans = (ans * x) % m;
x = (x * x) % m;
n >>>= 1;
}
return ans;
}
public static long[] crt(long[] r, long[] m) {
assert (r.length == m.length);
int n = r.length;
long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert (1 <= m[i]);
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
long tmp = r0;
r0 = r1;
r1 = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return new long[] { 0, 0 };
continue;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1 / g;
if ((r1 - r0) % g != 0)
return new long[] { 0, 0 };
long x = (r1 - r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if (r0 < 0)
r0 += m0;
// System.err.printf("%d %d\n", r0, m0);
}
return new long[] { r0, m0 };
}
public static long floor_sum(long n, long m, long a, long b) {
long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long y_max = (a * n + b) / m;
long x_max = y_max * m - b;
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
public static java.util.ArrayList<Long> divisors(long n) {
java.util.ArrayList<Long> divisors = new ArrayList<>();
java.util.ArrayList<Long> large = new ArrayList<>();
for (long i = 1; i * i <= n; i++)
if (n % i == 0) {
divisors.add(i);
if (i * i < n)
large.add(n / i);
}
for (int p = large.size() - 1; p >= 0; p--) {
divisors.add(large.get(p));
}
return divisors;
}
}
static class Multiset<T> extends java.util.TreeMap<T, Long> {
public Multiset() {
super();
}
public Multiset(java.util.List<T> list) {
super();
for (T e : list)
this.addOne(e);
}
public long count(Object elm) {
return getOrDefault(elm, 0L);
}
public void add(T elm, long amount) {
if (!this.containsKey(elm))
put(elm, amount);
else
replace(elm, get(elm) + amount);
if (this.count(elm) == 0)
this.remove(elm);
}
public void addOne(T elm) {
this.add(elm, 1);
}
public void removeOne(T elm) {
this.add(elm, -1);
}
public void removeAll(T elm) {
this.add(elm, -this.count(elm));
}
public static <T> Multiset<T> merge(Multiset<T> a, Multiset<T> b) {
Multiset<T> c = new Multiset<>();
for (T x : a.keySet())
c.add(x, a.count(x));
for (T y : b.keySet())
c.add(y, b.count(y));
return c;
}
}
static class GraphBuilder {
public static int[][] makeGraph(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][] graph = new int[NumberOfNodes][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = to[i];
if (undirected)
graph[to[i]][--outdegree[to[i]]] = from[i];
}
return graph;
}
public static int[][][] makeGraphWithWeight(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i] };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i] };
}
return graph;
}
public static int[][][] makeGraphWithEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], i, 1 };
}
return graph;
}
public static int[][][] makeGraphWithWeightAndEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from,
int[] to, int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i], i, 1 };
}
return graph;
}
}
static class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
static class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
private ArrayList<Integer> factorial_inversion;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
this.factorial_inversion = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0)
value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max) {
factorial.ensureCapacity(max + 1);
if (factorial.size() == 0)
factorial.add(1);
for (int i = factorial.size(); i <= max; i++) {
factorial.add(ma.mul(factorial.get(i - 1), i));
}
}
public ModInt factorial(int i) {
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(ma.mul(factorial.get(n), factorial_inversion.get(n - r)));
}
return create(ma.div(factorial.get(n), factorial.get(n - r)));
}
public ModInt combination(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(
ma.mul(factorial.get(n), ma.mul(factorial_inversion.get(n - r), factorial_inversion.get(r))));
}
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r), factorial.get(n - r))));
}
public void prepareFactorialInv(int max) {
prepareFactorial(max);
factorial_inversion.ensureCapacity(max + 1);
for (int i = factorial_inversion.size(); i <= max; i++) {
factorial_inversion.add(ma.inv(factorial.get(i)));
}
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (ma instanceof ModArithmetic.ModArithmeticMontgomery) {
return ((ModArithmetic.ModArithmeticMontgomery) ma).reduce(value);
}
return value;
}
public ModInt add(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis)
mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis)
mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis)
addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis)
mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1)
return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
long tmp2 = u;
u = v;
v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0)
throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1)
r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {
return 1;
}
int remainder(long value) {
return 0;
}
int add(int a, int b) {
return 0;
}
int sub(int a, int b) {
return 0;
}
int mul(int a, int b) {
return 0;
}
int pow(int a, long b) {
return 0;
}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {
return 2;
}
int remainder(long value) {
return (int) (value & 1);
}
int add(int a, int b) {
return a ^ b;
}
int sub(int a, int b) {
return a ^ b;
}
int mul(int a, int b) {
return a & b;
}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = (x + ((x * negInv) & 0xffff_ffffl) * mod) >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(int mod) {
super(mod);
/**
* m = floor(2^64/mod) 2^64 = p*mod + q, 2^32 = a*mod + b => (a*mod + b)^2 =
* p*mod + q => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long x) {
long z = (x & mask) * ml;
z = (x & mask) * mh + (x >>> 32) * ml + (z >>> 32);
z = (x >>> 32) * mh + (z >>> 32);
x -= z * mod;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
static class Convolution {
/**
* Find a primitive root.
*
* @param m A prime number.
* @return Primitive root.
*/
private static int primitiveRoot(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int[] divs = new int[20];
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long) (i) * i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
boolean ok = true;
for (int i = 0; i < cnt; i++) {
if (pow(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
/**
* Power.
*
* @param x Parameter x.
* @param n Parameter n.
* @param m Mod.
* @return n-th power of x mod m.
*/
private static long pow(long x, long n, int m) {
if (m == 1)
return 0;
long r = 1;
long y = x % m;
while (n > 0) {
if ((n & 1) != 0)
r = (r * y) % m;
y = (y * y) % m;
n >>= 1;
}
return r;
}
/**
* Ceil of power 2.
*
* @param n Value.
* @return Ceil of power 2.
*/
private static int ceilPow2(int n) {
int x = 0;
while ((1L << x) < n)
x++;
return x;
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static long garner(long[] c, int[] mods) {
int n = c.length + 1;
long[] cnst = new long[n];
long[] coef = new long[n];
java.util.Arrays.fill(coef, 1);
for (int i = 0; i < n - 1; i++) {
int m1 = mods[i];
long v = (c[i] - cnst[i] + m1) % m1;
v = v * pow(coef[i], m1 - 2, m1) % m1;
for (int j = i + 1; j < n; j++) {
long m2 = mods[j];
cnst[j] = (cnst[j] + coef[j] * v) % m2;
coef[j] = (coef[j] * m1) % m2;
}
}
return cnst[n - 1];
}
/**
* Pre-calculation for NTT.
*
* @param mod NTT Prime.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumE(int mod, int g) {
long[] sum_e = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now % mod;
now = now * ies[i] % mod;
}
return sum_e;
}
/**
* Pre-calculation for inverse NTT.
*
* @param mod Mod.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumIE(int mod, int g) {
long[] sum_ie = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now % mod;
now = now * es[i] % mod;
}
return sum_ie;
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterflyInv(long[] a, long[] sumIE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p];
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (mod + l - r) * inow % mod;
}
int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % mod;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly(long[] a, long[] sumE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p] * now % mod;
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (l - r + mod) % mod;
}
int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % mod;
}
}
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
public static long[] convolution(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int z = 1 << ceilPow2(n + m - 1);
{
long[] na = new long[z];
long[] nb = new long[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
int g = primitiveRoot(mod);
long[] sume = sumE(mod, g);
long[] sumie = sumIE(mod, g);
butterfly(a, sume, mod);
butterfly(b, sume, mod);
for (int i = 0; i < z; i++) {
a[i] = a[i] * b[i] % mod;
}
butterflyInv(a, sumie, mod);
a = java.util.Arrays.copyOf(a, n + m - 1);
long iz = pow(z, mod - 2, mod);
for (int i = 0; i < n + m - 1; i++)
a[i] = a[i] * iz % mod;
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static long[] convolutionLL(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int mod1 = 754974721;
int mod2 = 167772161;
int mod3 = 469762049;
long[] c1 = convolution(a, b, mod1);
long[] c2 = convolution(a, b, mod2);
long[] c3 = convolution(a, b, mod3);
int retSize = c1.length;
long[] ret = new long[retSize];
int[] mods = { mod1, mod2, mod3, mod };
for (int i = 0; i < retSize; ++i) {
ret[i] = garner(new long[] { c1[i], c2[i], c3[i] }, mods);
}
return ret;
}
/**
* Convolution by ModInt.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
public static java.util.List<ModIntFactory.ModInt> convolution(java.util.List<ModIntFactory.ModInt> a,
java.util.List<ModIntFactory.ModInt> b) {
int mod = a.get(0).mod();
long[] va = a.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] vb = b.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] c = convolutionLL(va, vb, mod);
ModIntFactory factory = new ModIntFactory(mod);
return java.util.Arrays.stream(c).mapToObj(factory::create).collect(java.util.stream.Collectors.toList());
}
/**
* Naive convolution. (Complexity is O(N^2)!!)
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Mod.
* @return Answer.
*/
public static long[] convolutionNaive(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
int k = n + m - 1;
long[] ret = new long[k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret[i + j] += a[i] * b[j] % mod;
ret[i + j] %= mod;
}
}
return ret;
}
}
static class SCC {
static class Edge {
int from, to;
public Edge(int from, int to) {
this.from = from;
this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(int i) {
if (!hasBuilt) {
throw new UnsupportedOperationException("Graph hasn't been built.");
}
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0)
continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
long p = stack[--ptr];
// vertex
int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j-- > 0) {
int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u)
low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u)
break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
int[] counts = new int[groupNum];
for (int x : ids)
counts[x]++;
int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
static class ContestScanner {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
public ContestScanner(java.io.InputStream in) {
this.in = in;
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit));
}
n = n * 10 + digit;
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long[] nextLongArray(int length) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = this.nextLong();
return array;
}
public long[] nextLongArray(int length, java.util.function.LongUnaryOperator map) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsLong(this.nextLong());
return array;
}
public int[] nextIntArray(int length) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = this.nextInt();
return array;
}
public int[][] nextIntArrayMulti(int length, int width) {
int[][] arrays = new int[width][length];
for (int i = 0; i < length; i++) {
for (int j = 0; j < width; j++)
arrays[j][i] = this.nextInt();
}
return arrays;
}
public int[] nextIntArray(int length, java.util.function.IntUnaryOperator map) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsInt(this.nextInt());
return array;
}
public double[] nextDoubleArray(int length) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = this.nextDouble();
return array;
}
public double[] nextDoubleArray(int length, java.util.function.DoubleUnaryOperator map) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
public long[][] nextLongMatrix(int height, int width) {
long[][] mat = new long[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextLong();
}
return mat;
}
public int[][] nextIntMatrix(int height, int width) {
int[][] mat = new int[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextInt();
}
return mat;
}
public double[][] nextDoubleMatrix(int height, int width) {
double[][] mat = new double[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextDouble();
}
return mat;
}
public char[][] nextCharMatrix(int height, int width) {
char[][] mat = new char[height][width];
for (int h = 0; h < height; h++) {
String s = this.next();
for (int w = 0; w < width; w++) {
mat[h][w] = s.charAt(w);
}
}
return mat;
}
}
static class ContestPrinter extends java.io.PrintWriter {
public ContestPrinter(java.io.PrintStream stream) {
super(stream);
}
public ContestPrinter() {
super(System.out);
}
private static String dtos(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(dtos(f, 20));
}
@Override
public void println(float f) {
super.println(dtos(f, 20));
}
@Override
public void print(double d) {
super.print(dtos(d, 20));
}
@Override
public void println(double d) {
super.println(dtos(d, 20));
}
public void printArray(int[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n - 1]));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n - 1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
}
static class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
static class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id)
return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N)
Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N)
Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--)
push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk)
push(lk >> i);
if (((rk >> i) << i) != rk)
push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r)
return E;
l += N;
r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1)
sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1)
sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1;
r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r)
return;
l += N;
r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N)
Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N)
Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1;
r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id)
continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N)
simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N)
simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N)
return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static class MaxFlow {
private static final class InternalCapEdge {
final int to;
final int rev;
long cap;
InternalCapEdge(int to, int rev, long cap) {
this.to = to;
this.rev = rev;
this.cap = cap;
}
}
public static final class CapEdge {
public final int from, to;
public final long cap, flow;
CapEdge(int from, int to, long cap, long flow) {
this.from = from;
this.to = to;
this.cap = cap;
this.flow = flow;
}
@Override
public boolean equals(Object o) {
if (o instanceof CapEdge) {
CapEdge e = (CapEdge) o;
return from == e.from && to == e.to && cap == e.cap && flow == e.flow;
}
return false;
}
}
private static final class IntPair {
final int first, second;
IntPair(int first, int second) {
this.first = first;
this.second = second;
}
}
static final long INF = Long.MAX_VALUE;
private final int n;
private final java.util.ArrayList<IntPair> pos;
private final java.util.ArrayList<InternalCapEdge>[] g;
@SuppressWarnings("unchecked")
public MaxFlow(int n) {
this.n = n;
this.pos = new java.util.ArrayList<>();
this.g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
this.g[i] = new java.util.ArrayList<>();
}
}
public int addEdge(int from, int to, long cap) {
rangeCheck(from, 0, n);
rangeCheck(to, 0, n);
nonNegativeCheck(cap, "Capacity");
int m = pos.size();
pos.add(new IntPair(from, g[from].size()));
int fromId = g[from].size();
int toId = g[to].size();
if (from == to)
toId++;
g[from].add(new InternalCapEdge(to, toId, cap));
g[to].add(new InternalCapEdge(from, fromId, 0L));
return m;
}
private InternalCapEdge getInternalEdge(int i) {
return g[pos.get(i).first].get(pos.get(i).second);
}
private InternalCapEdge getInternalEdgeReversed(InternalCapEdge e) {
return g[e.to].get(e.rev);
}
public CapEdge getEdge(int i) {
int m = pos.size();
rangeCheck(i, 0, m);
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
return new CapEdge(re.to, e.to, e.cap + re.cap, re.cap);
}
public CapEdge[] getEdges() {
CapEdge[] res = new CapEdge[pos.size()];
java.util.Arrays.setAll(res, this::getEdge);
return res;
}
public void changeEdge(int i, long newCap, long newFlow) {
int m = pos.size();
rangeCheck(i, 0, m);
nonNegativeCheck(newCap, "Capacity");
if (newFlow > newCap) {
throw new IllegalArgumentException(
String.format("Flow %d is greater than the capacity %d.", newCap, newFlow));
}
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
e.cap = newCap - newFlow;
re.cap = newFlow;
}
public long maxFlow(int s, int t) {
return flow(s, t, INF);
}
public long flow(int s, int t, long flowLimit) {
rangeCheck(s, 0, n);
rangeCheck(t, 0, n);
long flow = 0L;
int[] level = new int[n];
int[] que = new int[n];
int[] iter = new int[n];
while (flow < flowLimit) {
bfs(s, t, level, que);
if (level[t] < 0)
break;
java.util.Arrays.fill(iter, 0);
while (flow < flowLimit) {
long d = dfs(t, s, flowLimit - flow, iter, level);
if (d == 0)
break;
flow += d;
}
}
return flow;
}
private void bfs(int s, int t, int[] level, int[] que) {
java.util.Arrays.fill(level, -1);
int hd = 0, tl = 0;
que[tl++] = s;
level[s] = 0;
while (hd < tl) {
int u = que[hd++];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap == 0 || level[v] >= 0)
continue;
level[v] = level[u] + 1;
if (v == t)
return;
que[tl++] = v;
}
}
}
private long dfs(int cur, int s, long flowLimit, int[] iter, int[] level) {
if (cur == s)
return flowLimit;
long res = 0;
int curLevel = level[cur];
for (int itMax = g[cur].size(); iter[cur] < itMax; iter[cur]++) {
int i = iter[cur];
InternalCapEdge e = g[cur].get(i);
InternalCapEdge re = getInternalEdgeReversed(e);
if (curLevel <= level[e.to] || re.cap == 0)
continue;
long d = dfs(e.to, s, Math.min(flowLimit - res, re.cap), iter, level);
if (d <= 0)
continue;
e.cap += d;
re.cap -= d;
res += d;
if (res == flowLimit)
break;
}
return res;
}
public boolean[] minCut(int s) {
rangeCheck(s, 0, n);
boolean[] visited = new boolean[n];
int[] stack = new int[n];
int ptr = 0;
stack[ptr++] = s;
visited[s] = true;
while (ptr > 0) {
int u = stack[--ptr];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap > 0 && !visited[v]) {
visited[v] = true;
stack[ptr++] = v;
}
}
}
return visited;
}
private void rangeCheck(int i, int minInclusive, int maxExclusive) {
if (i < 0 || i >= maxExclusive) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, maxExclusive));
}
}
private void nonNegativeCheck(long cap, String attribute) {
if (cap < 0) {
throw new IllegalArgumentException(String.format("%s %d is negative.", attribute, cap));
}
}
}
static class StringAlgorithm {
private static int[] saNaive(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
insertionsortUsingComparator(sa, (l, r) -> {
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] - s[r];
l++;
r++;
}
return -(l - r);
});
return sa;
}
public static int[] saDoubling(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
int[] rnk = java.util.Arrays.copyOf(s, n);
int[] tmp = new int[n];
for (int k = 1; k < n; k *= 2) {
final int _k = k;
final int[] _rnk = rnk;
java.util.function.IntBinaryOperator cmp = (x, y) -> {
if (_rnk[x] != _rnk[y])
return _rnk[x] - _rnk[y];
int rx = x + _k < n ? _rnk[x + _k] : -1;
int ry = y + _k < n ? _rnk[y + _k] : -1;
return rx - ry;
};
mergesortUsingComparator(sa, cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp.applyAsInt(sa[i - 1], sa[i]) < 0 ? 1 : 0);
}
int[] buf = tmp;
tmp = rnk;
rnk = buf;
}
return sa;
}
private static void insertionsortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
for (int i = 1; i < n; i++) {
final int tmp = a[i];
if (comparator.applyAsInt(a[i - 1], tmp) > 0) {
int j = i;
do {
a[j] = a[j - 1];
j--;
} while (j > 0 && comparator.applyAsInt(a[j - 1], tmp) > 0);
a[j] = tmp;
}
}
}
private static void mergesortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
final int[] work = new int[n];
for (int block = 1; block <= n; block <<= 1) {
final int block2 = block << 1;
for (int l = 0, max = n - block; l < max; l += block2) {
int m = l + block;
int r = Math.min(l + block2, n);
System.arraycopy(a, l, work, 0, block);
for (int i = l, wi = 0, ti = m;; i++) {
if (ti == r) {
System.arraycopy(work, wi, a, i, block - wi);
break;
}
if (comparator.applyAsInt(work[wi], a[ti]) > 0) {
a[i] = a[ti++];
} else {
a[i] = work[wi++];
if (wi == block)
break;
}
}
}
}
}
private static final int THRESHOLD_NAIVE = 50;
// private static final int THRESHOLD_DOUBLING = 0;
private static int[] sais(int[] s, int upper) {
int n = s.length;
if (n == 0)
return new int[0];
if (n == 1)
return new int[] { 0 };
if (n == 2) {
if (s[0] < s[1]) {
return new int[] { 0, 1 };
} else {
return new int[] { 1, 0 };
}
}
if (n < THRESHOLD_NAIVE) {
return saNaive(s);
}
// if (n < THRESHOLD_DOUBLING) {
// return saDoubling(s);
// }
int[] sa = new int[n];
boolean[] ls = new boolean[n];
for (int i = n - 2; i >= 0; i--) {
ls[i] = s[i] == s[i + 1] ? ls[i + 1] : s[i] < s[i + 1];
}
int[] sumL = new int[upper + 1];
int[] sumS = new int[upper + 1];
for (int i = 0; i < n; i++) {
if (ls[i]) {
sumL[s[i] + 1]++;
} else {
sumS[s[i]]++;
}
}
for (int i = 0; i <= upper; i++) {
sumS[i] += sumL[i];
if (i < upper)
sumL[i + 1] += sumS[i];
}
java.util.function.Consumer<int[]> induce = lms -> {
java.util.Arrays.fill(sa, -1);
int[] buf = new int[upper + 1];
System.arraycopy(sumS, 0, buf, 0, upper + 1);
for (int d : lms) {
if (d == n)
continue;
sa[buf[s[d]]++] = d;
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
for (int i = n - 1; i >= 0; i--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
int[] lmsMap = new int[n + 1];
java.util.Arrays.fill(lmsMap, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lmsMap[i] = m++;
}
}
int[] lms = new int[m];
{
int p = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms[p++] = i;
}
}
}
induce.accept(lms);
if (m > 0) {
int[] sortedLms = new int[m];
{
int p = 0;
for (int v : sa) {
if (lmsMap[v] != -1) {
sortedLms[p++] = v;
}
}
}
int[] recS = new int[m];
int recUpper = 0;
recS[lmsMap[sortedLms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sortedLms[i - 1], r = sortedLms[i];
int endL = (lmsMap[l] + 1 < m) ? lms[lmsMap[l] + 1] : n;
int endR = (lmsMap[r] + 1 < m) ? lms[lmsMap[r] + 1] : n;
boolean same = true;
if (endL - l != endR - r) {
same = false;
} else {
while (l < endL && s[l] == s[r]) {
l++;
r++;
}
if (l == n || s[l] != s[r])
same = false;
}
if (!same) {
recUpper++;
}
recS[lmsMap[sortedLms[i]]] = recUpper;
}
int[] recSA = sais(recS, recUpper);
for (int i = 0; i < m; i++) {
sortedLms[i] = lms[recSA[i]];
}
induce.accept(sortedLms);
}
return sa;
}
public static int[] suffixArray(int[] s, int upper) {
assert (0 <= upper);
for (int d : s) {
assert (0 <= d && d <= upper);
}
return sais(s, upper);
}
public static int[] suffixArray(int[] s) {
int n = s.length;
int[] vals = Arrays.copyOf(s, n);
java.util.Arrays.sort(vals);
int p = 1;
for (int i = 1; i < n; i++) {
if (vals[i] != vals[i - 1]) {
vals[p++] = vals[i];
}
}
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = java.util.Arrays.binarySearch(vals, 0, p, s[i]);
}
return sais(s2, p);
}
public static int[] suffixArray(char[] s) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return sais(s2, 255);
}
public static int[] suffixArray(java.lang.String s) {
return suffixArray(s.toCharArray());
}
public static int[] lcpArray(int[] s, int[] sa) {
int n = s.length;
assert (n >= 1);
int[] rnk = new int[n];
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
int[] lcp = new int[n - 1];
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0)
h--;
if (rnk[i] == 0) {
continue;
}
int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
public static int[] lcpArray(char[] s, int[] sa) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcpArray(s2, sa);
}
public static int[] lcpArray(java.lang.String s, int[] sa) {
return lcpArray(s.toCharArray(), sa);
}
public static int[] zAlgorithm(int[] s) {
int n = s.length;
if (n == 0)
return new int[0];
int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
z[i] = k;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(char[] s) {
int n = s.length;
if (n == 0)
return new int[0];
int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
z[i] = k;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(String s) {
return zAlgorithm(s.toCharArray());
}
}
}
import java.util.*;
public class Main {
public static final int MOD998 = 998244353;
public static final int MOD100 = 1000000007;
public static void main(String[] args) throws Exception {
ContestScanner sc = new ContestScanner();
ContestPrinter cp = new ContestPrinter();
long X = sc.nextLong();
long Y = sc.nextLong();
long A = sc.nextLong();
long B = sc.nextLong();
long C = sc.nextLong();
boolean ans = false;
ans = ans || placeTwo(X, Y - (A + X - 1) / X, B, C);
ans = ans || placeTwo(X - (A + Y - 1) / Y, Y, B, C);
ans = ans || placeTwo(X, Y - (B + X - 1) / X, A, C);
ans = ans || placeTwo(X - (B + Y - 1) / Y, Y, A, C);
ans = ans || placeTwo(X, Y - (C + X - 1) / X, B, A);
ans = ans || placeTwo(X - (C + Y - 1) / Y, Y, B, A);
cp.println(ans ? "Yes" : "No");
cp.close();
}
static boolean placeTwo(long x, long y, long a, long b) {
if (x <= 0 || y <= 0) {
return false;
}
return (a + x - 1) / x + (b + x - 1) / x <= y || (a + y - 1) / y + (b + y - 1) / y <= x;
}
//////////////////
// My Library //
//////////////////
public static class SlopeTrick {
private PriorityQueue<Long> lq = new PriorityQueue<>(Comparator.reverseOrder());
private PriorityQueue<Long> rq = new PriorityQueue<>();
private long lshift = 0;
private long rshift = 0;
private long min = 0;
public long getMin() {
return min;
}
public long get(long x) {
long val = min;
for (long l : lq) {
if (l - x > 0) {
val += l - x;
}
}
for (long r : rq) {
if (x - r > 0) {
val += x - r;
}
}
return val;
}
public long getMinPosLeft() {
return lq.isEmpty() ? Long.MIN_VALUE : lq.peek() + lshift;
}
public long getMinPosRight() {
return rq.isEmpty() ? Long.MAX_VALUE : rq.peek() + rshift;
}
public void addConst(long a) {
min += a;
}
public void addSlopeRight(long a) {
if (!lq.isEmpty() && lq.peek() + lshift > a) {
min += lq.peek() + lshift - a;
lq.add(a - lshift);
rq.add(lq.poll() + lshift - rshift);
} else {
rq.add(a - rshift);
}
}
public void addSlopeLeft(long a) {
if (!rq.isEmpty() && rq.peek() < a) {
min += a - rq.peek() - rshift;
rq.add(a - rshift);
lq.add(rq.poll() + rshift - lshift);
} else {
lq.add(a - lshift);
}
}
public void addAbs(long a) {
addSlopeLeft(a);
addSlopeRight(a);
}
public void shift(long a) {
lshift += a;
rshift += a;
}
public void slideLeft(long a) {
lshift += a;
}
public void slideRight(long a) {
rshift += a;
}
public void clearLeft() {
lq.clear();
}
public void clearRight() {
rq.clear();
}
public void clearMin() {
min = 0;
}
}
public static int zeroOneBFS(int[][][] weighted_graph, int start, int goal) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
if (now == goal) {
return dist[goal];
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return -1;
}
public static int[] zeroOneBFSAll(int[][][] weighted_graph, int start) {
int[] dist = new int[weighted_graph.length];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[start] = 0;
LinkedList<Integer> queue = new LinkedList<>();
queue.add(start);
while (!queue.isEmpty()) {
int now = queue.poll();
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
if (info[1] == 0) {
queue.addFirst(info[0]);
} else {
queue.addLast(info[0]);
}
}
}
}
return dist;
}
public static long dijkstra(int[][][] weighted_graph, int start, int goal) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (now == goal) {
return dist[goal];
}
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return -1;
}
public static long[] dijkstraAll(int[][][] weighted_graph, int start) {
long[] dist = new long[weighted_graph.length];
Arrays.fill(dist, 0, dist.length, Long.MAX_VALUE);
dist[start] = 0;
PriorityQueue<Pair<Integer, Long>> unsettled = new PriorityQueue<>((u, v) -> (int) (u.cdr - v.cdr));
unsettled.offer(new Pair<Integer, Long>(start, 0L));
while (!unsettled.isEmpty()) {
Pair<Integer, Long> pair = unsettled.poll();
int now = pair.car;
if (dist[now] < pair.cdr) {
continue;
}
for (int[] info : weighted_graph[now]) {
if (dist[info[0]] > dist[now] + info[1]) {
dist[info[0]] = dist[now] + info[1];
unsettled.offer(new Pair<Integer, Long>(info[0], dist[info[0]]));
}
}
}
return dist;
}
public static long countLatticePoint(int[] p1, int[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
public static long countLatticePoint(long[] p1, long[] p2, boolean include_end) {
long difx = p2[0] - p1[0];
long dify = p2[1] - p1[1];
if (difx == 0 && dify == 0) {
return include_end ? 1 : 0;
}
if (difx == 0 || dify == 0) {
return Math.abs(difx + dify) + (include_end ? 1 : -1);
}
return MathLib.gcd(difx, dify) + (include_end ? 1 : -1);
}
// Don't contain same points!
public static long countLatticePoint(int[] p1, int[] p2, int[] p3, boolean include_edge) {
int[][] arr = new int[][] { p1, p2, p3 };
Arrays.sort(arr, Comparator.comparingInt(p -> ((int[]) p)[0]).thenComparingInt(p -> ((int[]) p)[1]));
if ((p2[0] - p1[0]) * (long) (p3[1] - p2[1]) == (p2[1] - p1[1]) * (long) (p3[0] - p2[0])) {
return countLatticePoint(arr[0], arr[2], true) - (include_edge ? 0 : 3);
}
long b = countLatticePoint(p1, p2, true) + countLatticePoint(p2, p3, true) + countLatticePoint(p3, p1, true)
- 3;
long i = (getAreaTriangle(p1, p2, p3) - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static long getAreaTriangle(int[] p1, int[] p2, int[] p3) {
int x1 = p2[0] - p1[0];
int x2 = p3[0] - p2[0];
int y1 = p2[1] - p1[1];
int y2 = p3[1] - p2[1];
return Math.abs((long) x1 * y2 - (long) x2 * y1);
}
// Don't contain same points!
public static long countLatticePointConvex(int[][] points, boolean include_edge) {
if (points.length == 1) {
return include_edge ? 1 : 0;
}
if (points.length == 2) {
return countLatticePoint(points[0], points[1], include_edge);
}
long s = 0;
for (int n = 1; n < points.length - 1; n++) {
s += getAreaTriangle(points[0], points[n], points[n + 1]);
}
long b = countLatticePoint(points[points.length - 1], points[0], true) - points.length;
for (int n = 0; n < points.length - 1; n++) {
b += countLatticePoint(points[n], points[n + 1], true);
}
long i = (s - b) / 2 + 1;
return include_edge ? i + b : i;
}
public static class RationalAngle implements Comparable<RationalAngle> {
public long x;
public long y;
public static boolean include_pi_to_minus = true;
public RationalAngle(long x, long y) {
if (x == 0) {
this.x = x;
if (y == 0) {
throw new UnsupportedOperationException("Angle to (0, 0) is invalid.");
} else {
this.y = y > 0 ? 1 : -1;
}
} else if (y == 0) {
this.x = x > 0 ? 1 : -1;
this.y = 0;
} else {
long gcd = MathLib.gcd(x, y);
this.x = x / gcd;
this.y = y / gcd;
}
}
public RationalAngle copy() {
return new RationalAngle(x, y);
}
public RationalAngle add(RationalAngle a) {
RationalAngle res = copy();
res.addArg(a);
return res;
}
public void addArg(RationalAngle a) {
long nx = x * a.x - y * a.y;
long ny = y * a.x + x * a.y;
x = nx;
y = ny;
}
public RationalAngle sub(RationalAngle a) {
RationalAngle res = copy();
res.subArg(a);
return res;
}
public void subArg(RationalAngle a) {
long nx = x * a.x + y * a.y;
long ny = y * a.x - x * a.y;
x = nx;
y = ny;
}
public boolean equals(RationalAngle a) {
return x == a.x && y == a.y;
}
public boolean parallel(RationalAngle a) {
return x == a.x && y == a.y || x == -a.x && y == -a.y;
}
public int rotDirection(RationalAngle trg) {
if (parallel(trg)) {
return 0;
} else if (trg.sub(this).y > 0) {
return 1;
} else {
return -1;
}
}
public RationalAngle minus() {
return new RationalAngle(x, -y);
}
public RationalAngle rev() {
return new RationalAngle(-x, -y);
}
public double toRadian() {
return Math.atan2(y, x);
}
private int toQuad() {
if (x == 0) {
if (y > 0) {
return 2;
} else {
return -2;
}
} else if (x > 0) {
if (y == 0) {
return 0;
} else if (y > 0) {
return 1;
} else {
return -1;
}
} else {
if (y == 0) {
return include_pi_to_minus ? -4 : 4;
} else if (y > 0) {
return 3;
} else {
return -3;
}
}
}
@Override
public int compareTo(RationalAngle ra) {
if (ra == null) {
throw new NullPointerException();
}
int me = toQuad();
int you = ra.toQuad();
if (me > you) {
return 1;
} else if (me < you) {
return -1;
}
long sub = sub(ra).y;
if (sub == 0) {
return 0;
} else if (sub > 0) {
return 1;
} else {
return -1;
}
}
}
public static class Pair<A, B> {
public final A car;
public final B cdr;
public Pair(A car_, B cdr_) {
car = car_;
cdr = cdr_;
}
private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);
}
private static int hc(Object o) {
return o == null ? 0 : o.hashCode();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair))
return false;
Pair<?, ?> rhs = (Pair<?, ?>) o;
return eq(car, rhs.car) && eq(cdr, rhs.cdr);
}
@Override
public int hashCode() {
return hc(car) ^ hc(cdr);
}
}
public static class Tuple1<A> extends Pair<A, Object> {
public Tuple1(A a) {
super(a, null);
}
}
public static class Tuple2<A, B> extends Pair<A, Tuple1<B>> {
public Tuple2(A a, B b) {
super(a, new Tuple1<>(b));
}
}
public static class Tuple3<A, B, C> extends Pair<A, Tuple2<B, C>> {
public Tuple3(A a, B b, C c) {
super(a, new Tuple2<>(b, c));
}
}
public static class Tuple4<A, B, C, D> extends Pair<A, Tuple3<B, C, D>> {
public Tuple4(A a, B b, C c, D d) {
super(a, new Tuple3<>(b, c, d));
}
}
public static class Tuple5<A, B, C, D, E> extends Pair<A, Tuple4<B, C, D, E>> {
public Tuple5(A a, B b, C c, D d, E e) {
super(a, new Tuple4<>(b, c, d, e));
}
}
public static class PriorityQueueLogTime<T> {
private PriorityQueue<T> queue;
private Multiset<T> total;
private int size = 0;
public PriorityQueueLogTime() {
queue = new PriorityQueue<>();
total = new Multiset<>();
}
public PriorityQueueLogTime(Comparator<T> c) {
queue = new PriorityQueue<>(c);
total = new Multiset<>();
}
public void clear() {
queue.clear();
total.clear();
size = 0;
}
public boolean contains(T e) {
return total.count(e) > 0;
}
public boolean isEmpty() {
return size == 0;
}
public boolean offer(T e) {
total.addOne(e);
size++;
return queue.offer(e);
}
public T peek() {
if (total.isEmpty()) {
return null;
}
simplify();
return queue.peek();
}
public T poll() {
if (total.isEmpty()) {
return null;
}
simplify();
size--;
T res = queue.poll();
total.removeOne(res);
return res;
}
public void remove(T e) {
total.removeOne(e);
size--;
}
public int size() {
return size;
}
private void simplify() {
while (total.count(queue.peek()) == 0) {
queue.poll();
}
}
}
static int[][] scanGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 2);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraph(node, edge, arr[0], arr[1], undirected);
}
static int[][][] scanWeightedGraphOneIndexed(ContestScanner sc, int node, int edge, boolean undirected) {
int[][] arr = sc.nextIntArrayMulti(edge, 3);
for (int n = 0; n < edge; n++) {
arr[0][n]--;
arr[1][n]--;
}
return GraphBuilder.makeGraphWithWeight(node, edge, arr[0], arr[1], arr[2], undirected);
}
static class EdgeData {
private int capacity;
private int[] from, to, weight;
private int p = 0;
private boolean weighted;
public EdgeData(boolean weighted) {
this(weighted, 500000);
}
public EdgeData(boolean weighted, int initial_capacity) {
capacity = initial_capacity;
from = new int[capacity];
to = new int[capacity];
weight = new int[capacity];
this.weighted = weighted;
}
public void addEdge(int u, int v) {
if (weighted) {
System.err.println("The graph is weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
capacity *= 2;
}
from[p] = u;
to[p] = v;
p++;
}
public void addEdge(int u, int v, int w) {
if (!weighted) {
System.err.println("The graph is NOT weighted!");
return;
}
if (p == capacity) {
int[] newfrom = new int[capacity * 2];
int[] newto = new int[capacity * 2];
int[] newweight = new int[capacity * 2];
System.arraycopy(from, 0, newfrom, 0, capacity);
System.arraycopy(to, 0, newto, 0, capacity);
System.arraycopy(weight, 0, newweight, 0, capacity);
capacity *= 2;
}
from[p] = u;
to[p] = v;
weight[p] = w;
p++;
}
public int[] getFrom() {
int[] result = new int[p];
System.arraycopy(from, 0, result, 0, p);
return result;
}
public int[] getTo() {
int[] result = new int[p];
System.arraycopy(to, 0, result, 0, p);
return result;
}
public int[] getWeight() {
int[] result = new int[p];
System.arraycopy(weight, 0, result, 0, p);
return result;
}
public int size() {
return p;
}
}
////////////////////////////////
// Atcoder Library for Java //
////////////////////////////////
static class MathLib {
private static long safe_mod(long x, long m) {
x %= m;
if (x < 0)
x += m;
return x;
}
private static long[] inv_gcd(long a, long b) {
a = safe_mod(a, b);
if (a == 0)
return new long[] { b, 0 };
long s = b, t = a;
long m0 = 0, m1 = 1;
while (t > 0) {
long u = s / t;
s -= t * u;
m0 -= m1 * u;
long tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 < 0)
m0 += b / s;
return new long[] { s, m0 };
}
public static long gcd(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return inv_gcd(a, b)[0];
}
public static long lcm(long a, long b) {
a = java.lang.Math.abs(a);
b = java.lang.Math.abs(b);
return a / gcd(a, b) * b;
}
public static long pow_mod(long x, long n, int m) {
assert n >= 0;
assert m >= 1;
if (m == 1)
return 0L;
x = safe_mod(x, m);
long ans = 1L;
while (n > 0) {
if ((n & 1) == 1)
ans = (ans * x) % m;
x = (x * x) % m;
n >>>= 1;
}
return ans;
}
public static long[] crt(long[] r, long[] m) {
assert (r.length == m.length);
int n = r.length;
long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
assert (1 <= m[i]);
long r1 = safe_mod(r[i], m[i]), m1 = m[i];
if (m0 < m1) {
long tmp = r0;
r0 = r1;
r1 = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1)
return new long[] { 0, 0 };
continue;
}
long[] ig = inv_gcd(m0, m1);
long g = ig[0], im = ig[1];
long u1 = m1 / g;
if ((r1 - r0) % g != 0)
return new long[] { 0, 0 };
long x = (r1 - r0) / g % u1 * im % u1;
r0 += x * m0;
m0 *= u1;
if (r0 < 0)
r0 += m0;
// System.err.printf("%d %d\n", r0, m0);
}
return new long[] { r0, m0 };
}
public static long floor_sum(long n, long m, long a, long b) {
long ans = 0;
if (a >= m) {
ans += (n - 1) * n * (a / m) / 2;
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
long y_max = (a * n + b) / m;
long x_max = y_max * m - b;
if (y_max == 0)
return ans;
ans += (n - (x_max + a - 1) / a) * y_max;
ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
return ans;
}
public static java.util.ArrayList<Long> divisors(long n) {
java.util.ArrayList<Long> divisors = new ArrayList<>();
java.util.ArrayList<Long> large = new ArrayList<>();
for (long i = 1; i * i <= n; i++)
if (n % i == 0) {
divisors.add(i);
if (i * i < n)
large.add(n / i);
}
for (int p = large.size() - 1; p >= 0; p--) {
divisors.add(large.get(p));
}
return divisors;
}
}
static class Multiset<T> extends java.util.TreeMap<T, Long> {
public Multiset() {
super();
}
public Multiset(java.util.List<T> list) {
super();
for (T e : list)
this.addOne(e);
}
public long count(Object elm) {
return getOrDefault(elm, 0L);
}
public void add(T elm, long amount) {
if (!this.containsKey(elm))
put(elm, amount);
else
replace(elm, get(elm) + amount);
if (this.count(elm) == 0)
this.remove(elm);
}
public void addOne(T elm) {
this.add(elm, 1);
}
public void removeOne(T elm) {
this.add(elm, -1);
}
public void removeAll(T elm) {
this.add(elm, -this.count(elm));
}
public static <T> Multiset<T> merge(Multiset<T> a, Multiset<T> b) {
Multiset<T> c = new Multiset<>();
for (T x : a.keySet())
c.add(x, a.count(x));
for (T y : b.keySet())
c.add(y, b.count(y));
return c;
}
}
static class GraphBuilder {
public static int[][] makeGraph(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][] graph = new int[NumberOfNodes][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = to[i];
if (undirected)
graph[to[i]][--outdegree[to[i]]] = from[i];
}
return graph;
}
public static int[][][] makeGraphWithWeight(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i] };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i] };
}
return graph;
}
public static int[][][] makeGraphWithEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from, int[] to,
boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], i, 1 };
}
return graph;
}
public static int[][][] makeGraphWithWeightAndEdgeInfo(int NumberOfNodes, int NumberOfEdges, int[] from,
int[] to, int[] weight, boolean undirected) {
int[][][] graph = new int[NumberOfNodes][][];
int[] outdegree = new int[NumberOfNodes];
for (int i = 0; i < NumberOfEdges; i++) {
outdegree[from[i]]++;
if (undirected)
outdegree[to[i]]++;
}
for (int i = 0; i < NumberOfNodes; i++)
graph[i] = new int[outdegree[i]][];
for (int i = 0; i < NumberOfEdges; i++) {
graph[from[i]][--outdegree[from[i]]] = new int[] { to[i], weight[i], i, 0 };
if (undirected)
graph[to[i]][--outdegree[to[i]]] = new int[] { from[i], weight[i], i, 1 };
}
return graph;
}
}
static class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y)
return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
static class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
private ArrayList<Integer> factorial_inversion;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
this.factorial_inversion = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0)
value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max) {
factorial.ensureCapacity(max + 1);
if (factorial.size() == 0)
factorial.add(1);
for (int i = factorial.size(); i <= max; i++) {
factorial.add(ma.mul(factorial.get(i - 1), i));
}
}
public ModInt factorial(int i) {
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(ma.mul(factorial.get(n), factorial_inversion.get(n - r)));
}
return create(ma.div(factorial.get(n), factorial.get(n - r)));
}
public ModInt combination(int n, int r) {
if (n < 0 || r < 0 || n < r)
return create(0);
prepareFactorial(n);
if (factorial_inversion.size() > n) {
return create(
ma.mul(factorial.get(n), ma.mul(factorial_inversion.get(n - r), factorial_inversion.get(r))));
}
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r), factorial.get(n - r))));
}
public void prepareFactorialInv(int max) {
prepareFactorial(max);
factorial_inversion.ensureCapacity(max + 1);
for (int i = factorial_inversion.size(); i <= max; i++) {
factorial_inversion.add(ma.inv(factorial.get(i)));
}
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (ma instanceof ModArithmetic.ModArithmeticMontgomery) {
return ((ModArithmetic.ModArithmeticMontgomery) ma).reduce(value);
}
return value;
}
public ModInt add(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis)
mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis)
mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis)
addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis)
mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1)
return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a;
a = b;
b = tmp1;
u -= t * v;
long tmp2 = u;
u = v;
v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0)
throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1)
r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {
return 1;
}
int remainder(long value) {
return 0;
}
int add(int a, int b) {
return 0;
}
int sub(int a, int b) {
return 0;
}
int mul(int a, int b) {
return 0;
}
int pow(int a, long b) {
return 0;
}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {
return 2;
}
int remainder(long value) {
return (int) (value & 1);
}
int add(int a, int b) {
return a ^ b;
}
int sub(int a, int b) {
return a ^ b;
}
int mul(int a, int b) {
return a & b;
}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = (x + ((x * negInv) & 0xffff_ffffl) * mod) >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(int mod) {
super(mod);
/**
* m = floor(2^64/mod) 2^64 = p*mod + q, 2^32 = a*mod + b => (a*mod + b)^2 =
* p*mod + q => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long x) {
long z = (x & mask) * ml;
z = (x & mask) * mh + (x >>> 32) * ml + (z >>> 32);
z = (x >>> 32) * mh + (z >>> 32);
x -= z * mod;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
static class Convolution {
/**
* Find a primitive root.
*
* @param m A prime number.
* @return Primitive root.
*/
private static int primitiveRoot(int m) {
if (m == 2)
return 1;
if (m == 167772161)
return 3;
if (m == 469762049)
return 3;
if (m == 754974721)
return 11;
if (m == 998244353)
return 3;
int[] divs = new int[20];
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0)
x /= 2;
for (int i = 3; (long) (i) * i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
boolean ok = true;
for (int i = 0; i < cnt; i++) {
if (pow(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok)
return g;
}
}
/**
* Power.
*
* @param x Parameter x.
* @param n Parameter n.
* @param m Mod.
* @return n-th power of x mod m.
*/
private static long pow(long x, long n, int m) {
if (m == 1)
return 0;
long r = 1;
long y = x % m;
while (n > 0) {
if ((n & 1) != 0)
r = (r * y) % m;
y = (y * y) % m;
n >>= 1;
}
return r;
}
/**
* Ceil of power 2.
*
* @param n Value.
* @return Ceil of power 2.
*/
private static int ceilPow2(int n) {
int x = 0;
while ((1L << x) < n)
x++;
return x;
}
/**
* Garner's algorithm.
*
* @param c Mod convolution results.
* @param mods Mods.
* @return Result.
*/
private static long garner(long[] c, int[] mods) {
int n = c.length + 1;
long[] cnst = new long[n];
long[] coef = new long[n];
java.util.Arrays.fill(coef, 1);
for (int i = 0; i < n - 1; i++) {
int m1 = mods[i];
long v = (c[i] - cnst[i] + m1) % m1;
v = v * pow(coef[i], m1 - 2, m1) % m1;
for (int j = i + 1; j < n; j++) {
long m2 = mods[j];
cnst[j] = (cnst[j] + coef[j] * v) % m2;
coef[j] = (coef[j] * m1) % m2;
}
}
return cnst[n - 1];
}
/**
* Pre-calculation for NTT.
*
* @param mod NTT Prime.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumE(int mod, int g) {
long[] sum_e = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_e[i] = es[i] * now % mod;
now = now * ies[i] % mod;
}
return sum_e;
}
/**
* Pre-calculation for inverse NTT.
*
* @param mod Mod.
* @param g Primitive root of mod.
* @return Pre-calculation table.
*/
private static long[] sumIE(int mod, int g) {
long[] sum_ie = new long[30];
long[] es = new long[30];
long[] ies = new long[30];
int cnt2 = Integer.numberOfTrailingZeros(mod - 1);
long e = pow(g, (mod - 1) >> cnt2, mod);
long ie = pow(e, mod - 2, mod);
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e;
ies[i - 2] = ie;
e = e * e % mod;
ie = ie * ie % mod;
}
long now = 1;
for (int i = 0; i < cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now % mod;
now = now * es[i] % mod;
}
return sum_ie;
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumIE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterflyInv(long[] a, long[] sumIE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = h; ph >= 1; ph--) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long inow = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p];
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (mod + l - r) * inow % mod;
}
int x = Integer.numberOfTrailingZeros(~s);
inow = inow * sumIE[x] % mod;
}
}
}
/**
* Inverse NTT.
*
* @param a Target array.
* @param sumE Pre-calculation table.
* @param mod NTT Prime.
*/
private static void butterfly(long[] a, long[] sumE, int mod) {
int n = a.length;
int h = ceilPow2(n);
for (int ph = 1; ph <= h; ph++) {
int w = 1 << (ph - 1), p = 1 << (h - ph);
long now = 1;
for (int s = 0; s < w; s++) {
int offset = s << (h - ph + 1);
for (int i = 0; i < p; i++) {
long l = a[i + offset];
long r = a[i + offset + p] * now % mod;
a[i + offset] = (l + r) % mod;
a[i + offset + p] = (l - r + mod) % mod;
}
int x = Integer.numberOfTrailingZeros(~s);
now = now * sumE[x] % mod;
}
}
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod NTT Prime.
* @return Answer.
*/
public static long[] convolution(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int z = 1 << ceilPow2(n + m - 1);
{
long[] na = new long[z];
long[] nb = new long[z];
System.arraycopy(a, 0, na, 0, n);
System.arraycopy(b, 0, nb, 0, m);
a = na;
b = nb;
}
int g = primitiveRoot(mod);
long[] sume = sumE(mod, g);
long[] sumie = sumIE(mod, g);
butterfly(a, sume, mod);
butterfly(b, sume, mod);
for (int i = 0; i < z; i++) {
a[i] = a[i] * b[i] % mod;
}
butterflyInv(a, sumie, mod);
a = java.util.Arrays.copyOf(a, n + m - 1);
long iz = pow(z, mod - 2, mod);
for (int i = 0; i < n + m - 1; i++)
a[i] = a[i] * iz % mod;
return a;
}
/**
* Convolution.
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Any mod.
* @return Answer.
*/
public static long[] convolutionLL(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
if (n == 0 || m == 0)
return new long[0];
int mod1 = 754974721;
int mod2 = 167772161;
int mod3 = 469762049;
long[] c1 = convolution(a, b, mod1);
long[] c2 = convolution(a, b, mod2);
long[] c3 = convolution(a, b, mod3);
int retSize = c1.length;
long[] ret = new long[retSize];
int[] mods = { mod1, mod2, mod3, mod };
for (int i = 0; i < retSize; ++i) {
ret[i] = garner(new long[] { c1[i], c2[i], c3[i] }, mods);
}
return ret;
}
/**
* Convolution by ModInt.
*
* @param a Target array 1.
* @param b Target array 2.
* @return Answer.
*/
public static java.util.List<ModIntFactory.ModInt> convolution(java.util.List<ModIntFactory.ModInt> a,
java.util.List<ModIntFactory.ModInt> b) {
int mod = a.get(0).mod();
long[] va = a.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] vb = b.stream().mapToLong(ModIntFactory.ModInt::value).toArray();
long[] c = convolutionLL(va, vb, mod);
ModIntFactory factory = new ModIntFactory(mod);
return java.util.Arrays.stream(c).mapToObj(factory::create).collect(java.util.stream.Collectors.toList());
}
/**
* Naive convolution. (Complexity is O(N^2)!!)
*
* @param a Target array 1.
* @param b Target array 2.
* @param mod Mod.
* @return Answer.
*/
public static long[] convolutionNaive(long[] a, long[] b, int mod) {
int n = a.length;
int m = b.length;
int k = n + m - 1;
long[] ret = new long[k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret[i + j] += a[i] * b[j] % mod;
ret[i + j] %= mod;
}
}
return ret;
}
}
static class SCC {
static class Edge {
int from, to;
public Edge(int from, int to) {
this.from = from;
this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(int i) {
if (!hasBuilt) {
throw new UnsupportedOperationException("Graph hasn't been built.");
}
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0)
continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
long p = stack[--ptr];
// vertex
int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j-- > 0) {
int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u)
low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u)
break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
int[] counts = new int[groupNum];
for (int x : ids)
counts[x]++;
int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, n));
}
}
}
static class ContestScanner {
private final java.io.InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private static final long LONG_MAX_TENTHS = 922337203685477580L;
private static final int LONG_MAX_LAST_DIGIT = 7;
private static final int LONG_MIN_LAST_DIGIT = 8;
public ContestScanner(java.io.InputStream in) {
this.in = in;
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (java.io.IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new java.util.NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext())
throw new java.util.NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
int digit = b - '0';
if (n >= LONG_MAX_TENTHS) {
if (n == LONG_MAX_TENTHS) {
if (minus) {
if (digit <= LONG_MIN_LAST_DIGIT) {
n = -n * 10 - digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
} else {
if (digit <= LONG_MAX_LAST_DIGIT) {
n = n * 10 + digit;
b = readByte();
if (!isPrintableChar(b)) {
return n;
} else if (b < '0' || '9' < b) {
throw new NumberFormatException(
String.format("%d%s... is not number", n, Character.toString(b)));
}
}
}
}
throw new ArithmeticException(
String.format("%s%d%d... overflows long.", minus ? "-" : "", n, digit));
}
n = n * 10 + digit;
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long[] nextLongArray(int length) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = this.nextLong();
return array;
}
public long[] nextLongArray(int length, java.util.function.LongUnaryOperator map) {
long[] array = new long[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsLong(this.nextLong());
return array;
}
public int[] nextIntArray(int length) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = this.nextInt();
return array;
}
public int[][] nextIntArrayMulti(int length, int width) {
int[][] arrays = new int[width][length];
for (int i = 0; i < length; i++) {
for (int j = 0; j < width; j++)
arrays[j][i] = this.nextInt();
}
return arrays;
}
public int[] nextIntArray(int length, java.util.function.IntUnaryOperator map) {
int[] array = new int[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsInt(this.nextInt());
return array;
}
public double[] nextDoubleArray(int length) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = this.nextDouble();
return array;
}
public double[] nextDoubleArray(int length, java.util.function.DoubleUnaryOperator map) {
double[] array = new double[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
public long[][] nextLongMatrix(int height, int width) {
long[][] mat = new long[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextLong();
}
return mat;
}
public int[][] nextIntMatrix(int height, int width) {
int[][] mat = new int[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextInt();
}
return mat;
}
public double[][] nextDoubleMatrix(int height, int width) {
double[][] mat = new double[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextDouble();
}
return mat;
}
public char[][] nextCharMatrix(int height, int width) {
char[][] mat = new char[height][width];
for (int h = 0; h < height; h++) {
String s = this.next();
for (int w = 0; w < width; w++) {
mat[h][w] = s.charAt(w);
}
}
return mat;
}
}
static class ContestPrinter extends java.io.PrintWriter {
public ContestPrinter(java.io.PrintStream stream) {
super(stream);
}
public ContestPrinter() {
super(System.out);
}
private static String dtos(double x, int n) {
StringBuilder sb = new StringBuilder();
if (x < 0) {
sb.append('-');
x = -x;
}
x += Math.pow(10, -n) / 2;
sb.append((long) x);
sb.append(".");
x -= (long) x;
for (int i = 0; i < n; i++) {
x *= 10;
sb.append((int) x);
x -= (int) x;
}
return sb.toString();
}
@Override
public void print(float f) {
super.print(dtos(f, 20));
}
@Override
public void println(float f) {
super.println(dtos(f, 20));
}
@Override
public void print(double d) {
super.print(dtos(d, 20));
}
@Override
public void println(double d) {
super.println(dtos(d, 20));
}
public void printArray(int[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(int[] array) {
this.printArray(array, " ");
}
public void printArray(int[] array, String separator, java.util.function.IntUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsInt(array[i]));
super.print(separator);
}
super.println(map.applyAsInt(array[n - 1]));
}
public void printArray(int[] array, java.util.function.IntUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(long[] array, String separator) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(array[i]);
super.print(separator);
}
super.println(array[n - 1]);
}
public void printArray(long[] array) {
this.printArray(array, " ");
}
public void printArray(long[] array, String separator, java.util.function.LongUnaryOperator map) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
super.print(map.applyAsLong(array[i]));
super.print(separator);
}
super.println(map.applyAsLong(array[n - 1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
}
static class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
static class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N;
r += N;
while (l < r) {
if ((l & 1) == 1)
sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1)
sumRight = op.apply(data[--r], sumRight);
l >>= 1;
r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N)
return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this.MAX = n;
int k = 1;
while (k < n)
k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e,
java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition,
F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id)
return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N)
Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N)
Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--)
push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk)
push(lk >> i);
if (((rk >> i) << i) != rk)
push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r)
return E;
l += N;
r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1)
sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1)
sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1;
r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(String.format("Invalid range: [%d, %d)", l, r));
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r)
return;
l += N;
r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N)
Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N)
Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1;
r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX)
return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0)
return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1)
r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d).", p, 0, MAX));
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(String.format("Index %d is not in [%d, %d].", p, 0, MAX));
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id)
continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N)
simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N)
simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N)
return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n-- > 0)
sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1)
sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
static class MaxFlow {
private static final class InternalCapEdge {
final int to;
final int rev;
long cap;
InternalCapEdge(int to, int rev, long cap) {
this.to = to;
this.rev = rev;
this.cap = cap;
}
}
public static final class CapEdge {
public final int from, to;
public final long cap, flow;
CapEdge(int from, int to, long cap, long flow) {
this.from = from;
this.to = to;
this.cap = cap;
this.flow = flow;
}
@Override
public boolean equals(Object o) {
if (o instanceof CapEdge) {
CapEdge e = (CapEdge) o;
return from == e.from && to == e.to && cap == e.cap && flow == e.flow;
}
return false;
}
}
private static final class IntPair {
final int first, second;
IntPair(int first, int second) {
this.first = first;
this.second = second;
}
}
static final long INF = Long.MAX_VALUE;
private final int n;
private final java.util.ArrayList<IntPair> pos;
private final java.util.ArrayList<InternalCapEdge>[] g;
@SuppressWarnings("unchecked")
public MaxFlow(int n) {
this.n = n;
this.pos = new java.util.ArrayList<>();
this.g = new java.util.ArrayList[n];
for (int i = 0; i < n; i++) {
this.g[i] = new java.util.ArrayList<>();
}
}
public int addEdge(int from, int to, long cap) {
rangeCheck(from, 0, n);
rangeCheck(to, 0, n);
nonNegativeCheck(cap, "Capacity");
int m = pos.size();
pos.add(new IntPair(from, g[from].size()));
int fromId = g[from].size();
int toId = g[to].size();
if (from == to)
toId++;
g[from].add(new InternalCapEdge(to, toId, cap));
g[to].add(new InternalCapEdge(from, fromId, 0L));
return m;
}
private InternalCapEdge getInternalEdge(int i) {
return g[pos.get(i).first].get(pos.get(i).second);
}
private InternalCapEdge getInternalEdgeReversed(InternalCapEdge e) {
return g[e.to].get(e.rev);
}
public CapEdge getEdge(int i) {
int m = pos.size();
rangeCheck(i, 0, m);
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
return new CapEdge(re.to, e.to, e.cap + re.cap, re.cap);
}
public CapEdge[] getEdges() {
CapEdge[] res = new CapEdge[pos.size()];
java.util.Arrays.setAll(res, this::getEdge);
return res;
}
public void changeEdge(int i, long newCap, long newFlow) {
int m = pos.size();
rangeCheck(i, 0, m);
nonNegativeCheck(newCap, "Capacity");
if (newFlow > newCap) {
throw new IllegalArgumentException(
String.format("Flow %d is greater than the capacity %d.", newCap, newFlow));
}
InternalCapEdge e = getInternalEdge(i);
InternalCapEdge re = getInternalEdgeReversed(e);
e.cap = newCap - newFlow;
re.cap = newFlow;
}
public long maxFlow(int s, int t) {
return flow(s, t, INF);
}
public long flow(int s, int t, long flowLimit) {
rangeCheck(s, 0, n);
rangeCheck(t, 0, n);
long flow = 0L;
int[] level = new int[n];
int[] que = new int[n];
int[] iter = new int[n];
while (flow < flowLimit) {
bfs(s, t, level, que);
if (level[t] < 0)
break;
java.util.Arrays.fill(iter, 0);
while (flow < flowLimit) {
long d = dfs(t, s, flowLimit - flow, iter, level);
if (d == 0)
break;
flow += d;
}
}
return flow;
}
private void bfs(int s, int t, int[] level, int[] que) {
java.util.Arrays.fill(level, -1);
int hd = 0, tl = 0;
que[tl++] = s;
level[s] = 0;
while (hd < tl) {
int u = que[hd++];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap == 0 || level[v] >= 0)
continue;
level[v] = level[u] + 1;
if (v == t)
return;
que[tl++] = v;
}
}
}
private long dfs(int cur, int s, long flowLimit, int[] iter, int[] level) {
if (cur == s)
return flowLimit;
long res = 0;
int curLevel = level[cur];
for (int itMax = g[cur].size(); iter[cur] < itMax; iter[cur]++) {
int i = iter[cur];
InternalCapEdge e = g[cur].get(i);
InternalCapEdge re = getInternalEdgeReversed(e);
if (curLevel <= level[e.to] || re.cap == 0)
continue;
long d = dfs(e.to, s, Math.min(flowLimit - res, re.cap), iter, level);
if (d <= 0)
continue;
e.cap += d;
re.cap -= d;
res += d;
if (res == flowLimit)
break;
}
return res;
}
public boolean[] minCut(int s) {
rangeCheck(s, 0, n);
boolean[] visited = new boolean[n];
int[] stack = new int[n];
int ptr = 0;
stack[ptr++] = s;
visited[s] = true;
while (ptr > 0) {
int u = stack[--ptr];
for (InternalCapEdge e : g[u]) {
int v = e.to;
if (e.cap > 0 && !visited[v]) {
visited[v] = true;
stack[ptr++] = v;
}
}
}
return visited;
}
private void rangeCheck(int i, int minInclusive, int maxExclusive) {
if (i < 0 || i >= maxExclusive) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, maxExclusive));
}
}
private void nonNegativeCheck(long cap, String attribute) {
if (cap < 0) {
throw new IllegalArgumentException(String.format("%s %d is negative.", attribute, cap));
}
}
}
static class StringAlgorithm {
private static int[] saNaive(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
insertionsortUsingComparator(sa, (l, r) -> {
while (l < n && r < n) {
if (s[l] != s[r])
return s[l] - s[r];
l++;
r++;
}
return -(l - r);
});
return sa;
}
public static int[] saDoubling(int[] s) {
int n = s.length;
int[] sa = new int[n];
for (int i = 0; i < n; i++) {
sa[i] = i;
}
int[] rnk = java.util.Arrays.copyOf(s, n);
int[] tmp = new int[n];
for (int k = 1; k < n; k *= 2) {
final int _k = k;
final int[] _rnk = rnk;
java.util.function.IntBinaryOperator cmp = (x, y) -> {
if (_rnk[x] != _rnk[y])
return _rnk[x] - _rnk[y];
int rx = x + _k < n ? _rnk[x + _k] : -1;
int ry = y + _k < n ? _rnk[y + _k] : -1;
return rx - ry;
};
mergesortUsingComparator(sa, cmp);
tmp[sa[0]] = 0;
for (int i = 1; i < n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (cmp.applyAsInt(sa[i - 1], sa[i]) < 0 ? 1 : 0);
}
int[] buf = tmp;
tmp = rnk;
rnk = buf;
}
return sa;
}
private static void insertionsortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
for (int i = 1; i < n; i++) {
final int tmp = a[i];
if (comparator.applyAsInt(a[i - 1], tmp) > 0) {
int j = i;
do {
a[j] = a[j - 1];
j--;
} while (j > 0 && comparator.applyAsInt(a[j - 1], tmp) > 0);
a[j] = tmp;
}
}
}
private static void mergesortUsingComparator(int[] a, java.util.function.IntBinaryOperator comparator) {
final int n = a.length;
final int[] work = new int[n];
for (int block = 1; block <= n; block <<= 1) {
final int block2 = block << 1;
for (int l = 0, max = n - block; l < max; l += block2) {
int m = l + block;
int r = Math.min(l + block2, n);
System.arraycopy(a, l, work, 0, block);
for (int i = l, wi = 0, ti = m;; i++) {
if (ti == r) {
System.arraycopy(work, wi, a, i, block - wi);
break;
}
if (comparator.applyAsInt(work[wi], a[ti]) > 0) {
a[i] = a[ti++];
} else {
a[i] = work[wi++];
if (wi == block)
break;
}
}
}
}
}
private static final int THRESHOLD_NAIVE = 50;
// private static final int THRESHOLD_DOUBLING = 0;
private static int[] sais(int[] s, int upper) {
int n = s.length;
if (n == 0)
return new int[0];
if (n == 1)
return new int[] { 0 };
if (n == 2) {
if (s[0] < s[1]) {
return new int[] { 0, 1 };
} else {
return new int[] { 1, 0 };
}
}
if (n < THRESHOLD_NAIVE) {
return saNaive(s);
}
// if (n < THRESHOLD_DOUBLING) {
// return saDoubling(s);
// }
int[] sa = new int[n];
boolean[] ls = new boolean[n];
for (int i = n - 2; i >= 0; i--) {
ls[i] = s[i] == s[i + 1] ? ls[i + 1] : s[i] < s[i + 1];
}
int[] sumL = new int[upper + 1];
int[] sumS = new int[upper + 1];
for (int i = 0; i < n; i++) {
if (ls[i]) {
sumL[s[i] + 1]++;
} else {
sumS[s[i]]++;
}
}
for (int i = 0; i <= upper; i++) {
sumS[i] += sumL[i];
if (i < upper)
sumL[i + 1] += sumS[i];
}
java.util.function.Consumer<int[]> induce = lms -> {
java.util.Arrays.fill(sa, -1);
int[] buf = new int[upper + 1];
System.arraycopy(sumS, 0, buf, 0, upper + 1);
for (int d : lms) {
if (d == n)
continue;
sa[buf[s[d]]++] = d;
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
sa[buf[s[n - 1]]++] = n - 1;
for (int i = 0; i < n; i++) {
int v = sa[i];
if (v >= 1 && !ls[v - 1]) {
sa[buf[s[v - 1]]++] = v - 1;
}
}
System.arraycopy(sumL, 0, buf, 0, upper + 1);
for (int i = n - 1; i >= 0; i--) {
int v = sa[i];
if (v >= 1 && ls[v - 1]) {
sa[--buf[s[v - 1] + 1]] = v - 1;
}
}
};
int[] lmsMap = new int[n + 1];
java.util.Arrays.fill(lmsMap, -1);
int m = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lmsMap[i] = m++;
}
}
int[] lms = new int[m];
{
int p = 0;
for (int i = 1; i < n; i++) {
if (!ls[i - 1] && ls[i]) {
lms[p++] = i;
}
}
}
induce.accept(lms);
if (m > 0) {
int[] sortedLms = new int[m];
{
int p = 0;
for (int v : sa) {
if (lmsMap[v] != -1) {
sortedLms[p++] = v;
}
}
}
int[] recS = new int[m];
int recUpper = 0;
recS[lmsMap[sortedLms[0]]] = 0;
for (int i = 1; i < m; i++) {
int l = sortedLms[i - 1], r = sortedLms[i];
int endL = (lmsMap[l] + 1 < m) ? lms[lmsMap[l] + 1] : n;
int endR = (lmsMap[r] + 1 < m) ? lms[lmsMap[r] + 1] : n;
boolean same = true;
if (endL - l != endR - r) {
same = false;
} else {
while (l < endL && s[l] == s[r]) {
l++;
r++;
}
if (l == n || s[l] != s[r])
same = false;
}
if (!same) {
recUpper++;
}
recS[lmsMap[sortedLms[i]]] = recUpper;
}
int[] recSA = sais(recS, recUpper);
for (int i = 0; i < m; i++) {
sortedLms[i] = lms[recSA[i]];
}
induce.accept(sortedLms);
}
return sa;
}
public static int[] suffixArray(int[] s, int upper) {
assert (0 <= upper);
for (int d : s) {
assert (0 <= d && d <= upper);
}
return sais(s, upper);
}
public static int[] suffixArray(int[] s) {
int n = s.length;
int[] vals = Arrays.copyOf(s, n);
java.util.Arrays.sort(vals);
int p = 1;
for (int i = 1; i < n; i++) {
if (vals[i] != vals[i - 1]) {
vals[p++] = vals[i];
}
}
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = java.util.Arrays.binarySearch(vals, 0, p, s[i]);
}
return sais(s2, p);
}
public static int[] suffixArray(char[] s) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return sais(s2, 255);
}
public static int[] suffixArray(java.lang.String s) {
return suffixArray(s.toCharArray());
}
public static int[] lcpArray(int[] s, int[] sa) {
int n = s.length;
assert (n >= 1);
int[] rnk = new int[n];
for (int i = 0; i < n; i++) {
rnk[sa[i]] = i;
}
int[] lcp = new int[n - 1];
int h = 0;
for (int i = 0; i < n; i++) {
if (h > 0)
h--;
if (rnk[i] == 0) {
continue;
}
int j = sa[rnk[i] - 1];
for (; j + h < n && i + h < n; h++) {
if (s[j + h] != s[i + h])
break;
}
lcp[rnk[i] - 1] = h;
}
return lcp;
}
public static int[] lcpArray(char[] s, int[] sa) {
int n = s.length;
int[] s2 = new int[n];
for (int i = 0; i < n; i++) {
s2[i] = s[i];
}
return lcpArray(s2, sa);
}
public static int[] lcpArray(java.lang.String s, int[] sa) {
return lcpArray(s.toCharArray(), sa);
}
public static int[] zAlgorithm(int[] s) {
int n = s.length;
if (n == 0)
return new int[0];
int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
z[i] = k;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(char[] s) {
int n = s.length;
if (n == 0)
return new int[0];
int[] z = new int[n];
for (int i = 1, j = 0; i < n; i++) {
int k = j + z[j] <= i ? 0 : Math.min(j + z[j] - i, z[i - j]);
while (i + k < n && s[k] == s[i + k])
k++;
z[i] = k;
if (j + z[j] < i + z[i])
j = i;
}
z[0] = n;
return z;
}
public static int[] zAlgorithm(String s) {
return zAlgorithm(s.toCharArray());
}
}
}
| ConDefects/ConDefects/Code/abc223_e/Java/26669422 |
condefects-java_data_1121 | import java.util.*;
class Main {
Scanner sc = new Scanner(System.in);
long X, Y, A, B, C;
String calc() {
X = sc.nextLong();
Y = sc.nextLong();
A = sc.nextLong();
B = sc.nextLong();
C = sc.nextLong();
if (check(X, Y, A, B, C)
|| check(Y, X, A, B, C)
|| check(X, Y, B, A, C)
|| check(Y, X, B, A, C)
|| check(X, Y, C, A, B)
|| check(Y, X, C, A, B)) return "Yes";
return "No";
}
boolean check(long w, long h, long w1, long r1, long r2) {
long h1 = (w1+w-1)/w;
return (last2(w, h-h1, r1, r2) || last2(h-h1, w, r1, r2));
}
boolean last2(long w, long h, long r1, long r2) {
if (w == 0) return false;
long h1 = (r1+w-1)/w;
return ((r2+w-1)/w <= h-h1);
}
public static void main(String[] args) {
System.out.println(new Main().calc());
}
}
import java.util.*;
class Main {
Scanner sc = new Scanner(System.in);
long X, Y, A, B, C;
String calc() {
X = sc.nextLong();
Y = sc.nextLong();
A = sc.nextLong();
B = sc.nextLong();
C = sc.nextLong();
if (check(X, Y, A, B, C)
|| check(Y, X, A, B, C)
|| check(X, Y, B, A, C)
|| check(Y, X, B, A, C)
|| check(X, Y, C, A, B)
|| check(Y, X, C, A, B)) return "Yes";
return "No";
}
boolean check(long w, long h, long w1, long r1, long r2) {
long h1 = (w1+w-1)/w;
return (last2(w, h-h1, r1, r2) || last2(h-h1, w, r1, r2));
}
boolean last2(long w, long h, long r1, long r2) {
if (w <= 0 || h <= 0) return false;
long h1 = (r1+w-1)/w;
return ((r2+w-1)/w <= h-h1);
}
public static void main(String[] args) {
System.out.println(new Main().calc());
}
}
| ConDefects/ConDefects/Code/abc223_e/Java/27540642 |
condefects-java_data_1122 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] s = new int[n];
for (int i = 0;i < n;i++) s[i] = sc.nextInt();
int[] a = new int[n + 2];
a[0] = a[1] = 0;
for (int i = 2;i < a.length;i ++) {
a[i] = s[i - 2] - a[i - 1] - a[i - 2];
}
int[] one = new int[(n + 2 + 2) / 3];
int[] two = new int[(n + 2 + 1) / 3];
int[] three = new int[(n + 2) / 3];
for (int i = 0;i < a.length;i ++) {
if ((i + 1) % 3 == 1) one[i / 3] = a[i];
else if ((i + 1) % 3 == 2) two[i / 3] = a[i];
else three[i / 3] = a[i];
}
int minOne = Integer.MAX_VALUE;
for (int i = 0;i < one.length;i ++) {
minOne = Math.min(one[i], minOne);
}
int minTwo = Integer.MAX_VALUE;
for (int i = 0;i < two.length;i ++)
minTwo = Math.min(minTwo, two[i]);
int minThree = Integer.MAX_VALUE;
for (int i = 0;i < three.length;i ++)
minThree = Math.min(three[i], minThree);
if (-minOne - minTwo > minThree) {
System.out.println("No");
return;
}
a[0] = -minOne;
a[1] = -minTwo;
for (int i = 2;i < a.length;i ++) a[i] = s[i - 2] - a[i - 1] - a[i - 2];
System.out.println("Yes");
StringBuilder sb = new StringBuilder();
for (int i : a) sb.append(i).append(' ');
sb.deleteCharAt(sb.length() - 1);
System.out.println(sb);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] s = new int[n];
for (int i = 0;i < n;i++) s[i] = sc.nextInt();
int[] a = new int[n + 2];
a[0] = a[1] = 0;
for (int i = 2;i < a.length;i ++) {
a[i] = s[i - 2] - a[i - 1] - a[i - 2];
}
int[] one = new int[(n + 2 + 2) / 3];
int[] two = new int[(n + 2 + 1) / 3];
int[] three = new int[(n + 2) / 3];
for (int i = 0;i < a.length;i ++) {
if ((i + 1) % 3 == 1) one[i / 3] = a[i];
else if ((i + 1) % 3 == 2) two[i / 3] = a[i];
else three[i / 3] = a[i];
}
int minOne = Integer.MAX_VALUE;
for (int i = 0;i < one.length;i ++) {
minOne = Math.min(one[i], minOne);
}
int minTwo = Integer.MAX_VALUE;
for (int i = 0;i < two.length;i ++)
minTwo = Math.min(minTwo, two[i]);
int minThree = Integer.MAX_VALUE;
for (int i = 0;i < three.length;i ++)
minThree = Math.min(three[i], minThree);
if ((long) -minOne - minTwo > minThree) {
System.out.println("No");
return;
}
a[0] = -minOne;
a[1] = -minTwo;
for (int i = 2;i < a.length;i ++) a[i] = s[i - 2] - a[i - 1] - a[i - 2];
System.out.println("Yes");
StringBuilder sb = new StringBuilder();
for (int i : a) sb.append(i).append(' ');
sb.deleteCharAt(sb.length() - 1);
System.out.println(sb);
}
} | ConDefects/ConDefects/Code/arc135_b/Java/29345744 |
condefects-java_data_1123 | import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.function.IntFunction;
public class Main{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
final MyReader in = new MyReader(System.in);
final MyWriter out = new MyWriter(System.out);
final MyWriter log = new MyWriter(System.err){
@Override
void ln(){
super.ln();
flush();
};
};
public static void main(final String[] args){ new Main().exe(); }
private void exe(){
input();
preCalc();
solve();
// out.println(solve());
out.flush();
log.println(elapsed());
}
int N = in.it();
long[] S = in.lg(N);
private void input(){}
private void preCalc(){}
void solve(){
var b = new long[N +2];
for (var i = 2;i < b.length;i++)
b[i] = S[i -2] -S[0] -b[i -1] -b[i -2];
var mins = new long[3];
for (var i = 0;i < b.length;i++)
mins[i %3] = Math.min(mins[i %3],b[i]);
var v = -(mins[0] +mins[1] +mins[2]);
if (v > S[0]) {
out.println(no);
return;
}
out.println(yes);
var c = new long[3];
c[1] = -mins[1];
c[2] = -mins[2];
c[0] = S[0] -c[1] -c[2];
for (var i = 0;i < b.length;i++)
b[i] += c[i %3];
out.println(c);
}
/* 定数 */
final static int infI = (int) 1e9;
final static long infL = (long) 1e18;
final static long mod = (int) 1e9 +7;
// final static long mod = 998244353;
final static String yes = "Yes";
final static String no = "No";
/* Util */
void swap(final int[] arr,final int i,final int j){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
void swap(final long[] arr,final int i,final int j){
long t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
/* 入力 */
static class MyReader{
byte[] buf = new byte[1 <<16];
int head = 0;
int tail = 0;
InputStream in;
public MyReader(final InputStream in){ this.in = in; }
byte read(){
if (head == tail) {
try {
tail = in.read(buf);
} catch (IOException e) {
e.printStackTrace();
}
head = 0;
}
return buf[head++];
}
boolean isPrintable(final byte c){ return 32 < c && c < 127; }
boolean isNum(final byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
return isPrintable(ret) ? ret : nextPrintable();
}
int it(){ return (int) lg(); }
int[] it(final int N){
int[] a = new int[N];
Arrays.setAll(a,i -> it());
return a;
}
int[][] it(final int H,final int W){ return arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(final int N){
int[] a = new int[N];
Arrays.setAll(a,i -> idx());
return a;
}
int[][] idx(final int H,final int W){ return arr(new int[H][],i -> idx(W)); }
int[][] trans(final int[][] mat){
int[][] ret = new int[mat[0].length][mat.length];
for (int i = 0;i < mat.length;i++)
for (int j = 0;j < mat[0].length;j++)
ret[j][i] = mat[i][j];
return ret;
}
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(final int N){
long[] a = new long[N];
Arrays.setAll(a,i -> lg());
return a;
}
long[][] lg(final int H,final int W){ return arr(new long[H][],i -> lg(W)); }
long[][] trans(final long[][] mat){
long[][] ret = new long[mat[0].length][mat.length];
for (int i = 0;i < mat.length;i++)
for (int j = 0;j < mat[0].length;j++)
ret[j][i] = mat[i][j];
return ret;
}
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(final int N){
double[] a = new double[N];
Arrays.setAll(a,i -> dbl());
return a;
}
public double[][] dbl(final int H,final int W){ return arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(final int H){ return arr(new char[H][],i -> ch()); }
char[][] trans(final char[][] mat){
char[][] ret = new char[mat[0].length][mat.length];
for (int i = 0;i < mat.length;i++)
for (int j = 0;j < mat[0].length;j++)
ret[j][i] = mat[i][j];
return ret;
}
String line(){
StringBuilder sb = new StringBuilder();
byte c;
while (isPrintable(c = read()) || c == ' ')
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
byte c;
while (isPrintable(c = read()))
sb.append((char) c);
return sb.toString();
}
String[] str(final int N){ return arr(new String[N],i -> str()); }
<T> T[] arr(final T[] arr,final IntFunction<T> f){
Arrays.setAll(arr,f);
return arr;
}
}
/* 出力 */
static class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
public MyWriter(final OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void sp(){ write((byte) ' '); }
void ln(){ write((byte) '\n'); }
void write(final byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
void write(final byte[] b,final int off,final int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
void println(final boolean b){ println(b ? yes : no); }
void println(final long n){
write(n);
ln();
}
public void println(final double d){ println(String.valueOf(d)); }
void println(final String s){
for (byte b:s.getBytes())
write(b);
ln();
}
public void println(final char[] s){
for (char b:s)
write((byte) b);
ln();
}
void println(final int[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(final long[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.function.IntFunction;
public class Main{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
final MyReader in = new MyReader(System.in);
final MyWriter out = new MyWriter(System.out);
final MyWriter log = new MyWriter(System.err){
@Override
void ln(){
super.ln();
flush();
};
};
public static void main(final String[] args){ new Main().exe(); }
private void exe(){
input();
preCalc();
solve();
// out.println(solve());
out.flush();
log.println(elapsed());
}
int N = in.it();
long[] S = in.lg(N);
private void input(){}
private void preCalc(){}
void solve(){
var b = new long[N +2];
for (var i = 2;i < b.length;i++)
b[i] = S[i -2] -S[0] -b[i -1] -b[i -2];
var mins = new long[3];
for (var i = 0;i < b.length;i++)
mins[i %3] = Math.min(mins[i %3],b[i]);
var v = -(mins[0] +mins[1] +mins[2]);
if (v > S[0]) {
out.println(no);
return;
}
out.println(yes);
var c = new long[3];
c[1] = -mins[1];
c[2] = -mins[2];
c[0] = S[0] -c[1] -c[2];
for (var i = 0;i < b.length;i++)
b[i] += c[i %3];
out.println(b);
}
/* 定数 */
final static int infI = (int) 1e9;
final static long infL = (long) 1e18;
final static long mod = (int) 1e9 +7;
// final static long mod = 998244353;
final static String yes = "Yes";
final static String no = "No";
/* Util */
void swap(final int[] arr,final int i,final int j){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
void swap(final long[] arr,final int i,final int j){
long t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
/* 入力 */
static class MyReader{
byte[] buf = new byte[1 <<16];
int head = 0;
int tail = 0;
InputStream in;
public MyReader(final InputStream in){ this.in = in; }
byte read(){
if (head == tail) {
try {
tail = in.read(buf);
} catch (IOException e) {
e.printStackTrace();
}
head = 0;
}
return buf[head++];
}
boolean isPrintable(final byte c){ return 32 < c && c < 127; }
boolean isNum(final byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
return isPrintable(ret) ? ret : nextPrintable();
}
int it(){ return (int) lg(); }
int[] it(final int N){
int[] a = new int[N];
Arrays.setAll(a,i -> it());
return a;
}
int[][] it(final int H,final int W){ return arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(final int N){
int[] a = new int[N];
Arrays.setAll(a,i -> idx());
return a;
}
int[][] idx(final int H,final int W){ return arr(new int[H][],i -> idx(W)); }
int[][] trans(final int[][] mat){
int[][] ret = new int[mat[0].length][mat.length];
for (int i = 0;i < mat.length;i++)
for (int j = 0;j < mat[0].length;j++)
ret[j][i] = mat[i][j];
return ret;
}
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(final int N){
long[] a = new long[N];
Arrays.setAll(a,i -> lg());
return a;
}
long[][] lg(final int H,final int W){ return arr(new long[H][],i -> lg(W)); }
long[][] trans(final long[][] mat){
long[][] ret = new long[mat[0].length][mat.length];
for (int i = 0;i < mat.length;i++)
for (int j = 0;j < mat[0].length;j++)
ret[j][i] = mat[i][j];
return ret;
}
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(final int N){
double[] a = new double[N];
Arrays.setAll(a,i -> dbl());
return a;
}
public double[][] dbl(final int H,final int W){ return arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(final int H){ return arr(new char[H][],i -> ch()); }
char[][] trans(final char[][] mat){
char[][] ret = new char[mat[0].length][mat.length];
for (int i = 0;i < mat.length;i++)
for (int j = 0;j < mat[0].length;j++)
ret[j][i] = mat[i][j];
return ret;
}
String line(){
StringBuilder sb = new StringBuilder();
byte c;
while (isPrintable(c = read()) || c == ' ')
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
byte c;
while (isPrintable(c = read()))
sb.append((char) c);
return sb.toString();
}
String[] str(final int N){ return arr(new String[N],i -> str()); }
<T> T[] arr(final T[] arr,final IntFunction<T> f){
Arrays.setAll(arr,f);
return arr;
}
}
/* 出力 */
static class MyWriter{
OutputStream out;
byte[] buf = new byte[1 <<16];
byte[] ibuf = new byte[20];
int tail = 0;
public MyWriter(final OutputStream out){ this.out = out; }
void flush(){
try {
out.write(buf,0,tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void sp(){ write((byte) ' '); }
void ln(){ write((byte) '\n'); }
void write(final byte b){
buf[tail++] = b;
if (tail == buf.length)
flush();
}
void write(final byte[] b,final int off,final int len){
for (int i = off;i < off +len;i++)
write(b[i]);
}
void write(long n){
if (n < 0) {
n = -n;
write((byte) '-');
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n %10 +'0');
n /= 10;
} while (n > 0);
write(ibuf,i,ibuf.length -i);
}
void println(final boolean b){ println(b ? yes : no); }
void println(final long n){
write(n);
ln();
}
public void println(final double d){ println(String.valueOf(d)); }
void println(final String s){
for (byte b:s.getBytes())
write(b);
ln();
}
public void println(final char[] s){
for (char b:s)
write((byte) b);
ln();
}
void println(final int[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
void println(final long[] a){
for (int i = 0;i < a.length;i++) {
if (0 < i)
sp();
write(a[i]);
}
ln();
}
}
}
| ConDefects/ConDefects/Code/arc135_b/Java/37045880 |
condefects-java_data_1124 | import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args){
Main m = new Main();
m.run();
}
public void run(){
Scanner sc= new Scanner(System.in);
int n = sc.nextInt();
long s[] = new long[n];
for(int i =0 ;i < n;i ++){
s[i] = sc.nextInt();
}
long dum[] = new long[n+2];
dum[0] = 0;
dum[1] = 0;
for(int i = 0 ;i < n ; i++){
dum[i+2] = s[i] - dum[i+1] - dum[i];
}
// System.out.println(Arrays.toString(dum));
long min[] = new long[3];
min[0] = dum[0];
min[1] = dum[1];
min[2] = dum[2];
for(int i =0 ;i < n +2 ;i++){
min[i%3] = Math.min(min[i%3], dum[i]);
}
if(min[0] + min[1]+ min[2] < 0){
System.out.println("No");
return;
}
long[] off = new long[3];
off[0] = min[0] - min[1] - min[2];
off[1] = min[1];
off[2] = min[2];
System.out.println("Yes");
for(int i = 0; i < n+1; i++){
System.out.print(dum[i]-off[i%3]);
System.out.print(" ");
}
System.out.println(dum[n+1]-off[(n+1)%3]);
}
}
import java.util.*;
import java.io.*;
public class Main{
public static void main(String[] args){
Main m = new Main();
m.run();
}
public void run(){
Scanner sc= new Scanner(System.in);
int n = sc.nextInt();
long s[] = new long[n];
for(int i =0 ;i < n;i ++){
s[i] = sc.nextInt();
}
long dum[] = new long[n+2];
dum[0] = 0;
dum[1] = 0;
for(int i = 0 ;i < n ; i++){
dum[i+2] = s[i] - dum[i+1] - dum[i];
}
// System.out.println(Arrays.toString(dum));
long min[] = new long[3];
min[0] = dum[0];
min[1] = dum[1];
min[2] = dum[2];
for(int i =0 ;i < n +2 ;i++){
min[i%3] = Math.min(min[i%3], dum[i]);
}
if(min[0] + min[1]+ min[2] < 0){
System.out.println("No");
return;
}
long[] off = new long[3];
off[0] = - min[1] - min[2];
off[1] = min[1];
off[2] = min[2];
System.out.println("Yes");
for(int i = 0; i < n+1; i++){
System.out.print(dum[i]-off[i%3]);
System.out.print(" ");
}
System.out.println(dum[n+1]-off[(n+1)%3]);
}
} | ConDefects/ConDefects/Code/arc135_b/Java/29307491 |
condefects-java_data_1125 | import java.util.*;
import java.io.*;
public class Main {
static FastScanner sc = new FastScanner(System.in);
static PrintWriter pw = new PrintWriter(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();
ArrayList<Long> arr = new ArrayList<>();
arr.add(0L);arr.add(0L);
long[] a = sc.nextLongArray(N);
int ai = 1;
for(int i = 0; i < N; i++){
arr.add(a[i]-arr.get(ai)-arr.get(ai-1));
ai++;
}
long v1 = 0;
for(int i = 0; i < arr.size(); i += 3){
v1 = Math.max(v1,-arr.get(i));
}
long v2 = 0;
for(int i = 1; i < arr.size(); i += 3){
v2 = Math.max(v2,-arr.get(i));
}
long v3 = Long.MAX_VALUE;
for(int i = 2; i < arr.size(); i += 3){
v3 = Math.min(v3,arr.get(i));
}
if(v1 + v2 > v3){
pw.println("No");
return;
}
//pw.println(v1 + " " + v2 + " " + v3);
for(int i = 0; i < N; i++){
if(i % 3 == 0){
arr.set(i,arr.get(i)+v1);
}else if(i % 3 == 1){
arr.set(i,arr.get(i)+v2);
}else{
arr.set(i,arr.get(i)-v1-v2);
}
}
pw.println("Yes");
pw.println(arrToString(arr));
}
private static String arrToString(ArrayList<Long> arr){
StringBuilder printer = new StringBuilder();
for(long v : arr) printer.append(v).append(" ");
return printer.toString().trim();
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
class FastScanner {
private BufferedReader reader = null;
private StringTokenizer tokenizer = null;
public FastScanner(InputStream in) {
reader = new BufferedReader(new InputStreamReader(in));
tokenizer = null;
}
public FastScanner(FileReader in) {
reader = new BufferedReader(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 String[] nextArray(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++)
a[i] = next();
return a;
}
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.io.*;
public class Main {
static FastScanner sc = new FastScanner(System.in);
static PrintWriter pw = new PrintWriter(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();
ArrayList<Long> arr = new ArrayList<>();
arr.add(0L);arr.add(0L);
long[] a = sc.nextLongArray(N);
int ai = 1;
for(int i = 0; i < N; i++){
arr.add(a[i]-arr.get(ai)-arr.get(ai-1));
ai++;
}
long v1 = 0;
for(int i = 0; i < arr.size(); i += 3){
v1 = Math.max(v1,-arr.get(i));
}
long v2 = 0;
for(int i = 1; i < arr.size(); i += 3){
v2 = Math.max(v2,-arr.get(i));
}
long v3 = Long.MAX_VALUE;
for(int i = 2; i < arr.size(); i += 3){
v3 = Math.min(v3,arr.get(i));
}
if(v1 + v2 > v3){
pw.println("No");
return;
}
//pw.println(v1 + " " + v2 + " " + v3);
for(int i = 0; i < N+2; i++){
if(i % 3 == 0){
arr.set(i,arr.get(i)+v1);
}else if(i % 3 == 1){
arr.set(i,arr.get(i)+v2);
}else{
arr.set(i,arr.get(i)-v1-v2);
}
}
pw.println("Yes");
pw.println(arrToString(arr));
}
private static String arrToString(ArrayList<Long> arr){
StringBuilder printer = new StringBuilder();
for(long v : arr) printer.append(v).append(" ");
return printer.toString().trim();
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
class FastScanner {
private BufferedReader reader = null;
private StringTokenizer tokenizer = null;
public FastScanner(InputStream in) {
reader = new BufferedReader(new InputStreamReader(in));
tokenizer = null;
}
public FastScanner(FileReader in) {
reader = new BufferedReader(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 String[] nextArray(int n) {
String[] a = new String[n];
for (int i = 0; i < n; i++)
a[i] = next();
return a;
}
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/arc135_b/Java/29584838 |
condefects-java_data_1126 | import java.io.*;
import java.util.*;
public class Main{
public static void main(String args[]) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int n = Integer.parseInt(br.readLine());
int[] ar = new int[n];
StringTokenizer st = new StringTokenizer(br.readLine());
for(int i = 0; i < n; i++)
ar[i] = Integer.parseInt(st.nextToken());
int l = 0;
int r = ar[n-1];
int v1, v2;
v1 = v2 = -1;
while(l < r){
int mid = (l + r)/2;
int res = check(ar, mid);
if(res >= 0){
v1 = mid;
v2 = res;
break;
}else if(res == -1)
r = mid-1;
else
l = mid+1;
}
if(v1 == -1)
pw.println("No");
else {
pw.println("Yes");
int[] res = new int[n+2];
int lx = v1;
int nx = v2;
res[n+1] = lx;
res[n] = nx;
for(int i = ar.length-1; i >= 0; i--) {
int nv = ar[i] - (lx+nx);
res[i] = nv;
lx = nx;
nx = nv;
}
for(int i : res)
pw.print(i + " ");
}
pw.close();
}
static int check(int[] ar, int v){
int min = 0;
int max = ar[ar.length-1]-v;
int[] tmp = new int[]{v, 0, ar[ar.length-1]-v};
int ind = 0;
for(int i = ar.length-2; i >= 0; i--){
if(ind == 0){
tmp[0] += ar[i] - ar[i+1];
if(tmp[0] < 0)
return -2;
}else if(ind == 1){
tmp[1] += ar[i] - ar[i+1];
min = Math.max(min, -tmp[1]);
}else{
tmp[2] += ar[i] - ar[i+1];
max = Math.min(max, tmp[2]);
}
ind = (ind+1)%3;
}
if(min > max || max < 0)
return -1;
return Math.max(0, min);
}
}
import java.io.*;
import java.util.*;
public class Main{
public static void main(String args[]) throws Exception{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int n = Integer.parseInt(br.readLine());
int[] ar = new int[n];
StringTokenizer st = new StringTokenizer(br.readLine());
for(int i = 0; i < n; i++)
ar[i] = Integer.parseInt(st.nextToken());
int l = 0;
int r = ar[n-1];
int v1, v2;
v1 = v2 = -1;
while(l <= r){
int mid = (l + r)/2;
int res = check(ar, mid);
if(res >= 0){
v1 = mid;
v2 = res;
break;
}else if(res == -1)
r = mid-1;
else
l = mid+1;
}
if(v1 == -1)
pw.println("No");
else {
pw.println("Yes");
int[] res = new int[n+2];
int lx = v1;
int nx = v2;
res[n+1] = lx;
res[n] = nx;
for(int i = ar.length-1; i >= 0; i--) {
int nv = ar[i] - (lx+nx);
res[i] = nv;
lx = nx;
nx = nv;
}
for(int i : res)
pw.print(i + " ");
}
pw.close();
}
static int check(int[] ar, int v){
int min = 0;
int max = ar[ar.length-1]-v;
int[] tmp = new int[]{v, 0, ar[ar.length-1]-v};
int ind = 0;
for(int i = ar.length-2; i >= 0; i--){
if(ind == 0){
tmp[0] += ar[i] - ar[i+1];
if(tmp[0] < 0)
return -2;
}else if(ind == 1){
tmp[1] += ar[i] - ar[i+1];
min = Math.max(min, -tmp[1]);
}else{
tmp[2] += ar[i] - ar[i+1];
max = Math.min(max, tmp[2]);
}
ind = (ind+1)%3;
}
if(min > max || max < 0)
return -1;
return Math.max(0, min);
}
} | ConDefects/ConDefects/Code/arc135_b/Java/29341546 |
condefects-java_data_1127 | import java.util.*;
import java.util.stream.*;
import java.io.*;
class Pair implements Comparable<Pair> {
int p, q;
@Override
public int compareTo(Pair other){
if(this.p > other.p) return 1;
else if(this.p < other.p) return -1;
else return 0;
}
}
public class Main {
static final int INF = 1<<30;
static final long INFL = 1L<<60;
static final int MOD = 1000000007;
static final int MOD2 = 998244353;
static List<List<Integer>> g;
public static void main(String[] args) {
FastScanner fs = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
int n = fs.nextInt();
int K = fs.nextInt();
Pair[] s = new Pair[n];
for(int i = 0; i < n; i++) s[i] = new Pair();
for(int i = 0; i < n; i++) s[i].p = fs.nextInt();
for(int i = 0; i < n; i++) s[i].q = fs.nextInt();
Arrays.sort(s);
long[][][] dp = new long[n+1][n+1][n+2];
dp[0][0][n+1] = 1;
for(int i = 0; i < n; i++){
int q = s[i].q;
for(int j = 0; j < n; j++){
for(int k = 0; k <= n+1; k++){
// not choose
dp[i+1][j][Math.min(q, k)] += dp[i][j][k];
dp[i+1][j][Math.min(q, k)] %= MOD2;
// choose
if(k > q) dp[i+1][j+1][k] += dp[i][j][k];
dp[i+1][j+1][k] %= MOD2;
}
}
}
long ans = 0;
for(int i = 1; i <= n; i++) ans = (ans + dp[n][K][i]) % MOD2;
pw.println(ans);
pw.close();
}
}
class FastScanner {
private InputStream in = System.in;
private byte[] buffer = new byte[1024];
private int length = 0, p = 0;
private boolean hasNextByte() {
if (p < length) return true;
else{
p = 0;
try{
length = in.read(buffer);
}catch(Exception e){
e.printStackTrace();
}
if(length == 0) return false;
}
return true;
}
private int readByte() {
if (hasNextByte() == true) return buffer[p++];
return -1;
}
private static boolean isPrintable(int n) {
return 33 <= n && n <= 126;
}
private void skip() {
while (hasNextByte() && !isPrintable(buffer[p])) p++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if(!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int temp = readByte();
while (isPrintable(temp)) {
sb.appendCodePoint(temp);
temp = readByte();
}
return sb.toString();
}
public int nextInt() {
return Math.toIntExact(nextLong());
}
public int[] nextInts(int n) {
int[] ar = new int[n];
for (int i = 0; i < n; i++) ar[i] = nextInt();
return ar;
}
public long[] nextLongs(int n) {
long[] ar = new long[n];
for (int i = 0; i < n; i++) ar[i] = nextLong();
return ar;
}
public long nextLong() {
if(!hasNext()) throw new NoSuchElementException();
boolean minus = false;
int temp = readByte();
if (temp == '-') {
minus = true;
temp = readByte();
}
if (temp < '0' || '9' < temp) throw new NumberFormatException();
long n = 0;
while (isPrintable(temp)) {
if ('0' <= temp && temp <= '9') {
n *= 10;
n += temp - '0';
}
temp = readByte();
}
return minus ? -n : n;
}
public char[] nextChars() {
String s = next();
return s.toCharArray();
}
public char[][] nextCharMat(int h, int w) {
char[][] ar = new char[h][w];
for(int i = 0; i < h; i++){
String s = next();
for(int j = 0; j < w; j++){
ar[i][j] = s.charAt(j);
}
}
return ar;
}
}
import java.util.*;
import java.util.stream.*;
import java.io.*;
class Pair implements Comparable<Pair> {
int p, q;
@Override
public int compareTo(Pair other){
if(this.p > other.p) return 1;
else if(this.p < other.p) return -1;
else return 0;
}
}
public class Main {
static final int INF = 1<<30;
static final long INFL = 1L<<60;
static final int MOD = 1000000007;
static final int MOD2 = 998244353;
static List<List<Integer>> g;
public static void main(String[] args) {
FastScanner fs = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
int n = fs.nextInt();
int K = fs.nextInt();
Pair[] s = new Pair[n];
for(int i = 0; i < n; i++) s[i] = new Pair();
for(int i = 0; i < n; i++) s[i].p = fs.nextInt();
for(int i = 0; i < n; i++) s[i].q = fs.nextInt();
Arrays.sort(s);
long[][][] dp = new long[n+1][n+1][n+2];
dp[0][0][n+1] = 1;
for(int i = 0; i < n; i++){
int q = s[i].q;
for(int j = 0; j < n; j++){
for(int k = 0; k <= n+1; k++){
// not choose
dp[i+1][j][Math.min(q, k)] += dp[i][j][k];
dp[i+1][j][Math.min(q, k)] %= MOD2;
// choose
if(k > q) dp[i+1][j+1][k] += dp[i][j][k];
dp[i+1][j+1][k] %= MOD2;
}
}
}
long ans = 0;
for(int i = 1; i <= n+1; i++) ans = (ans + dp[n][K][i]) % MOD2;
pw.println(ans);
pw.close();
}
}
class FastScanner {
private InputStream in = System.in;
private byte[] buffer = new byte[1024];
private int length = 0, p = 0;
private boolean hasNextByte() {
if (p < length) return true;
else{
p = 0;
try{
length = in.read(buffer);
}catch(Exception e){
e.printStackTrace();
}
if(length == 0) return false;
}
return true;
}
private int readByte() {
if (hasNextByte() == true) return buffer[p++];
return -1;
}
private static boolean isPrintable(int n) {
return 33 <= n && n <= 126;
}
private void skip() {
while (hasNextByte() && !isPrintable(buffer[p])) p++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if(!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int temp = readByte();
while (isPrintable(temp)) {
sb.appendCodePoint(temp);
temp = readByte();
}
return sb.toString();
}
public int nextInt() {
return Math.toIntExact(nextLong());
}
public int[] nextInts(int n) {
int[] ar = new int[n];
for (int i = 0; i < n; i++) ar[i] = nextInt();
return ar;
}
public long[] nextLongs(int n) {
long[] ar = new long[n];
for (int i = 0; i < n; i++) ar[i] = nextLong();
return ar;
}
public long nextLong() {
if(!hasNext()) throw new NoSuchElementException();
boolean minus = false;
int temp = readByte();
if (temp == '-') {
minus = true;
temp = readByte();
}
if (temp < '0' || '9' < temp) throw new NumberFormatException();
long n = 0;
while (isPrintable(temp)) {
if ('0' <= temp && temp <= '9') {
n *= 10;
n += temp - '0';
}
temp = readByte();
}
return minus ? -n : n;
}
public char[] nextChars() {
String s = next();
return s.toCharArray();
}
public char[][] nextCharMat(int h, int w) {
char[][] ar = new char[h][w];
for(int i = 0; i < h; i++){
String s = next();
for(int j = 0; j < w; j++){
ar[i][j] = s.charAt(j);
}
}
return ar;
}
} | ConDefects/ConDefects/Code/abc238_f/Java/29122182 |
condefects-java_data_1128 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.NoSuchElementException;
class Main {
public static void main(String[] args) {
new Main().run();
}
class DSU {
int[] parent;
public DSU(int n) {
parent=new int[n];
Arrays.fill(parent, -1);
}
int root(int x) {
return parent[x]<0?x:(parent[x]=root(parent[x]));
}
void union(int x, int y) {
x=root(x);
y=root(y);
if (x==y) return;
parent[x]=y;
}
boolean equiv(int x, int y) {
return root(x) == root(y);
}
}
final long mod=998244353;
void solve() {
FastScanner sc=new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
int N=sc.nextInt();
int K=sc.nextInt();
int[][] x=new int[N][2];
for (int i=0;i<N;++i) {
x[i][0]=sc.nextInt();
}
for (int i=0;i<N;++i) {
x[i][1]=sc.nextInt();
}
Arrays.sort(x, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return Integer.compare(o1[1], o2[1]);
}
});
long[][] dp=new long[K+2][N+2];
dp[0][N+1]=1;
for (int i=0;i<N;++i) {
long[][] ndp=new long[K+2][N+2];
for (int k=0;k<=K;++k) {
for (int min=1;min<=N+1;++min) {
ndp[k][Math.min(x[i][0], min)]+=dp[k][min];
ndp[k][Math.min(x[i][0], min)]%=mod;
if (min > x[i][0]) {
ndp[k+1][min]+=dp[k][min];
ndp[k+1][min]%=mod;
}
}
}
dp=ndp;
}
long ans=0;
for (int min=1;min<=N;++min) {
ans=(ans+dp[K][min])%mod;
}
pw.println(ans);
pw.close();
}
void run() {
solve();
}
static 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;}
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.Comparator;
import java.util.NoSuchElementException;
class Main {
public static void main(String[] args) {
new Main().run();
}
class DSU {
int[] parent;
public DSU(int n) {
parent=new int[n];
Arrays.fill(parent, -1);
}
int root(int x) {
return parent[x]<0?x:(parent[x]=root(parent[x]));
}
void union(int x, int y) {
x=root(x);
y=root(y);
if (x==y) return;
parent[x]=y;
}
boolean equiv(int x, int y) {
return root(x) == root(y);
}
}
final long mod=998244353;
void solve() {
FastScanner sc=new FastScanner();
PrintWriter pw=new PrintWriter(System.out);
int N=sc.nextInt();
int K=sc.nextInt();
int[][] x=new int[N][2];
for (int i=0;i<N;++i) {
x[i][0]=sc.nextInt();
}
for (int i=0;i<N;++i) {
x[i][1]=sc.nextInt();
}
Arrays.sort(x, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return Integer.compare(o1[1], o2[1]);
}
});
long[][] dp=new long[K+2][N+2];
dp[0][N+1]=1;
for (int i=0;i<N;++i) {
long[][] ndp=new long[K+2][N+2];
for (int k=0;k<=K;++k) {
for (int min=1;min<=N+1;++min) {
ndp[k][Math.min(x[i][0], min)]+=dp[k][min];
ndp[k][Math.min(x[i][0], min)]%=mod;
if (min > x[i][0]) {
ndp[k+1][min]+=dp[k][min];
ndp[k+1][min]%=mod;
}
}
}
dp=ndp;
}
long ans=0;
for (int min=1;min<=N+1;++min) {
ans=(ans+dp[K][min])%mod;
}
pw.println(ans);
pw.close();
}
void run() {
solve();
}
static 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;}
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/abc238_f/Java/29100838 |
condefects-java_data_1129 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.ToIntFunction;
public final class Main {
void solve(Input in, PrintWriter out) {
int N = in.nextInt();
int K = in.nextInt();
int[] P = in.nextIntArray(N);
int[] Q = in.nextIntArray(N);
decrement(P);
decrement(Q);
var a = new int[N];
for (int i = 0; i < P.length; i++) {
a[P[i]] = Q[i];
}
var dp = new long[N + 1][K + 1][N + 1];
dp[0][0][N] = 1;
for (int i = 0; i < N; i++) {
for (int k = 0; k <= K; k++) {
for (int q = 0; q <= N; q++) {
if (k + 1 <= K && a[i] < q) {
add(dp[i + 1][k + 1], q, dp[i][k][q]);
}
add(dp[i + 1][k], Math.min(q, a[i]), dp[i][k][q]);
}
}
}
var ans = mint(0);
for (int q = 0; q < N; q++) {
ans.add(dp[N][K][q]);
}
out.println(ans);
}
private static int[] decrement(int[] a) {
for (int i = 0; i < a.length; i++)
a[i]--;
return a;
}
private static final int MOD = 998_244_353;
static int rem(long a) {
return Mod.rem(a, MOD);
}
static long add(long x, long y) {
return Mod.add(x, y, MOD);
}
static void add(long[] a, int i, long v) {
Mod.add(a, i, v, MOD);
}
static long sub(long x, long y) {
return Mod.sub(x, y, MOD);
}
static long mul(long x, long y) {
return Mod.mul(x, y, MOD);
}
static long pow(long base, long exp) {
return Mod.pow(base, exp, MOD);
}
static long pow(long base, ToIntFunction<Mod> exp) {
return Mod.pow(base, exp, MOD);
}
static long mulInverse(long a) {
return Mod.mulInverse(a, MOD);
}
static long div(long x, long y) {
return Mod.div(x, y, MOD);
}
static long[] cachePow(long base, int maxExponent) {
return Mod.cachePow(base, maxExponent, MOD);
}
static long[] factorial(int maxN) {
return Mod.factorial(maxN, MOD);
}
static long[] inverseFactorial(long[] factorial) {
return Mod.inverseFactorial(factorial, MOD);
}
static Mod.Permutation permutation(int maxN) {
return Mod.permutation(maxN, MOD);
}
static Mod.Combination combination(int maxN) {
return Mod.combination(maxN, MOD);
}
static Mod.Int mint(long initialValue) {
return Mod.mint(initialValue, MOD);
}
static Mod.Int mint(Mod.Int initialValue) {
return Mod.mint(initialValue, MOD);
}
static final class Mod {
final int divisor;
Mod(int divisor) {
if (divisor <= 0)
throw new IllegalArgumentException();
this.divisor = divisor;
}
static int rem(long a, int mod) {
a %= mod;
if (a < 0)
return (int)(a + mod);
return (int)a;
}
int rem(long a) {
return rem(a, divisor);
}
static long add(long x, long y, int mod) {
long z = x + y;
if (((x ^ z) & (y ^ z)) < 0)
return x % mod + y % mod;
return z;
}
long add(long x, long y) {
return add(x, y, divisor);
}
static void add(long[] a, int i, long v, int mod) {
a[i] = add(a[i], v, mod);
}
void add(long[] a, int index, long v) {
add(a, index, v, divisor);
}
static long sub(long x, long y, int mod) {
long z = x - y;
if (((x ^ y) & (x ^ z)) < 0)
return x % mod - y % mod;
return z;
}
long sub(long x, long y) {
return sub(x, y, divisor);
}
static final long MUL_SAFE_MIN = Integer.MIN_VALUE + 1;
static final long MUL_SAFE_MAX = Integer.MAX_VALUE;
static long mul(long x, long y, int mod) {
if (x > MUL_SAFE_MAX || x < MUL_SAFE_MIN)
x %= mod;
if (y > MUL_SAFE_MAX || y < MUL_SAFE_MIN)
y %= mod;
return x * y;
}
long mul(long x, long y) {
return mul(x, y, divisor);
}
static long pow(long base, long exp, int mod) {
if (exp < 0)
throw new IllegalArgumentException();
long res = 1;
for (long e = exp; e > 0; e >>= 1) {
if ((e & 1) != 0)
res = mul(res, base, mod);
base = mul(base, base, mod);
}
return res;
}
long pow(long base, long exp) {
return pow(base, exp, divisor);
}
static long pow(long base, ToIntFunction<Mod> exp, int mod) {
// assert isPrime(mod);
if (base % mod == 0)
return 0;
return pow(base, exp.applyAsInt(new Mod(mod - 1)), mod);
}
long pow(long base, ToIntFunction<Mod> exp) {
return pow(base, exp, divisor);
}
static long mulInverse(long a, int mod) {
// assert isCoprime(a, m);
if (mod == 1)
return 0;
if (a == 0)
throw new IllegalArgumentException("divide by zero");
a = rem(a, mod);
long b = mod, x = 1, u = 0, tmp;
while (b != 0) {
long k = a / b;
a -= k * b;
tmp = a;
a = b;
b = tmp;
x -= k * u;
tmp = x;
x = u;
u = tmp;
}
if (a != 1)
throw new IllegalArgumentException("divide by zero");
return rem(x, mod);
}
long mulInverse(long a) {
return mulInverse(a, divisor);
}
static long div(long x, long y, int mod) {
return mul(x, mulInverse(y, mod), mod);
}
long div(long x, long y) {
return div(x, y, divisor);
}
static long[] cachePow(long base, int maxExponent, int mod) {
var res = new long[maxExponent + 1];
long v = res[0] = 1;
base = rem(base, mod);
for (int i = 1; i <= maxExponent; i++) {
v *= base;
if (v > MUL_SAFE_MAX)
v %= mod;
res[i] = v;
}
return res;
}
long[] cachePow(long base, int maxExponent) {
return cachePow(base, maxExponent, divisor);
}
static long[] factorial(int maxN, int mod) {
var res = new long[maxN + 1];
long v = res[0] = res[1] = 1;
for (int i = 2; i <= maxN; i++) {
v *= i;
if (v > MUL_SAFE_MAX)
v %= mod;
res[i] = v;
}
return res;
}
long[] factorial(int maxN) {
return factorial(maxN, divisor);
}
static long[] inverseFactorial(long[] factorial, int mod) {
int n = factorial.length;
var res = new long[n];
long v = res[n - 1] = mulInverse(factorial[n - 1], mod);
for (int i = n - 1; i > 0; i--) {
v *= i;
if (v > MUL_SAFE_MAX)
v %= mod;
res[i - 1] = v;
}
return res;
}
long[] inverseFactorial(long[] factorial) {
return inverseFactorial(factorial, divisor);
}
static Permutation permutation(int maxN, int mod) {
long[] fact = factorial(maxN, mod);
long[] invFact = inverseFactorial(fact, mod);
return new Permutation(fact, invFact, mod);
}
Permutation permutation(int maxN) {
return permutation(maxN, divisor);
}
static final class Permutation {
final int divisor;
final long[] factorial;
final long[] inverseFactorial;
private Permutation(long[] factorial,
long[] inverseFactorial,
int divisor) {
this.divisor = divisor;
this.factorial = factorial;
this.inverseFactorial = inverseFactorial;
}
long of(int n, int k) {
if (k > n)
return 0;
return mul(factorial[n], inverseFactorial[n - k], divisor);
}
Combination combination() {
return new Combination(factorial, inverseFactorial, divisor);
}
}
static Combination combination(int maxN, int mod) {
long[] fact = factorial(maxN, mod);
long[] invFact = inverseFactorial(fact, mod);
return new Combination(fact, invFact, mod);
}
Combination combination(int maxN) {
return combination(maxN, divisor);
}
static final class Combination {
final int divisor;
final long[] factorial;
final long[] inverseFactorial;
private Combination(long[] factorial,
long[] inverseFactorial,
int divisor) {
this.divisor = divisor;
this.factorial = factorial;
this.inverseFactorial = inverseFactorial;
}
long of(int n, int k) {
if (k > n)
return 0;
return mul(mul(factorial[n], inverseFactorial[k], divisor),
inverseFactorial[n - k],
divisor);
}
Permutation permutation() {
return new Permutation(factorial, inverseFactorial, divisor);
}
}
static Int mint(long initialValue, int mod) {
return new Int(initialValue, mod);
}
Int mint(long initialValue) {
return mint(initialValue, divisor);
}
static Int mint(Int initialValue, int mod) {
return new Int(initialValue.rawValue, mod);
}
Int mint(Int initialValue) {
return mint(initialValue, divisor);
}
static final class Int {
final int divisor;
private long rawValue;
private Int(long initialValue, int divisor) {
this.divisor = divisor;
rawValue = initialValue;
}
int rem() {
return (int)(rawValue = Mod.rem(rawValue, divisor));
}
Int set(long value) {
this.rawValue = value;
return this;
}
Int add(long a) {
rawValue = Mod.add(rawValue, a, divisor);
return this;
}
Int add(Int a) {
return add(a.rawValue);
}
Int sub(long a) {
rawValue = Mod.sub(rawValue, a, divisor);
return this;
}
Int sub(Int a) {
return sub(a.rawValue);
}
Int mul(long a) {
rawValue = Mod.mul(rawValue, a, divisor);
return this;
}
Int mul(Int a) {
return mul(a.rawValue);
}
Int pow(long exponent) {
rawValue = Mod.pow(rawValue, exponent, divisor);
return this;
}
Int div(long a) {
rawValue = Mod.div(rawValue, a, divisor);
return this;
}
Int div(Int a) {
return div(a.rawValue);
}
void addTo(long[] a, int i) {
Mod.add(a, i, rawValue, divisor);
}
@Override
public String toString() {
return Integer.toString(rem());
}
}
}
public static void main(String[] args) {
var w = new PrintWriter(System.out);
new Main().solve(new Input(System.in), w);
w.flush();
}
static final class Input {
private final InputStream in;
private final byte[] buffer = new byte[8192];
private int point;
private int readLength;
Input(InputStream in) {
this.in = Objects.requireNonNull(in);
}
private int readByte() {
if (point < readLength)
return buffer[point++];
try {
readLength = in.read(buffer);
} catch (IOException e) {
throw new AssertionError(null, e);
}
if (readLength == -1)
return -1;
point = 1;
return buffer[0];
}
private static boolean isVisibleChar(int c) {
return 33 <= c && c <= 126;
}
char nextChar() {
int b = readByte();
while (!(b == -1 || isVisibleChar(b)))
b = readByte();
if (b == -1)
throw new NoSuchElementException();
return (char)b;
}
String next() {
int c = nextChar();
var b = new StringBuilder();
do {
b.append((char)c);
c = readByte();
} while (isVisibleChar(c));
return b.toString();
}
String next(int length) {
if (length == 0)
return "";
var b = new StringBuilder(length);
int c = nextChar();
b.append((char)c);
for (int i = 1; i < length; i++) {
c = readByte();
if (!isVisibleChar(c))
throw new InputMismatchException();
b.append((char)c);
}
return b.toString();
}
long nextLong() {
int c = nextChar();
boolean minus = false;
long limit = -Long.MAX_VALUE;
if (c == '-') {
minus = true;
limit = Long.MIN_VALUE;
c = readByte();
}
long n = 0L;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
if (n < limit / 10L)
throw new InputMismatchException("overflow");
n *= 10L;
int digit = c - '0';
if (n < limit + digit)
throw new InputMismatchException("overflow");
n -= digit;
c = readByte();
} while (isVisibleChar(c));
return minus ? n : -n;
}
int nextInt() {
long n = nextLong();
if (n < Integer.MIN_VALUE || n > Integer.MAX_VALUE)
throw new InputMismatchException();
return (int)n;
}
double nextDouble() {
return Double.parseDouble(next());
}
int[] nextIntArray(int length) {
var a = new int[length];
for (int i = 0; i < length; i++)
a[i] = nextInt();
return a;
}
long[] nextLongArray(int length) {
var a = new long[length];
for (int i = 0; i < length; i++)
a[i] = nextLong();
return a;
}
char[] nextCharArray(int length) {
var a = new char[length];
for (int i = 0; i < length; i++)
a[i] = nextChar();
return a;
}
int[][] next2dIntArray(int height, int width) {
var a = new int[height][width];
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
a[i][j] = nextInt();
return a;
}
long[][] next2dLongArray(int height, int width) {
var a = new long[height][width];
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
a[i][j] = nextLong();
return a;
}
char[][] next2dCharArray(int height, int width) {
var a = new char[height][width];
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
a[i][j] = nextChar();
return a;
}
int[][] nextVerticalIntArrays(int arrayCount, int arrayLength) {
var a = new int[arrayCount][arrayLength];
for (int i = 0; i < arrayLength; i++)
for (int j = 0; j < arrayCount; j++)
a[j][i] = nextInt();
return a;
}
long[][] nextVerticalLongArrays(int arrayCount, int arrayLength) {
var a = new long[arrayCount][arrayLength];
for (int i = 0; i < arrayLength; i++)
for (int j = 0; j < arrayCount; j++)
a[j][i] = nextLong();
return a;
}
List<String> nextStringList(int length) {
var a = new ArrayList<String>(length);
for (int i = 0; i < length; i++)
a.add(next());
return a;
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.ToIntFunction;
public final class Main {
void solve(Input in, PrintWriter out) {
int N = in.nextInt();
int K = in.nextInt();
int[] P = in.nextIntArray(N);
int[] Q = in.nextIntArray(N);
decrement(P);
decrement(Q);
var a = new int[N];
for (int i = 0; i < P.length; i++) {
a[P[i]] = Q[i];
}
var dp = new long[N + 1][K + 1][N + 1];
dp[0][0][N] = 1;
for (int i = 0; i < N; i++) {
for (int k = 0; k <= K; k++) {
for (int q = 0; q <= N; q++) {
if (k + 1 <= K && a[i] < q) {
add(dp[i + 1][k + 1], q, dp[i][k][q]);
}
add(dp[i + 1][k], Math.min(q, a[i]), dp[i][k][q]);
}
}
}
var ans = mint(0);
for (int q = 0; q <= N; q++) {
ans.add(dp[N][K][q]);
}
out.println(ans);
}
private static int[] decrement(int[] a) {
for (int i = 0; i < a.length; i++)
a[i]--;
return a;
}
private static final int MOD = 998_244_353;
static int rem(long a) {
return Mod.rem(a, MOD);
}
static long add(long x, long y) {
return Mod.add(x, y, MOD);
}
static void add(long[] a, int i, long v) {
Mod.add(a, i, v, MOD);
}
static long sub(long x, long y) {
return Mod.sub(x, y, MOD);
}
static long mul(long x, long y) {
return Mod.mul(x, y, MOD);
}
static long pow(long base, long exp) {
return Mod.pow(base, exp, MOD);
}
static long pow(long base, ToIntFunction<Mod> exp) {
return Mod.pow(base, exp, MOD);
}
static long mulInverse(long a) {
return Mod.mulInverse(a, MOD);
}
static long div(long x, long y) {
return Mod.div(x, y, MOD);
}
static long[] cachePow(long base, int maxExponent) {
return Mod.cachePow(base, maxExponent, MOD);
}
static long[] factorial(int maxN) {
return Mod.factorial(maxN, MOD);
}
static long[] inverseFactorial(long[] factorial) {
return Mod.inverseFactorial(factorial, MOD);
}
static Mod.Permutation permutation(int maxN) {
return Mod.permutation(maxN, MOD);
}
static Mod.Combination combination(int maxN) {
return Mod.combination(maxN, MOD);
}
static Mod.Int mint(long initialValue) {
return Mod.mint(initialValue, MOD);
}
static Mod.Int mint(Mod.Int initialValue) {
return Mod.mint(initialValue, MOD);
}
static final class Mod {
final int divisor;
Mod(int divisor) {
if (divisor <= 0)
throw new IllegalArgumentException();
this.divisor = divisor;
}
static int rem(long a, int mod) {
a %= mod;
if (a < 0)
return (int)(a + mod);
return (int)a;
}
int rem(long a) {
return rem(a, divisor);
}
static long add(long x, long y, int mod) {
long z = x + y;
if (((x ^ z) & (y ^ z)) < 0)
return x % mod + y % mod;
return z;
}
long add(long x, long y) {
return add(x, y, divisor);
}
static void add(long[] a, int i, long v, int mod) {
a[i] = add(a[i], v, mod);
}
void add(long[] a, int index, long v) {
add(a, index, v, divisor);
}
static long sub(long x, long y, int mod) {
long z = x - y;
if (((x ^ y) & (x ^ z)) < 0)
return x % mod - y % mod;
return z;
}
long sub(long x, long y) {
return sub(x, y, divisor);
}
static final long MUL_SAFE_MIN = Integer.MIN_VALUE + 1;
static final long MUL_SAFE_MAX = Integer.MAX_VALUE;
static long mul(long x, long y, int mod) {
if (x > MUL_SAFE_MAX || x < MUL_SAFE_MIN)
x %= mod;
if (y > MUL_SAFE_MAX || y < MUL_SAFE_MIN)
y %= mod;
return x * y;
}
long mul(long x, long y) {
return mul(x, y, divisor);
}
static long pow(long base, long exp, int mod) {
if (exp < 0)
throw new IllegalArgumentException();
long res = 1;
for (long e = exp; e > 0; e >>= 1) {
if ((e & 1) != 0)
res = mul(res, base, mod);
base = mul(base, base, mod);
}
return res;
}
long pow(long base, long exp) {
return pow(base, exp, divisor);
}
static long pow(long base, ToIntFunction<Mod> exp, int mod) {
// assert isPrime(mod);
if (base % mod == 0)
return 0;
return pow(base, exp.applyAsInt(new Mod(mod - 1)), mod);
}
long pow(long base, ToIntFunction<Mod> exp) {
return pow(base, exp, divisor);
}
static long mulInverse(long a, int mod) {
// assert isCoprime(a, m);
if (mod == 1)
return 0;
if (a == 0)
throw new IllegalArgumentException("divide by zero");
a = rem(a, mod);
long b = mod, x = 1, u = 0, tmp;
while (b != 0) {
long k = a / b;
a -= k * b;
tmp = a;
a = b;
b = tmp;
x -= k * u;
tmp = x;
x = u;
u = tmp;
}
if (a != 1)
throw new IllegalArgumentException("divide by zero");
return rem(x, mod);
}
long mulInverse(long a) {
return mulInverse(a, divisor);
}
static long div(long x, long y, int mod) {
return mul(x, mulInverse(y, mod), mod);
}
long div(long x, long y) {
return div(x, y, divisor);
}
static long[] cachePow(long base, int maxExponent, int mod) {
var res = new long[maxExponent + 1];
long v = res[0] = 1;
base = rem(base, mod);
for (int i = 1; i <= maxExponent; i++) {
v *= base;
if (v > MUL_SAFE_MAX)
v %= mod;
res[i] = v;
}
return res;
}
long[] cachePow(long base, int maxExponent) {
return cachePow(base, maxExponent, divisor);
}
static long[] factorial(int maxN, int mod) {
var res = new long[maxN + 1];
long v = res[0] = res[1] = 1;
for (int i = 2; i <= maxN; i++) {
v *= i;
if (v > MUL_SAFE_MAX)
v %= mod;
res[i] = v;
}
return res;
}
long[] factorial(int maxN) {
return factorial(maxN, divisor);
}
static long[] inverseFactorial(long[] factorial, int mod) {
int n = factorial.length;
var res = new long[n];
long v = res[n - 1] = mulInverse(factorial[n - 1], mod);
for (int i = n - 1; i > 0; i--) {
v *= i;
if (v > MUL_SAFE_MAX)
v %= mod;
res[i - 1] = v;
}
return res;
}
long[] inverseFactorial(long[] factorial) {
return inverseFactorial(factorial, divisor);
}
static Permutation permutation(int maxN, int mod) {
long[] fact = factorial(maxN, mod);
long[] invFact = inverseFactorial(fact, mod);
return new Permutation(fact, invFact, mod);
}
Permutation permutation(int maxN) {
return permutation(maxN, divisor);
}
static final class Permutation {
final int divisor;
final long[] factorial;
final long[] inverseFactorial;
private Permutation(long[] factorial,
long[] inverseFactorial,
int divisor) {
this.divisor = divisor;
this.factorial = factorial;
this.inverseFactorial = inverseFactorial;
}
long of(int n, int k) {
if (k > n)
return 0;
return mul(factorial[n], inverseFactorial[n - k], divisor);
}
Combination combination() {
return new Combination(factorial, inverseFactorial, divisor);
}
}
static Combination combination(int maxN, int mod) {
long[] fact = factorial(maxN, mod);
long[] invFact = inverseFactorial(fact, mod);
return new Combination(fact, invFact, mod);
}
Combination combination(int maxN) {
return combination(maxN, divisor);
}
static final class Combination {
final int divisor;
final long[] factorial;
final long[] inverseFactorial;
private Combination(long[] factorial,
long[] inverseFactorial,
int divisor) {
this.divisor = divisor;
this.factorial = factorial;
this.inverseFactorial = inverseFactorial;
}
long of(int n, int k) {
if (k > n)
return 0;
return mul(mul(factorial[n], inverseFactorial[k], divisor),
inverseFactorial[n - k],
divisor);
}
Permutation permutation() {
return new Permutation(factorial, inverseFactorial, divisor);
}
}
static Int mint(long initialValue, int mod) {
return new Int(initialValue, mod);
}
Int mint(long initialValue) {
return mint(initialValue, divisor);
}
static Int mint(Int initialValue, int mod) {
return new Int(initialValue.rawValue, mod);
}
Int mint(Int initialValue) {
return mint(initialValue, divisor);
}
static final class Int {
final int divisor;
private long rawValue;
private Int(long initialValue, int divisor) {
this.divisor = divisor;
rawValue = initialValue;
}
int rem() {
return (int)(rawValue = Mod.rem(rawValue, divisor));
}
Int set(long value) {
this.rawValue = value;
return this;
}
Int add(long a) {
rawValue = Mod.add(rawValue, a, divisor);
return this;
}
Int add(Int a) {
return add(a.rawValue);
}
Int sub(long a) {
rawValue = Mod.sub(rawValue, a, divisor);
return this;
}
Int sub(Int a) {
return sub(a.rawValue);
}
Int mul(long a) {
rawValue = Mod.mul(rawValue, a, divisor);
return this;
}
Int mul(Int a) {
return mul(a.rawValue);
}
Int pow(long exponent) {
rawValue = Mod.pow(rawValue, exponent, divisor);
return this;
}
Int div(long a) {
rawValue = Mod.div(rawValue, a, divisor);
return this;
}
Int div(Int a) {
return div(a.rawValue);
}
void addTo(long[] a, int i) {
Mod.add(a, i, rawValue, divisor);
}
@Override
public String toString() {
return Integer.toString(rem());
}
}
}
public static void main(String[] args) {
var w = new PrintWriter(System.out);
new Main().solve(new Input(System.in), w);
w.flush();
}
static final class Input {
private final InputStream in;
private final byte[] buffer = new byte[8192];
private int point;
private int readLength;
Input(InputStream in) {
this.in = Objects.requireNonNull(in);
}
private int readByte() {
if (point < readLength)
return buffer[point++];
try {
readLength = in.read(buffer);
} catch (IOException e) {
throw new AssertionError(null, e);
}
if (readLength == -1)
return -1;
point = 1;
return buffer[0];
}
private static boolean isVisibleChar(int c) {
return 33 <= c && c <= 126;
}
char nextChar() {
int b = readByte();
while (!(b == -1 || isVisibleChar(b)))
b = readByte();
if (b == -1)
throw new NoSuchElementException();
return (char)b;
}
String next() {
int c = nextChar();
var b = new StringBuilder();
do {
b.append((char)c);
c = readByte();
} while (isVisibleChar(c));
return b.toString();
}
String next(int length) {
if (length == 0)
return "";
var b = new StringBuilder(length);
int c = nextChar();
b.append((char)c);
for (int i = 1; i < length; i++) {
c = readByte();
if (!isVisibleChar(c))
throw new InputMismatchException();
b.append((char)c);
}
return b.toString();
}
long nextLong() {
int c = nextChar();
boolean minus = false;
long limit = -Long.MAX_VALUE;
if (c == '-') {
minus = true;
limit = Long.MIN_VALUE;
c = readByte();
}
long n = 0L;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
if (n < limit / 10L)
throw new InputMismatchException("overflow");
n *= 10L;
int digit = c - '0';
if (n < limit + digit)
throw new InputMismatchException("overflow");
n -= digit;
c = readByte();
} while (isVisibleChar(c));
return minus ? n : -n;
}
int nextInt() {
long n = nextLong();
if (n < Integer.MIN_VALUE || n > Integer.MAX_VALUE)
throw new InputMismatchException();
return (int)n;
}
double nextDouble() {
return Double.parseDouble(next());
}
int[] nextIntArray(int length) {
var a = new int[length];
for (int i = 0; i < length; i++)
a[i] = nextInt();
return a;
}
long[] nextLongArray(int length) {
var a = new long[length];
for (int i = 0; i < length; i++)
a[i] = nextLong();
return a;
}
char[] nextCharArray(int length) {
var a = new char[length];
for (int i = 0; i < length; i++)
a[i] = nextChar();
return a;
}
int[][] next2dIntArray(int height, int width) {
var a = new int[height][width];
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
a[i][j] = nextInt();
return a;
}
long[][] next2dLongArray(int height, int width) {
var a = new long[height][width];
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
a[i][j] = nextLong();
return a;
}
char[][] next2dCharArray(int height, int width) {
var a = new char[height][width];
for (int i = 0; i < height; i++)
for (int j = 0; j < width; j++)
a[i][j] = nextChar();
return a;
}
int[][] nextVerticalIntArrays(int arrayCount, int arrayLength) {
var a = new int[arrayCount][arrayLength];
for (int i = 0; i < arrayLength; i++)
for (int j = 0; j < arrayCount; j++)
a[j][i] = nextInt();
return a;
}
long[][] nextVerticalLongArrays(int arrayCount, int arrayLength) {
var a = new long[arrayCount][arrayLength];
for (int i = 0; i < arrayLength; i++)
for (int j = 0; j < arrayCount; j++)
a[j][i] = nextLong();
return a;
}
List<String> nextStringList(int length) {
var a = new ArrayList<String>(length);
for (int i = 0; i < length; i++)
a.add(next());
return a;
}
}
}
| ConDefects/ConDefects/Code/abc238_f/Java/29131393 |
condefects-java_data_1130 |
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int n, a[][];
public static void main(String[] args) {
n = sc.nextInt();
a = new int[n][2];
for(int i = 0; i < n; i ++){
int l = sc.nextInt();
int r = sc.nextInt();
a[i] = new int[]{l, r};
}
Arrays.sort(a, (a1, a2) -> a1[0] - a2[0]);
//枚举每一个右端点i，查找最大且<=该右端点的线段j ans += j - i
int ans = 0;
for(int i = 0; i < n; i ++){
int cr = a[i][1];
int l = i, r = n - 1, j = l;
while(l <= r){
int m = (r + l) >>> 1;
if(a[m][0] <= cr){
j = m;
l = m + 1;
}else{
r = m - 1;
}
}
ans += j - i;
}
pw.println(ans);
pw.flush();
}
}
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static int n, a[][];
public static void main(String[] args) {
n = sc.nextInt();
a = new int[n][2];
for(int i = 0; i < n; i ++){
int l = sc.nextInt();
int r = sc.nextInt();
a[i] = new int[]{l, r};
}
Arrays.sort(a, (a1, a2) -> a1[0] - a2[0]);
//枚举每一个右端点i，查找最大且<=该右端点的线段j ans += j - i
long ans = 0;
for(int i = 0; i < n; i ++){
int cr = a[i][1];
int l = i, r = n - 1, j = l;
while(l <= r){
int m = (r + l) >>> 1;
if(a[m][0] <= cr){
j = m;
l = m + 1;
}else{
r = m - 1;
}
}
ans += j - i;
}
pw.println(ans);
pw.flush();
}
}
| ConDefects/ConDefects/Code/abc355_d/Java/54155496 |
condefects-java_data_1131 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
static StreamTokenizer st = new StreamTokenizer(br);
public static void solve() throws IOException {
int n=nextInt();
int[]a=new int[n],b=new int[n];
Integer[]arr=new Integer[n];
for(int i=0;i<n;i++) {
a[i]=nextInt();
b[i]=nextInt();
arr[i]=i;//存下标
}
Arrays.sort(arr,(o1,o2)->b[o1]-b[o2]);
long ans=0;
for(int i=0;i<n;i++) {
int t=arr[i];
int l=0,r=i-1,mid,ind=i;
while(l<=r) {
mid=l+(r-l)/2;
if(b[mid]>=a[t]) {
ind=mid;
r=mid-1;
}else {
l=mid+1;
}
}
ans+=(i-ind);
}
pw.print(ans);
}
public static void main(String[] args) throws IOException {
int T = 1;
//T = nextInt();
while (T-- > 0) {
solve();
}
pw.close();
}
public static int nextInt() throws IOException {
st.nextToken();
return (int) st.nval;
}
public static long nextLong() throws IOException {// 不能超过1e16
st.nextToken();
return (long) st.nval;
}
public static double nextDouble() throws IOException {
st.nextToken();
return st.nval;
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
static StreamTokenizer st = new StreamTokenizer(br);
public static void solve() throws IOException {
int n=nextInt();
int[]a=new int[n],b=new int[n];
Integer[]arr=new Integer[n];
for(int i=0;i<n;i++) {
a[i]=nextInt();
b[i]=nextInt();
arr[i]=i;//存下标
}
Arrays.sort(arr,(o1,o2)->b[o1]-b[o2]);
long ans=0;
for(int i=0;i<n;i++) {
int t=arr[i];
int l=0,r=i-1,mid,ind=i;
while(l<=r) {
mid=l+(r-l)/2;
if(b[arr[mid]]>=a[t]) {
ind=mid;
r=mid-1;
}else {
l=mid+1;
}
}
ans+=(i-ind);
}
pw.print(ans);
}
public static void main(String[] args) throws IOException {
int T = 1;
//T = nextInt();
while (T-- > 0) {
solve();
}
pw.close();
}
public static int nextInt() throws IOException {
st.nextToken();
return (int) st.nval;
}
public static long nextLong() throws IOException {// 不能超过1e16
st.nextToken();
return (long) st.nval;
}
public static double nextDouble() throws IOException {
st.nextToken();
return st.nval;
}
} | ConDefects/ConDefects/Code/abc355_d/Java/54000002 |
condefects-java_data_1132 |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
/**
* #
*
* @author pttrung
*/
public class Main {
public static long MOD = 998244353;
static int[] X = {0, 0, 1, -1};
static int[] Y = {1, -1, 0, 0};
public static void main(String[] args) throws FileNotFoundException {
// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
// "output.txt")));
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner();
int n = in.nextInt();
int[][] data = new int[2*n][2];
int index = 0;
for (int i = 0; i < n; i++) {
data[index][0] = in.nextInt();
data[index][1] = 0;
index++;
data[index][0] = in.nextInt();
data[index][1] = 1;
index++;
}
Arrays.sort(data,(a, b)-> {
if(a[0] != b[0]){
return Integer.compare(a[0], b[0]);
}
return Integer.compare(a[1], b[1]);
});
int cur = 0;
int re = 0;
for(int[]a : data){
//System.out.println(Arrays.toString(a) + " " + cur);
if(a[1] == 0){
re += cur;
cur++;
continue;
}
cur--;
}
out.println(re);
out.close();
}
public static int[] KMP(String val) {
int i = 0;
int j = -1;
int[] result = new int[val.length() + 1];
result[0] = -1;
while (i < val.length()) {
while (j >= 0 && val.charAt(j) != val.charAt(i)) {
j = result[j];
}
j++;
i++;
result[i] = j;
}
return result;
}
public static boolean nextPer(int[] data) {
int i = data.length - 1;
while (i > 0 && data[i] < data[i - 1]) {
i--;
}
if (i == 0) {
return false;
}
int j = data.length - 1;
while (data[j] < data[i - 1]) {
j--;
}
int temp = data[i - 1];
data[i - 1] = data[j];
data[j] = temp;
Arrays.sort(data, i, data.length);
return true;
}
public static int digit(long n) {
int result = 0;
while (n > 0) {
n /= 10;
result++;
}
return result;
}
public static double dist(long a, long b, long x, long y) {
double val = (b - a) * (b - a) + (x - y) * (x - y);
val = Math.sqrt(val);
double other = x * x + a * a;
other = Math.sqrt(other);
return val + other;
}
public static class Point implements Comparable<Point> {
int x, y;
public Point(int start, int end) {
this.x = start;
this.y = end;
}
@Override
public int compareTo(Point o) {
if (x != o.x) {
return Long.compare(x, o.x);
}
return Long.compare(y, o.y);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x &&
y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
public String toString() {
return x + " " + y;
}
}
public static class FT {
long[] data;
FT(int n) {
data = new long[n];
}
public void update(int index, long value) {
while (index < data.length) {
data[index] += value;
index += (index & (-index));
}
}
public long get(int index) {
long result = 0;
while (index > 0) {
result += data[index];
index -= (index & (-index));
}
return result;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static long pow(long a, int b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return (val * val) % MOD;
} else {
return (val * ((val * a) % MOD)) % MOD;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() throws FileNotFoundException {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
/**
* #
*
* @author pttrung
*/
public class Main {
public static long MOD = 998244353;
static int[] X = {0, 0, 1, -1};
static int[] Y = {1, -1, 0, 0};
public static void main(String[] args) throws FileNotFoundException {
// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
// "output.txt")));
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner();
int n = in.nextInt();
int[][] data = new int[2*n][2];
int index = 0;
for (int i = 0; i < n; i++) {
data[index][0] = in.nextInt();
data[index][1] = 0;
index++;
data[index][0] = in.nextInt();
data[index][1] = 1;
index++;
}
Arrays.sort(data,(a, b)-> {
if(a[0] != b[0]){
return Integer.compare(a[0], b[0]);
}
return Integer.compare(a[1], b[1]);
});
int cur = 0;
long re = 0;
for(int[]a : data){
//System.out.println(Arrays.toString(a) + " " + cur);
if(a[1] == 0){
re += cur;
cur++;
continue;
}
cur--;
}
out.println(re);
out.close();
}
public static int[] KMP(String val) {
int i = 0;
int j = -1;
int[] result = new int[val.length() + 1];
result[0] = -1;
while (i < val.length()) {
while (j >= 0 && val.charAt(j) != val.charAt(i)) {
j = result[j];
}
j++;
i++;
result[i] = j;
}
return result;
}
public static boolean nextPer(int[] data) {
int i = data.length - 1;
while (i > 0 && data[i] < data[i - 1]) {
i--;
}
if (i == 0) {
return false;
}
int j = data.length - 1;
while (data[j] < data[i - 1]) {
j--;
}
int temp = data[i - 1];
data[i - 1] = data[j];
data[j] = temp;
Arrays.sort(data, i, data.length);
return true;
}
public static int digit(long n) {
int result = 0;
while (n > 0) {
n /= 10;
result++;
}
return result;
}
public static double dist(long a, long b, long x, long y) {
double val = (b - a) * (b - a) + (x - y) * (x - y);
val = Math.sqrt(val);
double other = x * x + a * a;
other = Math.sqrt(other);
return val + other;
}
public static class Point implements Comparable<Point> {
int x, y;
public Point(int start, int end) {
this.x = start;
this.y = end;
}
@Override
public int compareTo(Point o) {
if (x != o.x) {
return Long.compare(x, o.x);
}
return Long.compare(y, o.y);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Point point = (Point) o;
return x == point.x &&
y == point.y;
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
public String toString() {
return x + " " + y;
}
}
public static class FT {
long[] data;
FT(int n) {
data = new long[n];
}
public void update(int index, long value) {
while (index < data.length) {
data[index] += value;
index += (index & (-index));
}
}
public long get(int index) {
long result = 0;
while (index > 0) {
result += data[index];
index -= (index & (-index));
}
return result;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static long pow(long a, int b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return (val * val) % MOD;
} else {
return (val * ((val * a) % MOD)) % MOD;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() throws FileNotFoundException {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
| ConDefects/ConDefects/Code/abc355_d/Java/54065337 |
condefects-java_data_1133 | import java.io.*;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.util.*;
public class Main {
//static Reader sc = new Reader();
static Scanner sc = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
//static Debugger debug = new Debugger();
//static Debug debug = new Debug();
//static int mod = (int)(1e9 + 7);
static int mod = 998244353;
/**Code Starts From Here**/
public static void main(String[] args) throws IOException {
int t = 1;
//int t = sc.nextInt();
while (t-- > 0) {
Attack();
}
sc.close();
out.flush();
}
public static void Attack() throws IOException {
int n = sc.nextInt();
ArrayList<Pair> res = new ArrayList<Pair>();
for(int i = 0; i < n; i++) {
int start = sc.nextInt();
int end = sc.nextInt();
res.add(new Pair(start, end));
}
Collections.sort(res, new sorting());
int total = 0;
for(int i = 0; i < res.size() - 1; i++) {
Pair current = res.get(i);
int ans = binary_search(current, i + 1, res.size() - 1, res);
if(ans == -1) continue;
total += (ans - i);
}
out.println(total);
}
public static int binary_search(Pair current, int s, int e, ArrayList<Pair> res) {
int low = s;
int high = e;
int ans = -1;
while(low <= high) {
int mid = low + (high - low) / 2;
if(res.get(mid).start <= current.end) {
ans = mid;
low = mid + 1;
}
else high = mid - 1;
}
return ans;
}
static class Pair {
int start;
int end;
public Pair(int start, int end) {
this.start = start;
this.end = end;
}
}
static class sorting implements Comparator<Pair> {
@Override
public int compare(Pair first, Pair second) {
int op1 = Integer.compare(first.start, second.start);
if(op1 != 0) return op1;
return Integer.compare(first.end, second.end);
}
}
/**Code Ends Here (No Need To Scroll Down)**/
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(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 {
byte[] buf = new byte[64];
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10 + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10L + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10 + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (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 char[] next() throws IOException {
StringBuilder sb = new StringBuilder();
byte c;
while ((c = read()) <= ' ') ;
do {sb.append((char) c);}
while ((c = read()) > ' ');
return sb.toString().toCharArray();
}
public int nextInt2() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10 + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public void close() throws IOException {
if (din == null) return;
din.close();
}
}
static long fast_pow(long a, long p, long mod) {
long res = 1;
while (p > 0) {
if (p % 2 == 0) {
a = ((a % mod) * (a % mod)) % mod;
p /= 2;
}
else {
res = ((res % mod) * (a % mod)) % mod;
p--;
}
}
return res;
}
static long exp(long base, long exp) {
if (exp == 0)
return 1;
long half = exp(base, exp / 2);
if (exp % 2 == 0)
return mul(half, half);
return mul(half, mul(half, base));
}
//Factorials and Inverse Factorials;
static long[] factorials = new long[2_000_001];
static long[] invFactorials = new long[2_000_001];
static boolean[] isPrime;
static void precompFacts() {
factorials[0] = invFactorials[0] = 1;
for (int i = 1; i < factorials.length; i++)
factorials[i] = mul(factorials[i - 1], i);
invFactorials[factorials.length - 1] = exp(factorials[factorials.length - 1], mod - 2);
for (int i = invFactorials.length - 2; i >= 0; i--)
invFactorials[i] = mul(invFactorials[i + 1], i + 1);
}
static long nCk(int n, int k) {
//use precompFacts first;
return mul(factorials[n], mul(invFactorials[k], invFactorials[n - k]));
}
//Prime Generator;
static void Generate_Primes(int upto) {
// Sieve of Eratosthenes:
isPrime = new boolean[upto + 1];
int[] smallestFactorOf = new int[upto + 1];
Arrays.fill(smallestFactorOf, 1);
Arrays.fill(isPrime, true);
isPrime[1] = isPrime[0] = false;
for (long i = 2; i < upto + 1; i++) {
if (isPrime[(int) i]) {
smallestFactorOf[(int) i] = (int) i;
// Mark all the multiples greater than or equal
// to the square of i to be false.
for (long j = i; j * i < upto + 1; j++) {
if (isPrime[(int) j * (int) i]) {
isPrime[(int) j * (int) i] = false;
smallestFactorOf[(int) j * (int) i] = (int) i;
}
}
}
}
}
static long modinv(long x) {return fast_pow(x, mod - 2, mod);}
static long add(long a, long b) {a += b; if (a >= mod) a-= mod; return a;}
static long mul(long a, long b) {return (long) ((long) ((a % mod) * 1L * (b % mod)) % mod);}
static long Div(long x, long y) {return mul(x, modinv(y));}
static long mod(long a, long b) {long r = a % b;return r < 0 ? r + b : r;}
static long sub(long x, long y) {long z = x - y; if (z < 0) z += mod;return z;}
static long GCD(long x, long y) {if(y == 0) return x;return GCD(y, x % y);}
static long LCM(long a, long b) {return (a / GCD(a, b)) * b;}
public static void sort(int[] arr) {
//because Arrays.sort() uses quicksort which is dumb
//Collections.sort() uses merge sort
ArrayList<Integer> ls = new ArrayList<>();
for (Integer x : arr) ls.add(x);
Collections.sort(ls);
for (int i = 0; i < arr.length; i++) arr[i] = ls.get(i);
}
public static void sort(long[] arr) {
//because Arrays.sort() uses quicksort which is dumb
//Collections.sort() uses merge sort
ArrayList<Long> ls = new ArrayList<>();
for (Long x : arr) ls.add(x);
Collections.sort(ls);
for (int i = 0; i < arr.length; i++) arr[i] = ls.get(i);
}
static class Unique_Pair {
int first;
int second;
Unique_Pair(int 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;
Unique_Pair pair = (Unique_Pair) o;
return first == pair.first && second == pair.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
}
static class MultiSet<T> {
TreeMap<T, Integer> frequency;
TreeSet<T> set;
int size;
public MultiSet() {
set = new TreeSet<>();
frequency = new TreeMap<>();
size = 0;
}
public MultiSet(Comparator<T> cmp) {
set = new TreeSet<>(cmp);
frequency = new TreeMap<>(cmp);
size = 0;
}
public void add(T elem) {
if (frequency.get(elem) == null || frequency.get(elem) == 0) {
frequency.put(elem, 0);
set.add(elem);
}
frequency.put(elem, frequency.get(elem) + 1);
size++;
}
public void remove(T elem) {
if (!set.contains(elem)) return;
frequency.put(elem, frequency.get(elem) - 1);
if (frequency.get(elem) == 0) set.remove(elem);
size--;
}
public boolean contains(T elem) {
return set.contains(elem);
}
}
@SuppressWarnings("serial")
static class CountMap<T> extends TreeMap<T, Integer>{
CountMap() {}
CountMap(T[] arr) {this.putCM(arr);}
public Integer putCM(T key) {
if (super.containsKey(key)) return super.put(key, super.get(key) + 1);
else return super.put(key, 1);
}
public Integer removeCM(T key) {
Integer count = super.get(key);
if (count == null) return -1;
if (count == 1) return super.remove(key);
else return super.put(key, super.get(key) - 1);
}
public Integer getCM(T key) {
Integer count = super.get(key);
if (count == null) return 0;
return count;
}
public void putCM(T[] arr) {
for (T ele : arr) this.putCM(ele);
}
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.util.*;
public class Main {
//static Reader sc = new Reader();
static Scanner sc = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
//static Debugger debug = new Debugger();
//static Debug debug = new Debug();
//static int mod = (int)(1e9 + 7);
static int mod = 998244353;
/**Code Starts From Here**/
public static void main(String[] args) throws IOException {
int t = 1;
//int t = sc.nextInt();
while (t-- > 0) {
Attack();
}
sc.close();
out.flush();
}
public static void Attack() throws IOException {
int n = sc.nextInt();
ArrayList<Pair> res = new ArrayList<Pair>();
for(int i = 0; i < n; i++) {
int start = sc.nextInt();
int end = sc.nextInt();
res.add(new Pair(start, end));
}
Collections.sort(res, new sorting());
long total = 0;
for(int i = 0; i < res.size() - 1; i++) {
Pair current = res.get(i);
int ans = binary_search(current, i + 1, res.size() - 1, res);
if(ans == -1) continue;
total += (ans - i);
}
out.println(total);
}
public static int binary_search(Pair current, int s, int e, ArrayList<Pair> res) {
int low = s;
int high = e;
int ans = -1;
while(low <= high) {
int mid = low + (high - low) / 2;
if(res.get(mid).start <= current.end) {
ans = mid;
low = mid + 1;
}
else high = mid - 1;
}
return ans;
}
static class Pair {
int start;
int end;
public Pair(int start, int end) {
this.start = start;
this.end = end;
}
}
static class sorting implements Comparator<Pair> {
@Override
public int compare(Pair first, Pair second) {
int op1 = Integer.compare(first.start, second.start);
if(op1 != 0) return op1;
return Integer.compare(first.end, second.end);
}
}
/**Code Ends Here (No Need To Scroll Down)**/
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(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 {
byte[] buf = new byte[64];
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10 + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10L + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10 + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (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 char[] next() throws IOException {
StringBuilder sb = new StringBuilder();
byte c;
while ((c = read()) <= ' ') ;
do {sb.append((char) c);}
while ((c = read()) > ' ');
return sb.toString().toCharArray();
}
public int nextInt2() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {ret = ret * 10 + c - '0';}
while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public void close() throws IOException {
if (din == null) return;
din.close();
}
}
static long fast_pow(long a, long p, long mod) {
long res = 1;
while (p > 0) {
if (p % 2 == 0) {
a = ((a % mod) * (a % mod)) % mod;
p /= 2;
}
else {
res = ((res % mod) * (a % mod)) % mod;
p--;
}
}
return res;
}
static long exp(long base, long exp) {
if (exp == 0)
return 1;
long half = exp(base, exp / 2);
if (exp % 2 == 0)
return mul(half, half);
return mul(half, mul(half, base));
}
//Factorials and Inverse Factorials;
static long[] factorials = new long[2_000_001];
static long[] invFactorials = new long[2_000_001];
static boolean[] isPrime;
static void precompFacts() {
factorials[0] = invFactorials[0] = 1;
for (int i = 1; i < factorials.length; i++)
factorials[i] = mul(factorials[i - 1], i);
invFactorials[factorials.length - 1] = exp(factorials[factorials.length - 1], mod - 2);
for (int i = invFactorials.length - 2; i >= 0; i--)
invFactorials[i] = mul(invFactorials[i + 1], i + 1);
}
static long nCk(int n, int k) {
//use precompFacts first;
return mul(factorials[n], mul(invFactorials[k], invFactorials[n - k]));
}
//Prime Generator;
static void Generate_Primes(int upto) {
// Sieve of Eratosthenes:
isPrime = new boolean[upto + 1];
int[] smallestFactorOf = new int[upto + 1];
Arrays.fill(smallestFactorOf, 1);
Arrays.fill(isPrime, true);
isPrime[1] = isPrime[0] = false;
for (long i = 2; i < upto + 1; i++) {
if (isPrime[(int) i]) {
smallestFactorOf[(int) i] = (int) i;
// Mark all the multiples greater than or equal
// to the square of i to be false.
for (long j = i; j * i < upto + 1; j++) {
if (isPrime[(int) j * (int) i]) {
isPrime[(int) j * (int) i] = false;
smallestFactorOf[(int) j * (int) i] = (int) i;
}
}
}
}
}
static long modinv(long x) {return fast_pow(x, mod - 2, mod);}
static long add(long a, long b) {a += b; if (a >= mod) a-= mod; return a;}
static long mul(long a, long b) {return (long) ((long) ((a % mod) * 1L * (b % mod)) % mod);}
static long Div(long x, long y) {return mul(x, modinv(y));}
static long mod(long a, long b) {long r = a % b;return r < 0 ? r + b : r;}
static long sub(long x, long y) {long z = x - y; if (z < 0) z += mod;return z;}
static long GCD(long x, long y) {if(y == 0) return x;return GCD(y, x % y);}
static long LCM(long a, long b) {return (a / GCD(a, b)) * b;}
public static void sort(int[] arr) {
//because Arrays.sort() uses quicksort which is dumb
//Collections.sort() uses merge sort
ArrayList<Integer> ls = new ArrayList<>();
for (Integer x : arr) ls.add(x);
Collections.sort(ls);
for (int i = 0; i < arr.length; i++) arr[i] = ls.get(i);
}
public static void sort(long[] arr) {
//because Arrays.sort() uses quicksort which is dumb
//Collections.sort() uses merge sort
ArrayList<Long> ls = new ArrayList<>();
for (Long x : arr) ls.add(x);
Collections.sort(ls);
for (int i = 0; i < arr.length; i++) arr[i] = ls.get(i);
}
static class Unique_Pair {
int first;
int second;
Unique_Pair(int 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;
Unique_Pair pair = (Unique_Pair) o;
return first == pair.first && second == pair.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
}
static class MultiSet<T> {
TreeMap<T, Integer> frequency;
TreeSet<T> set;
int size;
public MultiSet() {
set = new TreeSet<>();
frequency = new TreeMap<>();
size = 0;
}
public MultiSet(Comparator<T> cmp) {
set = new TreeSet<>(cmp);
frequency = new TreeMap<>(cmp);
size = 0;
}
public void add(T elem) {
if (frequency.get(elem) == null || frequency.get(elem) == 0) {
frequency.put(elem, 0);
set.add(elem);
}
frequency.put(elem, frequency.get(elem) + 1);
size++;
}
public void remove(T elem) {
if (!set.contains(elem)) return;
frequency.put(elem, frequency.get(elem) - 1);
if (frequency.get(elem) == 0) set.remove(elem);
size--;
}
public boolean contains(T elem) {
return set.contains(elem);
}
}
@SuppressWarnings("serial")
static class CountMap<T> extends TreeMap<T, Integer>{
CountMap() {}
CountMap(T[] arr) {this.putCM(arr);}
public Integer putCM(T key) {
if (super.containsKey(key)) return super.put(key, super.get(key) + 1);
else return super.put(key, 1);
}
public Integer removeCM(T key) {
Integer count = super.get(key);
if (count == null) return -1;
if (count == 1) return super.remove(key);
else return super.put(key, super.get(key) - 1);
}
public Integer getCM(T key) {
Integer count = super.get(key);
if (count == null) return 0;
return count;
}
public void putCM(T[] arr) {
for (T ele : arr) this.putCM(ele);
}
}
} | ConDefects/ConDefects/Code/abc355_d/Java/54159560 |
condefects-java_data_1134 | import java.util.Comparator;
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 result = 0;
Range[] list = new Range[n+1];
for (int i=0; i<n; i++) {
list[i] = new Range(sc.nextInt(), sc.nextInt());
}
list[n] = new Range(1000000001, 1000000001);
// 配列を l の昇順にソート
Arrays.sort(list, Comparator.comparingInt(value -> value.l));
for (int i=0; i<n; i++) {
int left = i;
int right = n + 1;
int mid;
while (right - left > 1) {
mid = (left + right) / 2;
//System.out.println("i-R:"+list[i].r+"j-L:"+list[mid - 1].l);
if (list[mid].l <= list[i].r) {
left = mid;
} else {
right = mid;
}
//System.out.println("left:"+left+"mid:"+mid+"right:"+right);
}
//System.out.println("i:"+i+" left:"+left+"right:"+right);
result += left - i;
}
System.out.println(result);
}
}
class Range {
public int l;
public int r;
Range(int l, int r) {
this.l = l;
this.r = r;
}
}
import java.util.Comparator;
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();
long result = 0;
Range[] list = new Range[n+1];
for (int i=0; i<n; i++) {
list[i] = new Range(sc.nextInt(), sc.nextInt());
}
list[n] = new Range(1000000001, 1000000001);
// 配列を l の昇順にソート
Arrays.sort(list, Comparator.comparingInt(value -> value.l));
for (int i=0; i<n; i++) {
int left = i;
int right = n + 1;
int mid;
while (right - left > 1) {
mid = (left + right) / 2;
//System.out.println("i-R:"+list[i].r+"j-L:"+list[mid - 1].l);
if (list[mid].l <= list[i].r) {
left = mid;
} else {
right = mid;
}
//System.out.println("left:"+left+"mid:"+mid+"right:"+right);
}
//System.out.println("i:"+i+" left:"+left+"right:"+right);
result += left - i;
}
System.out.println(result);
}
}
class Range {
public int l;
public int r;
Range(int l, int r) {
this.l = l;
this.r = r;
}
} | ConDefects/ConDefects/Code/abc355_d/Java/54016443 |
condefects-java_data_1135 |
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* #
*
* @author pttrung
*/
public class Main {
public static long MOD = 998244353;
public static void main(String[] args) throws FileNotFoundException {
// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
// "output.txt")));
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner();
int T = in.nextInt();
for (int z = 0; z < T; z++) {
int n = in.nextInt();
int k = in.nextInt();
boolean ok = true;
int first = -1;
int last = -1;
int zero = -1;
String data = in.next();
for (int i = 0; i < n && ok; i++) {
if (data.charAt(i) == '1') {
if (first == -1) {
first = i;
}
if (zero != -1 && first != -1 && first < zero && zero < i) {
System.out.println(first + " " + zero + " " + i);
ok = false;
break;
}
last = i;
continue;
}
if (data.charAt(i) == '?') {
continue;
}
zero = i;
}
//System.out.println(ok);
if (!ok) {
out.println("No");
continue;
}
if (first == -1) {
int cur = 0;
int total = 0;
for (int i = 0; i < n; i++) {
if (data.charAt(i) == '?') {
cur++;
continue;
}
if (cur == k) {
total++;
cur = 0;
continue;
}
if (cur > k) {
ok = false;
break;
}
cur = 0;
}
if (cur == k) {
total++;
} else if (cur > k) {
ok = false;
}
out.println((ok && total == 1) ? "Yes" : "No");
continue;
}
int a = first;
int b = last;
while (a > 0 && data.charAt(a - 1) == '?' && (last - a + 2) <= k) {
a--;
}
while (b < n - 1 && data.charAt(b + 1) == '?' && (b - first + 2) <= k) {
b++;
}
//System.out.println(a + " " + b);
out.println(((b - a + 1) == k) ? "Yes" : "No");
}
out.close();
}
static int abs(int a) {
return a < 0 ? -a : a;
}
public static int[] KMP(String val) {
int i = 0;
int j = -1;
int[] result = new int[val.length() + 1];
result[0] = -1;
while (i < val.length()) {
while (j >= 0 && val.charAt(j) != val.charAt(i)) {
j = result[j];
}
j++;
i++;
result[i] = j;
}
return result;
}
public static boolean nextPer(int[] data) {
int i = data.length - 1;
while (i > 0 && data[i] < data[i - 1]) {
i--;
}
if (i == 0) {
return false;
}
int j = data.length - 1;
while (data[j] < data[i - 1]) {
j--;
}
int temp = data[i - 1];
data[i - 1] = data[j];
data[j] = temp;
Arrays.sort(data, i, data.length);
return true;
}
public static int digit(long n) {
int result = 0;
while (n > 0) {
n /= 10;
result++;
}
return result;
}
public static double dist(long a, long b, long x, long y) {
double val = (b - a) * (b - a) + (x - y) * (x - y);
val = Math.sqrt(val);
double other = x * x + a * a;
other = Math.sqrt(other);
return val + other;
}
public static class Point {
int x;
int y;
public Point(int start, int end) {
this.x = start;
this.y = end;
}
public String toString() {
return x + " " + y;
}
}
public static class FT {
long[] data;
FT(int n) {
data = new long[n];
}
public void update(int index, long value) {
while (index < data.length) {
data[index] += value;
index += (index & (-index));
}
}
public long get(int index) {
long result = 0;
while (index > 0) {
result += data[index];
index -= (index & (-index));
}
return result;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static long pow(long a, long b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return (val * val) % MOD;
} else {
return (val * ((val * a) % MOD)) % MOD;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() throws FileNotFoundException {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* #
*
* @author pttrung
*/
public class Main {
public static long MOD = 998244353;
public static void main(String[] args) throws FileNotFoundException {
// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
// "output.txt")));
PrintWriter out = new PrintWriter(System.out);
Scanner in = new Scanner();
int T = in.nextInt();
for (int z = 0; z < T; z++) {
int n = in.nextInt();
int k = in.nextInt();
boolean ok = true;
int first = -1;
int last = -1;
int zero = -1;
String data = in.next();
for (int i = 0; i < n && ok; i++) {
if (data.charAt(i) == '1') {
if (first == -1) {
first = i;
}
if (zero != -1 && first != -1 && first < zero && zero < i) {
//System.out.println(first + " " + zero + " " + i);
ok = false;
break;
}
last = i;
continue;
}
if (data.charAt(i) == '?') {
continue;
}
zero = i;
}
//System.out.println(ok);
if (!ok) {
out.println("No");
continue;
}
if (first == -1) {
int cur = 0;
int total = 0;
for (int i = 0; i < n; i++) {
if (data.charAt(i) == '?') {
cur++;
continue;
}
if (cur == k) {
total++;
cur = 0;
continue;
}
if (cur > k) {
ok = false;
break;
}
cur = 0;
}
if (cur == k) {
total++;
} else if (cur > k) {
ok = false;
}
out.println((ok && total == 1) ? "Yes" : "No");
continue;
}
int a = first;
int b = last;
while (a > 0 && data.charAt(a - 1) == '?' && (last - a + 2) <= k) {
a--;
}
while (b < n - 1 && data.charAt(b + 1) == '?' && (b - first + 2) <= k) {
b++;
}
//System.out.println(a + " " + b);
out.println(((b - a + 1) == k) ? "Yes" : "No");
}
out.close();
}
static int abs(int a) {
return a < 0 ? -a : a;
}
public static int[] KMP(String val) {
int i = 0;
int j = -1;
int[] result = new int[val.length() + 1];
result[0] = -1;
while (i < val.length()) {
while (j >= 0 && val.charAt(j) != val.charAt(i)) {
j = result[j];
}
j++;
i++;
result[i] = j;
}
return result;
}
public static boolean nextPer(int[] data) {
int i = data.length - 1;
while (i > 0 && data[i] < data[i - 1]) {
i--;
}
if (i == 0) {
return false;
}
int j = data.length - 1;
while (data[j] < data[i - 1]) {
j--;
}
int temp = data[i - 1];
data[i - 1] = data[j];
data[j] = temp;
Arrays.sort(data, i, data.length);
return true;
}
public static int digit(long n) {
int result = 0;
while (n > 0) {
n /= 10;
result++;
}
return result;
}
public static double dist(long a, long b, long x, long y) {
double val = (b - a) * (b - a) + (x - y) * (x - y);
val = Math.sqrt(val);
double other = x * x + a * a;
other = Math.sqrt(other);
return val + other;
}
public static class Point {
int x;
int y;
public Point(int start, int end) {
this.x = start;
this.y = end;
}
public String toString() {
return x + " " + y;
}
}
public static class FT {
long[] data;
FT(int n) {
data = new long[n];
}
public void update(int index, long value) {
while (index < data.length) {
data[index] += value;
index += (index & (-index));
}
}
public long get(int index) {
long result = 0;
while (index > 0) {
result += data[index];
index -= (index & (-index));
}
return result;
}
}
public static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
public static long pow(long a, long b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
long val = pow(a, b / 2);
if (b % 2 == 0) {
return (val * val) % MOD;
} else {
return (val * ((val * a) % MOD)) % MOD;
}
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner() throws FileNotFoundException {
// System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (Exception e) {
throw new RuntimeException();
}
}
return st.nextToken();
}
public long nextLong() {
return Long.parseLong(next());
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
st = null;
try {
return br.readLine();
} catch (Exception e) {
throw new RuntimeException();
}
}
public boolean endLine() {
try {
String next = br.readLine();
while (next != null && next.trim().isEmpty()) {
next = br.readLine();
}
if (next == null) {
return true;
}
st = new StringTokenizer(next);
return st.hasMoreTokens();
} catch (Exception e) {
throw new RuntimeException();
}
}
}
} | ConDefects/ConDefects/Code/arc150_a/Java/35571849 |
condefects-java_data_1136 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.text.Format;
import java.util.*;
import java.util.function.Function;
import java.util.function.IntPredicate;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
@SuppressWarnings("unchecked")
public class Main {
public static void main(String[] args) {
solve(System.in, System.out);
}
private static void solve(PrintWriter pw, FastScanner fs) {
//==================
var N = fs.ni();
var ca = fs.n().toCharArray();
var ans = 0l;
for (int i = N - 2; i >= 0; i--) {
var j = i;
var cnt = 0;
while (j >= 0 && ca[j] == '>') {
cnt++;
j--;
}
ans += (cnt * ( cnt + 1)) /2;
i = j;
}
pw.println(ans);
}
//--------------
record Pair(long a, long b) {
}
record Triple(long a, long b, long c) {
}
public static void solve(InputStream in, PrintStream out) {
PrintWriter pw = new PrintWriter(out);
FastScanner fs = new FastScanner(in);
try {
solve(pw, fs);
} finally {
pw.flush();
}
}
//-------------------------------------------------------------------
/**
* 各インデックスが配列の長さ以内に収まっているか境界チェックを行う
* <p>
* 多次元配列のチェックをいちいち書くのがしんどい時に。
* arrayBound(new int[]{1,2,3} , new int[]{3,4,3})
*
* @param target 配列に設定したいインデックス
* @param len 配列の長さ
* @return 配列の長さ内に収まってる時 true
*/
private static boolean inarr(int[] target, int[] len) {
var b = true;
if (target.length != len.length) {
throw new IllegalArgumentException();
}
for (int i = 0; i < target.length; i++) {
b &= (0 <= target[i] && target[i] < len[i]);
}
return b;
}
private static int[] arr(int... a) {
return a;
}
private static long[] arr(long... a) {
return a;
}
//http://fantom1x.blog130.fc2.com/blog-entry-194.html
/**
* <h1>指定した値以上の先頭のインデクスを返す</h1>
* <p>配列要素が０のときは、０が返る。</p>
*
* @param arr ： 探索対象配列(単調増加であること)
* @param value ： 探索する値
* @return<b>int</b> ： 探索した値以上で、先頭になるインデクス
*/
public static final int lowerBound(final long[] arr, final long value) {
int low = 0;
int high = arr.length;
int mid;
while (low < high) {
mid = ((high - low) >>> 1) + low; //(low + high) / 2 (オーバーフロー対策)
if (arr[mid] < value) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
/**
* <h1>指定した値より大きい先頭のインデクスを返す</h1>
* <p>配列要素が０のときは、０が返る。</p>
*
* @param arr ： 探索対象配列(単調増加であること)
* @param value ： 探索する値
* @return<b>int</b> ： 探索した値より上で、先頭になるインデクス
*/
public static final int upperBound(final long[] arr, final long value) {
int low = 0;
int high = arr.length;
int mid;
while (low < high) {
mid = ((high - low) >>> 1) + low; //(low + high) / 2 (オーバーフロー対策)
if (arr[mid] <= value) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
//----------------
public static class FastScanner {
InputStream in;
byte[] buffer = new byte[1 << 10];
int length = 0;
int ptr = 0;
private final Predicate<Byte> isPrintable;
public FastScanner(InputStream in) {
this.in = in;
this.isPrintable = b -> (33 <= b && b <= 126);
}
public FastScanner(InputStream in, Predicate<Byte> predicate) {
this.in = in;
this.isPrintable = predicate;
}
private boolean hasNextByte() {
if (ptr < length) {
return true;
}
try {
length = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
ptr = 0;
return length != 0;
}
private byte read() {
if (hasNextByte()) {
return buffer[ptr++];
}
return 0;
}
private void skip() {
while (hasNextByte() && !isPrintable(buffer[ptr])) {
ptr++;
}
}
private boolean hasNext() {
skip();
return hasNextByte();
}
private boolean isPrintable(byte b) {
return 33 <= b && b <= 126;
}
private String innerNext(Predicate<Byte> isReadable) {
if (!hasNext()) {
throw new NoSuchElementException();
}
StringBuilder sb = new StringBuilder();
byte b = read();
while (isReadable.test(b)) {
sb.appendCodePoint(b);
b = read();
}
return sb.toString();
}
public String n() {
return innerNext(b -> (33 <= b && b <= 126));
}
public int ni() {
return (int) nl();
}
public char[][] ncaa(int n, int m) {
var grid = new char[n][m];
for (int i = 0; i < n; i++) {
grid[i] = n().toCharArray();
}
return grid;
}
public int[] nia(int n) {
int[] result = new int[n];
for (int i = 0; i < n; i++) {
result[i] = ni();
}
return result;
}
public int[][] niaa(int h, int w) {
int[][] result = new int[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
result[i][j] = ni();
}
}
return result;
}
public long[][] nlaa(int h, int w) {
long[][] result = new long[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
result[i][j] = nl();
}
}
return result;
}
public String[] na(int n) {
String[] result = new String[n];
for (int i = 0; i < n; i++) {
result[i] = n();
}
return result;
}
public long[] nla(int n) {
long[] result = new long[n];
for (int i = 0; i < n; i++) {
result[i] = nl();
}
return result;
}
public long nl() {
if (!hasNext()) {
throw new NoSuchElementException();
}
long result = 0;
boolean minus = false;
byte b;
b = read();
if (b == '-') {
minus = true;
b = read();
}
while (isPrintable(b)) {
if (b < '0' || b > '9') {
throw new NumberFormatException();
}
result *= 10;
result += (b - '0');
b = read();
}
return minus ? -result : result;
}
}
//-------------------------------------------------------------------
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.text.Format;
import java.util.*;
import java.util.function.Function;
import java.util.function.IntPredicate;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
@SuppressWarnings("unchecked")
public class Main {
public static void main(String[] args) {
solve(System.in, System.out);
}
private static void solve(PrintWriter pw, FastScanner fs) {
//==================
var N = fs.ni();
var ca = fs.n().toCharArray();
var ans = 0l;
for (int i = N - 2; i >= 0; i--) {
var j = i;
var cnt = 0l;
while (j >= 0 && ca[j] == '>') {
cnt++;
j--;
}
ans += (cnt * ( cnt + 1)) /2;
i = j;
}
pw.println(ans);
}
//--------------
record Pair(long a, long b) {
}
record Triple(long a, long b, long c) {
}
public static void solve(InputStream in, PrintStream out) {
PrintWriter pw = new PrintWriter(out);
FastScanner fs = new FastScanner(in);
try {
solve(pw, fs);
} finally {
pw.flush();
}
}
//-------------------------------------------------------------------
/**
* 各インデックスが配列の長さ以内に収まっているか境界チェックを行う
* <p>
* 多次元配列のチェックをいちいち書くのがしんどい時に。
* arrayBound(new int[]{1,2,3} , new int[]{3,4,3})
*
* @param target 配列に設定したいインデックス
* @param len 配列の長さ
* @return 配列の長さ内に収まってる時 true
*/
private static boolean inarr(int[] target, int[] len) {
var b = true;
if (target.length != len.length) {
throw new IllegalArgumentException();
}
for (int i = 0; i < target.length; i++) {
b &= (0 <= target[i] && target[i] < len[i]);
}
return b;
}
private static int[] arr(int... a) {
return a;
}
private static long[] arr(long... a) {
return a;
}
//http://fantom1x.blog130.fc2.com/blog-entry-194.html
/**
* <h1>指定した値以上の先頭のインデクスを返す</h1>
* <p>配列要素が０のときは、０が返る。</p>
*
* @param arr ： 探索対象配列(単調増加であること)
* @param value ： 探索する値
* @return<b>int</b> ： 探索した値以上で、先頭になるインデクス
*/
public static final int lowerBound(final long[] arr, final long value) {
int low = 0;
int high = arr.length;
int mid;
while (low < high) {
mid = ((high - low) >>> 1) + low; //(low + high) / 2 (オーバーフロー対策)
if (arr[mid] < value) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
/**
* <h1>指定した値より大きい先頭のインデクスを返す</h1>
* <p>配列要素が０のときは、０が返る。</p>
*
* @param arr ： 探索対象配列(単調増加であること)
* @param value ： 探索する値
* @return<b>int</b> ： 探索した値より上で、先頭になるインデクス
*/
public static final int upperBound(final long[] arr, final long value) {
int low = 0;
int high = arr.length;
int mid;
while (low < high) {
mid = ((high - low) >>> 1) + low; //(low + high) / 2 (オーバーフロー対策)
if (arr[mid] <= value) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
//----------------
public static class FastScanner {
InputStream in;
byte[] buffer = new byte[1 << 10];
int length = 0;
int ptr = 0;
private final Predicate<Byte> isPrintable;
public FastScanner(InputStream in) {
this.in = in;
this.isPrintable = b -> (33 <= b && b <= 126);
}
public FastScanner(InputStream in, Predicate<Byte> predicate) {
this.in = in;
this.isPrintable = predicate;
}
private boolean hasNextByte() {
if (ptr < length) {
return true;
}
try {
length = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
ptr = 0;
return length != 0;
}
private byte read() {
if (hasNextByte()) {
return buffer[ptr++];
}
return 0;
}
private void skip() {
while (hasNextByte() && !isPrintable(buffer[ptr])) {
ptr++;
}
}
private boolean hasNext() {
skip();
return hasNextByte();
}
private boolean isPrintable(byte b) {
return 33 <= b && b <= 126;
}
private String innerNext(Predicate<Byte> isReadable) {
if (!hasNext()) {
throw new NoSuchElementException();
}
StringBuilder sb = new StringBuilder();
byte b = read();
while (isReadable.test(b)) {
sb.appendCodePoint(b);
b = read();
}
return sb.toString();
}
public String n() {
return innerNext(b -> (33 <= b && b <= 126));
}
public int ni() {
return (int) nl();
}
public char[][] ncaa(int n, int m) {
var grid = new char[n][m];
for (int i = 0; i < n; i++) {
grid[i] = n().toCharArray();
}
return grid;
}
public int[] nia(int n) {
int[] result = new int[n];
for (int i = 0; i < n; i++) {
result[i] = ni();
}
return result;
}
public int[][] niaa(int h, int w) {
int[][] result = new int[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
result[i][j] = ni();
}
}
return result;
}
public long[][] nlaa(int h, int w) {
long[][] result = new long[h][w];
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
result[i][j] = nl();
}
}
return result;
}
public String[] na(int n) {
String[] result = new String[n];
for (int i = 0; i < n; i++) {
result[i] = n();
}
return result;
}
public long[] nla(int n) {
long[] result = new long[n];
for (int i = 0; i < n; i++) {
result[i] = nl();
}
return result;
}
public long nl() {
if (!hasNext()) {
throw new NoSuchElementException();
}
long result = 0;
boolean minus = false;
byte b;
b = read();
if (b == '-') {
minus = true;
b = read();
}
while (isPrintable(b)) {
if (b < '0' || b > '9') {
throw new NumberFormatException();
}
result *= 10;
result += (b - '0');
b = read();
}
return minus ? -result : result;
}
}
//-------------------------------------------------------------------
}
| ConDefects/ConDefects/Code/arc168_a/Java/48493692 |
condefects-java_data_1137 | import java.io.*;
import java.util.Random;
import java.util.StringTokenizer;
public class Main {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
private static StringTokenizer st;
public static void main(String[] args) throws IOException {
st = new StringTokenizer(reader.readLine());
int T = Integer.parseInt(st.nextToken());
for (int t = 0; t < T; t++) {
st = new StringTokenizer(reader.readLine());
long K = Long.parseLong(st.nextToken());
writer.write(Long.toString(solve(K)));
writer.newLine();
}
writer.flush();
}
static long solve(long K) {
long left = 0;
long right = (long)1e12 + 1;
while (right - left > 1) {
long mid = left + (right - left) / 2;
if (smallerNeq(mid) < K) {
left = mid;
} else {
right = mid;
}
}
return left;
}
static long smallerNeq(long x) {
String s = Long.toString(x);
int n = s.length();
long result = 0;
for (int i = 1; i < n; i++) {
result += pow(9, i);
}
for (int i = 0; i < n; i++) {
result += (s.charAt(i) - '0' - ((i == 0 || s.charAt(i - 1) < s.charAt(i)) ? 1 : 0)) * pow(9, n - i - 1);
if (i > 0 && s.charAt(i) == s.charAt(i - 1)) {
break;
}
}
return result;
}
static long pow(long x, long y) {
long result = 1;
for (int i = 0; i < y; i++) {
result *= x;
}
return result;
}
static boolean isNeq(long x) {
String s = Long.toString(x);
for (int i = 0; i < s.length() - 1; i++) {
if (s.charAt(i) == s.charAt(i + 1)) {
return false;
}
}
return true;
}
static long brute(long K) {
long counter = 0;
long x = 0;
while (counter < K) {
x++;
if (isNeq(x)) {
counter++;
if (x != solve(counter)) {
System.out.println(x);
}
}
}
return x;
}
}
import java.io.*;
import java.util.Random;
import java.util.StringTokenizer;
public class Main {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
private static StringTokenizer st;
public static void main(String[] args) throws IOException {
st = new StringTokenizer(reader.readLine());
int T = Integer.parseInt(st.nextToken());
for (int t = 0; t < T; t++) {
st = new StringTokenizer(reader.readLine());
long K = Long.parseLong(st.nextToken());
writer.write(Long.toString(solve(K)));
writer.newLine();
}
writer.flush();
}
static long solve(long K) {
long left = 0;
long right = (long)1e18;
while (right - left > 1) {
long mid = left + (right - left) / 2;
if (smallerNeq(mid) < K) {
left = mid;
} else {
right = mid;
}
}
return left;
}
static long smallerNeq(long x) {
String s = Long.toString(x);
int n = s.length();
long result = 0;
for (int i = 1; i < n; i++) {
result += pow(9, i);
}
for (int i = 0; i < n; i++) {
result += (s.charAt(i) - '0' - ((i == 0 || s.charAt(i - 1) < s.charAt(i)) ? 1 : 0)) * pow(9, n - i - 1);
if (i > 0 && s.charAt(i) == s.charAt(i - 1)) {
break;
}
}
return result;
}
static long pow(long x, long y) {
long result = 1;
for (int i = 0; i < y; i++) {
result *= x;
}
return result;
}
static boolean isNeq(long x) {
String s = Long.toString(x);
for (int i = 0; i < s.length() - 1; i++) {
if (s.charAt(i) == s.charAt(i + 1)) {
return false;
}
}
return true;
}
static long brute(long K) {
long counter = 0;
long x = 0;
while (counter < K) {
x++;
if (isNeq(x)) {
counter++;
if (x != solve(counter)) {
System.out.println(x);
}
}
}
return x;
}
}
| ConDefects/ConDefects/Code/arc173_a/Java/51132801 |
condefects-java_data_1138 | import java.util.Arrays;
import java.util.Scanner;
public final class Main {
public static void main(final String[] args) {
Scanner scanner = new Scanner(System.in);
final int K = scanner.nextInt() + 1;
scanner.close();
int[][] numberOf321LikeNumber = new int[10][10];
Arrays.fill(numberOf321LikeNumber[0], 1);
Arrays.setAll(numberOf321LikeNumber[1], index -> index);
for (int digits = 2; digits < 10; ++digits) {
int sum = 0;
for (int number = 0; number < 10; ++number) {
numberOf321LikeNumber[digits][number] = sum;
sum += numberOf321LikeNumber[digits - 1][number];
}
}
int digitsMax = 0;
int numberMax = 0;
int[] answerArray = new int[10];
Arrays.fill(answerArray, 0);
int cumulativeNumberOf321LikeNumber = 0;
for (int digits = 0; digits < 10; ++digits) {
for (int number = digits; number < 10; ++number) {
cumulativeNumberOf321LikeNumber += numberOf321LikeNumber[digits][number];
if (cumulativeNumberOf321LikeNumber >= K) {
digitsMax = digits;
numberMax = number;
break;
}
}
if (cumulativeNumberOf321LikeNumber >= K) {
break;
}
}
answerArray[digitsMax] = numberMax;
cumulativeNumberOf321LikeNumber -= numberOf321LikeNumber[digitsMax][numberMax];
for (int digits = digitsMax - 1; digits >= 0; --digits) {
for (int number = digits; number < 10; ++number) {
cumulativeNumberOf321LikeNumber += numberOf321LikeNumber[digits][number];
if (cumulativeNumberOf321LikeNumber >= K) {
answerArray[digits] = number;
cumulativeNumberOf321LikeNumber -= numberOf321LikeNumber[digits][number];
break;
}
}
}
int answer = 0;
for (int digits = digitsMax; digits >= 0; --digits) {
answer *= 10;
answer += answerArray[digits];
}
System.out.println(answer);
}
}
import java.util.Arrays;
import java.util.Scanner;
public final class Main {
public static void main(final String[] args) {
Scanner scanner = new Scanner(System.in);
final int K = scanner.nextInt() + 1;
scanner.close();
int[][] numberOf321LikeNumber = new int[10][10];
Arrays.fill(numberOf321LikeNumber[0], 1);
Arrays.setAll(numberOf321LikeNumber[1], index -> index);
for (int digits = 2; digits < 10; ++digits) {
int sum = 0;
for (int number = 0; number < 10; ++number) {
numberOf321LikeNumber[digits][number] = sum;
sum += numberOf321LikeNumber[digits - 1][number];
}
}
int digitsMax = 0;
int numberMax = 0;
int[] answerArray = new int[10];
Arrays.fill(answerArray, 0);
int cumulativeNumberOf321LikeNumber = 0;
for (int digits = 0; digits < 10; ++digits) {
for (int number = digits; number < 10; ++number) {
cumulativeNumberOf321LikeNumber += numberOf321LikeNumber[digits][number];
if (cumulativeNumberOf321LikeNumber >= K) {
digitsMax = digits;
numberMax = number;
break;
}
}
if (cumulativeNumberOf321LikeNumber >= K) {
break;
}
}
answerArray[digitsMax] = numberMax;
cumulativeNumberOf321LikeNumber -= numberOf321LikeNumber[digitsMax][numberMax];
for (int digits = digitsMax - 1; digits >= 0; --digits) {
for (int number = digits; number < 10; ++number) {
cumulativeNumberOf321LikeNumber += numberOf321LikeNumber[digits][number];
if (cumulativeNumberOf321LikeNumber >= K) {
answerArray[digits] = number;
cumulativeNumberOf321LikeNumber -= numberOf321LikeNumber[digits][number];
break;
}
}
}
long answer = 0;
for (int digits = digitsMax; digits >= 0; --digits) {
answer *= 10;
answer += answerArray[digits];
}
System.out.println(answer);
}
}
| ConDefects/ConDefects/Code/abc321_c/Java/47563805 |
condefects-java_data_1139 | import java.util.*;
class Main{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
String fm = s.next();
if(fm.indexOf("ff")==-1&&fm.indexOf("mm")==-1){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
import java.util.*;
class Main{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int n = s.nextInt();
String fm = s.next();
if(fm.indexOf("FF")==-1&&fm.indexOf("MM")==-1){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
} | ConDefects/ConDefects/Code/abc296_a/Java/44312977 |
condefects-java_data_1140 |
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// int t = sc.nextInt();
// while(t-->0){
int n = sc.nextInt();
String s = sc.next();
boolean ok = false;
for(int i=0;i<n-1;i++){
if(s.charAt(i)==s.charAt(i+1)){
ok=true;
break;
}
}
if(ok) System.out.println("No");
else System.out.println("YES");
//}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// int t = sc.nextInt();
// while(t-->0){
int n = sc.nextInt();
String s = sc.next();
boolean ok = false;
for(int i=0;i<n-1;i++){
if(s.charAt(i)==s.charAt(i+1)){
ok=true;
break;
}
}
if(ok) System.out.println("No");
else System.out.println("Yes");
//}
}
}
| ConDefects/ConDefects/Code/abc296_a/Java/42753674 |
condefects-java_data_1141 | import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
if(n == 1){
System.out.println("No");
return;
}
String[] s = sc.next().split("");
for(int i = 0; i < n - 1; i++){
if(s[i].equals(s[i+1])){
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
if(n == 1){
System.out.println("Yes");
return;
}
String[] s = sc.next().split("");
for(int i = 0; i < n - 1; i++){
if(s[i].equals(s[i+1])){
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
} | ConDefects/ConDefects/Code/abc296_a/Java/42882101 |
condefects-java_data_1142 | import java.io.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
long start = System.currentTimeMillis();
int n = in.nextInt();
int[] a = in.nextIntArray(n);
int thres = (n + 1) / 2;
for (int prime : new SieveOfEratosthenes(200000)) {
if (prime == 2) {
continue;
}
if (prime > 100000) {
break;
}
int[] c = new int[prime];
for (int i = 0; i < n; i++) {
c[a[i] % prime]++;
if (c[a[i] % prime] >= thres) {
out.println(prime);
return;
}
}
}
ThreadLocalRandom rand = ThreadLocalRandom.current();
while (System.currentTimeMillis() - start < 1800) {
int k = Math.min(n, 5);
int[] v = new int[k];
for (int i = 0; i < k; i++) {
v[i] = a[rand.nextInt(n)];
}
Arrays.sort(v);
int gcd = v[1] - v[0];
for (int i = 2; i < k; i++) {
if (gcd == 0) {
gcd = v[i] - v[i - 1];
} else if (v[i] - v[i - 1] != 0) {
gcd = gcd(gcd, v[i] - v[i - 1]);
}
}
if (gcd <= 2) {
continue;
}
int va = 0;
int co = 0;
for (int i = 0; i < n; i++) {
if (a[i] % gcd == va) {
co++;
} else if (co == 0) {
va = a[i] % gcd;
co++;
} else {
co--;
}
}
co = 0;
for (int i = 0; i < n; i++) {
if (a[i] % gcd == va) {
co++;
}
}
if (co >= thres) {
out.println(gcd);
return;
}
}
out.println(-1);
}
int gcd(int a, int b) {
return 0 < b ? gcd(b, a % b) : a;
}
static class SieveOfEratosthenes implements Iterable<Integer> {
private final List<Integer> primes = new ArrayList<>();
private int[] table;
public SieveOfEratosthenes() {
this(1000);
}
public SieveOfEratosthenes(int initialCapacity) {
calcTable(initialCapacity);
}
private void calcTable(int n) {
int oldCapacity = 0;
int[] newTable = new int[n];
if (table != null) {
oldCapacity = table.length;
System.arraycopy(table, 0, newTable, 0, oldCapacity);
}
table = newTable;
for (int i = oldCapacity; i < n; i++) {
table[i] = i;
}
for (int i = 2; i < n; i++) {
if (i >= oldCapacity && table[i] == i) {
primes.add(i);
}
for (int prime : primes) {
if (prime > table[i] || (long)prime * i >= n) {
break;
}
table[prime * i] = prime;
}
}
}
private void grow(int minCapacity) {
int oldCapacity = table.length;
int newCapacity = (int)Math.min(Integer.MAX_VALUE, (long)oldCapacity + (oldCapacity >> 1));
calcTable(newCapacity);
}
public int minPrimeFactor(int n) {
if (table.length <= n) {
grow(n + 1);
}
return table[n];
}
public int nthPrime(int n) {
while (primes.size() <= n) {
grow(table.length + 1);
}
return primes.get(n);
}
public int countLessThan(int n) {
while (primes.get(primes.size() - 1) < n) {
grow(table.length + 1);
}
int left = -1;
int right = primes.size();
while (right - left > 1) {
int mid = (left + right) / 2;
if (primes.get(mid) < n) {
left = mid;
} else {
right = mid;
}
}
return right;
}
public TreeMap<Integer, Integer> factorize(int n) {
TreeMap<Integer, Integer> primeFactors = new TreeMap<>();
while (n > 1) {
int primeFactor = minPrimeFactor(n);
int exp = 0;
while (n % primeFactor == 0) {
n /= primeFactor;
exp++;
}
primeFactors.put(primeFactor, exp);
}
return primeFactors;
}
public List<Integer> divisors(int n) {
List<Integer> divisors = new ArrayList<>();
divisors.add(1);
TreeMap<Integer, Integer> primeFactors = factorize(n);
for (Map.Entry<Integer, Integer> entry : primeFactors.entrySet()) {
int exp = entry.getValue();
int s = divisors.size();
for (int i = 0; i < s; i++) {
int v = 1;
for (int j = 0; j < exp; j++) {
v *= entry.getKey();
divisors.add(divisors.get(i) * v);
}
}
}
Collections.sort(divisors);
return divisors;
}
public IntStream stream() {
int characteristics = Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED | Spliterator.NONNULL | Spliterator.IMMUTABLE;
Spliterator.OfInt spliterator = Spliterators.spliteratorUnknownSize(iterator(), characteristics);
return StreamSupport.intStream(spliterator, false);
}
@Override
public PrimitiveIterator.OfInt iterator() {
return new PrimitiveIterator.OfInt() {
private int i = 0;
@Override
public int nextInt() {
return nthPrime(i++);
}
@Override
public boolean hasNext() {
return true;
}
};
}
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
import java.io.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
long start = System.currentTimeMillis();
int n = in.nextInt();
int[] a = in.nextIntArray(n);
int thres = (n + 2) / 2;
for (int prime : new SieveOfEratosthenes(200000)) {
if (prime == 2) {
continue;
}
if (prime > 100000) {
break;
}
int[] c = new int[prime];
for (int i = 0; i < n; i++) {
c[a[i] % prime]++;
if (c[a[i] % prime] >= thres) {
out.println(prime);
return;
}
}
}
ThreadLocalRandom rand = ThreadLocalRandom.current();
while (System.currentTimeMillis() - start < 1800) {
int k = Math.min(n, 5);
int[] v = new int[k];
for (int i = 0; i < k; i++) {
v[i] = a[rand.nextInt(n)];
}
Arrays.sort(v);
int gcd = v[1] - v[0];
for (int i = 2; i < k; i++) {
if (gcd == 0) {
gcd = v[i] - v[i - 1];
} else if (v[i] - v[i - 1] != 0) {
gcd = gcd(gcd, v[i] - v[i - 1]);
}
}
if (gcd <= 2) {
continue;
}
int va = 0;
int co = 0;
for (int i = 0; i < n; i++) {
if (a[i] % gcd == va) {
co++;
} else if (co == 0) {
va = a[i] % gcd;
co++;
} else {
co--;
}
}
co = 0;
for (int i = 0; i < n; i++) {
if (a[i] % gcd == va) {
co++;
}
}
if (co >= thres) {
out.println(gcd);
return;
}
}
out.println(-1);
}
int gcd(int a, int b) {
return 0 < b ? gcd(b, a % b) : a;
}
static class SieveOfEratosthenes implements Iterable<Integer> {
private final List<Integer> primes = new ArrayList<>();
private int[] table;
public SieveOfEratosthenes() {
this(1000);
}
public SieveOfEratosthenes(int initialCapacity) {
calcTable(initialCapacity);
}
private void calcTable(int n) {
int oldCapacity = 0;
int[] newTable = new int[n];
if (table != null) {
oldCapacity = table.length;
System.arraycopy(table, 0, newTable, 0, oldCapacity);
}
table = newTable;
for (int i = oldCapacity; i < n; i++) {
table[i] = i;
}
for (int i = 2; i < n; i++) {
if (i >= oldCapacity && table[i] == i) {
primes.add(i);
}
for (int prime : primes) {
if (prime > table[i] || (long)prime * i >= n) {
break;
}
table[prime * i] = prime;
}
}
}
private void grow(int minCapacity) {
int oldCapacity = table.length;
int newCapacity = (int)Math.min(Integer.MAX_VALUE, (long)oldCapacity + (oldCapacity >> 1));
calcTable(newCapacity);
}
public int minPrimeFactor(int n) {
if (table.length <= n) {
grow(n + 1);
}
return table[n];
}
public int nthPrime(int n) {
while (primes.size() <= n) {
grow(table.length + 1);
}
return primes.get(n);
}
public int countLessThan(int n) {
while (primes.get(primes.size() - 1) < n) {
grow(table.length + 1);
}
int left = -1;
int right = primes.size();
while (right - left > 1) {
int mid = (left + right) / 2;
if (primes.get(mid) < n) {
left = mid;
} else {
right = mid;
}
}
return right;
}
public TreeMap<Integer, Integer> factorize(int n) {
TreeMap<Integer, Integer> primeFactors = new TreeMap<>();
while (n > 1) {
int primeFactor = minPrimeFactor(n);
int exp = 0;
while (n % primeFactor == 0) {
n /= primeFactor;
exp++;
}
primeFactors.put(primeFactor, exp);
}
return primeFactors;
}
public List<Integer> divisors(int n) {
List<Integer> divisors = new ArrayList<>();
divisors.add(1);
TreeMap<Integer, Integer> primeFactors = factorize(n);
for (Map.Entry<Integer, Integer> entry : primeFactors.entrySet()) {
int exp = entry.getValue();
int s = divisors.size();
for (int i = 0; i < s; i++) {
int v = 1;
for (int j = 0; j < exp; j++) {
v *= entry.getKey();
divisors.add(divisors.get(i) * v);
}
}
}
Collections.sort(divisors);
return divisors;
}
public IntStream stream() {
int characteristics = Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED | Spliterator.NONNULL | Spliterator.IMMUTABLE;
Spliterator.OfInt spliterator = Spliterators.spliteratorUnknownSize(iterator(), characteristics);
return StreamSupport.intStream(spliterator, false);
}
@Override
public PrimitiveIterator.OfInt iterator() {
return new PrimitiveIterator.OfInt() {
private int i = 0;
@Override
public int nextInt() {
return nthPrime(i++);
}
@Override
public boolean hasNext() {
return true;
}
};
}
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
| ConDefects/ConDefects/Code/abc272_g/Java/35910474 |
condefects-java_data_1143 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {
static int ans = 1;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = Integer.parseInt(scanner.next());
recur(n,ans);
System.out.println(ans);
}
private static void recur(int n , int ans) {
if(n==0) {
ans = ans*1;
return;
}
ans = n * ans;
n--;
recur(n, ans);
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class Main {
static int ans = 1;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = Integer.parseInt(scanner.next());
recur(n,ans);
}
private static void recur(int n , int ans) {
if(n==0) {
ans = ans*1;
System.out.println(ans);
return;
}
ans = n * ans;
n--;
recur(n, ans);
}
}
| ConDefects/ConDefects/Code/abc273_a/Java/40290758 |
condefects-java_data_1144 | import java.util.Scanner;
class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
long ans = 0;
while(N>0)
ans *= N--;
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();
long ans = 1;
while(N>0)
ans *= N--;
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc273_a/Java/43509799 |
condefects-java_data_1145 | import java.util.*;
public class Main{
public static void main(String...args) {
Scanner sc = new Scanner(System.in);
final long K=sc.nextLong();
HashMap<Long,Integer> map=PF(K);
long min=1,max=K;
Set<Long> keySet=map.keySet();
while (max-min>1){
long i=(min+max)/2;
boolean bool=true;
for(var l:keySet){
int count=0;
long w=l;
while(i/w>=1){
count+=i/w;
w*=l;
}
if(map.get(l)>count){
bool=false;
break;
}
}
if(bool)max=i;
else min=i;
}
System.out.println(max);
}
public static HashMap<Long,Integer> PF(Long A) {
int max = (int) Math.ceil(Math.pow(A,0.5))+1;
boolean[] notPrime = new boolean[max];
ArrayList<Integer> list=new ArrayList<>();
for (int i = 2; i < max; i++) {
if (!notPrime[i]) {
list.add(i);
for (int a=1, b=i*a; b<max;a++,b=i*a) {
notPrime[b] = true;
}
}
}
HashMap<Long, Integer> map = new HashMap<>();
for(var p:list){
int a=0;
while (A%p==0){
a++;
A/=p;
}
if(a!=0)map.put((long)p,a);
}
if(A!=1){
map.put(A,1);
}
return map;
}
}
import java.util.*;
public class Main{
public static void main(String...args) {
Scanner sc = new Scanner(System.in);
final long K=sc.nextLong();
HashMap<Long,Integer> map=PF(K);
long min=1,max=K;
Set<Long> keySet=map.keySet();
while (max-min>1){
long i=(min+max)/2;
boolean bool=true;
for(var l:keySet){
long count=0;
long w=l;
while(i/w>=1){
count+=i/w;
w*=l;
}
if(map.get(l)>count){
bool=false;
break;
}
}
if(bool)max=i;
else min=i;
}
System.out.println(max);
}
public static HashMap<Long,Integer> PF(Long A) {
int max = (int) Math.ceil(Math.pow(A,0.5))+1;
boolean[] notPrime = new boolean[max];
ArrayList<Integer> list=new ArrayList<>();
for (int i = 2; i < max; i++) {
if (!notPrime[i]) {
list.add(i);
for (int a=1, b=i*a; b<max;a++,b=i*a) {
notPrime[b] = true;
}
}
}
HashMap<Long, Integer> map = new HashMap<>();
for(var p:list){
int a=0;
while (A%p==0){
a++;
A/=p;
}
if(a!=0)map.put((long)p,a);
}
if(A!=1){
map.put(A,1);
}
return map;
}
}
| ConDefects/ConDefects/Code/abc280_d/Java/45269480 |
condefects-java_data_1146 | import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
long K = in.nextLong();
long k = K;
Map<Long,Integer> mp = new HashMap<>();
for(long i = 2 ; i * i <= K ; i ++ ) {
if( K % i != 0 ) continue;
int count = 0 ;
while(K % i == 0) {
K /= i;
count ++ ;
}
mp.put(i,count);
}
if(K != 1) mp.put(K,1);
long l = 0;
long r = k;
while(r - l > 1) {
long mid = (r + l)/ 2;
boolean find = true;
for(long p : mp.keySet()) {
int count = 0;
int pcount = mp.get(p);
long tmp = mid ;
while(tmp != 0) {
tmp /= p;
count += tmp;
}
if(count < pcount) find = false;
}
if(find) r = mid ;
else l = mid;
}
out.println(r);
}
boolean isInteger (double value) { return (value == Math.floor(value)); }
int lower_bound(ArrayList<Integer> A, int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(ArrayList<Long> A, long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Long> A , long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Integer> A , int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
boolean [] Eratosthenes(){
int limit = 10101010;
boolean [] isprime = new boolean[limit+1];
Arrays.fill(isprime,true);
isprime[0] = false;
isprime[1] = false;
for(int i = 2 ; i <= limit ; i++ ){
if(!isprime[i]) continue;
for(int j = i * 2 ; j <= limit ; j += i ){
isprime[j] = false;
}
}
return isprime;
}
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
}
class Pair{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
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();
}
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();
}
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();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
long K = in.nextLong();
long k = K;
Map<Long,Integer> mp = new HashMap<>();
for(long i = 2 ; i * i <= K ; i ++ ) {
if( K % i != 0 ) continue;
int count = 0 ;
while(K % i == 0) {
K /= i;
count ++ ;
}
mp.put(i,count);
}
if(K != 1) mp.put(K,1);
long l = 0;
long r = k;
while(r - l > 1) {
long mid = (r + l)/ 2;
boolean find = true;
for(long p : mp.keySet()) {
long count = 0;
int pcount = mp.get(p);
long tmp = mid ;
while(tmp != 0) {
tmp /= p;
count += tmp;
}
if(count < pcount) find = false;
}
if(find) r = mid ;
else l = mid;
}
out.println(r);
}
boolean isInteger (double value) { return (value == Math.floor(value)); }
int lower_bound(ArrayList<Integer> A, int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(ArrayList<Long> A, long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Long> A , long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Integer> A , int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
boolean [] Eratosthenes(){
int limit = 10101010;
boolean [] isprime = new boolean[limit+1];
Arrays.fill(isprime,true);
isprime[0] = false;
isprime[1] = false;
for(int i = 2 ; i <= limit ; i++ ){
if(!isprime[i]) continue;
for(int j = i * 2 ; j <= limit ; j += i ){
isprime[j] = false;
}
}
return isprime;
}
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
}
class Pair{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
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();
}
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();
}
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();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
| ConDefects/ConDefects/Code/abc280_d/Java/41619673 |
condefects-java_data_1147 | import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
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());
char[][] s = new char[n][n];
for(int i = 0; i < n; i++) s[i] = sc.next().toCharArray();
int x1 = -1;
int y1 = -1;
int x2 = -1;
int y2 = -1;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if(s[i][j] == 'P') {
if(x1 == -1) {
x1 = i;
y1 = j;
} else {
x2 = i;
y2 = j;
}
}
}
}
final int[] dx = {-1, 0, 1, 0};
final int[] dy = {0, 1, 0, -1};
final int INF = 1 << 30;
int[][][][] dist = new int[n][n][n][n];
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
for(int k = 0; k < n; k++) {
Arrays.fill(dist[i][j][k], INF);
}
}
}
Queue<Integer[]> que = new ArrayDeque<Integer[]>();
que.add(new Integer[] {x1, y1, x2, y2});
dist[x1][y1][x2][y2] = 0;
while(!que.isEmpty()) {
int nx1 = que.peek()[0];
int ny1 = que.peek()[1];
int nx2 = que.peek()[2];
int ny2 = que.peek()[3];
que.poll();
for(int i = 0; i < 4; i++) {
int ntx1 = nx1 + dx[i];
int nty1 = ny1 + dy[i];
int ntx2 = nx2 + dx[i];
int nty2 = ny2 + dy[i];
if(ntx1 < 0 || n <= ntx1 || nty1 < 0 || n <= nty1 || s[ntx1][nty1] == '#') {
ntx1 = nx1;
nty1 = ny1;
}
if(ntx2 < 0 || n <= ntx2 || nty2 < 0 || n <= nty2 || s[ntx2][nty2] == '#') {
ntx2 = nx2;
nty2 = ny2;
}
if(dist[ntx1][nty1][ntx2][nty2] > dist[nx1][ny1][nx2][ny2] + 1) {
dist[ntx1][nty1][ntx2][nty2] = dist[nx1][ny1][nx2][ny2] + 1;
que.add(new Integer[] {ntx1, nty1, ntx2, nty2});
}
}
}
int ans = 1 << 60;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
ans = Math.min(ans, dist[i][j][i][j]);
}
}
if(ans == INF) ans = -1;
System.out.println(ans);
}
}
}
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
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());
char[][] s = new char[n][n];
for(int i = 0; i < n; i++) s[i] = sc.next().toCharArray();
int x1 = -1;
int y1 = -1;
int x2 = -1;
int y2 = -1;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if(s[i][j] == 'P') {
if(x1 == -1) {
x1 = i;
y1 = j;
} else {
x2 = i;
y2 = j;
}
}
}
}
final int[] dx = {-1, 0, 1, 0};
final int[] dy = {0, 1, 0, -1};
final int INF = 1 << 30;
int[][][][] dist = new int[n][n][n][n];
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
for(int k = 0; k < n; k++) {
Arrays.fill(dist[i][j][k], INF);
}
}
}
Queue<Integer[]> que = new ArrayDeque<Integer[]>();
que.add(new Integer[] {x1, y1, x2, y2});
dist[x1][y1][x2][y2] = 0;
while(!que.isEmpty()) {
int nx1 = que.peek()[0];
int ny1 = que.peek()[1];
int nx2 = que.peek()[2];
int ny2 = que.peek()[3];
que.poll();
for(int i = 0; i < 4; i++) {
int ntx1 = nx1 + dx[i];
int nty1 = ny1 + dy[i];
int ntx2 = nx2 + dx[i];
int nty2 = ny2 + dy[i];
if(ntx1 < 0 || n <= ntx1 || nty1 < 0 || n <= nty1 || s[ntx1][nty1] == '#') {
ntx1 = nx1;
nty1 = ny1;
}
if(ntx2 < 0 || n <= ntx2 || nty2 < 0 || n <= nty2 || s[ntx2][nty2] == '#') {
ntx2 = nx2;
nty2 = ny2;
}
if(dist[ntx1][nty1][ntx2][nty2] > dist[nx1][ny1][nx2][ny2] + 1) {
dist[ntx1][nty1][ntx2][nty2] = dist[nx1][ny1][nx2][ny2] + 1;
que.add(new Integer[] {ntx1, nty1, ntx2, nty2});
}
}
}
int ans = INF;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
ans = Math.min(ans, dist[i][j][i][j]);
}
}
if(ans == INF) ans = -1;
System.out.println(ans);
}
}
}
| ConDefects/ConDefects/Code/abc339_d/Java/51970475 |
condefects-java_data_1148 | import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
private static boolean DEBUG;
public static void main(final String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
@Override
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
public static final class FastInputStream {
private static final int BUF_SIZE = 1 << 14;
private final InputStream in;
private final byte buf[] = new byte[BUF_SIZE];
private int pos = 0;
private int count = 0;
private static final int TOKEN_SIZE = 1 << 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
public FastInputStream(final InputStream in) {
this.in = in;
}
private final void readBuf() {
pos = 0;
try { count = in.read(buf); }
catch(IOException e) { e.printStackTrace(); }
}
private final boolean hasNextByte() {
if(pos < count) return true;
readBuf();
return count > 0;
}
private final byte read() { if(hasNextByte()) return buf[pos ++]; else throw new NoSuchElementException(); }
private final boolean isPrintableChar(final byte c) { return 33 <= c && c <= 126; }
private final boolean isNumber(final byte c) { return 48 <= c && c <= 57; }
private final void skipUnprintable() {
while(true) {
for(int i = pos; i < count; i ++) {
if(isPrintableChar(buf[i])) { pos = i; return; }
}
readBuf();
if(count <= 0) throw new NoSuchElementException();
}
}
private final boolean readEOL() {
if(!hasNextByte()) return true;
if(buf[pos] == 13) {
pos ++;
if(hasNextByte() && buf[pos] == 10) pos ++;
return true;
}
if(buf[pos] == 10) {
pos ++;
return true;
}
return false;
}
public final char nextChar() {
skipUnprintable();
return (char)buf[pos ++];
}
public final String next() {
skipUnprintable();
int tokenCount = 0;
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
tokenBuf[tokenCount ++] = b;
}
readBuf();
}
return new String(tokenBuf, 0, tokenCount);
}
public final String nextLine() {
readEOL();
if(!hasNextByte()) throw new NoSuchElementException();
int tokenCount = 0;
while(!readEOL()) tokenBuf[tokenCount ++] = read();
return new String(tokenBuf, 0, tokenCount);
}
public final int nextInt() {
skipUnprintable();
int n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 214748364) throw new ArithmeticException("int overflow");
if(n == - 214748364 && b > 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 214748364) throw new ArithmeticException("int overflow");
if(n == 214748364 && b >= 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final long nextLong() {
skipUnprintable();
long n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == - 922337203685477580l && b > 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == 922337203685477580l && b >= 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final double nextDouble() { return Double.parseDouble(next()); }
public final void close() {
try { in.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class FastOutputStream {
private static final int BUF_SIZE = 1 << 13;
private final byte buf[] = new byte[BUF_SIZE];
private final OutputStream out;
private int count = 0;
private static final byte TRUE_BYTES[] = {116, 114, 117, 101};
private static final byte FALSE_BYTES[] = {102, 97, 108, 115, 101};
private static final byte INT_MIN_BYTES[] = {45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 56};
private static final byte LONG_MIN_BYTES[] = {45, 57, 50, 50, 51, 51, 55, 50, 48, 51,
54, 56, 53, 52, 55, 55, 53, 56, 48, 56};
private static final int TOKEN_SIZE = 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
private static final int PRECISION = 10;
public FastOutputStream(OutputStream out) {
this.out = out;
}
public final void print() { }
public final void write(final byte b) {
if(count == BUF_SIZE) internalFlush();
buf[count ++] = b;
}
public final void print(final char c) { write((byte) c); }
public final void print(final boolean b) {
if(b) {
if(count + 4 > BUF_SIZE) internalFlush();
System.arraycopy(TRUE_BYTES, 0, buf, count, TRUE_BYTES.length);
count += TRUE_BYTES.length;
}else {
if(count + 5 > BUF_SIZE) internalFlush();
System.arraycopy(FALSE_BYTES, 0, buf, count, FALSE_BYTES.length);
count += FALSE_BYTES.length;
}
}
public final void print(int x) {
if(count + 11 > BUF_SIZE) internalFlush();
if(x == Integer.MIN_VALUE) {
System.arraycopy(INT_MIN_BYTES, 0, buf, count, INT_MIN_BYTES.length);
count += INT_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 11;
while(x > 0) {
final int y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 11 - tokenCount);
count += 11 - tokenCount;
}
public final void print(long x) {
if(count + 20 > BUF_SIZE) internalFlush();
if(x == Long.MIN_VALUE) {
System.arraycopy(LONG_MIN_BYTES, 0, buf, count, LONG_MIN_BYTES.length);
count += LONG_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 20;
while(x > 0) {
final long y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 20 - tokenCount);
count += 20 - tokenCount;
}
public final void print(final double d) { print(d, PRECISION); }
public final void print(double d, final int precision) {
if(count == BUF_SIZE) internalFlush();
if(d < 0) {
buf[count ++] = 45;
d = - d;
}
d += Math.pow(10, - precision) / 2;
print((long)d);
if(precision == 0) return;
if(count + precision + 1 > BUF_SIZE) internalFlush();
buf[count ++] = 46;
d -= (long)d;
for(int i = 0; i < precision; i ++) {
d *= 10;
buf[count ++] = (byte)((int)d + 48);
d -= (int) d;
}
}
public final void print(final String s) { print(s.getBytes()); }
public final void print(final Object o) { print(o.toString()); }
public final void print(final byte[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
System.arraycopy(a, 0, buf, count, a.length);
count += a.length;
}
public final void print(final char[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
for(int i = 0; i < a.length; i ++) buf[count + i] = (byte)a[i];
count += a.length;
}
public final void println() { print('\n'); }
public final void println(final char c) { print(c); println(); }
public final void println(final boolean b) { print(b); println(); }
public final void println(final int x) { print(x); println(); }
public final void println(final long x) { print(x); println(); }
public final void println(final double d) { print(d); println(); }
public final void println(final double d, final int precision) { print(d, precision); println(); }
public final void println(final String s) { print(s); println(); }
public final void println(final Object o) { print(o); println(); }
public final void println(final char[] a) { print(a); println(); }
public final void println(final int[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final long[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a, final int precision) {
for(int i = 0; i < a.length; i ++) {
print(a[i], precision);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final String[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final Object[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
private final void internalFlush() {
try {
out.write(buf, 0, count);
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void flush() {
try {
out.write(buf, 0, count);
out.flush();
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void close() {
try { out.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class Solver {
private static final FastInputStream in = new FastInputStream(System.in);
public Solver() { }
private static final String nline() { return in.nextLine(); }
private static final String[] nline(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = nline(); return a; }
private static final char nc() { return in.nextChar(); }
private static final char[] nc(int n) {
final String str = nline();
if(n < 0) n = str.length();
final char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
private static final char[][] nc(final int n, final int m) { final char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
private static final boolean[] nb(int n, final char t) {
final char c[] = nc(-1);
if(n < 0) n = c.length;
final boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
private static final boolean[][] nb(final int n, final int m, final char t) { final boolean a[][] = new boolean[n][]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
private static final int ni() { return in.nextInt(); }
private static final int[] ni(final int n) { final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
private static final int[][] ni(final int n, final int m) { final int a[][] = new int[n][]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
private static final long nl() { return in.nextLong(); }
private static final long[] nl(final int n) { final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
private static final long[][] nl(final int n, final int m) { final long a[][] = new long[n][]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
private static final double nd() { return in.nextDouble(); }
private static final double[] nd(final int n) { final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
private static final double[][] nd(final int n, final int m) { final double a[][] = new double[n][]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
private static final String ns() { return in.next(); }
private static final String[] ns(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(); return a; }
private static final String[][] ns(final int n, final int m) { final String a[][] = new String[n][]; for(int i = 0; i < n; i ++) a[i] = ns(m); return a; }
private static final char booleanToChar(final boolean b) { return b ? '#' : '.'; }
private static final char[] booleanToChar(final boolean... a) {
final char c[] = new char[a.length];
for(int i = 0; i < a.length; i ++) c[i] = booleanToChar(a[i]);
return c;
}
private static final FastOutputStream out = new FastOutputStream(System.out);
private static final FastOutputStream err = new FastOutputStream(System.err);
private static final void prt() { out.print(); }
private static final void prt(final char c) { out.print(c); }
private static final void prt(final boolean b) { out.print(b); }
private static final void prt(final int x) { out.print(x); }
private static final void prt(final long x) { out.print(x); }
private static final void prt(final double d) { out.print(d); }
private static final void prt(final String s) { out.print(s); }
private static final void prt(final Object o) { out.print(o); }
private static final void prtln() { out.println(); }
private static final void prtln(final char c) { out.println(c); }
private static final void prtln(final boolean b) { out.println(b); }
private static final void prtln(final int x) { out.println(x); }
private static final void prtln(final long x) { out.println(x); }
private static final void prtln(final double d) { out.println(d); }
private static final void prtln(final String s) { out.println(s); }
private static final void prtln(final Object o) { out.println(o); }
private static final void prtln(final char... a) { out.println(a); }
private static final void prtln(final boolean... a) { out.println(booleanToChar(a)); }
private static final void prtln(final int... a) { out.println(a); }
private static final void prtln(final long... a) { out.println(a); }
private static final void prtln(final double... a) { out.println(a); }
private static final void prtln(final double[] a, int precision) { out.println(a, precision); }
private static final void prtln(final String... a) { out.println(a); }
private static final void prtln(final Object[] a) { out.println(a); }
private static final void prtlns(final char... a) { for(char ele : a) prtln(ele); }
private static final void prtlns(final boolean... a) { for(boolean ele : a) prtln(ele); }
private static final void prtlns(final int... a) { for(int ele : a) prtln(ele); }
private static final void prtlns(final long... a) { for(long ele : a) prtln(ele); }
private static final void prtlns(final double... a) { for(double ele : a) prtln(ele); }
private static final void prtlns(final Object[] a) { for(Object ele : a) prtln(ele); }
private static final void prtln(final char[][] a) { for(char[] ele : a) prtln(ele); }
private static final void prtln(final boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
private static final void prtln(final int[][] a) { for(int[] ele : a) prtln(ele); }
private static final void prtln(final long[][] a) { for(long[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a) { for(double[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a, int precision) { for(double[] ele : a) prtln(ele, precision); }
private static final void prtln(final String[][] a) { for(String[] ele : a) prtln(ele); }
private static final void prtln(final Object[][] a) { for(Object[] ele : a) prtln(ele); }
private static final void errprt() { if(DEBUG) err.print(); }
private static final void errprt(final char c) { if(DEBUG) err.print(c); }
private static final void errprt(final boolean b) { if(DEBUG) err.print(booleanToChar(b)); }
private static final void errprt(final int x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final long x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final double d) { if(DEBUG) err.print(d); }
private static final void errprt(final String s) { if(DEBUG) err.print(s); }
private static final void errprt(final Object o) { if(DEBUG) err.print(o); }
private static final void errprtln() { if(DEBUG) err.println(); }
private static final void errprtln(final char c) { if(DEBUG) err.println(c); }
private static final void errprtln(final boolean b) { if(DEBUG) err.println(booleanToChar(b)); }
private static final void errprtln(final int x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final long x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final double d) { if(DEBUG) err.println(d); }
private static final void errprtln(final String s) { if(DEBUG) err.println(s); }
private static final void errprtln(final Object o) { if(DEBUG) err.println(o); }
private static final void errprtln(final char... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final boolean... a) { if(DEBUG) err.println(booleanToChar(a)); }
private static final void errprtln(final int... a) {
if(DEBUG) {
boolean start = false;
for(int ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final long... a) {
if(DEBUG) {
boolean start = false;
for(long ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final double... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final double[] a, final int precision) { if(DEBUG) err.println(a, precision); }
private static final void errprtln(final String... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final Object[] a) { if(DEBUG) err.println(a); }
private static final void errprtlns(final char... a) { if(DEBUG) for(char ele : a) errprtln(ele); }
private static final void errprtlns(final boolean... a) { if(DEBUG) for(boolean ele : a) errprtln(ele); }
private static final void errprtlns(final int... a) { if(DEBUG) for(int ele : a) errprtln(ele); }
private static final void errprtlns(final long... a) { if(DEBUG) for(long ele : a) errprtln(ele); }
private static final void errprtlns(final double... a) { if(DEBUG) for(double ele : a) errprtln(ele); }
private static final void errprtlns(final Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
private static final void errprtln(final char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
private static final void errprtln(final boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
private static final void errprtln(final int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
private static final void errprtln(final long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a, int precision) { if(DEBUG) for(double[] ele : a) errprtln(ele, precision); }
private static final void errprtln(final String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
private static final void errprtln(final Object[][] a) { if(DEBUG) for(Object[] ele : a) errprtln(ele); }
private static final void errprtlns(final Object[][] a) { if(DEBUG) for(Object[] ele : a) { errprtlns(ele); errprtln(); } }
private static final void reply(final boolean b) { prtln(b ? "Yes" : "No"); }
private static final void REPLY(final boolean b) { prtln(b ? "YES" : "NO"); }
private static final void flush() { out.flush(); if(DEBUG) err.flush(); }
private static final void assertion(final boolean b) { if(!b) { flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char c) { if(!b) { errprtln(c); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean b2) { if(!b) { errprtln(b2); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double d) { if(!b) { errprtln(d); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String s) { if(!b) { errprtln(s); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object o) { if(!b) { errprtln(o); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void inclusiveRangeCheck(final int i, final int max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final int i, final int min, final int max) { rangeCheck(i, min, max + 1); }
private static final void inclusiveRangeCheck(final long i, final long max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final long i, final long min, final long max) { rangeCheck(i, min, max + 1); }
private static final void rangeCheck(final int i, final int max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final int i, final int min, final int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void rangeCheck(final long i, final long max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final long i, final long min, final long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void nonNegativeCheck(final long x) { nonNegativeCheck(x, "the argument"); }
private static final void nonNegativeCheck(final long x, final String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void positiveCheck(final long x) { positiveCheck(x, "the argument"); }
private static final void positiveCheck(final long x, final String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void exit() { flush(); System.exit(0); }
private static final void exit(final char c) { prtln(c); exit(); }
private static final void exit(final boolean b) { prtln(b); exit(); }
private static final void exit(final int x) { prtln(x); exit(); }
private static final void exit(final long x) { prtln(x); exit(); }
private static final void exit(final double d) { prtln(d); exit(); }
private static final void exit(final String s) { prtln(s); exit(); }
private static final void exit(final Object o) { prtln(o); exit(); }
private static final void exit(final char... a) { prtln(a); exit(); }
private static final void exit(final boolean... a) { prtln(a); exit(); }
private static final void exit(final int... a) { prtln(a); exit(); }
private static final void exit(final long... a) { prtln(a); exit(); }
private static final void exit(final double... a) { prtln(a); exit(); }
private static final void exit(final String... a) { prtln(a); exit(); }
private static final void exit(final Object[] a) { prtln(a); exit(); }
private static final void exit(final char[][] a) { prtln(a); exit(); }
private static final void exit(final boolean[][] a) { prtln(a); exit(); }
private static final void exit(final int[][] a) { prtln(a); exit(); }
private static final void exit(final long[][] a) { prtln(a); exit(); }
private static final void exit(final double[][] a) { prtln(a); exit(); }
private static final void exit(final String[][] a) { prtln(a); exit(); }
private static final void exit(final Object[][] a) { prtln(a); exit(); }
private static final long INF = (long)4e18;
private static final boolean isPlusINF(final long x) { return x > INF / 10; }
private static final boolean isMinusINF(final long x) { return isPlusINF(- x); }
private static final boolean isINF(final long x) { return isPlusINF(x) || isMinusINF(x); }
private static final int I_INF = (int)1e9 + 1000;
private static final boolean isPlusINF(final int x) { return x > I_INF / 10; }
private static final boolean isMinusINF(final int x) { return isPlusINF(- x); }
private static final boolean isINF(final int x) { return isPlusINF(x) || isMinusINF(x); }
private static final int min(final int a, final int b) { return Math.min(a, b); }
private static final long min(final long a, final long b) { return Math.min(a, b); }
private static final double min(final double a, final double b) { return Math.min(a, b); }
private static final <T extends Comparable<T>> T min(final T a, final T b) { return a.compareTo(b) <= 0 ? a : b; }
private static final int min(final int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
private static final long min(final long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
private static final double min(final double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
private static final int max(final int a, final int b) { return Math.max(a, b); }
private static final long max(final long a, final long b) { return Math.max(a, b); }
private static final double max(final double a, final double b) { return Math.max(a, b); }
private static final <T extends Comparable<T>> T max(final T a, final T b) { return a.compareTo(b) >= 0 ? a : b; }
private static final int max(final int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
private static final long max(final long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
private static final double max(final double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
private static final <T extends Comparable<T>> T max(final T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
private static final int max(final int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
private static final long max(final long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
private static final double max(final double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
private static final <T extends Comparable<T>> T max(final T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
private static final long sum(final int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
private static final long sum(final long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
private static final double sum(final double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
private static final int sum(final boolean... a) { int sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
private static final long[] sums(final int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final long[] sums(final long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final double[] sums(final double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final int[] sums(final boolean[] a) { int sum[] = new int[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
private static final long[][] sums(final int[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final long[][] sums(final long[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final double[][] sums(final double[][] a) {
final double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final int[][] sums(final boolean[][] a) {
final int sum[][] = new int[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
private static final int constrain(final int x, final int l, final int r) { return min(max(x, min(l, r)), max(l, r)); }
private static final long constrain(final long x, final long l, final long r) { return min(max(x, min(l, r)), max(l, r)); }
private static final double constrain(final double x, final double l, final double r) { return min(max(x, min(l, r)), max(l, r)); }
private static final int abs(final int x) { return x >= 0 ? x : - x; }
private static final long abs(final long x) { return x >= 0 ? x : - x; }
private static final double abs(final double x) { return x >= 0 ? x : - x; }
private static final int signum(final int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final long round(final double x) { return Math.round(x); }
private static final long floor(final double x) { return round(Math.floor(x)); }
private static final int divfloor(final int a, final int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long divfloor(final long a, final long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long ceil(final double x) { return round(Math.ceil(x)); }
private static final int divceil(final int a, final int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final long divceil(final long a, final long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final boolean mulGreater(final long a, final long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
private static final boolean mulGreaterEquals(final long a, final long b, final long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
private static final boolean mulLess(final long a, final long b, final long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
private static final boolean mulLessEquals(final long a, final long b, final long c) { return !mulGreater(a, b, c); } // a * b <= c
private static final double sqrt(final int x) { return Math.sqrt((double)x); }
private static final double sqrt(final long x) { return Math.sqrt((double)x); }
private static final double sqrt(final double x) { return Math.sqrt(x); }
private static final int floorsqrt(final int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final long floorsqrt(final long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final int ceilsqrt(final int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long ceilsqrt(final long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long fact(final int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
private static final long naiveP(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
private static final long naiveC(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
private static final double pow(final double x, final double y) { return Math.pow(x, y); }
private static final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
private static final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
private static final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
private static final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
private static final long lcm(final long a, final long b) { return a / gcd(a, b) * b; }
private static final int gcd(final int... a) { int gcd = 0; for(int ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final long gcd(final long... a) { long gcd = 0; for(long ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final double random() { return Math.random(); }
private static final int random(final int max) { return (int)floor(random() * max); }
private static final long random(final long max) { return floor(random() * max); }
private static final double random(final double max) { return random() * max; }
private static final int random(final int min, final int max) { return random(max - min) + min; }
private static final long random(final long min, final long max) { return random(max - min) + min; }
private static final double random(final double min, final double max) { return random(max - min) + min; }
private static final boolean isUpper(final char c) { return c >= 'A' && c <= 'Z'; }
private static final boolean isLower(final char c) { return c >= 'a' && c <= 'z'; }
private static final int upperToInt(final char c) { return c - 'A'; }
private static final int lowerToInt(final char c) { return c - 'a'; }
private static final int numToInt(final char c) { return c - '0'; }
private static final int charToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) : numToInt(c); }
private static final int alphabetToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) + 26 : 52; }
private static final char intToUpper(final int x) { return (char)(x + 'A'); }
private static final char intToLower(final int x) { return (char)(x + 'a'); }
private static final char intToNum(final int x) { return (char)(x + '0'); }
private static final int[] charToInt(final char[] a) { final int toint[] = new int[a.length]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final int[][] charToInt(final char[][] a) { final int toint[][] = new int[a.length][]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final long[] div(final long x) {
nonNegativeCheck(x);
final List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= x; i ++) if(x % i == 0) { divList.add(i); if(i * i != x) divList.add(x / i); }
final long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
private static final PairLL[] factor(long x) {
nonNegativeCheck(x);
final List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= x; i ++) {
if(x % i == 0) {
long cnt = 0;
while(x % i == 0) { x /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(x > 1) factorList.add(new PairLL(x, 1));
final PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
private static final boolean isPrime(final long x) { if(x <= 1) return false; for(long i = 2; i * i <= x; i ++) if(x % i == 0) return false; return true; }
private static final boolean[] prime(final int n) {
nonNegativeCheck(n);
final boolean prime[] = new boolean[n];
fill(prime, true);
if(n > 0) prime[0] = false;
if(n > 1) prime[1] = false;
for(int i = 2; i < n; i ++) if(prime[i]) for(int j = 2; i * j < n; j ++) prime[i * j] = false;
return prime;
}
private static final PairIL[] countElements(final int[] a, final boolean sort) {
final int len = a.length;
final int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairLL[] countElements(final long[] a, final boolean sort) {
final int len = a.length;
final long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairIL[] countElements(final String s, final boolean sort) {
final int len = s.length();
final char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final long triangular(final long n) { return n * (n + 1) / 2; }
private static final long arctriangularfloor(final long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
private static final long arctriangularceil(final long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
private static final int[] baseConvert(long x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final long x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int[] baseConvert(int x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final int x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
int tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final long[] baseConvert(long x, final long n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final long digit[] = new long[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = x % n; x /= n; }
return digit;
}
private static final long[] baseConvert(final long x, final long n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int numDigits(final long x) { nonNegativeCheck(x); return Long.toString(x).length(); }
private static final long bitFlag(final int i) { nonNegativeCheck(i); return 1L << i; }
private static final boolean isFlagged(final long x, final int i) { nonNegativeCheck(x); nonNegativeCheck(i); return (x >> i & 1) != 0; }
private static final long countString(final String s, final String t) { return (s.length() - s.replace(t, "").length()) / t.length(); }
private static final long countStringAll(final String s, final String t) { return s.length() - s.replaceAll(t, "").length(); }
private static final String reverse(final String s) { return (new StringBuilder(s)).reverse().toString(); }
private static final char[] reverse(final char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final boolean[] reverse(final boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final int[] reverse(final int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final long[] reverse(final long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final double[] reverse(final double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final String[] reverse(final String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final Object[] reverse(final Object[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final void fill(final char[] a, final char x) { Arrays.fill(a, x); }
private static final void fill(final boolean[] a, final boolean x) { Arrays.fill(a, x); }
private static final void fill(final int[] a, final int x) { Arrays.fill(a, x); }
private static final void fill(final long[] a, final long x) { Arrays.fill(a, x); }
private static final void fill(final double[] a, final double x) { Arrays.fill(a, x); }
private static final void fill(final char[][] a, final char x) { for(char[] ele : a) fill(ele, x); }
private static final void fill(final boolean[][] a, final boolean x) { for(boolean[] ele : a) fill(ele, x); }
private static final void fill(final int[][] a, final int x) { for(int[] ele : a) fill(ele, x); }
private static final void fill(final long[][] a, final long x) { for(long[] ele : a) fill(ele, x); }
private static final void fill(final double[][] a, final double x) { for(double[] ele : a) fill(ele, x); }
private static final void fill(final char[][][] a, final char x) { for(char[][] ele : a) fill(ele, x); }
private static final void fill(final boolean[][][] a, final boolean x) { for(boolean[][] ele : a) fill(ele, x); }
private static final void fill(final int[][][] a, final int x) { for(int[][] ele : a) fill(ele, x); }
private static final void fill(final long[][][] a, final long x) { for(long[][] ele : a) fill(ele, x); }
private static final void fill(final double[][][] a, final double x) { for(double[][] ele : a) fill(ele, x); }
private static final char[] resize(final char[] a, final int m, final int x) {
nonNegativeCheck(m);
final char resized[] = new char[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final boolean[] resize(final boolean[] a, final int m, final int x) {
nonNegativeCheck(m);
final boolean resized[] = new boolean[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] resize(final int[] a, final int m, final int x) {
nonNegativeCheck(m);
final int resized[] = new int[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final long[] resize(final long[] a, final int m, final int x) {
nonNegativeCheck(m);
final long resized[] = new long[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final double[] resize(final double[] a, final int m, final int x) {
nonNegativeCheck(m);
final double resized[] = new double[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final String[] resize(final String[] a, final int m, final int x) {
nonNegativeCheck(m);
final String resized[] = new String[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final Object[] resize(final Object[] a, final int m, final int x) {
nonNegativeCheck(m);
final Object resized[] = new Object[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] toIntArray(final List<Integer> list) { final int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
private static final long[] toLongArray(final List<Long> list) { final long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
private static final double[] toDoubleArray(final List<Double> list) { final double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
private static final char[] toCharArray(final List<Character> list) { final char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
private static final boolean[] toBooleanArray(final List<Boolean> list) { final boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
private static final String[] toStringArray(final List<String> list) { final String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
private static final <T> void toArray(final List<T> list, final T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
private static final void shuffleArray(final int[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final long[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final double[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final int[] randomi(final int n, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final long[] randoml(final int n, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final double[] randomd(final int n, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final int[] randomi(final int n, final int min, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final long[] randoml(final int n, final long min, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final double[] randomd(final int n, final double min, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final void swap(final char[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final boolean[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final int[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final long[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final double[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final String[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final Object[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final char[][] rotate(final char[][] a) {
final char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final boolean[][] rotate(final boolean[][] a) {
final boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[][] rotate(final int[][] a) {
final int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final long[][] rotate(final long[][] a) {
final long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final double[][] rotate(final double[][] a) {
final double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final Object[][] rotate(final Object[][] a) {
final Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[] compress(final int[] a) {
final int n = a.length;
final Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final long[] compress(final long[] a) {
final int n = a.length;
final Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final double[] compress(final double[] a) {
final int n = a.length;
final Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
// binary search
private static final int lowerBound(final int[] a, final int key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final int[] a, final int key) { return BS(a, key, true, true, false); }
private static final int upperBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final int[] a, final int key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final int[] a, final int index, final int key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final long[] a, final long key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final long[] a, final long key) { return BS(a, key, true, true, false); }
private static final int upperBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final long[] a, final long key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final long[] a, final int index, final long key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final double[] a, final double key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final double[] a, final double key) { return BS(a, key, true, true, false); }
private static final int upperBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final double[] a, final double key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final double[] a, final int index, final double key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final T[] a, final int index, final T key, final boolean gt, final boolean eq) {
int compare = a[index].compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
private static final <T> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final T[] a, final int index, T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a[index], key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final List<T> a, final int index, T key, final boolean gt, final boolean eq) {
int compare = a.get(index).compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
private static final <T> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final List<T> a, final int index, final T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a.get(index), key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final PairLL binaryRangeSearch(final long left, final long right, final UnaryOperator<Long> op, final boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) >> 1;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) >> 1;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
private static final double ternarySearch(double left, double right, final UnaryOperator<Double> op, final boolean minimize, final int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
private static final class Mod107 extends Mod {
public static final Mod107 md = new Mod107();
public static final long MOD = 1_000_000_007;
private Mod107() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod998 extends Mod {
public static final Mod998 md = new Mod998();
public static final long MOD = 998_244_353;
private Mod998() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod754974721 extends Mod {
public static final Mod754974721 md = new Mod754974721();
public static final long MOD = 754_974_721;
private Mod754974721() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod167772161 extends Mod {
public static final Mod167772161 md = new Mod167772161();
public static final long MOD = 167_772_161;
private Mod167772161() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod469762049 extends Mod {
public static final Mod469762049 md = new Mod469762049();
public static final long MOD = 469_762_049;
private Mod469762049() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class ArbitraryMod extends Mod {
private static final long MASK = 0xffff_ffffl;
private final long MH;
private final long ML;
public ArbitraryMod(long mod) { super(mod); long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
private final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
@Override
public long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return reduce(x);
}
@Override
public long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return reduce(x * y);
x = mod(x);
y = mod(y);
return reduce(x * y);
}
}
private abstract static class Mod {
public final long MOD;
public Mod(long mod) { MOD = mod; }
public abstract long mod(long x);
public final long[] mod(final long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
public final long[][] mod(final long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public final long[][][] mod(final long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public long add(long x, final long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
public final long sum(final long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
public long sub(long x, final long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
public final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
public abstract long mul(long x, long y);
public final long mul(final long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
public final long div(final long x, final long y) { return mul(x, inv(y)); }
public final long[] pows(long x, final int n) {
x = mod(x);
long pow[] = new long[n + 1];
pow[0] = 1;
for(int i = 0; i < n; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
public final long fact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
public final long invFact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
private static final int MAX_INV_SIZE = 100_100;
public final Map<Long, Long> invMap = new HashMap<>();
public final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
private final long calInv(final long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
public final long[] invs(final int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
private long g;
public final long primitiveRoot() { // O(1) or O(M^(1/2))
if(MOD == 2) return 1;
if(MOD == 167772161) return 3;
if(MOD == 469762049) return 3;
if(MOD == 754974721) return 11;
if(MOD == 998244353) return 3;
if(g != 0) return g;
PairLL factor[] = factor(MOD - 1);
outer: for(g = 2; ; g ++) {
for(PairLL p : factor) if(pow(g, (MOD - 1) / p.a) == 1) continue outer;
return g;
}
}
private static final int MAX_FACT1 = 5_000_100;
private static final int MAX_FACT2 = 500_100;
private static final int MAX_FACT_MAP_SIZE = 100;
private long fact[];
private long invFact[];
private boolean isFactPrepared = false;
private final Map<Long, long[]> factMap = new HashMap<>();
private final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
public final long P(final long n, final long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
public final long C(final long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
final int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
public final long H(final long n, final long r) { return C(n - 1 + r, r); }
public final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
private static final long mod(long x, final long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
private static final long pow(long x, long y, final long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
private static class Grids {
public final int h, w;
public final Grid[][] gs;
public final Grid[] gi;
public Grids(final int h, final int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
public final void init(final boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
public final void init(final long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
public final Grid get(final int x, final int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
public final Grid get(final int i) { return get(i / w, i % w); }
public static final int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
public static final int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
public final Grid next(final int x, final int y, final int i) { return next(gs[x][y], i); }
public final Grid next(final Grid g, final int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
private static class Grid implements Comparable<Grid> {
public int x, y, h, w, i; public boolean b; public long val;
public Grid() { }
public Grid(final int x, final int y, final int h, final int w) { init(x, y, h, w, false, 0); }
public Grid(final int x, final int y, final int h, final int w, final boolean b) { init(x, y, h, w, b, 0); }
public Grid(final int x, final int y, final int h, final int w, final long val) { init(x, y, h, w, false, val); }
public Grid(final int x, final int y, final int h, final int w, final boolean b, final long val) { init(x, y, h, w, b, val); }
public final void init(final int x, final int y, final int h, final int w, final boolean b, final long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public final String toString() { return "("+x+", "+y+")"+" "+booleanToChar(b)+" "+val; }
@Override public final int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public final int compareTo(final Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
private static final boolean isValid(final int x, final int y, final int h, final int w) { return x >= 0 && x < h && y >= 0 && y < w; }
private static final boolean isValid(final Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
private static class Graph {
public int numNode, numEdge;
public boolean directed;
public List<Edge> edges = new ArrayList<>();
public Node nodes[];
public Node reversedNodes[];
public Graph(final int numNode, final int numEdge, final boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
public void init(final List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
public void add(final int source, final int target, final long cost) { add(new Edge(source, target, cost)); }
public void add(final Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
public void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
private static class Node extends ArrayList<Edge> {
public final int id;
public Node(final int id) { this.id = id; }
public void add(final int target, final long cost) { add(new Edge(id, target, cost)); }
}
private static class Edge implements Comparable<Edge> {
public int source, target; public long cost;
public Edge(final int source, final int target, final long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public final String toString() { return source+" - "+cost+" -> "+target; }
@Override public final int hashCode() { return Objects.hash(source, target); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public final int compareTo(final Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
private static class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
public T a; public U b;
public Pair() { }
public Pair(final T a, final U b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public final int compareTo(final Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
private static final PairII npii() { return new PairII(ni(), ni()); }
private static final PairII[] npii(final int n) { final PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
private static final PairII[][] npii(final int n, final int m) { final PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
private static class PairII implements Comparable<PairII> {
public int a; public int b;
public PairII() { }
public PairII(final int a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairIL npil() { return new PairIL(ni(), nl()); }
private static final PairIL[] npil(final int n) { final PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
private static final PairIL[][] npil(final int n, final int m) { final PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
private static class PairIL implements Comparable<PairIL> {
public int a; public long b;
public PairIL() { }
public PairIL(final int a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairID npid() { return new PairID(ni(), nd()); }
private static final PairID[] npid(final int n) { final PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
private static final PairID[][] npid(final int n, final int m) { final PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
private static class PairID implements Comparable<PairID> {
public int a; public double b;
public PairID() { }
public PairID(final int a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairLI npli() { return new PairLI(nl(), ni()); }
private static final PairLI[] npli(final int n) { final PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
private static final PairLI[][] npli(final int n, final int m) { final PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
private static class PairLI implements Comparable<PairLI> {
public long a; public int b;
public PairLI() { }
public PairLI(final long a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairLL npll() { return new PairLL(nl(), nl()); }
private static final PairLL[] npll(final int n) { final PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
private static final PairLL[][] npll(final int n, final int m) { final PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
private static class PairLL implements Comparable<PairLL> {
public long a; public long b;
public PairLL() { }
public PairLL(final long a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairLD npld() { return new PairLD(nl(), nd()); }
private static final PairLD[] npld(final int n) { final PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
private static final PairLD[][] npld(final int n, final int m) { final PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
private static class PairLD implements Comparable<PairLD> {
public long a; public double b;
public PairLD() { }
public PairLD(final long a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairDI npdi() { return new PairDI(nd(), ni()); }
private static final PairDI[] npdi(final int n) { final PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
private static final PairDI[][] npdi(final int n, final int m) { final PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
private static class PairDI implements Comparable<PairDI> {
public double a; public int b;
public PairDI() { }
public PairDI(final double a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairDL npdl() { return new PairDL(nd(), nl()); }
private static final PairDL[] npdl(final int n) { final PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
private static final PairDL[][] npdl(final int n, final int m) { final PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
private static class PairDL implements Comparable<PairDL> {
public double a; public long b;
public PairDL() { }
public PairDL(final double a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairDD npdd() { return new PairDD(nd(), nd()); }
private static final PairDD[] npdd(final int n) { final PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
private static final PairDD[][] npdd(final int n, final int m) { final PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
private static class PairDD implements Comparable<PairDD> {
public double a; public double b;
public PairDD() { }
public PairDD(final double a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
// Tuple
private interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
private static class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
public T t; public V a;
public BasicTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public final String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public final int hashCode() { return Objects.hash(t, a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
private static class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
public V a;
public UniqueTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public final String toString() { return "("+a.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
private static class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
public Tuple1() { super(); }
public Tuple1(final T0 a0) { super(); this.a = a0; }
final T0 get0() { return a; }
final void set0(final T0 x) { a = x; }
}
private static class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
public Tuple2() { super(); }
public Tuple2(final T0 a0, final T1 a1) { super(); this.t = new Tuple1<>(a0); this.a = a1; }
final T0 get0() { return t.get0(); }
final T1 get1() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { a = x; }
}
private static class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
public Tuple3() { super(); }
public Tuple3(final T0 a0, final T1 a1, final T2 a2) { super(); this.t = new Tuple2<>(a0, a1); this.a = a2; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { a = x; }
}
private static class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
public Tuple4() { super(); }
public Tuple4(final T0 a0, final T1 a1, final T2 a2, final T3 a3) { super(); this.t = new Tuple3<>(a0, a1, a2); this.a = a3; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { a = x; }
}
private static class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
public Tuple5() { super(); }
public Tuple5(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4) { super(); this.t = new Tuple4<>(a0, a1, a2, a3); this.a = a4; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { a = x; }
}
private static class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
public Tuple6() { super(); }
public Tuple6(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) { super(); this.t = new Tuple5<>(a0, a1, a2, a3, a4); this.a = a5; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { a = x; }
}
private static class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
public Tuple7() { super(); }
public Tuple7(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) { super(); this.t = new Tuple6<>(a0, a1, a2, a3, a4, a5); this.a = a6; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { a = x; }
}
private static class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
public Tuple8() { super(); }
public Tuple8(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) { super(); this.t = new Tuple7<>(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return t.get6(); }
final T7 get7() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { t.set6(x); }
final void set7(final T7 x) { a = x; }
}
// Tuple3
private static class TupleIII implements Comparable<TupleIII> {
public int a; public int b; public int c;
public TupleIII() { }
public TupleIII(final int a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIIL implements Comparable<TupleIIL> {
public int a; public int b; public long c;
public TupleIIL() { }
public TupleIIL(final int a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
private static class TupleIID implements Comparable<TupleIID> {
public int a; public int b; public double c;
public TupleIID() { }
public TupleIID(final int a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleILI implements Comparable<TupleILI> {
public int a; public long b; public int c;
public TupleILI() { }
public TupleILI(final int a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleILL implements Comparable<TupleILL> {
public int a; public long b; public long c;
public TupleILL() { }
public TupleILL(final int a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleILD implements Comparable<TupleILD> {
public int a; public long b; public double c;
public TupleILD() { }
public TupleILD(final int a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleIDI implements Comparable<TupleIDI> {
public int a; public double b; public int c;
public TupleIDI() { }
public TupleIDI(final int a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIDL implements Comparable<TupleIDL> {
public int a; public double b; public long c;
public TupleIDL() { }
public TupleIDL(final int a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleIDD implements Comparable<TupleIDD> {
public int a; public double b; public double c;
public TupleIDD() { }
public TupleIDD(final int a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLII implements Comparable<TupleLII> {
public long a; public int b; public int c;
public TupleLII() { }
public TupleLII(final long a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLIL implements Comparable<TupleLIL> {
public long a; public int b; public long c;
public TupleLIL() { }
public TupleLIL(final long a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLID implements Comparable<TupleLID> {
public long a; public int b; public double c;
public TupleLID() { }
public TupleLID(final long a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLLI implements Comparable<TupleLLI> {
public long a; public long b; public int c;
public TupleLLI() { }
public TupleLLI(final long a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLLL implements Comparable<TupleLLL> {
public long a; public long b; public long c;
public TupleLLL() { }
public TupleLLL(final long a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLLD implements Comparable<TupleLLD> {
public long a; public long b; public double c;
public TupleLLD() { }
public TupleLLD(final long a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLDI implements Comparable<TupleLDI> {
public long a; public double b; public int c;
public TupleLDI() { }
public TupleLDI(final long a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLDL implements Comparable<TupleLDL> {
public long a; public double b; public long c;
public TupleLDL() { }
public TupleLDL(final long a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLDD implements Comparable<TupleLDD> {
public long a; public double b; public double c;
public TupleLDD() { }
public TupleLDD(final long a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDII implements Comparable<TupleDII> {
public double a; public int b; public int c;
public TupleDII() { }
public TupleDII(final double a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDIL implements Comparable<TupleDIL> {
public double a; public int b; public long c;
public TupleDIL() { }
public TupleDIL(final double a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDID implements Comparable<TupleDID> {
public double a; public int b; public double c;
public TupleDID() { }
public TupleDID(final double a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDLI implements Comparable<TupleDLI> {
public double a; public long b; public int c;
public TupleDLI() { }
public TupleDLI(final double a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDLL implements Comparable<TupleDLL> {
public double a; public long b; public long c;
public TupleDLL() { }
public TupleDLL(final double a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDLD implements Comparable<TupleDLD> {
public double a; public long b; public double c;
public TupleDLD() { }
public TupleDLD(final double a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDDI implements Comparable<TupleDDI> {
public double a; public double b; public int c;
public TupleDDI() { }
public TupleDDI(final double a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDDL implements Comparable<TupleDDL> {
public double a; public double b; public long c;
public TupleDDL() { }
public TupleDDL(final double a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDDD implements Comparable<TupleDDD> {
public double a; public double b; public double c;
public TupleDDD() { }
public TupleDDD(final double a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
long n = nl();
int m = ni();
PairLI p[] = npli(m);
if(m == 0) {
prtln(n % 2 != 0 ? "Takahashi" : "Aoki");
return;
}
for(int i = 0; i < m; i ++) if(p[i].a % 2 == 0) p[i].b = 1 - p[i].b;
int cnt = 0;
long x = p[0].a - 1;
long y = n - p[m - 1].a;
boolean odd = false;
for(int i = 1; i < m; i ++) {
if(p[i - 1].a % 2 == p[i].a % 2) odd = !odd;
if(p[i - 1].b != p[i].b) odd = !odd;
}
if(abs(x - y) == 1) odd = !odd;
prtln(abs(x - y) > 1 || (abs(x - y) == 1 && min(x, y) % 2 == 0) || odd ? "Takahashi" : "Aoki");
}
}
}
import java.util.*;
import java.io.*;
import java.math.*;
import java.util.function.*;
public class Main implements Runnable {
private static boolean DEBUG;
public static void main(final String[] args) {
DEBUG = args.length > 0 && args[0].equals("-DEBUG");
Thread.setDefaultUncaughtExceptionHandler((t, e) -> { e.printStackTrace(); System.exit(1); });
new Thread(null, new Main(), "", 1 << 31).start();
}
@Override
public void run() { Solver solver = new Solver(); solver.solve(); solver.exit(); }
public static final class FastInputStream {
private static final int BUF_SIZE = 1 << 14;
private final InputStream in;
private final byte buf[] = new byte[BUF_SIZE];
private int pos = 0;
private int count = 0;
private static final int TOKEN_SIZE = 1 << 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
public FastInputStream(final InputStream in) {
this.in = in;
}
private final void readBuf() {
pos = 0;
try { count = in.read(buf); }
catch(IOException e) { e.printStackTrace(); }
}
private final boolean hasNextByte() {
if(pos < count) return true;
readBuf();
return count > 0;
}
private final byte read() { if(hasNextByte()) return buf[pos ++]; else throw new NoSuchElementException(); }
private final boolean isPrintableChar(final byte c) { return 33 <= c && c <= 126; }
private final boolean isNumber(final byte c) { return 48 <= c && c <= 57; }
private final void skipUnprintable() {
while(true) {
for(int i = pos; i < count; i ++) {
if(isPrintableChar(buf[i])) { pos = i; return; }
}
readBuf();
if(count <= 0) throw new NoSuchElementException();
}
}
private final boolean readEOL() {
if(!hasNextByte()) return true;
if(buf[pos] == 13) {
pos ++;
if(hasNextByte() && buf[pos] == 10) pos ++;
return true;
}
if(buf[pos] == 10) {
pos ++;
return true;
}
return false;
}
public final char nextChar() {
skipUnprintable();
return (char)buf[pos ++];
}
public final String next() {
skipUnprintable();
int tokenCount = 0;
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
tokenBuf[tokenCount ++] = b;
}
readBuf();
}
return new String(tokenBuf, 0, tokenCount);
}
public final String nextLine() {
readEOL();
if(!hasNextByte()) throw new NoSuchElementException();
int tokenCount = 0;
while(!readEOL()) tokenBuf[tokenCount ++] = read();
return new String(tokenBuf, 0, tokenCount);
}
public final int nextInt() {
skipUnprintable();
int n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 214748364) throw new ArithmeticException("int overflow");
if(n == - 214748364 && b > 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 214748364) throw new ArithmeticException("int overflow");
if(n == 214748364 && b >= 56) throw new ArithmeticException("int overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final long nextLong() {
skipUnprintable();
long n = 0;
boolean minus = false;
if(buf[pos] == 45) {
minus = true;
pos ++;
if(!hasNextByte() || !isNumber(buf[pos])) throw new InputMismatchException();
}
outer: while(count > 0) {
for(int i = pos; i < count; i ++) {
final byte b = buf[i];
if(!isPrintableChar(b)) { pos = i; break outer; }
if(!isNumber(b)) throw new InputMismatchException();
if(minus) {
if(n < - 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == - 922337203685477580l && b > 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) + 48 - b;
}else {
if(n > 922337203685477580l) throw new ArithmeticException("long overflow");
if(n == 922337203685477580l && b >= 56) throw new ArithmeticException("long overflow");
n = (n << 3) + (n << 1) - 48 + b;
}
}
readBuf();
}
return n;
}
public final double nextDouble() { return Double.parseDouble(next()); }
public final void close() {
try { in.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class FastOutputStream {
private static final int BUF_SIZE = 1 << 13;
private final byte buf[] = new byte[BUF_SIZE];
private final OutputStream out;
private int count = 0;
private static final byte TRUE_BYTES[] = {116, 114, 117, 101};
private static final byte FALSE_BYTES[] = {102, 97, 108, 115, 101};
private static final byte INT_MIN_BYTES[] = {45, 50, 49, 52, 55, 52, 56, 51, 54, 52, 56};
private static final byte LONG_MIN_BYTES[] = {45, 57, 50, 50, 51, 51, 55, 50, 48, 51,
54, 56, 53, 52, 55, 55, 53, 56, 48, 56};
private static final int TOKEN_SIZE = 20;
private final byte tokenBuf[] = new byte[TOKEN_SIZE];
private static final int PRECISION = 10;
public FastOutputStream(OutputStream out) {
this.out = out;
}
public final void print() { }
public final void write(final byte b) {
if(count == BUF_SIZE) internalFlush();
buf[count ++] = b;
}
public final void print(final char c) { write((byte) c); }
public final void print(final boolean b) {
if(b) {
if(count + 4 > BUF_SIZE) internalFlush();
System.arraycopy(TRUE_BYTES, 0, buf, count, TRUE_BYTES.length);
count += TRUE_BYTES.length;
}else {
if(count + 5 > BUF_SIZE) internalFlush();
System.arraycopy(FALSE_BYTES, 0, buf, count, FALSE_BYTES.length);
count += FALSE_BYTES.length;
}
}
public final void print(int x) {
if(count + 11 > BUF_SIZE) internalFlush();
if(x == Integer.MIN_VALUE) {
System.arraycopy(INT_MIN_BYTES, 0, buf, count, INT_MIN_BYTES.length);
count += INT_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 11;
while(x > 0) {
final int y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 11 - tokenCount);
count += 11 - tokenCount;
}
public final void print(long x) {
if(count + 20 > BUF_SIZE) internalFlush();
if(x == Long.MIN_VALUE) {
System.arraycopy(LONG_MIN_BYTES, 0, buf, count, LONG_MIN_BYTES.length);
count += LONG_MIN_BYTES.length;
return;
}
if(x == 0) {
buf[count ++] = 48;
return;
}
if(x < 0) {
buf[count ++] = 45;
x = - x;
}
int tokenCount = 20;
while(x > 0) {
final long y = x / 10;
tokenBuf[-- tokenCount] = (byte) (x - (y << 3) - (y << 1) + 48);
x = y;
}
System.arraycopy(tokenBuf, tokenCount, buf, count, 20 - tokenCount);
count += 20 - tokenCount;
}
public final void print(final double d) { print(d, PRECISION); }
public final void print(double d, final int precision) {
if(count == BUF_SIZE) internalFlush();
if(d < 0) {
buf[count ++] = 45;
d = - d;
}
d += Math.pow(10, - precision) / 2;
print((long)d);
if(precision == 0) return;
if(count + precision + 1 > BUF_SIZE) internalFlush();
buf[count ++] = 46;
d -= (long)d;
for(int i = 0; i < precision; i ++) {
d *= 10;
buf[count ++] = (byte)((int)d + 48);
d -= (int) d;
}
}
public final void print(final String s) { print(s.getBytes()); }
public final void print(final Object o) { print(o.toString()); }
public final void print(final byte[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
System.arraycopy(a, 0, buf, count, a.length);
count += a.length;
}
public final void print(final char[] a) {
if(count + a.length > BUF_SIZE) internalFlush();
for(int i = 0; i < a.length; i ++) buf[count + i] = (byte)a[i];
count += a.length;
}
public final void println() { print('\n'); }
public final void println(final char c) { print(c); println(); }
public final void println(final boolean b) { print(b); println(); }
public final void println(final int x) { print(x); println(); }
public final void println(final long x) { print(x); println(); }
public final void println(final double d) { print(d); println(); }
public final void println(final double d, final int precision) { print(d, precision); println(); }
public final void println(final String s) { print(s); println(); }
public final void println(final Object o) { print(o); println(); }
public final void println(final char[] a) { print(a); println(); }
public final void println(final int[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final long[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final double[] a, final int precision) {
for(int i = 0; i < a.length; i ++) {
print(a[i], precision);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final String[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
public final void println(final Object[] a) {
for(int i = 0; i < a.length; i ++) {
print(a[i]);
print(i == a.length - 1 ? '\n' : ' ');
}
}
private final void internalFlush() {
try {
out.write(buf, 0, count);
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void flush() {
try {
out.write(buf, 0, count);
out.flush();
count = 0;
}
catch(IOException e) { e.printStackTrace(); }
}
public final void close() {
try { out.close(); }
catch(IOException e) { e.printStackTrace(); }
}
}
public static final class Solver {
private static final FastInputStream in = new FastInputStream(System.in);
public Solver() { }
private static final String nline() { return in.nextLine(); }
private static final String[] nline(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = nline(); return a; }
private static final char nc() { return in.nextChar(); }
private static final char[] nc(int n) {
final String str = nline();
if(n < 0) n = str.length();
final char a[] = new char[n];
for(int i = 0; i < n; i ++) a[i] = str.charAt(i);
return a;
}
private static final char[][] nc(final int n, final int m) { final char a[][] = new char[n][m]; for(int i = 0; i < n; i ++) a[i] = nc(m); return a; }
private static final boolean[] nb(int n, final char t) {
final char c[] = nc(-1);
if(n < 0) n = c.length;
final boolean a[] = new boolean[n];
for(int i = 0; i < n; i ++) a[i] = c[i] == t;
return a;
}
private static final boolean[][] nb(final int n, final int m, final char t) { final boolean a[][] = new boolean[n][]; for(int i = 0; i < n; i ++) a[i] = nb(m, t); return a; }
private static final int ni() { return in.nextInt(); }
private static final int[] ni(final int n) { final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = ni(); return a; }
private static final int[][] ni(final int n, final int m) { final int a[][] = new int[n][]; for(int i = 0; i < n; i ++) a[i] = ni(m); return a; }
private static final long nl() { return in.nextLong(); }
private static final long[] nl(final int n) { final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = nl(); return a; }
private static final long[][] nl(final int n, final int m) { final long a[][] = new long[n][]; for(int i = 0; i < n; i ++) a[i] = nl(m); return a; }
private static final double nd() { return in.nextDouble(); }
private static final double[] nd(final int n) { final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = nd(); return a; }
private static final double[][] nd(final int n, final int m) { final double a[][] = new double[n][]; for(int i = 0; i < n; i ++) a[i] = nd(m); return a; }
private static final String ns() { return in.next(); }
private static final String[] ns(final int n) { final String a[] = new String[n]; for(int i = 0; i < n; i ++) a[i] = ns(); return a; }
private static final String[][] ns(final int n, final int m) { final String a[][] = new String[n][]; for(int i = 0; i < n; i ++) a[i] = ns(m); return a; }
private static final char booleanToChar(final boolean b) { return b ? '#' : '.'; }
private static final char[] booleanToChar(final boolean... a) {
final char c[] = new char[a.length];
for(int i = 0; i < a.length; i ++) c[i] = booleanToChar(a[i]);
return c;
}
private static final FastOutputStream out = new FastOutputStream(System.out);
private static final FastOutputStream err = new FastOutputStream(System.err);
private static final void prt() { out.print(); }
private static final void prt(final char c) { out.print(c); }
private static final void prt(final boolean b) { out.print(b); }
private static final void prt(final int x) { out.print(x); }
private static final void prt(final long x) { out.print(x); }
private static final void prt(final double d) { out.print(d); }
private static final void prt(final String s) { out.print(s); }
private static final void prt(final Object o) { out.print(o); }
private static final void prtln() { out.println(); }
private static final void prtln(final char c) { out.println(c); }
private static final void prtln(final boolean b) { out.println(b); }
private static final void prtln(final int x) { out.println(x); }
private static final void prtln(final long x) { out.println(x); }
private static final void prtln(final double d) { out.println(d); }
private static final void prtln(final String s) { out.println(s); }
private static final void prtln(final Object o) { out.println(o); }
private static final void prtln(final char... a) { out.println(a); }
private static final void prtln(final boolean... a) { out.println(booleanToChar(a)); }
private static final void prtln(final int... a) { out.println(a); }
private static final void prtln(final long... a) { out.println(a); }
private static final void prtln(final double... a) { out.println(a); }
private static final void prtln(final double[] a, int precision) { out.println(a, precision); }
private static final void prtln(final String... a) { out.println(a); }
private static final void prtln(final Object[] a) { out.println(a); }
private static final void prtlns(final char... a) { for(char ele : a) prtln(ele); }
private static final void prtlns(final boolean... a) { for(boolean ele : a) prtln(ele); }
private static final void prtlns(final int... a) { for(int ele : a) prtln(ele); }
private static final void prtlns(final long... a) { for(long ele : a) prtln(ele); }
private static final void prtlns(final double... a) { for(double ele : a) prtln(ele); }
private static final void prtlns(final Object[] a) { for(Object ele : a) prtln(ele); }
private static final void prtln(final char[][] a) { for(char[] ele : a) prtln(ele); }
private static final void prtln(final boolean[][] a) { for(boolean[] ele : a) prtln(ele); }
private static final void prtln(final int[][] a) { for(int[] ele : a) prtln(ele); }
private static final void prtln(final long[][] a) { for(long[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a) { for(double[] ele : a) prtln(ele); }
private static final void prtln(final double[][] a, int precision) { for(double[] ele : a) prtln(ele, precision); }
private static final void prtln(final String[][] a) { for(String[] ele : a) prtln(ele); }
private static final void prtln(final Object[][] a) { for(Object[] ele : a) prtln(ele); }
private static final void errprt() { if(DEBUG) err.print(); }
private static final void errprt(final char c) { if(DEBUG) err.print(c); }
private static final void errprt(final boolean b) { if(DEBUG) err.print(booleanToChar(b)); }
private static final void errprt(final int x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final long x) { if(DEBUG) if(isINF(x)) err.print('_'); else err.print(x); }
private static final void errprt(final double d) { if(DEBUG) err.print(d); }
private static final void errprt(final String s) { if(DEBUG) err.print(s); }
private static final void errprt(final Object o) { if(DEBUG) err.print(o); }
private static final void errprtln() { if(DEBUG) err.println(); }
private static final void errprtln(final char c) { if(DEBUG) err.println(c); }
private static final void errprtln(final boolean b) { if(DEBUG) err.println(booleanToChar(b)); }
private static final void errprtln(final int x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final long x) { if(DEBUG) if(isINF(x)) err.println('_'); else err.println(x); }
private static final void errprtln(final double d) { if(DEBUG) err.println(d); }
private static final void errprtln(final String s) { if(DEBUG) err.println(s); }
private static final void errprtln(final Object o) { if(DEBUG) err.println(o); }
private static final void errprtln(final char... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final boolean... a) { if(DEBUG) err.println(booleanToChar(a)); }
private static final void errprtln(final int... a) {
if(DEBUG) {
boolean start = false;
for(int ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final long... a) {
if(DEBUG) {
boolean start = false;
for(long ele : a) {
errprt(ele);
if(!start) errprt(' ');
start = false;
}
err.println();
}
}
private static final void errprtln(final double... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final double[] a, final int precision) { if(DEBUG) err.println(a, precision); }
private static final void errprtln(final String... a) { if(DEBUG) err.println(a); }
private static final void errprtln(final Object[] a) { if(DEBUG) err.println(a); }
private static final void errprtlns(final char... a) { if(DEBUG) for(char ele : a) errprtln(ele); }
private static final void errprtlns(final boolean... a) { if(DEBUG) for(boolean ele : a) errprtln(ele); }
private static final void errprtlns(final int... a) { if(DEBUG) for(int ele : a) errprtln(ele); }
private static final void errprtlns(final long... a) { if(DEBUG) for(long ele : a) errprtln(ele); }
private static final void errprtlns(final double... a) { if(DEBUG) for(double ele : a) errprtln(ele); }
private static final void errprtlns(final Object[] a) { if(DEBUG) for(Object ele : a) errprtln(ele); }
private static final void errprtln(final char[][] a) { if(DEBUG) for(char[] ele : a) errprtln(ele); }
private static final void errprtln(final boolean[][] a) { if(DEBUG) for(boolean[] ele : a) errprtln(ele); }
private static final void errprtln(final int[][] a) { if(DEBUG) for(int[] ele : a) errprtln(ele); }
private static final void errprtln(final long[][] a) { if(DEBUG) for(long[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a) { if(DEBUG) for(double[] ele : a) errprtln(ele); }
private static final void errprtln(final double[][] a, int precision) { if(DEBUG) for(double[] ele : a) errprtln(ele, precision); }
private static final void errprtln(final String[][] a) { if(DEBUG) for(String[] ele : a) errprtln(ele); }
private static final void errprtln(final Object[][] a) { if(DEBUG) for(Object[] ele : a) errprtln(ele); }
private static final void errprtlns(final Object[][] a) { if(DEBUG) for(Object[] ele : a) { errprtlns(ele); errprtln(); } }
private static final void reply(final boolean b) { prtln(b ? "Yes" : "No"); }
private static final void REPLY(final boolean b) { prtln(b ? "YES" : "NO"); }
private static final void flush() { out.flush(); if(DEBUG) err.flush(); }
private static final void assertion(final boolean b) { if(!b) { flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char c) { if(!b) { errprtln(c); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean b2) { if(!b) { errprtln(b2); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long x) { if(!b) { errprtln(x); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double d) { if(!b) { errprtln(d); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String s) { if(!b) { errprtln(s); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object o) { if(!b) { errprtln(o); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String... a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final char[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final boolean[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final int[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final long[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final double[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final String[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void assertion(final boolean b, final Object[][] a) { if(!b) { errprtln(a); flush(); throw new AssertionError(); } }
private static final void inclusiveRangeCheck(final int i, final int max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final int i, final int min, final int max) { rangeCheck(i, min, max + 1); }
private static final void inclusiveRangeCheck(final long i, final long max) { inclusiveRangeCheck(i, 0, max); }
private static final void inclusiveRangeCheck(final long i, final long min, final long max) { rangeCheck(i, min, max + 1); }
private static final void rangeCheck(final int i, final int max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final int i, final int min, final int max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void rangeCheck(final long i, final long max) { rangeCheck(i, 0, max); }
private static final void rangeCheck(final long i, final long min, final long max) { if(i < min || i >= max) throw new IndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", i, max)); }
private static final void nonNegativeCheck(final long x) { nonNegativeCheck(x, "the argument"); }
private static final void nonNegativeCheck(final long x, final String attribute) { if(x < 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void positiveCheck(final long x) { positiveCheck(x, "the argument"); }
private static final void positiveCheck(final long x, final String attribute) { if(x <= 0) throw new IllegalArgumentException(String.format("%s %d is negative", attribute, x)); }
private static final void exit() { flush(); System.exit(0); }
private static final void exit(final char c) { prtln(c); exit(); }
private static final void exit(final boolean b) { prtln(b); exit(); }
private static final void exit(final int x) { prtln(x); exit(); }
private static final void exit(final long x) { prtln(x); exit(); }
private static final void exit(final double d) { prtln(d); exit(); }
private static final void exit(final String s) { prtln(s); exit(); }
private static final void exit(final Object o) { prtln(o); exit(); }
private static final void exit(final char... a) { prtln(a); exit(); }
private static final void exit(final boolean... a) { prtln(a); exit(); }
private static final void exit(final int... a) { prtln(a); exit(); }
private static final void exit(final long... a) { prtln(a); exit(); }
private static final void exit(final double... a) { prtln(a); exit(); }
private static final void exit(final String... a) { prtln(a); exit(); }
private static final void exit(final Object[] a) { prtln(a); exit(); }
private static final void exit(final char[][] a) { prtln(a); exit(); }
private static final void exit(final boolean[][] a) { prtln(a); exit(); }
private static final void exit(final int[][] a) { prtln(a); exit(); }
private static final void exit(final long[][] a) { prtln(a); exit(); }
private static final void exit(final double[][] a) { prtln(a); exit(); }
private static final void exit(final String[][] a) { prtln(a); exit(); }
private static final void exit(final Object[][] a) { prtln(a); exit(); }
private static final long INF = (long)4e18;
private static final boolean isPlusINF(final long x) { return x > INF / 10; }
private static final boolean isMinusINF(final long x) { return isPlusINF(- x); }
private static final boolean isINF(final long x) { return isPlusINF(x) || isMinusINF(x); }
private static final int I_INF = (int)1e9 + 1000;
private static final boolean isPlusINF(final int x) { return x > I_INF / 10; }
private static final boolean isMinusINF(final int x) { return isPlusINF(- x); }
private static final boolean isINF(final int x) { return isPlusINF(x) || isMinusINF(x); }
private static final int min(final int a, final int b) { return Math.min(a, b); }
private static final long min(final long a, final long b) { return Math.min(a, b); }
private static final double min(final double a, final double b) { return Math.min(a, b); }
private static final <T extends Comparable<T>> T min(final T a, final T b) { return a.compareTo(b) <= 0 ? a : b; }
private static final int min(final int... x) { int min = x[0]; for(int val : x) min = min(min, val); return min; }
private static final long min(final long... x) { long min = x[0]; for(long val : x) min = min(min, val); return min; }
private static final double min(final double... x) { double min = x[0]; for(double val : x) min = min(min, val); return min; }
private static final int max(final int a, final int b) { return Math.max(a, b); }
private static final long max(final long a, final long b) { return Math.max(a, b); }
private static final double max(final double a, final double b) { return Math.max(a, b); }
private static final <T extends Comparable<T>> T max(final T a, final T b) { return a.compareTo(b) >= 0 ? a : b; }
private static final int max(final int... x) { int max = x[0]; for(int val : x) max = max(max, val); return max; }
private static final long max(final long... x) { long max = x[0]; for(long val : x) max = max(max, val); return max; }
private static final double max(final double... x) { double max = x[0]; for(double val : x) max = max(max, val); return max; }
private static final <T extends Comparable<T>> T max(final T[] x) { T max = x[0]; for(T val : x) max = max(max, val); return max; }
private static final int max(final int[][] a) { int max = a[0][0]; for(int[] ele : a) max = max(max, max(ele)); return max; }
private static final long max(final long[][] a) { long max = a[0][0]; for(long[] ele : a) max = max(max, max(ele)); return max; }
private static final double max(final double[][] a) { double max = a[0][0]; for(double[] ele : a) max = max(max, max(ele)); return max; }
private static final <T extends Comparable<T>> T max(final T[][] a) { T max = a[0][0]; for(T[] ele : a) max = max(max, max(ele)); return max; }
private static final long sum(final int... a) { long sum = 0; for(int ele : a) sum += ele; return sum; }
private static final long sum(final long... a) { long sum = 0; for(long ele : a) sum += ele; return sum; }
private static final double sum(final double... a) { double sum = 0; for(double ele : a) sum += ele; return sum; }
private static final int sum(final boolean... a) { int sum = 0; for(boolean ele : a) sum += ele ? 1 : 0; return sum; }
private static final long[] sums(final int[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final long[] sums(final long[] a) { long sum[] = new long[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final double[] sums(final double[] a) { double sum[] = new double[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + a[i]; return sum; }
private static final int[] sums(final boolean[] a) { int sum[] = new int[a.length + 1]; sum[0] = 0; for(int i = 0; i < a.length; i ++) sum[i + 1] = sum[i] + (a[i] ? 1 : 0); return sum; }
private static final long[][] sums(final int[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final long[][] sums(final long[][] a) {
final long sum[][] = new long[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final double[][] sums(final double[][] a) {
final double sum[][] = new double[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + a[i][j];
}
return sum;
}
private static final int[][] sums(final boolean[][] a) {
final int sum[][] = new int[a.length + 1][a[0].length + 1];
for(int i = 0; i < a.length; i ++) {
for(int j = 0; j < a[i].length; j ++) sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + (a[i][j] ? 1 : 0);
}
return sum;
}
private static final int constrain(final int x, final int l, final int r) { return min(max(x, min(l, r)), max(l, r)); }
private static final long constrain(final long x, final long l, final long r) { return min(max(x, min(l, r)), max(l, r)); }
private static final double constrain(final double x, final double l, final double r) { return min(max(x, min(l, r)), max(l, r)); }
private static final int abs(final int x) { return x >= 0 ? x : - x; }
private static final long abs(final long x) { return x >= 0 ? x : - x; }
private static final double abs(final double x) { return x >= 0 ? x : - x; }
private static final int signum(final int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final long x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final int signum(final double x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
private static final long round(final double x) { return Math.round(x); }
private static final long floor(final double x) { return round(Math.floor(x)); }
private static final int divfloor(final int a, final int b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long divfloor(final long a, final long b) { return signum(a) == signum(b) ? a / b : - divceil(abs(a), abs(b)); }
private static final long ceil(final double x) { return round(Math.ceil(x)); }
private static final int divceil(final int a, final int b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final long divceil(final long a, final long b) { return a >= 0 && b > 0 ? (a + b - 1) / b : a < 0 && b < 0 ? divceil(abs(a), abs(b)) : - divfloor(abs(a), abs(b)); }
private static final boolean mulGreater(final long a, final long b, long c) { return b == 0 ? c < 0 : b < 0 ? mulLess(a, - b, - c) : a > divfloor(c, b); } // a * b > c
private static final boolean mulGreaterEquals(final long a, final long b, final long c) { return b == 0 ? c <= 0 : b < 0 ? mulLessEquals(a, - b, - c) : a >= divceil(c, b); } // a * b >= c
private static final boolean mulLess(final long a, final long b, final long c) { return !mulGreaterEquals(a, b, c); } // a * b < c
private static final boolean mulLessEquals(final long a, final long b, final long c) { return !mulGreater(a, b, c); } // a * b <= c
private static final double sqrt(final int x) { return Math.sqrt((double)x); }
private static final double sqrt(final long x) { return Math.sqrt((double)x); }
private static final double sqrt(final double x) { return Math.sqrt(x); }
private static final int floorsqrt(final int x) { int s = (int)floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final long floorsqrt(final long x) { long s = floor(sqrt(x)) + 1; while(s * s > x) s --; return s; }
private static final int ceilsqrt(final int x) { int s = (int)ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long ceilsqrt(final long x) { long s = ceil(sqrt(x)); while(s * s >= x) s --; s ++; return s; }
private static final long fact(final int n) { long ans = 1; for(int i = 1; i <= n; i ++) ans = Math.multiplyExact(ans, i); return ans; }
private static final long naiveP(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) ans = Math.multiplyExact(ans, n - i); return ans; }
private static final long naiveC(final long n, final long r) { long ans = 1; for(int i = 0; i < r; i ++) { ans = Math.multiplyExact(ans, n - i); ans /= (i + 1); } return ans; }
private static final double pow(final double x, final double y) { return Math.pow(x, y); }
private static final long pow(long x, long y) {
long ans = 1;
while(true) {
if((y & 1) != 0) ans = Math.multiplyExact(ans, x);
y >>= 1;
if(y <= 0) return ans;
x = Math.multiplyExact(x, x);
}
}
private static final double pow(double x, long y) {
double ans = 1;
while(true) {
if((y & 1) != 0) ans *= x;
y >>= 1;
if(y <= 0) return ans;
x *= x;
}
}
private static final int gcd(int a, int b) { while(true) { if(b == 0) return a; int tmp = a; a = b; b = tmp % b; } }
private static final long gcd(long a, long b) { while(true) { if(b == 0) return a; long tmp = a; a = b; b = tmp % b; } }
private static final long lcm(final long a, final long b) { return a / gcd(a, b) * b; }
private static final int gcd(final int... a) { int gcd = 0; for(int ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final long gcd(final long... a) { long gcd = 0; for(long ele : a) gcd = gcd(ele, gcd); return gcd; }
private static final double random() { return Math.random(); }
private static final int random(final int max) { return (int)floor(random() * max); }
private static final long random(final long max) { return floor(random() * max); }
private static final double random(final double max) { return random() * max; }
private static final int random(final int min, final int max) { return random(max - min) + min; }
private static final long random(final long min, final long max) { return random(max - min) + min; }
private static final double random(final double min, final double max) { return random(max - min) + min; }
private static final boolean isUpper(final char c) { return c >= 'A' && c <= 'Z'; }
private static final boolean isLower(final char c) { return c >= 'a' && c <= 'z'; }
private static final int upperToInt(final char c) { return c - 'A'; }
private static final int lowerToInt(final char c) { return c - 'a'; }
private static final int numToInt(final char c) { return c - '0'; }
private static final int charToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) : numToInt(c); }
private static final int alphabetToInt(final char c) { return isLower(c) ? lowerToInt(c) : isUpper(c) ? upperToInt(c) + 26 : 52; }
private static final char intToUpper(final int x) { return (char)(x + 'A'); }
private static final char intToLower(final int x) { return (char)(x + 'a'); }
private static final char intToNum(final int x) { return (char)(x + '0'); }
private static final int[] charToInt(final char[] a) { final int toint[] = new int[a.length]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final int[][] charToInt(final char[][] a) { final int toint[][] = new int[a.length][]; for(int i = 0; i < a.length; i ++) toint[i] = charToInt(a[i]); return toint; }
private static final long[] div(final long x) {
nonNegativeCheck(x);
final List<Long> divList = new ArrayList<>();
for(long i = 1; i * i <= x; i ++) if(x % i == 0) { divList.add(i); if(i * i != x) divList.add(x / i); }
final long div[] = new long[divList.size()];
for(int i = 0; i < divList.size(); i ++) div[i] = divList.get(i);
Arrays.sort(div);
return div;
}
private static final PairLL[] factor(long x) {
nonNegativeCheck(x);
final List<PairLL> factorList = new ArrayList<>();
for(long i = 2; i * i <= x; i ++) {
if(x % i == 0) {
long cnt = 0;
while(x % i == 0) { x /= i; cnt ++; }
factorList.add(new PairLL(i, cnt));
}
}
if(x > 1) factorList.add(new PairLL(x, 1));
final PairLL factor[] = new PairLL[factorList.size()];
for(int i = 0; i < factorList.size(); i ++) factor[i] = factorList.get(i);
Arrays.sort(factor);
return factor;
}
private static final boolean isPrime(final long x) { if(x <= 1) return false; for(long i = 2; i * i <= x; i ++) if(x % i == 0) return false; return true; }
private static final boolean[] prime(final int n) {
nonNegativeCheck(n);
final boolean prime[] = new boolean[n];
fill(prime, true);
if(n > 0) prime[0] = false;
if(n > 1) prime[1] = false;
for(int i = 2; i < n; i ++) if(prime[i]) for(int j = 2; i * j < n; j ++) prime[i * j] = false;
return prime;
}
private static final PairIL[] countElements(final int[] a, final boolean sort) {
final int len = a.length;
final int array[] = new int[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairLL[] countElements(final long[] a, final boolean sort) {
final int len = a.length;
final long array[] = new long[len];
for(int i = 0; i < len; i ++) array[i] = a[i];
if(sort) Arrays.sort(array);
final List<PairLL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairLL(array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairLL cnts[] = new PairLL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final PairIL[] countElements(final String s, final boolean sort) {
final int len = s.length();
final char array[] = s.toCharArray();
if(sort) Arrays.sort(array);
final List<PairIL> cntsList = new ArrayList<>();
long tmp = 1;
for(int i = 1; i <= len; i ++) {
if(i == len || array[i] != array[i - 1]) {
cntsList.add(new PairIL((int)array[i - 1], tmp));
tmp = 1;
}else tmp ++;
}
final PairIL cnts[] = new PairIL[cntsList.size()];
for(int i = 0; i < cntsList.size(); i ++) cnts[i] = cntsList.get(i);
return cnts;
}
private static final long triangular(final long n) { return n * (n + 1) / 2; }
private static final long arctriangularfloor(final long m) {
long n = (floor(sqrt(m * 8 + 1)) - 1) / 2 + 1;
while(triangular(n) > m) n --;
return n;
}
private static final long arctriangularceil(final long m) {
long n = max(0, (ceil(sqrt(m * 8 + 1)) + 1) / 2 - 1);
while(triangular(n) < m) n ++;
return n;
}
private static final int[] baseConvert(long x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final long x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int[] baseConvert(int x, final int n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final int digit[] = new int[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = (int)(x % n); x /= n; }
return digit;
}
private static final int[] baseConvert(final int x, final int n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
int tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final long[] baseConvert(long x, final long n, final int len) {
nonNegativeCheck(x);
nonNegativeCheck(n);
nonNegativeCheck(len);
final long digit[] = new long[len];
int i = 0;
while(x > 0 && i < len) { digit[i ++] = x % n; x /= n; }
return digit;
}
private static final long[] baseConvert(final long x, final long n) {
nonNegativeCheck(x);
nonNegativeCheck(n);
long tmp = x;
int len = 0;
while(tmp > 0) { tmp /= n; len ++; }
return baseConvert(x, n, len);
}
private static final int numDigits(final long x) { nonNegativeCheck(x); return Long.toString(x).length(); }
private static final long bitFlag(final int i) { nonNegativeCheck(i); return 1L << i; }
private static final boolean isFlagged(final long x, final int i) { nonNegativeCheck(x); nonNegativeCheck(i); return (x >> i & 1) != 0; }
private static final long countString(final String s, final String t) { return (s.length() - s.replace(t, "").length()) / t.length(); }
private static final long countStringAll(final String s, final String t) { return s.length() - s.replaceAll(t, "").length(); }
private static final String reverse(final String s) { return (new StringBuilder(s)).reverse().toString(); }
private static final char[] reverse(final char[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final boolean[] reverse(final boolean[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final int[] reverse(final int[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final long[] reverse(final long[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final double[] reverse(final double[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final String[] reverse(final String[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final Object[] reverse(final Object[] a) { for(int i = 0; i < a.length / 2; i ++) swap(a, i, a.length - i - 1); return a; }
private static final void fill(final char[] a, final char x) { Arrays.fill(a, x); }
private static final void fill(final boolean[] a, final boolean x) { Arrays.fill(a, x); }
private static final void fill(final int[] a, final int x) { Arrays.fill(a, x); }
private static final void fill(final long[] a, final long x) { Arrays.fill(a, x); }
private static final void fill(final double[] a, final double x) { Arrays.fill(a, x); }
private static final void fill(final char[][] a, final char x) { for(char[] ele : a) fill(ele, x); }
private static final void fill(final boolean[][] a, final boolean x) { for(boolean[] ele : a) fill(ele, x); }
private static final void fill(final int[][] a, final int x) { for(int[] ele : a) fill(ele, x); }
private static final void fill(final long[][] a, final long x) { for(long[] ele : a) fill(ele, x); }
private static final void fill(final double[][] a, final double x) { for(double[] ele : a) fill(ele, x); }
private static final void fill(final char[][][] a, final char x) { for(char[][] ele : a) fill(ele, x); }
private static final void fill(final boolean[][][] a, final boolean x) { for(boolean[][] ele : a) fill(ele, x); }
private static final void fill(final int[][][] a, final int x) { for(int[][] ele : a) fill(ele, x); }
private static final void fill(final long[][][] a, final long x) { for(long[][] ele : a) fill(ele, x); }
private static final void fill(final double[][][] a, final double x) { for(double[][] ele : a) fill(ele, x); }
private static final char[] resize(final char[] a, final int m, final int x) {
nonNegativeCheck(m);
final char resized[] = new char[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final boolean[] resize(final boolean[] a, final int m, final int x) {
nonNegativeCheck(m);
final boolean resized[] = new boolean[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] resize(final int[] a, final int m, final int x) {
nonNegativeCheck(m);
final int resized[] = new int[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final long[] resize(final long[] a, final int m, final int x) {
nonNegativeCheck(m);
final long resized[] = new long[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final double[] resize(final double[] a, final int m, final int x) {
nonNegativeCheck(m);
final double resized[] = new double[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final String[] resize(final String[] a, final int m, final int x) {
nonNegativeCheck(m);
final String resized[] = new String[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final Object[] resize(final Object[] a, final int m, final int x) {
nonNegativeCheck(m);
final Object resized[] = new Object[m];
if(x <= - a.length || x >= m) return resized;
if(x >= 0) System.arraycopy(a, 0, resized, x, min(a.length, m - x));
else System.arraycopy(a, - x, resized, 0, min(a.length + x, m));
return resized;
}
private static final int[] toIntArray(final List<Integer> list) { final int a[] = new int[list.size()]; int idx = 0; for(int ele : list) a[idx ++] = ele; return a; }
private static final long[] toLongArray(final List<Long> list) { final long a[] = new long[list.size()]; int idx = 0; for(long ele : list) a[idx ++] = ele; return a; }
private static final double[] toDoubleArray(final List<Double> list) { final double a[] = new double[list.size()]; int idx = 0; for(double ele : list) a[idx ++] = ele; return a; }
private static final char[] toCharArray(final List<Character> list) { final char a[] = new char[list.size()]; int idx = 0; for(char ele : list) a[idx ++] = ele; return a; }
private static final boolean[] toBooleanArray(final List<Boolean> list) { final boolean a[] = new boolean[list.size()]; int idx = 0; for(boolean ele : list) a[idx ++] = ele; return a; }
private static final String[] toStringArray(final List<String> list) { final String a[] = new String[list.size()]; int idx = 0; for(String ele : list) a[idx ++] = ele; return a; }
private static final <T> void toArray(final List<T> list, final T a[]) { int idx = 0; for(T ele : list) a[idx ++] = ele; }
private static final void shuffleArray(final int[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final long[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final void shuffleArray(final double[] a) { for(int i = 0; i < a.length; i ++) swap(a, i, random(i, a.length)); }
private static final int[] randomi(final int n, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final long[] randoml(final int n, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final double[] randomd(final int n, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(max); return a; }
private static final int[] randomi(final int n, final int min, final int max) { nonNegativeCheck(n); final int a[] = new int[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final long[] randoml(final int n, final long min, final long max) { nonNegativeCheck(n); final long a[] = new long[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final double[] randomd(final int n, final double min, final double max) { nonNegativeCheck(n); final double a[] = new double[n]; for(int i = 0; i < n; i ++) a[i] = random(min, max); return a; }
private static final void swap(final char[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); char tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final boolean[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); boolean tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final int[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final long[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); long tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final double[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); double tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final String[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); String tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final void swap(final Object[] a, final int i, final int j) { rangeCheck(i, a.length); rangeCheck(j, a.length); Object tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
private static final char[][] rotate(final char[][] a) {
final char[][] ans = new char[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final boolean[][] rotate(final boolean[][] a) {
final boolean[][] ans = new boolean[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[][] rotate(final int[][] a) {
final int[][] ans = new int[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final long[][] rotate(final long[][] a) {
final long[][] ans = new long[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final double[][] rotate(final double[][] a) {
final double[][] ans = new double[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final Object[][] rotate(final Object[][] a) {
final Object[][] ans = new Object[a[0].length][a.length];
for(int i = 0; i < a.length; i ++) for(int j = 0; j < a[i].length; j ++) ans[j][a.length - i - 1] = a[i][j];
return ans;
}
private static final int[] compress(final int[] a) {
final int n = a.length;
final Set<Integer> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final int compressed[] = new int[ts.size()];
int j = 0;
for(int x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final long[] compress(final long[] a) {
final int n = a.length;
final Set<Long> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final long compressed[] = new long[ts.size()];
int j = 0;
for(long x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
private static final double[] compress(final double[] a) {
final int n = a.length;
final Set<Double> ts = new TreeSet<>();
for(int i = 0; i < n; i ++) ts.add(a[i]);
final double compressed[] = new double[ts.size()];
int j = 0;
for(double x : ts) compressed[j ++] = x;
for(int i = 0; i < n; i ++) a[i] = lowerBound(compressed, a[i]);
return compressed;
}
// binary search
private static final int lowerBound(final int[] a, final int key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final int[] a, final int key) { return BS(a, key, true, true, false); }
private static final int upperBound(final int[] a, final int key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final int[] a, final int key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final int[] a, final int key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final int[] a, final int key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final int[] a, final int index, final int key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final long[] a, final long key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final long[] a, final long key) { return BS(a, key, true, true, false); }
private static final int upperBound(final long[] a, final long key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final long[] a, final long key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final long[] a, final long key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final long[] a, final long key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final long[] a, final int index, final long key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final int lowerBound(final double[] a, final double key) { return BS(a, key, true, true, true); }
private static final int lowerBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final int upperBound(final double[] a, final double key) { return BS(a, key, true, true, false); }
private static final int upperBound(final double[] a, final double key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final int cntBS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final int cntBS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final int BS(final double[] a, final double key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final int BS(final double[] a, final double key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final int binarySearch(final double[] a, final double key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final boolean isOKforBS(final double[] a, final int index, final double key, final boolean gt, final boolean eq) {
return (a[index] > key && gt) || (a[index] < key && !gt) || (a[index] == key && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final T[] a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length); }
private static final <T extends Comparable<? super T>> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final T[] a, final int index, final T key, final boolean gt, final boolean eq) {
int compare = a[index].compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final T[] a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final T[] a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final T[] a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.length : -1, asc ^ gt ? -1 : a.length, c); }
private static final <T> int BS(final T[] a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final T[] a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final T[] a, final int index, T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a[index], key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key) { return BS(a, key, true, true, true); }
private static final <T extends Comparable<? super T>> int lowerBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, true, ng, ok); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key) { return BS(a, key, true, true, false); }
private static final <T extends Comparable<? super T>> int upperBound(final List<T> a, final T key, final int ng, final int ok) { return BS(a, key, true, true, false, ng, ok); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, true); }
private static final <T extends Comparable<? super T>> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, true, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq) { return BS(a, key, asc, gt, eq, false); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok) { return BS(a, key, asc, gt, eq, false, ng, ok); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size()); }
private static final <T extends Comparable<? super T>> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok) {
int index = binarySearch(a, key, gt, eq, ng, ok);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T extends Comparable<? super T>> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq)) ok = mid; else ng = mid; }
return ok;
}
private static final <T extends Comparable<? super T>> boolean isOKforBS(final List<T> a, final int index, T key, final boolean gt, final boolean eq) {
int compare = a.get(index).compareTo(key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final <T> int lowerBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, true, c); }
private static final <T> int lowerBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, true, ng, ok, c); }
private static final <T> int upperBound(final List<T> a, final T key, final Comparator<? super T> c) { return BS(a, key, true, true, false, c); }
private static final <T> int upperBound(final List<T> a, final T key, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, true, true, false, ng, ok, c); }
private static final <T> int cntBS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, c); }
private static final <T> int cntBS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, true, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final int ng, final int ok, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, false, ng, ok, c); }
private static final <T> int BS(final List<T> a, final T key,
final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final Comparator<? super T> c) { return BS(a, key, asc, gt, eq, cnt, asc ^ gt ? a.size() : -1, asc ^ gt ? -1 : a.size(), c); }
private static final <T> int BS(final List<T> a, final T key, final boolean asc, final boolean gt, final boolean eq, final boolean cnt, final int ng, final int ok, final Comparator<? super T> c) {
int index = binarySearch(a, key, gt, eq, ng, ok, c);
return cnt ? (int)abs(ok - index) : index;
}
private static final <T> int binarySearch(final List<T> a, final T key, final boolean gt, final boolean eq, int ng, int ok, final Comparator<? super T> c) {
while(abs(ok - ng) > 1) { int mid = (ok + ng) >> 1; if(isOKforBS(a, mid, key, gt, eq, c)) ok = mid; else ng = mid; }
return ok;
}
private static final <T> boolean isOKforBS(final List<T> a, final int index, final T key, final boolean gt, final boolean eq, final Comparator<? super T> c) {
int compare = c.compare(a.get(index), key);
return (compare > 0 && gt) || (compare < 0 && !gt) || (compare == 0 && eq);
}
private static final PairLL binaryRangeSearch(final long left, final long right, final UnaryOperator<Long> op, final boolean minimize) {
long ok1 = right, ng1 = left;
while(abs(ok1 - ng1) > 1) {
long mid = (ok1 + ng1) >> 1;
boolean isOK = (op.apply(mid + 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok1 = mid; else ng1 = mid;
}
long ok2 = left, ng2 = right;
while(abs(ok2 - ng2) > 1) {
long mid = (ok2 + ng2) >> 1;
boolean isOK = (op.apply(mid - 1) - op.apply(mid)) * (minimize ? 1 : -1) >= 0;
if(isOK) ok2 = mid; else ng2 = mid;
}
return new PairLL(ok1, ok2); //[l, r]
}
private static final double ternarySearch(double left, double right, final UnaryOperator<Double> op, final boolean minimize, final int loop) {
for(int cnt = 0; cnt < loop; cnt ++) {
double m1 = (left * 2 + right) / 3.0;
double m2 = (left + right * 2) / 3.0;
if(op.apply(m1) > op.apply(m2) ^ minimize) right = m2; else left = m1;
}
return (left + right) / 2.0;
}
// mods
private static final class Mod107 extends Mod {
public static final Mod107 md = new Mod107();
public static final long MOD = 1_000_000_007;
private Mod107() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod998 extends Mod {
public static final Mod998 md = new Mod998();
public static final long MOD = 998_244_353;
private Mod998() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod754974721 extends Mod {
public static final Mod754974721 md = new Mod754974721();
public static final long MOD = 754_974_721;
private Mod754974721() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod167772161 extends Mod {
public static final Mod167772161 md = new Mod167772161();
public static final long MOD = 167_772_161;
private Mod167772161() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class Mod469762049 extends Mod {
public static final Mod469762049 md = new Mod469762049();
public static final long MOD = 469_762_049;
private Mod469762049() { super(MOD); }
@Override
public final long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return (x %= MOD) < 0 ? x + MOD : x;
}
@Override
public final long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return (x * y) % MOD;
x = mod(x);
y = mod(y);
return (x * y) % MOD;
}
}
private static final class ArbitraryMod extends Mod {
private static final long MASK = 0xffff_ffffl;
private final long MH;
private final long ML;
public ArbitraryMod(long mod) { super(mod); long a = (1l << 32) / MOD; long b = (1l << 32) % MOD; long m = a * a * MOD + 2 * a * b + (b * b) / MOD; MH = m >>> 32; ML = m & MASK; }
private final long reduce(long x) {
if(MOD == 1) return 0;
if(x < 0) return (x = reduce(- x)) == 0 ? 0 : MOD - x;
long z = (x & MASK) * ML;
z = (x & MASK) * MH + (x >>> 32) * ML + (z >>> 32);
z = (x >>> 32) * MH + (z >>> 32);
x -= z * MOD;
return x < MOD ? x : x - MOD;
}
@Override
public long mod(long x) {
if(0 <= x && x < MOD) return x;
if(- MOD <= x && x < 0) return x + MOD;
return reduce(x);
}
@Override
public long mul(long x, long y) {
if(x >= 0 && x < MOD && y >= 0 && y < MOD) return reduce(x * y);
x = mod(x);
y = mod(y);
return reduce(x * y);
}
}
private abstract static class Mod {
public final long MOD;
public Mod(long mod) { MOD = mod; }
public abstract long mod(long x);
public final long[] mod(final long[] a) { for(int i = 0; i < a.length; i ++) a[i] = mod(a[i]); return a; }
public final long[][] mod(final long[][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public final long[][][] mod(final long[][][] a) { for(int i = 0; i < a.length; i ++) mod(a[i]); return a; }
public long add(long x, final long y) { return (x += y) >= MOD * 2 || x < 0 ? mod(x) : x >= MOD ? x - MOD : x; }
public final long sum(final long... x) { long sum = 0; for(long ele : x) sum = add(sum, ele); return sum; }
public long sub(long x, final long y) { return (x -= y) < - MOD || x >= MOD ? mod(x) : x < 0 ? x + MOD : x; }
public final long pow(long x, long y) {
nonNegativeCheck(y);
x = mod(x);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mul(ans, x);
x = mul(x, x);
}
return ans;
}
public abstract long mul(long x, long y);
public final long mul(final long... x) { long ans = 1; for(long ele : x) ans = mul(ans, ele); return ans; }
public final long div(final long x, final long y) { return mul(x, inv(y)); }
public final long[] pows(long x, final int n) {
x = mod(x);
long pow[] = new long[n + 1];
pow[0] = 1;
for(int i = 0; i < n; i ++) pow[i + 1] = mul(pow[i], x);
return pow;
}
public final long fact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return fact[n];
else {
long ans = fact[MAX_FACT1 - 1];
for(int i = MAX_FACT1; i <= n; i ++) ans = mul(ans, i);
return ans;
}
}
public final long invFact(final int n) {
nonNegativeCheck(n);
prepareFact();
if(n < MAX_FACT1) return invFact[n];
else return inv(fact(n));
}
private static final int MAX_INV_SIZE = 100_100;
public final Map<Long, Long> invMap = new HashMap<>();
public final long inv(long x) {
x = mod(x);
if(invMap.containsKey(x)) return invMap.get(x);
if(invMap.size() >= MAX_INV_SIZE) return calInv(x);
invMap.put(x, calInv(x));
return invMap.get(x);
}
private final long calInv(final long x) { // O(logM)
PairLL s = new PairLL(MOD, 0);
PairLL t = new PairLL(mod(x), 1);
while(t.a > 0) {
long tmp = s.a / t.a;
PairLL u = new PairLL(s.a - t.a * tmp, s.b - t.b * tmp);
s = t;
t = u;
}
if(s.b < 0) s.b += MOD / s.a;
return s.b;
}
public final long[] invs(final int n) { // O(N)
positiveCheck(n);
long inv[] = new long[n + 1];
inv[1] = 1;
for(int i = 2; i <= n; i ++) inv[i] = mul(inv[(int)(MOD % i)], (MOD - MOD / i));
return inv;
}
private long g;
public final long primitiveRoot() { // O(1) or O(M^(1/2))
if(MOD == 2) return 1;
if(MOD == 167772161) return 3;
if(MOD == 469762049) return 3;
if(MOD == 754974721) return 11;
if(MOD == 998244353) return 3;
if(g != 0) return g;
PairLL factor[] = factor(MOD - 1);
outer: for(g = 2; ; g ++) {
for(PairLL p : factor) if(pow(g, (MOD - 1) / p.a) == 1) continue outer;
return g;
}
}
private static final int MAX_FACT1 = 5_000_100;
private static final int MAX_FACT2 = 500_100;
private static final int MAX_FACT_MAP_SIZE = 100;
private long fact[];
private long invFact[];
private boolean isFactPrepared = false;
private final Map<Long, long[]> factMap = new HashMap<>();
private final void prepareFact() {
if(isFactPrepared) return;
fact = new long[MAX_FACT1];
invFact = new long[MAX_FACT1];
fill(fact, 0);
fill(invFact, 0);
fact[0] = 1;
int maxIndex = min(MAX_FACT1, (int)MOD);
for(int i = 1; i < maxIndex; i ++) fact[i] = mul(fact[i - 1], i);
invFact[maxIndex - 1] = inv(fact[maxIndex - 1]);
for(int i = maxIndex - 1; i > 0; i --) invFact[i - 1] = mul(invFact[i], i);
isFactPrepared = true;
}
public final long P(final long n, final long r) {
if(!isFactPrepared) prepareFact();
if(n < 0 || r < 0 || n < r) return 0;
if(n < MAX_FACT1 && n < MOD) return mul(fact[(int)n], invFact[(int)(n - r)]);
if(!factMap.containsKey(n)) {
long largeFact[] = new long[MAX_FACT2];
factMap.put(n, largeFact);
fill(largeFact, -1);
largeFact[0] = 1;
}
long largeFact[] = factMap.get(n);
if(r >= MAX_FACT2) {
long ans = 1;
for(long i = n - r + 1; i <= n; i ++) ans = mul(ans, i);
return ans;
}else {
int i = (int)r;
while(largeFact[i] < 0) i --;
for(; i < r; i ++) largeFact[i + 1] = mul(largeFact[i], n - i);
if(factMap.size() > MAX_FACT_MAP_SIZE) factMap.remove(n);
return largeFact[(int)r];
}
}
public final long C(final long n, long r) {
if(!isFactPrepared) prepareFact();
if(n < 0) return mod(C(- n + r - 1, - n - 1) * ((r & 1) == 0 ? 1 : -1));
if(r < 0 || n < r) return 0;
r = min(r, n - r);
if(n < MOD) return mul(P(n, r), r < MAX_FACT1 ? invFact[(int)r] : inv(fact((int)r)));
long digitN[] = baseConvert(n, MOD);
long digitR[] = baseConvert(r, MOD);
final int len = digitN.length;
digitR = resize(digitR, len, 0);
long ans = 1;
for(int i = 0; i < len; i ++) ans = mul(ans, C(digitN[i], digitR[i]));
return ans;
}
public final long H(final long n, final long r) { return C(n - 1 + r, r); }
public final long sqrt(long x) {
x = mod(x);
long p = (MOD - 1) >> 1;
if(pow(x, p) != 1) return -1;
long q = MOD - 1;
int m = 1;
while(((q >>= 1) & 1) == 0) m ++;
long z = 1;
while(pow(z, p) == 1) z = random(1, MOD);
long c = pow(z, q);
long t = pow(x, q);
long r = pow(x, (q + 1) >> 1);
if(t == 0) return 0;
m -= 2;
while(t != 1) {
long pows[] = new long[m + 1];
pows[0] = t;
for(int i = 0; i < m; i ++) pows[i + 1] = mul(pows[i], pows[i]);
while(pows[m --] == 1) c = mul(c, c);
r = mul(r, c);
c = mul(c, c);
t = mul(t, c);
}
return r;
}
}
private static final long mod(long x, final long mod) {
if(0 <= x && x < mod) return x;
if(- mod <= x && x < 0) return x + mod;
return (x %= mod) < 0 ? x + mod : x;
}
private static final long pow(long x, long y, final long mod) {
nonNegativeCheck(y);
x = mod(x, mod);
long ans = 1;
for(; y > 0; y >>= 1) {
if((y & 1) != 0) ans = mod(ans * x, mod);
x = mod(x * x, mod);
}
return ans;
}
// grid
private static class Grids {
public final int h, w;
public final Grid[][] gs;
public final Grid[] gi;
public Grids(final int h, final int w) {
nonNegativeCheck(h);
nonNegativeCheck(w);
this.h = h;
this.w = w;
gs = new Grid[h][w];
gi = new Grid[h * w];
for(int i = 0; i < h; i ++) {
for(int j = 0; j < w; j ++) {
gs[i][j] = new Grid(i, j, h, w);
gi[gs[i][j].i] = gs[i][j];
}
}
}
public final void init(final boolean[][] b) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].b = b[i][j]; }
public final void init(final long[][] val) { for(int i = 0; i < h; i ++) for(int j = 0; j < w; j ++) gs[i][j].val = val[i][j]; }
public final Grid get(final int x, final int y) { return isValid(x, y, h, w) ? gs[x][y] : null; }
public final Grid get(final int i) { return get(i / w, i % w); }
public static final int dx[] = {0, -1, 1, 0, 0, -1, 1, -1, 1};
public static final int dy[] = {0, 0, 0, -1, 1, -1, -1, 1, 1};
public final Grid next(final int x, final int y, final int i) { return next(gs[x][y], i); }
public final Grid next(final Grid g, final int i) { return isValid(g.x + dx[i], g.y + dy[i], g.h, g.w) ? gs[g.x + dx[i]][g.y + dy[i]] : null; }
}
private static class Grid implements Comparable<Grid> {
public int x, y, h, w, i; public boolean b; public long val;
public Grid() { }
public Grid(final int x, final int y, final int h, final int w) { init(x, y, h, w, false, 0); }
public Grid(final int x, final int y, final int h, final int w, final boolean b) { init(x, y, h, w, b, 0); }
public Grid(final int x, final int y, final int h, final int w, final long val) { init(x, y, h, w, false, val); }
public Grid(final int x, final int y, final int h, final int w, final boolean b, final long val) { init(x, y, h, w, b, val); }
public final void init(final int x, final int y, final int h, final int w, final boolean b, final long val) { this.x = x; this.y = y; this.h = h; this.w = w; this.b = b; this.val = val; this.i = x * w + y; }
@Override public final String toString() { return "("+x+", "+y+")"+" "+booleanToChar(b)+" "+val; }
@Override public final int hashCode() { return Objects.hash(x, y, h, w, b, val); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Grid that = (Grid) obj;
if(this.x != that.x) return false;
if(this.y != that.y) return false;
if(this.h != that.h) return false;
if(this.w != that.w) return false;
if(this.b != that.b) return false;
if(this.val != that.val) return false;
return true;
}
@Override
public final int compareTo(final Grid that) {
int c = Long.compare(this.val, that.val);
if(c == 0) c = Integer.compare(this.x, that.x);
if(c == 0) c = Integer.compare(this.y, that.y);
return c;
}
}
private static final boolean isValid(final int x, final int y, final int h, final int w) { return x >= 0 && x < h && y >= 0 && y < w; }
private static final boolean isValid(final Grid g) { return isValid(g.x, g.y, g.h, g.w); }
// graph
private static class Graph {
public int numNode, numEdge;
public boolean directed;
public List<Edge> edges = new ArrayList<>();
public Node nodes[];
public Node reversedNodes[];
public Graph(final int numNode, final int numEdge, final boolean directed) {
nonNegativeCheck(numNode);
this.numNode = numNode;
this.numEdge = numEdge;
this.directed = directed;
nodes = new Node[numNode];
reversedNodes = new Node[numNode];
for(int i = 0; i < numNode; i ++) {
nodes[i] = new Node(i);
reversedNodes[i] = new Node(i);
}
}
public void init(final List<Edge> edges) {
this.edges = edges;
for(Edge e : edges) add(e);
}
public void add(final int source, final int target, final long cost) { add(new Edge(source, target, cost)); }
public void add(final Edge e) {
rangeCheck(e.source, numNode);
rangeCheck(e.target, numNode);
edges.add(e);
nodes[e.source].add(e.target, e.cost);
if(directed) reversedNodes[e.target].add(e.source, e.cost);
else nodes[e.target].add(e.source, e.cost);
numEdge = edges.size();
}
public void clearNodes() { edges.clear(); numEdge = 0; for(Node n : nodes) n.clear(); for(Node n : reversedNodes) n.clear(); }
}
private static class Node extends ArrayList<Edge> {
public final int id;
public Node(final int id) { this.id = id; }
public void add(final int target, final long cost) { add(new Edge(id, target, cost)); }
}
private static class Edge implements Comparable<Edge> {
public int source, target; public long cost;
public Edge(final int source, final int target, final long cost) { this.source = source; this.target = target; this.cost = cost; }
@Override public final String toString() { return source+" - "+cost+" -> "+target; }
@Override public final int hashCode() { return Objects.hash(source, target); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Edge that = (Edge) obj;
if(this.source != that.source) return false;
if(this.target != that.target) return false;
return true;
}
@Override
public final int compareTo(final Edge that) {
int c = Long.compare(this.cost, that.cost);
if(c == 0) c = Integer.compare(this.source, that.source);
if(c == 0) c = Integer.compare(this.target, that.target);
return c;
}
}
// Pair
private static class Pair<T extends Comparable<? super T>, U extends Comparable<? super U>> implements Comparable<Pair<T, U>> {
public T a; public U b;
public Pair() { }
public Pair(final T a, final U b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a.toString()+", "+b.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Pair that = (Pair) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(this.b.getClass() != that.b.getClass()) return false;
if(!this.a.equals(that.a)) return false;
if(!this.b.equals(that.b)) return false;
return true;
}
@Override public final int compareTo(final Pair<T, U> that) { int c = (this.a).compareTo(that.a); if(c == 0) c = (this.b).compareTo(that.b); return c; }
}
private static final PairII npii() { return new PairII(ni(), ni()); }
private static final PairII[] npii(final int n) { final PairII a[] = new PairII[n]; for(int i = 0; i < n; i ++) a[i] = npii(); return a; }
private static final PairII[][] npii(final int n, final int m) { final PairII a[][] = new PairII[n][m]; for(int i = 0; i < n; i ++) a[i] = npii(m); return a; }
private static class PairII implements Comparable<PairII> {
public int a; public int b;
public PairII() { }
public PairII(final int a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairII that = (PairII) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairIL npil() { return new PairIL(ni(), nl()); }
private static final PairIL[] npil(final int n) { final PairIL a[] = new PairIL[n]; for(int i = 0; i < n; i ++) a[i] = npil(); return a; }
private static final PairIL[][] npil(final int n, final int m) { final PairIL a[][] = new PairIL[n][m]; for(int i = 0; i < n; i ++) a[i] = npil(m); return a; }
private static class PairIL implements Comparable<PairIL> {
public int a; public long b;
public PairIL() { }
public PairIL(final int a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairIL that = (PairIL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairID npid() { return new PairID(ni(), nd()); }
private static final PairID[] npid(final int n) { final PairID a[] = new PairID[n]; for(int i = 0; i < n; i ++) a[i] = npid(); return a; }
private static final PairID[][] npid(final int n, final int m) { final PairID a[][] = new PairID[n][m]; for(int i = 0; i < n; i ++) a[i] = npid(m); return a; }
private static class PairID implements Comparable<PairID> {
public int a; public double b;
public PairID() { }
public PairID(final int a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairID that = (PairID) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairLI npli() { return new PairLI(nl(), ni()); }
private static final PairLI[] npli(final int n) { final PairLI a[] = new PairLI[n]; for(int i = 0; i < n; i ++) a[i] = npli(); return a; }
private static final PairLI[][] npli(final int n, final int m) { final PairLI a[][] = new PairLI[n][m]; for(int i = 0; i < n; i ++) a[i] = npli(m); return a; }
private static class PairLI implements Comparable<PairLI> {
public long a; public int b;
public PairLI() { }
public PairLI(final long a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLI that = (PairLI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairLL npll() { return new PairLL(nl(), nl()); }
private static final PairLL[] npll(final int n) { final PairLL a[] = new PairLL[n]; for(int i = 0; i < n; i ++) a[i] = npll(); return a; }
private static final PairLL[][] npll(final int n, final int m) { final PairLL a[][] = new PairLL[n][m]; for(int i = 0; i < n; i ++) a[i] = npll(m); return a; }
private static class PairLL implements Comparable<PairLL> {
public long a; public long b;
public PairLL() { }
public PairLL(final long a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLL that = (PairLL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairLD npld() { return new PairLD(nl(), nd()); }
private static final PairLD[] npld(final int n) { final PairLD a[] = new PairLD[n]; for(int i = 0; i < n; i ++) a[i] = npld(); return a; }
private static final PairLD[][] npld(final int n, final int m) { final PairLD a[][] = new PairLD[n][m]; for(int i = 0; i < n; i ++) a[i] = npld(m); return a; }
private static class PairLD implements Comparable<PairLD> {
public long a; public double b;
public PairLD() { }
public PairLD(final long a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairLD that = (PairLD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
private static final PairDI npdi() { return new PairDI(nd(), ni()); }
private static final PairDI[] npdi(final int n) { final PairDI a[] = new PairDI[n]; for(int i = 0; i < n; i ++) a[i] = npdi(); return a; }
private static final PairDI[][] npdi(final int n, final int m) { final PairDI a[][] = new PairDI[n][m]; for(int i = 0; i < n; i ++) a[i] = npdi(m); return a; }
private static class PairDI implements Comparable<PairDI> {
public double a; public int b;
public PairDI() { }
public PairDI(final double a, final int b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDI that = (PairDI) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); return c; }
}
private static final PairDL npdl() { return new PairDL(nd(), nl()); }
private static final PairDL[] npdl(final int n) { final PairDL a[] = new PairDL[n]; for(int i = 0; i < n; i ++) a[i] = npdl(); return a; }
private static final PairDL[][] npdl(final int n, final int m) { final PairDL a[][] = new PairDL[n][m]; for(int i = 0; i < n; i ++) a[i] = npdl(m); return a; }
private static class PairDL implements Comparable<PairDL> {
public double a; public long b;
public PairDL() { }
public PairDL(final double a, final long b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDL that = (PairDL) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); return c; }
}
private static final PairDD npdd() { return new PairDD(nd(), nd()); }
private static final PairDD[] npdd(final int n) { final PairDD a[] = new PairDD[n]; for(int i = 0; i < n; i ++) a[i] = npdd(); return a; }
private static final PairDD[][] npdd(final int n, final int m) { final PairDD a[][] = new PairDD[n][m]; for(int i = 0; i < n; i ++) a[i] = npdd(m); return a; }
private static class PairDD implements Comparable<PairDD> {
public double a; public double b;
public PairDD() { }
public PairDD(final double a, final double b) { this.a = a; this.b = b; }
@Override public final String toString() { return "("+a+", "+b+")"; }
@Override public final int hashCode() { return Objects.hash(a, b); }
@Override
public boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
PairDD that = (PairDD) obj;
if(this.a != that.a || this.b != that.b) return false;
return true;
}
@Override public final int compareTo(final PairDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); return c; }
}
// Tuple
private interface ITuple {
public StringBuilder toStringBuilder();
@Override public String toString();
@Override public int hashCode();
@Override public boolean equals(Object obj);
}
private static class BasicTuple<T extends ITuple & Comparable<? super T>, V extends Comparable<? super V>> implements Comparable<BasicTuple> {
public T t; public V a;
public BasicTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() {
sbTuple.setLength(0);
return sbTuple.append(t.toStringBuilder()).append(", ").append(a);
}
@Override public final String toString() { return "("+toStringBuilder().toString()+")"; }
@Override public final int hashCode() { return Objects.hash(t, a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
BasicTuple that = (BasicTuple) obj;
if(this.t.getClass() != that.t.getClass()) return false;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.t.equals(that.t)) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(BasicTuple that) { int c = (this.t).compareTo((T) (Object) that.t); if(c == 0) c = (this.a).compareTo((V) (Object) that.a); return c; }
}
private static class UniqueTuple<V extends Comparable<? super V>> implements ITuple, Comparable<UniqueTuple> {
public V a;
public UniqueTuple() { }
private final StringBuilder sbTuple = new StringBuilder();
public final StringBuilder toStringBuilder() { sbTuple.setLength(0); return sbTuple.append(a); }
@Override public final String toString() { return "("+a.toString()+")"; }
@Override public final int hashCode() { return Objects.hash(a); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
UniqueTuple that = (UniqueTuple) obj;
if(this.a.getClass() != that.a.getClass()) return false;
if(!this.a.equals(that.a)) return false;
return true;
}
@Override @SuppressWarnings("unchecked") public final int compareTo(UniqueTuple that) { return (this.a).compareTo((V) (Object) that.a); }
}
private static class Tuple1<T0 extends Comparable<? super T0>> extends UniqueTuple<T0> implements ITuple {
public Tuple1() { super(); }
public Tuple1(final T0 a0) { super(); this.a = a0; }
final T0 get0() { return a; }
final void set0(final T0 x) { a = x; }
}
private static class Tuple2<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>>
extends BasicTuple<Tuple1<T0>, T1> implements ITuple {
public Tuple2() { super(); }
public Tuple2(final T0 a0, final T1 a1) { super(); this.t = new Tuple1<>(a0); this.a = a1; }
final T0 get0() { return t.get0(); }
final T1 get1() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { a = x; }
}
private static class Tuple3<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>>
extends BasicTuple<Tuple2<T0, T1>, T2> implements ITuple {
public Tuple3() { super(); }
public Tuple3(final T0 a0, final T1 a1, final T2 a2) { super(); this.t = new Tuple2<>(a0, a1); this.a = a2; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { a = x; }
}
private static class Tuple4<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>>
extends BasicTuple<Tuple3<T0, T1, T2>, T3> implements ITuple {
public Tuple4() { super(); }
public Tuple4(final T0 a0, final T1 a1, final T2 a2, final T3 a3) { super(); this.t = new Tuple3<>(a0, a1, a2); this.a = a3; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { a = x; }
}
private static class Tuple5<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>>
extends BasicTuple<Tuple4<T0, T1, T2, T3>, T4> implements ITuple {
public Tuple5() { super(); }
public Tuple5(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4) { super(); this.t = new Tuple4<>(a0, a1, a2, a3); this.a = a4; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { a = x; }
}
private static class Tuple6<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>>
extends BasicTuple<Tuple5<T0, T1, T2, T3, T4>, T5> implements ITuple {
public Tuple6() { super(); }
public Tuple6(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5) { super(); this.t = new Tuple5<>(a0, a1, a2, a3, a4); this.a = a5; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { a = x; }
}
private static class Tuple7<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>>
extends BasicTuple<Tuple6<T0, T1, T2, T3, T4, T5>, T6> implements ITuple {
public Tuple7() { super(); }
public Tuple7(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6) { super(); this.t = new Tuple6<>(a0, a1, a2, a3, a4, a5); this.a = a6; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { a = x; }
}
private static class Tuple8<
T0 extends Comparable<? super T0>,
T1 extends Comparable<? super T1>,
T2 extends Comparable<? super T2>,
T3 extends Comparable<? super T3>,
T4 extends Comparable<? super T4>,
T5 extends Comparable<? super T5>,
T6 extends Comparable<? super T6>,
T7 extends Comparable<? super T7>>
extends BasicTuple<Tuple7<T0, T1, T2, T3, T4, T5, T6>, T7> implements ITuple {
public Tuple8() { super(); }
public Tuple8(final T0 a0, final T1 a1, final T2 a2, final T3 a3, final T4 a4, final T5 a5, final T6 a6, final T7 a7) { super(); this.t = new Tuple7<>(a0, a1, a2, a3, a4, a5, a6); this.a = a7; }
final T0 get0() { return t.get0(); }
final T1 get1() { return t.get1(); }
final T2 get2() { return t.get2(); }
final T3 get3() { return t.get3(); }
final T4 get4() { return t.get4(); }
final T5 get5() { return t.get5(); }
final T6 get6() { return t.get6(); }
final T7 get7() { return a; }
final void set0(final T0 x) { t.set0(x); }
final void set1(final T1 x) { t.set1(x); }
final void set2(final T2 x) { t.set2(x); }
final void set3(final T3 x) { t.set3(x); }
final void set4(final T4 x) { t.set4(x); }
final void set5(final T5 x) { t.set5(x); }
final void set6(final T6 x) { t.set6(x); }
final void set7(final T7 x) { a = x; }
}
// Tuple3
private static class TupleIII implements Comparable<TupleIII> {
public int a; public int b; public int c;
public TupleIII() { }
public TupleIII(final int a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIII that = (TupleIII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIII that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIIL implements Comparable<TupleIIL> {
public int a; public int b; public long c;
public TupleIIL() { }
public TupleIIL(final int a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIIL that = (TupleIIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIIL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c;
}
}
private static class TupleIID implements Comparable<TupleIID> {
public int a; public int b; public double c;
public TupleIID() { }
public TupleIID(final int a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIID that = (TupleIID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIID that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleILI implements Comparable<TupleILI> {
public int a; public long b; public int c;
public TupleILI() { }
public TupleILI(final int a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILI that = (TupleILI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleILL implements Comparable<TupleILL> {
public int a; public long b; public long c;
public TupleILL() { }
public TupleILL(final int a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILL that = (TupleILL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleILD implements Comparable<TupleILD> {
public int a; public long b; public double c;
public TupleILD() { }
public TupleILD(final int a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleILD that = (TupleILD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleILD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleIDI implements Comparable<TupleIDI> {
public int a; public double b; public int c;
public TupleIDI() { }
public TupleIDI(final int a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDI that = (TupleIDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDI that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleIDL implements Comparable<TupleIDL> {
public int a; public double b; public long c;
public TupleIDL() { }
public TupleIDL(final int a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDL that = (TupleIDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDL that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleIDD implements Comparable<TupleIDD> {
public int a; public double b; public double c;
public TupleIDD() { }
public TupleIDD(final int a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleIDD that = (TupleIDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleIDD that) { int c = Integer.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLII implements Comparable<TupleLII> {
public long a; public int b; public int c;
public TupleLII() { }
public TupleLII(final long a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLII that = (TupleLII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLII that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLIL implements Comparable<TupleLIL> {
public long a; public int b; public long c;
public TupleLIL() { }
public TupleLIL(final long a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLIL that = (TupleLIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLIL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLID implements Comparable<TupleLID> {
public long a; public int b; public double c;
public TupleLID() { }
public TupleLID(final long a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLID that = (TupleLID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLID that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLLI implements Comparable<TupleLLI> {
public long a; public long b; public int c;
public TupleLLI() { }
public TupleLLI(final long a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLI that = (TupleLLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLLL implements Comparable<TupleLLL> {
public long a; public long b; public long c;
public TupleLLL() { }
public TupleLLL(final long a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLL that = (TupleLLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLLD implements Comparable<TupleLLD> {
public long a; public long b; public double c;
public TupleLLD() { }
public TupleLLD(final long a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLLD that = (TupleLLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLLD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleLDI implements Comparable<TupleLDI> {
public long a; public double b; public int c;
public TupleLDI() { }
public TupleLDI(final long a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDI that = (TupleLDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDI that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleLDL implements Comparable<TupleLDL> {
public long a; public double b; public long c;
public TupleLDL() { }
public TupleLDL(final long a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDL that = (TupleLDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDL that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleLDD implements Comparable<TupleLDD> {
public long a; public double b; public double c;
public TupleLDD() { }
public TupleLDD(final long a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleLDD that = (TupleLDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleLDD that) { int c = Long.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDII implements Comparable<TupleDII> {
public double a; public int b; public int c;
public TupleDII() { }
public TupleDII(final double a, final int b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDII that = (TupleDII) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDII that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDIL implements Comparable<TupleDIL> {
public double a; public int b; public long c;
public TupleDIL() { }
public TupleDIL(final double a, final int b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDIL that = (TupleDIL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDIL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDID implements Comparable<TupleDID> {
public double a; public int b; public double c;
public TupleDID() { }
public TupleDID(final double a, final int b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDID that = (TupleDID) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDID that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Integer.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDLI implements Comparable<TupleDLI> {
public double a; public long b; public int c;
public TupleDLI() { }
public TupleDLI(final double a, final long b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLI that = (TupleDLI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDLL implements Comparable<TupleDLL> {
public double a; public long b; public long c;
public TupleDLL() { }
public TupleDLL(final double a, final long b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLL that = (TupleDLL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDLD implements Comparable<TupleDLD> {
public double a; public long b; public double c;
public TupleDLD() { }
public TupleDLD(final double a, final long b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDLD that = (TupleDLD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDLD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Long.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
private static class TupleDDI implements Comparable<TupleDDI> {
public double a; public double b; public int c;
public TupleDDI() { }
public TupleDDI(final double a, final double b, final int c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDI that = (TupleDDI) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDI that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Integer.compare(this.c, that.c); return c; }
}
private static class TupleDDL implements Comparable<TupleDDL> {
public double a; public double b; public long c;
public TupleDDL() { }
public TupleDDL(final double a, final double b, final long c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDL that = (TupleDDL) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDL that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Long.compare(this.c, that.c); return c; }
}
private static class TupleDDD implements Comparable<TupleDDD> {
public double a; public double b; public double c;
public TupleDDD() { }
public TupleDDD(final double a, final double b, final double c) { this.a = a; this.b = b; this.c = c; }
@Override public final String toString() { return "("+a+", "+b+", "+c+")"; }
@Override public final int hashCode() { return Objects.hash(a, b, c); }
@Override
public final boolean equals(final Object obj) {
if(this == obj) return true;
if(obj == null || this.getClass() != obj.getClass()) return false;
TupleDDD that = (TupleDDD) obj;
if(this.a != that.a || this.b != that.b || this.c != that.c) return false;
return true;
}
@Override public final int compareTo(final TupleDDD that) { int c = Double.compare(this.a, that.a); if(c == 0) c = Double.compare(this.b, that.b); if(c == 0) c = Double.compare(this.c, that.c); return c; }
}
public void solve() {
long n = nl();
int m = ni();
PairLI p[] = npli(m);
if(m == 0) {
prtln(n % 2 != 0 ? "Takahashi" : "Aoki");
return;
}
for(int i = 0; i < m; i ++) if(p[i].a % 2 == 0) p[i].b = 1 - p[i].b;
int cnt = 0;
long x = p[0].a - 1;
long y = n - p[m - 1].a;
boolean odd = false;
for(int i = 1; i < m; i ++) {
if(p[i - 1].a % 2 == p[i].a % 2) odd = !odd;
if(p[i - 1].b != p[i].b) odd = !odd;
}
if(abs(x - y) == 1) odd = !odd;
prtln(abs(x - y) > 1 || (abs(x - y) == 1 && min(x, y) % 2 != 0) || odd ? "Takahashi" : "Aoki");
}
}
}
| ConDefects/ConDefects/Code/arc151_c/Java/35736379 |
condefects-java_data_1149 | import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String[] s = bf.readLine().split(" ");
long a=Long.parseLong(s[0]); int b=Integer.parseInt(s[1]);
if(b==0) System.out.println(a%2==0?"Aoki":"Takahashi");
else{
long p=1,q=-1;
long sum=0;
for(int i=0; i<b; i++){
s = bf.readLine().split(" ");
long x=Long.parseLong(s[0]),y=Long.parseLong(s[1]);
if(q==-1) sum^=x-1;
else if(q==y) sum^=1;
q=y; p=x;
}
sum^=a-p-1;
System.out.println(sum>0?"Takahashi":"Aoki");
}
}
}
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String[] s = bf.readLine().split(" ");
long a=Long.parseLong(s[0]); int b=Integer.parseInt(s[1]);
if(b==0) System.out.println(a%2==0?"Aoki":"Takahashi");
else{
long p=1,q=-1;
long sum=0;
for(int i=0; i<b; i++){
s = bf.readLine().split(" ");
long x=Long.parseLong(s[0]),y=Long.parseLong(s[1]);
if(q==-1) sum^=x-1;
else if(q==y) sum^=1;
q=y; p=x;
}
sum^=a-p;
System.out.println(sum>0?"Takahashi":"Aoki");
}
}
} | ConDefects/ConDefects/Code/arc151_c/Java/36010169 |
condefects-java_data_1150 | 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() {
int n = sc.nextInt();
for(int i=0; i<n; i++) solve2();
}
void solve2() {
int n = sc.nextInt();
if(n == 1) {
out.println("Yes");
out.println("1");
return;
}
if(n == 2) {
out.println("No");
return;
}
if(n == 3) {
out.println("Yes");
out.println("2 3 6");
return;
}
out.println("Yes");
Set <Integer> set = new HashSet<>();
int l1 = 0;
int l2 = 0;
int l3 = 0;
for(int i=0; i<n-1; i++) {
int num = (i+1) * (i+2);
l3 = l2;
l2 = l1;
l1 = num;
set.add(num);
}
if(!set.contains(n)) {
set.add(n);
} else {
set.remove(l1);
set.remove(l2);
set.remove(l3);
set.add(l3 * 2);
set.add(l3 * 3);
set.add(l3 * 6);
set.add(n-1);
}
int[] res = set.stream().mapToInt(i->i).sorted().toArray();
double sum = 0;
for (int i=0; i<res.length; i++) {
if (i>0) out.print(" ");
out.print(res[i]);
sum += 1d / res[i];
}
out.println();
//out.println(sum);
}
}
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() {
int n = sc.nextInt();
for(int i=0; i<n; i++) solve2();
}
void solve2() {
int n = sc.nextInt();
if(n == 1) {
out.println("Yes");
out.println("1");
return;
}
if(n == 2) {
out.println("No");
return;
}
if(n == 3) {
out.println("Yes");
out.println("2 3 6");
return;
}
out.println("Yes");
Set <Integer> set = new HashSet<>();
int l1 = 0;
int l2 = 0;
int l3 = 0;
for(int i=0; i<n-1; i++) {
int num = (i+1) * (i+2);
l3 = l2;
l2 = l1;
l1 = num;
set.add(num);
}
if(!set.contains(n)) {
set.add(n);
} else {
set.remove(l1);
set.remove(l2);
set.remove(l3);
set.add(l3 * 2);
set.add(l3 * 3);
set.add(l3 * 6);
set.add(n-2);
}
int[] res = set.stream().mapToInt(i->i).sorted().toArray();
double sum = 0;
for (int i=0; i<res.length; i++) {
if (i>0) out.print(" ");
out.print(res[i]);
sum += 1d / res[i];
}
out.println();
//out.println(sum);
}
}
| ConDefects/ConDefects/Code/arc163_c/Java/43201642 |
condefects-java_data_1151 | 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 T = in.it();
Object solve(){
while (T-- > 0)
out.println(solve(in.it()));
return null;
}
private Object solve(int N){
if (N == 1)
return 1;
if (N == 2)
return false;
List<Integer> ans = new ArrayList<>();
boolean flg = false;
for (int i = 1;ans.size() +1 < N;i++)
if (i *(i +1) == N) {
int t = i *(i +1);
ans.add(t +1);
ans.add(t *(t +1));
flg = true;
} else
ans.add(i *(i +1));
if (flg)
ans.add(N -1);
else
ans.add(N);
assert new HashSet<>(ans).size() == N;
out.println(true);
return ans.toArray();
}
Node search(Node root,char[] s){
Node nd = root;
for (var c:s) {
if (nd.cld[c] == null)
nd.cld[c] = new Node(nd,c);
nd = nd.cld[c];
}
return nd;
}
}
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 T = in.it();
Object solve(){
while (T-- > 0)
out.println(solve(in.it()));
return null;
}
private Object solve(int N){
if (N == 1)
return "Yes 1";
if (N == 2)
return false;
List<Integer> ans = new ArrayList<>();
boolean flg = false;
for (int i = 1;ans.size() +1 < N;i++)
if (i *(i +1) == N) {
int t = i *(i +1);
ans.add(t +1);
ans.add(t *(t +1));
flg = true;
} else
ans.add(i *(i +1));
if (flg)
ans.add(N -1);
else
ans.add(N);
assert new HashSet<>(ans).size() == N;
out.println(true);
return ans.toArray();
}
Node search(Node root,char[] s){
Node nd = root;
for (var c:s) {
if (nd.cld[c] == null)
nd.cld[c] = new Node(nd,c);
nd = nd.cld[c];
}
return nd;
}
}
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/arc163_c/Java/43928630 |
condefects-java_data_1152 | import java.util.*;
import java.io.*;
public class Main {
static final long INF = 1l << 62;
static final int inf = 1 << 30;
static final int MOD = 998244353;
static final double EPS = 1e-9;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
solve(sc, pw);
pw.close();
}
static void solve(FastScanner sc, PrintWriter pw) {
int t = sc.nextInt();
int[] dat = new int[510];
Set<Integer> set = new HashSet<>();
for (int i = 1; i < 510; i++) {
dat[i] = i*(i+1);
set.add(dat[i]);
}
for (int test = 0; test < t; test++) {
int n = sc.nextInt();
if (n == 1) {
pw.println("Yes");
pw.println(1); continue;
}
if (n == 2) {
pw.println("No");
continue;
}
pw.println("Yes");
if (set.contains(n)) {
for (int i = 1; i < n-1; i++) pw.print(2*dat[i] + " ");
pw.println(2);
} else {
for (int i = 1; i < n; i++) pw.print(dat[i] + " ");
pw.println(n);
}
}
}
}
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.util.*;
import java.io.*;
public class Main {
static final long INF = 1l << 62;
static final int inf = 1 << 30;
static final int MOD = 998244353;
static final double EPS = 1e-9;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
PrintWriter pw = new PrintWriter(System.out);
solve(sc, pw);
pw.close();
}
static void solve(FastScanner sc, PrintWriter pw) {
int t = sc.nextInt();
int[] dat = new int[510];
Set<Integer> set = new HashSet<>();
for (int i = 1; i < 510; i++) {
dat[i] = i*(i+1);
set.add(dat[i]);
}
for (int test = 0; test < t; test++) {
int n = sc.nextInt();
if (n == 1) {
pw.println("Yes");
pw.println(1); continue;
}
if (n == 2) {
pw.println("No");
continue;
}
pw.println("Yes");
if (set.contains(n)) {
for (int i = 1; i < n-1; i++) pw.print(2*dat[i] + " ");
pw.println(2 + " " + (2*(n-1)));
} else {
for (int i = 1; i < n; i++) pw.print(dat[i] + " ");
pw.println(n);
}
}
}
}
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/arc163_c/Java/43201666 |
condefects-java_data_1153 | import java.util.*;
import java.io.*;
import java.math.*;
// import java.util.stream.Stream;
class Main{
static BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st;
static PrintWriter output = new PrintWriter(System.out);
static Scanner sc = new Scanner(System.in);
static long ans = -1;
public static void main(String[] args) throws IOException{
int n = sc.nextInt();
int m = sc.nextInt();
long [] a = new long[n];
long now_m = 0;
long now = 0;
for(int i=0;i<n;i++) a[i] = sc.nextLong();
long ans = now_m;
for(int i=0;i<m;i++) now_m += a[i] * (i+1);
for(int i=0;i<m;i++) now += a[i];
for(int i=0;i<n-m;i++) {
long next_m = now_m - now + a[i+m]*m;
long next_t = now - a[i] + a[i+m];
now_m = next_m;
now = next_t;
ans = Math.max(ans,now_m);
}
output.print(ans);
output.flush();
}
}
import java.util.*;
import java.io.*;
import java.math.*;
// import java.util.stream.Stream;
class Main{
static BufferedReader buff = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st;
static PrintWriter output = new PrintWriter(System.out);
static Scanner sc = new Scanner(System.in);
static long ans = -1;
public static void main(String[] args) throws IOException{
int n = sc.nextInt();
int m = sc.nextInt();
long [] a = new long[n];
long now_m = 0;
long now = 0;
for(int i=0;i<n;i++) a[i] = sc.nextLong();
for(int i=0;i<m;i++) now_m += a[i] * (i+1);
for(int i=0;i<m;i++) now += a[i];
long ans = now_m;
for(int i=0;i<n-m;i++) {
long next_m = now_m - now + a[i+m]*m;
long next_t = now - a[i] + a[i+m];
now_m = next_m;
now = next_t;
ans = Math.max(ans,now_m);
}
output.print(ans);
output.flush();
}
}
| ConDefects/ConDefects/Code/abc267_c/Java/38651019 |
condefects-java_data_1154 | 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();
int[] a = new int[n];
long[] s = new long[n+1];
long p = 0;
for (int i=0; i<n; i++) {
a[i] = nextInt();
s[i+1] = a[i];
if (i < m) p += a[i] * (i+1);
}
for (int i=1; i<=n; i++) s[i] += s[i-1];
long max = p;
for (int i=m; i<n; i++) {
p += 1L * a[i] * m;
p -= s[i] - s[i-m];
max = Math.max(max, p);
// println((a[i]*m) +" "+ (s[i] - s[i-m]) + " " + p);
}
println(max);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) {
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
public static String yesno(boolean b) {return b ? "Yes" : "No";}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
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 printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
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();
int[] a = new int[n];
long[] s = new long[n+1];
long p = 0;
for (int i=0; i<n; i++) {
a[i] = nextInt();
s[i+1] = a[i];
if (i < m) p += 1L * a[i] * (i+1);
}
for (int i=1; i<=n; i++) s[i] += s[i-1];
long max = p;
for (int i=m; i<n; i++) {
p += 1L * a[i] * m;
p -= s[i] - s[i-m];
max = Math.max(max, p);
// println((a[i]*m) +" "+ (s[i] - s[i-m]) + " " + p);
}
println(max);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) {
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
public static String yesno(boolean b) {return b ? "Yes" : "No";}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
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 printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc267_c/Java/39337528 |
condefects-java_data_1155 | import java.io.File;
import java.io.PrintWriter;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
int[] arr = new int[n];
for( int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
long summ = 0;
long subsum = 0;
for (int i = 1; i <= k; i++) {
subsum += arr[i-1]*i;
summ += arr[i-1];
}
long max = subsum;
for (int i = k; i < n; i++) {
subsum = subsum-summ+arr[i]*k;
summ += arr[i]-arr[i-k];
max = Math.max(max, subsum);
}
System.out.println(max);
}
}
import java.io.File;
import java.io.PrintWriter;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
long[] arr = new long[n];
for( int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
long summ = 0;
long subsum = 0;
for (int i = 1; i <= k; i++) {
subsum += arr[i-1]*i;
summ += arr[i-1];
}
long max = subsum;
for (int i = k; i < n; i++) {
subsum = subsum-summ+arr[i]*k;
summ += arr[i]-arr[i-k];
max = Math.max(max, subsum);
}
System.out.println(max);
}
}
| ConDefects/ConDefects/Code/abc267_c/Java/42249951 |
condefects-java_data_1156 |
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;
long w;
public Edge(int to, int pe) {
this.to = to;
this.pe = pe;
}
public Edge(int to, int pe, long w) {
this.to = to;
this.pe = pe;
this.w = w;
}
}
static class Pair {
int first;
int second;
public Pair() {
}
public Pair(int 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 idx = 1;
static int[] head;
static Edge[] edges;
static int inf = 1 << 30;
public static void solve() throws IOException{
int n = readInt(), m = readInt();
String s = (" " + readString()), t = (" " + readString());
boolean[][] dp = new boolean[n + 5][m + 5];
if (s.charAt(1) != t.charAt(1)) {
printWriter.println("No");
return;
}
dp[1][1] = true;
for (int i = 2; i <= n; i++) {
boolean ok = false;
if (s.charAt(i) == t.charAt(1)) {
ok = true;
dp[i][1] = true;
}
for (int j = 1; j <= m; j++) {
dp[i][j] = s.charAt(i) == t.charAt(j) && (dp[i - 1][j - 1] || dp[i - 1][m]);
if (dp[i][j]) ok = true;
}
if (!ok) {
printWriter.println("No");
return;
}
}
printWriter.println(dp[n][m] ? "Yes" : "No");
}
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... arr) {
return Arrays.stream(arr).max().getAsInt();
}
public static long max(long[] arr) {
return Arrays.stream(arr).max().getAsLong();
}
public static int min(int... arr) {
return Arrays.stream(arr).min().getAsInt();
}
public static long min(long... arr) {
return Arrays.stream(arr).min().getAsLong();
}
}
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;
long w;
public Edge(int to, int pe) {
this.to = to;
this.pe = pe;
}
public Edge(int to, int pe, long w) {
this.to = to;
this.pe = pe;
this.w = w;
}
}
static class Pair {
int first;
int second;
public Pair() {
}
public Pair(int 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 idx = 1;
static int[] head;
static Edge[] edges;
static int inf = 1 << 30;
public static void solve() throws IOException{
int n = readInt(), m = readInt();
String s = (" " + readString()), t = (" " + readString());
boolean[][] dp = new boolean[n + 5][m + 5];
if (s.charAt(1) != t.charAt(1)) {
printWriter.println("No");
return;
}
dp[1][1] = true;
for (int i = 2; i <= n; i++) {
boolean ok = false;
if (s.charAt(i) == t.charAt(1)) {
ok = true;
dp[i][1] = true;
}
for (int j = 2; j <= m; j++) {
dp[i][j] = s.charAt(i) == t.charAt(j) && (dp[i - 1][j - 1] || dp[i - 1][m]);
if (dp[i][j]) ok = true;
}
if (!ok) {
printWriter.println("No");
return;
}
}
printWriter.println(dp[n][m] ? "Yes" : "No");
}
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... arr) {
return Arrays.stream(arr).max().getAsInt();
}
public static long max(long[] arr) {
return Arrays.stream(arr).max().getAsLong();
}
public static int min(int... arr) {
return Arrays.stream(arr).min().getAsInt();
}
public static long min(long... arr) {
return Arrays.stream(arr).min().getAsLong();
}
}
| ConDefects/ConDefects/Code/abc329_e/Java/47778967 |
condefects-java_data_1157 |
import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void solve() throws IOException{
int n = in.nextInt();
int m = in.nextInt();
boolean[][] dp = new boolean[n+1][m+1];
dp[0][0] = true;
String s = in.nextLine();
String t = in.nextLine();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s.charAt(i-1) == t.charAt(j-1)) {
dp[i][j] |= dp[i-1][j-1] | dp[i-1][m];
}
if (s.charAt(i-1) == t.charAt(0)) {
dp[i][1] |= dp[i-1][j];
}
}
}
out.println(dp[n][m] ? "YES" : "NO");
}
static boolean MULTI_CASE = false;
public static void main(String[] args) throws IOException {
if (MULTI_CASE) {
int T = in.nextInt();
for (int i = 0; i < T; ++i) {
solve();
}
} else {
solve();
}
out.close();
}
static InputReader in = new InputReader();
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static class InputReader {
private StringTokenizer st;
private BufferedReader bf;
public InputReader() {
bf = new BufferedReader(new InputStreamReader(System.in));
st = null;
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(bf.readLine());
}
return st.nextToken();
}
public String nextLine() throws IOException {
return bf.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
/*
*/
import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void solve() throws IOException{
int n = in.nextInt();
int m = in.nextInt();
boolean[][] dp = new boolean[n+1][m+1];
dp[0][0] = true;
String s = in.nextLine();
String t = in.nextLine();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s.charAt(i-1) == t.charAt(j-1)) {
dp[i][j] |= dp[i-1][j-1] | dp[i-1][m];
}
if (s.charAt(i-1) == t.charAt(0)) {
dp[i][1] |= dp[i-1][j];
}
}
}
out.println(dp[n][m] ? "Yes" : "No");
}
static boolean MULTI_CASE = false;
public static void main(String[] args) throws IOException {
if (MULTI_CASE) {
int T = in.nextInt();
for (int i = 0; i < T; ++i) {
solve();
}
} else {
solve();
}
out.close();
}
static InputReader in = new InputReader();
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static class InputReader {
private StringTokenizer st;
private BufferedReader bf;
public InputReader() {
bf = new BufferedReader(new InputStreamReader(System.in));
st = null;
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(bf.readLine());
}
return st.nextToken();
}
public String nextLine() throws IOException {
return bf.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}
/*
*/ | ConDefects/ConDefects/Code/abc329_e/Java/47836068 |
condefects-java_data_1158 | import java.io.*;
import java.util.*;
public class Main {
private static FastScanner fs = new FastScanner();
private static int rec ( int i , int isStrictStart , String a , String b , int n , int m , int[][] dp ) {
if ( i == n ) {
return 1 ;
}
if ( dp[i][isStrictStart] != -1 ) return dp[i][isStrictStart] ;
int possible = 0 ;
for ( int j = 0 ; j < m ; j ++ ) {
if ( ( j > 0 ) && ( isStrictStart == 1 ) ) continue ;
for ( int k = j ; k < m ; k ++ ) {
int st = ( i - j ) ;
int ed = st + m - 1 ;
if ( ( st >= 0 ) && ( ed < n ) ) {
String sa = a.substring(i, i + ( k - j ) + 1 ) ;
String sb = b.substring(j, k + 1) ;
if ( sa.equals(sb) ) {
int isNexStrictStart = ( k == m - 1 ) ? 0 : 1 ;
possible = ( possible ^ rec ( i + ( k - j ) + 1 , isNexStrictStart , a , b , n , m , dp ) ) ;
}
}
}
}
dp[i][isStrictStart] = possible ;
return possible ;
}
private static void Test_Case () {
int n = fs.nextInt() ;
int m = fs.nextInt() ;
String a = fs.next() ;
String b = fs.next() ;
int[][] dp = new int[n + 1][3] ;
for ( int i = 0 ; i <= n ; i ++ ) {
for ( int j = 0 ; j < 3 ; j ++ ) {
dp[i][j] = -1 ;
}
}
System.out.println(( rec ( 0 , 1 , a , b , n , m , dp ) == 1 ) ? "Yes" : "No" ) ;
}
public static void main(String[] subscribeToSecondThread) {
int t = 1 ;
// int t = fs.nextInt();
while ( t > 0 ) {
Test_Case() ;
t -- ;
}
}
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());
}
}
}
import java.io.*;
import java.util.*;
public class Main {
private static FastScanner fs = new FastScanner();
private static int rec ( int i , int isStrictStart , String a , String b , int n , int m , int[][] dp ) {
if ( i == n ) {
return 1 ;
}
if ( dp[i][isStrictStart] != -1 ) return dp[i][isStrictStart] ;
int possible = 0 ;
for ( int j = 0 ; j < m ; j ++ ) {
if ( ( j > 0 ) && ( isStrictStart == 1 ) ) continue ;
for ( int k = j ; k < m ; k ++ ) {
int st = ( i - j ) ;
int ed = st + m - 1 ;
if ( ( st >= 0 ) && ( ed < n ) ) {
String sa = a.substring(i, i + ( k - j ) + 1 ) ;
String sb = b.substring(j, k + 1) ;
if ( sa.equals(sb) ) {
int isNexStrictStart = ( k == m - 1 ) ? 0 : 1 ;
if ( possible == 0 ) possible = rec ( i + ( k - j ) + 1 , isNexStrictStart , a , b , n , m , dp ) ;
}
}
}
}
dp[i][isStrictStart] = possible ;
return possible ;
}
private static void Test_Case () {
int n = fs.nextInt() ;
int m = fs.nextInt() ;
String a = fs.next() ;
String b = fs.next() ;
int[][] dp = new int[n + 1][3] ;
for ( int i = 0 ; i <= n ; i ++ ) {
for ( int j = 0 ; j < 3 ; j ++ ) {
dp[i][j] = -1 ;
}
}
System.out.println(( rec ( 0 , 1 , a , b , n , m , dp ) == 1 ) ? "Yes" : "No" ) ;
}
public static void main(String[] subscribeToSecondThread) {
int t = 1 ;
// int t = fs.nextInt();
while ( t > 0 ) {
Test_Case() ;
t -- ;
}
}
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());
}
}
} | ConDefects/ConDefects/Code/abc329_e/Java/47853588 |
condefects-java_data_1159 | 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();
sc.nextLine();
boolean[][] data = new boolean[N][N];
for (int i = 0; i < N; i++) {
for (int k = 0; k < N; k++) {
data[i][k] = false;
}
}
for (int i = 0; i < M; i++) {
int U = sc.nextInt();
int V = sc.nextInt();
data[U - 1][V - 1] = true;
data[V - 1][U - 1] = true;
sc.nextLine();
}
sc.close();
int count = 0;
for (int i = 0; i < N; i++) {
for (int k = i; k < N; k++) {
if (data[i][k]) {
for (int n = k; n < N; n++) {
if (data[k][n]) {
count += 1;
}
}
}
}
}
System.out.println(count);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
sc.nextLine();
boolean[][] data = new boolean[N][N];
for (int i = 0; i < N; i++) {
for (int k = 0; k < N; k++) {
data[i][k] = false;
}
}
for (int i = 0; i < M; i++) {
int U = sc.nextInt();
int V = sc.nextInt();
data[U - 1][V - 1] = true;
data[V - 1][U - 1] = true;
sc.nextLine();
}
sc.close();
int count = 0;
for (int i = 0; i < N; i++) {
for (int k = i; k < N; k++) {
if (data[i][k]) {
for (int n = k; n < N; n++) {
if (data[k][n] && data[n][i]) {
count += 1;
}
}
}
}
}
System.out.println(count);
}
}
| ConDefects/ConDefects/Code/abc262_b/Java/36374277 |
condefects-java_data_1160 | import java.util.ArrayList;
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);
int N = sc.nextInt();
int M = sc.nextInt();
int[] U = new int[M];
int[] V = new int[M];
for(int i = 0; i < M; i++){
U[i] = sc.nextInt();
V[i] = sc.nextInt();
}
List<List<Integer>> list = new ArrayList<>();
for(int i = 0; i < N; i++){
List<Integer> connected = new ArrayList<>();
list.add(connected);
}
for(int i = 0; i < M; i++){
list.get(U[i]-1).add(V[i]);
list.get(V[i]-1).add(U[i]);
}
for(int i = 0; i < N; i++){
Collections.sort(list.get(i));
}
System.out.println(list);
int ans = 0;
for(int a = 0; a < N; a++){
List<Integer> connecta = list.get(a);
for(int b : connecta){
if(b > a){
List<Integer> connectb = list.get(b-1);
//System.out.println(b);
for(int c : connectb){
if(c > b && list.get(c-1).contains(a+1)){
//System.out.println(a + " " + b + " " + c);
ans++;
}
}
}
}
}
System.out.println(ans);
sc.close();
}
}
import java.util.ArrayList;
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);
int N = sc.nextInt();
int M = sc.nextInt();
int[] U = new int[M];
int[] V = new int[M];
for(int i = 0; i < M; i++){
U[i] = sc.nextInt();
V[i] = sc.nextInt();
}
List<List<Integer>> list = new ArrayList<>();
for(int i = 0; i < N; i++){
List<Integer> connected = new ArrayList<>();
list.add(connected);
}
for(int i = 0; i < M; i++){
list.get(U[i]-1).add(V[i]);
list.get(V[i]-1).add(U[i]);
}
for(int i = 0; i < N; i++){
Collections.sort(list.get(i));
}
//System.out.println(list);
int ans = 0;
for(int a = 0; a < N; a++){
List<Integer> connecta = list.get(a);
for(int b : connecta){
if(b > a){
List<Integer> connectb = list.get(b-1);
//System.out.println(b);
for(int c : connectb){
if(c > b && list.get(c-1).contains(a+1)){
//System.out.println(a + " " + b + " " + c);
ans++;
}
}
}
}
}
System.out.println(ans);
sc.close();
}
} | ConDefects/ConDefects/Code/abc262_b/Java/36551481 |
condefects-java_data_1161 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
long k = sc.nextLong();
long[][] w = new long[n][n];
for (int i = 0; i < n; i++) {
//-1L表示顶点没有边相连
Arrays.fill(w[i], -1L);
}
for (int i = 0; i < m; i++) {
//下标从0开始
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
w[u][v] = sc.nextLong();
//无向图，顶点 u 和顶点 v 之间的边具有相同的权重。保证二维数组中的对称性。
w[v][u] = w[u][v];
}
boolean[] visit = new boolean[n];//访问布尔类型的数组，表示所有顶点都未被访问过
visit[0] = true;//0节点必须访问，也是从0开始
//顶点数 n，模数 k，邻接矩阵 w，访问标记数组 visit，已访问的顶点数量 count，当前路径权值之和 sum
long ans = dfs(n, k, w, visit, 1, 0L);
System.out.println(ans);
}
//深度优先搜索（DFS）算法，寻找一条特定路径上的权值之和的最小值。
private static long dfs(int n, long mod, long[][] w, boolean[] visit, int count, long sum) {
//如果已经访问了所有的顶点,返回当前路径权值之和 sm 对取模值 mod 的结果。
if (count == n) {
return sum % mod;
}
long ans = mod;
//遍历图中的顶点
for (int i = 0; i < n; i++) {
if (visit[i]) continue;
//遍历图中的其他未访问的顶点
for (int j = 1; j < n; j++) {
if (visit[j]) continue;
if (w[i][j] < 0) continue;
visit[j] = true;//将顶点 j 标记为已访问
ans = Math.min(ans, dfs(n, mod, w, visit, count + 1, sum + w[i][j]));
visit[j] = false;//恢复顶点 j 的访问状态，将其标记为未访问
}
}
return ans;
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
long k = sc.nextLong();
long[][] w = new long[n][n];
for (int i = 0; i < n; i++) {
//-1L表示顶点没有边相连
Arrays.fill(w[i], -1L);
}
for (int i = 0; i < m; i++) {
//下标从0开始
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
w[u][v] = sc.nextLong();
//无向图，顶点 u 和顶点 v 之间的边具有相同的权重。保证二维数组中的对称性。
w[v][u] = w[u][v];
}
boolean[] visit = new boolean[n];//访问布尔类型的数组，表示所有顶点都未被访问过
visit[0] = true;//0节点必须访问，也是从0开始
//顶点数 n，模数 k，邻接矩阵 w，访问标记数组 visit，已访问的顶点数量 count，当前路径权值之和 sum
long ans = dfs(n, k, w, visit, 1, 0L);
System.out.println(ans);
}
//深度优先搜索（DFS）算法，寻找一条特定路径上的权值之和的最小值。
private static long dfs(int n, long mod, long[][] w, boolean[] visit, int count, long sum) {
//如果已经访问了所有的顶点,返回当前路径权值之和 sm 对取模值 mod 的结果。
if (count == n) {
return sum % mod;
}
long ans = mod;
//遍历图中的顶点
for (int i = 0; i < n; i++) {
if (!visit[i]) continue;
//遍历图中的其他未访问的顶点
for (int j = 1; j < n; j++) {
if (visit[j]) continue;
if (w[i][j] < 0) continue;
visit[j] = true;//将顶点 j 标记为已访问
ans = Math.min(ans, dfs(n, mod, w, visit, count + 1, sum + w[i][j]));
visit[j] = false;//恢复顶点 j 的访问状态，将其标记为未访问
}
}
return ans;
}
}
| ConDefects/ConDefects/Code/abc328_e/Java/48831657 |
condefects-java_data_1162 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static void run (final FastScanner scanner, final PrintWriter out) {
int H = scanner.nextInt();
int W = scanner.nextInt();
int[][] gridA = new int[H][W];
int[][] gridB = new int[H][W];
Set<Integer> set = new HashSet<>();
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
gridA[i][j]= scanner.nextInt();;
set.add(gridA[i][j]);
}
}
boolean ok = true;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
gridB[i][j]= scanner.nextInt();;
if (!set.contains(gridB[i][j])) {
ok=false;
}
}
}
if(!ok) {
System.out.println(-1);
return;
}
Permutations permH = new Permutations(H);
Permutations permW = new Permutations(W);
for (int[] permh : permH.perms) {
for (int[] permw : permW.perms) {
int[][] aa = new int[H][W];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
aa[i][j]=gridA[permh[i]][permw[j]];
}
}
if (isSame(aa, gridB)) {
System.out.println(inversionNumber(permh) + inversionNumber(permw));
}
}
}
}
static int inversionNumber(int[] a) {
int ret = 0;
for (int i = 0; i < a.length; i++) {
for (int j = i+1; j < a.length; j++) {
if (a[i]>a[j]) {
ret++;
}
}
}
return ret;
}
static boolean isSame(int[][] a,int[][] b) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if(a[i][j]!=b[i][j]) {
return false;
}
}
}
return true;
}
static class Permutations {
int[] perm;
boolean[] used;
int N;
ArrayList<int[]> perms = new ArrayList<>();
public Permutations(int n) {
this.N=n;
used=new boolean[N];
perm=new int[N];
perm(0);
}
void perm(int depth) {
if (depth == N) {
int[] idxArr = new int[N];
for (int i = 0; i < N; i++) {
idxArr[i] = perm[i];
}
perms.add(idxArr);
return;
}
for (int i = 0; i < N; i++) {
if (used[i]) {
continue;
}
used[i] = true;
perm[depth] = i;
perm(depth + 1);
used[i] = false;
}
}
}
public static void main(final String[] args) {
PrintWriter out = new PrintWriter(System.out);
FastScanner scanner = new FastScanner();
try {
run(scanner, out);
} catch (Throwable e) {
throw e;
} finally {
out.flush();
}
}
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
public double nextDouble() { return Double.parseDouble(next());}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
public class Main {
static int MOD = 1000000007;
static int INF = Integer.MAX_VALUE/2;
static void run (final FastScanner scanner, final PrintWriter out) {
int H = scanner.nextInt();
int W = scanner.nextInt();
int[][] gridA = new int[H][W];
int[][] gridB = new int[H][W];
Set<Integer> set = new HashSet<>();
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
gridA[i][j]= scanner.nextInt();;
set.add(gridA[i][j]);
}
}
boolean ok = true;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
gridB[i][j]= scanner.nextInt();;
if (!set.contains(gridB[i][j])) {
ok=false;
}
}
}
if(!ok) {
System.out.println(-1);
return;
}
Permutations permH = new Permutations(H);
Permutations permW = new Permutations(W);
for (int[] permh : permH.perms) {
for (int[] permw : permW.perms) {
int[][] aa = new int[H][W];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
aa[i][j]=gridA[permh[i]][permw[j]];
}
}
if (isSame(aa, gridB)) {
System.out.println(inversionNumber(permh) + inversionNumber(permw));
return;
}
}
}
System.out.println(-1);
}
static int inversionNumber(int[] a) {
int ret = 0;
for (int i = 0; i < a.length; i++) {
for (int j = i+1; j < a.length; j++) {
if (a[i]>a[j]) {
ret++;
}
}
}
return ret;
}
static boolean isSame(int[][] a,int[][] b) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if(a[i][j]!=b[i][j]) {
return false;
}
}
}
return true;
}
static class Permutations {
int[] perm;
boolean[] used;
int N;
ArrayList<int[]> perms = new ArrayList<>();
public Permutations(int n) {
this.N=n;
used=new boolean[N];
perm=new int[N];
perm(0);
}
void perm(int depth) {
if (depth == N) {
int[] idxArr = new int[N];
for (int i = 0; i < N; i++) {
idxArr[i] = perm[i];
}
perms.add(idxArr);
return;
}
for (int i = 0; i < N; i++) {
if (used[i]) {
continue;
}
used[i] = true;
perm[depth] = i;
perm(depth + 1);
used[i] = false;
}
}
}
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/abc332_d/Java/53528967 |
condefects-java_data_1163 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int h = sc.nextInt();
int w = sc.nextInt();
int[][] a = new int[h][w];
int[][] b = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
a[i][j] = sc.nextInt();
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
b[i][j] = sc.nextInt();
int[] p = new int[h];
for (int i = 0; i < h; i++) p[i] = i;
int[] q = new int[w];
for (int i = 0; i < w; i++) q[i] = i;
do {
do {
boolean ok = true;
label:
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (a[p[i]][q[j]] != b[i][j]) {
ok = false;
break label;
}
}
}
if (ok) {
int ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < i; j++) {
if (p[j] > p[i]) ans++;
}
}
for (int i = 0; i < w; i++) {
for (int j = 0; j < i; j++) {
if (q[j] > q[i]) ans++;
}
}
System.out.println(ans);
return;
}
} while (nextPermutation(q));
} while (nextPermutation(p));
System.out.println(-1);
}
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) {
Scanner sc = new Scanner(System.in);
int h = sc.nextInt();
int w = sc.nextInt();
int[][] a = new int[h][w];
int[][] b = new int[h][w];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
a[i][j] = sc.nextInt();
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
b[i][j] = sc.nextInt();
int[] p = new int[h];
for (int i = 0; i < h; i++) p[i] = i;
int[] q = new int[w];
do {
for (int i = 0; i < w; i++) q[i] = i;
do {
boolean ok = true;
label:
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (a[p[i]][q[j]] != b[i][j]) {
ok = false;
break label;
}
}
}
if (ok) {
int ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < i; j++) {
if (p[j] > p[i]) ans++;
}
}
for (int i = 0; i < w; i++) {
for (int j = 0; j < i; j++) {
if (q[j] > q[i]) ans++;
}
}
System.out.println(ans);
return;
}
} while (nextPermutation(q));
} while (nextPermutation(p));
System.out.println(-1);
}
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/abc332_d/Java/48828379 |
condefects-java_data_1164 | 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[] SPoint = getIntArray(2);
final int[] GPoint = getIntArray(2);
final int[][] Circles = get2dIntArray(N, 3);
final IntBiPredicate hasLink = (c1, c2) -> ((long)Circles[c1][0] - Circles[c2][0]) * ((long)Circles[c1][0] - Circles[c2][0]) + ((long)Circles[c1][1] - Circles[c2][1]) * ((long)Circles[c1][1] - Circles[c2][1]) <= ((long)Circles[c1][2] + Circles[c2][2]) * ((long)Circles[c1][2] + Circles[c2][2]) && ((long)Circles[c1][0] - Circles[c2][0]) * ((long)Circles[c1][0] - Circles[c2][0]) + ((long)Circles[c1][1] - Circles[c2][1]) * ((long)Circles[c1][1] - Circles[c2][1]) + (long)Math.min(Circles[c1][2], Circles[c2][2]) * (long)Math.min(Circles[c1][2], Circles[c2][2]) >= (long)Math.max(Circles[c1][2], Circles[c2][2]) * (long)Math.max(Circles[c1][2], Circles[c2][2]);
final BiPredicate<int[], int[]> onCircle = (c, p) -> ((long)c[0] - p[0]) * ((long)c[0] - p[0]) + ((long)c[1] - p[1]) * ((long)c[1] - p[1]) == (long)c[2] * c[2];
final UnionFindTree uft = new UnionFindTree(N);
int sc = -1;
int gc = -1;
for(int c1 = 0; c1 < N; c1++) {
if(onCircle.test(Circles[c1], SPoint)) sc = c1;
if(onCircle.test(Circles[c1], GPoint)) gc = c1;
for(int c2 = c1 + 1; c2 < N; c2++) {
if(hasLink.test(c1, c2)) uft.unite(c1, c2);
}
}
println(uft.hasLink(sc, gc) ? "Yes" : "No");
flush();
}
@SuppressWarnings({"unchecked"})
private static final IntFunction<List<Integer>[]> getListArray = n -> Stream.generate(ArrayList::new).limit(n).toArray(List[]::new);
@FunctionalInterface
interface IntBiPredicate {
boolean test(int op1, int op2);
}
private static class UnionFindTree {
int[] parent;
int[] size;
int[] dist;
int unionCount;
UnionFindTree(int size) {
super();
this.parent = new int[size];
this.size = new int[size];
this.dist = new int[size];
clear();
}
UnionFindTree(UnionFindTree other) {
this.parent = Arrays.copyOf(other.parent, other.parent.length);
this.size = Arrays.copyOf(other.size, other.size.length);
this.dist = Arrays.copyOf(other.dist, other.dist.length);
this.unionCount = other.unionCount;
}
void clear() {
Arrays.fill(this.parent, -1);
Arrays.fill(this.size, 1);
Arrays.fill(this.dist, 0);
unionCount = this.size.length;
}
int getRoot(int node) {
if (parent[node] == -1) {
return node;
} else {
int prevParent = parent[node];
parent[node] = getRoot(parent[node]);
dist[node] += dist[prevParent];
return parent[node];
}
}
int getDist(int node) {
if(parent[node] == -1) {
return dist[node];
} else {
getRoot(node);
return dist[node];
}
}
boolean hasLink(int x, int y) {
return getRoot(x) == getRoot(y);
}
final void unite(int x, int y) {
unite(x, y, 0);
}
final void unite(int x, int y, int p) {
int rootx = getRoot(x);
int rooty = getRoot(y);
if (rootx == rooty) {
return;
}
if (size[rootx] < size[rooty]) {
int tmp = rootx;
rootx = rooty;
rooty = tmp;
tmp = x;
x = y;
y = tmp;
}
parent[rooty] = rootx;
dist[rooty] = p + dist[x] - dist[y];
size[rootx] += size[rooty];
unionCount--;
}
int getSize(int x) {
return size[getRoot(x)];
}
int getUnionCount() {
return unionCount;
}
}
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 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 char[][] get2dCharArrayWithBorder(int rows, int cols, char borderChar) {
Stream.Builder<char[]> sb = Stream.builder();
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
for (int idx = 0; idx < rows; idx++) {
sb.add((Character.toString(borderChar) + getNext() + Character.toString(borderChar)).toCharArray());
}
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
return sb.build().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 printf(String format, Object... args) {
print(String.format(format, args));
}
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[] SPoint = getIntArray(2);
final int[] GPoint = getIntArray(2);
final int[][] Circles = get2dIntArray(N, 3);
final IntBiPredicate hasLink = (c1, c2) -> ((long)Circles[c1][0] - Circles[c2][0]) * ((long)Circles[c1][0] - Circles[c2][0]) + ((long)Circles[c1][1] - Circles[c2][1]) * ((long)Circles[c1][1] - Circles[c2][1]) <= ((long)Circles[c1][2] + Circles[c2][2]) * ((long)Circles[c1][2] + Circles[c2][2]) && ((long)Circles[c1][0] - Circles[c2][0]) * ((long)Circles[c1][0] - Circles[c2][0]) + ((long)Circles[c1][1] - Circles[c2][1]) * ((long)Circles[c1][1] - Circles[c2][1]) >= ((long)Math.max(Circles[c1][2], Circles[c2][2]) - Math.min(Circles[c1][2], Circles[c2][2])) * ((long)Math.max(Circles[c1][2], Circles[c2][2]) - Math.min(Circles[c1][2], Circles[c2][2]));
final BiPredicate<int[], int[]> onCircle = (c, p) -> ((long)c[0] - p[0]) * ((long)c[0] - p[0]) + ((long)c[1] - p[1]) * ((long)c[1] - p[1]) == (long)c[2] * c[2];
final UnionFindTree uft = new UnionFindTree(N);
int sc = -1;
int gc = -1;
for(int c1 = 0; c1 < N; c1++) {
if(onCircle.test(Circles[c1], SPoint)) sc = c1;
if(onCircle.test(Circles[c1], GPoint)) gc = c1;
for(int c2 = c1 + 1; c2 < N; c2++) {
if(hasLink.test(c1, c2)) uft.unite(c1, c2);
}
}
println(uft.hasLink(sc, gc) ? "Yes" : "No");
flush();
}
@SuppressWarnings({"unchecked"})
private static final IntFunction<List<Integer>[]> getListArray = n -> Stream.generate(ArrayList::new).limit(n).toArray(List[]::new);
@FunctionalInterface
interface IntBiPredicate {
boolean test(int op1, int op2);
}
private static class UnionFindTree {
int[] parent;
int[] size;
int[] dist;
int unionCount;
UnionFindTree(int size) {
super();
this.parent = new int[size];
this.size = new int[size];
this.dist = new int[size];
clear();
}
UnionFindTree(UnionFindTree other) {
this.parent = Arrays.copyOf(other.parent, other.parent.length);
this.size = Arrays.copyOf(other.size, other.size.length);
this.dist = Arrays.copyOf(other.dist, other.dist.length);
this.unionCount = other.unionCount;
}
void clear() {
Arrays.fill(this.parent, -1);
Arrays.fill(this.size, 1);
Arrays.fill(this.dist, 0);
unionCount = this.size.length;
}
int getRoot(int node) {
if (parent[node] == -1) {
return node;
} else {
int prevParent = parent[node];
parent[node] = getRoot(parent[node]);
dist[node] += dist[prevParent];
return parent[node];
}
}
int getDist(int node) {
if(parent[node] == -1) {
return dist[node];
} else {
getRoot(node);
return dist[node];
}
}
boolean hasLink(int x, int y) {
return getRoot(x) == getRoot(y);
}
final void unite(int x, int y) {
unite(x, y, 0);
}
final void unite(int x, int y, int p) {
int rootx = getRoot(x);
int rooty = getRoot(y);
if (rootx == rooty) {
return;
}
if (size[rootx] < size[rooty]) {
int tmp = rootx;
rootx = rooty;
rooty = tmp;
tmp = x;
x = y;
y = tmp;
}
parent[rooty] = rootx;
dist[rooty] = p + dist[x] - dist[y];
size[rootx] += size[rooty];
unionCount--;
}
int getSize(int x) {
return size[getRoot(x)];
}
int getUnionCount() {
return unionCount;
}
}
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 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 char[][] get2dCharArrayWithBorder(int rows, int cols, char borderChar) {
Stream.Builder<char[]> sb = Stream.builder();
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
for (int idx = 0; idx < rows; idx++) {
sb.add((Character.toString(borderChar) + getNext() + Character.toString(borderChar)).toCharArray());
}
sb.add(Character.toString(borderChar).repeat(cols + 2).toCharArray());
return sb.build().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 printf(String format, Object... args) {
print(String.format(format, args));
}
private static void flush() {
writer.flush();
}
}
| ConDefects/ConDefects/Code/abc259_d/Java/53219783 |
condefects-java_data_1165 | import java.util.*;
public class Main {
static class UnionFind {
public int[] p;
public int[] r;
public int[] connectedSize;// 連結成分のサイズ
int count ;
public UnionFind(int size) {
p = new int[size];
r = new int[size];
connectedSize = new int[size];
Arrays.fill(connectedSize,1);
count = size;
for (int i = 0; i < size; i++) {
makeSet(i);
}
}
public void makeSet(int x) {
p[x] = x;
r[x] = 0;
}
public void union(int x, int y) {
final int xRoot = find(x);
final int yRoot = find(y);
if (r[xRoot] > r[yRoot]) {
p[yRoot] = xRoot;
connectedSize[xRoot]+=connectedSize[yRoot];
count--;
}
else if(r[xRoot] < r[yRoot]) {
connectedSize[yRoot]+=connectedSize[xRoot];
p[xRoot] = yRoot;
count--;
}
else if (xRoot != yRoot) {
p[yRoot] = xRoot;
connectedSize[xRoot]+=connectedSize[yRoot];
r[xRoot]++;
count--;
}
}
public int find(int x) {
if (x != p[x]) {
p[x] = find(p[x]);
}
return p[x];
}
public boolean same(int x, int y) {
return find(x) == find(y);
}
}
public static boolean onCircle(long px, long py, long cx, long cy, long r){
long abs = Math.abs(cx - px);
long abs2 = Math.abs(cy - py);
return abs * abs + abs2 * abs2 == r * r;
}
public static boolean crossCircle(long ax, long ay, long ar, long bx, long by, long br){
long abs = Math.abs(ax - bx);
long abs2 = Math.abs(ay - by);
long d = abs * abs + abs2 * abs2;
return d <= (ar+br)*(ar+br) && d >= (ar-br)*(ar-br);
}
public static void main(String[] args) {
int n = getInt();
long sx = getLong();
long sy = getLong();
long ty = getLong();
long tx = getLong();
HashMap<Integer, List<Integer>> edge = new HashMap<>();
long x[] = new long[n];
long y[] = new long[n];
long r[] = new long[n];
for(int i = 0;i < n;i++){
x[i] = getLong();
y[i] = getLong();
r[i] = getLong();
}
List<Integer> s = new ArrayList<>();
List<Integer> t = new ArrayList<>();
UnionFind uf = new UnionFind(n);
for(int i = 0;i < n;i++){
if(onCircle(sx, sy, x[i], y[i], r[i])){
s.add(i);
}
if(onCircle(tx, ty, x[i], y[i], r[i])){
t.add(i);
}
for(int j = i+1;j < n;j++){
if(crossCircle(x[i], y[i], r[i], x[j], y[j], r[j])){
uf.union(i,j);
}
}
}
for(Integer start: s){
for(Integer end: t){
if(uf.same(start, end)){
Yes();
return;
}
}
}
No();
}
static int sqrtI(long n){
return toInt(Math.sqrt(n));
}
static long toLong(double v) {
return Double.valueOf(v).longValue();
}
static int toInt(double v) {
return Double.valueOf(v).intValue();
}
static String[] createTiles(int w, int h, String out){
String[] s = new String[h + 2];
s[0] = s[h + 1] = out.repeat(w + 2);
for (int i = 1; i <= h; i++) {
s[i] = out + getString() + out;
}
return s;
}
static void outH(List<?> o){
int nl = o.size()-1;
for (int i = 0; i < o.size(); i++) {
System.out.print(o.get(i)+(i != nl ? " ":"\n"));
}
}
static void out(List<?> o){
for (Object oo: o) {
System.out.println(oo);
}
}
static void outH(Object[] o){
int nl = o.length-1;
for (int i = 0; i < o.length; i++) {
System.out.print(o[i]+(i != nl ? " ":""));
}
out();
}
static void outH(char[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(double[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(int[] in){
int nl = in.length-1;
for (int i = 0; i < in.length; i++) {
System.out.print(in[i]+(i != nl ? " ":""));
}
out();
}
static void outH(long[] l){
int nl = l.length-1;
for (int i = 0; i < l.length; i++) {
System.out.print(l[i]+(i != nl ? " ":""));
}
out();
}
static void outH(String[] s){
int nl = s.length-1;
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+(i != nl ? " ":""));
}
out();
}
static void out(){
System.out.println();
}
static void out(Object[] o){
for (Object oo : o) {
System.out.println(oo);
}
}
static String sortString(String s) {
char[] a = s.toCharArray();
Arrays.sort(a);
return new String(a);
}
static String sortStringDesc(String s) {
return new StringBuilder(sortString(s)).reverse().toString();
}
static void out(char[] c){
for (Character aChar : c) {
System.out.println(aChar);
}
}
static void out(double[] d){
for (Double aDouble : d) {
System.out.println(aDouble);
}
}
static void out(int[] i){
for (Integer iInteger: i) {
System.out.println(iInteger);
}
}
static void out(long[] l){
for (Long lLong: l) {
System.out.println(lLong);
}
}
static void out(String[] s){
for (String sString: s) {
System.out.println(sString);
}
}
static void out(Double d){
System.out.println(d);
}
static void out(Integer i){
System.out.println(i);
}
static void out(Long l){
System.out.println(l);
}
static void out(String s){
System.out.println(s);
}
static void YesOrNo(boolean b){
System.out.println(b ? "Yes" : "No");
}
static void YesOrNo(boolean b, String yes, String no){
System.out.println(b ? yes : no);
}
static void Yes(){
System.out.println("Yes");
}
static void No(){
System.out.println("No");
}
/*
static StringTokenizer st;
static InputStreamReader isr = new InputStreamReader(System.in);
static BufferedReader br = new BufferedReader(isr);
static String getString() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine().trim());
} catch (IOException e) {
System.exit(0);
}
}
return st.nextToken();
}
static long getLong() {
return Long.parseLong(getString());
}
static int getInt() {
return Integer.parseInt(getString());
}
static Double getDouble() {
return parseDouble(getString());
}
*/
private static final java.io.InputStream in = System.in;
private static final byte[] buffer = new byte[1024];
private static int ptr = 0;
private static 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;
static 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;
}
static int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
static boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
static String getString() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
static long getLong() {
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') {
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();
}
}
static public int getInt() {
long nl = getLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
static public double getDouble() {
return Double.parseDouble(getString());
}
static public long[] getLongArray(int length){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = getLong();
return array;
}
static public long[] getLongArray(int length, java.util.function.LongUnaryOperator map){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = map.applyAsLong(getLong());
return array;
}
static public int[] getIntArray(int length){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = getInt();
return array;
}
static public int[] getIntArray(int length, java.util.function.IntUnaryOperator map){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = map.applyAsInt(getInt());
return array;
}
static public double[] getDoubleArray(int length){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = getDouble();
return array;
}
static public double[] getDoubleArray(int length, java.util.function.DoubleUnaryOperator map){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = map.applyAsDouble(getDouble());
return array;
}
static public long[][] getLongMatrix(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] = getLong();
}
return mat;
}
static int[][] getIntMatrix(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] = getInt();
}
return mat;
}
static public double[][] getDoubleMatrix(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] = getDouble();
}
return mat;
}
static public char[][] nextCharMatrix(int height, int width){
char[][] mat = new char[height][width];
for(int h=0; h<height; h++){
String s = getString();
for(int w=0; w<width; w++){
mat[h][w] = s.charAt(w);
}
}
return mat;
}
public static long mod1097 = 1000000007L;
public static long mod9982 = 998244353L;
}
import java.util.*;
public class Main {
static class UnionFind {
public int[] p;
public int[] r;
public int[] connectedSize;// 連結成分のサイズ
int count ;
public UnionFind(int size) {
p = new int[size];
r = new int[size];
connectedSize = new int[size];
Arrays.fill(connectedSize,1);
count = size;
for (int i = 0; i < size; i++) {
makeSet(i);
}
}
public void makeSet(int x) {
p[x] = x;
r[x] = 0;
}
public void union(int x, int y) {
final int xRoot = find(x);
final int yRoot = find(y);
if (r[xRoot] > r[yRoot]) {
p[yRoot] = xRoot;
connectedSize[xRoot]+=connectedSize[yRoot];
count--;
}
else if(r[xRoot] < r[yRoot]) {
connectedSize[yRoot]+=connectedSize[xRoot];
p[xRoot] = yRoot;
count--;
}
else if (xRoot != yRoot) {
p[yRoot] = xRoot;
connectedSize[xRoot]+=connectedSize[yRoot];
r[xRoot]++;
count--;
}
}
public int find(int x) {
if (x != p[x]) {
p[x] = find(p[x]);
}
return p[x];
}
public boolean same(int x, int y) {
return find(x) == find(y);
}
}
public static boolean onCircle(long px, long py, long cx, long cy, long r){
long abs = Math.abs(cx - px);
long abs2 = Math.abs(cy - py);
return abs * abs + abs2 * abs2 == r * r;
}
public static boolean crossCircle(long ax, long ay, long ar, long bx, long by, long br){
long abs = Math.abs(ax - bx);
long abs2 = Math.abs(ay - by);
long d = abs * abs + abs2 * abs2;
return d <= (ar+br)*(ar+br) && d >= (ar-br)*(ar-br);
}
public static void main(String[] args) {
int n = getInt();
long sx = getLong();
long sy = getLong();
long tx = getLong();
long ty = getLong();
HashMap<Integer, List<Integer>> edge = new HashMap<>();
long x[] = new long[n];
long y[] = new long[n];
long r[] = new long[n];
for(int i = 0;i < n;i++){
x[i] = getLong();
y[i] = getLong();
r[i] = getLong();
}
List<Integer> s = new ArrayList<>();
List<Integer> t = new ArrayList<>();
UnionFind uf = new UnionFind(n);
for(int i = 0;i < n;i++){
if(onCircle(sx, sy, x[i], y[i], r[i])){
s.add(i);
}
if(onCircle(tx, ty, x[i], y[i], r[i])){
t.add(i);
}
for(int j = i+1;j < n;j++){
if(crossCircle(x[i], y[i], r[i], x[j], y[j], r[j])){
uf.union(i,j);
}
}
}
for(Integer start: s){
for(Integer end: t){
if(uf.same(start, end)){
Yes();
return;
}
}
}
No();
}
static int sqrtI(long n){
return toInt(Math.sqrt(n));
}
static long toLong(double v) {
return Double.valueOf(v).longValue();
}
static int toInt(double v) {
return Double.valueOf(v).intValue();
}
static String[] createTiles(int w, int h, String out){
String[] s = new String[h + 2];
s[0] = s[h + 1] = out.repeat(w + 2);
for (int i = 1; i <= h; i++) {
s[i] = out + getString() + out;
}
return s;
}
static void outH(List<?> o){
int nl = o.size()-1;
for (int i = 0; i < o.size(); i++) {
System.out.print(o.get(i)+(i != nl ? " ":"\n"));
}
}
static void out(List<?> o){
for (Object oo: o) {
System.out.println(oo);
}
}
static void outH(Object[] o){
int nl = o.length-1;
for (int i = 0; i < o.length; i++) {
System.out.print(o[i]+(i != nl ? " ":""));
}
out();
}
static void outH(char[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(double[] d){
int nl = d.length-1;
for (int i = 0; i < d.length; i++) {
System.out.print(d[i]+(i != nl ? " ":""));
}
out();
}
static void outH(int[] in){
int nl = in.length-1;
for (int i = 0; i < in.length; i++) {
System.out.print(in[i]+(i != nl ? " ":""));
}
out();
}
static void outH(long[] l){
int nl = l.length-1;
for (int i = 0; i < l.length; i++) {
System.out.print(l[i]+(i != nl ? " ":""));
}
out();
}
static void outH(String[] s){
int nl = s.length-1;
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+(i != nl ? " ":""));
}
out();
}
static void out(){
System.out.println();
}
static void out(Object[] o){
for (Object oo : o) {
System.out.println(oo);
}
}
static String sortString(String s) {
char[] a = s.toCharArray();
Arrays.sort(a);
return new String(a);
}
static String sortStringDesc(String s) {
return new StringBuilder(sortString(s)).reverse().toString();
}
static void out(char[] c){
for (Character aChar : c) {
System.out.println(aChar);
}
}
static void out(double[] d){
for (Double aDouble : d) {
System.out.println(aDouble);
}
}
static void out(int[] i){
for (Integer iInteger: i) {
System.out.println(iInteger);
}
}
static void out(long[] l){
for (Long lLong: l) {
System.out.println(lLong);
}
}
static void out(String[] s){
for (String sString: s) {
System.out.println(sString);
}
}
static void out(Double d){
System.out.println(d);
}
static void out(Integer i){
System.out.println(i);
}
static void out(Long l){
System.out.println(l);
}
static void out(String s){
System.out.println(s);
}
static void YesOrNo(boolean b){
System.out.println(b ? "Yes" : "No");
}
static void YesOrNo(boolean b, String yes, String no){
System.out.println(b ? yes : no);
}
static void Yes(){
System.out.println("Yes");
}
static void No(){
System.out.println("No");
}
/*
static StringTokenizer st;
static InputStreamReader isr = new InputStreamReader(System.in);
static BufferedReader br = new BufferedReader(isr);
static String getString() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine().trim());
} catch (IOException e) {
System.exit(0);
}
}
return st.nextToken();
}
static long getLong() {
return Long.parseLong(getString());
}
static int getInt() {
return Integer.parseInt(getString());
}
static Double getDouble() {
return parseDouble(getString());
}
*/
private static final java.io.InputStream in = System.in;
private static final byte[] buffer = new byte[1024];
private static int ptr = 0;
private static 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;
static 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;
}
static int readByte() {
if (hasNextByte()) return buffer[ptr++]; else return -1;
}
static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
static boolean hasNext() {
while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
static String getString() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
static long getLong() {
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') {
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();
}
}
static public int getInt() {
long nl = getLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
static public double getDouble() {
return Double.parseDouble(getString());
}
static public long[] getLongArray(int length){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = getLong();
return array;
}
static public long[] getLongArray(int length, java.util.function.LongUnaryOperator map){
long[] array = new long[length];
for(int i=0; i<length; i++) array[i] = map.applyAsLong(getLong());
return array;
}
static public int[] getIntArray(int length){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = getInt();
return array;
}
static public int[] getIntArray(int length, java.util.function.IntUnaryOperator map){
int[] array = new int[length];
for(int i=0; i<length; i++) array[i] = map.applyAsInt(getInt());
return array;
}
static public double[] getDoubleArray(int length){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = getDouble();
return array;
}
static public double[] getDoubleArray(int length, java.util.function.DoubleUnaryOperator map){
double[] array = new double[length];
for(int i=0; i<length; i++) array[i] = map.applyAsDouble(getDouble());
return array;
}
static public long[][] getLongMatrix(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] = getLong();
}
return mat;
}
static int[][] getIntMatrix(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] = getInt();
}
return mat;
}
static public double[][] getDoubleMatrix(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] = getDouble();
}
return mat;
}
static public char[][] nextCharMatrix(int height, int width){
char[][] mat = new char[height][width];
for(int h=0; h<height; h++){
String s = getString();
for(int w=0; w<width; w++){
mat[h][w] = s.charAt(w);
}
}
return mat;
}
public static long mod1097 = 1000000007L;
public static long mod9982 = 998244353L;
} | ConDefects/ConDefects/Code/abc259_d/Java/52051505 |
condefects-java_data_1166 | import java.math.BigInteger;
import java.util.Scanner;
/* --- ARC154A --- */
public class Main {
public static void main(String[] args){
/* --- Input --- */
var sc = new Scanner(System.in);
var N = sc.nextInt();
var A = sc.next().toCharArray();
var B = sc.next().toCharArray();
sc.close();
/* --- Process --- */
for(var i=0; i<N; i++){
if(A[i] > B[i]){
var t = A[i];
A[i] = B[i];
B[i] = t;
}
}
BigInteger ba = new BigInteger(String.valueOf(A));
BigInteger bb = new BigInteger(String.valueOf(A));
BigInteger bm = BigInteger.valueOf(998244353);
BigInteger ans = ba.multiply(bb).mod(bm);
/* --- Output --- */
System.out.println(ans);
System.out.flush();
}
}
import java.math.BigInteger;
import java.util.Scanner;
/* --- ARC154A --- */
public class Main {
public static void main(String[] args){
/* --- Input --- */
var sc = new Scanner(System.in);
var N = sc.nextInt();
var A = sc.next().toCharArray();
var B = sc.next().toCharArray();
sc.close();
/* --- Process --- */
for(var i=0; i<N; i++){
if(A[i] > B[i]){
var t = A[i];
A[i] = B[i];
B[i] = t;
}
}
BigInteger ba = new BigInteger(String.valueOf(A));
BigInteger bb = new BigInteger(String.valueOf(B));
BigInteger bm = BigInteger.valueOf(998244353);
BigInteger ans = ba.multiply(bb).mod(bm);
/* --- Output --- */
System.out.println(ans);
System.out.flush();
}
}
| ConDefects/ConDefects/Code/arc154_a/Java/38268465 |
condefects-java_data_1167 | import java.io.*;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
public class Main {
private static PrintWriter out;
public static void main(String[] args) {
Main main = new Main();
out = new PrintWriter(new BufferedOutputStream(System.out));
try {
main.run(args);
} catch (Exception e) {
e.printStackTrace();
}
out.close();
}
private void run(String[] arguments) throws Exception {
MyScanner sc = new MyScanner();
int N = sc.nextInt();
int M = sc.nextInt();
// M個の集合
ArrayList<Integer[]> unions = new ArrayList<>();
for (int i = 0; i < M; i++) {
int C = sc.nextInt();
Integer[] S = Arrays.stream(sc.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
unions.add(S);
}
ArrayDeque<HashSet<Integer>> allCombinations = new ArrayDeque<>();
for (int i = 0; i < Math.pow(2, M); i++) {
int addCount = 0;
HashSet<Integer> uniqueNumbers = new HashSet<>();
int[] debug = new int[M];
for (int j = 0; j < M; j++) {
if ((1&i>>j) == 1){
addCount++;
Integer[] union = unions.get(j);
for (Integer integer : union) {
uniqueNumbers.add(integer);
}
}
}
if (addCount > 1) {
allCombinations.add(uniqueNumbers);
}
}
int ans = 0;
while (!allCombinations.isEmpty()){
HashSet<Integer> currentUnion = allCombinations.pop();
boolean isOk = true;
// 1 ~ N
for (int i = 1; i <= N; i++) {
if (!currentUnion.contains(i)){
isOk = false;
break;
}
}
if (isOk){
ans++;
}
}
out.println(ans);
}
/*
* Form: http://codeforces.com/blog/entry/7018
*/
private class MyScanner {
BufferedReader br;
StringTokenizer st;
MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
import java.io.*;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
public class Main {
private static PrintWriter out;
public static void main(String[] args) {
Main main = new Main();
out = new PrintWriter(new BufferedOutputStream(System.out));
try {
main.run(args);
} catch (Exception e) {
e.printStackTrace();
}
out.close();
}
private void run(String[] arguments) throws Exception {
MyScanner sc = new MyScanner();
int N = sc.nextInt();
int M = sc.nextInt();
// M個の集合
ArrayList<Integer[]> unions = new ArrayList<>();
for (int i = 0; i < M; i++) {
int C = sc.nextInt();
Integer[] S = Arrays.stream(sc.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
unions.add(S);
}
ArrayDeque<HashSet<Integer>> allCombinations = new ArrayDeque<>();
for (int i = 0; i < Math.pow(2, M); i++) {
int addCount = 0;
HashSet<Integer> uniqueNumbers = new HashSet<>();
int[] debug = new int[M];
for (int j = 0; j < M; j++) {
if ((1&i>>j) == 1){
addCount++;
Integer[] union = unions.get(j);
for (Integer integer : union) {
uniqueNumbers.add(integer);
}
}
}
if (addCount >= 1) {
allCombinations.add(uniqueNumbers);
}
}
int ans = 0;
while (!allCombinations.isEmpty()){
HashSet<Integer> currentUnion = allCombinations.pop();
boolean isOk = true;
// 1 ~ N
for (int i = 1; i <= N; i++) {
if (!currentUnion.contains(i)){
isOk = false;
break;
}
}
if (isOk){
ans++;
}
}
out.println(ans);
}
/*
* Form: http://codeforces.com/blog/entry/7018
*/
private class MyScanner {
BufferedReader br;
StringTokenizer st;
MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
}
| ConDefects/ConDefects/Code/abc289_c/Java/41403869 |
condefects-java_data_1168 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int M = in.nextInt();
int[] C = new int[M];
int[] a = new int[M];
for(int i=0;i<M;i++){
C[i] = in.nextInt();
for(int j=0;j<C[i];j++){
int num = in.nextInt();
num--;
a[i] |= (1<<num);
}
}
int count =0;
for(int combination=0; combination < (1<<M); combination++){
int sumUnion = 0;//和集合
for(int i=0; i<M; i++){
if((combination>>i & 1) == 1 ){
sumUnion |= a[i];
}
}
if(sumUnion == (1<<M) - 1){
count++;
}
}
//結果の出力
System.out.print(count);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int M = in.nextInt();
int[] C = new int[M];
int[] a = new int[M];
for(int i=0;i<M;i++){
C[i] = in.nextInt();
for(int j=0;j<C[i];j++){
int num = in.nextInt();
num--;
a[i] |= (1<<num);
}
}
int count =0;
for(int combination=0; combination < (1<<M); combination++){
int sumUnion = 0;//和集合
for(int i=0; i<M; i++){
if((combination>>i & 1) == 1 ){
sumUnion |= a[i];
}
}
if(sumUnion == (1<<N) - 1){
count++;
}
}
//結果の出力
System.out.print(count);
}
} | ConDefects/ConDefects/Code/abc289_c/Java/39980033 |
condefects-java_data_1169 | import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
ContestScanner in = new ContestScanner(System.in);
ContestPrinter out = new ContestPrinter(System.out);
Task solver = new Task();
solver.solve(in, out);
out.flush();
out.close();
}
}
class Task {
long mod = 998244353;
long powmod(long a, long b) {
long ans = 1, d = a;
while (b > 0) {
if (b % 2 == 1) ans = ans * d % mod;
b >>= 1;
d = d * d % mod;
}
return ans;
}
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int lcm(int x, int y) {
return x * y / gcd(x, y);
}
public void solve(ContestScanner in, ContestPrinter out) throws Exception {
// int T = in.nextInt();
int T = 1;
for (int tc = 1; tc <= T; tc++) {
solveOne(in, out, tc);
}
}
private void solveOne(ContestScanner in, ContestPrinter out, int tc) {
int n = in.nextInt();
List<Integer>[] list = new List[n];
for (int i = 0; i < n; i++) {
list[i] = new ArrayList<>();
}
for (int i = 0; i < n; i++) {
int x = in.nextInt() - 1;
list[x].add(i);
}
long ans = 0;
for (int i = 0; i < n; i++) {
long sum = 0;
// a[i] - a[i - 1] - 1 + a[i] - a[i - 2] - 2
for (int j = 0; j < list[i].size(); j++) {
if (j > 0) {
ans += 1L * j * list[i].get(j) - sum - j * (j + 1) / 2;
}
sum += list[i].get(j);
}
}
out.println(ans);
}
}
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 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);
}
}
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);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
ContestScanner in = new ContestScanner(System.in);
ContestPrinter out = new ContestPrinter(System.out);
Task solver = new Task();
solver.solve(in, out);
out.flush();
out.close();
}
}
class Task {
long mod = 998244353;
long powmod(long a, long b) {
long ans = 1, d = a;
while (b > 0) {
if (b % 2 == 1) ans = ans * d % mod;
b >>= 1;
d = d * d % mod;
}
return ans;
}
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int lcm(int x, int y) {
return x * y / gcd(x, y);
}
public void solve(ContestScanner in, ContestPrinter out) throws Exception {
// int T = in.nextInt();
int T = 1;
for (int tc = 1; tc <= T; tc++) {
solveOne(in, out, tc);
}
}
private void solveOne(ContestScanner in, ContestPrinter out, int tc) {
int n = in.nextInt();
List<Integer>[] list = new List[n];
for (int i = 0; i < n; i++) {
list[i] = new ArrayList<>();
}
for (int i = 0; i < n; i++) {
int x = in.nextInt() - 1;
list[x].add(i);
}
long ans = 0;
for (int i = 0; i < n; i++) {
long sum = 0;
// a[i] - a[i - 1] - 1 + a[i] - a[i - 2] - 2
for (int j = 0; j < list[i].size(); j++) {
if (j > 0) {
ans += 1L * j * list[i].get(j) - sum - 1L * j * (j + 1) / 2;
}
sum += list[i].get(j);
}
}
out.println(ans);
}
}
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 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);
}
}
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);
}
}
| ConDefects/ConDefects/Code/abc318_e/Java/45470981 |
condefects-java_data_1170 |
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i = 0; i < n; i++) {
a[i] = sc.nextInt() - 1;
}
ArrayList<Long>[] lists = new ArrayList[n];
for(int i = 0; i < n; i++) {
lists[i] = new ArrayList<>();
}
for(int i = 0; i < n; i++) {
lists[a[i]].add((long)i);
}
long result = 0;
for(int i = 0; i < n; i++) {
for(int j = 1; j < lists[i].size() ; j++) {
// System.out.println(i + " " + j);
// result += (lists[i])
result += (j * ((lists[i].size() - 1) - j + 1)) * ((lists[i].get(j) - lists[i].get(j - 1) - 1));
// System.out.println("result " + result);
}
}
System.out.println(result);
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a[] = new int[n];
for(int i = 0; i < n; i++) {
a[i] = sc.nextInt() - 1;
}
ArrayList<Long>[] lists = new ArrayList[n];
for(int i = 0; i < n; i++) {
lists[i] = new ArrayList<>();
}
for(int i = 0; i < n; i++) {
lists[a[i]].add((long)i);
}
long result = 0;
for(int i = 0; i < n; i++) {
for(int j = 1; j < lists[i].size() ; j++) {
// System.out.println(i + " " + j);
// result += (lists[i])
result += ((long)j * ((lists[i].size() - 1) - j + 1)) * ((lists[i].get(j) - lists[i].get(j - 1) - 1));
// System.out.println("result " + result);
}
}
System.out.println(result);
}
}
| ConDefects/ConDefects/Code/abc318_e/Java/45572827 |
condefects-java_data_1171 | 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 SegmentTree {
int l , r; // range responsible for
SegmentTree left , right;
long lcm = 0, limit = (long)1e9 + 7;
SegmentTree(int l, int r, long a[]) {
this.l = l;
this.r = r;
if (l == r) {
this.lcm = 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.lcm = this.left.lcm/gcd(this.left.lcm , this.right.lcm)*this.right.lcm;
if(this.lcm >= limit) this.lcm = limit;
}
// public void merge(List<Integer> A , List<Integer> B , List<Integer> C) {
// 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++));
// // System.out.println(A);
// }
public long query(int left , int right) {
if (right < left) return 1;
// if (this.rem != 0) {
// this.val ^= this.rem;
// if (this.left != null)this.left.rem ^= this.rem;
// if (this.right != null)this.right.rem ^= this.rem;
// this.rem = 0;
// }
if (this.l > right || this.r < left) return 1;
if (this.l >= left && this.r <= right) return this.lcm;
long A =this.left.query(left , right) , B = this.right.query( left , right);
long ans = A/gcd(A , B)*B;
if(ans >= limit) ans = limit;
return ans;
}
// public void rangeUpdate1(int left , int right, int x) {
// if(left > right) return ;
// if(this.l > right || this.r < left) return;
// if(this.l >= left && this.r <= right) {
// this.val = 1l*(this.r - this.l + 1)*x;
// this.f.clear();
// this.f.put(x , this.r - this.l + 1);
// return;
// }
// this.left.rangeUpdate1(left , right , x);
// this.right.rangeUpdate1(left , right , x);
// merge(this.f , this.left.f , this.right.f);
// this.val = this.left.val+ this.right.val;
// }
// public void rangeUpdate(int left , int right, long x) {
// if (left > right) return ;
// if (this.rem != 0) {
// this.val ^= this.rem;
// if (this.left != null)this.left.rem ^= this.rem;
// if (this.right != null)this.right.rem ^= this.rem;
// this.rem = 0;
// }
// if (this.l > right || this.r < left) return;
// if (this.l >= left && this.r <= right) {
// this.val ^= x;
// if (this.left != null)this.left.rem ^= x;
// if (this.right != null)this.right.rem ^= x;
// return;
// }
// this.left.rangeUpdate(left , right , x);
// this.right.rangeUpdate(left , right , x);
// this.val = this.left.val ^ this.right.val;
// }
}
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 int height[];
static long p[];
static int endTime[];
static int colx[] = {1, -1, 0, 0};
static int coly[] = {0, 0, 1, -1};
// static int time;
static Long dp[][];
// static HashMap<String , Long> dmap;
static long dirpair[][];
static HashSet<String> not;
static SegmentTree 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();
}
public static void solve() throws IOException {
int n = ri() , a[] = rai(n);
HashMap<Integer , List<Integer>> map = new HashMap<>();
for(int i = 0;i < n;i++) {
map.putIfAbsent(a[i] , new ArrayList<>());
map.get(a[i]).add(i);
}
long ans = 0;
for(int x : map.keySet()) {
int c = 1;
long b = 0;
for(int i = 1;i < map.get(x).size();i++) {
b += (map.get(x).get(i) - map.get(x).get(i-1) - 1)*c;
c++;
ans += b;
}
}
System.out.println(ans);
// System.out.println(ans);
}
static long solve(int mask,int node,int N, int w[][]) {
int max = (int)1e9 + 10;
long inf = (long)1e17;
int bit = Integer.bitCount(mask);
if(bit == N) return 0;
if(node >= N) return inf;
if(dp[mask][node] != null) return dp[mask][node];
long ans = solve(mask , node + 1 , N,w);
if(ans == inf) ans = 0;
for(int i = 0;i < N;i++) {
if((mask&(1<<i)) != 0) continue;
if((mask&(1<<node)) != 0) continue;
if(w[node][i] < max) {
int nmask = mask|(1<<i);
nmask |= (1<<node);
long g = solve(nmask , node + 1 , N,w);
if(g == inf) continue;
ans = Math.max(ans , w[node][i] + g);
}
}
return dp[mask][node] = ans;
}
// void dfsLCA(int node, int par) {
// for(int next : graph.get(node)) {
// if(vis[next]) continue;
// lca[next][0] = node;
// for(int i = 1;i <= 30;i++) lca[next][i] = lca[lca[next][i-1]][i-1];
// dfs(next , 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((diff&(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 void dfs(int r, int c, char arr[][]) {
int n = arr.length , m = arr[0].length;
arr[r][c] = '#';
for (int i = 0; i < 4; i++) {
int nr = r + colx[i] , nc = c + coly[i];
if (nr < 0 || nc < 0 || nc >= m || nr >= n) continue;
if (arr[nr][nc] == '#') continue;
dfs(nr, nc, arr);
}
}
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] == '#');
}
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;
}
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 SegmentTree {
int l , r; // range responsible for
SegmentTree left , right;
long lcm = 0, limit = (long)1e9 + 7;
SegmentTree(int l, int r, long a[]) {
this.l = l;
this.r = r;
if (l == r) {
this.lcm = 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.lcm = this.left.lcm/gcd(this.left.lcm , this.right.lcm)*this.right.lcm;
if(this.lcm >= limit) this.lcm = limit;
}
// public void merge(List<Integer> A , List<Integer> B , List<Integer> C) {
// 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++));
// // System.out.println(A);
// }
public long query(int left , int right) {
if (right < left) return 1;
// if (this.rem != 0) {
// this.val ^= this.rem;
// if (this.left != null)this.left.rem ^= this.rem;
// if (this.right != null)this.right.rem ^= this.rem;
// this.rem = 0;
// }
if (this.l > right || this.r < left) return 1;
if (this.l >= left && this.r <= right) return this.lcm;
long A =this.left.query(left , right) , B = this.right.query( left , right);
long ans = A/gcd(A , B)*B;
if(ans >= limit) ans = limit;
return ans;
}
// public void rangeUpdate1(int left , int right, int x) {
// if(left > right) return ;
// if(this.l > right || this.r < left) return;
// if(this.l >= left && this.r <= right) {
// this.val = 1l*(this.r - this.l + 1)*x;
// this.f.clear();
// this.f.put(x , this.r - this.l + 1);
// return;
// }
// this.left.rangeUpdate1(left , right , x);
// this.right.rangeUpdate1(left , right , x);
// merge(this.f , this.left.f , this.right.f);
// this.val = this.left.val+ this.right.val;
// }
// public void rangeUpdate(int left , int right, long x) {
// if (left > right) return ;
// if (this.rem != 0) {
// this.val ^= this.rem;
// if (this.left != null)this.left.rem ^= this.rem;
// if (this.right != null)this.right.rem ^= this.rem;
// this.rem = 0;
// }
// if (this.l > right || this.r < left) return;
// if (this.l >= left && this.r <= right) {
// this.val ^= x;
// if (this.left != null)this.left.rem ^= x;
// if (this.right != null)this.right.rem ^= x;
// return;
// }
// this.left.rangeUpdate(left , right , x);
// this.right.rangeUpdate(left , right , x);
// this.val = this.left.val ^ this.right.val;
// }
}
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 int height[];
static long p[];
static int endTime[];
static int colx[] = {1, -1, 0, 0};
static int coly[] = {0, 0, 1, -1};
// static int time;
static Long dp[][];
// static HashMap<String , Long> dmap;
static long dirpair[][];
static HashSet<String> not;
static SegmentTree 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();
}
public static void solve() throws IOException {
int n = ri() , a[] = rai(n);
HashMap<Integer , List<Integer>> map = new HashMap<>();
for(int i = 0;i < n;i++) {
map.putIfAbsent(a[i] , new ArrayList<>());
map.get(a[i]).add(i);
}
long ans = 0;
for(int x : map.keySet()) {
long c = 1;
long b = 0;
for(int i = 1;i < map.get(x).size();i++) {
b += (map.get(x).get(i) - map.get(x).get(i-1) - 1)*c;
c++;
ans += b;
}
}
System.out.println(ans);
// System.out.println(ans);
}
static long solve(int mask,int node,int N, int w[][]) {
int max = (int)1e9 + 10;
long inf = (long)1e17;
int bit = Integer.bitCount(mask);
if(bit == N) return 0;
if(node >= N) return inf;
if(dp[mask][node] != null) return dp[mask][node];
long ans = solve(mask , node + 1 , N,w);
if(ans == inf) ans = 0;
for(int i = 0;i < N;i++) {
if((mask&(1<<i)) != 0) continue;
if((mask&(1<<node)) != 0) continue;
if(w[node][i] < max) {
int nmask = mask|(1<<i);
nmask |= (1<<node);
long g = solve(nmask , node + 1 , N,w);
if(g == inf) continue;
ans = Math.max(ans , w[node][i] + g);
}
}
return dp[mask][node] = ans;
}
// void dfsLCA(int node, int par) {
// for(int next : graph.get(node)) {
// if(vis[next]) continue;
// lca[next][0] = node;
// for(int i = 1;i <= 30;i++) lca[next][i] = lca[lca[next][i-1]][i-1];
// dfs(next , 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((diff&(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 void dfs(int r, int c, char arr[][]) {
int n = arr.length , m = arr[0].length;
arr[r][c] = '#';
for (int i = 0; i < 4; i++) {
int nr = r + colx[i] , nc = c + coly[i];
if (nr < 0 || nc < 0 || nc >= m || nr >= n) continue;
if (arr[nr][nc] == '#') continue;
dfs(nr, nc, arr);
}
}
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] == '#');
}
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;
}
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/abc318_e/Java/45227286 |
condefects-java_data_1172 | import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
sc.nextInt();
int specTypeNum = sc.nextInt();
// 商品情報リスト生成
List<Product> productList = new ArrayList<>();
// 一つ目の商品をリストに格納
int price = sc.nextInt();
int numOfSpec = sc.nextInt();
int[] specArray = new int[specTypeNum]; // int の配列は 0 埋めして生成される
for(int i = 0; i < numOfSpec; i++){
specArray[sc.nextInt() - 1] = 1;
}
Product product = new Product(price, numOfSpec, specArray);
productList.add(product);
// 二つ目以降の情報取得・リスト内データとの比較
while(sc.hasNext()){
// 情報取得
price = sc.nextInt();
numOfSpec = sc.nextInt();
specArray = new int[specTypeNum];
for(int i = 0; i < numOfSpec; i++){
specArray[sc.nextInt() - 1] = 1;
}
Product product_ = new Product(price, numOfSpec, specArray);
// リスト内データとの比較
boolean hasPlusOne;
boolean hasMinusOne;
for(Product p : productList){
hasPlusOne = false;
hasMinusOne = false;
for(int i = 0; i < specTypeNum; i++){
if(product_.getSpecArray()[i] - p.getSpecArray()[i] == 1){
hasPlusOne = true;
}
if(product_.getSpecArray()[i] - p.getSpecArray()[i] == -1){
hasMinusOne = true;
}
}
// +1 も -1 もあれば互換性なし
if (hasPlusOne && hasMinusOne){
continue;
}
// product_ の方が機能が多く、値段も同じかより安い
if(hasPlusOne && product_.getPrice() <= p.getPrice()){
System.out.println("Yes");
return;
}
// p の方が機能が多く、値段も同じかより安い
if(hasMinusOne && p.getPrice() <= product_.getPrice()){
System.out.println("Yes");
return;
}
// 機能が同じで、どちらかの値段がより安い (= 値段が異なる)
if(!hasMinusOne && !hasMinusOne && product_.getPrice() != p.getPrice()){
System.out.println("Yes");
return;
}
}
// リスト中のどの商品と比較しても条件が合わない場合、リストに追加
productList.add(product_);
}
sc.close();
// 全商品が条件に合わない
System.out.println("No");
}
static class Product {
private int price;
private int numOfSpec;
private int[] specArray;
public Product(int price, int numOfSpec, int[] specArray){
this.price = price;
this.numOfSpec = numOfSpec;
this.specArray = specArray;
}
public int getPrice(){
return this.price;
}
public int getNumOfSpec(){
return this.numOfSpec;
}
public int[] getSpecArray(){
return this.specArray;
}
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
sc.nextInt();
int specTypeNum = sc.nextInt();
// 商品情報リスト生成
List<Product> productList = new ArrayList<>();
// 一つ目の商品をリストに格納
int price = sc.nextInt();
int numOfSpec = sc.nextInt();
int[] specArray = new int[specTypeNum]; // int の配列は 0 埋めして生成される
for(int i = 0; i < numOfSpec; i++){
specArray[sc.nextInt() - 1] = 1;
}
Product product = new Product(price, numOfSpec, specArray);
productList.add(product);
// 二つ目以降の情報取得・リスト内データとの比較
while(sc.hasNext()){
// 情報取得
price = sc.nextInt();
numOfSpec = sc.nextInt();
specArray = new int[specTypeNum];
for(int i = 0; i < numOfSpec; i++){
specArray[sc.nextInt() - 1] = 1;
}
Product product_ = new Product(price, numOfSpec, specArray);
// リスト内データとの比較
boolean hasPlusOne;
boolean hasMinusOne;
for(Product p : productList){
hasPlusOne = false;
hasMinusOne = false;
for(int i = 0; i < specTypeNum; i++){
if(product_.getSpecArray()[i] - p.getSpecArray()[i] == 1){
hasPlusOne = true;
}
if(product_.getSpecArray()[i] - p.getSpecArray()[i] == -1){
hasMinusOne = true;
}
}
// +1 も -1 もあれば互換性なし
if (hasPlusOne && hasMinusOne){
continue;
}
// product_ の方が機能が多く、値段も同じかより安い
if(hasPlusOne && product_.getPrice() <= p.getPrice()){
System.out.println("Yes");
return;
}
// p の方が機能が多く、値段も同じかより安い
if(hasMinusOne && p.getPrice() <= product_.getPrice()){
System.out.println("Yes");
return;
}
// 機能が同じで、どちらかの値段がより安い (= 値段が異なる)
if(!hasPlusOne && !hasMinusOne && product_.getPrice() != p.getPrice()){
System.out.println("Yes");
return;
}
}
// リスト中のどの商品と比較しても条件が合わない場合、リストに追加
productList.add(product_);
}
sc.close();
// 全商品が条件に合わない
System.out.println("No");
}
static class Product {
private int price;
private int numOfSpec;
private int[] specArray;
public Product(int price, int numOfSpec, int[] specArray){
this.price = price;
this.numOfSpec = numOfSpec;
this.specArray = specArray;
}
public int getPrice(){
return this.price;
}
public int getNumOfSpec(){
return this.numOfSpec;
}
public int[] getSpecArray(){
return this.specArray;
}
}
} | ConDefects/ConDefects/Code/abc310_b/Java/43938360 |
condefects-java_data_1173 | import java.util.*;
import java.io.*;
public class Main {
static ContestScanner sc = new ContestScanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
//int T = sc.nextInt();
//for(int i = 0; i < T; i++)solve();
solve();
pw.flush();
}
public static void solve() {
int N = sc.nextInt();
int M = sc.nextInt();
ArrayList<ArrayList<int[]>> arr = new ArrayList<>();
for(int i = 0; i < N; i++){
arr.add(new ArrayList<>());
}
long[] d1 = new long[N];
Arrays.fill(d1,Long.MAX_VALUE);
for(int i = 0; i < M; i++){
int a = sc.nextInt()-1;
int b = sc.nextInt()-1;
int c = sc.nextInt();
arr.get(a).add(new int[]{b,c,i+1});
arr.get(b).add(new int[]{a,c,i+1});
}
PriorityQueue<long[]> pq = new PriorityQueue<long[]>((a,b) -> (a[2]-b[2] > 0 ? 1 : a[2] == b[2] ? 0 : -1));
for(int[] v : arr.get(0)){
pq.add(new long[]{v[0],v[1],v[2]});
}
boolean[] used = new boolean[N];
used[0] = true;
d1[0] = 0;
ArrayList<Integer> check = new ArrayList<>();
while(pq.size() > 0){
long[] p = pq.poll();
int b = (int)p[0];
long d = p[1];
int i = (int)p[2];
if(used[b]) continue;
d1[b] = d;
used[b] = true;
check.add(i);
for(int[] v : arr.get(b)){
pq.add(new long[]{v[0],v[1]+d,v[2]});
}
}
for(int v : check) sb.append(v).append(" ");
pw.println(sb.toString());
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
/**
* 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;
}
}
import java.util.*;
import java.io.*;
public class Main {
static ContestScanner sc = new ContestScanner(System.in);
static PrintWriter pw = new PrintWriter(System.out);
static StringBuilder sb = new StringBuilder();
static long mod = (long) 1e9 + 7;
public static void main(String[] args) throws Exception {
//int T = sc.nextInt();
//for(int i = 0; i < T; i++)solve();
solve();
pw.flush();
}
public static void solve() {
int N = sc.nextInt();
int M = sc.nextInt();
ArrayList<ArrayList<int[]>> arr = new ArrayList<>();
for(int i = 0; i < N; i++){
arr.add(new ArrayList<>());
}
long[] d1 = new long[N];
Arrays.fill(d1,Long.MAX_VALUE);
for(int i = 0; i < M; i++){
int a = sc.nextInt()-1;
int b = sc.nextInt()-1;
int c = sc.nextInt();
arr.get(a).add(new int[]{b,c,i+1});
arr.get(b).add(new int[]{a,c,i+1});
}
PriorityQueue<long[]> pq = new PriorityQueue<long[]>((a,b) -> (a[1]-b[1] > 0 ? 1 : a[1] == b[1] ? 0 : -1));
for(int[] v : arr.get(0)){
pq.add(new long[]{v[0],v[1],v[2]});
}
boolean[] used = new boolean[N];
used[0] = true;
d1[0] = 0;
ArrayList<Integer> check = new ArrayList<>();
while(pq.size() > 0){
long[] p = pq.poll();
int b = (int)p[0];
long d = p[1];
int i = (int)p[2];
if(used[b]) continue;
d1[b] = d;
used[b] = true;
check.add(i);
for(int[] v : arr.get(b)){
pq.add(new long[]{v[0],v[1]+d,v[2]});
}
}
for(int v : check) sb.append(v).append(" ");
pw.println(sb.toString());
}
static class GeekInteger {
public static void save_sort(int[] array) {
shuffle(array);
Arrays.sort(array);
}
public static int[] shuffle(int[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
int randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
public static void save_sort(long[] array) {
shuffle(array);
Arrays.sort(array);
}
public static long[] shuffle(long[] array) {
int n = array.length;
Random random = new Random();
for (int i = 0, j; i < n; i++) {
j = i + random.nextInt(n - i);
long randomElement = array[j];
array[j] = array[i];
array[i] = randomElement;
}
return array;
}
}
}
/**
* 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;
}
}
| ConDefects/ConDefects/Code/abc252_e/Java/33591950 |
condefects-java_data_1174 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
int m = Integer.parseInt(sa[1]);
int n2 = n * 2;
sa = br.readLine().split(" ");
int[] a = new int[n2];
for (int i = 0; i < n2; i++) {
a[i] = Integer.parseInt(sa[i]);
}
br.close();
long sum = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n2; i++) {
sum += a[i];
map.put(a[i], map.getOrDefault(a[i], 0) + 1);
}
if (sum % 2 == 1 && m % 2 == 0) {
System.out.println("Alice");
return;
}
int odd = 0;
for (int v : map.values()) {
if (v % 2 == 1) {
odd++;
}
}
if (odd == 0) {
System.out.println("Bob");
return;
}
if (m % 2 == 1) {
System.out.println("Alice");
return;
}
int m2 = m / 2;
boolean ok = true;
for (int k : map.keySet()) {
if (map.get(k) % 2 == 1) {
Integer v = map.get((k + m2) % m);
if (v == null || v % 2 == 0) {
ok = false;
break;
}
}
}
if (ok) {
System.out.println("Bob");
} else {
System.out.println("Alice");
}
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] sa = br.readLine().split(" ");
int n = Integer.parseInt(sa[0]);
int m = Integer.parseInt(sa[1]);
int n2 = n * 2;
sa = br.readLine().split(" ");
int[] a = new int[n2];
for (int i = 0; i < n2; i++) {
a[i] = Integer.parseInt(sa[i]);
}
br.close();
long sum = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n2; i++) {
sum += a[i];
map.put(a[i], map.getOrDefault(a[i], 0) + 1);
}
if (sum % 2 == 1 && m % 2 == 0) {
System.out.println("Alice");
return;
}
int odd = 0;
for (int v : map.values()) {
if (v % 2 == 1) {
odd++;
}
}
if (odd == 0) {
System.out.println("Bob");
return;
}
if (m % 2 == 1) {
System.out.println("Alice");
return;
}
int m2 = m / 2;
boolean ok = true;
for (int k : map.keySet()) {
if (map.get(k) % 2 == 1) {
Integer v = map.get((k + m2) % m);
if (v == null || v % 2 == 0) {
ok = false;
break;
}
}
}
if (ok && odd % 4 == 0) {
System.out.println("Bob");
} else {
System.out.println("Alice");
}
}
}
| ConDefects/ConDefects/Code/arc148_d/Java/34805396 |
condefects-java_data_1175 | import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
String N = sc.next();
String W = sc.next();
System.out.println(N+"san");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
String N = sc.next();
String W = sc.next();
System.out.println(N+" san");
}
} | ConDefects/ConDefects/Code/abc325_a/Java/52986503 |
condefects-java_data_1176 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(sc.nextLine().replaceAll(" .*", "san"));
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print(sc.nextLine().replaceAll(" .*", " san"));
}
} | ConDefects/ConDefects/Code/abc325_a/Java/54905122 |
condefects-java_data_1177 | import java.util.*;
import java.io.*;
import java.math.*;
class Main{
void solve(PrintWriter out, In in) {
int n = in.nextInt() , d = in.nextInt();
ArrayList<pair> wall = new ArrayList<>();
for(int i = 0 ; i < n ; i ++ ) {
long l = in.nextLong() , r = in.nextLong();
wall.add(new pair(l , r));
}
Collections.sort(wall,Comparator.comparing(pair::a).thenComparing(pair::b));
long ans = 0 , x = -1000000000000L;
for(pair p : wall) {
if(x + d - 1 < p.a()) {
ans ++ ;
x = p.b();
}
}
out.print(ans);
}
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
}
class pair{
long a , b ;
pair(long a , long b) {
this.a = a ;
this.b = b ;
}
long a() { return this.a ;}
long b() { return this.b ;}
}
class Pair implements Comparable<Pair>{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() {
return this.first ;
}
int second() {
return this.second;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair that = (Pair)o;
return first == that.first && second == that.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public int compareTo(Pair o) {
return first == o.first ? Integer.compare(second, o.second) : Integer.compare(first, o.first);
}
@Override
public String toString(){
return first()+" "+second();
}
}
class PairII {
private int first;
private int second;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() {
return this.first;
}
int second() {
return this.second;
}
int third() {
return this.third;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
PairII other = (PairII) obj;
return this.first == other.first && this.second == other.second && this.third == other.third;
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + first;
result = 31 * result + second;
result = 31 * result + third;
return result;
}
@Override
public String toString() {
return this.first+" "+this.second+" "+this.third;
}
}
class In{
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();
}
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();
}
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();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
import java.util.*;
import java.io.*;
import java.math.*;
class Main{
void solve(PrintWriter out, In in) {
int n = in.nextInt() , d = in.nextInt();
ArrayList<pair> wall = new ArrayList<>();
for(int i = 0 ; i < n ; i ++ ) {
long l = in.nextLong() , r = in.nextLong();
wall.add(new pair(l , r));
}
Collections.sort(wall,Comparator.comparing(pair::b).thenComparing(pair::a));
long ans = 0 , x = -1000000000000L;
for(pair p : wall) {
if(x + d - 1 < p.a()) {
ans ++ ;
x = p.b();
}
}
out.print(ans);
}
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}
}
class pair{
long a , b ;
pair(long a , long b) {
this.a = a ;
this.b = b ;
}
long a() { return this.a ;}
long b() { return this.b ;}
}
class Pair implements Comparable<Pair>{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() {
return this.first ;
}
int second() {
return this.second;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Pair)) {
return false;
}
Pair that = (Pair)o;
return first == that.first && second == that.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
@Override
public int compareTo(Pair o) {
return first == o.first ? Integer.compare(second, o.second) : Integer.compare(first, o.first);
}
@Override
public String toString(){
return first()+" "+second();
}
}
class PairII {
private int first;
private int second;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() {
return this.first;
}
int second() {
return this.second;
}
int third() {
return this.third;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
PairII other = (PairII) obj;
return this.first == other.first && this.second == other.second && this.third == other.third;
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + first;
result = 31 * result + second;
result = 31 * result + third;
return result;
}
@Override
public String toString() {
return this.first+" "+this.second+" "+this.third;
}
}
class In{
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();
}
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();
}
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();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
| ConDefects/ConDefects/Code/abc230_d/Java/42873970 |
condefects-java_data_1178 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
static int n;
static int d;
static Pair[] p;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
d = sc.nextInt();
p = new Pair[n];
for(int i = 0; i < n ;i++) {
p[i] = new Pair(sc.nextLong(), sc.nextLong());
}
Arrays.sort(p);
long ans = 0;
long x = -(1 << 10);
long l = 0;
long r = 0;
for(int i = 0 ; i < n ; i++) {
l = p[i].getL();
r = p[i].getR();
if(x + d - 1 < l) {
ans++;
x = r;
}
}
System.out.println(ans);
}
}
class Pair implements Comparable<Pair>{
long l;
long r;
Pair(long l ,long r) {
this.l = l;
this.r = r;
}
public long getL() {
return l;
}
public long getR() {
return r;
}
@Override
public int compareTo(Pair o) {
if(this.r < o.r) {
return -1;
}
if(this.r == o.r && this.l < o.l) {
return -1;
}
if(this.r == o.r && this.l == o.l) {
return 0;
}
return 1;
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static int n;
static int d;
static Pair[] p;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
d = sc.nextInt();
p = new Pair[n];
for(int i = 0; i < n ;i++) {
p[i] = new Pair(sc.nextLong(), sc.nextLong());
}
Arrays.sort(p);
long ans = 0;
long x = Long.MIN_VALUE;
long l = 0;
long r = 0;
for(int i = 0 ; i < n ; i++) {
l = p[i].getL();
r = p[i].getR();
if(x + d - 1 < l) {
ans++;
x = r;
}
}
System.out.println(ans);
}
}
class Pair implements Comparable<Pair>{
long l;
long r;
Pair(long l ,long r) {
this.l = l;
this.r = r;
}
public long getL() {
return l;
}
public long getR() {
return r;
}
@Override
public int compareTo(Pair o) {
if(this.r < o.r) {
return -1;
}
if(this.r == o.r && this.l < o.l) {
return -1;
}
if(this.r == o.r && this.l == o.l) {
return 0;
}
return 1;
}
}
| ConDefects/ConDefects/Code/abc230_d/Java/40160260 |
condefects-java_data_1179 | import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
String S = sc.next();
long K = sc.nextLong();
ArrayList<Integer> y0 = new ArrayList<>();
ArrayList<Integer> y1 = new ArrayList<>();
for (int i = 0; i < S.length(); i++) {
if ( S.charAt(i) == 'Y' ) {
y0.add(i);
y1.add(S.length() - i - 1);
}
}
Collections.reverse(y1);
if ( y0.size() == 0 ) {
System.out.println(0);
return;
}
int min = 1;
int max = y0.size() + 1;
while ( max - min > 1 ) {
int mid = (min + max) / 2;
if ( solve0(y0, y1, K, mid) ) {
min = mid;
} else {
max = mid;
}
}
System.out.println(min);
}
boolean solve0(ArrayList<Integer> y0, ArrayList<Integer> y1, long K, int a) {
if ( a % 2 == 0 ) {
return solve0(y0, K, a / 2, a / 2);
} else {
return solve0(y0, K, a - a / 2, a / 2) || solve0(y1, K, a - a / 2, a / 2);
}
}
boolean solve0(ArrayList<Integer> y, long K, int a0, int a1) {
long k0 = 0;
for (int i = 0; i < a0; i++) {
long p = y.get(i);
if ( i > 0 ) k0 += (p - y.get(i - 1) - 1) * i;
}
long k1 = 0;
for (int i = a0; i < a0 + a1; i++) {
k1 += ((long)y.get(i)) - y.get(a0 - 1) - (i - a0 + 1);
}
if ( k0 + k1 <= K ) return true;
for (int i = 1; i <= y.size() - a0 - a1; i++) {
int i0 = i + a0 - 1;
int i1 = i + a0;
int i2 = i + a0 + a1 - 1;
k0 -= y.get(i0 - 1) - y.get(i - 1) - (a0 - 1);
k0 += ((long)(a0 - 1)) * (y.get(i0) - y.get(i0 - 1));
k1 -= ((long)a1) * (y.get(i0) - y.get(i0 - 1) - 1);
k1 += y.get(i2) - y.get(i0) - 1 - (a1 - 1);
if ( k0 + k1 <= K ) return true;
}
return false;
}
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.Collections;
import java.util.NoSuchElementException;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
public void solve() {
FastScanner sc = new FastScanner(System.in);
String S = sc.next();
long K = sc.nextLong();
ArrayList<Integer> y0 = new ArrayList<>();
ArrayList<Integer> y1 = new ArrayList<>();
for (int i = 0; i < S.length(); i++) {
if ( S.charAt(i) == 'Y' ) {
y0.add(i);
y1.add(S.length() - i - 1);
}
}
Collections.reverse(y1);
if ( y0.size() == 0 ) {
System.out.println(0);
return;
}
int min = 1;
int max = y0.size() + 1;
while ( max - min > 1 ) {
int mid = (min + max) / 2;
if ( solve0(y0, y1, K, mid) ) {
min = mid;
} else {
max = mid;
}
}
System.out.println(min);
}
boolean solve0(ArrayList<Integer> y0, ArrayList<Integer> y1, long K, int a) {
if ( a % 2 == 0 ) {
return solve0(y0, K, a / 2, a / 2);
} else {
return solve0(y0, K, a - a / 2, a / 2) || solve0(y1, K, a - a / 2, a / 2);
}
}
boolean solve0(ArrayList<Integer> y, long K, int a0, int a1) {
long k0 = 0;
for (int i = 0; i < a0; i++) {
long p = y.get(i);
if ( i > 0 ) k0 += (p - y.get(i - 1) - 1) * i;
}
long k1 = 0;
for (int i = a0; i < a0 + a1; i++) {
k1 += ((long)y.get(i)) - y.get(a0 - 1) - (i - a0 + 1);
}
if ( k0 + k1 <= K ) return true;
for (int i = 1; i <= y.size() - a0 - a1; i++) {
int i0 = i + a0 - 1;
int i1 = i + a0;
int i2 = i + a0 + a1 - 1;
k0 -= y.get(i0 - 1) - y.get(i - 1) - (a0 - 1);
k0 += ((long)(a0 - 1)) * (y.get(i0) - y.get(i0 - 1) - 1);
k1 -= ((long)a1) * (y.get(i0) - y.get(i0 - 1) - 1);
k1 += y.get(i2) - y.get(i0) - 1 - (a1 - 1);
if ( k0 + k1 <= K ) return true;
}
return false;
}
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/abc229_g/Java/46163023 |
condefects-java_data_1180 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[n];
int[] f = new int[(int)1e6];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
f[a[i]]++;
}
for (int p10 = 1; p10 < (int)1e6; p10 *= 10) {
for (int i = 0; i < f.length; i++) {
if (i / p10 % 10 > 0) {
f[i] += f[i - p10];
}
}
}
long ans = 0;
for (int x : a) {
ans += f[999999 - x];
while (x > 0) {
if (x % 10 > 4) break;
x /= 10;
}
if (x == 0) ans--;
}
System.out.println(ans);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[n];
int[] f = new int[(int)1e6];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
f[a[i]]++;
}
for (int p10 = 1; p10 < (int)1e6; p10 *= 10) {
for (int i = 0; i < f.length; i++) {
if (i / p10 % 10 > 0) {
f[i] += f[i - p10];
}
}
}
long ans = 0;
for (int x : a) {
ans += f[999999 - x];
while (x > 0) {
if (x % 10 > 4) break;
x /= 10;
}
if (x == 0) ans--;
}
System.out.println(ans/2);
}
} | ConDefects/ConDefects/Code/arc136_d/Java/45536357 |
condefects-java_data_1181 | // package lingdaily.date0915;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
for(int i = 0 ; i < n ; i++){
arr[i] = sc.nextInt();
}
int[] f = new int[(int)1e6];
for(int i = 0 ; i < n ; i++){
f[arr[i]]++;
}
for(int p = 1 ; p < 1e6 ;p = p * 10){
for(int i = 0 ; i < 1e6 ;i++){
if(i / p % 10 > 0){
f[i] += f[i - p];
}
}
}
int ans = 0;
next:for(int i = 0 ; i < n ; i++){
int x = arr[i];
ans += f[999999 - x];
for(;x > 0 ; x /= 10){
if(x % 10 > 4){
continue next;
}
}
ans--;
}
System.out.println(ans / 2);
}
}
// package lingdaily.date0915;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
for(int i = 0 ; i < n ; i++){
arr[i] = sc.nextInt();
}
int[] f = new int[(int)1e6];
for(int i = 0 ; i < n ; i++){
f[arr[i]]++;
}
for(int p = 1 ; p < 1e6 ;p = p * 10){
for(int i = 0 ; i < 1e6 ;i++){
if(i / p % 10 > 0){
f[i] += f[i - p];
}
}
}
long ans = 0;
next:for(int i = 0 ; i < n ; i++){
int x = arr[i];
ans += f[999999 - x];
for(;x > 0 ; x /= 10){
if(x % 10 > 4){
continue next;
}
}
ans--;
}
System.out.println(ans / 2);
}
}
| ConDefects/ConDefects/Code/arc136_d/Java/45543804 |
condefects-java_data_1182 | import java.util.*;
import java.io.*;
class Main {
private static final void solve() {
int n = sc.nextInt();
final int m = (int) 1e6;
var a = sc.nextIntArray(n);
long ans = 0;
for (int i : a) {
var yes = true;
while (i != 0) {
yes &= i < 5;
i /= 10;
}
if (yes)
ans--;
}
var d = new long[m];
for (int i : a)
d[i]++;
var t = new int[6];
var tt = new int[6];
for (int i = 0; i < m; i++) {
int ii = i;
for (int jjj = 0; jjj < 6; jjj++) {
tt[jjj] = ii % 10;
ii /= 10;
}
for (int j = 1; j < 64; j++) {
int jj = j;
boolean fu = false;
t = tt.clone();
for (int k = 0; k < 6; k++) {
if ((jj & 1) == 1) {
t[k]--;
fu ^= true;
}
jj >>= 1;
}
var yes = true;
for (int k : t)
yes &= k != -1;
if (!yes)
continue;
int to = 0;
for (int k = 5; k >= 0; k--) {
to *= 10;
to += t[k];
}
if (fu)
d[i] += d[to];
else
d[i] -= d[to];
}
}
for (int i : a) {
int j = m - i - 1;
ans += d[j];
}
ou.println(ans / 2);
}
public static void main(String[] args) {
solve();
ou.flush();
}
private static final ContestScanner sc = new ContestScanner(System.in);
private static final ContestPrinter ou = new ContestPrinter(System.out);
}
final class ContestScanner {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public ContestScanner(InputStream in) {
this.in = in;
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen)
return true;
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
return buflen > 0;
}
private int readByte() {
return hasNextByte() ? buffer[ptr++] : -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 void nextThrow(int n) {
for (int i = 0; i < n; i++)
this.next();
}
public void nextThrow() {
this.nextThrow(1);
}
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 boolean[] nextBoolean(char True) {
String s = this.next();
int n = s.length();
boolean[] array = new boolean[n];
for (int i = 0; i < n; i++)
array[i] = s.charAt(i) == True;
return array;
}
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 long[] nextLongArray(int length, long[] a) {
long[] array = new long[length + a.length];
for (int i = 0; i < length; i++)
array[i] = this.nextLong();
for (int i = length; i < array.length; i++)
array[i] = a[i - length];
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 int[] nextIntArray(int length, int[] array) {
int n = length + array.length;
int[] a = new int[n];
for (int i = 0; i < length; i++)
a[i] = this.nextInt();
for (int i = length; i < n; i++)
a[i] = array[i - length];
return a;
}
public Integer[] nextIntegerArray(int length, java.util.function.IntUnaryOperator map) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsInt(this.nextInt());
return array;
}
public Integer[] nextIntegerArray(int length) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++)
array[i] = 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 String[] nextArray(int length) {
String[] array = new String[length];
for (int i = 0; i < length; i++)
array[i] = this.next();
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 long[][] nextLongMatrix(int height, int width, java.util.function.LongUnaryOperator map) {
long[][] mat = new long[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++)
mat[h][w] = map.applyAsLong(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 int[][] nextIntMatrix(int height, int width, java.util.function.IntUnaryOperator map) {
int[][] mat = new int[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++)
mat[h][w] = map.applyAsInt(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 boolean[][] nextBooleanMatrix(int height, int width, char True) {
boolean[][] mat = new boolean[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) == True;
}
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;
}
}
final 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.*;
class Main {
private static final void solve() {
int n = sc.nextInt();
final int m = (int) 1e6;
var a = sc.nextIntArray(n);
long ans = 0;
for (int i : a) {
var yes = true;
while (i != 0) {
yes &= i % 10 < 5;
i /= 10;
}
if (yes)
ans--;
}
var d = new long[m];
for (int i : a)
d[i]++;
var t = new int[6];
var tt = new int[6];
for (int i = 0; i < m; i++) {
int ii = i;
for (int jjj = 0; jjj < 6; jjj++) {
tt[jjj] = ii % 10;
ii /= 10;
}
for (int j = 1; j < 64; j++) {
int jj = j;
boolean fu = false;
t = tt.clone();
for (int k = 0; k < 6; k++) {
if ((jj & 1) == 1) {
t[k]--;
fu ^= true;
}
jj >>= 1;
}
var yes = true;
for (int k : t)
yes &= k != -1;
if (!yes)
continue;
int to = 0;
for (int k = 5; k >= 0; k--) {
to *= 10;
to += t[k];
}
if (fu)
d[i] += d[to];
else
d[i] -= d[to];
}
}
for (int i : a) {
int j = m - i - 1;
ans += d[j];
}
ou.println(ans / 2);
}
public static void main(String[] args) {
solve();
ou.flush();
}
private static final ContestScanner sc = new ContestScanner(System.in);
private static final ContestPrinter ou = new ContestPrinter(System.out);
}
final class ContestScanner {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
public ContestScanner(InputStream in) {
this.in = in;
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen)
return true;
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
return buflen > 0;
}
private int readByte() {
return hasNextByte() ? buffer[ptr++] : -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 void nextThrow(int n) {
for (int i = 0; i < n; i++)
this.next();
}
public void nextThrow() {
this.nextThrow(1);
}
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 boolean[] nextBoolean(char True) {
String s = this.next();
int n = s.length();
boolean[] array = new boolean[n];
for (int i = 0; i < n; i++)
array[i] = s.charAt(i) == True;
return array;
}
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 long[] nextLongArray(int length, long[] a) {
long[] array = new long[length + a.length];
for (int i = 0; i < length; i++)
array[i] = this.nextLong();
for (int i = length; i < array.length; i++)
array[i] = a[i - length];
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 int[] nextIntArray(int length, int[] array) {
int n = length + array.length;
int[] a = new int[n];
for (int i = 0; i < length; i++)
a[i] = this.nextInt();
for (int i = length; i < n; i++)
a[i] = array[i - length];
return a;
}
public Integer[] nextIntegerArray(int length, java.util.function.IntUnaryOperator map) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++)
array[i] = map.applyAsInt(this.nextInt());
return array;
}
public Integer[] nextIntegerArray(int length) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++)
array[i] = 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 String[] nextArray(int length) {
String[] array = new String[length];
for (int i = 0; i < length; i++)
array[i] = this.next();
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 long[][] nextLongMatrix(int height, int width, java.util.function.LongUnaryOperator map) {
long[][] mat = new long[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++)
mat[h][w] = map.applyAsLong(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 int[][] nextIntMatrix(int height, int width, java.util.function.IntUnaryOperator map) {
int[][] mat = new int[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++)
mat[h][w] = map.applyAsInt(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 boolean[][] nextBooleanMatrix(int height, int width, char True) {
boolean[][] mat = new boolean[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) == True;
}
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;
}
}
final 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/arc136_d/Java/29752611 |
condefects-java_data_1183 | 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);
Ex_OptimalPathDecomposition solver = new Ex_OptimalPathDecomposition();
solver.solve(1, in, out);
out.close();
}
static class Ex_OptimalPathDecomposition {
Graph g;
int k;
final int infinity = (int) 1e9;
public void solve(int testNumber, FastScanner in, PrintWriter out) {
int n = in.nextInt();
g = new Graph(n);
for (int i = 0; i < n - 1; i++) {
int a = in.nextInt() - 1;
int b = in.nextInt() - 1;
g.addEdge(a, b);
g.addEdge(b, a);
}
int l = 0;
int r = 20;
while (r - l > 1) {
int m = (l + r) / 2;
k = m;
int[] d = dfs(0, -1);
if (Math.min(d[0], Math.min(d[1], d[2])) <= k) {
r = m;
} else {
l = m;
}
}
out.println(r);
}
private int[] dfs(int v, int p) {
// d[i] = i children match root's color
int[] d = new int[]{1, infinity, infinity};
for (int e = g.firstEdge[v]; e >= 0; e = g.edgeNxt[e]) {
int u = g.edgeDst[e];
if (u == p) {
continue;
}
int[] f = dfs(u, v);
int[] nd = new int[]{infinity, infinity, infinity};
// match
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (d[x] + f[y] > k + 1) {
continue;
}
nd[x + 1] = Math.min(nd[x + 1], Math.max(d[x], f[y]));
}
}
// don't match
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (d[x] + f[y] > k) {
continue;
}
nd[x] = Math.min(nd[x], f[y] + 1);
}
}
d = nd;
}
return d;
}
class Graph {
int n;
int[] firstEdge;
int[] edgeDst;
int[] edgeNxt;
int numEdges;
Graph(int n) {
this.n = n;
firstEdge = new int[n];
Arrays.fill(firstEdge, -1);
final int initialCapacity = 2 * n - 2;
edgeDst = new int[initialCapacity];
edgeNxt = new int[initialCapacity];
numEdges = 0;
}
void addEdge(int a, int b) {
int e = numEdges++;
if (e >= edgeDst.length) {
reallocate();
}
edgeDst[e] = b;
edgeNxt[e] = firstEdge[a];
firstEdge[a] = e;
}
private void reallocate() {
int k = edgeDst.length;
edgeDst = Arrays.copyOf(edgeDst, 3 * k / 2);
edgeNxt = Arrays.copyOf(edgeNxt, 3 * k / 2);
}
}
}
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);
Ex_OptimalPathDecomposition solver = new Ex_OptimalPathDecomposition();
solver.solve(1, in, out);
out.close();
}
static class Ex_OptimalPathDecomposition {
Graph g;
int k;
final int infinity = (int) 1e9;
public void solve(int testNumber, FastScanner in, PrintWriter out) {
int n = in.nextInt();
g = new Graph(n);
for (int i = 0; i < n - 1; i++) {
int a = in.nextInt() - 1;
int b = in.nextInt() - 1;
g.addEdge(a, b);
g.addEdge(b, a);
}
int l = 0;
int r = 20;
while (r - l > 1) {
int m = (l + r) / 2;
k = m;
int[] d = dfs(0, -1);
if (Math.min(d[0], Math.min(d[1], d[2])) <= k) {
r = m;
} else {
l = m;
}
}
out.println(r);
}
private int[] dfs(int v, int p) {
// d[i] = i children match root's color
int[] d = new int[]{1, infinity, infinity};
for (int e = g.firstEdge[v]; e >= 0; e = g.edgeNxt[e]) {
int u = g.edgeDst[e];
if (u == p) {
continue;
}
int[] f = dfs(u, v);
int[] nd = new int[]{infinity, infinity, infinity};
// match
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (d[x] + f[y] > k + 1) {
continue;
}
nd[x + 1] = Math.min(nd[x + 1], Math.max(d[x], f[y]));
}
}
// don't match
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (d[x] + f[y] > k) {
continue;
}
nd[x] = Math.min(nd[x], Math.max(d[x], f[y] + 1));
}
}
d = nd;
}
return d;
}
class Graph {
int n;
int[] firstEdge;
int[] edgeDst;
int[] edgeNxt;
int numEdges;
Graph(int n) {
this.n = n;
firstEdge = new int[n];
Arrays.fill(firstEdge, -1);
final int initialCapacity = 2 * n - 2;
edgeDst = new int[initialCapacity];
edgeNxt = new int[initialCapacity];
numEdges = 0;
}
void addEdge(int a, int b) {
int e = numEdges++;
if (e >= edgeDst.length) {
reallocate();
}
edgeDst[e] = b;
edgeNxt[e] = firstEdge[a];
firstEdge[a] = e;
}
private void reallocate() {
int k = edgeDst.length;
edgeDst = Arrays.copyOf(edgeDst, 3 * k / 2);
edgeNxt = Arrays.copyOf(edgeNxt, 3 * k / 2);
}
}
}
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/abc293_h/Java/39714449 |
condefects-java_data_1184 | import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
int n = in.nextInt();
String s = in.next();
int [] w = in.IntArray(n);
ArrayList<Integer> zero = new ArrayList<>();
ArrayList<Integer> one = new ArrayList<>();
ArrayList<Integer> all = new ArrayList<>();
for(int i = 0 ; i < n ; i ++ ) {
if(s.charAt(i) == '0') zero.add(w[i]);
else one.add(w[i]);
all.add(w[i]);
}
Collections.sort(zero);
Collections.sort(one);
int ans = 0;
// 30 40 45 60 80
// 30 60 80
// 40 45
for(int i = 0 ; i < n ; i ++ ) {
int base = all.get(i);
ans = Math.max(upper_bound(zero,base)+(one.size()-lower_bound(one,base+1)),ans);
}
out.print(ans);
}
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}/*
* upper_bound O(logN)
* keyより大きいインデックスを返します。
*/
int upper_bound(int [] A , int key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(long [] A , long key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Integer> A , int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Long> A , long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
/*
* lower_bound O(logN)
* key以下のインデックスを返します。
*/
int lower_bound(int [] A , int key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(long [] A , long key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(ArrayList<Integer> A, int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(ArrayList<Long> A, long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
}
class Pair{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
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();
}
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();
}
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();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
import java.util.*;
import java.io.*;
class Main{
void solve(PrintWriter out, In in) {
int n = in.nextInt();
String s = in.next();
int [] w = in.IntArray(n);
ArrayList<Integer> zero = new ArrayList<>();
ArrayList<Integer> one = new ArrayList<>();
ArrayList<Integer> all = new ArrayList<>();
for(int i = 0 ; i < n ; i ++ ) {
if(s.charAt(i) == '0') zero.add(w[i]);
else one.add(w[i]);
all.add(w[i]);
}
Collections.sort(zero);
Collections.sort(one);
int ans = 0;
// 30 40 45 60 80
// 30 60 80
// 40 45
for(int i = 0 ; i < n ; i ++ ) {
int base = all.get(i);
ans = Math.max(upper_bound(zero,base)+(one.size()-lower_bound(one,base+1)),ans);
}
ans = Math.max(ans,zero.size());
ans = Math.max(ans,one.size());
out.print(ans);
}
public static void main(String[] args) {
PrintWriter out = new PrintWriter(System.out);
In in = new In();
new Main().solve(out,in);
out.flush();
}/*
* upper_bound O(logN)
* keyより大きいインデックスを返します。
*/
int upper_bound(int [] A , int key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(long [] A , long key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Integer> A , int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
int upper_bound(ArrayList<Long> A , long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) <= key) left = mid + 1;
else right = mid;
}
return right;
}
/*
* lower_bound O(logN)
* key以下のインデックスを返します。
*/
int lower_bound(int [] A , int key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(long [] A , long key) {
int left = 0;
int right = A.length;
while(left < right) {
int mid = (left + right) / 2;
if(A[mid] < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(ArrayList<Integer> A, int key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
int lower_bound(ArrayList<Long> A, long key) {
int left = 0;
int right = A.size();
while(left < right) {
int mid = (left + right) / 2;
if(A.get(mid) < key) left = mid + 1;
else right = mid;
}
return right;
}
}
class Pair{
private int first ;
private int second;
Pair(int first,int second) {
this.first = first;
this.second = second;
}
int first() { return this.first ; }
int second() { return this.second; }
@Override
public String toString(){ return first()+" = "+second(); }
}
class PairII {
private int first ;
private int second ;
private int third;
PairII(int first, int second, int third) {
this.first = first;
this.second = second;
this.third = third;
}
int first() { return this.first ; }
int second() { return this.second; }
int third() { return this.third ; }
@Override
public String toString(){ return first()+" = "+second()+" = "+third() ; }
}
class In{
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();
}
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();
}
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();
}
}
int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
double nextDouble() {
return Double.parseDouble(next());
}
int [] IntArray(int n) {
final int [] Array = new int [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextInt();
}
return Array;
}
int [][] IntArray(int n , int m) {
final int [][] Array = new int [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = IntArray(m);
}
return Array;
}
long [] LongArray(int n) {
final long [] Array = new long [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = nextLong();
}
return Array;
}
long [][] LongArray(int n , int m) {
final long [][] Array = new long [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = LongArray(m);
}
return Array;
}
String [] StringArray(int n) {
final String [] Array = new String [n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next();
}
return Array;
}
char [] CharArray(int n) {
final char [] Array = new char[n];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().charAt(0);
}
return Array;
}
char [][] CharArray(int n , int m) {
final char [][] Array = new char [n][m];
for(int i = 0 ; i < n ; i ++ ) {
Array[i] = next().toCharArray();
}
return Array;
}
}
| ConDefects/ConDefects/Code/abc257_c/Java/41518900 |
condefects-java_data_1185 | import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int[] weight = new int[n];
ArrayList<Integer> child = new ArrayList<>();
ArrayList<Integer> adult = new ArrayList<>();
for(int i = 0;i < n;i++) {
weight[i] = Integer.parseInt(sc.next());
if(s.charAt(i) == '0') {
child.add(weight[i]);
}else {
adult.add(weight[i]);
}
}Collections.sort(child,Collections.reverseOrder());
Collections.sort(adult,Collections.reverseOrder());
int cnum = child.size();
int anum = adult.size();
int ans = 0;
if(cnum == 0) {
System.out.print(n);
return;
}
//System.out.println(child);
//System.out.println(adult);
for(int i = 0;i < cnum;i++) {
int p = child.get(i) + 1;
int ind = binarySearch(p,anum,adult);
//System.out.println(p + " " + ind);
ans = Math.max(ans,(cnum - i) + ind + 1);
}
System.out.print(ans);
}public static int binarySearch(int p,int anum,ArrayList<Integer> adult) {
int left = -1;
int right = anum;
while(left < right - 1) {
int mid = (left + right)/2;
if(adult.get(mid) >= p) {
left = mid;
}else {
right = mid;
}
}return left;
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int[] weight = new int[n];
ArrayList<Integer> child = new ArrayList<>();
ArrayList<Integer> adult = new ArrayList<>();
for(int i = 0;i < n;i++) {
weight[i] = Integer.parseInt(sc.next());
if(s.charAt(i) == '0') {
child.add(weight[i]);
}else {
adult.add(weight[i]);
}
}Collections.sort(child,Collections.reverseOrder());
Collections.sort(adult,Collections.reverseOrder());
int cnum = child.size();
int anum = adult.size();
int ans = 0;
if(cnum == 0) {
System.out.print(n);
return;
}
//System.out.println(child);
//System.out.println(adult);
for(int i = 0;i < cnum;i++) {
int p = child.get(i) + 1;
int ind = binarySearch(p,anum,adult);
//System.out.println(p + " " + ind);
ans = Math.max(ans,(cnum - i) + ind + 1);
}ans = Math.max(ans, anum);
System.out.print(ans);
}public static int binarySearch(int p,int anum,ArrayList<Integer> adult) {
int left = -1;
int right = anum;
while(left < right - 1) {
int mid = (left + right)/2;
if(adult.get(mid) >= p) {
left = mid;
}else {
right = mid;
}
}return left;
}
} | ConDefects/ConDefects/Code/abc257_c/Java/45798480 |
condefects-java_data_1186 | 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();
char[] s = next().toCharArray();
int[] w = nextIntArray(n);
int adultNum = 0;
List<Person> list = new ArrayList<>();
for (int i=0; i<n; i++) {
if (s[i] == '1') adultNum++;
list.add(new Person(s[i]=='1'?true:false, w[i]));
}
list.sort(Comparator.comparing(Person::getWeight, Comparator.naturalOrder()));
int ans = 0;
int score = adultNum;
for (int i=0; i<n; i++) {
if (list.get(i).isAdult == true) score -= 1;
else score += 1;
if (i == n-1) {
ans = Math.max(ans, score);
}
else {
if (list.get(i).weight != list.get(i+1).weight) {
ans = Math.max(ans, score);
}
}
}
println(ans);
}
public static class Person {
boolean isAdult;
int weight;
Person (boolean isAdult, int weight) {
this.isAdult = isAdult;
this.weight = weight;
}
int getWeight() {return this.weight;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) {
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
public static String yesno(boolean b) {return b ? "Yes" : "No";}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
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 printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
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();
char[] s = next().toCharArray();
int[] w = nextIntArray(n);
int adultNum = 0;
List<Person> list = new ArrayList<>();
for (int i=0; i<n; i++) {
if (s[i] == '1') adultNum++;
list.add(new Person(s[i]=='1'?true:false, w[i]));
}
list.sort(Comparator.comparing(Person::getWeight, Comparator.naturalOrder()));
int ans = adultNum;
int score = adultNum;
for (int i=0; i<n; i++) {
if (list.get(i).isAdult == true) score -= 1;
else score += 1;
if (i == n-1) {
ans = Math.max(ans, score);
}
else {
if (list.get(i).weight != list.get(i+1).weight) {
ans = Math.max(ans, score);
}
}
}
println(ans);
}
public static class Person {
boolean isAdult;
int weight;
Person (boolean isAdult, int weight) {
this.isAdult = isAdult;
this.weight = weight;
}
int getWeight() {return this.weight;}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// useful methods, useful fields, useful static inner class
/////////////////////////////////////////////////////////////////////////////////////////////////
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
public static class Edge {
int id, from, to, cost;
Edge(int to, int cost) {
this.to = to;
this.cost = cost;
}
Edge(int from, int to, int cost) {
this.from = from;
this.to = to;
this.cost = cost;
}
Edge(int id, int from, int to, int cost) {
this.id = id;
this.from = from;
this.to = to;
this.cost = cost;
}
int getCost() {return this.cost;}
}
public static String yesno(boolean b) {return b ? "Yes" : "No";}
/////////////////////////////////////////////////////////////////////////////////////////////////
// input
/////////////////////////////////////////////////////////////////////////////////////////////////
public static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 32768);
public static StringTokenizer tokenizer = null;
public static String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public static String[] nextArray(int n) {
String[] a = new String[n];
for (int i=0; i<n; i++) a[i] = next();
return a;
}
public static int nextInt() {return Integer.parseInt(next());};
public static int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i=0; i<n; i++) a[i] = nextInt();
return a;
}
public static int[][] nextIntTable(int n, int m) {
int[][] a = new int[n][m];
for (int i=0; i<n; i++) {
for (int j=0; j<m; j++) a[i][j] = nextInt();
}
return a;
}
public static long nextLong() {return Long.parseLong(next());}
public static long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i=0; i<n; i++) a[i] = nextLong();
return a;
}
public static double nextDouble() {return Double.parseDouble(next());}
public static char nextChar() {return next().charAt(0);}
public static char[] nextCharArray() {return next().toCharArray();}
public static char[][] nextCharTable(int n, int m) {
char[][] a = new char[n][m];
for (int i=0; i<n; i++) {
a[i] = next().toCharArray();
}
return a;
}
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 printLongArray(long[] a) {
for (int i=0; i<a.length; i++) {
if (i != 0) print(" ");
print(a[i]);
}
println("");
}
public static void printBooleanArray (boolean[] a) {
for (int i=0; i<a.length; i++) {
char c = a[i]==true? 'o' : 'x';
print(c);
}
println("");
}
public static void printCharTable(char[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]);
}
println("");
}
}
public static void printIntTable(int[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
public static void printBooleanTable(boolean[][] b) {
for (int i=0; i<b.length; i++) {
for (int j=0; j<b[0].length; j++) {
print(b[i][j]? "o" : "x");
}
println("");
}
}
public static void printLongTable(long[][] a) {
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[0].length; j++) {
print(a[i][j]==-infl? "# " : a[i][j]+" ");
}
println("");
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// main method
/////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc257_c/Java/39161207 |
condefects-java_data_1187 | import java.io.*;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static Scanner in = new Scanner(System.in);
static BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" "); int a = Integer.parseInt(strs[0]);
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" ");
//int T=Integer.parseInt(strs[0]);
//int T=in.nextInt();
int T=1;
while(T>0){
//String[] strs1 = re.readLine().split(" ");
//int n=Integer.parseInt(strs1[0]);
//String s=re.readLine();
//char arr[]=s.toCharArray();
//Set<Integer>set=new HashSet<>();
//Map<Long,Integer>map=new HashMap<>();26
//abcdefghijklmnopqrstuvwxyz
//Map<Integer,List<Integer>>map=new HashMap<>();
//TreeSet<Integer> set = new TreeSet<>();
//int max=0;int min=2100000000;
int n=in.nextInt();
int m=in.nextInt();
int arr[][]=new int [n][2];
int max=0;int res=0;
int t=0;
for(int i=0;i<n;i++){
arr[i][0]=in.nextInt();
if(arr[i][0]==m)t++;
}
for(int i=0;i<n;i++){
arr[i][1]=in.nextInt();
}
if(t!=0){
for(int i=0;i<n;i++){
if(arr[i][0]==m&&arr[i][1]>max){
max=arr[i][1];res=i+1;
}
}
}
else{
m=arr[0][0];
for(int i=0;i<n;i++){
if(arr[i][1]>max){
max=arr[i][1];res=i+1;
}
}
}
out.println(res);
T--;
}
out.flush();
}
}
import java.io.*;
import java.util.*;
public class Main {
static PrintWriter out = new PrintWriter(System.out);
static Scanner in = new Scanner(System.in);
static BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
static BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" "); int a = Integer.parseInt(strs[0]);
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//String[] strs = re.readLine().split(" ");
//int T=Integer.parseInt(strs[0]);
//int T=in.nextInt();
int T=1;
while(T>0){
//String[] strs1 = re.readLine().split(" ");
//int n=Integer.parseInt(strs1[0]);
//String s=re.readLine();
//char arr[]=s.toCharArray();
//Set<Integer>set=new HashSet<>();
//Map<Long,Integer>map=new HashMap<>();26
//abcdefghijklmnopqrstuvwxyz
//Map<Integer,List<Integer>>map=new HashMap<>();
//TreeSet<Integer> set = new TreeSet<>();
//int max=0;int min=2100000000;
int n=in.nextInt();
int m=in.nextInt();
int arr[][]=new int [n][2];
int max=0;int res=0;
int t=0;
for(int i=0;i<n;i++){
arr[i][0]=in.nextInt();
if(arr[i][0]==m)t++;
}
for(int i=0;i<n;i++){
arr[i][1]=in.nextInt();
}
if(t!=0){
for(int i=0;i<n;i++){
if(arr[i][0]==m&&arr[i][1]>max){
max=arr[i][1];res=i+1;
}
}
}
else{
m=arr[0][0];
for(int i=0;i<n;i++){
if(arr[i][0]==m&&arr[i][1]>max){
max=arr[i][1];res=i+1;
}
}
}
out.println(res);
T--;
}
out.flush();
}
} | ConDefects/ConDefects/Code/abc299_b/Java/42074031 |
condefects-java_data_1188 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
int t = Integer.parseInt(sc.next());
int[] c = new int[n];
int[] r = new int[n];
boolean flag = false;
for (int i = 0; i < n; i++) {
c[i] = Integer.parseInt(sc.next());
if (c[i] == t)
flag = true;
}
for (int i = 0; i < n; i++) {
r[i] = Integer.parseInt(sc.next());
}
sc.close();
if (flag) {
int max = 0;
int result = 0;
for (int i = 0; i < n; i++) {
if (c[i] == t && max < r[i]) {
result = i + 1;
max = r[i];
}
}
System.out.println(result);
} else {
int false_max = r[0];
int faluse_result = 0;
for (int i = 0; i < n; i++) {
if (c[0] == c[i] && false_max < r[i]) {
faluse_result = i + 1;
false_max = r[i];
}
}
System.out.println(faluse_result);
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = Integer.parseInt(sc.next());
int t = Integer.parseInt(sc.next());
int[] c = new int[n];
int[] r = new int[n];
boolean flag = false;
for (int i = 0; i < n; i++) {
c[i] = Integer.parseInt(sc.next());
if (c[i] == t)
flag = true;
}
for (int i = 0; i < n; i++) {
r[i] = Integer.parseInt(sc.next());
}
sc.close();
if (flag) {
int max = 0;
int result = 0;
for (int i = 0; i < n; i++) {
if (c[i] == t && max < r[i]) {
result = i + 1;
max = r[i];
}
}
System.out.println(result);
} else {
int false_max = r[0];
int faluse_result = 1;
for (int i = 0; i < n; i++) {
if (c[0] == c[i] && false_max < r[i]) {
faluse_result = i + 1;
false_max = r[i];
}
}
System.out.println(faluse_result);
}
}
} | ConDefects/ConDefects/Code/abc299_b/Java/42837627 |
condefects-java_data_1189 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int T = sc.nextInt();
int[] C = new int[N];
for (int i = 0; i < N; i++) {
C[i] = sc.nextInt();
}
int[] R = new int[N];
for (int i = 0; i < N; i++) {
R[i] = sc.nextInt();
}
int max = 0;
int maxI = 0;
for (int i = 0; i < N; i++) {
if (C[i] == T && R[i] > max) {
max = R[i];
maxI = i;
}
}
if (max == 0) {
for (int i = 0; i < N; i++) {
if (C[i] == C[0] && R[i] > max) {
max = R[i];
maxI = i;
}
}
}
System.out.println(maxI);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int T = sc.nextInt();
int[] C = new int[N];
for (int i = 0; i < N; i++) {
C[i] = sc.nextInt();
}
int[] R = new int[N];
for (int i = 0; i < N; i++) {
R[i] = sc.nextInt();
}
int max = 0;
int maxI = 0;
for (int i = 0; i < N; i++) {
if (C[i] == T && R[i] > max) {
max = R[i];
maxI = i;
}
}
if (max == 0) {
for (int i = 0; i < N; i++) {
if (C[i] == C[0] && R[i] > max) {
max = R[i];
maxI = i;
}
}
}
System.out.println(maxI + 1);
}
} | ConDefects/ConDefects/Code/abc299_b/Java/41505924 |
condefects-java_data_1190 | import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
Kattio io = new Kattio();
int n = io.nextInt(), t = io.nextInt();
int[] c = new int[n + 1], r = new int[n + 1];
for (int i = 1; i <= n; i++) c[i] = io.nextInt();
for (int i = 1; i <= n; i++) r[i] = io.nextInt();
int ans = 0;
for (int i = 1; i <= n; i++) {
if (c[i] == t) {
if (r[i] > r[ans] || ans == 0) ans = i;
}
}
if (ans != 0) io.println(ans);
else {
for (int i = 1; i <= n; i++) {
if (r[i] > r[ans]) ans = i;
}
io.println(ans);
}
io.close();
}
private static class Kattio extends PrintWriter {
private BufferedReader br;
private StringTokenizer st;
private String line, token;
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
br = new BufferedReader(new InputStreamReader(i));
}
public boolean hasMoreTokens() {
return peekToken() != null;
}
public String next() {
return nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
private String peekToken() {
if (token == null)
try {
while (st == null || !st.hasMoreTokens()) {
line = br.readLine();
if (line == null) return null;
st = new StringTokenizer(line);
}
token = st.nextToken();
} catch (IOException e) {
}
return token;
}
private String nextToken() {
String ans = peekToken();
token = null;
return ans;
}
}
}
import java.util.*;
import java.io.*;
public class Main {
public static void main(String[] args) {
Kattio io = new Kattio();
int n = io.nextInt(), t = io.nextInt();
int[] c = new int[n + 1], r = new int[n + 1];
for (int i = 1; i <= n; i++) c[i] = io.nextInt();
for (int i = 1; i <= n; i++) r[i] = io.nextInt();
int ans = 0;
for (int i = 1; i <= n; i++) {
if (c[i] == t) {
if (r[i] > r[ans] || ans == 0) ans = i;
}
}
if (ans != 0) io.println(ans);
else {
for (int i = 1; i <= n; i++) {
if (c[i] == c[1] && r[i] > r[ans]) ans = i;
}
io.println(ans);
}
io.close();
}
private static class Kattio extends PrintWriter {
private BufferedReader br;
private StringTokenizer st;
private String line, token;
public Kattio() {
this(System.in, System.out);
}
public Kattio(InputStream i, OutputStream o) {
super(o);
br = new BufferedReader(new InputStreamReader(i));
}
public boolean hasMoreTokens() {
return peekToken() != null;
}
public String next() {
return nextToken();
}
public int nextInt() {
return Integer.parseInt(nextToken());
}
public double nextDouble() {
return Double.parseDouble(nextToken());
}
public long nextLong() {
return Long.parseLong(nextToken());
}
private String peekToken() {
if (token == null)
try {
while (st == null || !st.hasMoreTokens()) {
line = br.readLine();
if (line == null) return null;
st = new StringTokenizer(line);
}
token = st.nextToken();
} catch (IOException e) {
}
return token;
}
private String nextToken() {
String ans = peekToken();
token = null;
return ans;
}
}
} | ConDefects/ConDefects/Code/abc299_b/Java/43053765 |
condefects-java_data_1191 |
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int times = sc.nextInt();
long[][] num = new long[n][2];
for (int i = 0; i < n; i++) {
num[i][0] = sc.nextInt();
num[i][1] = sc.nextInt();
}
int tempn = times - 1;
BigInteger sumai = new BigInteger("0");
BigInteger res = null;
for (int i = 0; i < n; i++) {
if (times == -1)
continue;
sumai = sumai.add(new BigInteger(num[i][0]+"")).add(new BigInteger(num[i][1]+""));
//res = 前ai、bi项求和+(times-i)*bi;i为第i关
BigInteger bi = sumai.add(new BigInteger(num[i][1]+"").multiply(new BigInteger(tempn+"")));
tempn--;
//赋初值
if(i == 0) {
res = bi;
}else//获取较小值
if (res.compareTo(bi) > 0)
res = bi;
}
System.out.println(res);
}
}
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int times = sc.nextInt();
long[][] num = new long[n][2];
for (int i = 0; i < n; i++) {
num[i][0] = sc.nextInt();
num[i][1] = sc.nextInt();
}
int tempn = times - 1;
BigInteger sumai = new BigInteger("0");
BigInteger res = null;
for (int i = 0; i < n; i++) {
if (tempn == -1)
continue;
sumai = sumai.add(new BigInteger(num[i][0]+"")).add(new BigInteger(num[i][1]+""));
//res = 前ai、bi项求和+(times-i)*bi;i为第i关
BigInteger bi = sumai.add(new BigInteger(num[i][1]+"").multiply(new BigInteger(tempn+"")));
tempn--;
//赋初值
if(i == 0) {
res = bi;
}else//获取较小值
if (res.compareTo(bi) > 0)
res = bi;
}
System.out.println(res);
}
}
| ConDefects/ConDefects/Code/abc258_d/Java/37716190 |
condefects-java_data_1192 | import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// ステージ数
int n = sc.nextInt();
// 目標クリア回数
long x = sc.nextInt();
// 最小クリアタイム
long mint = 0;
// 累計必要時間
long needt = 0;
// 全ステージを検証
for (int i=0; i<n; i++)
{
// このステージのムービー時間
int m = sc.nextInt();
// このステージのプレイ時間
int p = sc.nextInt();
// このステージを周回した場合の目標達成時間
long t = needt + m + p * (x - i);
// 最小時間を更新
if (i == 0)
{
mint = t;
}
else
{
mint = Math.min(mint, t);
}
// 累計必要時間を更新
needt += m + p;
}
System.out.println(mint);
}
}
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// ステージ数
int n = sc.nextInt();
// 目標クリア回数
long x = sc.nextInt();
// 最小クリアタイム
long mint = 0;
// 累計必要時間
long needt = 0;
// 全ステージを検証
for (int i=0; i<n && i<x; i++)
{
// このステージのムービー時間
int m = sc.nextInt();
// このステージのプレイ時間
int p = sc.nextInt();
// このステージを周回した場合の目標達成時間
long t = needt + m + p * (x - i);
// 最小時間を更新
if (i == 0)
{
mint = t;
}
else
{
mint = Math.min(mint, t);
}
// 累計必要時間を更新
needt += m + p;
}
System.out.println(mint);
}
}
| ConDefects/ConDefects/Code/abc258_d/Java/46157583 |
condefects-java_data_1193 | import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.*;
class Solver{
long 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";
long elapsed(){ return System.currentTimeMillis() -st; }
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int X = in.it();
long[][] T = in.lg(N,2);
Object solve(){
long ans = infL;
int cleared = 0;
long sum = 0;
long minB = infL;
for (var t:T) {
sum += t[0] +t[1];
cleared++;
minB = Math.min(minB,t[1]);
ans = Math.min(ans,sum +minB *(X -cleared));
}
return ans;
}
}
class Util{
static int[][] trans(int[]... T){ return arr(new int[T[0].length][],i -> arrI(T.length,j -> T[j][i])); }
static long[][] trans(long[]... T){ return arr(new long[T[0].length][],i -> arrL(T.length,j -> T[j][i])); }
static double[][] trans(double[]... T){ return arr(new double[T[0].length][],i -> arrD(T.length,j -> T[j][i])); }
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
Arrays.setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
Arrays.setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
Arrays.setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
Arrays.setAll(arr,f);
return arr;
}
}
class Edge{
int id;
int u;
int v;
long l;
Edge rev;
Edge(int id,int u,int v){
this.id = id;
this.u = u;
this.v = v;
}
void rev(Edge rev){ rev.l = l; }
}
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());
}
}
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 Math.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()); }
Edge[] e(int N,int M){ return e(N,M,e -> e.l = 1); }
Edge[] e(int N,int M,Consumer<Edge> f){
return Util.arr(new Edge[M],i -> {
Edge e = new Edge(i,idx(),idx());
f.accept(e);
return e;
});
}
Edge[][] g(int N,int M,boolean b){ return g(N,b,e(N,M)); }
Edge[][] g(int N,int M,boolean b,Consumer<Edge> f){ return g(N,b,e(N,M,f)); }
Edge[][] g(int N,boolean b,Edge[] E){
int[] c = new int[N];
for (var e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (var e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
var rev = new Edge(e.id,e.v,e.u);
e.rev(rev);
g[e.v][--c[e.v]] = e.rev = rev;
}
}
return g;
}
}
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();
}
}
private void sp(){ write((byte) ' '); }
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 write(Object obj){
if (obj instanceof Boolean)
write((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);
boolean ln = false;
if (0 < l) {
Object a = Array.get(obj,0);
ln = !(a instanceof char[]) && a.getClass().isArray();
}
for (int i = 0;i < l;i++) {
write(Array.get(obj,i));
if (i +1 < l)
if (ln)
ln();
else
sp();
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
write(obj);
ln();
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.*;
class Solver{
long 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";
long elapsed(){ return System.currentTimeMillis() -st; }
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int X = in.it();
long[][] T = in.lg(N,2);
Object solve(){
long ans = infL *4;
int cleared = 0;
long sum = 0;
long minB = infL;
for (var t:T) {
sum += t[0] +t[1];
cleared++;
minB = Math.min(minB,t[1]);
ans = Math.min(ans,sum +minB *(X -cleared));
}
return ans;
}
}
class Util{
static int[][] trans(int[]... T){ return arr(new int[T[0].length][],i -> arrI(T.length,j -> T[j][i])); }
static long[][] trans(long[]... T){ return arr(new long[T[0].length][],i -> arrL(T.length,j -> T[j][i])); }
static double[][] trans(double[]... T){ return arr(new double[T[0].length][],i -> arrD(T.length,j -> T[j][i])); }
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
Arrays.setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
Arrays.setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
Arrays.setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
Arrays.setAll(arr,f);
return arr;
}
}
class Edge{
int id;
int u;
int v;
long l;
Edge rev;
Edge(int id,int u,int v){
this.id = id;
this.u = u;
this.v = v;
}
void rev(Edge rev){ rev.l = l; }
}
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());
}
}
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 Math.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()); }
Edge[] e(int N,int M){ return e(N,M,e -> e.l = 1); }
Edge[] e(int N,int M,Consumer<Edge> f){
return Util.arr(new Edge[M],i -> {
Edge e = new Edge(i,idx(),idx());
f.accept(e);
return e;
});
}
Edge[][] g(int N,int M,boolean b){ return g(N,b,e(N,M)); }
Edge[][] g(int N,int M,boolean b,Consumer<Edge> f){ return g(N,b,e(N,M,f)); }
Edge[][] g(int N,boolean b,Edge[] E){
int[] c = new int[N];
for (var e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (var e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
var rev = new Edge(e.id,e.v,e.u);
e.rev(rev);
g[e.v][--c[e.v]] = e.rev = rev;
}
}
return g;
}
}
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();
}
}
private void sp(){ write((byte) ' '); }
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 write(Object obj){
if (obj instanceof Boolean)
write((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);
boolean ln = false;
if (0 < l) {
Object a = Array.get(obj,0);
ln = !(a instanceof char[]) && a.getClass().isArray();
}
for (int i = 0;i < l;i++) {
write(Array.get(obj,i));
if (i +1 < l)
if (ln)
ln();
else
sp();
}
} else
for (char b:Objects.toString(obj).toCharArray())
write((byte) b);
}
void println(Object obj){
if (obj == null)
return;
write(obj);
ln();
}
} | ConDefects/ConDefects/Code/abc258_d/Java/40124353 |
condefects-java_data_1194 | import com.sun.source.tree.WhileLoopTree;
import java.io.*;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
int n = in.nextInt();
long x = in.nextLong();
long[] a = new long[n];
long[] b = new long[n];
long[] sum = new long[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextLong();
b[i] = in.nextLong();
if(i == 0){
sum[i] = a[i] + b[i];
}else{
sum[i] = sum[i-1] + a[i] + b[i];
}
}
long ans = a[0] + x * b[0];
for (int i = 0; i < n; i++) {
ans = Math.min(ans,sum[i] + (x-i-1) * b[i]);
}
out.println(ans);
}
long lcm(long a,long b){
return a / gcd(a,b) * b;
}
long gcd(long a,long b){
return b == 0 ? a : gcd(b,a%b);
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class IntPair{
int f;
int s;
IntPair(int f,int s){
this.f = f;
this.s = s;
}
}
class LongPair{
long f;
long s;
LongPair(long f,long s){
this.f = f;
this.s = s;
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
import com.sun.source.tree.WhileLoopTree;
import java.io.*;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353;
void solve() {
int n = in.nextInt();
long x = in.nextLong();
long[] a = new long[n];
long[] b = new long[n];
long[] sum = new long[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextLong();
b[i] = in.nextLong();
if(i == 0){
sum[i] = a[i] + b[i];
}else{
sum[i] = sum[i-1] + a[i] + b[i];
}
}
long ans = a[0] + x * b[0];
for (int i = 0; i < Math.min(n,x); i++) {
ans = Math.min(ans,sum[i] + (x-i-1) * b[i]);
}
out.println(ans);
}
long lcm(long a,long b){
return a / gcd(a,b) * b;
}
long gcd(long a,long b){
return b == 0 ? a : gcd(b,a%b);
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class IntPair{
int f;
int s;
IntPair(int f,int s){
this.f = f;
this.s = s;
}
}
class LongPair{
long f;
long s;
LongPair(long f,long s){
this.f = f;
this.s = s;
}
}
class FastIn extends In {
private final BufferedInputStream reader = new BufferedInputStream(System.in);
private final byte[] buffer = new byte[0x10000];
private int i = 0;
private int length = 0;
public int read() {
if (i == length) {
i = 0;
try {
length = reader.read(buffer);
} catch (IOException ignored) {
}
if (length == -1) {
return 0;
}
}
if (length <= i) {
throw new RuntimeException();
}
return buffer[i++];
}
String next() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
while ('!' <= b && b <= '~') {
builder.appendCodePoint(b);
b = read();
}
return builder.toString();
}
String nextLine() {
StringBuilder builder = new StringBuilder();
int b = read();
while (b != 0 && b != '\r' && b != '\n') {
builder.appendCodePoint(b);
b = read();
}
if (b == '\r') {
read();
}
return builder.toString();
}
int nextInt() {
long val = nextLong();
if ((int)val != val) {
throw new NumberFormatException();
}
return (int)val;
}
long nextLong() {
int b = read();
while (b < '!' || '~' < b) {
b = read();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = read();
}
long n = 0;
int c = 0;
while ('0' <= b && b <= '9') {
n = n * 10 + b - '0';
b = read();
c++;
}
if (c == 0 || c >= 2 && n == 0) {
throw new NumberFormatException();
}
return neg ? -n : n;
}
}
class In {
private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 0x10000);
private StringTokenizer tokenizer;
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
class Out {
private final PrintWriter out = new PrintWriter(System.out);
private final PrintWriter err = new PrintWriter(System.err);
boolean autoFlush = false;
boolean enableDebug;
Out(boolean enableDebug) {
this.enableDebug = enableDebug;
}
void println(Object... args) {
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
out.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
if (autoFlush) {
out.flush();
}
}
void debug(Object... args) {
if (!enableDebug) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == Double.class ? String.format("%.10f", obj) :
clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
err.flush();
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
} | ConDefects/ConDefects/Code/abc258_d/Java/43551820 |
condefects-java_data_1195 |
import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int n = sc.nextInt();
int x = sc.nextInt();
long ans = Long.MAX_VALUE;
long acc = 0;
for (int i = 0; i < n; i++) {
int a = sc.nextInt(), b = sc.nextInt();
acc = acc + a + b;
long left = x - i - 1;
ans = Math.min(ans, acc + left * b);
}
System.out.println(ans);
}
}
import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int n = sc.nextInt();
int x = sc.nextInt();
long ans = Long.MAX_VALUE;
long acc = 0;
for (int i = 0; i < n && i < x; i++) {
int a = sc.nextInt(), b = sc.nextInt();
acc = acc + a + b;
long left = x - i - 1;
ans = Math.min(ans, acc + left * b);
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc258_d/Java/37638220 |
condefects-java_data_1196 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int row = Integer.parseInt(sc.next());
int column = Integer.parseInt(sc.next());
List<String> s = new ArrayList<>();
for (int i = 0; i < row; i++) {
s.add(sc.next());
}
List<Character> c = new ArrayList<>();
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
c.add(s.get(i).charAt(j));
}
}
int vertex = row * column;
List<List<Integer>> graph = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
graph.add(new ArrayList<>());
}
List<Boolean> troutInInfluence = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
troutInInfluence.add(false);
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (c.get(i) == '#') {
if (i == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i + column, true);
} else if (i == column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
} else if (0 < i && i < column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
} else if (i == (row - 1) * column) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - column, true);
} else if (i == row * column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i - column, true);
} else if ((row - 1) * column < i && i < row * column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i - column, true);
} else if (i % column == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
} else if (i % column == column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
} else if (0 < i % column && i % column < column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
}
}
}
} else if (row == 1 && column == 1) {
if (c.get(0) == '#') {
troutInInfluence.set(0, true);
}
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (c.get(i) == '#') {
if (i == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
} else if (i == column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
} else if (0 < i && i < column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (c.get(i) == '#') {
if (i == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + column, true);
} else if (i == row - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - column, true);
} else if (0 < i && i < row - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
}
}
}
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (troutInInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(column + 1);
} else if (i == (row - 1) * column) {
graph.get(i).add(i + 1);
graph.get(i).add(i - column);
} else if (i == row * column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if ((row - 1) * column < i && i < row * column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if (i % column == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (i % column == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (0 < i % column && i % column < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
} else if (row == 1 && column == 1) {
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (troutInInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (troutInInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + column);
} else if (i == row - 1) {
graph.get(i).add(i - column);
} else if (0 < i && i < row - 1) {
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
}
List<Boolean> used = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
used.add(false);
}
List<Integer> last = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
last.add(0);
}
int time = 0;
int ans = 1;
for (int i = 0; i < vertex; i++) {
if (troutInInfluence.get(i) == false) {
if (used.get(i) == true) {
continue;
}
time++;
int cnt = 0;
Queue<Integer> queue = new LinkedList<>();
queue.add(i);
used.set(i, true);
while (!queue.isEmpty()) {
int position = queue.remove();
cnt++;
for (int j = 0; j < graph.get(position).size(); j++) {
int next = graph.get(position).get(j);
if (used.get(next) == true) {
continue;
}
if (troutInInfluence.get(next) == true) {
if (last.get(next) != time) {
cnt++;
last.set(next, time);
}
continue;
}
queue.add(next);
used.set(next, true);
}
}
ans = Math.max(ans, cnt);
}
}
System.out.println(ans);
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int row = Integer.parseInt(sc.next());
int column = Integer.parseInt(sc.next());
List<String> s = new ArrayList<>();
for (int i = 0; i < row; i++) {
s.add(sc.next());
}
List<Character> c = new ArrayList<>();
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
c.add(s.get(i).charAt(j));
}
}
int vertex = row * column;
List<List<Integer>> graph = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
graph.add(new ArrayList<>());
}
List<Boolean> troutInInfluence = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
troutInInfluence.add(false);
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (c.get(i) == '#') {
if (i == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i + column, true);
} else if (i == column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
} else if (0 < i && i < column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
} else if (i == (row - 1) * column) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - column, true);
} else if (i == row * column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i - column, true);
} else if ((row - 1) * column < i && i < row * column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i - column, true);
} else if (i % column == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
} else if (i % column == column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
} else if (0 < i % column && i % column < column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
}
}
}
} else if (row == 1 && column == 1) {
if (c.get(0) == '#') {
troutInInfluence.set(0, true);
}
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (c.get(i) == '#') {
if (i == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
} else if (i == column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - 1, true);
} else if (0 < i && i < column - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + 1, true);
troutInInfluence.set(i - 1, true);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (c.get(i) == '#') {
if (i == 0) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + column, true);
} else if (i == row - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i - column, true);
} else if (0 < i && i < row - 1) {
troutInInfluence.set(i, true);
troutInInfluence.set(i + column, true);
troutInInfluence.set(i - column, true);
}
}
}
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (troutInInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (i == (row - 1) * column) {
graph.get(i).add(i + 1);
graph.get(i).add(i - column);
} else if (i == row * column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if ((row - 1) * column < i && i < row * column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if (i % column == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (i % column == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (0 < i % column && i % column < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
} else if (row == 1 && column == 1) {
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (troutInInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (troutInInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + column);
} else if (i == row - 1) {
graph.get(i).add(i - column);
} else if (0 < i && i < row - 1) {
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
}
List<Boolean> used = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
used.add(false);
}
List<Integer> last = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
last.add(0);
}
int time = 0;
int ans = 1;
for (int i = 0; i < vertex; i++) {
if (troutInInfluence.get(i) == false) {
if (used.get(i) == true) {
continue;
}
time++;
int cnt = 0;
Queue<Integer> queue = new LinkedList<>();
queue.add(i);
used.set(i, true);
while (!queue.isEmpty()) {
int position = queue.remove();
cnt++;
for (int j = 0; j < graph.get(position).size(); j++) {
int next = graph.get(position).get(j);
if (used.get(next) == true) {
continue;
}
if (troutInInfluence.get(next) == true) {
if (last.get(next) != time) {
cnt++;
last.set(next, time);
}
continue;
}
queue.add(next);
used.set(next, true);
}
}
ans = Math.max(ans, cnt);
}
}
System.out.println(ans);
}
}
| ConDefects/ConDefects/Code/abc351_d/Java/53390787 |
condefects-java_data_1197 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int row = Integer.parseInt(sc.next());
int column = Integer.parseInt(sc.next());
List<String> s = new ArrayList<>();
for (int i = 0; i < row; i++) {
s.add(sc.next());
}
List<Character> c = new ArrayList<>();
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
c.add(s.get(i).charAt(j));
}
}
int vertex = row * column;
List<List<Integer>> graph = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
graph.add(new ArrayList<>());
}
List<Boolean> magneticInfluence = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
magneticInfluence.add(i, false);
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (c.get(i) == '#') {
if (i == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i + column, true);
} else if (i == column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
} else if (0 < i && i < column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
} else if (i == (row - 1) * column) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - column, true);
} else if (i == row * column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i - column, true);
} else if ((row - 1) * column < i && i < row * column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i - column, true);
} else if (i % column == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
} else if (i % column == column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
} else if (0 < i % column && i % column < column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
}
}
}
} else if (row == 1 && column == 1) {
if (c.get(0) == '#') {
magneticInfluence.set(0, true);
}
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (c.get(i) == '#') {
if (i == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
} else if (i == column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
} else if (0 < i && i < column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (c.get(i) == '#') {
if (i == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + column, true);
} else if (i == row - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - column, true);
} else if (0 < i && i < row - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
}
}
}
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (magneticInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (i == (row - 1) * column) {
graph.get(i).add(i + 1);
graph.get(i).add(i - column);
} else if (i == row * column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if ((row - 1) * column < i && i < row * column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if (i % column == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (i % column == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (0 < i % column && i % column < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
} else if (row == 1 && column == 1) {
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (magneticInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (magneticInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + column);
} else if (i == row - 1) {
graph.get(i).add(i - column);
} else if (0 < i && i < row - 1) {
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
}
List<Boolean> visited = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
visited.add(i, false);
}
List<Integer> lastTravel = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
lastTravel.add(0);
}
int timeOfTravel = 0;
int answer = 1;
for (int i = 0; i < vertex; i++) {
if (magneticInfluence.get(i) == false) {
if (visited.get(i) == true) {
continue;
}
timeOfTravel++;
int cnt = 0;
Queue<Integer> queue = new LinkedList<>();
queue.add(i);
visited.set(i, true);
while (!queue.isEmpty()) {
int currentPosition = queue.remove();
cnt++;
for (int j = 0; j < graph.get(currentPosition).size(); j++) {
int nextPosition = graph.get(currentPosition).get(j);
if (visited.get(nextPosition) == true) {
continue;
}
if (magneticInfluence.get(i) == true) {
if (lastTravel.get(nextPosition) != timeOfTravel) {
cnt++;
lastTravel.set(nextPosition, timeOfTravel);
}
continue;
}
queue.add(nextPosition);
visited.set(nextPosition, true);
}
}
answer = Math.max(answer, cnt);
}
}
System.out.println(answer);
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int row = Integer.parseInt(sc.next());
int column = Integer.parseInt(sc.next());
List<String> s = new ArrayList<>();
for (int i = 0; i < row; i++) {
s.add(sc.next());
}
List<Character> c = new ArrayList<>();
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
c.add(s.get(i).charAt(j));
}
}
int vertex = row * column;
List<List<Integer>> graph = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
graph.add(new ArrayList<>());
}
List<Boolean> magneticInfluence = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
magneticInfluence.add(i, false);
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (c.get(i) == '#') {
if (i == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i + column, true);
} else if (i == column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
} else if (0 < i && i < column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
} else if (i == (row - 1) * column) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - column, true);
} else if (i == row * column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i - column, true);
} else if ((row - 1) * column < i && i < row * column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i - column, true);
} else if (i % column == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
} else if (i % column == column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
} else if (0 < i % column && i % column < column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
}
}
}
} else if (row == 1 && column == 1) {
if (c.get(0) == '#') {
magneticInfluence.set(0, true);
}
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (c.get(i) == '#') {
if (i == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
} else if (i == column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - 1, true);
} else if (0 < i && i < column - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + 1, true);
magneticInfluence.set(i - 1, true);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (c.get(i) == '#') {
if (i == 0) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + column, true);
} else if (i == row - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i - column, true);
} else if (0 < i && i < row - 1) {
magneticInfluence.set(i, true);
magneticInfluence.set(i + column, true);
magneticInfluence.set(i - column, true);
}
}
}
}
if (row > 1 && column > 1) {
for (int i = 0; i < vertex; i++) {
if (magneticInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
} else if (i == (row - 1) * column) {
graph.get(i).add(i + 1);
graph.get(i).add(i - column);
} else if (i == row * column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if ((row - 1) * column < i && i < row * column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i - column);
} else if (i % column == 0) {
graph.get(i).add(i + 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (i % column == column - 1) {
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
} else if (0 < i % column && i % column < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
} else if (row == 1 && column == 1) {
} else if (row == 1) {
for (int i = 0; i < column; i++) {
if (magneticInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + 1);
} else if (i == column - 1) {
graph.get(i).add(i - 1);
} else if (0 < i && i < column - 1) {
graph.get(i).add(i + 1);
graph.get(i).add(i - 1);
}
}
}
} else if (column == 1) {
for (int i = 0; i < row; i++) {
if (magneticInfluence.get(i) == false) {
if (i == 0) {
graph.get(i).add(i + column);
} else if (i == row - 1) {
graph.get(i).add(i - column);
} else if (0 < i && i < row - 1) {
graph.get(i).add(i + column);
graph.get(i).add(i - column);
}
}
}
}
List<Boolean> visited = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
visited.add(i, false);
}
List<Integer> lastTravel = new ArrayList<>();
for (int i = 0; i < vertex; i++) {
lastTravel.add(0);
}
int timeOfTravel = 0;
int answer = 1;
for (int i = 0; i < vertex; i++) {
if (magneticInfluence.get(i) == false) {
if (visited.get(i) == true) {
continue;
}
timeOfTravel++;
int cnt = 0;
Queue<Integer> queue = new LinkedList<>();
queue.add(i);
visited.set(i, true);
while (!queue.isEmpty()) {
int currentPosition = queue.remove();
cnt++;
for (int j = 0; j < graph.get(currentPosition).size(); j++) {
int nextPosition = graph.get(currentPosition).get(j);
if (visited.get(nextPosition) == true) {
continue;
}
if (magneticInfluence.get(nextPosition) == true) {
if (lastTravel.get(nextPosition) != timeOfTravel) {
cnt++;
lastTravel.set(nextPosition, timeOfTravel);
}
continue;
}
queue.add(nextPosition);
visited.set(nextPosition, true);
}
}
answer = Math.max(answer, cnt);
}
}
System.out.println(answer);
}
}
| ConDefects/ConDefects/Code/abc351_d/Java/53668464 |
condefects-java_data_1198 | import java.util.*;
import java.io.*;
public class Main {
static MyScanner sc;
static PrintWriter out;
static {
sc = new MyScanner();
out = new PrintWriter(System.out);
}
public static Long bfs(Node[] g, int n, int s) {
Queue<Integer> q = new LinkedList<>();
q.add(s);
g[s].color = 1;
long a = 1, b = 0;
while(!q.isEmpty()) {
int u = q.poll();
if(g[u].visited)
continue;
g[u].visited = true;
for(int v : g[u].l) {
if(g[v].color == g[u].color) {
return null;
}
else if(g[v].color == 0) {
if(g[u].color == 1)
b++;
else
a++;
g[v].color = g[u].color * -1;
q.add(v);
}
}
}
return (a * (a - 1) + b * (b - 1)) / 2;
}
public static void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
Node[] g = new Node[n];
for(int i = 0; i < n; i++)
g[i] = new Node();
for(int i = 0; i < m; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
g[u].l.add(v);
g[v].l.add(u);
}
int ans = n * (n - 1) / 2 - m;
for(int i = 0; i < n; i++) {
if(g[i].visited)
continue;
Long val = bfs(g, n, i);
if(val == null) {
out.println(0);
return;
}
ans -= val;
}
out.println(ans);
}
public static void main(String[] args) {
int t = 1;
while(t-- > 0)
solve();
out.flush();
}
}
class Pair {
long x, y;
Pair(long x, long y) {
this.x = x;
this.y = y;
}
}
class Node {
ArrayList<Integer> l;
boolean visited;
int color;
Node() {
l = new ArrayList<>();
visited = false;
color = 0;
}
}
class MyScanner {
BufferedReader br;
StringTokenizer tok;
MyScanner() {
try { br = new BufferedReader(new InputStreamReader(System.in)); }
catch(Exception e) { System.out.println(e); }
tok = new StringTokenizer("");
}
public String next() {
try {
while(!tok.hasMoreTokens()) tok = new StringTokenizer(br.readLine());
}
catch(Exception e) { System.out.println(e); }
return tok.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
import java.util.*;
import java.io.*;
public class Main {
static MyScanner sc;
static PrintWriter out;
static {
sc = new MyScanner();
out = new PrintWriter(System.out);
}
public static Long bfs(Node[] g, int n, int s) {
Queue<Integer> q = new LinkedList<>();
q.add(s);
g[s].color = 1;
long a = 1, b = 0;
while(!q.isEmpty()) {
int u = q.poll();
if(g[u].visited)
continue;
g[u].visited = true;
for(int v : g[u].l) {
if(g[v].color == g[u].color) {
return null;
}
else if(g[v].color == 0) {
if(g[u].color == 1)
b++;
else
a++;
g[v].color = g[u].color * -1;
q.add(v);
}
}
}
return (a * (a - 1) + b * (b - 1)) / 2;
}
public static void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
Node[] g = new Node[n];
for(int i = 0; i < n; i++)
g[i] = new Node();
for(int i = 0; i < m; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
g[u].l.add(v);
g[v].l.add(u);
}
long ans = n * (n - 1l) / 2 - m;
for(int i = 0; i < n; i++) {
if(g[i].visited)
continue;
Long val = bfs(g, n, i);
if(val == null) {
out.println(0);
return;
}
ans -= val;
}
out.println(ans);
}
public static void main(String[] args) {
int t = 1;
while(t-- > 0)
solve();
out.flush();
}
}
class Pair {
long x, y;
Pair(long x, long y) {
this.x = x;
this.y = y;
}
}
class Node {
ArrayList<Integer> l;
boolean visited;
int color;
Node() {
l = new ArrayList<>();
visited = false;
color = 0;
}
}
class MyScanner {
BufferedReader br;
StringTokenizer tok;
MyScanner() {
try { br = new BufferedReader(new InputStreamReader(System.in)); }
catch(Exception e) { System.out.println(e); }
tok = new StringTokenizer("");
}
public String next() {
try {
while(!tok.hasMoreTokens()) tok = new StringTokenizer(br.readLine());
}
catch(Exception e) { System.out.println(e); }
return tok.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
| ConDefects/ConDefects/Code/abc282_d/Java/37737774 |
condefects-java_data_1199 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static final long MOD=998244353;
static int[] ans;
static int size = 0;
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
graph G = new graph(n);
for (int i = 0; i < m; i++) {
int a = sc.nextInt()-1;
int b = sc.nextInt()-1;
G.addEdge(a, b, 1);
G.addEdge(b, a, 1);
}
char[] cs = sc.next().toCharArray();
boolean[] vis = new boolean[n];
int[] c = new int[n];
ArrayList<Integer> list = new ArrayList<>();
G.dfs(0, -1, c, vis, list, cs);
int start = 0;
if (Character.getNumericValue(cs[0])!=c[0]) {
start = 1;
}
StringBuilder sb = new StringBuilder();
for (int i = start; i < list.size(); i++) {
sb.append(list.get(i)+" ");
}
out.println(list.size());
out.println(String.valueOf(sb));
out.flush();
}
static class Edge implements Comparable<Edge>{
int to;
long v;
public Edge(int to,long v) {
this.to=to;
this.v=v;
}
@Override
public boolean equals(Object obj){
if(obj instanceof Edge) {
Edge other = (Edge) obj;
return other.to==this.to && other.v==this.v;
}
return false;
}//同値の定義
@Override
public int hashCode() {
return Objects.hash(this.to,this.v);
}
@Override
public int compareTo( Edge p2 ){
if (this.v>p2.v) {
return 1;
}
else if (this.v<p2.v) {
return -1;
}
else {
return 0;
}
}
}
static class graph{
ArrayList<Edge>[] list;
int size;
long INF=Long.MAX_VALUE/2;
int[] color;
@SuppressWarnings("unchecked")
public graph(int n) {
size = n;
list = new ArrayList[n];
color =new int[n];
for(int i=0;i<n;i++){
list[i] = new ArrayList<Edge>();
}
}
void addEdge(int from,int to,long w) {
list[from].add(new Edge(to,w));
}
void dfs(int v, int p, int[] c, boolean[] vis, ArrayList<Integer> ans, char[] cs) {
vis[v] = true;
ans.add((v+1));
c[v] ^= 1;
for (Edge e: list[v]) {
if(vis[e.to]) continue;
dfs(e.to, v, c, vis, ans, cs);
}
if (v!=0) {
if (c[v]==Character.getNumericValue(cs[v])) {
ans.add(p+1);
c[p] ^= 1;
}else {
c[v] ^= 1;
ans.add(p+1);
ans.add(v+1);
ans.add(p+1);
}
}
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static final long MOD=998244353;
static int[] ans;
static int size = 0;
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
graph G = new graph(n);
for (int i = 0; i < m; i++) {
int a = sc.nextInt()-1;
int b = sc.nextInt()-1;
G.addEdge(a, b, 1);
G.addEdge(b, a, 1);
}
char[] cs = sc.next().toCharArray();
boolean[] vis = new boolean[n];
int[] c = new int[n];
ArrayList<Integer> list = new ArrayList<>();
G.dfs(0, -1, c, vis, list, cs);
int start = 0;
if (Character.getNumericValue(cs[0])!=c[0]) {
start = 1;
}
StringBuilder sb = new StringBuilder();
for (int i = start; i < list.size(); i++) {
sb.append(list.get(i)+" ");
}
out.println(list.size()-start);
out.println(String.valueOf(sb));
out.flush();
}
static class Edge implements Comparable<Edge>{
int to;
long v;
public Edge(int to,long v) {
this.to=to;
this.v=v;
}
@Override
public boolean equals(Object obj){
if(obj instanceof Edge) {
Edge other = (Edge) obj;
return other.to==this.to && other.v==this.v;
}
return false;
}//同値の定義
@Override
public int hashCode() {
return Objects.hash(this.to,this.v);
}
@Override
public int compareTo( Edge p2 ){
if (this.v>p2.v) {
return 1;
}
else if (this.v<p2.v) {
return -1;
}
else {
return 0;
}
}
}
static class graph{
ArrayList<Edge>[] list;
int size;
long INF=Long.MAX_VALUE/2;
int[] color;
@SuppressWarnings("unchecked")
public graph(int n) {
size = n;
list = new ArrayList[n];
color =new int[n];
for(int i=0;i<n;i++){
list[i] = new ArrayList<Edge>();
}
}
void addEdge(int from,int to,long w) {
list[from].add(new Edge(to,w));
}
void dfs(int v, int p, int[] c, boolean[] vis, ArrayList<Integer> ans, char[] cs) {
vis[v] = true;
ans.add((v+1));
c[v] ^= 1;
for (Edge e: list[v]) {
if(vis[e.to]) continue;
dfs(e.to, v, c, vis, ans, cs);
}
if (v!=0) {
if (c[v]==Character.getNumericValue(cs[v])) {
ans.add(p+1);
c[p] ^= 1;
}else {
c[v] ^= 1;
ans.add(p+1);
ans.add(v+1);
ans.add(p+1);
}
}
}
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
} | ConDefects/ConDefects/Code/abc244_g/Java/30401725 |
condefects-java_data_1200 | 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);
B_PlusAndAnd solver = new B_PlusAndAnd();
solver.solve(1, in, out);
out.close();
}
static class B_PlusAndAnd {
public void solve(int testNumber, FastScanner in, PrintWriter out) {
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
int ans = 0;
int[] cost = new int[n];
Integer[] o = new Integer[n];
for (int i = 0; i < n; i++) {
o[i] = i;
}
for (int bit = 30; bit >= 0; bit--) {
for (int i = 0; i < n; i++) {
int x = a[i];
int y = ans | (1 << bit);
// Find the smallest number >= x that has all bits from y set.
int r = 0;
boolean eq = true;
for (int j = 30; j >= 0; j--) {
int bitX = (x >> j) & 1;
int bitY = (y >> j) & 1;
int bitR = 0;
if (bitY == 1 || (eq && bitX == 1)) {
bitR = 1;
}
eq = eq && bitR > bitX;
r |= bitR << j;
}
cost[i] = r - x;
}
Arrays.sort(o, (u, v) -> Integer.compare(cost[u], cost[v]));
long totalCost = 0;
for (int i = 0; i < k; i++) {
totalCost += cost[o[i]];
}
if (totalCost <= m) {
ans |= 1 << bit;
}
}
out.println(ans);
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
try {
in = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
} catch (Exception e) {
throw new AssertionError();
}
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String rl = in.readLine();
if (rl == null) {
return null;
}
st = new StringTokenizer(rl);
} 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);
B_PlusAndAnd solver = new B_PlusAndAnd();
solver.solve(1, in, out);
out.close();
}
static class B_PlusAndAnd {
public void solve(int testNumber, FastScanner in, PrintWriter out) {
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
int ans = 0;
int[] cost = new int[n];
Integer[] o = new Integer[n];
for (int i = 0; i < n; i++) {
o[i] = i;
}
for (int bit = 30; bit >= 0; bit--) {
for (int i = 0; i < n; i++) {
int x = a[i];
int y = ans | (1 << bit);
// Find the smallest number >= x that has all bits from y set.
int r = 0;
boolean eq = true;
for (int j = 30; j >= 0; j--) {
int bitX = (x >> j) & 1;
int bitY = (y >> j) & 1;
int bitR = 0;
if (bitY == 1 || (eq && bitX == 1)) {
bitR = 1;
}
eq = eq && bitR == bitX;
r |= bitR << j;
}
cost[i] = r - x;
}
Arrays.sort(o, (u, v) -> Integer.compare(cost[u], cost[v]));
long totalCost = 0;
for (int i = 0; i < k; i++) {
totalCost += cost[o[i]];
}
if (totalCost <= m) {
ans |= 1 << bit;
}
}
out.println(ans);
}
}
static class FastScanner {
private BufferedReader in;
private StringTokenizer st;
public FastScanner(InputStream stream) {
try {
in = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
} catch (Exception e) {
throw new AssertionError();
}
}
public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
String rl = in.readLine();
if (rl == null) {
return null;
}
st = new StringTokenizer(rl);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
| ConDefects/ConDefects/Code/arc146_b/Java/34179112 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.