代码随想录-Day42

news2024/10/7 4:35:25

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 数组，最终得到满足条件的最大子集大小。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

检索增强生成RAG系列2--提高RAG准确度的关键点

检索增强生成RAG系列2--提高RAG准确度的关键点

上一章讲到了RAG的基本流程&#xff0c;但是如果只是完成一个基本流程&#xff0c;想要在商业上使用还是不行&#xff0c;因为正常商业上的使用其准确度至少有个90%甚至更高。那么如何提高RAG的准确度&#xff0c;那么需要看看RAG有哪些关键点。 目录 1 RAG结构图2 文档处理3 …
阅读更多...
MySQL之可扩展性(六)

MySQL之可扩展性(六)

可扩展性 向外扩展 12.重新均衡分片数据 如有必要&#xff0c;可以通过在分片间移动数据来达到负载均衡。举个例子&#xff0c;许多读者可能听一些大型图片分享网站或流行社区网站的开发者提到过用于分片间移动用户数据的工具。在分片间移动数据的好处很明显。例如&#xff…
阅读更多...
springboot+vue+mybatis母婴二手销售系统+PPT+论文+讲解+售后

springboot+vue+mybatis母婴二手销售系统+PPT+论文+讲解+售后

目前由于我国二手销售的规模较小,同发达国家相比,二手销售比重始终偏低,消费总额增长缓慢,进一步抑制了市场消费的提升,随着市场竞争的日益激烈,虽然许多商家主动选用二手销售模式,但却缺乏对其充分的重视与销售风险的良性控制,一些商家没有建立独立的信用实践管理部门,无法在交…
阅读更多...
python OpenCV 库中的 cv2.Canny() 函数来对图像进行边缘检测，并显示检测到的边缘特征

python OpenCV 库中的 cv2.Canny() 函数来对图像进行边缘检测，并显示检测到的边缘特征

import cv2# 加载图像 image cv2.imread(4.png)# 使用 Canny 边缘检测算法提取边缘特征 edges cv2.Canny(image, 100, 200)# 显示边缘特征 cv2.imshow(Edges, edges) cv2.waitKey(0) cv2.destroyAllWindows() 代码解析&#xff1a; 导入 OpenCV 库&#xff1a; import cv2加…
阅读更多...
Linux 安装 MySQL 8.0.26

Linux 安装 MySQL 8.0.26

1、MySQL 8.0.26 下载 官方网站下载 MySQL 8.0.26 安装包&#xff0c;下载地址&#xff1a;mysql8.0.26 本案例采用Linux 64位操作系统进行讲解&#xff0c;通过wget命令下载安装包。 使用df -lh命令查看&#xff0c;磁盘大小&#xff0c;尽量安装在比较大的磁盘下&#xff0c…
阅读更多...
猫狗识别—静态图像识别

猫狗识别—静态图像识别

猫狗识别—静态图像识别 1. 导入必要的库:2. 设置数据目录和模型路径:3. 定义图像转换4. 使用GPU5. 加载没有预训练权重的ResNet模型6. 创建Tkinter窗口:7.定义选择图片的函数:8.定义预测图片的函数:9.退出程序的函数:10.创建按钮:11.运行Tkinter事件循环:12. 完整代码&#xf…
阅读更多...
不止是只有维度建模，数据仓库还有Data Vault建模

不止是只有维度建模，数据仓库还有Data Vault建模

引言 在数据仓库设计中&#xff0c;传统的星型和雪花型模型有着各自的优势和劣势。随着数据量的增大和数据源的多样化&#xff0c;Data Vault&#xff08;数据仓库&#xff09;建模方法逐渐受到关注和应用。Data Vault建模是一种灵活、可扩展、适应性强的建模方法&#xff0c;…
阅读更多...
视频多功能闪剪助手，智能去重去水印一键剪辑

视频多功能闪剪助手，智能去重去水印一键剪辑

这款软件具有全平台去水印的功能&#xff0c;无论视频来自哪个平台&#xff0c;无论水印的位置如何变换&#xff0c;它都能轻松去除。同时&#xff0c;它还支持各种去重方法&#xff0c;无论重复内容的形式如何&#xff0c;它都能一一识别并移除&#xff0c;让你的视频内容始终…
阅读更多...
HarmonyOS Next开发学习手册——层叠布局 (Stack)

HarmonyOS Next开发学习手册——层叠布局 (Stack)

概述 层叠布局&#xff08;StackLayout&#xff09;用于在屏幕上预留一块区域来显示组件中的元素&#xff0c;提供元素可以重叠的布局。层叠布局通过 Stack 容器组件实现位置的固定定位与层叠&#xff0c;容器中的子元素依次入栈&#xff0c;后一个子元素覆盖前一个子元素&…
阅读更多...
SpringCloud Alibaba Sentinel规则持久化实践总结

SpringCloud Alibaba Sentinel规则持久化实践总结

默认情况下&#xff0c;一旦我们重启应用&#xff0c;sentinel规则将消失&#xff0c;生产环境需要将配置规则进行持久化。这里我们实践将Sentinel持久化到Nacos中。 ① pom依赖 我们引入sentinel-datasource-nacos&#xff1a; <dependency><groupId>com.aliba…
阅读更多...
【Android Studio】Notification通知提醒功能完整代码以及踩坑记录

【Android Studio】Notification通知提醒功能完整代码以及踩坑记录

前言&#xff1a;在最近学习安卓通知功能的开发中&#xff0c;遇到了一些坑&#xff0c;困扰了我一些时间&#xff0c;搜集了大量资料写个博客总结一下&#xff0c;希望对大家有帮助。 目录 一、启动项目闪退 1.1、问题详情 1.2、解决方法 二、点击通知无法跳转 2.1、问题…
阅读更多...
计算机缺失OpenCL.dll怎么办，OpenCL.dll丢失的多种解决方法

计算机缺失OpenCL.dll怎么办，OpenCL.dll丢失的多种解决方法

在使用电脑的过程中&#xff0c;我们经常会遇到一些开机弹窗问题。其中&#xff0c;开机弹窗找不到OpenCL.dll是一种常见的情况。本文将详细介绍开机弹窗找不到OpenCL.dll的原因分析、解决方法以及预防措辞&#xff0c;帮助大家更好地解决这一问题。 一&#xff0c;了解OpenCL.…
阅读更多...
[AIGC] Doris：一款高效的MPP数据仓库引擎

[AIGC] Doris：一款高效的MPP数据仓库引擎

在大数据处理的领域中&#xff0c;Apache Doris&#xff08;原百度 Palo&#xff09;是一个高效的MPP&#xff08;大规模并行处理&#xff09;数据仓库&#xff0c;最初由百度开发&#xff0c;现在已经成为Apache的孵化项目。 (图片取自百度) – 文章目录 1. Doris的基础知识…
阅读更多...
并发 多线程

并发 多线程

目录 thread thread 类总览 构造函数 join joinable ​编辑 detach swap yield swap 成员函数的调用 namespace::this_thread 线程同步--锁 互斥锁mutex 递归锁recursive_mutex 定时锁 Lock 锁辅助类 lock_guard​编辑 unique_lock std::lock 解决死锁问题 消息…
阅读更多...
华为认证hcna题库背诵技巧有哪些?hcna和hcia有什么区别?

华为认证hcna题库背诵技巧有哪些?hcna和hcia有什么区别?

大家都知道华为认证hcna是有题库供考生刷题备考的&#xff0c;但题库中海量的题目想要在短时间背诵下来可并不是一件容易的事情&#xff0c;这就需要我们掌握一定的技巧才行。华为认证hcna题库背诵技巧有哪些? hcna和hcna这二者又有什么区别呢?今天的文章将为大家进行详细解…
阅读更多...
鸿蒙开发设备管理：【@ohos.batteryInfo (电量信息)】

鸿蒙开发设备管理：【@ohos.batteryInfo (电量信息)】

电量信息 该模块主要提供电池状态和充放电状态的查询接口。 说明&#xff1a; 本模块首批接口从API version 6开始支持。后续版本的新增接口&#xff0c;采用上角标单独标记接口的起始版本。 导入模块 import batteryInfo from ohos.batteryInfo;属性 描述电池信息。 系统能…
阅读更多...
汇川学习笔记7 - 雕刻机项目

汇川学习笔记7 - 雕刻机项目

1、系统上电轴准备好之后&#xff0c;自动复回原点一次&#xff0c; 2、在雕刻机面板上有三个按钮用来控制画三种图形 3、注意cnc代码放置的文件夹 4、FILE0文件内容 5、FILE1文件内容 6、FILE2文件内容 7、程序代码下载地址 https://download.csdn.net/download/qq_6191667…
阅读更多...
设置日历程序

设置日历程序

目录 一 设计原型 二 后台源码 一 设计原型 二 后台源码 namespace 设置日历 {public partial class Form1 : Form{public Form1(){InitializeComponent();}private void dateTimePicker1_ValueChanged(object sender, EventArgs e){richTextBox1.Text dateTimePicker1.T…
阅读更多...
CCSP自考攻略+经验总结

CCSP自考攻略+经验总结

备考攻略 备考攻略准备阶段通读阶段精度阶段总复习阶段刷题阶段命运审判 写到最后 备考攻略 趁着对ssp知识点的理解还在&#xff0c;开始ccsp的考证之路&#xff0c;文章结构还是按照cissp备考篇的结构梳理。本次备考和cissp的离职在家备考不同&#xff0c;ccsp是在职利用非工…
阅读更多...
鸿蒙开发Ability Kit（程序框架服务）：【ServiceAbility切换】 组件切换

鸿蒙开发Ability Kit（程序框架服务）：【ServiceAbility切换】 组件切换

ServiceAbility切换 FA模型中的ServiceAbility对应Stage模型中的ServiceExtensionAbility。Stage模型下的ServiceExtensionAbility为系统API&#xff0c;只有系统应用才可以创建。因此&#xff0c;FA模型的ServiceAbility的切换&#xff0c;对于系统应用和三方应用策略有所不同…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023