アルゴリズムコンテストのJava基盤のテンプレート（更新）

オブジェクトの読み取りを定義します。1.

static Scanner sc=new Scanner(System.in);

共通の操作を2.String

• 公共のcharのcharAt（int index）指定さ：の文字列を返しますインデックスの文字を、
• 公共int型の長さは（）：文字列の長さを返します。
• 公共のintのindexOf（String str）文字：戻り値文字列strが最初の位置に発生します。
• 公共のintのindexOf（文字列str、INTたfromIndex）： 戻り値から文字列fromIndexのの位置strが最初に表示されるようになりました。
• サブストリングパブリック文字列（INTたbeginIndex）：戻り値から文字列beginIndexのサブの終わりに始まります。
• 公共の文字列の部分文字列は、（int型beginIndexパラメータ、INT endIndexの）： から文字列を返したbeginIndexがに開始endsIndexのエンド部分文字列
• INTのcompareTo公開（STR文字）：文字列の大きさの比較は、戻りの負未満である、それは等しい戻りより正の数より大きいを返す0
• パブリックブールのequals（String str）文字：かどうか、同じ文字列を決定します
• char型のパブリック[] toCharArray（） ：新しい文字配列にこの文字列
• パブリック文字列[]スプリット（文字列の正規表現 ）： 指定された文字列の区切り文字の分離は、それは文字列の配列が後に分離返します

 スプリット（）メソッドは、正規表現を分割するために与えられた文字列にマッチします。

注:. 、| そして* などのエスケープ文字として、追加する必要があります。\\ 。

注：|ハイフンとして複数の区切り文字を使用することができます。 

String[] s=str.split(" +");
String[] s=str.split("\\s+");
以一个或多个空格分割

• ストリングpublic（CharSequence引数のターゲット、のCharSequenceの交換）に置き換え  ：置換文字列置換を使用して、ターゲット文字列マッチングを。
• 文字列でReplaceAll（文字列の正規表現、文字列置換 ）： すべての代替選択肢のこの文字列与えられ、与えられた正規表現の部分文字列にマッチします

String ss=str.replaceAll(" +",",");
String ss=str.replaceAll("\\s+",",");
二者都能把一个或多个空格换成逗号，没有学过正则表达式，具体区别并不懂

 

• 文字列タイプでは、変更する必要がある場合に使用することができ、変更することができないのStringBuilderを

 

 import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    public static void main(String[] args) {
        String s="abc def ghi";
        String[] a=s.split(" ");//a[0]=abc a[1]=def a[2]=ghi
        for(int i=0;i<a.length;i++) {
            System.out.print("a["+i+"]="+a[i]+" ");
        }
        System.out.println();
        String str="abcabc";
        char[] ch=str.toCharArray();
        //ch[0]=a ch[1]=b ch[2]=c ch[3]=a ch[4]=b ch[5]=c
        for(int i=0;i<ch.length;i++) {
            System.out.print("ch["+i+"]="+ch[i]+" ");
        }
        System.out.println();
        System.out.println(str.indexOf("b"));//1
        System.out.println(str.indexOf("b",3));//4
        System.out.println(str.substring(3));//abc
        System.out.println(str.substring(3,5));//ab
        System.out.println(str.compareTo("abc"));//3
        System.out.println(str.compareTo("abcabcabc"));//-3
        System.out.println(str.compareTo("abcabc"));//0
        System.out.println(str.equals("abcabc"));//true
        System.out.println(str.equals("abc"));//false
        System.out.println(str.replace("abc","ac"));//acac
        System.out.println(str.toLowerCase());//abcabc
        System.out.println(str.toUpperCase());//ABCABC
    }
}

3.StringBuilder

• StringBuilderオブジェクトの作成：StringBuilderのSTRB =新しいStringBuilderの（）;
• 追記（文字列STR）/アペンド（CHAR C） ：接続文字列
• toString（） ：同じ構築物またはバッファの内容から文字列を返します
• setCharAt（INT I、チャーC） ：コードセットCのi番目のユニット（理解されるように置換）
• INSERT（int型オフセット、文字列STR）/ INSERT（intはオフセット、チャーC） ：前の指定された位置に文字（文字列）を挿入
• 削除（int型のstartIndex、int型endIndexの）終了位置（無料）への削除開始位置（包括的）の間の文字列：

import java.util.*;
public class Main {
	static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
		//输入abc
		StringBuilder strB=new StringBuilder(sc.next());
		System.out.println(strB.toString());//abc
		//输入def
		strB.append(sc.next());
		System.out.println(strB.toString());//abcdef
		//将第2个代码单元设置为m
		strB.setCharAt(2,'m');
		System.out.println(strB.toString());//abmdef
		//在第4个代码单元之前插入pq
		strB.insert(4,"pq");
		System.out.println(strB.toString());//abmdpqef
		//删除下标[2,5)之间的字符串
		strB.delete(2,5);
		System.out.println(strB.toString());//abqef
	}
}

4。Javaはクラス構造を使用して実装するソート

例：もし候補が複数のテスト番号の昇順に、それらの出力の同じ画分より低いテストの点数の高いからのスコアによる出力及びライン上の候補数、。

• コンパレータ（C ++ CMP言葉遣い同様の機能）

import java.util.*;
public class Main {
	static Scanner sc=new Scanner(System.in);
	static class student{
		String ID;
		int score;
		public student(String ID,int score) {
			this.ID=ID;
			this.score=score;
		}
	}
	static student[] stu=new student[1005];
	static Comparator cmp=new Comparator<student>() {
		public int compare(student a,student b) {
			if(a.score!=b.score) return b.score-a.score;//分数从高到低
			else return a.ID.compareTo(b.ID);//字典序从小到大
		}
	};
	static int mp[]=new int[15];
	public static void main(String[] args) {
		int N,M,G;
		while(sc.hasNext()) {
			N=sc.nextInt();
			if(N==0) break;
			M=sc.nextInt();
			G=sc.nextInt();
			for(int i=1;i<=M;i++) mp[i]=sc.nextInt();
			int cnt=0;
			for(int i=1;i<=N;i++) {
				String s=sc.next();
				int m=sc.nextInt();
				int sum=0;
				for(int j=1;j<=m;j++) {
					sum+=mp[sc.nextInt()];
				}
				if(sum>=G)
				stu[cnt++]=new student(s,sum);
			}
			Arrays.sort(stu,0,cnt,cmp);
			System.out.println(cnt);
			for(int i=0;i<cnt;i++) {
				System.out.println(stu[i].ID+" "+stu[i].score);
			}
		}
	}
}

• 同等の（C ++過負荷と同様未満）

import java.util.*;
public class Main {
	static Scanner sc=new Scanner(System.in);
	static class student implements Comparable<student>{
		String ID;
		int score;
		public student(String ID,int score) {
			this.ID=ID;
			this.score=score;
		}
		public int compareTo(student other) {
			if(this.score!=other.score) return other.score-this.score;
			else return (this.ID).compareTo(other.ID);
		}
	}
	static student[] stu=new student[1005];
	static int mp[]=new int[15];
	public static void main(String[] args) {
		int N,M,G;
		while(sc.hasNext()) {
			N=sc.nextInt();
			if(N==0) break;
			M=sc.nextInt();
			G=sc.nextInt();
			for(int i=1;i<=M;i++) mp[i]=sc.nextInt();
			int cnt=0;
			for(int i=1;i<=N;i++) {
				String s=sc.next();
				int m=sc.nextInt();
				int sum=0;
				for(int j=1;j<=m;j++) {
					sum+=mp[sc.nextInt()];
				}
				if(sum>=G)
				stu[cnt++]=new student(s,sum);
			}
			Arrays.sort(stu,0,cnt);
			System.out.println(cnt);
			for(int i=0;i<cnt;i++) {
				System.out.println(stu[i].ID+" "+stu[i].score);
			}
		}
	}
}

5.List

ArrayListを：可変サイズの配列

• 根底にあるアレイが実装されているのArrayListは、ArrayListには、配列のサイズを変更することができると考えることができます。より多くの要素がArrayListに追加されると、その大きさが動的に増加されます。
• より高速なクエリや、変更、追加、および低速の削除

LinkedListの：リスト

• LinkedListの底が二重にリンクされたリストによって達成されます。
• 追加と削除速く、遅くクエリと変更

ベクター：お勧めできませんが（ベクタが使用して同期、必然的に効率に影響を与えます）

• ベクターおよびArrayListのは、アレイを介して達成されるが、ベクターは、スレッドセーフです。そして、同期（同期）プロセスを通じて、セキュリティスレッドを確保するために多くの方法がありArrayListを、と比較。
• 両者の違いは、同じ拡大戦略ではありませんもあります。リストが最初に作成されたときの容量は、それが拡張になると思うのに十分な時間がないときは、リスト、一覧に増加要素と、初期サイズがあるでしょう。自動ベクトル、オリジナルの50％のArrayListの成長の下で、デフォルトの配列の元の長さの増加を倍増します。

リファレンスから：https://blog.csdn.net/qq_38218238/article/details/82904926

一般的な方法：

• ブール追加（オブジェクトE）：要素の端部に挿入
• ボイド追加（int型のインデックス、オブジェクト要素 ）： 指定された場所に挿入エレメント、前シフトのすべての要素の後に
• オブジェクトセット（INTインデックス、オブジェクト要素 ）： 位置における変更要素
• オブジェクトのget（int index）指定さ：場所にある要素を返します。
• オブジェクトのremove（int index）指定さ：要素の指定された位置、前方のすべての動き1の背後にある要素を削除します

注意：

• 少し速くためのループでのArrayListを横断
• トラバースはるかに高速でのLinkedListのforEach

import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    static List<Integer> arraylist=new ArrayList<Integer>();
    static List<Integer> linkedlist=new LinkedList<Integer>();
    static void query() {//查询
        for(int i=0;i<arraylist.size();i++) {
            System.out.print(arraylist.get(i)+" ");
        }
        System.out.println();
        for(int i=0;i<linkedlist.size();i++) {
            System.out.print(linkedlist.get(i)+" ");
        }
        System.out.println();
//        forEach循环
        for(Integer x:arraylist) {
            System.out.print(x+" ");
        }
        System.out.println();
        for(Integer x:linkedlist) {
            System.out.print(x+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        //增 --在末尾增
        for(int i=0;i<=10;i++) {
            arraylist.add(i);
            linkedlist.add(i);
        }
        query();//0 1 2 3 4 5 6 7 8 9 10
        //删 --把第0个元素删掉
        arraylist.remove(0);
        linkedlist.remove(0);
        query();//1 2 3 4 5 6 7 8 9 10
        //增 --在下标1处增一个元素0
        arraylist.add(1,0);
        linkedlist.add(1,0);
        query();//1 0 2 3 4 5 6 7 8 9 10
        //改 --把下标为1的那个元素改为2
        arraylist.set(1,2);
        linkedlist.set(1,2);
        query();//1 2 2 3 4 5 6 7 8 9 10
    }
}

二次元のArrayList 

import java.util.*;
public class Main {
	static Scanner sc=new Scanner(System.in);
	static int INF=0x3f3f3f3f;
	static int N=200005;
	static char s[]=new char[N];
	static ArrayList[] pos=new ArrayList[N];
	static void init() {
		for(int i=0;i<26;i++) {
			pos[i]=new ArrayList<Integer>();
		}
	}
	public static void main(String[] args) {
		init();
		int n=sc.nextInt();
		int k=sc.nextInt();
		String string=sc.next();
		s=string.toCharArray();
		for(int i=0;i<n;i++) {
			pos[s[i]-'a'].add(i);
		}
		int ans=INF;
		for(int i=0;i<26;i++) {
			int len=pos[i].size();
			for(int j=0;j+k-1<len;j++) {
				int a=
				ans=Math.min(ans,(int)pos[i].get(j+k-1)-(int)pos[i].get(j)+1);
			}
		}
		if(ans==INF) ans=-1;
		System.out.println(ans);
	}
}

6.Map

定義：

• TreeMapの： 静的な地図<文字列、整数>マップ=新しいTreeMapを<文字列、整数>（）;
• HashMapの： 静的な地図<文字列、整数>マップ=新しいHashMapの<文字列、整数>（）;

共通操作：

• Vプット（Kキー、V値 ）： 追加要素。この事実は、他の機能はありますか？置き換え

       最初の鍵が格納されている場合、記憶素子に直接、またはnull
       最初のキーが存在しない場合、以前の値の値に置き換えるために、以前の値が返さ

• 空をクリア（）：要素のキーをすべて削除
• V削除（オブジェクトキー）：キー要素に応じてキーを削除し、値を返します
• INTサイズ（）：リターンキーと値のペアのセットの数
• VのGET（オブジェクトキーは）：キーに応じた値を取得します。
• ブールのcontainsKey（オブジェクトキー）：コレクションに指定されたキーが含まれているかどうかを判断します
• ブールのcontainsValue（Object値は）：コレクションが指定された値が含まれているかどうかを判断します
• ブールのisEmpty（）セットが空であるか否かを判断します
• セット<のMap.Entry <K、V >> のentrySet（）： キーと値のペアのセットのセットを返します
• セットのkeySet（）：コレクションのすべてのキーのコレクションを取得します。
• コレクションの値は（）：セット内のすべての値のセットを取得します。

import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    static Map<String,Integer> map=new TreeMap<String,Integer>();
//  static Map<String,Integer> map=new HashMap<String,Integer>();
    static void query() {
    	//forEach:通过Map.entrySet遍历key和value(效率高？）
    	for(Map.Entry<String,Integer> entry:map.entrySet()) {
    		System.out.print(entry.getKey()+":"+entry.getValue()+" ");
    	}
    	System.out.println();
    	//forEach:利用 keyset 集合遍历map
    	for(String key:map.keySet()) {
    		System.out.print(key+":"+map.get(key));
    	}
    	System.out.println();
    	//通过Iterator
    }
    public static void main(String[] args) {
    	map.put("ac",1);
    	map.put("wa",0);
    	query();//ac:1 wa:0
    	map.put("ac",666);
    	System.out.println(map.get("ac"));//666
    	query();//ac:666 wa:0
    	System.out.println(map.size());//2
    	map.remove("wa");
    	query();//ac:666 
    	System.out.println(map.size());//1
    }
}

7.Set 

定義：

• TreeSetの：静的セット<整数>セット=新しいTreeSetの<整数>（）;
• HashSetの：静的セット<整数>セット=新しいHashSetの<整数>（）;

共通操作

• 追加（）：コレクションに要素を追加    
• クリア（）：セット内のすべての要素を削除します
• ）（含まれています。  コレクションは、特定の要素が含まれているかどうかを決定します
• isEmpty（）セットが空であるか否かを判断します
• 削除（）：コレクションから特定のオブジェクトを削除    
• サイズ（）：  コレクションのサイズを返します。

import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    static Set<Integer> set=new TreeSet<Integer>();
//  static Set<Integer> set=new HashSet<Integer>();
    public static void main(String[] args) {
    	set.add(1);
    	set.add(2);
    	set.add(3);
    	System.out.println(set.contains(1));//true
    	System.out.println(set.size());//3
    	set.remove(1);
    	System.out.println(set.size());//2
    	System.out.println(set.contains(1));//false
    	//forEach遍历   输出结果为：2 3
    	for(Integer x:set) {
    		System.out.print(x+" ");
    	}
    }
}

8.Queue 

定義

• キュー：            静的キュー<整数> Q =新しいLinkedListの<整数>（）;
• 優先度つきキュー：静的優先度つきキュー<整数> PQ =新しい優先度つきキュー<整数>（）;

共通操作

• ブールオファーは（EはE）：キューがいっぱいの場合はtrueを要素とリターンを追加し、それは偽を返します。
• Eの世論調査（）：削除し、キューが空の場合の要素が尋ねるキューの先頭を返すには、nullが返されます
• EのPEEKは（）：キューが空の場合、キューの要素ヘッドを返し、nullが返されます

import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    static Queue<Integer> q=new LinkedList<Integer>();
    static PriorityQueue<Integer> pq=new PriorityQueue<Integer>();
    public static void main(String[] args) {
    	/*--Queue--*/
    	//添加
    	q.offer(0);
    	q.offer(3);
    	q.offer(2);
    	q.offer(1);
    	//删除队首并返回队首的值
    	System.out.println(q.poll());//0
    	//返回队首值
    	System.out.println(q.peek());//3
    	//forEach  输出结果为：3 2 1
    	for(Integer x:q) {
    		System.out.print(x+" ");
    	}
    	System.out.println();
    	/*--PriorityQueue--*/
    	//添加
    	pq.offer(0);
    	pq.offer(3);
    	pq.offer(2);
    	pq.offer(1);
    	//删除队首并返回队首的值
    	System.out.println(pq.poll());//0
    	//forEach  输出结果为：1 3 2（用forEach并不会排序输出）
    	for(Integer x:pq) {
    		System.out.print(x+" ");
    	}
    	System.out.println();
    	//返回队首值
    	System.out.println(pq.peek());//1
    	//while循环单个输出    输出结果为：1 2 3
    	while(!pq.isEmpty()) {
    		System.out.print(pq.poll()+" ");
    	}
    }
}

9.Stack

定义：静的スタック<整数> S =新しいスタック<整数>（）;

共通操作：

• オブジェクトPEEKは（）：スタックから削除せずに、スタックの一番上にあるオブジェクトを表示します。
• オブジェクトポップ（）：トップスタックオブジェクトを除去し、そしてこの関数の値は、オブジェクトを返します。
• オブジェクトプッシュ（対象要素）：スタックの最上部の上にアイテム。

import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    static Stack<Integer> s=new Stack<Integer>();
    public static void main(String[] args) {
    	s.push(1);
    	s.push(2);
    	s.push(3);
    	System.out.println(s.peek());//3
    	System.out.println(s.pop());//3
    	System.out.println(s.peek());//2
    	s.push(3);
    	//forEach   输出结果：1 2 3（不符合后进先出）
    	for(Integer x:s) {
    		System.out.print(x+" ");
    	}
    	System.out.println();
    	//while     输出结果：3 2 1
    	while(!s.isEmpty()) {
    		System.out.print(s.pop()+" ");
    	}
    }
}

10.int変換と文字列

int x=123;
String sx=String.valueOf(x);
String sy="321";
int y=Integer.parseInt(sy);

11.完全な配列

import java.util.*;
public class Main {
    static Scanner sc=new Scanner(System.in);
    static char s[]=new char[15];
    static void swap(char s[],int i,int j) {//交换函数
    	char tmp=s[i];
    	s[i]=s[j];
    	s[j]=tmp;
    }
    static void reverse(char s[],int begin,int end) {//逆序函数
    	while(begin<end) {
    		char tmp=s[begin];
    		s[begin]=s[end-1];
    		s[end-1]=tmp;
    		begin++;
    		end--;
    	}
    }
    static void fullsort(char s[],int begin,int end) {//递归实现全排列
    	if(begin==end) {
    		System.out.println(s);
    		return ;
    	}
    	for(int i=begin;i<end;i++) {
    		swap(s,i,begin);
    		fullsort(s,begin+1,end);
    		swap(s,i,begin);
    	}
    }
    static boolean next_permutation(char s[],int begin,int end) {//下一个字典序
    	int i=end-1;
    	while(i>begin&&s[i-1]>=s[i]) i--;
    	if(i==begin) return false;
    	i--;
    	int j=end-1;
    	while(j>i&&s[j]<=s[i]) j--;
    	swap(s,i,j);
    	reverse(s,i+1,end);
    	return true;
    }
    public static void main(String[] args) {
    	String str=sc.next();
    	s=str.toCharArray();
    	Arrays.sort(s);
    	do {
    		System.out.println(s);
    	}while(next_permutation(s,0,s.length));
    }
}