剑指offer

最新推荐文章于 2025-05-10 18:09:08 发布

依然不放弃

最新推荐文章于 2025-05-10 18:09:08 发布

阅读量78

点赞数

文章标签：算法

本文链接：https://blog.youkuaiyun.com/qq_43727546/article/details/119565152

版权

这篇博客涵盖了多种算法问题，包括重建二叉树的剑指Offer07题目，以及买卖股票的最佳时机系列问题。博主分别用递归和动态规划解决了这些问题。此外，还涉及矩阵路径寻找和机器人运动范围的算法实现。每个问题都提供了详细的解题思路和代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

剑指 Offer 07. 重建二叉树

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return help(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
    }
    TreeNode* help(vector<int>& preorder,int preleft,int preright, vector<int>& inorder,int inleft,int inright){
        if(preleft>preright) return nullptr;
        int i=inleft;
        for(;i<=inright;i++){
            if(inorder[i]==preorder[preleft])
                break;
        }
        TreeNode* root=new TreeNode(preorder[preleft]);
        root->left=help(preorder,preleft+1,i-inleft+preleft,inorder,inleft,i-1);
        root->right=help(preorder,i-inleft+preleft+1,preright,inorder,i+1,inright);
        return root;
    }
};

121. 买卖股票的最佳时机

我的最小买

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1) return 0;
        int min=prices[0];int ret=0;
        for(int i=1;i<prices.size();i++){
            if(prices[i]>min){
                ret=max(ret,prices[i]-min);
            }else{
                min=prices[i];
            }
        }
        return ret;
    }
};

122. 买卖股票的最佳时机 II

贪心：每一步局部解组合=全局的最优解

没有T+1，次数，手续费

每一天能赚就赚，否则就错过赚钱的机会了，所以赚就赚。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()<=1) return 0;
        int ret=0;
        int min=prices[0];
        for(int i=1;i<prices.size();i++){
            if(prices[i]>min)
                ret+=prices[i]-min;
            min=prices[i];            
        }
        return ret;
    }
};

188. 买卖股票的最佳时机 IV

k次限制，三维动态规划

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size()<=1) return 0;
        int n=prices.size();
        vector<vector<vector<int>>> dp(n,vector<vector<int>>(k+1,vector<int>(2,0)));
        dp[0][0][1]=-prices[0];
        for(int i=1;i<=k;i++){
            dp[0][i][0]=dp[0][i][1]=INT_MIN/2;
        }
        for(int i=1;i<n;i++){
            for(int j=0;j<=k;j++){
                dp[i][j][0]=max(dp[i-1][j][0],j==0?INT_MIN/2:dp[i-1][j-1][1]+prices[i]);
                dp[i][j][1]=max(dp[i-1][j][1],dp[i-1][j][0]-prices[i]);
            }
        }
        int ret=0;
        for(int i=0;i<=k;i++){
            ret=max(ret,dp[n-1][i][0]);
        }
        return ret;
    }
};

剑指 Offer 12. 矩阵中的路径

class Solution {
public:
    int rows, cols;
    bool exist(vector<vector<char>>& board, string word) {
        rows = board.size();
        cols = board[0].size();
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                if(dfs(board, word, i, j, 0)) return true;
            }
        }
        return false;
    }
    bool dfs(vector<vector<char>>& board, string word, int i, int j, int k) {
        if(i >= rows || i < 0 || j >= cols || j < 0 || board[i][j] != word[k]) return false; 
        if(k == word.size() - 1) return true; //全部匹配
        board[i][j] = '\0';
        bool res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) || 
                      dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i , j - 1, k + 1);
        board[i][j] = word[k];
        return res;
    }
};

剑指 Offer 13. 机器人的运动范围

class Solution {
public:
    int get(int m){
        int ret=0;
        while(m!=0){
            ret+=m%10;
            m=m/10;
        }
        return ret;
    }
    int movingCount(int m, int n, int k) {
        vector<vector<bool>> used(m,vector<bool>(n,false));
        return help(m,n,k,0,0,used);
    }
    int help(int m, int n, int k,int i,int j,vector<vector<bool>>& used){
        if(i<0 || i>=m || j<0 || j>=n ||  used[i][j]==true || get(i)+get(j)>k) return 0;
        used[i][j]=true;//不用撤销
        int ret=1+help(m,n,k,i-1,j,used)+help(m,n,k,i+1,j,used)+help(m,n,k,i,j-1,used)+help(m,n,k,i,j+1,used);
        return ret;  
    }
};

class Solution {
public:
    int cuttingRope(int n) {
        vector<int> dp(n+1,0);
        dp[1]=1;
        for(int i=2;i<=n;i++){
            for(int j=1;j<i;j++)
                dp[i]=max(dp[i],dp[i-j]*j);
        }
        return dp[n];
    }
};