解题思路：
这道题需要注意的是s和t长度相等，但都为空的情况。只需要扫描一遍s建立字典（char, count），然后扫描t，如果有
未出现的字母，或者键值小于0，就可以返回false了。
bool isAnagram(string s, string t) {
if (s.length() != t.length())
return false;
if (s.length() == 0 && t.length() == 0)
return true;
map<char,int> dict;
for (int i = 0; i < s.length(); i++) {
if (dict.find(s[i]) == dict.end()) {
dict.insert(dict.end(), make_pair(s[i],1));
} else
dict.find(s[i])->second++;
}
for (int i = 0; i < t.length(); i++) {
if (dict.find(t[i]) == dict.end())
return false;
else {
dict.find(t[i])->second--;
if (dict.find(t[i])->second < 0)
return false;
}
}
return true;
}
但是，因为题目中说是小写字母，所以可以用数组来做。思路类似，相比使用map插入更简单。
bool isAnagram(string s, string t) {
if (s.length() != t.length()) return false;
int n = s.length();
int counts[26] = {0};
for (int i = 0; i < n; i++) {
counts[s[i] - 'a']++;
counts[t[i] - 'a']--;
}
for (int i = 0; i < 26; i++)
if (counts[i]) return false;
return true;
}
与这道题类似的是这个：
解题思路：
使用数组计数。
bool canConstruct(string ransomNote, string magazine) {
int i;
int arr[26] = {0};
for (i = 0; i < magazine.length(); i++) {
arr[magazine[i]-'a']++;
}
for (i = 0; i < ransomNote.length(); i++) {
arr[ransomNote[i]-'a']--;
if (arr[ransomNote[i]-'a'] < 0)
return false;
}
return true;
}
相同思路的还有这道题：
解题思路：
因为数字是1~n的，所以考虑直接利用下标。将nums[i]-1取绝对值后作为新的索引，将此处的数组值添加负号。
如果再次索引到此处，则可以将此索引值+1加入到result中。
vector<int> findDuplicates(vector<int>& nums) {
vector<int> result;
int i;
for (i = 0; i < nums.size(); i++) {
if (nums[abs(nums[i])-1] < 0)
result.push_back(abs(nums[i]));
else
nums[abs(nums[i])-1] *= -1;
}
return result;
}
相同的还有这道题：
438. Find All Anagrams in a String
解题思路：
同样用数组存p内字母的情况，然后扫s检查就好。需要注意的是memcpy函数的使用，分配空间时，不要用数字。。。
之前我写memcpy(temp, pArr, 26);实际上：
简直呵呵哒。
vector<int> findAnagrams(string s, string p) {
vector<int> result;
if (p.length() > s.length())
return result;
int pArr[26] = {0};
for (int i = 0; i < p.length(); i++) {
pArr[p[i] - 'a'] ++;
}
int i,j,k;
bool flag;
for (i = 0; i <= s.length() - p.length() ; i++) {
int temp[26];
memcpy(temp, pArr, sizeof(pArr));
flag = true;
for (j = i; j < i + p.length(); j++) {
if (temp[s[j] - 'a'] == 0) {
flag = false;
break;
}
else
temp[s[j] - 'a'] --;
}
if (flag == true) {
for (k = 0; k < 26; k++) {
if (temp[k] != 0)
break;
}
if (k == 26) {
result.push_back(i);
}
}
}
return result;
}
解题思路：
本来是用遍历两次数组来算的，外层0~n-1，内层i+1~n-1，找到即跳出。但是如果数组很大，这样无疑很耗时。
由于数组是升序，所以考虑从左右两端开始查找。如果numbers[left]+numbers[right]==target，就找到了；
大于的话right左移，小于的话left右移。当left>=right时，终止。
vector<int> twoSum(vector<int>& numbers, int target) {
vector<int> result;
int left = 0;
int right = numbers.size() - 1;
while(left < right) {
if (numbers[left] + numbers[right] == target) {
result.push_back(left + 1);
result.push_back(right + 1);
break;
}
else if (numbers[left] + numbers[right] > target) {
right --;
}
else {
left ++;
}
}
return result;
}