代码随想录-Day42

1049. 最后一块石头的重量 II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

示例 1：

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。
示例 2：

输入：stones = [31,26,33,21,40]
输出：5
在这里插入图片描述

方法一：一维数组

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int i : stones) {
            sum += i;
        }
        int target = sum >> 1;
        //初始化dp数组
        int[] dp = new int[target + 1];
        for (int i = 0; i < stones.length; i++) {
            //采用倒序
            for (int j = target; j >= stones[i]; j--) {
                //两种情况，要么放，要么不放
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - 2 * dp[target];
    }
}

这段Java代码是一个解决方案，用于解决“最后的石头重量II”问题。这个问题源于LeetCode上的1049题。问题是这样的：有一堆石头，每个石头有一定的重量。在每一轮操作中，你可以选择任意两块石头然后将它们一起粉碎，新石头的重量等于两者之差的绝对值。最终，所有的石头都会变成一堆石头，而最后一块石头的重量就是这些石头的重量之和。任务是找到一种操作策略，使得最后这块石头的重量尽可能小。

代码解析

  1. 计算总重量：首先，遍历输入数组stones，计算所有石头的总重量，并存储在变量sum中。

  2. 确定目标重量：因为最终目标是最小化两堆石头重量之差，所以理论上最优情况是一堆石头的总重量尽可能接近总重量的一半。因此，设定目标重量target为sum除以2（使用右移运算符>> 1等同于除以2，用于快速整除）。

  3. 初始化动态规划数组：创建一个长度为target + 1的数组dp，用于动态规划计算。dp[j]表示能否通过选择某些石头使总重量达到j，并且这个总重量尽可能接近target。

  4. 填充动态规划数组：

    • 双层循环遍历每个石头和每个可能的目标重量。外层循环遍历石头，内层循环从target反向遍历到当前石头的重量。这是因为在考虑加入当前石头时，我们总是从最大的可能贡献开始尝试（即直接达到或接近目标重量）。
    • 对于每个石头，如果它不超重（即j >= stones[i]），则更新dp[j]为不包含当前石头能达到的最大重量dp[j]与包含当前石头能达到的新重量dp[j - stones[i]] + stones[i]之间的较大值。这体现了动态规划中的决策过程：要么选取当前石头，要么不选取。

  5. 计算结果：最后，由于dp[target]代表了最接近sum/2的最大可能重量，因此两堆石头的重量之差即为sum - 2 * dp[target]。这是因为总重量是sum，最优情况下两堆重量尽量平衡，即一边为dp[target]，另一边为sum - dp[target]，但为了求差值最小，我们直接用总重量减去两倍的dp[target]。

小结

这段代码通过动态规划的方法，有效地解决了“最后的石头重量II”问题，寻找了一种策略来最小化最终剩余石头的重量。

方法二：二维数组

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int s : stones) {
            sum += s;
        }

        int target = sum / 2;
        //初始化，dp[i][j]为可以放0-i物品，背包容量为j的情况下背包中的最大价值
        int[][] dp = new int[stones.length][target + 1];
        //dp[i][0]默认初始化为0
        //dp[0][j]取决于stones[0]
        for (int j = stones[0]; j <= target; j++) {
            dp[0][j] = stones[0];
        }

        for (int i = 1; i < stones.length; i++) {
            for (int j = 1; j <= target; j++) {//注意是等于
                if (j >= stones[i]) {
                    //不放:dp[i - 1][j] 放:dp[i - 1][j - stones[i]] + stones[i]
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        System.out.println(dp[stones.length - 1][target]);
        return (sum - dp[stones.length - 1][target]) - dp[stones.length - 1][target];
    }
}

这段代码实现了一个解决“最后一块石头的重量 II”问题的算法。这个问题可以转换成一个背包问题，下面是对代码的详细解释：

题目描述

有一堆石头，每个石头都有一个正整数的重量。每次选择两块石头进行碰撞，重量大的石头会减少重量小的石头的重量。最后剩下的石头最小可能的重量是多少？

解决思路

将石头分成两堆，使得两堆的重量差最小。为了实现这个目标，我们可以将这个问题看作是一个“0/1 背包问题”。

代码解释

  1. 计算总重量 sum

    int sum = 0;
for (int s : stones) {
    sum += s;
}

    计算所有石头的总重量 sum。

  2. 计算目标重量 target

    int target = sum / 2;

    计算背包容量的目标值 target，即总重量的一半。这是为了尽量使两堆石头的重量接近。

  3. 初始化动态规划数组 dp

    int[][] dp = new int[stones.length][target + 1];

    创建一个二维数组 dp，dp[i][j] 表示前 i 个石头中能够放入容量为 j 的背包中的最大重量。

  4. 初始化第一行

    for (int j = stones[0]; j <= target; j++) {
    dp[0][j] = stones[0];
}

    初始化第一行，即只考虑第一个石头。如果背包容量大于等于第一个石头的重量，那么可以放入这个石头。

  5. 填充动态规划数组 dp

    for (int i = 1; i < stones.length; i++) {
    for (int j = 1; j <= target; j++) {
        if (j >= stones[i]) {
            dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - stones[i]] + stones[i]);
        } else {
            dp[i][j] = dp[i - 1][j];
        }
    }
}

    填充 dp 数组。对于每个石头 i 和每个可能的背包容量 j，我们有两种选择：

    • 不放入当前石头：dp[i - 1][j]
    • 放入当前石头：dp[i - 1][j - stones[i]] + stones[i]
      取两者的最大值。

  6. 计算并返回结果

    return (sum - dp[stones.length - 1][target]) - dp[stones.length - 1][target];

    最后计算两个堆的重量差并返回。sum - dp[stones.length - 1][target] 是剩下的石头的总重量，减去 dp[stones.length - 1][target]，得到最小的剩余重量。

总结

这段代码通过动态规划解决了“最后一块石头的重量 II”的问题。它将石头分成两堆，使得两堆的重量差最小，从而得到最小的剩余重量。

494. 目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：

输入：nums = [1], target = 1
输出：1
在这里插入图片描述

方法一：

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];

        //如果target的绝对值大于sum，那么是没有方案的
        if (Math.abs(target) > sum) return 0;
        //如果(target+sum)除以2的余数不为0，也是没有方案的
        if ((target + sum) % 2 == 1) return 0;

        int bagSize = (target + sum) / 2;
        int[] dp = new int[bagSize + 1];
        dp[0] = 1;

        for (int i = 0; i < nums.length; i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }

        return dp[bagSize];
    }
}

这段代码实现了一个解决“目标和”问题的算法。题目要求是找到一种加减运算，使得数组中的元素的和等于目标值 target。这是一个变形的背包问题，下面是对代码的详细解释：

题目描述

给定一个整数数组 nums 和一个整数 target，求在数组中添加 + 或 - 符号，使得计算结果等于 target 的方法数。

解决思路

将数组划分为两个子集，使得一个子集的和减去另一个子集的和等于目标值 target。设这两个子集分别为 P 和 N。那么有以下关系：

[ P - N = \text{target} ]
[ P + N = \text{sum} ]

通过这两个方程可以得到：

[ 2P = \text{target} + \text{sum} ]

因此，问题转换为在数组中找到一个子集 P，使得 P 的和等于 (target + sum) / 2。

代码解释

  1. 计算数组总和 sum

    int sum = 0;
for (int i = 0; i < nums.length; i++) sum += nums[i];

  2. 特殊情况处理

    if (Math.abs(target) > sum) return 0;
if ((target + sum) % 2 == 1) return 0;
    • 如果 target 的绝对值大于 sum，那么无法通过加减运算得到 target。
    • 如果 (target + sum) 不是偶数，也无法找到一个整数子集和使得 P 等于 (target + sum) / 2。

  3. 计算背包容量 bagSize

    int bagSize = (target + sum) / 2;

  4. 初始化动态规划数组 dp

    int[] dp = new int[bagSize + 1];
dp[0] = 1;

    dp[j] 表示和为 j 的子集数目。初始时，和为 0 的子集只有一个，即空集。

  5. 填充动态规划数组 dp

    for (int i = 0; i < nums.length; i++) {
    for (int j = bagSize; j >= nums[i]; j--) {
        dp[j] += dp[j - nums[i]];
    }
}
    • 遍历每个数字 nums[i]。
    • 更新 dp 数组，从后向前遍历，确保每个数字只使用一次。
    • dp[j] += dp[j - nums[i]] 表示当前数字 nums[i] 可以加入和为 j - nums[i] 的子集，形成和为 j 的子集。

  6. 返回结果

    return dp[bagSize];

    返回和为 bagSize 的子集数目，即满足条件的方案数。

总结

这段代码通过将问题转换为背包问题，使用动态规划求解目标和问题。通过判断特殊情况、计算背包容量和填充动态规划数组，最终得到了满足条件的方案数。

方法二：二维数组

class Solution {
    public int findTargetSumWays(int[] nums, int target) {

        // 01背包应用之“有多少种不同的填满背包最大容量的方法“
        // 易于理解的二维数组解法及详细注释

        int sum = 0;
        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }

        // 注意nums[i] >= 0的题目条件，意味着sum也是所有nums[i]的绝对值之和
        // 这里保证了sum + target一定是大于等于零的，也就是left大于等于零（毕竟我们定义left大于right）
        if(sum < Math.abs(target)){
            return 0;
        }

        // 利用二元一次方程组将left用target和sum表示出来（替换掉right组合），详见代码随想录对此题的分析
        // 如果所求的left数组和为小数，则作为整数数组的nums里的任何元素自然是没有办法凑出这个小数的
        if((sum + target) % 2 != 0) {
            return 0;
        }

        int left = (sum + target) / 2;
        
        // dp[i][j]：遍历到数组第i个数时， left为j时的能装满背包的方法总数
        int[][] dp = new int[nums.length][left + 1];

        // 初始化最上行（dp[0][j])，当nums[0] == j时（注意nums[0]和j都一定是大于等于零的，因此不需要判断等于-j时的情况），有唯一一种取法可取到j，dp[0][j]此时等于1
        // 其他情况dp[0][j] = 0
        // java整数数组默认初始值为0
        if (nums[0] <= left) {
            dp[0][nums[0]] = 1;
        }

        // 初始化最左列（dp[i][0])
        // 当从nums数组的索引0到i的部分有n个0时（n > 0)，每个0可以取+/-，因此有2的n次方中可以取到j = 0的方案
        // n = 0说明当前遍历到的数组部分没有0全为正数，因此只有一种方案可以取到j = 0（就是所有数都不取）
        int numZeros = 0;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] == 0) {
                numZeros++;
            }
            dp[i][0] = (int) Math.pow(2, numZeros);

        }

        // 递推公式分析：
        // 当nums[i] > j时，这时候nums[i]一定不能取，所以是dp[i - 1][j]种方案数
        // nums[i] <= j时，num[i]可取可不取，因此方案数是dp[i - 1][j] + dp[i - 1][j - nums[i]]
        // 由递推公式可知，先遍历i或j都可
        for(int i = 1; i < nums.length; i++) {
            for(int j = 1; j <= left; j++) {
                if(nums[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
                }
            }
        }

	// 打印dp数组
        // for(int i = 0; i < nums.length; i++) {
        //     for(int j = 0; j <= left; j++) {
        //         System.out.print(dp[i][j] + " ");
        //     }
        //     System.out.println("");
        // }

        return dp[nums.length - 1][left];
        
    }
}

这段代码实现了一个解决“目标和”问题的算法，使用二维动态规划数组来计算有多少种不同的方法可以使数组中的元素加减组合得到目标值 target。下面是对代码的详细解释：

题目描述

给定一个整数数组 nums 和一个整数 target，求在数组中添加 + 或 - 符号，使得计算结果等于 target 的方法数。

解决思路

通过将问题转换为背包问题，找到一种加减运算，使得数组中的元素的和等于目标值 target。具体来说，将数组划分为两个子集，使得一个子集的和减去另一个子集的和等于目标值 target。这可以通过以下关系来实现：

[ P - N = \text{target} ]
[ P + N = \text{sum} ]

通过这两个方程可以得到：

[ 2P = \text{target} + \text{sum} ]

因此，问题转换为在数组中找到一个子集 P，使得 P 的和等于 (target + sum) / 2。

代码解释

  1. 计算数组总和 sum

    int sum = 0;
for (int i = 0; i < nums.length; i++) {
    sum += nums[i];
}

  2. 特殊情况处理

    if (sum < Math.abs(target)) {
    return 0;
}
if ((sum + target) % 2 != 0) {
    return 0;
}
    • 如果 target 的绝对值大于 sum，那么无法通过加减运算得到 target。
    • 如果 (sum + target) 不是偶数，也无法找到一个整数子集和使得 P 等于 (target + sum) / 2。

  3. 计算 left

    int left = (sum + target) / 2;

  4. 初始化动态规划数组 dp

    int[][] dp = new int[nums.length][left + 1];
if (nums[0] <= left) {
    dp[0][nums[0]] = 1;
}

    dp[i][j] 表示遍历到数组第 i 个数时，和为 j 的方法总数。

  5. 初始化最左列 dp[i][0]

    int numZeros = 0;
for (int i = 0; i < nums.length; i++) {
    if (nums[i] == 0) {
        numZeros++;
    }
    dp[i][0] = (int) Math.pow(2, numZeros);
}
    • 初始化最左列，当和为 0 时，如果数组中有 n 个 0，则有 2^n 种方案，因为每个 0 可以取 + 或 -。

  6. 填充动态规划数组 dp

    for (int i = 1; i < nums.length; i++) {
    for (int j = 1; j <= left; j++) {
        if (nums[i] > j) {
            dp[i][j] = dp[i - 1][j];
        } else {
            dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
        }
    }
}
    • 遍历每个数字 nums[i] 和每个可能的背包容量 j。
    • 如果 nums[i] > j，则当前数字不能放入背包，方案数为 dp[i - 1][j]。
    • 否则，方案数为 dp[i - 1][j] + dp[i - 1][j - nums[i]]，即不放入当前数字的方案数加上放入当前数字的方案数。

  7. 返回结果

    return dp[nums.length - 1][left];

    返回和为 left 的方法数，即满足条件的方案数。

总结

这段代码通过将问题转换为背包问题，使用二维动态规划数组来求解目标和问题。通过初始化和填充动态规划数组，最终得到了满足条件的方案数。

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
示例 2：

输入：strs = [“10”, “0”, “1”], m = 1, n = 1
输出：2
解释：最大的子集是 {“0”, “1”} ，所以答案是 2 。
在这里插入图片描述

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        //dp[i][j]表示i个0和j个1时的最大子集
        int[][] dp = new int[m + 1][n + 1];
        int oneNum, zeroNum;
        for (String str : strs) {
            oneNum = 0;
            zeroNum = 0;
            for (char ch : str.toCharArray()) {
                if (ch == '0') {
                    zeroNum++;
                } else {
                    oneNum++;
                }
            }
            //倒序遍历
            for (int i = m; i >= zeroNum; i--) {
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
}

这段代码实现了一个解决“01背包”问题的算法，具体是关于求最大子集的问题。题目要求给定一个包含仅由 '0' 和 '1' 组成的字符串数组 strs，以及两个整数 m 和 n，要求找出数组中的最大子集，该子集中的 '0' 的数量不超过 m，且 '1' 的数量不超过 n。

解决思路

这是一个典型的二维“01背包”问题。每个字符串可以看作是一个物品，字符串中 '0' 的数量和 '1' 的数量分别对应物品的重量。目标是选择尽可能多的字符串，使得总的 '0' 和 '1' 的数量不超过 m 和 n。

代码解释

  1. 初始化动态规划数组 dp

    int[][] dp = new int[m + 1][n + 1];

    dp[i][j] 表示在最多有 i 个 '0' 和 j 个 '1' 的情况下，可以组成的最大子集的大小。

  2. 遍历每个字符串 str

    int oneNum, zeroNum;
for (String str : strs) {
    oneNum = 0;
    zeroNum = 0;
    for (char ch : str.toCharArray()) {
        if (ch == '0') {
            zeroNum++;
        } else {
            oneNum++;
        }
    }
    • 统计字符串中 '0' 和 '1' 的数量。
    • oneNum 表示字符串中 '1' 的数量。
    • zeroNum 表示字符串中 '0' 的数量。

  3. 更新动态规划数组 dp

    for (int i = m; i >= zeroNum; i--) {
    for (int j = n; j >= oneNum; j--) {
        dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
    }
}
    • 通过倒序遍历来确保每个字符串只被计算一次。
    • 对于每个 dp[i][j]，考虑当前字符串是否放入背包：
      • 如果不放入，dp[i][j] 保持不变。
      • 如果放入，新的状态是 dp[i - zeroNum][j - oneNum] + 1。
      • 取两者的最大值更新 dp[i][j]。

  4. 返回结果

    return dp[m][n];

    最后，dp[m][n] 即为最多有 m 个 '0' 和 n 个 '1' 的情况下，可以组成的最大子集的大小。

总结

这段代码通过动态规划解决了“01背包”问题。使用二维数组 dp 来存储在不同的 '0' 和 '1' 限制下可以组成的最大子集的大小。通过遍历每个字符串，计算其 '0' 和 '1' 的数量，并更新 dp 数组，最终得到满足条件的最大子集大小。

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

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

相关文章

定制型汽车传感器在汽车中的应用

定制型汽车传感器在汽车中的应用

定制型汽车霍尔传感器在汽车中的应用及功能 曲轴和凸轮轴位置传感器&#xff1a; 这些传感器用于监测发动机的曲轴和凸轮轴的位置&#xff0c;帮助发动机管理系统精确控制点火时机和燃油喷射&#xff0c;提高发动机效率。 变速器控制系统&#xff1a; 在自动变速器中&#xf…
阅读更多...
通达信短线抄底主升浪幅图指标公式源码

通达信短线抄底主升浪幅图指标公式源码

通达信短线抄底主升浪幅图指标公式源码&#xff1a; A1:REF(C,1); A2:SMA(MAX(C-A1,0),5,1)/SMA(ABS(C-A1),5,1)*1000; A3:BARSLAST(REF(CROSS("RSI.RSI1"(6,12,24),"RSI.RSI2"(6,12,24)),1)); A4:A2-LLV(A2,10); A5:(MA(A4,2)*3A4*13)/16; A6:IF(A5>1…
阅读更多...
PTE-靶场训练-1

PTE-靶场训练-1

PTE-靶场训练实战笔记 靶场搭建 靶场下载链接&#xff1a; https://pan.baidu.com/s/1ce1Kk0hSYlxrUoRTnNsiKA?pwdha1x vim /etc/sysconfig/network-scripts/ifcfg-eth0 设置好后reboot重启一下即可&#xff0c;然后访问81-85端口&#xff0c;共5题。 因为靶场出了问题&a…
阅读更多...
学生信息管理系统

学生信息管理系统

DDL和DML -- 创建学生表 CREATE TABLE students (student_id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(50),age INT,gender VARCHAR(10) );-- 创建课程表 CREATE TABLE courses (course_id INT PRIMARY KEY AUTO_INCREMENT,course_name VARCHAR(50) );-- 创建教师表 CREA…
阅读更多...
酷瓜云课堂（内网版）v1.1.5 发布，局域网在线学习+考试系统

酷瓜云课堂（内网版）v1.1.5 发布，局域网在线学习+考试系统

更新内容 更新layui-v2.9.10更新docker国内镜像地址增加导入镜像构建容器的方式教师不批阅非首次考试试卷轮播图增加专栏类型目标链接增加课程能否发布检查去除初始化kindeditor语言文件去除选择题EF选项优化富文本内容显示样式优化内容图片点击放大监听优化试题题干答案等图片…
阅读更多...
基于STM32的智能水质监测系统

基于STM32的智能水质监测系统

目录 引言环境准备智能水质监测系统基础代码实现&#xff1a;实现智能水质监测系统 4.1 数据采集模块4.2 数据处理与分析4.3 控制系统实现4.4 用户界面与数据可视化应用场景&#xff1a;水质管理与优化问题解决方案与优化收尾与总结 1. 引言 智能水质监测系统通过使用STM32嵌…
阅读更多...
ONLYOFFICE桌面编辑器8.1版：个性化编辑和功能强化的全面升级

ONLYOFFICE桌面编辑器8.1版：个性化编辑和功能强化的全面升级

ONLYOFFICE是一款全面的办公套件&#xff0c;由Ascensio System SIA开发。该软件提供了一系列与微软Office系列产品相似的办公工具&#xff0c;包括处理文档&#xff08;ONLYOFFICE Document Editor&#xff09;、电子表格&#xff08;ONLYOFFICE Spreadsheet Editor&#xff0…
阅读更多...
Pycharm主题切换(禁用)导致UI界面显示异常解决

Pycharm主题切换(禁用)导致UI界面显示异常解决

安装其他主题 Material Theme UI One Dark theme One Dark theme安装 (Material Theme UI主题同理) Pycharm 打开 Settings > Plugins&#xff0c;搜索One Dark theme 安装即可 One Dark theme 效果显示 问题记录 UI显示异常 安装多个主题时&#xff0c;当禁用某些主题&…
阅读更多...
通信协议总结

通信协议总结

IIC 基本特点 同步&#xff0c;半双工 标准100KHz&#xff0c;最高400KHz&#xff08;IIC主要应用于低速设备&#xff09; 硬件组成 需外接上拉电阻 通信过程 空闲状态 SDA和SCL都处于高电平 开始信号S和终止信号P 在数据传输过程中&#xff0c;当SCL0时&#xff0c;SDA才…
阅读更多...
Redis-主从复制-测试主从模式下的读写操作

Redis-主从复制-测试主从模式下的读写操作

文章目录 1、在主机6379写入数据2、在从机6380上写数据报错3、从机只能读数据&#xff0c;不能写数据 1、在主机6379写入数据 127.0.0.1:6379> keys * (empty array) 127.0.0.1:6379> set uname jim OK 127.0.0.1:6379> get uname "jim" 127.0.0.1:6379>…
阅读更多...
高中数学：不等式-常见题型解题技巧

高中数学：不等式-常见题型解题技巧

一、“1”的代换 练习 例题1 例题2 解 二、基本不等式中的“变形” 就是&#xff0c;一般情况下&#xff0c;我们在题目中&#xff0c;是不能够直接使用基本不等式进行求解的。 而是要对条件等式进行变形&#xff0c;满足基本不等式的使用条件 练习 例题1 解析 两边同…
阅读更多...
002关于Geogebra软件的介绍及与MatLab的区别

002关于Geogebra软件的介绍及与MatLab的区别

为什么要学Geogebra&#xff1f; 因为和MatLab的科学计算相比&#xff0c;GeoGebra重点突出教学展示&#xff0c;对于教师、学生人群来讲再合适不过了&#xff0c;尤其是可以融入到PPT里边呈现交互式动画&#xff0c;想想听众的表情&#xff01;这不就弥补了看到PPT播放数学公…
阅读更多...
关于ONLYOFFICE8.1版本桌面编辑器测评——AI时代的领跑者

关于ONLYOFFICE8.1版本桌面编辑器测评——AI时代的领跑者

关于作者&#xff1a;个人主页 目录 一.产品介绍 1.关于ONLYOFFICE 2.关于产品的多元化功能 二.关于产品体验方式 1.关于套件的使用网页版登录 2.关于ONLYOFFICE本地版 三.关于产品界面设计 四.关于产品文字处理器&#xff08;Document Editor&#xff09; 1.电子表格&a…
阅读更多...
1954springboot VUE 天然气系统隐患管理系统开发mysql数据库web结构java编程计算机网页源码maven项目

1954springboot VUE 天然气系统隐患管理系统开发mysql数据库web结构java编程计算机网页源码maven项目

一、源码特点 springboot VUE天然气系统隐患管理系统是一套完善的完整信息管理类型系统&#xff0c;结合springboot框架和VUE完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用springboot框架&#xff08;MVC 模式开发&#xff09;&#xff0c;系统具有完整的…
阅读更多...
【HarmonyOS4学习笔记】《HarmonyOS4+NEXT星河版入门到企业级实战教程》课程学习笔记（十九）

【HarmonyOS4学习笔记】《HarmonyOS4+NEXT星河版入门到企业级实战教程》课程学习笔记（十九）

课程地址&#xff1a; 黑马程序员HarmonyOS4NEXT星河版入门到企业级实战教程&#xff0c;一套精通鸿蒙应用开发 &#xff08;本篇笔记对应课程第 29 节&#xff09; P29《28.网络连接-第三方库axios》 要想使用第三方库axios&#xff0c;需要先安装ohpm&#xff0c;因为 axios…
阅读更多...
Jupyter Notebook 说明 和 安装教程【WIN MAC】

Jupyter Notebook 说明 和 安装教程【WIN MAC】

一、Jupyter Notebook 简介&#xff08;来源百度百科&#xff09; Jupyter Notebook&#xff08;此前被称为 Python notebook&#xff09;是一个交互式笔记本&#xff0c;支持运行40多种编程语言。 Jupyter Notebook 的本质是一个Web应用程序&#xff0c;便于创建和共享程序文…
阅读更多...
git基本使用（二）：git分支的操作命令

git基本使用（二）：git分支的操作命令

Git 的多分支管理是指在同一个仓库中创建和管理多个分支&#xff0c;每个分支可以独立开发&#xff0c;互不干扰。分支是 Git 中的一种强大功能&#xff0c;允许开发人员同时在多个不同的功能、修复或实验上工作&#xff0c;而不会影响主分支或其他分支。通过多分支管理&#x…
阅读更多...
240627_关于CNN中图像维度变化问题

240627_关于CNN中图像维度变化问题

240627_关于CNN中图像维度变化问题 在学习一些经典模型时&#xff0c;其中得维度变化关系总搞不太明白&#xff0c;集中学习了以下&#xff0c;在此作以梳理总结&#xff1a; 一般来说涉及到的维度变换都是四个维度&#xff0c;当batch size4&#xff0c;图像尺寸为640*640&a…
阅读更多...
Kubernetes之Scheduler详解

Kubernetes之Scheduler详解

本文尝试从Kubernetes Scheduler的功能介绍、交互逻辑、伪代码实现、最佳实践、自定义Scheduler举例及其历史演进6个方面进行详细阐述。希望对您有所帮助&#xff01; 一、Kubernetes Scheduler 功能 Kubernetes Scheduler 是 Kubernetes 集群的核心组件之一&#xff0c;负责…
阅读更多...
数据处理python

数据处理python

1.列筛选 &#xff08;1&#xff09;某一列&某几列 对于一个表单里面的数据&#xff0c;如果我们想要对于这个表单里面的数据进行处理&#xff0c;我们可以一列一列进行处理&#xff0c;也可以多列一起进行处理&#xff1b; 一列一列处理&#xff1a; 只需要在这个dataf…
阅读更多...
最新文章

Copyright @ 2022~2023