id
stringlengths 22
25
| content
stringlengths 327
628k
| max_stars_repo_path
stringlengths 49
49
|
|---|---|---|
condefects-java_data_1901 | import java.io.*; import java.util.*;
public class Main
{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int n = Integer.parseInt(br.readLine());
String a = br.readLine();
String b = br.readLine();
int[] temp = new int[26];
int[] temp2 = new int[26];
for(int i=0; i<n; i++){
temp[(int)a.charAt(i)-97]++;
temp2[(int)b.charAt(i)-97]++;
}
boolean found = true;
for(int i=0; i<26; i++){
if(temp[i]!=temp2[i]){
found=false;
break;
}
}
int start = -1;
int end = n-1;
while(start<end-1){
int find = start+(end-start)/2;
int index = 0;
boolean k = true;
for(int i=find; i<n; i++){
while(index!=n&&b.charAt(index)!=a.charAt(i)){
index++;
}
if(index==n){
k=false;
break;
}
else{
index++;
}
}
if(k){
end=find;
}
else{
start=find;
}
}
if(found){
pw.println(end);
}
else{
pw.println(start);
}
pw.close();
}
}
import java.io.*; import java.util.*;
public class Main
{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
int n = Integer.parseInt(br.readLine());
String a = br.readLine();
String b = br.readLine();
int[] temp = new int[26];
int[] temp2 = new int[26];
for(int i=0; i<n; i++){
temp[(int)a.charAt(i)-97]++;
temp2[(int)b.charAt(i)-97]++;
}
boolean found = true;
for(int i=0; i<26; i++){
if(temp[i]!=temp2[i]){
found=false;
break;
}
}
int start = -1;
int end = n-1;
while(start<end-1){
int find = start+(end-start)/2;
int index = 0;
boolean k = true;
for(int i=find; i<n; i++){
while(index!=n&&b.charAt(index)!=a.charAt(i)){
index++;
}
if(index==n){
k=false;
break;
}
else{
index++;
}
}
if(k){
end=find;
}
else{
start=find;
}
}
if(found){
pw.println(end);
}
else{
pw.println(-1);
}
pw.close();
}
}
| ConDefects/ConDefects/Code/arc154_b/Java/38269852 |
condefects-java_data_1902 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
int[]a=new int[n];
int[]b=new int[m];
for(int i=0;i<n;i++){
a[i]=scanner.nextInt();
}
for(int i=0;i<m;i++){
b[i]=scanner.nextInt();
}
int[]c=new int[n+m];
for(int i=0;i<n;i++){
c[i]=a[i];
}
for(int i=0;i<m;i++){
c[n+1]=b[i];
}
Arrays.sort(c);
for(int i=0;i<n;i++){
int ans=Arrays.binarySearch(c,a[i])+1;
System.out.print(ans+" ");
}
System.out.println();
for(int i=0;i<m;i++){
int ans=Arrays.binarySearch(c,b[i])+1;
System.out.print(ans+" ");
}
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n=scanner.nextInt();
int m=scanner.nextInt();
int[]a=new int[n];
int[]b=new int[m];
for(int i=0;i<n;i++){
a[i]=scanner.nextInt();
}
for(int i=0;i<m;i++){
b[i]=scanner.nextInt();
}
int[]c=new int[n+m];
for(int i=0;i<n;i++){
c[i]=a[i];
}
for(int i=0;i<m;i++){
c[n+i]=b[i];
}
Arrays.sort(c);
for(int i=0;i<n;i++){
int ans=Arrays.binarySearch(c,a[i])+1;
System.out.print(ans+" ");
}
System.out.println();
for(int i=0;i<m;i++){
int ans=Arrays.binarySearch(c,b[i])+1;
System.out.print(ans+" ");
}
}
} | ConDefects/ConDefects/Code/abc294_c/Java/42070795 |
condefects-java_data_1903 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
/* --- ABC319C --- */
public class Main {
private static int[][] C;
public static void main(String[] args) throws Exception {
/* --- Input --- */
var br = new BufferedReader(new InputStreamReader(System.in));
C = new int[3][3];
for (var i = 0; i < 3; i++) {
var sa = br.readLine().split(" ");
for (var j = 0; j < 3; j++) {
C[i][j] = Integer.parseInt(sa[j]);
}
}
br.close();
/* --- Process --- */
var ary = new ArrayList<Integer>();
for(var i=0; i<9; i++){
ary.add(i);
}
var cnt = 0;
var sum = 0;
do {
sum++;
var A = new int[3][3];
for (var v : ary) {
var i = v / 3;
var j = v % 3;
A[i][j] = C[i][j];
if (isGakkari(A, i, j)) {
cnt++;
break;
}
}
ary = next_permutation(ary);
} while (ary != null);
System.out.println(cnt);
System.out.println(sum);
/* --- Output --- */
System.out.println((double)(sum - cnt) / sum);
System.out.flush();
}
// 新たに知ったマス以外の２マスがすでに知っていて同じ数だった時にがっかりする
private static boolean isGakkari(int[][] A, int i, int j){
if(A[i][(j+1)%3] != 0 && A[i][(j+1)%3] == A[i][(j+2)%3]) return true; // 横
if(A[(i+1)%3][j] != 0 && A[(i+1)%3][j] == A[(i+2)%3][j]) return true; // 縦
// 斜↗︎
if(i == j){
if(A[(i+1)%3][(j+1)%3] != 0 && A[(i+1)%3][(j+1)%3] == A[(i+2)%3][(j+2)%3]) return true;
}
// 斜↘︎
if((i == 0 && j == 2) || (i == 1 && j == 1) || (i == 2 && j == 0)){
if(A[(i+2)%3][(j+1)%3] != 0 && A[(i+2)%3][(j+1)%3] == A[(i+1)%3][(j+2)%3]) return true;
}
return false;
}
//引数に与えられた順列の次の順列を生成する
private static ArrayList<Integer> next_permutation(ArrayList<Integer> l){
var list = new ArrayList<>(l);
var len = list.size();
var x = -1;
for(var i=len-1; i>0 && x==-1; i--) if(list.get(i-1) < list.get(i)) x = i-1;
if(x == -1) return null;
var y = -1;
for(var i=len-1; i>x && y==-1; i--) if(list.get(x) < list.get(i)) y = i;
Collections.swap(list, x, y);
len--;
x++;
while(x < len){
Collections.swap(list, x, len);
len--;
x++;
}
return list;
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
/* --- ABC319C --- */
public class Main {
private static int[][] C;
public static void main(String[] args) throws Exception {
/* --- Input --- */
var br = new BufferedReader(new InputStreamReader(System.in));
C = new int[3][3];
for (var i = 0; i < 3; i++) {
var sa = br.readLine().split(" ");
for (var j = 0; j < 3; j++) {
C[i][j] = Integer.parseInt(sa[j]);
}
}
br.close();
/* --- Process --- */
var ary = new ArrayList<Integer>();
for(var i=0; i<9; i++){
ary.add(i);
}
var cnt = 0;
var sum = 0;
do {
sum++;
var A = new int[3][3];
for (var v : ary) {
var i = v / 3;
var j = v % 3;
A[i][j] = C[i][j];
if (isGakkari(A, i, j)) {
cnt++;
break;
}
}
ary = next_permutation(ary);
} while (ary != null);
/* --- Output --- */
System.out.println((double)(sum - cnt) / sum);
System.out.flush();
}
// 新たに知ったマス以外の２マスがすでに知っていて同じ数だった時にがっかりする
private static boolean isGakkari(int[][] A, int i, int j){
if(A[i][(j+1)%3] != 0 && A[i][(j+1)%3] == A[i][(j+2)%3]) return true; // 横
if(A[(i+1)%3][j] != 0 && A[(i+1)%3][j] == A[(i+2)%3][j]) return true; // 縦
// 斜↗︎
if(i == j){
if(A[(i+1)%3][(j+1)%3] != 0 && A[(i+1)%3][(j+1)%3] == A[(i+2)%3][(j+2)%3]) return true;
}
// 斜↘︎
if((i == 0 && j == 2) || (i == 1 && j == 1) || (i == 2 && j == 0)){
if(A[(i+2)%3][(j+1)%3] != 0 && A[(i+2)%3][(j+1)%3] == A[(i+1)%3][(j+2)%3]) return true;
}
return false;
}
//引数に与えられた順列の次の順列を生成する
private static ArrayList<Integer> next_permutation(ArrayList<Integer> l){
var list = new ArrayList<>(l);
var len = list.size();
var x = -1;
for(var i=len-1; i>0 && x==-1; i--) if(list.get(i-1) < list.get(i)) x = i-1;
if(x == -1) return null;
var y = -1;
for(var i=len-1; i>x && y==-1; i--) if(list.get(x) < list.get(i)) y = i;
Collections.swap(list, x, y);
len--;
x++;
while(x < len){
Collections.swap(list, x, len);
len--;
x++;
}
return list;
}
}
| ConDefects/ConDefects/Code/abc319_c/Java/45420573 |
condefects-java_data_1904 | import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
static long mod = 1000000007;
static long INF = Long.MAX_VALUE;
static String Yes = "Yes";
static String No = "No";
static String LF = "\n";
static String Grid[];
static Queue<Long> AD = new ArrayDeque<Long>();
static Queue<Long> PQ = new PriorityQueue<Long>();
static TreeSet<Integer> TS = new TreeSet<Integer>();
static LinkedHashMap<Long, Long> LHM = new LinkedHashMap<Long, Long>();
static TreeMap<Long, Long> Imos = new TreeMap<Long, Long>();
static class oneNodeList extends HashMap<Integer, Integer>{}
static oneNodeList[] edgeList;
static long DPDistance[];
static StringBuffer sb = new StringBuffer();
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
// AtCoder_Temp
int C[] = new int[9];
for(int i=0; i<9; i++) {
C[i] = Integer.parseInt(sc.next());
}
boolean flgH0 = (C[0]==C[1] || C[1]==C[2] || C[2]==C[0]);
boolean flgH1 = (C[3]==C[4] || C[4]==C[5] || C[5]==C[3]);
boolean flgH2 = (C[6]==C[7] || C[7]==C[8] || C[8]==C[6]);
boolean flgV0 = (C[0]==C[3] || C[3]==C[6] || C[6]==C[0]);
boolean flgV1 = (C[1]==C[4] || C[4]==C[7] || C[7]==C[1]);
boolean flgV2 = (C[2]==C[5] || C[5]==C[8] || C[8]==C[2]);
boolean flgN = (C[0]==C[4] || C[4]==C[8] || C[8]==C[0]);
boolean flgZ = (C[2]==C[4] || C[4]==C[6] || C[6]==C[2]);
int xH0 = -1;
int xH1 = -1;
int xH2 = -1;
int xV0 = -1;
int xV1 = -1;
int xV2 = -1;
int xN = -1;
int xZ = -1;
if(flgH0) {
if(C[1]==C[2]) xH0=0;
if(C[2]==C[0]) xH0=1;
if(C[0]==C[1]) xH0=2;
}
if(flgH1) {
if(C[4]==C[5]) xH1=3;
if(C[5]==C[3]) xH1=4;
if(C[3]==C[4]) xH1=5;
}
if(flgH2) {
if(C[7]==C[8]) xH2=6;
if(C[8]==C[6]) xH2=7;
if(C[6]==C[7]) xH2=8;
}
if(flgV0) {
if(C[3]==C[6]) xV0=0;
if(C[6]==C[0]) xV0=3;
if(C[0]==C[3]) xV0=6;
}
if(flgV1) {
if(C[4]==C[7]) xV1=1;
if(C[7]==C[1]) xV1=4;
if(C[1]==C[4]) xV1=7;
}
if(flgV2) {
if(C[5]==C[8]) xV2=2;
if(C[8]==C[2]) xV2=5;
if(C[2]==C[5]) xV2=8;
}
if(flgN) {
if(C[4]==C[8]) xN=0;
if(C[8]==C[0]) xN=4;
if(C[0]==C[4]) xN=8;
}
if(flgZ) {
if(C[4]==C[6]) xZ=2;
if(C[6]==C[2]) xZ=4;
if(C[2]==C[4]) xZ=6;
}
/* 順列格納用配列 */
var arr = new int[9];
for (int i=0; i<9; i++) {
arr[i] = i;
}
long bunbo = 0;
long bunsi = 0;
/* 順列全探索 */
do {
bunbo += 1;
boolean isSad = false;
boolean isChk[] = new boolean[9];
for(int i=0; i<9; i++) {
if(flgH0 && arr[i]==xH0 && !isChk[0] && !isChk[1] && !isChk[2]) isSad=true;
if(flgH1 && arr[i]==xH1 && !isChk[3] && !isChk[4] && !isChk[5]) isSad=true;
if(flgH2 && arr[i]==xH2 && !isChk[6] && !isChk[7] && !isChk[8]) isSad=true;
if(flgV0 && arr[i]==xV0 && !isChk[0] && !isChk[3] && !isChk[6]) isSad=true;
if(flgV1 && arr[i]==xV1 && !isChk[1] && !isChk[4] && !isChk[7]) isSad=true;
if(flgV2 && arr[i]==xV2 && !isChk[2] && !isChk[5] && !isChk[8]) isSad=true;
if(flgN && arr[i]==xN && !isChk[0] && !isChk[4] && !isChk[8]) isSad=true;
if(flgZ && arr[i]==xZ && !isChk[2] && !isChk[4] && !isChk[6]) isSad=true;
isChk[arr[i]] = true;
}
if(!isSad) bunsi += Math.pow(10, 10);
} while (nextPermutation(arr));
String S = Long.toString(bunsi/bunbo);
StringBuffer sb = new StringBuffer();
if(S.length() < 10) {
sb.append("0.");
for(int i=0; i<10-S.length(); i++) {
sb.append("0");
}
sb.append(S);
} else {
sb.append(1);
}
System.out.println(sb.toString());
// Scannerクラスのインスタンスをクローズ
sc.close();
}
/**
* 素因数分解
* @param N 合成数
*/
static void PrimeFactorization() {
// AtCoder_Temp
long N = Long.parseLong(sc.next());
Double NSqrt = Math.sqrt(N);
HashMap<Long, Long> HM = new HashMap<Long, Long>();
for(long i=2; i<=NSqrt; i++) {
while(N%i == 0) {
if(HM.containsKey(i)) {
HM.put(i, HM.get(i)+1);
} else {
HM.put(i, (long) 1);
}
N /= i;
}
}
if(N != 1) {
if(HM.containsKey(N)) {
HM.put(N, HM.get(N)+1);
} else {
HM.put(N, (long) 1);
}
}
long Ans = 1;
/*
for(Entry<Long, Long> e : HM.entrySet() ) {
long K = e.getKey();
long V = e.getValue();
}
*/
System.out.println(Ans);
}
/**
* HashMap in HashMap
* @param N 要素数
*/
static void MapInMap(int N) {
HashMap<Integer, HashMap<Integer, Integer>> B = new HashMap<Integer, HashMap<Integer, Integer>>();
for(int i=0; i<N; i++) {
int AWk = Integer.parseInt(sc.next());
if(B.containsKey(AWk)) {
HashMap<Integer, Integer> HM = B.get(AWk);
HM.put(HM.size()+1, i+1);
B.put(AWk, HM);
} else {
HashMap<Integer, Integer> HM = new HashMap<Integer, Integer>();
HM.put(1, i+1);
B.put(AWk, HM);
}
}
}
/**
* 順列全探索
* @param N 要素数
*/
static void SearchPermutation(int N) {
/* 順列格納用配列 */
var arr = new int[N];
for (int i=0; i<N; i++) {
arr[i] = i;
}
/* 順列全探索 */
do {
// ここにロジックを追加
} while (nextPermutation(arr));
}
/* 順列 */
public static boolean nextPermutation(int[] arr) {
int len = arr.length;
int left = len - 2;
while (left >= 0 && arr[left] >= arr[left+1]) left--;
if (left < 0) return false;
int right = len - 1;
while (arr[left] >= arr[right]) right--;
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right = len - 1;
while (left < right) {
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right--;
}
return true;
}
/**
* 三角形の面積
*/
static double GetTriangleArea(double AX,double AY,double BX,double BY,double CX,double CY) {
return (((CX-BX)*(AY-BY))-((AX-BX)*(CY-BY)))*0.5;
}
/**
* いもす法（1次元）セットアップ
* @param N 要素数
*/
static void ImosSetUp1D(int N) {
for(int i=0; i<N; i++) {
long A = Long.parseLong(sc.next());
long B = Long.parseLong(sc.next());
long P = Long.parseLong(sc.next());
if(Imos.containsKey(A)) {
Imos.put(A, Imos.get(A)+P);
} else {
Imos.put(A, P);
}
if(Imos.containsKey(B)) {
Imos.put(B, Imos.get(B)-P);
} else {
Imos.put(B, -P);
}
}
}
/**
* いもす法（1次元）シミュレートロジック
*/
static void ImosSimulate1D() {
/*
long nowD = 1;
long nowP = 0;
for(Entry<Long, Long> e : Imos.entrySet() ) {
long nextD = e.getKey();
long addP = e.getValue();
// 何かしらのロジック
nowD = nextD;
nowP += addP;
}
*/
}
/**
* グラフの生成（隣接リスト）
* @param N 頂点数
* @param M 辺の数
*/
static void makeGraph2(int N, long M) {
edgeList = new oneNodeList[N];
for(int i=0; i<N; i++) {
edgeList[i] = new oneNodeList();
}
for(long i=0; i<M; i++) {
int A = Integer.parseInt(sc.next())-1;
int B = Integer.parseInt(sc.next())-1;
edgeList[A].put(B, 1);
edgeList[B].put(A, 1); // 無向グラフの場合、逆方向にも張る
}
}
/**
* DFS（深さ優先探索）（隣接リスト）
* @param v チェック対象の座標
*/
static void DFS2(int v) {
for(Map.Entry<Integer, Integer> entry : edgeList[v].entrySet()) {
if(DPDistance[entry.getKey()] < 0) {
DPDistance[entry.getKey()] = DPDistance[v] + entry.getValue();
DFS2(entry.getKey());
}
}
}
/**
* BFS（幅優先探索）（隣接リスト）
* @param S 開始座標
*/
static void BFS2(int N, int S) {
Deque<Integer> q = new ArrayDeque<>();
DPDistance = new long[N];
Arrays.fill(DPDistance, INF);
DPDistance[S] = 0;
q.add(S);
while(q.size() > 0) {
int now = q.poll();
for(Map.Entry<Integer, Integer> entry : edgeList[now].entrySet()) {
DPDistance[entry.getKey()] = Math.min(DPDistance[entry.getKey()], DPDistance[now] + entry.getValue());
q.add(entry.getKey());
}
edgeList[now].clear();
}
}
/**
* ダイクストラ法（隣接リスト）
* ※頂点の距離のみ実装済み
* ※辺の重み未対応
*
* @param N 頂点数
* @param S 開始頂点
*/
static void dijkstra(int N, int S) {
DPDistance = new long[N];
boolean FIX[] = new boolean[N];
Arrays.fill(DPDistance, INF);
Arrays.fill(FIX, false);
DPDistance[S] = 0;
for(;;) {
long min = INF; // 最小の重み
int now = -1; // 今回処理する頂点
// 処理対象の頂点を決める
for(int i=0; i<N; i++) {
if(!FIX[i]) {
if(min > DPDistance[i]) {
min = DPDistance[i];
now = i;
}
}
}
// 頂点が決まらなかったら処理終了
if(now < 0) {
break;
}
// 処理対象の頂点を確定済み状態にする
FIX[now] = true;
for(int i=0; i < edgeList[now].size(); i++) {
int next = edgeList[now].get(i);
if(!FIX[next]) {
DPDistance[next] = Math.min(DPDistance[next], DPDistance[now] + 1);
}
}
}
}
/**
* bit全探索
* @param N 要素数
*/
static long bitSearch(int N) {
long DP = INF;
// 全探索パターン数
long Pattern = (long) Math.pow(2, N);
// 全探索パターン数分ループ
for(long i=0; i<Pattern; i++) {
// j番目の要素のbit判定
for(long j=0; j<N; j++) {
if((1&i>>j) == 1) {
// j番目の要素がONの場合
// TODO ONの場合のコードを実装
} else {
// TODO OFFの場合のコードを実装
}
}
// TODO DPの判定を実装
}
// 求めたDPの返却
return DP;
}
/**
* ビット演算(AND)
* @param A
* @param B
* @return
*/
static long bitAND(long A, long B) {
return A&B;
}
/**
* ビット演算(OR)
* @param A
* @param B
* @return
*/
static long bitOR(long A, long B) {
return A|B;
}
/**
* ビット演算(XOR)
* @param A
* @param B
* @return
*/
static long bitXOR(long A, long B) {
return A^B;
}
/**
* ビット演算(NOT)
* @param A
* @param B
* @return
*/
static long bitNOT(long A) {
return ~A;
}
/**
* 小さい順に約数を列挙する
* @param N 約数を求めたい数値
* @param sqrtN Nの平方根（あらかじめsqrtで求めておくこと）
* @param Start 集計を開始する値（1を設定して呼び出す）
*/
static void makeDivisors(long N, double sqrtN, long Start) {
while(Start <= sqrtN) {
if(N%Start == 0) {
System.out.println(Start);
makeDivisors(N,sqrtN,Start+1);
if(Start * Start != N) {
System.out.println(N/Start);
}
break;
}
Start++;
}
}
/**
* 壁座標が与えられるパターンのとき、グリッドを作成する
* @param H
* @param W
* @param N
* @return なし
*/
public static void makeGrid(int H, int W, int N) {
Grid = new String[H+2];
// グリッドの初期化
for(int i=0; i<H+1; i++) {
Grid[i] = "#";
}
for(int i=1; i<W+2; i++) {
Grid[0] += "#";
for(int j=1; j<H+1; j++) {
Grid[j] += ".";
}
Grid[H+1] += "#";
}
for(int i=0; i<H+1; i++) {
Grid[i] += "#";
}
// 与えられた座標を壁にする
for(int i=0; i<N; i++) {
int r = sc.nextInt();
int c = sc.nextInt();
Grid[r] = Grid[r].substring(0, c) + "#" + Grid[r].substring(c+2);
}
}
/**
* 最小公倍数を求める
* @param A
* @param B
* @return lcm
*/
public static long lcm(long A, long B) {
return A * B / gcd(A,B);
}
/**
* 最大公約数を求める
* @param A
* @param B
* @return gcd
*/
public static long gcd(long A, long B) {
return gcdMain(Math.max(A, B), Math.min(A, B));
}
public static long gcdMain(long numBig, long numSmall) {
if(numSmall==0) return numBig;
else return gcd(numSmall, numBig%numSmall);
}
/**
* 組み合わせの数を求める
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk
*/
public static long nCk(long n,long k) {
long ret = 1;
long min = Math.min(k, n-k);
for(long i=1; i<=min; i++) {
ret *= n+1-i;
ret /= i;
}
return ret;
}
/**
* 組み合わせの数を求める（MOD処理含む）
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk mod M (M must be prime number) O(min(k,n-k)*logM)
*/
public static int nCk(int n,int k,int M) {
long ret = 1;
int min = Math.min(k, n-k);
for(int i=1;i<=min;i++) {
ret = (ret * modPow(i,M-2,M)) % M;
}
for(int i=n-min+1;i<=n;i++) {
ret = (ret * i) % M;
}
return (int)ret;
}
/**
* 累乗計算（MOD処理含む）
* @param a
* @param b
* @param M
* @return a^b mod M O(logB)
*/
public static long modPow(long a,long b,int M) {
long ret = 1;
if(b > 0) {
TreeMap<Long, Long> memo = new TreeMap<Long, Long>(Collections.reverseOrder());
memo.put((long) 1, a%M);
long PowTmp = 1;
while(PowTmp < b) {
memo.put(PowTmp*2, (memo.get(PowTmp)*memo.get(PowTmp))%M);
PowTmp *= 2;
}
ret = a;
b--;
for(Entry<Long, Long> e : memo.entrySet() ) {
long nowB = e.getKey();
long nowA = e.getValue();
while(b - nowB >= 0) {
ret *= nowA;
ret %= M;
b -= nowB;
}
}
}
return ret;
}
}
class UnionFind {
int[] parent;
int[] rank;
public UnionFind(int n) {
// 初期化コンストラクタ
this.parent = new int[n];
this.rank = new int[n];
// 最初はすべてが根
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
/**
* 要素の根を返す。
* 経路圧縮付き。（1→3→2となっていて2をfindした際、1→3,2と木の深さを浅くする。）
*
* @param x
* @return 要素xの根
*/
public int find(int x) {
if (x == parent[x]) {
return x;
} else {
// 経路圧縮時はrank変更しない
parent[x] = find(parent[x]);
return parent[x];
}
}
/**
* ２つの要素が同じ集合に属するかどうかを返す。
*
* @param x
* @param y
* @return 同じ集合であればtrue
*/
public boolean same(int x, int y) {
return find(x) == find(y);
}
/**
* 要素xが属する集合と要素yが属する集合を連結する。
* 木の高さ（ランク）を気にして、低い方に高い方をつなげる。（高い方の根を全体の根とする。）
*
* @param x
* @param y
*/
public void unite(int x, int y) {
int xRoot = find(x);
int yRoot = find(y);
if (xRoot == yRoot) {
// 属する集合が同じな場合、何もしない
return;
}
// rankを比較して共通の根を決定する。
// ※find時の経路圧縮はrank考慮しない
if (rank[xRoot] > rank[yRoot]) {
// xRootのrankのほうが大きければ、共通の根をxRootにする
parent[yRoot] = xRoot;
} else if (rank[xRoot] < rank[yRoot]) {
// yRootのrankのほうが大きければ、共通の根をyRootにする
parent[xRoot] = yRoot;
} else {
// rankが同じであれば、どちらかを根として、rankを一つ上げる。
parent[xRoot] = yRoot;
rank[xRoot]++;
}
}
}
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
static long mod = 1000000007;
static long INF = Long.MAX_VALUE;
static String Yes = "Yes";
static String No = "No";
static String LF = "\n";
static String Grid[];
static Queue<Long> AD = new ArrayDeque<Long>();
static Queue<Long> PQ = new PriorityQueue<Long>();
static TreeSet<Integer> TS = new TreeSet<Integer>();
static LinkedHashMap<Long, Long> LHM = new LinkedHashMap<Long, Long>();
static TreeMap<Long, Long> Imos = new TreeMap<Long, Long>();
static class oneNodeList extends HashMap<Integer, Integer>{}
static oneNodeList[] edgeList;
static long DPDistance[];
static StringBuffer sb = new StringBuffer();
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
// AtCoder_Temp
int C[] = new int[9];
for(int i=0; i<9; i++) {
C[i] = Integer.parseInt(sc.next());
}
boolean flgH0 = (C[0]==C[1] || C[1]==C[2] || C[2]==C[0]);
boolean flgH1 = (C[3]==C[4] || C[4]==C[5] || C[5]==C[3]);
boolean flgH2 = (C[6]==C[7] || C[7]==C[8] || C[8]==C[6]);
boolean flgV0 = (C[0]==C[3] || C[3]==C[6] || C[6]==C[0]);
boolean flgV1 = (C[1]==C[4] || C[4]==C[7] || C[7]==C[1]);
boolean flgV2 = (C[2]==C[5] || C[5]==C[8] || C[8]==C[2]);
boolean flgN = (C[0]==C[4] || C[4]==C[8] || C[8]==C[0]);
boolean flgZ = (C[2]==C[4] || C[4]==C[6] || C[6]==C[2]);
int xH0 = -1;
int xH1 = -1;
int xH2 = -1;
int xV0 = -1;
int xV1 = -1;
int xV2 = -1;
int xN = -1;
int xZ = -1;
if(flgH0) {
if(C[1]==C[2]) xH0=0;
if(C[2]==C[0]) xH0=1;
if(C[0]==C[1]) xH0=2;
}
if(flgH1) {
if(C[4]==C[5]) xH1=3;
if(C[5]==C[3]) xH1=4;
if(C[3]==C[4]) xH1=5;
}
if(flgH2) {
if(C[7]==C[8]) xH2=6;
if(C[8]==C[6]) xH2=7;
if(C[6]==C[7]) xH2=8;
}
if(flgV0) {
if(C[3]==C[6]) xV0=0;
if(C[6]==C[0]) xV0=3;
if(C[0]==C[3]) xV0=6;
}
if(flgV1) {
if(C[4]==C[7]) xV1=1;
if(C[7]==C[1]) xV1=4;
if(C[1]==C[4]) xV1=7;
}
if(flgV2) {
if(C[5]==C[8]) xV2=2;
if(C[8]==C[2]) xV2=5;
if(C[2]==C[5]) xV2=8;
}
if(flgN) {
if(C[4]==C[8]) xN=0;
if(C[8]==C[0]) xN=4;
if(C[0]==C[4]) xN=8;
}
if(flgZ) {
if(C[4]==C[6]) xZ=2;
if(C[6]==C[2]) xZ=4;
if(C[2]==C[4]) xZ=6;
}
/* 順列格納用配列 */
var arr = new int[9];
for (int i=0; i<9; i++) {
arr[i] = i;
}
long bunbo = 0;
long bunsi = 0;
/* 順列全探索 */
do {
bunbo += 1;
boolean isSad = false;
boolean isChk[] = new boolean[9];
for(int i=0; i<9; i++) {
if(flgH0 && arr[i]==xH0 && !isChk[0] && !isChk[1] && !isChk[2]) isSad=true;
if(flgH1 && arr[i]==xH1 && !isChk[3] && !isChk[4] && !isChk[5]) isSad=true;
if(flgH2 && arr[i]==xH2 && !isChk[6] && !isChk[7] && !isChk[8]) isSad=true;
if(flgV0 && arr[i]==xV0 && !isChk[0] && !isChk[3] && !isChk[6]) isSad=true;
if(flgV1 && arr[i]==xV1 && !isChk[1] && !isChk[4] && !isChk[7]) isSad=true;
if(flgV2 && arr[i]==xV2 && !isChk[2] && !isChk[5] && !isChk[8]) isSad=true;
if(flgN && arr[i]==xN && !isChk[0] && !isChk[4] && !isChk[8]) isSad=true;
if(flgZ && arr[i]==xZ && !isChk[2] && !isChk[4] && !isChk[6]) isSad=true;
isChk[arr[i]] = true;
}
if(!isSad) bunsi += Math.pow(10, 10);
} while (nextPermutation(arr));
String S = Long.toString(bunsi/bunbo);
StringBuffer sb = new StringBuffer();
if(S.length() <= 10) {
sb.append("0.");
for(int i=0; i<10-S.length(); i++) {
sb.append("0");
}
sb.append(S);
} else {
sb.append(1);
}
System.out.println(sb.toString());
// Scannerクラスのインスタンスをクローズ
sc.close();
}
/**
* 素因数分解
* @param N 合成数
*/
static void PrimeFactorization() {
// AtCoder_Temp
long N = Long.parseLong(sc.next());
Double NSqrt = Math.sqrt(N);
HashMap<Long, Long> HM = new HashMap<Long, Long>();
for(long i=2; i<=NSqrt; i++) {
while(N%i == 0) {
if(HM.containsKey(i)) {
HM.put(i, HM.get(i)+1);
} else {
HM.put(i, (long) 1);
}
N /= i;
}
}
if(N != 1) {
if(HM.containsKey(N)) {
HM.put(N, HM.get(N)+1);
} else {
HM.put(N, (long) 1);
}
}
long Ans = 1;
/*
for(Entry<Long, Long> e : HM.entrySet() ) {
long K = e.getKey();
long V = e.getValue();
}
*/
System.out.println(Ans);
}
/**
* HashMap in HashMap
* @param N 要素数
*/
static void MapInMap(int N) {
HashMap<Integer, HashMap<Integer, Integer>> B = new HashMap<Integer, HashMap<Integer, Integer>>();
for(int i=0; i<N; i++) {
int AWk = Integer.parseInt(sc.next());
if(B.containsKey(AWk)) {
HashMap<Integer, Integer> HM = B.get(AWk);
HM.put(HM.size()+1, i+1);
B.put(AWk, HM);
} else {
HashMap<Integer, Integer> HM = new HashMap<Integer, Integer>();
HM.put(1, i+1);
B.put(AWk, HM);
}
}
}
/**
* 順列全探索
* @param N 要素数
*/
static void SearchPermutation(int N) {
/* 順列格納用配列 */
var arr = new int[N];
for (int i=0; i<N; i++) {
arr[i] = i;
}
/* 順列全探索 */
do {
// ここにロジックを追加
} while (nextPermutation(arr));
}
/* 順列 */
public static boolean nextPermutation(int[] arr) {
int len = arr.length;
int left = len - 2;
while (left >= 0 && arr[left] >= arr[left+1]) left--;
if (left < 0) return false;
int right = len - 1;
while (arr[left] >= arr[right]) right--;
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right = len - 1;
while (left < right) {
{ int t = arr[left]; arr[left] = arr[right]; arr[right] = t; }
left++;
right--;
}
return true;
}
/**
* 三角形の面積
*/
static double GetTriangleArea(double AX,double AY,double BX,double BY,double CX,double CY) {
return (((CX-BX)*(AY-BY))-((AX-BX)*(CY-BY)))*0.5;
}
/**
* いもす法（1次元）セットアップ
* @param N 要素数
*/
static void ImosSetUp1D(int N) {
for(int i=0; i<N; i++) {
long A = Long.parseLong(sc.next());
long B = Long.parseLong(sc.next());
long P = Long.parseLong(sc.next());
if(Imos.containsKey(A)) {
Imos.put(A, Imos.get(A)+P);
} else {
Imos.put(A, P);
}
if(Imos.containsKey(B)) {
Imos.put(B, Imos.get(B)-P);
} else {
Imos.put(B, -P);
}
}
}
/**
* いもす法（1次元）シミュレートロジック
*/
static void ImosSimulate1D() {
/*
long nowD = 1;
long nowP = 0;
for(Entry<Long, Long> e : Imos.entrySet() ) {
long nextD = e.getKey();
long addP = e.getValue();
// 何かしらのロジック
nowD = nextD;
nowP += addP;
}
*/
}
/**
* グラフの生成（隣接リスト）
* @param N 頂点数
* @param M 辺の数
*/
static void makeGraph2(int N, long M) {
edgeList = new oneNodeList[N];
for(int i=0; i<N; i++) {
edgeList[i] = new oneNodeList();
}
for(long i=0; i<M; i++) {
int A = Integer.parseInt(sc.next())-1;
int B = Integer.parseInt(sc.next())-1;
edgeList[A].put(B, 1);
edgeList[B].put(A, 1); // 無向グラフの場合、逆方向にも張る
}
}
/**
* DFS（深さ優先探索）（隣接リスト）
* @param v チェック対象の座標
*/
static void DFS2(int v) {
for(Map.Entry<Integer, Integer> entry : edgeList[v].entrySet()) {
if(DPDistance[entry.getKey()] < 0) {
DPDistance[entry.getKey()] = DPDistance[v] + entry.getValue();
DFS2(entry.getKey());
}
}
}
/**
* BFS（幅優先探索）（隣接リスト）
* @param S 開始座標
*/
static void BFS2(int N, int S) {
Deque<Integer> q = new ArrayDeque<>();
DPDistance = new long[N];
Arrays.fill(DPDistance, INF);
DPDistance[S] = 0;
q.add(S);
while(q.size() > 0) {
int now = q.poll();
for(Map.Entry<Integer, Integer> entry : edgeList[now].entrySet()) {
DPDistance[entry.getKey()] = Math.min(DPDistance[entry.getKey()], DPDistance[now] + entry.getValue());
q.add(entry.getKey());
}
edgeList[now].clear();
}
}
/**
* ダイクストラ法（隣接リスト）
* ※頂点の距離のみ実装済み
* ※辺の重み未対応
*
* @param N 頂点数
* @param S 開始頂点
*/
static void dijkstra(int N, int S) {
DPDistance = new long[N];
boolean FIX[] = new boolean[N];
Arrays.fill(DPDistance, INF);
Arrays.fill(FIX, false);
DPDistance[S] = 0;
for(;;) {
long min = INF; // 最小の重み
int now = -1; // 今回処理する頂点
// 処理対象の頂点を決める
for(int i=0; i<N; i++) {
if(!FIX[i]) {
if(min > DPDistance[i]) {
min = DPDistance[i];
now = i;
}
}
}
// 頂点が決まらなかったら処理終了
if(now < 0) {
break;
}
// 処理対象の頂点を確定済み状態にする
FIX[now] = true;
for(int i=0; i < edgeList[now].size(); i++) {
int next = edgeList[now].get(i);
if(!FIX[next]) {
DPDistance[next] = Math.min(DPDistance[next], DPDistance[now] + 1);
}
}
}
}
/**
* bit全探索
* @param N 要素数
*/
static long bitSearch(int N) {
long DP = INF;
// 全探索パターン数
long Pattern = (long) Math.pow(2, N);
// 全探索パターン数分ループ
for(long i=0; i<Pattern; i++) {
// j番目の要素のbit判定
for(long j=0; j<N; j++) {
if((1&i>>j) == 1) {
// j番目の要素がONの場合
// TODO ONの場合のコードを実装
} else {
// TODO OFFの場合のコードを実装
}
}
// TODO DPの判定を実装
}
// 求めたDPの返却
return DP;
}
/**
* ビット演算(AND)
* @param A
* @param B
* @return
*/
static long bitAND(long A, long B) {
return A&B;
}
/**
* ビット演算(OR)
* @param A
* @param B
* @return
*/
static long bitOR(long A, long B) {
return A|B;
}
/**
* ビット演算(XOR)
* @param A
* @param B
* @return
*/
static long bitXOR(long A, long B) {
return A^B;
}
/**
* ビット演算(NOT)
* @param A
* @param B
* @return
*/
static long bitNOT(long A) {
return ~A;
}
/**
* 小さい順に約数を列挙する
* @param N 約数を求めたい数値
* @param sqrtN Nの平方根（あらかじめsqrtで求めておくこと）
* @param Start 集計を開始する値（1を設定して呼び出す）
*/
static void makeDivisors(long N, double sqrtN, long Start) {
while(Start <= sqrtN) {
if(N%Start == 0) {
System.out.println(Start);
makeDivisors(N,sqrtN,Start+1);
if(Start * Start != N) {
System.out.println(N/Start);
}
break;
}
Start++;
}
}
/**
* 壁座標が与えられるパターンのとき、グリッドを作成する
* @param H
* @param W
* @param N
* @return なし
*/
public static void makeGrid(int H, int W, int N) {
Grid = new String[H+2];
// グリッドの初期化
for(int i=0; i<H+1; i++) {
Grid[i] = "#";
}
for(int i=1; i<W+2; i++) {
Grid[0] += "#";
for(int j=1; j<H+1; j++) {
Grid[j] += ".";
}
Grid[H+1] += "#";
}
for(int i=0; i<H+1; i++) {
Grid[i] += "#";
}
// 与えられた座標を壁にする
for(int i=0; i<N; i++) {
int r = sc.nextInt();
int c = sc.nextInt();
Grid[r] = Grid[r].substring(0, c) + "#" + Grid[r].substring(c+2);
}
}
/**
* 最小公倍数を求める
* @param A
* @param B
* @return lcm
*/
public static long lcm(long A, long B) {
return A * B / gcd(A,B);
}
/**
* 最大公約数を求める
* @param A
* @param B
* @return gcd
*/
public static long gcd(long A, long B) {
return gcdMain(Math.max(A, B), Math.min(A, B));
}
public static long gcdMain(long numBig, long numSmall) {
if(numSmall==0) return numBig;
else return gcd(numSmall, numBig%numSmall);
}
/**
* 組み合わせの数を求める
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk
*/
public static long nCk(long n,long k) {
long ret = 1;
long min = Math.min(k, n-k);
for(long i=1; i<=min; i++) {
ret *= n+1-i;
ret /= i;
}
return ret;
}
/**
* 組み合わせの数を求める（MOD処理含む）
* @param n 要素素
* @param k 選択する数
* @param M
* @return nCk mod M (M must be prime number) O(min(k,n-k)*logM)
*/
public static int nCk(int n,int k,int M) {
long ret = 1;
int min = Math.min(k, n-k);
for(int i=1;i<=min;i++) {
ret = (ret * modPow(i,M-2,M)) % M;
}
for(int i=n-min+1;i<=n;i++) {
ret = (ret * i) % M;
}
return (int)ret;
}
/**
* 累乗計算（MOD処理含む）
* @param a
* @param b
* @param M
* @return a^b mod M O(logB)
*/
public static long modPow(long a,long b,int M) {
long ret = 1;
if(b > 0) {
TreeMap<Long, Long> memo = new TreeMap<Long, Long>(Collections.reverseOrder());
memo.put((long) 1, a%M);
long PowTmp = 1;
while(PowTmp < b) {
memo.put(PowTmp*2, (memo.get(PowTmp)*memo.get(PowTmp))%M);
PowTmp *= 2;
}
ret = a;
b--;
for(Entry<Long, Long> e : memo.entrySet() ) {
long nowB = e.getKey();
long nowA = e.getValue();
while(b - nowB >= 0) {
ret *= nowA;
ret %= M;
b -= nowB;
}
}
}
return ret;
}
}
class UnionFind {
int[] parent;
int[] rank;
public UnionFind(int n) {
// 初期化コンストラクタ
this.parent = new int[n];
this.rank = new int[n];
// 最初はすべてが根
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
/**
* 要素の根を返す。
* 経路圧縮付き。（1→3→2となっていて2をfindした際、1→3,2と木の深さを浅くする。）
*
* @param x
* @return 要素xの根
*/
public int find(int x) {
if (x == parent[x]) {
return x;
} else {
// 経路圧縮時はrank変更しない
parent[x] = find(parent[x]);
return parent[x];
}
}
/**
* ２つの要素が同じ集合に属するかどうかを返す。
*
* @param x
* @param y
* @return 同じ集合であればtrue
*/
public boolean same(int x, int y) {
return find(x) == find(y);
}
/**
* 要素xが属する集合と要素yが属する集合を連結する。
* 木の高さ（ランク）を気にして、低い方に高い方をつなげる。（高い方の根を全体の根とする。）
*
* @param x
* @param y
*/
public void unite(int x, int y) {
int xRoot = find(x);
int yRoot = find(y);
if (xRoot == yRoot) {
// 属する集合が同じな場合、何もしない
return;
}
// rankを比較して共通の根を決定する。
// ※find時の経路圧縮はrank考慮しない
if (rank[xRoot] > rank[yRoot]) {
// xRootのrankのほうが大きければ、共通の根をxRootにする
parent[yRoot] = xRoot;
} else if (rank[xRoot] < rank[yRoot]) {
// yRootのrankのほうが大きければ、共通の根をyRootにする
parent[xRoot] = yRoot;
} else {
// rankが同じであれば、どちらかを根として、rankを一つ上げる。
parent[xRoot] = yRoot;
rank[xRoot]++;
}
}
} | ConDefects/ConDefects/Code/abc319_c/Java/45415952 |
condefects-java_data_1905 | /**
< 基本的な考え方 >
以下のような場合 (リーチは区別するために a,b を追加)
1 2a 2b
3 4 5
6 7 2c
1 行目でがっかりするのは ...2a/b...2b/a...1... の順に数字が並んだ場合
3 列目でがっかりするのは ...2c/b...2b/c...1... の順に数字が並んだ場合
上記のパターンを除いた 1,2a,2b,5,2c の並べ方の数を
1,2a,2b,5,2c の並べ方全体の数で割ればよい
< 処理するにあたって >
上記の場合
a b c
d e f
g h i
というマス目の並べ方のうち
...b...c...a...
...c...b...a...
...c...i...f...
...i...c...f...
の場合を除いた並べ方の確率と同じ
マス目の数字のまま計算するよりこちらの方が実装がちょっと楽なので
こちらで処理する
*/
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.regex.Pattern;
public class Main {
private static Scanner sc = new Scanner(System.in);
// 3*3 の二次元配列にマスを格納
private static int[][] square = new int[3][3];
// a, b, c, ... のマス目
private static String[][] alphabetSquare = {{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}};
// リーチの行・列の文字を格納するセット
private static Set<String> reachStringSet = new HashSet<>();
// NG のパターンを格納するリスト
private static List<Pattern> ngPatternList = new ArrayList<>();
public static void main(String[] args) {
// 3*3 の二次元配列にマスを格納
for (int record = 0; record < 3; record++){
for (int column = 0; column < 3; column++){
square[record][column] = sc.nextInt();
}
}
sc.close();
// 行内にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
for (int record = 0; record < 3; record++){
registerIfNgPattern(record, 0, record, 1, record, 2);
registerIfNgPattern(record, 0, record, 2, record, 1);
registerIfNgPattern(record, 1, record, 2, record, 0);
}
// 列内にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
for (int column = 0; column < 3; column++){
registerIfNgPattern(0, column, 1, column, 2, column);
registerIfNgPattern(0, column, 2, column, 1, column);
registerIfNgPattern(1, column, 2, column, 0, column);
}
// 斜め (＼) にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
registerIfNgPattern(0, 0, 1, 1, 2, 2);
registerIfNgPattern(0, 0, 2, 2, 1, 1);
registerIfNgPattern(1, 1, 2, 2, 0, 0);
// 斜め (／) にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
registerIfNgPattern(0, 2, 1, 1, 2, 0);
registerIfNgPattern(0, 2, 2, 0, 1, 1);
registerIfNgPattern(1, 1, 2, 0, 0, 2);
// リーチの行・列の文字 を Array に詰める
String[] reachStringArray = reachStringSet.toArray(new String[reachStringSet.size()]);
// 並べ方の計算の事前準備
ArrayList<String> prepareList = new ArrayList<>();
prepareList.add("");
// 文字数 - 1 桁目までの全パターンを格納
ArrayList<String> addedList = new ArrayList<>();
for (int index = 0; index < reachStringArray.length - 1; index++){
for (String prepareStr : prepareList){
for (String str : reachStringArray){
if (prepareStr.contains(str)){
continue;
}
addedList.add(prepareStr + str);
}
}
prepareList = (ArrayList<String>) addedList.clone();
addedList.clear();
}
// 最後の文字を埋めつつ、並べ方の全数とがっかりしない並べ方の数を数える
int allCounter = 0;
int okCounter = 0;
for (String prepareStr : prepareList){
for (String str : reachStringArray){
if (prepareStr.contains(str)){
continue;
}
allCounter++;
boolean isOk = true;
for (Pattern pattern : ngPatternList){
if (pattern.matcher(prepareStr + str).matches()){
isOk = false;
continue;
}
}
if (isOk){
okCounter++;
}
}
}
// リーチの行・列が 1 つも無い場合、答えは 0
if (allCounter == 0){
System.out.println("0.000000000");
} else {
double answer = BigDecimal.valueOf(okCounter).divide(BigDecimal.valueOf(allCounter), 9, RoundingMode.HALF_UP).doubleValue();
System.out.println(answer);
}
}
private static void registerIfNgPattern(int compareRec1, int compareCol1, int compareRec2, int compareCol2, int anotherRec, int anotherCol){
if (square[compareRec1][compareCol1] == square[compareRec2][compareCol2]){
ngPatternList.add(Pattern.compile("^.*" + alphabetSquare[compareRec1][compareCol1] + ".*" + alphabetSquare[compareRec2][compareCol2] + ".*" + alphabetSquare[anotherRec][anotherCol] + ".*$"));
ngPatternList.add(Pattern.compile("^.*" + alphabetSquare[compareRec2][compareCol2] + ".*" + alphabetSquare[compareRec1][compareCol1] + ".*" + alphabetSquare[anotherRec][anotherCol] + ".*$"));
reachStringSet.add(alphabetSquare[compareRec1][compareCol1]);
reachStringSet.add(alphabetSquare[compareRec2][compareCol2]);
reachStringSet.add(alphabetSquare[anotherRec][anotherCol]);
}
}
}
/**
< 基本的な考え方 >
以下のような場合 (リーチは区別するために a,b を追加)
1 2a 2b
3 4 5
6 7 2c
1 行目でがっかりするのは ...2a/b...2b/a...1... の順に数字が並んだ場合
3 列目でがっかりするのは ...2c/b...2b/c...1... の順に数字が並んだ場合
上記のパターンを除いた 1,2a,2b,5,2c の並べ方の数を
1,2a,2b,5,2c の並べ方全体の数で割ればよい
< 処理するにあたって >
上記の場合
a b c
d e f
g h i
というマス目の並べ方のうち
...b...c...a...
...c...b...a...
...c...i...f...
...i...c...f...
の場合を除いた並べ方の確率と同じ
マス目の数字のまま計算するよりこちらの方が実装がちょっと楽なので
こちらで処理する
*/
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.regex.Pattern;
public class Main {
private static Scanner sc = new Scanner(System.in);
// 3*3 の二次元配列にマスを格納
private static int[][] square = new int[3][3];
// a, b, c, ... のマス目
private static String[][] alphabetSquare = {{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}};
// リーチの行・列の文字を格納するセット
private static Set<String> reachStringSet = new HashSet<>();
// NG のパターンを格納するリスト
private static List<Pattern> ngPatternList = new ArrayList<>();
public static void main(String[] args) {
// 3*3 の二次元配列にマスを格納
for (int record = 0; record < 3; record++){
for (int column = 0; column < 3; column++){
square[record][column] = sc.nextInt();
}
}
sc.close();
// 行内にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
for (int record = 0; record < 3; record++){
registerIfNgPattern(record, 0, record, 1, record, 2);
registerIfNgPattern(record, 0, record, 2, record, 1);
registerIfNgPattern(record, 1, record, 2, record, 0);
}
// 列内にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
for (int column = 0; column < 3; column++){
registerIfNgPattern(0, column, 1, column, 2, column);
registerIfNgPattern(0, column, 2, column, 1, column);
registerIfNgPattern(1, column, 2, column, 0, column);
}
// 斜め (＼) にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
registerIfNgPattern(0, 0, 1, 1, 2, 2);
registerIfNgPattern(0, 0, 2, 2, 1, 1);
registerIfNgPattern(1, 1, 2, 2, 0, 0);
// 斜め (／) にリーチがあるかチェック
// ある場合、NG パターンと計算に使用する文字を登録
registerIfNgPattern(0, 2, 1, 1, 2, 0);
registerIfNgPattern(0, 2, 2, 0, 1, 1);
registerIfNgPattern(1, 1, 2, 0, 0, 2);
// リーチの行・列の文字 を Array に詰める
String[] reachStringArray = reachStringSet.toArray(new String[reachStringSet.size()]);
// 並べ方の計算の事前準備
ArrayList<String> prepareList = new ArrayList<>();
prepareList.add("");
// 文字数 - 1 桁目までの全パターンを格納
ArrayList<String> addedList = new ArrayList<>();
for (int index = 0; index < reachStringArray.length - 1; index++){
for (String prepareStr : prepareList){
for (String str : reachStringArray){
if (prepareStr.contains(str)){
continue;
}
addedList.add(prepareStr + str);
}
}
prepareList = (ArrayList<String>) addedList.clone();
addedList.clear();
}
// 最後の文字を埋めつつ、並べ方の全数とがっかりしない並べ方の数を数える
int allCounter = 0;
int okCounter = 0;
for (String prepareStr : prepareList){
for (String str : reachStringArray){
if (prepareStr.contains(str)){
continue;
}
allCounter++;
boolean isOk = true;
for (Pattern pattern : ngPatternList){
if (pattern.matcher(prepareStr + str).matches()){
isOk = false;
continue;
}
}
if (isOk){
okCounter++;
}
}
}
// リーチの行・列が 1 つも無い場合、答えは 0
if (allCounter == 0){
System.out.println("1.000000000");
} else {
double answer = BigDecimal.valueOf(okCounter).divide(BigDecimal.valueOf(allCounter), 9, RoundingMode.HALF_UP).doubleValue();
System.out.println(answer);
}
}
private static void registerIfNgPattern(int compareRec1, int compareCol1, int compareRec2, int compareCol2, int anotherRec, int anotherCol){
if (square[compareRec1][compareCol1] == square[compareRec2][compareCol2]){
ngPatternList.add(Pattern.compile("^.*" + alphabetSquare[compareRec1][compareCol1] + ".*" + alphabetSquare[compareRec2][compareCol2] + ".*" + alphabetSquare[anotherRec][anotherCol] + ".*$"));
ngPatternList.add(Pattern.compile("^.*" + alphabetSquare[compareRec2][compareCol2] + ".*" + alphabetSquare[compareRec1][compareCol1] + ".*" + alphabetSquare[anotherRec][anotherCol] + ".*$"));
reachStringSet.add(alphabetSquare[compareRec1][compareCol1]);
reachStringSet.add(alphabetSquare[compareRec2][compareCol2]);
reachStringSet.add(alphabetSquare[anotherRec][anotherCol]);
}
}
}
| ConDefects/ConDefects/Code/abc319_c/Java/45760105 |
condefects-java_data_1906 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
class Solver extends Util{
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
// Object solve(){
// int N;
// // for (int j = 0;j < N;j++)
// // extracted(N,j);
// N = 200000;
// AVLSegmentTree<Data, Long> seg = avl(N);
// RangeData<Data, Long> seg2 = lazy(N);
// // for (int i = 0;i < N;i++) {
// // long v = rd.nextInt(1000);
// // seg.add(new Data(v));
// // seg2.upd(i,v);
// // }
// // for (int i = 0;i < N;i++) {
// // long a = seg.get(i).v;
// // long b = seg2.get(i).v;
// // assert a == b;
// // }
//
// while (elapsed() < 1000) {
// int i,j;
// do {
// i = rd.nextInt(N);
// j = rd.nextInt(N) +1;
// } while (i >= j);
// long x = rd.nextInt(10) +1;
// // log.printlns(i,j,x);
// if (rd.nextBoolean()) {
// seg.upd(i,j,x);
// seg2.upd(i,j,x);
// } else {
// var a = seg.get(i,j).v;
// var b = seg2.get(i,j).v;
// assert a == b : i +"," +j;
// }
// }
//
// int cnt = 0;
// seg = avl(N);
// reset();
// while (elapsed() < 1000) {
// cnt++;
// int i,j;
// do {
// i = rd.nextInt(N);
// j = rd.nextInt(N) +1;
// } while (i >= j);
// long x = rd.nextInt(10) +1;
// if (rd.nextBoolean())
// seg.upd(i,j,x);
// else
// seg.get(i,j);
// }
//
// return cnt;
// }
//
// private RangeData<Data, Long> lazy(int N){
// RangeData<Data, Long> seg2 = new LazySegmentTree<>(N){
// @Override
// protected Data e(){ return new Data(0); }
//
// @Override
// protected void agg(Data x,Data a,Data b){ x.v = a.v +b.v; }
//
// @Override
// protected void map(Data v,Long f){ v.v += f *v.sz; }
//
// @Override
// protected Long comp(Long f,Long g){ return f +g; }
// };
// return seg2;
// }
//
// private AVLSegmentTree<Data, Long> avl(int N){
// AVLSegmentTree<Data, Long> seg = new AVLSegmentTree<>(N){
// @Override
// protected Data e(){ return new Data(0); }
//
// @Override
// protected void agg(Data x,Data a,Data b){ x.v = a.v +b.v; }
//
// @Override
// protected void map(Data v,Long f){ v.v += f *v.sz; }
//
// @Override
// protected Long comp(Long f,Long g){ return f +g; }
//
// protected void pow(Data v,Data a,int n){ v.v += a.v *n; }
// };
// return seg;
// }
Object solve(){
int N = in.it();
int Q = in.it();
long[] A = in.lg(N);
var seg = new AVLSegmentTree<Data, long[]>(){
@Override
protected long[] comp(long[] f,long[] g){ return new long[]{f[0] *g[0] %mod, (f[1] *g[0] +g[1]) %mod}; }
@Override
protected Data e(){ return new Data(0); }
@Override
protected void map(Data v,long[] f){ v.v = (v.v *f[0] +f[1]) %mod; }
@Override
protected void agg(Data v,Data a,Data b){ v.v = a.v +b.v; }
};
seg.build(N,i -> new Data(A[i]));
long[] ans = new long[N];
while (Q-- > 0) {
int l = in.idx();
int r = in.it();
long inv = inv(r -l,mod);
long a = (r -l -1) *inv %mod;
long x = in.lg();
long b = x *inv %mod;
seg.upd(l,r,new long[]{a, b});
}
for (int i = 0;i < N;i++)
ans[i] = seg.get(i).v;
return ans;
}
long inv(long x,long mod){ return pow(x,mod -2,mod); }
long pow(long x,long n){ return pow(x,n,mod); }
long pow(long x,long n,long mod){
x %= mod;
long ret = 1;
while (0 < n) {
if ((n &1) == 1)
ret = ret *x %mod;
x = x *x %mod;
n >>= 1;
}
return ret;
}
}
class Data extends BaseV{
long v;
public Data(long v){ this.v = v; }
}
abstract class AVLSegmentTree<V extends BaseV, F> extends RangeData<V, F>{
private V e = e();
private Node nl = new Node(0);
public AVLSegmentTree(int n){ nl.cld(1,new Node(n)); }
public AVLSegmentTree(){ this(0); }
public void add(V v){ ins(size(),v); }
public void ins(int i,V v){
if (v.sz == 0)
v.sz = 1;
ins(nl.rht,i,v);
}
private void ins(Node nd,int i,V v){
if (nd.sz == 0) {
nd.val = v;
nd.sz = v.sz;
v.sz = 1;
return;
}
if (nd.leaf)
split(nd,i);
if (i == 0 || i < nd.lft.sz)
ins(nd.lft,i,v);
else
ins(nd.rht,i -nd.lft.sz,v);
if (abs(nd.bis) > 1)
nd.par.cld(nd.par.lft == nd ? -1 : 1,nd = rotate(nd));
nd.merge();
}
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
if (size() < r) {
var v = e();
v.sz = r -size();
add(v);
}
upd(nl.rht,l,r,f);
}
private void upd(Node nd,int l,int r,F f){
if (r < 1 || nd.sz < l || (l = max(0,l)) == (r = min(nd.sz,r)))
return;
if (l == 0 && r == nd.sz) {
nd.prop(f);
return;
}
if (nd.leaf)
split(nd,0 < l ? l : r);
else
nd.push();
upd(nd.lft,l,r,f);
upd(nd.rht,l -nd.lft.sz,r -nd.lft.sz,f);
if (abs(nd.bis) > 1)
nd.par.cld(nd.par.lft == nd ? -1 : 1,nd = rotate(nd));
nd.merge();
}
private void split(Node nd,int c){
nd.leaf = false;
nd.cld(-1,new Node(nd.val,c));
nd.cld(1,new Node(nd.sz -c));
agg(nd.rht.val,nd.val,e);
nd.val = e();
}
public void build(int n,IntFunction<V> init){ nl.cld(1,build(0,n,init)); }
private Node build(int i,int n,IntFunction<V> init){
var ret = new Node(n);
if (n == 1) {
ret.val = init.apply(i);
ret.val.sz = 1;
} else {
ret.leaf = false;
ret.cld(-1,build(i,n /2,init));
ret.cld(1,build(i +n /2,n -n /2,init));
ret.merge();
}
return ret;
}
@Override
public V get(int i){ return get(i,i +1); }
@Override
public V get(int l,int r){
V ret = e();
get(ret,nl.rht,l,r);
return ret;
}
private void get(V ret,Node nd,int l,int r){
if (r < 1 || nd.sz < l)
return;
l = max(0,l);
r = min(nd.sz,r);
if (l == r)
return;
if (l == 0 && r == nd.sz) {
agg(ret,ret,nd.val());
ret.sz += nd.sz;
return;
}
if (nd.leaf) {
pow(ret,nd.val,r -l);
ret.sz += r -l;
return;
}
nd.push();
get(ret,nd.lft,l,r);
get(ret,nd.rht,l -nd.lft.sz,r -nd.lft.sz);
}
public V all(){ return nl.rht.val(); }
public int size(){ return nl.rht.sz; }
private class Node{
private int rnk,bis,sz;
private V val;
private F laz;
private Node par,lft,rht;
private boolean leaf = true;
private Node(int sz){ this(e(),sz); }
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){
if (c < 0)
lft = nd;
else
rht = nd;
nd.par = this;
}
private void merge(){
if (leaf)
return;
rnk = max(lft.rnk,rht.rnk) +1;
bis = rht.rnk -lft.rnk;
agg(val,lft.val(),rht.val());
val.sz = sz = lft.sz +rht.sz;
}
private V val(){
if (leaf && 1 < sz) {
var ret = e();
pow(ret,val,sz);
ret.sz = sz;
return ret;
}
return val;
}
private void push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
}
private void prop(F f){
map(val,f);
if (!leaf)
laz = laz == null ? f : comp(laz,f);
}
}
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected void pow(V v,V a,int n){
var x = e();
agg(x,e,a);
x.sz = a.sz;
while (true) {
if ((n &1) == 1) {
agg(v,v,x);
v.sz += x.sz;
}
n >>= 1;
if (n == 0)
break;
agg(x,x,x);
x.sz <<= 1;
}
}
protected F comp(F f,F g){ return null; }
private Node rotate(Node u){
var v = u.cld(u.bis);
v.push();
if (u.bis *v.bis < 0)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.merge();
return v;
}
}
abstract class SegmentTree<V extends BaseV, F> extends Seg<V, F>{
public SegmentTree(int n){ super(n); }
@Override
protected abstract void agg(V v,V a,V b);
@Override
public void upd(int i,F f){
super.upd(i,f);
up(i,i +1);
}
}
abstract class DualSegmentTree<V extends BaseV, F> extends Seg<V, F>{
public DualSegmentTree(int n){ super(n); }
@Override
protected void rangeMap(int i){}
@Override
protected abstract F comp(F f,F g);
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
public V get(int i){
down(i,i +1);
return super.get(i);
}
}
abstract class LazySegmentTree<V extends BaseV, F> extends Seg<V, F>{
public LazySegmentTree(int n){ super(n); }
@Override
protected abstract void agg(V v,V a,V b);
@Override
protected abstract F comp(F f,F g);
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
up(l,r);
}
@Override
public V get(int i){ return get(i,i +1); }
@Override
public V get(int l,int r){
down(l,r);
return super.get(l,r);
}
}
abstract class Seg<V extends BaseV, F> extends RangeData<V, F>{
private int n,log;
private V[] val;
private F[] lazy;
@SuppressWarnings("unchecked")
Seg(int n){
this.n = n;
while (1 <<log <= n)
log++;
val = (V[]) new BaseV[n <<1];
lazy = (F[]) new Object[n];
for (int i = -1;++i < n;) {
V v = val[i +n] = init(i);
v.sz = 1;
}
for (int i = n;--i > 0;merge(i)) {
V v = val[i] = e();
v.sz = val[i <<1].sz +val[i <<1 |1].sz;
}
}
protected abstract V e();
protected V init(int i){ return e(); }
protected void agg(V v,V a,V b){}
protected abstract void map(V v,F f);
protected void rangeMap(int i){ map(val[i],lazy[i]); }
protected F comp(F f,F g){ return null; }
private V eval(int i){
if (0 < i && i < n && lazy[i] != null) {
rangeMap(i);
prop(i <<1,lazy[i]);
prop(i <<1 |1,lazy[i]);
lazy[i] = null;
}
return val[i];
}
private void merge(int i){ agg(val[i],eval(i <<1),eval(i <<1 |1)); }
private void prop(int i,F f){
if (i < n)
lazy[i] = lazy[i] == null ? f : comp(lazy[i],f);
else
map(val[i],f);
}
protected void up(int l,int r){
for (l = oddPart(l +n),r = oddPart(r +n);l != r;)
merge(l > r ? (l >>= 1) : (r >>= 1));
while (1 < l)
merge(l >>= 1);
}
protected void down(int l,int r){
int i = log;
for (l = oddPart(l +n),r = oddPart(r +n);i > 0;i--) {
eval(l >>i);
eval(r >>i);
}
}
private int oddPart(int i){ return i /(i &-i); }
@Override
public void upd(int i,F f){ prop(i +n,f); }
@Override
public void upd(int l,int r,F f){
for (l += n,r += n;l < r;l >>= 1,r >>= 1) {
if ((l &1) == 1)
prop(l++,f);
if ((r &1) == 1)
prop(--r,f);
}
}
@Override
public V get(int i){ return val[i +n]; }
@Override
public V get(int l,int r){
V vl = e(),vr = e();
for (l += n,r += n;l < r;l >>= 1,r >>= 1) {
if ((l &1) == 1) {
var t = eval(l++);
agg(vl,vl,t);
vl.sz += t.sz;
}
if ((r &1) == 1) {
var t = eval(--r);
agg(vr,t,vr);
vr.sz += t.sz;
}
}
agg(vl,vl,vr);
return vl;
}
}
abstract class BaseV{ int sz; }
abstract class RangeData<V, F> {
public void upd(int i,F f){}
public void upd(int l,int r,F f){}
public V get(int i){ return null; }
public V get(int l,int r){ return null; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<60 |1 <<30) -1;
private long st = System.currentTimeMillis();
public static Random rd = ThreadLocalRandom.current();
public MyReader in = new MyReader(System.in);
public MyWriter out = new MyWriter(System.out);
public MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
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{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
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 ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[] cs)
for (char b:cs)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Iterable<?> co)
for (Object e:co)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
void printlns(Object... o){
print(o);
ln();
}
}
class Main{
public static void main(String[] args) throws Exception{
new Solver(){
public void exe(){
out.println(solve());
out.flush();
log.println(elapsed());
}
}.exe();
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import java.util.stream.*;
class Solver extends Util{
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
// Object solve(){
// int N;
// // for (int j = 0;j < N;j++)
// // extracted(N,j);
// N = 200000;
// AVLSegmentTree<Data, Long> seg = avl(N);
// RangeData<Data, Long> seg2 = lazy(N);
// // for (int i = 0;i < N;i++) {
// // long v = rd.nextInt(1000);
// // seg.add(new Data(v));
// // seg2.upd(i,v);
// // }
// // for (int i = 0;i < N;i++) {
// // long a = seg.get(i).v;
// // long b = seg2.get(i).v;
// // assert a == b;
// // }
//
// while (elapsed() < 1000) {
// int i,j;
// do {
// i = rd.nextInt(N);
// j = rd.nextInt(N) +1;
// } while (i >= j);
// long x = rd.nextInt(10) +1;
// // log.printlns(i,j,x);
// if (rd.nextBoolean()) {
// seg.upd(i,j,x);
// seg2.upd(i,j,x);
// } else {
// var a = seg.get(i,j).v;
// var b = seg2.get(i,j).v;
// assert a == b : i +"," +j;
// }
// }
//
// int cnt = 0;
// seg = avl(N);
// reset();
// while (elapsed() < 1000) {
// cnt++;
// int i,j;
// do {
// i = rd.nextInt(N);
// j = rd.nextInt(N) +1;
// } while (i >= j);
// long x = rd.nextInt(10) +1;
// if (rd.nextBoolean())
// seg.upd(i,j,x);
// else
// seg.get(i,j);
// }
//
// return cnt;
// }
//
// private RangeData<Data, Long> lazy(int N){
// RangeData<Data, Long> seg2 = new LazySegmentTree<>(N){
// @Override
// protected Data e(){ return new Data(0); }
//
// @Override
// protected void agg(Data x,Data a,Data b){ x.v = a.v +b.v; }
//
// @Override
// protected void map(Data v,Long f){ v.v += f *v.sz; }
//
// @Override
// protected Long comp(Long f,Long g){ return f +g; }
// };
// return seg2;
// }
//
// private AVLSegmentTree<Data, Long> avl(int N){
// AVLSegmentTree<Data, Long> seg = new AVLSegmentTree<>(N){
// @Override
// protected Data e(){ return new Data(0); }
//
// @Override
// protected void agg(Data x,Data a,Data b){ x.v = a.v +b.v; }
//
// @Override
// protected void map(Data v,Long f){ v.v += f *v.sz; }
//
// @Override
// protected Long comp(Long f,Long g){ return f +g; }
//
// protected void pow(Data v,Data a,int n){ v.v += a.v *n; }
// };
// return seg;
// }
Object solve(){
int N = in.it();
int Q = in.it();
long[] A = in.lg(N);
var seg = new AVLSegmentTree<Data, long[]>(){
@Override
protected long[] comp(long[] f,long[] g){ return new long[]{f[0] *g[0] %mod, (f[1] *g[0] +g[1]) %mod}; }
@Override
protected Data e(){ return new Data(0); }
@Override
protected void map(Data v,long[] f){ v.v = (v.v *f[0] +f[1]) %mod; }
@Override
protected void agg(Data v,Data a,Data b){ v.v = (a.v +b.v) %mod; }
};
seg.build(N,i -> new Data(A[i]));
long[] ans = new long[N];
while (Q-- > 0) {
int l = in.idx();
int r = in.it();
long inv = inv(r -l,mod);
long a = (r -l -1) *inv %mod;
long x = in.lg();
long b = x *inv %mod;
seg.upd(l,r,new long[]{a, b});
}
for (int i = 0;i < N;i++)
ans[i] = seg.get(i).v;
return ans;
}
long inv(long x,long mod){ return pow(x,mod -2,mod); }
long pow(long x,long n){ return pow(x,n,mod); }
long pow(long x,long n,long mod){
x %= mod;
long ret = 1;
while (0 < n) {
if ((n &1) == 1)
ret = ret *x %mod;
x = x *x %mod;
n >>= 1;
}
return ret;
}
}
class Data extends BaseV{
long v;
public Data(long v){ this.v = v; }
}
abstract class AVLSegmentTree<V extends BaseV, F> extends RangeData<V, F>{
private V e = e();
private Node nl = new Node(0);
public AVLSegmentTree(int n){ nl.cld(1,new Node(n)); }
public AVLSegmentTree(){ this(0); }
public void add(V v){ ins(size(),v); }
public void ins(int i,V v){
if (v.sz == 0)
v.sz = 1;
ins(nl.rht,i,v);
}
private void ins(Node nd,int i,V v){
if (nd.sz == 0) {
nd.val = v;
nd.sz = v.sz;
v.sz = 1;
return;
}
if (nd.leaf)
split(nd,i);
if (i == 0 || i < nd.lft.sz)
ins(nd.lft,i,v);
else
ins(nd.rht,i -nd.lft.sz,v);
if (abs(nd.bis) > 1)
nd.par.cld(nd.par.lft == nd ? -1 : 1,nd = rotate(nd));
nd.merge();
}
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
if (size() < r) {
var v = e();
v.sz = r -size();
add(v);
}
upd(nl.rht,l,r,f);
}
private void upd(Node nd,int l,int r,F f){
if (r < 1 || nd.sz < l || (l = max(0,l)) == (r = min(nd.sz,r)))
return;
if (l == 0 && r == nd.sz) {
nd.prop(f);
return;
}
if (nd.leaf)
split(nd,0 < l ? l : r);
else
nd.push();
upd(nd.lft,l,r,f);
upd(nd.rht,l -nd.lft.sz,r -nd.lft.sz,f);
if (abs(nd.bis) > 1)
nd.par.cld(nd.par.lft == nd ? -1 : 1,nd = rotate(nd));
nd.merge();
}
private void split(Node nd,int c){
nd.leaf = false;
nd.cld(-1,new Node(nd.val,c));
nd.cld(1,new Node(nd.sz -c));
agg(nd.rht.val,nd.val,e);
nd.val = e();
}
public void build(int n,IntFunction<V> init){ nl.cld(1,build(0,n,init)); }
private Node build(int i,int n,IntFunction<V> init){
var ret = new Node(n);
if (n == 1) {
ret.val = init.apply(i);
ret.val.sz = 1;
} else {
ret.leaf = false;
ret.cld(-1,build(i,n /2,init));
ret.cld(1,build(i +n /2,n -n /2,init));
ret.merge();
}
return ret;
}
@Override
public V get(int i){ return get(i,i +1); }
@Override
public V get(int l,int r){
V ret = e();
get(ret,nl.rht,l,r);
return ret;
}
private void get(V ret,Node nd,int l,int r){
if (r < 1 || nd.sz < l)
return;
l = max(0,l);
r = min(nd.sz,r);
if (l == r)
return;
if (l == 0 && r == nd.sz) {
agg(ret,ret,nd.val());
ret.sz += nd.sz;
return;
}
if (nd.leaf) {
pow(ret,nd.val,r -l);
ret.sz += r -l;
return;
}
nd.push();
get(ret,nd.lft,l,r);
get(ret,nd.rht,l -nd.lft.sz,r -nd.lft.sz);
}
public V all(){ return nl.rht.val(); }
public int size(){ return nl.rht.sz; }
private class Node{
private int rnk,bis,sz;
private V val;
private F laz;
private Node par,lft,rht;
private boolean leaf = true;
private Node(int sz){ this(e(),sz); }
private Node(V val,int sz){
this.sz = sz;
this.val = val;
val.sz = 1;
}
private Node cld(int c){ return c < 0 ? lft : rht; }
private void cld(int c,Node nd){
if (c < 0)
lft = nd;
else
rht = nd;
nd.par = this;
}
private void merge(){
if (leaf)
return;
rnk = max(lft.rnk,rht.rnk) +1;
bis = rht.rnk -lft.rnk;
agg(val,lft.val(),rht.val());
val.sz = sz = lft.sz +rht.sz;
}
private V val(){
if (leaf && 1 < sz) {
var ret = e();
pow(ret,val,sz);
ret.sz = sz;
return ret;
}
return val;
}
private void push(){
if (laz != null) {
lft.prop(laz);
rht.prop(laz);
laz = null;
}
}
private void prop(F f){
map(val,f);
if (!leaf)
laz = laz == null ? f : comp(laz,f);
}
}
protected abstract V e();
protected abstract void agg(V v,V a,V b);
protected abstract void map(V v,F f);
protected void pow(V v,V a,int n){
var x = e();
agg(x,e,a);
x.sz = a.sz;
while (true) {
if ((n &1) == 1) {
agg(v,v,x);
v.sz += x.sz;
}
n >>= 1;
if (n == 0)
break;
agg(x,x,x);
x.sz <<= 1;
}
}
protected F comp(F f,F g){ return null; }
private Node rotate(Node u){
var v = u.cld(u.bis);
v.push();
if (u.bis *v.bis < 0)
v = rotate(v);
u.cld(u.bis,v.cld(-u.bis));
v.cld(-u.bis,u);
u.merge();
return v;
}
}
abstract class SegmentTree<V extends BaseV, F> extends Seg<V, F>{
public SegmentTree(int n){ super(n); }
@Override
protected abstract void agg(V v,V a,V b);
@Override
public void upd(int i,F f){
super.upd(i,f);
up(i,i +1);
}
}
abstract class DualSegmentTree<V extends BaseV, F> extends Seg<V, F>{
public DualSegmentTree(int n){ super(n); }
@Override
protected void rangeMap(int i){}
@Override
protected abstract F comp(F f,F g);
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
public V get(int i){
down(i,i +1);
return super.get(i);
}
}
abstract class LazySegmentTree<V extends BaseV, F> extends Seg<V, F>{
public LazySegmentTree(int n){ super(n); }
@Override
protected abstract void agg(V v,V a,V b);
@Override
protected abstract F comp(F f,F g);
@Override
public void upd(int i,F f){ upd(i,i +1,f); }
@Override
public void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
up(l,r);
}
@Override
public V get(int i){ return get(i,i +1); }
@Override
public V get(int l,int r){
down(l,r);
return super.get(l,r);
}
}
abstract class Seg<V extends BaseV, F> extends RangeData<V, F>{
private int n,log;
private V[] val;
private F[] lazy;
@SuppressWarnings("unchecked")
Seg(int n){
this.n = n;
while (1 <<log <= n)
log++;
val = (V[]) new BaseV[n <<1];
lazy = (F[]) new Object[n];
for (int i = -1;++i < n;) {
V v = val[i +n] = init(i);
v.sz = 1;
}
for (int i = n;--i > 0;merge(i)) {
V v = val[i] = e();
v.sz = val[i <<1].sz +val[i <<1 |1].sz;
}
}
protected abstract V e();
protected V init(int i){ return e(); }
protected void agg(V v,V a,V b){}
protected abstract void map(V v,F f);
protected void rangeMap(int i){ map(val[i],lazy[i]); }
protected F comp(F f,F g){ return null; }
private V eval(int i){
if (0 < i && i < n && lazy[i] != null) {
rangeMap(i);
prop(i <<1,lazy[i]);
prop(i <<1 |1,lazy[i]);
lazy[i] = null;
}
return val[i];
}
private void merge(int i){ agg(val[i],eval(i <<1),eval(i <<1 |1)); }
private void prop(int i,F f){
if (i < n)
lazy[i] = lazy[i] == null ? f : comp(lazy[i],f);
else
map(val[i],f);
}
protected void up(int l,int r){
for (l = oddPart(l +n),r = oddPart(r +n);l != r;)
merge(l > r ? (l >>= 1) : (r >>= 1));
while (1 < l)
merge(l >>= 1);
}
protected void down(int l,int r){
int i = log;
for (l = oddPart(l +n),r = oddPart(r +n);i > 0;i--) {
eval(l >>i);
eval(r >>i);
}
}
private int oddPart(int i){ return i /(i &-i); }
@Override
public void upd(int i,F f){ prop(i +n,f); }
@Override
public void upd(int l,int r,F f){
for (l += n,r += n;l < r;l >>= 1,r >>= 1) {
if ((l &1) == 1)
prop(l++,f);
if ((r &1) == 1)
prop(--r,f);
}
}
@Override
public V get(int i){ return val[i +n]; }
@Override
public V get(int l,int r){
V vl = e(),vr = e();
for (l += n,r += n;l < r;l >>= 1,r >>= 1) {
if ((l &1) == 1) {
var t = eval(l++);
agg(vl,vl,t);
vl.sz += t.sz;
}
if ((r &1) == 1) {
var t = eval(--r);
agg(vr,t,vr);
vr.sz += t.sz;
}
}
agg(vl,vl,vr);
return vl;
}
}
abstract class BaseV{ int sz; }
abstract class RangeData<V, F> {
public void upd(int i,F f){}
public void upd(int l,int r,F f){}
public V get(int i){ return null; }
public V get(int l,int r){ return null; }
}
class Util{
public static String yes = "Yes",no = "No";
public static int infI = (1 <<30) -1;
public static long infL = (1L <<60 |1 <<30) -1;
private long st = System.currentTimeMillis();
public static Random rd = ThreadLocalRandom.current();
public MyReader in = new MyReader(System.in);
public MyWriter out = new MyWriter(System.out);
public MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
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{
private byte[] buf = new byte[1 <<16];
private int ptr,tail;
private InputStream in;
MyReader(InputStream in){ this.in = in; }
private byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
private boolean isPrintable(byte c){ return 32 < c && c < 127; }
private byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
long lg(){
byte i = nextPrintable();
boolean negative = i == 45;
long n = negative ? 0 : i -'0';
while (isPrintable(i = read()))
n = 10 *n +i -'0';
return negative ? -n : n;
}
long[] lg(int N){ return Util.arrL(N,i -> lg()); }
long[][] lg(int H,int W){ return Util.arr(new long[H][],i -> lg(W)); }
double dbl(){ return Double.parseDouble(str()); }
double[] dbl(int N){ return Util.arrD(N,i -> dbl()); }
double[][] dbl(int H,int W){ return Util.arr(new double[H][],i -> dbl(W)); }
char[] ch(){ return str().toCharArray(); }
char[][] ch(int H){ return Util.arr(new char[H][],i -> ch()); }
String line(){
StringBuilder sb = new StringBuilder();
for (byte c;(c = read()) != '\n';)
sb.append((char) c);
return sb.toString();
}
String str(){
StringBuilder sb = new StringBuilder();
sb.append((char) nextPrintable());
for (byte c;isPrintable(c = read());)
sb.append((char) c);
return sb.toString();
}
String[] str(int N){ return Util.arr(new String[N],i -> str()); }
}
class MyWriter{
private OutputStream out;
private byte[] buf = new byte[1 <<16],ibuf = new byte[20];
private int tail;
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 ? Util.yes : Util.no);
else if (obj instanceof Integer)
write((int) obj);
else if (obj instanceof Long)
write((long) obj);
else if (obj instanceof char[] cs)
for (char b:cs)
write((byte) b);
else if (obj.getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++) {
print(Array.get(obj,i));
if (i +1 < l)
write((byte) ' ');
}
} else
print(Objects.toString(obj).toCharArray());
}
void println(Object obj){
if (obj == null)
return;
if (obj instanceof Iterable<?> co)
for (Object e:co)
println(e);
else if (obj.getClass().isArray() && Array.getLength(obj) > 0 && Array.get(obj,0).getClass().isArray()) {
int l = Array.getLength(obj);
for (int i = 0;i < l;i++)
println(Array.get(obj,i));
} else {
print(obj);
ln();
}
}
void printlns(Object... o){
print(o);
ln();
}
}
class Main{
public static void main(String[] args) throws Exception{
new Solver(){
public void exe(){
out.println(solve());
out.flush();
log.println(elapsed());
}
}.exe();
}
}
| ConDefects/ConDefects/Code/abc332_f/Java/48528522 |
condefects-java_data_1907 | import java.awt.Dimension;
import java.awt.Point;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.FilterOutputStream;
import java.io.Flushable;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Formatter;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.function.DoubleUnaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;
//Maybe use
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.TreeMap;
import java.util.TreeSet;
final class Main{
private static final boolean autoFlush = false;
private static final SimpleScanner sc = new SimpleScanner(System.in);
private static final SimpleWriter out = new SimpleWriter(System.out,autoFlush);
private static final int MOD = 998244353;
private static class F{
final long a,b;
F(long a,long b){
this.a = a;
this.b = b;
}
}
public static void main(String[] args){
int N = sc.nextInt();
int M = sc.nextInt();
Long[] A = new Long[N];
for(int i=0;i<N;i++)
A[i] = sc.nextLong();
final F origin = new F(1,0);
LazySegmentTree<Long,F> lSegT = new LazySegmentTree<>(A,0L,origin,false){
public Long function(Long a,Long b){
return a;
}
public Long mapping(Long a,F f){
return (a*f.a%MOD+f.b)%MOD;
}
public F composition(F a,F b){
long c = a.a*b.a%MOD;
long d = (b.a*a.b%MOD+b.b)%MOD;
return new F(c,d);
}
};
while(M-->0){
int L = sc.nextInt();
int R = sc.nextInt();
int X = sc.nextInt()%MOD;
long a = (R-L)*MathFunction.modPow(R-L+1,MOD-2,MOD)%MOD;
long b = X*MathFunction.modPow(R-L+1,MOD-2,MOD)%MOD;
lSegT.apply(L-1,R,new F(a,b));
}
long[] ans = new long[N];
for(int i=0;i<N;i++)
ans[i] = lSegT.get(i);
out.println(ans);
out.close();
}
}
/*
,.へ
___ ﾑ i
「ﾋ_i〉 ゝ 〈
ﾄ ノ iニ()
i { ＿＿＿_ | ヽ
i i ／_, ,‐-＼ i }
| i ／（●) ( ● )＼ {､ λ
ト－┤. ／ （__人__） ＼ ,ノ￣,!
i ゝ､_ | ´￣` | ,. '´ﾊ ,!
ヽ、 ｀`､,__＼ ／" ＼ ヽ／
＼ノ ﾉ ﾊ￣ r/::r―--―/:７ ﾉ ／
ヽ. ヽ:<:'::'|:/ / ,."
`ｰ ､ ＼ヽ:::|/ ｒ'"
／￣二二二二二二二二二二二二二二二二二ヽ
| 答 | A C │|
＼＿二二二二二二二二二二二二二二二二二ノ
*/
/*////////////////////////////////////////////////////////////////////////////////////////////
* My Library *
@author viral
*/////////////////////////////////////////////////////////////////////////////////////////////
final class Factorial{
//階乗とその逆元
private final long[] fact, inFact;
private final long mod;
/**
* 1～Nの階乗とその逆元をmodで割ったあまりを事前に計算します。
*
* @param N 計算範囲
* @param mod 法
*/
public Factorial(final int N,final long mod){
fact = new long[N+1];
fact[0] = fact[1] = 1;
for(int i = 2;i<=N;++i){
fact[i] = fact[i-1]*i%mod;
}
inFact = new long[N+1];
inFact[N] = MathFunction.modPow(fact[N],mod-2,mod);
for(int i = N;i>0;--i){
inFact[i-1] = inFact[i]*i%mod;
}
inFact[0] = 1;
this.mod = mod;
}
/**
* num!をmodで割ったあまりを返します。
*
* @param num num!となるnum
*
* @return num!
*/
public long getFact(final int num){
return fact[num];
}
/**
* num!^-1をmodで割ったあまりを返します。
*
* @param num num!^-1となるnum
*
* @return num!
*/
public long getInFact(final int num){
return inFact[num];
}
/**
* modを法とした時のnum^-1を返します。
*
* @param num num^-1 mod mとなるnum
*
* @return num!
*/
public long getInverse(final int num){
return fact[num-1]*inFact[num]%mod;
}
/**
* aCbをmodで割ったあまりを返します。
*
* @param a aCbとなるa
* @param b aCbとなるb
*
* @return aCb
*/
public long getCombi(final int a,final int b){
if(a<b||a<0||b<0){
return 0;
}
return (fact[a]*inFact[a-b]%mod)*inFact[b]%mod;
}
}
final class ArrayFunction{
/**
* カウントソートによるソートです。
* 各要素が0以上であり最大値が十分小さい時はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param maximumLimit array内の最大要素
*/
public static void countSort(final int[] array,final int maximumLimit){
countSort(array,0,array.length,maximumLimit);
}
/**
* カウントソートによるソートです。
* 各要素が0以上であり最大値が十分小さい時はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
* @param maximumLimit array内の最大要素
*/
public static void countSort(final int[] array,final int l,final int r,final int maximumLimit){
final int[] list = new int[maximumLimit+1];
for(int i = l;i<r;++i){
++list[array[i]];
}
int temp = l;
for(int i = 0;i<list.length;++i){
while(list[i]-->0){
array[temp++] = i;
}
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void insertSort(final int[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のlong型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void insertSort(final long[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のchar型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void insertSort(final char[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象の配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static <E extends Comparable<E>> void insertSort(final E[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])>0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void reverseInsertSort(final int[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のlong型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void reverseInsertSort(final long[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のchar型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void reverseInsertSort(final char[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象の配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static <E extends Comparable<E>> void reverseInsertSort(final E[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])<0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateR(final int[][] array){
final int[][] ans = new int[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateR(final long[][] array){
final long[][] ans = new long[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateR(final char[][] array){
final char[][] ans = new char[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateR(final double[][] array){
final double[][] ans = new double[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateR(final boolean[][] array){
final boolean[][] ans = new boolean[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateR(final E[][] array,final E[][] ans){
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateL(final int[][] array){
final int[][] ans = new int[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
final int index = i;
Arrays.setAll(ans[i],k->array[k][ans.length-index-1]);
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateL(final long[][] array){
final long[][] ans = new long[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
final int index = i;
Arrays.setAll(ans[i],k->array[k][ans.length-index-1]);
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateL(final char[][] array){
final char[][] ans = new char[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateL(final double[][] array){
final double[][] ans = new double[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateL(final boolean[][] array){
final boolean[][] ans = new boolean[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateL(final E[][] array,final E[][] ans){
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(int[] array){
return lis(array,false);
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(int[][] arrays,int p){
return lis(arrays,p,false);
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(long[] array){
return lis(array,false);
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(long[][] arrays,int p){
return lis(arrays,p,false);
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(int[] array,boolean include){
int[] list = new int[array.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int num: array){
int index = include?Searcher.overSearch(list,num):Searcher.upSearch(list,num);
list[index] = Math.min(list[index],num);
}
int answer = Searcher.underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(int[][] arrays,int p,boolean include){
int[] list = new int[arrays.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int[] array: arrays){
int index = include?Searcher.overSearch(list,array[p]):Searcher.upSearch(list,array[p]);
list[index] = Math.min(list[index],array[p]);
}
int answer = Searcher.underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(long[] array,boolean include){
long[] list = new long[array.length];
Arrays.fill(list,Long.MAX_VALUE);
for(long num: array){
int index = include?Searcher.overSearch(list,num):Searcher.upSearch(list,num);
list[index] = Math.min(list[index],num);
}
int answer = Searcher.underSearch(list,Long.MAX_VALUE);
return answer+1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(long[][] arrays,int p,boolean include){
long[] list = new long[arrays.length];
Arrays.fill(list,Long.MAX_VALUE);
for(long[] array: arrays){
int index = include?Searcher.overSearch(list,array[p]):Searcher.upSearch(list,array[p]);
list[index] = Math.min(list[index],array[p]);
}
int answer = Searcher.underSearch(list,Long.MAX_VALUE);
return answer+1;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort(final ArrayList<ArrayList<Integer>> route){
final int[] count = new int[route.size()];
int pathCount = 0;
for(final ArrayList<Integer> path: route){
for(final int point: path){
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for(int i = 1;i<count.length;++i){
if(count[i]==0){
deq.add(i);
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while(deq.size()>0){
int nowP = deq.pollFirst();
for(final int nextP: route.get(nowP)){
ans[index][0] = nowP;
ans[index++][1] = nextP;
if(--count[nextP]==0){
deq.add(nextP);
}
}
}
return ans;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort(final int[][] route){
final int[] count = new int[route.length];
int pathCount = 0;
for(final int[] path: route){
for(final int point: path){
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for(int i = 1;i<count.length;++i){
if(count[i]==0){
deq.add(i);
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while(deq.size()>0){
int nowP = deq.pollFirst();
for(final int nextP: route[nowP]){
ans[index][0] = nowP;
ans[index++][1] = nextP;
if(--count[nextP]==0){
deq.add(nextP);
}
}
}
return ans;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final int[] array,final int a,final int b){
final int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final long[] array,final int a,final int b){
final long temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final double[] array,final int a,final int b){
final double temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final char[] array,final int a,final int b){
final char temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final boolean[] array,final int a,final int b){
final boolean temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static <E> void swap(final E[] array,final int a,final int b){
final E temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final int[][] array,final int a,final int b,final int c,final int d){
final int temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final long[][] array,final int a,final int b,final int c,final int d){
final long temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final double[][] array,final int a,final int b,final int c,final int d){
final double temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final char[][] array,final int a,final int b,final int c,final int d){
final char temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final boolean[][] array,final int a,final int b,final int c,final int d){
final boolean temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static <E> void swap(final E[][] array,final int a,final int b,final int c,final int d){
final E temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation(final int[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]<array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation(final long[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]<array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
long min = Long.MAX_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation(final char[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]<array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static <E extends Comparable<E>> boolean nextPermutation(final E[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1].compareTo(array[i])<0){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = -1;
E min = MathFunction.max(array);
int subIndex = -1;
E max = array[index1];
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
if(max.compareTo(array[i])<0){
subIndex = i;
max = array[i];
}
}
if(index2==-1){
swap(array,index1,subIndex);
}
else{
swap(array,index1,index2);
}
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static boolean previousPermutation(final int[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]>array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static boolean previousPermutation(final long[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]>array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
long max = Long.MIN_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static boolean previousPermutation(final char[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]>array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static <E extends Comparable<E>> boolean previousPermutation(final E[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1].compareTo(array[i])>0){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = -1;
E max = MathFunction.min(array);
int subIndex = -1;
E min = array[index1];
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
if(min.compareTo(array[i])>0){
subIndex = i;
min = array[i];
}
}
if(index2==-1){
swap(array,index1,subIndex);
}
else{
swap(array,index1,index2);
}
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static int[] reBuild(final int[] array,final IntUnaryOperator func){
final int[] ans = new int[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsInt(array[i]);
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static int[] reBuild(final int[] array,final IntBinaryOperator func){
final int[] ans = new int[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsInt(i,array[i]);
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static long[] reBuild(final long[] array,final LongUnaryOperator func){
final long[] ans = new long[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsLong(array[i]);
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static long[] reBuild(final long[] array,final LongBinaryOperator func){
final long[] ans = new long[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsLong(i,array[i]);
}
return ans;
}
/**
* 配列の要素を順に引数のConsumerに作用させます。
*
* @param array 作用させる配列
* @param func 作用先のConsumer
*/
public static void computeByArray(final int[] array,final IntConsumer func){
for(final int num: array){
func.accept(num);
}
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final int[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final long[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final double[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final char[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final boolean[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static <E> void reverseRange(final E[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* Mo's Algorithm用のComparatorを返します。
*
* @param 分割数
* @return Mo's Algorithm用のComparator
*/
public static Comparator<int[]> mo_sComparator(final int M){
return (a,b)->a[0]/M!=b[0]/M?Integer.compare(a[0]/M,b[0]/M):
Integer.compare(a[1]/M,b[1]/M)*((a[0]/M&1)==0?-1:1);
}
}
final class Converter{
/**
* 渡された文字列を逆順にした文字列を返します。
*
* @param str 元の文字列
*
* @return strを逆順にした文字列
*/
public static String reverse(final String str){
final StringBuilder sb = new StringBuilder();
for(int i = str.length()-1;i>=0;--i){
sb.append(str.charAt(i));
}
return sb.toString();
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static int[] toIntArray(final List<Integer> list){
final int[] ans = new int[list.size()];
int index = 0;
for(int num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static long[] toLongArray(final List<Long> list){
final long[] ans = new long[list.size()];
int index = 0;
for(long num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static char[] toCharArray(final List<Character> list){
final char[] ans = new char[list.size()];
int index = 0;
for(char num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static double[] toDoubleArray(final List<Double> list){
final double[] ans = new double[list.size()];
int index = 0;
for(double num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static boolean[] toBooleanArray(final List<Boolean> list){
final boolean[] ans = new boolean[list.size()];
int index = 0;
for(boolean num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static byte[] toByteArray(final List<Byte> list){
final byte[] ans = new byte[list.size()];
int index = 0;
for(byte num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static short[] toShortArray(final List<Short> list){
final short[] ans = new short[list.size()];
int index = 0;
for(short num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static float[] toFloatArray(final List<Float> list){
final float[] ans = new float[list.size()];
int index = 0;
for(float num: list){
ans[index++] = num;
}
return ans;
}
}
final class MathFunction{
private static final int[] numberForIntPrime = {2,7,61};
private static final long[] numberForLongPrime = {2,7,61,325,9375,28178,450775,9780504,1795265022};
/**
* aとbの最大公約数を求めます。戻り値は0以上であることが保証されます。
*
* @param a 公約数を求める整数
* @param b 公約数を求める整数
*
* @return aとbの最大公約数
*/
public static long gcd(long a,long b){
a = Math.abs(a);
b = Math.abs(b);
if(b==0){
return a;
}
long temp;
while((temp = a%b)!=0){
a = b;
b = temp;
}
return b;
}
/**
* aとbの最小公倍数を求めます。
* オーバーフロー検知は出来ません。
*
* @param a 公倍数を求める整数
* @param b 公倍数を求める整数
*
* @return aとbの最小公倍数
*/
public static long lcm(final long a,final long b){
return a/gcd(a,b)*b;
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
public static boolean isPrime(long n){
n = Math.abs(n);
if(n==2L){
return true;
}
if(n==1L||(n&1L)==0L){
return false;
}
if(n<=4_759_123_141L){
return isPrimeForInt(n);
}
return isPrimeForBigInteger(n);
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
private static boolean isPrimeForInt(long n){
long d = n-1;
while((d&1)==0L){
d >>= 1;
}
for(final long a: numberForIntPrime){
if(a>=n){
return true;
}
long t = d;
long y = MathFunction.modPow(a,t,n);
while(t<n-1L&&y!=1&&y!=n-1){
y = y*y%n;
t <<= 1;
}
if(y!=n-1&&(t&1L)==0){
return false;
}
}
return true;
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
private static boolean isPrimeForBigInteger(long n){
long d = n-1L;
while((d&1)==0L){
d >>= 1;
}
final BigInteger bigN = BigInteger.valueOf(n);
final BigInteger bigNSubOne = bigN.subtract(BigInteger.ONE);
final BigInteger bigD = BigInteger.valueOf(d);
for(final long a: numberForLongPrime){
if(a>=n){
return true;
}
BigInteger t = bigD;
BigInteger y = BigInteger.valueOf(a).modPow(t,bigN);
while(t.compareTo(bigNSubOne)<0&&!y.equals(BigInteger.ONE)&&!y.equals(bigNSubOne)){
y = y.multiply(y).mod(bigN);
t = t.shiftLeft(1);
}
if(!y.equals(bigNSubOne)&&(t.intValue()&1)==0){
return false;
}
}
return true;
}
/**
* num以下の素数を列挙します。
*
* @param num 素数を探す上限値
*
* @return num以下の素数のint型配列
*/
public static int[] primes(final int num){
if(num<2){
return new int[0];
}
final BitSet numbers = new BitSet(num+1);
numbers.set(2,num+1);
final int limit = (int)Math.sqrt(num);
int bit = 0;
while(
rangeCheckClose(
bit=numbers.nextSetBit(bit+1),
2,
limit)){
for(int j = bit*bit;j<=num;j+=bit){
numbers.clear(j);
}
}
final int[] answer = new int[numbers.cardinality()];
bit = 0;
for(int i=0;i<answer.length;++i)
bit = (answer[i] = numbers.nextSetBit(bit+1));
return answer;
}
/**
* a**bを計算します。
*
* @param a 被累乗数
* @param b 指数
*
* @return a**b
*/
public static long pow(long a,long b){
long ans = 1;
while(b>0){
if((b&1)==1){
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
/**
* a**bをmodで割ったあまりを計算します。
*
* @param a 被累乗数
* @param b 指数
* @param mod 法とする整数
*
* @return a**bをmodで割ったあまり
*/
public static long modPow(long a,long b,final long mod){
long ans = 1;
a %= mod;
while(b>0){
if((b&1)==1){
ans *= a;
}
ans %= mod;
a *= a;
a %= mod;
b >>= 1;
}
return ans;
}
/**
* N!を計算します。
*
* @param N 階乗を求めるのに用いる値
*
* @return N!
*/
public static long fact(final int N){
long ans = 1;
for(int i = 2;i<=N;++i){
ans *= i;
}
return ans;
}
/**
* N!をmodで割ったあまりを計算します。
*
* @param N 階乗を求めるのに用いる値
* @param mod 法とする整数
*
* @return N!をmodで割ったあまり
*/
public static long modFact(final int N,final long mod){
long ans = 1;
for(int i = 2;i<=N;++i){
ans *= i;
ans %= mod;
}
return ans;
}
/**
* nCrを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
*
* @return nCr
*/
public static long combi(final long n,long r){
if(r<0||n<r){
return 0;
}
long ans = 1;
r = Math.min(n-r,r);
for(int i = 0;i<r;++i){
ans *= n-i;
ans /= i+1;
}
return ans;
}
/**
* nCrをmodで割ったあまりを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
* @param mod 法とする整数
*
* @return nCrをmodで割ったあまり
*/
public static long modCombi(final long n,long r,final long mod){
if(r<0||n<r){
return 0;
}
long ans = 1;
r = Math.min(n-r,r);
for(int i = 0;i<r;++i){
ans *= (n-i)%mod;
ans %= mod;
ans *= modPow(i+1,mod-2,mod);
ans %= mod;
}
return ans;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param x1 点1のx座標
* @param y1 点1のy座標
* @param x2 点2のx座標
* @param y2 点2のy座標
* @param x3 点3のx座標
* @param y3 点3のy座標
* @param x4 点4のx座標
* @param y4 点4のy座標
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed(final int x1,final int y1,final int x2,final int y2,final int x3,final int y3,final int x4,final int y4){
final long s1 = (long)(x1-x2)*(y3-y1)-(long)(y1-y2)*(x3-x1);
final long t1 = (long)(x1-x2)*(y4-y1)-(long)(y1-y2)*(x4-x1);
final long s2 = (long)(x3-x4)*(y1-y3)-(long)(y3-y4)*(x1-x3);
final long t2 = (long)(x3-x4)*(y2-y3)-(long)(y3-y4)*(x2-x3);
final long temp1 = s1*t1;
final long temp2 = s2*t2;
if(temp1>0||temp2>0){
return -1;
}
if(temp1==0&&temp2==0){
return 0;
}
return 1;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param p1 点1
* @param p2 点2
* @param p3 点3
* @param p4 点4
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed(final Point p1,final Point p2,final Point p3,final Point p4){
return isCrossed(p1.x,p1.y,p2.x,p2.y,p3.x,p3.y,p4.x,p4.y);
}
/**
* 指定された頂点を順に結んで出来上がる多角形が凸多角形か判定します。
*
* @param points 多角形を構成する点
*
* @return 多角形が凸多角形ならtrue
*/
public static boolean isConvex(final Point... points){
final int n = points.length;
if(n<3){
return false;
}
if(n==3){
return true;
}
boolean conv = true;
for(int i = 0;i<n;++i){
int result = isCrossed(points[i],points[(i+2)%n],points[(i+1)%n],points[(i+1+n/2)%n]);
conv &= result>=0;
}
return conv;
}
/**
* numをmodで割ったあまりを返します。
* 戻り値は0以上mod未満であることが保証されます。
*
* @param num 被除算数
* @param mod 法とする値
*
* @return numをmodで割ったあまり
*/
public static long remainder(long num,final long mod){
num %= mod;
if(num<0){
num += mod;
}
return num;
}
/**
* numが何桁かを返します。
* 0は1桁として捉えます。
*
* @param num 調べる整数
*
* @return numの桁数
*/
public static int digit(final long num){
if(num<10L){
return 1;
}
if(num<100L){
return 2;
}
if(num<1000L){
return 3;
}
if(num<10000L){
return 4;
}
if(num<100000L){
return 5;
}
if(num<1000000L){
return 6;
}
if(num<10000000L){
return 7;
}
if(num<100000000L){
return 8;
}
if(num<1000000000L){
return 9;
}
if(num<10000000000L){
return 10;
}
if(num<100000000000L){
return 11;
}
if(num<1000000000000L){
return 12;
}
if(num<10000000000000L){
return 13;
}
if(num<100000000000000L){
return 14;
}
if(num<1000000000000000L){
return 15;
}
if(num<10000000000000000L){
return 16;
}
if(num<100000000000000000L){
return 17;
}
if(num<1000000000000000000L){
return 18;
}
return 19;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static int max(final int... nums){
int ans = Integer.MIN_VALUE;
for(int num: nums){
ans = Math.max(ans,num);
}
return ans;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static long max(final long... nums){
long ans = Long.MIN_VALUE;
for(long num: nums){
ans = Math.max(ans,num);
}
return ans;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static double max(final double... nums){
double ans = -Double.MIN_VALUE;
for(double num: nums){
ans = Math.max(ans,num);
}
return ans;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static <E extends Comparable<E>> E max(final E[] nums){
E ans = nums[0];
for(E value: nums){
if(ans.compareTo(value)>0){
ans = value;
}
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static int min(final int... nums){
int ans = Integer.MAX_VALUE;
for(int num: nums){
ans = Math.min(ans,num);
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static long min(final long... nums){
long ans = Long.MAX_VALUE;
for(long num: nums){
ans = Math.min(ans,num);
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static double min(final double... nums){
double ans = Double.MAX_VALUE;
for(double num: nums){
ans = Math.min(ans,num);
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static <E extends Comparable<E>> E min(final E[] nums){
E ans = nums[0];
for(E value: nums){
if(ans.compareTo(value)<0){
ans = value;
}
}
return ans;
}
/**
* 引数の総和を返します。
*
* @param nums 加算対象
*
* @return 引数の総和
*/
public static long sum(final int... nums){
long ans = 0;
for(int num: nums){
ans += num;
}
return ans;
}
/**
* 引数の総和を返します。
*
* @param nums 加算対象
*
* @return 引数の総和
*/
public static long sum(final long... nums){
long ans = 0;
for(long num: nums){
ans += num;
}
return ans;
}
/**
* 引数の総和を指定された値で割ったあまりを返します。
*
* @param mod 法とする値
* @param nums 加算対象
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final long mod,final int... nums){
long ans = 0;
for(int num: nums){
ans += num;
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 引数の総和を指定された値で割ったあまりを返します。
*
* @param mod 法とする値
* @param nums 加算対象
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final long mod,final long... nums){
long ans = 0;
for(long num: nums){
ans += num;
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 指定された区間の総和を返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
*
* @return 指定された区間の総和
*/
public static long sum(final int[] nums,int from,int to){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
}
return ans;
}
/**
* 指定された区間の総和を返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
*
* @return 指定された区間の総和
*/
public static long sum(final long[] nums,int from,int to){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
}
return ans;
}
/**
* 指定された区間の総和を指定された値で割ったあまりを返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
* @param mod 法とする値
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final int[] nums,int from,int to,long mod){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 指定された区間の総和を指定された値で割ったあまりを返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
* @param mod 法とする値
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final long[] nums,int from,int to,long mod){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck(final int num,final int l,final int r){
return l<=num&&num<r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck(final long num,final long l,final long r){
return l<=num&&num<r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck(final double num,final double l,final double r){
return l<=num&&num<r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheck(final E num,final E l,final E r){
return 0<=l.compareTo(num)&&0<num.compareTo(r);
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen(final int num,final int l,final int r){
return l<num&&num<r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen(final long num,final long l,final long r){
return l<num&&num<r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen(final double num,final double l,final double r){
return l<num&&num<r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckOpen(final E num,final E l,final E r){
return 0<l.compareTo(num)&&0<num.compareTo(r);
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose(final int num,final int l,final int r){
return l<=num&&num<=r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose(final long num,final long l,final long r){
return l<=num&&num<=r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose(final double num,final double l,final double r){
return l<=num&&num<=r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckClose(final E num,final E l,final E r){
return 0<=l.compareTo(num)&&0<=num.compareTo(r);
}
/**
* 引数の中でのmexを求めます。
*
* @param nums 引数
*/
public static int mex(final int... nums){
final BitSet set = new BitSet(nums.length);
for(final int num: nums)
if(num<nums.length)
set.set(num);
return set.nextSetBit(0);
}
}
final class Searcher{
private static final int CYCLE_COUNT = Double.MAX_EXPONENT+53;
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final char[] array,final int value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static int downSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static long downSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限より小さい値を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static double search(double a,double b,final double value,final DoubleUnaryOperator func){
double ans = a-Math.abs(a), c;
for(int $ = 0;$<CYCLE_COUNT;++$){
c = (a+b)/2;
if(func.applyAsDouble(c)>value){
b = c;
}
else{
a = (ans = c);
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final int[] array,final int value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final long[] array,final long value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final double[] array,final double value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final char[] array,final char value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains(final E[] array,final E value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
int result = array[c].compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains(final List<E> list,final E value){
int a = 0, b = list.size()-1, c;
while(a-b<1){
c = (a+b)/2;
int result = list.get(c).compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains(int a,int b,final int value,final IntUnaryOperator func){
int c;
while(a-b<1){
c = (a+b)/2;
int num = func.applyAsInt(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains(long a,long b,final long value,final LongUnaryOperator func){
long c;
while(a-b<1){
c = (a+b)/2;
long num = func.applyAsLong(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final int[] array,final int value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final long[] array,final long value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final double[] array,final double value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final char[] array,final char value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> int search(final E[] array,final E value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
int result = array[c].compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listのvalueのインデックス(無ければ - 1)
*/
public static <E extends Comparable<E>> int search(final List<E> list,final E value){
int a = 0, b = list.size()-1, c;
while(a-b<1){
c = (a+b)/2;
int result = list.get(c).compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static int search(int a,int b,final int value,final IntUnaryOperator func){
int c;
while(a-b<1){
c = (a+b)/2;
int num = func.applyAsInt(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return c;
}
}
return a-1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static long search(long a,long b,final long value,final LongUnaryOperator func){
long c;
while(a-b<1){
c = (a+b)/2;
long num = func.applyAsLong(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return c;
}
}
return a-1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final char[] array,final char value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>=0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = list.size(), c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>=0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static int upSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static long upSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final char[] array,final char value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>=0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* リスト内の指定された要素より小さい要素を探します。
* リスト内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>=0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static int underSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static long underSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final char[] array,final char value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* リスト内の指定された要素より大きい要素を探します。
* リスト内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = list.size(), c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static int overSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static long overSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final int[] array,final int value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final long[] array,final long value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final double[] array,final double value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final char[] array,final char value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch(final E[] array,final E value){
for(int i = 0;i<array.length;++i){
if(array[i].compareTo(value)==0){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch(final List<E> list,final E value){
for(int i = 0;i<list.size();++i){
if(list.get(i).compareTo(value)==0){
return i;
}
}
return -1;
}
}
/**
* Binary Indexed Treeクラスです。
* 引数は1-indexedであることを要求します。
*/
final class BIT{
final int size;
final private long[] tree;
/**
* 大きさnのBITを生成します。
*
* @param n 生成するBITの大きさ
*/
public BIT(int n){
size = n;
tree = new long[n+1];
}
/**
* [1,i]の総和を求めます。
*
* @param i 求める区間の右端(iを含む)
*
* @return [1,i]の総和
*/
public long sum(int i){
long sum = 0;
while(i>0){
sum += tree[i];
i ^= i&(-i);
}
return sum;
}
/**
* i番目に引数の値を加算します。
*
* @param i 加算する位置
* @param x 加算する値
*/
public void add(int i,long x){
while(i<=size){
tree[i] += x;
i += i&(-i);
}
}
/**
* このBITの値を全て0にします。
*/
public void clear(){
Arrays.fill(tree,0L);
}
}
/**
* Binary Indexed Treeのint特化クラスです。
* 引数は1-indexedであることを要求します。
*/
final class BITInt{
final int size;
final private int[] tree;
/**
* 大きさnのBITを生成します。
*
* @param n 生成するBITの大きさ
*/
public BITInt(int n){
size = n;
tree = new int[n+1];
}
/**
* [1,i]の総和を求めます。
*
* @param i 求める区間の右端(iを含む)
*
* @return [1,i]の総和
*/
public int sum(int i){
int sum = 0;
while(i>0){
sum += tree[i];
i ^= i&(-i);
}
return sum;
}
/**
* i番目に引数の値を加算します。
*
* @param i 加算する位置
* @param x 加算する値
*/
public void add(int i,int x){
while(i<=size){
tree[i] += x;
i += i&(-i);
}
}
/**
* このBITの値を全て0にします。
*/
public void clear(){
Arrays.fill(tree,0);
}
}
/**
* Bitsetクラスです。
* java.util.BitSetと同様の処理が出来るほか、ビットシフトに対応しています。
*/
final class Bitset implements Cloneable{
private final long[] bit;
private final int size;
private final long MASK;
/**
* 引数の値までを十分に扱える大きさのBitsetを構築します。
*
* @param len このBitsetで扱う最大値(lenを含まない)
*/
public Bitset(final int len){
size = (len+63)>>6;
bit = new long[size];
MASK = (-1L) >>> ((size<<6)-len);
}
/**
* 引数のlong型配列を元にBitsetを構築します。
*
* @param arr 元となるlong型配列
*/
private Bitset(final long[] arr){
this(arr.length);
System.arraycopy(arr,0,bit,0,size);
}
/**
* 引数の位置のフラグをtrueにします。
*
* @param index フラグをtrueにする位置
*/
public void set(final int index){
if(index>=size<<6){
throw new ArrayIndexOutOfBoundsException(index+" is out of this bitset's size "+size);
}
bit[index>>6] |= (1L<<(index&0b111111));
}
/**
* 引数の位置のフラグをfalseにします。
*
* @param index フラグをfalseにする位置
*/
public void clear(final int index){
if(index>=size<<6){
throw new ArrayIndexOutOfBoundsException(index+" is out of this bitset's size "+size);
}
long m = ~(1L<<(index&0b111111));
bit[index>>6] &= m;
}
/**
* 引数の位置のフラグを取得します。
*
* @param index 取得するフラグの位置
*
* @return 引数の位置のフラグ
*/
public boolean get(final int index){
if(index>=size<<6){
throw new ArrayIndexOutOfBoundsException(index+" is out of this bitset's size "+size);
}
return (bit[index>>6]&(1L<<(index&0b111111)))!=0;
}
/**
* 引数の値の分だけ左にビットシフトします。
* ビット長は変化せず、溢れた分のビットは破棄されます。
*
* @param num ビットシフトする回数
*/
public void shiftLeft(int num){
if(num>=size<<6){
Arrays.fill(bit,0L);
return;
}
final int n = num>>6;
num &= 0b111111;
for(int i = size-1;i>=n;--i){
bit[i] = (bit[i-n]<<num)|(i!=n&&num!=0?bit[i-n-1] >>> (64-num):0L);
}
for(int i = 0;i<n;++i){
bit[i] = 0L;
}
bit[size-1] &= MASK;
}
/**
* 引数の値の分だけ右にビットシフトします。
* ビット長は変化せず、溢れた分のビットは破棄されます。
*
* @param num ビットシフトする回数
*/
public void shiftRight(int num){
if(num>=size<<6){
Arrays.fill(bit,0L);
return;
}
final int n = num>>6;
num &= 0b111111;
for(int i = 0;i<size-n;++i){
bit[i] = (bit[i+n] >>> num)|(i+n+1!=size&&num!=0?bit[i+n+1]<<(64-num):0L);
}
for(int i = size-1;i>=size-n;--i){
bit[i] = 0L;
}
}
/**
* このBitsetを表すlong型配列を返します。
* このlong型配列はBitsetと連動しているため、変更を加えたときの挙動は保証されません。
*
* @return このBitsetを表すlong型配列
*/
public long[] longValues(){
return bit;
}
/**
* このBitsetをlongと解釈した時の値を返します。
*
* @return このBitsetをlongと解釈した時の値
*/
public long longValue(){
return bit[0];
}
/**
* 引数のBitsetとの論理積を取ります。
*
* @param b 論理積を取るBitset
*/
public void and(final Bitset b){
final long[] bit2 = b.longValues();
final int m = Math.min(bit2.length,size);
for(int i = 0;i<m;++i){
bit[i] &= bit2[i];
}
for(int i = m;i<size;++i){
bit[i] = 0;
}
bit[size-1] &= MASK;
}
/**
* 引数のBitsetとの論理和を取ります。
*
* @param b 論理和を取るBitset
*/
public void or(final Bitset b){
final long[] bit2 = b.longValues();
final int m = Math.min(bit2.length,size);
for(int i = 0;i<m;++i){
bit[i] |= bit2[i];
}
bit[size-1] &= MASK;
}
/**
* 引数のBitsetとの排他的論理和を取ります。
*
* @param b 排他的論理和を取るBitset
*/
public void xor(final Bitset b){
final long[] bit2 = b.longValues();
final int m = Math.min(bit2.length,size);
for(int i = 0;i<m;++i){
bit[i] ^= bit2[i];
}
bit[size-1] &= MASK;
}
/**
* このBitsetと同等の、異なるBitsetを生成します。
*
* @return このBitsetと同等の、異なるBitset
*
* @throws CloneNotSupportedException 多分起きない
*/
public Bitset clone() throws CloneNotSupportedException{
super.clone();
return new Bitset(bit);
}
}
/**
* Matrixクラスです。
* 行列を保持するクラスで、簡単な四則演算に行列式、累乗などを提供しています。
*/
final class Matrix{
private final long[][] matrix;
/**
* H行W列の、全要素がdefの行列を構築します。
*
* @param H 行数
* @param W 列数
* @param def 全要素の値
*/
public Matrix(final int H,final int W,final long def){
matrix = new long[H][W];
if(def!=0){
for(final long[] mat: matrix){
Arrays.fill(mat,def);
}
}
}
/**
* H行W列の、全要素が0である行列を構築します。
*
* @param H 行数
* @param W 列数
*/
public Matrix(final int H,final int W){
this(H,W,0);
}
/**
* Dimensionで表される行数、列数で全要素がdefの行列を構築します。
*
* @param d 行・列数
* @param def 全要素の値
*/
public Matrix(final Dimension d,final long def){
this(d.height,d.width,def);
}
/**
* 引数の二次元配列を元に行列を構築します。
* 値をコピーして構築するため、引数の行列とは連動していません。
*
* @param mat 元となる二次元配列
*/
public Matrix(final long[][] mat){
matrix = new long[mat.length][];
for(int i = 0;i<mat.length;++i){
matrix[i] = Arrays.copyOf(mat[i],mat[i].length);
}
}
/**
* i行j列目の要素を取得します。
*
* @param i 行番号
* @param j 列番号
*
* @return i行j列目の要素
*/
public long get(final int i,final int j){
return matrix[i][j];
}
/**
* i行j列目の要素を引数の値で上書きします。
*
* @param i 行番号
* @param j 列番号
* @param value 上書きする値
*
* @return value
*/
public long set(final int i,final int j,final long value){
return matrix[i][j] = value;
}
/**
* この行列を複製します。
*
* @return この行列と等価な行列(連動していない)
*/
public Matrix copy(){
return new Matrix(matrix);
}
/**
* この行列の行・列数を表すDimensionを返します。
*
* @return この行列の行・列数を表すDimension
*/
public Dimension size(){
return new Dimension(matrix[0].length,matrix.length);
}
/**
* この行列に引数の行列を加算した行列を返します。
*
* @param m 加算する行列
*
* @return この行列に引数の行列を加算した行列と等価な行列
*/
public Matrix add(final Matrix m){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,matrix[i][j]+m.get(i,j));
}
}
return ans;
}
/**
* この行列に引数の行列を減算した行列を返します。
*
* @param m 減算する行列
*
* @return この行列に引数の行列を減算した行列と等価な行列
*/
public Matrix subtract(final Matrix m){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,matrix[i][j]-m.get(i,j));
}
}
return ans;
}
/**
* この行列に引数の行列を乗算した行列を返します。
*
* @param m 乗算する行列
*
* @return この行列に引数の行列を乗算した行列と等価な行列
*/
public Matrix multiply(final Matrix m){
if(size().width!=m.size().height){
throw new IllegalArgumentException("matrix length is not same");
}
final Matrix ans = new Matrix(size().height,m.size().width);
final Dimension size = ans.size();
final int len = size().width;
for(int i = 0;i<size.height;++i){
for(int j = 0;j<size.width;++j){
long sum = 0;
for(int k = 0;k<len;++k){
sum += matrix[i][k]*m.get(k,j);
}
ans.set(i,j,sum);
}
}
return ans;
}
/**
* この行列に引数の行列を加算した行列を返します。
* 各要素はmodで除算したあまりに変換されます。
*
* @param m 加算する行列
* @param mod 法となる値
*
* @return この行列に引数の行列を加算した行列と等価な行列
*/
public Matrix modAdd(final Matrix m,final long mod){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,MathFunction.remainder(matrix[i][j]+m.get(i,j),mod));
}
}
return ans;
}
/**
* この行列に引数の行列を減算した行列を返します。
* 各要素はmodで除算したあまりに変換されます。
*
* @param m 減算する行列
* @param mod 法となる値
*
* @return この行列に引数の行列を減算した行列と等価な行列
*/
public Matrix modSubtract(final Matrix m,final long mod){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,MathFunction.remainder(matrix[i][j]-m.get(i,j),mod));
}
}
return ans;
}
/**
* この行列に引数の行列を乗算した行列を返します。
* 各要素はmodで乗算したあまりに変換されます。
*
* @param m 乗算する行列
* @param mod 法となる値
*
* @return この行列に引数の行列を乗算した行列と等価な行列
*/
public Matrix modMultiply(final Matrix m,final long mod){
if(size().width!=m.size().height){
throw new IllegalArgumentException("matrix length is not same");
}
final Matrix ans = new Matrix(size().height,m.size().width);
final Dimension size = ans.size();
final int len = size().width;
for(int i = 0;i<size.height;++i){
for(int j = 0;j<size.width;++j){
long sum = 0;
for(int k = 0;k<len;++k){
sum = MathFunction.remainder(sum+matrix[i][k]*m.get(k,j),mod);
}
ans.set(i,j,sum);
}
}
return ans;
}
/**
* 元となる行列に引数の行列を指定された回数だけ乗算します。
*
* @param original 元となる行列
* @param pw 乗算する配列
* @param exp 乗算する回数
*
* @return 元となる行列に引数の行列を指定された回数だけ乗算した行列と等価な行列
*/
public static Matrix pow(final Matrix original,final Matrix pw,long exp){
Matrix a = original.copy();
Matrix b = pw.copy();
while(0<exp){
if((exp&1)==1){
a = b.multiply(a);
}
b = b.multiply(b);
exp >>= 1;
}
return a;
}
/**
* 元となる行列に引数の行列を指定された回数だけ乗算します。
* 各要素はmodで乗算したあまりに変換されます。
*
* @param original 元となる行列
* @param pw 乗算する配列
* @param exp 乗算する回数
* @param mod 法となる値
*
* @return 元となる行列に引数の行列を指定された回数だけ乗算した行列と等価な行列
*/
public static Matrix modPow(final Matrix original,final Matrix pw,long exp,final long mod){
Matrix a = original.copy();
Matrix b = pw.copy();
while(0<exp){
if((exp&1)==1){
a = b.modMultiply(a,mod);
}
b = b.modMultiply(b,mod);
exp >>= 1;
}
return a;
}
/**
* この行列の行列式を返します。
*
* @return この行列の行列式
*/
public long determinant(){
return determinant(matrix);
}
/**
* 引数の二次元配列の行列式を返します。
*
* @param mat 元となる二次元配列
*
* @return 二次元配列の行列式
*/
private static long determinant(final long[][] mat){
if(mat.length==1){
return mat[0][0];
}
final long[][] miniMat = new long[mat.length-1][mat.length-1];
for(int i = 1;i<mat.length;++i){
System.arraycopy(mat[i],1,miniMat[i-1],0,miniMat.length);
}
long ans = mat[0][0]*determinant(miniMat);
for(int i = 1;i<mat.length;++i){
for(int j = 1;j<mat.length;++j){
miniMat[j-1][i-1] = mat[j][i-1];
}
final long num = mat[0][i]*determinant(miniMat);
ans += i%2==0?num:-num;
}
return ans;
}
/**
* この行列を表すStringを返します。
*
* @return この行列を表すString
*/
@Override public String toString(){
final StringBuilder ans = new StringBuilder();
ans.append(Arrays.toString(matrix[0]));
for(int i = 1;i<matrix.length;++i){
ans.append("\n");
ans.append(Arrays.toString(matrix[i]));
}
return ans.toString();
}
}
/**
* RollingHashクラスです。
* 一応文字列連結メソッドなどを実装していますが、使用は推奨されません。
*/
final class RollingHash implements Comparable<RollingHash>{
private static final long BASE = new Random().nextInt(1000)+Character.MAX_VALUE+1;
private static final long MASK30 = (1L<<30)-1;
private static final long MASK31 = (1L<<31)-1;
private static final long MOD = (1L<<61)-1;
private static final long MASK61 = MOD;
private long[] hash;
private String string;
/**
* 引数の文字列を元にRollingHashを構築します。
*
* @param str 元となるString
*/
public RollingHash(final String str){
string = str;
hash = new long[str.length()+1];
roll();
}
/**
* フィールドのstringを元にハッシュ値を計算します。
*/
private void roll(){
final int len = string.length();
for(int i = 1;i<=len;++i){
hash[i] = multiply(hash[i-1],BASE)+string.charAt(i-1)-' '+1;
if(MOD<=hash[i]){
hash[i] -= MOD;
}
}
}
/**
* long*long用の特別メソッドです。
*
* @param a 乗算する値
* @param b 乗算される値
*
* @return a*b mod 2^61-1
*/
private static long multiply(final long a,final long b){
final long au = a>>31;
final long ad = a&MASK31;
final long bu = b>>31;
final long bd = b&MASK31;
final long mid = ad*bu+au*bd;
final long midu = mid>>30;
final long midd = mid&MASK30;
return mod(au*bu*2+midu+(midd<<31)+ad*bd);
}
/**
* x mod 2^61-1を計算します。
*
* @param x 元となる値
*
* @return x mod 2^61-1
*/
private static long mod(final long x){
final long xu = x>>61;
final long xd = x&MASK61;
long ans = xu+xd;
if(MOD<=ans){
ans -= MOD;
}
return ans;
}
/**
* ハッシュ値を計算します。
*
* @param l 左端
* @param r 右端
*
* @return [l,r]のハッシュ値
*/
public long getHash(final int l,final int r){
return (hash[r]-multiply(hash[l],modBasePow(r-l))+MOD)%MOD;
}
/**
* BASE^b mod 2^61-1を計算します。
*
* @param b 指数
*
* @return BASE^b mod 2^61-1
*/
private static long modBasePow(long b){
long ans = 1;
long a = BASE;
while(b>0){
if((b&1)==1){
ans = multiply(ans,a);
}
a = multiply(a,a);
b >>= 1;
}
return ans;
}
/**
* 指定された区間と引数の指定された区間が等しいか返します。
*
* @param rh 比較対象のRollingHash
* @param l1 このRollingHashの左端
* @param r1 このRollingHashの右端
* @param l2 比較対象の左端
* @param r2 比較対象の右端
*
* @return 等しい可能性があるならtrue、確実に異なるならfalse
*/
public boolean equals(final RollingHash rh,final int l1,final int r1,final int l2,final int r2){
if(r1-l1!=r2-l2){
return false;
}
return getHash(l1,r1)==rh.getHash(l2,r2);
}
/**
* このRollingHashの長さを返します。
*
* @return このRollingHashの長さ
*/
public int length(){
return string.length();
}
/**
* このRollingHashの元となるStringのハッシュ値を返します。
*
* @return このRollingHashの元となるStringのハッシュ値
*/
@Override public int hashCode(){
return string.hashCode();
}
/**
* このRollingHashの元となるStringを返します。
*
* @return このRollingHashの元となるString
*/
@Override public String toString(){
return string;
}
/**
* 引数と自身が等しいか返します。
*
* @param o 比較対象
*
* @return 等しい可能性があるならtrue、確実に異なるならfalse
*/
@Override public boolean equals(Object o){
if(o instanceof final RollingHash rh){
return equals(rh,0,length(),0,rh.length());
}
return false;
}
/**
* 引数のRollingHashの元となるStringと辞書順で比較します。
*
* @param rh the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
@Override public int compareTo(RollingHash rh){
return string.compareTo(rh.toString());
}
/**
* 引数のStringと辞書順で比較します。
*
* @param str the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
public int compareTo(String str){
return string.compareTo(str);
}
/**
* このRollingHashのi文字目を返します。
*
* @param i インデックス
*
* @return i番目の文字を表すchar
*/
public char charAt(final int i){
return string.charAt(i);
}
/**
* 引数のRollingHashの元となるStringと大文字小文字を無視して辞書順で比較します。
*
* @param rh the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
public int compareToIgnoreCase(final RollingHash rh){
return string.compareToIgnoreCase(rh.toString());
}
/**
* 引数のStringと大文字小文字を無視して辞書順で比較します。
*
* @param str the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
public int compareToIgnoreCase(final String str){
return string.compareToIgnoreCase(str);
}
/**
* 引数のRollingHashを末尾に連結します。
* 計算量はO(length+rh.length)です。
*
* @param rh 連結する文字列を表すRollingHash
*/
public void concat(final RollingHash rh){
concat(rh.toString());
}
/**
* 引数のStringを末尾に連結します。
* 計算量はO(length+rh.length)です。
*
* @param str 連結する文字列
*/
public void concat(final String str){
string = string.concat(str);
hash = new long[string.length()+1];
roll();
}
/**
* このRollingHashの連続部分列として引数のRollingHashが存在するか判定します。
*
* @param rh 連続部分列として存在するか検査するRollingHash
*
* @return 部分列として存在する可能性があるならtrue、確実に含まれていないならfalse
*/
public boolean contains(final RollingHash rh){
final long hash = rh.getHash(0,rh.length());
final int len = length()-rh.length();
for(int i = 0;i<=len;++i){
if(hash==getHash(i,rh.length()+i)){
return true;
}
}
return false;
}
/**
* 引数のStringが連続部分列として存在するか判定します。
*
* @param str 存在判定をするString
*
* @return 連続部分列として存在するならtrue、それ以外はfalse
*/
public boolean contains(final String str){
return indexOf(str)!=-1;
}
/**
* 引数の文字が先頭から何番目に存在するか返します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
*
* @return 最も左側にある引数の文字のインデックス(無ければ - 1)
*/
public int indexOf(final int ch){
return indexOf(ch,0);
}
/**
* 引数の文字を指定されたインデックス以降で探索します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
* @param fromIndex 探索開始位置
*
* @return 最も左側にある引数の文字のインデックス(無ければ - 1)
*/
public int indexOf(final int ch,final int fromIndex){
final int len = length();
for(int i = fromIndex;i<len;++i){
if(string.charAt(i)==ch){
return i;
}
}
return -1;
}
/**
* 引数の文字列が先頭から何番目に存在するか返します。
* 存在しない場合は-1を返します。
*
* @param str 探索する文字列
*
* @return 最も左側にある引数の文字列のインデックス(無ければ - 1)
*/
public int indexOf(final String str){
return indexOf(str,0);
}
/**
* 引数の文字列を指定されたインデックス以降で探索します。
* 存在しない場合は-1を返します。
*
* @param str 探索する文字列
* @param fromIndex 探索開始位置
*
* @return 最も左側にある引数の文字列のインデックス(無ければ - 1)
*/
public int indexOf(final String str,final int fromIndex){
long hash = 0;
for(final char c: str.toCharArray()){
hash = multiply(hash,BASE)+c-' '+1;
if(MOD<=hash){
hash -= MOD;
}
}
final int len = length()-str.length();
for(int i = fromIndex;i<=len;++i){
if(hash==getHash(i,str.length()+i)){
return i;
}
}
return -1;
}
/**
* このRollingHashが表す文字列が空文字列か判定します。
*
* @return ""と等しいならtrue、それ以外はfalse
*/
public boolean isEmpty(){
return length()==0;
}
/**
* 引数の文字を指定されたインデックス以降で探索します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
* @param fromIndex 探索開始位置
*
* @return 最も右側にある引数の文字のインデックス(無ければ - 1)
*/
public int lastIndexOf(final int ch,final int fromIndex){
for(int i = fromIndex;i>=0;--i){
if(string.charAt(i)==ch){
return i;
}
}
return -1;
}
/**
* 引数の文字が先頭から何番目に存在するか返します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
*
* @return 最も左側にある引数の文字のインデックス(無ければ - 1)
*/
public int lastIndexOf(final int ch){
return lastIndexOf(ch,length()-1);
}
/**
* 引数のbooleanを表す文字列を元にRollingHashを構築します。
*
* @param b 元となるboolean
*
* @return 引数のbooleanを表すRollingHash
*/
public static RollingHash valueOf(final boolean b){
return new RollingHash(b?"true":"false");
}
/**
* 引数のcharを元にRollingHashを構築します。
*
* @param c 元となるchar
*
* @return 引数のcharを表すRollingHash
*/
public static RollingHash valueOf(final char c){
return new RollingHash(""+c);
}
/**
* 引数のchar[]を表す文字列を元にRollingHashを構築します。
*
* @param c 元となるchar[]
*
* @return 引数のchar[]を表すRollingHash
*/
public static RollingHash valueOf(final char[] c){
return new RollingHash(String.valueOf(c,0,c.length));
}
/**
* 引数のchar[]を表す文字列の、引数の区間を元にRollingHashを構築します。
*
* @param c 元となるchar[]
* @param offset 左端
* @param count 文字数
*
* @return 引数のchar[]の引数の区間を表すRollingHash
*/
public static RollingHash valueOf(final char[] c,final int offset,final int count){
return new RollingHash(String.valueOf(c,offset,count));
}
/**
* 引数のdoubleを表す文字列を元にRollingHashを構築します。
*
* @param d 元となるdouble
*
* @return 引数のdoubleを表すRollingHash
*/
public static RollingHash valueOf(final double d){
return new RollingHash(String.valueOf(d));
}
/**
* 引数のfloatを表す文字列を元にRollingHashを構築します。
*
* @param f 元となるfloat
*
* @return 引数のfloatを表すRollingHash
*/
public static RollingHash valueOf(final float f){
return new RollingHash(String.valueOf(f));
}
/**
* 引数のintを表す文字列を元にRollingHashを構築します。
*
* @param i 元となるint
*
* @return 引数のintを表すRollingHash
*/
public static RollingHash valueOf(final int i){
return new RollingHash(String.valueOf(i));
}
/**
* 引数のlongを表す文字列を元にRollingHashを構築します。
*
* @param l 元となるlong
*
* @return 引数のlongを表すRollingHash
*/
public static RollingHash valueOf(final long l){
return new RollingHash(String.valueOf(l));
}
/**
* 引数のObjectを表す文字列を元にRollingHashを構築します。
*
* @param obj 元となるObject
*
* @return 引数のObjectを表すRollingHash
*/
public static RollingHash valueOf(final Object obj){
return new RollingHash(String.valueOf(obj));
}
}
/**
* SegmentTreeクラスです。
* 載せる演算はfunctionを定義して使用して下さい。
*
* @param <E> 演算を適用する要素の型
*/
@SuppressWarnings("unchecked")
abstract class SegmentTree<E>{
final int N, size;
final E def;
final Object[] node;
/**
* 大きさnの、単位元がdefであるSegmentTreeを構築します。
*
* @param n 扱う範囲
* @param def 単位元
* @param is1indexed 各メソッドに渡すインデックスが1-indexedか
*/
public SegmentTree(final int n,final E def,final boolean is1indexed){
int num = 2;
while(num<n<<1){
num <<= 1;
}
N = num;
size = num>>1-(is1indexed?1:0);
node = new Object[N];
this.def = def;
Arrays.fill(node,this.def);
}
/**
* 引数の配列を元に、単位元がdefであるSegmentTreeを構築します。
* 浅いコピーなので、引数の配列の要素に変更を加えたときの動作は保証されません。
*
* @param arr 元となる配列
* @param def 単位元
* @param is1indexed 各メソッドに渡すインデックスが1-indexedか
*/
public SegmentTree(final E[] arr,final E def,final boolean is1indexed){
int num = 2;
while(num<arr.length<<1){
num <<= 1;
}
N = num;
size = num>>1-(is1indexed?1:0);
node = new Object[N];
this.def = def;
System.arraycopy(arr,0,node,N>>1,arr.length);
for(int i = arr.length+(N>>1);i<N;i++){
node[i] = def;
}
updateAll();
}
/**
* 大きさn、単位元がdefのSegmentTreeを構築します。
* 各メソッドに渡すインデックスは0-indexedであることが要求されます。
*
* @param n 大きさ
* @param def 単位元
*/
public SegmentTree(final int n,final E def){
this(n,def,false);
}
/**
* このSegmentTreeのテーブルを一括で更新します。
*/
private void updateAll(){
for(int i = (N>>1)-1;i>0;i--){
node[i] = function((E)node[i<<1],(E)node[(i<<1)+1]);
}
}
/**
* 引数の位置の値を引数の値で上書きします。
*
* @param n インデックス
* @param value 上書きする値
*/
public void update(int n,final E value){
n += size;
node[n] = value;
n >>= 1;
while(n>0){
node[n] = function((E)node[n<<1],(E)node[(n<<1)+1]);
n >>= 1;
}
}
/**
* 引数の位置の要素を返します。
*
* @param a インデックス
*
* @return 引数の位置の要素
*/
public E get(final int a){
return (E)node[a+size];
}
/**
* このSegmentTree上の要素全てにfunctionを適用した結果を返します。
*
* @return 要素全てにfunctionを適用した結果
*/
public E answer(){
return (E)node[1];
}
/**
* 引数の区間の要素にfunctionを適用した結果を返します。
* 閉区間であることに注意して下さい。
*
* @param l 左端(lを含む)
* @param r 右端(rを含む)
*
* @return [l,r]の要素にfunctionを適用した結果
*/
public E query(int l,int r){
l += size;
r += size;
E answer = def;
while(l>0&&r>0&&l<=r){
if(l%2==1){
answer = function((E)node[l++],answer);
}
l >>= 1;
if(r%2==0){
answer = function(answer,(E)node[r--]);
}
r >>= 1;
}
return answer;
}
/**
* このSegmentTree上で適用する関数を定義したメソッドです。
*
* @param a 要素1
* @param b 要素2
*
* @return aとbに関数を適用した結果
*/
abstract public E function(E a,E b);
}
/**
* LazySegmentTreeクラスです。
* 載せる演算はfunction、演算の合成はcomposition、演算の適用はmappingに定義して使用して下さい。
*
* @param <S> 演算を適用する要素の型
* @param <F> 演算に使用するパラメータ
*/
@SuppressWarnings("unchecked")
abstract class LazySegmentTree<S,F>{
private final int size, log;
private final S defaultS;
private final F defaultF;
private final S[] node;
private final F[] lazy;
/**
* 大きさN、単位元がdefaultS、恒等写像がdefaultFであるLazySegmentTreeを構築します。
* 各メソッドに渡すインデックスは0-indexedであることが要求されます。
*
* @param N 大きさ
* @param defaultS 単位元
* @param defaultF 恒等写像
*/
public LazySegmentTree(final int N,final S defaultS,final F defaultF){
this(N,defaultS,defaultF,false);
}
/**
* 大きさN、単位元がdefaultS、恒等写像がdefaultFであるLazySegmentTreeを構築します。
*
* @param N 大きさ
* @param defaultS 単位元
* @param defaultF 恒等写像
* @param is1indexed 各メソッドに渡すインデックスは1-indexedか
*/
public LazySegmentTree(final int N,final S defaultS,final F defaultF,final boolean is1indexed){
this.log = 32-Integer.numberOfLeadingZeros(N-1);
this.size = (1<<log)-(is1indexed?1:0);
this.defaultS = defaultS;
this.defaultF = defaultF;
this.node = (S[])new Object[1<<log+1];
this.lazy = (F[])new Object[1<<log+1];
clear();
}
/**
* 引数の配列を元に、単位元がdefaultS、恒等写像がdefaultFであるLazySegmentTreeを構築します。
*
* @param defaultValues 大きさ
* @param defaultS 単位元
* @param defaultF 恒等写像
* @param is1indexed 各メソッドに渡すインデックスは1-indexedか
*/
public LazySegmentTree(final S[] defaultValues,final S defaultS,final F defaultF,final boolean is1indexed){
this(defaultValues.length,defaultS,defaultF,is1indexed);
updateAll(defaultValues);
}
/**
* 全ての要素を単位元に、演算を恒等写像にします。
*/
public void clear(){
Arrays.fill(this.node,this.defaultS);
Arrays.fill(this.lazy,this.defaultF);
}
/**
* 引数の要素を元にテーブルを再構築します。
*
* @param defaultValues 元となる配列
*/
private void updateAll(final S[] defaultValues){
System.arraycopy(defaultValues,0,node,1<<log,defaultValues.length);
for(int i = (1<<log)-1;i>0;i--){
node[i] = function(node[i<<1],node[i<<1|1]);
}
}
/**
* 引数の位置の演算を適用し、子に伝播します。
*
* @param index 演算を適用する位置
*/
private void spread(final int index){
if(lazy[index]!=defaultF){
int l = index<<1;
int r = index<<1|1;
node[l] = mapping(node[l],lazy[index]);
node[r] = mapping(node[r],lazy[index]);
lazy[l] = composition(lazy[l],lazy[index]);
lazy[r] = composition(lazy[r],lazy[index]);
lazy[index] = defaultF;
}
}
/**
* 親から順に引数の位置までの演算を適用します。
*
* @param from 演算を適用する終点
*/
private void spreadLine(final int from){
for(int i = log;i>0;i--)
spread(from>>i);
}
/**
* 引数の区間の演算を適用します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
*/
private void spreadRange(final int l,final int r){
for(int i = log;i>0;i--){
if((l>>i<<i)!=l)
spread(l>>i);
if((r>>i<<i)!=r)
spread(r>>i);
}
}
/**
* 引数の位置の要素の情報を親に向かって伝播します。
*
* @param index 伝播したい要素のインデックス
*/
private void update(int index){
while((index >>= 1)>0)
node[index] = function(node[index<<1],node[index<<1|1]);
}
/**
* 区間の要素の情報を親に向かって伝播します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
*/
private void update(final int l,final int r){
for(int i = 1;i<=log;i++){
int subL = l>>i;
int subR = r>>i;
if((subL<<i)!=l)
node[subL] = function(node[subL<<1],node[subL<<1|1]);
if((subR<<i)!=r)
node[subR] = function(node[subR<<1],node[subR<<1|1]);
}
}
/**
* 引数の位置の要素を引数の値で上書きします。
*
* @param index インデックス
* @param x 上書きする値
*/
public void update(int index,final S x){
index += size;
spreadLine(index);
node[index] = x;
update(index);
}
/**
* 引数の位置の要素を取得します
*
* @param index インデックス
*
* @return 引数の位置の要素
*/
public S get(int index){
index += size;
spreadLine(index);
return node[index];
}
/**
* 指定された区間にfunctionを適用した結果を返します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
*
* @return [l,r)の要素にfunctionを適用した結果
*/
public S query(int l,int r){
l += size;
r += size;
spreadRange(l,r);
S sumL = defaultS;
S sumR = defaultS;
while(l<r){
if((l&1)==1)
sumL = function(sumL,node[l++]);
if((r&1)==1)
sumR = function(node[--r],sumR);
l >>= 1;
r >>= 1;
}
return function(sumL,sumR);
}
/**
* 全要素にfunctionを適用した結果を返します。
*
* @return 全要素にfunctionを適用した結果
*/
public S answer(){
return node[1];
}
/**
* 引数の位置の要素に指定されたパラメータによる演算を反映します。
*
* @param index インデックス
* @param f 反映する演算を表すパラメータ
*/
public void apply(int index,final F f){
index += size;
spreadLine(index);
node[index] = mapping(node[index],f);
update(index);
}
/**
* 指定された区間の要素に指定されたパラメータによる演算を反映します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
* @param f 反映する演算を表すパラメータ
*/
public void apply(int l,int r,final F f){
l += size;
r += size;
spreadRange(l,r);
int subL = l;
int subR = r;
while(subL<subR){
if((subL&1)==1){
node[subL] = mapping(node[subL],f);
lazy[subL] = composition(lazy[subL++],f);
}
if((subR&1)==1){
node[--subR] = mapping(node[subR],f);
lazy[subR] = composition(lazy[subR],f);
}
subL >>= 1;
subR >>= 1;
}
update(l,r);
}
/**
* 各要素に適用する関数を定義するメソッドです。
*
* @param s1 要素1
* @param s2 要素2
*
* @return 要素に関数を適用した結果
*/
abstract public S function(S s1,S s2);
/**
* パラメータを合成するメソッドです。
* パラメータを表すインスタンスが不変であること、
* ここで返すインスタンスが他に影響を及ぼさないことが要求されます。
*
* @param f1 パラメータ1
* @param f2 パラメータ2
*
* @return パラメータを合成した結果を表すパラメータ
*/
abstract public F composition(F f1,F f2);
/**
* パラメータを元に要素に演算を適用します。
*
* @param s 要素
* @param f パラメータ
*
* @return 要素に演算を適用した結果
*/
abstract public S mapping(S s,F f);
}
/**
* UnionFindクラスです。
* 連結成分の大きさの他、辺の数、連結成分の数も取得できます。
*/
final class UnionFind{
private final int[] par, rank, size, path;
private int count;
/**
* 大きさNのUnionFindを構築します。
*
* @param N 大きさ
*/
public UnionFind(final int N){
count = N;
par = new int[N];
rank = new int[N];
size = new int[N];
path = new int[N];
Arrays.fill(par,-1);
Arrays.fill(size,1);
}
/**
* 引数の頂点の代表される親を返します。
*
* @param ind 代表を取得する頂点
*
* @return 代表される親
*/
public int root(final int ind){
if(par[ind]==-1){
return ind;
}
else{
return par[ind] = root(par[ind]);
}
}
/**
* 引数の二つの頂点が同一の連結成分に属するか返します。
*
* @param x 頂点1
* @param y 頂点2
*
* @return 同一の連結成分に属するならtrue、それ以外はfalse
*/
public boolean isSame(final int x,final int y){
return root(x)==root(y);
}
/**
* 引数の二つの頂点を連結します。
* 連結済みであっても辺はカウントされることに注意して下さい。
*
* @param x 頂点1
* @param y 頂点2
*
* @return 既に二頂点が同一の連結成分に属しているならfalse、それ以外はtrue
*/
public boolean unite(final int x,final int y){
int rx = root(x);
int ry = root(y);
++path[rx];
if(rx==ry){
return false;
}
if(rank[rx]<rank[ry]){
int temp = rx;
rx = ry;
ry = temp;
}
par[ry] = rx;
if(rank[rx]==rank[ry]){
++rank[rx];
}
path[rx] += path[ry];
size[rx] += size[ry];
--count;
return true;
}
/**
* このUnionFindの連結成分の数を返します。
*
* @return 連結成分の数
*/
public int groupCount(){
return count;
}
/**
* 引数の頂点の連結成分の辺の総数を返します。
*
* @param x 頂点
*
* @return 連結成分の辺の総数
*/
public int pathCount(final int x){
return path[root(x)];
}
/**
* 引数の頂点の連結成分の頂点数を返します。
*
* @param x 頂点
*
* @return 連結成分の頂点数
*/
public int size(final int x){
return size[root(x)];
}
}
/**
* Treeクラスです。
* java.util.TreeSetと基本変わりませんが、インデックスを指定してのアクセスがO(log N)で可能です。
*
* @param <E> Treeに載せる要素の型
*/
final class Tree<E extends Comparable<E>>{
private Node<E> root;
private int size, hash;
public Tree(){
size = 0;
root = null;
hash = 0;
}
static final private class Node<E>{
E value;
int height, size;
Node<E> left, right, parent;
public Node(final Node<E> p,final E v){
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add(final E x){
boolean bool = true;
if(root==null){
root = new Node<>(null,x);
}
else{
Node<E> par;
Node<E> now = root;
do{
par = now;
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
bool = false;
break;
}
}
while(now!=null);
if(bool){
final int result = x.compareTo(par.value);
if(result<0){
par.left = new Node<>(par,x);
}
else{
par.right = new Node<>(par,x);
}
fix(par);
}
}
if(bool){
++size;
hash ^= x.hashCode();
}
return bool;
}
public E get(int index){
if(root==null||size<=index){
throw new NullPointerException();
}
Node<E> now = root;
while(true){
assert now!=null;
final int ls = now.left!=null?now.left.size:0;
if(index<ls){
now = now.left;
}
else if(ls<index){
now = now.right;
index -= ls+1;
}
else{
break;
}
}
return now.value;
}
public boolean remove(final E x){
final Node<E> n = getNode(x);
if(n==null){
return false;
}
--size;
hash ^= n.value.hashCode();
delete(n);
return true;
}
private void delete(final Node<E> node){
if(node!=null){
if(node.left==null&&node.right==null){
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = null;
}
else{
node.parent.right = null;
}
fix(node.parent);
}
else{
root = null;
}
node.parent = null;
}
else{
if(node.left!=null&&node.right!=null){
final Node<E> rep = getFirstNode(node.right);
node.value = rep.value;
delete(rep);
}
else{
final Node<E> rep = node.left!=null?node.left:node.right;
rep.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = rep;
}
else{
node.parent.right = rep;
}
fix(node.parent);
}
else{
root = rep;
}
node.parent = null;
}
}
}
}
private Node<E> getNode(final E x){
Node<E> now = root;
while(now!=null){
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
break;
}
}
return now;
}
public E first(){
if(root==null){
return null;
}
return getFirstNode(root).value;
}
private Node<E> getFirstNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.left;
}
return par;
}
public E last(){
if(root==null){
return null;
}
return getLastNode(root).value;
}
private Node<E> getLastNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.right;
}
return par;
}
public boolean contains(final E x){
if(root==null){
return false;
}
return getNode(x)!=null;
}
public E pollFirst(){
if(root==null){
return null;
}
--size;
final Node<E> min = getFirstNode(root);
hash ^= min.value.hashCode();
delete(min);
return min.value;
}
public E pollLast(){
if(root==null){
return null;
}
--size;
final Node<E> max = getLastNode(root);
hash ^= max.value.hashCode();
delete(max);
return max.value;
}
public E ceiling(final E x){
return ceiling(root,x);
}
private E ceiling(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>0){
node = node.right;
}
else if(result<0){
ans = node;
node = node.left;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E higher(final E x){
return higher(root,x);
}
private E higher(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>=0){
node = node.right;
}
else{
ans = node;
node = node.left;
}
}
return ans!=null?ans.value:null;
}
public E floor(final E x){
return floor(root,x);
}
private E floor(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<0){
node = node.left;
}
else if(result>0){
ans = node;
node = node.right;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E lower(final E x){
return lower(root,x);
}
private E lower(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<=0){
node = node.left;
}
else{
ans = node;
node = node.right;
}
}
return ans!=null?ans.value:null;
}
public void clear(){
root = null;
size = 0;
hash = 0;
}
public boolean isEmpty(){
return size==0;
}
public int size(){
return size;
}
public ArrayList<E> toList(){
final ArrayList<E> list = new ArrayList<>();
if(root!=null){
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add(root);
while(!deq.isEmpty()){
final Node<E> now = deq.pollLast();
if(list.size()==0){
if(now.left!=null){
deq.add(now);
deq.add(now.left);
}
else{
list.add(now.value);
if(now.right!=null){
deq.add(now.right);
}
}
}
else if(now.left!=null&&list.get(list.size()-1).compareTo(now.left.value)<0){
deq.add(now);
deq.add(now.left);
}
else{
list.add(now.value);
if(now.right!=null){
deq.add(now.right);
}
}
}
}
return list;
}
@Override public String toString(){
final ArrayList<E> list = toList();
return list.toString();
}
@Override public boolean equals(final Object o){
if(o instanceof final Tree<?> tree){
if(size!=tree.size()){
return false;
}
final ArrayList<E> list1 = toList();
final ArrayList<?> list2 = tree.toList();
for(int i = 0;i<size;++i){
if(!list1.get(i).equals(list2.get(i))){
return false;
}
}
return true;
}
return false;
}
@Override public int hashCode(){
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix(Node<E> node){
while(node!=null){
final int lh = node.left==null?0:node.left.height;
final int rh = node.right==null?0:node.right.height;
if(lh-rh>1){
assert node.left!=null;
if(node.left.right!=null&&node.left.right.height==lh-1){
rotateL(node.left);
}
rotateR(node);
}
else if(rh-lh>1){
assert node.right!=null;
if(node.right.left!=null&&node.right.left.height==rh-1){
rotateR(node.right);
}
rotateL(node);
}
else{
setStates(node);
}
node = node.parent;
}
}
private void rotateR(final Node<E> node){
final Node<E> temp = node.left;
node.left = temp.right;
if(node.left!=null){
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void rotateL(final Node<E> node){
final Node<E> temp = node.right;
node.right = temp.left;
if(node.right!=null){
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void setStates(final Node<E> node){
final int lh = node.left!=null?node.left.height:0;
final int rh = node.right!=null?node.right.height:0;
node.height = Math.max(lh,rh)+1;
final int ls = node.left!=null?node.left.size:0;
final int rs = node.right!=null?node.right.size:0;
node.size = ls+rs+1;
}
}
final class TreeMulti<E extends Comparable<E>>{
private Node<E> root;
private long size;
private int uniqueSize;
private int hash;
public TreeMulti(){
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node<E>{
E value;
long count, size;
int height;
Node<E> left, right, parent;
public Node(final Node<E> p,final E v,final long c){
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add(final E x){
if(root==null){
root = new Node<>(null,x,1);
++uniqueSize;
}
else{
Node<E> par;
Node<E> now = root;
boolean bool = true;
do{
par = now;
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
bool = false;
++now.count;
break;
}
}
while(now!=null);
if(bool){
++uniqueSize;
final int result = x.compareTo(par.value);
if(result<0){
par.left = new Node<>(par,x,1);
}
else{
par.right = new Node<>(par,x,1);
}
}
fix(par);
}
++size;
hash ^= x.hashCode();
}
public void add(final E x,final long sum){
if(root==null){
root = new Node<>(null,x,sum);
++uniqueSize;
}
else{
Node<E> par;
Node<E> now = root;
boolean bool = true;
do{
par = now;
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
bool = false;
now.count += sum;
fix(now);
break;
}
}
while(now!=null);
if(bool){
++uniqueSize;
final int result = x.compareTo(par.value);
if(result<0){
par.left = new Node<>(par,x,sum);
}
else{
par.right = new Node<>(par,x,sum);
}
fix(par);
}
}
size += sum;
hash ^= sum%2==1?x.hashCode():0;
}
public E get(long index){
if(root==null||size<=index){
throw new NullPointerException();
}
Node<E> now = root;
while(true){
assert now!=null;
final long ls = now.left!=null?now.left.size:0;
if(index<ls){
now = now.left;
}
else if(ls+now.count<=index){
index -= ls+now.count;
now = now.right;
}
else{
break;
}
}
return now.value;
}
public boolean remove(final E x){
final Node<E> n = getNode(x);
if(n==null){
return false;
}
--size;
hash ^= n.hashCode();
delete(n);
return true;
}
public long remove(final E x,final long sum){
final Node<E> n = getNode(x);
if(n==null){
return 0;
}
final long ans = Math.min(sum,n.count);
size -= ans;
hash ^= ans%2==1?n.hashCode():0;
n.count -= ans-1;
delete(n);
return ans;
}
public long removeAll(final E x){
final Node<E> n = getNode(x);
if(n==null){
return 0;
}
size -= n.count;
final long ans = n.count;
hash ^= ans%2==1?n.hashCode():0;
n.count = 0;
delete(n);
return ans;
}
private void delete(final Node<E> node){
if(node!=null){
if(node.count>1){
--node.count;
fix(node);
return;
}
if(node.left==null&&node.right==null){
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = null;
}
else{
node.parent.right = null;
}
fix(node.parent);
}
else{
root = null;
}
node.parent = null;
--uniqueSize;
}
else{
if(node.left!=null&&node.right!=null){
final Node<E> rep = getFirstNode(node.right);
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete(rep);
}
else{
final Node<E> rep = node.left!=null?node.left:node.right;
rep.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = rep;
}
else{
node.parent.right = rep;
}
fix(node.parent);
}
else{
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node<E> getNode(final E x){
Node<E> now = root;
while(now!=null){
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
break;
}
}
return now;
}
public E first(){
if(root==null){
return null;
}
return getFirstNode(root).value;
}
private Node<E> getFirstNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.left;
}
return par;
}
public E last(){
if(root==null){
return null;
}
return getLastNode(root).value;
}
private Node<E> getLastNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.right;
}
return par;
}
public boolean contains(final E x){
if(root==null){
return false;
}
return getNode(x)!=null;
}
public long sum(final E x){
if(root==null){
return 0;
}
Node<E> node = getNode(x);
return node!=null?node.count:0;
}
public E pollFirst(){
if(root==null){
return null;
}
--size;
final Node<E> min = getFirstNode(root);
hash ^= min.value.hashCode();
final E ans = min.value;
delete(min);
return ans;
}
public E pollLast(){
if(root==null){
return null;
}
--size;
final Node<E> max = getLastNode(root);
hash ^= max.value.hashCode();
final E ans = max.value;
delete(max);
return ans;
}
public E ceiling(final E x){
return ceiling(root,x);
}
private E ceiling(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>0){
node = node.right;
}
else if(result<0){
ans = node;
node = node.left;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E higher(final E x){
return higher(root,x);
}
private E higher(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>=0){
node = node.right;
}
else{
ans = node;
node = node.left;
}
}
return ans!=null?ans.value:null;
}
public E floor(final E x){
return floor(root,x);
}
private E floor(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<0){
node = node.left;
}
else if(result>0){
ans = node;
node = node.right;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E lower(final E x){
return lower(root,x);
}
private E lower(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<=0){
node = node.left;
}
else{
ans = node;
node = node.right;
}
}
return ans!=null?ans.value:null;
}
public int size(){
return uniqueSize;
}
public long sumSize(){
return size;
}
public ArrayList<E> toList(){
final ArrayList<E> list = new ArrayList<>();
if(root!=null){
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add(root);
while(!deq.isEmpty()){
final Node<E> now = deq.pollLast();
if(list.size()==0){
if(now.left!=null){
deq.add(now);
deq.add(now.left);
}
else{
for(int i = 0;i<now.count;++i){
list.add(now.value);
}
if(now.right!=null){
deq.add(now.right);
}
}
}
else if(now.left!=null&&list.get(list.size()-1).compareTo(now.left.value)<0){
deq.add(now);
deq.add(now.left);
}
else{
for(int i = 0;i<now.count;++i){
list.add(now.value);
}
if(now.right!=null){
deq.add(now.right);
}
}
}
}
return list;
}
@Override public String toString(){
final ArrayList<E> list = toList();
return list.toString();
}
@Override public boolean equals(final Object o){
if(o instanceof final TreeMulti<?> tree){
if(size!=tree.size()){
return false;
}
final ArrayList<E> array1 = toList();
final ArrayList<?> array2 = tree.toList();
for(int i = 0;i<size;++i){
if(!array1.get(i).equals(array2.get(i))){
return false;
}
}
return true;
}
return false;
}
@Override public int hashCode(){
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix(Node<E> node){
while(node!=null){
final int lh = node.left==null?0:node.left.height;
final int rh = node.right==null?0:node.right.height;
if(lh-rh>1){
assert node.left!=null;
if(node.left.right!=null&&node.left.right.height==lh-1){
rotateL(node.left);
setStates(node.left);
}
rotateR(node);
}
else if(rh-lh>1){
assert node.right!=null;
if(node.right.left!=null&&node.right.left.height==rh-1){
rotateR(node.right);
setStates(node.right);
}
rotateL(node);
}
setStates(node);
node = node.parent;
}
}
private void rotateR(final Node<E> node){
final Node<E> temp = node.left;
node.left = temp.right;
if(node.left!=null){
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void rotateL(final Node<E> node){
final Node<E> temp = node.right;
node.right = temp.left;
if(node.right!=null){
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void setStates(final Node<E> node){
final int lh = node.left!=null?node.left.height:0;
final int rh = node.right!=null?node.right.height:0;
node.height = Math.max(lh,rh)+1;
final long ls = node.left!=null?node.left.size:0;
final long rs = node.right!=null?node.right.size:0;
node.size = ls+rs+node.count;
}
}
/**
* SimpleScannerクラスです。
* java.util.Scannerクラスよりは速いですが、競プロ用に特化しているため
* charの値がスペース以下の文字は全て区切り文字と判断します。
* 仕様上、必ず入力の最後には区切り文字を含めて下さい。
*/
final class SimpleScanner{
private final int BUFF_SIZE = 1<<17;
private final InputStream is;
private final byte[] buff;
private int point, length;
/**
* 引数のInputStreamを元にSimpleScannerを構築します。
*
* @param is 元となるInputStream
*/
public SimpleScanner(final InputStream is){
this.is = is;
buff = new byte[BUFF_SIZE];
point = length = 0;
}
/**
* バッファに再読み込みします。
* 何かしら入力がされるまで待機します。
*/
private void reload(){
do{
try{
length = is.read(buff,point = 0,BUFF_SIZE);
}catch(final IOException e){
e.printStackTrace();
System.exit(1);
}
}
while(length==-1);
}
/**
* バッファから一文字読み込みます。
*
* @return 読み込んだ文字を表すbyte
*/
private byte read(){
if(point==length){
reload();
}
return buff[point++];
}
/**
* バッファから文字を表すbyteを取得します。
*
* @return まだ読んでない中で最初に入力された文字を表すbyte
*/
public byte nextByte(){
byte c = read();
while(c<=' '){
c = read();
}
return c;
}
/**
* バッファからintを読み込みます。
* オーバーフローは検知できないので注意して下さい。
*
* @return 区切り文字までの文字列をintと解釈した時の値
*/
public int nextInt(){
int ans = 0;
byte c = nextByte();
final boolean negate = c=='-';
if(!MathFunction.rangeCheckClose(c,'0','9')){
c = read();
}
while(MathFunction.rangeCheckClose(c,'0','9')){
ans = ans*10+c-'0';
c = read();
}
return negate?-ans:ans;
}
/**
* バッファからlongを読み込みます。
* オーバーフローは検知できないので注意して下さい。
*
* @return 区切り文字までの文字列をlongと解釈した時の値
*/
public long nextLong(){
long ans = 0;
byte c = nextByte();
final boolean negate = c=='-';
if(!MathFunction.rangeCheckClose(c,'0','9')){
c = read();
}
while(MathFunction.rangeCheckClose(c,'0','9')){
ans = ans*10L+c-'0';
c = read();
}
return negate?-ans:ans;
}
/**
* バッファからcharを読み込みます。
*
* @return 区切り文字を無視した、一番最初に取得された文字を表すchar
*/
public char nextChar(){
return (char)nextByte();
}
/**
* バッファからStringを読み込みます。
*
* @return 区切り文字までの文字列を表すString
*/
public String next(){
final StringBuilder ans = new StringBuilder();
byte c = nextByte();
while(c>' '){
ans.append((char)c);
c = read();
}
return ans.toString();
}
/**
* バッファからBigIntegerを読み込みます。
*
* @return 区切り文字までの文字列を整数と解釈した時のBigInteger
*/
public BigInteger nextBigInteger(){
return new BigInteger(next());
}
/**
* バッファからbyte[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字を無視してn個文字を取得した結果を表すbyte[]
*/
public byte[] nextByte(final int n){
final byte[] ans = new byte[n];
for(int i = 0;i<n;++i){
ans[i] = nextByte();
}
return ans;
}
/**
* バッファからint[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字で区切ってn個intを取得した結果を表すint[]
*/
public int[] nextInt(final int n){
final int[] ans = new int[n];
for(int i = 0;i<n;++i){
ans[i] = nextInt();
}
return ans;
}
/**
* バッファからlong[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字で区切ってn個longを取得した結果を表すlong[]
*/
public long[] nextLong(final int n){
final long[] ans = new long[n];
for(int i = 0;i<n;++i){
ans[i] = nextLong();
}
return ans;
}
/**
* バッファからString[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字で区切ってn個Stringを取得した結果を表すString[]
*/
public String[] next(final int n){
final String[] ans = new String[n];
for(int i = 0;i<n;++i){
ans[i] = next();
}
return ans;
}
public byte[][] nextByte(final int n,final int m){
final byte[][] ans = new byte[n][];
for(int i = 0;i<n;++i){
ans[i] = nextByte(m);
}
return ans;
}
public int[][] nextInt(final int n,final int m){
final int[][] ans = new int[n][];
for(int i = 0;i<n;++i){
ans[i] = nextInt(m);
}
return ans;
}
public long[][] nextLong(final int n,final int m){
final long[][] ans = new long[n][];
for(int i = 0;i<n;++i){
ans[i] = nextLong(m);
}
return ans;
}
public String[][] next(final int n,final int m){
final String[][] ans = new String[n][];
for(int i = 0;i<n;++i){
ans[i] = next(m);
}
return ans;
}
public char[] nextCharArray(){
return next().toCharArray();
}
public char[][] nextCharArray(final int n){
final char[][] ans = new char[n][];
for(int i = 0;i<n;++i){
ans[i] = nextCharArray();
}
return ans;
}
public int[][] nextGraph(final int N,final int M){
if(M==0){
return new int[N+1][0];
}
final int[][] ans = new int[N+1][];
final int[] count = new int[N+1];
final int[][] path = nextInt(M,2);
for(final int[] temp: path){
++count[temp[0]];
++count[temp[1]];
}
for(int i = 1;i<=N;++i){
ans[i] = new int[count[i]];
}
for(final int[] temp: path){
ans[temp[0]][--count[temp[0]]] = temp[1];
ans[temp[1]][--count[temp[1]]] = temp[0];
}
ans[0] = new int[0];
return ans;
}
public Point nextPoint(){
return new Point(nextInt(),nextInt());
}
public Point[] nextPoint(final int n){
final Point[] ans = new Point[n];
for(int i = 0;i<n;++i){
ans[i] = nextPoint();
}
return ans;
}
public void close(){
try{
is.close();
}catch(final IOException e){
e.printStackTrace();
System.exit(1);
}
}
}
/**
* SimpleWriterクラス用のSimpleOutputStreamクラスです。
* ちょっとだけ速いです。
*/
final class SimpleOutputStream extends FilterOutputStream{
private final byte[] buf;
private int count;
public SimpleOutputStream(final OutputStream out){
this(out,1<<17);
}
public SimpleOutputStream(final OutputStream out,final int size){
super(out);
if(size<=0){
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
private void flushBuffer() throws IOException{
if(count>0){
out.write(buf,0,count);
count = 0;
}
}
public void write(final int b) throws IOException{
if(count>=buf.length){
flushBuffer();
}
buf[count++] = (byte)b;
}
public void write(final byte[] b,final int off,final int len) throws IOException{
if(len>=buf.length){
flushBuffer();
out.write(b,off,len);
return;
}
if(len>buf.length-count){
flushBuffer();
}
System.arraycopy(b,off,buf,count,len);
count += len;
}
public void flush() throws IOException{
flushBuffer();
out.flush();
}
}
/**
* SimpleWriterクラスです。
* そこそこ速い出力を提供します。
*/
final class SimpleWriter implements Appendable, Closeable, Flushable, AutoCloseable{
private Writer out;
private final boolean autoFlush;
private boolean trouble = false;
private Formatter formatter;
private PrintStream psOut = null;
public SimpleWriter(final Writer out){
this(out,false);
}
public SimpleWriter(final Writer out,final boolean autoFlush){
this.out = out;
this.autoFlush = autoFlush;
}
public SimpleWriter(final OutputStream out){
this(out,false);
}
public SimpleWriter(final OutputStream out,final boolean autoFlush){
this(out,autoFlush,Charset.defaultCharset());
}
public SimpleWriter(final OutputStream out,final boolean autoFlush,final Charset charset){
this(new BufferedWriter(new OutputStreamWriter(new SimpleOutputStream(out),charset)),autoFlush);
if(out instanceof PrintStream){
psOut = (PrintStream)out;
}
}
private void ensureOpen() throws IOException{
if(out==null){
throw new IOException("Stream closed");
}
}
public void flush(){
try{
ensureOpen();
out.flush();
}catch(IOException x){
trouble = true;
}
}
public void close(){
try{
if(out==null){
return;
}
out.close();
out = null;
}catch(IOException x){
trouble = true;
}
}
public boolean checkError(){
if(out!=null){
flush();
}
else if(psOut!=null){
return psOut.checkError();
}
return trouble;
}
public void write(final int c){
try{
ensureOpen();
out.write(c);
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void write(final char[] buf,final int off,final int len){
try{
ensureOpen();
out.write(buf,off,len);
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void write(final char[] buf){
write(buf,0,buf.length);
}
public void write(final String s,final int off,final int len){
try{
ensureOpen();
out.write(s,off,len);
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void write(final String s){
write(s,0,s.length());
}
private void newLine(){
try{
ensureOpen();
out.write(System.lineSeparator());
if(autoFlush){
out.flush();
}
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void print(final boolean b){
write(b?"true":"false");
}
public void print(final char c){
write(c);
}
public void print(final int i){
write(String.valueOf(i));
}
public void print(final long l){
write(String.valueOf(l));
}
public void print(final float f){
write(String.valueOf(f));
}
public void print(final double d){
write(String.valueOf(d));
}
public void print(final char[] s){
write(s);
}
public void print(final String s){
write(s);
}
public void print(final Object obj){
write(obj.toString());
}
public void println(){
newLine();
}
public void println(final boolean x){
print(x);
println();
}
public void println(final char x){
print(x);
println();
}
public void println(final int x){
print(x);
println();
}
public void println(final long x){
print(x);
println();
}
public void println(final float x){
print(x);
println();
}
public void println(final double x){
print(x);
println();
}
public void println(final char[] x){
print(x);
println();
}
public void println(final String x){
print(x);
println();
}
public void println(final Object x){
print(x.toString());
println();
}
public SimpleWriter printf(final String format,final Object... args){
return format(format,args);
}
public SimpleWriter printf(final Locale l,final String format,final Object... args){
return format(l,format,args);
}
public SimpleWriter format(final String format,final Object... args){
try{
ensureOpen();
if((formatter==null)||(formatter.locale()!=Locale.getDefault())){
formatter = new Formatter(this);
}
formatter.format(Locale.getDefault(),format,args);
if(autoFlush){
out.flush();
}
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
return this;
}
public SimpleWriter format(final Locale l,final String format,final Object... args){
try{
ensureOpen();
if((formatter==null)||(formatter.locale()!=l)){
formatter = new Formatter(this,l);
}
formatter.format(l,format,args);
if(autoFlush){
out.flush();
}
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
return this;
}
public SimpleWriter append(final CharSequence csq){
write(String.valueOf(csq));
return this;
}
public SimpleWriter append(CharSequence csq,final int start,final int end){
if(csq==null){
csq = "null";
}
return append(csq.subSequence(start,end));
}
public SimpleWriter append(final char c){
write(c);
return this;
}
public void print(final int[] array){
print(array,' ');
}
public void print(final int[] array,final String str){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public void print(final int[] array,final char c){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public void print(final int[][] array){
print(array,' ');
}
public void print(final int[][] arrays,final String str){
if(arrays.length==0)
return;
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public void print(final int[][] arrays,final char c){
if(arrays.length==0)
return;
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public void println(final int[] array){
print(array,' ');
println();
}
public void println(final int[] array,final String str){
print(array,str);
println();
}
public void println(final int[] array,final char c){
print(array,c);
println();
}
public void println(final int[][] array){
print(array,' ');
println();
}
public void println(final int[][] arrays,final String str){
print(arrays,str);
println();
}
public void println(final int[][] arrays,final char c){
print(arrays,c);
println();
}
public void print(final long[] array){
print(array,' ');
}
public void print(final long[] array,final String str){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public void print(final long[] array,final char c){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public void print(final long[][] array){
print(array,' ');
}
public void print(final long[][] arrays,final String str){
if(arrays.length==0)
return;
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public void print(final long[][] arrays,final char c){
if(arrays.length==0)
return;
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public void println(final long[] array){
println(array,' ');
}
public void println(final long[] array,final String str){
print(array,str);
println();
}
public void println(final long[] array,final char c){
print(array,c);
println();
}
public void println(final long[][] array){
println(array,' ');
}
public void println(final long[][] arrays,final String str){
print(arrays,str);
println();
}
public void println(final long[][] arrays,final char c){
print(arrays,c);
println();
}
public void print(final double[] array){
print(array,' ');
}
public void print(final double[] array,final String str){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public void print(final double[] array,final char c){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public void print(final double[][] array){
print(array,' ');
}
public void print(final double[][] arrays,final String str){
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public void print(final double[][] arrays,final char c){
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public void println(final double[] array){
println(array,' ');
}
public void println(final double[] array,final String str){
print(array,str);
println();
}
public void println(final double[] array,final char c){
print(array,c);
println();
}
public void println(final double[][] array){
println(array,' ');
}
public void println(final double[][] arrays,final String str){
print(arrays,str);
println();
}
public void println(final double[][] arrays,final char c){
print(arrays,c);
println();
}
public void println(final char[] cs,final String str){
print(cs[0]);
for(int i = 1;i<cs.length;++i){
print(str);
print(cs[i]);
}
println();
}
public void println(final char[] cs,final char c){
print(cs[0]);
for(int i = 1;i<cs.length;++i){
print(c);
print(cs[i]);
}
println();
}
public void println(final char[][] cs){
for(final char[] c: cs){
println(c);
}
}
public void println(final char[][] cs,final String str){
for(final char[] c: cs){
println(c,str);
}
}
public void println(final char[][] cs,final char c){
for(final char[] cc: cs){
println(cc,c);
}
}
public <E> void print(final E[] array){
print(array,' ');
}
public <E> void print(final E[] array,final String str){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public <E> void print(final E[] array,final char c){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public <E> void print(final E[][] arrays){
print(arrays,' ');
}
public <E> void print(final E[][] arrays,final String str){
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public <E> void print(final E[][] arrays,final char c){
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public <E> void println(final E[] array){
println(array,' ');
}
public <E> void println(final E[] array,final String str){
print(array,str);
println();
}
public <E> void println(final E[] array,final char c){
print(array,c);
println();
}
public <E> void println(final E[][] arrays){
println(arrays,' ');
}
public <E> void println(final E[][] arrays,final String str){
print(arrays,str);
println();
}
public <E> void println(final E[][] arrays,final char c){
print(arrays,c);
println();
}
public <E> void println(final List<E> list){
println(list,' ');
}
public <E> void println(final List<E> list,final String str){
if(list.size()>0){
print(list.get(0));
for(int i = 1;i<list.size();++i){
print(str);
print(list.get(i));
}
}
println();
}
public <E> void println(final List<E> list,final char c){
if(list.size()>0){
print(list.get(0));
for(int i = 1;i<list.size();++i){
print(c);
print(list.get(i));
}
}
println();
}
}
import java.awt.Dimension;
import java.awt.Point;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.FilterOutputStream;
import java.io.Flushable;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Formatter;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.function.DoubleUnaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;
//Maybe use
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.TreeMap;
import java.util.TreeSet;
final class Main{
private static final boolean autoFlush = false;
private static final SimpleScanner sc = new SimpleScanner(System.in);
private static final SimpleWriter out = new SimpleWriter(System.out,autoFlush);
private static final int MOD = 998244353;
private static class F{
final long a,b;
F(long a,long b){
this.a = a;
this.b = b;
}
}
public static void main(String[] args){
int N = sc.nextInt();
int M = sc.nextInt();
Long[] A = new Long[N];
for(int i=0;i<N;i++)
A[i] = sc.nextLong()%MOD;
final F origin = new F(1,0);
LazySegmentTree<Long,F> lSegT = new LazySegmentTree<>(A,0L,origin,false){
public Long function(Long a,Long b){
return a;
}
public Long mapping(Long a,F f){
return (a*f.a%MOD+f.b)%MOD;
}
public F composition(F a,F b){
long c = a.a*b.a%MOD;
long d = (b.a*a.b%MOD+b.b)%MOD;
return new F(c,d);
}
};
while(M-->0){
int L = sc.nextInt();
int R = sc.nextInt();
int X = sc.nextInt()%MOD;
long a = (R-L)*MathFunction.modPow(R-L+1,MOD-2,MOD)%MOD;
long b = X*MathFunction.modPow(R-L+1,MOD-2,MOD)%MOD;
lSegT.apply(L-1,R,new F(a,b));
}
long[] ans = new long[N];
for(int i=0;i<N;i++)
ans[i] = lSegT.get(i);
out.println(ans);
out.close();
}
}
/*
,.へ
___ ﾑ i
「ﾋ_i〉 ゝ 〈
ﾄ ノ iニ()
i { ＿＿＿_ | ヽ
i i ／_, ,‐-＼ i }
| i ／（●) ( ● )＼ {､ λ
ト－┤. ／ （__人__） ＼ ,ノ￣,!
i ゝ､_ | ´￣` | ,. '´ﾊ ,!
ヽ、 ｀`､,__＼ ／" ＼ ヽ／
＼ノ ﾉ ﾊ￣ r/::r―--―/:７ ﾉ ／
ヽ. ヽ:<:'::'|:/ / ,."
`ｰ ､ ＼ヽ:::|/ ｒ'"
／￣二二二二二二二二二二二二二二二二二ヽ
| 答 | A C │|
＼＿二二二二二二二二二二二二二二二二二ノ
*/
/*////////////////////////////////////////////////////////////////////////////////////////////
* My Library *
@author viral
*/////////////////////////////////////////////////////////////////////////////////////////////
final class Factorial{
//階乗とその逆元
private final long[] fact, inFact;
private final long mod;
/**
* 1～Nの階乗とその逆元をmodで割ったあまりを事前に計算します。
*
* @param N 計算範囲
* @param mod 法
*/
public Factorial(final int N,final long mod){
fact = new long[N+1];
fact[0] = fact[1] = 1;
for(int i = 2;i<=N;++i){
fact[i] = fact[i-1]*i%mod;
}
inFact = new long[N+1];
inFact[N] = MathFunction.modPow(fact[N],mod-2,mod);
for(int i = N;i>0;--i){
inFact[i-1] = inFact[i]*i%mod;
}
inFact[0] = 1;
this.mod = mod;
}
/**
* num!をmodで割ったあまりを返します。
*
* @param num num!となるnum
*
* @return num!
*/
public long getFact(final int num){
return fact[num];
}
/**
* num!^-1をmodで割ったあまりを返します。
*
* @param num num!^-1となるnum
*
* @return num!
*/
public long getInFact(final int num){
return inFact[num];
}
/**
* modを法とした時のnum^-1を返します。
*
* @param num num^-1 mod mとなるnum
*
* @return num!
*/
public long getInverse(final int num){
return fact[num-1]*inFact[num]%mod;
}
/**
* aCbをmodで割ったあまりを返します。
*
* @param a aCbとなるa
* @param b aCbとなるb
*
* @return aCb
*/
public long getCombi(final int a,final int b){
if(a<b||a<0||b<0){
return 0;
}
return (fact[a]*inFact[a-b]%mod)*inFact[b]%mod;
}
}
final class ArrayFunction{
/**
* カウントソートによるソートです。
* 各要素が0以上であり最大値が十分小さい時はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param maximumLimit array内の最大要素
*/
public static void countSort(final int[] array,final int maximumLimit){
countSort(array,0,array.length,maximumLimit);
}
/**
* カウントソートによるソートです。
* 各要素が0以上であり最大値が十分小さい時はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
* @param maximumLimit array内の最大要素
*/
public static void countSort(final int[] array,final int l,final int r,final int maximumLimit){
final int[] list = new int[maximumLimit+1];
for(int i = l;i<r;++i){
++list[array[i]];
}
int temp = l;
for(int i = 0;i<list.length;++i){
while(list[i]-->0){
array[temp++] = i;
}
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void insertSort(final int[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のlong型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void insertSort(final long[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のchar型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void insertSort(final char[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]>array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによるソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象の配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static <E extends Comparable<E>> void insertSort(final E[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])>0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のint型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void reverseInsertSort(final int[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
int num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のlong型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void reverseInsertSort(final long[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
long num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象のchar型配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static void reverseInsertSort(final char[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
char num = array[j];
while(l<j&&array[j-1]<array[j]){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 挿入ソートによる逆順ソートです。
* 各要素がほとんどソートされている場合はこちらの使用を推奨します。
*
* @param array ソート対象の配列
* @param l ソート範囲の左端
* @param r ソート範囲の右端(rを含まない)
*/
public static <E extends Comparable<E>> void reverseInsertSort(final E[] array,final int l,final int r){
for(int i = l+1;i<r;i++){
int j = i;
E num = array[j];
while(l<j&&array[j-1].compareTo(array[j])<0){
array[j] = array[j-1];
--j;
}
array[j] = num;
}
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateR(final int[][] array){
final int[][] ans = new int[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateR(final long[][] array){
final long[][] ans = new long[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateR(final char[][] array){
final char[][] ans = new char[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateR(final double[][] array){
final double[][] ans = new double[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateR(final boolean[][] array){
final boolean[][] ans = new boolean[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を右周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateR(final E[][] array,final E[][] ans){
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[ans[i].length-j-1][i];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static int[][] rotateL(final int[][] array){
final int[][] ans = new int[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
final int index = i;
Arrays.setAll(ans[i],k->array[k][ans.length-index-1]);
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static long[][] rotateL(final long[][] array){
final long[][] ans = new long[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
final int index = i;
Arrays.setAll(ans[i],k->array[k][ans.length-index-1]);
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static char[][] rotateL(final char[][] array){
final char[][] ans = new char[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static double[][] rotateL(final double[][] array){
final double[][] ans = new double[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static boolean[][] rotateL(final boolean[][] array){
final boolean[][] ans = new boolean[array[0].length][array.length];
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 配列を左周りに90度回転させたものを返します。
* 長方形でない配列に関しての動作は保証していません。
*
* @param array 回転させる行列
*
* @return 回転させた配列
*/
public static <E> E[][] rotateL(final E[][] array,final E[][] ans){
for(int i = 0;i<ans.length;++i){
for(int j = 0;j<ans[i].length;++j){
ans[i][j] = array[j][ans.length-i-1];
}
}
return ans;
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(int[] array){
return lis(array,false);
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(int[][] arrays,int p){
return lis(arrays,p,false);
}
/**
* 引数の配列の最長狭義増加部分列の長さを返します。
*
* @param array 最長狭義増加部分列の長さを求める配列
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(long[] array){
return lis(array,false);
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(long[][] arrays,int p){
return lis(arrays,p,false);
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(int[] array,boolean include){
int[] list = new int[array.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int num: array){
int index = include?Searcher.overSearch(list,num):Searcher.upSearch(list,num);
list[index] = Math.min(list[index],num);
}
int answer = Searcher.underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(int[][] arrays,int p,boolean include){
int[] list = new int[arrays.length];
Arrays.fill(list,Integer.MAX_VALUE);
for(int[] array: arrays){
int index = include?Searcher.overSearch(list,array[p]):Searcher.upSearch(list,array[p]);
list[index] = Math.min(list[index],array[p]);
}
int answer = Searcher.underSearch(list,Integer.MAX_VALUE);
return answer+1;
}
/**
* 引数の配列の最長増加部分列の長さを返します。
*
* @param array 最長増加部分列の長さを求める配列
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return 最長狭義増加部分列の長さ
*/
public static int lis(long[] array,boolean include){
long[] list = new long[array.length];
Arrays.fill(list,Long.MAX_VALUE);
for(long num: array){
int index = include?Searcher.overSearch(list,num):Searcher.upSearch(list,num);
list[index] = Math.min(list[index],num);
}
int answer = Searcher.underSearch(list,Long.MAX_VALUE);
return answer+1;
}
/**
* 引数の配列指定されたインデックスの最長狭義増加部分列の長さを返します。
*
* @param arrays 最長狭義増加部分列の長さを求める配列
* @param p 探索する配列のインデックス
* @param include 広義増加列ならtrue、狭義増加列ならfalse
*
* @return arrays[i][p](0 < = p < = arrays.length)の最長狭義増加部分列の長さ
*/
public static int lis(long[][] arrays,int p,boolean include){
long[] list = new long[arrays.length];
Arrays.fill(list,Long.MAX_VALUE);
for(long[] array: arrays){
int index = include?Searcher.overSearch(list,array[p]):Searcher.upSearch(list,array[p]);
list[index] = Math.min(list[index],array[p]);
}
int answer = Searcher.underSearch(list,Long.MAX_VALUE);
return answer+1;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort(final ArrayList<ArrayList<Integer>> route){
final int[] count = new int[route.size()];
int pathCount = 0;
for(final ArrayList<Integer> path: route){
for(final int point: path){
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for(int i = 1;i<count.length;++i){
if(count[i]==0){
deq.add(i);
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while(deq.size()>0){
int nowP = deq.pollFirst();
for(final int nextP: route.get(nowP)){
ans[index][0] = nowP;
ans[index++][1] = nextP;
if(--count[nextP]==0){
deq.add(nextP);
}
}
}
return ans;
}
/**
* 引数の情報から求められる有向辺に対してトポロジカルソートを行ないます。
* 戻り値は辺を表すint型二次元配列です。
*
* @param route 有向グラフの隣接リスト
*
* @return トポロジカルソート済み有向グラフ
*/
public static int[][] topologicalSort(final int[][] route){
final int[] count = new int[route.length];
int pathCount = 0;
for(final int[] path: route){
for(final int point: path){
++pathCount;
++count[point];
}
}
final ArrayDeque<Integer> deq = new ArrayDeque<>();
for(int i = 1;i<count.length;++i){
if(count[i]==0){
deq.add(i);
}
}
final int[][] ans = new int[pathCount][2];
int index = 0;
while(deq.size()>0){
int nowP = deq.pollFirst();
for(final int nextP: route[nowP]){
ans[index][0] = nowP;
ans[index++][1] = nextP;
if(--count[nextP]==0){
deq.add(nextP);
}
}
}
return ans;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final int[] array,final int a,final int b){
final int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final long[] array,final int a,final int b){
final long temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final double[] array,final int a,final int b){
final double temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final char[] array,final int a,final int b){
final char temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static void swap(final boolean[] array,final int a,final int b){
final boolean temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元
* @param b 交換先
*/
public static <E> void swap(final E[] array,final int a,final int b){
final E temp = array[a];
array[a] = array[b];
array[b] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final int[][] array,final int a,final int b,final int c,final int d){
final int temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final long[][] array,final int a,final int b,final int c,final int d){
final long temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final double[][] array,final int a,final int b,final int c,final int d){
final double temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final char[][] array,final int a,final int b,final int c,final int d){
final char temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static void swap(final boolean[][] array,final int a,final int b,final int c,final int d){
final boolean temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の位置の要素を交換します。
*
* @param array 交換する要素の含まれる配列
* @param a 交換元の第1インデックス
* @param b 交換元の第2インデックス
* @param c 交換先の第1インデックス
* @param d 交換先の第2インデックス
*/
public static <E> void swap(final E[][] array,final int a,final int b,final int c,final int d){
final E temp = array[a][b];
array[a][b] = array[c][d];
array[c][d] = temp;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation(final int[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]<array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation(final long[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]<array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
long min = Long.MAX_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static boolean nextPermutation(final char[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]<array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int min = Integer.MAX_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の次に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で次に当たる配列がある場合はtrue、arrayが降順に並んでいるならfalse
*/
public static <E extends Comparable<E>> boolean nextPermutation(final E[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1].compareTo(array[i])<0){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = -1;
E min = MathFunction.max(array);
int subIndex = -1;
E max = array[index1];
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],array[index1],min)){
min = array[i];
index2 = i;
}
if(max.compareTo(array[i])<0){
subIndex = i;
max = array[i];
}
}
if(index2==-1){
swap(array,index1,subIndex);
}
else{
swap(array,index1,index2);
}
reverseRange(array,index1+1,array.length);
insertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static boolean previousPermutation(final int[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]>array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static boolean previousPermutation(final long[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]>array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
long max = Long.MIN_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static boolean previousPermutation(final char[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1]>array[i]){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = 0;
int max = Integer.MIN_VALUE;
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
}
swap(array,index1,index2);
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列の要素を並び替えた時の、辞書順で引数の直前に当たる順番に並び替えます。
* 原則として、要素に重複が無いものとして処理します。重複がある場合の戻り値は保証されていません。
*
* @param array 並び替え対象の配列
*
* @return 辞書順で直前に当たる配列がある場合はtrue、arrayが昇順に並んでいるならfalse
*/
public static <E extends Comparable<E>> boolean previousPermutation(final E[] array){
int index1 = 0;
for(int i = 1;i<array.length;++i){
if(array[i-1].compareTo(array[i])>0){
index1 = i;
}
}
if(--index1<0){
return false;
}
int index2 = -1;
E max = MathFunction.min(array);
int subIndex = -1;
E min = array[index1];
for(int i = index1+1;i<array.length;++i){
if(MathFunction.rangeCheckOpen(array[i],max,array[index1])){
max = array[i];
index2 = i;
}
if(min.compareTo(array[i])>0){
subIndex = i;
min = array[i];
}
}
if(index2==-1){
swap(array,index1,subIndex);
}
else{
swap(array,index1,index2);
}
reverseRange(array,index1+1,array.length);
reverseInsertSort(array,index1+1,array.length);
return true;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static int[] reBuild(final int[] array,final IntUnaryOperator func){
final int[] ans = new int[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsInt(array[i]);
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static int[] reBuild(final int[] array,final IntBinaryOperator func){
final int[] ans = new int[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsInt(i,array[i]);
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static long[] reBuild(final long[] array,final LongUnaryOperator func){
final long[] ans = new long[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsLong(array[i]);
}
return ans;
}
/**
* 引数の配列と関数を元に配列を再構築します。
*
* @param array 元となる配列
* @param func 配列に施す関数
*/
public static long[] reBuild(final long[] array,final LongBinaryOperator func){
final long[] ans = new long[array.length];
for(int i = 0;i<array.length;++i){
ans[i] = func.applyAsLong(i,array[i]);
}
return ans;
}
/**
* 配列の要素を順に引数のConsumerに作用させます。
*
* @param array 作用させる配列
* @param func 作用先のConsumer
*/
public static void computeByArray(final int[] array,final IntConsumer func){
for(final int num: array){
func.accept(num);
}
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final int[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final long[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final double[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final char[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static void reverseRange(final boolean[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* 引数の区間の要素を逆順にします。
*
* @param array 元となる配列
* @param l 区間の左端
* @param r 区間の右端(rを含まない)
*/
public static <E> void reverseRange(final E[] array,int l,int r){
while(l<r)
swap(array,l++,--r);
}
/**
* Mo's Algorithm用のComparatorを返します。
*
* @param 分割数
* @return Mo's Algorithm用のComparator
*/
public static Comparator<int[]> mo_sComparator(final int M){
return (a,b)->a[0]/M!=b[0]/M?Integer.compare(a[0]/M,b[0]/M):
Integer.compare(a[1]/M,b[1]/M)*((a[0]/M&1)==0?-1:1);
}
}
final class Converter{
/**
* 渡された文字列を逆順にした文字列を返します。
*
* @param str 元の文字列
*
* @return strを逆順にした文字列
*/
public static String reverse(final String str){
final StringBuilder sb = new StringBuilder();
for(int i = str.length()-1;i>=0;--i){
sb.append(str.charAt(i));
}
return sb.toString();
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static int[] toIntArray(final List<Integer> list){
final int[] ans = new int[list.size()];
int index = 0;
for(int num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static long[] toLongArray(final List<Long> list){
final long[] ans = new long[list.size()];
int index = 0;
for(long num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static char[] toCharArray(final List<Character> list){
final char[] ans = new char[list.size()];
int index = 0;
for(char num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static double[] toDoubleArray(final List<Double> list){
final double[] ans = new double[list.size()];
int index = 0;
for(double num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static boolean[] toBooleanArray(final List<Boolean> list){
final boolean[] ans = new boolean[list.size()];
int index = 0;
for(boolean num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static byte[] toByteArray(final List<Byte> list){
final byte[] ans = new byte[list.size()];
int index = 0;
for(byte num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static short[] toShortArray(final List<Short> list){
final short[] ans = new short[list.size()];
int index = 0;
for(short num: list){
ans[index++] = num;
}
return ans;
}
/**
* 渡されたラッパークラスのListをプリミティヴ型の配列に変換します。
*
* @param list 元のList
*
* @return listの要素をプリミティヴ型に変換した配列
*/
public static float[] toFloatArray(final List<Float> list){
final float[] ans = new float[list.size()];
int index = 0;
for(float num: list){
ans[index++] = num;
}
return ans;
}
}
final class MathFunction{
private static final int[] numberForIntPrime = {2,7,61};
private static final long[] numberForLongPrime = {2,7,61,325,9375,28178,450775,9780504,1795265022};
/**
* aとbの最大公約数を求めます。戻り値は0以上であることが保証されます。
*
* @param a 公約数を求める整数
* @param b 公約数を求める整数
*
* @return aとbの最大公約数
*/
public static long gcd(long a,long b){
a = Math.abs(a);
b = Math.abs(b);
if(b==0){
return a;
}
long temp;
while((temp = a%b)!=0){
a = b;
b = temp;
}
return b;
}
/**
* aとbの最小公倍数を求めます。
* オーバーフロー検知は出来ません。
*
* @param a 公倍数を求める整数
* @param b 公倍数を求める整数
*
* @return aとbの最小公倍数
*/
public static long lcm(final long a,final long b){
return a/gcd(a,b)*b;
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
public static boolean isPrime(long n){
n = Math.abs(n);
if(n==2L){
return true;
}
if(n==1L||(n&1L)==0L){
return false;
}
if(n<=4_759_123_141L){
return isPrimeForInt(n);
}
return isPrimeForBigInteger(n);
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
private static boolean isPrimeForInt(long n){
long d = n-1;
while((d&1)==0L){
d >>= 1;
}
for(final long a: numberForIntPrime){
if(a>=n){
return true;
}
long t = d;
long y = MathFunction.modPow(a,t,n);
while(t<n-1L&&y!=1&&y!=n-1){
y = y*y%n;
t <<= 1;
}
if(y!=n-1&&(t&1L)==0){
return false;
}
}
return true;
}
/**
* 引数が素数か判定します。
*
* @param n 検査対象
*
* @return nが素数であるならtrue、素数でないならfalse
*/
private static boolean isPrimeForBigInteger(long n){
long d = n-1L;
while((d&1)==0L){
d >>= 1;
}
final BigInteger bigN = BigInteger.valueOf(n);
final BigInteger bigNSubOne = bigN.subtract(BigInteger.ONE);
final BigInteger bigD = BigInteger.valueOf(d);
for(final long a: numberForLongPrime){
if(a>=n){
return true;
}
BigInteger t = bigD;
BigInteger y = BigInteger.valueOf(a).modPow(t,bigN);
while(t.compareTo(bigNSubOne)<0&&!y.equals(BigInteger.ONE)&&!y.equals(bigNSubOne)){
y = y.multiply(y).mod(bigN);
t = t.shiftLeft(1);
}
if(!y.equals(bigNSubOne)&&(t.intValue()&1)==0){
return false;
}
}
return true;
}
/**
* num以下の素数を列挙します。
*
* @param num 素数を探す上限値
*
* @return num以下の素数のint型配列
*/
public static int[] primes(final int num){
if(num<2){
return new int[0];
}
final BitSet numbers = new BitSet(num+1);
numbers.set(2,num+1);
final int limit = (int)Math.sqrt(num);
int bit = 0;
while(
rangeCheckClose(
bit=numbers.nextSetBit(bit+1),
2,
limit)){
for(int j = bit*bit;j<=num;j+=bit){
numbers.clear(j);
}
}
final int[] answer = new int[numbers.cardinality()];
bit = 0;
for(int i=0;i<answer.length;++i)
bit = (answer[i] = numbers.nextSetBit(bit+1));
return answer;
}
/**
* a**bを計算します。
*
* @param a 被累乗数
* @param b 指数
*
* @return a**b
*/
public static long pow(long a,long b){
long ans = 1;
while(b>0){
if((b&1)==1){
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
/**
* a**bをmodで割ったあまりを計算します。
*
* @param a 被累乗数
* @param b 指数
* @param mod 法とする整数
*
* @return a**bをmodで割ったあまり
*/
public static long modPow(long a,long b,final long mod){
long ans = 1;
a %= mod;
while(b>0){
if((b&1)==1){
ans *= a;
}
ans %= mod;
a *= a;
a %= mod;
b >>= 1;
}
return ans;
}
/**
* N!を計算します。
*
* @param N 階乗を求めるのに用いる値
*
* @return N!
*/
public static long fact(final int N){
long ans = 1;
for(int i = 2;i<=N;++i){
ans *= i;
}
return ans;
}
/**
* N!をmodで割ったあまりを計算します。
*
* @param N 階乗を求めるのに用いる値
* @param mod 法とする整数
*
* @return N!をmodで割ったあまり
*/
public static long modFact(final int N,final long mod){
long ans = 1;
for(int i = 2;i<=N;++i){
ans *= i;
ans %= mod;
}
return ans;
}
/**
* nCrを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
*
* @return nCr
*/
public static long combi(final long n,long r){
if(r<0||n<r){
return 0;
}
long ans = 1;
r = Math.min(n-r,r);
for(int i = 0;i<r;++i){
ans *= n-i;
ans /= i+1;
}
return ans;
}
/**
* nCrをmodで割ったあまりを計算します。
*
* @param n 二項係数を求めるのに用いる値
* @param r 二項係数を求めるのに用いる値
* @param mod 法とする整数
*
* @return nCrをmodで割ったあまり
*/
public static long modCombi(final long n,long r,final long mod){
if(r<0||n<r){
return 0;
}
long ans = 1;
r = Math.min(n-r,r);
for(int i = 0;i<r;++i){
ans *= (n-i)%mod;
ans %= mod;
ans *= modPow(i+1,mod-2,mod);
ans %= mod;
}
return ans;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param x1 点1のx座標
* @param y1 点1のy座標
* @param x2 点2のx座標
* @param y2 点2のy座標
* @param x3 点3のx座標
* @param y3 点3のy座標
* @param x4 点4のx座標
* @param y4 点4のy座標
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed(final int x1,final int y1,final int x2,final int y2,final int x3,final int y3,final int x4,final int y4){
final long s1 = (long)(x1-x2)*(y3-y1)-(long)(y1-y2)*(x3-x1);
final long t1 = (long)(x1-x2)*(y4-y1)-(long)(y1-y2)*(x4-x1);
final long s2 = (long)(x3-x4)*(y1-y3)-(long)(y3-y4)*(x1-x3);
final long t2 = (long)(x3-x4)*(y2-y3)-(long)(y3-y4)*(x2-x3);
final long temp1 = s1*t1;
final long temp2 = s2*t2;
if(temp1>0||temp2>0){
return -1;
}
if(temp1==0&&temp2==0){
return 0;
}
return 1;
}
/**
* 引数の前半二点、後半二点で構成される二線分が交差しているか返します。
*
* @param p1 点1
* @param p2 点2
* @param p3 点3
* @param p4 点4
*
* @return 交差している(線分の端が他方の線分上に存在する場合も含む)場合は1、同一線分直線上なら0、それ以外は-1
*/
public static int isCrossed(final Point p1,final Point p2,final Point p3,final Point p4){
return isCrossed(p1.x,p1.y,p2.x,p2.y,p3.x,p3.y,p4.x,p4.y);
}
/**
* 指定された頂点を順に結んで出来上がる多角形が凸多角形か判定します。
*
* @param points 多角形を構成する点
*
* @return 多角形が凸多角形ならtrue
*/
public static boolean isConvex(final Point... points){
final int n = points.length;
if(n<3){
return false;
}
if(n==3){
return true;
}
boolean conv = true;
for(int i = 0;i<n;++i){
int result = isCrossed(points[i],points[(i+2)%n],points[(i+1)%n],points[(i+1+n/2)%n]);
conv &= result>=0;
}
return conv;
}
/**
* numをmodで割ったあまりを返します。
* 戻り値は0以上mod未満であることが保証されます。
*
* @param num 被除算数
* @param mod 法とする値
*
* @return numをmodで割ったあまり
*/
public static long remainder(long num,final long mod){
num %= mod;
if(num<0){
num += mod;
}
return num;
}
/**
* numが何桁かを返します。
* 0は1桁として捉えます。
*
* @param num 調べる整数
*
* @return numの桁数
*/
public static int digit(final long num){
if(num<10L){
return 1;
}
if(num<100L){
return 2;
}
if(num<1000L){
return 3;
}
if(num<10000L){
return 4;
}
if(num<100000L){
return 5;
}
if(num<1000000L){
return 6;
}
if(num<10000000L){
return 7;
}
if(num<100000000L){
return 8;
}
if(num<1000000000L){
return 9;
}
if(num<10000000000L){
return 10;
}
if(num<100000000000L){
return 11;
}
if(num<1000000000000L){
return 12;
}
if(num<10000000000000L){
return 13;
}
if(num<100000000000000L){
return 14;
}
if(num<1000000000000000L){
return 15;
}
if(num<10000000000000000L){
return 16;
}
if(num<100000000000000000L){
return 17;
}
if(num<1000000000000000000L){
return 18;
}
return 19;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static int max(final int... nums){
int ans = Integer.MIN_VALUE;
for(int num: nums){
ans = Math.max(ans,num);
}
return ans;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static long max(final long... nums){
long ans = Long.MIN_VALUE;
for(long num: nums){
ans = Math.max(ans,num);
}
return ans;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static double max(final double... nums){
double ans = -Double.MIN_VALUE;
for(double num: nums){
ans = Math.max(ans,num);
}
return ans;
}
/**
* 引数の中で最大の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最大の要素
*/
public static <E extends Comparable<E>> E max(final E[] nums){
E ans = nums[0];
for(E value: nums){
if(ans.compareTo(value)>0){
ans = value;
}
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static int min(final int... nums){
int ans = Integer.MAX_VALUE;
for(int num: nums){
ans = Math.min(ans,num);
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static long min(final long... nums){
long ans = Long.MAX_VALUE;
for(long num: nums){
ans = Math.min(ans,num);
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static double min(final double... nums){
double ans = Double.MAX_VALUE;
for(double num: nums){
ans = Math.min(ans,num);
}
return ans;
}
/**
* 引数の中で最小の値を返します。
*
* @param nums 探索対象
*
* @return 引数で最小の要素
*/
public static <E extends Comparable<E>> E min(final E[] nums){
E ans = nums[0];
for(E value: nums){
if(ans.compareTo(value)<0){
ans = value;
}
}
return ans;
}
/**
* 引数の総和を返します。
*
* @param nums 加算対象
*
* @return 引数の総和
*/
public static long sum(final int... nums){
long ans = 0;
for(int num: nums){
ans += num;
}
return ans;
}
/**
* 引数の総和を返します。
*
* @param nums 加算対象
*
* @return 引数の総和
*/
public static long sum(final long... nums){
long ans = 0;
for(long num: nums){
ans += num;
}
return ans;
}
/**
* 引数の総和を指定された値で割ったあまりを返します。
*
* @param mod 法とする値
* @param nums 加算対象
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final long mod,final int... nums){
long ans = 0;
for(int num: nums){
ans += num;
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 引数の総和を指定された値で割ったあまりを返します。
*
* @param mod 法とする値
* @param nums 加算対象
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final long mod,final long... nums){
long ans = 0;
for(long num: nums){
ans += num;
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 指定された区間の総和を返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
*
* @return 指定された区間の総和
*/
public static long sum(final int[] nums,int from,int to){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
}
return ans;
}
/**
* 指定された区間の総和を返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
*
* @return 指定された区間の総和
*/
public static long sum(final long[] nums,int from,int to){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
}
return ans;
}
/**
* 指定された区間の総和を指定された値で割ったあまりを返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
* @param mod 法とする値
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final int[] nums,int from,int to,long mod){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 指定された区間の総和を指定された値で割ったあまりを返します。
*
* @param nums 加算対象
* @param from 区間の左端
* @param to 区間の右端(toを含まない)
* @param mod 法とする値
*
* @return 引数の総和を指定された値で割ったあまり
*/
public static long modSum(final long[] nums,int from,int to,long mod){
long ans = 0;
for(int i = from;i<to;++i){
ans += nums[i];
ans %= mod;
}
if(ans<0){
ans += mod;
}
return ans;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck(final int num,final int l,final int r){
return l<=num&&num<r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck(final long num,final long l,final long r){
return l<=num&&num<r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheck(final double num,final double l,final double r){
return l<=num&&num<r;
}
/**
* 引数numがl以上r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含まない)
*
* @return l <= num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheck(final E num,final E l,final E r){
return 0<=l.compareTo(num)&&0<num.compareTo(r);
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen(final int num,final int l,final int r){
return l<num&&num<r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen(final long num,final long l,final long r){
return l<num&&num<r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckOpen(final double num,final double l,final double r){
return l<num&&num<r;
}
/**
* 引数numがlより大きく、r未満の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含まない)
* @param r 上限(rを含まない)
*
* @return l < num < rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckOpen(final E num,final E l,final E r){
return 0<l.compareTo(num)&&0<num.compareTo(r);
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose(final int num,final int l,final int r){
return l<=num&&num<=r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose(final long num,final long l,final long r){
return l<=num&&num<=r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static boolean rangeCheckClose(final double num,final double l,final double r){
return l<=num&&num<=r;
}
/**
* 引数numがl以上r以下の範囲内か判定します。
*
* @param num 判定する値
* @param l 下限(lを含む)
* @param r 上限(rを含む)
*
* @return l <= num <= rを満たしていればtrue 、 満たしていなければfalse
*/
public static <E extends Comparable<E>> boolean rangeCheckClose(final E num,final E l,final E r){
return 0<=l.compareTo(num)&&0<=num.compareTo(r);
}
/**
* 引数の中でのmexを求めます。
*
* @param nums 引数
*/
public static int mex(final int... nums){
final BitSet set = new BitSet(nums.length);
for(final int num: nums)
if(num<nums.length)
set.set(num);
return set.nextSetBit(0);
}
}
final class Searcher{
private static final int CYCLE_COUNT = Double.MAX_EXPONENT+53;
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static int downSearch(final char[] array,final int value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最大のインデックスを返します。
* 見つからなかった場合は指定された要素未満で最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以下で最大のインデックス
*/
public static <E extends Comparable<E>> int downSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static int downSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static long downSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最大の引数を返します。
* 見つからなかった場合は指定された値未満で最大の引数を返します。
* もしそのような要素が存在しない場合は下限より小さい値を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以下で最大の引数
*/
public static double search(double a,double b,final double value,final DoubleUnaryOperator func){
double ans = a-Math.abs(a), c;
for(int $ = 0;$<CYCLE_COUNT;++$){
c = (a+b)/2;
if(func.applyAsDouble(c)>value){
b = c;
}
else{
a = (ans = c);
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final int[] array,final int value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final long[] array,final long value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final double[] array,final double value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static boolean contains(final char[] array,final char value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains(final E[] array,final E value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
int result = array[c].compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> boolean contains(final List<E> list,final E value){
int a = 0, b = list.size()-1, c;
while(a-b<1){
c = (a+b)/2;
int result = list.get(c).compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains(int a,int b,final int value,final IntUnaryOperator func){
int c;
while(a-b<1){
c = (a+b)/2;
int num = func.applyAsInt(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がa以上b以下で探索値を取るかを表すboolean
*/
public static boolean contains(long a,long b,final long value,final LongUnaryOperator func){
long c;
while(a-b<1){
c = (a+b)/2;
long num = func.applyAsLong(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return true;
}
}
return false;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final int[] array,final int value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final long[] array,final long value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final double[] array,final double value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayのvalueのインデックス(無ければ - 1)
*/
public static int search(final char[] array,final char value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = c-1;
}
else if(array[c]<value){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return arrayにvalueが含まれているかを表すboolean
*/
public static <E extends Comparable<E>> int search(final E[] array,final E value){
int a = 0, b = array.length-1, c;
while(a-b<1){
c = (a+b)/2;
int result = array[c].compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* リスト内の指定された要素を探します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return listのvalueのインデックス(無ければ - 1)
*/
public static <E extends Comparable<E>> int search(final List<E> list,final E value){
int a = 0, b = list.size()-1, c;
while(a-b<1){
c = (a+b)/2;
int result = list.get(c).compareTo(value);
if(result>0){
b = c-1;
}
else if(result<0){
a = c+1;
}
else{
return c;
}
}
return -1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static int search(int a,int b,final int value,final IntUnaryOperator func){
int c;
while(a-b<1){
c = (a+b)/2;
int num = func.applyAsInt(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return c;
}
}
return a-1;
}
/**
* 広義単調増加な関数内の指定された値を探します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return この関数がvalueを取る引数(無ければa - 1)
*/
public static long search(long a,long b,final long value,final LongUnaryOperator func){
long c;
while(a-b<1){
c = (a+b)/2;
long num = func.applyAsLong(c);
if(num>value){
b = c-1;
}
else if(num<value){
a = c+1;
}
else{
return c;
}
}
return a-1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static int upSearch(final char[] array,final char value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>=0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* リスト内の指定された要素を探します。
* リスト内で見つかった場合はその要素と同一で最小のインデックスを返します。
* 見つからなかった場合は指定された要素以上で最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 指定された要素以上で最小のインデックス
*/
public static <E extends Comparable<E>> int upSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = list.size(), c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>=0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static int upSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値を探します。
* 関数内で見つかった場合はその値と同一で最小の引数を返します。
* 見つからなかった場合は指定された値以上で最大の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 指定された値以上で最小の引数
*/
public static long upSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>=value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static int underSearch(final char[] array,final char value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より小さい要素を探します。
* 配列内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>=0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* リスト内の指定された要素より小さい要素を探します。
* リスト内で見つかった場合は条件を満たす最大のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最大のインデックス
*/
public static <E extends Comparable<E>> int underSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = -1, c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>=0){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static int underSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より小さい値を探します。
* 関数内で見つかった場合は条件を満たす最大の引数を返します。
* もしそのような要素が存在しない場合は下限-1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最大の引数
*/
public static long underSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = a-1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>=value){
b = c-1;
}
else{
a = (ans = c)+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final int[] array,final int value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final long[] array,final long value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final double[] array,final double value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int overSearch(final char[] array,final char value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c]>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素より大きい要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はarray.lengthを返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch(final E[] array,final E value){
int a = 0, b = array.length-1, ans = array.length, c;
while(a-b<1){
c = (a+b)/2;
if(array[c].compareTo(value)>0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* リスト内の指定された要素より大きい要素を探します。
* リスト内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合はlist.size()を返します。
*
* @param list 探索対象のリスト
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int overSearch(final List<E> list,final E value){
int a = 0, b = list.size()-1, ans = list.size(), c;
while(a-b<1){
c = (a+b)/2;
if(list.get(c).compareTo(value)>0){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static int overSearch(int a,int b,final int value,final IntUnaryOperator func){
int ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsInt(c)>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 広義単調増加な関数内の指定された値より大きい値を探します。
* 関数内で見つかった場合は条件を満たす最小の引数を返します。
* もしそのような要素が存在しない場合は上限+1を返します。
*
* @param a 探索範囲の下限
* @param b 探索範囲の上限
* @param value 探索値
*
* @return 条件を満たす最小の引数
*/
public static long overSearch(long a,long b,final long value,final LongUnaryOperator func){
long ans = b+1, c;
while(a-b<1){
c = (a+b)/2;
if(func.applyAsLong(c)>value){
b = (ans = c)-1;
}
else{
a = c+1;
}
}
return ans;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final int[] array,final int value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final long[] array,final long value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final double[] array,final double value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static int linearSearch(final char[] array,final char value){
for(int i = 0;i<array.length;++i){
if(array[i]==value){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param array 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch(final E[] array,final E value){
for(int i = 0;i<array.length;++i){
if(array[i].compareTo(value)==0){
return i;
}
}
return -1;
}
/**
* 配列内の指定された要素を探します。
* 配列内で見つかった場合は条件を満たす最小のインデックスを返します。
* もしそのような要素が存在しない場合は-1を返します。
*
* @param list 探索対象の配列
* @param value 探索要素
*
* @return 条件を満たす最小のインデックス
*/
public static <E extends Comparable<E>> int linearSearch(final List<E> list,final E value){
for(int i = 0;i<list.size();++i){
if(list.get(i).compareTo(value)==0){
return i;
}
}
return -1;
}
}
/**
* Binary Indexed Treeクラスです。
* 引数は1-indexedであることを要求します。
*/
final class BIT{
final int size;
final private long[] tree;
/**
* 大きさnのBITを生成します。
*
* @param n 生成するBITの大きさ
*/
public BIT(int n){
size = n;
tree = new long[n+1];
}
/**
* [1,i]の総和を求めます。
*
* @param i 求める区間の右端(iを含む)
*
* @return [1,i]の総和
*/
public long sum(int i){
long sum = 0;
while(i>0){
sum += tree[i];
i ^= i&(-i);
}
return sum;
}
/**
* i番目に引数の値を加算します。
*
* @param i 加算する位置
* @param x 加算する値
*/
public void add(int i,long x){
while(i<=size){
tree[i] += x;
i += i&(-i);
}
}
/**
* このBITの値を全て0にします。
*/
public void clear(){
Arrays.fill(tree,0L);
}
}
/**
* Binary Indexed Treeのint特化クラスです。
* 引数は1-indexedであることを要求します。
*/
final class BITInt{
final int size;
final private int[] tree;
/**
* 大きさnのBITを生成します。
*
* @param n 生成するBITの大きさ
*/
public BITInt(int n){
size = n;
tree = new int[n+1];
}
/**
* [1,i]の総和を求めます。
*
* @param i 求める区間の右端(iを含む)
*
* @return [1,i]の総和
*/
public int sum(int i){
int sum = 0;
while(i>0){
sum += tree[i];
i ^= i&(-i);
}
return sum;
}
/**
* i番目に引数の値を加算します。
*
* @param i 加算する位置
* @param x 加算する値
*/
public void add(int i,int x){
while(i<=size){
tree[i] += x;
i += i&(-i);
}
}
/**
* このBITの値を全て0にします。
*/
public void clear(){
Arrays.fill(tree,0);
}
}
/**
* Bitsetクラスです。
* java.util.BitSetと同様の処理が出来るほか、ビットシフトに対応しています。
*/
final class Bitset implements Cloneable{
private final long[] bit;
private final int size;
private final long MASK;
/**
* 引数の値までを十分に扱える大きさのBitsetを構築します。
*
* @param len このBitsetで扱う最大値(lenを含まない)
*/
public Bitset(final int len){
size = (len+63)>>6;
bit = new long[size];
MASK = (-1L) >>> ((size<<6)-len);
}
/**
* 引数のlong型配列を元にBitsetを構築します。
*
* @param arr 元となるlong型配列
*/
private Bitset(final long[] arr){
this(arr.length);
System.arraycopy(arr,0,bit,0,size);
}
/**
* 引数の位置のフラグをtrueにします。
*
* @param index フラグをtrueにする位置
*/
public void set(final int index){
if(index>=size<<6){
throw new ArrayIndexOutOfBoundsException(index+" is out of this bitset's size "+size);
}
bit[index>>6] |= (1L<<(index&0b111111));
}
/**
* 引数の位置のフラグをfalseにします。
*
* @param index フラグをfalseにする位置
*/
public void clear(final int index){
if(index>=size<<6){
throw new ArrayIndexOutOfBoundsException(index+" is out of this bitset's size "+size);
}
long m = ~(1L<<(index&0b111111));
bit[index>>6] &= m;
}
/**
* 引数の位置のフラグを取得します。
*
* @param index 取得するフラグの位置
*
* @return 引数の位置のフラグ
*/
public boolean get(final int index){
if(index>=size<<6){
throw new ArrayIndexOutOfBoundsException(index+" is out of this bitset's size "+size);
}
return (bit[index>>6]&(1L<<(index&0b111111)))!=0;
}
/**
* 引数の値の分だけ左にビットシフトします。
* ビット長は変化せず、溢れた分のビットは破棄されます。
*
* @param num ビットシフトする回数
*/
public void shiftLeft(int num){
if(num>=size<<6){
Arrays.fill(bit,0L);
return;
}
final int n = num>>6;
num &= 0b111111;
for(int i = size-1;i>=n;--i){
bit[i] = (bit[i-n]<<num)|(i!=n&&num!=0?bit[i-n-1] >>> (64-num):0L);
}
for(int i = 0;i<n;++i){
bit[i] = 0L;
}
bit[size-1] &= MASK;
}
/**
* 引数の値の分だけ右にビットシフトします。
* ビット長は変化せず、溢れた分のビットは破棄されます。
*
* @param num ビットシフトする回数
*/
public void shiftRight(int num){
if(num>=size<<6){
Arrays.fill(bit,0L);
return;
}
final int n = num>>6;
num &= 0b111111;
for(int i = 0;i<size-n;++i){
bit[i] = (bit[i+n] >>> num)|(i+n+1!=size&&num!=0?bit[i+n+1]<<(64-num):0L);
}
for(int i = size-1;i>=size-n;--i){
bit[i] = 0L;
}
}
/**
* このBitsetを表すlong型配列を返します。
* このlong型配列はBitsetと連動しているため、変更を加えたときの挙動は保証されません。
*
* @return このBitsetを表すlong型配列
*/
public long[] longValues(){
return bit;
}
/**
* このBitsetをlongと解釈した時の値を返します。
*
* @return このBitsetをlongと解釈した時の値
*/
public long longValue(){
return bit[0];
}
/**
* 引数のBitsetとの論理積を取ります。
*
* @param b 論理積を取るBitset
*/
public void and(final Bitset b){
final long[] bit2 = b.longValues();
final int m = Math.min(bit2.length,size);
for(int i = 0;i<m;++i){
bit[i] &= bit2[i];
}
for(int i = m;i<size;++i){
bit[i] = 0;
}
bit[size-1] &= MASK;
}
/**
* 引数のBitsetとの論理和を取ります。
*
* @param b 論理和を取るBitset
*/
public void or(final Bitset b){
final long[] bit2 = b.longValues();
final int m = Math.min(bit2.length,size);
for(int i = 0;i<m;++i){
bit[i] |= bit2[i];
}
bit[size-1] &= MASK;
}
/**
* 引数のBitsetとの排他的論理和を取ります。
*
* @param b 排他的論理和を取るBitset
*/
public void xor(final Bitset b){
final long[] bit2 = b.longValues();
final int m = Math.min(bit2.length,size);
for(int i = 0;i<m;++i){
bit[i] ^= bit2[i];
}
bit[size-1] &= MASK;
}
/**
* このBitsetと同等の、異なるBitsetを生成します。
*
* @return このBitsetと同等の、異なるBitset
*
* @throws CloneNotSupportedException 多分起きない
*/
public Bitset clone() throws CloneNotSupportedException{
super.clone();
return new Bitset(bit);
}
}
/**
* Matrixクラスです。
* 行列を保持するクラスで、簡単な四則演算に行列式、累乗などを提供しています。
*/
final class Matrix{
private final long[][] matrix;
/**
* H行W列の、全要素がdefの行列を構築します。
*
* @param H 行数
* @param W 列数
* @param def 全要素の値
*/
public Matrix(final int H,final int W,final long def){
matrix = new long[H][W];
if(def!=0){
for(final long[] mat: matrix){
Arrays.fill(mat,def);
}
}
}
/**
* H行W列の、全要素が0である行列を構築します。
*
* @param H 行数
* @param W 列数
*/
public Matrix(final int H,final int W){
this(H,W,0);
}
/**
* Dimensionで表される行数、列数で全要素がdefの行列を構築します。
*
* @param d 行・列数
* @param def 全要素の値
*/
public Matrix(final Dimension d,final long def){
this(d.height,d.width,def);
}
/**
* 引数の二次元配列を元に行列を構築します。
* 値をコピーして構築するため、引数の行列とは連動していません。
*
* @param mat 元となる二次元配列
*/
public Matrix(final long[][] mat){
matrix = new long[mat.length][];
for(int i = 0;i<mat.length;++i){
matrix[i] = Arrays.copyOf(mat[i],mat[i].length);
}
}
/**
* i行j列目の要素を取得します。
*
* @param i 行番号
* @param j 列番号
*
* @return i行j列目の要素
*/
public long get(final int i,final int j){
return matrix[i][j];
}
/**
* i行j列目の要素を引数の値で上書きします。
*
* @param i 行番号
* @param j 列番号
* @param value 上書きする値
*
* @return value
*/
public long set(final int i,final int j,final long value){
return matrix[i][j] = value;
}
/**
* この行列を複製します。
*
* @return この行列と等価な行列(連動していない)
*/
public Matrix copy(){
return new Matrix(matrix);
}
/**
* この行列の行・列数を表すDimensionを返します。
*
* @return この行列の行・列数を表すDimension
*/
public Dimension size(){
return new Dimension(matrix[0].length,matrix.length);
}
/**
* この行列に引数の行列を加算した行列を返します。
*
* @param m 加算する行列
*
* @return この行列に引数の行列を加算した行列と等価な行列
*/
public Matrix add(final Matrix m){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,matrix[i][j]+m.get(i,j));
}
}
return ans;
}
/**
* この行列に引数の行列を減算した行列を返します。
*
* @param m 減算する行列
*
* @return この行列に引数の行列を減算した行列と等価な行列
*/
public Matrix subtract(final Matrix m){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,matrix[i][j]-m.get(i,j));
}
}
return ans;
}
/**
* この行列に引数の行列を乗算した行列を返します。
*
* @param m 乗算する行列
*
* @return この行列に引数の行列を乗算した行列と等価な行列
*/
public Matrix multiply(final Matrix m){
if(size().width!=m.size().height){
throw new IllegalArgumentException("matrix length is not same");
}
final Matrix ans = new Matrix(size().height,m.size().width);
final Dimension size = ans.size();
final int len = size().width;
for(int i = 0;i<size.height;++i){
for(int j = 0;j<size.width;++j){
long sum = 0;
for(int k = 0;k<len;++k){
sum += matrix[i][k]*m.get(k,j);
}
ans.set(i,j,sum);
}
}
return ans;
}
/**
* この行列に引数の行列を加算した行列を返します。
* 各要素はmodで除算したあまりに変換されます。
*
* @param m 加算する行列
* @param mod 法となる値
*
* @return この行列に引数の行列を加算した行列と等価な行列
*/
public Matrix modAdd(final Matrix m,final long mod){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,MathFunction.remainder(matrix[i][j]+m.get(i,j),mod));
}
}
return ans;
}
/**
* この行列に引数の行列を減算した行列を返します。
* 各要素はmodで除算したあまりに変換されます。
*
* @param m 減算する行列
* @param mod 法となる値
*
* @return この行列に引数の行列を減算した行列と等価な行列
*/
public Matrix modSubtract(final Matrix m,final long mod){
if(!size().equals(m.size())){
throw new IllegalArgumentException("matrix size is not same");
}
final Matrix ans = new Matrix(size(),0);
for(int i = 0;i<matrix.length;++i){
for(int j = 0;j<matrix[i].length;++j){
ans.set(i,j,MathFunction.remainder(matrix[i][j]-m.get(i,j),mod));
}
}
return ans;
}
/**
* この行列に引数の行列を乗算した行列を返します。
* 各要素はmodで乗算したあまりに変換されます。
*
* @param m 乗算する行列
* @param mod 法となる値
*
* @return この行列に引数の行列を乗算した行列と等価な行列
*/
public Matrix modMultiply(final Matrix m,final long mod){
if(size().width!=m.size().height){
throw new IllegalArgumentException("matrix length is not same");
}
final Matrix ans = new Matrix(size().height,m.size().width);
final Dimension size = ans.size();
final int len = size().width;
for(int i = 0;i<size.height;++i){
for(int j = 0;j<size.width;++j){
long sum = 0;
for(int k = 0;k<len;++k){
sum = MathFunction.remainder(sum+matrix[i][k]*m.get(k,j),mod);
}
ans.set(i,j,sum);
}
}
return ans;
}
/**
* 元となる行列に引数の行列を指定された回数だけ乗算します。
*
* @param original 元となる行列
* @param pw 乗算する配列
* @param exp 乗算する回数
*
* @return 元となる行列に引数の行列を指定された回数だけ乗算した行列と等価な行列
*/
public static Matrix pow(final Matrix original,final Matrix pw,long exp){
Matrix a = original.copy();
Matrix b = pw.copy();
while(0<exp){
if((exp&1)==1){
a = b.multiply(a);
}
b = b.multiply(b);
exp >>= 1;
}
return a;
}
/**
* 元となる行列に引数の行列を指定された回数だけ乗算します。
* 各要素はmodで乗算したあまりに変換されます。
*
* @param original 元となる行列
* @param pw 乗算する配列
* @param exp 乗算する回数
* @param mod 法となる値
*
* @return 元となる行列に引数の行列を指定された回数だけ乗算した行列と等価な行列
*/
public static Matrix modPow(final Matrix original,final Matrix pw,long exp,final long mod){
Matrix a = original.copy();
Matrix b = pw.copy();
while(0<exp){
if((exp&1)==1){
a = b.modMultiply(a,mod);
}
b = b.modMultiply(b,mod);
exp >>= 1;
}
return a;
}
/**
* この行列の行列式を返します。
*
* @return この行列の行列式
*/
public long determinant(){
return determinant(matrix);
}
/**
* 引数の二次元配列の行列式を返します。
*
* @param mat 元となる二次元配列
*
* @return 二次元配列の行列式
*/
private static long determinant(final long[][] mat){
if(mat.length==1){
return mat[0][0];
}
final long[][] miniMat = new long[mat.length-1][mat.length-1];
for(int i = 1;i<mat.length;++i){
System.arraycopy(mat[i],1,miniMat[i-1],0,miniMat.length);
}
long ans = mat[0][0]*determinant(miniMat);
for(int i = 1;i<mat.length;++i){
for(int j = 1;j<mat.length;++j){
miniMat[j-1][i-1] = mat[j][i-1];
}
final long num = mat[0][i]*determinant(miniMat);
ans += i%2==0?num:-num;
}
return ans;
}
/**
* この行列を表すStringを返します。
*
* @return この行列を表すString
*/
@Override public String toString(){
final StringBuilder ans = new StringBuilder();
ans.append(Arrays.toString(matrix[0]));
for(int i = 1;i<matrix.length;++i){
ans.append("\n");
ans.append(Arrays.toString(matrix[i]));
}
return ans.toString();
}
}
/**
* RollingHashクラスです。
* 一応文字列連結メソッドなどを実装していますが、使用は推奨されません。
*/
final class RollingHash implements Comparable<RollingHash>{
private static final long BASE = new Random().nextInt(1000)+Character.MAX_VALUE+1;
private static final long MASK30 = (1L<<30)-1;
private static final long MASK31 = (1L<<31)-1;
private static final long MOD = (1L<<61)-1;
private static final long MASK61 = MOD;
private long[] hash;
private String string;
/**
* 引数の文字列を元にRollingHashを構築します。
*
* @param str 元となるString
*/
public RollingHash(final String str){
string = str;
hash = new long[str.length()+1];
roll();
}
/**
* フィールドのstringを元にハッシュ値を計算します。
*/
private void roll(){
final int len = string.length();
for(int i = 1;i<=len;++i){
hash[i] = multiply(hash[i-1],BASE)+string.charAt(i-1)-' '+1;
if(MOD<=hash[i]){
hash[i] -= MOD;
}
}
}
/**
* long*long用の特別メソッドです。
*
* @param a 乗算する値
* @param b 乗算される値
*
* @return a*b mod 2^61-1
*/
private static long multiply(final long a,final long b){
final long au = a>>31;
final long ad = a&MASK31;
final long bu = b>>31;
final long bd = b&MASK31;
final long mid = ad*bu+au*bd;
final long midu = mid>>30;
final long midd = mid&MASK30;
return mod(au*bu*2+midu+(midd<<31)+ad*bd);
}
/**
* x mod 2^61-1を計算します。
*
* @param x 元となる値
*
* @return x mod 2^61-1
*/
private static long mod(final long x){
final long xu = x>>61;
final long xd = x&MASK61;
long ans = xu+xd;
if(MOD<=ans){
ans -= MOD;
}
return ans;
}
/**
* ハッシュ値を計算します。
*
* @param l 左端
* @param r 右端
*
* @return [l,r]のハッシュ値
*/
public long getHash(final int l,final int r){
return (hash[r]-multiply(hash[l],modBasePow(r-l))+MOD)%MOD;
}
/**
* BASE^b mod 2^61-1を計算します。
*
* @param b 指数
*
* @return BASE^b mod 2^61-1
*/
private static long modBasePow(long b){
long ans = 1;
long a = BASE;
while(b>0){
if((b&1)==1){
ans = multiply(ans,a);
}
a = multiply(a,a);
b >>= 1;
}
return ans;
}
/**
* 指定された区間と引数の指定された区間が等しいか返します。
*
* @param rh 比較対象のRollingHash
* @param l1 このRollingHashの左端
* @param r1 このRollingHashの右端
* @param l2 比較対象の左端
* @param r2 比較対象の右端
*
* @return 等しい可能性があるならtrue、確実に異なるならfalse
*/
public boolean equals(final RollingHash rh,final int l1,final int r1,final int l2,final int r2){
if(r1-l1!=r2-l2){
return false;
}
return getHash(l1,r1)==rh.getHash(l2,r2);
}
/**
* このRollingHashの長さを返します。
*
* @return このRollingHashの長さ
*/
public int length(){
return string.length();
}
/**
* このRollingHashの元となるStringのハッシュ値を返します。
*
* @return このRollingHashの元となるStringのハッシュ値
*/
@Override public int hashCode(){
return string.hashCode();
}
/**
* このRollingHashの元となるStringを返します。
*
* @return このRollingHashの元となるString
*/
@Override public String toString(){
return string;
}
/**
* 引数と自身が等しいか返します。
*
* @param o 比較対象
*
* @return 等しい可能性があるならtrue、確実に異なるならfalse
*/
@Override public boolean equals(Object o){
if(o instanceof final RollingHash rh){
return equals(rh,0,length(),0,rh.length());
}
return false;
}
/**
* 引数のRollingHashの元となるStringと辞書順で比較します。
*
* @param rh the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
@Override public int compareTo(RollingHash rh){
return string.compareTo(rh.toString());
}
/**
* 引数のStringと辞書順で比較します。
*
* @param str the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
public int compareTo(String str){
return string.compareTo(str);
}
/**
* このRollingHashのi文字目を返します。
*
* @param i インデックス
*
* @return i番目の文字を表すchar
*/
public char charAt(final int i){
return string.charAt(i);
}
/**
* 引数のRollingHashの元となるStringと大文字小文字を無視して辞書順で比較します。
*
* @param rh the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
public int compareToIgnoreCase(final RollingHash rh){
return string.compareToIgnoreCase(rh.toString());
}
/**
* 引数のStringと大文字小文字を無視して辞書順で比較します。
*
* @param str the object to be compared.
*
* @return 辞書順で自身が小さいなら-1、等しいなら0、それ以外は1
*/
public int compareToIgnoreCase(final String str){
return string.compareToIgnoreCase(str);
}
/**
* 引数のRollingHashを末尾に連結します。
* 計算量はO(length+rh.length)です。
*
* @param rh 連結する文字列を表すRollingHash
*/
public void concat(final RollingHash rh){
concat(rh.toString());
}
/**
* 引数のStringを末尾に連結します。
* 計算量はO(length+rh.length)です。
*
* @param str 連結する文字列
*/
public void concat(final String str){
string = string.concat(str);
hash = new long[string.length()+1];
roll();
}
/**
* このRollingHashの連続部分列として引数のRollingHashが存在するか判定します。
*
* @param rh 連続部分列として存在するか検査するRollingHash
*
* @return 部分列として存在する可能性があるならtrue、確実に含まれていないならfalse
*/
public boolean contains(final RollingHash rh){
final long hash = rh.getHash(0,rh.length());
final int len = length()-rh.length();
for(int i = 0;i<=len;++i){
if(hash==getHash(i,rh.length()+i)){
return true;
}
}
return false;
}
/**
* 引数のStringが連続部分列として存在するか判定します。
*
* @param str 存在判定をするString
*
* @return 連続部分列として存在するならtrue、それ以外はfalse
*/
public boolean contains(final String str){
return indexOf(str)!=-1;
}
/**
* 引数の文字が先頭から何番目に存在するか返します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
*
* @return 最も左側にある引数の文字のインデックス(無ければ - 1)
*/
public int indexOf(final int ch){
return indexOf(ch,0);
}
/**
* 引数の文字を指定されたインデックス以降で探索します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
* @param fromIndex 探索開始位置
*
* @return 最も左側にある引数の文字のインデックス(無ければ - 1)
*/
public int indexOf(final int ch,final int fromIndex){
final int len = length();
for(int i = fromIndex;i<len;++i){
if(string.charAt(i)==ch){
return i;
}
}
return -1;
}
/**
* 引数の文字列が先頭から何番目に存在するか返します。
* 存在しない場合は-1を返します。
*
* @param str 探索する文字列
*
* @return 最も左側にある引数の文字列のインデックス(無ければ - 1)
*/
public int indexOf(final String str){
return indexOf(str,0);
}
/**
* 引数の文字列を指定されたインデックス以降で探索します。
* 存在しない場合は-1を返します。
*
* @param str 探索する文字列
* @param fromIndex 探索開始位置
*
* @return 最も左側にある引数の文字列のインデックス(無ければ - 1)
*/
public int indexOf(final String str,final int fromIndex){
long hash = 0;
for(final char c: str.toCharArray()){
hash = multiply(hash,BASE)+c-' '+1;
if(MOD<=hash){
hash -= MOD;
}
}
final int len = length()-str.length();
for(int i = fromIndex;i<=len;++i){
if(hash==getHash(i,str.length()+i)){
return i;
}
}
return -1;
}
/**
* このRollingHashが表す文字列が空文字列か判定します。
*
* @return ""と等しいならtrue、それ以外はfalse
*/
public boolean isEmpty(){
return length()==0;
}
/**
* 引数の文字を指定されたインデックス以降で探索します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
* @param fromIndex 探索開始位置
*
* @return 最も右側にある引数の文字のインデックス(無ければ - 1)
*/
public int lastIndexOf(final int ch,final int fromIndex){
for(int i = fromIndex;i>=0;--i){
if(string.charAt(i)==ch){
return i;
}
}
return -1;
}
/**
* 引数の文字が先頭から何番目に存在するか返します。
* 存在しない場合は-1を返します。
*
* @param ch 探索する文字を表すint
*
* @return 最も左側にある引数の文字のインデックス(無ければ - 1)
*/
public int lastIndexOf(final int ch){
return lastIndexOf(ch,length()-1);
}
/**
* 引数のbooleanを表す文字列を元にRollingHashを構築します。
*
* @param b 元となるboolean
*
* @return 引数のbooleanを表すRollingHash
*/
public static RollingHash valueOf(final boolean b){
return new RollingHash(b?"true":"false");
}
/**
* 引数のcharを元にRollingHashを構築します。
*
* @param c 元となるchar
*
* @return 引数のcharを表すRollingHash
*/
public static RollingHash valueOf(final char c){
return new RollingHash(""+c);
}
/**
* 引数のchar[]を表す文字列を元にRollingHashを構築します。
*
* @param c 元となるchar[]
*
* @return 引数のchar[]を表すRollingHash
*/
public static RollingHash valueOf(final char[] c){
return new RollingHash(String.valueOf(c,0,c.length));
}
/**
* 引数のchar[]を表す文字列の、引数の区間を元にRollingHashを構築します。
*
* @param c 元となるchar[]
* @param offset 左端
* @param count 文字数
*
* @return 引数のchar[]の引数の区間を表すRollingHash
*/
public static RollingHash valueOf(final char[] c,final int offset,final int count){
return new RollingHash(String.valueOf(c,offset,count));
}
/**
* 引数のdoubleを表す文字列を元にRollingHashを構築します。
*
* @param d 元となるdouble
*
* @return 引数のdoubleを表すRollingHash
*/
public static RollingHash valueOf(final double d){
return new RollingHash(String.valueOf(d));
}
/**
* 引数のfloatを表す文字列を元にRollingHashを構築します。
*
* @param f 元となるfloat
*
* @return 引数のfloatを表すRollingHash
*/
public static RollingHash valueOf(final float f){
return new RollingHash(String.valueOf(f));
}
/**
* 引数のintを表す文字列を元にRollingHashを構築します。
*
* @param i 元となるint
*
* @return 引数のintを表すRollingHash
*/
public static RollingHash valueOf(final int i){
return new RollingHash(String.valueOf(i));
}
/**
* 引数のlongを表す文字列を元にRollingHashを構築します。
*
* @param l 元となるlong
*
* @return 引数のlongを表すRollingHash
*/
public static RollingHash valueOf(final long l){
return new RollingHash(String.valueOf(l));
}
/**
* 引数のObjectを表す文字列を元にRollingHashを構築します。
*
* @param obj 元となるObject
*
* @return 引数のObjectを表すRollingHash
*/
public static RollingHash valueOf(final Object obj){
return new RollingHash(String.valueOf(obj));
}
}
/**
* SegmentTreeクラスです。
* 載せる演算はfunctionを定義して使用して下さい。
*
* @param <E> 演算を適用する要素の型
*/
@SuppressWarnings("unchecked")
abstract class SegmentTree<E>{
final int N, size;
final E def;
final Object[] node;
/**
* 大きさnの、単位元がdefであるSegmentTreeを構築します。
*
* @param n 扱う範囲
* @param def 単位元
* @param is1indexed 各メソッドに渡すインデックスが1-indexedか
*/
public SegmentTree(final int n,final E def,final boolean is1indexed){
int num = 2;
while(num<n<<1){
num <<= 1;
}
N = num;
size = num>>1-(is1indexed?1:0);
node = new Object[N];
this.def = def;
Arrays.fill(node,this.def);
}
/**
* 引数の配列を元に、単位元がdefであるSegmentTreeを構築します。
* 浅いコピーなので、引数の配列の要素に変更を加えたときの動作は保証されません。
*
* @param arr 元となる配列
* @param def 単位元
* @param is1indexed 各メソッドに渡すインデックスが1-indexedか
*/
public SegmentTree(final E[] arr,final E def,final boolean is1indexed){
int num = 2;
while(num<arr.length<<1){
num <<= 1;
}
N = num;
size = num>>1-(is1indexed?1:0);
node = new Object[N];
this.def = def;
System.arraycopy(arr,0,node,N>>1,arr.length);
for(int i = arr.length+(N>>1);i<N;i++){
node[i] = def;
}
updateAll();
}
/**
* 大きさn、単位元がdefのSegmentTreeを構築します。
* 各メソッドに渡すインデックスは0-indexedであることが要求されます。
*
* @param n 大きさ
* @param def 単位元
*/
public SegmentTree(final int n,final E def){
this(n,def,false);
}
/**
* このSegmentTreeのテーブルを一括で更新します。
*/
private void updateAll(){
for(int i = (N>>1)-1;i>0;i--){
node[i] = function((E)node[i<<1],(E)node[(i<<1)+1]);
}
}
/**
* 引数の位置の値を引数の値で上書きします。
*
* @param n インデックス
* @param value 上書きする値
*/
public void update(int n,final E value){
n += size;
node[n] = value;
n >>= 1;
while(n>0){
node[n] = function((E)node[n<<1],(E)node[(n<<1)+1]);
n >>= 1;
}
}
/**
* 引数の位置の要素を返します。
*
* @param a インデックス
*
* @return 引数の位置の要素
*/
public E get(final int a){
return (E)node[a+size];
}
/**
* このSegmentTree上の要素全てにfunctionを適用した結果を返します。
*
* @return 要素全てにfunctionを適用した結果
*/
public E answer(){
return (E)node[1];
}
/**
* 引数の区間の要素にfunctionを適用した結果を返します。
* 閉区間であることに注意して下さい。
*
* @param l 左端(lを含む)
* @param r 右端(rを含む)
*
* @return [l,r]の要素にfunctionを適用した結果
*/
public E query(int l,int r){
l += size;
r += size;
E answer = def;
while(l>0&&r>0&&l<=r){
if(l%2==1){
answer = function((E)node[l++],answer);
}
l >>= 1;
if(r%2==0){
answer = function(answer,(E)node[r--]);
}
r >>= 1;
}
return answer;
}
/**
* このSegmentTree上で適用する関数を定義したメソッドです。
*
* @param a 要素1
* @param b 要素2
*
* @return aとbに関数を適用した結果
*/
abstract public E function(E a,E b);
}
/**
* LazySegmentTreeクラスです。
* 載せる演算はfunction、演算の合成はcomposition、演算の適用はmappingに定義して使用して下さい。
*
* @param <S> 演算を適用する要素の型
* @param <F> 演算に使用するパラメータ
*/
@SuppressWarnings("unchecked")
abstract class LazySegmentTree<S,F>{
private final int size, log;
private final S defaultS;
private final F defaultF;
private final S[] node;
private final F[] lazy;
/**
* 大きさN、単位元がdefaultS、恒等写像がdefaultFであるLazySegmentTreeを構築します。
* 各メソッドに渡すインデックスは0-indexedであることが要求されます。
*
* @param N 大きさ
* @param defaultS 単位元
* @param defaultF 恒等写像
*/
public LazySegmentTree(final int N,final S defaultS,final F defaultF){
this(N,defaultS,defaultF,false);
}
/**
* 大きさN、単位元がdefaultS、恒等写像がdefaultFであるLazySegmentTreeを構築します。
*
* @param N 大きさ
* @param defaultS 単位元
* @param defaultF 恒等写像
* @param is1indexed 各メソッドに渡すインデックスは1-indexedか
*/
public LazySegmentTree(final int N,final S defaultS,final F defaultF,final boolean is1indexed){
this.log = 32-Integer.numberOfLeadingZeros(N-1);
this.size = (1<<log)-(is1indexed?1:0);
this.defaultS = defaultS;
this.defaultF = defaultF;
this.node = (S[])new Object[1<<log+1];
this.lazy = (F[])new Object[1<<log+1];
clear();
}
/**
* 引数の配列を元に、単位元がdefaultS、恒等写像がdefaultFであるLazySegmentTreeを構築します。
*
* @param defaultValues 大きさ
* @param defaultS 単位元
* @param defaultF 恒等写像
* @param is1indexed 各メソッドに渡すインデックスは1-indexedか
*/
public LazySegmentTree(final S[] defaultValues,final S defaultS,final F defaultF,final boolean is1indexed){
this(defaultValues.length,defaultS,defaultF,is1indexed);
updateAll(defaultValues);
}
/**
* 全ての要素を単位元に、演算を恒等写像にします。
*/
public void clear(){
Arrays.fill(this.node,this.defaultS);
Arrays.fill(this.lazy,this.defaultF);
}
/**
* 引数の要素を元にテーブルを再構築します。
*
* @param defaultValues 元となる配列
*/
private void updateAll(final S[] defaultValues){
System.arraycopy(defaultValues,0,node,1<<log,defaultValues.length);
for(int i = (1<<log)-1;i>0;i--){
node[i] = function(node[i<<1],node[i<<1|1]);
}
}
/**
* 引数の位置の演算を適用し、子に伝播します。
*
* @param index 演算を適用する位置
*/
private void spread(final int index){
if(lazy[index]!=defaultF){
int l = index<<1;
int r = index<<1|1;
node[l] = mapping(node[l],lazy[index]);
node[r] = mapping(node[r],lazy[index]);
lazy[l] = composition(lazy[l],lazy[index]);
lazy[r] = composition(lazy[r],lazy[index]);
lazy[index] = defaultF;
}
}
/**
* 親から順に引数の位置までの演算を適用します。
*
* @param from 演算を適用する終点
*/
private void spreadLine(final int from){
for(int i = log;i>0;i--)
spread(from>>i);
}
/**
* 引数の区間の演算を適用します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
*/
private void spreadRange(final int l,final int r){
for(int i = log;i>0;i--){
if((l>>i<<i)!=l)
spread(l>>i);
if((r>>i<<i)!=r)
spread(r>>i);
}
}
/**
* 引数の位置の要素の情報を親に向かって伝播します。
*
* @param index 伝播したい要素のインデックス
*/
private void update(int index){
while((index >>= 1)>0)
node[index] = function(node[index<<1],node[index<<1|1]);
}
/**
* 区間の要素の情報を親に向かって伝播します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
*/
private void update(final int l,final int r){
for(int i = 1;i<=log;i++){
int subL = l>>i;
int subR = r>>i;
if((subL<<i)!=l)
node[subL] = function(node[subL<<1],node[subL<<1|1]);
if((subR<<i)!=r)
node[subR] = function(node[subR<<1],node[subR<<1|1]);
}
}
/**
* 引数の位置の要素を引数の値で上書きします。
*
* @param index インデックス
* @param x 上書きする値
*/
public void update(int index,final S x){
index += size;
spreadLine(index);
node[index] = x;
update(index);
}
/**
* 引数の位置の要素を取得します
*
* @param index インデックス
*
* @return 引数の位置の要素
*/
public S get(int index){
index += size;
spreadLine(index);
return node[index];
}
/**
* 指定された区間にfunctionを適用した結果を返します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
*
* @return [l,r)の要素にfunctionを適用した結果
*/
public S query(int l,int r){
l += size;
r += size;
spreadRange(l,r);
S sumL = defaultS;
S sumR = defaultS;
while(l<r){
if((l&1)==1)
sumL = function(sumL,node[l++]);
if((r&1)==1)
sumR = function(node[--r],sumR);
l >>= 1;
r >>= 1;
}
return function(sumL,sumR);
}
/**
* 全要素にfunctionを適用した結果を返します。
*
* @return 全要素にfunctionを適用した結果
*/
public S answer(){
return node[1];
}
/**
* 引数の位置の要素に指定されたパラメータによる演算を反映します。
*
* @param index インデックス
* @param f 反映する演算を表すパラメータ
*/
public void apply(int index,final F f){
index += size;
spreadLine(index);
node[index] = mapping(node[index],f);
update(index);
}
/**
* 指定された区間の要素に指定されたパラメータによる演算を反映します。
*
* @param l 左端(lを含む)
* @param r 右端(rを含まない)
* @param f 反映する演算を表すパラメータ
*/
public void apply(int l,int r,final F f){
l += size;
r += size;
spreadRange(l,r);
int subL = l;
int subR = r;
while(subL<subR){
if((subL&1)==1){
node[subL] = mapping(node[subL],f);
lazy[subL] = composition(lazy[subL++],f);
}
if((subR&1)==1){
node[--subR] = mapping(node[subR],f);
lazy[subR] = composition(lazy[subR],f);
}
subL >>= 1;
subR >>= 1;
}
update(l,r);
}
/**
* 各要素に適用する関数を定義するメソッドです。
*
* @param s1 要素1
* @param s2 要素2
*
* @return 要素に関数を適用した結果
*/
abstract public S function(S s1,S s2);
/**
* パラメータを合成するメソッドです。
* パラメータを表すインスタンスが不変であること、
* ここで返すインスタンスが他に影響を及ぼさないことが要求されます。
*
* @param f1 パラメータ1
* @param f2 パラメータ2
*
* @return パラメータを合成した結果を表すパラメータ
*/
abstract public F composition(F f1,F f2);
/**
* パラメータを元に要素に演算を適用します。
*
* @param s 要素
* @param f パラメータ
*
* @return 要素に演算を適用した結果
*/
abstract public S mapping(S s,F f);
}
/**
* UnionFindクラスです。
* 連結成分の大きさの他、辺の数、連結成分の数も取得できます。
*/
final class UnionFind{
private final int[] par, rank, size, path;
private int count;
/**
* 大きさNのUnionFindを構築します。
*
* @param N 大きさ
*/
public UnionFind(final int N){
count = N;
par = new int[N];
rank = new int[N];
size = new int[N];
path = new int[N];
Arrays.fill(par,-1);
Arrays.fill(size,1);
}
/**
* 引数の頂点の代表される親を返します。
*
* @param ind 代表を取得する頂点
*
* @return 代表される親
*/
public int root(final int ind){
if(par[ind]==-1){
return ind;
}
else{
return par[ind] = root(par[ind]);
}
}
/**
* 引数の二つの頂点が同一の連結成分に属するか返します。
*
* @param x 頂点1
* @param y 頂点2
*
* @return 同一の連結成分に属するならtrue、それ以外はfalse
*/
public boolean isSame(final int x,final int y){
return root(x)==root(y);
}
/**
* 引数の二つの頂点を連結します。
* 連結済みであっても辺はカウントされることに注意して下さい。
*
* @param x 頂点1
* @param y 頂点2
*
* @return 既に二頂点が同一の連結成分に属しているならfalse、それ以外はtrue
*/
public boolean unite(final int x,final int y){
int rx = root(x);
int ry = root(y);
++path[rx];
if(rx==ry){
return false;
}
if(rank[rx]<rank[ry]){
int temp = rx;
rx = ry;
ry = temp;
}
par[ry] = rx;
if(rank[rx]==rank[ry]){
++rank[rx];
}
path[rx] += path[ry];
size[rx] += size[ry];
--count;
return true;
}
/**
* このUnionFindの連結成分の数を返します。
*
* @return 連結成分の数
*/
public int groupCount(){
return count;
}
/**
* 引数の頂点の連結成分の辺の総数を返します。
*
* @param x 頂点
*
* @return 連結成分の辺の総数
*/
public int pathCount(final int x){
return path[root(x)];
}
/**
* 引数の頂点の連結成分の頂点数を返します。
*
* @param x 頂点
*
* @return 連結成分の頂点数
*/
public int size(final int x){
return size[root(x)];
}
}
/**
* Treeクラスです。
* java.util.TreeSetと基本変わりませんが、インデックスを指定してのアクセスがO(log N)で可能です。
*
* @param <E> Treeに載せる要素の型
*/
final class Tree<E extends Comparable<E>>{
private Node<E> root;
private int size, hash;
public Tree(){
size = 0;
root = null;
hash = 0;
}
static final private class Node<E>{
E value;
int height, size;
Node<E> left, right, parent;
public Node(final Node<E> p,final E v){
value = v;
parent = p;
height = 1;
size = 1;
}
}
public boolean add(final E x){
boolean bool = true;
if(root==null){
root = new Node<>(null,x);
}
else{
Node<E> par;
Node<E> now = root;
do{
par = now;
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
bool = false;
break;
}
}
while(now!=null);
if(bool){
final int result = x.compareTo(par.value);
if(result<0){
par.left = new Node<>(par,x);
}
else{
par.right = new Node<>(par,x);
}
fix(par);
}
}
if(bool){
++size;
hash ^= x.hashCode();
}
return bool;
}
public E get(int index){
if(root==null||size<=index){
throw new NullPointerException();
}
Node<E> now = root;
while(true){
assert now!=null;
final int ls = now.left!=null?now.left.size:0;
if(index<ls){
now = now.left;
}
else if(ls<index){
now = now.right;
index -= ls+1;
}
else{
break;
}
}
return now.value;
}
public boolean remove(final E x){
final Node<E> n = getNode(x);
if(n==null){
return false;
}
--size;
hash ^= n.value.hashCode();
delete(n);
return true;
}
private void delete(final Node<E> node){
if(node!=null){
if(node.left==null&&node.right==null){
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = null;
}
else{
node.parent.right = null;
}
fix(node.parent);
}
else{
root = null;
}
node.parent = null;
}
else{
if(node.left!=null&&node.right!=null){
final Node<E> rep = getFirstNode(node.right);
node.value = rep.value;
delete(rep);
}
else{
final Node<E> rep = node.left!=null?node.left:node.right;
rep.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = rep;
}
else{
node.parent.right = rep;
}
fix(node.parent);
}
else{
root = rep;
}
node.parent = null;
}
}
}
}
private Node<E> getNode(final E x){
Node<E> now = root;
while(now!=null){
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
break;
}
}
return now;
}
public E first(){
if(root==null){
return null;
}
return getFirstNode(root).value;
}
private Node<E> getFirstNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.left;
}
return par;
}
public E last(){
if(root==null){
return null;
}
return getLastNode(root).value;
}
private Node<E> getLastNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.right;
}
return par;
}
public boolean contains(final E x){
if(root==null){
return false;
}
return getNode(x)!=null;
}
public E pollFirst(){
if(root==null){
return null;
}
--size;
final Node<E> min = getFirstNode(root);
hash ^= min.value.hashCode();
delete(min);
return min.value;
}
public E pollLast(){
if(root==null){
return null;
}
--size;
final Node<E> max = getLastNode(root);
hash ^= max.value.hashCode();
delete(max);
return max.value;
}
public E ceiling(final E x){
return ceiling(root,x);
}
private E ceiling(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>0){
node = node.right;
}
else if(result<0){
ans = node;
node = node.left;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E higher(final E x){
return higher(root,x);
}
private E higher(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>=0){
node = node.right;
}
else{
ans = node;
node = node.left;
}
}
return ans!=null?ans.value:null;
}
public E floor(final E x){
return floor(root,x);
}
private E floor(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<0){
node = node.left;
}
else if(result>0){
ans = node;
node = node.right;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E lower(final E x){
return lower(root,x);
}
private E lower(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<=0){
node = node.left;
}
else{
ans = node;
node = node.right;
}
}
return ans!=null?ans.value:null;
}
public void clear(){
root = null;
size = 0;
hash = 0;
}
public boolean isEmpty(){
return size==0;
}
public int size(){
return size;
}
public ArrayList<E> toList(){
final ArrayList<E> list = new ArrayList<>();
if(root!=null){
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add(root);
while(!deq.isEmpty()){
final Node<E> now = deq.pollLast();
if(list.size()==0){
if(now.left!=null){
deq.add(now);
deq.add(now.left);
}
else{
list.add(now.value);
if(now.right!=null){
deq.add(now.right);
}
}
}
else if(now.left!=null&&list.get(list.size()-1).compareTo(now.left.value)<0){
deq.add(now);
deq.add(now.left);
}
else{
list.add(now.value);
if(now.right!=null){
deq.add(now.right);
}
}
}
}
return list;
}
@Override public String toString(){
final ArrayList<E> list = toList();
return list.toString();
}
@Override public boolean equals(final Object o){
if(o instanceof final Tree<?> tree){
if(size!=tree.size()){
return false;
}
final ArrayList<E> list1 = toList();
final ArrayList<?> list2 = tree.toList();
for(int i = 0;i<size;++i){
if(!list1.get(i).equals(list2.get(i))){
return false;
}
}
return true;
}
return false;
}
@Override public int hashCode(){
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix(Node<E> node){
while(node!=null){
final int lh = node.left==null?0:node.left.height;
final int rh = node.right==null?0:node.right.height;
if(lh-rh>1){
assert node.left!=null;
if(node.left.right!=null&&node.left.right.height==lh-1){
rotateL(node.left);
}
rotateR(node);
}
else if(rh-lh>1){
assert node.right!=null;
if(node.right.left!=null&&node.right.left.height==rh-1){
rotateR(node.right);
}
rotateL(node);
}
else{
setStates(node);
}
node = node.parent;
}
}
private void rotateR(final Node<E> node){
final Node<E> temp = node.left;
node.left = temp.right;
if(node.left!=null){
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void rotateL(final Node<E> node){
final Node<E> temp = node.right;
node.right = temp.left;
if(node.right!=null){
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void setStates(final Node<E> node){
final int lh = node.left!=null?node.left.height:0;
final int rh = node.right!=null?node.right.height:0;
node.height = Math.max(lh,rh)+1;
final int ls = node.left!=null?node.left.size:0;
final int rs = node.right!=null?node.right.size:0;
node.size = ls+rs+1;
}
}
final class TreeMulti<E extends Comparable<E>>{
private Node<E> root;
private long size;
private int uniqueSize;
private int hash;
public TreeMulti(){
size = 0;
uniqueSize = 0;
root = null;
hash = 0;
}
static final private class Node<E>{
E value;
long count, size;
int height;
Node<E> left, right, parent;
public Node(final Node<E> p,final E v,final long c){
value = v;
parent = p;
count = c;
height = 1;
size = c;
}
}
public void add(final E x){
if(root==null){
root = new Node<>(null,x,1);
++uniqueSize;
}
else{
Node<E> par;
Node<E> now = root;
boolean bool = true;
do{
par = now;
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
bool = false;
++now.count;
break;
}
}
while(now!=null);
if(bool){
++uniqueSize;
final int result = x.compareTo(par.value);
if(result<0){
par.left = new Node<>(par,x,1);
}
else{
par.right = new Node<>(par,x,1);
}
}
fix(par);
}
++size;
hash ^= x.hashCode();
}
public void add(final E x,final long sum){
if(root==null){
root = new Node<>(null,x,sum);
++uniqueSize;
}
else{
Node<E> par;
Node<E> now = root;
boolean bool = true;
do{
par = now;
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
bool = false;
now.count += sum;
fix(now);
break;
}
}
while(now!=null);
if(bool){
++uniqueSize;
final int result = x.compareTo(par.value);
if(result<0){
par.left = new Node<>(par,x,sum);
}
else{
par.right = new Node<>(par,x,sum);
}
fix(par);
}
}
size += sum;
hash ^= sum%2==1?x.hashCode():0;
}
public E get(long index){
if(root==null||size<=index){
throw new NullPointerException();
}
Node<E> now = root;
while(true){
assert now!=null;
final long ls = now.left!=null?now.left.size:0;
if(index<ls){
now = now.left;
}
else if(ls+now.count<=index){
index -= ls+now.count;
now = now.right;
}
else{
break;
}
}
return now.value;
}
public boolean remove(final E x){
final Node<E> n = getNode(x);
if(n==null){
return false;
}
--size;
hash ^= n.hashCode();
delete(n);
return true;
}
public long remove(final E x,final long sum){
final Node<E> n = getNode(x);
if(n==null){
return 0;
}
final long ans = Math.min(sum,n.count);
size -= ans;
hash ^= ans%2==1?n.hashCode():0;
n.count -= ans-1;
delete(n);
return ans;
}
public long removeAll(final E x){
final Node<E> n = getNode(x);
if(n==null){
return 0;
}
size -= n.count;
final long ans = n.count;
hash ^= ans%2==1?n.hashCode():0;
n.count = 0;
delete(n);
return ans;
}
private void delete(final Node<E> node){
if(node!=null){
if(node.count>1){
--node.count;
fix(node);
return;
}
if(node.left==null&&node.right==null){
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = null;
}
else{
node.parent.right = null;
}
fix(node.parent);
}
else{
root = null;
}
node.parent = null;
--uniqueSize;
}
else{
if(node.left!=null&&node.right!=null){
final Node<E> rep = getFirstNode(node.right);
node.value = rep.value;
node.count = rep.count;
rep.count = 0;
delete(rep);
}
else{
final Node<E> rep = node.left!=null?node.left:node.right;
rep.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = rep;
}
else{
node.parent.right = rep;
}
fix(node.parent);
}
else{
root = rep;
}
node.parent = null;
--uniqueSize;
}
}
}
}
private Node<E> getNode(final E x){
Node<E> now = root;
while(now!=null){
final int result = x.compareTo(now.value);
if(result<0){
now = now.left;
}
else if(result>0){
now = now.right;
}
else{
break;
}
}
return now;
}
public E first(){
if(root==null){
return null;
}
return getFirstNode(root).value;
}
private Node<E> getFirstNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.left;
}
return par;
}
public E last(){
if(root==null){
return null;
}
return getLastNode(root).value;
}
private Node<E> getLastNode(Node<E> node){
assert node!=null;
Node<E> par = null;
while(node!=null){
par = node;
node = par.right;
}
return par;
}
public boolean contains(final E x){
if(root==null){
return false;
}
return getNode(x)!=null;
}
public long sum(final E x){
if(root==null){
return 0;
}
Node<E> node = getNode(x);
return node!=null?node.count:0;
}
public E pollFirst(){
if(root==null){
return null;
}
--size;
final Node<E> min = getFirstNode(root);
hash ^= min.value.hashCode();
final E ans = min.value;
delete(min);
return ans;
}
public E pollLast(){
if(root==null){
return null;
}
--size;
final Node<E> max = getLastNode(root);
hash ^= max.value.hashCode();
final E ans = max.value;
delete(max);
return ans;
}
public E ceiling(final E x){
return ceiling(root,x);
}
private E ceiling(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>0){
node = node.right;
}
else if(result<0){
ans = node;
node = node.left;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E higher(final E x){
return higher(root,x);
}
private E higher(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result>=0){
node = node.right;
}
else{
ans = node;
node = node.left;
}
}
return ans!=null?ans.value:null;
}
public E floor(final E x){
return floor(root,x);
}
private E floor(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<0){
node = node.left;
}
else if(result>0){
ans = node;
node = node.right;
}
else{
return x;
}
}
return ans!=null?ans.value:null;
}
public E lower(final E x){
return lower(root,x);
}
private E lower(Node<E> node,final E x){
Node<E> ans = null;
while(node!=null){
final int result = x.compareTo(node.value);
if(result<=0){
node = node.left;
}
else{
ans = node;
node = node.right;
}
}
return ans!=null?ans.value:null;
}
public int size(){
return uniqueSize;
}
public long sumSize(){
return size;
}
public ArrayList<E> toList(){
final ArrayList<E> list = new ArrayList<>();
if(root!=null){
final ArrayDeque<Node<E>> deq = new ArrayDeque<>();
deq.add(root);
while(!deq.isEmpty()){
final Node<E> now = deq.pollLast();
if(list.size()==0){
if(now.left!=null){
deq.add(now);
deq.add(now.left);
}
else{
for(int i = 0;i<now.count;++i){
list.add(now.value);
}
if(now.right!=null){
deq.add(now.right);
}
}
}
else if(now.left!=null&&list.get(list.size()-1).compareTo(now.left.value)<0){
deq.add(now);
deq.add(now.left);
}
else{
for(int i = 0;i<now.count;++i){
list.add(now.value);
}
if(now.right!=null){
deq.add(now.right);
}
}
}
}
return list;
}
@Override public String toString(){
final ArrayList<E> list = toList();
return list.toString();
}
@Override public boolean equals(final Object o){
if(o instanceof final TreeMulti<?> tree){
if(size!=tree.size()){
return false;
}
final ArrayList<E> array1 = toList();
final ArrayList<?> array2 = tree.toList();
for(int i = 0;i<size;++i){
if(!array1.get(i).equals(array2.get(i))){
return false;
}
}
return true;
}
return false;
}
@Override public int hashCode(){
return hash;
}
/*
* 以下、平衡用メソッド
*/
private void fix(Node<E> node){
while(node!=null){
final int lh = node.left==null?0:node.left.height;
final int rh = node.right==null?0:node.right.height;
if(lh-rh>1){
assert node.left!=null;
if(node.left.right!=null&&node.left.right.height==lh-1){
rotateL(node.left);
setStates(node.left);
}
rotateR(node);
}
else if(rh-lh>1){
assert node.right!=null;
if(node.right.left!=null&&node.right.left.height==rh-1){
rotateR(node.right);
setStates(node.right);
}
rotateL(node);
}
setStates(node);
node = node.parent;
}
}
private void rotateR(final Node<E> node){
final Node<E> temp = node.left;
node.left = temp.right;
if(node.left!=null){
node.left.parent = node;
}
temp.right = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void rotateL(final Node<E> node){
final Node<E> temp = node.right;
node.right = temp.left;
if(node.right!=null){
node.right.parent = node;
}
temp.left = node;
temp.parent = node.parent;
if(node.parent!=null){
if(node.parent.left==node){
node.parent.left = temp;
}
else{
node.parent.right = temp;
}
}
else{
root = temp;
}
node.parent = temp;
setStates(node);
}
private void setStates(final Node<E> node){
final int lh = node.left!=null?node.left.height:0;
final int rh = node.right!=null?node.right.height:0;
node.height = Math.max(lh,rh)+1;
final long ls = node.left!=null?node.left.size:0;
final long rs = node.right!=null?node.right.size:0;
node.size = ls+rs+node.count;
}
}
/**
* SimpleScannerクラスです。
* java.util.Scannerクラスよりは速いですが、競プロ用に特化しているため
* charの値がスペース以下の文字は全て区切り文字と判断します。
* 仕様上、必ず入力の最後には区切り文字を含めて下さい。
*/
final class SimpleScanner{
private final int BUFF_SIZE = 1<<17;
private final InputStream is;
private final byte[] buff;
private int point, length;
/**
* 引数のInputStreamを元にSimpleScannerを構築します。
*
* @param is 元となるInputStream
*/
public SimpleScanner(final InputStream is){
this.is = is;
buff = new byte[BUFF_SIZE];
point = length = 0;
}
/**
* バッファに再読み込みします。
* 何かしら入力がされるまで待機します。
*/
private void reload(){
do{
try{
length = is.read(buff,point = 0,BUFF_SIZE);
}catch(final IOException e){
e.printStackTrace();
System.exit(1);
}
}
while(length==-1);
}
/**
* バッファから一文字読み込みます。
*
* @return 読み込んだ文字を表すbyte
*/
private byte read(){
if(point==length){
reload();
}
return buff[point++];
}
/**
* バッファから文字を表すbyteを取得します。
*
* @return まだ読んでない中で最初に入力された文字を表すbyte
*/
public byte nextByte(){
byte c = read();
while(c<=' '){
c = read();
}
return c;
}
/**
* バッファからintを読み込みます。
* オーバーフローは検知できないので注意して下さい。
*
* @return 区切り文字までの文字列をintと解釈した時の値
*/
public int nextInt(){
int ans = 0;
byte c = nextByte();
final boolean negate = c=='-';
if(!MathFunction.rangeCheckClose(c,'0','9')){
c = read();
}
while(MathFunction.rangeCheckClose(c,'0','9')){
ans = ans*10+c-'0';
c = read();
}
return negate?-ans:ans;
}
/**
* バッファからlongを読み込みます。
* オーバーフローは検知できないので注意して下さい。
*
* @return 区切り文字までの文字列をlongと解釈した時の値
*/
public long nextLong(){
long ans = 0;
byte c = nextByte();
final boolean negate = c=='-';
if(!MathFunction.rangeCheckClose(c,'0','9')){
c = read();
}
while(MathFunction.rangeCheckClose(c,'0','9')){
ans = ans*10L+c-'0';
c = read();
}
return negate?-ans:ans;
}
/**
* バッファからcharを読み込みます。
*
* @return 区切り文字を無視した、一番最初に取得された文字を表すchar
*/
public char nextChar(){
return (char)nextByte();
}
/**
* バッファからStringを読み込みます。
*
* @return 区切り文字までの文字列を表すString
*/
public String next(){
final StringBuilder ans = new StringBuilder();
byte c = nextByte();
while(c>' '){
ans.append((char)c);
c = read();
}
return ans.toString();
}
/**
* バッファからBigIntegerを読み込みます。
*
* @return 区切り文字までの文字列を整数と解釈した時のBigInteger
*/
public BigInteger nextBigInteger(){
return new BigInteger(next());
}
/**
* バッファからbyte[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字を無視してn個文字を取得した結果を表すbyte[]
*/
public byte[] nextByte(final int n){
final byte[] ans = new byte[n];
for(int i = 0;i<n;++i){
ans[i] = nextByte();
}
return ans;
}
/**
* バッファからint[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字で区切ってn個intを取得した結果を表すint[]
*/
public int[] nextInt(final int n){
final int[] ans = new int[n];
for(int i = 0;i<n;++i){
ans[i] = nextInt();
}
return ans;
}
/**
* バッファからlong[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字で区切ってn個longを取得した結果を表すlong[]
*/
public long[] nextLong(final int n){
final long[] ans = new long[n];
for(int i = 0;i<n;++i){
ans[i] = nextLong();
}
return ans;
}
/**
* バッファからString[]を読み込みます。
*
* @param n 取得する個数
*
* @return 区切り文字で区切ってn個Stringを取得した結果を表すString[]
*/
public String[] next(final int n){
final String[] ans = new String[n];
for(int i = 0;i<n;++i){
ans[i] = next();
}
return ans;
}
public byte[][] nextByte(final int n,final int m){
final byte[][] ans = new byte[n][];
for(int i = 0;i<n;++i){
ans[i] = nextByte(m);
}
return ans;
}
public int[][] nextInt(final int n,final int m){
final int[][] ans = new int[n][];
for(int i = 0;i<n;++i){
ans[i] = nextInt(m);
}
return ans;
}
public long[][] nextLong(final int n,final int m){
final long[][] ans = new long[n][];
for(int i = 0;i<n;++i){
ans[i] = nextLong(m);
}
return ans;
}
public String[][] next(final int n,final int m){
final String[][] ans = new String[n][];
for(int i = 0;i<n;++i){
ans[i] = next(m);
}
return ans;
}
public char[] nextCharArray(){
return next().toCharArray();
}
public char[][] nextCharArray(final int n){
final char[][] ans = new char[n][];
for(int i = 0;i<n;++i){
ans[i] = nextCharArray();
}
return ans;
}
public int[][] nextGraph(final int N,final int M){
if(M==0){
return new int[N+1][0];
}
final int[][] ans = new int[N+1][];
final int[] count = new int[N+1];
final int[][] path = nextInt(M,2);
for(final int[] temp: path){
++count[temp[0]];
++count[temp[1]];
}
for(int i = 1;i<=N;++i){
ans[i] = new int[count[i]];
}
for(final int[] temp: path){
ans[temp[0]][--count[temp[0]]] = temp[1];
ans[temp[1]][--count[temp[1]]] = temp[0];
}
ans[0] = new int[0];
return ans;
}
public Point nextPoint(){
return new Point(nextInt(),nextInt());
}
public Point[] nextPoint(final int n){
final Point[] ans = new Point[n];
for(int i = 0;i<n;++i){
ans[i] = nextPoint();
}
return ans;
}
public void close(){
try{
is.close();
}catch(final IOException e){
e.printStackTrace();
System.exit(1);
}
}
}
/**
* SimpleWriterクラス用のSimpleOutputStreamクラスです。
* ちょっとだけ速いです。
*/
final class SimpleOutputStream extends FilterOutputStream{
private final byte[] buf;
private int count;
public SimpleOutputStream(final OutputStream out){
this(out,1<<17);
}
public SimpleOutputStream(final OutputStream out,final int size){
super(out);
if(size<=0){
throw new IllegalArgumentException("Buffer size <= 0");
}
buf = new byte[size];
}
private void flushBuffer() throws IOException{
if(count>0){
out.write(buf,0,count);
count = 0;
}
}
public void write(final int b) throws IOException{
if(count>=buf.length){
flushBuffer();
}
buf[count++] = (byte)b;
}
public void write(final byte[] b,final int off,final int len) throws IOException{
if(len>=buf.length){
flushBuffer();
out.write(b,off,len);
return;
}
if(len>buf.length-count){
flushBuffer();
}
System.arraycopy(b,off,buf,count,len);
count += len;
}
public void flush() throws IOException{
flushBuffer();
out.flush();
}
}
/**
* SimpleWriterクラスです。
* そこそこ速い出力を提供します。
*/
final class SimpleWriter implements Appendable, Closeable, Flushable, AutoCloseable{
private Writer out;
private final boolean autoFlush;
private boolean trouble = false;
private Formatter formatter;
private PrintStream psOut = null;
public SimpleWriter(final Writer out){
this(out,false);
}
public SimpleWriter(final Writer out,final boolean autoFlush){
this.out = out;
this.autoFlush = autoFlush;
}
public SimpleWriter(final OutputStream out){
this(out,false);
}
public SimpleWriter(final OutputStream out,final boolean autoFlush){
this(out,autoFlush,Charset.defaultCharset());
}
public SimpleWriter(final OutputStream out,final boolean autoFlush,final Charset charset){
this(new BufferedWriter(new OutputStreamWriter(new SimpleOutputStream(out),charset)),autoFlush);
if(out instanceof PrintStream){
psOut = (PrintStream)out;
}
}
private void ensureOpen() throws IOException{
if(out==null){
throw new IOException("Stream closed");
}
}
public void flush(){
try{
ensureOpen();
out.flush();
}catch(IOException x){
trouble = true;
}
}
public void close(){
try{
if(out==null){
return;
}
out.close();
out = null;
}catch(IOException x){
trouble = true;
}
}
public boolean checkError(){
if(out!=null){
flush();
}
else if(psOut!=null){
return psOut.checkError();
}
return trouble;
}
public void write(final int c){
try{
ensureOpen();
out.write(c);
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void write(final char[] buf,final int off,final int len){
try{
ensureOpen();
out.write(buf,off,len);
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void write(final char[] buf){
write(buf,0,buf.length);
}
public void write(final String s,final int off,final int len){
try{
ensureOpen();
out.write(s,off,len);
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void write(final String s){
write(s,0,s.length());
}
private void newLine(){
try{
ensureOpen();
out.write(System.lineSeparator());
if(autoFlush){
out.flush();
}
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
}
public void print(final boolean b){
write(b?"true":"false");
}
public void print(final char c){
write(c);
}
public void print(final int i){
write(String.valueOf(i));
}
public void print(final long l){
write(String.valueOf(l));
}
public void print(final float f){
write(String.valueOf(f));
}
public void print(final double d){
write(String.valueOf(d));
}
public void print(final char[] s){
write(s);
}
public void print(final String s){
write(s);
}
public void print(final Object obj){
write(obj.toString());
}
public void println(){
newLine();
}
public void println(final boolean x){
print(x);
println();
}
public void println(final char x){
print(x);
println();
}
public void println(final int x){
print(x);
println();
}
public void println(final long x){
print(x);
println();
}
public void println(final float x){
print(x);
println();
}
public void println(final double x){
print(x);
println();
}
public void println(final char[] x){
print(x);
println();
}
public void println(final String x){
print(x);
println();
}
public void println(final Object x){
print(x.toString());
println();
}
public SimpleWriter printf(final String format,final Object... args){
return format(format,args);
}
public SimpleWriter printf(final Locale l,final String format,final Object... args){
return format(l,format,args);
}
public SimpleWriter format(final String format,final Object... args){
try{
ensureOpen();
if((formatter==null)||(formatter.locale()!=Locale.getDefault())){
formatter = new Formatter(this);
}
formatter.format(Locale.getDefault(),format,args);
if(autoFlush){
out.flush();
}
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
return this;
}
public SimpleWriter format(final Locale l,final String format,final Object... args){
try{
ensureOpen();
if((formatter==null)||(formatter.locale()!=l)){
formatter = new Formatter(this,l);
}
formatter.format(l,format,args);
if(autoFlush){
out.flush();
}
}catch(InterruptedIOException x){
Thread.currentThread().interrupt();
}catch(IOException x){
trouble = true;
}
return this;
}
public SimpleWriter append(final CharSequence csq){
write(String.valueOf(csq));
return this;
}
public SimpleWriter append(CharSequence csq,final int start,final int end){
if(csq==null){
csq = "null";
}
return append(csq.subSequence(start,end));
}
public SimpleWriter append(final char c){
write(c);
return this;
}
public void print(final int[] array){
print(array,' ');
}
public void print(final int[] array,final String str){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public void print(final int[] array,final char c){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public void print(final int[][] array){
print(array,' ');
}
public void print(final int[][] arrays,final String str){
if(arrays.length==0)
return;
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public void print(final int[][] arrays,final char c){
if(arrays.length==0)
return;
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public void println(final int[] array){
print(array,' ');
println();
}
public void println(final int[] array,final String str){
print(array,str);
println();
}
public void println(final int[] array,final char c){
print(array,c);
println();
}
public void println(final int[][] array){
print(array,' ');
println();
}
public void println(final int[][] arrays,final String str){
print(arrays,str);
println();
}
public void println(final int[][] arrays,final char c){
print(arrays,c);
println();
}
public void print(final long[] array){
print(array,' ');
}
public void print(final long[] array,final String str){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public void print(final long[] array,final char c){
if(array.length==0)
return;
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public void print(final long[][] array){
print(array,' ');
}
public void print(final long[][] arrays,final String str){
if(arrays.length==0)
return;
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public void print(final long[][] arrays,final char c){
if(arrays.length==0)
return;
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public void println(final long[] array){
println(array,' ');
}
public void println(final long[] array,final String str){
print(array,str);
println();
}
public void println(final long[] array,final char c){
print(array,c);
println();
}
public void println(final long[][] array){
println(array,' ');
}
public void println(final long[][] arrays,final String str){
print(arrays,str);
println();
}
public void println(final long[][] arrays,final char c){
print(arrays,c);
println();
}
public void print(final double[] array){
print(array,' ');
}
public void print(final double[] array,final String str){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public void print(final double[] array,final char c){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public void print(final double[][] array){
print(array,' ');
}
public void print(final double[][] arrays,final String str){
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public void print(final double[][] arrays,final char c){
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public void println(final double[] array){
println(array,' ');
}
public void println(final double[] array,final String str){
print(array,str);
println();
}
public void println(final double[] array,final char c){
print(array,c);
println();
}
public void println(final double[][] array){
println(array,' ');
}
public void println(final double[][] arrays,final String str){
print(arrays,str);
println();
}
public void println(final double[][] arrays,final char c){
print(arrays,c);
println();
}
public void println(final char[] cs,final String str){
print(cs[0]);
for(int i = 1;i<cs.length;++i){
print(str);
print(cs[i]);
}
println();
}
public void println(final char[] cs,final char c){
print(cs[0]);
for(int i = 1;i<cs.length;++i){
print(c);
print(cs[i]);
}
println();
}
public void println(final char[][] cs){
for(final char[] c: cs){
println(c);
}
}
public void println(final char[][] cs,final String str){
for(final char[] c: cs){
println(c,str);
}
}
public void println(final char[][] cs,final char c){
for(final char[] cc: cs){
println(cc,c);
}
}
public <E> void print(final E[] array){
print(array,' ');
}
public <E> void print(final E[] array,final String str){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(str);
print(array[i]);
}
}
public <E> void print(final E[] array,final char c){
print(array[0]);
for(int i = 1;i<array.length;++i){
print(c);
print(array[i]);
}
}
public <E> void print(final E[][] arrays){
print(arrays,' ');
}
public <E> void print(final E[][] arrays,final String str){
print(arrays[0],str);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],str);
}
}
public <E> void print(final E[][] arrays,final char c){
print(arrays[0],c);
for(int i = 1;i<arrays.length;++i){
println();
print(arrays[i],c);
}
}
public <E> void println(final E[] array){
println(array,' ');
}
public <E> void println(final E[] array,final String str){
print(array,str);
println();
}
public <E> void println(final E[] array,final char c){
print(array,c);
println();
}
public <E> void println(final E[][] arrays){
println(arrays,' ');
}
public <E> void println(final E[][] arrays,final String str){
print(arrays,str);
println();
}
public <E> void println(final E[][] arrays,final char c){
print(arrays,c);
println();
}
public <E> void println(final List<E> list){
println(list,' ');
}
public <E> void println(final List<E> list,final String str){
if(list.size()>0){
print(list.get(0));
for(int i = 1;i<list.size();++i){
print(str);
print(list.get(i));
}
}
println();
}
public <E> void println(final List<E> list,final char c){
if(list.size()>0){
print(list.get(0));
for(int i = 1;i<list.size();++i){
print(c);
print(list.get(i));
}
}
println();
}
}
| ConDefects/ConDefects/Code/abc332_f/Java/48417116 |
condefects-java_data_1908 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
int m = Integer.parseInt(sc.next());
final long mod = 998244353;
SegTreeLazy segTreeLazy = new SegTreeLazy(n);
for(int i = 0; i < n; i++) segTreeLazy.set(i, Long.parseLong(sc.next()));
segTreeLazy.build();
for(int i = 0; i < m; i++) {
int l = Integer.parseInt(sc.next());
int r = Integer.parseInt(sc.next());
long x = Long.parseLong(sc.next());
l--;
x %= mod;
long p = r - l;
long invp = inv(p, mod);
long q = 1 - invp;
q = (q + mod) % mod;
x = (x * invp) % mod;
segTreeLazy.update(l, r, new long[] {q, x});
}
for(int i = 0; i < 4 * n; i++) segTreeLazy.eval(i);
StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; i++) sb.append(segTreeLazy.get(i) + " ");
System.out.println(sb.toString());
}
}
static long inv(long x, long mod) {
long res = 1;
long y = mod - 2;
while(y > 0) {
if((y & 1) != 0) {
res *= x;
res %= mod;
}
y = y >> 1;
x *= x;
x %= mod;
}
return res;
}
}
class SegTreeLazy{
int n;
final long ex = 1;
final long[] em = {1, 0};
long[] dat;
long[][] lazy;
final long mod = 998244353;
private long fx(long a, long b) {
return Math.min(a, b);
}
private long fa(long x, long[] f) {
return (f[0] * x + f[1]) % mod;
}
private long[] fm(long[] f, long[] g) {
return new long[] {(f[0] * g[0]) % mod, (g[0] * f[1] + g[1]) % mod};
}
public SegTreeLazy(int n) {
int x = 1;
while(n > x) x *= 2;
this.n = x;
dat = new long[4 * n];
lazy = new long[4 * n][2];
for(int i = 0; i < 4 * n; i++) {
lazy[i][0] = 1;
lazy[i][1] = 0;
}
}
void set(int i, long x) {
dat[i + n - 1] = x;
}
long get(int i) {
eval(i + n - 1);
return dat[i + n - 1];
}
void build() {
for (int k = n - 2; k >= 0; k--) dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
}
void eval(int k) {
if(lazy[k][0] == 1 && lazy[k][1] == 0) return;
if(k < n - 1) {
lazy[2 * k + 1] = fm(lazy[2 * k + 1], lazy[k]);
lazy[2 * k + 2] = fm(lazy[2 * k + 2], lazy[k]);
}
dat[k] = fa(dat[k], lazy[k]);
lazy[k][0] = 1;
lazy[k][1] = 0;
//lazy[k] = em;
}
void update(int a, int b, long[] x) {
update(a, b, x, 0, 0, n);
}
void update(int a, int b, long[] x, int k, int l, int r) {
eval(k);
if(a <= l && r <= b) {
lazy[k] = fm(lazy[k], x);
eval(k);
} else if(a < r && l < b){
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
dat[k] = fx(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
long query(int a, int b) {
return query_sub(a, b, 0, 0, n);
}
long query_sub(int a, int b, int k, int l, int r) {
if(r <= a || b <= l) return ex;
else if(a <= l && r <= b) return dat[k];
else {
long vl = query_sub(a, b, 2 * k + 1, l, (l + r) / 2);
long vr = query_sub(a, b, 2 * k + 2, (l + r) / 2, r);
return fx(vl, vr);
}
}
void show() {
int x = 0;
int y = 1;
while(x < n) {
for(int i = x; i < y; i++) {
System.out.print(dat[i] + " ");
}
System.out.println();
x = y;
y = 2 * y + 1;
}
}
void showlazy() {
int x = 0;
int y = 1;
while(x < n) {
for(int i = x; i < y; i++) {
System.out.print(lazy[i][0] + " : " + lazy[i][1] + " ");
}
System.out.println();
x = y;
y = 2 * y + 1;
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try(Scanner sc = new Scanner(System.in);) {
int n = Integer.parseInt(sc.next());
int m = Integer.parseInt(sc.next());
final long mod = 998244353;
SegTreeLazy segTreeLazy = new SegTreeLazy(n);
for(int i = 0; i < n; i++) segTreeLazy.set(i, Long.parseLong(sc.next()));
segTreeLazy.build();
for(int i = 0; i < m; i++) {
int l = Integer.parseInt(sc.next());
int r = Integer.parseInt(sc.next());
long x = Long.parseLong(sc.next());
l--;
x %= mod;
long p = r - l;
long invp = inv(p, mod);
long q = 1 - invp;
q = (q + mod) % mod;
x = (x * invp) % mod;
segTreeLazy.update(l, r, new long[] {q, x});
}
for(int i = 0; i < 4 * n; i++) segTreeLazy.eval(i);
StringBuilder sb = new StringBuilder();
for(int i = 0; i < n; i++) sb.append(((segTreeLazy.get(i)) % mod) + " ");
System.out.println(sb.toString());
}
}
static long inv(long x, long mod) {
long res = 1;
long y = mod - 2;
while(y > 0) {
if((y & 1) != 0) {
res *= x;
res %= mod;
}
y = y >> 1;
x *= x;
x %= mod;
}
return res;
}
}
class SegTreeLazy{
int n;
final long ex = 1;
final long[] em = {1, 0};
long[] dat;
long[][] lazy;
final long mod = 998244353;
private long fx(long a, long b) {
return Math.min(a, b);
}
private long fa(long x, long[] f) {
return (f[0] * x + f[1]) % mod;
}
private long[] fm(long[] f, long[] g) {
return new long[] {(f[0] * g[0]) % mod, (g[0] * f[1] + g[1]) % mod};
}
public SegTreeLazy(int n) {
int x = 1;
while(n > x) x *= 2;
this.n = x;
dat = new long[4 * n];
lazy = new long[4 * n][2];
for(int i = 0; i < 4 * n; i++) {
lazy[i][0] = 1;
lazy[i][1] = 0;
}
}
void set(int i, long x) {
dat[i + n - 1] = x;
}
long get(int i) {
eval(i + n - 1);
return dat[i + n - 1];
}
void build() {
for (int k = n - 2; k >= 0; k--) dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
}
void eval(int k) {
if(lazy[k][0] == 1 && lazy[k][1] == 0) return;
if(k < n - 1) {
lazy[2 * k + 1] = fm(lazy[2 * k + 1], lazy[k]);
lazy[2 * k + 2] = fm(lazy[2 * k + 2], lazy[k]);
}
dat[k] = fa(dat[k], lazy[k]);
lazy[k][0] = 1;
lazy[k][1] = 0;
//lazy[k] = em;
}
void update(int a, int b, long[] x) {
update(a, b, x, 0, 0, n);
}
void update(int a, int b, long[] x, int k, int l, int r) {
eval(k);
if(a <= l && r <= b) {
lazy[k] = fm(lazy[k], x);
eval(k);
} else if(a < r && l < b){
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
dat[k] = fx(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
long query(int a, int b) {
return query_sub(a, b, 0, 0, n);
}
long query_sub(int a, int b, int k, int l, int r) {
if(r <= a || b <= l) return ex;
else if(a <= l && r <= b) return dat[k];
else {
long vl = query_sub(a, b, 2 * k + 1, l, (l + r) / 2);
long vr = query_sub(a, b, 2 * k + 2, (l + r) / 2, r);
return fx(vl, vr);
}
}
void show() {
int x = 0;
int y = 1;
while(x < n) {
for(int i = x; i < y; i++) {
System.out.print(dat[i] + " ");
}
System.out.println();
x = y;
y = 2 * y + 1;
}
}
void showlazy() {
int x = 0;
int y = 1;
while(x < n) {
for(int i = x; i < y; i++) {
System.out.print(lazy[i][0] + " : " + lazy[i][1] + " ");
}
System.out.println();
x = y;
y = 2 * y + 1;
}
}
} | ConDefects/ConDefects/Code/abc332_f/Java/48705204 |
condefects-java_data_1909 | import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
public class Main {
static FastScanner sc;
static PrintWriter out;
public static void main(String[] args) {
sc = new FastScanner(System.in);
out = new PrintWriter(System.out);
new Main().solve();
out.flush();
}
static long mod = 998244353;
public void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
Long[] dat = new Long[n];
for(int i=0; i<n; i++) {
dat[i] = sc.nextLong();
}
LazySegTree<Long, long[]> seg = new LazySegTree<>(
dat,
(x, y) -> (x + y) % mod,
0L,
(f, x) -> (f[0] * x % mod + f[1]) % mod,
(f, g) -> new long[] { f[0] * g[0] % mod, (f[0] * g[1] % mod + f[1]) % mod},
new long[]{1L, 0L});
for(int i=0; i<m; i++) {
int l = sc.nextInt()-1;
int r = sc.nextInt();
int d = r-l;
int x = sc.nextInt();
long dinv = modinv(d);
seg.apply(l, r, new long[]{(1+mod-dinv)%mod , dinv * x % mod});
}
long[] res = new long[n];
for(int i=0; i<n; i++) {
res[i] = seg.get(i);
if(i>0) out.print(" ");
out.print(res[i]);
}
out.println();
}
static long modinv(long a) {
return modpow(a, mod-2);
}
static long modpow(long a, long b) {
long res = 1;
while(b > 0) {
if((b & 1) == 1) {
res = (res * a) % mod;
}
a = (a * a) % mod;
b >>= 1;
}
return res;
}
class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return E;
l += N; r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1; r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N; r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1; r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N) return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
}
class FastScanner {
private final InputStream 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;
}
public FastScanner(Path path) {
try {
this.in = Files.newInputStream(path);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public FastScanner(InputStream in) {
this.in = in;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
}
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
public class Main {
static FastScanner sc;
static PrintWriter out;
public static void main(String[] args) {
sc = new FastScanner(System.in);
out = new PrintWriter(System.out);
new Main().solve();
out.flush();
}
static long mod = 998244353;
public void solve() {
int n = sc.nextInt();
int m = sc.nextInt();
Long[] dat = new Long[n];
for(int i=0; i<n; i++) {
dat[i] = sc.nextLong();
}
LazySegTree<Long, long[]> seg = new LazySegTree<>(
dat,
(x, y) -> (x + y) % mod,
0L,
(f, x) -> (f[0] * x % mod + f[1]) % mod,
(f, g) -> new long[] { f[0] * g[0] % mod, (f[0] * g[1] % mod + f[1]) % mod},
new long[]{1L, 0L});
for(int i=0; i<m; i++) {
int l = sc.nextInt()-1;
int r = sc.nextInt();
int d = r-l;
int x = sc.nextInt();
long dinv = modinv(d);
seg.apply(l, r, new long[]{(1+mod-dinv)%mod , dinv * x % mod});
}
long[] res = new long[n];
for(int i=0; i<n; i++) {
res[i] = seg.prod(i, i+1);
if(i>0) out.print(" ");
out.print(res[i]);
}
out.println();
}
static long modinv(long a) {
return modpow(a, mod-2);
}
static long modpow(long a, long b) {
long res = 1;
while(b > 0) {
if((b & 1) == 1) {
res = (res * a) % mod;
}
a = (a * a) % mod;
b >>= 1;
}
return res;
}
class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return E;
l += N; r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1; r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N; r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1; r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N) return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
}
class FastScanner {
private final InputStream 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;
}
public FastScanner(Path path) {
try {
this.in = Files.newInputStream(path);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public FastScanner(InputStream in) {
this.in = in;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while(true){
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
}else if(b == -1 || !isPrintableChar(b)){
return minus ? -n : n;
}else{
throw new NumberFormatException();
}
b = readByte();
}
}
} | ConDefects/ConDefects/Code/abc332_f/Java/50690321 |
condefects-java_data_1910 | // import static org.junit.jupiter.api.Assertions.assertEquals;
// import org.junit.jupiter.api.Test;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
if(S.charAt(0)!=S.charAt(1)){
if(S.charAt(0)!=S.charAt(2)){
System.out.println(1);
}
else{
System.out.println(2);
}
return;
}
for(int i=1;i<S.length();i++){
if(S.charAt(i)!=S.charAt(i+1)){
System.out.println(i+1);
return;
}
}
// @Test
// void addition() {
// assertEquals(2, 1 + 1);
}
}
// import static org.junit.jupiter.api.Assertions.assertEquals;
// import org.junit.jupiter.api.Test;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String S = sc.next();
if(S.charAt(0)!=S.charAt(1)){
if(S.charAt(0)!=S.charAt(2)){
System.out.println(1);
}
else{
System.out.println(2);
}
return;
}
for(int i=1;i<S.length();i++){
if(S.charAt(i)!=S.charAt(i+1)){
System.out.println(i+2);
return;
}
}
// @Test
// void addition() {
// assertEquals(2, 1 + 1);
}
} | ConDefects/ConDefects/Code/abc342_a/Java/54660420 |
condefects-java_data_1911 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] S = sc.nextLine().split("");
sc.close();
if (S[0].equals(S[1])) {
for (int i = 3; i < S.length; i++) {
if (!S[0].equals(S[i])) {
System.out.println(i + 1);
}
}
}else if(S[1].equals(S[2])) {
System.out.println(1);
}else {
System.out.println(2);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] S = sc.nextLine().split("");
sc.close();
if (S[0].equals(S[1])) {
for (int i = 2; i < S.length; i++) {
if (!S[0].equals(S[i])) {
System.out.println(i + 1);
}
}
}else if(S[1].equals(S[2])) {
System.out.println(1);
}else {
System.out.println(2);
}
}
}
| ConDefects/ConDefects/Code/abc342_a/Java/53442733 |
condefects-java_data_1912 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
sc.close();
String[] S = s.split("");
String ini = S[0];
if (!ini.equals(S[1])) {
System.out.println(ini.equals(S[2]) ? 2 : 1);
} else {
for (int i = 3; i < S.length; i++) {
if (!ini.equals(S[i])) {
System.out.println(i + 1);
}
}
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
sc.close();
String[] S = s.split("");
String ini = S[0];
if (!ini.equals(S[1])) {
System.out.println(ini.equals(S[2]) ? 2 : 1);
} else {
for (int i = 2; i < S.length; i++) {
if (!ini.equals(S[i])) {
System.out.println(i + 1);
}
}
}
}
}
| ConDefects/ConDefects/Code/abc342_a/Java/54193749 |
condefects-java_data_1913 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String S = sc.next();
int sLength = S.length();
for (int i=0;i<sLength;i++) {
char ch = S.charAt(i);
int cnt = 0;
for (int j=0;j<sLength;j++){
char ch2 = S.charAt(j);
if (i != j && ch != ch2){
cnt++;
if (cnt == 2) {
System.out.println(ch);
return;
}
}
}
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String S = sc.next();
int sLength = S.length();
for (int i=0;i<sLength;i++) {
char ch = S.charAt(i);
int cnt = 0;
for (int j=0;j<sLength;j++){
char ch2 = S.charAt(j);
if (i != j && ch != ch2){
cnt++;
if (cnt == 2) {
System.out.println(i+1);
return;
}
}
}
}
}
}
| ConDefects/ConDefects/Code/abc342_a/Java/52007490 |
condefects-java_data_1914 | import java.util.StringTokenizer;
import java.util.stream.Stream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Main{
public static void main(String[] args)throws Exception{
FastReader fr = new FastReader();
int n = fr.nextInt();
int m = fr.nextInt();
int ans = 0;
String[] s = new String[n];
for (int i = 0; i < n; i++){
s[i] = fr.next();
}
fr.close();
for (int i = 0; i < n; i++){
boolean bool = true;
for (int j = i + 1; j < n; j++){
for (int k = 0; k < m; k++){
if (s[i].charAt(k) == 'x' && s[j].charAt(k) == 'x'){
bool = false;
}
}
if (bool == true) ans ++;
}
}
System.out.println(ans);
}
}
class FastReader {
BufferedReader br = null;
StringTokenizer st = new StringTokenizer("");
public FastReader() throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
}
public int nextInt() throws Exception {
return Integer.parseInt(next());
}
public long nextLong() throws Exception {
return Long.parseLong(next());
}
public double nextDouble() throws Exception {
return Double.parseDouble(next());
}
public int[] nextIntArray() throws Exception {
return Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
}
public String next() throws Exception {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
String nextLine() throws IOException {
return br.readLine();
}
public void close() throws Exception {
br.close();
}
}
import java.util.StringTokenizer;
import java.util.stream.Stream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Main{
public static void main(String[] args)throws Exception{
FastReader fr = new FastReader();
int n = fr.nextInt();
int m = fr.nextInt();
int ans = 0;
String[] s = new String[n];
for (int i = 0; i < n; i++){
s[i] = fr.next();
}
fr.close();
for (int i = 0; i < n; i++){
for (int j = i + 1; j < n; j++){
boolean bool = true;
for (int k = 0; k < m; k++){
if (s[i].charAt(k) == 'x' && s[j].charAt(k) == 'x'){
bool = false;
}
}
if (bool == true) ans ++;
}
}
System.out.println(ans);
}
}
class FastReader {
BufferedReader br = null;
StringTokenizer st = new StringTokenizer("");
public FastReader() throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
}
public int nextInt() throws Exception {
return Integer.parseInt(next());
}
public long nextLong() throws Exception {
return Long.parseLong(next());
}
public double nextDouble() throws Exception {
return Double.parseDouble(next());
}
public int[] nextIntArray() throws Exception {
return Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
}
public String next() throws Exception {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
String nextLine() throws IOException {
return br.readLine();
}
public void close() throws Exception {
br.close();
}
} | ConDefects/ConDefects/Code/abc282_b/Java/43023184 |
condefects-java_data_1915 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 参加者の人数
int num = Integer.parseInt(scanner.next());
// 問題数
int problem = Integer.parseInt(scanner.next());
String[] score = new String[num];
for (int i = 0; i < num; i++) {
score[i] = scanner.next();
}
int count = 0;
boolean flg = true;
for (int i = 0; i < num - 1; i++) {
for (int j = 0; j < num; j++) {
if (i >= j) {
continue;
}
String[] numbers1 = score[i].split("");
String[] numbers2 = score[j].split("");
for (int k = 0; k < problem; k++) {
if (numbers1[k].equals("o")) {
continue;
} else {
if (numbers2[k].equals("o")) {
continue;
} else {
flg = false;
break;
}
}
}
if (flg) {
count++;
}
}
}
System.out.println(count);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 参加者の人数
int num = Integer.parseInt(scanner.next());
// 問題数
int problem = Integer.parseInt(scanner.next());
String[] score = new String[num];
for (int i = 0; i < num; i++) {
score[i] = scanner.next();
}
int count = 0;
for (int i = 0; i < num - 1; i++) {
for (int j = 0; j < num; j++) {
boolean flg = true;
if (i >= j) {
continue;
}
String[] numbers1 = score[i].split("");
String[] numbers2 = score[j].split("");
for (int k = 0; k < problem; k++) {
if (numbers1[k].equals("o")) {
continue;
} else {
if (numbers2[k].equals("o")) {
continue;
} else {
flg = false;
break;
}
}
}
if (flg) {
count++;
}
}
}
System.out.println(count);
}
} | ConDefects/ConDefects/Code/abc282_b/Java/46182357 |
condefects-java_data_1916 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long s = sc.nextLong();
long k = sc.nextLong();
long sum = 0;
for (long i = 0; i < n; i++) {
sum += sc.nextLong() * sc.nextLong();
}
sc.close();
System.out.println(sum > s ? sum : sum + k);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long s = sc.nextLong();
long k = sc.nextLong();
long sum = 0;
for (long i = 0; i < n; i++) {
sum += sc.nextLong() * sc.nextLong();
}
sc.close();
System.out.println(sum >= s ? sum : sum + k);
}
} | ConDefects/ConDefects/Code/abc332_a/Java/54295806 |
condefects-java_data_1917 | import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int S = scanner.nextInt();
int K = scanner.nextInt();
int sum = 0;
for (int i = 0; i < N; i++) {
int a = scanner.nextInt();
int b = scanner.nextInt();
sum += a * b;
}
if (sum < S){
sum += K;
}
System.err.print(sum);
// Scannerを閉じる
scanner.close();
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int N = scanner.nextInt();
int S = scanner.nextInt();
int K = scanner.nextInt();
int sum = 0;
for (int i = 0; i < N; i++) {
int a = scanner.nextInt();
int b = scanner.nextInt();
sum += a * b;
}
if (sum < S){
sum += K;
}
System.out.print(sum);
// Scannerを閉じる
scanner.close();
}
}
| ConDefects/ConDefects/Code/abc332_a/Java/52198929 |
condefects-java_data_1918 |
//ここからコピーするーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
import java.io.File;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception{
//Scanner sc = new Scanner( new File("src/data.txt") );
Scanner sc = new Scanner( System.in );
//int n = Integer.parseInt(sc.next());
//long n = Long.parseLong(sc.next());
//String s = sc.next();
//String w [] = s.split("");
//HashMap<String,Integer> map = new HashMap<String,Integer>();
//BigInteger bg = new BigInteger(sc.next());
//System.out.println();
//テンプレーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
int n = Integer.parseInt(sc.next());
int s = Integer.parseInt(sc.next());
int k = Integer.parseInt(sc.next());
int sum=0;
for(int i=0;i<n;i++) {
int p = Integer.parseInt(sc.next());
int q = Integer.parseInt(sc.next());
sum += p*q;
}
if(sum > s) sum+=k;
System.out.println(sum);
}
//mainここまでーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
//入出力系---------------------------------------------------------------------------------------------
//配列の入力
public static int [] arrayInt(int n) {
int [] a = new int[n];
for(int i = 0;i < n;i++){
a[i] = 0;
}
return a;
}
public static long [] arrayLong(int n) {
long [] a = new long[n];
for(int i = 0;i < n;i++){
a[i] = 0;
}
return a;
}
public static double [] arrayDouble(int n) {
double [] a = new double[n];
for(int i = 0;i < n;i++){
a[i] = 0;
}
return a;
}
public static String [] arrayString(int n) {
String [] a = new String[n];
for(int i = 0;i < n;i++){
a[i] = "";
}
return a;
}
//配列の出力---------------------------------------------------------------------------------------------
public static void arrayPrint(int[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
public static void arrayPrint(long[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
public static void arrayPrint(double[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
public static void arrayPrint(String[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
//ーーーーーーーーーーーーーーーーーーーーーーーーーー
//数値を1桁ずつ取り出してarraylistに格納（向き逆---------------------------------------------------------------------------------------------
public static List<Integer> CutInt(int n) {
List<Integer> list = new ArrayList<>();
while(n != 0) {
list.add(n%10);
n /=10;
}
return list;
}
//配列の値を大きい順に並べ替える---------------------------------------------------------------------------------------------
public static int [] SortDesc(int []n) {
Arrays.sort(n);
int [] m = new int[n.length];
for(int i=0;i<n.length;i++) {
m[i] = n[n.length - i - 1];
}
return m;
}
//double系---------------------------------------------------------------------------------------------
//少数点のf桁までを出力（f+1桁を四捨五入)
public static void doublePrint(double n, int f) {
Integer i = Integer.valueOf(f);
String s = "%."+i.toString()+"f";
System.out.println(String.format(s, n));
}
//String系---------------------------------------------------------------------------------------------
public static String [] separateString(String s) {
String [] ss = s.split("");
for(int i = 0;i < ss.length;i++){
System.out.println(ss[i]);
}
return ss;
}
//hashmap系---------------------------------------------------------------------------------------------
//アルファベットをカウントするhashmap 小文字
public static LinkedHashMap<String,Integer> LowerABMap (LinkedHashMap<String,Integer> map) {
map.put("a", 0);
map.put("b", 0);
map.put("c", 0);
map.put("d", 0);
map.put("e", 0);
map.put("f", 0);
map.put("g", 0);
map.put("h", 0);
map.put("i", 0);
map.put("j", 0);
map.put("k", 0);
map.put("l", 0);
map.put("m", 0);
map.put("n", 0);
map.put("o", 0);
map.put("p", 0);
map.put("q", 0);
map.put("r", 0);
map.put("s", 0);
map.put("t", 0);
map.put("u", 0);
map.put("v", 0);
map.put("w", 0);
map.put("x", 0);
map.put("y", 0);
map.put("z", 0);
return map;
}
//アルファベットをカウントするhashmap 大文字
public static LinkedHashMap<String,Integer> UpperABMap (LinkedHashMap<String,Integer> map) {
map.put("A", 0);
map.put("B", 0);
map.put("C", 0);
map.put("D", 0);
map.put("E", 0);
map.put("F", 0);
map.put("G", 0);
map.put("H", 0);
map.put("I", 0);
map.put("J", 0);
map.put("K", 0);
map.put("L", 0);
map.put("M", 0);
map.put("N", 0);
map.put("O", 0);
map.put("P", 0);
map.put("Q", 0);
map.put("R", 0);
map.put("S", 0);
map.put("T", 0);
map.put("U", 0);
map.put("V", 0);
map.put("W", 0);
map.put("X", 0);
map.put("Y", 0);
map.put("Z", 0);
return map;
}
}
//ここまでコピーするーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
//ここからコピーするーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
import java.io.File;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception{
//Scanner sc = new Scanner( new File("src/data.txt") );
Scanner sc = new Scanner( System.in );
//int n = Integer.parseInt(sc.next());
//long n = Long.parseLong(sc.next());
//String s = sc.next();
//String w [] = s.split("");
//HashMap<String,Integer> map = new HashMap<String,Integer>();
//BigInteger bg = new BigInteger(sc.next());
//System.out.println();
//テンプレーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
int n = Integer.parseInt(sc.next());
int s = Integer.parseInt(sc.next());
int k = Integer.parseInt(sc.next());
int sum=0;
for(int i=0;i<n;i++) {
int p = Integer.parseInt(sc.next());
int q = Integer.parseInt(sc.next());
sum += p*q;
}
if(sum < s) sum+=k;
System.out.println(sum);
}
//mainここまでーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー
//入出力系---------------------------------------------------------------------------------------------
//配列の入力
public static int [] arrayInt(int n) {
int [] a = new int[n];
for(int i = 0;i < n;i++){
a[i] = 0;
}
return a;
}
public static long [] arrayLong(int n) {
long [] a = new long[n];
for(int i = 0;i < n;i++){
a[i] = 0;
}
return a;
}
public static double [] arrayDouble(int n) {
double [] a = new double[n];
for(int i = 0;i < n;i++){
a[i] = 0;
}
return a;
}
public static String [] arrayString(int n) {
String [] a = new String[n];
for(int i = 0;i < n;i++){
a[i] = "";
}
return a;
}
//配列の出力---------------------------------------------------------------------------------------------
public static void arrayPrint(int[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
public static void arrayPrint(long[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
public static void arrayPrint(double[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
public static void arrayPrint(String[] n) {
for(int apIdx = 0;apIdx < n.length; apIdx++) {
if(apIdx != n.length -1) System.out.print(n[apIdx]+" ");
else System.out.println(n[apIdx]);
}
}
//ーーーーーーーーーーーーーーーーーーーーーーーーーー
//数値を1桁ずつ取り出してarraylistに格納（向き逆---------------------------------------------------------------------------------------------
public static List<Integer> CutInt(int n) {
List<Integer> list = new ArrayList<>();
while(n != 0) {
list.add(n%10);
n /=10;
}
return list;
}
//配列の値を大きい順に並べ替える---------------------------------------------------------------------------------------------
public static int [] SortDesc(int []n) {
Arrays.sort(n);
int [] m = new int[n.length];
for(int i=0;i<n.length;i++) {
m[i] = n[n.length - i - 1];
}
return m;
}
//double系---------------------------------------------------------------------------------------------
//少数点のf桁までを出力（f+1桁を四捨五入)
public static void doublePrint(double n, int f) {
Integer i = Integer.valueOf(f);
String s = "%."+i.toString()+"f";
System.out.println(String.format(s, n));
}
//String系---------------------------------------------------------------------------------------------
public static String [] separateString(String s) {
String [] ss = s.split("");
for(int i = 0;i < ss.length;i++){
System.out.println(ss[i]);
}
return ss;
}
//hashmap系---------------------------------------------------------------------------------------------
//アルファベットをカウントするhashmap 小文字
public static LinkedHashMap<String,Integer> LowerABMap (LinkedHashMap<String,Integer> map) {
map.put("a", 0);
map.put("b", 0);
map.put("c", 0);
map.put("d", 0);
map.put("e", 0);
map.put("f", 0);
map.put("g", 0);
map.put("h", 0);
map.put("i", 0);
map.put("j", 0);
map.put("k", 0);
map.put("l", 0);
map.put("m", 0);
map.put("n", 0);
map.put("o", 0);
map.put("p", 0);
map.put("q", 0);
map.put("r", 0);
map.put("s", 0);
map.put("t", 0);
map.put("u", 0);
map.put("v", 0);
map.put("w", 0);
map.put("x", 0);
map.put("y", 0);
map.put("z", 0);
return map;
}
//アルファベットをカウントするhashmap 大文字
public static LinkedHashMap<String,Integer> UpperABMap (LinkedHashMap<String,Integer> map) {
map.put("A", 0);
map.put("B", 0);
map.put("C", 0);
map.put("D", 0);
map.put("E", 0);
map.put("F", 0);
map.put("G", 0);
map.put("H", 0);
map.put("I", 0);
map.put("J", 0);
map.put("K", 0);
map.put("L", 0);
map.put("M", 0);
map.put("N", 0);
map.put("O", 0);
map.put("P", 0);
map.put("Q", 0);
map.put("R", 0);
map.put("S", 0);
map.put("T", 0);
map.put("U", 0);
map.put("V", 0);
map.put("W", 0);
map.put("X", 0);
map.put("Y", 0);
map.put("Z", 0);
return map;
}
}
//ここまでコピーするーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー | ConDefects/ConDefects/Code/abc332_a/Java/53973085 |
condefects-java_data_1919 | import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), s = sc.nextInt(), k = sc.nextInt(), total = 0;
for(int i=0; i<n; i++) total += sc.nextInt() * sc.nextInt();
System.out.print(total > s ? total : total + k);
}
}
import java.util.Scanner;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), s = sc.nextInt(), k = sc.nextInt(), total = 0;
for(int i=0; i<n; i++) total += sc.nextInt() * sc.nextInt();
System.out.print(total < s ? total + k : total);
}
} | ConDefects/ConDefects/Code/abc332_a/Java/54900683 |
condefects-java_data_1920 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int kijun = sc.nextInt();
int souryou = sc.nextInt();
int sum = 0;
for(int i= 0;i<num;i++) {
int price = sc.nextInt();
int kosuu = sc.nextInt();
sum += price * kosuu;
}
if(kijun <= sum) {
sum += souryou;
}
System.out.println(sum);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int kijun = sc.nextInt();
int souryou = sc.nextInt();
int sum = 0;
for(int i= 0;i<num;i++) {
int price = sc.nextInt();
int kosuu = sc.nextInt();
sum += price * kosuu;
}
if(sum < kijun) {
sum += souryou;
}
System.out.println(sum);
}
}
| ConDefects/ConDefects/Code/abc332_a/Java/52502304 |
condefects-java_data_1921 | 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[] a = in.nextLongArray(n);
long[] b = new long[n];
Arrays.setAll(b, i -> 2 * a[n - 1] - a[n - 1 - i]);
out.println(Math.max(f(a), f(b)));
}
long f(long[] a) {
int n = a.length;
long d = a[n - 1] - a[0];
long[] b = new long[n - 1];
for (int i = 1; i < n; i++) {
b[i - 1] = (a[i] - a[i - 1]) * 2;
}
long gcd = b[0];
for (int i = 1; i < n - 1; i++) {
gcd = gcd(gcd, b[i]);
}
long ans = a[0] % gcd;
return d + ans;
}
long gcd(long a, long b) {
return 0 < b ? gcd(b, a % b) : a;
}
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.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[] a = in.nextLongArray(n);
long[] b = new long[n];
Arrays.setAll(b, i -> 2 * a[n - 1] - a[n - 1 - i]);
out.println(Math.min(f(a), f(b)));
}
long f(long[] a) {
int n = a.length;
long d = a[n - 1] - a[0];
long[] b = new long[n - 1];
for (int i = 1; i < n; i++) {
b[i - 1] = (a[i] - a[i - 1]) * 2;
}
long gcd = b[0];
for (int i = 1; i < n - 1; i++) {
gcd = gcd(gcd, b[i]);
}
long ans = a[0] % gcd;
return d + ans;
}
long gcd(long a, long b) {
return 0 < b ? gcd(b, a % b) : a;
}
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/arc152_c/Java/38097831 |
condefects-java_data_1922 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import javax.management.RuntimeErrorException;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int[] A = in.it(N);
Object solve(){
int L = A[N -1] -A[0];
long gcd = 0;
for (var a:A) {
int tmp = A[N -1] -(2 *a -A[0]);
tmp += L;
gcd = gcd(gcd,tmp);
gcd = gcd(gcd,3 *L -tmp);
}
long ans = A[N -1] %gcd;
if (ans < L)
ans += L;
return ans;
}
long gcd(long a,long b){ return b == 0 ? a : gcd(b,a %b); }
}
abstract class Seg<V, F> {
protected int n;
private V e;
private V[] val;
private F[] lazy;
private int[] rg;
private int[] stk = new int[100];
@SuppressWarnings("unchecked")
Seg(int n,V e,IntFunction<V> sup){
this.n = n;
this.e = e;
val = (V[]) new Object[n <<1];
lazy = (F[]) new Object[n];
rg = new int[n <<1];
for (int i = n <<1;--i > 0;)
rg[i] = i < n ? rg[i <<1] : 1;
build(sup);
}
void build(IntFunction<V> sup){
for (int i = 0;i < n;i++) {
val[i] = e;
val[i +n] = sup.apply(i);
}
}
V agg(V v0,V v1){ throw new UnsupportedOperationException("agg"); }
V map(V v,F f){ throw new UnsupportedOperationException("map"); }
F comp(F f0,F f1){ throw new UnsupportedOperationException("comp"); }
F powF(F f,int rg){ throw new UnsupportedOperationException("powF"); }
void merge(int i){ val[i] = agg(eval(i <<1),eval(i <<1 |1)); }
void up(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
while (l != r)
if (l > r)
merge(l >>= 1);
else
merge(r >>= 1);
while (1 < l)
merge(l >>= 1);
}
private void comp(int i,F f){
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i],f) : f;
else
val[i] = map(val[i],f);
}
private V eval(int i){
if (i < n && lazy[i] != null) {
val[i] = map(val[i],powF(lazy[i],rg[i]));
comp(i <<1,lazy[i]);
comp(i <<1 |1,lazy[i]);
lazy[i] = null;
}
return val[i];
}
protected void down(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
int s = 0;
while (0 < r) {
while (l > r) {
stk[++s] = l;
l >>= 1;
}
stk[++s] = r;
if (l == r)
l >>= 1;
r >>= 1;
}
while (0 < s)
eval(stk[--s]);
}
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
l += n;
r += n;
do {
if ((l &1) == 1)
comp(l++,f);
if ((r &1) == 1)
comp(--r,f);
} while ((l >>= 1) < (r >>= 1));
}
V get(int i){ return eval(i +n); }
V get(int l,int r){
l += n;
r += n;
V vl = e;
V vr = e;
while (l < r) {
if ((l &1) == 1)
vl = agg(vl,eval(l++));
if ((r &1) == 1)
vr = agg(eval(--r),vr);
l >>= 1;
r >>= 1;
}
return agg(vl,vr);
}
}
class DualSegmentTree<V, F> extends Seg<V, F>{
DualSegmentTree(int n,V e){ this(n,e,i -> e); }
DualSegmentTree(int n,V e,IntFunction<V> sup){ super(n,e,sup); }
@Override
F powF(F f,int rg){ return f; }
@Override
protected void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
V get(int i){
down(i,i +1);
return super.get(i);
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
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.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import javax.management.RuntimeErrorException;
class Solver{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
void reset(){ st = System.currentTimeMillis(); }
static int infI = (int) 1e9;
static long infL = (long) 1e18;
// static long mod = (int) 1e9 +7;
static long mod = 998244353;
static String yes = "Yes";
static String no = "No";
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
void println(Object obj){ super.println(obj == null ? "null" : obj); };
@Override
protected void ln(){
super.ln();
flush();
};
};
int N = in.it();
int[] A = in.it(N);
Object solve(){
int L = A[N -1] -A[0];
long gcd = 0;
for (var a:A) {
int tmp = A[N -1] -(2 *a -A[0]);
gcd = gcd(gcd,tmp);
}
long ans = A[N -1] %gcd;
if (ans < L)
ans += L;
return ans;
}
long gcd(long a,long b){ return b == 0 ? a : gcd(b,a %b); }
}
abstract class Seg<V, F> {
protected int n;
private V e;
private V[] val;
private F[] lazy;
private int[] rg;
private int[] stk = new int[100];
@SuppressWarnings("unchecked")
Seg(int n,V e,IntFunction<V> sup){
this.n = n;
this.e = e;
val = (V[]) new Object[n <<1];
lazy = (F[]) new Object[n];
rg = new int[n <<1];
for (int i = n <<1;--i > 0;)
rg[i] = i < n ? rg[i <<1] : 1;
build(sup);
}
void build(IntFunction<V> sup){
for (int i = 0;i < n;i++) {
val[i] = e;
val[i +n] = sup.apply(i);
}
}
V agg(V v0,V v1){ throw new UnsupportedOperationException("agg"); }
V map(V v,F f){ throw new UnsupportedOperationException("map"); }
F comp(F f0,F f1){ throw new UnsupportedOperationException("comp"); }
F powF(F f,int rg){ throw new UnsupportedOperationException("powF"); }
void merge(int i){ val[i] = agg(eval(i <<1),eval(i <<1 |1)); }
void up(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
while (l != r)
if (l > r)
merge(l >>= 1);
else
merge(r >>= 1);
while (1 < l)
merge(l >>= 1);
}
private void comp(int i,F f){
if (i < n)
lazy[i] = lazy[i] != null ? comp(lazy[i],f) : f;
else
val[i] = map(val[i],f);
}
private V eval(int i){
if (i < n && lazy[i] != null) {
val[i] = map(val[i],powF(lazy[i],rg[i]));
comp(i <<1,lazy[i]);
comp(i <<1 |1,lazy[i]);
lazy[i] = null;
}
return val[i];
}
protected void down(int l,int r){
l += n;
r += n;
l /= l &-l;
r /= r &-r;
int s = 0;
while (0 < r) {
while (l > r) {
stk[++s] = l;
l >>= 1;
}
stk[++s] = r;
if (l == r)
l >>= 1;
r >>= 1;
}
while (0 < s)
eval(stk[--s]);
}
void upd(int i,F f){ upd(i,i +1,f); }
void upd(int l,int r,F f){
l += n;
r += n;
do {
if ((l &1) == 1)
comp(l++,f);
if ((r &1) == 1)
comp(--r,f);
} while ((l >>= 1) < (r >>= 1));
}
V get(int i){ return eval(i +n); }
V get(int l,int r){
l += n;
r += n;
V vl = e;
V vr = e;
while (l < r) {
if ((l &1) == 1)
vl = agg(vl,eval(l++));
if ((r &1) == 1)
vr = agg(eval(--r),vr);
l >>= 1;
r >>= 1;
}
return agg(vl,vr);
}
}
class DualSegmentTree<V, F> extends Seg<V, F>{
DualSegmentTree(int n,V e){ this(n,e,i -> e); }
DualSegmentTree(int n,V e,IntFunction<V> sup){ super(n,e,sup); }
@Override
F powF(F f,int rg){ return f; }
@Override
protected void upd(int l,int r,F f){
down(l,r);
super.upd(l,r,f);
}
@Override
V get(int i){
down(i,i +1);
return super.get(i);
}
}
class Util{
static int[] arrI(int N,IntUnaryOperator f){
int[] ret = new int[N];
setAll(ret,f);
return ret;
}
static long[] arrL(int N,IntToLongFunction f){
long[] ret = new long[N];
setAll(ret,f);
return ret;
}
static double[] arrD(int N,IntToDoubleFunction f){
double[] ret = new double[N];
setAll(ret,f);
return ret;
}
static <T> T[] arr(T[] arr,IntFunction<T> f){
setAll(arr,f);
return arr;
}
}
class MyReader{
byte[] buf = new byte[1 <<16];
int ptr = 0;
int tail = 0;
InputStream in;
MyReader(InputStream in){ this.in = in; }
byte read(){
if (ptr == tail)
try {
tail = in.read(buf);
ptr = 0;
} catch (IOException e) {}
return buf[ptr++];
}
boolean isPrintable(byte c){ return 32 < c && c < 127; }
boolean isNum(byte c){ return 47 < c && c < 58; }
byte nextPrintable(){
byte ret = read();
while (!isPrintable(ret))
ret = read();
return ret;
}
int it(){ return toIntExact(lg()); }
int[] it(int N){ return Util.arrI(N,i -> it()); }
int[][] it(int H,int W){ return Util.arr(new int[H][],i -> it(W)); }
int idx(){ return it() -1; }
int[] idx(int N){ return Util.arrI(N,i -> idx()); }
int[][] idx(int H,int W){ return Util.arr(new int[H][],i -> idx(W)); }
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/arc152_c/Java/44123444 |
condefects-java_data_1923 | import java.io.*;
import java.math.*;
import java.time.*;
import java.util.*;
import java.util.Map.Entry;
class Main implements Runnable {
public static void solve () {
//同じ要素=良い線を構成できるということ
int n = nextInt();
int[] a = nextIntArray(n);
long all = 0;
for (int i=1; i<=n; i++) {
all += 1L * (n+1-i) * (i/2);
}
//allから良い線を引いてみる
//ある良い線があることによって、何個の部分文字列で「交換する回数が1回減ったか」を考える
long good = 0;
List<List<Integer>> list = new ArrayList<>();
for (int i=0; i<=n; i++) list.add(new ArrayList<>());
for (int i=0; i<n; i++) list.get(a[i]).add(i);
for (int i=0; i<=n; i++) {
int iSize = list.get(i).size();
if (iSize == 0) continue;
int l = 0, r = iSize - 1;
while (l < r) {
if (list.get(i).get(l) < n+1-list.get(i).get(r)) {
good += 1L * (r-l) * list.get(i).get(l);
l += 1;
}
else {
good += 1L * (r-l) * (n+1-list.get(i).get(r));
r -= 1;
}
}
}
println(all - good);
}
public static long nCr (long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
/*
* ############################################################################################
* # useful fields, useful methods, useful class
* ##############################################################################################
*/
// fields
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
// public static int[] dy = {-1, 0, -1, 1, 0, 1};
// public static int[] dx = {-1, -1, 0, 0, 1, 1};
// public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
// public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
// methods
public static int min (int... a) {Arrays.sort(a); return a[0];}
public static int max (int... a) {Arrays.sort(a); return a[a.length-1];}
public static long min (long... a) {Arrays.sort(a); return a[0];}
public static long max (long... a) {Arrays.sort(a); return a[a.length-1];}
public static long pow (long c, long b) {
long res = 1;
for (int i=0; i<b; i++) {
res *= c;
}
return res;
}
// class
public static class Edge implements Comparable<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;
}
@Override public int compareTo (Edge e) {
return this.cost - e.cost;
}
}
public static class Point implements Comparable<Point> {
int x, y;
Point (int x, int y) {
this.x = x;
this.y = y;
}
@Override public int compareTo (Point p) {
return this.y - p.y;
}
}
/*
* ##############################################################################################
* # input
* ##############################################################################################
*/
// input - fields
public static final InputStream in = System.in;
public static final byte[] buffer = new byte[1024];
public static int ptr = 0;
public static int bufferLength = 0;
// input - basic methods
public static boolean hasNextByte() {
if (ptr < bufferLength) {
return true;
}
else {
ptr = 0;
try {
bufferLength = in.read(buffer);
}
catch (IOException e) {
e.printStackTrace();
}
if (bufferLength <= 0) {
return false;
}
}
return true;
}
public static int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
public static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public static void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public static boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
// input - single
public static 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 static int nextInt() {
return (int) nextLong();
}
public static 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 static double nextDouble() {
return Double.parseDouble(next());
}
// input - array
public static String[] nextStringArray(int n) {
String[] array = new String[n];
for (int i = 0; i < n; i++) array[i] = next();
return array;
}
public static int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) array[i] = nextInt();
return array;
}
public static long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) array[i] = nextLong();
return array;
}
public static double[] nextDoubleArray(int n) {
double[] array = new double[n];
for (int i = 0; i < n; i++) {
array[i] = nextDouble();
}
return array;
}
// input - table
public static char[][] nextCharTable(int h, int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) array[i] = next().toCharArray();
return array;
}
public static int[][] nextIntTable(int h, int w) {
int[][] a = new int[h][];
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++) a[i][j] = nextInt();
}
return a;
}
/*
* ##############################################################################################
* # output
* ##############################################################################################
*/
// output - fields
static PrintWriter out = new PrintWriter(System.out);
//output - single
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
//output - array
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++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
/*
* ##############################################################################################
* # main
* ##############################################################################################
*/
public static void main(String[] args) {
new Thread(null, new Main(), "", 64 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
}
import java.io.*;
import java.math.*;
import java.time.*;
import java.util.*;
import java.util.Map.Entry;
class Main implements Runnable {
public static void solve () {
//同じ要素=良い線を構成できるということ
int n = nextInt();
int[] a = nextIntArray(n);
long all = 0;
for (int i=1; i<=n; i++) {
all += 1L * (n+1-i) * (i/2);
}
//allから良い線を引いてみる
//ある良い線があることによって、何個の部分文字列で「交換する回数が1回減ったか」を考える
long good = 0;
List<List<Integer>> list = new ArrayList<>();
for (int i=0; i<=n; i++) list.add(new ArrayList<>());
for (int i=1; i<=n; i++) list.get(a[i-1]).add(i);
for (int i=0; i<=n; i++) {
int iSize = list.get(i).size();
if (iSize == 0) continue;
int l = 0, r = iSize - 1;
while (l < r) {
if (list.get(i).get(l) < n+1-list.get(i).get(r)) {
good += 1L * (r-l) * list.get(i).get(l);
l += 1;
}
else {
good += 1L * (r-l) * (n+1-list.get(i).get(r));
r -= 1;
}
}
}
println(all - good);
}
public static long nCr (long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
/*
* ############################################################################################
* # useful fields, useful methods, useful class
* ##############################################################################################
*/
// fields
public static final int infi = (int)1e9;
public static final long infl = (long)1e18;
public static final int modi = (int)1e9 + 7;
public static final long modl = (long)1e18 + 7;
public static int[] dy = {-1, 0, 1, 0};
public static int[] dx = {0, 1, 0, -1};
// public static int[] dy = {-1, 0, -1, 1, 0, 1};
// public static int[] dx = {-1, -1, 0, 0, 1, 1};
// public static int[] dy = {-1, -1, -1, 0, 1, 1, 1, 0};
// public static int[] dx = {-1, 0, 1, 1, 1, 0, -1, -1};
// methods
public static int min (int... a) {Arrays.sort(a); return a[0];}
public static int max (int... a) {Arrays.sort(a); return a[a.length-1];}
public static long min (long... a) {Arrays.sort(a); return a[0];}
public static long max (long... a) {Arrays.sort(a); return a[a.length-1];}
public static long pow (long c, long b) {
long res = 1;
for (int i=0; i<b; i++) {
res *= c;
}
return res;
}
// class
public static class Edge implements Comparable<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;
}
@Override public int compareTo (Edge e) {
return this.cost - e.cost;
}
}
public static class Point implements Comparable<Point> {
int x, y;
Point (int x, int y) {
this.x = x;
this.y = y;
}
@Override public int compareTo (Point p) {
return this.y - p.y;
}
}
/*
* ##############################################################################################
* # input
* ##############################################################################################
*/
// input - fields
public static final InputStream in = System.in;
public static final byte[] buffer = new byte[1024];
public static int ptr = 0;
public static int bufferLength = 0;
// input - basic methods
public static boolean hasNextByte() {
if (ptr < bufferLength) {
return true;
}
else {
ptr = 0;
try {
bufferLength = in.read(buffer);
}
catch (IOException e) {
e.printStackTrace();
}
if (bufferLength <= 0) {
return false;
}
}
return true;
}
public static int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
public static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public static void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public static boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
// input - single
public static 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 static int nextInt() {
return (int) nextLong();
}
public static 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 static double nextDouble() {
return Double.parseDouble(next());
}
// input - array
public static String[] nextStringArray(int n) {
String[] array = new String[n];
for (int i = 0; i < n; i++) array[i] = next();
return array;
}
public static int[] nextIntArray(int n) {
int[] array = new int[n];
for (int i = 0; i < n; i++) array[i] = nextInt();
return array;
}
public static long[] nextLongArray(int n) {
long[] array = new long[n];
for (int i = 0; i < n; i++) array[i] = nextLong();
return array;
}
public static double[] nextDoubleArray(int n) {
double[] array = new double[n];
for (int i = 0; i < n; i++) {
array[i] = nextDouble();
}
return array;
}
// input - table
public static char[][] nextCharTable(int h, int w) {
char[][] array = new char[h][w];
for (int i = 0; i < h; i++) array[i] = next().toCharArray();
return array;
}
public static int[][] nextIntTable(int h, int w) {
int[][] a = new int[h][];
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++) a[i][j] = nextInt();
}
return a;
}
/*
* ##############################################################################################
* # output
* ##############################################################################################
*/
// output - fields
static PrintWriter out = new PrintWriter(System.out);
//output - single
public static void print(Object o) {out.print(o);}
public static void println(Object o) {out.println(o);}
//output - array
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++) {
if (j != 0) print(" ");
print(a[i][j]);
}
println("");
}
}
/*
* ##############################################################################################
* # main
* ##############################################################################################
*/
public static void main(String[] args) {
new Thread(null, new Main(), "", 64 * 1024 * 1024).start();
}
public void run() {
solve();
out.close();
}
} | ConDefects/ConDefects/Code/abc290_e/Java/40101713 |
condefects-java_data_1924 | import java.io.*;
import java.util.*;
class FastScaner {
InputStream in;
FastScaner(InputStream in) {
this.in = in;
}
char nextChar() {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n');
return ch;
} catch(IOException e) {
throw new IllegalStateException(e);
}
}
int nextInt() {
return (int) nextLong();
}
long nextLong() {
try {
long result = 0;
int flag = 1;
int ch;
do {
ch = in.read();
if(ch=='-') {
flag = -1;
}
} while(!Character.isDigit(ch));
do {
result *= 10;
result += ch - '0';
ch = in.read();
} while(Character.isDigit(ch));
return result * flag;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
char[] nextCharArray(int start, int end) {
char[] result = new char[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextChar();
}
return result;
}
int[] nextIntArray(int start, int end) {
int[] result = new int[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextInt();
}
return result;
}
long[] nextLongArray(int start, int end) {
long[] result = new long[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextLong();
}
return result;
}
char[][] nextCharMatrix(int s1, int e1, int s2, int e2) {
char[][] result = new char[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextChar();
}
}
return result;
}
int[][] nextIntMatrix(int s1, int e1, int s2, int e2) {
int[][] result = new int[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextInt();
}
}
return result;
}
long[][] nextLongMatrix(int s1, int e1, int s2, int e2) {
long[][] result = new long[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextLong();
}
}
return result;
}
String next() {
return next(' ');
}
String nextLine() {
return next((char)-1);
}
String next(char a) {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n' || ch==a);
StringBuilder buf = new StringBuilder();
do {
buf.append(ch);
ch = (char)in.read();
} while(ch != '\r' && ch != '\n' && ch != a);
return buf.toString();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
class FastWriter {
public static final String LINE_SEPARATOR = System.getProperty("line.separator");
PrintStream out;
StringBuilder buf;
FastWriter(PrintStream out) {
this.out = out;
this.buf = new StringBuilder();
}
FastWriter pr(char ch) {
buf.append(ch);
return this;
}
FastWriter pr(int o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(long o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(double o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Object o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Iterable<?> o) {
for(var e : o) {
buf.append(e);
buf.append(' ');
}
return this;
}
FastWriter ln() {
int l = buf.length();
if(l >= 1) {
if(buf.charAt(l-1)==' ') {
buf.deleteCharAt(l-1);
}
}
buf.append(LINE_SEPARATOR);
return this;
}
void flush() {
System.out.print(buf);
}
}
public class Main {
static FastScaner in = new FastScaner(System.in);
static FastWriter out = new FastWriter(System.out);
static FastWriter tr = new FastWriter(System.err);
void solve() {
int N = in.nextInt();
int[] A = in.nextIntArray(1, N);
long same = 0;
Map<Integer,Long> sum = new HashMap<Integer,Long>(N);
for(int i=1; i<=(N+1)/2; i++) {
int d = i; //Math.min(i, N-i+1);
same += sum.getOrDefault(A[i], 0L);
sum.put(A[i], sum.getOrDefault(A[i], 0L) + d);
if(N%2==1 && i==(N+1)/2) {
break;
}
int ri = N-i+1;
same += sum.getOrDefault(A[ri], 0L);
sum.put(A[ri], sum.getOrDefault(A[ri], 0L) + d);
}
long all = 0;
for(int i=1; i<N; i++) {
all += (long)(N-i) * ((i+1) / 2);
}
tr.pr(all).pr(same).ln();
out.pr(all-same).ln();
}
public static void main(String[] args) {
try {
new Main().solve();
} finally {
out.flush();
tr.flush();
}
}
}
import java.io.*;
import java.util.*;
class FastScaner {
InputStream in;
FastScaner(InputStream in) {
this.in = in;
}
char nextChar() {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n');
return ch;
} catch(IOException e) {
throw new IllegalStateException(e);
}
}
int nextInt() {
return (int) nextLong();
}
long nextLong() {
try {
long result = 0;
int flag = 1;
int ch;
do {
ch = in.read();
if(ch=='-') {
flag = -1;
}
} while(!Character.isDigit(ch));
do {
result *= 10;
result += ch - '0';
ch = in.read();
} while(Character.isDigit(ch));
return result * flag;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
char[] nextCharArray(int start, int end) {
char[] result = new char[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextChar();
}
return result;
}
int[] nextIntArray(int start, int end) {
int[] result = new int[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextInt();
}
return result;
}
long[] nextLongArray(int start, int end) {
long[] result = new long[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextLong();
}
return result;
}
char[][] nextCharMatrix(int s1, int e1, int s2, int e2) {
char[][] result = new char[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextChar();
}
}
return result;
}
int[][] nextIntMatrix(int s1, int e1, int s2, int e2) {
int[][] result = new int[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextInt();
}
}
return result;
}
long[][] nextLongMatrix(int s1, int e1, int s2, int e2) {
long[][] result = new long[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextLong();
}
}
return result;
}
String next() {
return next(' ');
}
String nextLine() {
return next((char)-1);
}
String next(char a) {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n' || ch==a);
StringBuilder buf = new StringBuilder();
do {
buf.append(ch);
ch = (char)in.read();
} while(ch != '\r' && ch != '\n' && ch != a);
return buf.toString();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
class FastWriter {
public static final String LINE_SEPARATOR = System.getProperty("line.separator");
PrintStream out;
StringBuilder buf;
FastWriter(PrintStream out) {
this.out = out;
this.buf = new StringBuilder();
}
FastWriter pr(char ch) {
buf.append(ch);
return this;
}
FastWriter pr(int o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(long o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(double o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Object o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Iterable<?> o) {
for(var e : o) {
buf.append(e);
buf.append(' ');
}
return this;
}
FastWriter ln() {
int l = buf.length();
if(l >= 1) {
if(buf.charAt(l-1)==' ') {
buf.deleteCharAt(l-1);
}
}
buf.append(LINE_SEPARATOR);
return this;
}
void flush() {
out.print(buf);
}
}
public class Main {
static FastScaner in = new FastScaner(System.in);
static FastWriter out = new FastWriter(System.out);
static FastWriter tr = new FastWriter(System.err);
void solve() {
int N = in.nextInt();
int[] A = in.nextIntArray(1, N);
long same = 0;
Map<Integer,Long> sum = new HashMap<Integer,Long>(N);
for(int i=1; i<=(N+1)/2; i++) {
int d = i; //Math.min(i, N-i+1);
same += sum.getOrDefault(A[i], 0L);
sum.put(A[i], sum.getOrDefault(A[i], 0L) + d);
if(N%2==1 && i==(N+1)/2) {
break;
}
int ri = N-i+1;
same += sum.getOrDefault(A[ri], 0L);
sum.put(A[ri], sum.getOrDefault(A[ri], 0L) + d);
}
long all = 0;
for(int i=1; i<N; i++) {
all += (long)(N-i) * ((i+1) / 2);
}
tr.pr(all).pr(same).ln();
out.pr(all-same).ln();
}
public static void main(String[] args) {
try {
new Main().solve();
} finally {
out.flush();
tr.flush();
}
}
}
| ConDefects/ConDefects/Code/abc290_e/Java/41290929 |
condefects-java_data_1925 | import java.io.*;
import java.util.*;
class FastScaner {
InputStream in;
FastScaner() {
this.in = System.in;
}
char nextChar() {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n');
return ch;
} catch(IOException e) {
throw new IllegalStateException(e);
}
}
int nextInt() {
return (int) nextLong();
}
long nextLong() {
try {
long result = 0;
int flag = 1;
int ch;
do {
ch = in.read();
if(ch=='-') {
flag = -1;
}
} while(!Character.isDigit(ch));
do {
result *= 10;
result += ch - '0';
ch = in.read();
} while(Character.isDigit(ch));
return result * flag;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
char[] nextCharArray(int start, int end) {
char[] result = new char[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextChar();
}
return result;
}
int[] nextIntArray(int start, int end) {
int[] result = new int[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextInt();
}
return result;
}
long[] nextLongArray(int start, int end) {
long[] result = new long[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextLong();
}
return result;
}
char[][] nextCharMatrix(int s1, int e1, int s2, int e2) {
char[][] result = new char[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextChar();
}
}
return result;
}
int[][] nextIntMatrix(int s1, int e1, int s2, int e2) {
int[][] result = new int[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextInt();
}
}
return result;
}
long[][] nextLongMatrix(int s1, int e1, int s2, int e2) {
long[][] result = new long[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextLong();
}
}
return result;
}
String next() {
return next(' ');
}
String nextLine() {
return next((char)-1);
}
String next(char a) {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n' || ch==a);
StringBuilder buf = new StringBuilder();
do {
buf.append(ch);
ch = (char)in.read();
} while(ch != '\r' && ch != '\n' && ch != a);
return buf.toString();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
class FastWriter {
public static final String LINE_SEPARATOR = System.getProperty("line.separator");
PrintStream out;
StringBuilder buf;
FastWriter() {
this.out = System.out;
this.buf = new StringBuilder();
}
FastWriter pr(char ch) {
buf.append(ch);
return this;
}
FastWriter pr(int o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(long o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(double o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Object o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Iterable<?> o) {
for(var e : o) {
buf.append(e);
buf.append(' ');
}
return this;
}
FastWriter ln() {
int l = buf.length();
if(l >= 1) {
if(buf.charAt(l-1)==' ') {
buf.deleteCharAt(l-1);
}
}
buf.append(LINE_SEPARATOR);
return this;
}
void flush() {
System.out.print(buf);
}
}
public class Main {
static FastScaner in = new FastScaner();
static FastWriter out = new FastWriter();
void solve() {
int N = in.nextInt();
int[] A = in.nextIntArray(1, N);
long same = 0;
Map<Integer,Long> sum = new HashMap<Integer,Long>(N);
for(int i=1; i<=(N+1)/2; i++) {
int ri = N-i+1;
int d = i; //Math.min(i, N-i+1);
same += sum.getOrDefault(A[i], 0L);
sum.put(A[i], sum.getOrDefault(A[i], 0L) + d);
if(N%2==1 && i==(N+1)/2) {
break;
}
same += sum.getOrDefault(A[ri], 0L);
sum.put(A[ri], sum.getOrDefault(A[ri], 0L) + d);
}
long all = 0;
for(int i=1; i<N; i++) {
all += (long)(N-i) * ((i+1) / 2);
}
out.pr(all).pr(same).ln();
out.pr(all-same).ln();
}
public static void main(String[] args) {
try {
new Main().solve();
} finally {
out.flush();
}
}
}
import java.io.*;
import java.util.*;
class FastScaner {
InputStream in;
FastScaner() {
this.in = System.in;
}
char nextChar() {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n');
return ch;
} catch(IOException e) {
throw new IllegalStateException(e);
}
}
int nextInt() {
return (int) nextLong();
}
long nextLong() {
try {
long result = 0;
int flag = 1;
int ch;
do {
ch = in.read();
if(ch=='-') {
flag = -1;
}
} while(!Character.isDigit(ch));
do {
result *= 10;
result += ch - '0';
ch = in.read();
} while(Character.isDigit(ch));
return result * flag;
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
char[] nextCharArray(int start, int end) {
char[] result = new char[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextChar();
}
return result;
}
int[] nextIntArray(int start, int end) {
int[] result = new int[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextInt();
}
return result;
}
long[] nextLongArray(int start, int end) {
long[] result = new long[end+1];
for(int i=start; i<=end; i++) {
result[i] = nextLong();
}
return result;
}
char[][] nextCharMatrix(int s1, int e1, int s2, int e2) {
char[][] result = new char[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextChar();
}
}
return result;
}
int[][] nextIntMatrix(int s1, int e1, int s2, int e2) {
int[][] result = new int[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextInt();
}
}
return result;
}
long[][] nextLongMatrix(int s1, int e1, int s2, int e2) {
long[][] result = new long[e1+1][e2+1];
for(int i=s1; i<=e1; i++) {
for(int j=s2; j<=e2; j++) {
result[i][j] = nextLong();
}
}
return result;
}
String next() {
return next(' ');
}
String nextLine() {
return next((char)-1);
}
String next(char a) {
try {
char ch;
do {
ch = (char)in.read();
} while(ch == '\r' || ch=='\n' || ch==a);
StringBuilder buf = new StringBuilder();
do {
buf.append(ch);
ch = (char)in.read();
} while(ch != '\r' && ch != '\n' && ch != a);
return buf.toString();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
class FastWriter {
public static final String LINE_SEPARATOR = System.getProperty("line.separator");
PrintStream out;
StringBuilder buf;
FastWriter() {
this.out = System.out;
this.buf = new StringBuilder();
}
FastWriter pr(char ch) {
buf.append(ch);
return this;
}
FastWriter pr(int o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(long o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(double o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Object o) {
buf.append(o);
buf.append(' ');
return this;
}
FastWriter pr(Iterable<?> o) {
for(var e : o) {
buf.append(e);
buf.append(' ');
}
return this;
}
FastWriter ln() {
int l = buf.length();
if(l >= 1) {
if(buf.charAt(l-1)==' ') {
buf.deleteCharAt(l-1);
}
}
buf.append(LINE_SEPARATOR);
return this;
}
void flush() {
System.out.print(buf);
}
}
public class Main {
static FastScaner in = new FastScaner();
static FastWriter out = new FastWriter();
void solve() {
int N = in.nextInt();
int[] A = in.nextIntArray(1, N);
long same = 0;
Map<Integer,Long> sum = new HashMap<Integer,Long>(N);
for(int i=1; i<=(N+1)/2; i++) {
int ri = N-i+1;
int d = i; //Math.min(i, N-i+1);
same += sum.getOrDefault(A[i], 0L);
sum.put(A[i], sum.getOrDefault(A[i], 0L) + d);
if(N%2==1 && i==(N+1)/2) {
break;
}
same += sum.getOrDefault(A[ri], 0L);
sum.put(A[ri], sum.getOrDefault(A[ri], 0L) + d);
}
long all = 0;
for(int i=1; i<N; i++) {
all += (long)(N-i) * ((i+1) / 2);
}
//out.pr(all).pr(same).ln();
out.pr(all-same).ln();
}
public static void main(String[] args) {
try {
new Main().solve();
} finally {
out.flush();
}
}
}
| ConDefects/ConDefects/Code/abc290_e/Java/41289433 |
condefects-java_data_1926 | //package EveryDayProblem_0x3f;
import java.util.*;
public class Main {
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
int n = scanner.nextInt();
int[] a = new int[n];
List<Integer>[] cord = new List[n + 1];
for (int i = 0; i <= n; i++) {
cord[i] = new ArrayList<>();
}
for (int i = 0; i < n; i++) {
a[i] = scanner.nextInt();
if (i < n / 2) {
cord[a[i]].add(i);
}else {
cord[a[i]].add(n - 1 - i);
}
}
//先计算没有一个一样的值
long res = 0;
for (int len = 2; len <= n; len++) {
res = res + (len / 2) * 1l * (n - len + 1);
}
//System.out.println("res = " + res);
for (int i = 0; i <= n; i++) {
//System.out.println(cord[i]);
//每一对相同的贡献了多少相同
List<Integer> list = cord[i];
Collections.sort(list);
int ans = 0;
for (int j = 0; j < list.size(); j++) {
res -= ans;
ans += list.get(j) + 1;
}
}
System.out.println(res);
}
}
//package EveryDayProblem_0x3f;
import java.util.*;
public class Main {
private static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
int n = scanner.nextInt();
int[] a = new int[n];
List<Integer>[] cord = new List[n + 1];
for (int i = 0; i <= n; i++) {
cord[i] = new ArrayList<>();
}
for (int i = 0; i < n; i++) {
a[i] = scanner.nextInt();
if (i < n / 2) {
cord[a[i]].add(i);
}else {
cord[a[i]].add(n - 1 - i);
}
}
//先计算没有一个一样的值
long res = 0;
for (int len = 2; len <= n; len++) {
res = res + (len / 2) * 1l * (n - len + 1);
}
//System.out.println("res = " + res);
for (int i = 0; i <= n; i++) {
//System.out.println(cord[i]);
//每一对相同的贡献了多少相同
List<Integer> list = cord[i];
Collections.sort(list);
long ans = 0;
for (int j = 0; j < list.size(); j++) {
res -= ans;
ans += list.get(j) + 1;
}
}
System.out.println(res);
}
}
| ConDefects/ConDefects/Code/abc290_e/Java/44631791 |
condefects-java_data_1927 | import java.util.*;
import java.io.*;
import java.math.*;
class Solver {
void solve(FScanner sc, FWriter out) {
long n = sc.nextLong(), a = sc.nextLong(), b = sc.nextLong();
BigInteger bn = BigInteger.valueOf(n), ba = BigInteger.valueOf(a), bb = BigInteger.valueOf(b);
BigInteger bab = ba.multiply(bb);
BigInteger total = MathLib.arithmeticProgression2(1, n, n);
BigInteger fizz = MathLib.arithmeticProgression(ba, bn.divide(ba), ba);
BigInteger buzz = MathLib.arithmeticProgression(bb, bn.divide(bb), bb);
BigInteger fizzbuzz = MathLib.arithmeticProgression(bab, bn.divide(bab), bab);
out.println(total.subtract(fizz).subtract(buzz).add(fizzbuzz));
}
}
class XY {
long x;
long y;
XY(long x, long y) {
this.x = x;
this.y = y;
}
double slope(XY b) {
var dx = b.x - x;
if (dx == 0) {
if (b.y == y) {
return 0;
} else if (b.y - y > 0) {
return Double.POSITIVE_INFINITY;
}
return Double.NEGATIVE_INFINITY;
}
return (1.0 * (b.y - y)) / dx;
}
double rad(XY b) {
return Math.atan2(b.y - y, b.x - x);
}
double deg(XY b) {
return MathLib.radToDeg(rad(b));
}
@Override
public String toString() {
return "XY [x=" + x + ", y=" + y + "]";
}
}
class MathLib {
public static long gcd(long a, long b) {
long c = b;
b = a;
do {
a = b;
b = c;
if (a < b) {
long tmp = a;
a = b;
b = tmp;
}
if(b == 0) return a;
c = a % b;
} while (c != 0);
return b;
}
public static long lcm(long m, long n) {
return m * n / gcd(m, n);
}
public static BigInteger gcd(BigInteger a, BigInteger b) {
return a.gcd(b);
}
public static BigInteger lcm(BigInteger m, BigInteger n) {
return m.multiply(n).divide(gcd(m, n));
}
public static long sign(long x) {
if (x == 0)
return 0;
if (x < 0)
return -1;
return 1;
}
public static long sign(double x) {
if (x > -0.00001 && x < 0.00001)
return 0;
if (x < 0)
return -1;
return 1;
}
public static double radToDeg(double rad) {
return rad * 180 / Math.PI;
}
public static double degToRad(double deg) {
return deg / 180 * Math.PI;
}
// 等差数列の和
// 初項a, 項数n, 公差d
public static BigInteger arithmeticProgression(BigInteger a, BigInteger n, BigInteger d) {
return (BigInteger.TWO.multiply(a).add(n.subtract(BigInteger.ONE).multiply(d))).multiply(n).divide(BigInteger.TWO);
}
// 初項a, 末項l, 項数n
public static BigInteger arithmeticProgression2(long a, long l, long n) {
return (BigInteger.valueOf(a).add(BigInteger.valueOf(l))).multiply(BigInteger.valueOf(n)).divide(BigInteger.TWO);
}
}
// common
public class Main {
public static void main(String[] args) {
FScanner sc = new FScanner(System.in);
FWriter out = new FWriter(System.out);
try {
(new Solver()).solve(sc, out);
} catch (Throwable e) {
out.println(e);
out.flush();
System.exit(1);
}
out.flush();
sc.close();
}
}
class TwoKeyMap<K, V> {
Map<K, Map<K, V>> map = new HashMap<>();
Set<K> _key2Set = new HashSet<>();
TwoKeyMap<K, V> put(K key1, K key2, V value) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).put(key2, value);
return this;
}
TwoKeyMap<K, V> put(K[] key, V value) {
return put(key[0], key[1], value);
}
TwoKeyMap<K, V> merge(K key1, K key2, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).merge(key2, value, remappingFunction);
return this;
}
TwoKeyMap<K, V> merge(K[] key, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
return merge(key[0], key[1], value, remappingFunction);
}
V get(K key1, K key2) {
var m1 = map.get(key1);
if (m1 == null)
return null;
return m1.get(key2);
}
Map<K, V> get(K key1) {
return map.get(key1);
}
V get(K[] key) {
return get(key[0], key[1]);
}
V computeIfAbsent(K key1, K key2, java.util.function.Function<? super K, ? extends V> mappingFunction) {
return map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).computeIfAbsent(key2, mappingFunction);
}
boolean containsKey(K key1, K key2) {
return get(key1, key2) != null;
}
Set<K> key1Set() {
return map.keySet();
}
Set<K> key2Set() {
// 本来はインスタンス作るべきだが、競技プログラミング向けなのでパフォーマンス優先
return _key2Set;
}
}
class FScanner {
private InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FScanner(InputStream in) {
this.in = in;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
return nextSB().toString();
}
public char[] nextCharArray() {
StringBuilder sb = nextSB();
char[] c = new char[sb.length()];
for(int i = 0; i < sb.length(); i++) {
c[i] = sb.charAt(i);
}
return c;
}
public StringBuilder nextSB() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb;
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public java.math.BigDecimal nextDecimal() {
return new java.math.BigDecimal(next());
}
public java.util.stream.IntStream nextIntStream(int n) {
return java.util.stream.IntStream.range(0, n).map(i -> nextInt());
}
public java.util.stream.LongStream nextLongStream(int n) {
return java.util.stream.LongStream.range(0L, (long) n).map(i -> nextLong());
}
public java.util.stream.Stream<String> nextStream(int n) {
return java.util.stream.IntStream.range(0, n).mapToObj(i -> next());
}
public int[] nextIntArray(int arraySize) {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
}
public long[] nextLongArray(int arraySize) {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
}
public java.util.stream.Stream<int[]> nextIntArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
});
}
public java.util.stream.Stream<long[]> nextLongArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
});
}
public boolean close() {
return true;
}
}
class FWriter {
OutputStream out;
byte[] buf = new byte[1 << 16];
byte[] ibuf = new byte[20];
int tail = 0;
final byte SP = (byte) ' ', LF = (byte) '\n', HYPHEN = (byte) '-';
boolean isDebug = false;
FWriter(OutputStream out) {
this.out = out;
}
void flush() {
try {
out.write(buf, 0, tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void write(byte b) {
buf[tail++] = b;
if (tail == buf.length) {
flush();
}
}
void write(byte[] b, int off, int len) {
for (int i = off; i < off + len; i++) {
write(b[i]);
}
}
void println() {
write(LF);
}
FWriter print(char c) {
write((byte) c);
return this;
}
FWriter println(char c) {
print(c);
println();
return this;
}
FWriter print(int n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(int n) {
print(n);
println();
return this;
}
FWriter print(long n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(long n) {
print(n);
println();
return this;
}
FWriter print(String s) {
if (s != null) {
byte[] b = s.getBytes();
write(b, 0, b.length);
}
return this;
}
FWriter println(String s) {
print(s);
println();
return this;
}
FWriter print(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(int[] a) {
print(a);
println();
return this;
}
FWriter print(long[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(long[] a) {
print(a);
println();
return this;
}
FWriter print(char[] s, int from, int to) {
for (int i = from; i < to && s[i] != '\0'; i++) {
print(s[i]);
}
return this;
}
FWriter print(char[] s) {
print(s, 0, s.length);
return this;
}
FWriter println(char[] s, int from, int to) {
print(s, from, to);
println();
return this;
}
FWriter println(char[] s) {
println(s, 0, s.length);
return this;
}
FWriter print(double n, int accuracy) {
long longN = (long) n;
print(longN);
n -= (long) n;
write((byte) '.');
for (int j = 0; j < accuracy; j++) {
n *= 10;
int digit = (int) n;
write((byte) (digit + '0'));
n -= digit;
}
return this;
}
FWriter print(double n) {
print(n, 10);
return this;
}
FWriter println(double n) {
print(n);
println();
return this;
}
FWriter println(double n, int accuracy) {
print(n, accuracy);
println();
return this;
}
FWriter print(Object o) {
if (o != null) {
print(o.toString());
}
return this;
}
FWriter println(Object o) {
print(o);
println();
return this;
}
FWriter println(Throwable e) {
println(e.toString());
for (StackTraceElement el : e.getStackTrace()) {
print(" ").println(el.toString());
}
if (e.getCause() != null) {
println(e.getCause());
}
return this;
}
void enableDebug() {
this.isDebug = true;
}
private void _debug(Object o, int indent) {
if(o == null) {
for(var i = 0; i < indent; i++) print(' ');
print("null");
} else if(o.getClass().isArray()) {
for(int i = 0; i < java.lang.reflect.Array.getLength(o); i++) {
println();
_debug(java.lang.reflect.Array.get(o, i), indent + 2);
}
return;
} else if(o instanceof Collection) {
for(var item : (Collection<?>)o) {
println();
_debug(item, indent + 2);
}
} else if(o instanceof Map) {
for(var i = 0; i < indent; i++) print(' ');
println('{');
for(var entry : ((Map<?,?>)o).entrySet()) {
for(var i = 0; i < indent + 2; i++) print(' ');
_debug(entry.getKey(), 0);
_debug(" ", 0);
_debug(entry.getValue(), 0);
println();
}
for(var i = 0; i < indent; i++) print(' ');
println('}');
return;
}
for(var i = 0; i < indent; i++) print(' ');
print(o);
}
FWriter debug(Object... os) {
if(!isDebug) return this;
print("[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).print("]: ");
for(var o : os) {
_debug(o, 0);
print(' ');
}
print(" :[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).println("]");
return this;
}
}
import java.util.*;
import java.io.*;
import java.math.*;
class Solver {
void solve(FScanner sc, FWriter out) {
long n = sc.nextLong(), a = sc.nextLong(), b = sc.nextLong();
BigInteger bn = BigInteger.valueOf(n), ba = BigInteger.valueOf(a), bb = BigInteger.valueOf(b);
BigInteger bab = MathLib.lcm(ba, bb);
BigInteger total = MathLib.arithmeticProgression2(1, n, n);
BigInteger fizz = MathLib.arithmeticProgression(ba, bn.divide(ba), ba);
BigInteger buzz = MathLib.arithmeticProgression(bb, bn.divide(bb), bb);
BigInteger fizzbuzz = MathLib.arithmeticProgression(bab, bn.divide(bab), bab);
out.println(total.subtract(fizz).subtract(buzz).add(fizzbuzz));
}
}
class XY {
long x;
long y;
XY(long x, long y) {
this.x = x;
this.y = y;
}
double slope(XY b) {
var dx = b.x - x;
if (dx == 0) {
if (b.y == y) {
return 0;
} else if (b.y - y > 0) {
return Double.POSITIVE_INFINITY;
}
return Double.NEGATIVE_INFINITY;
}
return (1.0 * (b.y - y)) / dx;
}
double rad(XY b) {
return Math.atan2(b.y - y, b.x - x);
}
double deg(XY b) {
return MathLib.radToDeg(rad(b));
}
@Override
public String toString() {
return "XY [x=" + x + ", y=" + y + "]";
}
}
class MathLib {
public static long gcd(long a, long b) {
long c = b;
b = a;
do {
a = b;
b = c;
if (a < b) {
long tmp = a;
a = b;
b = tmp;
}
if(b == 0) return a;
c = a % b;
} while (c != 0);
return b;
}
public static long lcm(long m, long n) {
return m * n / gcd(m, n);
}
public static BigInteger gcd(BigInteger a, BigInteger b) {
return a.gcd(b);
}
public static BigInteger lcm(BigInteger m, BigInteger n) {
return m.multiply(n).divide(gcd(m, n));
}
public static long sign(long x) {
if (x == 0)
return 0;
if (x < 0)
return -1;
return 1;
}
public static long sign(double x) {
if (x > -0.00001 && x < 0.00001)
return 0;
if (x < 0)
return -1;
return 1;
}
public static double radToDeg(double rad) {
return rad * 180 / Math.PI;
}
public static double degToRad(double deg) {
return deg / 180 * Math.PI;
}
// 等差数列の和
// 初項a, 項数n, 公差d
public static BigInteger arithmeticProgression(BigInteger a, BigInteger n, BigInteger d) {
return (BigInteger.TWO.multiply(a).add(n.subtract(BigInteger.ONE).multiply(d))).multiply(n).divide(BigInteger.TWO);
}
// 初項a, 末項l, 項数n
public static BigInteger arithmeticProgression2(long a, long l, long n) {
return (BigInteger.valueOf(a).add(BigInteger.valueOf(l))).multiply(BigInteger.valueOf(n)).divide(BigInteger.TWO);
}
}
// common
public class Main {
public static void main(String[] args) {
FScanner sc = new FScanner(System.in);
FWriter out = new FWriter(System.out);
try {
(new Solver()).solve(sc, out);
} catch (Throwable e) {
out.println(e);
out.flush();
System.exit(1);
}
out.flush();
sc.close();
}
}
class TwoKeyMap<K, V> {
Map<K, Map<K, V>> map = new HashMap<>();
Set<K> _key2Set = new HashSet<>();
TwoKeyMap<K, V> put(K key1, K key2, V value) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).put(key2, value);
return this;
}
TwoKeyMap<K, V> put(K[] key, V value) {
return put(key[0], key[1], value);
}
TwoKeyMap<K, V> merge(K key1, K key2, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
_key2Set.add(key2);
map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).merge(key2, value, remappingFunction);
return this;
}
TwoKeyMap<K, V> merge(K[] key, V value,
java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
return merge(key[0], key[1], value, remappingFunction);
}
V get(K key1, K key2) {
var m1 = map.get(key1);
if (m1 == null)
return null;
return m1.get(key2);
}
Map<K, V> get(K key1) {
return map.get(key1);
}
V get(K[] key) {
return get(key[0], key[1]);
}
V computeIfAbsent(K key1, K key2, java.util.function.Function<? super K, ? extends V> mappingFunction) {
return map.computeIfAbsent(key1, (f) -> new HashMap<K, V>()).computeIfAbsent(key2, mappingFunction);
}
boolean containsKey(K key1, K key2) {
return get(key1, key2) != null;
}
Set<K> key1Set() {
return map.keySet();
}
Set<K> key2Set() {
// 本来はインスタンス作るべきだが、競技プログラミング向けなのでパフォーマンス優先
return _key2Set;
}
}
class FScanner {
private InputStream in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FScanner(InputStream in) {
this.in = in;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[ptr++];
else
return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr]))
ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
return nextSB().toString();
}
public char[] nextCharArray() {
StringBuilder sb = nextSB();
char[] c = new char[sb.length()];
for(int i = 0; i < sb.length(); i++) {
c[i] = sb.charAt(i);
}
return c;
}
public StringBuilder nextSB() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb;
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (b != -1 && isPrintableChar(b)) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else {
throw new NumberFormatException();
}
b = readByte();
}
return minus ? -n : n;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public java.math.BigDecimal nextDecimal() {
return new java.math.BigDecimal(next());
}
public java.util.stream.IntStream nextIntStream(int n) {
return java.util.stream.IntStream.range(0, n).map(i -> nextInt());
}
public java.util.stream.LongStream nextLongStream(int n) {
return java.util.stream.LongStream.range(0L, (long) n).map(i -> nextLong());
}
public java.util.stream.Stream<String> nextStream(int n) {
return java.util.stream.IntStream.range(0, n).mapToObj(i -> next());
}
public int[] nextIntArray(int arraySize) {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
}
public long[] nextLongArray(int arraySize) {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
}
public java.util.stream.Stream<int[]> nextIntArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
int[] ary = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextInt();
}
return ary;
});
}
public java.util.stream.Stream<long[]> nextLongArrayStream(int n, int arraySize) {
return java.util.stream.IntStream.range(0, n).mapToObj(_i -> {
long[] ary = new long[arraySize];
for (int i = 0; i < arraySize; i++) {
ary[i] = nextLong();
}
return ary;
});
}
public boolean close() {
return true;
}
}
class FWriter {
OutputStream out;
byte[] buf = new byte[1 << 16];
byte[] ibuf = new byte[20];
int tail = 0;
final byte SP = (byte) ' ', LF = (byte) '\n', HYPHEN = (byte) '-';
boolean isDebug = false;
FWriter(OutputStream out) {
this.out = out;
}
void flush() {
try {
out.write(buf, 0, tail);
tail = 0;
} catch (IOException e) {
e.printStackTrace();
}
}
void write(byte b) {
buf[tail++] = b;
if (tail == buf.length) {
flush();
}
}
void write(byte[] b, int off, int len) {
for (int i = off; i < off + len; i++) {
write(b[i]);
}
}
void println() {
write(LF);
}
FWriter print(char c) {
write((byte) c);
return this;
}
FWriter println(char c) {
print(c);
println();
return this;
}
FWriter print(int n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(int n) {
print(n);
println();
return this;
}
FWriter print(long n) {
if (n < 0) {
n = -n;
write(HYPHEN);
}
int i = ibuf.length;
do {
ibuf[--i] = (byte) (n % 10 + '0');
n /= 10;
} while (n > 0);
write(ibuf, i, ibuf.length - i);
return this;
}
FWriter println(long n) {
print(n);
println();
return this;
}
FWriter print(String s) {
if (s != null) {
byte[] b = s.getBytes();
write(b, 0, b.length);
}
return this;
}
FWriter println(String s) {
print(s);
println();
return this;
}
FWriter print(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(int[] a) {
print(a);
println();
return this;
}
FWriter print(long[] a) {
for (int i = 0; i < a.length; i++) {
if (i > 0)
write(SP);
print(a[i]);
}
return this;
}
FWriter println(long[] a) {
print(a);
println();
return this;
}
FWriter print(char[] s, int from, int to) {
for (int i = from; i < to && s[i] != '\0'; i++) {
print(s[i]);
}
return this;
}
FWriter print(char[] s) {
print(s, 0, s.length);
return this;
}
FWriter println(char[] s, int from, int to) {
print(s, from, to);
println();
return this;
}
FWriter println(char[] s) {
println(s, 0, s.length);
return this;
}
FWriter print(double n, int accuracy) {
long longN = (long) n;
print(longN);
n -= (long) n;
write((byte) '.');
for (int j = 0; j < accuracy; j++) {
n *= 10;
int digit = (int) n;
write((byte) (digit + '0'));
n -= digit;
}
return this;
}
FWriter print(double n) {
print(n, 10);
return this;
}
FWriter println(double n) {
print(n);
println();
return this;
}
FWriter println(double n, int accuracy) {
print(n, accuracy);
println();
return this;
}
FWriter print(Object o) {
if (o != null) {
print(o.toString());
}
return this;
}
FWriter println(Object o) {
print(o);
println();
return this;
}
FWriter println(Throwable e) {
println(e.toString());
for (StackTraceElement el : e.getStackTrace()) {
print(" ").println(el.toString());
}
if (e.getCause() != null) {
println(e.getCause());
}
return this;
}
void enableDebug() {
this.isDebug = true;
}
private void _debug(Object o, int indent) {
if(o == null) {
for(var i = 0; i < indent; i++) print(' ');
print("null");
} else if(o.getClass().isArray()) {
for(int i = 0; i < java.lang.reflect.Array.getLength(o); i++) {
println();
_debug(java.lang.reflect.Array.get(o, i), indent + 2);
}
return;
} else if(o instanceof Collection) {
for(var item : (Collection<?>)o) {
println();
_debug(item, indent + 2);
}
} else if(o instanceof Map) {
for(var i = 0; i < indent; i++) print(' ');
println('{');
for(var entry : ((Map<?,?>)o).entrySet()) {
for(var i = 0; i < indent + 2; i++) print(' ');
_debug(entry.getKey(), 0);
_debug(" ", 0);
_debug(entry.getValue(), 0);
println();
}
for(var i = 0; i < indent; i++) print(' ');
println('}');
return;
}
for(var i = 0; i < indent; i++) print(' ');
print(o);
}
FWriter debug(Object... os) {
if(!isDebug) return this;
print("[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).print("]: ");
for(var o : os) {
_debug(o, 0);
print(' ');
}
print(" :[DEBUG:").print(Thread.currentThread().getStackTrace()[2].getLineNumber()).println("]");
return this;
}
} | ConDefects/ConDefects/Code/abc253_d/Java/36343842 |
condefects-java_data_1928 | import java.io.*;
import java.util.*;
public class Main {
// static class twodarray implements Comparable<twodarray> {
// int first;
// int second;
// // boolean state;
// public twodarray() {
// }
// public twodarray(int first,int second) {
// this.first = first;
// this.second = second;
// // this.state=state;
// }
// @Override
// public int compareTo(twodarray o2) {
// if (this.first < o2.first || (this.first == o2.first && this.second > o2.second))
// return -1;
// return 1;
// }
// @Override
// public boolean equals(Object other) {
// if (other instanceof twodarray) {
// twodarray casted = (twodarray) other;
// return casted.first == this.first && casted.second == this.second;
// }
// return false;
// }
// @Override
// public int hashCode() {
// String unique = this.first + "_" + this.second;
// return unique.hashCode();
// }
// }
static long gcd(long a,long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() //considers white spaces also
{
String str = "";
try {
str = br.readLine().trim();//used to eliminate trailing and leading spaces
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static FastReader in = new FastReader();
static FastWriter out = new FastWriter();
static int findSet(int v,int[] parent)
{
if(v==parent[v])
return v;
return parent[v]=findSet(parent[v],parent);//log(n) operation
}
static void unionSets(int a,int b,int[] parent)
{
a=findSet(a,parent);
b=findSet(b,parent);
if(a!=b)
{
parent[b]=a;
}
}
static HashMap<Long,Long> freq=new HashMap<>();
static boolean[] visited;
public static void main(String[] args) throws IOException {
try {
// int testCases =in.nextInt();
int testCases =1;
while (testCases-- > 0) {
// out.println("testcases is : "+testCases);
solve();
}
out.close();
} catch (Exception e) {
e.printStackTrace();
out.print(e);
return;
}
}
//use this sqrt instead of Math.sqrt , this uses binary search and removes inaccuracies of long values
static long bs_sqrt(long x) {
long left = 0, right = 2000000123;
while (right > left) {
long mid = (left + right) / 2;
if (mid * mid > x) right = mid;
else left = mid + 1;
}
return left - 1;
}
static boolean isPrime(long n)
{
if (n <= 1)
return false;
for (int i = 2; i <=Math.sqrt(n); i++)
if (n % i == 0)
return false;
return true;
}
static void solve() throws IOException{
long n=in.nextLong(),a=in.nextLong(),b=in.nextLong();
long sum=(n*(n+1))/2;
long sum1=a*((n/a)*((n/a) +1))/2;
long sum2=b*((n/b)*((n/b) +1))/2;
long p=a*b;
long sum3=p*((n/p)*((n/p) +1))/2;
out.println(sum-(sum1+sum2-sum3));
}
static int[] fillIntArray(int n) throws IOException{
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = in.nextInt();
// for(int i=0;i<n;i++)
// out.print(arr[i]+" ");
return arr;
}
static int[] fillIntArrayOneBased(int n) throws IOException {
int[] arr = new int[n+1];
for (int i = 1; i <= n; i++)
arr[i] = in.nextInt();
// for(int i=0;i<n;i++)
// out.print(arr[i]+" ");
return arr;
}
static void merge(int arr[], int l, int m, int r)
{
int n1 = m - l + 1;
int n2 = r - m;
int L[] = new int[n1];
int R[] = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
static void sort(int arr[], int l, int r)
{
if (l < r) {
int m =l+ (r-l)/2;
sort(arr, l, m);
sort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
}
////hashmap code for getting key with freq of only one
////public int singleNumber(int[] nums) {
//// Map<Integer, Integer> freq = new HashMap<>();
////
//// for (int i : nums) {
//// if (freq.get(i) == null) {
//// freq.put(i, 1);
//// } else {
//// freq.put(i, freq.get(i) + 1);
//// }
//// }
////
//// for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
//// if (entry.getValue() == 1) {
//// return entry.getKey();
//// }
//// }
////
//// return 0;
////}
//CYCLE IN DFS
//static void dfs(int v,boolean[] visited,int[][] points,HashMap<Integer,Integer> index, Stack<Integer> inProcess) throws IOException {
// // base case, dead end
// if(!index.containsKey(v))
// {
// return;
// }
//
// // loop detected, we are already processing this node
// if(inProcess.contains(v))
// {
// out.println("No");
// state=true;
// return;
// }
// // dfs
// inProcess.push(v);
// visited[v]=true;
// dfs(index.get(v),visited,points,index, inProcess);
// inProcess.pop(); // end of processing children
//}
////building a heap is O(n) by using heapify method bottom to top
//// Note:- In order to take mod of negative number use (i % K + K)%K;
/* package codechef; // don't place package name! */
//import java.util.*;
//import java.lang.*;
//import java.io.*;
//class Codechef
//{
// public static void main (String[] args) throws java.lang.Exception
// {
// Scanner sc=new Scanner(System.in);
// int t=sc.nextInt();
// while(t-->0)
// {
// int n=sc.nextInt();
// int[] arr=new int[n];
// boolean state=false;
// for(int i=0;i<n;i++)
// {
// arr[i]=sc.nextInt();
// }
//
//
// }
//
// }
//
//}
////Techniques:
////divide into cases,brute force,pattern finding
////sorting,greedy,binary search,two pointer,sliding window
////dynamic programming,transform into graph,dfs,bfs,union find
////to create array of arraylist List<Integer>[] g=new List[size] use List interface;
/* package codechef; // don't place package name! */
//linked list contains is O(N)
//when you know the range in which the answer lies try using binary search such that all left elements give the ans and right ones dont
//use linkedhashmap is used for maintaining order of keys in sorted manner
//for dp think of 0 1 knapsack(especially when we need to select k out of n options) and recursive memoization
//in knapsack for i th row you always include the ith object and select the best of the two options (of considering ith object and by not considering ith object by simply choosing i-1,j)
//preorder is nothing but dfs in trees
//
//import java.util.*;
// import java.lang.*;
// import java.io.*;
//
//class Codechef
//{
// public static void main (String[] args) throws java.lang.Exception
// {
// Scanner sc=new Scanner(System.in);
// int t=sc.nextInt();
// while(t-->0)
// {
// int n=sc.nextInt();
// int[] arr=new int[n];
// boolean state=false;
// for(int i=0;i<n;i++)
// {
// arr[i]=sc.nextInt();
// }
// int min=Integer.MAX_VALUE;
// for(int i=1;i<n-1;i++)//we are assuming arr[i] to be median
// {
// int[] temp=new int[n-1-i];
// for(int j=i+1;j<n;j++){
// temp[j-(i+1)]=arr[j];
// }
// Arrays.sort(temp);
// for(int k=0;k<i;k++){
// int tofind= -arr[k];
// int l=i+1;
// int r=n-1;
// while()
// }
//
// }
// System.out.println(min);
//
// }
//
// }
//
//}
import java.io.*;
import java.util.*;
public class Main {
// static class twodarray implements Comparable<twodarray> {
// int first;
// int second;
// // boolean state;
// public twodarray() {
// }
// public twodarray(int first,int second) {
// this.first = first;
// this.second = second;
// // this.state=state;
// }
// @Override
// public int compareTo(twodarray o2) {
// if (this.first < o2.first || (this.first == o2.first && this.second > o2.second))
// return -1;
// return 1;
// }
// @Override
// public boolean equals(Object other) {
// if (other instanceof twodarray) {
// twodarray casted = (twodarray) other;
// return casted.first == this.first && casted.second == this.second;
// }
// return false;
// }
// @Override
// public int hashCode() {
// String unique = this.first + "_" + this.second;
// return unique.hashCode();
// }
// }
static long gcd(long a,long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() //considers white spaces also
{
String str = "";
try {
str = br.readLine().trim();//used to eliminate trailing and leading spaces
} catch (Exception e) {
e.printStackTrace();
}
return str;
}
}
static class FastWriter {
private final BufferedWriter bw;
public FastWriter() {
this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
}
public void print(Object object) throws IOException {
bw.append("" + object);
}
public void println(Object object) throws IOException {
print(object);
bw.append("\n");
}
public void close() throws IOException {
bw.close();
}
}
static FastReader in = new FastReader();
static FastWriter out = new FastWriter();
static int findSet(int v,int[] parent)
{
if(v==parent[v])
return v;
return parent[v]=findSet(parent[v],parent);//log(n) operation
}
static void unionSets(int a,int b,int[] parent)
{
a=findSet(a,parent);
b=findSet(b,parent);
if(a!=b)
{
parent[b]=a;
}
}
static HashMap<Long,Long> freq=new HashMap<>();
static boolean[] visited;
public static void main(String[] args) throws IOException {
try {
// int testCases =in.nextInt();
int testCases =1;
while (testCases-- > 0) {
// out.println("testcases is : "+testCases);
solve();
}
out.close();
} catch (Exception e) {
e.printStackTrace();
out.print(e);
return;
}
}
//use this sqrt instead of Math.sqrt , this uses binary search and removes inaccuracies of long values
static long bs_sqrt(long x) {
long left = 0, right = 2000000123;
while (right > left) {
long mid = (left + right) / 2;
if (mid * mid > x) right = mid;
else left = mid + 1;
}
return left - 1;
}
static boolean isPrime(long n)
{
if (n <= 1)
return false;
for (int i = 2; i <=Math.sqrt(n); i++)
if (n % i == 0)
return false;
return true;
}
static void solve() throws IOException{
long n=in.nextLong(),a=in.nextLong(),b=in.nextLong();
long sum=(n*(n+1))/2;
long sum1=a*((n/a)*((n/a) +1))/2;
long sum2=b*((n/b)*((n/b) +1))/2;
long p= a*b /(gcd(a,b));
long sum3=p*((n/p)*((n/p) +1))/2;
out.println(sum-(sum1+sum2-sum3));
}
static int[] fillIntArray(int n) throws IOException{
int[] arr = new int[n];
for (int i = 0; i < n; i++)
arr[i] = in.nextInt();
// for(int i=0;i<n;i++)
// out.print(arr[i]+" ");
return arr;
}
static int[] fillIntArrayOneBased(int n) throws IOException {
int[] arr = new int[n+1];
for (int i = 1; i <= n; i++)
arr[i] = in.nextInt();
// for(int i=0;i<n;i++)
// out.print(arr[i]+" ");
return arr;
}
static void merge(int arr[], int l, int m, int r)
{
int n1 = m - l + 1;
int n2 = r - m;
int L[] = new int[n1];
int R[] = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[l + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[m + 1 + j];
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
static void sort(int arr[], int l, int r)
{
if (l < r) {
int m =l+ (r-l)/2;
sort(arr, l, m);
sort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
}
////hashmap code for getting key with freq of only one
////public int singleNumber(int[] nums) {
//// Map<Integer, Integer> freq = new HashMap<>();
////
//// for (int i : nums) {
//// if (freq.get(i) == null) {
//// freq.put(i, 1);
//// } else {
//// freq.put(i, freq.get(i) + 1);
//// }
//// }
////
//// for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
//// if (entry.getValue() == 1) {
//// return entry.getKey();
//// }
//// }
////
//// return 0;
////}
//CYCLE IN DFS
//static void dfs(int v,boolean[] visited,int[][] points,HashMap<Integer,Integer> index, Stack<Integer> inProcess) throws IOException {
// // base case, dead end
// if(!index.containsKey(v))
// {
// return;
// }
//
// // loop detected, we are already processing this node
// if(inProcess.contains(v))
// {
// out.println("No");
// state=true;
// return;
// }
// // dfs
// inProcess.push(v);
// visited[v]=true;
// dfs(index.get(v),visited,points,index, inProcess);
// inProcess.pop(); // end of processing children
//}
////building a heap is O(n) by using heapify method bottom to top
//// Note:- In order to take mod of negative number use (i % K + K)%K;
/* package codechef; // don't place package name! */
//import java.util.*;
//import java.lang.*;
//import java.io.*;
//class Codechef
//{
// public static void main (String[] args) throws java.lang.Exception
// {
// Scanner sc=new Scanner(System.in);
// int t=sc.nextInt();
// while(t-->0)
// {
// int n=sc.nextInt();
// int[] arr=new int[n];
// boolean state=false;
// for(int i=0;i<n;i++)
// {
// arr[i]=sc.nextInt();
// }
//
//
// }
//
// }
//
//}
////Techniques:
////divide into cases,brute force,pattern finding
////sorting,greedy,binary search,two pointer,sliding window
////dynamic programming,transform into graph,dfs,bfs,union find
////to create array of arraylist List<Integer>[] g=new List[size] use List interface;
/* package codechef; // don't place package name! */
//linked list contains is O(N)
//when you know the range in which the answer lies try using binary search such that all left elements give the ans and right ones dont
//use linkedhashmap is used for maintaining order of keys in sorted manner
//for dp think of 0 1 knapsack(especially when we need to select k out of n options) and recursive memoization
//in knapsack for i th row you always include the ith object and select the best of the two options (of considering ith object and by not considering ith object by simply choosing i-1,j)
//preorder is nothing but dfs in trees
//
//import java.util.*;
// import java.lang.*;
// import java.io.*;
//
//class Codechef
//{
// public static void main (String[] args) throws java.lang.Exception
// {
// Scanner sc=new Scanner(System.in);
// int t=sc.nextInt();
// while(t-->0)
// {
// int n=sc.nextInt();
// int[] arr=new int[n];
// boolean state=false;
// for(int i=0;i<n;i++)
// {
// arr[i]=sc.nextInt();
// }
// int min=Integer.MAX_VALUE;
// for(int i=1;i<n-1;i++)//we are assuming arr[i] to be median
// {
// int[] temp=new int[n-1-i];
// for(int j=i+1;j<n;j++){
// temp[j-(i+1)]=arr[j];
// }
// Arrays.sort(temp);
// for(int k=0;k<i;k++){
// int tofind= -arr[k];
// int l=i+1;
// int r=n-1;
// while()
// }
//
// }
// System.out.println(min);
//
// }
//
// }
//
//}
| ConDefects/ConDefects/Code/abc253_d/Java/40366671 |
condefects-java_data_1929 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
long gcdLong(long n1, long n2) {
if (n2 == 0) {
return n1;
}
return gcdLong(n2, n1 % n2);
}
void solve(){
long N = scanner.nextLong();
long A = scanner.nextLong();
long B = scanner.nextLong();
long AB = A*B;
long lcm = AB/gcdLong(A, B);
long ASum = getSum(A, N/A, A);
long BSum = getSum(B, N/B, B);
long ABSum = getSum(AB, N/lcm, lcm);
long total = getSum(1, N, 1);
out.print(total-ASum-BSum+ABSum);
}
long getSum(long start, long n, long d){
long end = start + (n-1)*d;
if(n%2==0){
return (n/2)*(start+end);
}
return ((start + end)/2)*n;
}
private static final boolean memory = true;
private static final boolean singleTest = true;
// ----- runner templates ----- //
void run() {
int numOfTests = singleTest? 1: scanner.nextInt();
for(int testIdx = 1; testIdx <= numOfTests; testIdx++){
solve();
}
out.flush();
out.close();
}
// ----- runner templates ----- //
public static void main(String[] args) {
if(memory) {
new Thread(null, () -> new Main().run(), "go", 1 << 26).start();
}
else{
new Main().run();
}
}
//------ input and output ------//
public static FastScanner scanner = new FastScanner(System.in);
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return negative ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
return (char) c;
}
public String next() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isWhitespace(c));
return res.toString();
}
private boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
int[] nextIntArray(int n, int base){
int[] arr = new int[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextInt();}
return arr;
}
long[] nextLongArray(int n, int base){
long[] arr = new long[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextLong();}
return arr;
}
int[][] nextIntGrid(int n, int m, int base){
int[][] grid = new int[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextInt();}}
return grid;
}
char[][] nextCharGrid(int n, int m, int base){
char[][] grid = new char[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextChar();}}
return grid;
}
double[][] nextDoubleGrid(int n, int m, int base){
double[][] grid = new double[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextDouble();}}
return grid;
}
int[][] nextUnweightedGraph(int n, int m, int base){
int[][] g = new int[base + n][];
int[][] edges = new int[m][2];
int[] adjSize = new int[n+base];
for(int i = 0; i < m; i++){
int a = scanner.nextInt(), b = scanner.nextInt();
edges[i][0]=a;
adjSize[a]++;
edges[i][1]=b;
adjSize[b]++;
}
for(int i = base; i < base + n; i++){
g[i]=new int[adjSize[i]];
adjSize[i]=0;
}
for(int[] e: edges){
int a = e[0], b = e[1];
g[a][adjSize[a]++]=b;
g[b][adjSize[b]++]=a;
}
return g;
}
//------ debug and print functions ------//
void debug(Object...os){out.println(deepToString(os));}
void print(int[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(long[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(char[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(Object... o){for(int i = 0; i < o.length; i++){out.print(o[i]);out.print(i==o.length-1?'\n':' ');}}
<T> void printArrayList(List<T> arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr.get(i));out.print(i==end? '\n':' ');}}
//------ sort primitive type arrays ------//
static void sort(int[] arr){
List<Integer> temp = new ArrayList<>();
for(int val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(long[] arr){
List<Long> temp = new ArrayList<>();
for(long val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(char[] arr) {
List<Character> temp = new ArrayList<>();
for (char val : arr) {temp.add(val);}
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) {arr[i] = temp.get(i);}
}
}
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;
public class Main {
long gcdLong(long n1, long n2) {
if (n2 == 0) {
return n1;
}
return gcdLong(n2, n1 % n2);
}
void solve(){
long N = scanner.nextLong();
long A = scanner.nextLong();
long B = scanner.nextLong();
long AB = A*B;
long lcm = AB/gcdLong(A, B);
long ASum = getSum(A, N/A, A);
long BSum = getSum(B, N/B, B);
long ABSum = getSum(lcm, N/lcm, lcm);
long total = getSum(1, N, 1);
out.print(total-ASum-BSum+ABSum);
}
long getSum(long start, long n, long d){
long end = start + (n-1)*d;
if(n%2==0){
return (n/2)*(start+end);
}
return ((start + end)/2)*n;
}
private static final boolean memory = true;
private static final boolean singleTest = true;
// ----- runner templates ----- //
void run() {
int numOfTests = singleTest? 1: scanner.nextInt();
for(int testIdx = 1; testIdx <= numOfTests; testIdx++){
solve();
}
out.flush();
out.close();
}
// ----- runner templates ----- //
public static void main(String[] args) {
if(memory) {
new Thread(null, () -> new Main().run(), "go", 1 << 26).start();
}
else{
new Main().run();
}
}
//------ input and output ------//
public static FastScanner scanner = new FastScanner(System.in);
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static class FastScanner {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar, numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public int nextInt() {
return (int) nextLong();
}
public long nextLong() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
boolean negative = false;
if (c == '-') {
negative = true;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return negative ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public char nextChar() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
return (char) c;
}
public String next() {
int c = read();
while (isWhitespace(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isWhitespace(c));
return res.toString();
}
private boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
int[] nextIntArray(int n, int base){
int[] arr = new int[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextInt();}
return arr;
}
long[] nextLongArray(int n, int base){
long[] arr = new long[n + base];
for(int i = base; i < n + base; i++){arr[i] = scanner.nextLong();}
return arr;
}
int[][] nextIntGrid(int n, int m, int base){
int[][] grid = new int[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextInt();}}
return grid;
}
char[][] nextCharGrid(int n, int m, int base){
char[][] grid = new char[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextChar();}}
return grid;
}
double[][] nextDoubleGrid(int n, int m, int base){
double[][] grid = new double[n + base][m + base];
for(int i = base; i < n + base; i++){for(int j = base; j < m + base; j++){grid[i][j] = scanner.nextDouble();}}
return grid;
}
int[][] nextUnweightedGraph(int n, int m, int base){
int[][] g = new int[base + n][];
int[][] edges = new int[m][2];
int[] adjSize = new int[n+base];
for(int i = 0; i < m; i++){
int a = scanner.nextInt(), b = scanner.nextInt();
edges[i][0]=a;
adjSize[a]++;
edges[i][1]=b;
adjSize[b]++;
}
for(int i = base; i < base + n; i++){
g[i]=new int[adjSize[i]];
adjSize[i]=0;
}
for(int[] e: edges){
int a = e[0], b = e[1];
g[a][adjSize[a]++]=b;
g[b][adjSize[b]++]=a;
}
return g;
}
//------ debug and print functions ------//
void debug(Object...os){out.println(deepToString(os));}
void print(int[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(long[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(char[] arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr[i]);out.print(i==end? '\n':' ');}}
void print(Object... o){for(int i = 0; i < o.length; i++){out.print(o[i]);out.print(i==o.length-1?'\n':' ');}}
<T> void printArrayList(List<T> arr, int start, int end){for(int i = start; i <= end; i++){out.print(arr.get(i));out.print(i==end? '\n':' ');}}
//------ sort primitive type arrays ------//
static void sort(int[] arr){
List<Integer> temp = new ArrayList<>();
for(int val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(long[] arr){
List<Long> temp = new ArrayList<>();
for(long val: arr){temp.add(val);}
Collections.sort(temp);
for(int i = 0; i < arr.length; i++){arr[i] = temp.get(i);}
}
static void sort(char[] arr) {
List<Character> temp = new ArrayList<>();
for (char val : arr) {temp.add(val);}
Collections.sort(temp);
for (int i = 0; i < arr.length; i++) {arr[i] = temp.get(i);}
}
} | ConDefects/ConDefects/Code/abc253_d/Java/40436233 |
condefects-java_data_1930 | import java.io.IOException;
import java.io.InputStream;
import java.util.*;
public class Main {
private static final long MOD = 998244353L;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
Scanner sn = new Scanner(System.in);
char[] s = sc.next().toCharArray();
int cnt = 0;
for(int i = 0; i < s.length; i++) {
if (i != s.length - 1 && s[i] == '0') {
Long zeroCnt = 1L;
while (i + 1 != s.length - 1 && s[i + 1] == '0') {
zeroCnt++;
i++;
}
cnt += Math.round(zeroCnt / 2.0);
} else {
cnt++;
}
}
System.out.println(cnt);
}
private static long solve(int N, int[] A, int[] B) {
long[] pow2 = new long[N + 1];
pow2[0] = 1;
for (int i = 1; i <= N; i++) {
pow2[i] = (pow2[i - 1] * 2) % MOD;
}
long[] dp = new long[N + 1];
dp[0] = 1;
dp[1] = 2;
for (int i = 2; i <= N; i++) {
if (A[i - 1] != B[i - 1]) {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
} else {
dp[i] = dp[i - 1];
}
}
return (pow2[N] - dp[N] + MOD) % MOD;
}
static int gcd(int a, int b) {
while(a >= 1 && b >= 1) {
if(a >= b) {
a = (a % b);
} else {
b = (b % a);
}
}
if (a != 0) return a;
return b;
}
// 素因数分解を行う関数
static Map<Long, Integer> factorize(long n) {
Map<Long, Integer> factors = new HashMap<>();
for (long i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
factors.put(i, factors.getOrDefault(i, 0) + 1);
}
}
if (n != 1) {
factors.put(n, 1);
}
return factors;
}
// p^eの約数の個数を求める関数
static long countDivisors(long p, int e) {
long res = 1;
for (int i = 0; i <= e; i++) {
res *= (i + 1);
}
return res;
}
// x^nを求める関数
static long pow(long x, int n) {
long res = 1;
while (n > 0) {
if ((n & 1) == 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
//入力文字列が一致するかどうかをチェックする再帰的関数
//指定されたワイルドカードパターン
public static boolean isMatch(String word, int n, String pattern, int m,
Map<String, Boolean> lookup) {
//入力の動的要素から一意のマップキーを作成します
String key = n + "|" + m;
//サブ問題が以前に見られた場合
if (lookup.containsKey(key)) {
return lookup.get(key);
}
//サブ問題が初めて見られるので、それを解決して
//結果をマップに保存します
//パターンの終わりに到達しました
if (m == pattern.length()) {
//入力文字列の終わりにも達した場合にのみtrueを返します
lookup.put(key, (n == word.length()));
return n == word.length();
}
//入力文字列が最後に達した場合、
//パターンの残りの文字はすべて'*'です
if (n == word.length()) {
for (int i = m; i < pattern.length(); i++) {
if (pattern.charAt(i) != '*') {
lookup.put(key, false);
return false;
}
}
lookup.put(key, true);
return true;
}
//現在のワイルドカード文字が「?」の場合またはの現在の文字
//パターンは入力文字列の現在の文字と同じです
if (word.charAt(m) == '?' || pattern.charAt(m) == '?' || pattern.charAt(m) == word.charAt(n)) {
//パターンと入力文字列の次の文字に移動します
lookup.put(key, isMatch(word, n + 1, pattern, m + 1, lookup));
}
//現在のワイルドカード文字が「*」の場合
else if (pattern.charAt(m) == '*') {
//入力文字列の次の文字に移動するか
//'*'を無視して、パターン内の次の文字に移動します
lookup.put(key, isMatch(word, n + 1, pattern, m, lookup) ||
isMatch(word, n, pattern, m + 1, lookup));
} else {
//パターン内の現在の文字がそうでないときにここに到達します
//ワイルドカード文字であり、現在の文字と一致しません
//入力文字列の文字
lookup.put(key, false);
}
return lookup.get(key);
}
//文字列が特定のワイルドカードパターンと一致するかどうかを確認します
public static String isMatch(String word, String pattern) {
Map<String, Boolean> lookup = new HashMap<>();
if (isMatch(word, 0, pattern, 0, lookup)) {
return "Yes";
} else {
return "No";
}
}
public static ArrayList<Boolean> es(Long n) {
ArrayList<Boolean> flg = new ArrayList<Boolean>();
flg.add(false);
for (int i = 0; i < n - 1; i++) {
flg.add(true);
}
for (int p = 2; p <= n; p++) {
if (!flg.get(p)) continue;
for (int q = p * 2; q <= n; q += p) {
flg.set(q, false);
}
}
return flg;
}
private static void dfs(int v, boolean[] flg, ArrayList<Integer>[] adjacent) {
flg[v] = true;
for (int i : adjacent[v]) {
if (flg[i]) continue;
dfs(i, flg, adjacent);
}
return;
}
private static long countOccurrences(String str, char ch) {
return str.chars()
.filter(c -> c == ch)
.count();
}
private static long getCommonDivisor(long x, long y) {
long biggerNum = Math.max(x, y);
long smallerNum = Math.min(x, y);
// 大きい方から小さい方を割った余を求める
long surplus = biggerNum % smallerNum;
// 割り切れていれば、それを返す
if (surplus == 0) {
return smallerNum;
}
// 割り切れなければ再帰的に自信を呼び出す
surplus = getCommonDivisor(smallerNum, surplus);
return surplus;
}
public static boolean isPrime(long num) {
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false; // 偶数はあらかじめ除く
double sqrtNum = Math.sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
// 組み合わせ
public static long combination(int n, int r) {
long c[][] = new long[n + 5][n + 5];
//パスカルの三角形作成
c[0][0] = 1;
for (int i = 0; i < n + 3; i++) {
for (int j = 0; j < n + 3; j++) {
long tmp = c[i][j];
c[i + 1][j] += tmp;
c[i + 1][j + 1] += tmp;
}
}
return c[n][r];
}
// 文字列比較
public static boolean strCompare(String a, String b) {
boolean result = false;
int mod = 2147483647;
if (a.hashCode() % mod == b.hashCode() % mod) {
result = true;
} else {
result = false;
}
return result;
}
public static Map<Integer, Set<Integer>> addGraph(Map<Integer, Set<Integer>> graph, int a, int b) {
Set<Integer> set = graph.getOrDefault(a, new HashSet<>());
set.add(b);
graph.put(a, set);
return graph;
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
}
class UnionFind {
int[] parent;
int[] rank;
public UnionFind(int n) {
// 初期化コンストラクタ
this.parent = new int[n + 1];
this.rank = new int[n + 1];
// 最初はすべてが根
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
/**
* 要素の根を返す。
* 経路圧縮付き。（1→3→2となっていて2をfindした際、1→3,2と木の深さを浅くする。）
*
* @param x
* @return 要素xの根
*/
public int find(int x) {
if (x == parent[x]) {
return x;
} else {
// 経路圧縮時はrank変更しない
parent[x] = find(parent[x]);
return parent[x];
}
}
/**
* ２つの要素が同じ集合に属するかどうかを返す。
*
* @param x
* @param y
* @return 同じ集合であればtrue
*/
public boolean same(int x, int y) {
return find(x) == find(y);
}
/**
* 要素xが属する集合と要素yが属する集合を連結する。
* 木の高さ（ランク）を気にして、低い方に高い方をつなげる。（高い方の根を全体の根とする。）
*
* @param x
* @param y
*/
public void unite(int x, int y) {
int xRoot = find(x);
int yRoot = find(y);
if (xRoot == yRoot) {
// 属する集合が同じな場合、何もしない
return;
}
// rankを比較して共通の根を決定する。
// ※find時の経路圧縮はrank考慮しない
if (rank[xRoot] > rank[yRoot]) {
// xRootのrankのほうが大きければ、共通の根をxRootにする
parent[yRoot] = xRoot;
} else if (rank[xRoot] < rank[yRoot]) {
// yRootのrankのほうが大きければ、共通の根をyRootにする
parent[xRoot] = yRoot;
} else {
// rankが同じであれば、どちらかを根として、rankを一つ上げる。
parent[xRoot] = yRoot;
rank[xRoot]++;
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
public class Main {
private static final long MOD = 998244353L;
public static void main(String[] args) {
FastScanner sc = new FastScanner();
Scanner sn = new Scanner(System.in);
char[] s = sc.next().toCharArray();
int cnt = 0;
for(int i = 0; i < s.length; i++) {
if (i != s.length - 1 && s[i] == '0') {
Long zeroCnt = 1L;
while (i + 1 <= s.length - 1 && s[i + 1] == '0') {
zeroCnt++;
i++;
}
cnt += Math.round(zeroCnt / 2.0);
} else {
cnt++;
}
}
System.out.println(cnt);
}
private static long solve(int N, int[] A, int[] B) {
long[] pow2 = new long[N + 1];
pow2[0] = 1;
for (int i = 1; i <= N; i++) {
pow2[i] = (pow2[i - 1] * 2) % MOD;
}
long[] dp = new long[N + 1];
dp[0] = 1;
dp[1] = 2;
for (int i = 2; i <= N; i++) {
if (A[i - 1] != B[i - 1]) {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
} else {
dp[i] = dp[i - 1];
}
}
return (pow2[N] - dp[N] + MOD) % MOD;
}
static int gcd(int a, int b) {
while(a >= 1 && b >= 1) {
if(a >= b) {
a = (a % b);
} else {
b = (b % a);
}
}
if (a != 0) return a;
return b;
}
// 素因数分解を行う関数
static Map<Long, Integer> factorize(long n) {
Map<Long, Integer> factors = new HashMap<>();
for (long i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
factors.put(i, factors.getOrDefault(i, 0) + 1);
}
}
if (n != 1) {
factors.put(n, 1);
}
return factors;
}
// p^eの約数の個数を求める関数
static long countDivisors(long p, int e) {
long res = 1;
for (int i = 0; i <= e; i++) {
res *= (i + 1);
}
return res;
}
// x^nを求める関数
static long pow(long x, int n) {
long res = 1;
while (n > 0) {
if ((n & 1) == 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
//入力文字列が一致するかどうかをチェックする再帰的関数
//指定されたワイルドカードパターン
public static boolean isMatch(String word, int n, String pattern, int m,
Map<String, Boolean> lookup) {
//入力の動的要素から一意のマップキーを作成します
String key = n + "|" + m;
//サブ問題が以前に見られた場合
if (lookup.containsKey(key)) {
return lookup.get(key);
}
//サブ問題が初めて見られるので、それを解決して
//結果をマップに保存します
//パターンの終わりに到達しました
if (m == pattern.length()) {
//入力文字列の終わりにも達した場合にのみtrueを返します
lookup.put(key, (n == word.length()));
return n == word.length();
}
//入力文字列が最後に達した場合、
//パターンの残りの文字はすべて'*'です
if (n == word.length()) {
for (int i = m; i < pattern.length(); i++) {
if (pattern.charAt(i) != '*') {
lookup.put(key, false);
return false;
}
}
lookup.put(key, true);
return true;
}
//現在のワイルドカード文字が「?」の場合またはの現在の文字
//パターンは入力文字列の現在の文字と同じです
if (word.charAt(m) == '?' || pattern.charAt(m) == '?' || pattern.charAt(m) == word.charAt(n)) {
//パターンと入力文字列の次の文字に移動します
lookup.put(key, isMatch(word, n + 1, pattern, m + 1, lookup));
}
//現在のワイルドカード文字が「*」の場合
else if (pattern.charAt(m) == '*') {
//入力文字列の次の文字に移動するか
//'*'を無視して、パターン内の次の文字に移動します
lookup.put(key, isMatch(word, n + 1, pattern, m, lookup) ||
isMatch(word, n, pattern, m + 1, lookup));
} else {
//パターン内の現在の文字がそうでないときにここに到達します
//ワイルドカード文字であり、現在の文字と一致しません
//入力文字列の文字
lookup.put(key, false);
}
return lookup.get(key);
}
//文字列が特定のワイルドカードパターンと一致するかどうかを確認します
public static String isMatch(String word, String pattern) {
Map<String, Boolean> lookup = new HashMap<>();
if (isMatch(word, 0, pattern, 0, lookup)) {
return "Yes";
} else {
return "No";
}
}
public static ArrayList<Boolean> es(Long n) {
ArrayList<Boolean> flg = new ArrayList<Boolean>();
flg.add(false);
for (int i = 0; i < n - 1; i++) {
flg.add(true);
}
for (int p = 2; p <= n; p++) {
if (!flg.get(p)) continue;
for (int q = p * 2; q <= n; q += p) {
flg.set(q, false);
}
}
return flg;
}
private static void dfs(int v, boolean[] flg, ArrayList<Integer>[] adjacent) {
flg[v] = true;
for (int i : adjacent[v]) {
if (flg[i]) continue;
dfs(i, flg, adjacent);
}
return;
}
private static long countOccurrences(String str, char ch) {
return str.chars()
.filter(c -> c == ch)
.count();
}
private static long getCommonDivisor(long x, long y) {
long biggerNum = Math.max(x, y);
long smallerNum = Math.min(x, y);
// 大きい方から小さい方を割った余を求める
long surplus = biggerNum % smallerNum;
// 割り切れていれば、それを返す
if (surplus == 0) {
return smallerNum;
}
// 割り切れなければ再帰的に自信を呼び出す
surplus = getCommonDivisor(smallerNum, surplus);
return surplus;
}
public static boolean isPrime(long num) {
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false; // 偶数はあらかじめ除く
double sqrtNum = Math.sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
// 組み合わせ
public static long combination(int n, int r) {
long c[][] = new long[n + 5][n + 5];
//パスカルの三角形作成
c[0][0] = 1;
for (int i = 0; i < n + 3; i++) {
for (int j = 0; j < n + 3; j++) {
long tmp = c[i][j];
c[i + 1][j] += tmp;
c[i + 1][j + 1] += tmp;
}
}
return c[n][r];
}
// 文字列比較
public static boolean strCompare(String a, String b) {
boolean result = false;
int mod = 2147483647;
if (a.hashCode() % mod == b.hashCode() % mod) {
result = true;
} else {
result = false;
}
return result;
}
public static Map<Integer, Set<Integer>> addGraph(Map<Integer, Set<Integer>> graph, int a, int b) {
Set<Integer> set = graph.getOrDefault(a, new HashSet<>());
set.add(b);
graph.put(a, set);
return graph;
}
}
class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
private void skipUnprintable() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
}
public boolean hasNext() {
skipUnprintable();
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public long nextLong() {
if (!hasNext()) throw new NoSuchElementException();
long n = 0;
boolean minus = false;
int b = readByte();
if (b == '-') {
minus = true;
b = readByte();
}
if (b < '0' || '9' < b) {
throw new NumberFormatException();
}
while (true) {
if ('0' <= b && b <= '9') {
n *= 10;
n += b - '0';
} else if (b == -1 || !isPrintableChar(b)) {
return minus ? -n : n;
} else {
throw new NumberFormatException();
}
b = readByte();
}
}
}
class UnionFind {
int[] parent;
int[] rank;
public UnionFind(int n) {
// 初期化コンストラクタ
this.parent = new int[n + 1];
this.rank = new int[n + 1];
// 最初はすべてが根
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
/**
* 要素の根を返す。
* 経路圧縮付き。（1→3→2となっていて2をfindした際、1→3,2と木の深さを浅くする。）
*
* @param x
* @return 要素xの根
*/
public int find(int x) {
if (x == parent[x]) {
return x;
} else {
// 経路圧縮時はrank変更しない
parent[x] = find(parent[x]);
return parent[x];
}
}
/**
* ２つの要素が同じ集合に属するかどうかを返す。
*
* @param x
* @param y
* @return 同じ集合であればtrue
*/
public boolean same(int x, int y) {
return find(x) == find(y);
}
/**
* 要素xが属する集合と要素yが属する集合を連結する。
* 木の高さ（ランク）を気にして、低い方に高い方をつなげる。（高い方の根を全体の根とする。）
*
* @param x
* @param y
*/
public void unite(int x, int y) {
int xRoot = find(x);
int yRoot = find(y);
if (xRoot == yRoot) {
// 属する集合が同じな場合、何もしない
return;
}
// rankを比較して共通の根を決定する。
// ※find時の経路圧縮はrank考慮しない
if (rank[xRoot] > rank[yRoot]) {
// xRootのrankのほうが大きければ、共通の根をxRootにする
parent[yRoot] = xRoot;
} else if (rank[xRoot] < rank[yRoot]) {
// yRootのrankのほうが大きければ、共通の根をyRootにする
parent[xRoot] = yRoot;
} else {
// rankが同じであれば、どちらかを根として、rankを一つ上げる。
parent[xRoot] = yRoot;
rank[xRoot]++;
}
}
} | ConDefects/ConDefects/Code/abc283_c/Java/40007642 |
condefects-java_data_1931 | import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Map<Integer, Integer> map = new HashMap<>();
for(int i=0; i<n; i++){
int taste = sc.nextInt();
int color = sc.nextInt();
if(map.containsKey(color)){
int getTaste = map.get(color);
if(getTaste < taste){
map.put(color, taste);
}
} else {
map.put(color, taste);
}
}
Integer maxValue = 0;
for(Integer value : map.values()){
if(maxValue < value){
maxValue = value;
}
}
System.out.println(maxValue);
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Map<Integer, Integer> map = new HashMap<>();
for(int i=0; i<n; i++){
int taste = sc.nextInt();
int color = sc.nextInt();
if(map.containsKey(color)){
int getTaste = map.get(color);
if(taste < getTaste){
map.put(color, taste);
}
} else {
map.put(color, taste);
}
}
Integer maxValue = 0;
for(Integer value : map.values()){
if(maxValue < value){
maxValue = value;
}
}
System.out.println(maxValue);
}
}
| ConDefects/ConDefects/Code/abc348_c/Java/53786975 |
condefects-java_data_1932 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
public static void main(String[] args) throws Exception {
Map<String,Integer> mp = new HashMap<>();
mp.put("tourist",3858);
mp.put("ksun48",3679);
mp.put("Benq",3658);
mp.put("Um_nik",3848);
mp.put("apiad",3638);
mp.put("Stonefeang",3630);
mp.put("ecnerwala",3613);
mp.put("mnbvmar",3555);
mp.put("newbiedmy",3516);
mp.put("semiexp",3481);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String name = br.readLine();
System.out.println(mp.get(name));
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
public static void main(String[] args) throws Exception {
Map<String,Integer> mp = new HashMap<>();
mp.put("tourist",3858);
mp.put("ksun48",3679);
mp.put("Benq",3658);
mp.put("Um_nik",3648);
mp.put("apiad",3638);
mp.put("Stonefeang",3630);
mp.put("ecnerwala",3613);
mp.put("mnbvmar",3555);
mp.put("newbiedmy",3516);
mp.put("semiexp",3481);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String name = br.readLine();
System.out.println(mp.get(name));
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45473426 |
condefects-java_data_1933 |
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static Utils utils = new Utils();
public static void main(String[] args) throws IOException {
// int o = readInt();
// while (o-- > 0)
solve();
closeAndFlush();
}
static class Edge {
int to, pe, w;
public Edge(int to, int pe) {
this.to = to;
this.pe = pe;
}
public Edge(int to, int pe, int w) {
this.to = to;
this.pe = pe;
this.w = w;
}
}
static class Pair {
int first, 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 n, m, idx = 1;
static int[] head;
static Edge[] edges;
public static void solve() throws IOException {
Map<String, String> map = new HashMap<>();
map.put("tourist", "3858");
map.put("ksun48", "3679");
map.put("Benq", "3658");
map.put("Um_nik", "3648");
map.put("apiad", "3638");
map.put("Stonefeang", "3630");
map.put("ecnerwala", "3630");
map.put("mnbvmar", "3555");
map.put("newbiedmy", "3516");
map.put("semiexp", "3481");
printWriter.println(map.get(readString()));
}
public static void add(int a, int b) {
edges[idx] = new Edge(b, head[a]);
head[a] = idx++;
}
public static void add(int a, int b, int c) {
edges[idx] = new Edge(b, head[a], c);
head[a] = idx++;
}
public static int readInt() throws IOException {
return sc.nextInt();
}
public static long readLong() throws IOException {
return sc.nextLong();
}
public static String readString() throws IOException {
return sc.next();
// return sc.nextLine();
}
public static void closeAndFlush() throws IOException {
printWriter.flush();
printWriter.close();
sc.close();
}
public static void arrayToString(int[] arr) {
for (int i = 0; i < arr.length; i++) {
printWriter.print(arr[i] + " ");
}
printWriter.println();
}
public static void arrayToString(int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
printWriter.print(arr[i][j] + " ");
}
printWriter.println();
}
}
}
class Utils {
public static int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readInt();
}
return arr;
}
public static int[][] nextIntArray(int n, int m) throws IOException {
int[][] arr = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readInt();
}
}
return arr;
}
public static long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readLong();
}
return arr;
}
public static long[][] nextLongArray(int n, int m) throws IOException {
long[][] arr = new long[n + 1][];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readLong();
}
}
return arr;
}
public static String[] nextStringArray(int n) throws IOException {
String[] strings = new String[n + 1];
for (int i = 1; i <= n; i++) {
strings[i] = " " + Main.readString();
}
return strings;
}
public static char[][] nextCharArray(int n, int m) throws IOException {
char[][] chars = new char[n + 5][m + 5];
for (int i = 1; i <= n; i++) {
chars[i] = (" " + Main.readString()).toCharArray();
}
return chars;
}
public static int forceInt(long n) {
return (int) n;
}
public static int forceInt(double n) {
return (int) n;
}
public static long forceLong(int n) {
return n;
}
public static long forceLong(double n) {
return (long) n;
}
public static int max(int a, int b, int c) {
return Math.max(a, Math.max(b, c));
}
public static int min(int a, int b, int c) {
return Math.min(a, Math.min(b, c));
}
}
import java.io.*;
import java.util.*;
public class Main {
static Scanner sc = new Scanner(System.in);
static PrintWriter printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static Utils utils = new Utils();
public static void main(String[] args) throws IOException {
// int o = readInt();
// while (o-- > 0)
solve();
closeAndFlush();
}
static class Edge {
int to, pe, w;
public Edge(int to, int pe) {
this.to = to;
this.pe = pe;
}
public Edge(int to, int pe, int w) {
this.to = to;
this.pe = pe;
this.w = w;
}
}
static class Pair {
int first, 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 n, m, idx = 1;
static int[] head;
static Edge[] edges;
public static void solve() throws IOException {
Map<String, String> map = new HashMap<>();
map.put("tourist", "3858");
map.put("ksun48", "3679");
map.put("Benq", "3658");
map.put("Um_nik", "3648");
map.put("apiad", "3638");
map.put("Stonefeang", "3630");
map.put("ecnerwala", "3613");
map.put("mnbvmar", "3555");
map.put("newbiedmy", "3516");
map.put("semiexp", "3481");
printWriter.println(map.get(readString()));
}
public static void add(int a, int b) {
edges[idx] = new Edge(b, head[a]);
head[a] = idx++;
}
public static void add(int a, int b, int c) {
edges[idx] = new Edge(b, head[a], c);
head[a] = idx++;
}
public static int readInt() throws IOException {
return sc.nextInt();
}
public static long readLong() throws IOException {
return sc.nextLong();
}
public static String readString() throws IOException {
return sc.next();
// return sc.nextLine();
}
public static void closeAndFlush() throws IOException {
printWriter.flush();
printWriter.close();
sc.close();
}
public static void arrayToString(int[] arr) {
for (int i = 0; i < arr.length; i++) {
printWriter.print(arr[i] + " ");
}
printWriter.println();
}
public static void arrayToString(int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
printWriter.print(arr[i][j] + " ");
}
printWriter.println();
}
}
}
class Utils {
public static int[] nextIntArray(int n) throws IOException {
int[] arr = new int[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readInt();
}
return arr;
}
public static int[][] nextIntArray(int n, int m) throws IOException {
int[][] arr = new int[n + 1][m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readInt();
}
}
return arr;
}
public static long[] nextLongArray(int n) throws IOException {
long[] arr = new long[n + 1];
for (int i = 1; i <= n; i++) {
arr[i] = Main.readLong();
}
return arr;
}
public static long[][] nextLongArray(int n, int m) throws IOException {
long[][] arr = new long[n + 1][];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = Main.readLong();
}
}
return arr;
}
public static String[] nextStringArray(int n) throws IOException {
String[] strings = new String[n + 1];
for (int i = 1; i <= n; i++) {
strings[i] = " " + Main.readString();
}
return strings;
}
public static char[][] nextCharArray(int n, int m) throws IOException {
char[][] chars = new char[n + 5][m + 5];
for (int i = 1; i <= n; i++) {
chars[i] = (" " + Main.readString()).toCharArray();
}
return chars;
}
public static int forceInt(long n) {
return (int) n;
}
public static int forceInt(double n) {
return (int) n;
}
public static long forceLong(int n) {
return n;
}
public static long forceLong(double n) {
return (long) n;
}
public static int max(int a, int b, int c) {
return Math.max(a, Math.max(b, c));
}
public static int min(int a, int b, int c) {
return Math.min(a, Math.min(b, c));
}
}
| ConDefects/ConDefects/Code/abc319_a/Java/45444899 |
condefects-java_data_1934 | import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
Map<String,Integer> mymap=new HashMap<>();
mymap.put("tourist",3858);
mymap.put("ksun48",3679);
mymap.put("Benq",3658);
mymap.put("Um_nik",3648);
mymap.put("apiad",3638);
mymap.put("Stonefeang",3630);
mymap.put("ecnerwala",3613);
mymap.put("mnbvmar",3555);
mymap.put("ecnerwala",3516);
mymap.put("semiexp",3481);
String input=sc.next();
System.out.println(mymap.get(input));
}
}
import java.util.*;
public class Main {
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
Map<String,Integer> mymap=new HashMap<>();
mymap.put("tourist",3858);
mymap.put("ksun48",3679);
mymap.put("Benq",3658);
mymap.put("Um_nik",3648);
mymap.put("apiad",3638);
mymap.put("Stonefeang",3630);
mymap.put("ecnerwala",3613);
mymap.put("mnbvmar",3555);
mymap.put("newbiedmy",3516);
mymap.put("semiexp",3481);
String input=sc.next();
System.out.println(mymap.get(input));
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45409908 |
condefects-java_data_1935 | import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String S = scanner.next();
if(S.equals("tourist")) {
System.out.println(3858);
}else if(S.equals("ksun48")) {
System.out.println(3679);
}else if(S.equals("Benq")) {
System.out.println(3658);
}else if(S.equals("Um_nik")) {
System.out.println(3648);
}else if(S.equals("apiad")) {
System.out.println(3638);
}else if(S.equals("Stonefeang")) {
System.out.println(3630);
}else if(S.equals("3cnerwala")) {
System.out.println(3613);
}else if (S.equals("mnbvmar")) {
System.out.println(3555);
}else if (S.equals("newbiedmy")) {
System.out.println(3516);
}else if (S.equals("semiexp")) {
System.out.println(3481);
}
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String S = scanner.next();
if(S.equals("tourist")) {
System.out.println(3858);
}else if(S.equals("ksun48")) {
System.out.println(3679);
}else if(S.equals("Benq")) {
System.out.println(3658);
}else if(S.equals("Um_nik")) {
System.out.println(3648);
}else if(S.equals("apiad")) {
System.out.println(3638);
}else if(S.equals("Stonefeang")) {
System.out.println(3630);
}else if(S.equals("ecnerwala")) {
System.out.println(3613);
}else if (S.equals("mnbvmar")) {
System.out.println(3555);
}else if (S.equals("newbiedmy")) {
System.out.println(3516);
}else if (S.equals("semiexp")) {
System.out.println(3481);
}
}
} | ConDefects/ConDefects/Code/abc319_a/Java/46131401 |
condefects-java_data_1936 | import java.util.*;
public class Main{
public static void main(String[] args){
Map<String,Integer> mp=new HashMap<>();
Scanner sc =new Scanner(System.in);
mp.put("tourist",mp.getOrDefault("tourist",3858));
mp.put("ksun48", mp.getOrDefault("ksnu48",3679));
mp.put("Benq ",mp.getOrDefault("Benq",3658));
mp.put("Um_nik", mp.getOrDefault("Um_nik",3648));
mp.put("apiad" ,mp.getOrDefault("apiad",3638));
mp.put("Stonefeang" ,mp.getOrDefault("Stonefeang",3630));
mp.put("ecnerwala" ,mp.getOrDefault("ecnerwala",3613));
mp.put("mnbvmar",mp.getOrDefault("mnbvmar",3555));
mp.put("newbiedmy",mp.getOrDefault("newbiedmy",3516));
mp.put("semiexp",mp.getOrDefault("semiexp",3481));
String s =sc.nextLine();
System.out.println(mp.get(s));
}
}
import java.util.*;
public class Main{
public static void main(String[] args){
Map<String,Integer> mp=new HashMap<>();
Scanner sc =new Scanner(System.in);
mp.put("tourist",mp.getOrDefault("tourist",3858));
mp.put("ksun48", mp.getOrDefault("ksnu48",3679));
mp.put("Benq",mp.getOrDefault("Benq",3658));
mp.put("Um_nik", mp.getOrDefault("Um_nik",3648));
mp.put("apiad" ,mp.getOrDefault("apiad",3638));
mp.put("Stonefeang" ,mp.getOrDefault("Stonefeang",3630));
mp.put("ecnerwala" ,mp.getOrDefault("ecnerwala",3613));
mp.put("mnbvmar",mp.getOrDefault("mnbvmar",3555));
mp.put("newbiedmy",mp.getOrDefault("newbiedmy",3516));
mp.put("semiexp",mp.getOrDefault("semiexp",3481));
String s =sc.nextLine();
System.out.println(mp.get(s));
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45403177 |
condefects-java_data_1937 | import java.util.*;
public class Main{
public static void main(String [] args){
Map<String,Integer> tik=new HashMap<>();
tik.put("tourist",3858);
tik.put("ksun48",3679);
tik.put("Benq",3658);
tik.put("Um_nik",3630);
tik.put("apiad",3638);
tik.put("Stonefeang",3630);
tik.put("ecnerwala", 3613);
tik.put("mnbvmar", 3555);
tik.put("newbiedmy", 3516);
tik.put("semiexp", 3481);
Scanner kl=new Scanner(System.in);
String ma=kl.nextLine().trim();
if(tik.containsKey(ma)){
int pt=tik.get(ma);
System.out.println(pt);
}
}
}
import java.util.*;
public class Main{
public static void main(String [] args){
Map<String,Integer> tik=new HashMap<>();
tik.put("tourist",3858);
tik.put("ksun48",3679);
tik.put("Benq",3658);
tik.put("Um_nik",3648);
tik.put("apiad",3638);
tik.put("Stonefeang",3630);
tik.put("ecnerwala", 3613);
tik.put("mnbvmar", 3555);
tik.put("newbiedmy", 3516);
tik.put("semiexp", 3481);
Scanner kl=new Scanner(System.in);
String ma=kl.nextLine().trim();
if(tik.containsKey(ma)){
int pt=tik.get(ma);
System.out.println(pt);
}
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45404030 |
condefects-java_data_1938 | import java.util.*;
class Main{
public static void main(String [] args){
HashMap <String,Integer> top = new HashMap<String,Integer>();
top.put("tourist",3858);
top.put("ksun48",3679);
top.put("Benq",3658);
top.put("Um_nik",3648);
top.put("apiad",3638);
top.put("Stonefeang",3630);
top.put("ecnerwala",3613);
top.put("mnbvmar",3555);
top.put("newbiedmy",3516);
top.put("semiexp",3581);
Scanner scr = new Scanner(System.in);
String a = scr.next();
System.out.println(top.get(a));
}
}
import java.util.*;
class Main{
public static void main(String [] args){
HashMap <String,Integer> top = new HashMap<String,Integer>();
top.put("tourist",3858);
top.put("ksun48",3679);
top.put("Benq",3658);
top.put("Um_nik",3648);
top.put("apiad",3638);
top.put("Stonefeang",3630);
top.put("ecnerwala",3613);
top.put("mnbvmar",3555);
top.put("newbiedmy",3516);
top.put("semiexp",3481);
Scanner scr = new Scanner(System.in);
String a = scr.next();
System.out.println(top.get(a));
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45404910 |
condefects-java_data_1939 |
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
String S = scanner.nextLine();
String[] namesStrings = {"tourist","ksun38","Benq","Um_nik","apiad","Stonefeang","ecnerwala","mnbvmar","newbiedmy","semiexp"};
int[] rateArray = {3858,3679,3658,3648,3638,3630,3613,3555,3516,3481};
for(int i = 0;i<namesStrings.length;i++){
if(S.equals(namesStrings[i])){
System.out.println(rateArray[i]);
}
}
scanner.close();
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
String S = scanner.nextLine();
String[] namesStrings = {"tourist","ksun48","Benq","Um_nik","apiad","Stonefeang","ecnerwala","mnbvmar","newbiedmy","semiexp"};
int[] rateArray = {3858,3679,3658,3648,3638,3630,3613,3555,3516,3481};
for(int i = 0;i<namesStrings.length;i++){
if(S.equals(namesStrings[i])){
System.out.println(rateArray[i]);
}
}
scanner.close();
}
}
| ConDefects/ConDefects/Code/abc319_a/Java/45740674 |
condefects-java_data_1940 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int rate = 0;
switch(s) {
case "tourist":
rate = 3858;
break;
case "ksun48":
rate = 3679;
break;
case "Benq":
rate = 3658;
break;
case "Um_nik":
rate = 3648;
break;
case "apiad":
rate = 3838;
break;
case "Stonefeang":
rate = 3630;
break;
case "ecnerwala":
rate = 3613;
break;
case "mnbvmar":
rate =3555;
break;
case "newbiedmy":
rate = 3516;
break;
case "semiexp":
rate = 3481;
break;
}
System.out.println(rate);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int rate = 0;
switch(s) {
case "tourist":
rate = 3858;
break;
case "ksun48":
rate = 3679;
break;
case "Benq":
rate = 3658;
break;
case "Um_nik":
rate = 3648;
break;
case "apiad":
rate = 3638;
break;
case "Stonefeang":
rate = 3630;
break;
case "ecnerwala":
rate = 3613;
break;
case "mnbvmar":
rate =3555;
break;
case "newbiedmy":
rate = 3516;
break;
case "semiexp":
rate = 3481;
break;
}
System.out.println(rate);
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45454992 |
condefects-java_data_1941 | import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
// 整数の入力
String S = scanner.next();
// みんなの成績
Map<String, Integer> map = new HashMap<>();
// 手打ち
map.put("tourist", 3858);
map.put("ksun48", 3679);
map.put("Benq", 3658);
map.put("Um_nik", 3648);
map.put("apiad", 3638);
map.put("Stonefeang", 3630);
map.put("ecnerwala", 3613);
map.put("mnbvmar", 3555);
map.put("ewbiedmy", 3516);
map.put("semiexp", 3481);
// Mapからデータを取得する
System.out.println(map.get(S));
}
}
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
// 整数の入力
String S = scanner.next();
// みんなの成績
Map<String, Integer> map = new HashMap<>();
// 手打ち
map.put("tourist", 3858);
map.put("ksun48", 3679);
map.put("Benq", 3658);
map.put("Um_nik", 3648);
map.put("apiad", 3638);
map.put("Stonefeang", 3630);
map.put("ecnerwala", 3613);
map.put("mnbvmar", 3555);
map.put("newbiedmy", 3516);
map.put("semiexp", 3481);
// Mapからデータを取得する
System.out.println(map.get(S));
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45520211 |
condefects-java_data_1942 | import java.util.Scanner;
class Main {
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
String S = scanner.nextLine();
scanner.close();
switch(S){
case "tourist":
System.out.println(3858);
break;
case "ksun48":
System.out.println(3697);
break;
case "Benq":
System.out.println(3658);
break;
case "Um_nik":
System.out.println(3648);
break;
case "apiad":
System.out.println(3638);
break;
case "Stonefeang":
System.out.println(3630);
break;
case "ecnerwala":
System.out.println(3613);
break;
case "mnbvmar":
System.out.println(3555);
break;
case "newbiedmy":
System.out.println(3516);
break;
case "semiexp":
System.out.println(3481);
break;
}
}
}
import java.util.Scanner;
class Main {
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
String S = scanner.nextLine();
scanner.close();
switch(S){
case "tourist":
System.out.println(3858);
break;
case "ksun48":
System.out.println(3679);
break;
case "Benq":
System.out.println(3658);
break;
case "Um_nik":
System.out.println(3648);
break;
case "apiad":
System.out.println(3638);
break;
case "Stonefeang":
System.out.println(3630);
break;
case "ecnerwala":
System.out.println(3613);
break;
case "mnbvmar":
System.out.println(3555);
break;
case "newbiedmy":
System.out.println(3516);
break;
case "semiexp":
System.out.println(3481);
break;
}
}
}
| ConDefects/ConDefects/Code/abc319_a/Java/45706385 |
condefects-java_data_1943 | import java.util.*;
class Main
{
public static void main(String[] args)
{
Scanner csa=new Scanner(System.in);
String x=csa.next();
switch(x)
{
case "tourist":
System.out.println("3858");
break;
case "ksun48":
System.out.println("3679");
break;
case "Benq":
System.out.println("3658");
break;
case "Um_nik":
System.out.println("3648");
break;
case "apiad":
System.out.println("3638");
break;
case "stonefeang":
System.out.println("3630");
break;
case "ecnerwala":
System.out.println("3613");
break;
case "mnbvmar":
System.out.println("3555");
break;
case "newbiedmy":
System.out.println("3516");
break;
case "semiexp":
System.out.println("3481");
break;
}
}
}
import java.util.*;
class Main
{
public static void main(String[] args)
{
Scanner csa=new Scanner(System.in);
String x=csa.next();
switch(x)
{
case "tourist":
System.out.println("3858");
break;
case "ksun48":
System.out.println("3679");
break;
case "Benq":
System.out.println("3658");
break;
case "Um_nik":
System.out.println("3648");
break;
case "apiad":
System.out.println("3638");
break;
case "Stonefeang":
System.out.println("3630");
break;
case "ecnerwala":
System.out.println("3613");
break;
case "mnbvmar":
System.out.println("3555");
break;
case "newbiedmy":
System.out.println("3516");
break;
case "semiexp":
System.out.println("3481");
break;
}
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45407819 |
condefects-java_data_1944 | import java.util.*;
public class Main{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
Map<String,Integer> user=new HashMap<String,Integer>();
user.put("tourist",3458);
user.put("ksun48",3679);
user.put("Benq",3658);
user.put("Um_nik",3648);
user.put("apiad",3638);
user.put("Stonefeang",3630);
user.put("ecnerwala",3613);
user.put("mnbvmar",3555);
user.put("newbiedmy",3516);
user.put("semiexp",3481);
String s=sc.nextLine();
if(user.containsKey(s)){
int r=user.get(s);
System.out.println(r);
}
else
{
System.out.println("0");
}
}
}
import java.util.*;
public class Main{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
Map<String,Integer> user=new HashMap<String,Integer>();
user.put("tourist",3858);
user.put("ksun48",3679);
user.put("Benq",3658);
user.put("Um_nik",3648);
user.put("apiad",3638);
user.put("Stonefeang",3630);
user.put("ecnerwala",3613);
user.put("mnbvmar",3555);
user.put("newbiedmy",3516);
user.put("semiexp",3481);
String s=sc.nextLine();
if(user.containsKey(s)){
int r=user.get(s);
System.out.println(r);
}
else
{
System.out.println("0");
}
}
} | ConDefects/ConDefects/Code/abc319_a/Java/45394239 |
condefects-java_data_1945 | import java.util.*;
class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int N = scan.nextInt();
List<Integer> list = new ArrayList<>();
for(int i = 2; i <= 2 * N + 1; i++){
list.add(i);
}
System.out.println(1);
System.out.flush();
for(int i = 0; i < N / 2 + 1; i++){
int aoki = scan.nextInt();
list.remove(list.indexOf(aoki));
System.out.println(list.get(0));
System.out.flush();
list.remove(0);
}
scan.nextInt();
return;
}
}
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int N = scan.nextInt();
List<Integer> list = new ArrayList<>();
for(int i = 2; i <= 2 * N + 1; i++){
list.add(i);
}
System.out.println(1);
System.out.flush();
for(int i = 0; i < N; i++){
int aoki = scan.nextInt();
list.remove(list.indexOf(aoki));
System.out.println(list.get(0));
System.out.flush();
list.remove(0);
}
scan.nextInt();
return;
}
} | ConDefects/ConDefects/Code/abc244_c/Java/38070668 |
condefects-java_data_1946 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[2 * n + 1];
for (int i = 0 ; i <= n ; i++) {
for (int j = 0 ; j < 2 * n + 1 ; j++) {
if (a[j] == 0) {
System.out.println(a[j] + 1);
System.out.flush();
a[j]++;
break;
}
}
int m = sc.nextInt();
a[m - 1]++;
}
System.out.println(sc.nextInt());
return;
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[2 * n + 1];
for (int i = 0 ; i <= n ; i++) {
for (int j = 0 ; j < 2 * n + 1 ; j++) {
if (a[j] == 0) {
System.out.println(j + 1);
System.out.flush();
a[j]++;
break;
}
}
int m = sc.nextInt();
a[m - 1]++;
}
System.out.println(sc.nextInt());
return;
}
}
| ConDefects/ConDefects/Code/abc244_c/Java/31786237 |
condefects-java_data_1947 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), k = sc.nextInt();
int ans = n;
String s = sc.next();
char[] str = s.toCharArray();
//枚举循环节的长度
for(int i = 1; i * i <= n; i++){
//需要修改的次数累计变量
int cnt = 0;
//除不尽肯定不能当循环节的长度
if(n % i != 0){
continue;
}
//遍历第一组循环节
for(int j = 0; j < i; j++){
int[] cs = new int[26];
for(int m = 0; j + i * m < s.length(); m++){
cs[str[j + i * m] - 'a']++;
}
int sum = 0;
for(int num : cs){
sum += num;
}
sum -= Arrays.stream(cs).max().getAsInt();
cnt += sum;
}
if(cnt <= k){
ans = Math.min(ans, i);
}
}
System.out.println(ans);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(), k = sc.nextInt();
int ans = n;
String s = sc.next();
char[] str = s.toCharArray();
//枚举循环节的长度
for(int i = 1; i <= n; i++){
//需要修改的次数累计变量
int cnt = 0;
//除不尽肯定不能当循环节的长度
if(n % i != 0){
continue;
}
//遍历第一组循环节
for(int j = 0; j < i; j++){
int[] cs = new int[26];
for(int m = 0; j + i * m < s.length(); m++){
cs[str[j + i * m] - 'a']++;
}
int sum = 0;
for(int num : cs){
sum += num;
}
sum -= Arrays.stream(cs).max().getAsInt();
cnt += sum;
}
if(cnt <= k){
ans = Math.min(ans, i);
}
}
System.out.println(ans);
}
} | ConDefects/ConDefects/Code/arc140_a/Java/32078791 |
condefects-java_data_1948 |
import java.io.*;
import java.util.*;
public class Main {
private static int[][] dirs = {{-1,-1}, {1, 1}, {-1, 1}, {1, -1}};
private static long inf = (long) 1e13;
private static long div = 998_244_353L;
// private static long div = ((long)1e9) + 7;
public static class SegTree {
int n;
int[] t;
boolean[] marked;
SegTree(int n) {
this.n = n;
this.t = new int[4 * n + 1];
this.marked = new boolean[4 * n + 1];
}
void push(int v) {
if (marked[v]) {
t[v*2] = t[v*2+1] = t[v];
marked[v*2] = marked[v*2+1] = true;
marked[v] = false;
}
}
private void update(int v, int tl, int tr, int l, int r, int new_val) {
if (l > r)
return;
if (l == tl && tr == r) {
t[v] = new_val;
marked[v] = true;
} else {
push(v);
int tm = (tl + tr) / 2;
update(v*2, tl, tm, l, Math.min(r, tm), new_val);
update(v*2+1, tm+1, tr, Math.max(l, tm+1), r, new_val);
}
}
void update(int l, int r, int new_val) {
update(1, 1, n, l, r, new_val);
}
private int get(int v, int tl, int tr, int pos) {
if (tl == tr) {
return t[v];
}
push(v);
int tm = (tl + tr) / 2;
if (pos <= tm)
return get(v*2, tl, tm, pos);
else
return get(v*2+1, tm+1, tr, pos);
}
int get(int pos) {
return get(1, 1, n, pos);
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
private static void swap(char[] arr, int i, int j) {
char tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
private static void perms(int offset, List<List<Integer>> perms, int[] arr) {
if (offset == arr.length) {
List<Integer> perm = new ArrayList<>();
for (int j : arr) perm.add(j);
perms.add(perm);
return;
}
for(int i = offset; i < arr.length; ++i) {
swap(arr, offset, i);
perms(offset + 1, perms, arr);
swap(arr, offset, i);
}
}
private static long pow(long num, long pow, long div) {
if (pow == 0) return 1L;
long res = pow(num, pow/2, div);
long ret = 1;
if (pow % 2 != 0) ret = num % div;
ret = (ret * res) % div;
ret = (ret * res) % div;
return ret;
}
private static void dfs(int source, List<List<int[]>> adj, boolean[] visited, boolean[] marked) {
for(var ng:adj.get(source)) {
int to = ng[0];
int eId = ng[1];
if (visited[to]) continue;
visited[to] = true;
marked[eId] = true;
dfs(to, adj, visited, marked);
}
}
private static void bfs(List<List<int[]>> adj, boolean[] visited, boolean[] marked) {
visited[0] = true;
Queue<Integer> bfs = new LinkedList<>();
bfs.add(0);
while(!bfs.isEmpty()) {
Queue<Integer> next = new LinkedList<>();
while(!bfs.isEmpty()) {
var head = bfs.remove();
for(var ng:adj.get(head)) {
int to = ng[0];
int eId = ng[1];
if (visited[to]) continue;
visited[to] = true;
marked[eId] = true;
next.add(to);
}
}
bfs = next;
}
}
public static void main(String[] commands) throws Exception {
BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
String[] parts = rd.readLine().split(" ");
int N = Integer.parseInt(parts[0]);
int K = Integer.parseInt(parts[1]);
String s = rd.readLine();
List<Integer> divs = new ArrayList<>();
for(int x = 1; x * x <= N; ++x) {
if (N % x != 0) continue;
int first = x;
int second = N/x;
divs.add(first);
if (first != second) {
divs.add(second);
}
}
for(var t:divs) {
if (N % t != 0) continue;
boolean[] visited = new boolean[N];
int k = K;
for(int st = 0;st < N; ++st) {
int[] count = new int[26];
int offset = st;
while(offset < N && !visited[offset]) {
visited[offset] = true;
int curr = s.charAt(offset) - 'a';
count[curr]++;
offset += t;
}
int total = 0;
int max = 0;
for(int c:count) {
max = Math.max(max, c);
total += c;
}
k -= total - max;
}
if (k >= 0) {
System.out.println(t);
return;
}
}
}
}
import java.io.*;
import java.util.*;
public class Main {
private static int[][] dirs = {{-1,-1}, {1, 1}, {-1, 1}, {1, -1}};
private static long inf = (long) 1e13;
private static long div = 998_244_353L;
// private static long div = ((long)1e9) + 7;
public static class SegTree {
int n;
int[] t;
boolean[] marked;
SegTree(int n) {
this.n = n;
this.t = new int[4 * n + 1];
this.marked = new boolean[4 * n + 1];
}
void push(int v) {
if (marked[v]) {
t[v*2] = t[v*2+1] = t[v];
marked[v*2] = marked[v*2+1] = true;
marked[v] = false;
}
}
private void update(int v, int tl, int tr, int l, int r, int new_val) {
if (l > r)
return;
if (l == tl && tr == r) {
t[v] = new_val;
marked[v] = true;
} else {
push(v);
int tm = (tl + tr) / 2;
update(v*2, tl, tm, l, Math.min(r, tm), new_val);
update(v*2+1, tm+1, tr, Math.max(l, tm+1), r, new_val);
}
}
void update(int l, int r, int new_val) {
update(1, 1, n, l, r, new_val);
}
private int get(int v, int tl, int tr, int pos) {
if (tl == tr) {
return t[v];
}
push(v);
int tm = (tl + tr) / 2;
if (pos <= tm)
return get(v*2, tl, tm, pos);
else
return get(v*2+1, tm+1, tr, pos);
}
int get(int pos) {
return get(1, 1, n, pos);
}
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
private static void swap(char[] arr, int i, int j) {
char tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
private static void perms(int offset, List<List<Integer>> perms, int[] arr) {
if (offset == arr.length) {
List<Integer> perm = new ArrayList<>();
for (int j : arr) perm.add(j);
perms.add(perm);
return;
}
for(int i = offset; i < arr.length; ++i) {
swap(arr, offset, i);
perms(offset + 1, perms, arr);
swap(arr, offset, i);
}
}
private static long pow(long num, long pow, long div) {
if (pow == 0) return 1L;
long res = pow(num, pow/2, div);
long ret = 1;
if (pow % 2 != 0) ret = num % div;
ret = (ret * res) % div;
ret = (ret * res) % div;
return ret;
}
private static void dfs(int source, List<List<int[]>> adj, boolean[] visited, boolean[] marked) {
for(var ng:adj.get(source)) {
int to = ng[0];
int eId = ng[1];
if (visited[to]) continue;
visited[to] = true;
marked[eId] = true;
dfs(to, adj, visited, marked);
}
}
private static void bfs(List<List<int[]>> adj, boolean[] visited, boolean[] marked) {
visited[0] = true;
Queue<Integer> bfs = new LinkedList<>();
bfs.add(0);
while(!bfs.isEmpty()) {
Queue<Integer> next = new LinkedList<>();
while(!bfs.isEmpty()) {
var head = bfs.remove();
for(var ng:adj.get(head)) {
int to = ng[0];
int eId = ng[1];
if (visited[to]) continue;
visited[to] = true;
marked[eId] = true;
next.add(to);
}
}
bfs = next;
}
}
public static void main(String[] commands) throws Exception {
BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
String[] parts = rd.readLine().split(" ");
int N = Integer.parseInt(parts[0]);
int K = Integer.parseInt(parts[1]);
String s = rd.readLine();
List<Integer> divs = new ArrayList<>();
for(int x = 1; x * x <= N; ++x) {
if (N % x != 0) continue;
int first = x;
int second = N/x;
divs.add(first);
if (first != second) {
divs.add(second);
}
}
Collections.sort(divs);
for(var t:divs) {
boolean[] visited = new boolean[N];
int k = K;
for(int st = 0;st < N; ++st) {
int[] count = new int[26];
int offset = st;
while(offset < N && !visited[offset]) {
visited[offset] = true;
int curr = s.charAt(offset) - 'a';
count[curr]++;
offset += t;
}
int total = 0;
int max = 0;
for(int c:count) {
max = Math.max(max, c);
total += c;
}
k -= total - max;
}
if (k >= 0) {
System.out.println(t);
return;
}
}
}
}
| ConDefects/ConDefects/Code/arc140_a/Java/31731372 |
condefects-java_data_1949 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
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;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.readInt();
int k = in.readInt();
char[] s = in.readString().toCharArray();
// abcabc
for (int i = 1; i <= s.length / 2; i++) {
int cnt = 0;
int[][] t = new int[i][26];
for (int x = 0; x < i; x++) t[x][s[x] - 'a']++;
for (int j = i; j < s.length; j++) {
t[j % i][s[j] - 'a']++;
}
for (int x = 0; x < i; x++) {
Arrays.sort(t[x]);
int sum = 0;
for (int y = 0; y < 25; y++) sum += t[x][y];
cnt += sum;
}
if (cnt <= k) {
out.println(i);
return;
}
}
out.println(n);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.IOException;
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;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
static class TaskA {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.readInt();
int k = in.readInt();
char[] s = in.readString().toCharArray();
int ans = 0;
// abcabc
for (int i = 1; i <= s.length / 2; i++) {
if (n % i != 0) continue;
int cnt = 0;
int[][] t = new int[i][26];
for (int x = 0; x < i; x++) t[x][s[x] - 'a']++;
for (int j = i; j < s.length; j++) {
t[j % i][s[j] - 'a']++;
}
for (int x = 0; x < i; x++) {
Arrays.sort(t[x]);
int sum = 0;
for (int y = 0; y < 25; y++) sum += t[x][y];
cnt += sum;
}
if (cnt <= k) {
out.println(i);
return;
}
}
out.println(n);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| ConDefects/ConDefects/Code/arc140_a/Java/31720582 |
condefects-java_data_1950 | import java.util.*;
import java.io.*;
class Main{
static ArrayList<ArrayList<Integer>> list;
static FastScanner fs = null;
public static void main(String[] args) {
fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = fs.nextInt();
int k = fs.nextInt();
String s = fs.next();
char ch[] = new char[n+1];
for(int i=1;i<=n;i++){
ch[i] = s.charAt(i-1);
}
for(int i=1;i<=n;i++){
if(n%i!=0)
continue;
int co = 0;
for(int y = 1;y<=i;y++){
Map<Integer,Integer> map = new HashMap<>();
int f = 0;
int g = 0;
for(int j = y;j<=n;j+=i){
f+=1;
int d = j%(i);
if(d==0)
d = i;
int x = ch[j]-'a';
if(map.get(x)==null){
map.put(x,1);
g = 1;
}
else{
map.replace(x,1+map.get(x));
g = Math.max(g,map.get(x));
}
}
co+=(f-g);
}
// out.println(co+" --");
if(co<=k){
out.println((i));
break;
}
}
out.close();
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
}
import java.util.*;
import java.io.*;
class Main{
static ArrayList<ArrayList<Integer>> list;
static FastScanner fs = null;
public static void main(String[] args) {
fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
int n = fs.nextInt();
int k = fs.nextInt();
String s = fs.next();
char ch[] = new char[n+1];
for(int i=1;i<=n;i++){
ch[i] = s.charAt(i-1);
}
for(int i=1;i<=n;i++){
if(n%i!=0)
continue;
int co = 0;
for(int y = 1;y<=i;y++){
Map<Integer,Integer> map = new HashMap<>();
int f = 0;
int g = 0;
for(int j = y;j<=n;j+=i){
f+=1;
int d = j%(i);
if(d==0)
d = i;
int x = ch[j]-'a';
if(map.get(x)==null){
map.put(x,1);
g = Math.max(g,1);
}
else{
map.replace(x,1+map.get(x));
g = Math.max(g,map.get(x));
}
}
co+=(f-g);
}
// out.println(co+" --");
if(co<=k){
out.println((i));
break;
}
}
out.close();
}
static void sort(int[] a) {
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
}
} | ConDefects/ConDefects/Code/arc140_a/Java/32421525 |
condefects-java_data_1951 | import java.io.PrintWriter;
public class Main {
public static void main(String[] args) throws Exception {
final FastScanner sc = new FastScanner(System.in);
final int n = sc.nextInt();
final int q = sc.nextInt();
final DisjointSetUnion dsu = new DisjointSetUnion(n + q);
final int[] box2grp = new int[n + q];
final int[] grp2box = new int[n + q];
for (int i = 0; i < n + q; i++) {
box2grp[i] = dsu.leader(i);
grp2box[dsu.leader(i)] = i;
}
final PrintWriter pw = new PrintWriter(System.out);
int next_ball = n;
for (int cnt = 0; cnt < q; cnt++) {
int t = sc.nextInt();
if (t == 1) {
int box_x = sc.nextInt() - 1;
int box_y = sc.nextInt() - 1;
if (box2grp[box_y] != -1) {
if (box2grp[box_x] != -1) {
//箱Xと箱Yにあるグループをマージ
dsu.merge(dsu.leader(box2grp[box_x]), dsu.leader(box2grp[box_y]));
}
grp2box[dsu.leader(box2grp[box_y])] = box_x;
//箱Yを空にする
box2grp[box_y] = -1;
}
} else if (t == 2) {
int box_x = sc.nextInt() - 1;
if (box2grp[box_x] != -1) {
dsu.merge(dsu.leader(box2grp[box_x]), dsu.leader(next_ball));
}
grp2box[dsu.leader(next_ball)] = box_x;
box2grp[box_x] = dsu.leader(next_ball);
next_ball++;
} else if (t == 3) {
int ball_x = sc.nextInt() - 1;
pw.println(grp2box[dsu.leader(ball_x)] + 1);
}
}
pw.close();
sc.close();
}
//DisjointSetUnionライブラリ
static class DisjointSetUnion {
private final int n;
private final int[] parent_or_size;
public DisjointSetUnion(int n) {
this.n = n;
parent_or_size = new int[n];
java.util.Arrays.fill(parent_or_size, -1);
}
public int merge(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return -1;
}
int x = leader(a);
int y = leader(b);
if (x == y) {
return x;
}
if (-parent_or_size[x] < -parent_or_size[y]) {
int temp = x;
x = y;
y = temp;
}
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
public boolean isSame(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return false;
}
return leader(a) == leader(b);
}
public int leader(int a) {
if (parent_or_size[a] < 0) {
return a;
} else {
parent_or_size[a] = leader(parent_or_size[a]);
return parent_or_size[a];
}
}
public int size(int a) {
if (!(0 <= a && a < n)) {
return -1;
}
return -parent_or_size[leader(a)];
}
public java.util.List<java.util.List<Integer>> groups() {
int m = 0;
java.util.List<java.util.List<Integer>> result = new java.util.ArrayList<>();
java.util.Map<Integer, Integer> map_leader = new java.util.HashMap<>();
for (int i = 0; i < n; i++) {
int lead = leader(i);
if (!map_leader.containsKey(lead)) {
map_leader.put(lead, m++);
result.add(new java.util.ArrayList<>());
}
result.get(map_leader.get(lead)).add(i);
}
return result;
}
}
// FastScannerライブラリ
static class FastScanner implements AutoCloseable {
private final java.io.InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner(java.io.InputStream source) {
this.in = source;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buf);
} catch (java.io.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 java.util.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 java.util.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());
}
@Override
public void close() throws Exception {
in.close();
}
}
}
import java.io.PrintWriter;
public class Main {
public static void main(String[] args) throws Exception {
final FastScanner sc = new FastScanner(System.in);
final int n = sc.nextInt();
final int q = sc.nextInt();
final DisjointSetUnion dsu = new DisjointSetUnion(n + q);
final int[] box2grp = new int[n + q];
final int[] grp2box = new int[n + q];
for (int i = 0; i < n + q; i++) {
box2grp[i] = dsu.leader(i);
grp2box[dsu.leader(i)] = i;
}
final PrintWriter pw = new PrintWriter(System.out);
int next_ball = n;
for (int cnt = 0; cnt < q; cnt++) {
int t = sc.nextInt();
if (t == 1) {
int box_x = sc.nextInt() - 1;
int box_y = sc.nextInt() - 1;
if (box2grp[box_y] != -1) {
if (box2grp[box_x] != -1) {
//箱Xと箱Yにあるグループをマージ
dsu.merge(dsu.leader(box2grp[box_x]), dsu.leader(box2grp[box_y]));
}
grp2box[dsu.leader(box2grp[box_y])] = box_x;
//箱Xの中身は、箱Yのあったグループになる
box2grp[box_x] = dsu.leader(box2grp[box_y]);
//箱Yを空にする
box2grp[box_y] = -1;
}
} else if (t == 2) {
int box_x = sc.nextInt() - 1;
if (box2grp[box_x] != -1) {
dsu.merge(dsu.leader(box2grp[box_x]), dsu.leader(next_ball));
}
grp2box[dsu.leader(next_ball)] = box_x;
box2grp[box_x] = dsu.leader(next_ball);
next_ball++;
} else if (t == 3) {
int ball_x = sc.nextInt() - 1;
pw.println(grp2box[dsu.leader(ball_x)] + 1);
}
}
pw.close();
sc.close();
}
//DisjointSetUnionライブラリ
static class DisjointSetUnion {
private final int n;
private final int[] parent_or_size;
public DisjointSetUnion(int n) {
this.n = n;
parent_or_size = new int[n];
java.util.Arrays.fill(parent_or_size, -1);
}
public int merge(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return -1;
}
int x = leader(a);
int y = leader(b);
if (x == y) {
return x;
}
if (-parent_or_size[x] < -parent_or_size[y]) {
int temp = x;
x = y;
y = temp;
}
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
public boolean isSame(int a, int b) {
if (!(0 <= a && a < n) || !(0 <= b && b < n)) {
return false;
}
return leader(a) == leader(b);
}
public int leader(int a) {
if (parent_or_size[a] < 0) {
return a;
} else {
parent_or_size[a] = leader(parent_or_size[a]);
return parent_or_size[a];
}
}
public int size(int a) {
if (!(0 <= a && a < n)) {
return -1;
}
return -parent_or_size[leader(a)];
}
public java.util.List<java.util.List<Integer>> groups() {
int m = 0;
java.util.List<java.util.List<Integer>> result = new java.util.ArrayList<>();
java.util.Map<Integer, Integer> map_leader = new java.util.HashMap<>();
for (int i = 0; i < n; i++) {
int lead = leader(i);
if (!map_leader.containsKey(lead)) {
map_leader.put(lead, m++);
result.add(new java.util.ArrayList<>());
}
result.get(map_leader.get(lead)).add(i);
}
return result;
}
}
// FastScannerライブラリ
static class FastScanner implements AutoCloseable {
private final java.io.InputStream in;
private final byte[] buf = new byte[1024];
private int ptr = 0;
private int buflen = 0;
FastScanner(java.io.InputStream source) {
this.in = source;
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buf);
} catch (java.io.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 java.util.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 java.util.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());
}
@Override
public void close() throws Exception {
in.close();
}
}
}
| ConDefects/ConDefects/Code/abc279_f/Java/37611607 |
condefects-java_data_1952 | import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
Main() { super(System.out); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
Main o = new Main(); o.main(); o.flush();
}
byte[][] cc;
void mark(int i, int j) {
cc[i][j] = '#';
}
void solve(int l, int r) {
while (r - l + 1 >= 10) {
// ##..#
// #..##
// .....
// .#.##
// ##..#
mark(l, l);
mark(l, l + 1);
mark(l + 1, l);
mark(l, r);
mark(l + 1, r);
mark(l + 1, r - 1);
mark(r, l);
mark(r, l + 1);
mark(r - 1, l + 1);
mark(r, r);
mark(r - 1, r);
mark(r - 1, r - 1);
l += 2;
r -= 2;
}
if (r - l + 1 == 6) {
// ###...
// ...###
// ###...
// ...###
// ###...
// ...###
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 2);
mark(l + 1, l + 3); mark(l + 1, l + 4); mark(l + 1, l + 5);
mark(l + 2, l + 0); mark(l + 2, l + 1); mark(l + 2, l + 2);
mark(l + 3, l + 3); mark(l + 3, l + 4); mark(l + 3, l + 5);
mark(l + 4, l + 0); mark(l + 4, l + 1); mark(l + 4, l + 2);
mark(l + 5, l + 3); mark(l + 5, l + 4); mark(l + 5, l + 5);
} else if (r - l + 1 == 7) {
// ##...#.
// ##....#
// ..###..
// ..###..
// ..###..
// #....##
// .#...##
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 5);
mark(l + 1, l + 0); mark(l + 1, l + 1); mark(l + 1, l + 6);
mark(l + 2, l + 2); mark(l + 2, l + 3); mark(l + 2, l + 4);
mark(l + 3, l + 2); mark(l + 3, l + 3); mark(l + 3, l + 4);
mark(l + 4, l + 2); mark(l + 4, l + 3); mark(l + 4, l + 4);
mark(l + 5, l + 0); mark(l + 5, l + 5); mark(l + 5, l + 6);
mark(l + 6, l + 1); mark(l + 6, l + 5); mark(l + 6, l + 6);
} else if (r - l + 1 == 8) {
// ##...#..
// #...##..
// ..##...#
// ..#...##
// .#..##..
// ##..#...
// ...#..##
// ..##..#.
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 5);
mark(l + 1, l + 0); mark(l + 1, l + 4); mark(l + 1, l + 5);
mark(l + 2, l + 2); mark(l + 2, l + 3); mark(l + 2, l + 7);
mark(l + 3, l + 2); mark(l + 3, l + 6); mark(l + 3, l + 7);
mark(l + 4, l + 1); mark(l + 4, l + 4); mark(l + 4, l + 5);
mark(l + 5, l + 0); mark(l + 5, l + 1); mark(l + 5, l + 4);
mark(l + 6, l + 3); mark(l + 6, l + 6); mark(l + 6, l + 7);
mark(l + 7, l + 2); mark(l + 7, l + 3); mark(l + 7, l + 6);
} else if (r - l + 1 == 9) {
// ###...
// ...###
// ......###
// ###...
// ...###
// ......###
// ###...
// ...###
// ......###
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 2);
mark(l + 1, l + 3); mark(l + 1, l + 4); mark(l + 1, l + 5);
mark(l + 2, l + 6); mark(l + 2, l + 7); mark(l + 2, l + 8);
mark(l + 3, l + 0); mark(l + 3, l + 1); mark(l + 3, l + 2);
mark(l + 4, l + 3); mark(l + 4, l + 4); mark(l + 4, l + 5);
mark(l + 5, l + 6); mark(l + 5, l + 7); mark(l + 5, l + 8);
mark(l + 6, l + 0); mark(l + 6, l + 1); mark(l + 6, l + 2);
mark(l + 7, l + 3); mark(l + 7, l + 4); mark(l + 7, l + 5);
mark(l + 8, l + 6); mark(l + 8, l + 7); mark(l + 8, l + 8);
}
}
void main() {
int n = sc.nextInt();
cc = new byte[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cc[i][j] = '.';
solve(0, n - 1);
for (int i = 0; i < n; i++)
println(new String(cc[i]));
}
}
import java.io.*;
import java.util.*;
public class Main extends PrintWriter {
Main() { super(System.out); }
Scanner sc = new Scanner(System.in);
public static void main(String[] $) {
Main o = new Main(); o.main(); o.flush();
}
byte[][] cc;
void mark(int i, int j) {
cc[i][j] = '#';
}
void solve(int l, int r) {
while (r - l + 1 >= 10) {
// ##..#
// #..##
// .....
// .#.##
// ##..#
mark(l, l);
mark(l, l + 1);
mark(l + 1, l);
mark(l, r);
mark(l + 1, r);
mark(l + 1, r - 1);
mark(r, l);
mark(r, l + 1);
mark(r - 1, l + 1);
mark(r, r - 1);
mark(r - 1, r);
mark(r - 1, r - 1);
l += 2;
r -= 2;
}
if (r - l + 1 == 6) {
// ###...
// ...###
// ###...
// ...###
// ###...
// ...###
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 2);
mark(l + 1, l + 3); mark(l + 1, l + 4); mark(l + 1, l + 5);
mark(l + 2, l + 0); mark(l + 2, l + 1); mark(l + 2, l + 2);
mark(l + 3, l + 3); mark(l + 3, l + 4); mark(l + 3, l + 5);
mark(l + 4, l + 0); mark(l + 4, l + 1); mark(l + 4, l + 2);
mark(l + 5, l + 3); mark(l + 5, l + 4); mark(l + 5, l + 5);
} else if (r - l + 1 == 7) {
// ##...#.
// ##....#
// ..###..
// ..###..
// ..###..
// #....##
// .#...##
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 5);
mark(l + 1, l + 0); mark(l + 1, l + 1); mark(l + 1, l + 6);
mark(l + 2, l + 2); mark(l + 2, l + 3); mark(l + 2, l + 4);
mark(l + 3, l + 2); mark(l + 3, l + 3); mark(l + 3, l + 4);
mark(l + 4, l + 2); mark(l + 4, l + 3); mark(l + 4, l + 4);
mark(l + 5, l + 0); mark(l + 5, l + 5); mark(l + 5, l + 6);
mark(l + 6, l + 1); mark(l + 6, l + 5); mark(l + 6, l + 6);
} else if (r - l + 1 == 8) {
// ##...#..
// #...##..
// ..##...#
// ..#...##
// .#..##..
// ##..#...
// ...#..##
// ..##..#.
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 5);
mark(l + 1, l + 0); mark(l + 1, l + 4); mark(l + 1, l + 5);
mark(l + 2, l + 2); mark(l + 2, l + 3); mark(l + 2, l + 7);
mark(l + 3, l + 2); mark(l + 3, l + 6); mark(l + 3, l + 7);
mark(l + 4, l + 1); mark(l + 4, l + 4); mark(l + 4, l + 5);
mark(l + 5, l + 0); mark(l + 5, l + 1); mark(l + 5, l + 4);
mark(l + 6, l + 3); mark(l + 6, l + 6); mark(l + 6, l + 7);
mark(l + 7, l + 2); mark(l + 7, l + 3); mark(l + 7, l + 6);
} else if (r - l + 1 == 9) {
// ###...
// ...###
// ......###
// ###...
// ...###
// ......###
// ###...
// ...###
// ......###
mark(l + 0, l + 0); mark(l + 0, l + 1); mark(l + 0, l + 2);
mark(l + 1, l + 3); mark(l + 1, l + 4); mark(l + 1, l + 5);
mark(l + 2, l + 6); mark(l + 2, l + 7); mark(l + 2, l + 8);
mark(l + 3, l + 0); mark(l + 3, l + 1); mark(l + 3, l + 2);
mark(l + 4, l + 3); mark(l + 4, l + 4); mark(l + 4, l + 5);
mark(l + 5, l + 6); mark(l + 5, l + 7); mark(l + 5, l + 8);
mark(l + 6, l + 0); mark(l + 6, l + 1); mark(l + 6, l + 2);
mark(l + 7, l + 3); mark(l + 7, l + 4); mark(l + 7, l + 5);
mark(l + 8, l + 6); mark(l + 8, l + 7); mark(l + 8, l + 8);
}
}
void main() {
int n = sc.nextInt();
cc = new byte[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
cc[i][j] = '.';
solve(0, n - 1);
for (int i = 0; i < n; i++)
println(new String(cc[i]));
}
}
| ConDefects/ConDefects/Code/agc056_a/Java/27694075 |
condefects-java_data_1953 | import java.util.*; import java.io.*; import java.math.*;
public class Main{
//見なくていいよ ここから------------------------------------------
static class InputIterator{
ArrayList<String> inputLine = new ArrayList<>(1024);
int index = 0; int max; String read;
InputIterator(){
try{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
while((read = br.readLine()) != null){
inputLine.addAll(Arrays.asList(read.split(" ")));
}
}catch(IOException e){}
max = inputLine.size();
}
boolean hasNext(){return (index < max);}
String next(){
if(hasNext()){
return inputLine.get(index++);
}else{
throw new IndexOutOfBoundsException("There is no more input");
}
}
}
static HashMap<Integer, String> CONVSTR = new HashMap<>();
static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
static PrintWriter out = new PrintWriter(System.out);
static void flush(){out.flush();}
static void myout(Object t){out.println(t);}
static void myerr(Object... t){System.err.print("debug:");System.err.println(Arrays.deepToString(t));}
static String next(){return ii.next();}
static boolean hasNext(){return ii.hasNext();}
static int nextInt(){return Integer.parseInt(next());}
static long nextLong(){return Long.parseLong(next());}
static double nextDouble(){return Double.parseDouble(next());}
static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
static ArrayList<String> nextStrArray(int size){
ArrayList<String> ret = new ArrayList<>(size);
for(int i = 0; i < size; i++){
ret.add(next());
}
return ret;
}
static ArrayList<Integer> nextIntArray(int size){
ArrayList<Integer> ret = new ArrayList<>(size);
for(int i = 0; i < size; i++){
ret.add(Integer.parseInt(next()));
}
return ret;
}
static ArrayList<Long> nextLongArray(int size){
ArrayList<Long> ret = new ArrayList<>(size);
for(int i = 0; i < size; i++){
ret.add(Long.parseLong(next()));
}
return ret;
}
@SuppressWarnings("unchecked")
static String myconv(Object list, int no){//only join
StringBuilder sb = new StringBuilder("");
String joinString = CONVSTR.get(no);
if(list instanceof String[]){
return String.join(joinString, (String[])list);
}else if(list instanceof long[]){
long[] tmp = (long[])list;
if(tmp.length == 0){
return "";
}
sb.append(String.valueOf(tmp[0]));
for(int i = 1; i < tmp.length; i++){
sb.append(joinString).append(String.valueOf(tmp[i]));
}
return sb.toString();
}else if(list instanceof int[]){
int[] tmp = (int[])list;
if(tmp.length == 0){
return "";
}
sb.append(String.valueOf(tmp[0]));
for(int i = 1; i < tmp.length; i++){
sb.append(joinString).append(String.valueOf(tmp[i]));
}
return sb.toString();
}else if(list instanceof ArrayList){
ArrayList tmp = (ArrayList)list;
if(tmp.size() == 0){
return "";
}
sb.append(tmp.get(0));
for(int i = 1; i < tmp.size(); i++){
sb.append(joinString).append(tmp.get(i));
}
return sb.toString();
}else{
throw new ClassCastException("Don't join");
}
}
static ArrayList<String> myconv(String str, int no){//only split
String splitString = CONVSTR.get(no);
return new ArrayList<String>(Arrays.asList(str.split(splitString)));
}
static ArrayList<String> myconv(String str, String no){
return new ArrayList<String>(Arrays.asList(str.split(no)));
}
public static void main(String[] args){
CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
solve();flush();
}
//見なくていいよ ここまで------------------------------------------
//このコードをコンパイルするときは、「-encoding UTF-8」を指定すること
static void solve(){//ここがメイン関数
int N = nextInt();
String S = next();
String output = S;
int L = S.indexOf("p");
if(L == -1){
L = N;
}
for(int R = L + 1; R < N; R++){
String V = "";
for(int j = R; j >= L; j--){
V += (S.charAt(j) == 'p') ? "d" : "p";
}
String check = S.substring(0, L) + V + S.substring(R + 1, N);
if(output.compareTo(check) >= 1){
output = check;
}
}
myout(output);
}
//メソッド追加エリア ここから
//メソッド追加エリア ここまで
}
import java.util.*; import java.io.*; import java.math.*;
public class Main{
//見なくていいよ ここから------------------------------------------
static class InputIterator{
ArrayList<String> inputLine = new ArrayList<>(1024);
int index = 0; int max; String read;
InputIterator(){
try{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
while((read = br.readLine()) != null){
inputLine.addAll(Arrays.asList(read.split(" ")));
}
}catch(IOException e){}
max = inputLine.size();
}
boolean hasNext(){return (index < max);}
String next(){
if(hasNext()){
return inputLine.get(index++);
}else{
throw new IndexOutOfBoundsException("There is no more input");
}
}
}
static HashMap<Integer, String> CONVSTR = new HashMap<>();
static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
static PrintWriter out = new PrintWriter(System.out);
static void flush(){out.flush();}
static void myout(Object t){out.println(t);}
static void myerr(Object... t){System.err.print("debug:");System.err.println(Arrays.deepToString(t));}
static String next(){return ii.next();}
static boolean hasNext(){return ii.hasNext();}
static int nextInt(){return Integer.parseInt(next());}
static long nextLong(){return Long.parseLong(next());}
static double nextDouble(){return Double.parseDouble(next());}
static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
static ArrayList<String> nextStrArray(int size){
ArrayList<String> ret = new ArrayList<>(size);
for(int i = 0; i < size; i++){
ret.add(next());
}
return ret;
}
static ArrayList<Integer> nextIntArray(int size){
ArrayList<Integer> ret = new ArrayList<>(size);
for(int i = 0; i < size; i++){
ret.add(Integer.parseInt(next()));
}
return ret;
}
static ArrayList<Long> nextLongArray(int size){
ArrayList<Long> ret = new ArrayList<>(size);
for(int i = 0; i < size; i++){
ret.add(Long.parseLong(next()));
}
return ret;
}
@SuppressWarnings("unchecked")
static String myconv(Object list, int no){//only join
StringBuilder sb = new StringBuilder("");
String joinString = CONVSTR.get(no);
if(list instanceof String[]){
return String.join(joinString, (String[])list);
}else if(list instanceof long[]){
long[] tmp = (long[])list;
if(tmp.length == 0){
return "";
}
sb.append(String.valueOf(tmp[0]));
for(int i = 1; i < tmp.length; i++){
sb.append(joinString).append(String.valueOf(tmp[i]));
}
return sb.toString();
}else if(list instanceof int[]){
int[] tmp = (int[])list;
if(tmp.length == 0){
return "";
}
sb.append(String.valueOf(tmp[0]));
for(int i = 1; i < tmp.length; i++){
sb.append(joinString).append(String.valueOf(tmp[i]));
}
return sb.toString();
}else if(list instanceof ArrayList){
ArrayList tmp = (ArrayList)list;
if(tmp.size() == 0){
return "";
}
sb.append(tmp.get(0));
for(int i = 1; i < tmp.size(); i++){
sb.append(joinString).append(tmp.get(i));
}
return sb.toString();
}else{
throw new ClassCastException("Don't join");
}
}
static ArrayList<String> myconv(String str, int no){//only split
String splitString = CONVSTR.get(no);
return new ArrayList<String>(Arrays.asList(str.split(splitString)));
}
static ArrayList<String> myconv(String str, String no){
return new ArrayList<String>(Arrays.asList(str.split(no)));
}
public static void main(String[] args){
CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
solve();flush();
}
//見なくていいよ ここまで------------------------------------------
//このコードをコンパイルするときは、「-encoding UTF-8」を指定すること
static void solve(){//ここがメイン関数
int N = nextInt();
String S = next();
String output = S;
int L = S.indexOf("p");
if(L == -1){
L = N;
}
for(int R = L; R < N; R++){
String V = "";
for(int j = R; j >= L; j--){
V += (S.charAt(j) == 'p') ? "d" : "p";
}
String check = S.substring(0, L) + V + S.substring(R + 1, N);
if(output.compareTo(check) >= 1){
output = check;
}
}
myout(output);
}
//メソッド追加エリア ここから
//メソッド追加エリア ここまで
}
| ConDefects/ConDefects/Code/arc148_b/Java/35459787 |
condefects-java_data_1954 | //Some of the methods are copied from GeeksforGeeks Website
import java.util.*;
import java.lang.*;
import java.text.BreakIterator;
import java.io.*;
@SuppressWarnings("unchecked")
public class Main
{
//static Scanner sc=new Scanner(System.in);
//static Reader sc=new Reader();
static FastReader sc=new FastReader(System.in);
static long mod = (long)(1e9)+ 7;
static int max_num=(int)1e5+5;
static List<Integer> gr[];
static String fun(String s,int f,int l)
{
String ss=s.substring(f,l+1);
StringBuilder sb=new StringBuilder(""); sb.append(ss); sb=sb.reverse(); String rev=sb.toString();
StringBuilder sb2=new StringBuilder("");
char a[]=rev.toCharArray();
for(int i=0;i<rev.length();i++)
{
if(a[i]=='p') sb2.append("d");
else sb2.append("p");
}
return sb2.toString();
}
public static void main (String[] args) throws java.lang.Exception
{
try{
/* out.println("Case #"+tt+": "+ans );
gr=new ArrayList[n];
for(int i=0;i<n;i++) gr[i]=new ArrayList<>();
while(l<=r)
{
int m=l+(r-l)/2;
if(val(m))
{
ans=m;
l=m+1;
}
else
r=m-1;
}
Collections.sort(al,Collections.reverseOrder());
StringBuilder sb=new StringBuilder(""); sb.append(cur); sb=sb.reverse(); String rev=sb.toString();
map.put(a[i],map.getOrDefault(a[i],0)+1);
map.putIfAbsent(x,new ArrayList<>());
long n=sc.nextLong();
String s=sc.next();
char a[]=s.toCharArray();
*/
int t = 1;//sc.nextInt();
for(int tt=1;tt<=t;tt++)
{
int n=sc.nextInt();
String s=sc.next();
char a[]=s.toCharArray();
String ans=s;
int l=0;
while(l<n && a[l]=='d') l++;
for(int r=l+1;r<n;r++)
{
String f=s.substring(0,l);
String m=fun(s,l,r);
String last=s.substring(r+1);
String cur=f+m+last;
if(cur.compareTo(ans)<=0)
{
ans=cur;
}
}
out.println(ans);
}
out.flush();
out.close();
}
catch(Exception e)
{}
}
/*
...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
*/
static void flag(boolean flag)
{
out.println(flag ? "YES" : "NO");
out.flush();
}
/*
Map<Long,Long> map=new HashMap<>();
for(int i=0;i<n;i++)
{
if(!map.containsKey(a[i]))
map.put(a[i],1);
else
map.replace(a[i],map.get(a[i])+1);
}
Set<Map.Entry<Long,Long>> hmap=map.entrySet();
for(Map.Entry<Long,Long> data : hmap)
{
}
Iterator<Integer> itr = set.iterator();
while(itr.hasNext())
{
int val=itr.next();
}
*/
// static class Pair
// {
// int x,y;
// Pair(int x,int y)
// {
// this.x=x;
// this.y=y;
// }
// }
// Arrays.sort(p, new Comparator<Pair>()
// {
// @Override
// public int compare(Pair o1,Pair o2)
// {
// if(o1.x>o2.x) return 1;
// else if(o1.x==o2.x)
// {
// if(o1.y>o2.y) return 1;
// else return -1;
// }
// else return -1;
// }});
static void print(int a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
out.print(a[i]+" ");
}
out.println();
out.flush();
}
static void print(long a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
out.print(a[i]+" ");
}
out.println();
out.flush();
}
static void print_int(ArrayList<Integer> al)
{
int si=al.size();
for(int i=0;i<si;i++)
{
out.print(al.get(i)+" ");
}
out.println();
out.flush();
}
static void print_long(ArrayList<Long> al)
{
int si=al.size();
for(int i=0;i<si;i++)
{
out.print(al.get(i)+" ");
}
out.println();
out.flush();
}
static void pn(int x)
{
out.println(x);
out.flush();
}
static void pn(long x)
{
out.println(x);
out.flush();
}
static void pn(String x)
{
out.println(x);
out.flush();
}
static int LowerBound(int a[], int x)
{
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]>=x) r=m;
else l=m;
}
return r;
}
static int UpperBound(int a[], int x)
{// x is the key or target value
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]<=x) l=m;
else r=m;
}
return l+1;
}
static void DFS(ArrayList<Integer> graph[],boolean[] visited, int u)
{
visited[u]=true;
int v=0;
for(int i=0;i<graph[u].size();i++)
{
v=graph[u].get(i);
if(!visited[v])
DFS(graph,visited,v);
}
}
static boolean[] prime(int num)
{
boolean[] bool = new boolean[num];
for (int i = 0; i< bool.length; i++) {
bool[i] = true;
}
for (int i = 2; i< Math.sqrt(num); i++) {
if(bool[i] == true) {
for(int j = (i*i); j<num; j = j+i) {
bool[j] = false;
}
}
}
if(num >= 0) {
bool[0] = false;
bool[1] = false;
}
return bool;
}
static long nCr(long a,long b,long mod)
{
return (((fact[(int)a] * modInverse(fact[(int)b],mod))%mod * modInverse(fact[(int)(a - b)],mod))%mod + mod)%mod;
}
static long fact[]=new long[max_num];
static void fact_fill()
{
fact[0]=1l;
for(int i=1;i<max_num;i++)
{
fact[i]=(fact[i-1]*(long)i);
if(fact[i]>=mod)
fact[i]%=mod;
}
}
static long modInverse(long a, long m)
{
return power(a, m - 2, m);
}
static long power(long x, long y, long m)
{
if (y == 0)
return 1;
long p = power(x, y / 2, m) % m;
p = (long)((p * (long)p) % m);
if (y % 2 == 0)
return p;
else
return (long)((x * (long)p) % m);
}
static long sum_array(int a[])
{
int n=a.length;
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static long sum_array(long a[])
{
int n=a.length;
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static void sort(int[] a)
{
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void sort(long[] a)
{
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void reverse_array(int a[])
{
int n=a.length;
int i,t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static void reverse_array(long a[])
{
int n=a.length;
int i; long t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static class FastReader{
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is) {
in = is;
}
int scan() throws IOException {
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan());
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
int nextInt() throws IOException {
int c, val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException {
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
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]; // 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 nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
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 void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
static PrintWriter out=new PrintWriter(System.out);
static int int_max=Integer.MAX_VALUE;
static int int_min=Integer.MIN_VALUE;
static long long_max=Long.MAX_VALUE;
static long long_min=Long.MIN_VALUE;
}
// Thank You !
//Some of the methods are copied from GeeksforGeeks Website
import java.util.*;
import java.lang.*;
import java.text.BreakIterator;
import java.io.*;
@SuppressWarnings("unchecked")
public class Main
{
//static Scanner sc=new Scanner(System.in);
//static Reader sc=new Reader();
static FastReader sc=new FastReader(System.in);
static long mod = (long)(1e9)+ 7;
static int max_num=(int)1e5+5;
static List<Integer> gr[];
static String fun(String s,int f,int l)
{
String ss=s.substring(f,l+1);
StringBuilder sb=new StringBuilder(""); sb.append(ss); sb=sb.reverse(); String rev=sb.toString();
StringBuilder sb2=new StringBuilder("");
char a[]=rev.toCharArray();
for(int i=0;i<rev.length();i++)
{
if(a[i]=='p') sb2.append("d");
else sb2.append("p");
}
return sb2.toString();
}
public static void main (String[] args) throws java.lang.Exception
{
try{
/* out.println("Case #"+tt+": "+ans );
gr=new ArrayList[n];
for(int i=0;i<n;i++) gr[i]=new ArrayList<>();
while(l<=r)
{
int m=l+(r-l)/2;
if(val(m))
{
ans=m;
l=m+1;
}
else
r=m-1;
}
Collections.sort(al,Collections.reverseOrder());
StringBuilder sb=new StringBuilder(""); sb.append(cur); sb=sb.reverse(); String rev=sb.toString();
map.put(a[i],map.getOrDefault(a[i],0)+1);
map.putIfAbsent(x,new ArrayList<>());
long n=sc.nextLong();
String s=sc.next();
char a[]=s.toCharArray();
*/
int t = 1;//sc.nextInt();
for(int tt=1;tt<=t;tt++)
{
int n=sc.nextInt();
String s=sc.next();
char a[]=s.toCharArray();
String ans=s;
int l=0;
while(l<n && a[l]=='d') l++;
for(int r=l;r<n;r++)
{
String f=s.substring(0,l);
String m=fun(s,l,r);
String last=s.substring(r+1);
String cur=f+m+last;
if(cur.compareTo(ans)<=0)
{
ans=cur;
}
}
out.println(ans);
}
out.flush();
out.close();
}
catch(Exception e)
{}
}
/*
...SOLUTION ENDS HERE...........SOLUTION ENDS HERE...
*/
static void flag(boolean flag)
{
out.println(flag ? "YES" : "NO");
out.flush();
}
/*
Map<Long,Long> map=new HashMap<>();
for(int i=0;i<n;i++)
{
if(!map.containsKey(a[i]))
map.put(a[i],1);
else
map.replace(a[i],map.get(a[i])+1);
}
Set<Map.Entry<Long,Long>> hmap=map.entrySet();
for(Map.Entry<Long,Long> data : hmap)
{
}
Iterator<Integer> itr = set.iterator();
while(itr.hasNext())
{
int val=itr.next();
}
*/
// static class Pair
// {
// int x,y;
// Pair(int x,int y)
// {
// this.x=x;
// this.y=y;
// }
// }
// Arrays.sort(p, new Comparator<Pair>()
// {
// @Override
// public int compare(Pair o1,Pair o2)
// {
// if(o1.x>o2.x) return 1;
// else if(o1.x==o2.x)
// {
// if(o1.y>o2.y) return 1;
// else return -1;
// }
// else return -1;
// }});
static void print(int a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
out.print(a[i]+" ");
}
out.println();
out.flush();
}
static void print(long a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
out.print(a[i]+" ");
}
out.println();
out.flush();
}
static void print_int(ArrayList<Integer> al)
{
int si=al.size();
for(int i=0;i<si;i++)
{
out.print(al.get(i)+" ");
}
out.println();
out.flush();
}
static void print_long(ArrayList<Long> al)
{
int si=al.size();
for(int i=0;i<si;i++)
{
out.print(al.get(i)+" ");
}
out.println();
out.flush();
}
static void pn(int x)
{
out.println(x);
out.flush();
}
static void pn(long x)
{
out.println(x);
out.flush();
}
static void pn(String x)
{
out.println(x);
out.flush();
}
static int LowerBound(int a[], int x)
{
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]>=x) r=m;
else l=m;
}
return r;
}
static int UpperBound(int a[], int x)
{// x is the key or target value
int l=-1,r=a.length;
while(l+1<r) {
int m=(l+r)>>>1;
if(a[m]<=x) l=m;
else r=m;
}
return l+1;
}
static void DFS(ArrayList<Integer> graph[],boolean[] visited, int u)
{
visited[u]=true;
int v=0;
for(int i=0;i<graph[u].size();i++)
{
v=graph[u].get(i);
if(!visited[v])
DFS(graph,visited,v);
}
}
static boolean[] prime(int num)
{
boolean[] bool = new boolean[num];
for (int i = 0; i< bool.length; i++) {
bool[i] = true;
}
for (int i = 2; i< Math.sqrt(num); i++) {
if(bool[i] == true) {
for(int j = (i*i); j<num; j = j+i) {
bool[j] = false;
}
}
}
if(num >= 0) {
bool[0] = false;
bool[1] = false;
}
return bool;
}
static long nCr(long a,long b,long mod)
{
return (((fact[(int)a] * modInverse(fact[(int)b],mod))%mod * modInverse(fact[(int)(a - b)],mod))%mod + mod)%mod;
}
static long fact[]=new long[max_num];
static void fact_fill()
{
fact[0]=1l;
for(int i=1;i<max_num;i++)
{
fact[i]=(fact[i-1]*(long)i);
if(fact[i]>=mod)
fact[i]%=mod;
}
}
static long modInverse(long a, long m)
{
return power(a, m - 2, m);
}
static long power(long x, long y, long m)
{
if (y == 0)
return 1;
long p = power(x, y / 2, m) % m;
p = (long)((p * (long)p) % m);
if (y % 2 == 0)
return p;
else
return (long)((x * (long)p) % m);
}
static long sum_array(int a[])
{
int n=a.length;
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static long sum_array(long a[])
{
int n=a.length;
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
return sum;
}
static void sort(int[] a)
{
ArrayList<Integer> l=new ArrayList<>();
for (int i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void sort(long[] a)
{
ArrayList<Long> l=new ArrayList<>();
for (long i:a) l.add(i);
Collections.sort(l);
for (int i=0; i<a.length; i++) a[i]=l.get(i);
}
static void reverse_array(int a[])
{
int n=a.length;
int i,t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static void reverse_array(long a[])
{
int n=a.length;
int i; long t;
for (i = 0; i < n / 2; i++) {
t = a[i];
a[i] = a[n - i - 1];
a[n - i - 1] = t;
}
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
static class FastReader{
byte[] buf = new byte[2048];
int index, total;
InputStream in;
FastReader(InputStream is) {
in = is;
}
int scan() throws IOException {
if (index >= total) {
index = 0;
total = in.read(buf);
if (total <= 0) {
return -1;
}
}
return buf[index++];
}
String next() throws IOException {
int c;
for (c = scan(); c <= 32; c = scan());
StringBuilder sb = new StringBuilder();
for (; c > 32; c = scan()) {
sb.append((char) c);
}
return sb.toString();
}
int nextInt() throws IOException {
int c, val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
long nextLong() throws IOException {
int c;
long val = 0;
for (c = scan(); c <= 32; c = scan());
boolean neg = c == '-';
if (c == '-' || c == '+') {
c = scan();
}
for (; c >= '0' && c <= '9'; c = scan()) {
val = (val << 3) + (val << 1) + (c & 15);
}
return neg ? -val : val;
}
}
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]; // 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 nextInt() throws IOException
{
int ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do
{
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
public long nextLong() throws IOException
{
long ret = 0;
byte c = read();
while (c <= ' ')
c = read();
boolean neg = (c == '-');
if (neg)
c = read();
do {
ret = ret * 10 + c - '0';
}
while ((c = read()) >= '0' && c <= '9');
if (neg)
return -ret;
return ret;
}
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 void close() throws IOException
{
if (din == null)
return;
din.close();
}
}
static PrintWriter out=new PrintWriter(System.out);
static int int_max=Integer.MAX_VALUE;
static int int_min=Integer.MIN_VALUE;
static long long_max=Long.MAX_VALUE;
static long long_min=Long.MIN_VALUE;
}
// Thank You ! | ConDefects/ConDefects/Code/arc148_b/Java/34803001 |
condefects-java_data_1955 | import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
static FastScanner sc ;
static PrintWriter pw ;
static final int inf = Integer.MAX_VALUE / 2 ;
// static final long inf = Long.MAX_VALUE / 2L ;
static final String LF = "\n" ;
static final String yes = "Yes" ;
static final String no = "No" ;
static final int mod = 1000000007 ;
// static final int mod = 998244353 ;
public static void solve() {
int N = ni() ;
String S = ns() ;
TreeSet<String> res = new TreeSet<String>() ;
res.add( S ) ;
int left = 0 ;
for ( ; left < S.length() ; left++ ) if ( S.charAt( left ) == 'p' ) break ;
String T = S.substring( 0 , left ) ;
for ( int i = left + 1 ; i < S.length() ; i++ ) {
StringBuilder sb = new StringBuilder( T ) ;
sb.append( f( S.substring( left , i ) ) ) ;
sb.append( S.substring( i , S.length() ) ) ;
res.add( sb.toString() ) ;
}
pr( res.first() ) ;
}
public static String f( String s ) {
StringBuilder sb = new StringBuilder() ;
for ( int i = 0 ; i < s.length() ; i++ ) {
char ch = s.charAt( s.length() - 1 - i ) == 'd' ? 'p' : 'd' ;
sb.append( ch ) ;
}
return sb.toString() ;
}
public static void main(String[] args) {
sc = new FastScanner() ;
pw = new PrintWriter( System.out ) ;
solve() ;
pw.flush() ;
pw.close() ;
}
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
}
public static int ni() { return Integer.parseInt( sc.next() ) ;}
public static int[] nia( int N ) { int[] res = new int[N]; Arrays.setAll( res , i -> ni() ) ; return res ; }
public static long nl() { return Long.parseLong( sc.next() ) ;}
public static long[] nla( int N ) { long[] res = new long[N]; Arrays.setAll( res , i -> nl() ) ; return res ; }
public static String ns() { return sc.next() ;}
public static String[] nsa( int N ) { String[] res = new String[N]; Arrays.setAll( res , i -> ns() ) ; return res ; }
public static void pr( int[] o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( long[] o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( Object o ) { pw.println( o ) ; }
public static void pr( Object... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void debug( Object... o ) { pr( o ) ; pw.flush() ; }
public static int max( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static int min( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long max( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static long min( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long pow( int a , int b ) { long res = 1L ; for ( int i = 0 ; i < b ; i++ ) res *= (long)a ; return res ; }
public static long[] getsum( int[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static long[] getsum( long[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static int lb( int[] A , int key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i >= 0 && A[i] == key ) i-- ; return i + 1 ; }
public static int ub( int[] A , int key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i < A.length && A[i] == key ) i++ ; return i ; }
public static int lb( long[] A , long key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i >= 0 && A[i] == key ) i-- ; return i + 1 ; }
public static int ub( long[] A , long key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i < A.length && A[i] == key ) i++ ; return i ; }
}
import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
static FastScanner sc ;
static PrintWriter pw ;
static final int inf = Integer.MAX_VALUE / 2 ;
// static final long inf = Long.MAX_VALUE / 2L ;
static final String LF = "\n" ;
static final String yes = "Yes" ;
static final String no = "No" ;
static final int mod = 1000000007 ;
// static final int mod = 998244353 ;
public static void solve() {
int N = ni() ;
String S = ns() ;
TreeSet<String> res = new TreeSet<String>() ;
res.add( S ) ;
int left = 0 ;
for ( ; left < S.length() ; left++ ) if ( S.charAt( left ) == 'p' ) break ;
String T = S.substring( 0 , left ) ;
for ( int i = left + 1 ; i <= S.length() ; i++ ) {
StringBuilder sb = new StringBuilder( T ) ;
sb.append( f( S.substring( left , i ) ) ) ;
sb.append( S.substring( i , S.length() ) ) ;
res.add( sb.toString() ) ;
}
pr( res.first() ) ;
}
public static String f( String s ) {
StringBuilder sb = new StringBuilder() ;
for ( int i = 0 ; i < s.length() ; i++ ) {
char ch = s.charAt( s.length() - 1 - i ) == 'd' ? 'p' : 'd' ;
sb.append( ch ) ;
}
return sb.toString() ;
}
public static void main(String[] args) {
sc = new FastScanner() ;
pw = new PrintWriter( System.out ) ;
solve() ;
pw.flush() ;
pw.close() ;
}
static class FastScanner {
private final InputStream in = System.in;
private final byte[] buffer = new byte[1024];
private int ptr = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
}else{
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
public boolean hasNext() { skipUnprintable(); return hasNextByte();}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while(isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
}
public static int ni() { return Integer.parseInt( sc.next() ) ;}
public static int[] nia( int N ) { int[] res = new int[N]; Arrays.setAll( res , i -> ni() ) ; return res ; }
public static long nl() { return Long.parseLong( sc.next() ) ;}
public static long[] nla( int N ) { long[] res = new long[N]; Arrays.setAll( res , i -> nl() ) ; return res ; }
public static String ns() { return sc.next() ;}
public static String[] nsa( int N ) { String[] res = new String[N]; Arrays.setAll( res , i -> ns() ) ; return res ; }
public static void pr( int[] o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( long[] o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void pr( Object o ) { pw.println( o ) ; }
public static void pr( Object... o ) { for ( int i = 0 ; i < o.length - 1 ; i++ ) pw.print( o[i] + " " ) ; pw.println( o[o.length-1] ) ; }
public static void debug( Object... o ) { pr( o ) ; pw.flush() ; }
public static int max( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static int min( int... x ) { int res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long max( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.max( res , x[i] ) ; return res ; }
public static long min( long... x ) { long res = x[0] ; for ( int i = 1 ; i < x.length ; i++ ) res = Math.min( res , x[i] ) ; return res ; }
public static long pow( int a , int b ) { long res = 1L ; for ( int i = 0 ; i < b ; i++ ) res *= (long)a ; return res ; }
public static long[] getsum( int[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static long[] getsum( long[] a ) { long[] res = new long[a.length+1] ; for ( int i = 0 ; i < a.length ; i++ ) res[i+1] += res[i] + a[i] ; return res ; }
public static int lb( int[] A , int key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i >= 0 && A[i] == key ) i-- ; return i + 1 ; }
public static int ub( int[] A , int key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i < A.length && A[i] == key ) i++ ; return i ; }
public static int lb( long[] A , long key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i >= 0 && A[i] == key ) i-- ; return i + 1 ; }
public static int ub( long[] A , long key ) { int i = Arrays.binarySearch( A , key ) ; if ( i < 0 ) return -1 * ( i + 1 ) ; while ( i < A.length && A[i] == key ) i++ ; return i ; }
}
| ConDefects/ConDefects/Code/arc148_b/Java/35011367 |
condefects-java_data_1956 | import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
long[] n = new long[t];
long[] a = new long[t];
long[] b = new long[t];
long[] x = new long[t];
long[] y = new long[t];
long[] z = new long[t];
for(var i=0; i<t; i++) {
n[i]=sc.nextLong();
a[i]=sc.nextLong();
b[i]=sc.nextLong();
x[i]=sc.nextLong();
y[i]=sc.nextLong();
z[i]=sc.nextLong();
}
sc.close();
System.out.println(arc139b(t,n,a,b,x,y,z));
System.out.flush();
}
private static StringBuilder arc139b(int t, long[] n, long[] a, long[] b, long[] x, long[] y, long[] z){
StringBuilder ans = new StringBuilder();
for(int i=0; i<t; i++){
ans.append(solve(n[i],a[i],b[i],x[i],y[i],z[i])).append("\n");
}
return ans;
}
private static long solve(long n, long a, long b, long x, long y, long z){
// A増やす操作について、1増やす操作の方がコスパが良い場合は,1をA回増やす操作に置き換える
y = Math.min(y, a*x);
// B増やす操作も同様
z = Math.min(z, b*x);
// コストパフォーマンスの良い方をAにする
double cospaA = (double)y / a;
double cospaB = (double)z / b;
if(cospaA > cospaB){
long tempA = a;
long tempY = y;
double tempCospaA = cospaA;
a = b;
y = z;
cospaA = cospaB;
b = tempA;
z = tempY;
cospaB = tempCospaA;
}
long ans = Long.MAX_VALUE;
if(x <= cospaA){
ans = n * x;
}else if(cospaA <= x && x <= cospaB){
ans = (n / a) * y + (n % a) * x;
}else if(cospaA <= cospaB && cospaB <= x){
ans = n * x; // n回1増やす操作をするのが最大コスト
// a増やす操作->b増やす操作->1増やす操作の順で考えるとTLEする
// b回a増やす操作とa回b増やす操作は同義なので
// ab増やす操作->a増やす操作->b増やす操作->1増やす操作の順で考える
// ab増やす操作はコスパの良いb回a増やす操作の方を使う
long ab = a*b;
long w = y*b;
// i:ab増やす操作回数(最大使うと最善にできない可能性があるので1つだけ余裕を持たせる)
long i = n / ab - 1;
// ab増やした後のnまでの残り
n -= ab * i;
// j:a増やす操作回数
for(long j=0; j<=n/a; j++){
// k:b増やす操作回数
long k = (n - a*j) / b;
// l:1増やす操作回数
long l = n - a*j - b*k;
long cost = i*w + j*y + k*z + l*x;
ans = Math.min(ans, cost);
}
}
return ans;
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
long[] n = new long[t];
long[] a = new long[t];
long[] b = new long[t];
long[] x = new long[t];
long[] y = new long[t];
long[] z = new long[t];
for(var i=0; i<t; i++) {
n[i]=sc.nextLong();
a[i]=sc.nextLong();
b[i]=sc.nextLong();
x[i]=sc.nextLong();
y[i]=sc.nextLong();
z[i]=sc.nextLong();
}
sc.close();
System.out.println(arc139b(t,n,a,b,x,y,z));
System.out.flush();
}
private static StringBuilder arc139b(int t, long[] n, long[] a, long[] b, long[] x, long[] y, long[] z){
StringBuilder ans = new StringBuilder();
for(int i=0; i<t; i++){
ans.append(solve(n[i],a[i],b[i],x[i],y[i],z[i])).append("\n");
}
return ans;
}
private static long solve(long n, long a, long b, long x, long y, long z){
// A増やす操作について、1増やす操作の方がコスパが良い場合は,1をA回増やす操作に置き換える
y = Math.min(y, a*x);
// B増やす操作も同様
z = Math.min(z, b*x);
// コストパフォーマンスの良い方をAにする
double cospaA = (double)y / a;
double cospaB = (double)z / b;
if(cospaA > cospaB){
long tempA = a;
long tempY = y;
double tempCospaA = cospaA;
a = b;
y = z;
cospaA = cospaB;
b = tempA;
z = tempY;
cospaB = tempCospaA;
}
long ans = Long.MAX_VALUE;
if(x <= cospaA){
ans = n * x;
}else if(cospaA <= x && x <= cospaB){
ans = (n / a) * y + (n % a) * x;
}else if(cospaA <= cospaB && cospaB <= x){
ans = n * x; // n回1増やす操作をするのが最大コスト
// a増やす操作->b増やす操作->1増やす操作の順で考えるとTLEする
// b回a増やす操作とa回b増やす操作は同義なので
// ab増やす操作->a増やす操作->b増やす操作->1増やす操作の順で考える
// ab増やす操作はコスパの良いb回a増やす操作の方を使う
long ab = a*b;
long w = y*b;
// i:ab増やす操作回数(最大使うと最善にできない可能性があるので1つだけ余裕を持たせる)
long i = Math.max(0, n / ab - 1);
// ab増やした後のnまでの残り
n -= ab * i;
// j:a増やす操作回数
for(long j=0; j<=n/a; j++){
// k:b増やす操作回数
long k = (n - a*j) / b;
// l:1増やす操作回数
long l = n - a*j - b*k;
long cost = i*w + j*y + k*z + l*x;
ans = Math.min(ans, cost);
}
}
return ans;
}
}
| ConDefects/ConDefects/Code/arc139_b/Java/31251620 |
condefects-java_data_1957 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringJoiner;
public class Main {
public static void main(String[] args) {
var sc = new FastScanner(System.in);
var pw = new PrintWriter(System.out);
var T = sc.nextInt();
for (int i = 0; i < T; i++) {
var N = sc.nextInt();
var A = sc.nextInt();
var B = sc.nextInt();
var X = sc.nextInt();
var Y = sc.nextInt();
var Z = sc.nextInt();
pw.println(solve(N, A, B, X, Y, Z));
}
pw.flush();
}
static long solve(int N, int A, int B, int X, int Y, int Z) {
// 1 < A < B => 1を使う
// A < 1 < B => できるだけAを使って後は1で埋める
// A < B < 1 => できるだけAとBで構成し、しょうがない部分は1を使う
// 効率が A < Bとなるように調整する
// Y/A > Z/B
if( isCheap(B, Z, A, Y) ) {
int t = B;
B = A;
A = t;
t = Y;
Y = Z;
Z = t;
}
if( isCheap(1, X, A, Y) ) {
return (long)N*X;
} else if( isCheap(1, X, B, Z) ) {
int q = N/A;
int r = N%A;
return (long)q*Y + (long)r*X;
} else {
// できるだけAとBで構成したいが良い組合わせがわからないので全部試す
// 一つ固定するとあとは分かるので回す数が少ないほうを使う
if( A < B ) {
long ans = Long.MAX_VALUE;
for (int i = 0; i <= Math.min(A-1, N/B); i++) {
int n = N;
long cost = 0;
n -= i*B;
cost += (long)i*Z;
int q = n/A;
int r = n%A;
cost += (long)q*Y;
cost += (long)r*X;
ans = Math.min(ans, cost);
}
return ans;
} else {
long ans = Long.MAX_VALUE;
for (int i = 0; i <= Math.min(B-1, N/A); i++) {
int n = N;
long cost = 0;
n -= i*A;
cost += (long)i*Y;
int qab = (int)(n/((long)A*B));
int rab = (int)(n%((long)A*B));
cost += (long)qab*B*Y;
n = rab;
int q = n/B;
int r = n%B;
cost += (long)q*Z;
cost += (long)r*X;
ans = Math.min(ans, cost);
}
return ans;
}
}
}
static boolean isCheap(int dist1, int cost1, int dist2, int cost2) {
// cost1/dist1 < cost2/dist2
return cost1*dist2 < cost2*dist1;
}
static void writeLines(int[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeLines(long[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeSingleLine(int[] as) {
var pw = new PrintWriter(System.out);
for (var i = 0; i < as.length; i++) {
if (i != 0) pw.print(" ");
pw.print(as[i]);
}
pw.println();
pw.flush();
}
static void debug(Object... args) {
var j = new StringJoiner(" ");
for (var arg : args) {
if (arg == null) j.add("null");
else if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
else j.add(arg.toString());
}
System.err.println(j);
}
@SuppressWarnings("unused")
private static class FastScanner {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public FastScanner(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new RuntimeException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new RuntimeException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new RuntimeException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new RuntimeException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new RuntimeException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new RuntimeException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] 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.util.Arrays;
import java.util.StringJoiner;
public class Main {
public static void main(String[] args) {
var sc = new FastScanner(System.in);
var pw = new PrintWriter(System.out);
var T = sc.nextInt();
for (int i = 0; i < T; i++) {
var N = sc.nextInt();
var A = sc.nextInt();
var B = sc.nextInt();
var X = sc.nextInt();
var Y = sc.nextInt();
var Z = sc.nextInt();
pw.println(solve(N, A, B, X, Y, Z));
}
pw.flush();
}
static long solve(int N, int A, int B, int X, int Y, int Z) {
// 1 < A < B => 1を使う
// A < 1 < B => できるだけAを使って後は1で埋める
// A < B < 1 => できるだけAとBで構成し、しょうがない部分は1を使う
// 効率が A < Bとなるように調整する
// Y/A > Z/B
if( isCheap(B, Z, A, Y) ) {
int t = B;
B = A;
A = t;
t = Y;
Y = Z;
Z = t;
}
if( isCheap(1, X, A, Y) ) {
return (long)N*X;
} else if( isCheap(1, X, B, Z) ) {
int q = N/A;
int r = N%A;
return (long)q*Y + (long)r*X;
} else {
// できるだけAとBで構成したいが良い組合わせがわからないので全部試す
// 一つ固定するとあとは分かるので回す数が少ないほうを使う
if( A < B ) {
long ans = Long.MAX_VALUE;
for (int i = 0; i <= Math.min(A-1, N/B); i++) {
int n = N;
long cost = 0;
n -= i*B;
cost += (long)i*Z;
int q = n/A;
int r = n%A;
cost += (long)q*Y;
cost += (long)r*X;
ans = Math.min(ans, cost);
}
return ans;
} else {
long ans = Long.MAX_VALUE;
for (int i = 0; i <= Math.min(B-1, N/A); i++) {
int n = N;
long cost = 0;
n -= i*A;
cost += (long)i*Y;
int qab = (int)(n/((long)A*B));
int rab = (int)(n%((long)A*B));
cost += (long)qab*B*Y;
n = rab;
int q = n/B;
int r = n%B;
cost += (long)q*Z;
cost += (long)r*X;
ans = Math.min(ans, cost);
}
return ans;
}
}
}
static boolean isCheap(int dist1, int cost1, int dist2, int cost2) {
// cost1/dist1 < cost2/dist2
return (long)cost1*dist2 < (long)cost2*dist1;
}
static void writeLines(int[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeLines(long[] as) {
var pw = new PrintWriter(System.out);
for (var a : as) pw.println(a);
pw.flush();
}
static void writeSingleLine(int[] as) {
var pw = new PrintWriter(System.out);
for (var i = 0; i < as.length; i++) {
if (i != 0) pw.print(" ");
pw.print(as[i]);
}
pw.println();
pw.flush();
}
static void debug(Object... args) {
var j = new StringJoiner(" ");
for (var arg : args) {
if (arg == null) j.add("null");
else if (arg instanceof int[]) j.add(Arrays.toString((int[]) arg));
else if (arg instanceof long[]) j.add(Arrays.toString((long[]) arg));
else if (arg instanceof double[]) j.add(Arrays.toString((double[]) arg));
else if (arg instanceof Object[]) j.add(Arrays.toString((Object[]) arg));
else j.add(arg.toString());
}
System.err.println(j);
}
@SuppressWarnings("unused")
private static class FastScanner {
private final InputStream in;
private final byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public FastScanner(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new RuntimeException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new RuntimeException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new RuntimeException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new RuntimeException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new RuntimeException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new RuntimeException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] 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/arc139_b/Java/32997285 |
condefects-java_data_1958 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input1 = scanner.nextLine();
String[] numList = input1.split(" ");
String input2 = scanner.nextLine();
String[] humanList = input2.split(" ");
int count = 0;
for (int i = 1; i < Integer.parseInt(numList[0]); i++){
if (Integer.parseInt(humanList[i]) < Integer.parseInt((numList[1]))){
count++;
}
}
System.out.println(count);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input1 = scanner.nextLine();
String[] numList = input1.split(" ");
String input2 = scanner.nextLine();
String[] humanList = input2.split(" ");
int count = 0;
for (int i = 0; i < Integer.parseInt(numList[0]); i++){
if (Integer.parseInt(humanList[i]) < Integer.parseInt((numList[1]))){
count++;
}
}
System.out.println(count);
}
}
| ConDefects/ConDefects/Code/abc222_b/Java/30976853 |
condefects-java_data_1959 | import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
public final class Main {
private static final Scanner scanner;
private static final PrintWriter writer;
// private static final long PRIME = 1000000007;
// private static final long PRIME = 998244353;
static {
scanner = new Scanner(System.in);
writer = new PrintWriter(System.out);
}
public static final void main(String[] args) {
final int N = getNextInt();
final int Q = getNextInt();
TreeSet<Integer> notCalled = new TreeSet<>(Stream.iterate(1, i -> i + 1).limit(N).collect(Collectors.toList()));
TreeSet<Integer> called = new TreeSet<>();
for(int qidx = 0; qidx < Q; qidx++) {
switch(getNextInt()) {
case 1:
{
called.add(notCalled.pollFirst());
}
break;
case 2:
{
called.remove(getNextInt());
}
break;
case 3:
{
println(called.pollFirst());
}
break;
default:
}
}
flush();
}
private static final int bitCount(long pattern, long stopBit) {
int ret = 0;
for(long i = 0; 1 << i < stopBit; i++) {
if((pattern & (1 << i)) != 0) {
ret++;
}
}
return ret;
}
private static final int max(int... arg) {
return Arrays.stream(arg).max().orElse(0);
}
private static final int min(int... arg) {
return Arrays.stream(arg).min().orElse(0);
}
private static final int pow(int x, int p) {
int r = 1;
for(int i = 0; (1 << i) <= p; i++) {
if((p & (1 << i)) != 0) {
r *= x;
}
x *= x;
}
return r;
}
private static final long max(long... arg) {
return Arrays.stream(arg).max().orElse(0);
}
private static final long min(long... arg) {
return Arrays.stream(arg).min().orElse(0);
}
private static final long pow(long x, int p) {
long r = 1;
for(int i = 0; (1 << i) <= p; i++) {
if((p & (1 << i)) != 0) {
r *= x;
}
x *= x;
}
return r;
}
private static final long pow(long x, long p, long div) {
long r = 1;
for(long i = 0; (1 << i) <= p; i++) {
if((p & (1 << i)) != 0) {
r *= x;
r %= div;
}
x *= x;
x %= div;
}
return r;
}
private static final short max(short a, short b) {
return a < b ? b : a;
}
private static final short min(short a, short b) {
return a > b ? b : a;
}
private static final String getNext() {
return scanner.next();
}
private static final int getNextInt() {
return Integer.parseInt(scanner.next());
}
private static final long getNextLong() {
return Long.parseLong(scanner.next());
}
private static final double getNextDouble() {
return Double.parseDouble(scanner.next());
}
private static final int[] getIntArray(int length) {
return getIntArray(length, v -> v);
}
private static final int[] getIntArray(int length, IntUnaryOperator mapper) {
return IntStream.generate(()->getNextInt()).limit(length).map(mapper).toArray();
}
private static final long[] getLongArray(int length) {
return getLongArray(length, v -> v);
}
private static final long[] getLongArray(int length, LongUnaryOperator mapper) {
return LongStream.generate(()->getNextLong()).limit(length).map(mapper).toArray();
}
private static final int[][] get2dIntArray(int rows, int cols) {
return get2dIntArray(rows, cols, v -> v);
}
private static final int[][] get2dIntArray(int rows, int cols, IntUnaryOperator mapper) {
return Stream.generate(()->getIntArray(cols, mapper)).limit(rows).toArray(int[][]::new);
}
private static final long[][] get2dLongArray(int rows, int cols) {
return get2dLongArray(rows, cols, v -> v);
}
private static final long[][] get2dLongArray(int rows, int cols, LongUnaryOperator mapper) {
return Stream.generate(()->getLongArray(cols, mapper)).limit(rows).toArray(long[][]::new);
}
private static final void print(int[] argi) {
Arrays.stream(argi).forEach(i->print(String.valueOf(i) + " "));
}
private static final void print(Object obj) {
writer.print(obj);
}
private static final void print(Object... arg) {
Arrays.stream(arg).forEach(obj->print(obj));
}
private static final void println(int[] argi) {
print(argi);
println();
}
private static final void println(Object obj) {
print(obj);
println();
}
private static final void println(Object... arg) {
print(arg);
println();
}
private static final void println() {
writer.println();
}
private static final void flush() {
writer.flush();
}
}
import java.util.*;
import java.io.*;
import java.util.function.*;
import java.util.stream.*;
public final class Main {
private static final Scanner scanner;
private static final PrintWriter writer;
// private static final long PRIME = 1000000007;
// private static final long PRIME = 998244353;
static {
scanner = new Scanner(System.in);
writer = new PrintWriter(System.out);
}
public static final void main(String[] args) {
final int N = getNextInt();
final int Q = getNextInt();
TreeSet<Integer> notCalled = new TreeSet<>(Stream.iterate(1, i -> i + 1).limit(N).collect(Collectors.toList()));
TreeSet<Integer> called = new TreeSet<>();
for(int qidx = 0; qidx < Q; qidx++) {
switch(getNextInt()) {
case 1:
{
called.add(notCalled.pollFirst());
}
break;
case 2:
{
called.remove(getNextInt());
}
break;
case 3:
{
println(called.first());
}
break;
default:
}
}
flush();
}
private static final int bitCount(long pattern, long stopBit) {
int ret = 0;
for(long i = 0; 1 << i < stopBit; i++) {
if((pattern & (1 << i)) != 0) {
ret++;
}
}
return ret;
}
private static final int max(int... arg) {
return Arrays.stream(arg).max().orElse(0);
}
private static final int min(int... arg) {
return Arrays.stream(arg).min().orElse(0);
}
private static final int pow(int x, int p) {
int r = 1;
for(int i = 0; (1 << i) <= p; i++) {
if((p & (1 << i)) != 0) {
r *= x;
}
x *= x;
}
return r;
}
private static final long max(long... arg) {
return Arrays.stream(arg).max().orElse(0);
}
private static final long min(long... arg) {
return Arrays.stream(arg).min().orElse(0);
}
private static final long pow(long x, int p) {
long r = 1;
for(int i = 0; (1 << i) <= p; i++) {
if((p & (1 << i)) != 0) {
r *= x;
}
x *= x;
}
return r;
}
private static final long pow(long x, long p, long div) {
long r = 1;
for(long i = 0; (1 << i) <= p; i++) {
if((p & (1 << i)) != 0) {
r *= x;
r %= div;
}
x *= x;
x %= div;
}
return r;
}
private static final short max(short a, short b) {
return a < b ? b : a;
}
private static final short min(short a, short b) {
return a > b ? b : a;
}
private static final String getNext() {
return scanner.next();
}
private static final int getNextInt() {
return Integer.parseInt(scanner.next());
}
private static final long getNextLong() {
return Long.parseLong(scanner.next());
}
private static final double getNextDouble() {
return Double.parseDouble(scanner.next());
}
private static final int[] getIntArray(int length) {
return getIntArray(length, v -> v);
}
private static final int[] getIntArray(int length, IntUnaryOperator mapper) {
return IntStream.generate(()->getNextInt()).limit(length).map(mapper).toArray();
}
private static final long[] getLongArray(int length) {
return getLongArray(length, v -> v);
}
private static final long[] getLongArray(int length, LongUnaryOperator mapper) {
return LongStream.generate(()->getNextLong()).limit(length).map(mapper).toArray();
}
private static final int[][] get2dIntArray(int rows, int cols) {
return get2dIntArray(rows, cols, v -> v);
}
private static final int[][] get2dIntArray(int rows, int cols, IntUnaryOperator mapper) {
return Stream.generate(()->getIntArray(cols, mapper)).limit(rows).toArray(int[][]::new);
}
private static final long[][] get2dLongArray(int rows, int cols) {
return get2dLongArray(rows, cols, v -> v);
}
private static final long[][] get2dLongArray(int rows, int cols, LongUnaryOperator mapper) {
return Stream.generate(()->getLongArray(cols, mapper)).limit(rows).toArray(long[][]::new);
}
private static final void print(int[] argi) {
Arrays.stream(argi).forEach(i->print(String.valueOf(i) + " "));
}
private static final void print(Object obj) {
writer.print(obj);
}
private static final void print(Object... arg) {
Arrays.stream(arg).forEach(obj->print(obj));
}
private static final void println(int[] argi) {
print(argi);
println();
}
private static final void println(Object obj) {
print(obj);
println();
}
private static final void println(Object... arg) {
print(arg);
println();
}
private static final void println() {
writer.println();
}
private static final void flush() {
writer.flush();
}
}
| ConDefects/ConDefects/Code/abc294_d/Java/43566754 |
condefects-java_data_1960 | import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// 人数
int n = sc.nextInt();
// イベント数
int q = sc.nextInt();
// 呼ばれてない人の中で最小
Integer minWeit = 1;
// 呼ばれたけど行ってない人
Set<String> call = new HashSet<>();
for (int i=1; i<=q; i++)
{
// イベントの種類
int e = sc.nextInt();
// System.out.println("event"+e);
if (e == 1)
{
call.add(minWeit.toString());
minWeit++;
}
else if (e == 2)
{
// 行く人
String p = sc.next();
call.remove(p);
}
else
{
Iterator it = call.iterator();
String s = it.next().toString();
System.out.println(s);
}
}
}
}
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// 人数
int n = sc.nextInt();
// イベント数
int q = sc.nextInt();
// 呼ばれてない人の中で最小
Integer minWeit = 1;
// 呼ばれたけど行ってない人
Set<String> call = new LinkedHashSet<>();
for (int i=1; i<=q; i++)
{
// イベントの種類
int e = sc.nextInt();
// System.out.println("event"+e);
if (e == 1)
{
call.add(minWeit.toString());
minWeit++;
}
else if (e == 2)
{
// 行く人
String p = sc.next();
call.remove(p);
}
else
{
Iterator it = call.iterator();
String s = it.next().toString();
System.out.println(s);
}
}
}
}
| ConDefects/ConDefects/Code/abc294_d/Java/45502625 |
condefects-java_data_1961 | import javax.swing.*;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.BinaryOperator;
public class Main {
public static int[] dijkstraDistance;
public static void main(String[] args) {
FastScanner scan = new FastScanner();
int N = scan.nextInt();
int Q = scan.nextInt();
Set<Integer> queue = new HashSet<>();
int next = 1;
for (int i = 0; i < Q; i++) {
int x = scan.nextInt();
if (x == 1) {
queue.add(next);
next++;
}
if (x == 2) {
int n = scan.nextInt();
queue.remove(n);
}
if (x == 3) {
for (int n : queue) {
print(n);
break;
}
}
}
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static long gcd(long l, long r) {
if (r == 0) return l;
return gcd(r, l % r);
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
public static <T extends Comparable<T>> T max(Collection<T> values) {
return Collections.max(values);
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> T min(Collection<T> values) {
return Collections.min(values);
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? -1 : 1);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static <T extends Comparable<T>> int[] lis(List<T> array) {
int N = array.size();
int[] result = new int[N];
List<T> B = new ArrayList<>();
for (int i = 0; i < N; i++) {
int k = lowerBound(B, array.get(i));
if (k == B.size()) B.add(array.get(i));
else B.set(k, array.get(i));
result[i] = k + 1;
}
return result;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class DijkstraComparator<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return Integer.compare(Main.dijkstraDistance[(int) o1], Main.dijkstraDistance[(int) o2]);
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject> {
int i;
T value;
public IndexedObject(int i, T value) {
this.i = i;
this.value = value;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.value.equals(((IndexedObject<?>)o).value);
}
@Override
public int compareTo(IndexedObject o) {
if (o.value.getClass() != this.value.getClass()) throw new IllegalArgumentException();
return value.compareTo((T) o.value);
}
@Override
public int hashCode() {
return this.i + this.value.hashCode();
}
@Override
public String toString() {
return "IndexedObject{" +
"i=" + i +
", value=" + value +
'}';
}
}
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
return this.x == ((Point)o).x && this.y == ((Point)o).y;
}
@Override
public int hashCode() {
return Integer.hashCode(x) * 524287 + Integer.hashCode(y);
}
}
class GraphBuilder {
private Map<Integer, List<Integer>> edges = new HashMap<>();
private final int N;
private final boolean isDirected;
public GraphBuilder(int N, boolean isDirected) {
this.isDirected = isDirected;
this.N = N;
for (int i = 0; i < N; i++) {
edges.put(i, new ArrayList<>());
}
}
public GraphBuilder(int N) {
this(N, false);
}
public void addEdge(int u, int v) {
edges.get(u).add(v);
if (!isDirected) edges.get(v).add(u);
}
public Map<Integer, List<Integer>> getEdges() {
return edges;
}
public int getN() {
return N;
}
}
class 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());
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y) return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0) value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max){
factorial.ensureCapacity(max+1);
if(factorial.size()==0) factorial.add(1);
if (usesMontgomery) {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), maMontgomery.generate(i)));
}
} else {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), i));
}
}
}
public ModInt factorial(int i){
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), factorial.get(r)));
}
public ModInt combination(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r),factorial.get(n-r))));
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (usesMontgomery) {
return maMontgomery.reduce(value);
}
return value;
}
public ModInt add(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis) mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis) mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis) addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis) mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1) return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a; a = b; b = tmp1;
u -= t * v;
long tmp2 = u; u = v; v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1) r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {return 1;}
int remainder(long value) {return 0;}
int add(int a, int b) {return 0;}
int sub(int a, int b) {return 0;}
int mul(int a, int b) {return 0;}
int pow(int a, long b) {return 0;}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {return 2;}
int remainder(long value) {return (int) (value & 1);}
int add(int a, int b) {return a ^ b;}
int sub(int a, int b) {return a ^ b;}
int mul(int a, int b) {return a & b;}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = (x + ((x * negInv) & 0xffff_ffffl) * mod) >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(int mod) {
super(mod);
/**
* m = floor(2^64/mod)
* 2^64 = p*mod + q, 2^32 = a*mod + b
* => (a*mod + b)^2 = p*mod + q
* => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long x) {
long z = (x & mask) * ml;
z = (x & mask) * mh + (x >>> 32) * ml + (z >>> 32);
z = (x >>> 32) * mh + (z >>> 32);
x -= z * mod;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
class SCC {
static class Edge {
int from, to;
public Edge(int from, int to) {
this.from = from; this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(int i) {
if (!hasBuilt) {
throw new UnsupportedOperationException(
"Graph hasn't been built."
);
}
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
long p = stack[--ptr];
// vertex
int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j --> 0) {
int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
int[] counts = new int[groupNum];
for (int x : ids) counts[x]++;
int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, n)
);
}
}
}
class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return E;
l += N; r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1; r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N; r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1; r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N) return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N) return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>>{
S first;
T second;
public Pair(S s, T t){
first = s;
second = t;
}
public S getFirst(){return first;}
public T getSecond(){return second;}
public boolean equals(Object another){
if(this==another) return true;
if(!(another instanceof Pair)) return false;
Pair otherPair = (Pair)another;
return this.first.equals(otherPair.first) && this.second.equals(otherPair.second);
}
public int compareTo(Pair<S,T> another){
java.util.Comparator<Pair<S,T>> comp1 = java.util.Comparator.comparing(Pair::getFirst);
java.util.Comparator<Pair<S,T>> comp2 = comp1.thenComparing(Pair::getSecond);
return comp2.compare(this, another);
}
public int hashCode(){
return first.hashCode() * 10007 + second.hashCode();
}
public String toString(){
return String.format("(%s, %s)", first, second);
}
}
import javax.swing.*;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.BinaryOperator;
public class Main {
public static int[] dijkstraDistance;
public static void main(String[] args) {
FastScanner scan = new FastScanner();
int N = scan.nextInt();
int Q = scan.nextInt();
Set<Integer> queue = new TreeSet<>();
int next = 1;
for (int i = 0; i < Q; i++) {
int x = scan.nextInt();
if (x == 1) {
queue.add(next);
next++;
}
if (x == 2) {
int n = scan.nextInt();
queue.remove(n);
}
if (x == 3) {
for (int n : queue) {
print(n);
break;
}
}
}
}
public static void write(Object... objs) {
try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("", true)))) {
for (Object o : objs) {
pw.println(o);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static long gcd(long l, long r) {
if (r == 0) return l;
return gcd(r, l % r);
}
public static BigInteger gcd(BigInteger l, BigInteger r) {
return l.gcd(r);
}
public static BigInteger lcm(BigInteger l, BigInteger r) {
return l.multiply(r).divide(gcd(l, r));
}
@SafeVarargs
public static <T extends Comparable<T>> T max(T... values) {
return Collections.max(Arrays.asList(values));
}
public static <T extends Comparable<T>> T max(Collection<T> values) {
return Collections.max(values);
}
@SafeVarargs
public static <T extends Comparable<T>> T min(T... values) {
return Collections.min(Arrays.asList(values));
}
public static <T extends Comparable<T>> T min(Collection<T> values) {
return Collections.min(values);
}
public static <T extends Comparable<T>> int lowerBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) >= 0 ? 1 : -1);
}
public static <T extends Comparable<T>> int upperBound(List<T> list, T key) {
return ~Collections.binarySearch(list, key, (x, y) -> x.compareTo(y) > 0 ? -1 : 1);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map) {
return sortMapByKey(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByKey(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByKey(Collections.reverseOrder()));
else entries.sort(Entry.comparingByKey());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map) {
return sortMapByValue(map, false);
}
public static <T1 extends Comparable<T1>, T2 extends Comparable<T2>> LinkedHashMap<T1, T2> sortMapByValue(Map<T1, T2> map, boolean isReverse) {
List<Entry<T1, T2>> entries = new LinkedList<>(map.entrySet());
if (isReverse) entries.sort(Entry.comparingByValue(Collections.reverseOrder()));
else entries.sort(Entry.comparingByValue());
LinkedHashMap<T1, T2> result = new LinkedHashMap<>();
for (Entry<T1, T2> entry : entries) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
public static long nCr(long n, long r) {
long result = 1;
for (int i = 1; i <= r; i++) {
result = result * (n - i + 1) / i;
}
return result;
}
public static <T extends Comparable<T>> int[] lis(List<T> array) {
int N = array.size();
int[] result = new int[N];
List<T> B = new ArrayList<>();
for (int i = 0; i < N; i++) {
int k = lowerBound(B, array.get(i));
if (k == B.size()) B.add(array.get(i));
else B.set(k, array.get(i));
result[i] = k + 1;
}
return result;
}
public static void print() {
print("");
}
public static void print(Object o) {
System.out.println(o);
}
public static void print(Object... objs) {
for (Object o : objs) {
System.out.print(o + " ");
}
print();
}
}
class DijkstraComparator<T> implements Comparator<T> {
@Override
public int compare(T o1, T o2) {
return Integer.compare(Main.dijkstraDistance[(int) o1], Main.dijkstraDistance[(int) o2]);
}
}
class IndexedObject<T extends Comparable<T>> implements Comparable<IndexedObject> {
int i;
T value;
public IndexedObject(int i, T value) {
this.i = i;
this.value = value;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof IndexedObject)) return false;
return this.i == ((IndexedObject<?>)o).i && this.value.equals(((IndexedObject<?>)o).value);
}
@Override
public int compareTo(IndexedObject o) {
if (o.value.getClass() != this.value.getClass()) throw new IllegalArgumentException();
return value.compareTo((T) o.value);
}
@Override
public int hashCode() {
return this.i + this.value.hashCode();
}
@Override
public String toString() {
return "IndexedObject{" +
"i=" + i +
", value=" + value +
'}';
}
}
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
return this.x == ((Point)o).x && this.y == ((Point)o).y;
}
@Override
public int hashCode() {
return Integer.hashCode(x) * 524287 + Integer.hashCode(y);
}
}
class GraphBuilder {
private Map<Integer, List<Integer>> edges = new HashMap<>();
private final int N;
private final boolean isDirected;
public GraphBuilder(int N, boolean isDirected) {
this.isDirected = isDirected;
this.N = N;
for (int i = 0; i < N; i++) {
edges.put(i, new ArrayList<>());
}
}
public GraphBuilder(int N) {
this(N, false);
}
public void addEdge(int u, int v) {
edges.get(u).add(v);
if (!isDirected) edges.get(v).add(u);
}
public Map<Integer, List<Integer>> getEdges() {
return edges;
}
public int getN() {
return N;
}
}
class 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());
}
}
class DSU {
private int n;
private int[] parentOrSize;
public DSU(int n) {
this.n = n;
this.parentOrSize = new int[n];
java.util.Arrays.fill(parentOrSize, -1);
}
int merge(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
int x = leader(a);
int y = leader(b);
if (x == y) return x;
if (-parentOrSize[x] < -parentOrSize[y]) {
int tmp = x;
x = y;
y = tmp;
}
parentOrSize[x] += parentOrSize[y];
parentOrSize[y] = x;
return x;
}
boolean same(int a, int b) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("a=" + a);
if (!(0 <= b && b < n))
throw new IndexOutOfBoundsException("b=" + b);
return leader(a) == leader(b);
}
int leader(int a) {
if (parentOrSize[a] < 0) {
return a;
} else {
parentOrSize[a] = leader(parentOrSize[a]);
return parentOrSize[a];
}
}
int size(int a) {
if (!(0 <= a && a < n))
throw new IndexOutOfBoundsException("" + a);
return -parentOrSize[leader(a)];
}
java.util.ArrayList<java.util.ArrayList<Integer>> groups() {
int[] leaderBuf = new int[n];
int[] groupSize = new int[n];
for (int i = 0; i < n; i++) {
leaderBuf[i] = leader(i);
groupSize[leaderBuf[i]]++;
}
java.util.ArrayList<java.util.ArrayList<Integer>> result = new java.util.ArrayList<>(n);
for (int i = 0; i < n; i++) {
result.add(new java.util.ArrayList<>(groupSize[i]));
}
for (int i = 0; i < n; i++) {
result.get(leaderBuf[i]).add(i);
}
result.removeIf(java.util.ArrayList::isEmpty);
return result;
}
}
class ModIntFactory {
private final ModArithmetic ma;
private final int mod;
private final boolean usesMontgomery;
private final ModArithmetic.ModArithmeticMontgomery maMontgomery;
private ArrayList<Integer> factorial;
public ModIntFactory(int mod) {
this.ma = ModArithmetic.of(mod);
this.usesMontgomery = ma instanceof ModArithmetic.ModArithmeticMontgomery;
this.maMontgomery = usesMontgomery ? (ModArithmetic.ModArithmeticMontgomery) ma : null;
this.mod = mod;
this.factorial = new ArrayList<>();
}
public ModInt create(long value) {
if ((value %= mod) < 0) value += mod;
if (usesMontgomery) {
return new ModInt(maMontgomery.generate(value));
} else {
return new ModInt((int) value);
}
}
private void prepareFactorial(int max){
factorial.ensureCapacity(max+1);
if(factorial.size()==0) factorial.add(1);
if (usesMontgomery) {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), maMontgomery.generate(i)));
}
} else {
for(int i=factorial.size(); i<=max; i++){
factorial.add(ma.mul(factorial.get(i-1), i));
}
}
}
public ModInt factorial(int i){
prepareFactorial(i);
return create(factorial.get(i));
}
public ModInt permutation(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), factorial.get(r)));
}
public ModInt combination(int n, int r){
if(n < 0 || r < 0 || n < r) return create(0);
prepareFactorial(n);
return create(ma.div(factorial.get(n), ma.mul(factorial.get(r),factorial.get(n-r))));
}
public int getMod() {
return mod;
}
public class ModInt {
private int value;
private ModInt(int value) {
this.value = value;
}
public int mod() {
return mod;
}
public int value() {
if (usesMontgomery) {
return maMontgomery.reduce(value);
}
return value;
}
public ModInt add(ModInt mi) {
return new ModInt(ma.add(value, mi.value));
}
public ModInt add(ModInt mi1, ModInt mi2) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3);
}
public ModInt add(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.add(value, mi1.value)).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt add(ModInt mi1, ModInt... mis) {
ModInt mi = add(mi1);
for (ModInt m : mis) mi.addAsg(m);
return mi;
}
public ModInt add(long mi) {
return new ModInt(ma.add(value, ma.remainder(mi)));
}
public ModInt sub(ModInt mi) {
return new ModInt(ma.sub(value, mi.value));
}
public ModInt sub(long mi) {
return new ModInt(ma.sub(value, ma.remainder(mi)));
}
public ModInt mul(ModInt mi) {
return new ModInt(ma.mul(value, mi.value));
}
public ModInt mul(ModInt mi1, ModInt mi2) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mul(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return new ModInt(ma.mul(value, mi1.value)).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mul(ModInt mi1, ModInt... mis) {
ModInt mi = mul(mi1);
for (ModInt m : mis) mi.mulAsg(m);
return mi;
}
public ModInt mul(long mi) {
return new ModInt(ma.mul(value, ma.remainder(mi)));
}
public ModInt div(ModInt mi) {
return new ModInt(ma.div(value, mi.value));
}
public ModInt div(long mi) {
return new ModInt(ma.div(value, ma.remainder(mi)));
}
public ModInt inv() {
return new ModInt(ma.inv(value));
}
public ModInt pow(long b) {
return new ModInt(ma.pow(value, b));
}
public ModInt addAsg(ModInt mi) {
this.value = ma.add(value, mi.value);
return this;
}
public ModInt addAsg(ModInt mi1, ModInt mi2) {
return addAsg(mi1).addAsg(mi2);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3);
}
public ModInt addAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return addAsg(mi1).addAsg(mi2).addAsg(mi3).addAsg(mi4);
}
public ModInt addAsg(ModInt... mis) {
for (ModInt m : mis) addAsg(m);
return this;
}
public ModInt addAsg(long mi) {
this.value = ma.add(value, ma.remainder(mi));
return this;
}
public ModInt subAsg(ModInt mi) {
this.value = ma.sub(value, mi.value);
return this;
}
public ModInt subAsg(long mi) {
this.value = ma.sub(value, ma.remainder(mi));
return this;
}
public ModInt mulAsg(ModInt mi) {
this.value = ma.mul(value, mi.value);
return this;
}
public ModInt mulAsg(ModInt mi1, ModInt mi2) {
return mulAsg(mi1).mulAsg(mi2);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3);
}
public ModInt mulAsg(ModInt mi1, ModInt mi2, ModInt mi3, ModInt mi4) {
return mulAsg(mi1).mulAsg(mi2).mulAsg(mi3).mulAsg(mi4);
}
public ModInt mulAsg(ModInt... mis) {
for (ModInt m : mis) mulAsg(m);
return this;
}
public ModInt mulAsg(long mi) {
this.value = ma.mul(value, ma.remainder(mi));
return this;
}
public ModInt divAsg(ModInt mi) {
this.value = ma.div(value, mi.value);
return this;
}
public ModInt divAsg(long mi) {
this.value = ma.div(value, ma.remainder(mi));
return this;
}
@Override
public String toString() {
return String.valueOf(value());
}
@Override
public boolean equals(Object o) {
if (o instanceof ModInt) {
ModInt mi = (ModInt) o;
return mod() == mi.mod() && value() == mi.value();
}
return false;
}
@Override
public int hashCode() {
return (1 * 37 + mod()) * 37 + value();
}
}
private static abstract class ModArithmetic {
abstract int mod();
abstract int remainder(long value);
abstract int add(int a, int b);
abstract int sub(int a, int b);
abstract int mul(int a, int b);
int div(int a, int b) {
return mul(a, inv(b));
}
int inv(int a) {
int b = mod();
if (b == 1) return 0;
long u = 1, v = 0;
while (b >= 1) {
int t = a / b;
a -= t * b;
int tmp1 = a; a = b; b = tmp1;
u -= t * v;
long tmp2 = u; u = v; v = tmp2;
}
if (a != 1) {
throw new ArithmeticException("divide by zero");
}
return remainder(u);
}
int pow(int a, long b) {
if (b < 0) throw new ArithmeticException("negative power");
int r = 1;
int x = a;
while (b > 0) {
if ((b & 1) == 1) r = mul(r, x);
x = mul(x, x);
b >>= 1;
}
return r;
}
static ModArithmetic of(int mod) {
if (mod <= 0) {
throw new IllegalArgumentException();
} else if (mod == 1) {
return new ModArithmetic1();
} else if (mod == 2) {
return new ModArithmetic2();
} else if (mod == 998244353) {
return new ModArithmetic998244353();
} else if (mod == 1000000007) {
return new ModArithmetic1000000007();
} else if ((mod & 1) == 1) {
return new ModArithmeticMontgomery(mod);
} else {
return new ModArithmeticBarrett(mod);
}
}
private static final class ModArithmetic1 extends ModArithmetic {
int mod() {return 1;}
int remainder(long value) {return 0;}
int add(int a, int b) {return 0;}
int sub(int a, int b) {return 0;}
int mul(int a, int b) {return 0;}
int pow(int a, long b) {return 0;}
}
private static final class ModArithmetic2 extends ModArithmetic {
int mod() {return 2;}
int remainder(long value) {return (int) (value & 1);}
int add(int a, int b) {return a ^ b;}
int sub(int a, int b) {return a ^ b;}
int mul(int a, int b) {return a & b;}
}
private static final class ModArithmetic998244353 extends ModArithmetic {
private final int mod = 998244353;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmetic1000000007 extends ModArithmetic {
private final int mod = 1000000007;
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int res = a + b;
return res >= mod ? res - mod : res;
}
int sub(int a, int b) {
int res = a - b;
return res < 0 ? res + mod : res;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
private static final class ModArithmeticMontgomery extends ModArithmeticDynamic {
private final long negInv;
private final long r2;
private ModArithmeticMontgomery(int mod) {
super(mod);
long inv = 0;
long s = 1, t = 0;
for (int i = 0; i < 32; i++) {
if ((t & 1) == 0) {
t += mod;
inv += s;
}
t >>= 1;
s <<= 1;
}
long r = (1l << 32) % mod;
this.negInv = inv;
this.r2 = (r * r) % mod;
}
private int generate(long x) {
return reduce(x * r2);
}
private int reduce(long x) {
x = (x + ((x * negInv) & 0xffff_ffffl) * mod) >>> 32;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return generate((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
@Override
int inv(int a) {
return super.inv(reduce(a));
}
@Override
int pow(int a, long b) {
return generate(super.pow(a, b));
}
}
private static final class ModArithmeticBarrett extends ModArithmeticDynamic {
private static final long mask = 0xffff_ffffl;
private final long mh;
private final long ml;
private ModArithmeticBarrett(int mod) {
super(mod);
/**
* m = floor(2^64/mod)
* 2^64 = p*mod + q, 2^32 = a*mod + b
* => (a*mod + b)^2 = p*mod + q
* => p = mod*a^2 + 2ab + floor(b^2/mod)
*/
long a = (1l << 32) / mod;
long b = (1l << 32) % mod;
long m = a * a * mod + 2 * a * b + (b * b) / mod;
mh = m >>> 32;
ml = m & mask;
}
private int reduce(long x) {
long z = (x & mask) * ml;
z = (x & mask) * mh + (x >>> 32) * ml + (z >>> 32);
z = (x >>> 32) * mh + (z >>> 32);
x -= z * mod;
return (int) (x < mod ? x : x - mod);
}
@Override
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
@Override
int mul(int a, int b) {
return reduce((long) a * b);
}
}
private static class ModArithmeticDynamic extends ModArithmetic {
final int mod;
ModArithmeticDynamic(int mod) {
this.mod = mod;
}
int mod() {
return mod;
}
int remainder(long value) {
return (int) ((value %= mod) < 0 ? value + mod : value);
}
int add(int a, int b) {
int sum = a + b;
return sum >= mod ? sum - mod : sum;
}
int sub(int a, int b) {
int sum = a - b;
return sum < 0 ? sum + mod : sum;
}
int mul(int a, int b) {
return (int) (((long) a * b) % mod);
}
}
}
}
class SCC {
static class Edge {
int from, to;
public Edge(int from, int to) {
this.from = from; this.to = to;
}
}
final int n;
int m;
final java.util.ArrayList<Edge> unorderedEdges;
final int[] start;
final int[] ids;
boolean hasBuilt = false;
public SCC(int n) {
this.n = n;
this.unorderedEdges = new java.util.ArrayList<>();
this.start = new int[n + 1];
this.ids = new int[n];
}
public void addEdge(int from, int to) {
rangeCheck(from);
rangeCheck(to);
unorderedEdges.add(new Edge(from, to));
start[from + 1]++;
this.m++;
}
public int id(int i) {
if (!hasBuilt) {
throw new UnsupportedOperationException(
"Graph hasn't been built."
);
}
rangeCheck(i);
return ids[i];
}
public int[][] build() {
for (int i = 1; i <= n; i++) {
start[i] += start[i - 1];
}
Edge[] orderedEdges = new Edge[m];
int[] count = new int[n + 1];
System.arraycopy(start, 0, count, 0, n + 1);
for (Edge e : unorderedEdges) {
orderedEdges[count[e.from]++] = e;
}
int nowOrd = 0;
int groupNum = 0;
int k = 0;
// parent
int[] par = new int[n];
int[] vis = new int[n];
int[] low = new int[n];
int[] ord = new int[n];
java.util.Arrays.fill(ord, -1);
// u = lower32(stack[i]) : visiting vertex
// j = upper32(stack[i]) : jth child
long[] stack = new long[n];
// size of stack
int ptr = 0;
// non-recursional DFS
for (int i = 0; i < n; i++) {
if (ord[i] >= 0) continue;
par[i] = -1;
// vertex i, 0th child.
stack[ptr++] = 0l << 32 | i;
// stack is not empty
while (ptr > 0) {
// last element
long p = stack[--ptr];
// vertex
int u = (int) (p & 0xffff_ffffl);
// jth child
int j = (int) (p >>> 32);
if (j == 0) { // first visit
low[u] = ord[u] = nowOrd++;
vis[k++] = u;
}
if (start[u] + j < count[u]) { // there are more children
// jth child
int to = orderedEdges[start[u] + j].to;
// incr children counter
stack[ptr++] += 1l << 32;
if (ord[to] == -1) { // new vertex
stack[ptr++] = 0l << 32 | to;
par[to] = u;
} else { // backward edge
low[u] = Math.min(low[u], ord[to]);
}
} else { // no more children (leaving)
while (j --> 0) {
int to = orderedEdges[start[u] + j].to;
// update lowlink
if (par[to] == u) low[u] = Math.min(low[u], low[to]);
}
if (low[u] == ord[u]) { // root of a component
while (true) { // gathering verticies
int v = vis[--k];
ord[v] = n;
ids[v] = groupNum;
if (v == u) break;
}
groupNum++; // incr the number of components
}
}
}
}
for (int i = 0; i < n; i++) {
ids[i] = groupNum - 1 - ids[i];
}
int[] counts = new int[groupNum];
for (int x : ids) counts[x]++;
int[][] groups = new int[groupNum][];
for (int i = 0; i < groupNum; i++) {
groups[i] = new int[counts[i]];
}
for (int i = 0; i < n; i++) {
int cmp = ids[i];
groups[cmp][--counts[cmp]] = i;
}
hasBuilt = true;
return groups;
}
private void rangeCheck(int i) {
if (i < 0 || i >= n) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for length %d", i, n)
);
}
}
}
class LazySegTree<S, F> {
final int MAX;
final int N;
final int Log;
final java.util.function.BinaryOperator<S> Op;
final S E;
final java.util.function.BiFunction<F, S, S> Mapping;
final java.util.function.BinaryOperator<F> Composition;
final F Id;
final S[] Dat;
final F[] Laz;
@SuppressWarnings("unchecked")
public LazySegTree(int n, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.Log = Integer.numberOfTrailingZeros(N);
this.Op = op;
this.E = e;
this.Mapping = mapping;
this.Composition = composition;
this.Id = id;
this.Dat = (S[]) new Object[N << 1];
this.Laz = (F[]) new Object[N];
java.util.Arrays.fill(Dat, E);
java.util.Arrays.fill(Laz, Id);
}
public LazySegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e, java.util.function.BiFunction<F, S, S> mapping, java.util.function.BinaryOperator<F> composition, F id) {
this(dat.length, op, e, mapping, composition, id);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, Dat, N, l);
for (int i = N - 1; i > 0; i--) {
Dat[i] = Op.apply(Dat[i << 1 | 0], Dat[i << 1 | 1]);
}
}
private void push(int k) {
if (Laz[k] == Id) return;
int lk = k << 1 | 0, rk = k << 1 | 1;
Dat[lk] = Mapping.apply(Laz[k], Dat[lk]);
Dat[rk] = Mapping.apply(Laz[k], Dat[rk]);
if (lk < N) Laz[lk] = Composition.apply(Laz[k], Laz[lk]);
if (rk < N) Laz[rk] = Composition.apply(Laz[k], Laz[rk]);
Laz[k] = Id;
}
private void pushTo(int k) {
for (int i = Log; i > 0; i--) push(k >> i);
}
private void pushTo(int lk, int rk) {
for (int i = Log; i > 0; i--) {
if (((lk >> i) << i) != lk) push(lk >> i);
if (((rk >> i) << i) != rk) push(rk >> i);
}
}
private void updateFrom(int k) {
k >>= 1;
while (k > 0) {
Dat[k] = Op.apply(Dat[k << 1 | 0], Dat[k << 1 | 1]);
k >>= 1;
}
}
private void updateFrom(int lk, int rk) {
for (int i = 1; i <= Log; i++) {
if (((lk >> i) << i) != lk) {
int lki = lk >> i;
Dat[lki] = Op.apply(Dat[lki << 1 | 0], Dat[lki << 1 | 1]);
}
if (((rk >> i) << i) != rk) {
int rki = (rk - 1) >> i;
Dat[rki] = Op.apply(Dat[rki << 1 | 0], Dat[rki << 1 | 1]);
}
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = x;
updateFrom(p);
}
public S get(int p) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
return Dat[p];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return E;
l += N; r += N;
pushTo(l, r);
S sumLeft = E, sumRight = E;
while (l < r) {
if ((l & 1) == 1) sumLeft = Op.apply(sumLeft, Dat[l++]);
if ((r & 1) == 1) sumRight = Op.apply(Dat[--r], sumRight);
l >>= 1; r >>= 1;
}
return Op.apply(sumLeft, sumRight);
}
public S allProd() {
return Dat[1];
}
public void apply(int p, F f) {
exclusiveRangeCheck(p);
p += N;
pushTo(p);
Dat[p] = Mapping.apply(f, Dat[p]);
updateFrom(p);
}
public void apply(int l, int r, F f) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
if (l == r) return;
l += N; r += N;
pushTo(l, r);
for (int l2 = l, r2 = r; l2 < r2;) {
if ((l2 & 1) == 1) {
Dat[l2] = Mapping.apply(f, Dat[l2]);
if (l2 < N) Laz[l2] = Composition.apply(f, Laz[l2]);
l2++;
}
if ((r2 & 1) == 1) {
r2--;
Dat[r2] = Mapping.apply(f, Dat[r2]);
if (r2 < N) Laz[r2] = Composition.apply(f, Laz[r2]);
}
l2 >>= 1; r2 >>= 1;
}
updateFrom(l, r);
}
public int maxRight(int l, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(l);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
pushTo(l);
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!g.test(Op.apply(sum, Dat[l]))) {
while (l < N) {
push(l);
l = l << 1;
if (g.test(Op.apply(sum, Dat[l]))) {
sum = Op.apply(sum, Dat[l]);
l++;
}
}
return l - N;
}
sum = Op.apply(sum, Dat[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> g) {
inclusiveRangeCheck(r);
if (!g.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
pushTo(r - 1);
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!g.test(Op.apply(Dat[r], sum))) {
while (r < N) {
push(r);
r = r << 1 | 1;
if (g.test(Op.apply(Dat[r], sum))) {
sum = Op.apply(Dat[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = Op.apply(Dat[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d is not in [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
private S[] simulatePushAll() {
S[] simDat = java.util.Arrays.copyOf(Dat, 2 * N);
F[] simLaz = java.util.Arrays.copyOf(Laz, 2 * N);
for (int k = 1; k < N; k++) {
if (simLaz[k] == Id) continue;
int lk = k << 1 | 0, rk = k << 1 | 1;
simDat[lk] = Mapping.apply(simLaz[k], simDat[lk]);
simDat[rk] = Mapping.apply(simLaz[k], simDat[rk]);
if (lk < N) simLaz[lk] = Composition.apply(simLaz[k], simLaz[lk]);
if (rk < N) simLaz[rk] = Composition.apply(simLaz[k], simLaz[rk]);
simLaz[k] = Id;
}
return simDat;
}
public String toDetailedString() {
return toDetailedString(1, 0, simulatePushAll());
}
private String toDetailedString(int k, int sp, S[] dat) {
if (k >= N) return indent(sp) + dat[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent, dat);
s += "\n";
s += indent(sp) + dat[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent, dat);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
S[] dat = simulatePushAll();
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(dat[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Permutation implements java.util.Iterator<int[]>, Iterable<int[]> {
private int[] next;
public Permutation(int n) {
next = java.util.stream.IntStream.range(0, n).toArray();
}
@Override
public boolean hasNext() {
return next != null;
}
@Override
public int[] next() {
int[] r = next.clone();
next = nextPermutation(next);
return r;
}
@Override
public java.util.Iterator<int[]> iterator() {
return this;
}
public static int[] nextPermutation(int[] a) {
if (a == null || a.length < 2)
return null;
int p = 0;
for (int i = a.length - 2; i >= 0; i--) {
if (a[i] >= a[i + 1])
continue;
p = i;
break;
}
int q = 0;
for (int i = a.length - 1; i > p; i--) {
if (a[i] <= a[p])
continue;
q = i;
break;
}
if (p == 0 && q == 0)
return null;
int temp = a[p];
a[p] = a[q];
a[q] = temp;
int l = p, r = a.length;
while (++l < --r) {
temp = a[l];
a[l] = a[r];
a[r] = temp;
}
return a;
}
}
class SegTree<S> {
final int MAX;
final int N;
final java.util.function.BinaryOperator<S> op;
final S E;
final S[] data;
@SuppressWarnings("unchecked")
public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
this.MAX = n;
int k = 1;
while (k < n) k <<= 1;
this.N = k;
this.E = e;
this.op = op;
this.data = (S[]) new Object[N << 1];
java.util.Arrays.fill(data, E);
}
public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
this(dat.length, op, e);
build(dat);
}
private void build(S[] dat) {
int l = dat.length;
System.arraycopy(dat, 0, data, N, l);
for (int i = N - 1; i > 0; i--) {
data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
}
}
public void set(int p, S x) {
exclusiveRangeCheck(p);
data[p += N] = x;
p >>= 1;
while (p > 0) {
data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
p >>= 1;
}
}
public S get(int p) {
exclusiveRangeCheck(p);
return data[p + N];
}
public S prod(int l, int r) {
if (l > r) {
throw new IllegalArgumentException(
String.format("Invalid range: [%d, %d)", l, r)
);
}
inclusiveRangeCheck(l);
inclusiveRangeCheck(r);
S sumLeft = E;
S sumRight = E;
l += N; r += N;
while (l < r) {
if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
l >>= 1; r >>= 1;
}
return op.apply(sumLeft, sumRight);
}
public S allProd() {
return data[1];
}
public int maxRight(int l, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(l);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (l == MAX) return MAX;
l += N;
S sum = E;
do {
l >>= Integer.numberOfTrailingZeros(l);
if (!f.test(op.apply(sum, data[l]))) {
while (l < N) {
l = l << 1;
if (f.test(op.apply(sum, data[l]))) {
sum = op.apply(sum, data[l]);
l++;
}
}
return l - N;
}
sum = op.apply(sum, data[l]);
l++;
} while ((l & -l) != l);
return MAX;
}
public int minLeft(int r, java.util.function.Predicate<S> f) {
inclusiveRangeCheck(r);
if (!f.test(E)) {
throw new IllegalArgumentException("Identity element must satisfy the condition.");
}
if (r == 0) return 0;
r += N;
S sum = E;
do {
r--;
while (r > 1 && (r & 1) == 1) r >>= 1;
if (!f.test(op.apply(data[r], sum))) {
while (r < N) {
r = r << 1 | 1;
if (f.test(op.apply(data[r], sum))) {
sum = op.apply(data[r], sum);
r--;
}
}
return r + 1 - N;
}
sum = op.apply(data[r], sum);
} while ((r & -r) != r);
return 0;
}
private void exclusiveRangeCheck(int p) {
if (p < 0 || p >= MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
);
}
}
private void inclusiveRangeCheck(int p) {
if (p < 0 || p > MAX) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
);
}
}
// **************** DEBUG **************** //
private int indent = 6;
public void setIndent(int newIndent) {
this.indent = newIndent;
}
@Override
public String toString() {
return toSimpleString();
}
public String toDetailedString() {
return toDetailedString(1, 0);
}
private String toDetailedString(int k, int sp) {
if (k >= N) return indent(sp) + data[k];
String s = "";
s += toDetailedString(k << 1 | 1, sp + indent);
s += "\n";
s += indent(sp) + data[k];
s += "\n";
s += toDetailedString(k << 1 | 0, sp + indent);
return s;
}
private static String indent(int n) {
StringBuilder sb = new StringBuilder();
while (n --> 0) sb.append(' ');
return sb.toString();
}
public String toSimpleString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
for (int i = 0; i < N; i++) {
sb.append(data[i + N]);
if (i < N - 1) sb.append(',').append(' ');
}
sb.append(']');
return sb.toString();
}
}
class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S,T>>{
S first;
T second;
public Pair(S s, T t){
first = s;
second = t;
}
public S getFirst(){return first;}
public T getSecond(){return second;}
public boolean equals(Object another){
if(this==another) return true;
if(!(another instanceof Pair)) return false;
Pair otherPair = (Pair)another;
return this.first.equals(otherPair.first) && this.second.equals(otherPair.second);
}
public int compareTo(Pair<S,T> another){
java.util.Comparator<Pair<S,T>> comp1 = java.util.Comparator.comparing(Pair::getFirst);
java.util.Comparator<Pair<S,T>> comp2 = comp1.thenComparing(Pair::getSecond);
return comp2.compare(this, another);
}
public int hashCode(){
return first.hashCode() * 10007 + second.hashCode();
}
public String toString(){
return String.format("(%s, %s)", first, second);
}
} | ConDefects/ConDefects/Code/abc294_d/Java/44190273 |
condefects-java_data_1962 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String n = sc.next();
String t = "oxxoxxoxxo";
boolean check = t.contains(n);
if(check){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String n = sc.next();
String t = "oxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxxoxx";
boolean check = t.contains(n);
if(check){
System.out.println("Yes");
}else{
System.out.println("No");
}
}
} | ConDefects/ConDefects/Code/abc230_b/Java/44485526 |
condefects-java_data_1963 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
String s=scan.next();
String answer="Yes";
for(int i=0;i<=s.length()-3;i++){
if(s.charAt(i)=='o'){
if(i<(s.length()-1)){
if(s.charAt(i+1)=='x'){
if((i+1)<(s.length()-1)) {
if(s.charAt(i+2)=='x')continue;
else answer="No";
}
}
else
answer="No";
}
}
}
int sum=0;
for(int i=0;i<s.length();i++){
if(s.charAt(i)=='x')
sum++;
if(s.charAt(i)=='o')
sum=0;
}
if(sum>=3)
answer="No";
System.out.println(answer);
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
String s=scan.next();
String answer="Yes";
for(int i=0;i<=s.length()-2;i++){
if(s.charAt(i)=='o'){
if(i<(s.length()-1)){
if(s.charAt(i+1)=='x'){
if((i+1)<(s.length()-1)) {
if(s.charAt(i+2)=='x')continue;
else answer="No";
}
}
else
answer="No";
}
}
}
int sum=0;
for(int i=0;i<s.length();i++){
if(s.charAt(i)=='x')
sum++;
if(s.charAt(i)=='o')
sum=0;
}
if(sum>=3)
answer="No";
System.out.println(answer);
}
}
| ConDefects/ConDefects/Code/abc230_b/Java/36480597 |
condefects-java_data_1964 | import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner scan = new Scanner(System.in);
String S3 = scan.next();
// S3をsplitで分割して1文字ずつ格納
String[] strArray = S3.split("");
boolean Maru = false;
boolean Batu1 = false;
boolean Batu2 = false;
//System.out.println(strArray[0]);
if (strArray[0] == "o") {
Maru = true;
}
else {
Batu1 = true;
}
String next_str = "";
for (int i = 1; i < strArray.length; i++) {
next_str = strArray[i];
if (Maru) {
if (next_str.equals("x")) {
Maru = false;
Batu1 = true;
}
else {
System.out.println("No");
System.exit(0);
}
}
else if (Batu1) {
if (next_str.equals("x")) {
Batu1 = false;
Batu2 = true;
}
else {
if (i != 1) {
System.out.println("No");
System.exit(0);
}
else {
Batu1 = false;
Maru = true;
}
}
}
else if (Batu2) {
if (next_str.equals("o")) {
Batu2 = false;
Maru = true;
}
else {
System.out.println("No");
System.exit(0);
}
}
}
System.out.println("Yes");
}
}
import java.util.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner scan = new Scanner(System.in);
String S3 = scan.next();
// S3をsplitで分割して1文字ずつ格納
String[] strArray = S3.split("");
boolean Maru = false;
boolean Batu1 = false;
boolean Batu2 = false;
//System.out.println(strArray[0]);
if (strArray[0].equals("o")) {
Maru = true;
}
else {
Batu1 = true;
}
String next_str = "";
for (int i = 1; i < strArray.length; i++) {
next_str = strArray[i];
if (Maru) {
if (next_str.equals("x")) {
Maru = false;
Batu1 = true;
}
else {
System.out.println("No");
System.exit(0);
}
}
else if (Batu1) {
if (next_str.equals("x")) {
Batu1 = false;
Batu2 = true;
}
else {
if (i != 1) {
System.out.println("No");
System.exit(0);
}
else {
Batu1 = false;
Maru = true;
}
}
}
else if (Batu2) {
if (next_str.equals("o")) {
Batu2 = false;
Maru = true;
}
else {
System.out.println("No");
System.exit(0);
}
}
}
System.out.println("Yes");
}
}
| ConDefects/ConDefects/Code/abc230_b/Java/40717129 |
condefects-java_data_1965 | import com.sun.source.tree.WhileLoopTree;
import java.io.*;
import java.util.*;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static StringTokenizer st;
static int MOD = (int) 1e9+7;
public static void main(String[] args) throws IOException {
int n = readInt(), m = readInt();
long sum = 0;
int[] A = new int[n];
Map<Integer, Integer> cnt = new HashMap<>();
TreeSet<Integer> ts = new TreeSet<>();
for (int i = 0; i < n; i++) {
A[i] = readInt(); sum+=A[i];
ts.add(A[i]);
cnt.put(A[i], cnt.getOrDefault(A[i], 0) + 1);
}
int cur = 0;
long zero = 0;
while (true) {
if (cnt.getOrDefault(cur, 0) > 0) {
zero += (long) cnt.get(cur) * cur;
cur++;
} else {
break;
}
}
long ans = sum - zero;
for (int v : ts) {
if (v < cur) continue;
cur = v;
long tmp = 0;
while (true) {
if (cnt.getOrDefault(cur, 0) > 0) {
tmp += (long) cnt.get(cur) * cur;
cur++;
} else {
break;
}
}
if (cur == m - 1) tmp += zero;
ans = Math.min(ans, sum - tmp);
}
System.out.println(ans);
/*int n = readInt();
int[] deg = new int[n + 1];
Set<Integer>[] adj = new Set[n + 1];
for (int i = 1; i <= n; i++) adj[i] = new HashSet<>();
for (int i = 0; i < n - 1; i++) {
int u = readInt(), v = readInt();
deg[u]++; deg[v]++;
adj[u].add(v); adj[v].add(u);
}
List<Integer> ans = new ArrayList<>();
Queue<Integer> q = new LinkedList<>();
Set<Integer> vis = new HashSet<>();
for (int i = 1; i <= n; i++) {
if (deg[i] == 1) {
q.add(i);
}
}
if (q.isEmpty()) throw new IOException();
while (!q.isEmpty()) {
int sz = q.size();
while (sz-->0) {
int u = q.poll();
int mid = adj[u].stream().findFirst().get();
if (vis.contains(mid) || vis.contains(u)) continue;
vis.add(mid); vis.add(u);
ans.add(adj[mid].size());
for (int v : adj[mid]) {
deg[v]--; vis.add(v);
if (deg[v] == 1) {
adj[v].remove(mid);
int nxt = adj[v].stream().findFirst().get();
deg[nxt]--;
if (!vis.contains(nxt)) {
q.add(nxt);
}
}
}
adj[u].clear();
adj[mid].clear();
}
}
Collections.sort(ans);
for (int v : ans) {
System.out.print(v + " ");
}
System.out.println();*/
}
static String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine().trim());
return st.nextToken();
}
static long readLong() throws IOException {
return Long.parseLong(next());
}
static int readInt() throws IOException {
return Integer.parseInt(next());
}
static double readDouble() throws IOException {
return Double.parseDouble(next());
}
static char readCharacter() throws IOException {
return next().charAt(0);
}
static String readLine() throws IOException {
return br.readLine().trim();
}
static int readLongLineInt() throws IOException{
int x = 0, c;
while((c = br.read()) != ' ' && c != '\n')
x = x * 10 + (c - '0');
return x;
}
}
import com.sun.source.tree.WhileLoopTree;
import java.io.*;
import java.util.*;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
static StringTokenizer st;
static int MOD = (int) 1e9+7;
public static void main(String[] args) throws IOException {
int n = readInt(), m = readInt();
long sum = 0;
int[] A = new int[n];
Map<Integer, Integer> cnt = new HashMap<>();
TreeSet<Integer> ts = new TreeSet<>();
for (int i = 0; i < n; i++) {
A[i] = readInt(); sum+=A[i];
ts.add(A[i]);
cnt.put(A[i], cnt.getOrDefault(A[i], 0) + 1);
}
int cur = 0;
long zero = 0;
while (true) {
if (cnt.getOrDefault(cur, 0) > 0) {
zero += (long) cnt.get(cur) * cur;
cur++;
} else {
break;
}
}
long ans = sum - zero;
for (int v : ts) {
if (v < cur) continue;
cur = v;
long tmp = 0;
while (true) {
if (cnt.getOrDefault(cur, 0) > 0) {
tmp += (long) cnt.get(cur) * cur;
cur++;
} else {
break;
}
}
if (cur == m) tmp += zero;
ans = Math.min(ans, sum - tmp);
}
System.out.println(ans);
/*int n = readInt();
int[] deg = new int[n + 1];
Set<Integer>[] adj = new Set[n + 1];
for (int i = 1; i <= n; i++) adj[i] = new HashSet<>();
for (int i = 0; i < n - 1; i++) {
int u = readInt(), v = readInt();
deg[u]++; deg[v]++;
adj[u].add(v); adj[v].add(u);
}
List<Integer> ans = new ArrayList<>();
Queue<Integer> q = new LinkedList<>();
Set<Integer> vis = new HashSet<>();
for (int i = 1; i <= n; i++) {
if (deg[i] == 1) {
q.add(i);
}
}
if (q.isEmpty()) throw new IOException();
while (!q.isEmpty()) {
int sz = q.size();
while (sz-->0) {
int u = q.poll();
int mid = adj[u].stream().findFirst().get();
if (vis.contains(mid) || vis.contains(u)) continue;
vis.add(mid); vis.add(u);
ans.add(adj[mid].size());
for (int v : adj[mid]) {
deg[v]--; vis.add(v);
if (deg[v] == 1) {
adj[v].remove(mid);
int nxt = adj[v].stream().findFirst().get();
deg[nxt]--;
if (!vis.contains(nxt)) {
q.add(nxt);
}
}
}
adj[u].clear();
adj[mid].clear();
}
}
Collections.sort(ans);
for (int v : ans) {
System.out.print(v + " ");
}
System.out.println();*/
}
static String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine().trim());
return st.nextToken();
}
static long readLong() throws IOException {
return Long.parseLong(next());
}
static int readInt() throws IOException {
return Integer.parseInt(next());
}
static double readDouble() throws IOException {
return Double.parseDouble(next());
}
static char readCharacter() throws IOException {
return next().charAt(0);
}
static String readLine() throws IOException {
return br.readLine().trim();
}
static int readLongLineInt() throws IOException{
int x = 0, c;
while((c = br.read()) != ' ' && c != '\n')
x = x * 10 + (c - '0');
return x;
}
}
| ConDefects/ConDefects/Code/abc277_d/Java/41859129 |
condefects-java_data_1966 | import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner();
int n = sc.nextInt();
int m = sc.nextInt();
TreeMap<Integer, Long> counts = new TreeMap<>();
long total = 0;
for (int i = 0; i < n; i++) {
int x = sc.nextInt();
total += x;
counts.put(x, counts.getOrDefault(x, 0L) + 1);
counts.put(x + m, counts.getOrDefault(x + m, 0L) + 1);
}
Integer key = -1;
long ans = 0;
while (key < m) {
key = counts.higherKey(key);
long current = (key % m) * counts.get(key);
while (counts.containsKey(key + 1)) {
key++;
current += (key % m) * counts.get(key);
}
ans = Math.max(ans, current);
}
System.out.println(total - ans);
}
}
class Utilities {
static String arrayToLineString(Object[] arr) {
return Arrays.stream(arr).map(x -> x.toString()).collect(Collectors.joining("\n"));
}
static String arrayToLineString(int[] arr) {
return String.join("\n", Arrays.stream(arr).mapToObj(String::valueOf).toArray(String[]::new));
}
}
class Scanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
StringBuilder sb = new StringBuilder();
public Scanner() throws Exception {
}
public int nextInt() throws Exception {
return Integer.parseInt(next());
}
public long nextLong() throws Exception {
return Long.parseLong(next());
}
public double nextDouble() throws Exception {
return Double.parseDouble(next());
}
public int[] nextIntArray() throws Exception {
return Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
}
public String next() throws Exception {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
}
import java.io.*;
import java.util.*;
import java.util.stream.*;
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner();
int n = sc.nextInt();
int m = sc.nextInt();
TreeMap<Integer, Long> counts = new TreeMap<>();
long total = 0;
for (int i = 0; i < n; i++) {
int x = sc.nextInt();
total += x;
counts.put(x, counts.getOrDefault(x, 0L) + 1);
counts.put(x + m, counts.getOrDefault(x + m, 0L) + 1);
}
Integer key = -1;
long ans = 0;
while (key < m) {
key = counts.higherKey(key);
long current = (key % m) * counts.get(key);
while (counts.containsKey(key + 1)) {
key++;
current += (key % m) * counts.get(key);
}
ans = Math.max(ans, current);
}
System.out.println(Math.max(0, total - ans));
}
}
class Utilities {
static String arrayToLineString(Object[] arr) {
return Arrays.stream(arr).map(x -> x.toString()).collect(Collectors.joining("\n"));
}
static String arrayToLineString(int[] arr) {
return String.join("\n", Arrays.stream(arr).mapToObj(String::valueOf).toArray(String[]::new));
}
}
class Scanner {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer("");
StringBuilder sb = new StringBuilder();
public Scanner() throws Exception {
}
public int nextInt() throws Exception {
return Integer.parseInt(next());
}
public long nextLong() throws Exception {
return Long.parseLong(next());
}
public double nextDouble() throws Exception {
return Double.parseDouble(next());
}
public int[] nextIntArray() throws Exception {
return Stream.of(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
}
public String next() throws Exception {
while (!st.hasMoreTokens()) {
st = new StringTokenizer(br.readLine());
}
return st.nextToken();
}
} | ConDefects/ConDefects/Code/abc277_d/Java/45297967 |
condefects-java_data_1967 | import javax.management.InstanceNotFoundException;
import javax.swing.text.html.InlineView;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353; //1000000007
int n = in.nextInt();
long m = in.nextLong();
long[] a = in.nextLongArray(n);
long[] sums = new long[n];
boolean[] aa = new boolean[n];
void solve() {
Arrays.sort(a);
long sum = 0;
for (long l : a) {
sum += l;
}
long max = 0;
for (int i = 0; i < n; i++) {
if(!aa[i]){
long temp = dfs(i,new HashSet<>());
max = Math.max(temp,max);
}
}
out.println(sum - max);
}
long dfs(int now,Set<Integer> p){
aa[now] = true;
p.add(now);
sums[now] = a[now];
if((a[(now+1)%n] - a[now] + m) % m <= 1 && !p.contains((now+1)%n)){
if(aa[(now+1)%n]){
return sums[(now+1)%n];
}else{
sums[now] = dfs((now+1)%n,p)+a[now];
return sums[now];
}
}
return a[now];
}
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);
}
void ans(boolean a){
out.println(a ? "Yes" : "No");
}
void ans(boolean a,String t,String f){
out.println(a ? t : f);
}
long pow(long a,long b){
long n = 1;
for (long i = 0; i < Math.abs(b); i++) {
n *= a;
n %= mod;
}
return b > 0 ? n : 1/n;
}
List<List<Integer>> listNew(int n){
List<List<Integer>> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
list.add(new ArrayList<>());
}
return list;
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class Pair{
int f;
int s;
Pair(int f,int 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(char a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(int a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(long a) {
out.println(a);
if (autoFlush) {
out.flush();
}
}
void println(double a) {
out.println(String.format("%.10f", a));
if (autoFlush) {
out.flush();
}
}
void println(String s) {
out.println(s);
if (autoFlush) {
out.flush();
}
}
void println(char[] s) {
out.println(String.valueOf(s));
if (autoFlush) {
out.flush();
}
}
void println(int[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (int i : a) {
joiner.add(Integer.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void println(long[] a) {
StringJoiner joiner = new StringJoiner(" ");
for (long i : a) {
joiner.add(Long.toString(i));
}
out.println(joiner);
if (autoFlush) {
out.flush();
}
}
void flush() {
err.flush();
out.flush();
}
}
import javax.management.InstanceNotFoundException;
import javax.swing.text.html.InlineView;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static In in = new FastIn();
static Out out = new Out(false);
static final long inf = 0x1fffffffffffffffL;
static final int iinf = 0x3fffffff;
static final double eps = 1e-9;
static long mod = 998244353; //1000000007
int n = in.nextInt();
long m = in.nextLong();
long[] a = in.nextLongArray(n);
long[] sums = new long[n];
boolean[] aa = new boolean[n];
void solve() {
Arrays.sort(a);
long sum = 0;
for (long l : a) {
sum += l;
}
long max = 0;
for (int i = 0; i < n; i++) {
if(!aa[i]){
long temp = dfs(i,new HashSet<>());
max = Math.max(temp,max);
}
}
out.println(sum - max);
}
long dfs(int now,Set<Integer> p){
aa[now] = true;
p.add(now);
sums[now] = a[now];
if((a[(now+1)%n] - a[now] + m) % m <= 1 && !p.contains((now+1)%n)){
if(aa[(now+1)%n]){
return sums[(now+1)%n] + a[now];
}else{
sums[now] = dfs((now+1)%n,p)+a[now];
return sums[now];
}
}
return a[now];
}
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);
}
void ans(boolean a){
out.println(a ? "Yes" : "No");
}
void ans(boolean a,String t,String f){
out.println(a ? t : f);
}
long pow(long a,long b){
long n = 1;
for (long i = 0; i < Math.abs(b); i++) {
n *= a;
n %= mod;
}
return b > 0 ? n : 1/n;
}
List<List<Integer>> listNew(int n){
List<List<Integer>> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
list.add(new ArrayList<>());
}
return list;
}
public static void main(String... args) {
new Main().solve();
out.flush();
}
}
class Pair{
int f;
int s;
Pair(int f,int 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(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/abc277_d/Java/40956617 |
condefects-java_data_1968 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@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.nextInt();
var M = fs.nextInt();
var An = fs.nextLongArray(N);
Arrays.sort(An);
var sum = Arrays.stream(An).sum();
var d = 0L;
var ans = Long.MAX_VALUE;
for (int i = 0; i < 2 * N; i++) {
var j = i;
d = An[j % N];
while (true) {
if (i % N == (j + 1) % N) {
ans = Math.min(ans, sum - d);
break;
}
if (An[j % N] == An[(j + 1) % N] || (An[j % N] + 1) == An[(j + 1) % N]) {
d += An[(j + 1) % N];
j++;
} else {
ans = Math.min(ans, sum - d);
break;
}
}
i = j;
}
pw.println(ans);
//==================
}
//--------------
record Pair(int a, int b) {
}
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();
}
}
//-------------------------------------------------------------------
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 next() {
return innerNext(b -> (33 <= b && b <= 126));
}
public int nextInt() {
return (int) nextLong();
}
public int[] nextIntArray(int n) {
int[] result = new int[n];
for (int i = 0; i < n; i++) {
result[i] = nextInt();
}
return result;
}
public String[] nextArray(int n) {
String[] result = new String[n];
for (int i = 0; i < n; i++) {
result[i] = next();
}
return result;
}
public long[] nextLongArray(int n) {
long[] result = new long[n];
for (int i = 0; i < n; i++) {
result[i] = nextLong();
}
return result;
}
public long nextLong() {
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.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@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.nextInt();
var M = fs.nextInt();
var An = fs.nextLongArray(N);
Arrays.sort(An);
var sum = Arrays.stream(An).sum();
var d = 0L;
var ans = Long.MAX_VALUE;
for (int i = 0; i < 2 * N; i++) {
var j = i;
d = An[j % N];
while (true) {
if (i % N == (j + 1) % N) {
ans = Math.min(ans, sum - d);
break;
}
if (An[j % N] == An[(j + 1) % N] || ((An[j % N] + 1) % M) == An[(j + 1) % N]) {
d += An[(j + 1) % N];
j++;
} else {
ans = Math.min(ans, sum - d);
break;
}
}
i = j;
}
pw.println(ans);
//==================
}
//--------------
record Pair(int a, int b) {
}
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();
}
}
//-------------------------------------------------------------------
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 next() {
return innerNext(b -> (33 <= b && b <= 126));
}
public int nextInt() {
return (int) nextLong();
}
public int[] nextIntArray(int n) {
int[] result = new int[n];
for (int i = 0; i < n; i++) {
result[i] = nextInt();
}
return result;
}
public String[] nextArray(int n) {
String[] result = new String[n];
for (int i = 0; i < n; i++) {
result[i] = next();
}
return result;
}
public long[] nextLongArray(int n) {
long[] result = new long[n];
for (int i = 0; i < n; i++) {
result[i] = nextLong();
}
return result;
}
public long nextLong() {
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/abc277_d/Java/45996648 |
condefects-java_data_1969 |
import java.util.*;
public class Main{
static long dp[][] = new long[5005][5005];
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
long n = in.nextLong();
long a = in.nextLong();
long b = in.nextLong();
if(n<a){
System.out.println(0);
return;
}
if(a>b){
long ans=(n/a-1)*b;
if(n%a>=b)
ans+=b-1;
else
ans+=n%a;
System.out.println(ans);
}else{
System.out.println(n-a+1);
}
}
}
import java.util.*;
public class Main{
static long dp[][] = new long[5005][5005];
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
long n = in.nextLong();
long a = in.nextLong();
long b = in.nextLong();
if(n<a){
System.out.println(0);
return;
}
if(a>b){
long ans=n / a + (n / a - 1) * (b - 1);;
if(n%a>=b)
ans+=b-1;
else
ans+=n%a;
System.out.println(ans);
}else{
System.out.println(n-a+1);
}
}
}
| ConDefects/ConDefects/Code/arc145_b/Java/33938234 |
condefects-java_data_1970 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Long N = input.nextLong();
Long A = input.nextLong();
Long B = input.nextLong();
Long result = Long.valueOf(0);
result = countSet(A, B, N) - countSet(A, B, A-1);
System.out.println(result);
}
public static Long countSet(Long A, Long B, Long X) {
return (X / A) * Math.min(A, B) + Math.min(X % A, B - 1);
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Long N = input.nextLong();
Long A = input.nextLong();
Long B = input.nextLong();
Long result = Long.valueOf(0);
result = countSet(A, B, N) - countSet(A, B, A-1);
System.out.println(Math.max(result, 0));
}
public static Long countSet(Long A, Long B, Long X) {
return (X / A) * Math.min(A, B) + Math.min(X % A, B - 1);
}
}
| ConDefects/ConDefects/Code/arc145_b/Java/33695650 |
condefects-java_data_1971 | import java.util.*;
import java.util.stream.Collectors;
public class Main{
// static final int INF = Integer.MAX_VALUE;
// static final long INF = Long.MAX_VALUE;
// static final long MOD = 998244353;
static long N;
static long A;
static long B;
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
N = sc.nextLong();
A = sc.nextLong();
B = sc.nextLong();
class P{
}
if(A > B){
long M = N / A;
// long ans = B * (N / A - 1);
// N -= A * (N / A) - 1;
// System.out.println(ans);
// System.out.println(N);
// ans += Math.min(B, N);
// int[] a = new int[5];
// a[6] = 0;
System.out.println(B*(M-1)+Math.min(N - M*A + 1, B));
// long ans = Math.max(f(N) - f(A-1), 0);
// System.out.println(ans);
}else{
long ans = Math.max(N - A + 1, 0);
// long ans = Math.max((N/A)*A + Math.min(N % A, B - 1) - A + 1, 0);
System.out.println(ans);
}
}
static long f(long x){
return (x/A)*Math.min(A, B) + Math.min(x % A, B - 1);
}
}
import java.util.*;
import java.util.stream.Collectors;
public class Main{
// static final int INF = Integer.MAX_VALUE;
// static final long INF = Long.MAX_VALUE;
// static final long MOD = 998244353;
static long N;
static long A;
static long B;
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
N = sc.nextLong();
A = sc.nextLong();
B = sc.nextLong();
class P{
}
if(A > B){
long M = N / A;
// long ans = B * (N / A - 1);
// N -= A * (N / A) - 1;
// System.out.println(ans);
// System.out.println(N);
// ans += Math.min(B, N);
// int[] a = new int[5];
// a[6] = 0;
System.out.println(Math.max(B*(M-1)+Math.min(N - M*A + 1, B), 0));
// long ans = Math.max(f(N) - f(A-1), 0);
// System.out.println(ans);
}else{
long ans = Math.max(N - A + 1, 0);
// long ans = Math.max((N/A)*A + Math.min(N % A, B - 1) - A + 1, 0);
System.out.println(ans);
}
}
static long f(long x){
return (x/A)*Math.min(A, B) + Math.min(x % A, B - 1);
}
}
| ConDefects/ConDefects/Code/arc145_b/Java/33639122 |
condefects-java_data_1972 | import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import javax.naming.TimeLimitExceededException;
//import static java.lang.Math.*;
import static java.util.Arrays.*;
//import static java.util.Collections.*;
//import static java.util.Comparator.*;
class Solver{
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";
Util util = new Util();
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
long N = in.lg();
long A = in.lg();
long B = in.lg();
Object solve(){ return f(N) -f(A -1); }
private long f(long x){ return x /A *Math.min(A,B) +Math.min(x %A,B -1); }
}
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 Util{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
static int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
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 void rev(int[] arr){
for (int l = 0,r = arr.length -1;l < r;) {
arr[l] ^= arr[r];
arr[r] ^= arr[l];
arr[l++] ^= arr[r--];
}
}
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 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 (Edge e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (Edge e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
Edge 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 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 instanceof Collection<?>) {
Iterator<?> itr = ((Collection<?>) obj).iterator();
while (itr.hasNext()) {
print(itr.next());
if (itr.hasNext())
ln();
}
} 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++) {
print(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;
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.util.elapsed());
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
import javax.naming.TimeLimitExceededException;
//import static java.lang.Math.*;
import static java.util.Arrays.*;
//import static java.util.Collections.*;
//import static java.util.Comparator.*;
class Solver{
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";
Util util = new Util();
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
long N = in.lg();
long A = in.lg();
long B = in.lg();
Object solve(){ return A > N ? 0 : f(N) -f(A -1); }
private long f(long x){ return x /A *Math.min(A,B) +Math.min(x %A,B -1); }
}
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 Util{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
static int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
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 void rev(int[] arr){
for (int l = 0,r = arr.length -1;l < r;) {
arr[l] ^= arr[r];
arr[r] ^= arr[l];
arr[l++] ^= arr[r--];
}
}
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 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 (Edge e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (Edge e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
Edge 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 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 instanceof Collection<?>) {
Iterator<?> itr = ((Collection<?>) obj).iterator();
while (itr.hasNext()) {
print(itr.next());
if (itr.hasNext())
ln();
}
} 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++) {
print(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;
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.util.elapsed());
}
}
| ConDefects/ConDefects/Code/arc145_b/Java/41712483 |
condefects-java_data_1973 | 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 void main(String args[]){
try {
PrintWriter o = new PrintWriter(System.out);
boolean multiTest = false;
// init
if(multiTest) {
int t = fReader.nextInt(), loop = 0;
while (loop < t) {loop++;solve(o);}
} else solve(o);
o.close();
} catch (Exception e) {e.printStackTrace();}
}
static void solve(PrintWriter o) {
try {
long n = fReader.nextLong(), a = fReader.nextLong(), b = fReader.nextLong();
long res = 0l;
if(b >= a) {
res += Math.max(0, n-a+1);
}
else {
long t = n/a, mod = n%a;
res += 1l*Math.max(0, t-1)*b;
res += Math.min(mod+1, b);
}
o.println(res);
} catch (Exception e){e.printStackTrace();}
}
public static int upper_bound(List<int[]> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid)[0] <= val) l = mid + 1;
else r = mid;
}
return l;
}
public static int lower_bound(List<Integer> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid) < val) l = mid + 1;
else r = mid;
}
return l;
}
public static long gcd(long a, long b){
return b == 0 ? a : gcd(b, a%b);
}
public static long lcm(long a, long b){
return a / gcd(a,b)*b;
}
public static boolean isPrime(long x){
boolean ok = true;
for(long i=2;i<=Math.sqrt(x);i++){
if(x % i == 0){
ok = false;
break;
}
}
return ok;
}
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 long qpow(long a, long n){
long ret = 1l;
while(n > 0){
if((n & 1) == 1){
ret = ret * a;
}
n >>= 1;
a = a * a;
}
return ret;
}
public static class unionFind {
int[] parent;
int[] size;
int n;
public unionFind(int n){
this.n = n;
parent = new int[n+1];
size = new int[n+1];
for(int i=1;i<n;i++){
parent[i] = i;
size[i] = 1;
}
}
public int find(int p){
while(p != parent[p]){
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
public void union(int p, int q){
int root_p = find(p);
int root_q = find(q);
if(root_p == root_q) return;
if(size[root_p] >= size[root_q]){
parent[root_q] = root_p;
size[root_p] += size[root_q];
size[root_q] = 0;
}
else{
parent[root_p] = root_q;
size[root_q] += size[root_p];
size[root_p] = 0;
}
n--;
}
public int getCount(){
return n;
}
public int[] getSize(){
return size;
}
}
public static class FenWick {
long[] tree;
int n;
public FenWick(int n){
this.n = n;
tree = new long[n+1];
}
public void add(int x, int val){
while(x <= n){
tree[x] += val;
x += lowBit(x);
}
}
public int query(int x){
int ret = 0;
while(x > 0){
ret += tree[x];
x -= lowBit(x);
}
return ret;
}
public int lowBit(int x) {
return x&-x;
}
}
public static class fReader {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static StringTokenizer tokenizer = new StringTokenizer("");
private static String next() throws IOException{
while(!tokenizer.hasMoreTokens()){tokenizer = new StringTokenizer(reader.readLine());}
return tokenizer.nextToken();
}
public static int nextInt() throws IOException {return Integer.parseInt(next());}
public static Long nextLong() throws IOException {return Long.parseLong(next());}
public static double nextDouble() throws IOException {return Double.parseDouble(next());}
public static char nextChar() throws IOException {return next().toCharArray()[0];}
public static String nextString() throws IOException {return next();}
public static String nextLine() throws IOException {return reader.readLine();}
}
}
import java.io.*;
import java.util.*;
public class Main {
public static int INF = 0x3f3f3f3f;
public static int mod = 1000000007;
public static int mod9 = 998244353;
public static void main(String args[]){
try {
PrintWriter o = new PrintWriter(System.out);
boolean multiTest = false;
// init
if(multiTest) {
int t = fReader.nextInt(), loop = 0;
while (loop < t) {loop++;solve(o);}
} else solve(o);
o.close();
} catch (Exception e) {e.printStackTrace();}
}
static void solve(PrintWriter o) {
try {
long n = fReader.nextLong(), a = fReader.nextLong(), b = fReader.nextLong();
long res = 0l;
if(b >= a) {
res += Math.max(0, n-a+1);
}
else {
long t = n/a, mod = n%a;
res += 1l*Math.max(0, t-1)*b;
if(t > 0) res += Math.min(mod+1, b);
}
o.println(res);
} catch (Exception e){e.printStackTrace();}
}
public static int upper_bound(List<int[]> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid)[0] <= val) l = mid + 1;
else r = mid;
}
return l;
}
public static int lower_bound(List<Integer> a, int val){
int l = 0, r = a.size();
while(l < r){
int mid = l + (r - l) / 2;
if(a.get(mid) < val) l = mid + 1;
else r = mid;
}
return l;
}
public static long gcd(long a, long b){
return b == 0 ? a : gcd(b, a%b);
}
public static long lcm(long a, long b){
return a / gcd(a,b)*b;
}
public static boolean isPrime(long x){
boolean ok = true;
for(long i=2;i<=Math.sqrt(x);i++){
if(x % i == 0){
ok = false;
break;
}
}
return ok;
}
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 long qpow(long a, long n){
long ret = 1l;
while(n > 0){
if((n & 1) == 1){
ret = ret * a;
}
n >>= 1;
a = a * a;
}
return ret;
}
public static class unionFind {
int[] parent;
int[] size;
int n;
public unionFind(int n){
this.n = n;
parent = new int[n+1];
size = new int[n+1];
for(int i=1;i<n;i++){
parent[i] = i;
size[i] = 1;
}
}
public int find(int p){
while(p != parent[p]){
parent[p] = parent[parent[p]];
p = parent[p];
}
return p;
}
public void union(int p, int q){
int root_p = find(p);
int root_q = find(q);
if(root_p == root_q) return;
if(size[root_p] >= size[root_q]){
parent[root_q] = root_p;
size[root_p] += size[root_q];
size[root_q] = 0;
}
else{
parent[root_p] = root_q;
size[root_q] += size[root_p];
size[root_p] = 0;
}
n--;
}
public int getCount(){
return n;
}
public int[] getSize(){
return size;
}
}
public static class FenWick {
long[] tree;
int n;
public FenWick(int n){
this.n = n;
tree = new long[n+1];
}
public void add(int x, int val){
while(x <= n){
tree[x] += val;
x += lowBit(x);
}
}
public int query(int x){
int ret = 0;
while(x > 0){
ret += tree[x];
x -= lowBit(x);
}
return ret;
}
public int lowBit(int x) {
return x&-x;
}
}
public static class fReader {
private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
private static StringTokenizer tokenizer = new StringTokenizer("");
private static String next() throws IOException{
while(!tokenizer.hasMoreTokens()){tokenizer = new StringTokenizer(reader.readLine());}
return tokenizer.nextToken();
}
public static int nextInt() throws IOException {return Integer.parseInt(next());}
public static Long nextLong() throws IOException {return Long.parseLong(next());}
public static double nextDouble() throws IOException {return Double.parseDouble(next());}
public static char nextChar() throws IOException {return next().toCharArray()[0];}
public static String nextString() throws IOException {return next();}
public static String nextLine() throws IOException {return reader.readLine();}
}
}
| ConDefects/ConDefects/Code/arc145_b/Java/33640985 |
condefects-java_data_1974 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
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_ABGame solver = new B_ABGame();
solver.solve(1, in, out);
out.close();
}
static class B_ABGame {
public void solve(int testNumber, FastScanner in, PrintWriter out) {
long n = in.nextLong();
long a = in.nextLong();
long b = in.nextLong();
out.println(f(n + 1, a, b) - f(a, a, b));
}
private long f(long n, long a, long b) {
if (a <= b) {
return n;
}
long full = n / a;
long rem = n % a;
long res = 0;
res += full * b;
res += Math.min(rem, b);
return res;
}
}
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 long nextLong() {
return Long.parseLong(next());
}
}
}
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
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_ABGame solver = new B_ABGame();
solver.solve(1, in, out);
out.close();
}
static class B_ABGame {
public void solve(int testNumber, FastScanner in, PrintWriter out) {
long n = in.nextLong();
long a = in.nextLong();
long b = in.nextLong();
out.println(Math.max(0, f(n + 1, a, b) - f(a, a, b)));
}
private long f(long n, long a, long b) {
if (a <= b) {
return n;
}
long full = n / a;
long rem = n % a;
long res = 0;
res += full * b;
res += Math.min(rem, b);
return res;
}
}
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 long nextLong() {
return Long.parseLong(next());
}
}
}
| ConDefects/ConDefects/Code/arc145_b/Java/33634743 |
condefects-java_data_1975 | import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long a = sc.nextLong();
long b = sc.nextLong();
sc.close();
if(n<a){
System.out.println(0);
return;
}
if(a <= b){
System.out.println(n);
return;
}
// if(n<b){
// if(n>=a) System.out.println(n-a+1);
// else System.out.println(0);
// return;
// }
// if(a == 1){
// System.out.println(n);
// return;
// }
// if(b==1){
// System.out.println(n/a);
// return;
// }
// long w = n/a;
// long ans = w*b;
// if(n< a*w + b-1){
// ans = b*(w-1) + (n-a*w + 1);
// }
// System.out.println(ans);
System.out.println((n/a - 1)*b + 1 + Math.min(n%a, b - 1));
}
}
// System.out.println();
// for(int i=0; i<n; i++){
// }
// for(int i=0; i<n; i++){
// for(int j=0; j<n; j++){
// }
// }
// ArrayList<Integer> l = new ArrayList<>();
// LinkedList<Integer> l = new LinkedList<>();
// for(Map.Entry<String, String> entry : map.entrySet()) {
// System.out.println(entry.getKey());
// System.out.println(entry.getValue());
// }
// TreeMap<Integer,Integer> m = new TreeMap<>();
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
long a = sc.nextLong();
long b = sc.nextLong();
sc.close();
if(n<a){
System.out.println(0);
return;
}
if(a <= b){
System.out.println(n - a + 1);
return;
}
// if(n<b){
// if(n>=a) System.out.println(n-a+1);
// else System.out.println(0);
// return;
// }
// if(a == 1){
// System.out.println(n);
// return;
// }
// if(b==1){
// System.out.println(n/a);
// return;
// }
// long w = n/a;
// long ans = w*b;
// if(n< a*w + b-1){
// ans = b*(w-1) + (n-a*w + 1);
// }
// System.out.println(ans);
System.out.println((n/a - 1)*b + 1 + Math.min(n%a, b - 1));
}
}
// System.out.println();
// for(int i=0; i<n; i++){
// }
// for(int i=0; i<n; i++){
// for(int j=0; j<n; j++){
// }
// }
// ArrayList<Integer> l = new ArrayList<>();
// LinkedList<Integer> l = new LinkedList<>();
// for(Map.Entry<String, String> entry : map.entrySet()) {
// System.out.println(entry.getKey());
// System.out.println(entry.getValue());
// }
// TreeMap<Integer,Integer> m = new TreeMap<>();
| ConDefects/ConDefects/Code/arc145_b/Java/33649137 |
condefects-java_data_1976 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
var sc = new Scanner(System.in);
long n = Long.parseLong(sc.next());
long a = Long.parseLong(sc.next());
long b = Long.parseLong(sc.next());
if(a > n){
System.out.println(0);
}else if(a <= b){
System.out.println(n-a+1);
}else{
long ans = (n/a-1)*b + Math.min(n%a, b-1);
if(n/a >= 2){
ans++;
}
System.out.println(ans);
}
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
var sc = new Scanner(System.in);
long n = Long.parseLong(sc.next());
long a = Long.parseLong(sc.next());
long b = Long.parseLong(sc.next());
if(a > n){
System.out.println(0);
}else if(a <= b){
System.out.println(n-a+1);
}else{
long ans = (n/a-1)*b + Math.min(n%a, b-1);
if(n/a >= 1){
ans++;
}
System.out.println(ans);
}
}
} | ConDefects/ConDefects/Code/arc145_b/Java/33634136 |
condefects-java_data_1977 | import java.util.*;
import java.io.*;
import java.util.function.*;
public class Main {
public static boolean solve(int[] A, int[][] X, int N, int M) {
for (int i = 1; i < N; i++) {
for (int j = 0; j < M; j++) {
X[i][j] += X[i-1][j];
}
}
for (int j = 0; j < M; j++) {
if (X[N-1][j] < A[j]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
ContestScanner sc = new ContestScanner(System.in);
FastWriter out = new FastWriter(System.out);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = sc.nextIntArray(M);
int[][] X = sc.nextIntMatrix(N, M);
out.write((solve(A, X, N, M) ? "YES\n" : "NO\n"));
out.flush();
}
}
class ContestScanner {
private final 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(InputStream in) {
this.in = in;
}
public ContestScanner(File file) throws FileNotFoundException {
this(new BufferedInputStream(new FileInputStream(file)));
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public String nextLine() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b) || b == ' ') {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString().trim();
}
public String[] nextStringArray(int length) {
String[] array = new String[length];
for (int i = 0; i < length; i++) array[i] = this.next();
return array;
}
public String[] nextStringArray(int length, UnaryOperator<String> map) {
String[] array = new String[length];
for (int i = 0; i < length; i++) array[i] = map.apply(this.next());
return array;
}
public String[][] nextStringMatrix(int height, int width) {
String[][] mat = new String[height][width];
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
mat[h][w] = this.next();
}
}
return mat;
}
public String[][] nextStringMatrix(int height, int width, UnaryOperator<String> map) {
String[][] mat = new String[height][width];
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
mat[h][w] = map.apply(this.next());
}
}
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;
}
public char[][] nextCharMatrix(int height, int width, UnaryOperator<Character> map) {
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] = map.apply(s.charAt(w));
}
}
return mat;
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
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, IntUnaryOperator map) {
int[] array = new int[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsInt(this.nextInt());
return array;
}
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, 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 Integer[] nextIntegerArray(int length) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++) array[i] = this.nextInt();
return array;
}
public Integer[] nextIntegerArray(int length, IntUnaryOperator map) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsInt(this.nextInt());
return array;
}
public Integer[][] nextIntegerMatrix(int height, int width) {
Integer[][] mat = new Integer[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextInt();
}
return mat;
}
public Integer[][] nextIntegerMatrix(int height, int width, IntUnaryOperator map) {
Integer[][] mat = new Integer[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 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') {
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 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, LongUnaryOperator map) {
long[] array = new long[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsLong(this.nextLong());
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, 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 Long[] nextLongNonPrimitiveArray(int length) {
Long[] array = new Long[length];
for (int i = 0; i < length; i++) array[i] = this.nextLong();
return array;
}
public Long[] nextLongNonPrimitiveArray(int length, LongUnaryOperator map) {
Long[] array = new Long[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsLong(this.nextLong());
return array;
}
public Long[][] nextLongNonPrimitiveMatrix(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[][] nextLongNonPrimitiveMatrix(int height, int width, 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 double nextDouble() {
return Double.parseDouble(next());
}
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, DoubleUnaryOperator map) {
double[] array = new double[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
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 double[][] nextDoubleMatrix(int height, int width, DoubleUnaryOperator map) {
double[][] mat = new double[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = map.applyAsDouble(this.nextDouble());
}
return mat;
}
}
class FastWriter {
private static final int BUF_SIZE = 1 << 13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWriter() {
out = null;
}
public FastWriter(OutputStream os) {
this.out = os;
}
public FastWriter(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastWriter write(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE) innerflush();
return this;
}
public FastWriter write(char c) {
return write((byte) c);
}
public FastWriter write(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
return this;
}
public FastWriter write(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
});
return this;
}
private static int countDigits(int l) {
if (l >= 1000000000) return 10;
if (l >= 100000000) return 9;
if (l >= 10000000) return 8;
if (l >= 1000000) return 7;
if (l >= 100000) return 6;
if (l >= 10000) return 5;
if (l >= 1000) return 4;
if (l >= 100) return 3;
if (l >= 10) return 2;
return 1;
}
public FastWriter write(int x) {
if (x == Integer.MIN_VALUE) {
return write((long) x);
}
if (ptr + 12 >= BUF_SIZE) innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
public FastWriter write(long x) {
if (x == Long.MIN_VALUE) {
return write("" + x);
}
if (ptr + 21 >= BUF_SIZE) innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
public FastWriter write(double x, int precision) {
if (x < 0) {
write('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
write((long) x).write(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
write((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastWriter writeln(char c) {
return write(c).writeln();
}
public FastWriter writeln(int x) {
return write(x).writeln();
}
public FastWriter writeln(long x) {
return write(x).writeln();
}
public FastWriter writeln(double x, int precision) {
return write(x, precision).writeln();
}
public FastWriter write(int... xs) {
boolean first = true;
for (int x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter write(long... xs) {
boolean first = true;
for (long x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter writeln() {
return write((byte) '\n');
}
public FastWriter writeln(int... xs) {
return write(xs).writeln();
}
public FastWriter writeln(long... xs) {
return write(xs).writeln();
}
public FastWriter writeln(char[] line) {
return write(line).writeln();
}
public FastWriter writeln(char[]... map) {
for (char[] line : map) write(line).writeln();
return this;
}
public FastWriter writeln(String s) {
return write(s).writeln();
}
private void innerflush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (IOException e) {
throw new RuntimeException("innerflush");
}
}
public void flush() {
innerflush();
try {
out.flush();
} catch (IOException e) {
throw new RuntimeException("flush");
}
}
public FastWriter print(byte b) {
return write(b);
}
public FastWriter print(char c) {
return write(c);
}
public FastWriter print(String s) {
return write(s);
}
public FastWriter print(int x) {
return write(x);
}
public FastWriter print(long x) {
return write(x);
}
public FastWriter print(double x, int precision) {
return write(x, precision);
}
public FastWriter print(double x) {
return print(x, 20);
}
public FastWriter println(char c) {
return writeln(c);
}
public FastWriter println(int x) {
return writeln(x);
}
public FastWriter println(long x) {
return writeln(x);
}
public FastWriter println(double x, int precision) {
return writeln(x, precision);
}
public FastWriter println(double x) {
return println(x, 20);
}
public FastWriter println(String s) {
return writeln(s);
}
public FastWriter println() {
return writeln();
}
public FastWriter print(Object x) {
return print(x.toString());
}
public FastWriter println(Object x) {
return println(x.toString());
}
public void printArray(int[] array, String separator) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.applyAsInt(array[i]));
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.applyAsLong(array[i]));
print(separator);
}
println(map.applyAsLong(array[n - 1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(double[] array, String separator) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
println(array[n - 1]);
}
public void printArray(double[] array) {
this.printArray(array, " ");
}
public void printArray(double[] array, String separator, java.util.function.DoubleUnaryOperator map) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.applyAsDouble(array[i]));
print(separator);
}
println(map.applyAsDouble(array[n - 1]));
}
public void printArray(double[] array, java.util.function.DoubleUnaryOperator map) {
this.printArray(array, " ", map);
}
public <T> void printArray(T[] array, String separator) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.apply(array[i]));
print(separator);
}
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.*;
import java.io.*;
import java.util.function.*;
public class Main {
public static boolean solve(int[] A, int[][] X, int N, int M) {
for (int i = 1; i < N; i++) {
for (int j = 0; j < M; j++) {
X[i][j] += X[i-1][j];
}
}
for (int j = 0; j < M; j++) {
if (X[N-1][j] < A[j]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
ContestScanner sc = new ContestScanner(System.in);
FastWriter out = new FastWriter(System.out);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = sc.nextIntArray(M);
int[][] X = sc.nextIntMatrix(N, M);
out.write((solve(A, X, N, M) ? "Yes\n" : "No\n"));
out.flush();
}
}
class ContestScanner {
private final 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(InputStream in) {
this.in = in;
}
public ContestScanner(File file) throws FileNotFoundException {
this(new BufferedInputStream(new FileInputStream(file)));
}
public ContestScanner() {
this(System.in);
}
private boolean hasNextByte() {
if (ptr < buflen) {
return true;
} else {
ptr = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0) {
return false;
}
}
return true;
}
private int readByte() {
if (hasNextByte()) return buffer[ptr++];
else return -1;
}
private static boolean isPrintableChar(int c) {
return 33 <= c && c <= 126;
}
public boolean hasNext() {
while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
return hasNextByte();
}
public String next() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public String nextLine() {
if (!hasNext()) throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (isPrintableChar(b) || b == ' ') {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString().trim();
}
public String[] nextStringArray(int length) {
String[] array = new String[length];
for (int i = 0; i < length; i++) array[i] = this.next();
return array;
}
public String[] nextStringArray(int length, UnaryOperator<String> map) {
String[] array = new String[length];
for (int i = 0; i < length; i++) array[i] = map.apply(this.next());
return array;
}
public String[][] nextStringMatrix(int height, int width) {
String[][] mat = new String[height][width];
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
mat[h][w] = this.next();
}
}
return mat;
}
public String[][] nextStringMatrix(int height, int width, UnaryOperator<String> map) {
String[][] mat = new String[height][width];
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
mat[h][w] = map.apply(this.next());
}
}
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;
}
public char[][] nextCharMatrix(int height, int width, UnaryOperator<Character> map) {
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] = map.apply(s.charAt(w));
}
}
return mat;
}
public int nextInt() {
long nl = nextLong();
if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
return (int) nl;
}
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, IntUnaryOperator map) {
int[] array = new int[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsInt(this.nextInt());
return array;
}
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, 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 Integer[] nextIntegerArray(int length) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++) array[i] = this.nextInt();
return array;
}
public Integer[] nextIntegerArray(int length, IntUnaryOperator map) {
Integer[] array = new Integer[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsInt(this.nextInt());
return array;
}
public Integer[][] nextIntegerMatrix(int height, int width) {
Integer[][] mat = new Integer[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = this.nextInt();
}
return mat;
}
public Integer[][] nextIntegerMatrix(int height, int width, IntUnaryOperator map) {
Integer[][] mat = new Integer[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 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') {
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 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, LongUnaryOperator map) {
long[] array = new long[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsLong(this.nextLong());
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, 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 Long[] nextLongNonPrimitiveArray(int length) {
Long[] array = new Long[length];
for (int i = 0; i < length; i++) array[i] = this.nextLong();
return array;
}
public Long[] nextLongNonPrimitiveArray(int length, LongUnaryOperator map) {
Long[] array = new Long[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsLong(this.nextLong());
return array;
}
public Long[][] nextLongNonPrimitiveMatrix(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[][] nextLongNonPrimitiveMatrix(int height, int width, 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 double nextDouble() {
return Double.parseDouble(next());
}
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, DoubleUnaryOperator map) {
double[] array = new double[length];
for (int i = 0; i < length; i++) array[i] = map.applyAsDouble(this.nextDouble());
return array;
}
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 double[][] nextDoubleMatrix(int height, int width, DoubleUnaryOperator map) {
double[][] mat = new double[height][width];
for (int h = 0; h < height; h++)
for (int w = 0; w < width; w++) {
mat[h][w] = map.applyAsDouble(this.nextDouble());
}
return mat;
}
}
class FastWriter {
private static final int BUF_SIZE = 1 << 13;
private final byte[] buf = new byte[BUF_SIZE];
private final OutputStream out;
private int ptr = 0;
private FastWriter() {
out = null;
}
public FastWriter(OutputStream os) {
this.out = os;
}
public FastWriter(String path) {
try {
this.out = new FileOutputStream(path);
} catch (FileNotFoundException e) {
throw new RuntimeException("FastWriter");
}
}
public FastWriter write(byte b) {
buf[ptr++] = b;
if (ptr == BUF_SIZE) innerflush();
return this;
}
public FastWriter write(char c) {
return write((byte) c);
}
public FastWriter write(char[] s) {
for (char c : s) {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
}
return this;
}
public FastWriter write(String s) {
s.chars().forEach(c -> {
buf[ptr++] = (byte) c;
if (ptr == BUF_SIZE) innerflush();
});
return this;
}
private static int countDigits(int l) {
if (l >= 1000000000) return 10;
if (l >= 100000000) return 9;
if (l >= 10000000) return 8;
if (l >= 1000000) return 7;
if (l >= 100000) return 6;
if (l >= 10000) return 5;
if (l >= 1000) return 4;
if (l >= 100) return 3;
if (l >= 10) return 2;
return 1;
}
public FastWriter write(int x) {
if (x == Integer.MIN_VALUE) {
return write((long) x);
}
if (ptr + 12 >= BUF_SIZE) innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
private static int countDigits(long l) {
if (l >= 1000000000000000000L) return 19;
if (l >= 100000000000000000L) return 18;
if (l >= 10000000000000000L) return 17;
if (l >= 1000000000000000L) return 16;
if (l >= 100000000000000L) return 15;
if (l >= 10000000000000L) return 14;
if (l >= 1000000000000L) return 13;
if (l >= 100000000000L) return 12;
if (l >= 10000000000L) return 11;
if (l >= 1000000000L) return 10;
if (l >= 100000000L) return 9;
if (l >= 10000000L) return 8;
if (l >= 1000000L) return 7;
if (l >= 100000L) return 6;
if (l >= 10000L) return 5;
if (l >= 1000L) return 4;
if (l >= 100L) return 3;
if (l >= 10L) return 2;
return 1;
}
public FastWriter write(long x) {
if (x == Long.MIN_VALUE) {
return write("" + x);
}
if (ptr + 21 >= BUF_SIZE) innerflush();
if (x < 0) {
write((byte) '-');
x = -x;
}
int d = countDigits(x);
for (int i = ptr + d - 1; i >= ptr; i--) {
buf[i] = (byte) ('0' + x % 10);
x /= 10;
}
ptr += d;
return this;
}
public FastWriter write(double x, int precision) {
if (x < 0) {
write('-');
x = -x;
}
x += Math.pow(10, -precision) / 2;
// if(x < 0){ x = 0; }
write((long) x).write(".");
x -= (long) x;
for (int i = 0; i < precision; i++) {
x *= 10;
write((char) ('0' + (int) x));
x -= (int) x;
}
return this;
}
public FastWriter writeln(char c) {
return write(c).writeln();
}
public FastWriter writeln(int x) {
return write(x).writeln();
}
public FastWriter writeln(long x) {
return write(x).writeln();
}
public FastWriter writeln(double x, int precision) {
return write(x, precision).writeln();
}
public FastWriter write(int... xs) {
boolean first = true;
for (int x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter write(long... xs) {
boolean first = true;
for (long x : xs) {
if (!first) write(' ');
first = false;
write(x);
}
return this;
}
public FastWriter writeln() {
return write((byte) '\n');
}
public FastWriter writeln(int... xs) {
return write(xs).writeln();
}
public FastWriter writeln(long... xs) {
return write(xs).writeln();
}
public FastWriter writeln(char[] line) {
return write(line).writeln();
}
public FastWriter writeln(char[]... map) {
for (char[] line : map) write(line).writeln();
return this;
}
public FastWriter writeln(String s) {
return write(s).writeln();
}
private void innerflush() {
try {
out.write(buf, 0, ptr);
ptr = 0;
} catch (IOException e) {
throw new RuntimeException("innerflush");
}
}
public void flush() {
innerflush();
try {
out.flush();
} catch (IOException e) {
throw new RuntimeException("flush");
}
}
public FastWriter print(byte b) {
return write(b);
}
public FastWriter print(char c) {
return write(c);
}
public FastWriter print(String s) {
return write(s);
}
public FastWriter print(int x) {
return write(x);
}
public FastWriter print(long x) {
return write(x);
}
public FastWriter print(double x, int precision) {
return write(x, precision);
}
public FastWriter print(double x) {
return print(x, 20);
}
public FastWriter println(char c) {
return writeln(c);
}
public FastWriter println(int x) {
return writeln(x);
}
public FastWriter println(long x) {
return writeln(x);
}
public FastWriter println(double x, int precision) {
return writeln(x, precision);
}
public FastWriter println(double x) {
return println(x, 20);
}
public FastWriter println(String s) {
return writeln(s);
}
public FastWriter println() {
return writeln();
}
public FastWriter print(Object x) {
return print(x.toString());
}
public FastWriter println(Object x) {
return println(x.toString());
}
public void printArray(int[] array, String separator) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.applyAsInt(array[i]));
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.applyAsLong(array[i]));
print(separator);
}
println(map.applyAsLong(array[n - 1]));
}
public void printArray(long[] array, java.util.function.LongUnaryOperator map) {
this.printArray(array, " ", map);
}
public void printArray(double[] array, String separator) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
println(array[n - 1]);
}
public void printArray(double[] array) {
this.printArray(array, " ");
}
public void printArray(double[] array, String separator, java.util.function.DoubleUnaryOperator map) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.applyAsDouble(array[i]));
print(separator);
}
println(map.applyAsDouble(array[n - 1]));
}
public void printArray(double[] array, java.util.function.DoubleUnaryOperator map) {
this.printArray(array, " ", map);
}
public <T> void printArray(T[] array, String separator) {
int n = array.length;
if (n == 0) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(array[i]);
print(separator);
}
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) {
println();
return;
}
for (int i = 0; i < n - 1; i++) {
print(map.apply(array[i]));
print(separator);
}
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/abc356_b/Java/54439076 |
condefects-java_data_1978 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[M];
int[][] X = new int[N][M];
int[] Check =new int[M];
//input set
for (int i=0;i<M;i++){
A[i]=sc.nextInt();
}
//inupt set
for (int i=0;i<N;i++){
for (int j=0;j<M;j++){
X[i][j]=sc.nextInt();
}
}
for (int j=0;j<M;j++){
int sum=0;
for (int i=0;i<N;i++){
sum+=X[i][j];
}
Check[j]=sum;
}
for(int i=0;i<M;i++){
if (Check[i]<A[i]){
System.out.println("No");
System.exit(0);
}
}
System.out.println("yes");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[M];
int[][] X = new int[N][M];
int[] Check =new int[M];
//input set
for (int i=0;i<M;i++){
A[i]=sc.nextInt();
}
//inupt set
for (int i=0;i<N;i++){
for (int j=0;j<M;j++){
X[i][j]=sc.nextInt();
}
}
for (int j=0;j<M;j++){
int sum=0;
for (int i=0;i<N;i++){
sum+=X[i][j];
}
Check[j]=sum;
}
for(int i=0;i<M;i++){
if (Check[i]<A[i]){
System.out.println("No");
System.exit(0);
}
}
System.out.println("Yes");
}
} | ConDefects/ConDefects/Code/abc356_b/Java/54655937 |
condefects-java_data_1979 | import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in) ;
int N = sc.nextInt();
int M = sc.nextInt();
int A[] = new int[M];
for(int j=0;j<M;j++)
{
A[j] = sc.nextInt();//摂取基準
}
int X[][] = new int[N][M];
for(int i=0;i<N;i++)
{
for(int j=0;j<M;j++)
{
X[i][j]=sc.nextInt();//N品目における栄養素Мの摂取量
}
}
String hantei = "Yes";
int sum[] = new int[M];
for(int j=0;j<M;j++)
{
for(int i=0;i<N;i++)
{
sum[j]+=X[i][j];
}
if(A[j]>=sum[j])
{
hantei = "No";
break;
}
}
System.out.println(hantei);
}
}
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in) ;
int N = sc.nextInt();
int M = sc.nextInt();
int A[] = new int[M];
for(int j=0;j<M;j++)
{
A[j] = sc.nextInt();//摂取基準
}
int X[][] = new int[N][M];
for(int i=0;i<N;i++)
{
for(int j=0;j<M;j++)
{
X[i][j]=sc.nextInt();//N品目における栄養素Мの摂取量
}
}
String hantei = "Yes";
int sum[] = new int[M];
for(int j=0;j<M;j++)
{
for(int i=0;i<N;i++)
{
sum[j]+=X[i][j];
}
if(A[j]>sum[j])
{
hantei = "No";
break;
}
}
System.out.println(hantei);
}
} | ConDefects/ConDefects/Code/abc356_b/Java/54741441 |
condefects-java_data_1980 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int N = in.nextInt();
int M = in.nextInt();
int[] nums = new int[M];
int[] A = new int[M];
for (int i = 0; i < M; i++) {
A[i] = in.nextInt();
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
nums[j] += in.nextInt();
}
}
for (int i = 0; i < M; i++) {
if (nums[i] < A[i] * N) {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
// System.out.println("Hello LeetCoder");
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int N = in.nextInt();
int M = in.nextInt();
int[] nums = new int[M];
int[] A = new int[M];
for (int i = 0; i < M; i++) {
A[i] = in.nextInt();
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
nums[j] += in.nextInt();
}
}
for (int i = 0; i < M; i++) {
if (nums[i] < A[i]) {
System.out.println("No");
return;
}
}
System.out.println("Yes");
}
// System.out.println("Hello LeetCoder");
}
} | ConDefects/ConDefects/Code/abc356_b/Java/55137891 |
condefects-java_data_1981 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int N = scan.nextInt();
int M = scan.nextInt();
int[] A = new int[M];
for (int i = 0; i < M; i++) {
A[i] = scan.nextInt();
}
int[] X = new int[M];
Arrays.fill(X, 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
X[j] += scan.nextInt();
}
}
boolean result = true;
for (int i = 0; i < M; i++) {
if (X[i] <= A[i]) {
result = false;
}
}
System.out.println(result ? "Yes" : "No");
}
}
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int N = scan.nextInt();
int M = scan.nextInt();
int[] A = new int[M];
for (int i = 0; i < M; i++) {
A[i] = scan.nextInt();
}
int[] X = new int[M];
Arrays.fill(X, 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
X[j] += scan.nextInt();
}
}
boolean result = true;
for (int i = 0; i < M; i++) {
if (X[i] < A[i]) {
result = false;
}
}
System.out.println(result ? "Yes" : "No");
}
} | ConDefects/ConDefects/Code/abc356_b/Java/54515769 |
condefects-java_data_1982 | import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[M];
int[][] X = new int[N][M];
for (int i = 0; i < M; i++) {
A[i] = sc.nextInt();
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
X[i][j] = sc.nextInt();
}
}
sc.close();
int[] total = new int[M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
X[i][j] += total[j];
}
}
boolean result = true;
for (int i = 0; i < M; i++){
if(A[i] > total[i]){
result = false;
break;
}
}
System.out.println(result ? "Yes" : "No");
}
}
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] A = new int[M];
int[][] X = new int[N][M];
for (int i = 0; i < M; i++) {
A[i] = sc.nextInt();
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
X[i][j] = sc.nextInt();
}
}
sc.close();
int[] total = new int[M];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
total[j] += X[i][j];
}
}
boolean result = true;
for (int i = 0; i < M; i++){
if(A[i] > total[i]){
result = false;
break;
}
}
System.out.println(result ? "Yes" : "No");
}
}
| ConDefects/ConDefects/Code/abc356_b/Java/54729310 |
condefects-java_data_1983 | import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.function.BinaryOperator;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
long X = 0;
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
X = sc.nextLong();
long[] A = new long[N];
Elem[] E = new Elem[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextLong();
E[i] = new Elem(A[i], i);
}
Elem INF = new Elem(Long.MAX_VALUE, Integer.MAX_VALUE);
SegmentTree<Elem> tree = new SegmentTree<>(N, (e0, e1) -> min(e0, e1), INF);
PriorityQueue<Elem> queue = new PriorityQueue<>();
for (int i = 0; i < N; i++) {
queue.add(E[i]);
tree.update(i, E[i]);
}
long ans = Long.MAX_VALUE;
while ( queue.size() > 0 ) {
Elem e = queue.poll();
long max = e.min;
//long min = Math.min(tree.query(0, e.id).max, tree.query(e.id + 1, N).max);
long min = tree.query(0, N).max;
ans = Math.min(ans, max - min);
if ( ans <= 0 ) { ans = 0; break; }
Elem n = e.back();
if ( n == null ) break;
queue.add(n);
tree.update(n.id, n);
}
if ( ans < X ) {
ans = 0;
}
System.out.println(ans);
}
Elem min(Elem e0, Elem e1) {
if ( e0.max != e1.max ) {
return e0.max < e1.max ? e0 : e1;
} else if ( e0.id != e1.id ) {
return e0.id < e1.id ? e0 : e1;
} else {
return e0;
}
}
static final long LIMIT = 1L << 40;
class Elem implements Comparable<Elem> {
long A = 0;
int id = 0;
long min = 0;
long max = 0;
int cnt = 0;
Elem(long A, int id) {
this.A = A;
this.id = id;
this.min = A;
this.max = A;
while ( min < LIMIT ) {
min = min * 2L;
max = max * 2L + X;
cnt++;
}
}
Elem() {}
Elem back() {
if ( cnt == 0 ) return null;
Elem n = new Elem();
n.A = this.A;
n.id = this.id;
n.min = this.min / 2L;
n.max = (this.max - X) / 2L;
n.cnt = this.cnt - 1;
return n;
}
@Override
public int compareTo(Main.Elem o) {
if ( min != o.min ) {
return min < o.min ? 1 : -1;
} else if ( max != o.max ) {
return max < o.max ? 1 : -1;
} else {
return id - o.id;
}
}
}
class SegmentTree<T> {
// 最下段の個数
int N = 1;
T[] tree = null;
// 演算に影響しない値(加減なら0、最大なら-INF等)
// f(a, e) = f(e, a) = f(a)となるようなe
T IDENTITY = null;
// 演算
BinaryOperator<T> f = null;
// 要素1〜maxまで
SegmentTree(int max, BinaryOperator<T> f, T identity) {
this.f = f;
this.IDENTITY = identity;
while ( N <= max ) {
N *= 2;
}
tree = (T[]) Array.newInstance(identity.getClass(), 2 * N - 1);
Arrays.fill(tree, identity);
}
// 初期化
void init(T[] arr) {
System.arraycopy(arr, 0, tree, N - 1, arr.length);
// 演算実行
for ( int i = N - 2 ; i >= 0 ; i-- ) {
tree[i] = f.apply(tree[2 * i + 1], tree[2 * i + 2]);
}
}
// i番目(0-indexed)の値
T get(int i) {
return tree[N - 1 + i];
}
// i番目の要素をaに更新
void update(int i, T a) {
int idx = N - 1 + i;
tree[idx] = a;
while ( idx > 0 ) {
idx = (idx - 1) / 2;
tree[idx] = f.apply(tree[2 * idx + 1], tree[2 * idx + 2]);
}
}
// [i, j)の区間(i番目(含む)からj番目(含まない))までの間で演算実行
T query(int i, int j) {
return query(i, j, 0, 0, N);
}
T query(int i, int j, int cur, int l, int r) {
// 入っていない場合
if ( r <= i || j <= l ) {
return IDENTITY;
}
// 完全に入っている場合
if ( i <= l && r <= j ) {
return tree[cur];
}
T val0 = query(i, j, 2 * cur + 1, l, (l + r) / 2);
T val1 = query(i, j, 2 * cur + 2, (l + r) / 2, r);
return f.apply(val0, val1);
}
}
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.lang.reflect.Array;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.function.BinaryOperator;
public class Main {
public static void main(String[] args) {
Main o = new Main();
o.solve();
}
long X = 0;
public void solve() {
FastScanner sc = new FastScanner(System.in);
int N = sc.nextInt();
X = sc.nextLong();
long[] A = new long[N];
Elem[] E = new Elem[N];
for (int i = 0; i < N; i++) {
A[i] = sc.nextLong();
E[i] = new Elem(A[i], i);
}
Elem INF = new Elem(Long.MAX_VALUE, Integer.MAX_VALUE);
SegmentTree<Elem> tree = new SegmentTree<>(N, (e0, e1) -> min(e0, e1), INF);
PriorityQueue<Elem> queue = new PriorityQueue<>();
for (int i = 0; i < N; i++) {
queue.add(E[i]);
tree.update(i, E[i]);
}
long ans = Long.MAX_VALUE;
while ( queue.size() > 0 ) {
Elem e = queue.poll();
long max = e.min;
//long min = Math.min(tree.query(0, e.id).max, tree.query(e.id + 1, N).max);
long min = tree.query(0, N).max;
ans = Math.min(ans, max - min);
if ( ans <= 0 ) { ans = 0; break; }
Elem n = e.back();
if ( n == null ) break;
queue.add(n);
tree.update(n.id, n);
}
if ( ans < X ) {
ans = 0;
}
System.out.println(ans);
}
Elem min(Elem e0, Elem e1) {
if ( e0.max != e1.max ) {
return e0.max < e1.max ? e0 : e1;
} else if ( e0.id != e1.id ) {
return e0.id < e1.id ? e0 : e1;
} else {
return e0;
}
}
static final long LIMIT = 1L << 32;
class Elem implements Comparable<Elem> {
long A = 0;
int id = 0;
long min = 0;
long max = 0;
int cnt = 0;
Elem(long A, int id) {
this.A = A;
this.id = id;
this.min = A;
this.max = A;
while ( min < LIMIT ) {
min = min * 2L;
max = max * 2L + X;
cnt++;
}
}
Elem() {}
Elem back() {
if ( cnt == 0 ) return null;
Elem n = new Elem();
n.A = this.A;
n.id = this.id;
n.min = this.min / 2L;
n.max = (this.max - X) / 2L;
n.cnt = this.cnt - 1;
return n;
}
@Override
public int compareTo(Main.Elem o) {
if ( min != o.min ) {
return min < o.min ? 1 : -1;
} else if ( max != o.max ) {
return max < o.max ? 1 : -1;
} else {
return id - o.id;
}
}
}
class SegmentTree<T> {
// 最下段の個数
int N = 1;
T[] tree = null;
// 演算に影響しない値(加減なら0、最大なら-INF等)
// f(a, e) = f(e, a) = f(a)となるようなe
T IDENTITY = null;
// 演算
BinaryOperator<T> f = null;
// 要素1〜maxまで
SegmentTree(int max, BinaryOperator<T> f, T identity) {
this.f = f;
this.IDENTITY = identity;
while ( N <= max ) {
N *= 2;
}
tree = (T[]) Array.newInstance(identity.getClass(), 2 * N - 1);
Arrays.fill(tree, identity);
}
// 初期化
void init(T[] arr) {
System.arraycopy(arr, 0, tree, N - 1, arr.length);
// 演算実行
for ( int i = N - 2 ; i >= 0 ; i-- ) {
tree[i] = f.apply(tree[2 * i + 1], tree[2 * i + 2]);
}
}
// i番目(0-indexed)の値
T get(int i) {
return tree[N - 1 + i];
}
// i番目の要素をaに更新
void update(int i, T a) {
int idx = N - 1 + i;
tree[idx] = a;
while ( idx > 0 ) {
idx = (idx - 1) / 2;
tree[idx] = f.apply(tree[2 * idx + 1], tree[2 * idx + 2]);
}
}
// [i, j)の区間(i番目(含む)からj番目(含まない))までの間で演算実行
T query(int i, int j) {
return query(i, j, 0, 0, N);
}
T query(int i, int j, int cur, int l, int r) {
// 入っていない場合
if ( r <= i || j <= l ) {
return IDENTITY;
}
// 完全に入っている場合
if ( i <= l && r <= j ) {
return tree[cur];
}
T val0 = query(i, j, 2 * cur + 1, l, (l + r) / 2);
T val1 = query(i, j, 2 * cur + 2, (l + r) / 2, r);
return f.apply(val0, val1);
}
}
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/agc057_b/Java/32272963 |
condefects-java_data_1984 | import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.System.exit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
static class Token implements Comparable<Token> {
final long v;
final int i, j;
public Token(long v, int i, int j) {
this.v = v;
this.i = i;
this.j = j;
}
public int compareTo(Token o) {
return Long.compare(v, o.v);
}
}
static void solve() throws Exception {
int n = scanInt();
long x = scanLong(), a[] = new long[n], min = Long.MAX_VALUE, max = 0;
PriorityQueue<Token> pq = new PriorityQueue<>();
for (int i = 0; i < n; i++) {
a[i] = scanLong();
max = max(max, a[i]);
min = min(min, a[i]);
pq.add(new Token(a[i], i, 0));
}
long ans = max - min;
for (int i = 0; i < 30 * n; i++) {
Token tok = pq.remove();
ans = min(ans, max - tok.v);
Token nt = new Token(2 * tok.v + x, tok.i, tok.j + 1);
max = max(max, a[tok.i] << (tok.j + 1));
pq.add(nt);
}
out.print(max(ans, 0));
}
static int scanInt() throws IOException {
return parseInt(scanString());
}
static long scanLong() throws IOException {
return parseLong(scanString());
}
static String scanString() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
static BufferedReader in;
static PrintWriter out;
static StringTokenizer tok;
public static void main(String[] args) {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
in.close();
out.close();
} catch (Throwable e) {
e.printStackTrace();
exit(1);
}
}
}
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.System.exit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
static class Token implements Comparable<Token> {
final long v;
final int i, j;
public Token(long v, int i, int j) {
this.v = v;
this.i = i;
this.j = j;
}
public int compareTo(Token o) {
return Long.compare(v, o.v);
}
}
static void solve() throws Exception {
int n = scanInt();
long x = scanLong(), a[] = new long[n], min = Long.MAX_VALUE, max = 0;
PriorityQueue<Token> pq = new PriorityQueue<>();
for (int i = 0; i < n; i++) {
a[i] = scanLong();
max = max(max, a[i]);
min = min(min, a[i]);
pq.add(new Token(a[i], i, 0));
}
long ans = max - min;
for (int i = 0; i < 32 * n; i++) {
Token tok = pq.remove();
ans = min(ans, max - tok.v);
Token nt = new Token(2 * tok.v + x, tok.i, tok.j + 1);
max = max(max, a[tok.i] << (tok.j + 1));
pq.add(nt);
}
out.print(max(ans, 0));
}
static int scanInt() throws IOException {
return parseInt(scanString());
}
static long scanLong() throws IOException {
return parseLong(scanString());
}
static String scanString() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
static BufferedReader in;
static PrintWriter out;
static StringTokenizer tok;
public static void main(String[] args) {
try {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
in.close();
out.close();
} catch (Throwable e) {
e.printStackTrace();
exit(1);
}
}
} | ConDefects/ConDefects/Code/agc057_b/Java/31497001 |
condefects-java_data_1985 | 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 = 998244353;
public static void main(String[] args) throws Exception {
solve();
pw.flush();
}
public static void solve(){
double A = sc.nextDouble();
double B = sc.nextDouble();
if(A > B){
double tmp = A;
A = B;
B = tmp;
}
double ans = 0d;
double left = 0d;
double right = 30.1d;
double diff = 1e-8;
while(right - left > diff){
double i = (right+left)/2d;
double rad = Math.toRadians(i);
double len = A/Math.cos(rad);
double height = len*Math.sin(rad);
double rad2 = Math.toRadians(120d-(90d-i));
double height2 = len*Math.cos(rad2);
if(height+height2 > B){
right = i;
}else{
ans = Math.max(ans,len);
left = i;
}
}
pw.println(ans);
}
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 BIT {
int size;
long[] bit;
public BIT(long[] b) {
this.bit = b;
this.size = b.length;
}
public BIT(int sz) {
this.size = sz + 2;
this.bit = new long[size + 2];
}
void add(int pos, long x) {
pos++;
while (pos <= size) {
bit[pos] += x;
pos += (pos & -pos);
}
}
long sum(int pos) {
long s = 0;
pos++;
while (pos > 0) {
s += bit[pos];
pos -= (pos & -pos);
}
return s;
}
}
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 = 998244353;
public static void main(String[] args) throws Exception {
solve();
pw.flush();
}
public static void solve(){
double A = sc.nextDouble();
double B = sc.nextDouble();
if(A > B){
double tmp = A;
A = B;
B = tmp;
}
double ans = 0d;
double left = 0d;
double right = 30d;
double diff = 1e-8;
while(right - left > diff){
double i = (right+left)/2d;
double rad = Math.toRadians(i);
double len = A/Math.cos(rad);
double height = len*Math.sin(rad);
double rad2 = Math.toRadians(120d-(90d-i));
double height2 = len*Math.cos(rad2);
if(height+height2 > B){
right = i;
}else{
ans = Math.max(ans,len);
left = i;
}
}
pw.println(ans);
}
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 BIT {
int size;
long[] bit;
public BIT(long[] b) {
this.bit = b;
this.size = b.length;
}
public BIT(int sz) {
this.size = sz + 2;
this.bit = new long[size + 2];
}
void add(int pos, long x) {
pos++;
while (pos <= size) {
bit[pos] += x;
pos += (pos & -pos);
}
}
long sum(int pos) {
long s = 0;
pos++;
while (pos > 0) {
s += bit[pos];
pos -= (pos & -pos);
}
return s;
}
}
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/abc292_f/Java/43045838 |
condefects-java_data_1986 | import java.util.Scanner;
public class Main{
public static void main(String []args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(String.format("%4d",n));
}
}
import java.util.Scanner;
public class Main{
public static void main(String []args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
System.out.println(String.format("%04d",n));
}
} | ConDefects/ConDefects/Code/abc222_a/Java/36163929 |
condefects-java_data_1987 | import java.util.Scanner;
public class Main {//A - Four Digits
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
String s = "" + x;
String result = "";
if(s.length() == 4) {
result = "" + x;
}else if(s.length() == 3) {
result = "0" + x;
}else if(s.length() == 2) {
result = "00" + x;
}else {
result = "00x" + x;
}
System.out.println(result);
}
}
import java.util.Scanner;
public class Main {//A - Four Digits
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
String s = "" + x;
String result = "";
if(s.length() == 4) {
result = "" + x;
}else if(s.length() == 3) {
result = "0" + x;
}else if(s.length() == 2) {
result = "00" + x;
}else {
result = "000" + x;
}
System.out.println(result);
}
}
| ConDefects/ConDefects/Code/abc222_a/Java/35828090 |
condefects-java_data_1988 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static FastIn in = new FastIn();
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static final double eps = 1e-9;
static int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
//----------------------------------TEMPLATE-----------------------------------------------------------------------------------------------------------------------------------
static class SegTree {
int n;
long[] sum;
int[] flip;
SegTree(int _n) {
n = _n;
sum = new long[n * 4];
flip = new int[n * 4];
}
void pushDown(int o, int l, int r) {
if (flip[o] == 1) {
int mid = (l + r) / 2;
sum[o * 2] = mid - l + 1 - sum[o * 2];
flip[o * 2] ^= 1;
sum[o * 2 + 1] = r - mid - sum[o * 2 + 1];
flip[o * 2 + 1] ^= 1;
flip[o] = 0;
}
}
void pushUp(int o) {
sum[o] = (sum[o * 2] + sum[o * 2 + 1]);
}
void upDate(int o, int l, int r, int L, int R) {
if (l >= L && r <= R) {
sum[o] = r - l + 1 - sum[o];
flip[o] ^= 1;
return;
}
pushDown(o, l, r);
int mid = (l + r) / 2;
if (mid >= L) upDate(o * 2, l, mid, L, R);
if (mid < R) upDate(o * 2 + 1, mid + 1, r, L, R);
pushUp(o);
}
long query(int o, int l, int r, int L, int R) {
if (l >= L && r <= R) {
return sum[o];
}
pushDown(o, l, r);
long ans = 0;
int mid = (l + r) / 2;
if (mid >= L) ans += query(o * 2, l, mid, L, R);
if (mid < R) ans += query(o * 2 + 1, mid + 1, r, L, R);
return ans;
}
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
//TODO 记得必要时开long或BigInteger
//int T = in.nextInt();
long mod = 998244353;
void solve() {
int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
long[] s = new long[m + 1];
for (int i = 0; i <= m; i++) {
s[i] = i;
}
for (int i = 2; i <= n; i++) {
long[] ss = new long[m + 1];
for (int j = 1; j <= m; j++) {
ss[j] = (ss[j - 1] + s[m]) % mod;
ss[j] = ((ss[j] - (s[Math.min(m, j + k - 1)] - s[Math.max(0, j - k)])) % mod + mod) % mod;
}
s = ss;
}
out.println((s[m] % mod + mod) % mod);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static void main(String... args) {
new Main().solve();
out.close();
}
}
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;
}
@Override
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());
}
}
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static FastIn in = new FastIn();
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static final double eps = 1e-9;
static int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
//----------------------------------TEMPLATE-----------------------------------------------------------------------------------------------------------------------------------
static class SegTree {
int n;
long[] sum;
int[] flip;
SegTree(int _n) {
n = _n;
sum = new long[n * 4];
flip = new int[n * 4];
}
void pushDown(int o, int l, int r) {
if (flip[o] == 1) {
int mid = (l + r) / 2;
sum[o * 2] = mid - l + 1 - sum[o * 2];
flip[o * 2] ^= 1;
sum[o * 2 + 1] = r - mid - sum[o * 2 + 1];
flip[o * 2 + 1] ^= 1;
flip[o] = 0;
}
}
void pushUp(int o) {
sum[o] = (sum[o * 2] + sum[o * 2 + 1]);
}
void upDate(int o, int l, int r, int L, int R) {
if (l >= L && r <= R) {
sum[o] = r - l + 1 - sum[o];
flip[o] ^= 1;
return;
}
pushDown(o, l, r);
int mid = (l + r) / 2;
if (mid >= L) upDate(o * 2, l, mid, L, R);
if (mid < R) upDate(o * 2 + 1, mid + 1, r, L, R);
pushUp(o);
}
long query(int o, int l, int r, int L, int R) {
if (l >= L && r <= R) {
return sum[o];
}
pushDown(o, l, r);
long ans = 0;
int mid = (l + r) / 2;
if (mid >= L) ans += query(o * 2, l, mid, L, R);
if (mid < R) ans += query(o * 2 + 1, mid + 1, r, L, R);
return ans;
}
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
//TODO 记得必要时开long或BigInteger
//int T = in.nextInt();
long mod = 998244353;
void solve() {
int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
long[] s = new long[m + 1];
for (int i = 0; i <= m; i++) {
s[i] = i;
}
for (int i = 2; i <= n; i++) {
long[] ss = new long[m + 1];
for (int j = 1; j <= m; j++) {
ss[j] = (ss[j - 1] + s[m]) % mod;
if (k > 0) ss[j] = ((ss[j] - (s[Math.min(m, j + k - 1)] - s[Math.max(0, j - k)])) % mod + mod) % mod;
}
s = ss;
}
out.println((s[m] % mod + mod) % mod);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public static void main(String... args) {
new Main().solve();
out.close();
}
}
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;
}
@Override
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());
}
}
| ConDefects/ConDefects/Code/abc253_e/Java/44614303 |
condefects-java_data_1989 |
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();//数字范围：1 ~ m
int k = sc.nextInt();//相邻数字最小差值
long[][] f = new long[n + 1][m + 1];
//f[i][j]表示长度为 i 的序列，最后一个数选 1 ~ j （最后一个数不超过 j ），所构成的方案数
int mod = 998244353;
for (int i = 1; i <= m; i++) {
f[1][i] = i;
}
for (int i = 2; i <= n; i++) {//枚举每次的数字
for (int j = 1; j <= m; j++) {//枚举第 i 个数
if (k == 0) {
f[i][j] += f[i - 1][m];//当前状态可以由之前的任意状态转移过来
f[i][j] %= mod;
continue;
}
if (j + k <= m) {
f[i][j] += f[i - 1][m] - f[i - 1][j + k - 1];
f[i][j] %= mod;
}
if (j - k > 0) {
f[i][j] += f[i - 1][j - k];
f[i][j] %= mod;
}
}
for (int j = 1; j <= m; j++) {
f[i][j] += f[i][j - 1];
f[i][j] %= mod;
}
}
System.out.println(f[n][m]);
}
}
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();//数字范围：1 ~ m
int k = sc.nextInt();//相邻数字最小差值
long[][] f = new long[n + 1][m + 1];
//f[i][j]表示长度为 i 的序列，最后一个数选 1 ~ j （最后一个数不超过 j ），所构成的方案数
int mod = 998244353;
for (int i = 1; i <= m; i++) {
f[1][i] = i;
}
for (int i = 2; i <= n; i++) {//枚举每次的数字
for (int j = 1; j <= m; j++) {//枚举第 i 个数
if (k == 0) {
f[i][j] += f[i - 1][m];//当前状态可以由之前的任意状态转移过来
f[i][j] %= mod;
continue;
}
if (j + k <= m) {
f[i][j] += f[i - 1][m] - f[i - 1][j + k - 1] + mod;
f[i][j] %= mod;
}
if (j - k > 0) {
f[i][j] += f[i - 1][j - k];
f[i][j] %= mod;
}
}
for (int j = 1; j <= m; j++) {
f[i][j] += f[i][j - 1];
f[i][j] %= mod;
}
}
System.out.println(f[n][m]);
}
}
| ConDefects/ConDefects/Code/abc253_e/Java/44602159 |
condefects-java_data_1990 | import java.io.*;
import java.math.BigDecimal;
import java.util.*;
public class Main {
static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
static int mod = 998244353;
static int res,q,n;
static int t;
static Boolean[][] memo;
static int[] a,s,f;
static List<Integer>[] graph;
static double ans = 0.00;
/**
* 2 5 10 12 15 20
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Fastinanner3 in = new Fastinanner3(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
long[][] dp = new long[n+1][m+1];
for(int i = 1; i<=m;i++){
dp[1][i] = i;
}
for(int i = 2;i <=n;i++){
for(int j = 1; j <= m;j++){
dp[i][j] = (dp[i][j] + dp[i-1][Math.max(j-k,0)])%mod;
dp[i][j] = (dp[i][j] + dp[i-1][m] - dp[i-1][Math.min(j+k,m+1)-1]+mod)%mod;
}
for(int j = 2;j<=m;j++){
dp[i][j] = (dp[i][j]+dp[i][j-1])%mod;
}
}
out.println(dp[n][m]);
in.close();
out.close();
}
private static int length(Integer key) {
int ans = 0;
while(key > 0){
key/=10;
ans++;
}
return ans;
}
private static int calc(final int n, final long[] ns) {
Trie root = new Trie();
final int h = 29;
for (long a : ns){
int d = 1<<h;
Trie tr = root;
while (d > 0){
if ((a & d) == 0){
if (tr.next[0]==null)tr.next[0]=new Trie();
tr = tr.next[0];
}else {
if (tr.next[1]==null)tr.next[1]=new Trie();
tr = tr.next[1];
}
d >>= 1;
}
}
return todo(root, 1<<h);
}
private static int todo(Trie tr, int h){
int res = 0;
if(tr.next[0] != null){
int l = todo(tr.next[0], h>>1);
if (tr.next[1] != null){
int r = todo(tr.next[1], h>>1);
res = Math.min(l, r) + h;
}else {
res = l;
}
}else if (tr.next[1] != null){
res = todo(tr.next[1], h>>1);
}
return res;
}
private static long help(long[] dict, int pos, int left, int right) {
if(pos==-1){
return 0L;
}
int oneStart=right+1;
for(int i=left;i<=right;i++){
if(((dict[i]>>pos)&1)==1){
oneStart=i;
break;
}
}
if(oneStart==left||oneStart==right+1){
return help(dict,pos-1,left,right);
}else {
return (1<<pos)+Math.min(help(dict,pos-1,left,oneStart-1),help(dict,pos-1,oneStart,right));
}
}
private static void connect(int i, int j,int[] p,int[] cnt) {
int fi = father(i,p);
int fj = father(j,p);
if(fi != fj) {
p[fi] = fj;
cnt[fj] += cnt[fi];
}
}
static int father(int i,int[] p) {
if(p[i] == i) return i;
return p[i] = father(p[i],p);
}
private static long rationalMod(long p, long q,int MOD) {
return (p % MOD * pow(q, MOD - 2,MOD) % MOD) % MOD;
}
public static long pow (long x, long exp,int MOD){
if (exp==0) return 1;
long t = pow(x, exp/2,MOD);
t = t*t % MOD;
if (exp%2 == 0) return t;
return t*x % MOD;
}
/**
* 2 1
* 22 2 290+116 406 12 23 2*3
* 222 4
* 2222 8
* @param index
* @param max
* @param curr
* @param n
* @param m
*/
private static void dfs(int index,int max,double curr,int n,int m){
if(index > max){
return;
}
if(n == 0){
return;
}
if(m == 0){
ans+=curr;
return;
}
ans += (n/(double)(n+m))*curr;
if(m >= 3) {
dfs(index + 1, max, (m/(double)(n+m))*curr*((m-1)/(double)(n+m-1))*((m-2)/(double)(n+m-2))
//new BigDecimal(m).divide(new BigDecimal(n + m),
// 8,BigDecimal.ROUND_CEILING).multiply(curr).multiply
// (new BigDecimal(m - 1)
// .divide(new BigDecimal(n+m-1),8,BigDecimal.ROUND_CEILING)).multiply(new BigDecimal(m-2).divide(new BigDecimal(n+m-2),8,
// BigDecimal.ROUND_CEILING))
, n, m - 3);
}
if(m >= 2)
dfs(index+1,max,(m/(double)(n+m))*curr*((m-1)/(double)(n+m-1))*((n-1)/(double)(n+m-2)),n-1,m-2);
}
private static void dfs3(int u, int p, int l) {
t = Math.max(t, a[u] + l);
for(int v : graph[u]) {
if(v == p) continue;
dfs3(v, u, Math.min(2, l + 1));
}
}
private static void dfs2(int u, int p, int w) {
for(int v : graph[u]) {
if(v == p || f[v] == -1) continue;
if(f[v] + 1 == f[u]) {
int w2 = -1;
if(w != -1 || s[u] != -1) w2 = Math.max(w, s[u]) + 1;
if(w2 != -1) res = Math.max(res, f[v] + w2);
dfs2(v, u, w2);
} else {
int w2 = Math.max(w, f[u]) + 1;
res = Math.max(res, f[v] + w2);
dfs2(v, u, w2);
}
}
}
private static void dfs1(int u, int p) {
if(a[u] == t) {
f[u] = 0;
q = u;
}
for(int v : graph[u]) {
if(v == p) continue;
dfs1(v, u);
if(f[v] == -1) continue;
if(f[v] + 1 > f[u]) {
s[u] = f[u];
f[u] = f[v] + 1;
} else {
s[u] = Math.max(s[u], f[v] + 1);
}
}
}
private static boolean helper1(int index, int k, long target) {
if (k > n - index) {
return false;
}
if (index == n) {
return true;
}
if (k == 0) {
return false;
}
if (memo[index][k] != null) {
return memo[index][k];
}
long sum = 0;
for (int i = index; i < n; i++) {
sum += a[i];
if ((sum & target) != target) {
continue;
}
if (helper1(i + 1, k - 1, target)) {
return memo[index][k] = true;
}
}
return memo[index][k] = false;
}
private static boolean helper(int idx, int k, long target) {
if (k > n - idx) return false;
if (idx == n) return true;
if (k == 0) return false;
if (memo[idx][k] != null) return memo[idx][k];
long sum = 0;
for (int i = idx; i < n; i++) {
sum += a[i];
if ((sum & target) != target) continue;
if (helper(i + 1, k - 1, target)) return memo[idx][k] = true;
}
return memo[idx][k] = false;
}
static class Node1 {
Node1[] next = new Node1[2];
}
static Node1 root = new Node1();
private static void add(long x) {
Node1 curr = root;
for (int i = 39; i >= 0; i--) {
int a = (int) ((x >> i) & 1);
if (curr.next[a] == null) {
curr.next[a] = new Node1();
}
curr = curr.next[a];
}
}
private static long get(long x) {
long ans = 0;
Node1 curr = root;
for (int i = 39; i >= 0; i--) {
if (((x >> i) & 1) == 0) {
if (curr.next[1] != null) {
ans = ans * 2 + 1;
curr = curr.next[1];
} else {
ans = ans * 2;
curr = curr.next[0];
}
} else {
if (curr.next[0] != null) {
ans = ans * 2 + 1;
curr = curr.next[0];
} else {
ans = ans * 2;
curr = curr.next[1];
}
}
}
return ans;
}
public static boolean isPrime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
public void solve(int n, int[] c, int[] s) {
}
static class Node {
Node left;
Node right;
int v;
int l;
int r;
public Node(int x, int y) {
l = x;
r = y;
v = Integer.MAX_VALUE;
}
public int find(int x, int y) {
if (x > y) return Integer.MAX_VALUE;
if (l == x && r == y) return v;
int m = (l + r) >> 1;
if (left == null) left = new Node(l, m);
if (right == null) right = new Node(m + 1, r);
if (m >= y) {
return left.find(x, y);
} else if (m < x) {
return right.find(x, y);
} else {
return Math.min(left.find(x, m), right.find(m + 1, y));
}
}
public void update(int x, int y) {
v = Math.min(v, y);
if (l == r) return;
int m = (l + r) >> 1;
if (left == null) left = new Node(l, m);
if (right == null) right = new Node(m + 1, r);
if (m >= x) {
left.update(x, y);
} else {
right.update(x, y);
}
}
}
private static void delete(long a, int m, Trie1 trie) {
if (m == -1) return;
int bit = (a & (1L << m)) == 0 ? 0 : 1;
if (bit == 0) {
trie.left.flow--;
if (trie.left.flow == 0) {
trie.left = null;
} else {
delete(a, m - 1, trie.left);
}
} else {
trie.right.flow--;
if (trie.right.flow == 0) {
trie.right = null;
} else {
delete(a, m - 1, trie.right);
}
}
}
private static long query(long a, int m, Trie1 trie) {
if (trie == null || m == -1) return 0;
int bit = (a & (1L << m)) == 0 ? 0 : 1;
long res = 0;
if (bit == 0 && trie.right != null || bit == 1 && trie.left != null) {
res += 1L << m;
Trie1 child = bit == 0 ? trie.right : trie.left;
return res + query(a, m - 1, child);
}
Trie1 child = bit == 0 ? trie.left : trie.right;
return res + query(a, m - 1, child);
}
private static void add(long a, int m, Trie1 trie) {
if (m == -1) return;
int bit = (a & (1L << m)) == 0 ? 0 : 1;
Trie1 child = bit == 0 ? trie.left : trie.right;
if (bit == 0) {
if (trie.left == null) trie.left = new Trie1();
trie.left.flow++;
add(a, m - 1, trie.left);
} else {
if (trie.right == null) trie.right = new Trie1();
trie.right.flow++;
add(a, m - 1, trie.right);
}
}
static private class Trie1 {
Trie1 left, right;
int flow;
}
static class Trie{
Trie[] next;
public Trie(){
next = new Trie[2];
}
}
}
class Fastinanner3 {
private StringTokenizer tokenizer;
private BufferedReader reader;
public Fastinanner3(InputStream inputStream) {
reader = new BufferedReader(new InputStreamReader(inputStream));
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
return null;
}
if (line == null) {
return null;
}
tokenizer = new StringTokenizer(line);
}
return tokenizer.nextToken();
}
public String nextLine() {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
return null;
}
return line;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public void close() {
try {
reader.close();
} catch (IOException e) {
}
}
}
import java.io.*;
import java.math.BigDecimal;
import java.util.*;
public class Main {
static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
static int mod = 998244353;
static int res,q,n;
static int t;
static Boolean[][] memo;
static int[] a,s,f;
static List<Integer>[] graph;
static double ans = 0.00;
/**
* 2 5 10 12 15 20
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Fastinanner3 in = new Fastinanner3(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
long[][] dp = new long[n+1][m+1];
for(int i = 1; i<=m;i++){
dp[1][i] = i;
}
for(int i = 2;i <=n;i++){
for(int j = 1; j <= m;j++){
dp[i][j] = (dp[i][j] + dp[i-1][Math.max(j-k,0)])%mod;
dp[i][j] = (dp[i][j] + dp[i-1][m] - dp[i-1][k==0?j:Math.min(j+k,m+1)-1]+mod)%mod;
}
for(int j = 2;j<=m;j++){
dp[i][j] = (dp[i][j]+dp[i][j-1])%mod;
}
}
out.println(dp[n][m]);
in.close();
out.close();
}
private static int length(Integer key) {
int ans = 0;
while(key > 0){
key/=10;
ans++;
}
return ans;
}
private static int calc(final int n, final long[] ns) {
Trie root = new Trie();
final int h = 29;
for (long a : ns){
int d = 1<<h;
Trie tr = root;
while (d > 0){
if ((a & d) == 0){
if (tr.next[0]==null)tr.next[0]=new Trie();
tr = tr.next[0];
}else {
if (tr.next[1]==null)tr.next[1]=new Trie();
tr = tr.next[1];
}
d >>= 1;
}
}
return todo(root, 1<<h);
}
private static int todo(Trie tr, int h){
int res = 0;
if(tr.next[0] != null){
int l = todo(tr.next[0], h>>1);
if (tr.next[1] != null){
int r = todo(tr.next[1], h>>1);
res = Math.min(l, r) + h;
}else {
res = l;
}
}else if (tr.next[1] != null){
res = todo(tr.next[1], h>>1);
}
return res;
}
private static long help(long[] dict, int pos, int left, int right) {
if(pos==-1){
return 0L;
}
int oneStart=right+1;
for(int i=left;i<=right;i++){
if(((dict[i]>>pos)&1)==1){
oneStart=i;
break;
}
}
if(oneStart==left||oneStart==right+1){
return help(dict,pos-1,left,right);
}else {
return (1<<pos)+Math.min(help(dict,pos-1,left,oneStart-1),help(dict,pos-1,oneStart,right));
}
}
private static void connect(int i, int j,int[] p,int[] cnt) {
int fi = father(i,p);
int fj = father(j,p);
if(fi != fj) {
p[fi] = fj;
cnt[fj] += cnt[fi];
}
}
static int father(int i,int[] p) {
if(p[i] == i) return i;
return p[i] = father(p[i],p);
}
private static long rationalMod(long p, long q,int MOD) {
return (p % MOD * pow(q, MOD - 2,MOD) % MOD) % MOD;
}
public static long pow (long x, long exp,int MOD){
if (exp==0) return 1;
long t = pow(x, exp/2,MOD);
t = t*t % MOD;
if (exp%2 == 0) return t;
return t*x % MOD;
}
/**
* 2 1
* 22 2 290+116 406 12 23 2*3
* 222 4
* 2222 8
* @param index
* @param max
* @param curr
* @param n
* @param m
*/
private static void dfs(int index,int max,double curr,int n,int m){
if(index > max){
return;
}
if(n == 0){
return;
}
if(m == 0){
ans+=curr;
return;
}
ans += (n/(double)(n+m))*curr;
if(m >= 3) {
dfs(index + 1, max, (m/(double)(n+m))*curr*((m-1)/(double)(n+m-1))*((m-2)/(double)(n+m-2))
//new BigDecimal(m).divide(new BigDecimal(n + m),
// 8,BigDecimal.ROUND_CEILING).multiply(curr).multiply
// (new BigDecimal(m - 1)
// .divide(new BigDecimal(n+m-1),8,BigDecimal.ROUND_CEILING)).multiply(new BigDecimal(m-2).divide(new BigDecimal(n+m-2),8,
// BigDecimal.ROUND_CEILING))
, n, m - 3);
}
if(m >= 2)
dfs(index+1,max,(m/(double)(n+m))*curr*((m-1)/(double)(n+m-1))*((n-1)/(double)(n+m-2)),n-1,m-2);
}
private static void dfs3(int u, int p, int l) {
t = Math.max(t, a[u] + l);
for(int v : graph[u]) {
if(v == p) continue;
dfs3(v, u, Math.min(2, l + 1));
}
}
private static void dfs2(int u, int p, int w) {
for(int v : graph[u]) {
if(v == p || f[v] == -1) continue;
if(f[v] + 1 == f[u]) {
int w2 = -1;
if(w != -1 || s[u] != -1) w2 = Math.max(w, s[u]) + 1;
if(w2 != -1) res = Math.max(res, f[v] + w2);
dfs2(v, u, w2);
} else {
int w2 = Math.max(w, f[u]) + 1;
res = Math.max(res, f[v] + w2);
dfs2(v, u, w2);
}
}
}
private static void dfs1(int u, int p) {
if(a[u] == t) {
f[u] = 0;
q = u;
}
for(int v : graph[u]) {
if(v == p) continue;
dfs1(v, u);
if(f[v] == -1) continue;
if(f[v] + 1 > f[u]) {
s[u] = f[u];
f[u] = f[v] + 1;
} else {
s[u] = Math.max(s[u], f[v] + 1);
}
}
}
private static boolean helper1(int index, int k, long target) {
if (k > n - index) {
return false;
}
if (index == n) {
return true;
}
if (k == 0) {
return false;
}
if (memo[index][k] != null) {
return memo[index][k];
}
long sum = 0;
for (int i = index; i < n; i++) {
sum += a[i];
if ((sum & target) != target) {
continue;
}
if (helper1(i + 1, k - 1, target)) {
return memo[index][k] = true;
}
}
return memo[index][k] = false;
}
private static boolean helper(int idx, int k, long target) {
if (k > n - idx) return false;
if (idx == n) return true;
if (k == 0) return false;
if (memo[idx][k] != null) return memo[idx][k];
long sum = 0;
for (int i = idx; i < n; i++) {
sum += a[i];
if ((sum & target) != target) continue;
if (helper(i + 1, k - 1, target)) return memo[idx][k] = true;
}
return memo[idx][k] = false;
}
static class Node1 {
Node1[] next = new Node1[2];
}
static Node1 root = new Node1();
private static void add(long x) {
Node1 curr = root;
for (int i = 39; i >= 0; i--) {
int a = (int) ((x >> i) & 1);
if (curr.next[a] == null) {
curr.next[a] = new Node1();
}
curr = curr.next[a];
}
}
private static long get(long x) {
long ans = 0;
Node1 curr = root;
for (int i = 39; i >= 0; i--) {
if (((x >> i) & 1) == 0) {
if (curr.next[1] != null) {
ans = ans * 2 + 1;
curr = curr.next[1];
} else {
ans = ans * 2;
curr = curr.next[0];
}
} else {
if (curr.next[0] != null) {
ans = ans * 2 + 1;
curr = curr.next[0];
} else {
ans = ans * 2;
curr = curr.next[1];
}
}
}
return ans;
}
public static boolean isPrime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
public void solve(int n, int[] c, int[] s) {
}
static class Node {
Node left;
Node right;
int v;
int l;
int r;
public Node(int x, int y) {
l = x;
r = y;
v = Integer.MAX_VALUE;
}
public int find(int x, int y) {
if (x > y) return Integer.MAX_VALUE;
if (l == x && r == y) return v;
int m = (l + r) >> 1;
if (left == null) left = new Node(l, m);
if (right == null) right = new Node(m + 1, r);
if (m >= y) {
return left.find(x, y);
} else if (m < x) {
return right.find(x, y);
} else {
return Math.min(left.find(x, m), right.find(m + 1, y));
}
}
public void update(int x, int y) {
v = Math.min(v, y);
if (l == r) return;
int m = (l + r) >> 1;
if (left == null) left = new Node(l, m);
if (right == null) right = new Node(m + 1, r);
if (m >= x) {
left.update(x, y);
} else {
right.update(x, y);
}
}
}
private static void delete(long a, int m, Trie1 trie) {
if (m == -1) return;
int bit = (a & (1L << m)) == 0 ? 0 : 1;
if (bit == 0) {
trie.left.flow--;
if (trie.left.flow == 0) {
trie.left = null;
} else {
delete(a, m - 1, trie.left);
}
} else {
trie.right.flow--;
if (trie.right.flow == 0) {
trie.right = null;
} else {
delete(a, m - 1, trie.right);
}
}
}
private static long query(long a, int m, Trie1 trie) {
if (trie == null || m == -1) return 0;
int bit = (a & (1L << m)) == 0 ? 0 : 1;
long res = 0;
if (bit == 0 && trie.right != null || bit == 1 && trie.left != null) {
res += 1L << m;
Trie1 child = bit == 0 ? trie.right : trie.left;
return res + query(a, m - 1, child);
}
Trie1 child = bit == 0 ? trie.left : trie.right;
return res + query(a, m - 1, child);
}
private static void add(long a, int m, Trie1 trie) {
if (m == -1) return;
int bit = (a & (1L << m)) == 0 ? 0 : 1;
Trie1 child = bit == 0 ? trie.left : trie.right;
if (bit == 0) {
if (trie.left == null) trie.left = new Trie1();
trie.left.flow++;
add(a, m - 1, trie.left);
} else {
if (trie.right == null) trie.right = new Trie1();
trie.right.flow++;
add(a, m - 1, trie.right);
}
}
static private class Trie1 {
Trie1 left, right;
int flow;
}
static class Trie{
Trie[] next;
public Trie(){
next = new Trie[2];
}
}
}
class Fastinanner3 {
private StringTokenizer tokenizer;
private BufferedReader reader;
public Fastinanner3(InputStream inputStream) {
reader = new BufferedReader(new InputStreamReader(inputStream));
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
return null;
}
if (line == null) {
return null;
}
tokenizer = new StringTokenizer(line);
}
return tokenizer.nextToken();
}
public String nextLine() {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
return null;
}
return line;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public void close() {
try {
reader.close();
} catch (IOException e) {
}
}
}
| ConDefects/ConDefects/Code/abc253_e/Java/44603851 |
condefects-java_data_1991 | import java.io.*;
import java.util.StringTokenizer;
/**
* E - Distance Sequence
*/
public class Main {
static class FastReader {
BufferedReader reader;
StringTokenizer tokenizer;
FastReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 1024);
tokenizer = null;
}
// reads in the next string
String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
// reads in the next int
int nextInt() {
return Integer.parseInt(next());
}
// reads in the next long
long nextLong() {
return Long.parseLong(next());
}
// reads in the next double
double nextDouble() {
return Double.parseDouble(next());
}
void close() {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private static FastReader in = new FastReader(System.in);
private static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
private static final int MAXN = 1010, MAXM = 5010, MOD = 998244353;
private static long[][] dp = new long[MAXN][MAXM];
private static int n, m, k;
public static void main(String[] args) {
n = in.nextInt();
m = in.nextInt();
k = in.nextInt();
for (int i = 1; i <= m; i++) dp[1][i] = 1;
for (int i = 2; i <= n; i++) {
long pre = 0;
for (int j = 1; j <= m; j++) {
if (j - k >= 1) pre = (pre + dp[i - 1][j - k]) % MOD;
dp[i][j] = pre;
}
long suf = 0;
for (int j = m; j >= 1; j--) {
int t = j + k + k == 0 ? 1 : 0;
if (t <= m) suf = (suf + dp[i - 1][t]) % MOD;
dp[i][j] = (dp[i][j] + suf) % MOD;
}
}
long ans = 0;
for (int i = 1; i <= m; i++) {
ans = (ans + dp[n][i]) % MOD;
}
out.println(ans);
out.flush();
out.close();
in.close();
}
}
import java.io.*;
import java.util.StringTokenizer;
/**
* E - Distance Sequence
*/
public class Main {
static class FastReader {
BufferedReader reader;
StringTokenizer tokenizer;
FastReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 1024);
tokenizer = null;
}
// reads in the next string
String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
// reads in the next int
int nextInt() {
return Integer.parseInt(next());
}
// reads in the next long
long nextLong() {
return Long.parseLong(next());
}
// reads in the next double
double nextDouble() {
return Double.parseDouble(next());
}
void close() {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private static FastReader in = new FastReader(System.in);
private static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
private static final int MAXN = 1010, MAXM = 5010, MOD = 998244353;
private static long[][] dp = new long[MAXN][MAXM];
private static int n, m, k;
public static void main(String[] args) {
n = in.nextInt();
m = in.nextInt();
k = in.nextInt();
for (int i = 1; i <= m; i++) dp[1][i] = 1;
for (int i = 2; i <= n; i++) {
long pre = 0;
for (int j = 1; j <= m; j++) {
if (j - k >= 1) pre = (pre + dp[i - 1][j - k]) % MOD;
dp[i][j] = pre;
}
long suf = 0;
for (int j = m; j >= 1; j--) {
int t = j + k + (k == 0 ? 1 : 0);
if (t <= m) suf = (suf + dp[i - 1][t]) % MOD;
dp[i][j] = (dp[i][j] + suf) % MOD;
}
}
long ans = 0;
for (int i = 1; i <= m; i++) {
ans = (ans + dp[n][i]) % MOD;
}
out.println(ans);
out.flush();
out.close();
in.close();
}
}
| ConDefects/ConDefects/Code/abc253_e/Java/44834561 |
condefects-java_data_1992 | import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
//import static java.lang.Math.*;
import static java.util.Arrays.*;
//import static java.util.Collections.*;
//import static java.util.Comparator.*;
class Solver{
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";
Util util = new Util();
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int T = in.it();
Object solve(){
while (T-- > 0)
out.println(solve(in.it()));
return null;
}
private long solve(int N){
long ans = 0;
for (long y = 1;y *y <= N;y++) {
long zNum = N /y -y;
ans += 3 *(y -1);
ans += 3 *zNum;
ans += 6 *(y -1) *zNum;
}
ans += Math.sqrt(N);
return ans %mod;
}
}
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 Util{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
static int[][] trans(int[]... T){ return arr(new int[T[0].length][],i -> arrI(T.length,j -> T[j][i])); }
static int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
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];
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 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 (Edge e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (Edge e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
Edge 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 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 instanceof Collection<?>) {
Iterator<?> itr = ((Collection<?>) obj).iterator();
while (itr.hasNext()) {
print(itr.next());
if (itr.hasNext())
ln();
}
} 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++) {
print(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;
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.util.elapsed());
}
}
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.*;
//import static java.lang.Math.*;
import static java.util.Arrays.*;
//import static java.util.Collections.*;
//import static java.util.Comparator.*;
class Solver{
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";
Util util = new Util();
Random rd = ThreadLocalRandom.current();
MyReader in = new MyReader(System.in);
MyWriter out = new MyWriter(System.out);
MyWriter log = new MyWriter(System.err){
@Override
protected void ln(){
super.ln();
flush();
};
};
int T = in.it();
Object solve(){
while (T-- > 0)
out.println(solve(in.it()));
return null;
}
private long solve(int N){
long ans = 0;
for (long y = 1;y *y <= N;y++) {
long zNum = N /y -y;
ans += 3 *(y -1);
ans += 3 *zNum;
ans += 6 *(y -1) *zNum;
}
ans +=(int) Math.sqrt(N);
return ans %mod;
}
}
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 Util{
long st = System.currentTimeMillis();
long elapsed(){ return System.currentTimeMillis() -st; }
static int[][] trans(int[]... T){ return arr(new int[T[0].length][],i -> arrI(T.length,j -> T[j][i])); }
static int[][] addId(int[][] T){
return arr(new int[T.length][],i -> {
int[] t = copyOf(T[i],T[i].length +1);
t[t.length -1] = i;
return t;
});
}
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];
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 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 (Edge e:E) {
c[e.u]++;
if (!b)
c[e.v]++;
}
Edge[][] g = Util.arr(new Edge[N][],i -> new Edge[c[i]]);
for (Edge e:E) {
g[e.u][--c[e.u]] = e;
if (!b) {
Edge 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 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 instanceof Collection<?>) {
Iterator<?> itr = ((Collection<?>) obj).iterator();
while (itr.hasNext()) {
print(itr.next());
if (itr.hasNext())
ln();
}
} 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++) {
print(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;
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.util.elapsed());
}
}
| ConDefects/ConDefects/Code/arc160_b/Java/41429934 |
condefects-java_data_1993 | import java.util.*;
public class Main {
public static int UPPER = 600000;
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int d = sc.nextInt();
int[] a = new int[n + 1];
Seg seg = new Seg(UPPER + 1);
for(int i = 0;i < n;i++) {
a[i] = sc.nextInt();
}int[] nums = new int[UPPER + 1];//最後に選んだ数がiのときの最大値;
for(int i = 0;i < n;i++) {
int min = Math.max(1, a[i] - d);
int max = Math.min(a[i] + d, UPPER);
//System.out.println("now: " + i);
int ret = seg.getTree(min + seg.k, max + seg.k, 0);
//System.out.println(min + " " + max + " " + ret);
//seg.lookTree();
if(nums[i] < ret + 1) {
nums[i] = ret + 1;
seg.changeTree(a[i] + seg.k,nums[i]);
}
}System.out.print(seg.tree[1]);
}public static class Seg{
int n;
int k;
int[] tree;
public Seg(int n) {
this.n = n;
k = 1;
while(k < n) {
k *= 2;
}tree = new int[2 * k + 1];
}public void lookTree() {
int level = 1;
for(int i = 1;i < 2 *k;i++) {
System.out.print(tree[i] + " ");
if(i >= Math.pow(2, level) - 1) {
System.out.print("\n");
level++;
}
}System.out.print("\n");
}
public int getTree(int start,int end,int retNum) {
//System.out.println(start + " " + end + " " +retNum);
//存在しない範囲なだけ
if(start > end) {
return -1;
}
//その場所だけを参照すればいい時。
if(start == end) {
//System.out.println("a" + psum[start]);
return tree[start];
}
//スタートが根の右側、すなわちそれ以上↑に行くと範囲外になる時
if(start % 2 == 1) {
//System.out.println("b" + getTree(start + 1,end,psum[start]));
//
return Math.max(retNum,getTree(start + 1,end,Math.max(retNum, tree[start])));
}//ゴールが根の左側、すなわちそれ以上↑に行くと範囲外になる時
if(end % 2 == 0) {
return Math.max(retNum, getTree(start,end - 1,Math.max(retNum, tree[end])));
}//startをどんどん右に動かしていくイメージ。もちろん逆でも実装は出来るはず
if(start < end) {
retNum = Math.max(retNum, getTree(start/2,end/2,retNum));
//System.out.println("c" + retNum);
}return retNum;
}
public void changeTree(int ind,int val) {
tree[ind] = val;
//ノード1──すべての区間──はそれより上の階層がない
if(ind != 1) {
changeTree(ind/2,Math.max(tree[ind/2 * 2], tree[ind/2 * 2 + 1]));
}
}
}
}
import java.util.*;
public class Main {
public static int UPPER = 600000;
public static void main(String[] args) {
// TODO 自動生成されたメソッド・スタブ
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int d = sc.nextInt();
int[] a = new int[n + 1];
Seg seg = new Seg(UPPER + 1);
for(int i = 0;i < n;i++) {
a[i] = sc.nextInt();
}int[] nums = new int[UPPER + 1];//最後に選んだ数がiのときの最大値;
for(int i = 0;i < n;i++) {
int min = Math.max(1, a[i] - d);
int max = Math.min(a[i] + d, UPPER);
//System.out.println("now: " + i);
int ret = seg.getTree(min + seg.k, max + seg.k, 0);
//System.out.println(min + " " + max + " " + ret);
//seg.lookTree();
if(nums[i] < ret + 1) {
nums[i] = ret + 1;
seg.changeTree(a[i] + seg.k,nums[i]);
}
}System.out.print(seg.tree[1]);
}public static class Seg{
int n;
int k;
int[] tree;
public Seg(int n) {
this.n = n;
k = 1;
while(k < n) {
k *= 2;
}tree = new int[2 * k + 1];
}public void lookTree() {
int level = 1;
for(int i = 1;i < 2 *k;i++) {
System.out.print(tree[i] + " ");
if(i >= Math.pow(2, level) - 1) {
System.out.print("\n");
level++;
}
}System.out.print("\n");
}
public int getTree(int start,int end,int retNum) {
//System.out.println(start + " " + end + " " +retNum);
//存在しない範囲なだけ
if(start > end) {
return -1;
}
//その場所だけを参照すればいい時。
if(start == end) {
//System.out.println("a" + psum[start]);
return Math.max(retNum, tree[start]);
}
//スタートが根の右側、すなわちそれ以上↑に行くと範囲外になる時
if(start % 2 == 1) {
//System.out.println("b" + getTree(start + 1,end,psum[start]));
//
return Math.max(retNum,getTree(start + 1,end,Math.max(retNum, tree[start])));
}//ゴールが根の左側、すなわちそれ以上↑に行くと範囲外になる時
if(end % 2 == 0) {
return Math.max(retNum, getTree(start,end - 1,Math.max(retNum, tree[end])));
}//startをどんどん右に動かしていくイメージ。もちろん逆でも実装は出来るはず
if(start < end) {
retNum = Math.max(retNum, getTree(start/2,end/2,retNum));
//System.out.println("c" + retNum);
}return retNum;
}
public void changeTree(int ind,int val) {
tree[ind] = val;
//ノード1──すべての区間──はそれより上の階層がない
if(ind != 1) {
changeTree(ind/2,Math.max(tree[ind/2 * 2], tree[ind/2 * 2 + 1]));
}
}
}
} | ConDefects/ConDefects/Code/abc339_e/Java/49964271 |
condefects-java_data_1994 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int[] tree = new int[500005];
static int[] a = new int[500005];
static int N = 500000;
public static void main(String[] args) throws IOException {
int n = input.nextInt();
int d = input.nextInt();
int ans = 0;
for (int i = 0; i < n; i++) {
int num = input.nextInt();
int L = Math.max(1, num -d);
int R = Math.min(N, num + d);
int res = query(L, R);
if (res+1 > a[num]){
update(num, res+1);
a[num] = res+1;
ans = Math.max(ans, res+1);
}
}
out.println(ans);
out.flush();
out.close();
br.close();
}
public static int lowbit(int x){
return x & (-x);
}
public static void update(int x, int value){
while(x <= N){
tree[x] = value;
for(int i = 1; i > lowbit(x); i <<= 1){
tree[x] = Math.max(tree[x], tree[x - i]);
}
x+=lowbit(x);
}
}
public static int query(int L, int R){
int ans = 0;
while (L <= R){
ans = Math.max(ans, a[R]);
R--;
while (R - L >= lowbit(R)){
ans = Math.max(ans, tree[R]);
R-=lowbit(R);
}
}
return ans;
}
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static Input input = new Input(System.in);
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static class Input {
public BufferedReader reader;
public StringTokenizer tokenizer;
public Input(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
String str = null;
try {
str = reader.readLine();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return str;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public Double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
}
}
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static int[] tree = new int[500005];
static int[] a = new int[500005];
static int N = 500000;
public static void main(String[] args) throws IOException {
int n = input.nextInt();
int d = input.nextInt();
int ans = 0;
for (int i = 0; i < n; i++) {
int num = input.nextInt();
int L = Math.max(1, num -d);
int R = Math.min(N, num + d);
int res = query(L, R);
if (res+1 > a[num]){
update(num, res+1);
a[num] = res+1;
ans = Math.max(ans, res+1);
}
}
out.println(ans);
out.flush();
out.close();
br.close();
}
public static int lowbit(int x){
return x & (-x);
}
public static void update(int x, int value){
while(x <= N){
tree[x] = Math.max(value, tree[x]);
for(int i = 1; i > lowbit(x); i <<= 1){
tree[x] = Math.max(tree[x], tree[x - i]);
}
x+=lowbit(x);
}
}
public static int query(int L, int R){
int ans = 0;
while (L <= R){
ans = Math.max(ans, a[R]);
R--;
while (R - L >= lowbit(R)){
ans = Math.max(ans, tree[R]);
R-=lowbit(R);
}
}
return ans;
}
static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
static Input input = new Input(System.in);
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static class Input {
public BufferedReader reader;
public StringTokenizer tokenizer;
public Input(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public String nextLine() {
String str = null;
try {
str = reader.readLine();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
return str;
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public Double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
}
}
| ConDefects/ConDefects/Code/abc339_e/Java/49991873 |
condefects-java_data_1995 | import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010l;//10^18
static boolean ok = false;
static long ans = 0;
static final int[] dx = {1, -1, 0, 0};
static final int[] dy = {0, 0, 1, -1};
static final long[] MODS = {998244353, 1000000007, 1000000009, 1000000021};
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int d = sc.nextInt();
int[] a = sc.nextIntArray(n);
SegTree<Integer> seg = new SegTree<Integer>(5 * 100000 + 1, (x, y) -> Math.max(x, y), 0);
int[] dp = new int[n];
for (int i = 0; i < n; i++) {
int l = Math.max(a[i] - d, 0);
int r = Math.min(a[i] + d + 1, 5 * 100000 + 1);
int val = seg.prod(l, r);
dp[i] = val + 1;
seg.set(a[i], Math.max(dp[i], seg.get(a[i])));
}
System.out.println(dp[n - 1]);
}
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)
);
}
}
}
}
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
public class Main {
static final long MOD1=1000000007;
static long MOD=998244353;
static final int NTT_MOD1 = 998244353;
static final int NTT_MOD2 = 1053818881;
static final int NTT_MOD3 = 1004535809;
static long MAX = 1000000000000000010l;//10^18
static boolean ok = false;
static long ans = 0;
static final int[] dx = {1, -1, 0, 0};
static final int[] dy = {0, 0, 1, -1};
static final long[] MODS = {998244353, 1000000007, 1000000009, 1000000021};
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public double[] nextDoubleArray(int n) {
double[] a = new double[n];
for (int i = 0; i < n; i++)
a[i] = nextDouble();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
public static void main(String[] args){
PrintWriter out = new PrintWriter(System.out);
InputReader sc=new InputReader(System.in);
int n = sc.nextInt();
int d = sc.nextInt();
int[] a = sc.nextIntArray(n);
SegTree<Integer> seg = new SegTree<Integer>(5 * 100000 + 1, (x, y) -> Math.max(x, y), 0);
int[] dp = new int[n];
for (int i = 0; i < n; i++) {
int l = Math.max(a[i] - d, 0);
int r = Math.min(a[i] + d + 1, 5 * 100000 + 1);
int val = seg.prod(l, r);
dp[i] = val + 1;
seg.set(a[i], Math.max(dp[i], seg.get(a[i])));
}
System.out.println(seg.allProd());
}
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)
);
}
}
}
}
| ConDefects/ConDefects/Code/abc339_e/Java/53056931 |
condefects-java_data_1996 | import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;
// If AtCoder, change className to Main
public class Main {
static MyScanner sc = new MyScanner();
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) {
int t = 1;
while (t-- > 0) {
solve();
}
out.close();
}
private static void solve() {
MaxSegmentTree st = new MaxSegmentTree(500001);
for (int i = 0; i < 500001; i++) st.set(i, 0);
int n = sc.nextInt(), d = sc.nextInt();
int max = 0;
for (int i = 0; i < n; i++) {
int a = sc.nextInt();
int val = st.rangeMax(Math.max(0, a - d), Math.min(500000, a + d)) + 1;
st.set(a, val);
max = Math.max(val, max);
}
out.println(max);
}
// public static void solve() {
// MaxSegmentTree st = new MaxSegmentTree(500001);
// for (int i = 0; i < 500001; i++) st.set(i, 0);
// int n = sc.nextInt(), d = sc.nextInt();
// int max = 0;
// for (int i = 0; i < n; i++) {
// int a = sc.nextInt();
// int val = st.max(Math.max(0, a - d), Math.min(500000, a + d)) + 1;
// st.set(a, val);
// max = Math.max(val, max);
// }
// out.println(max);
// }
static class MaxSegmentTree {
private final int[] segtree;
private final int len;
public MaxSegmentTree(int len) {
this.len = len;
segtree = new int[len * 2];
Arrays.fill(segtree, Integer.MAX_VALUE);
}
/** Sets the value at ind to val. */
public void set(int ind, int val) {
ind += len;
segtree[ind] = val;
for (; ind > 1; ind /= 2) {
segtree[ind / 2] = Math.max(segtree[ind], segtree[ind ^ 1]);
}
}
/** @return the minimum of all elements in [start, end). */
public int rangeMax(int start, int end) {
int max = Integer.MIN_VALUE;
for (start += len, end += len; start < end; start /= 2, end /= 2) {
if (start % 2 == 1) { max = Math.max(max, segtree[start++]); }
if (end % 2 == 1) { max = Math.max(max, segtree[--end]); }
}
return max;
}
public int max(int l, int r) {
return rangeMax(l, r + 1);
}
}
//-----------PrintWriter for faster output---------------------------------
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public 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.Arrays;
import java.util.StringTokenizer;
// If AtCoder, change className to Main
public class Main {
static MyScanner sc = new MyScanner();
public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public static void main(String[] args) {
int t = 1;
while (t-- > 0) {
solve();
}
out.close();
}
private static void solve() {
MaxSegmentTree st = new MaxSegmentTree(500001);
for (int i = 0; i < 500001; i++) st.set(i, 0);
int n = sc.nextInt(), d = sc.nextInt();
int max = 0;
for (int i = 0; i < n; i++) {
int a = sc.nextInt();
int val = st.rangeMax(Math.max(0, a - d), Math.min(500000, a + d) + 1) + 1;
st.set(a, val);
max = Math.max(val, max);
}
out.println(max);
}
// public static void solve() {
// MaxSegmentTree st = new MaxSegmentTree(500001);
// for (int i = 0; i < 500001; i++) st.set(i, 0);
// int n = sc.nextInt(), d = sc.nextInt();
// int max = 0;
// for (int i = 0; i < n; i++) {
// int a = sc.nextInt();
// int val = st.max(Math.max(0, a - d), Math.min(500000, a + d)) + 1;
// st.set(a, val);
// max = Math.max(val, max);
// }
// out.println(max);
// }
static class MaxSegmentTree {
private final int[] segtree;
private final int len;
public MaxSegmentTree(int len) {
this.len = len;
segtree = new int[len * 2];
Arrays.fill(segtree, Integer.MAX_VALUE);
}
/** Sets the value at ind to val. */
public void set(int ind, int val) {
ind += len;
segtree[ind] = val;
for (; ind > 1; ind /= 2) {
segtree[ind / 2] = Math.max(segtree[ind], segtree[ind ^ 1]);
}
}
/** @return the minimum of all elements in [start, end). */
public int rangeMax(int start, int end) {
int max = Integer.MIN_VALUE;
for (start += len, end += len; start < end; start /= 2, end /= 2) {
if (start % 2 == 1) { max = Math.max(max, segtree[start++]); }
if (end % 2 == 1) { max = Math.max(max, segtree[--end]); }
}
return max;
}
public int max(int l, int r) {
return rangeMax(l, r + 1);
}
}
//-----------PrintWriter for faster output---------------------------------
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public 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/abc339_e/Java/51714405 |
condefects-java_data_1997 | import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int cntT = 0;
int cntA = 0;
for(int i = 0; i < n; i++){
char c = s.charAt(i);
if(c == 'A') cntA++;
else cntT++;
}
boolean ans = false;
if(cntA < cntT) ans = true;
else if(cntA > cntT) ans = false;
else ans = (s.charAt(n-1) == 'T');
System.out.println(ans ? 'T' : 'A');
}
}
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int cntT = 0;
int cntA = 0;
for(int i = 0; i < n; i++){
char c = s.charAt(i);
if(c == 'A') cntA++;
else cntT++;
}
boolean ans = false;
if(cntA < cntT) ans = true;
else if(cntA > cntT) ans = false;
else ans = (s.charAt(n-1) != 'T');
System.out.println(ans ? 'T' : 'A');
}
} | ConDefects/ConDefects/Code/abc301_a/Java/44876558 |
condefects-java_data_1998 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int t = 0;
int a = 0;
int i;
for(i = 0; i < n; i++) {
if(s.charAt(i) == 'T') {
t++;
} else {
a++;
}
}
if(t > a) {
System.out.println("T");
} else if(a > t) {
System.out.println("A");
} else if(s.charAt(i-1) == 'A') {
System.out.println("T");
}
sc.close();
}
}
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next();
int t = 0;
int a = 0;
int i;
for(i = 0; i < n; i++) {
if(s.charAt(i) == 'T') {
t++;
} else {
a++;
}
}
if(t > a) {
System.out.println("T");
} else if(a > t) {
System.out.println("A");
} else if(s.charAt(i-1) == 'A') {
System.out.println("T");
} else {
System.out.println("A");
}
sc.close();
}
} | ConDefects/ConDefects/Code/abc301_a/Java/41679683 |
condefects-java_data_1999 | import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
public class Main {
//iseven
public static boolean iseven(int n){if(n%2==0){return true;}else{return false;}}
public static boolean iseven(long n){if(n%2==0){return true;}else{return false;}}
//pair
class Pair<T extends Comparable<T>> implements Comparable<Pair<T>>{
public T a, b, c;
public Pair(T a, T b, T c){this.a = a; this.b = b; this.c = c;}
public int compareTo(Pair<T> tar){
int r = a.compareTo(tar.a);
if(r != 0) return r;
return b.compareTo(tar.b);
}
}
//input
public static Scanner sc = new Scanner(System.in);
public static int ri(){return sc.nextInt();}
public static double rd(){return sc.nextDouble();}
public static long rl(){return sc.nextLong();}
public static String rs(){return sc.next();}
public static String rsl(){return sc.nextLine();}
public static char[] rac(){return sc.next().toCharArray();}
public static int[] ri(int n){int[] a = new int[n];for(int i=0;i<n;i++){ a[i]=ri();}return a;}
public static double[] rd(int n){double[] a = new double[n];for(int i=0;i<n;i++){ a[i]=rd();}return a;}
public static long[] rl(int n){long[] a = new long[n];for(int i=0;i<n;i++){ a[i]=rl();}return a;}
public static String[] rsStrings(int n){String[] a = new String[n];for(int i=0;i<n;i++){ a[i]=rs();}return a;}
//output
public static void puts(){System.out.println();}
public static void puts(String str){System.out.println(str);}
public static void puts(int n){System.out.println(n);}
public static void puts(long n){System.out.println(n);}
public static void puts(double n){System.out.println(n);}
public static void puts(boolean n){System.out.println(n);}
public static void print(String str){System.out.print(str);}
public static void print(int n){System.out.print(n);}
public static void print(long n){System.out.print(n);}
public static void print(double n){System.out.print(n);}
public static void print(boolean n){System.out.print(n);}
public static long nx = 0;
public static long ny = 0;
public static Map<Long,Long> kabey = new HashMap<>();
//階乗
public static BigInteger BFact(int n) {
BigInteger z =BigInteger.valueOf(n);
for(int i=1;i<=n;i++) {
z=z.multiply(BigInteger.valueOf(i));
}
return z;
}
//最大公約数--ユークリッド互除法
public static long gcd(long a,long b){
while(a!=b){
if(a>b)a=a-b;
else b=b-a;
}
return a;
}
//lcm
public static long lcm(long a, long b, long c){
return (a/c)*(b/c)*c;//
}
//exitメソッド
public static void exit(){System.exit(0);}
public static String[] Upper = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
public static long max = 0;
public static List<Set<Integer>> list = new ArrayList<>();
public static int cnt=0;
public static Map<Integer,Integer> map = new HashMap<>();
public static long sum;
public static void main(String[] args) throws Exception {
int n = ri();
String [] str = rs().split("");
boolean judge = true;//true = T false = A
int a = 0;
int b = 0;
for(int i=0;i<n;i++){
if(str[i].equals("T")){
a++;
}else{
b++;
}
if(a > b){
judge = true;
}else {
judge = false;
}
}
if(judge){
puts("T");
}else{
puts("A");
}
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
public class Main {
//iseven
public static boolean iseven(int n){if(n%2==0){return true;}else{return false;}}
public static boolean iseven(long n){if(n%2==0){return true;}else{return false;}}
//pair
class Pair<T extends Comparable<T>> implements Comparable<Pair<T>>{
public T a, b, c;
public Pair(T a, T b, T c){this.a = a; this.b = b; this.c = c;}
public int compareTo(Pair<T> tar){
int r = a.compareTo(tar.a);
if(r != 0) return r;
return b.compareTo(tar.b);
}
}
//input
public static Scanner sc = new Scanner(System.in);
public static int ri(){return sc.nextInt();}
public static double rd(){return sc.nextDouble();}
public static long rl(){return sc.nextLong();}
public static String rs(){return sc.next();}
public static String rsl(){return sc.nextLine();}
public static char[] rac(){return sc.next().toCharArray();}
public static int[] ri(int n){int[] a = new int[n];for(int i=0;i<n;i++){ a[i]=ri();}return a;}
public static double[] rd(int n){double[] a = new double[n];for(int i=0;i<n;i++){ a[i]=rd();}return a;}
public static long[] rl(int n){long[] a = new long[n];for(int i=0;i<n;i++){ a[i]=rl();}return a;}
public static String[] rsStrings(int n){String[] a = new String[n];for(int i=0;i<n;i++){ a[i]=rs();}return a;}
//output
public static void puts(){System.out.println();}
public static void puts(String str){System.out.println(str);}
public static void puts(int n){System.out.println(n);}
public static void puts(long n){System.out.println(n);}
public static void puts(double n){System.out.println(n);}
public static void puts(boolean n){System.out.println(n);}
public static void print(String str){System.out.print(str);}
public static void print(int n){System.out.print(n);}
public static void print(long n){System.out.print(n);}
public static void print(double n){System.out.print(n);}
public static void print(boolean n){System.out.print(n);}
public static long nx = 0;
public static long ny = 0;
public static Map<Long,Long> kabey = new HashMap<>();
//階乗
public static BigInteger BFact(int n) {
BigInteger z =BigInteger.valueOf(n);
for(int i=1;i<=n;i++) {
z=z.multiply(BigInteger.valueOf(i));
}
return z;
}
//最大公約数--ユークリッド互除法
public static long gcd(long a,long b){
while(a!=b){
if(a>b)a=a-b;
else b=b-a;
}
return a;
}
//lcm
public static long lcm(long a, long b, long c){
return (a/c)*(b/c)*c;//
}
//exitメソッド
public static void exit(){System.exit(0);}
public static String[] Upper = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
public static long max = 0;
public static List<Set<Integer>> list = new ArrayList<>();
public static int cnt=0;
public static Map<Integer,Integer> map = new HashMap<>();
public static long sum;
public static void main(String[] args) throws Exception {
int n = ri();
String [] str = rs().split("");
boolean judge = true;//true = T false = A
int a = 0;
int b = 0;
for(int i=0;i<n;i++){
if(str[i].equals("T")){
a++;
}else{
b++;
}
if(a > b){
judge = true;
}else if(a < b){
judge = false;
}
}
if(judge){
puts("T");
}else{
puts("A");
}
}
} | ConDefects/ConDefects/Code/abc301_a/Java/45349129 |
condefects-java_data_2000 |
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt();
String[] s = sc.next().split("");
int taka = 0;
int ao = 0;
int winner = 0;
if (s.length % 1 == 1) {
winner = s.length / 2 + 1;
} else {
winner = s.length / 2;
}
for (String str : s) {
if (str.equals("T")) {
taka++;
} else {
ao++;
}
if (taka == winner) {
pw.println("T");
break;
} else if (ao == winner) {
pw.println("A");
break;
}
}
pw.flush();
}
}
import java.io.PrintWriter;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt();
String[] s = sc.next().split("");
int taka = 0;
int ao = 0;
int winner = 0;
if (s.length % 2 == 1) {
winner = s.length / 2 + 1;
} else {
winner = s.length / 2;
}
for (String str : s) {
if (str.equals("T")) {
taka++;
} else {
ao++;
}
if (taka == winner) {
pw.println("T");
break;
} else if (ao == winner) {
pw.println("A");
break;
}
}
pw.flush();
}
}
| ConDefects/ConDefects/Code/abc301_a/Java/41671399 |