官网的提交指南 2025

JAVA 提交指南 / Hints for JAVA

请注意：提交的 JAVA 代码的类名必须为 Main 且类前不加修饰符。代码中不能包含package语句。我们给出了一份 JAVA 的 A+B 样例程序供参考。 Attention: The class name of JAVA MUST be Main and without any modifier. Do NOT use any package in your code. Here is a piece of correct JAVA code for A+B Problem.

import java.io.BufferedInputStream; 
import java.util.*; 
class Main { 
    public static void main(String[] args) { 
        Scanner in = new Scanner(new BufferedInputStream(System.in)); 
        int a, b; 
        a = in.nextInt(); 
        b = in.nextInt(); 
        System.out.println(a + b); 
    } 
}

模板正文

        由于本人是C++转Java，还不太熟悉，所以整理了一份比较万能的模板壳子，可以节省较多时间，以及避免令人抓耳挠腮的低级bug。希望对有同样需求的同学，能提供一定帮助。

import java.io.*;
import java.util.*;

class Main {
    // 常用的输入方式：Scanner和BufferedReader
    private static Scanner sc;
    private static BufferedReader br;
    
    public static void main(String[] args) throws IOException {
        // 初始化输入流
        initInput();
        
        // 在这里编写你的解题逻辑
        solve();
        
        // 关闭输入流
        closeInput();
    }
    
    // 初始化输入方式
    private static void initInput() {
        // Scanner方式，适用于大多数情况
        sc = new Scanner(new BufferedInputStream(System.in));
        
        // BufferedReader方式，适用于大量输入的情况
        br = new BufferedReader(new InputStreamReader(System.in));
    }
    
    // 关闭输入流
    private static void closeInput() throws IOException {
        if (sc != null) {
            sc.close();
        }
        if (br != null) {
            br.close();
        }
    }
    
    // 解题主方法
    private static void solve() throws IOException {
        // 示例：读取输入并处理
        // 根据具体题目需求修改此处代码
        
        // 使用Scanner读取
        // int n = sc.nextInt();
        // String s = sc.next();
        
        // 使用BufferedReader读取
        // String line = br.readLine();
        // String[] parts = line.split(" ");
        
        // 输出结果
        // System.out.println(result);
    }
    
    // 可以在这里添加一些常用的辅助方法
    // 例如：数组处理、字符串处理、数学计算等
    
    // 读取一行整数并转换为数组
    private static int[] readIntArray() throws IOException {
        String line = br.readLine();
        if (line == null || line.isEmpty()) {
            return new int[0];
        }
        String[] parts = line.split(" ");
        int[] arr = new int[parts.length];
        for (int i = 0; i < parts.length; i++) {
            arr[i] = Integer.parseInt(parts[i]);
        }
        return arr;
    }
    
    // 交换数组中的两个元素
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

简单解释

1. 完全符合 CCF CSP 的提交要求：

   • 类名是 Main
   • 没有任何类修饰符
   • 不包含 package 语句

2. 包含了两种常用的输入方式：

   • Scanner：使用简单，适合大多数情况
   • BufferedReader：读取速度快，适合处理大量输入

3. 结构清晰：

   • 初始化输入流
   • 解题主方法
   • 关闭输入流
   • 常用辅助方法

4. 可扩展性：

   • 可以根据具体题目需求，在 solve () 方法中实现解题逻辑
   • 已包含一些常用辅助方法，如数组处理等
   • 可以根据需要添加更多辅助方法

使用时，只需保留必要的部分，删除不需要的代码即可。对于不同的题目，主要修改 solve () 方法中的逻辑。

附加内容：面向算法竞赛、以 C++ STL/IO 背景为出发点的 Java 学习指南

1. 基础语法对照

功能	C++	Java
主函数入口	int main(){}	public class Main { public static void main(String[] args) { } }
类型	int, long long, double	int, long, double（注意：long=64位，等价 C++ long long）
布尔	bool	boolean
常量	const int N=1e5;	final int N=100000;
没有 struct 里的方法	struct / class	统一用 class（支持方法）
指针/引用	有	无（传参是值传递，但对象是引用语义）

---

2. 输入输出（关键，竞赛 IO 优化）

C++

ios::sync_with_stdio(false);

cin.tie(nullptr);

int n;

cin >> n;

Java

默认 IO 很慢，推荐用 BufferedReader + StringTokenizer 或 FastScanner。

import java.io.*;
import java.util.*;

class Main {
    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = null;
        String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }
        int nextInt() throws IOException { return Integer.parseInt(next()); }
        long nextLong() throws IOException { return Long.parseLong(next()); }
    }

    public static void main(String[] args) throws IOException {
        FastScanner fs = new FastScanner();
        int n = fs.nextInt();
        System.out.println(n);
    }
}

⚡ 相当于 scanf/printf 的速度。

---

3. 常用容器对照表

功能	C++ STL	Java
动态数组	vector<int>	ArrayList<Integer>
栈	stack<int>	Stack<Integer> / ArrayDeque<Integer>
队列	queue<int>	ArrayDeque<Integer> / LinkedList<Integer>
双端队列	deque<int>	ArrayDeque<Integer>
优先队列	priority_queue<int> (默认大根堆)	PriorityQueue<Integer> (默认小根堆)
集合	set<int>	TreeSet<Integer>（有序） / HashSet<Integer>（无序）
映射	map<int,int>	TreeMap<Integer,Integer>（有序） / HashMap<Integer,Integer>（无序）
排序	sort(v.begin(),v.end())	Collections.sort(list) / Arrays.sort(arr)
下标访问	v[i]	list.get(i) / list.set(i,val)

⚠️ Java 的集合泛型必须是对象类型 (Integer)，没有原生泛型数组，性能略逊。

---

4. 常用算法函数

功能	C++ STL	Java
排序	sort(all(v))	Collections.sort(list) / Arrays.sort(arr)
反转	reverse(all(v))	Collections.reverse(list)
最小值	*min_element(all(v))	Collections.min(list)
最大值	*max_element(all(v))	Collections.max(list)
二分查找	lower_bound, upper_bound	Collections.binarySearch(list, x) (需排序)
随机打乱	random_shuffle	Collections.shuffle(list)

---

5. 数组与字符串

• Java 数组固定大小：int[] a = new int[n];

• 字符串：

  • C++: string s;

  • Java: String s;

  • 拼接效率低 → 用 StringBuilder：

    StringBuilder sb = new StringBuilder();
    sb.append("abc");
    System.out.println(sb.toString());
    

---

6. 常见坑点

1. 溢出问题

   • Java int 是 32 位，容易爆，竞赛里常用 long。

   • 没有 unsigned。

2. 数组初始化

   • int[] a = new int[n]; 默认全是 0。

   • Arrays.fill(a, -1); 类似 memset。

3. 比较器写法

   PriorityQueue<int[]> pq = new PriorityQueue<>((x,y)->x[0]-y[0]);
   

   相当于 C++ 自定义 cmp。

4. 时间限制

   • Java 通常比 C++ 慢 2~3 倍。

   • 要极限优化 IO，少用对象，注意常数。

---

7. 竞赛常用模板（Java版）

快速输入输出

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

排序 + 自定义比较

Arrays.sort(arr, (a,b)->a[1]-b[1]);

二分查找

int idx = Arrays.binarySearch(arr, x); // 找不到返回 <0

模运算

final int MOD = 1_000_000_007; long res = (a * b) % MOD;

---

8. 学习路线（针对竞赛）

1. 语法过渡：掌握基本数据类型、类、方法、数组。

2. IO 优化：熟练使用 FastScanner + PrintWriter。

3. 容器对照：理解 ArrayList / HashMap / PriorityQueue 的用法。

4. 算法库迁移：学会 Arrays/Collections 常用方法。

5. 模板化积累：建立常用模板（IO、排序、二分、图、并查集、线段树）。

---

总结：
再集中掌握 Java IO + 容器 + Comparator + 数组/字符串处理，就能在竞赛中切换语言。