力扣题目训练（4）

2024年1月28日力扣题目训练

2024年1月28日第四天编程训练，今天主要是进行一些题训练，包括简单题3道、中等题2道和困难题1道，昨天没有做完，自制力还是不行，我写这个的初衷只是为了记录自己每天干了什么,希望能坚持下去。

326. 3 的幂

链接: 3 的幂
难度： 简单
题目：

运行示例：

思路：
利用循环判断是否为3的幂。
代码：

class Solution {
public:
    bool isPowerOfThree(int n) {
        while(n && n % 3 == 0){
            n /= 3;
        }
        return n == 1;
    }
};

342. 4的幂

链接: 4的幂
难度： 简单
题目：

运行示例：

思路：
我的方法是循环，还有就是找到4在这个范围内的最大值然后取余。
官方的方法是：
如果 n 是 4 的幂，那么 n 一定也是 2 的幂。因此我们可以首先判断 n是否是 2 的幂，在此基础上再判断 n 是否是 4 的幂。

代码：

class Solution {
public:
    bool isPowerOfFour(int n) {
        return n > 0 && (n & (n - 1)) == 0 && n % 3 == 1;
    }
};

344.反转字符串

链接: 反转字符串
难度： 简单
题目：

运行示例：

思路：
这道题就是简单的遍历与置换。
代码：

class Solution {
public:
    void reverseString(vector<char>& s) {
        int n = s.size();
        for(int i = 0 ; i < n/2; i++){
            char c = s[i];
            s[i] = s[n-i-1];
            s[n-i-1] = c;
        }

    }
};

93. 复原 IP 地址

链接: IP 地址
难度： 中等
题目：

运行示例：

思路：
这是一道比较典型的回溯法的题目。
代码：

class Solution {
public:
    void backtrack(string s, int index, int point, vector<string>& ans, string temp){
        if(point == 4 and temp.size() == s.size() + 4){
            ans.push_back(temp.substr(0,temp.size()-1));
            return;
        }
        for(int i = 1; i <= 3; i++){
            if(i + index > s.size()) return;
            if(i != 1 && s[index] == '0') return;
            if(i == 3 && stoi(s.substr(index,3)) > 255) return;
            backtrack(s,index+i,point+1,ans,temp+s.substr(index,i)+'.');
        }
    }
    vector<string> restoreIpAddresses(string s) {
        vector<string> ans;
        string temp ="";
        backtrack(s,0,0,ans,temp);
        return ans;

    }
};

95. 不同的二叉搜索树 II

链接: 二叉搜索树
难度： 中等
题目：

运行示例：

思路：
回溯法，递归得到当前节点的左右子树。
代码：

class Solution {
public:
    vector<TreeNode*> generateTree(int start, int end){
        if(start > end){
            return {NULL};
        }
        vector<TreeNode*> Trees;
        for(int i = start; i <= end; i++){
            vector<TreeNode*> leftTree = generateTree(start,i-1);
            vector<TreeNode*> rightTree = generateTree(i+1,end);
            for(auto& left : leftTree){
                for(auto& right: rightTree){
                    TreeNode* currTree = new TreeNode(i);
                    currTree->left = left;
                    currTree->right = right;
                    Trees.push_back(currTree);
                }
            }
        }
        return Trees;
    }

    vector<TreeNode*> generateTrees(int n) {
        if(!n) return {};
        return generateTree(1,n);
    }
};

42. 接雨水

链接: 接雨水
难度： 困难
题目：

运行示例：

思路：
这道题对我来说我是没有思路的，我想过用动态规划，但是我不知道怎么用。
官方算法

代码：
动态规划：

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if(n == 0) return 0;
        vector<int> leftMax(n), rightMax(n);
        leftMax[0]  = height[0];
        rightMax[n-1] = height[n-1];
        for(int i = 1; i < n; i++){
            leftMax[i] = max(leftMax[i-1], height[i]);
        }
        for(int i = n-2; i >= 0; i--){
            rightMax[i] = max(rightMax[i+1], height[i]);
        }
        int ans  = 0;
        for(int i = 0; i < n; i++){
            ans += min(leftMax[i], rightMax[i])-height[i];
        }
        return ans;
    }
};

栈

class Solution {
public:
    int trap(vector<int>& height) {
        int ans = 0;
        stack<int> stk;
        int n = height.size();
        for (int i = 0; i < n; ++i) {
            while (!stk.empty() && height[i] > height[stk.top()]) {
                int top = stk.top();
                stk.pop();
                if (stk.empty()) {
                    break;
                }
                int left = stk.top();
                int currWidth = i - left - 1;
                int currHeight = min(height[left], height[i]) - height[top];
                ans += currWidth * currHeight;
            }
            stk.push(i);
        }
        return ans;
    }
};