コードカプリスアルゴリズムトレーニングキャンプ6日目| 242. 効果的なアナグラム| 349. 2つの配列の積| 1. 2つの数値の和| 827. 最大の人工島

242. 効果的なアナグラム

class Solution {
    
    
public:
    bool isAnagram(string s, string t) {
    
    
        int record[26] = {
    
    0};
        for (int i = 0; i < s.size(); i++) {
    
    
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < t.size(); i++) {
    
    
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
    
    
            if (record[i] != 0) {
    
    
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

349. 2 つの配列の交差

class Solution {
    
    
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    
    
        unordered_set<int>uset(nums1.begin(),nums1.end());
        unordered_set<int>res;
        for(int a:nums2){
    
    
            if(uset.find(a)!=uset.end()){
    
    
                res.insert(a);
            }
        }
        return {
    
    res.begin(),res.end()};

    }
};

202. ハッピーナンバー

class Solution {
    
    
    unordered_set<int>happy;
    int pingfanghe(int n){
    
    
        int res=0;
        while(n){
    
    
            int count2=n%10;
            n=n/10;
            res+=count2*count2;
        }
        return res;
    }
public:
    bool isHappy(int n) {
    
    
        if(n==1)return true;
        if(happy.find(n)==happy.end()){
    
    
            happy.insert(n);
            n=pingfanghe(n);
            return isHappy(n);
        }else{
    
    
            return false;
        }
    }
};

1. 2 つの数値の合計

class Solution {
    
    
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    
    
        unordered_map<int,int>umap;
        for(int i=0;i<nums.size();i++){
    
    
            if(umap.find(target-nums[i])==umap.end()){
    
    
                umap[nums[i]]=i;
            }else{
    
    
                return {
    
    i,umap[target-nums[i]]};
            }
        }
        return {
    
    };
    }
};

827. 最大の人工島

class Solution {
    
    
    int maxm=0;
    int count=0;
    int mask=2;
    int index[4][2]={
    
    0, 1, 1, 0, -1, 0, 0, -1};
    void dfs(vector<vector<int>>& grid,int x, int y){
    
    
        if (grid[x][y] != 1 || grid[x][y] == 0) return;
        grid[x][y]=mask;
        count++;
        for(int i=0;i<4;i++){
    
    
            int nextx=x+index[i][0];
            int nexty=y+index[i][1];
            if(nextx<0||nexty<0||nextx>=grid.size()||nexty>=grid[0].size()){
    
    
                continue;
            }
            if(grid[nextx][nexty]==1){
    
    
                dfs(grid,nextx,nexty);
            }
        }
    }

public:
    int largestIsland(vector<vector<int>>& grid) {
    
    
        unordered_map<int,int>umap;
        for(int i=0;i<grid.size();i++){
    
    
            for(int j=0;j<grid[0].size();j++){
    
    
                if(grid[i][j]==1){
    
    
                    count=0;
                    dfs(grid,i,j);
                    umap[mask]=count;
                    maxm=max(maxm,count);
                    mask++;
                }
            }
        }
        unordered_set<int>uset;
        for(int i=0;i<grid.size();i++){
    
    
            for(int j=0;j<grid[0].size();j++){
    
    
                if(grid[i][j]==0){
    
    
                    uset.clear();
                    int a=0;
                    for(int k=0;k<4;k++){
    
    
                        int nextx=i+index[k][0];
                        int nexty=j+index[k][1];
                        if(nextx<0||nexty<0||nextx>=grid.size()||nexty>=grid[0].size()){
    
    
                            continue;
                        }
                        if(grid[nextx][nexty]!=0 && umap.count(grid[nextx][nexty])>0 && 
                                uset.find(grid[nextx][nexty])==uset.end()){
    
    
                            a+=umap[grid[nextx][nexty]];
                            uset.insert(grid[nextx][nexty]);
                        }
                     }
                    maxm=max(a+1,maxm);
                }
            }
        }
        return maxm;
    }
};