Repeated DNA Sequences

All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, for example: "ACGAATTCCG". When studying DNA, it is sometimes useful to identify repeated sequences within the DNA.

Write a function to find all the 10-letter-long sequences (substrings) that occur more than once in a DNA molecule.

For example,

Given s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT",

Return:
["AAAAACCCCC", "CCCCCAAAAA"].

算法一：

基本思路，从坐向右依次比较。

public class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        HashSet<String>  set = new HashSet<String>(); //set可以除去重复的序列
        for(int i = 0 ; i < s.length() - 20 ; i ++ ){
            String tmp = s.substring(i,i+10);
            if(s.indexOf(tmp,i+10) > -1){//从i+10之后搜索是否存在tmp
                set.add(tmp);
            }
        }
        List<String> list = new ArrayList<String>(set);
        return list;
    }
}

Submission Result: Time Limit Exceeded

No，No，No，，，，，，，，，，，，，，，，，，，

显然String类中的indexOf方法没有使用类似KMP这样的匹配方法，而是使用了暴力破解。

该怎么提高效率呢？

算法二：

使用KMP,BM等匹配算法来提高效率

但是，尽管在一次遍历比较中效率提高了，但是我们依然需要进行n-10次遍历，

这种向后看的缺点就是我们看不到未来，因此需要对每一个可能的10-long-sequence都向后匹配一次，查询它是否是重复的，所以KMP和BM并不是很适合这种情况。

算法三：

前两种算法都是向后看，也就是从左向右进行。

接下来我们换种思路，我们采用向前看的思路。

就是我们检查一个10-long-sequence是否在以前出现过，需要消耗一定空间（如果一个字符一个字节，那么需要O（n2））；我们是否可以减小消耗空间？

注意到整个序列中只有4种字符A,C,G,T.

而且他们各自的ASCII码是

A: 0100 0001　　C: 0100 0011　　G: 0100 0111　　T: 0101 0100

只有后三位不同，而一个int型是32位，所以10-long-sequence只需要一个4个字节就可以存储了。

而将十个字符组成一个整数，才用的是<<和&，如：cur = (cur << 3) | (s.charAt(index) & 0x07)

当要结合第一到十一个字符时，先提取出后27位，再<<3,然后将第十一个字符加到尾部，如：cur = ((cur & 0x07ffffff) << 3) | (s.charAt(index++) & 0x07);

既然要向前看，那么我们就需要保存遍历前的子序列，故需要一个map。

参考自http://www.cnblogs.com/grandyang/p/4284205.html（这是C++版的）

public class Solution {
    public List<String> findRepeatedDnaSequences(String s) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        List<String> list = new ArrayList<String>();
        if(s.length() < 10 ){
            return list;
        }
        int index = 0;
        int cur = 0;//用来存储10-long-sequence
        for( ; index < 9; index ++){//提取出了前九个字符
            cur = (cur << 3) | (s.charAt(index) & 0x07);
        }
        while(index < s.length()){
            cur = ((cur & 0x07ffffff) << 3) | (s.charAt(index++) & 0x07);//提取10-long-sequence的第十个字符；
            if(map.containsKey(cur)){//前面是否存在cur这个序列
                int count = map.get(cur);
                if(count == 1){//cur在前面仅出现了一次
                    list.add(s.substring(index - 10,index));//如果存在说明这个序列出现过，则加入list
                }
                map.put(cur,++count);
            }else{//不存在，则添加一个新的键值对
                map.put(cur,1);
            }
        }
        return list;
    }
}

Runtime: 409 ms

这个题要注意到的是只有四个字符，如果有26个字符呢？显然也就不合适来（7*26bit）

所以又有人提出了将四个字符编码，A ：00； C：01； G：10； T：11

20bit就可以表示10-long-sequence，看着仿佛减少了存储空间，实际上并没有，还是用int来保存（我还是认为上面的算法，至少不用自己管字符和编码之间的转换）

接下来的思路还是向前看的思路。