字符串题目
2018-01-24 20:19:48
- 重复字符串匹配
问题描述：
问题求解：
使用brute force的方法求解，也就是依次比较，但是差别就是在A到末尾的时候循环从头开始继续进行比较。
public int repeatedStringMatch(String A, String B) {
for (int i = 0,j; i < A.length(); i++) {
for (j = 0; j < B.length() && B.charAt(j) == A.charAt((i+j) % A.length()); j++);
// i就是A中前面失配的个数，j.length = 部分1 + n * A.length + 部分2
// i + j = i + 部分1 + n * A.length + 部分2 =(n + 1)* A.length + 部分2
// 所以其实就是一个向上取整
if(j == B.length()) return (i+j) / A.length() + ((i + j) % A.length() == 0 ? 0 : 1);
}
return -1;
}
使用brute force的方法求解的运行效率是很低的，可以采用KMP算法加之改进。
public int repeatedStringMatch(String A, String B) {
int[] prefix = new int[B.length()];
for (int i = 1, j = 0; i < B.length(); ) {
if (B.charAt(i) == B.charAt(j)) prefix[i++] = ++j;
else if (j == 0) i++;
else j = prefix[j - 1];
}
for (int i = 0, j = 0; i < A.length(); i += j - prefix[j - 1], j = prefix[j - 1]) {
while (j < B.length() && A.charAt((i + j) % A.length()) == B.charAt(j)) j++;
if (j == B.length()) return (int)Math.ceil((double)(i + j) / A.length());
if (j == 0) j++;
}
return -1;
}
- 字符数组压缩
问题描述：
问题举例：
问题求解：
使用双层while循环可以避免使用单层for循环末尾取不到的问题，并且代码显得更加紧凑。
public int compress2(char[] chars) {
int indexAns = 0;
int index = 0;
while(index < chars.length) {
char currentChar = chars[index];
int count = 0;
while(index < chars.length && chars[index] == currentChar) {
index++;
count++;
}
chars[indexAns++] = currentChar;
if(count != 1) {
for(char c : Integer.toString(count).toCharArray()) {
chars[indexAns++] = c;
}
}
}
return indexAns;
}
- 回文子串
问题描述：
问题求解：
最初想到的解法就是DP，就是不断从长度1，2，3生成判断是否回文，计数。
public int countSubstrings(String s) {
int cnt = 0;
boolean map[][] = new boolean[s.length()][s.length()];
for (int i = 0; i < s.length(); i++) {
map[i][i] = true;
cnt++;
if (i + 1 < s.length() && s.charAt(i) == s.charAt(i + 1)) {
map[i][i + 1] = true;
cnt++;
}
}
for (int i = 2; i < s.length(); i++) {
for (int j = 0; j < s.length() - i; j++) {
if (s.charAt(j) == s.charAt(j + i) && map[j + 1][j + i - 1]) {
map[j][j+i] = true;
cnt++;
}
else {
map[j][j+i] = false;
}
}
}
return cnt;
}
事实上，也可以使用递归的思路，不断的生成字串进行判断，这种方法也是非常巧妙的。
int count = 0;
public int countSubstrings2(String s) {
if (s == null || s.length() == 0) return 0;
for (int i = 0; i < s.length(); i++) { // i is the mid point
extendPalindrome(s, i, i); // odd length;
extendPalindrome(s, i, i + 1); // even length
}
return count;
}
private void extendPalindrome(String s, int left, int right) {
while (left >=0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
count++; left--; right++;
}
}
-
Implement Magic Dictionary
问题描述：
问题求解：
使用Trie树可以很方便的进行求解，思路清晰。
public class MagicDictionary {
class TrieNode {
TrieNode[] child = new TrieNode[26];
boolean isWord = false;
}
TrieNode root;
/** Initialize your data structure here. */
public MagicDictionary() {
root = new TrieNode();
}
/** Build a dictionary through a list of words */
public void buildDict(String[] dict) {
for (String i : dict) {
TrieNode cur = root;
for (char j : i.toCharArray()) {
if(cur.child[j - 'a'] == null) cur.child[j - 'a'] = new TrieNode();
cur = cur.child[j - 'a'];
}
cur.isWord = true;
}
}
/** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
public boolean search(String word) {
char[] s = word.toCharArray();
for (int i = 0; i < s.length; i++) {
for (char j = 'a'; j <= 'z'; j++) {
if(j == s[i]) continue;
char pre = s[i];
s[i] = j;
if (helper(s, root)) {
return true;
}
s[i] = pre;
}
}
return false;
}
boolean helper(char[] s, TrieNode root) {
TrieNode tmp = root;
for (char c : s) {
if(tmp.child[c - 'a'] == null) return false;
tmp = tmp.child[c - 'a'];
}
return tmp.isWord;
}
}
- 判断子串
问题描述：
问题求解：
方法一、双指针，遍历t一遍，就可以得到结果，代码简洁，时间复杂度为O(n)。
public boolean isSubsequence(String s, String t) {
if (s.equals("")) return true;
if (t.equals("")) return false;
boolean res = false;
int idxt = 0;
int idxs = 0;
char[] s1 = s.toCharArray();
char[] t1 = t.toCharArray();
for(;idxt < t1.length; idxt++) {
if (t1[idxt] == s1[idxs]) idxs++;
if (idxs == s1.length) {
res = true;
break;
}
}
return res;
}
方法二、follow up里提到，如果问题是一个t，多个s的情况下，使用上述的双指针，算法时间复杂度为O(kn)，就不那么理想了。一般来说这种问题，可以使用预处理的方法进行改进。我们可以使用一个HashMap，将每个字符出现的index保存下来。对于每个query，遍历一遍s，对每个字符进行查看，如果Hash中没有的话，直接返回false，如果存在，则寻找其index，进行判断。
public boolean isSubsequence(String s, String t) {
if (s.equals("")) return true;
if (t.equals("")) return false;
HashMap<Character, List<Integer>> map = new HashMap<>();
char[] t1 = t.toCharArray();
char[] s1 = s.toCharArray();
for (int i = 0; i < t1.length; i++) {
if (!map.containsKey(t1[i])) map.put(t1[i], new ArrayList<Integer>());
map.get(t1[i]).add(i);
}
int idx = 0;
for (int i = 0; i < s1.length; i++) {
if (!map.containsKey(s1[i])) return false;
int k = Collections.binarySearch(map.get(s1[i]), idx);
if (k < 0) k = -k - 1;
if (k == map.get(s1[i]).size()) return false;
idx = map.get(s1[i]).get(k) + 1;
}
return true;
}
