今天做了一道中等難度的字符串題目,這道題目花了我兩個小時,不過也做了不少的思考,寫篇日志記錄一下我的思考過程。
首先是題目內容:
<h4>題目</h4>
給出一個字符串數組S,找到其中所有的亂序字符串(Anagram)。如果一個字符串是亂序字符串,那么他存在一個字母集合相同,但順序不同的字符串也在S中。
<h4>樣例</h4>
對于字符串數組 ["lint","intl","inlt","code"]
返回 ["lint","inlt","intl"]
<h4>注意</h4>
所有的字符串都只包含小寫字母
我一開始的想法很簡單,先寫一個算法判斷兩個字符串是否為亂序字符串,再遍歷整個數組S,找出所有的亂序字符串。判斷亂序字符串的方法就是把一個字符串放入HashMap當中,使用HashMap<Character, int>記錄字符串,如果有重復的字符就把map的value值++,再遍歷第二個字符串和第一個生成出來的map,遇到相同的就把HashMap對應char的value減1,減為0就remove掉這個key。
具體是這樣的
public boolean compareStrings(String A, String B) {
CompareString cs = new CompareString();
if(B.length() > A.length())
return false;
Map<Character,Integer> aMap = cs.StringToMap(A);
//Map<Character,Integer> bMap = cs.StringToMap(B);
for(int i = 0; i < B.length(); i++){
char b = B.charAt(i);
if (aMap.containsKey(b)){
if(aMap.get(b) > 1){
int times = aMap.get(b)-1;
aMap.put(b, times);
}else
aMap.remove(b);
}else
return false;
}
return true;
}
public Map<Character,Integer> StringToMap(String S){
Map<Character,Integer> sMap = new HashMap<Character,Integer>();
for(int i = 0; i < S.length();i++){
char a = S.charAt(i);
if(sMap.containsKey(a)){
int times = sMap.get(a)+1;
sMap.put(a, times);
}else
sMap.put(a, 1);
}
return sMap;
}
不過這樣的想法雖然可行,但是算法復雜度卻有O(n2)那么高!因為要把整個數組S里面的String兩兩比較一遍,我覺得這太蠢了,一定有更加簡單易行的方法。
于是,必須轉換思路。
我想到,如果ASCII碼來判斷兩個字符串是否為亂序字符串呢?就好像MD5算法一樣,我最后只需要給每一個亂序字符串算出一個特定的數字,用這個數字作為key,把所有等于這個key的字符串放入一個list中,把這個list作為value,用這樣的<key, value>組成HashMap,這樣我只需要便利一遍字符串數組S,再遍歷一遍生成的HashMap,把Map中value的list長度大于1的都放到return list中作為該程序的返回值,問題不就引刃而解了嗎!這樣算法復雜度只有O(n),等于用空間換時間了,可行!
于是寫出了這樣的算法
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class disOrderString {
/**
* @param strs: A list of strings
* @return: A list of strings
*/
public List<String> anagrams(String[] strs) {
List<String> disOrderList = new ArrayList<String>();
Map<Long,List<String>> anagram = new HashMap<Long,List<String>>();
disOrderString ds = new disOrderString();
for(int i = 0; i< strs.length;i++){
String str = strs[i];
long strAscii = ds.stringToAscii(str);
System.out.println(strAscii + ":" + str);
if(anagram.containsKey(strAscii)){
anagram.get(strAscii).add(str);
}else{
List<String> strString = new ArrayList<String>();
strString.add(str);
anagram.put(strAscii, strString);
}
}
Iterator iter = anagram.entrySet().iterator();
while(iter.hasNext()){
Map.Entry entry = (Map.Entry) iter.next();
List<String> list = (List<String>) entry.getValue();
if(list.size() > 1)
disOrderList.addAll(list);
}
return disOrderList;
}
//it's unique
public long stringToAscii(String target){
long asciiSum = 0;
int length = target.length();
for(int i = 0;i<target.length();i++){
asciiSum += Math.pow(target.charAt(i) - 'a' + 1,7);
}
if(length == 0)
return 0;
return (long) (asciiSum*asciiSum/length);
}
public static void main(String args[]){
disOrderString ds = new disOrderString();
String[] strs = {"coroners","crooners","deed","ed","gums","mugs","per","potties","rep","sanity","satiny","smug","tiptoes"};
List ret = ds.anagrams(strs);
for(int i = 0; i < ret.size();i++){
System.out.println(ret.get(i));
}
}
}
其中,stringToAscii(String target) 里的加權算法我調整了很多次,最后決定使用7次方,因為7是一個出現頻率相對低的質數,而最后返回加權后的ascii碼的平方與長度的比值,將字符串長度也考慮到其中,減少誤差。最終通過了lintCode 的測試,不過我覺得這個算法依然有改進的空間,當數組足夠復雜的情況下,可能依然有誤算的情況出現。
7次方的計算是一個非常耗費時間的計算,而樓下評論中有人給出了更簡化的算法,思路非常簡單,但我當時一門心思鉆進了計算hash數值的死胡同里……
他的思路也是認為每一組亂序字符串都有唯一的相同的“ Hash 值 ”,但是這個值不局限于數值,而是數字和字母的結合,比如 "and" 和 "dan",他們的“ Hash 值 ”就是“a1d1n1","array" 和 "yarar" 就是 a2r2y1,這樣就確保了唯一性,算法效率也很高。
代碼如下
public ArrayList<String> anagrams(String[] strs) {
HashMap<String, ArrayList<String>> hash = new HashMap<String, ArrayList<String>>();
for (String str : strs) {
// create unique label for each string
String key = generalLabel(str);
// map the label to a list of anagrams
ArrayList<String> res = hash.get(key);
if (res==null) {
res = new ArrayList<String>();
hash.put(key, res);
}
res.add(str);
}
ArrayList<String> resSet = new ArrayList<String>();
for (ArrayList<String> anagram : hash.values()) {
// ignore strings without anagrams
if (anagram.size()>1) resSet.addAll(anagram);
}
return resSet;
}
/*
* create a unique label for a string
* "cat", "atc" => a1c1t1
*/
public String generalLabel(String str) {
int[] hash = new int[26];
for (int i=0; i<str.length(); ++i) {
int index = (int)(str.charAt(i) - 'a');
hash[index]++;
}
StringBuilder ss = new StringBuilder();
for (int i=0; i<26; ++i) {
if (hash[i]==0) continue;
char c = (char)('a' + i);
ss.append(c);
ss.append(hash[i]);
}
return ss.toString();
}