刷题基础知识

Map的使用：

public class Main
{
    public long factorial(int n){
        if(n<=1)
            return 1;
        return n * factorial(n-1);
    }

    public long func(String line){
        HashMap<Character, Integer> map  = new HashMap<Character, Integer>();
        for(int i=0;i<line.length();i++){
            Character c = line.charAt(i);
            if(map.containsKey(c))
                map.put(c, map.get(c)+1);    //修改Map的元素值
            else
                map.put(c, 1);
        }
        //访问Map
        long tmp = 1;
        for(Character key : map.keySet()){
            int val = map.get(key);
            tmp *= factorial(val);
        }

        return factorial(line.length()) / tmp;
    }


    public static void main(String[] args)
    {
        Main ob = new Main();
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextLine()){
            System.out.println(ob.func(scan.nextLine()));
        }
    }
}

匹配一个或多个空格：scan.nextLine().split("\s+");

大部分内置类均位于java.lang.*、java.util.*、java.io.*包中

 

格式化输出的方法：

 

System.out.println("x = " + x + ", y = " + y);
// printf()方式
System.out.printf("x = %d, y = %f
", x, y);
// format()方式
System.out.format("x = %d, y = %f
", x, y);

scan有直接返回大数的方法，无需通过String创建大数。

 

数组填充：https://www.runoob.com/java/arrays-fill.html

 

当内存超了,标志数组可以考虑用BitSet：

BitSet arr = new BitSet(n);
arr.set(0, n, true);
arr.get(0)

在处理string和int交叉输入时，最好统一用nextLine()获取行，利用string.split('\s+')划分，然后转成int

 

自定义比较对象：https://blog.csdn.net/qq_36785612/article/details/79935552

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main
{
    public void func(Score[] countryList){
        Arrays.sort(countryList, new MyCompare());
        //从大到小打印
        for(int i=countryList.length-1;i>=0;i--)
            System.out.println(countryList[i].contouryName);
    }

    public static void main(String[] args)
    {
        Main obj = new Main();
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextLine()){
            int num = Integer.parseInt(scan.nextLine());
            Score[] countryList = new Score[num];
            for(int i=0;i<num;i++){
                String line = scan.nextLine();
                String[] strList = line.split("\s+");
                Score country = new Score(strList[0], Integer.parseInt(strList[1]),
                        Integer.parseInt(strList[2]), Integer.parseInt(strList[3]));
                countryList[i] = country;
            }
            obj.func(countryList);
        }
    }
}

class Score{
    public String contouryName;
    public int goldScore;
    public int sliverScore;
    public int bronzeScore;

    Score(){
        this.contouryName = "";
        this.goldScore = 0;
        this.sliverScore = 0;
        this.bronzeScore = 0;
    }

    Score(String contouryName, int goldScore, int sliverScore, int bronzeScore){
        this.contouryName = contouryName;
        this.goldScore = goldScore;
        this.sliverScore = sliverScore;
        this.bronzeScore = bronzeScore;
    }
}

class MyCompare implements Comparator<Score>{
    @Override
    public int compare(Score a, Score b){
        if(a.goldScore > b.goldScore)
            return 1;
        else if(a.goldScore == b.goldScore){
            if(a.sliverScore > b.sliverScore)
                return 1;
            else if(a.sliverScore == b.sliverScore){
                if(a.bronzeScore > b.bronzeScore)
                    return 1;
                else if(a.bronzeScore == b.bronzeScore)
                    return a.contouryName.compareTo(b.contouryName);
            }
        }
        return -1;
    }
}

java中的栈类：

import java.util.Stack;

求最大公约数：辗转相除法。

 

表达式的计算：

建立两个栈：一个a存数字，一个b存运算符。

从左向右遍历，若为数字直接入a，若为运算符与b栈顶比较：若优先级大则入栈b；否则

 

对List排序：

import java.util.Collections;
Collections.sort(list);

 

注意string.replaceAll才支持正则表达式，string.replace不支持.

 String strM = mStr.replaceAll("\s+", "").toLowerCase();

去除string开头结尾的空格和换行符: 

str.trim()

将int转成BigInterger：

BigInteger bi = BigInteger.valueOf(myInteger.intValue());

对于高精度的double小数或大数，直接利用toString()转成String，或直接打印，均会以科学计数法输出。解决办法：

BigDecimal bigA = new BigDecimal(a);
BigDecimal res = bigA.pow(b);
String sRes = res.stripTrailingZeros().toPlainString();    //去除末尾无效0

char转int不一定要强制转换，但是int转char要强制转换。

 

判断数组中是否存在重复元素:

public static boolean hasRepeat(String[] pInStr){
    HashSet<String> hashSet = new HashSet<>();
    for(int i=0;i<pInStr.length;i++){
        hashSet.add(pInStr[i]);
    }
    if(hashSet.size() == pInStr.length){
        return false;
    } else{
        return true;
    }
}

判断数组中是否包含某个元素：

Arrays.asList(pInStr).contains(FirstState)

对ArrayList动态数组排序：

ArrayList<String> leftList =  new ArrayList<>();
ArrayList<String> rightList =  new ArrayList<>();
for(int i=0;i<pInStr.length;i++){
    if(FirstState.compareTo(pInStr[i])<=0){
        leftList.add(pInStr[i]);
    } else{
        rightList.add(pInStr[i]);
    }
}
Collections.sort(leftList);
Collections.sort(rightList);

对String[]排序：

Arrays.sort(strList); //无返回值