第一部分选择题80分，40个，每个2分

1. 五花八门，出的什么问题都有，什么概率论，KMP 卡特兰数，cmd 命令，Linux 命令，应有尽有，

2. 下面主要说一下编程题 有三个题 （20+30+30分）

   1. 组队吃鸡
      时间限制：C/C++语言 1000MS；其他语言 3000MS
      内存限制：C/C++语言 65536KB；其他语言 589824KB
      题目描述：
      最近一款吃鸡类型的游戏火爆全球。在组队模式下，你可以邀请自己的好友组建自己的小队，并选择是否填充（是否同意和非好友游玩），然后加入游戏。现在有A个单人队伍，B个双人队伍，C个三人队伍，D个四人队伍，并且全都同意填充，请问最多能组成多少个四人队伍。

      输入
      第一行一个正整数T，表示数据组数。（1≤T≤100）

      接下来T行，每行四个非负整数，A，B，C，D。（0≤A, B, C, D≤150）

      输出
      共T行，每行输出一个队伍数。

      样例输入
      4
      1 2 3 4
      4 3 2 1
      2 2 2 1
      0 2 0 1
      样例输出
      6
      5
      4
      2
      AC代码如下

      import java.util.Scanner;
      
      public class _360_1 {
          public static void main(String[] args) {
              Scanner sc =new Scanner(System.in);
              int T=sc.nextInt();
              while(T-->0){
                  int sum=0;
                  int a=sc.nextInt();
                  int b=sc.nextInt();
                  int c=sc.nextInt();
                  int d=sc.nextInt();
                  sum+=d;//4人队伍
                  //三人队伍找单人去借
                  if(c>a){
                      sum+=(a);
                      a=0;
                  }else{
                      sum+=c;
                      a-=c;
                  }
                  if(b>=2){
                      sum+=(b/2);
                      b=b%2;
                  }
                  if(b>0){
                      if(a>=2){
                          sum+=1;
                          a=a-2;
                      }
                  }
                  if(a>=4){
                      sum+=(a/4);
                  }
                  System.out.println(sum);
      
              }
      
          }
      
      }
      

   2.重排序列

    时间限制：C/C++语言 1000MS；其他语言 3000MS
    内存限制：C/C++语言 65536KB；其他语言 589824KB
    题目描述：
    给定一个长度为N的序列A1到AN，现在要对序列进行M次操作，每次操作对序列的前若干项进行升序或降序排列，求经过这M次操作后得到的序列。
    
    输入
    第一行包含两个整数N和M，1≤N，M≤105。
    
    第二行包含N个空格隔开的整数A1到AN，1≤Ai≤109。
    
    接下来M行，每行包含两个整数t和x，0≤t≤1，1≤x≤N。若t=0，则表示对A1到Ax进行升序排列；若t=1，则表示对A1到Ax进行降序排列。操作执行顺序与输入顺序一致。
    
    输出
    输出N个空格隔开的整数，即经过M次操作后得到的序列。
    
    样例输入
    4 2
    1 2 4 3
    1 3
    0 2
    样例输出
    2 4 1 3
   

   AC代码如下

   		import java.util.Arrays;
   		import java.util.Scanner;
   		public class _360_2 {
   		    public static void main(String[] args) {
   		        Scanner sc = new Scanner(System.in);
   		        int N = sc.nextInt();
   		        int M = sc.nextInt();
   		        int a[] = new int[N];
   		        for (int i = 0; i < N; i++) {
   		            a[i] = sc.nextInt();
   		        }
   		        for (int i = 0; i < M; i++) {
   		            int flag = sc.nextInt();
   		            int index = sc.nextInt();
   		            if (flag == 0) {
   		                Arrays.sort(a, 0, index);
   		            } else {
   		                Arrays.sort(a, 0, index);
   		                change(a, index);
   		            }
   		        }
   		        for (int i = 0; i < N; i++) {
   		            System.out.print(a[i] + " ");
   		        }
   		
   		
   		    }
   		
   		    private static void change(int[] a, int index) {
   		        for (int j = 0; j < index / 2; j++) {
   		            int tmp = a[j];
   		            a[j] = a[index - 1 - j];
   		            a[index - 1 - j] = tmp;
   		        }
   		
   		    }
   		}
   
   

3.移动排列
时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
给定一个1到N的排列A1到AN，每次可以将排列的第一个数移到排列的末尾，假设经过若干次移动后得到排列B1到BN，那么|B1-1|+|B2-2|+|B3-3|+…+|BN-N|的最小值是多少？

样例解释 

经过两次移动后得到排列{1 5 2 4 3}，此时|B1-1|+|B2-2|+|B3-3|+|B4-4|+|B5-5|取得最小值。

输入
第一行包含一个整数N，1≤N≤105。

第二行包含N个空格隔开的整数A1到AN。

输出
输出|B1-1|+|B2-2|+|B3-3|+...+|BN-N|的最小值。

样例输入
5
4 3 1 5 2
样例输出
6

过了55%的数据的代码如下

import java.util.Scanner;
public class _360_3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int a[]=new int[N];
        for (int i = 0; i < N; i++) {
            a[i]=sc.nextInt();
        }
        int b[]=new int[N];
        for(int i=0;i<N;i++){
            b[i]=i+1;
        }
        //最多转N次
        int res = Integer.MAX_VALUE;
        int p=0;
        while(p++<N){
            int sum=0;
            for(int i=0;i<N;i++){
                sum+=(Math.abs(a[(i+p)%N]-b[i]));
            }
            if(sum<res) res=sum;
        }
        System.out.println(res);
    }
}