【蓝桥杯2019JavaB】特别数的和、外卖店优先级

时间限制: 1.0s 内存限制: 512.0MB 本题总分：15 分
【问题描述】
小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
请问，在 1 到 n 中，所有这样的数的和是多少？
【输入格式】
输入一行包含两个整数 n。
【输出格式】
输出一行，包含一个整数，表示满足条件的数的和。
【样例输入】
40
【样例输出】
574
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ n ≤ 10。
对于 50% 的评测用例，1 ≤ n ≤ 100。
对于 80% 的评测用例，1 ≤ n ≤ 1000。
对于所有评测用例，1 ≤ n ≤ 10000。

这道题应该没什么好说的，题目的意思已经非常明确了。

public class Main{
	public static void main(String[] args) {	
		Scanner sc = new Scanner(System.in);
		List<Integer>list=new ArrayList<>();
		int n=sc.nextInt();
		for(int i=1;i<=n;i++) {
			String str=i+"";
			if(str.contains("2")||str.contains("0")||str.contains("1")||str.contains("9")) {
				list.add(i);
			}
		}
		int sum=0;
		for(int i:list)sum+=i;
		System.out.println(sum);
		sc.close();
	}
}

外卖店优先级

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。
每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。
如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果 优先级小于等于 3，则会被清除出优先缓存。
给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优先缓存中。
【输入格式】
第一行包含 3 个整数 N、M 和 T。
以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。
【输出格式】
输出一个整数代表答案。
【样例输入】
2 6 6
1 1
5 2
3 1
6 2
2 1
6 2
【样例输出】
1
【样例解释】
6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6，加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
【评测用例规模与约定】
对于 80% 的评测用例，1 ≤ N, M, T ≤ 10000。

【蓝桥杯2018JavaB】日志统计
我看这题和18年JavaB组的 日志统计题目十分相似。所以，提取数据是一样的，然后对数据进行操作。我这里为了获取到T时刻的优先级，创建了一个数组，下标代表时刻，值代表在这个时刻有多少订单。然后代码就很明确去写了。

public class Main{
	static int counts=0;
	public static void main(String[] args) {			
		Scanner sc=new Scanner(System.in);
		int N=sc.nextInt();
		int M=sc.nextInt();
		int T=sc.nextInt();
		Map<Integer,List>map=new HashMap<>();
		for(int i=0;i<M;i++) {
			int value=sc.nextInt();
			int key=sc.nextInt();
			if(map.get(key)==null) {
				List<Integer>list = new ArrayList<>();
				list.add(value);
				map.put(key, list);
			}else {
				map.get(key).add(value);
			}
		}
		Set<Integer>set = map.keySet();
		for(Integer key:set) {
			List<Integer>list =map.get(key);
			int[]times=new int[T+1];
			for(Integer i:list)times[i]++;
			int nowCount=0;//记录优先级
			for(int i=0;i<=T;i++) {
				if(times[i]>0) {
					nowCount+=times[i]*2;
				}else {
					if(nowCount>0)
					nowCount--;
				}
			}
			if(nowCount>=5)counts++;
		}
		System.out.println(counts);
	}
}

然后是别人的代码

public class G外卖店优先级 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		try {
			Set<Integer> set = new HashSet<Integer>();
			int N = input.nextInt(); // N 家外卖店，编�?? 1 �?? N
			int M = input.nextInt(); // 给定 T 时刻以内�?? M 条订单信�??
			int T = input.nextInt();
			int[][] orders = new int[M][2]; // 给定 T 时刻以内�?? M 条订单信�??
			for (int i = 0; i < M; i++) {
				for (int j = 0; j < 2; j++) {
					orders[i][j] = input.nextInt();
				}
			}
 
			int[] priority = new int[N];
			int[] sign = new int[N];
			for (int i = 1; i <= T; i++) {
				for (int j = 0; j < M; j++) {
					if (orders[j][0] == i) {
						priority[orders[j][1] - 1] += 2;
						if (priority[orders[j][1] - 1] > 5 && !set.contains(orders[j][1] - 1)) {
							set.add(orders[j][1] - 1);
						}
						sign[orders[j][1] - 1] = 1;
					}
				}
				for (int j = 0; j < N; j++) {
					if (sign[j] == 0 && priority[j] > 0)
						priority[j]--;
					if (priority[j] <= 3) {
						set.remove(j);
					}
				}
				sign = new int[N];
			}
			System.out.println(set.size());
		} catch (Exception e) {
			input.close();
		}
	}
}