北大OJ试题笔记 : 1000-1002

近期由于一些需要，在开始刷OJ试题，留下一些做题笔记，也许以后还用得到，使用的语言主要为Java和C，后面可能还会继续更新。

1000：输出a+b:

#include

int main(void)
{
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d", a+b);
    return 0;
}

1001: 高精度幂的计算

Description：对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。 

现在要你解决的问题是：对一个实数R( 0.0 < R < 99.999 )，要求写程序精确计算 R 的 n 次方(Rn)，其中n 是整数并且 0 < n <= 25。
Input：T输入包括多组 R 和 n。 R 的值占第 1 到第 6 列，n 的值占第 8 和第 9 列。
Output：对于每组输入，要求输出一行，该行包含精确的 R 的 n 次方。输出需要去掉前导的 0 后不要的 0 。如果输出是整数，不要输出小数点。

Sample Input：

95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12

Sample Output：

548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

代码如下：

import java.math.BigDecimal;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            // 用BigDecimal来处理超过16位的数，因为Math.pow(a, b)函数，形参和返回值都为double,显然不满足需求。
            BigDecimal R = scanner.nextBigDecimal();//读取R，n
            int n = scanner.nextInt();

            // stripTrailingZeros()函数去掉数字尾部的0
            // 为了去除前导0，将其转换为字符串，利用正则表达式来去掉前导0
            String value = R.pow(n).stripTrailingZeros().toPlainString().replaceFirst("^0*", "");
            System.out.println(value);
        }

        scanner.close();        
    }
}

1002：487-3279. 优化了半天终于AC了

Description：企业喜欢用容易被记住的电话号码。让电话号码容易被记住的一个办法是将它写成一个容易记住的单词或者短语。例如，你需要给滑铁卢大学打电话时，可以拨打TUT-GLOP。有时，只将电话号码中部分数字拼写成单词。当你晚上回到酒店，可以通过拨打310-GINO来向Gino's订一份pizza。让电话号码容易被记住的另一个办法是以一种好记的方式对号码的数字进行分组。通过拨打必胜客的“三个十”号码3-10-10-10，你可以从他们那里订pizza。 
电话号码的标准格式是七位十进制数，并在第三、第四位数字之间有一个连接符。电话拨号盘提供了从字母到数字的映射，映射关系如下： 
A, B, 和C 映射到 2 
D, E, 和F 映射到 3 
G, H, 和I 映射到 4 
J, K, 和L 映射到 5 
M, N, 和O 映射到 6 
P, R, 和S 映射到 7 
T, U, 和V 映射到 8 
W, X, 和Y 映射到 9 

Q和Z没有映射到任何数字，连字符不需要拨号，可以任意添加和删除。 TUT-GLOP的标准格式是888-4567，310-GINO的标准格式是310-4466，3-10-10-10的标准格式是310-1010。 
如果两个号码有相同的标准格式，那么他们就是等同的（相同的拨号） 
你的公司正在为本地的公司编写一个电话号码薄。作为质量控制的一部分，你想要检查是否有两个和多个公司拥有相同的电话号码。 

Input：输入的格式是，第一行是一个正整数，指定电话号码薄中号码的数量（最多100000）。余下的每行是一个电话号码。每个电话号码由数字，大写字母（除了Q和Z）以及连接符组成。每个电话号码中只会刚好有7个数字或者字母。
Output：对于每个出现重复的号码产生一行输出，输出是号码的标准格式紧跟一个空格然后是它的重复次数。如果存在多个重复的号码，则按照号码的字典升序输出。如果输入数据中没有重复的号码，输出一行：No duplicates. 

Sample Input：
12
4873279
ITS-EASY
888-4567
3-10-10-10
888-GLOP
TUT-GLOP
967-11-11
310-GINO
F101010
888-1200
-4-8-7-3-2-7-9-
487-3279

Sample Output：
310-1010 2
487-3279 4
888-4567 3

旧代码：

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Test {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        scanner.useDelimiter("\n");

        Map map = new HashMap();
        map.put('A', '2');
        map.put('B', '2');
        map.put('C', '2');
        map.put('D', '3');
        map.put('E', '3');
        map.put('F', '3');
        map.put('G', '4');
        map.put('H', '4');
        map.put('I', '4');
        map.put('J', '5');
        map.put('K', '5');
        map.put('L', '5');
        map.put('M', '6');
        map.put('N', '6');
        map.put('O', '6');
        map.put('P', '7');
        map.put('R', '7');
        map.put('S', '7');
        map.put('T', '8');
        map.put('U', '8');
        map.put('V', '8');
        map.put('W', '9');
        map.put('X', '9');
        map.put('Y', '9');

        int n = 0;
        List list = new LinkedList();//存储转化后的号码
        Map save = new TreeMap();//存放重复的号码
        char item;
        int j = 0;

        while (scanner.hasNext()) {

            if (j == 0) {
                n = Integer.parseInt(scanner.nextLine());
            }

            if (j == n) {
                break;
            }

            String line = scanner.nextLine();
            line = line.replaceAll("-", "");

            // 转化为数字
            for (int i = 0; i < line.length(); i++) {
                item = line.charAt(i);

                if (map.containsKey(item)) {
                    line = line.replace(item, map.get(item));
                }
            }

            //判断是否重复
            if (list.contains(line)) {
                if (save.containsKey(line)) {
                    save.put(line, save.get(line) + 1);
                } else {
                    save.put(line, 2);
                }
            }

            list.add(line);
            j++;
        }

        scanner.close();

        if (save.isEmpty()) {
            System.out.println("No duplicates.");
        } else {
            for (String kString : save.keySet()) {
                String tmp = kString.substring(0, 3) + "-" + kString.substring(3, 7);
                System.out.println(tmp + " " + save.get(kString));
            }
        }
    }
}

新的代码中，去掉了存储转化后电话号码的List，节省了一部分判断时间和空间，终于通过了，代码应该是还可以优化的，以后有时间继续吧

package Main;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        Map map = new HashMap();
        map.put('A', '2');
        map.put('B', '2');
        map.put('C', '2');
        map.put('D', '3');
        map.put('E', '3');
        map.put('F', '3');
        map.put('G', '4');
        map.put('H', '4');
        map.put('I', '4');
        map.put('J', '5');
        map.put('K', '5');
        map.put('L', '5');
        map.put('M', '6');
        map.put('N', '6');
        map.put('O', '6');
        map.put('P', '7');
        map.put('R', '7');
        map.put('S', '7');
        map.put('T', '8');
        map.put('U', '8');
        map.put('V', '8');
        map.put('W', '9');
        map.put('X', '9');
        map.put('Y', '9');

        int n = 0;
        Map save = new TreeMap();
        char item;

        if (scanner.hasNext()) {
            n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                String line = scanner.next();
                line = line.replaceAll("-", "");

                for (int j = 0; j < line.length(); j++) {
                    item = line.charAt(j);

                    if (!Character.isDigit(item)) {
                        line = line.replace(item, map.get(item));
                    }
                }

                Integer times = save.get(line);
                save.put(line, times == null ? 1 : times + 1);
            }

        }

        scanner.close();
        boolean flag = false;

        for (String kString : save.keySet()) {
            if (save.get(kString) > 1) {
                flag = true;
                System.out.println(kString.substring(0, 3) + "-" + kString.substring(3, 7) + " " + save.get(kString));
            }
        }

        if (!flag) {
            System.out.println("No duplicates.");
        }
    }
}