directorio
Definición de la tabla de hash
tabla Hash clasificación número entero
método de la cremallera (para resolver el problema de una llave seguido de múltiples valores)
La cadena más larga palíndromo
La agrupación de los términos con carácter
Sin repetición de la cadena más larga de caracteres
Definición de la tabla de hash
carácter almohadilla
tabla Hash clasificación número entero
método de la cremallera (para resolver el problema de una llave seguido de múltiples valores)
Descripción teórica
la implementación del código
tabla Hash (método de cremallera) .cpp
#include <stdio.h>
#include <vector>
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
int hash_func(int key, int table_len){
return key % table_len;
}
void insert(ListNode *hash_table[], ListNode *node, int table_len){
int hash_key = hash_func(node->val, table_len);
node->next = hash_table[hash_key];
hash_table[hash_key] = node;
}
bool search(ListNode *hash_table[], int value, int table_len){
int hash_key = hash_func(value, table_len);
ListNode *head = hash_table[hash_key];
while(head){
if (head->val == value){
return true;
}
head = head->next;
}
return false;
}
int main(){
const int TABLE_LEN = 11;
ListNode *hash_table[TABLE_LEN] = {0};
std::vector<ListNode *> hash_node_vec;
int test[8] = {1, 1, 4, 9, 20, 30, 150, 500};
for (int i = 0; i < 8; i++){
hash_node_vec.push_back(new ListNode(test[i]));
}
for (int i = 0; i < hash_node_vec.size(); i++){
insert(hash_table, hash_node_vec[i], TABLE_LEN);
}
printf("Hash table:\n");
for (int i = 0; i < TABLE_LEN; i++){
printf("[%d]:", i);
ListNode *head = hash_table[i];
while(head){
printf("->%d", head->val);
head = head->next;
}
printf("\n");
}
printf("\n");
printf("Test search:\n");
for (int i = 0; i < 10; i++){
if (search(hash_table, i, TABLE_LEN)){
printf("%d is in the hash table.\n");
}
else{
printf("%d is not in the hash table.\n");
}
}
return 0;
}La cadena más larga palíndromo
LeetCode 409.Longest palíndromo
Conoce incluye sólo un caso de la cadena de caracteres, encontrar el palíndromo longitud de la cadena más larga con la cadena de caracteres que se pueden generar.
Por ejemplo, s = "abccccddaa", puede generar una longitud máxima de cadena de palindromic 9. dccaaaccd, adccbccda, acdcacdca similares, son correctas.
idea general
Los detalles de diseño
la implementación del código
#include <stdio.h>
#include <string>
class Solution {
public:
int longestPalindrome(std::string s) {
int char_map[128] = {0};
int max_length = 0;
int flag = 0;
for (int i = 0; i < s.length(); i++){
char_map[s[i]]++;
}
for (int i = 0; i < 128; i++){
if (char_map[i] % 2 == 0){
max_length += char_map[i];
}
else{
max_length += char_map[i] - 1;
flag = 1;
}
}
return max_length + flag;
}
};
int main(){
std::string s = "abccccddaa";
Solution solve;
printf("%d\n", solve.longestPalindrome(s));
return 0;
}modo plazo
Patrón LeetCode 290.Word
patrón de cadena conocida contra la cadena str, perfil de compatibilidad confirmar str. representantes str y la coincidencia de patrones cadena de palabras str y modelo del carácter de correspondencia. (Donde el patrón contiene sólo caracteres en minúsculas, str la palabra contiene sólo caracteres en minúsculas, separados por espacios)
idea general
Los detalles de diseño
la implementación del código
#include <stdio.h>
#include <string>
#include <map>
class Solution {
public:
bool wordPattern(std::string pattern, std::string str) {
std::map<std::string, char> word_map;
char used[128] = {0};
std::string word;
int pos = 0;
str.push_back(' ');
for (int i = 0; i < str.length(); i++){
if (str[i] == ' '){
if (pos == pattern.length()){
return false;
}
if (word_map.find(word) == word_map.end()){
if (used[pattern[pos]]){
return false;
}
word_map[word] = pattern[pos];
used[pattern[pos]] = 1;
}
else{
if (word_map[word] != pattern[pos]){
return false;
}
}
word = "";
pos++;
}
else{
word += str[i];
}
}
if (pos != pattern.length()){
return false;
}
return true;
}
};
int main(){
std::string pattern = "abba";
std::string str = "dog cat cat dog";
Solution solve;
printf("%d\n", solve.wordPattern(pattern, str));
return 0;
}La agrupación de los términos con carácter
LeetCode 49.Group anagramas
Dado un conjunto de cuerdas, todos Anagram (orden alfabético inverso por las palabras constituida) en la salida juntos.
Solve1
idea general
Los detalles de diseño
la implementación del código
#include <stdio.h>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
class Solution {
public:
std::vector<std::vector<std::string> > groupAnagrams(
std::vector<std::string>& strs) {
std::map<std::string, std::vector<std::string> > anagram;
std::vector<std::vector<std::string> > result;
for (int i = 0; i < strs.size(); i++){
std::string str = strs[i];
std::sort(str.begin(), str.end());
if (anagram.find(str) == anagram.end()){
std::vector<std::string> item;
anagram[str] = item;
}
anagram[str].push_back(strs[i]);
}
std::map<std::string, std::vector<std::string> > ::iterator it;
for (it = anagram.begin(); it != anagram.end(); it++){
result.push_back((*it).second);
}
return result;
}
};
int main(){
std::vector<std::string> strs;
strs.push_back("eat");
strs.push_back("tea");
strs.push_back("tan");
strs.push_back("ate");
strs.push_back("nat");
strs.push_back("bat");
Solution solve;
std::vector<std::vector<std::string> > result
= solve.groupAnagrams(strs);
for (int i = 0; i < result.size(); i++){
for (int j = 0; j < result[i].size(); j++){
printf("[%s]", result[i][j].c_str());
}
printf("\n");
}
return 0;
}Solve2
idea general
la implementación del código
#include <stdio.h>
#include <vector>
#include <string>
#include <map>
void change_to_vector(std::string &str, std::vector<int> &vec){
for (int i = 0; i < 26; i++){
vec.push_back(0);
}
for (int i = 0; i < str.length(); i++){
vec[str[i]-'a']++;
}
}
class Solution {
public:
std::vector<std::vector<std::string> > groupAnagrams(
std::vector<std::string>& strs) {
std::map<std::vector<int>, std::vector<std::string> > anagram;
std::vector<std::vector<std::string> > result;
for (int i = 0; i < strs.size(); i++){
std::vector<int> vec;
change_to_vector(strs[i], vec);
if (anagram.find(vec) == anagram.end()){
std::vector<std::string> item;
anagram[vec] = item;
}
anagram[vec].push_back(strs[i]);
}
std::map<std::vector<int>,
std::vector<std::string> > ::iterator it;
for (it = anagram.begin(); it != anagram.end(); it++){
result.push_back((*it).second);
}
return result;
}
};
int main(){
std::vector<std::string> strs;
strs.push_back("eat");
strs.push_back("tea");
strs.push_back("tan");
strs.push_back("ate");
strs.push_back("nat");
strs.push_back("bat");
Solution solve;
std::vector<std::vector<std::string> > result = solve.groupAnagrams(strs);
for (int i = 0; i < result.size(); i++){
for (int j = 0; j < result[i].size(); j++){
printf("[%s]", result[i][j].c_str());
}
printf("\n");
}
return 0;
}Sin repetición de la cadena más larga de caracteres
LeetCode 3.Longest Subcadena Sin caracteres repetidos
Dada una longitud de cadena de la subcadena más larga de la solicitud de la cadena no repetitiva de caracteres.
idea general
Los detalles de diseño
la implementación del código
#include <stdio.h>
#include <string>
class Solution {
public:
int lengthOfLongestSubstring(std::string s) {
int begin = 0;
int result = 0;
std::string word = "";
int char_map[128] = {0};
for (int i = 0; i < s.length(); i++){
char_map[s[i]]++;
if (char_map[s[i]] == 1){
word += s[i];
if (result < word.length()){
result = word.length();
}
}
else{
while(begin < i && char_map[s[i]] > 1){
char_map[s[begin]]--;
begin++;
}
word = "";
for (int j = begin; j <= i; j++){
word += s[j];
}
}
}
return result;
}
};
int main(){
std::string s = "abcbadab";
Solution solve;
printf("%d\n", solve.lengthOfLongestSubstring(s));
return 0;
}secuencias de ADN repetitivas
LeetCode 187.Repeated secuencias de ADN
La secuencia de ADN se considera como que contiene sólo [ 'A', 'C', 'G', 'T'] cadena de 4 caracteres, a una cadena de ADN, y parecía encontrar toda longitud de más de 10 veces cadena.
Solve1
idea general
la implementación del código
#include <stdio.h>
#include <vector>
#include <string>
#include <map>
class Solution {
public:
std::vector<std::string> findRepeatedDnaSequences(std::string s) {
std::map<std::string, int> word_map;
std::vector<std::string> result;
for (int i = 0; i < s.length(); i++){
std::string word = s.substr(i, 10);
if (word_map.find(word) != word_map.end()){
word_map[word] += 1;
}
else{
word_map[word] = 1;
}
}
std::map<std::string, int> ::iterator it;
for (it = word_map.begin(); it != word_map.end(); it++){
if (it->second > 1){
result.push_back(it->first);
}
}
return result;
}
};
int main(){
std::string s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT";
Solution solve;
std::vector<std::string> result = solve.findRepeatedDnaSequences(s);
for (int i = 0; i < result.size(); i++){
printf("%s\n", result[i].c_str());
}
return 0;
}Solve2
idea general
Los detalles de diseño
la implementación del código
#include <stdio.h>
#include <vector>
#include <string>
int g_hash_map[1048576] = {0};
std::string change_int_to_DNA(int DNA){
static const char DNA_CHAR[] = {'A', 'C', 'G', 'T'};
std::string str;
for (int i = 0; i < 10; i++){
str += DNA_CHAR[DNA & 3];
DNA = DNA >> 2;
}
return str;
}
class Solution {
public:
std::vector<std::string> findRepeatedDnaSequences(std::string s) {
std::vector<std::string> result;
if (s.length() < 10){
return result;
}
for (int i = 0; i < 1048576; i++){
g_hash_map[i] = 0;
}
int char_map[128] = {0};
char_map['A'] = 0;
char_map['C'] = 1;
char_map['G'] = 2;
char_map['T'] = 3;
int key = 0;
for (int i = 9; i >= 0; i--){
key = (key << 2) + char_map[s[i]];
}
g_hash_map[key] = 1;
for (int i = 10; i < s.length(); i++){
key = key >> 2;
key = key | (char_map[s[i]] << 18);
g_hash_map[key]++;
}
for (int i = 0; i < 1048576; i++){
if (g_hash_map[i] > 1){
result.push_back(change_int_to_DNA(i));
}
}
return result;
}
};
int main(){
std::string s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT";
Solution solve;
std::vector<std::string> result = solve.findRepeatedDnaSequences(s);
for (int i = 0; i < result.size(); i++){
printf("%s\n", result[i].c_str());
}
return 0;
}cadena mínimo ventana
LeetCode 3.Longest Subcadena Sin caracteres repetidos
secuencia de la secuencia conocida S y T, S, en la búsqueda de la ventana mínimo (intervalo), de modo que el intervalo incluye todos los caracteres en la cadena de T.
idea general
Los detalles de diseño
la implementación del código
#include <stdio.h>
#include <string>
class Solution {
public:
int lengthOfLongestSubstring(std::string s) {
int begin = 0;
int result = 0;
std::string word = "";
int char_map[128] = {0};
for (int i = 0; i < s.length(); i++){
char_map[s[i]]++;
if (char_map[s[i]] == 1){
word += s[i];
if (result < word.length()){
result = word.length();
}
}
else{
while(begin < i && char_map[s[i]] > 1){
char_map[s[begin]]--;
begin++;
}
word = "";
for (int j = begin; j <= i; j++){
word += s[j];
}
}
}
return result;
}
};
int main(){
std::string s = "abcbadab";
Solution solve;
printf("%d\n", solve.lengthOfLongestSubstring(s));
return 0;
}
