代码随想录算法训练营29期|day55 任务以及具体安排

第九章 动态规划part12

  •  309.最佳买卖股票时机含冷冻期  
    class Solution {
    public int maxProfit(int[] prices) {
        //0代表持股票，1代表保持卖出状态，2代表卖出股票。3代表冷冻
        int[][] dp = new int[prices.length][4];
        dp[0][0] = -prices[0];
        for(int i = 1 ; i < prices.length ; i++){
            dp[i][0] = Math.max(dp[i-1][0], Math.max(dp[i-1][1]-prices[i], dp[i-1][3]-prices[i]));
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][3]);
            dp[i][2] = dp[i-1][0] + prices[i];
            dp[i][3] = dp[i-1][2];
        }
        return Math.max(dp[prices.length-1][1], Math.max(dp[prices.length-1][2], dp[prices.length-1][3]));
    }
}

    思路：分为四种状态进行讨论，所以需要二维数组，0代表持有股票的最大金额，1代表保持卖出状态的最大金额，2表示卖出股票的最大金额，3表示冷冻的最大金额，然后进行递推公式的推导，进行dp数组的初始化。

  •  714.买卖股票的最佳时机含手续费  
    /**
 * 卖出时支付手续费
 * @param prices
 * @param fee
 * @return
 */
public int maxProfit(int[] prices, int fee) {
    int len = prices.length;
    // 0 : 持股（买入）
    // 1 : 不持股（售出）
    // dp 定义第i天持股/不持股 所得最多现金
    int[][] dp = new int[len][2];
    dp[0][0] = -prices[0];
    for (int i = 1; i < len; i++) {
        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
        dp[i][1] = Math.max(dp[i - 1][0] + prices[i] - fee, dp[i - 1][1]);
    }
    return Math.max(dp[len - 1][0], dp[len - 1][1]);
}

    思路：该题和买卖股票2基本类似，就是需要减去手续费。

  • 总结

    之前我们已经把力扣上股票系列的题目都讲过的，但没有来一篇股票总结，来帮大家高屋建瓴，所以总结篇这就来了！

    股票问题总结

  • 动态规划：121.买卖股票的最佳时机(opens new window)
  • 动态规划：122.买卖股票的最佳时机II(opens new window)
  • 动态规划：123.买卖股票的最佳时机III(opens new window)
  • 动态规划：188.买卖股票的最佳时机IV(opens new window)
  • 动态规划：309.最佳买卖股票时机含冷冻期(opens new window)
  • 动态规划：714.买卖股票的最佳时机含手续费(opens new window)

  • #卖股票的最佳时机

    动态规划：121.买卖股票的最佳时机 (opens new window)，股票只能买卖一次，问最大利润。

    【贪心解法】

    取最左最小值，取最右最大值，那么得到的差值就是最大利润，代码如下：

    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int low = INT_MAX;
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            low = min(low, prices[i]);  // 取最左最小价格
            result = max(result, prices[i] - low); // 直接取最大区间利润
        }
        return result;
    }
};

    【动态规划】

  • dp[i][0] 表示第i天持有股票所得现金。
  • dp[i][1] 表示第i天不持有股票所得现金。

  • 如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i] 所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

  • 如果第i天不持有股票即dp[i][1]， 也可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
  • 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0] 所以dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

  • 代码如下：

    // 版本一
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if (len == 0) return 0;
        vector<vector<int>> dp(len, vector<int>(2));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
        }
        return dp[len - 1][1];
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

  • 使用滚动数组，代码如下：

    // 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

  • #买卖股票的最佳时机II

    动态规划：122.买卖股票的最佳时机II (opens new window)可以多次买卖股票，问最大收益。

    【贪心解法】

    收集每天的正利润便可，代码如下：

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

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

  • 【动态规划】

    dp数组定义：

  • dp[i][0] 表示第i天持有股票所得现金
  • dp[i][1] 表示第i天不持有股票所得最多现金

  • 如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]

  • 注意这里和121. 买卖股票的最佳时机 (opens new window)唯一不同的地方，就是推导dp[i][0]的时候，第i天买入股票的情况。

    在121. 买卖股票的最佳时机 (opens new window)中，因为股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定就是 -prices[i]。

    而本题，因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。

    代码如下：（注意代码中的注释，标记了和121.买卖股票的最佳时机唯一不同的地方）

    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(len, vector<int>(2, 0));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[len - 1][1];
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

  • #买卖股票的最佳时机III

    动态规划：123.买卖股票的最佳时机III (opens new window)最多买卖两次，问最大收益。

    【动态规划】

    一天一共就有五个状态，

  • 没有操作
  • 第一次买入
  • 第一次卖出
  • 第二次买入
  • 第二次卖出

  • dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。

    达到dp[i][1]状态，有两个具体操作：

  • 操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
  • 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

  • dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

    同理dp[i][2]也有两个操作：

  • 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

  • 所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

    同理可推出剩下状态部分：

    dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

    dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

    代码如下：

    // 版本一
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[prices.size() - 1][4];
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(n × 5)

  • 当然，大家可以看到力扣官方题解里的一种优化空间写法，我这里给出对应的C++版本：

    // 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<int> dp(5, 0);
        dp[1] = -prices[0];
        dp[3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[1] = max(dp[1], dp[0] - prices[i]);
            dp[2] = max(dp[2], dp[1] + prices[i]);
            dp[3] = max(dp[3], dp[2] - prices[i]);
            dp[4] = max(dp[4], dp[3] + prices[i]);
        }
        return dp[4];
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

  • 这种写法看上去简单，其实思路很绕，不建议大家这么写，这么思考，很容易把自己绕进去！ 对于本题，把版本一的写法研究明白，足以！

    #买卖股票的最佳时机IV

    动态规划：188.买卖股票的最佳时机IV (opens new window)最多买卖k笔交易，问最大收益。

    使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

    j的状态表示为：

  • 0 表示不操作
  • 1 第一次买入
  • 2 第一次卖出
  • 3 第二次买入
  • 4 第二次卖出
  • .....

  • 除了0以外，偶数就是卖出，奇数就是买入。

  • 确定递推公式

  • 达到dp[i][1]状态，有两个具体操作：

  • 操作一：第i天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
  • 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

  • dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);

    同理dp[i][2]也有两个操作：

  • 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
  • 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

  • dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

    同理可以类比剩下的状态，代码如下：

    for (int j = 0; j < 2 * k - 1; j += 2) {
    dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
    dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
}

    整体代码如下：

    class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {

        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
        for (int j = 1; j < 2 * k; j += 2) {
            dp[0][j] = -prices[0];
        }
        for (int i = 1;i < prices.size(); i++) {
            for (int j = 0; j < 2 * k - 1; j += 2) {
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[prices.size() - 1][2 * k];
    }
};

    当然有的解法是定义一个三维数组dp[i][j][k]，第i天，第j次买卖，k表示买还是卖的状态，从定义上来讲是比较直观。但感觉三维数组操作起来有些麻烦，直接用二维数组来模拟三维数组的情况，代码看起来也清爽一些。

    #最佳买卖股票时机含冷冻期

    动态规划：309.最佳买卖股票时机含冷冻期 (opens new window)可以多次买卖但每次卖出有冷冻期1天。

    相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题加上了一个冷冻期。

    在动态规划：122.买卖股票的最佳时机II (opens new window)中有两个状态，持有股票后的最多现金，和不持有股票的最多现金。本题则可以花费为四个状态

    dp[i][j]：第i天状态为j，所剩的最多现金为dp[i][j]。

    具体可以区分出如下四个状态：

  • 状态一：买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
  • 卖出股票状态，这里就有两种卖出股票状态
    • 状态二：两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
    • 状态三：今天卖出了股票
  • 状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

  • 达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：

  • 操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
  • 操作二：今天买入了，有两种情况
    • 前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
    • 前一天是保持卖出股票状态（状态二），dp[i - 1][1] - prices[i]

  • 所以操作二取最大值，即：max(dp[i - 1][3], dp[i - 1][1]) - prices[i]

    那么dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);

    达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：

  • 操作一：前一天就是状态二
  • 操作二：前一天是冷冻期（状态四）

  • dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

    达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：

  • 操作一：昨天一定是买入股票状态（状态一），今天卖出

  • 即：dp[i][2] = dp[i - 1][0] + prices[i];

    达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：

  • 操作一：昨天卖出了股票（状态三）

  • p[i][3] = dp[i - 1][2];

    综上分析，递推代码如下：

    dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3]- prices[i], dp[i - 1][1]) - prices[i];
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];

    整体代码如下：

    class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0) return 0;
        vector<vector<int>> dp(n, vector<int>(4, 0));
        dp[0][0] -= prices[0]; // 持股票
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
            dp[i][2] = dp[i - 1][0] + prices[i];
            dp[i][3] = dp[i - 1][2];
        }
        return max(dp[n - 1][3],max(dp[n - 1][1], dp[n - 1][2]));
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

  • #买卖股票的最佳时机含手续费

    动态规划：714.买卖股票的最佳时机含手续费 (opens new window)可以多次买卖，但每次有手续费。

    相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。

    唯一差别在于递推公式部分，所以本篇也就不按照动规五部曲详细讲解了，主要讲解一下递推公式部分。

    这里重申一下dp数组的含义：

    dp[i][0] 表示第i天持有股票所省最多现金。 dp[i][1] 表示第i天不持有股票所得最多现金

    如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]

  • 所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);

    在来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
  • 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][0] + prices[i] - fee

  • 所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);

    本题和动态规划：122.买卖股票的最佳时机II (opens new window)的区别就是这里需要多一个减去手续费的操作。

    以上分析完毕，代码如下：

    class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] -= prices[0]; // 持股票
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return max(dp[n - 1][0], dp[n - 1][1]);
    }
};

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/397117.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Redis事务长什么样？一文带你全面了解

Redis事务长什么样？一文带你全面了解

一、概述 1.1、Redis事务简介 在 Redis 中&#xff0c;事务是一组命令的有序队列&#xff0c;Redis 使用 MULTI、EXEC、WATCH 和 DISCARD 等命令来实现事务。事务的执行是原子的&#xff0c;要么所有命令都执行成功&#xff0c;要么所有命令都不执行。事务中的命令在 EXEC 执行…
阅读更多...
Avalonia学习（二十五）-系统界面

Avalonia学习（二十五）-系统界面

目前项目式练习&#xff0c;界面内容偏多&#xff0c;所以不给大家贴代码了&#xff0c;可以留言交流。此次为大家展示的是物联项目的例子&#xff0c;仅仅是学习&#xff0c;我把一些重点列举一下。 界面无边框 同前面 treeview控件 通过treevie控件导航 tabcontrol控件 …
阅读更多...
AUTOSAR CP--chapter7从CAN网络学习Autosar通信

AUTOSAR CP--chapter7从CAN网络学习Autosar通信

从CAN网络学习Autosar通信 前言缩写词CAN通信在AUTOSAR架构中的传输上位机配置 第六章总结&#xff1a;学习了如何使用工具的自动配置功能&#xff0c;位我们生成系统描述中部分ecu的BSW模块配置&#xff0c;但是自动配置的功能虽然为我们提供了极大的便利&#xff0c;我们仍然…
阅读更多...
css3的var()函数

css3的var()函数

css3的var()函数 变量要以两个连字符--(横杆)(减号)为开头 变量可以在:root{}中定义, :root可以在css中创建全局样式变量。通过 :root本身写的样式&#xff0c;相当于 html&#xff0c;但优先级比后者高。 在CSS3中&#xff0c;var()函数是一个用于插入CSS自定义属性&#xff…
阅读更多...
Active Directory 的密码管理策略

Active Directory 的密码管理策略

员工使用的密码可以决定或破坏组织中的数据安全性&#xff0c;但是&#xff0c;知道员工通常不遵循良好的密码卫生习惯也就不足为奇了。从在本机工具&#xff08;如 Windows Active Directory 组策略&#xff09;中设置弱密码和通用密码到宽松的密码策略规则&#xff0c;有几个…
阅读更多...
Eclipse - Text Editors (文本编辑器)

Eclipse - Text Editors (文本编辑器)

Eclipse - Text Editors [文本编辑器] References Window -> Preferences -> General -> Editors -> Text Editors Displayed tab witdth: 4 勾选 Insert spaces for tabs 勾选 Show line number References [1] Yongqiang Cheng, https://yongqiang.blog.csdn.n…
阅读更多...
学习总结19

学习总结19

# 奶牛的耳语 ## 题目描述 在你的养牛场&#xff0c;所有的奶牛都养在一排呈直线的牛栏中。一共有 n 头奶牛&#xff0c;其中第 i 头牛在直线上所处的位置可以用一个整数坐标 pi(0< pi < 10^8) 来表示。在无聊的日子里&#xff0c;奶牛们常常在自己的牛栏里与其它奶牛交…
阅读更多...
【Azure 架构师学习笔记】- Azure Databricks (7) --Unity Catalog(UC) 基本概念和组件

【Azure 架构师学习笔记】- Azure Databricks (7) --Unity Catalog(UC) 基本概念和组件

本文属于【Azure 架构师学习笔记】系列。 本文属于【Azure Databricks】系列。 接上文 【Azure 架构师学习笔记】- Azure Databricks (6) - 配置Unity Catalog 前言 在以前的Databricks中&#xff0c;主要由Workspace和集群、SQL Warehouse组成&#xff0c; 这两年Databricks公…
阅读更多...
NLP_BERT与GPT争锋

NLP_BERT与GPT争锋

文章目录 介绍小结 介绍 在开始训练GPT之前&#xff0c;我们先比较一下BERT和 GPT 这两种基于 Transformer 的预训练模型结构&#xff0c;找出它们的异同。 Transformer架构被提出后不久&#xff0c;一大批基于这个架构的预训练模型就如雨后春笋般地出现了。其中最重要、影响…
阅读更多...
2024全年放假日历表及调休安排 用手机便签设置放假倒计时

2024全年放假日历表及调休安排 用手机便签设置放假倒计时

对于绝大多数的上班族来说&#xff0c;春节长假已经结束&#xff0c;现在要回归到正常的工作和生活中。为了给生活增加一些“盼头”&#xff0c;很多小伙伴不约而同打开手机日历&#xff0c;查看下个法定节假日是什么时候。下面给大家具体讲一下2024全年放假日历表及调休安排&a…
阅读更多...
EasySass: could not generate CSS file. See Output panel for details.微信小程序报错及解决

EasySass: could not generate CSS file. See Output panel for details.微信小程序报错及解决

解决微信小程序导入vscode的easysass包报错 问题发现问题来源和解决制作不易&#xff0c;感谢三联&#xff0c;谢谢大家啦 问题发现 当我喜滋滋的在vscode中导入easysass包之后&#xff0c;又在微信小程序中添加vscode扩展&#xff0c;又去文件中改好了配置文件后却直接弹出了…
阅读更多...
5G——物理层仿真

5G——物理层仿真

1.前置条件 2.仿真流程 1.填写搜索过程 解&#xff1a; 2.填写每一步细节 2.2.1 准备 解&#xff1a; &#xff08;1&#xff09;BCH &#xff08;2&#xff09;BCCH 解析&#xff1a;因为PBCH是物理广播信道&#xff0c;BCCH是用于广播系统控制信息的下行信道&#…
阅读更多...
生成对抗网络----GAN

生成对抗网络----GAN

系列文章目录 文章目录 系列文章目录前言一、基本构成二、应用领域三、基本原理四、如何训练GAN 前言 一、基本构成 GAN (Generative Adversarial Network) : 通过两个神经网络&#xff0c;即生成器&#xff08;Generator&#xff09;和判别器&#xff08;Discriminator&#…
阅读更多...
【Linux 内核源码分析】虚拟内存地址空间

【Linux 内核源码分析】虚拟内存地址空间

在现代操作系统中&#xff0c;每个进程被分配了独享的虚拟内存地址空间。这个地址空间可以视为一维线性空间&#xff0c;由多个连续的内存页组成。初始时&#xff0c;操作系统会将整个虚拟地址空间分成几个不同的区域&#xff0c;每个区域用于特定的目的。以下是一个常见的布局…
阅读更多...
【Linux取经路】文件系统之重定向的实现原理

【Linux取经路】文件系统之重定向的实现原理

文章目录 一、再来理解重定向1.1 输出重定向效果演示1.2 重定向的原理1.3 dup21.4 输入重定向效果演示1.5 输入重定向代码实现 二、再来理解标准输出和标准错误2.1 同时对标准输出和标准错误进行重定向2.2 将标准输出和标准错误重定向到同一个文件 三、再看一切皆文件四、结语 …
阅读更多...
Camtasia 2023 v23.4.2.51146 Win功能强大的屏幕录制和视频编辑软件

Camtasia 2023 v23.4.2.51146 Win功能强大的屏幕录制和视频编辑软件

Camtasia 2023.3.4.2是一款适用于各类用户的屏幕录制和视频编辑软件&#xff0c;特别适合需要制作教育、培训和营销视频的专业人士。它结合了易用性和多样的功能&#xff0c;使视频制作变得更加高效和专业。 软件安装 适用于 Win10.win11系统 1.直接安装软件&#xff0c;安装…
阅读更多...
redis scan命令导致cpu飙升

redis scan命令导致cpu飙升

一.背景 今天下午Redis的cpu占用突然异常升高&#xff0c;一度占用达到了90%&#xff0c;触发了钉钉告警&#xff0c;之后又回到正常水平&#xff0c;跟DBA沟通&#xff0c;他说主要是下面这个语句的问题 SCAN 0 MATCH fastUser:6136* COUNT 10000这个语句的执行时长很短&…
阅读更多...
nginx 日志改为json格式

nginx 日志改为json格式

nginx 日志改为json格式 场景描述效果变更旧样式新样式 场景描述 正常使用nginx时&#xff0c;使用默认的日志输出格式&#xff0c;对于后续日志接入其他第三方日志收集、清洗环节&#xff0c;因分隔符问题可能不是很友好。 xxxx - - [19/Feb/2024:11:16:48 0800] "GET …
阅读更多...
并发编程线程安全之同步锁Synchronized

并发编程线程安全之同步锁Synchronized

一、原子性定义 原子性的本质是互斥访问&#xff0c;同一时刻只有一个线程对它进行访问操作 二、原子性问题的简述 public class AutomicDemo {int count 0;public static void main(String[] args) throws InterruptedException {AutomicDemo automicDemo new AutomicDem…
阅读更多...
Idea启动Gradle报错： Please, re-import the Gradle project and try again

Idea启动Gradle报错： Please, re-import the Gradle project and try again

Idea启动Gradle报错&#xff1a;Warning:Unable to make the module: reading, related gradle configuration was not found. Please, re-import the Gradle project and try again. 解决办法&#xff1a; 开启步骤&#xff1a;View -> Tool Windows -> Gradle 点击refe…
阅读更多...
最新文章

Copyright @ 2022~2023