#G 特殊年份
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
问题描述
今年是 2021 年，2021 这个数字非常特殊，它的千位和十位相等，个位比百位大 1 ，我们称满足这样条件的年份为特殊年份。
输入 5 个年份，请计算这里面有多少个特殊年份。
输入格式
输入 5 行，每行一个 4 位十进制数（数值范围为 1000 至 9999 ），表示一个年份。
输出格式
输出一个整数，表示输入的 5 个年份中有多少个特殊年份。
测试样例1
Input：
2019
2021
1920
2120
9899
Output：
2
Explanation：
2021 和 9899 是特殊年份，其它不是特殊年份。
代码实现
static int sum=0; public static void main(String[] args) { Scanner sc=new Scanner(System.in); for (int i = 0; i < 5; i++) { f(sc.nextInt()); } System.out.println(sum); } public static void f(int x) { if(x%10==x/100%10+1&&x/1000==x/10%10) { sum++; } }
#H 小平方
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
问题描述
小蓝发现，对于一个正整数 n 和一个小于 n 的正整数 v，将 v 平方后对 n 取余可能小于 n 的一半，也可能大于等于 n 的一半。
请问，在 1 到 n − 1 中，有多少个数平方后除以 n 的余数小于 n 的一半。
例如，当 n = 4 时，1 , 2 , 3 的平方除以 4 的余数都小于 4 的一半。
又如，当 n = 5 时，1 , 4 的平方除以 5 的余数都是 1 ，小于 5 的一半。而 2 , 3 的平方除以 5 的余数都是 4 ，大于等于 5 的一半。
输入格式
输入一行包含一个整数 n 。
输出格式
输出一个整数，表示满足条件的数的数量。
测试样例1
Input：
5
Output：
2
评测用例规模与约定
对于所有评测用例，1 ≤ n ≤ 10000 。
代码实现
public static void main(String[] args) { Scanner sc=new Scanner(System.in); int x=sc.nextInt(); int y=x/2; int sum=0; for (int i = 1; i <= x-1; i++) { double a=Math.pow(i, 2)%x; if(a<y) { sum++; } } System.out.println(sum); }
#I 完全平方数
时间限制: 2.0s 内存限制: 512.0MB 本题总分：25 分
问题描述
一个整数 a 是一个完全平方数，是指它是某一个整数的平方，即存在一个整数 b ，使得 a = b^2 。
给定一个正整数 n ，请找到最小的正整数 x ，使得它们的乘积是一个完全平方数。
输入格式
输入一行包含一个正整数 n 。
输出格式
输出找到的最小的正整数 x 。
测试样例1
Input：
12
Output：
3
测试样例2
Input：
15
Output：
15
评测用例规模与约定
对于 30% 的评测用例，1 ≤ n ≤ 1000 ，答案不超过 1000 10001000。
对于 60% 的评测用例，1 ≤ n ≤ 10^8 ，答案不超过 10^8。
对于所有评测用例，1 ≤ n ≤ 1 0^12 ，答案不超过 10^12。
代码实现
public static void main(String[] args) { Scanner sc=new Scanner(System.in); int n=sc.nextInt(); int a=1; while(true) { String str=String.valueOf(Math.sqrt(n*a)); int x=str.indexOf("."); int b=Integer.parseInt(String.valueOf(str.charAt(x+1))); if(b==0&&str.length()-x-1==1) { System.out.println(a); return; } a++; } }
#J 负载均衡
时间限制: 2.0s 内存限制: 512.0MB 本题总分: 25 分
问题描述
有 n 台计算机，第i台计算机的运算能力为 。
有一系列的任务被指派到各个计算机上，第 i 个任务在 时刻分配，指定计算机编号为 ，耗时为 且算力消耗为 。如果此任务成功分配，将立刻开始运行，期间持续占用 号计算机 的算力，持续 秒。对于每次任务分配，如果计算机剩余的运算能力不足则输出 −1，并取消这次分配，否则输出分配完这个任务后这台计算机的剩余运算能力。
输入格式
输入的第一行包含两个整数 n,m，分别表示计算机数目和要分配的任务数。
第二行包含 n 个整数 ,,···，分别表示每个计算机的运算能力。
接下来 m 行每行 4 个整数 意义如上所述。数据保证 严格递增，即 。
输出格式
输出 m 行，每行包含一个数，对应每次任务分配的结果。
测试数据
Input：
2 6
5 5
1 1 5 3
2 2 2 6
3 1 2 3
4 1 6 1
5 1 3 3
6 1 3 4
Output：
2
-1
-1
1
-1
0
没有完全解出来，但是已经能过几个数据了，多少有一些提示作用。
代码实现 (有个bug没修，但是给的测试用例没问题)
//存储任务的总信息 static Map<Integer, List<Integer>> map=new HashMap<>(); //存储每个任务的时间 static List<Integer> times=new ArrayList<>(); //存储每个任务所消耗的空间 static List<Integer> kj=new ArrayList<>(); public static void main(String[] args) { Scanner sc=new Scanner(System.in); int n=sc.nextInt();//电脑的数量 int m=sc.nextInt();//任务数 for (int i =1 ; i < n+1; i++) { map.putIfAbsent(i, new ArrayList<>()); map.get(i).add(sc.nextInt()); } for (int i = 1; i < m+1; i++) { int a=sc.nextInt();//读取任务编号 int b=sc.nextInt();//读取电脑编号 int c=sc.nextInt();//读取时间消耗 int d=sc.nextInt();//读取空间消耗 //时间消耗随着任务的增长而减小 for (Integer item:map.keySet()) { if(map.get(item).size()==5) { for (int j = 0; j < times.size(); j++) { int y=times.get(j)-1; if(y==0) { int x=map.get(item).get(0); map.get(item).set(0,x+kj.remove(j)); times.remove(j); }else { times.set(j, y); } } } } //初始化电脑的任务 if(map.get(b).get(0)>d&&map.get(b).size()<5) { map.get(b).add(a); map.get(b).add(b); map.get(b).add(c); map.get(b).add(d); // times.add(c); // kj.add(d); } //判断任务的消耗是否超出电脑本身的消耗 if(map.get(b).get(0)-d<0) { System.out.println(-1); continue; }else { //未超出电脑消耗的话则为任务分配空间 int x=map.get(b).get(0)-d; times.add(c); kj.add(d); System.out.println(x); map.get(b).set(0,x); } } }
照搬网上的，话说按照网上的这个方法，我是很懵逼的。
import java.io.IOException; import java.io.InputStream; import java.io.PrintWriter; import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.StringTokenizer; import java.util.PriorityQueue; import java.util.Queue; public class Main { public static void main(String[] args) { InputReader in = new InputReader(System.in); PrintWriter out = new PrintWriter(System.out); Queue<Item> queue = new PriorityQueue(); int n = in.nextInt(), m = in.nextInt(); int[] comp = new int[n + 1]; int a, b, c, d, time = 1; for (int i = 1; i <= n; i++) comp[i] = in.nextInt(); for (int i = 0; i < m; i++) { a = in.nextInt(); b = in.nextInt(); c = in.nextInt(); d = in.nextInt(); if (a > time) time = a; while (queue.size() > 0) { Item item = queue.peek(); if (item.time > time) break; comp[item.idx] += item.val; queue.remove(); } if (comp[b] >= d) { queue.add(new Item(b, d, time + c)); out.println(comp[b] -= d); } else out.println("-1"); } out.flush(); } static class Item implements Comparable<Item> { int time, idx, val; Item(int idx, int val, int time) { this.time = time; this.idx = idx; this.val = val; } @Override public int compareTo(Item o) { return this.time - o.time; } } static class InputReader { BufferedReader read; StringTokenizer token; String delimiters; InputReader (InputStream in) { this(in, " \t\n\r\f"); } InputReader (InputStream in, String delimiters) { this.read = new BufferedReader(new InputStreamReader(in)); this.token = new StringTokenizer("", this.delimiters = delimiters); } String next() { while (!token.hasMoreTokens()) try { token = new StringTokenizer(read.readLine(), delimiters); } catch (IOException e) { e.printStackTrace(); } return token.nextToken(); } int nextInt() { return Integer.parseInt(next()); } } }
