• ACM中使用 JAVA v2. 1

    ACM中使用JAVA v2.1

                                                                         严明超

                                                      (Blog:mingchaoyan.blogbus.com

                                                      Email:mingchaoyan@gmail.com)

    0.前 言

       

     文前声明：本文只谈java用于acm，且不推荐大家把java作为自己的第一语言玩acm； 

    为防止大家过多的把本应学习算法的宝贵时间浪费在学习语言上，同时也为实现lcy一队一java的要求；我根据自己用java的经验，总结成文，希望可以抛砖引玉，帮助大家快速学会用java ac；

    Java对熟悉c/c++的选手来说应该是似曾相识的，因为它本身就是用相似c/c++结构设计的。一些安装jdk，配置环境变量，以Main做类名等等这些我就不多说了。IDE推荐使用Eclipse，你可以在这里下载。Eclipse是个平台，所以你也可以装个插件来跑c/c++，插件怎么装可以看看这里（正规比赛一般都有Eclipse，没vs，因为vs是windows下的，正规比赛肯定不会用windows,为什么，你懂的）；

    说了点无关的话，进入正题，在这里你将看到以下内容：1，输入输入，2.，大数/高精度，3，排序，4“STL”,5,其他

    1. 输入输出

    1.1 Scanner

        输入首推Scanner，输出首推System.out.pritnln()/System.out.print();

    这个学过java的一般都知道怎么用，先以标准输入为参数new 一个Scanner，如果要读入一个int，就用nextInt(),double 就用nextDouble，其他类型依次类推，另外可以用hasNextInt来判断是否还有下一个。至于读入以字符串用next(),读入一行用nextLine();

    附上A+B代码

    [c-sharp] view plaincopy
    1. import java.io.*;  
    2. import java.util.*;  
    3. public class Main {  
    4.         public static void main(String args[]) {  
    5.                 Scanner cin = new Scanner(System.in);  
    6.                 int a, b;  
    7.                 while (cin.hasNextInt()) {  
    8.                         a = cin.nextInt();  
    9.                         b = cin.nextInt();  
    10.                         System.out.println(a + b);  
    11.                 }  
    12.         }  
    13. }  
    1.2 StreamTokenizer和PrintWriter

        但是用Scanner输入就像cin那样比较慢，当数据量一大会超时的，我记得有一个题目（忘了具体哪个题目），很直白的bfs就会超时，不排除你有很强的剪枝（虽然这样的情况的确很少，一般Scanner用用足够了），此时不得不用StreamTokenizer   和  PrintWriter ，请看看注释(这里格式比较乱，推荐大家把他copy到Eclipse下 ctrl+Shift + f （格式化代码）了再读)：

    [c-sharp] view plaincopy
    1. import java.io.*;  
    2.   
    3. public class Main {  
    4.         public static void main(String[] args) throws IOException  
    5.                 // in.nextTokenizer可能抛出这个异常  
    6.         {  
    7.                 StreamTokenizer in = new StreamTokenizer(new BufferedReader(  
    8.                                         new InputStreamReader(System.in)));  
    9.                 // 这句是io流包装来包装去，记住就好；  
    10.                 PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));  
    11.                 int a, b;  
    12.                 while (in.nextToken() != StreamTokenizer.TT_EOF)  
    13.                         // 用in.nextToken()读下一个标记，StreamTokenizer.TT_EOF这个是个参数，就是EOF  
    14.                 {  
    15.                         a = (int) in.nval;  
    16.                         // 读进来的是double型的，所以要转成int  
    17.                         in.nextToken();  
    18.                         // 读入b值（a的值是在while循环中读入的）  
    19.                         b = (int) in.nval;  
    20.                         out.println(a + b);  
    21.                 }  
    22.                 out.flush();  
    23.                 // 刷新缓冲区，必须的，不然a+b会留在缓冲区  
    24.         }  
    25. }  

    一般也用不到PrintWriter ，除非像这个输出结果数据量很大，那用PrintWriter就会快很多了；

    另外对于输入，jdk 5.0以后可以用System.out.printf()这个格式化输出了，你可以把它和printf联系起来，类似的，比如输出小数点后3位System.out.printlnf("%.f%n",a);注意引号中的%n，这个是表示与平台无关的换行，如果一定要用那个我们熟悉的/n，那就请在加一个/r，用/n/r,不然PE，搞不好还WA。。。这个问题是很著名的不同平台回车和换行的尴尬，我就不多解释了；

    1.3 文件

    还有一个问题，测试文件的输入输出。就像用C++时，只要简单的在main下添加两个freopen，java中也有类似的方法；

    [c-sharp] view plaincopy
    1. FileInputStreamfin=newFileInputStream("/home/JCrzer/workspace/ACM/in.txt");   
    2.   
    3. PrintStreamfout=newPrintStream("/home/JCrazer/workspace/ACM/out.txt");  
    4.   
    5. System.setIn(fin);  
    6.   
    7. System.setOut(fout);  

    Windows要不"/"改成"//"，或者索性改成"/",你懂的。。。。

    2 大数/高精度

    用java写acm应该就是冲着这个来的吧^_^，java中有两个类BigDecimal 和 BigInteger。看名字就知道他们的区别了

    2.1 大数

    以下是hdoj1002代码，很直白的，不多解释；

    [c-sharp] view plaincopy
    1. import java.math.*;  
    2. import java.util.*;  
    3. public class Main {  
    4.         public static void main(String[] args) {  
    5.                 Scanner in = new Scanner(System.in);  
    6.                 int t = in.nextInt();  
    7.                 for (int i = 1; i <= t; ++i) {  
    8.                         if (i != 1)  
    9.                                 System.out.println();  
    10.                         BigInteger a = in.nextBigInteger();  
    11.                         BigInteger b = in.nextBigInteger();  
    12.                         System.out.println("Case " + i + ":");  
    13.                         System.out.println(a + " + " + b + " = " + a.add(b));  
    14.                 }  
    15.         }  
    16. }  

    2.2 高精度

    来看hdoj1753

    [c-sharp] view plaincopy
    1. import java.math.BigDecimal;  
    2. import java.util.Scanner;  
    3. public class Main {  
    4.         public static void main(String[] args) {  
    5.                 Scanner in = new Scanner(System.in);  
    6.                 BigDecimal a, b;  
    7.                 while (in.hasNext()) {  
    8.                         a = in.nextBigDecimal();  
    9.                         b = in.nextBigDecimal();  
    10.                         System.out.println(a.add(b).stripTrailingZeros().toPlainString());  
    11.                 }  
    12.         }  
    13. }  

    因为高精度加法结果的精度是取两个加数中较大的那个，所以可能会出现后置0，这时就要通过stripTrailingZeros()把后置0去掉，又因为，BigDecimal的toString()方法可能返回的是科学技术法表示的，所以要用toPlainString()转成普遍计数法；

    关于大数高精度其实还有很多问题，比如初始化构造，精度，比如舍入等等，这些零零碎碎的东西太多了，都举个例子写下会累死我的，我也不想把api中的内容copy来贴在这里充字数，所以建议平时多查查api（在这里查，中文版），还有有什么需要留言吧~；

    3排序

    大数可能之前大家也敲过，排序可能是大家陌生的，因为java写排序和c/c++差别有点大；

    最简单的排序Arrays.sort(a)，默认是按数组a从小到大排序的,如果是String就按字典序，而且对指定范围的排序也已经有重载版本sort(Object[] a, int fromIndex, int toIndex) 其中和c++中类似，此方法排序时，范围包括fromIndex,,不包括toIndex。但只是这种单一的排序方式显然不能满足我们变幻莫测排序要求。排序有两种方法：

    3.1 实现Comparable接口

    这个比较常用，就是在设计Node这个类时（java中没有struct关键词，都要用class代替），实现Comparable这个接口，重写其compareTo这个方法，在这个方法中规定你要的排序顺序。如此在接下来的对Node实例数组排序时，就是按照你定义的排序顺序来排的；比如：

    [c-sharp] view plaincopy
    1. import java.util.Arrays;  
    2. class Node implements Comparable {  
    3.         int a;  
    4.         Node(int a) {  
    5.                 this.a = a;  
    6.         }  
    7.         @Override  
    8.                 public int compareTo(Object arg0) {  
    9.                         int a = ((Node) arg0).a;  
    10.                         if (this.a < a)  
    11.                                 return -1;  
    12.                         else if (this.a > a)  
    13.                                 return 1;  
    14.                         return 0;  
    15.                         //熟练了就可以犀利的写成 return this.a-a; 但下文都用以上“规范清晰”的写法  
    16.                 }  
    17.         @Override  
    18.                 public String toString() {  
    19.                         return "" + a;  
    20.                 }  
    21. }  
    22. public class Main {  
    23.         public static void main(String[] args) {  
    24.                 Node[] node = new Node[4];  
    25.                 node[0] = new Node(9);  
    26.                 node[1] = new Node(8);  
    27.                 node[2] = new Node(100);  
    28.                 node[3] = new Node(0);  
    29.                 Arrays.sort(node);  
    30.                 System.out.println(Arrays.toString(node));  
    31.         }  
    32. }  

    运行结果：

    [0, 8, 9, 100]

    说明3点：

    1.在Node类中的toString是只是我为了打印运行结果而重写的，与排序无关；

    2.Node有多个属性时，当然可以根据需要二级排序，三级排序等等；

    3.这样设计Node之后只能按照你定义的排序了，如果对一个Node要用不同的标准排序，请看下面：

    3.2 使用Comparator比较器

         使用Comparator就不像上面那样比较死板了，你可以设计Cmp1，Cmp2来满足你不同标准排序的要求

    比如下面是我随便举的例子，标准1：对人员先按照名字升序，如果名字相同按照年龄升序 ，标准2：先对年龄升序，如果年龄相同就按姓名升序

    [c-sharp] view plaincopy
    1. import java.util.Arrays;  
    2. import java.util.Comparator;  
    3. class Person {  
    4.         private String name;  
    5.         private int age;  
    6.         public Person(String name, int age) {  
    7.                 this.name = name;  
    8.                 this.age = age;  
    9.         }  
    10.         public String getName() {  
    11.                 return this.name;  
    12.         }  
    13.         public int getAge() {  
    14.                 return this.age;  
    15.         }  
    16.         @Override  
    17.                 public String toString() {  
    18.                         // TODO Auto-generated method stub  
    19.                         return "" + this.name + " " + this.age;  
    20.                 }  
    21. }  
    22. class Cmp1 implements Comparator {  
    23.         @Override  
    24.                 public int compare(Object arg0, Object arg1) {  
    25.                         Person a = (Person) arg0;  
    26.                         Person b = (Person) arg1;  
    27.                         if (a.getName().compareTo(b.getName()) != 0)  
    28.                                 return a.getName().compareTo(b.getName());  
    29.                         else {  
    30.                                 if (a.getAge() < b.getAge())  
    31.                                         return -1;  
    32.                                 else if (a.getAge() > b.getAge())  
    33.                                         return 1;  
    34.                                 else  
    35.                                         return 0;  
    36.                         }  
    37.                 }  
    38. }  
    39. class Cmp2 implements Comparator {  
    40.         @Override  
    41.                 public int compare(Object arg0, Object arg1) {  
    42.                         Person a = (Person) arg0;  
    43.                         Person b = (Person) arg1;  
    44.                         if (a.getAge() < b.getAge())  
    45.                                 return -1;  
    46.                         else if (a.getAge() > b.getAge())  
    47.                                 return 1;  
    48.                         else  
    49.                                 return a.getName().compareTo(b.getName());  
    50.                 }  
    51. }  
    52. public class Main {  
    53.         public static void main(String[] args) {  
    54.                 Person[] p = new Person[4];  
    55.                 p[0] = new Person("ZZZ", 19);  
    56.                 p[1] = new Person("AAA", 109);  
    57.                 p[2] = new Person("AAA", 19);  
    58.                 p[3] = new Person("YYY", 100);  
    59.                 Arrays.sort(p, new Cmp1());  
    60.                 System.out.println("Cmp1");  
    61.                 System.out.println(Arrays.toString(p));  
    62.                 Arrays.sort(p, new Cmp2());  
    63.                 System.out.println("Cmp2");  
    64.                 System.out.println(Arrays.toString(p));  
    65.         }  
    66. }  

    运行结果；

    Cmp1

    [AAA 19, AAA 109, YYY 100, ZZZ 19]

    Cmp2

    [AAA 19, ZZZ 19, YYY 100, AAA 109]

     

    这种方法在CMP这个类设计好后，要排序时直接在Arrays.sort()中new一个CMP实例就好了，是不是很像c++中sort,或者qsort。由于这个类只在排序时使用，所以也可以设计成匿名内部类（只对Cmp1举例），代码如下；

    [c-sharp] view plaincopy
    1. import java.util.Arrays;  
    2. import java.util.Comparator;  
    3. class Person {  
    4.         private String name;  
    5.         private int age;  
    6.         public Person(String name, int age) {  
    7.                 this.name = name;  
    8.                 this.age = age;  
    9.         }  
    10.         public String getName() {  
    11.                 return this.name;  
    12.         }  
    13.         public int getAge() {  
    14.                 return this.age;  
    15.         }  
    16.         @Override  
    17.                 public String toString() {  
    18.                         return "" + this.name + " " + this.age;  
    19.                 }  
    20. }  
    21. public class Main {  
    22.         public static void main(String[] args) {  
    23.                 Person[] p = new Person[4];  
    24.                 p[0] = new Person("ZZZ", 19);  
    25.                 p[1] = new Person("AAA", 109);  
    26.                 p[2] = new Person("AAA", 19);  
    27.                 p[3] = new Person("YYY", 100);  
    28.                 Arrays.sort(p, new Comparator<Object>() {  
    29.                         @Override  
    30.                         public int compare(Object arg0, Object arg1) {  
    31.                                 Person a = (Person) arg0;  
    32.                                 Person b = (Person) arg1;  
    33.                                 if (a.getName().compareTo(b.getName()) != 0)  
    34.                         return a.getName().compareTo(b.getName());  
    35.                                 else {  
    36.                                         if (a.getAge() < b.getAge())  
    37.                         return -1;  
    38.                                         else if (a.getAge() > b.getAge())  
    39.                         return 1;  
    40.                                         else  
    41.                         return 0;  
    42.                                 }  
    43.                         }  
    44.                 });  
    45.                 System.out.println(Arrays.toString(p));  
    46.         }  
    47. }  

    匿名内部类是没有名字的内部类，你可以理解我把CMP这个类设计在了Arrays.sort()这个方法的参数中。你若java中这种机制不是很理解，就用前面那种吧。

    4 “STL”

    之所以对STL加引号，是因为JAVA中似乎不叫标准模板库，不过这个只是称呼，你知道我是在说这个就好了。很多前辈都提出了“STL伤代码能力论”我只是把它对应C++的那些列出来，用不用你看着办吧：

    4.1 Sting 和StringBuffer

    关于String我只想说这个是常量，创建了以后永远不会变的，想要变就用StringBuffer；这个有很多意想不到的方法，比如split方法可以根据给定的字符拆分字符串，方便吧，自己处理会麻烦死的还容易出错，再比如这两个都支持正则，正则的强大不需要我解释，另外还有很多，查api去吧~~~

    4.2 List接口

    就是表，可以用LinkedList类（可以理解链表实现所以增删比较快），ArrayList类（理解为数组实现访问比较快），当然还有大家很熟悉的Vector类；

    创建 List ll = new LinkedList（）；（你也可以LinkedList  ll = new LinkedList（）；但推荐使用前者，因为在创建对象是，使用接口的引用指向对象是一个好习惯~）

    方法： add(e), get(int index), clear(),isEmpty(),size()。。。（方法太多了，C++中实现的方法JAVA中差不多都有增无减地实现了，真的不想一一列出来，还是那句话，查api吧，真不行就留言）

    JAVA集合框架中很多方法都是通用的，下面的有些方法就不再列举了；

    4.3 Map接口

    映射，有Hashtable类（Hashtable的同步版本），LinkedHashMap类（按元素插入顺序排序），HashMap类（比较常用），TreeMap类（按元素的自然顺序排序，这个的存储方式是传说中的红黑树~）可以实现；使用put方法添加元素，get（key）方法获得对应key的值，containsKey（key）方法判断是否已经存在此映射；

    4.4  Set接口

    集合，有HashSet类（没有排序），LinkedHashSet类（按插入顺序排序），TreeSet类（按自然序排序）可以实现；

    4.5 Queue 接口

    队列，用实现List的那些类实现好了，offer方法入队，poll方法取队头并扔掉头（若不想扔掉用peek方法）；

    4.6 PriorityQueue 类

    优先队列，注意这个是类，所以创建时一定要PriorityQueue qp = new PriotityQueue();方法和Queue类似；

    4.7 Stack类

    栈，注意这个也是类，push压入栈，poll取栈顶并扔掉（同样peek取顶不扔掉）；

     

    最后举一个例子吧HDOJ1873（这个例子可以看到这些“玩具”的数组怎么创建）

     

    [c-sharp] view plaincopy
    1. import java.io.*;  
    2. import java.util.PriorityQueue;  
    3. public class Main {  
    4.         public static class Patient implements Comparable {  
    5.                 int id, priority;  
    6.                 public Patient(int id, int priority) {  
    7.                         this.id = id;  
    8.                         this.priority = priority;  
    9.                 }  
    10.                 @Override  
    11.                         public int compareTo(Object arg0) {  
    12.                                 // 设置病人的优先级  
    13.                                 int priority = ((Patient) arg0).priority;  
    14.                                 int id = ((Patient) arg0).id;  
    15.                                 if (this.priority > priority)  
    16.                                         return -1;  
    17.                                 else if (this.priority < priority)  
    18.                                         return 1;  
    19.                                 else  
    20.                                         return this.id - id;  
    21.                         }  
    22.         }  
    23.         public static void main(String[] args) throws IOException {  
    24.                 StreamTokenizer in = new StreamTokenizer(new BufferedReader(  
    25.                                         new InputStreamReader(System.in)));  
    26.                 while (in.nextToken() != StreamTokenizer.TT_EOF) {  
    27.                         int n = (int) in.nval;  
    28.                         int id = 1;  
    29.                         PriorityQueue<Patient>[] pq = new PriorityQueue[3];  
    30.                         // PriorityQueue<Patient> 泛型，new PriorityQueue[3]后面就不要加<Patient>了  
    31.                         for (int i = 0; i < 3; ++i) {  
    32.                                 pq[i] = new PriorityQueue<Patient>();  
    33.                         }  
    34.                         for (int i = 0; i < n; ++i) {  
    35.                                 in.nextToken();  
    36.                                 String flag = in.sval;  
    37.                                 if (flag.equals("OUT")) {  
    38.                                         // String的等值比较，不要用==呀！！！！！！！！  
    39.                                         in.nextToken();  
    40.                                         int doctor = (int) in.nval;  
    41.                                         if (pq[doctor - 1].isEmpty())  
    42.                                                 // 是否为空  
    43.                                                 System.out.println("EMPTY");  
    44.                                         else  
    45.                                                 System.out.println(pq[doctor - 1].poll().id);  
    46.                                         // 取队头并扔掉  
    47.                                 } else {  
    48.                                         in.nextToken();  
    49.                                         int doctor = (int) in.nval;  
    50.                                         in.nextToken();  
    51.                                         int priority = (int) in.nval;  
    52.                                         pq[doctor - 1].offer(new Patient(id++, priority));  
    53.                                 }  
    54.                         }  
    55.                 }  
    56.         }  
    57. }  

    5 其他

    想不好再写什么，看大家需要吧~

    关于传值问题：

    Java中对象（强调8种基本数据类型除外）一定是引用传递的，所以当你不需要引用传递时，就拷贝一份副本传进去，当然拷贝可以用clone(),具体写法看以下例子：

    [c-sharp] view plaincopy
    1. public class Main {  
    2.         public static class Point implements Cloneable{  
    3.                 int x, y;  
    4.                 public Point(int x, int y) {  
    5.                         this.x = x;  
    6.                         this.y = y;  
    7.                 }  
    8.                 @Override  
    9.                         protected Object clone() throws CloneNotSupportedException {  
    10.                                 return super.clone();  
    11.                         }  
    12.                 @Override  
    13.                         public String toString() {  
    14.                                 return "("+x+","+y+")";  
    15.                         }  
    16.         }  
    17.         static void fun(Point p) {  
    18.                 p.x += 1;  
    19.                 p.y += 1;  
    20.         }  
    21.         public static void main(String[] args) throws CloneNotSupportedException {  
    22.                 Point p1 = new Point(9,8);  
    23.                 System.out.print("p1:");  
    24.                 System.out.println(p1);  
    25.                 //p2 is a copy of p1  
    26.                 Point p2 = (Point) p1.clone();  
    27.                 fun(p2);  
    28.                 System.out.print("yeah~ if you convert p1's clone, p1 won't change");  
    29.                 System.out.println(p1);  
    30.                 System.out.print("if you convert p1 directly, p1 will change in main()");  
    31.                 fun(p1);  
    32.                 System.out.println(p1);  
    33.         }  
    34. }  

    6后记

    本文给出一些用java做acm的基本用法，一般不是“纯java选手”，学会上面这些应付应付比赛中“突如其来”的大数高精度之类java有明显优势的题目足够了。但是不要迷恋java，java只是一种语言，语言是规则，算法是思想；
  • 相关阅读:
    转　[Lucene.Net] 基本用法
    万商网与Alibaba等的比较
    B2B闯入者 新势力正在崛起
    项目管理随想一
    【转载】/proc目录中的重要信息
    文件名乱码转换器
    C函数调用中对入参取地址引发的问题
    编译通过的代码不算什么，一眼能看懂的代码才算好代码
    Handler使用
    删除system/app下的apk
  • 原文地址：https://www.cnblogs.com/gaoxiangde/p/4379892.html
Copyright © 2020-2023  润新知