算法.图论-习题全集(Updating)

news2024/12/28 2:30:51

文章目录

  • 本节设置的意义
  • 并查集篇
    • 并查集简介以及常见技巧
    • 并查集板子(洛谷)
    • 情侣牵手问题
    • 相似的字符串组
    • 岛屿数量(并查集做法)
    • 省份数量
    • 移除最多的同行或同列石头
    • 最大的人工岛
    • 找出知晓秘密的所有专家
  • 建图及其拓扑排序篇
    • 链式前向星建图板子
    • 课程表

本节设置的意义

主要就是为了复习图论算法, 尝试从题目解析的角度,更深入的理解图论算法…

并查集篇

并查集简介以及常见技巧

并查集是一种用于大集团查找, 合并等操作的数据结构, 常见的方法有

  • find: 用来查找元素在大集团中的代表元素(这里使用的是扁平化的处理)
  • isSameSet: 用来查找两个元素是不是一个大集团的(其实就是find的应用)
  • union: 用来合并两大集团的元素

关于并查集打标签的技巧, 其实我们之前的size数组也是一种打标签的逻辑, 其实打标签就是给每一个集团的代表节点打上标签即可, 还有我们在并查集的题目中通常会设置一个sets作为集合的总数目(每次合并–), 这是一个常见的技巧, 并查集的细节我们在这里不进行过多的介绍, 在之前的章节中有细致的描述…

并查集板子(洛谷)

这里我们的并查集的板子使用的是洛谷的板子(小挂大的优化都没必要其实)

// 并查集模版(洛谷)
// 本实现用递归函数实现路径压缩，而且省掉了小挂大的优化，一般情况下可以省略
// 测试链接 : https://www.luogu.com.cn/problem/P3367

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main{

	public static int MAXN = 10001;

	public static int[] father = new int[MAXN];

	public static int n;

	public static void build() {
		for (int i = 0; i <= n; i++) {
			father[i] = i;
		}
	}

	public static int find(int i) {
		if (i != father[i]) {
			father[i] = find(father[i]);
		}
		return father[i];
	}

	public static boolean isSameSet(int x, int y) {
		return find(x) == find(y);
	}

	public static void union(int x, int y) {
		father[find(x)] = find(y);
	}

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		while (in.nextToken() != StreamTokenizer.TT_EOF) {
			n = (int) in.nval;
			build();
			in.nextToken();
			int m = (int) in.nval;
			for (int i = 0; i < m; i++) {
				in.nextToken();
				int z = (int) in.nval;
				in.nextToken();
				int x = (int) in.nval;
				in.nextToken();
				int y = (int) in.nval;
				if (z == 1) {
					union(x, y);
				} else {
					out.println(isSameSet(x, y) ? "Y" : "N");
				}
			}
		}
		out.flush();
		out.close();
		br.close();
	}

}

情侣牵手问题

在这里插入图片描述
本题的突破点就是如果一个大集团里面有 n 对情侣, 那么我们至少要交换 n - 1次(通过把情侣进行编号)

// 这次我们尝试使用轻量版的并查集来解决这道题
class Solution {

    private static final int MAX_CP = 31;

    private static final int[] father = new int[MAX_CP];

    private static int sets = 0;

    private static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b) {
        return find(a) == find(b);
    }

    private static void union(int a, int b) {
        int fa = find(a);
        int fb = find(b);
        if (fa != fb) {
            father[fa] = fb;
            sets--;
        }
    }

    // 初始化并查集
    private static void build(int n) {
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        sets = n;
    }

    public int minSwapsCouples(int[] row) {
        build(row.length / 2);
        for (int i = 0; i < row.length; i += 2) {
            int n1 = row[i] / 2;
            int n2 = row[i + 1] / 2;
            union(n1, n2);
        }
        return row.length / 2 - sets;
    }
}

相似的字符串组

在这里插入图片描述
其实就是枚举每一个位置, 然后判断是不是一组的就OK了

// 还是使用一下轻量级的并查集板子
class Solution {

    private static final int MAX_SZ = 301;

    private static final int[] father = new int[MAX_SZ];

    private static int sets = 0;

    private static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b) {
        return find(a) == find(b);
    }

    private static void union(int a, int b) {
        int fa = find(a);
        int fb = find(b);
        if (fa != fb) {
            father[fa] = fb;
            sets--;
        }
    }

    // 初始化并查集
    private static void build(int n) {
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        sets = n;
    }

    public int numSimilarGroups(String[] strs) {
        build(strs.length);
        // 主流程的时间复杂度是 O(n ^ 2), 遍历strs的每一个位置
        int m = strs[0].length();
        for (int i = 0; i < strs.length; i++) {
            for (int j = i + 1; j < strs.length; j++) {
                // 获取到两个字符串, 然后计算两个字符串的不同字符数量
                String s1 = strs[i];
                String s2 = strs[j];
                int diff = 0;
                for (int k = 0; k < m && diff < 3; k++) {
                    if (s1.charAt(k) != s2.charAt(k))
                        diff++;
                }
                if (diff == 0 || diff == 2)
                    union(i, j);
            }
        }
        return sets;
    }
}

岛屿数量(并查集做法)

在这里插入图片描述
这道题的解法非常多, 比如多源 BFS , 洪水填充(其实就是递归加回溯) , 还有今天介绍的并查集的方法(这个方法不是最好的)

// 这个题的并查集做法只要注意一点就可以了: 把一个二维下标转化为一维下标
class Solution {

    private static final int MAX_SZ = 301 * 301;

    private static final int[] father = new int[MAX_SZ];

    private static int sets = 0;

    private static int row = 0;

    private static int col = 0;

    // 模拟bfs的move数组
    private static final int[] move = { -1, 0, 1, 0, -1 };

    private static int find(int i) {
        if (i != father[i]) {
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b) {
        return find(a) == find(b);
    }

    private static void union(int a, int b) {
        int fa = find(a);
        int fb = find(b);
        if (fa != fb) {
            father[fa] = fb;
            sets--;
        }
    }

    private static void build(char[][] grid, int rl, int cl) {
        row = rl;
        col = cl;
        sets = 0;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == '1') {
                    sets++;
                    father[getIndex(i, j)] = getIndex(i, j);
                }
            }
        }
    }

    public int numIslands(char[][] grid) {
        // 初始化并查集并统计 '1' 的数量
        build(grid, grid.length, grid[0].length);
        // 遍历grid进行合并
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                // 向四个方向扩展
                if (grid[i][j] == '1') {
                    for (int k = 0; k < 4; k++) {
                        int nx = i + move[k];
                        int ny = j + move[k + 1];
                        if (nx >= 0 && nx < row && ny >= 0 && ny < col && grid[nx][ny] == '1') {
                            union(getIndex(i, j), getIndex(nx, ny));
                        }
                    }
                }
            }
        }
        return sets;
    }

    // 二维下标转一维下标
    private static int getIndex(int i, int j) {
        return i * col + j;
    }
}

省份数量

在这里插入图片描述
没什么可说的, 就是一个简单的并查集的思路

class Solution {
    // 这其实也是一个并查集的题
    private static final int MAXM = 201;

    private static final int[] father = new int[MAXM];

    private static final int[] size = new int[MAXM];

    private static int sets = 0;

    private static int find(int i){
        if(i != father[i]){
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b){
        return find(a) == find(b);
    }

    private static void union(int a, int b){
        if(!isSameSet(a, b)){
            int fa = find(a);
            int fb = find(b);
            if(size[fa] > size[fb]){
                father[fb] = fa;
                size[fa] += size[fb];
            }else{
                father[fa] = fb;
                size[fb] += size[fa];
            }
            sets--;
        }
    }

    private static void build(int n){
        for(int i = 0; i < n; i++){
            father[i] = i;
            size[i] = 1;
        }
        sets = n;
    }

    public int findCircleNum(int[][] isConnected) {
        // 初始化并查集
        build(isConnected.length);

        for(int i = 0; i < isConnected.length; i++){
            int[] info = isConnected[i];
            for(int j = 0; j < info.length; j++){
                if(info[j] == 1){
                    union(i, j);
                }
            }
        }

        return sets;
    }
}

移除最多的同行或同列石头

在这里插入图片描述
其实就是每一个集团最后都会被消成一个元素, 我们中间用哈希表加了一些关于离散化的处理的技巧

// 使用一下轻量版本的并查集加上哈希表进行离散化的操作
class Solution {

    private static Map<Integer, Integer> rowFirst = new HashMap<>();
    
    private static Map<Integer, Integer> colFirst = new HashMap<>();

    private static final int MAXM = 1001;

    private static final int[] father = new int[MAXM];

    private static int sets = 0;

    private static int find(int i){
        if(i != father[i]){
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b){
        return find(a) == find(b);
    }

    private static void union(int a, int b){
        int fa = find(a);
        int fb = find(b);
        if(fa != fb){
            father[fa] = fb;
            sets--;
        }
    }

    // 初始化并查集
    private static void build(int n){
        for(int i = 0; i < n; i++){
            father[i] = i;
        }
        sets = n;
    }

    public int removeStones(int[][] stones) {
        // 清空哈希表
        rowFirst.clear();
        colFirst.clear();
        // 初始化并查集
        build(stones.length);
        for(int i = 0; i < stones.length; i++){
            int row = stones[i][0];
            int col = stones[i][1];
            if(!rowFirst.containsKey(row)){
                rowFirst.put(row, i);
            }else{
                union(rowFirst.get(row), i);
            }
            if(!colFirst.containsKey(col)){
                colFirst.put(col, i);
            }else{
                union(colFirst.get(col), i);
            }
        }
        return stones.length - sets;
    }
    
}

最大的人工岛

在这里插入图片描述
本题注意的点就是, 首先我们二维的矩阵, 想要使用并查集, 需要先把二维的坐标转化为一维的坐标, 然后通过一维的坐标使用并查集, 首先把所有的岛进行合并, 然后来到一个 空位置 , 就尝试向四个方向进行扩展尝试进行岛屿的链接, 最后返回最大的连成一片的岛屿数量即可

/**
 * 本题我们是采用的并查集(轻量板子)的方法来做
 *  核心点就是首先使用 并查集 (二维下标转换一维下标) 进行人工岛的合并
 *  本题需要我们使用size的辅助信息, 因为 size 也相当于打标签的技巧
 *  然后枚举每一个位置进行岛屿的合并
 */
class Solution {

    private static final int MAX_LEN = 501;

    private static final int MAX_SIZE = MAX_LEN * MAX_LEN;

    private static final int[] father = new int[MAX_SIZE];

    private static final int[] size = new int[MAX_SIZE];

    private static int len = 0;

    private static final int[] move = {-1, 0, 1, 0, -1};

    private static int find(int i){
        if(i != father[i]){
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b){
        return find(a) == find(b);
    }

    private static void union(int a, int b){
        if(!isSameSet(a, b)){
            int fa = find(a);
            int fb = find(b);
            if(size[fa] > size[fb]){
                father[fb] = fa;
                size[fa] += size[fb];
            }else{
                father[fa] = fb;
                size[fb] += size[fa];
            }
        }
    }

    // 初始化并查集
    private static void build(int[][] grid){
        len = grid.length;
        for(int i = 0; i < len; i++){
            for(int j = 0; j < len; j++){
                if(grid[i][j] == 1){
                    int index = getIndex(i, j);
                    father[index] = index;
                    size[index] = 1;
                }
            }
        }
    }

    // 二维下标转换为一维下标
    private static int getIndex(int i, int j){
        return i * len + j;
    }

    public int largestIsland(int[][] grid) {
        build(grid);
        int res = 0;
        // 遍历矩阵进行合并
        for(int i = 0; i < len; i++){
            for(int j = 0; j < len; j++){
                if(grid[i][j] == 1){
                    // 此时向四周进行扩展合并
                    for(int k = 0; k < 4; k++){
                        int nx = i + move[k];
                        int ny = j + move[k + 1];
                        if(nx >= 0 && nx < len && ny >= 0 && ny < len && grid[nx][ny] == 1){
                            union(getIndex(i, j), getIndex(nx, ny));
                        }
                    }   
                    // 尝试进行人工岛最大面积的更新
                    res = Math.max(res, size[find(getIndex(i, j))]);
                }
            }
        }

        // 遍历所有的 0 位置, 尝试向四周进行枚举更新最大值
        // 创建一个map用来进行去重
        Set<Integer> set = new HashSet<>();
        for(int i = 0; i < len; i++){
            for(int j = 0; j < len; j++){
                if(grid[i][j] == 0){
                    set.clear();
                    int tempRes = 1;
                    // 向四周进行扩展然后尝试进行岛屿链接
                    for(int k = 0; k < 4; k++){
                        int nx = i + move[k];
                        int ny = j + move[k + 1];
                        if(nx >= 0 && nx < len && ny >= 0 && ny < len && grid[nx][ny] == 1){
                            int f = find(getIndex(nx, ny));
                            if(!set.contains(f)){
                                tempRes += size[f];
                                set.add(f);
                            }
                        }
                    }
                    res = Math.max(res, tempRes); 
                }
            }
        }
        return res;
    }
}

找出知晓秘密的所有专家

在这里插入图片描述
本题我们运用的是一种打标签的技巧, 还有就是注意的是并查集如何进行拆解, 其实就是修改一下father数组的内容, 然后把size数组的值置为1即可

/**
 * 本题主要就是涉及到并查集的打标签的技巧, 还有如何拆散一个并查集
 * 首先就是关于并查集打标签: 其实就是给集团领袖节点打上标签信息(类似size数组)
 * 关于拆散并查集: 其实就是把father数组重新设置为自身, size置为1(如果有的话)
 */

class Solution {

    // 并查集轻量化的板子
    private static final int MAXN = 100001;

    private static final int[] father = new int[MAXN];

    private static final boolean[] knowSecrets = new boolean[MAXN];

    private static int find(int i){
        if(i != father[i]){
            father[i] = find(father[i]);
        }
        return father[i];
    }

    private static boolean isSameSet(int a, int b){
        return find(a) == find(b);
    }

    private static void union(int a, int b){
        if(!isSameSet(a, b)){
            father[find(a)] = find(b);
        }
    }

    // 初始化并查集
    private static void build(int n, int firstPerson){
        for(int i = 0; i < n; i++){
            father[i] = i;
            knowSecrets[i] = false;
        }
        // 初始化知道秘密的集团(只需要给领袖节点打上标签就好了)
        union(0, firstPerson);
        knowSecrets[0] = true;
        knowSecrets[firstPerson] = true;
    }

    public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
        // 首先初始化并查集
        build(n, firstPerson);
        // 把meetings进行排序便于处理
        Arrays.sort(meetings, (a, b) -> a[2] - b[2]);
        int l = 0;
        int r = 0;
        while(l < meetings.length){
            // 首先把r指针置为l的位置
            r = l;
            int tempL = l;
            // 向右侧扩充(结束的时候r指向的下一个不同的元素的边界位置)
            while(r < meetings.length && meetings[r][2] == meetings[l][2]){
                r++;
            }
            // 先便利一边并查集进行集合元素的合并
            while(l < r){
                union(meetings[l][0], meetings[l][1]);
                if(isSameSet(0, meetings[l][0])) knowSecrets[meetings[l][0]] = true;
                if(isSameSet(0, meetings[l][1])) knowSecrets[meetings[l][1]] = true;
                l++;
            }
            // 再次便利一边这个时间点的元素进行集合的拆解
            l = tempL;
            while(l < r){
                if(!isSameSet(meetings[l][0], 0) && !isSameSet(meetings[l][1], 0)){
                    father[meetings[l][0]] = meetings[l][0];
                    father[meetings[l][1]] = meetings[l][1];
                }
                l++;
            }
            l = r;
        }
        // 进行元素的收集
        List<Integer> res = new ArrayList<>();
        for(int i = 0; i < n; i++){
            if(isSameSet(0, i)){
                res.add(i);
            }
        }
        return res;
    }
}

建图及其拓扑排序篇

建图的方法有三种, 邻接表, 邻接矩阵, 以及链式前向星, 我们更推荐的是静态空间的链式前向星的建图法, 下面是链式前向星的板子

链式前向星建图板子

/**
 * 关于大厂笔试以及比赛中的建图方式的测试, 其实就是使用静态的数组空间进行建图
 * 我们设置 3 / 4 / 5 个静态数组空间
 * head数组(存储点对应的头边编号), next数组(边对应下一条边的编号), to数组(边去往的点), weight数组(边对应的权值), indegree数组(点对应的入度)
 * 关于拓扑排序(topoSort), 我们最常用的方法其实就是零入度删除法(使用队列, 必要的时候使用小根堆), 关于是否环化的判断我们使用计数器实现
 * 下面是我们提供的链式建图的板子, 以及拓扑排序的板子
 */

 public class createGraphByLinkedProStar{

    // 设置点的最大数量
    private static final int MAXN = 10001;

    // 设置边的最大数量
    private static final int MAXM = 10001;

    // head数组
    private static final int[] head = new int[MAXN];

    // next数组
    private static final int[] next = new int[MAXM];

    // to数组
    private static final int[] to = new int[MAXM];

    // weight数组
    private static final int[] weight = new int[MAXM];

    // indegree数组(统计入度)
    private static final int[] indegree = new int[MAXN];

    // cnt统计边的数量
    private static int cnt = 1;
    
    // 添加边的方法(顺便统计入度)
    private static void addEdge(int u, int v, int w){
        next[cnt] = head[u];
        to[cnt] = v;
        weight[cnt] = w;
        head[u] = cnt++;
        indegree[v]++;
    }

    // 初始化静态空间(只需要清空head以及indegree数组)然后建图(这里是有向带权图)
    private static void build(int n, int[][] edges){
        cnt = 1;
        for(int i = 0; i <= n; i++){
            indegree[i] = 0;
            head[i] = 0;
        }
        for(int[] edge : edges){
            addEdge(edge[0], edge[1], edge[2]);
        }
    }

    // 拓扑排序(topoSort的板子)
    private static int[] topoSort(int n){
        // 首先创建一个队列(将来可以作为结果返回)
        int[] queue = new int[n];
        int l = 0;
        int r = 0;
        // 遍历入度表, 添加所有0入度的点进队列
        for(int i = 0; i < n; i++){
            if(indegree[i] == 0){
                queue[r++] = i;
            }
        }
        // 利用链式前向星的遍历开始跑拓扑排序
        int elemCnt = 0;
        while(l < r){
            int cur = queue[l++];
            elemCnt++;
            for(int ei = head[cur]; ei != 0; ei = next[ei]){
                if(--indegree[to[ei]] == 0){
                    queue[r++] = to[ei];
                }
            }
        }
        return elemCnt == n ? queue : new int[0];
    }
 }

课程表

标准的使用拓扑排序的板子 + 加上链式前向星建图法直接打败 100 %

在这里插入图片描述

class Solution {

     // 设置点的最大数量
    private static final int MAXN = 10001;

    // 设置边的最大数量
    private static final int MAXM = 10001;

    // head数组
    private static final int[] head = new int[MAXN];

    // next数组
    private static final int[] next = new int[MAXM];

    // to数组
    private static final int[] to = new int[MAXM];

    // indegree数组(统计入度)
    private static final int[] indegree = new int[MAXN];

    // cnt统计边的数量
    private static int cnt = 1;

    // 添加边的方法(顺便统计入度)
    private static void addEdge(int u, int v){
        next[cnt] = head[u];
        to[cnt] = v;
        head[u] = cnt++;
        indegree[v]++;
    }

    // 初始化静态空间(只需要清空head以及indegree数组)然后建图(这里是有向带权图)
    private static void build(int n, int[][] edges){
        cnt = 1;
        for(int i = 0; i <= n; i++){
            indegree[i] = 0;
            head[i] = 0;
        }
        for(int[] edge : edges){
            addEdge(edge[1], edge[0]);
        }
    }

    // 拓扑排序(topoSort的板子)
    private static int[] topoSort(int n){
        // 首先创建一个队列(将来可以作为结果返回)
        int[] queue = new int[n];
        int l = 0;
        int r = 0;
        // 遍历入度表, 添加所有0入度的点进队列
        for(int i = 0; i < n; i++){
            if(indegree[i] == 0){
                queue[r++] = i;
            }
        }
        // 利用链式前向星的遍历开始跑拓扑排序
        int elemCnt = 0;
        while(l < r){
            int cur = queue[l++];
            elemCnt++;
            for(int ei = head[cur]; ei != 0; ei = next[ei]){
                if(--indegree[to[ei]] == 0){
                    queue[r++] = to[ei];
                }
            }
        }
        return elemCnt == n ? queue : new int[0];
    }

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        build(numCourses, prerequisites);
        return topoSort(numCourses);
    }
}

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

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

相关文章

云原生之k8s服务管理

云原生之k8s服务管理

文章目录 服务管理Service服务原理ClusterIP服务 对外发布应用服务类型NodePort服务Ingress安装配置Ingress规则 Dashboard概述 认证和授权ServiceAccount用户概述创建ServiceAccount 权限管理角色与授权 服务管理 Service 服务原理 容器化带来的问题 自动调度&#xff1a;…
阅读更多...
Atomic原子操作类详解

Atomic原子操作类详解

Atomic原子操作类介绍 在并发编程中很容易出现并发安全的问题&#xff0c;有一个很简单的例子就是多线程更新变量i1,比如多个线程执行i操作&#xff0c;就有可能获取不到正确的值&#xff0c;而这个问题&#xff0c;最常用的方法是通过Synchronized进行控制来达到线程安全的目…
阅读更多...
随手记： vue监听路由

随手记： vue监听路由

随手记&#xff1a;没空记详细 newVal,oldVal 可以查看到最新路由和上一条路由详细 watch: {$route: {handler(newVal,oldVal) {console.log(newVal, oldVal)if(oldVal.path /organization/serviceManagement/list) {if(this.cacheId ! newVal.query.id) {this.cacheId newV…
阅读更多...
AndroidStudio与开发板调试时连接失败或APP闪退的解决方案，涉及SELINUX及获取Root权限

AndroidStudio与开发板调试时连接失败或APP闪退的解决方案，涉及SELINUX及获取Root权限

现象 用AndroidStudio打开工程代码，点击运行后，报错： 解决方案 具体原因是尝试运行 su（通常用于获取超级用户权限）时失败了，提示 “Permission denied” 通过 CONFIG_SECURITY_SELINUX 变量控制 SElinux 开启或关闭 在vim /rk3568_android_sdk/device/rockchip/rk…
阅读更多...
深度学习之One Stage目标检测算法2

深度学习之One Stage目标检测算法2

我们将对单次目标检测器&#xff08;包括SSD系列和YOLO系列等算法&#xff09;进行综述。我们将分析FPN以理解多尺度特征图如何提高准确率&#xff0c;特别是小目标的检测&#xff0c;其在单次检测器中的检测效果通常很差。然后我们将分析Focal loss和RetinaNet&#xff0c;看看…
阅读更多...
Flutter通过 Coap发送组播

Flutter通过 Coap发送组播

Flutter发送组播的流程 1.初始化 CoAP 客户端 需要初始化 CoAP 客户端并将其连接到组播地址和端口。您可以使用 CoAP 库提供的类来创建和配置客户端 final client CoapClient(Uri.parse(coap://224.0.1.1:5683), // 组播地址和端口 ); 2.创建 CoAP 请求 创建一个 CoAP 请…
阅读更多...
使用Python3实现Gitee码云自动化发布

使用Python3实现Gitee码云自动化发布

仓库信息 https://gitee.com/liumou_site/ip 实现代码 import osimport requests from loguru import loggerdef gitee(ver, message, prerelease: bool False):"""在 Gitee 上创建发布版本:param ver: 版本号:param message: 发布信息:param prerelease: 是…
阅读更多...
【软考】系统架构设计师-2022年下半年上午综合知识真题及答案

【软考】系统架构设计师-2022年下半年上午综合知识真题及答案

​全国计算机技术与软件专业技术资格&#xff08;水平&#xff09;考试 高级 系统架构设计师 2022 年 下半年 上午试卷 综合知识 试题一 云计算服务体系结构如下图所示&#xff0c;图中①、②、③分别与⊆SaaSPaaSIaas 相对应&#xff0c; 图中①、②、③应为( ) A.⊆应用层、…
阅读更多...
5. Spring Cloud OpenFeign 声明式 WebService 客户端的超详细使用

5. Spring Cloud OpenFeign 声明式 WebService 客户端的超详细使用

5. Spring Cloud OpenFeign 声明式 WebService 客户端的超详细使用 文章目录 5. Spring Cloud OpenFeign 声明式 WebService 客户端的超详细使用前言1. OpenFeign 介绍1.1 Feign 和 OpenFeign 区别 2. OpenFeign 应用实例2.2 注意事项和细节 3. OpenFeign 内置的“日志配置” 操…
阅读更多...
Centos 8, add repo

Centos 8, add repo

Centos repo前言 Centos 8更换在线阿里云创建一键更换repo 自动化脚本 华为Centos 源 , 阿里云Centos 源 华为epel 源 , 阿里云epel 源vim /centos8_repo.sh #!/bin/bash # -*- coding: utf-8 -*- # Author: make.han
阅读更多...
指南: 如何在 MEV 项目中使用 Yul

指南: 如何在 MEV 项目中使用 Yul

这对我来说是一个反复出现的故事。我学习了一些 Solidity&#xff0c;发现了一个我想要研究的服务。代码看起来是这样的&#xff1a; Seaport Core: BasicOrderFulfiller.sol Solidity 代码在哪里&#xff1f;人们似乎不再使用普通的 Solidity 代码了 &#x1f972; 这种在智能…
阅读更多...
web——upload-labs——第十一关——黑名单验证，双写绕过

web——upload-labs——第十一关——黑名单验证，双写绕过

还是查看源码&#xff0c; $file_name str_ireplace($deny_ext,"", $file_name); 该语句的作用是&#xff1a;从 $file_name 中去除所有出现在 $deny_ext 数组中的元素&#xff0c;替换为空字符串&#xff08;即删除这些元素&#xff09;。str_ireplace() 在处理时…
阅读更多...
北京申请中级职称流程（2024年）

北京申请中级职称流程（2024年）

想找个完整详细点的申请流程资料真不容易&#xff0c;做个分享送给需要的人吧。 不清楚为什么说文章过度宣传&#xff0c;把链接和页面去掉了&#xff0c;网上自己找一下。 最好用windows自带的EDGE浏览器打开申请网站&#xff0c;只有在开始申请的时间内才可以进行网上申报&…
阅读更多...
Visual Studio 圈复杂度评估

Visual Studio 圈复杂度评估

VisualStudio自带的有工具 之后就可以看到分析结果
阅读更多...
MySQL UPDATE语句执行链路解析

MySQL UPDATE语句执行链路解析

文章目录 引言1. 总览&#xff1a;UPDATE语句的执行链路2. 客户端发起请求2.1 SQL请求的形成2.2 MySQL通信协议 3. 连接器模块3.1 连接管3.2 会话上下文 4. SQL解析器4.1 语法解析4.2 语法错误处理 5. 查询优化器5.1 查询优化的核心概念5.2 优化器生成执行计划的步骤5.3 优化器…
阅读更多...
.net6.0(.net Core)读取 appsettings.json 配置文件

.net6.0(.net Core)读取 appsettings.json 配置文件

① 新项目中创建名为 appsettings.json 的 json文件&#xff0c;内容为&#xff1a; {//数据库连接字符串:"ConnectionString": {"DBconn": "server127.0.0.1;databasedb;uidsa;pwd123456;Timeout600;EncryptTrue;TrustServerCertificateTrue;"…
阅读更多...
[CISCN 2019初赛]Love Math 详细题解

[CISCN 2019初赛]Love Math 详细题解

知识点: 数学函数转换字符串 GET传参外部赋值 eval()函数解析执行命令 PHP动态调用函数名 源码: <?php error_reporting(0); //听说你很喜欢数学,不知道你是否爱它胜过爱flag if(!isset($_GET[c])){show_source(__FILE__); }else{//例子 c20-1$content $_GET[c];if (…
阅读更多...
湛江市社保卡申领指南：手机获取电子照片回执单号

湛江市社保卡申领指南：手机获取电子照片回执单号

在湛江市&#xff0c;社保卡的申领流程已经实现了数字化&#xff0c;为市民带来了极大的便利。特别是通过手机获取数码照片回执单号&#xff0c;这一环节更是简化了申领过程。今天&#xff0c;我们将详细介绍如何不去照相馆&#xff0c;利用手机来获取数码照片回执单号&#xf…
阅读更多...
第27天 安全开发-PHP应用TP 框架路由访问对象操作内置过滤绕过核心漏洞

第27天 安全开发-PHP应用TP 框架路由访问对象操作内置过滤绕过核心漏洞

时间轴 演示案例 TP 框架-开发-配置架构&路由&MVC 模型 TP 框架-安全-不安全写法&版本过滤绕过 TP 框架-开发-配置架构&路由&MVC 模型 参考&#xff1a; https://www.kancloud.cn/manual/thinkphp5_1 1、配置架构-导入使用 去thinkphp官网可以看到&…
阅读更多...
【自动驾驶】数据集合集！

【自动驾驶】数据集合集！

本文将为您介绍经典、热门的数据集&#xff0c;希望对您在选择适合的数据集时有所帮助。 1 Automatic-driving-Test 更新时间&#xff1a;2024-07-26 访问地址: GitHub 描述&#xff1a; 该模型使用 ultralytics yolo v8 和 deepsort 方法来检测车道与车轮的碰撞并跟踪车辆。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023