第四章 哈希表

01有效的字母异位词

//2024.1.29
#include <iostream>
#include <vector>
#include <string>
using namespace std;

//哈希法(数组)
bool can_change(string a, string b){
    if(a.size() != b.size())
        return false;
    vector<int> record(26, 0);
    for (size_t i = 0; i < a.size(); i++)
    {
        record[a[i] - 'a']++;
    }
    for (size_t i = 0; i < b.size(); i++)
    {
        record[b[i] - 'a']--;
    }
    for (size_t i = 0; i < 26; i++)
    {
        if(record[i] != 0)
            return false;
    }
    return true;
}

int main(){
    cout << can_change("abcacc", "cbacac");
}

02两个数组的交集

//2024.1.29
#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>
using namespace std;

//哈希法(set)
vector<int> intersection(vector<int>& nums1, vector<int>& nums2){
    unordered_set<int> result_set;
    unordered_set<int> nums_set(nums1.begin(), nums1.end());
    for(int num : nums2){
        if(nums_set.find(num) != nums_set.end()){
            result_set.insert(num);
        }
    }
    return vector<int>(result_set.begin(), result_set.end()); 
}

void print(int val){
    cout << val << " ";
}

int main(){
    vector<int> a = {1,3,3,4,5};
    vector<int> b = {3,5,1,2,1};
    vector<int> c = intersection(a, b);
    for_each(c.begin(), c.end(), print);
}

03两数之和

//2024.1.30
#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;

void print(int val){
    cout << val << " ";
}

//暴力解法
vector<int> two_sum1(vector<int> nums, int target){
    for (int i = 0; i < nums.size(); i++)
    {
        for(int j = i + 1; j < nums.size(); j++){
            if(nums[i] + nums[j] == target){
                return {i , j};
            }
        }
    }
    return {};
}

//哈希法(map)
vector<int> two_sum2(vector<int> nums, int target){
    unordered_map<int, int> map;
    for(int i = 0; i < nums.size(); i++){
        auto iter = map.find(target - nums[i]);
        if(iter != map.end()){
            return {iter->second, i};
        }
        map.insert(pair<int,int>(nums[i], i));
    }
    return {};
}

//双指针
vector<int> two_sum3(vector<int> nums, int target){
    sort(nums.begin(), nums.end());
    int left = 0;
    int right = nums.size() - 1;

    while(left < right){
        
        if(left < right && nums[left] + nums[right] > target){
            right--; 
        }else if(left < right && nums[left] + nums[right] < target){
            left++;
        }else if(left < right && nums[left] + nums[right] == target){
            return {left, right};
        }
    }

    return {};
}
int main(){
    vector<int> a = {2,7,11,15,12};
    vector<int> b = two_sum3(a, 18);
    for_each(b.begin(), b.end(), print);
}

04四数相加

//2024.1.31
#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

//哈希法
int four_sum(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D){
    unordered_map<int, int> map;
    for(int a : A){
        for(int b : B){
            map[a + b]++;
        }
    }
    int count = 0;
    for(int c : C){
        for(int d : D){
            if(map.find(0 - (c + d)) != map.end()){
                count += map[0 - (c + d)];
            }
        }
    }
    return count;
}

int main(){
    vector<int> A = {1, 2, 3, 4};
    vector<int> B = {-1, -2, -3, -4};
    vector<int> C = {0, 0, 0, 0};
    vector<int> D = {0, 0, 0, 0};
    int count = four_sum(A, B, C, D);
    cout << count << endl;
}

05三数之和

//2024.2.1
#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_set>
using namespace std;


//哈希法
vector<vector<int>> three_sum1(vector<int>& nums){
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());
    
    for(int i = 0; i < nums.size(); i++){
        if(nums[i] > 0){
            return result;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }
        unordered_set<int> set;
        for(int j = i + 1; j < nums.size(); j++){
            if(j > i + 2 && nums[j] == nums[j - 1] && nums[j - 1] == nums[j - 2]){
                continue;
            }
            int c = 0 - (nums[i] + nums[j]);
            if(set.find(c) != set.end()){
                result.push_back({nums[i], nums[j], c});
                set.erase(c);
            }else{
                set.insert(nums[j]);
            }
        }
    }
    return result;
}

//双指针法
vector<vector<int>> three_sum2(vector<int>& nums){
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());
    for(int i = 0; i < nums.size(); i++){
        if(nums[i] > 0){
            return result;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }
        int left = i + 1;
        int right = nums.size() - 1;
        while(right > left){
            if(nums[i] + nums[left] + nums[right] > 0){
                right--;
            }else if(nums[i] + nums[left] + nums[right] < 0){
                left++;
            }else{
                result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                while(right > left && nums[right] == nums[right - 1])
                    right--;
                while(right > left && nums[left] == nums[left + 1])
                    left++;

                right--;
                left++;
            }
        }
    }
    return result;
}

void print(vector<int> nums){
    for(int num : nums){
        cout << num << " ";
    }
    cout << endl;
}

int main(){
    vector<int> nums = {-2,-3,-1,1,1,1,1,0,5,2};
    vector<vector<int>> result = three_sum2(nums);
    for_each(result.begin(), result.end(), print);
}

06四数之和

//2024.2.5
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

vector<vector<int>> four_sum(vector<int>& nums, int target){
    vector<vector<int>> result;
    for(int i = 0; i < nums.size(); i++){
        if(nums[i] > target){
            return result;
        }
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }
        for(int j = i + 1; j < nums.size(); j++){
            if(j > i + 1 && nums[j] == nums[j - 1]){
                continue;
            }
            int left = j + 1;
            int right = nums.size() - 1;

            while(left < right){
                if(nums[i] + nums[j] + nums[left] + nums[right] > target){
                    right--;
                }else if(nums[i] + nums[j] + nums[left] + nums[right] < target){
                    left++;
                }else{
                    result.push_back({nums[i], nums[j], nums[left], nums[right]});

                    while(left < right && nums[left] == nums[left + 1])left++;
                    while(left < right && nums[right] == nums[right -1])right--;

                    right--;
                    left++;
                }
            }
        }
    }
    return result;
}

void print(vector<int> nums){
    for(int num : nums){
        cout << num << " ";
    }
    cout << endl;
}

int main(){
    vector<int> nums = {-2,-3,5,6,4,9,3,8,1,4,4,3,5,7};
    vector<vector<int>> result = four_sum(nums, 28);
    for_each(result.begin(), result.end(), print);
}