^表示异或
   如
a^b

奇技淫巧
不用第三个变量，交换两个变量值
a=a^b
b=a^b
a=a^b

解释
a=a^b   
b=a^b 此时相当于之前的变量值 a^b^b 又因为b^b=0, b=a^0=a
a=a^b 此时相当于a^b^a 满足交换律所以，a=0^b=b

int a=1,b=1;
那么  a&b = 1

奇技淫巧
int a=10 b=16=2^4
如果此时要求  a%b   那么可以->   a&(b-1)
两者是等价的，并且后者更快
注意 b必须是2^n次方，

原理
当b为2^n时，此时换成二进制可以看出，只有从右往左数第n+1位为1，其他位为0
如 2^3 =1000b   2^3-1= 0111b 
此时-1的话，就可以把前 n位变成1，那么此时按位与即可求出余数

<< 向左移位 ，类似乘2，低位直接补0
>> 带符号向右移位 ，类似除2,这个是带符号位右移，负数高位补1，正数高位补0
>>> 忽视符号位向右移位  ，类似除2，直接右移，高位补0


奇技淫巧
求2的N次方
可以  1<<N

System.out.println((4.0/3)*pi*r*r*r);
和
System.out.println((4/3)*pi*r*r*r);

1. 获得实例

```java
  Calendar data=Calendar.getInstance();

```java
  data.set(2024,Calendar.MAY,1,8,0,0);

2. 设置日期
3. 加减时间

data.add(Calendar.MINUTE, (int) -(10+time));

- yyyy：年。
- MM：月。
- dd：日 。
- hh：1~12 小时制 (1-12)。
- HH：24 小时制 (0-23)。
- mm：分。
- ss：秒。
- **上面的比较常用**
- S：毫秒。
- E：星期几。
- D：一年中的第几天。
- F：一月中的第几个星期(会把这个月总共过的天数除以 7)。
- w：一年中的第几个星期。
- W：一月中的第几星期(会根据实际情况来算)。
- a：上下午标识。
- k：和HH差不多，表示一天 24 小时制 (1-24)。
- K：和hh差不多，表示一天 12 小时制 (0-11)。
- z：表示时区。

SimpleDateFormat sp=new SimpleDateFormat("HH:mm");

System.out.println(sp.format(data.getTime()));

BigDecimal bg=new BigDecimal(h);
//新建一个BigDecimal类
bg=bg.round(new MathContext(2, RoundingMode.HALF_UP));
//使用BigDecimal类里面的round方法,新建MathContext对象作为参数,规定位数,近似方式
System.out.println(bg.doubleValue());
//使用BigDecimal获得值

ArrayList<Integer> sort = new ArrayList<Integer>();
//生成Arraylist,并给定泛型
for (int i = 0; i < 3; i++) {
    sort.add(sc.nextInt());
    //添加数据
}
sort.sort(Comparator.reverseOrder());
//使用sort方法进行排序,并给定comparator,如上面的就是从小到大排序,
//如果想逆序,就是用Comparator.naturalOrder()
while (sort.listIterator().hasNext()) {
    System.out.println(sort.listIterator().next());
}

Arrays.sort(a,(x,y)->{
            if (x[3]>y[3])return -1;
            if (x[0]>y[0]&&x[3]==y[3])return -1;
            if (x[4]<y[4]&&x[3]==y[3]&&x[0]==y[0])return -1;
            return 1;
        });

Arrays.sort(a, Comparator.comparing(需要的转换或者访问操作));

Arrays.sort(a, Comparator.comparing(String::valueOf));

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

         sc.nextLine();

        ArrayList<Integer> list = new ArrayList<>();
        StringBuilder sb = new StringBuilder();

        sb.append(sc.nextLine());
        String[] s1 = sb.toString().split(" ");
        Arrays.parallelSort(s1,
                Comparator.comparing(
                        Integer::parseInt
                )
        );

        System.out.println(String.join(" ", s1));

    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> set = new ArrayList<>();
        int sum=0;
        while (sc.hasNextInt()){

            set.add(sc.nextInt());
        }
        for (int i = 1; i <= set.size(); i++) { //n个元素的子集
            for (int j = 0; j <= set.size()-i; j++) { //从第一个开始遍历
                for (int k = j; k < j+i; k++) { //遍历i个元素
                    sum+= set.get(k);
                }
            }
        }
        System.out.println(sum);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<BigInteger> set = new ArrayList<>();
        BigInteger sum = new BigInteger(String.valueOf(0));
        while (sc.hasNext()){

            set.add(new BigInteger(sc.next()));
        }
        for (int i = 1; i <= (1<<set.size()); i++) { //n个元素的子集,则有1<<n种子集
            for (int j = 0; j < set.size(); j++) { //遍历集合中的每一个元素
                if ((i&(1<<j))>0){
                    sum=sum.add(set.get(j));
                }
            }
        }
        System.out.println(sum);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Long> set = new ArrayList<>();
        while (sc.hasNextLong()){
            set.add(sc.nextLong());
        }
        BigInteger sum = new BigInteger(String.valueOf(0));
        for (int i = 0; i < set.size(); i++) {
            sum=sum.add(BigInteger.valueOf(set.get(i)*(1L <<(set.size()-1))));
        }
        System.out.println(sum);
    }
}

- 参数一, 要填充的数组
- 参数二,要填充的数字

Arrays.fill(int[],-1)
给前面这个数组填充-1

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        int n = Integer.parseInt(sc.nextLine());
        ________________________这里需要扫下一行，而不是扫sc.nextInt(),这样会漏掉一个换行符
        for (int i = 0; i < n; i++) {
            String[] str = sc.nextLine().split(" ");
            String f="";

            int result=0;
            if (str.length==3) {
                operation=str[0];
                result=operate( Integer.parseInt(str[1]), Integer.parseInt(str[2]));
                f=String.format("%s%s%s=%d", str[1],sign,str[2],result);
            }else {
                result=operate(Integer.parseInt(str[0]), Integer.parseInt(str[1]));
                f=String.format("%s%s%s=%d", str[0],sign,str[1],result);
            }
            System.out.println(f);
            System.out.println(f.length());
            }
        }

// 最优输入流
static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
// 最优输出流
static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out))); 
    
static int nextInt() throws IOException { // 输入流的封装函数
    in.nextToken();
    return (int) in.nval;
}
    
public static void main(String[] args) throws IOException {
    out.println(想要输出的东西)；
    out.flush(); // 刷新输出流
}

private static boolean isZhi(int i) {
// 判断i是否为2、3、5
    if (i==2||i==3||i==5){
        return true;
    }
    
    // 判断i是否为偶数、5的倍数、3的倍数
    if (i %2==0|| i %5==0|| i %3==0){
        return false;
    } else {
        boolean flag=true;
        // 遍历2到i的平方根之间的数，判断i是否为合数
        for (int i1 = 2; i1 *i1<=i; i1++) {
            if (i %i1==0){
                flag=false;
                break;
            }
    
        }
        return flag;
    }
}

#include <bits/stdc++.h>
using namespace std;
long long n,m;
bool vis[10000001]={1,1};//0，1均既不是素数，也不是和数，所以先标记为不是
int Prime[10000001],k;
void prime(long long n)
{
    for(int i=2;i<=n;i++)//最小的素数是2
    {
        if(!vis[i])
        {
            Prime[++k]=i;//如果是素数就标记一下
         }
        for(int j=1;j<=k;j++)//j小于当前所有的素数的个数
        {
            if(Prime[j]*i>n)
            {
                break;
            }
            vis[Prime[j]*i]=true;//用素数依次×i，结果标记为合数
            if(i%Prime[j]==0)
            {
                break;
            }
        }
    }//欧拉筛法，就是拿当前的数×之前的筛出来的素数，这个数即为合数
}
int main()
{
    cin>>n;
    prime(100001);//在10的5次方范围内筛素数
    for(int i=1;i<=n;i++)
    {
        int t;
        cin>>t;
        if(!vis[t])//上面标记过了，这时输入后直接判断就行了
        {
            cout<<t<<" ";
        }
    }
    return 0;
}

// 静态变量定义
static boolean[] notPrime;     // 布尔数组，标记是否为非素数（false表示是素数）
static ArrayList<Integer> curPrimes; // 动态数组，存储当前已筛选出的素数集合

public static void main(String[] args) throws IOException {
    int n = nextInt();  // 读取输入的n值
    
    // 初始化非素数标记数组
    notPrime = new boolean[n + 1];  // 数组下标范围为[0, n]
    notPrime[0] = notPrime[1] = true;  // 0和1不是素数
    curPrimes = new ArrayList<>();  // 初始化素数集合
    
    // 欧拉筛核心逻辑
    for (int i = 2; i <= n; i++) {  // 修正：i应遍历到n，确保n自身被处理
        // 如果i未被标记为非素数，则i是素数
        if (!notPrime[i]) {
            curPrimes.add(i);  // 将素数i加入集合
        }
        
        // 用当前i与已知素数生成合数
        for (int j = 0; j < curPrimes.size(); j++) {
            int prime = curPrimes.get(j);  // 当前素数
            int composite = prime * i;     // 生成的合数
            
            // 若合数超过n，终止内层循环
            if (composite > n) break;
            
            // 标记合数为非素数
            notPrime[composite] = true;
            
            // 关键逻辑：若i能被当前素数整除，终止循环
            // 保证合数仅被其最小质因数筛除
            if (i % prime == 0) break;
        }
    }
    
    // 输出所有素数（未被标记为非素数的数）
    for (int i = 0; i <= n; i++) {
        if (!notPrime[i]) out.print(i + " ");
    }
    
    // 流操作
    out.flush();  // 强制刷新缓冲区，确保内容输出
    out.close();  // 关闭输出流
}

text


初始堆：     5         插入3后：    5          调整后：    3
          /   \                 /   \                /   \
         8    10               8    10              5    10
                             /                   /
                            3                   8

text


删除前：     3          交换堆顶和末尾：    8         调整后：    5
          /   \                     /   \                 /   \
         5    10                   5    10               8    10
       /                         /
      8                         3（已删除）

text


初始数组：[9, 5, 2, 7, 3]
构建小根堆：
        2
      /   \
     3     5
    / \
   7   9

public class MinHeap {
    private int[] heap;
    private int capacity;
    private int size;

    public MinHeap(int capacity) {
        this.capacity = capacity;
        this.heap = new int[capacity];
        this.size = 0;
    }

    // 插入元素
    public void insert(int value) {
        if (size == capacity) throw new IllegalStateException("Heap is full");
        heap[size] = value;
        siftUp(size);
        size++;
    }

    // 上浮操作
    private void siftUp(int index) {
        while (index > 0) {
            int parent = (index - 1) / 2;
            if (heap[parent] <= heap[index]) break;
            swap(parent, index);
            index = parent;
        }
    }

    // 删除堆顶
    public int poll() {
        if (size == 0) throw new IllegalStateException("Heap is empty");
        int root = heap[0];
        heap[0] = heap[size - 1];
        size--;
        siftDown(0);
        return root;
    }

    // 下沉操作
    private void siftDown(int index) {
        while (true) {
            int left = 2 * index + 1;
            int right = 2 * index + 2;
            int smallest = index;
            if (left < size && heap[left] < heap[smallest]) {
                smallest = left;
            }
            if (right < size && heap[right] < heap[smallest]) {
                smallest = right;
            }
            if (smallest == index) break;
            swap(index, smallest);
            index = smallest;
        }
    }

    private void swap(int i, int j) {
        int temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

class MinHeap{
int size=0;
long[] heap=new long[20001];

    public long peek(){
        return heap[0];
    }
    public void swap(int index1,int index2){
        long temp=heap[index1];
        heap[index1]=heap[index2];
        heap[index2]=temp;
    }
    private void siftUp(int index){
        while (index > 0&&index<size) {
                int parent=(index-1)/2;
                if (heap[parent]<=heap[index])break;
                swap(parent,index);
                index=parent;
        }
    }
    private void siftDown(int index){
        while (index<size){
            int lch=2*index+1;
            int rch=2*index+2;
            int smallest=index;
            if (lch<size&&heap[lch]<heap[smallest])smallest=lch;
            if (rch<size&&heap[rch]<heap[smallest])smallest=rch;
            if (index==smallest)break;
            swap(smallest,index);
            index=smallest;
        }

    }
    public void add(long data){
        heap[size++]=data;
        siftUp(size-1);

    }
    public long poll(){
        long smal=peek();
        heap[0]=heap[--size];
        siftDown(0);
        return smal;

    }
}

char[] chars = sb.toString().toCharArray();
        int begin=0,end=sb.length()-1;
        while (chars[begin]=='0')begin++;
        while (chars[end]=='0')end--;
        for (int i = begin ; i <= end; i++) {
            System.out.print(chars[i]);
        }

#include <iostream>
#include "iomanip"
using namespace std;
int a[100][100];
void fillTable(int x,int y,int step) {

    if (step==1)
    {
        return;
    }
    step /= 2;
    fillTable(x, y, step );
    fillTable(x+step, y, step);
    for (int i = 0; i < step; i++)
    {
        for (int j = 0; j < step; j++) {
            a[x + i][y + step + j] = a[x + i + step][y + j];
            a[x + step + i][y + step + j] = a[x + i][y + j];
             
        }
    }
    
}
int main() {
    int n=0;
    cout << "请输入比赛的选手数量" << endl;
    cin >> n;
    cout << endl;
    cout << "日期  ";
    for (int i = 0; i < n-1; i++)
    {
        cout << setw(5) << i + 1;
    }
    cout << endl;
    cout << "选手  ";
    for (int i = 0; i < n-1; i++)
    {
        cout<< setw(5) << setfill('-') << " ";
    }
    cout << endl;
    for (int i = 1; i <= n; i++)
    {
        a[i][1] = i ;
    }
    fillTable(1, 1, n);


    for (int i = 1; i <= n; i++) {
        
        cout <<setfill(' ') << setw(4) << i << setw(2) << ":";
        for (int j = 1; j < n; j++)
        {
            cout << setw(5) << a[i][j];
        }
        cout << endl;
    }


    return 0;
}

#include <iostream>	
#include <iomanip>
using namespace std;
int Partition(int s[], int f[], int p, int r);
void quickSort(int s[],int f[],int p,int r) {
    if (p<r)
    {
        int q=Partition(s, f, p, r); //返回pirvot正确的位置，左边都是小于pivot的，右边是大于pivot的
        quickSort(s, f, p, q - 1); //对左边排序
        quickSort(s, f, q + 1, r);//对右边排序
    }
}
int Partition(int s[],int f[], int p, int r) {
    int i = p;
    int j = r+1;
    while (i<j) //易错,双指针有交叉的时候证明排序已经结束，左边是小的，右边是大的
        
    {
        while (f[p] > f[++i]);//易错，从左到右扫描，正常的话都是比他小的，比他大的就不正常，退出循环
        while (f[p] < f[--j]);//易错，同上
        //交叉的时候，j是pivot要插入的位置，为什么呢？
        if (i >= j)break;
        
        f[i] = f[i] ^ f[j]; f[j] = f[i] ^ f[j]; f[i] = f[i] ^ f[j];  //异或交换两个变量的值，参考不常见操作符，异或
        s[i] = s[i] ^ s[j]; s[j] = s[i] ^ s[j]; s[i] = s[i] ^ s[j];
        
        
    }
    int tempS = s[p];
    int tempF = f[p];
    s[p] = s[j];
    f[p] = f[j];
    s[j] = tempS;
    f[j] = tempF;

    return j;
}
void printArray(int s[],int f[], int begin, int end) {
    for (int i = begin; i <= end; i++)
    {
        cout << setw(15) << i;
        cout << setw(15) << s[i];
        cout << setw(15) << f[i];
        cout << endl;
    }
}

void greedySelector(int a[], int s[], int f[], int begin, int end) {
    int p = begin; //上一个选的
    a[p] = true;
    
    for (int i = begin; i <=end; i++)
    {
        if (f[p] <= s[i]) {
            a[i] = true;
            p = i;
        }
    }
}
int main() {
    int n;
    int s[100], f[100];
    int a[100] = {};//初始化为零
    cout << "请输入活动的个数,n=";
    cin >> n;
    cout << "请分别输入开始时间s[i]和结束时间f[i]:" << endl;
    for (int i = 1; i <= n; i++)
    {
        cout << "s["<<i<<"] = ";
        cin >> s[i];
        cout << "f["<<i<<"] = ";
        cin >> f[i];
        cout << endl;


    }
    quickSort(s, f, 1, n );

    cout << "按结束时间非减序排列如下：" << endl;
    cout << setw(15) << "序号" << setw(15) << "开始时间" << setw(15) << "结束时间" << endl;
    printArray(s,f, 1, n);

    greedySelector(a, s, f, 1, n);

    cout << "安排的活动序号依次为" << endl;
    for (int i = 0; i <= n; i++)
    {
        if (a[i])
        {
            cout <<std::left<< setw(15) << i;
            cout << s[i] << "->" << f[i]<<endl;
        }
    }
    return 0;
}

public static void dfs(int size){
    if (size==n){
        for (int i = 0; i < n; i++) {
            sb.append("    ").append(result[i]);
        }
        out.println(sb);
        sb.delete(0,sb.length());
        out.flush(); // 强制清空缓冲区
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (used[i]){
            continue;
        }
        result[size]=i+1;
        used[i]=true;
        dfs(size+1);
    
        used[i]=false;
    }
}

public static void dfs(int size){
    if (size==n){
        //如果已经搜索到底了，就输出
        return;
    }
    
    for (int i = 0; i < n; i++) {
        if (used[i]){			//剪枝函数，剪掉不满足条件的路径
            continue;
        }
        result[size]=i+1;
        used[i]=true;   //使用一个boolean数组存储用过的数字
        dfs(size+1);	//dfs加一层，如果是组合数，就要设置一个begin参数，
                        //				每次下一个存入的数要比上一个大
    
        used[i]=false;   //回溯
    }
}

public static void dfs(int[]nums,int begin,int r,int n,int size){
        if (size==r){
            for (int i = 0; i < r; i++) {
                out.print(String.format("%3d",nums[i]));
            }
            out.println();
            return;
        }
        if (n-begin+1<r-size)return;

        for (int i = begin; i <= n; i++) {
            nums[size]=i;
            dfs(nums,i+1,r,n,size+1);
        }
    }

public static void dfs(int[]nums,int begin,int r,int n,int size){
        if (size==r){
            //如果已经搜索到底了，就输出
            return;
        }
        if (n-begin+1<r-size)return;  //剪枝函数，begin从1开始就要+1，
                                                        //不是就不用

        for (int i = begin; i <= n; i++) {
            nums[size]=i;                 //注意这里的标号是size，不要写成begin或者i
            dfs(nums,i+1,r,n,size+1);		//这里的下一个begin是i+1，因为后面的要比前面的大
        }									//size+1，搜索下一个数
    }

1. <font style="color:#000000;background-color:#D9DFFC;">从后向前查找第一个升序对：</font>  

2. <font style="background-color:#D9DFFC;">从后向前查找第一个比 a[i] 大的元素：</font>  

3. <font style="background-color:#D9DFFC;">交换 a[i] 和 a[j]：</font>  

public class Main {
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in))); // 最优输入流
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out))); // 最优输出流

    static int nextInt() throws IOException { // 输入流的封装函数
        in.nextToken();
        return (int) in.nval;
    }
    static Double nextDouble() throws IOException { // 输入流的封装函数
        in.nextToken();
        return  in.nval;
    }
    static Long nextLong() throws IOException { // 输入流的封装函数
        in.nextToken();
        return  (long) in.nval;
    }

    public static void main(String[] args) throws IOException {
        int n=nextInt(),m=nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i]=nextInt();
        }
        for (int i = 0; i < m; i++) {
            nextPermutation(nums);
        }
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < n; i++) {
            sb.append(nums[i]).append(" ");
        }
        out.println(sb);
        out.flush(); // 刷新输出流
        out.close();//关闭流
    }
    public static void nextPermutation(int []num){
        int n = num.length;
        int i = n - 2;
        for (; i >= 0&&num[i]>num[i+1]; i--);
        if (i<0)return;

        int j= n -1;
        for (; j >i&&num[j]<num[i]; j--);

        //交换
        num[i]=num[i]^num[j];
        num[j]=num[i]^num[j];
        num[i]=num[i]^num[j];




        for (int k = 1; k <= (n - i) / 2; k++) {
            if (i+k==n-k)break;
            num[i+k]=num[i+k]^num[n-k];
            num[n-k]=num[i+k]^num[n-k];
            num[i+k]=num[i+k]^num[n-k];
        }

    }
}

public static void main(String[] args) throws IOException {
        int n=nextInt();
        int k=nextInt();

        long[] woods = new long[n];
        long sum=0;
        for (int i = 0; i < n; i++) {
            woods[i]=nextLong();
            sum+=woods[i];

        }


        long left=1;
        long right= Math.min(sum / k, Arrays.stream(woods).max().getAsLong());
        long ans=0;

        if (right<1) {
            out.println(0);
            out.flush();
            return;
        }
        while (left<=right){
            long mid =left+(right-left)/2;
            long cnt=0;
            for (int i = 0; i < n; i++) {
                cnt+= (woods[i]/mid);
                if (cnt>=k)break;
            }

            if (cnt>=k){
                ans=mid;
                left=mid+1;
            }else {
                right=mid-1;
            }
        }
        out.println(ans);
        out.flush(); // 刷新输出流
        out.close();//关闭流
    }

class UnionFind{
    int[] pre;
    int[] rank;
    public UnionFind(int size){ //初始化
        pre=new int[size];
        rank=new int[size];
        Arrays.fill(rank,1);
        for (int i = 0; i < size; i++) {
            pre[i]=i;
        }
    }
    public int find(int x){ //查找
        if (pre[x]==x)return x;
        return pre[x]=find(pre[x]); //路径压缩
    }
    public boolean Union(int x,int y){ //合并
        int prevX=find(x);
        int prevY=find(y);
        if (prevX==prevY)return false;

        if (rank[prevX]<rank[prevY]){ //按秩合并
            pre[prevX]=prevY;
            rank[prevY]+=rank[prevX];
        }else {
            pre[prevY]=prevX;
            rank[prevX]+=rank[prevY];
        }
        return true;
    }
}