算法刷题记录(LeetCode 541-570)

541. Reverse String II

正常遍历

    string reverseStr(string s, int k) {
        int end=0;
        while(end<s.length()){
            int new_end=min(end+k,(int)s.length());
            for (int i = 0; i < (new_end-end)/2; ++i) {
                char temp=s[end+i];
                s[end+i]=s[new_end-i-1];
                s[new_end-i-1]=temp;
            }
            end+=k*2;
        }
        return s;
    }

*542. 01 Matrix

DFS (不要写递归，用队列实现)

class Solution {
    private static final int UNKNOWN = 1000000;
    private static final int[][] DIRECTIONS = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    private int[][] res;
    private boolean[][] visited;

    public int[][] updateMatrix(int[][] mat) {
        int m = mat.length, n = mat[0].length;
        res = new int[m][n];
        visited=new boolean[m][n];
        for (int[] row : res) {
            Arrays.fill(row, UNKNOWN);
        }
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 0) {
                    queue.offer(new int[]{i, j,0});
                }
            }
        }
        while (!queue.isEmpty()) {
            var val=queue.poll();
            int x=val[0];
            int y=val[1];
            int distance=val[2];
            visited[x][y]=true;
            res[x][y]=Math.min(res[x][y],distance);
            for (var d:DIRECTIONS){
                int i=x+d[0];
                int j=y+d[1];
                if (i>=0&&j>=0&&i<mat.length&&j<mat[0].length&&!visited[i][j]){
                    queue.offer(new int[]{i,j,distance+1});
                }
            }
        }
        return res;
    }
}

*547. Number of Provinces

class UnionFind{
public:
    int find(int x){
        int root = x;
        
        while(father[root] != -1){
            root = father[root];
        }
        
        while(x != root){
            int original_father = father[x];
            father[x] = root;
            x = original_father;
        }
        
        return root;
    }
    
    bool is_connected(int x,int y){
        return find(x) == find(y);
    }
    
    void merge(int x,int y){
        int root_x = find(x);
        int root_y = find(y);
        
        if(root_x != root_y){
            father[root_x] = root_y;
            num_of_sets--;
        }
    }
    
    void add(int x){
        if(!father.count(x)){
            father[x] = -1;
            num_of_sets++;
        }
    }
    
    int get_num_of_sets(){
        return num_of_sets;
    }
    
private:
    // 记录父节点
    unordered_map<int,int> father;
    // 记录集合数量
    int num_of_sets = 0;
};

class Solution {
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        UnionFind uf;
        for(int i = 0;i < isConnected.size();i++){
            uf.add(i);
            for(int j = 0;j < i;j++){
                if(isConnected[i][j]){
                    uf.merge(i,j);
                }
            }
        }
        
        return uf.get_num_of_sets();
    }
};

551. Student Attendance Record I

带条件的遍历

    bool checkRecord(string s) {
        int absents=0;
        int consecutive=0;
        for (char ch:s) {
            if(ch=='A'){
               absents++;
                if (absents>1){
                    return false;
                }
            }
            else if (ch=='L'){
                consecutive++;
                if (consecutive>2){
                    return false;
                }
                continue;
            }
            consecutive=0;
        }
        return true;
    }

*554. Brick Wall

Vector+HashSet 半超时

class Solution {
public:
    int leastBricks(vector<vector<int>>& wall) {
        vector<unordered_set<int>> edges(wall.size(),unordered_set<int>());
        set<int> edgeSet;
        for (int i=0;i<wall.size();i++) {
            int curr=0;
            for (int val:wall[i]) {
                curr+=val;
                edgeSet.insert(curr);
                edges[i].insert(curr);
            }
        }
        auto lastElement= prev(edgeSet.end());
        edgeSet.erase(lastElement);
        if (edgeSet.empty()){
            return wall.size();
        }
        int minCross=std::numeric_limits<int>::max();
        for (int edge:edgeSet) {
            int currCross=0;
            for (const auto & i : edges) {
                if (!i.count(edge)){
                    currCross++;
                }
            }
            minCross=min(minCross,currCross);
        }
        return minCross;
    }
};

寻找最多的公共边，他就是最小通过数

    int leastBricks(vector<vector<int>>& wall) {
//        vector<vector<int>> edges(wall.size(),vector<int>());
        unordered_map<int,int> edgeMap;
        int curr=0;
        for (auto & i : wall) {
            curr=0;
            for (int val:i) {
                curr+=val;
                edgeMap[curr]++;
            }
        }
        edgeMap.erase(curr);
        if (edgeMap.empty()){
            return wall.size();
        }
        int minCross=std::numeric_limits<int>::max();
        for (auto p:edgeMap) {
            minCross=min((int)wall.size()-p.second,minCross);
        }
        return minCross;
    }

557. Reverse Words in a String III

    string reverseWords(string s) {
        int begin=0;
        for (int i = 0; i < s.length(); ++i) {
            if (s[i]!=' '){
                continue;
            }
            if (i-begin<2){
                begin=i+1;
                continue;
            }
            int end=i-1;
            while(begin<end){
                char temp=s[begin];
                s[begin]=s[end];
                s[end]=temp;
                begin++;
                end--;
            }
            begin=i+1;
        }
        if (s.length()-begin>1){
            int end=s.length()-1;
            while(begin<end){
                char temp=s[begin];
                s[begin]=s[end];
                s[end]=temp;
                begin++;
                end--;
            } 
        }
        return s;
    }

559. Maximum Depth of N-ary Tree

    int maxDepth(Node* root) {
        if(root== nullptr){
            return 0;
        }
        int maxChildLength=0;
        for (auto node:root->children) {
            maxChildLength=max(maxChildLength, maxDepth(node));
        }
        return 1+maxChildLength;
    }

561. Array Partition

    int arrayPairSum(vector<int>& nums) {
        int sum=0;
        std::sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i+=2) {
            sum+=nums[i];
        }
        return sum;
    }

566. Reshape the Matrix

    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        int n = mat[0].size();
        int sourceElements=mat.size()*mat[0].size();
        int targetElements=r*c;
        if(sourceElements!=targetElements){
            return mat;
        }
        vector<vector<int>> target(r,vector<int>(c));
        for (int x = 0; x < sourceElements; ++x) {
            target[x / c][x % c] = mat[x / n][x % n];
        }
        return target;
    }
};

563. Binary Tree Tilt

class Solution {
public:
    int totalTilt=0;
    int findTilt(TreeNode* root) {
        getTreeSum(root);
        return totalTilt;
    }
    int getTreeSum(TreeNode* node){
        if (node== nullptr){
            return 0;
        }
        int lSum= getTreeSum(node->left);
        int rSum= getTreeSum(node->right);
        totalTilt+=abs(rSum-lSum);
        return lSum+rSum+node->val;
    }
};

567. Permutation in String

    public boolean checkInclusion(String s1, String s2) {
        if (s1.length()>s2.length()){
            return false;
        }
        int[] requirements=new int[256];
        for (char ch:s1.toCharArray()){
            requirements[ch]++;
        }
        int totalRequirements=s1.length();
        char[] s2Arr=s2.toCharArray();
        for (int i=0;i<s1.length();i++){
            if (requirements[s2Arr[i]]>0){
                totalRequirements--;
            }
            requirements[s2Arr[i]]--;
        }
        int left=0;
        int right=s1.length();
        if (totalRequirements==0){
            return true;
        }
        while (right<s2.length()){
            if (requirements[s2Arr[left]]>=0){
                totalRequirements++;
            }
            requirements[s2Arr[left]]++;
            if (requirements[s2Arr[right]]>0){
                totalRequirements--;
            }
            requirements[s2Arr[right]]--;
            if (totalRequirements==0){
                return true;
            }
            left++;
            right++;
        }
        return false;
    }