牛客、SQL刷题总结

【2021】阿里巴巴编程题

子集

链接：https://www.nowcoder.com/questionTerminal/a55198d2e65746009110226f2f6c8533
来源：牛客网

import java.io.*;
import java.util.*;
 
public class Main{
  //排序器，将X从小到大排序，最关键的一步是将相同的X按Y从大到小排序，因为如果按Y从小到大排序，
  //会导致后面的大的Y覆盖末尾前面的小的Y，这样就不符合贪心算法的尽量保证末尾元素最小的要求了。
    private static Comparator<int[]> comparator = new Comparator<int[]>(){
        @Override
        public int compare(int[] o1,int[] o2){
            if (o1[0] > o2[0]) return 1;
            else if (o1[0] < o2[0]) return -1;
            else {
                if (o1[1] > o2[1]) return -1;
                else if (o1[1] == o2[1]) return 0;
                else return 1;
            }
        }
    };

    public static void main(String[] args) throws IOException{
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String str = bf.readLine();
        int n = Integer.parseInt(str);
        for (int i = 0;i < n;i++){
            String str1 = bf.readLine();
            int m = Integer.parseInt(str1);
            String[] str2 = bf.readLine().split(" ");
            String[] str3 = bf.readLine().split(" ");
            int[][] items = new int[m][2];
            for (int j = 0;j < m;j++){
                items[j] = new int[]{Integer.parseInt(str2[j]),Integer.parseInt(str3[j])};
            }
            
            //对数组排序
            Arrays.sort(items,comparator);
            //res保存最长递增子序列的大小。
            int res = 1;
            //用来保存每个长度末尾的Y尽可能小的[x,y]数组。
            int[][] dp = new int[m + 1][2];
            dp[1] = items[0];
            //二分法进行查找此时的Y刚刚好大于哪一个下标的Y，又小于下一个下标的Y，这样更改下一个下标
            //的Y，为此时的Y，就可以保证dp数组保存的是末尾可能的最小的Y。这种方法相对于DP寻找最长
            //递增子序列，更快，时间复杂度为O(nlogn)
            for (int j = 1;j < m;j++){
                if (dp[res][1] < items[j][1]) dp[++res] = items[j];
                else if (dp[res][1] > items[j][1]){
                    int l = 1,r = res,pos = 0;
                    while (l <= r){
                        int mid = (l + r) >> 1;
                        if (dp[mid][1] < items[j][1]){
                            pos = mid;
                            l = mid + 1;
                        }else{
                            r = mid - 1;
                        }
                    }
                    if (dp[pos][0] != items[j][0]) dp[pos + 1] = items[j];
                }
            }
            System.out.println(res);
        }
    }
}

SQL刷题

185. 部门工资前三高的所有员工

# Write your MySQL query statement below
SELECT
	Department.NAME AS Department,
	e1.NAME AS Employee,
	e1.Salary AS Salary 
FROM
	Employee AS e1,Department 
WHERE
	e1.DepartmentId = Department.Id 
	AND 3 > (SELECT  count( DISTINCT e2.Salary ) 
			 FROM	Employee AS e2 
			 WHERE	e1.Salary < e2.Salary 	AND e1.DepartmentId = e2.DepartmentId 	) 
ORDER BY Department.NAME,Salary DESC;

华为机试

HJ19 简单错误记录

//纯粹的考代码实现能力
//记录个数，故使用Map，不需要排序故使用HashMap，根据题意是要循环输出，而且提交一次会有测试用例提示，需要按照输入顺序输出，故使用LinkedHashMap
//在输出的时候，题目的意思是循环八个，但问题是必须记录全部错误个数，否则刚记录完后弹出了，错误数就对不上了，跟操作系统里的缺页有那么点相似。
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;

public class Main{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		Map<String, Integer> map=new LinkedHashMap<String, Integer>();
		while(sc.hasNext()){
			String str=sc.next();
			int linenum=sc.nextInt();
			String[] arr=str.split("\\\\");  //根据\切割
			String s=arr[arr.length-1];
			if(s.length()>16)  //截取
				s=s.substring(s.length()-16);
			String key=s+" "+linenum;
			int value=1;
			if(map.containsKey(key))
				map.put(key, map.get(key)+1);
			else {
				map.put(key, value);
			}
		}
		int count=0;
		for(String string:map.keySet()){
			count++;
			if(count>(map.keySet().size()-8)) //输出最后八个记录
			    System.out.println(string+" "+map.get(string));
		}
	}
}