【JAVA-排列组合】一个套路速解排列组合题

说明

在初遇排列组合题目时，总让人摸不着头脑，但是做多了题目后，发现几乎能用同一个模板做完所有这种类型的题目，大大提高了解题效率。本文简要介绍这种方法。

题目列表

所有题目均从leetcode查找，便于在线验证
46.全排列
47.全排列 II
78.子集
90.子集 II
39.组合总和
40.组合总和 II

模板代码

本文所有题目都可以用以下模板代码解决：

public class Template{
    private List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> path = new LinkedList<>();
        dfs(nums, path);
        return res;
    }
    private void dfs(int[] nums, LinkedList<Integer> path) {
        if (path.size() == nums.length) { 
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            path.addLast(nums[i]);
            dfs(nums,path);
            path.removeLast();
        }
    }
}

上述代码是求nums（无重复元素）的全排列，每个元素允许选择多次。以1，2，3为例，如下图所示，从上往下看，选择第一个元素的时候，
可以选择1，2，3，假设第一个选定为1（将选定的元素存入path中，即path=[1]），那么第二个元素也能选择1，2，3，同理，第二个元素也选择1，即path=[1,1]时，选择第三个元素，依然能选择1，2，3。当第三个元素选定后，此时path的长度等于nums的长度，一个排列结果就计算出来了，加入到结果res中去，接着回溯，按照同样的逻辑运行下去，最后得到全排列结果。
在这里插入图片描述

题解

46. 全排列

题目描述

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。你可以按任意顺序返回答案。
示例 1：

输入： nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入： nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入： nums = [1]
输出：[[1]]

思路

和模板代码相比，只多一个限制：

  1. 一个元素只能选择一次。

还是以1，2，3为例，如下图，当path=[1]，选择第二个元素时，由于已经选择了1，所以再选择1时，应该被剪掉（红叉表示）。
为了判断某个元素是否被使用过，可以定义一个used数组，维护方式如下：

  1. 当元素被加入path中时，该元素被使用，used[i]=1；
  2. 当元素被移除path时，该元素未被使用，used[i]=0；
    在计算时，如果发现元素已经被使用，则剪枝。

在这里插入图片描述

完整代码

package leetcode.plzh;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Permute_046 {
    private List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        if(nums.length==0) return res;
        LinkedList<Integer> path = new LinkedList<>();
        int[] used = new int[nums.length];
        dfs(nums, path, used);
        return res;
    }

    private void dfs(int[] nums, LinkedList<Integer> path, int[] used) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if(used[i]==1) continue;//剪枝，同个元素不能选择多次
            path.addLast(nums[i]);
            used[i] = 1;
            dfs(nums,path,used);
            path.removeLast();
            used[i] = 0;
        }
    }
}

执行结果

在这里插入图片描述

小结

求数字数组（无重复元素）的全排列，在模板代码的基础上修改：

  1. 已经选择过的数字不能重复选择（使用used数组判断某个元素是否被使用过）

47.全排列 II

题目描述

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：

输入： nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]

示例 2：

输入： nums = [1,2,3]
输出：
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

思路

和模板代码相比，多了以下限制：

  1. 一个元素只能选择一次。
  2. 可能存在重复元素

重复元素造成之前的全排列结果存在重复，现在的问题是怎么去重？
以1，1，2为例，如下图，我们第一个元素可以选择1，1，2，很明显选择第一个1的排列和选择第二个1的排列情况相同，所以选择第二个1的时候应该剪枝。为了判断重复，可以先将nums从小到大排序，如果：i>0&&nums[i]==nums[i-1]，说明重复，应该剪枝（i等于0时，代表该元素第一次被选择，肯定不存在重复）。

在这里插入图片描述

需要注意的是，再上图绿色标记部分，此时path=[1], 选择第二个元素时，遍历i的范围为0,1,2。即第二个元素有可能加入nums[0],nums[1],nums[2]。

  1. i=0时，如果第二个元素选择nums[0],因为path中已经选择了第一个1，所以剪枝（used[i]==1）
  2. i=1时，path：[1,1]
  3. i=2时，path：[1,2]

上面的步骤2来看，满足条件：i>0&&nums[i]==nums[i-1]，按照上面的逻辑，应该被剪枝，但是显然[1,1,2]是一个合法的排列结果，不应该被剪掉。仔细观察发现，只有同层存在相同元素时才应该剪枝，不同层则不应该剪。

  1. 对于应该被剪枝的部分（红x标记），回溯后，第一个1会被标记为未使用，即：nums[i-1]=0
  2. 对于不应该被剪枝的部分（绿色标记），第一个1会被标记为使用，即：nums[i-1]=1

现在我们只取情况1，所以判断条件可以改写为：nums[i]==nums[i-1]&&used[i-1]==0

完整代码

package leetcode.plzh;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class PermuteUnique_047 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> permuteUnique(int[] nums) {
        if (nums.length == 0) return res;
        List<Integer> path = new ArrayList<>();
        int[] used = new int[nums.length];
        Arrays.sort(nums);//排序，方便判断同层是否重复，nums[i-1]==nums[i]则重复
        dfs(nums, path, used);
        return res;
    }

    private void dfs(int[] nums, List<Integer> path, int[] used) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i] == 1) continue;//剪枝，同个元素不能选多次，
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0) continue;//剪枝，避免同层重复
            path.add(nums[i]);
            used[i] = 1;
            dfs(nums, path, used);
            path.remove(path.size() - 1);
            used[i] = 0;
        }
    }
}

执行结果

在这里插入图片描述

小结

求数字数组（有重复元素）的全排列，在模板代码的基础上修改：

  1. 已经选择过的数字不能重复选择（使用used数组判断某个元素是否被使用过）
  2. 使用nums[i]==nums[i-1]判断重复：对nums从小到大排序
  3. 同层重复剪枝（nums[i]==nums[i-1]&&used[i-1]==0）

78.子集

题目描述

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：

输入： nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入： nums = [0]
输出： [[],[0]]

思路

和模板代码相比，多了以下限制：

  1. 一个元素只能选择一次。
  2. 求子集，其长度不一定是nums.length，而是在这个范围：[0,nums.length]
  3. 求的是组合，而非排列，即[1,2]，[2,1]是同一种结果

对于限制2：

长度不再是nums.length，那么在向res加入path时，应该分别判断长度是0~nums.length时，加入结果。

对于限制3：
以1，2，3为例，如果将nums排序后，path后入的元素比上一个元素还要小时，应该剪枝。
在这里插入图片描述

完整代码

package leetcode.plzh;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class Subsets_078 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> subsets(int[] nums) {
        if (nums.length == 0) return res;
        LinkedList<Integer> path = new LinkedList<>();
        int[] used = new int[nums.length];
        Arrays.sort(nums);//保证后入的元素一定大于先入的元素，所以排序
        for (int i = 0; i <= nums.length; i++) {
            dfs(nums, path, used, i);
        }

        return res;
    }

    private void dfs(int[] nums, LinkedList<Integer> path, int[] used, int len) {
        if (path.size() == len) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i] == 1) continue;//剪枝，同个元素不能选多次，
            if (!path.isEmpty() && nums[i] < path.peekLast()) continue;//剪枝，选择的下个元素比上个元素还要小
            path.addLast(nums[i]);
            used[i] = 1;
            dfs(nums, path, used, len);
            path.removeLast();
            used[i] = 0;
        }
    }
}

执行结果

在这里插入图片描述

优化代码

可以优化如下：

dfs中的for循环不是固定从0开始，而是从传入的begin开始。第一个元素从0开始找，第二个元素就只能从1开始找。总是从排序数组的下个元素找，包含两个隐含信息，同一个元素不可能被同时选择多次；下一个总是大于上一个元素。所以之前的剪枝逻辑都可以去掉。

package leetcode.plzh;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Subsets_078 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> subsets(int[] nums) {
        if (nums.length == 0) return res;
        List<Integer> path = new ArrayList<>();
        Arrays.sort(nums);
        dfs(nums, 0,path);
        return res;
    }

    private void dfs(int[] nums, int begin,List<Integer> path) {
        res.add(new ArrayList<>(path));
        for (int i = begin; i < nums.length; i++) {
            path.add(nums[i]);
            dfs(nums, i+1,path);//不能继续找当前元素，直接找下个元素，path中不可能选择到同一个元素，下一个也始终比上一个大
            path.remove(path.size() - 1);

        }
    }
}

优化执行结果

在这里插入图片描述
备注：后面的组合题，都可以使用这个模板

小结

求数组（无重复元素）的子集：
1.对nums排序
2.修改dfs中的for循环，让i从begin开始，下次遍历时用dfs(nums, i+1,path)

90.子集 II

题目描述

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
示例 1：

输入： nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入： nums = [0]
输出： [[],[0]]

思路

和78 子集相比，多了以下限制：

  1. nums可能包含重复数组

去重逻辑：同层相同则剪枝，nums[i]==nums[i-1]&&used[i-1]==0
在这里插入图片描述

完整代码

package leetcode.plzh;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SubsetsWithDup_090_02 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums.length == 0) return res;
        List<Integer> path = new ArrayList<>();
        int[] used = new int[nums.length];
        Arrays.sort(nums);
        dfs(nums, 0, path, used);
        return res;
    }
    private void dfs(int[] nums, int begin, List<Integer> path, int[] used) {
        res.add(new ArrayList<>(path));
        for (int i = begin; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0) continue;//同层相同，则剪枝
            path.add(nums[i]);
            used[i] = 1;
            dfs(nums, i + 1, path, used);
            path.remove(path.size() - 1);
            used[i] = 0;
        }
    }
}

执行结果

在这里插入图片描述

小结

求数组（有重复元素）的子集：
1.对nums排序
2.修改dfs中的for循环，让i从begin开始，下次遍历时用dfs(nums, i+1,path)
3. 增加同层相同元素的剪枝逻辑：i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0

39.组合总和

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。
示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

思路

和78 子集相比，多了以下限制：

  1. 一个元素可以选择多次
  2. 目标和要等于target

对于限制1：修改dfs中下一个遍历为：dfs(nums, i，path)，
对于限制2：只有当目标和等于target时，才加入res中，为了避免死循环，比如一直选第一个元素，当path中的和大于target时，应该中止该分支的查找（不再向path中加入新的值），直接return。

完整代码

package leetcode.plzh;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class CombinationSum_039 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<Integer> path = new ArrayList<>();
        Arrays.sort(candidates);
        dfs(candidates, 0, path, target);

        return res;
    }

    private static int cnt = 0;

    private void dfs(int[] candidates, int begin, List<Integer> path, int target) {
        int total = path.stream().reduce(0, Integer::sum);
        if (total > target) return;
        if (total == target) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i < candidates.length; i++) {
            path.add(candidates[i]);
            dfs(candidates, i, path, target);
            path.remove(path.size() - 1);
        }
    }
}

执行结果

在这里插入图片描述

优化代码

在上面的代码中，每次dfs都是要对path求和，效率低下，我们可以直接传入target，固定第一个元素后，找下一个元素，target应该要减去当前元素。比如要在2,3,5中找和为8的组合，那么固定第一个元素2，下面就应该时找等于8-2的组合。当target为0时，说明path的和就等于target，当target小于0时，说明path中的累加和已经超过了原来的target，此时return。

package leetcode.plzh;

import java.util.*;

public class CombinationSum_039 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<Integer> path = new ArrayList<>();
        Arrays.sort(candidates);
        dfs(candidates, 0, path, target);
        return res;
    }

    private void dfs(int[] candidates, int begin, List<Integer> path, int target) {
        if(target<0) return;
        if (target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = begin; i < candidates.length; i++) {
            path.add(candidates[i]);
            dfs(candidates, i, path, target-candidates[i]);
            path.remove(path.size() - 1);
        }
    }
}

优化执行结果

时间由原来的21ms降低为3ms
在这里插入图片描述

40.组合总和 II

题目描述

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。

示例 1：

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2：

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

思路

和39 组合总和相比，多了以下限制：

  1. 一个元素只能选择一次
  2. 可能存在重复元素

对于限制1

可以dfs中遍历时，查找下一个元素即可：dfs(candidates, i+1, path, target-candidates[i]);

对于限制2：

新增去重逻辑：同层相同则剪枝，nums[i]==nums[i-1]&&used[i-1]==0

完整代码

package leetcode.plzh;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class CombinationSum2_040 {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        LinkedList<Integer> path = new LinkedList<>();
        int[] used = new int[candidates.length];
        dfs(candidates, 0, path, target,used);
        return res;
    }

    public void dfs(int[] candidates, int begin, LinkedList<Integer> path, int target,int[] used) {
        if (target < 0) return;
        if (target == 0) {
            res.add(new ArrayList<>(path));
        }

        for (int i = begin; i < candidates.length; i++) {
            if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==0) continue; //同层相同剪枝
            path.addLast(candidates[i]);
            used[i] = 1;
            dfs(candidates, i + 1, path, target - candidates[i],used);
            path.removeLast();
            used[i] = 0;
        }
    }
}

执行结果

在这里插入图片描述

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

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

相关文章

限制Domain Admin登录非域控服务器和用户计算机

限制Domain Admin登录非域控服务器和用户计算机

限制Domain Admin管理员使用敏感管理员帐户(域或林中管理员组、域管理员组和企业管理员组中的成员帐户)登录到信任度较低的服务器和用户端计算机。 此限制可防止管理员通过登录到信任度较低的计算机来无意中增加凭据被盗的风险。 建议采用的策略 建议使用以下策略限制对信任度…
阅读更多...
​软考-高级-系统架构设计师教程（清华第2版）【第10章 软件架构的演化和维护（P345~382）-思维导图】​

​软考-高级-系统架构设计师教程（清华第2版）【第10章 软件架构的演化和维护（P345~382）-思维导图】​

软考-高级-系统架构设计师教程&#xff08;清华第2版&#xff09;【第10章 软件架构的演化和维护&#xff08;P345~382&#xff09;-思维导图】 课本里章节里所有蓝色字体的思维导图
阅读更多...
redis运维(六)redis-cli命令

redis运维(六)redis-cli命令

一 redis-cli 注意&#xff1a; redis-cli核redis-server版本必须适配 --> 见 redis-cli --version提示&#xff1a; 不过一般安装服务端 redis-server 时内置了客户端 redis-cli说明&#xff1a; redis-cli 是 redis 的一种命令行的客户端工具备注&#xff1a; redis-se…
阅读更多...
Qt按钮大全续集（QCommandLinkButton和QDialogButtonBox ）

Qt按钮大全续集（QCommandLinkButton和QDialogButtonBox ）

## QCommandLinkButton 控件简介 QCommandLinkButton 控件中文名是“命令链接按钮”。QCommandLinkButton 继承QPushButton。CommandLinkButton 控件和 RadioButton 相似，都是用于在互斥选项中选择一项。表面上同平面按钮一样，但是 CommandLinkButton 除带有正常的按钮上的文…
阅读更多...
二叉树相关题目

二叉树相关题目

一、概念 二、题目 2.1 把数组转换成二叉树 2.2.1 使用队列方式 public static Node getTreeFromArr2(int[] arr) {if (arr null || arr.length 0) {return null;}LinkedList<Node> quque new LinkedList<>();Node root new Node(arr[0]);quque.add(root);in…
阅读更多...
单片机FLASH下载算法的制作

单片机FLASH下载算法的制作

环境 硬件使用正点原子STM32F407探索者V2开发板 编程环境使用MDK 下载工具使用JLINK FLASH芯片使用W25Q128 什么是下载算法 单片机FLASH的下载算法是一个FLM文件&#xff0c;FLM通过编译链接得到&#xff0c;其内部包含一系列对FLASH的操作&#xff0c;包括初始化、擦除、写…
阅读更多...
delphi电子处方流转(药店)

delphi电子处方流转(药店)

【delphi电子处方流转(药店)】支持 处方下载、处方核验、处方审核、药品销售出库明细上传、药品销售出库明细撤销等功能。
阅读更多...
【Java 语言】读取 properties 配置文件 ( Java 语言中的 properties 配置文件 | 使用 properties 配置文件 )

【Java 语言】读取 properties 配置文件 ( Java 语言中的 properties 配置文件 | 使用 properties 配置文件 )

文章目录 一、Java 语言中的 properties 配置文件二、使用 properties 配置文件三、完整代码示例1、Java 代码2、properties 配置文件3、执行结果 一、Java 语言中的 properties 配置文件 Java 语言中 , properties 配置文件 是一种用于存储应用程序配置信息的文本文件 ; prop…
阅读更多...
腾讯云服务器多少钱一年？腾讯云服务器88元一年，附优惠购买入口

腾讯云服务器多少钱一年？腾讯云服务器88元一年，附优惠购买入口

腾讯云服务器可以以低至88元一年的价格购买&#xff01;这个价格可以说是非常实惠。现在&#xff0c;让我们一起来了解腾讯云服务器的价格以及如何购买优惠的服务器。 如何购买88元一年的腾讯云服务器&#xff1f; 购买腾讯云服务器非常简单&#xff0c;只需按照以下步骤&…
阅读更多...
Odoo 15开发手册第四章 模块继承

Odoo 15开发手册第四章 模块继承

Odoo 的一项强大之处是无需直接修改所扩展模块的代码即可添加功能。这都归功于与自身代码组件相独立的功能继承。对模块的扩展可通过继承机制实现&#xff0c;以已有对象的修改层的形式。这些修改可以发生在每个层面&#xff0c;包括模型、视图和业务逻辑层面。我们不是直接修改…
阅读更多...
idea查看UML类图

idea查看UML类图

idea查看UML类图 一、如何查看UML类图 1.1 选择需要查看的类或者包&#xff0c;鼠标右键&#xff0c;选择Diagrams->Show Diagram 1.2 对于UML类图中的包&#xff0c;选中后点击鼠标右键-> Expand Nodes(展开节点) 展开前 展开后 1.3 展开后分布比较凌乱&#xff…
阅读更多...
Axure基础详解二十二：随机点名效果

Axure基础详解二十二：随机点名效果

效果演示 组件 建立一个【中继器】&#xff0c;内部插入一个“文本框”。【中继器】每页项目数为1&#xff0c;开始页为1。 设置交互 页面载入时交互 给【中继器】新曾行&#xff0c;“name”数据列添加10行数据&#xff0c;填入相应的名字&#xff1b;“shunxu”数据列全部…
阅读更多...
GLSL: Shader cannot be patched for instancing.

GLSL: Shader cannot be patched for instancing.

最近在 unity 里碰到了这么一个错误&#xff0c;只有这么点信息&#xff0c;让人看着挺懵逼的&#xff0c;后来发现&#xff0c;是因为 unity 的 terrain 组件在设置里勾了 Draw Instanced 选项导致的&#xff0c;感觉应该是 unity 的 bug。 因为错出在 2021&#xff0c;2022就…
阅读更多...
ZYNQ_project:test_fifo_255X8

ZYNQ_project:test_fifo_255X8

首先&#xff0c;这个vivado的fifo和quartus有很大不同。 用BRAM来实现异步fifo。 vivado的fifo有复位&#xff0c;在时钟信号稳定后&#xff0c;复位至少三个时钟周期&#xff08;读写端口的慢时钟&#xff09;&#xff0c;复位完成后30个时钟周期后再进行写操作&#xff08…
阅读更多...
网络安全-黑客技术（自学笔记）

网络安全-黑客技术（自学笔记）

前言 前几天发布了一篇 网络安全&#xff08;黑客&#xff09;自学 没想到收到了许多人的私信想要学习网安黑客技术&#xff01;却不知道从哪里开始学起&#xff01;怎么学 今天给大家分享一下&#xff0c;很多人上来就说想学习黑客&#xff0c;但是连方向都没搞清楚就开始学习…
阅读更多...
python基于DETR(DEtection TRansformer)开发构建人员手持物品检测识别分析系统

python基于DETR(DEtection TRansformer)开发构建人员手持物品检测识别分析系统

PyTorch训练代码和DETR&#xff08;DEDetection-TRansformer&#xff09;的预训练模型。我们用Transformer替换了完全复杂的手工制作的对象检测管道&#xff0c;并将Faster R-CNN与ResNet-50匹配&#xff0c;使用一半的计算能力&#xff08;FLOP&#xff09;和相同数量的参数在…
阅读更多...
vue3路由

vue3路由

vue3路由总结 vue3路由安装和引入&#xff1a;路由配置、创建 Router 实例&#xff1a;导航守卫 使用路由返回上一个页面没有跳转指定页 vue3路由 Vue3 路由是 Vue.js 3.x 版本中用于管理页面跳转和导航的模块。它基于 Vue Router 4.x&#xff0c;相较于 Vue2 的路由机制&…
阅读更多...
来讲解一手事务隔离级别

来讲解一手事务隔离级别

简介 在数据库管理系统中&#xff0c;事务是一组被视为单一工作单元的操作&#xff0c;这些操作要么全部执行成功&#xff0c;要么全部回滚。为了确保在多用户并发访问数据库时数据的一致性和可靠性&#xff0c;引入了事务隔离级别的概念。事务隔离级别定义了一个事务对于其他…
阅读更多...
餐厅订座预约小程序的效果如何

餐厅订座预约小程序的效果如何

市场中无论哪种城市&#xff0c;餐厅非常多&#xff0c;一条不长的商业街&#xff0c;汇聚着数家餐饮品牌&#xff0c;且相互间竞争激烈&#xff0c;并且各个商家都希望用成本低高效率的方法引流及转化。 随着互联网深入各个行业&#xff0c;传统餐饮行业经营痛点不少。 传统餐…
阅读更多...
（Matalb回归预测）WOA-BP鲸鱼算法优化BP神经网络的多维回归预测

（Matalb回归预测）WOA-BP鲸鱼算法优化BP神经网络的多维回归预测

目录 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 亮点与优势&#xff1a; 二、实际运行效果&#xff1a; 三、部分代码&#xff1a; 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 本代码基于Matalb平台编译&#xff0c;将WOA(鲸鱼算法)与BP神…
阅读更多...
最新文章

Copyright @ 2022~2023