算法刷题记录(LeetCode 571-600)

575. Distribute Candies

    int distributeCandies(vector<int>& candyType) {
        unordered_set<int> candies;
        int max_types=candyType.size()/2;
        for (int candy:candyType) {
            if(candies.size()>=max_types){
                return max_types;
            }
            candies.insert(candy);
        }
        return min(candyType.size()/2,candies.size());
    }

581. Shortest Unsorted Continuous Subarray

单调栈

要记录当前最大的出栈数以及最左的发生出栈的位置

    int findUnsortedSubarray(vector<int>& nums) {
        int biggest_out=numeric_limits<int>::min();
        int leftest_re_arr=numeric_limits<int>::max();
        deque<int> st;
        for (int i = 0; i < nums.size(); ++i) {
            if (!st.empty()&&nums[st.back()]>nums[i]){
                while (!st.empty()&&(nums[st.back()]>nums[i]||st.back()>leftest_re_arr)) {
                    int curr = st.back();
                    st.pop_back();
                    if (biggest_out < nums[curr]) {
                        biggest_out = nums[curr];
                    }
                    leftest_re_arr=min(leftest_re_arr,curr);
                }
            }

            if (biggest_out<=nums[i]){
                st.push_back(i);
            }
        }
        return nums.size()-st.size();
    }

双指针

583. Delete Operation for Two Strings

    public int minDistance(String word1, String word2) {
        int[][] dp=new int[word1.length()+1][word2.length()+1];

        for (int i=1;i<=word1.length();i++){
            for (int j=1;j<=word2.length();j++){
                if (word1.charAt(i-1)==word2.charAt(j-1)){
                    dp[i][j]=Math.max(Math.max(dp[i-1][j-1]+1,dp[i-1][j]),dp[i][j-1]);
                }
                else{
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        int maxLen=dp[word1.length()][word2.length()];
        return word1.length()+word2.length()-2*maxLen;
    }

589. N-ary Tree Preorder Traversal

class Solution {
public:
    vector<int> res;
    vector<int> preorder(Node* root) {
        if (root== nullptr){
            return res;
        }
        res.push_back(root->val);
        for (auto* child:root->children) {
            preorder(child);
        }
        return res;
    }
};

590. N-ary Tree Postorder Traversal

class Solution {
public:
    vector<int> ans;
    vector<int> postorder(Node* root) {
        dfs(root);
        return ans;
    }
    void dfs(Node* root){
        if (!root){
            return;
        }
        for (auto child:root->children) {
            dfs(child);
        }
        ans.push_back(root->val);
    }
};

*593. Valid Square

class Solution {
    typedef pair<int,int> pint;
public:
    int cenX;
    int cenY;
    bool validSquare(vector<int>& p1, vector<int>& p2, vector<int>& p3, vector<int>& p4) {
        // 中心点，缩放 4 倍，避免除法
        cenX = p1[0] + p2[0] + p3[0] + p4[0];
        cenY = p1[1] + p2[1] + p3[1] + p4[1];
        // 将中心点移动到坐标原点
        vector<array<int,2>> pts = {cen2Ori(p1),cen2Ori(p2),cen2Ori(p3),cen2Ori(p4)};
        // 将四个顶点存入哈希表
        auto arrayHash = [fn = hash<long>{}] (const array<int, 2>& arr) -> size_t { // 哈希函数
            return fn(*((long const*)arr.data()));
        };
        unordered_set<array<int, 2>, decltype(arrayHash)> pts_set(pts.begin(), pts.end(), 0, arrayHash);
        if(pts_set.size() < 4) return false;
        // 检查每个点旋转 90 度以后的点是否在哈希表中
        for(auto &pt: pts){
            if(!pts_set.count({-pt[1], pt[0]})) return false;
        }
        return true;
    }
    array<int,2> cen2Ori(vector<int> p) {
        array<int,2> vec={ p[0]*4-cenX, p[1]*4-cenY};
        return vec;
    }
};

Java 为什么用ArrayList?因为不需要重写hash 和 equals方法

class Solution {
    public int centerX;
    public int centerY;
    public boolean validSquare(int[] p1, int[] p2, int[] p3, int[] p4) {
        centerX=p1[0]+p2[0]+p3[0]+p4[0];
        centerY=p1[1]+p2[1]+p3[1]+p4[1];
        ArrayList<ArrayList<Integer>> arr=new ArrayList<>(Arrays.asList(shift2Origin(p1),shift2Origin(p2),shift2Origin(p3),shift2Origin(p4)));
        HashSet<ArrayList<Integer>> set = new HashSet<>(arr);
        if (set.size()<4){
            return false;
        }
        for (var val:arr){
            if (!set.contains(new ArrayList<>(Arrays.asList(-val.get(1),val.get(0))))){
                return false;
            }
        }
        return true;
    }
    ArrayList<Integer> shift2Origin(int[] pt){
        return new ArrayList<>( Arrays.asList(pt[0]*4-centerX,pt[1]*4-centerY));
    }
}

594. Longest Harmonious Subsequence

class Solution {
public:
    int findLHS(vector<int>& nums) {
        unordered_map<int,int> values;
        set<int> distinct_values;
        int ans=0;
        for (const int& val:nums) {
            values[val]++;
            distinct_values.insert(val);
        }
        int prev=*distinct_values.begin();
        auto pointer=distinct_values.begin();
        pointer++;
        for (; pointer != distinct_values.end(); pointer++) {
            int curr_val=*pointer;
            if (curr_val-prev==1){
                ans=max(ans,values[prev]+values[curr_val]);
            }
            prev=curr_val;
        }
        return ans;
    }
};

598. Range Addition II

    int maxCount(int m, int n, vector<vector<int>>& ops) {
        int min_row=m;
        int min_column=n;
        for (auto coorindate:ops) {
            min_row=min(min_row,coorindate[0]);
            min_column= min(min_column,coorindate[1]);
        }
        return min_row*min_column;
    }

599. Minimum Index Sum of Two Lists

    public String[] findRestaurant(String[] list1, String[] list2) {
        HashMap<String,Integer> dictionary=new HashMap<>();
        for (int i=0;i<list1.length;i++){
            dictionary.put(list1[i],i);
        }
        int currMinIdx=Integer.MAX_VALUE;
        ArrayList<String> ans=new ArrayList<>();
        for (int i=0;i<list2.length;i++){
            if (dictionary.containsKey(list2[i])){
                int currIdx=dictionary.get(list2[i])+i;
                if (currIdx<currMinIdx){
                    ans.clear();
                    ans.add(list2[i]);
                    currMinIdx=currIdx;
                }
                else if (currIdx==currMinIdx){
                    ans.add(list2[i]);
                }
            }
        }
        String[] res=new String[ans.size()];
        for (int i=0;i<ans.size();i++){
            res[i]=ans.get(i);
        }
        return res;
    }