1、char类型数组输入：

快输+一维char数组：g[]

char[] g=in.readLine().toCharArray();

快输+二维char数组：g[][]

for(int i=0;i<r;i++){
    char[] ss=in.readLine().toCharArray();
    for(int j=0;j<c;j++){
        g[i][j]=ss[j];
    }
}
//或者
for(int i=0;i<r;i++){
    g[i]=in.readLine().toCharArray();
}

普通+二维char数组：g[][]

for(int i=0;i<4;i++){
    g[i]=sc.next().toCharArray();
}

2、c++结构体在java中的使用方法：

需要排序：

https://www.acwing.com/file_system/file/content/whole/index/content/1925156/

class PII implements Comparable<PII>{
    int x,y,h;
    PII(int x,int y,int h){
        this.x=x;
        this.y=y;
        this.h=h;
    }
    @Override
    public int compareTo(PII o) {
        //按照h的大小排序
        return Integer.compare(h, o.h);
    }
}

PriorityQueue[HTML_REMOVED] queue = new PriorityQueue[HTML_REMOVED]();
在优先队列中必须使用

不需排序：厚棉鞋

3、科学计数法

java中好像只有Double类型可以用1e5这类表示形式，如果需要要赋值int类型：

int res=(int)1e5;

4、LinkedList使用方法

（1） 定义：LinkedList<String> list = new LinkedList<>();

public class Main {
    public static void main(String[] args) {
        LinkedList<String> linkedList1 = new LinkedList<>();
        System.out.println(linkedList1);//[]
        String[] arr = {"H", "E", "L", "L", "O"};
        LinkedList<String> linkedList2 = new LinkedList<>(Arrays.asList(arr));
        System.out.println(linkedList2);//[H, E, L, L, O]
    }
}

（2）增：add()
public boolean add(E e)：链表末尾添加元素，返回是否成功；
public void add(int index, E element)：向指定位置插入元素；

（3）删：remove()
public void clear()：清空链表；
public boolean remove(Object o)：删除某一元素，返回是否成功；
public E remove(int index)：删除指定位置的元素；

（4）查：get()
public boolean contains(Object o)：判断是否含有某一元素；
public E get(int index)：返回指定位置的元素；

（5）改：set()
public E set(int index, E element)：设置指定位置的元素；

（6）其他：
public int size()：返回链表元素个数；
public Object[] toArray()：返回一个由链表元素组成的数组；
public <T> T[] toArray(T[] a)：返回一个由链表元素转换类型而成的数组；

（7）遍历：
for循环1：

for (String str: linkedList) {
    System.out.println(str);
}

for循环2：

for (int i = 0; i < linkedList.size(); i++) {
    System.out.println(linkedList.get(i));
}

迭代器：

Iterator iter = linkedList.iterator();
while (iter.hasNext()) {
    System.out.println(iter.next());
}

5、HashMap使用方法

创建：

Map<String,Integer> map= new HashMap<>();

遍历：
for遍历1：

Map<String, String> map = new HashMap<String, String>();
for (String key : map.keySet()) {
    map.get(key);
}

for遍历2：

Map<String, String> map = new HashMap<String, String>();
for (Entry<String, String> entry : map.entrySet()) {
    entry.getKey();
    entry.getValue();
}

键值对的添加:

hashMap.put("apple", 1);

按照Key获取值:（好像不可以按照值获取Key）

System.out.println(hashMap.get("apple"));//1

常用方法：

存在某个Key的判断:
if(map.containsKey(key))
删除HashMap中的指定键及其对应的值：

HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("name", "Lucy");
hashMap.put("age", 20);
hashMap.put("gender", "Female");
hashMap.remove("age");//使用remove方法删除其中的一条数据（键为“age”）

删除HashMap中指定键的键值对，但只有在当前键对应的值为指定值时才删除:

HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("name", "Lucy");
hashMap.put("age", 20);
hashMap.put("gender", "Female");
hashMap.remove("name", "Lucy");//使用remove方法删除键为“name”且对应的值为“Lucy”的键值对

删除HashMap中所有的键值对:
hashMap.clear();

6、StringBuffer使用方法：

（1）定义：
StringBuffer sBuffer = new StringBuffer();
StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
（2）方法：
sb.append(String s)
将指定的字符串追加到ab字符序列。
sb.deleteCharAt(idx);
将idx位置的字符删除。

以上两种方法经常用于字符串DFS

ab.reverse()
将此字符序列用其反转形式取代。
char charAt(int index)
返回此序列中指定索引处的 char 值。
String toString()
返回此序列中数据的字符串表示形式。

7、格式化2位小数 String.format()

double d = 3.1415926;
String result = String.format("%.2f",d);

java中位运算^,&,<<,>>,<<<,>>>总结

位运算总结

排序

java.util.Arrays.sort()支持对int[],long[],short[],char[],byte[],float[],double[],Object[]进行排序

1、快速排序：首先是最简单的Array.sort，直接进行排序：

public static void main(String[] args) {
    int[] arr = {4,3,5,1,7,9,3};
    Arrays.sort(arr);
    for (int i : arr){
        System.out.println(i);
    }
}

2、部分排序法：使用Array.sort还可进行选择想要排序的部分数字，如将下角标编号为1~4的数字进行排序，其他数字顺序不变。

public static void main(String[] args) {
    int[] arr = {4,3,5,1,2,9,3,0};

    Arrays.sort(arr,1,4);

    for (int i = 0;i<arr.length;i++){
        System.out.print(arr[i]+",");
    }
}

Java的Arrays.toString()方法介绍

Arrays.toString和Object.toString的使用区别

BigInteger类型

BigInteger

求环TLE时，可以将队列改成栈

栈的用法：
Stack<Integer> sk = new Stack<Integer>();
sk.push(0);
int u = sk.pop();

一些自己感觉很经典的处理方式：

1、DFS排列问题

需要st[]数组，因为每遍历到一个数，都会从头选择，且只能选择没有用过的数，此时就要用st数组。

变式1：当数字列表中存在重复数字

排序Arrays.sort(nums)+剪枝if(i>0&&nums[i]==nums[i-1]&&st[i-1]==true) continue;
就是如果重复数的第一个没有用过（被撤销）那么这俩数就在同一层，需要剪枝；
如果第一个数用过了st[i-1]==false，说明这俩重复的数不在同一层，纵向重复不能剪枝。

LeetCode 47.全排列II

2、DFS组合问题：相同数字列表的不同排列视为一个结果

核心：使用start变量划分范围，每次递归时不能从start前面开始，进行下一次递归时使用i+1更新start，即下一次从当前下标i的下一个下标i+1开始循环。
不用使用st[]数组，因为每次都是从当前位置后面的开始遍历，不会重复，不会有用过的。

for(int i=start;i<nums.length;i++) {
    list.add(nums[i]);
    dfs(lists, target, nums, list,i+1);
    list.remove(list.size()-1);
}

变式1：当数字列表中的数字可以无限制重复被选取（当然有别的限制）

下一次从当前下标i开始循环，表示可以选包括最近已选的那个数及之后的数中选择。

LeetCode 39. 组合总和

变式2：当数字列表中存在重复数字

排序Arrays.sort(nums)+剪枝if(i>start&&nums[i]==nums[i-1]) continue;
在一个for循环中，所有被遍历到的数都是属于一个层级的。
我们要让一个层级中，必须出现且只出现一个2，那么就放过第一个出现重复的2，但不放过后面出现的2。第一个出现的2的特点就是 i == start. 第二个出现的2 特点是i > start.

LeetCode 40. 组合总和 II

如果写if i > 0 and nums[i-1] == nums[i] 会发现纵向的也被剪枝了，会导致全局只有一个相同数字可用，
改成i > start后，这样递归进入下一层时和上一层的重复结果没有任何关系了。