2016"百度之星" - 资格赛（Astar Round1）Problem A B C D--java代码

Problem A : 字符串的Hash值
Problem Description
度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到：

度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到：
度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到：

Si​​ 代表 S[i] 字符的 ASCII 码。
请帮助度熊计算大字符串中任意一段的哈希值是多少。

Output
对于每一个询问，输出一个整数值，代表大字符串从 aa 位到 bb 位的子串的哈希值。

Sample Input
Copy
2
ACMlove2015
1 11
8 10
1
testMessage
1 1
Sample Output
6891
9240
88

分析：
本题最直接的思路是直接计算每次的hash值，但是需要对每组String内输入的a和b都需要从a 位置计算到b 位置，系统会显示TLE, 所以，这里需要用到乘法逆元（具体请自行百度）。

java代码如下：

package bestcoder;

import java.util.Scanner;
//
public class HashOfString {
    public int maxLen = 1000001;
    public int inv[] = new int [maxLen];
    public int re[] = new int [maxLen];
    public int allHash[];
    public int mod = 9973;

    public static void main(String args[]) {
        HashOfString m = new HashOfString();
        m.getInput();
    }

    public void getInput() {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()) {
            int T = cin.nextInt();
            String str = cin.next();
            getArray(str);
            for (int i = 1; i <= T; i++) {
                int a = cin.nextInt();
                int b = cin.nextInt();

                int num = getNum(a , b);
                System.out.println(num);
            }
        }
        cin.close();
    }
    public void getArray(String str){
        inv[1]=1;  
        for(int i=2;inew int[str.length() + 1];
        allHash[0] = 1;
        re[0] = 1;
        char[] ch = str.toCharArray();
        for(int i = 0; i < ch.length; i++){
            int num = ch[i];
            allHash[i + 1] = allHash[i] * (num - 28);
            allHash[i+1] %= mod;
            re[i + 1] = inv[allHash[i + 1]];
        }
    }

    public int getNum(int a, int b) {
        return (allHash[b]*re[a-1]) % mod ;
    }
}

Problem B:
Problem Description
度熊面前有一个全是由1构成的字符串，被称为全1序列。你可以合并任意相邻的两个1，从而形成一个新的序列。对于给定的一个全1序列，请计算根据以上方法，可以构成多少种不同的序列。

Input
这里包括多组测试数据，每组测试数据包含一个正整数NN，代表全1序列的长度。

1\leq N \leq 2001≤N≤200

Output
对于每组测试数据，输出一个整数，代表由题目中所给定的全1序列所能形成的新序列的数量。

Sample Input
1
3
5
Sample Output
1
3
8

Hint

如果序列是：(111)。可以构造出如下三个新序列：(111), (21), (12)。

AC 的Java代码如下：

package bestcoder;

import java.math.BigInteger;
import java.util.Scanner;
//斐波那契堆1~200
//由于当N较大时（如N=200时），所得的结果会超过Integer和Long,所以本题求解需要用到BigInteger
public class FibonacciHeap {
    int max = 201;
    BigInteger [] fun = new BigInteger[max];

    public static void main(String args[]) {
        FibonacciHeap m = new FibonacciHeap();
        m.getInput();
    }

    public void getInput() {
        Scanner cin = new Scanner(System.in);
        getSequence();
        while (cin.hasNext()) {
                int N = cin.nextInt();
                if(N >= 1 && N <= 200)
                    System.out.println(fun[N]);
                else 
                    System.out.println();

        }
        cin.close();
    }
    public void getSequence(){
        fun[0] = new BigInteger("1");
        fun[1] = new BigInteger("1");
        for(int i = 2; i < max; i++){
            fun[i] = (fun[i - 1]).add( fun[i - 2]);
        }
    }
}

Problem C: 神奇字典
Problem Description
度熊手上有一本神奇的字典，你可以在它里面做如下三个操作：

1、insert : 往神奇字典中插入一个单词

2、delete: 在神奇字典中删除所有前缀等于给定字符串的单词

3、search: 查询是否在神奇字典中有一个字符串的前缀等于给定的字符串
Input
这里仅有一组测试数据。第一行输入一个正整数N (1\leq N\leq 100000)N(1≤N≤100000)，代表度熊对于字典的操作次数，接下来NN行，每行包含两个字符串，中间中用空格隔开。第一个字符串代表了相关的操作（包括： insert, delete 或者 search）。第二个字符串代表了相关操作后指定的那个字符串，第二个字符串的长度不会超过30。第二个字符串仅由小写字母组成。

Output
对于每一个search 操作，如果在度熊的字典中存在给定的字符串为前缀的单词，则输出Yes 否则输出 No。

Sample Input
5
insert hello
insert hehe
search h
delete he
search hello
Sample Output
Yes
No

AC的java代码：

package bestcoder;

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

//神奇词典
//用TrieTree 来解决本题
public class Main {
    Word root = new Word('@');//总目录，它的子节点为词典所有单词的首字母
    public static void main(String args[]) {
        Main m = new Main();
        m.getInput();
    }

    public void getInput() {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()) {
            int N = cin.nextInt();
            for (int i = 0; i < N; i++) {
                String option = cin.next();//操作，用String来保存
                String str = cin.nextLine();//单词，用String来保存
                Order(option, str);
            }
            break;
        }
        cin.close();
    }

    //根据输入，找到对应的命令：insert,delete,search
    public void Order(String opt, String str) {
        char[] charArray = str.toCharArray();//将单词字符串转化为字符数组
        switch (opt) {
        case "insert": {
            insertTrieTree(charArray);
            break;
        }
        case "delete": {
            delTrieTree(charArray);
            break;
        }
        case "search": {
            searchTrieTree(charArray);
            break;
        }
        default: {
//          System.out.println();
            break;
        }
        }
    }

    //删除操作 delete str:删除以str为前缀的“单词”
    public void delTrieTree(char[] cc) {
        int count = 0;
        Word pa = root;
        if (root.ch.containsKey(cc[0])) {
            Word w = root.ch.get(cc[0]);
            int i = 0;
            for (i = 1; i < cc.length; i++) {
                if (w.ch.containsKey(cc[i])) {
                    pa = w;
                    w = w.ch.get(cc[i]);
                } else
                    break;
            }
            if (i == cc.length) {
                count = w.num;
                pa.ch.remove(cc[i-1]);
                w.ch.clear();

                w = root.ch.get(cc[0]);
                for (i = 1; i < cc.length; i++) {
                        w.num -= count;
                        w = w.ch.get(cc[i]);
                }
            }
        }

    }

    //查找
    public void searchTrieTree(char[] cc) {
        if (root.ch.containsKey(cc[0])) {
            Word w = root.ch.get(cc[0]);
            int i = 0;
            for (i = 1; i < cc.length; i++) {
                if (w.ch.containsKey(cc[i])) {
                    w = w.ch.get(cc[i]);
                } else
                    break;
            }
            if (i == cc.length && w.num > 0)
                System.out.println("Yes");
            else
                System.out.println("No");
        } else
            System.out.println("No");
    }

    //插入
    public void insertTrieTree(char[] cc) {
        if (!root.ch.containsKey(cc[0])) {
            root.ch.put(cc[0], new Word(cc[0]));
        }
        root.ch.get(cc[0]).num++;
        Word w = root.ch.get(cc[0]);
        for (int i = 1; i < cc.length; i++) {
            if (!w.ch.containsKey(cc[i])) {
                w.ch.put(cc[i], new Word(cc[i]));
            }
            w = w.ch.get(cc[i]);
            w.num++;
        }
    }
}

class Word {
    char c;
    int num = 0;
    public Word(char c) {
        this.c = c;
    }
    Map ch = new HashMap();
}

Problem D: 人名统计
Problem Description
度熊所居住的 D 国，是一个完全尊重人权的国度。以至于这个国家的所有人命名自己的名字都非常奇怪。一个人的名字由若干个字符组成，同样的，这些字符的全排列的结果中的每一个字符串，也都是这个人的名字。例如，如果一个人名字是 ACM，那么 AMC， CAM， MAC， MCA， 等也都是这个人的名字。在这个国家中，没有两个名字相同的人。

度熊想统计这个国家的人口数量，请帮助度熊设计一个程序，用来统计每一个人在之前被统计过多少次。

Input
这里包括一组测试数据，第一行包含一个正整数NN，接下来的NN 行代表了 NN 个名字。NN 不会超过100,000100,000，他们的名字不会超过40位.

Output
对于每输入的一个人名，输出一个整数，代表这个人之前被统计了多少次。

Sample Input
5
ACM
MAC
BBA
ACM
BAB
Sample Output
0
1
0
2
1
AC的java代码如下：

package bestcoder;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
//百度之星挑战赛：Problem D: 一个人的名字由若干个字符组成，同样的，这些字符的全排列的结果中的每一个字符串，也都是这个人的名字。
//例如，如果一个人名字是 ACM，那么 AMC， CAM， MAC， MCA， 等也都是这个人的名字
public class SameNamePermutation {

    Map map = new HashMap();;

    public static void main(String args[]) {
        SameNamePermutation m = new SameNamePermutation();
        m.getInput();
    }

    public void getInput() {
        Scanner cin = new Scanner(System.in);
        while (cin.hasNext()) {
            int T = cin.nextInt();
            for (int i = 1; i <= T; i++) {
                String str = cin.next();
                int num = getNum(str);
                System.out.println(num);
            }
        }
        cin.close();
    }

    public int getNum(String str) {
        int num = 0;
        str = insertSort(str);//对字符串进行排序
        if(map.containsKey(str)){
            map.put(str, map.get(str) + 1);
            num = map.get(str);
        }
        else{
            map.put(str,0);
            num = 0;
        }
        return num;
    }
    public String insertSort(String str){
        char[] ch = str.toCharArray();
        /*for(int i = 1; i < ch.length; i++){
            char tmp = ch[i];
            int j = 0;
            for(j = i; j > 0 && tmp < ch[j - 1]; j--){
                ch[j] = ch[j-1];
            }
            ch[j] = tmp;
        }*/
        Arrays.sort(ch);
        String s = Arrays.toString(ch);
        return s;
    }
}