文心一言 VS 讯飞星火 VS chatgpt （318）-- 算法导论22.3 10题

news2024/11/15 5:11:51

十、修改深度优先搜索的伪代码，让其打印出有向图G的每条边及其分类。并指出，如果图G是无向图，要进行何种修改才能达到相同的效果。如果要写代码，请用go语言。

文心一言：

首先，我们来定义深度优先搜索（DFS）的伪代码，并修改它以打印出有向图G的每条边及其分类（这里我们可以简单地将边分类为“树边”（在搜索过程中首次访问的边的方向）、“后向边”（指向已访问的祖先的边）、“前向边”（指向已访问但不是祖先的节点的边）和“横叉边”（指向未访问的节点但不是当前搜索路径上的边的特殊情况，在有向图中不常见，因为方向性）。然而，在有向图中，我们通常只区分树边、后向边和前向边，横叉边的概念更多应用于无向图）。

有向图的DFS伪代码

DFS(G, v):
    标记v为已访问
    对于G中每个从v出发的边(v, w):
        if w未被访问:
            打印 "树边: (" + v + ", " + w + ")"
            DFS(G, w)
        else if w在v的祖先列表中:
            打印 "后向边: (" + v + ", " + w + ")"
        else:
            打印 "前向边: (" + v + ", " + w + ")"

Go语言实现

在Go语言中，我们可以使用map来表示图，其中键是节点，值是与该节点相连的其他节点的列表。这里，我们还需要一个额外的数据结构来跟踪每个节点的访问状态和其祖先。

package main

import (
    "fmt"
)

type Graph map[string][]string
type VisitStatus map[string]bool
type Ancestors map[string][]string

func dfs(g Graph, v string, visited VisitStatus, ancestors Ancestors) {
    visited[v] = true
    ancestors[v] = append(ancestors[v], v) // 每个节点都是自己的祖先

    for _, w := range g[v] {
        if !visited[w] {
            fmt.Printf("树边: (%s, %s)\n", v, w)
            dfs(g, w, visited, ancestors)
            ancestors[v] = append(ancestors[v], ancestors[w]...) // 更新祖先列表
        } else if contains(ancestors[v], w) {
            fmt.Printf("后向边: (%s, %s)\n", v, w)
        } else {
            fmt.Printf("前向边: (%s, %s)\n", v, w)
        }
    }
}

func contains(s []string, e string) bool {
    for _, a := range s {
        if a == e {
            return true
        }
    }
    return false
}

func main() {
    g := Graph{
        "A": []string{"B", "C"},
        "B": []string{"D", "E"},
        "C": []string{"F"},
        "D": []string{"C"},
        "E": []string{},
        "F": []string{},
    }

    visited := make(VisitStatus)
    ancestors := make(Ancestors)

    for k := range g {
        if !visited[k] {
            dfs(g, k, visited, ancestors)
        }
    }
}

无向图的修改

对于无向图，主要区别在于我们不再区分前向边和后向边（因为边是双向的），而只区分树边和横叉边（或称为交叉边）。由于无向图中没有固定的方向，我们可以简单地去掉后向边和前向边的判断，并将所有已访问但非当前搜索路径上的边视为横叉边。但通常，我们更关心的是树边和非树边（即，连接两个已访问节点的边，但不属于当前搜索树的边）。

在Go实现中，你可能需要稍微调整DFS函数来适应无向图的特性，但基本框架是相似的。主要区别在于如何追踪和分类边。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火：

首先，我们需要修改深度优先搜索的伪代码以打印出有向图G的每条边及其分类。我们可以在遍历过程中记录每个节点的访问状态，并在回溯时打印出边的信息。以下是修改后的伪代码：

function DFS(G, v):
    标记v为已访问
    for each 邻接点u in G[v]:
        if u未被访问：
            print("边： (v, u)")
            DFS(G, u)
        elif u已被访问且不是v的父节点：
            print("反向边： (u, v)")

如果要让这个算法适用于无向图，我们需要进行一些修改。对于无向图，我们只需要在遍历过程中检查是否已经访问过邻接点，而不需要关心边的方向。以下是修改后的伪代码：

function DFS(G, v):
    标记v为已访问
    for each 邻接点u in G[v]:
        if u未被访问：
            print("边： (v, u)")
            DFS(G, u)

接下来，我们将上述伪代码转换为Go语言代码：

package main

import "fmt"

func DFS(G map[int][]int, v int, visited map[int]bool) {
    visited[v] = true
    for _, u := range G[v] {
        if !visited[u] {
            fmt.Printf("边： (%d, %d)\n", v, u)
            DFS(G, u, visited)
        } else {
            fmt.Printf("反向边： (%d, %d)\n", u, v)
        }
    }
}

func main() {
    G := map[int][]int{
        0: {1, 2},
        1: {2},
        2: {0, 3},
        3: {3},
    }
    visited := make(map[int]bool)
    DFS(G, 0, visited)
}

这段Go代码定义了一个名为DFS的函数，它接受一个表示图的邻接表G、一个起始顶点v和一个记录已访问顶点的映射visited。在main函数中，我们创建了一个示例图并调用DFS函数从顶点0开始遍历。

360智脑：

首先，我们需要定义一个函数来对边的类型进行分类。在有向图中，边的类型可以是树边、后向边、前向边或交叉边。然后，我们可以在深度优先搜索（DFS）的过程中打印出每条边及其分类。

以下是一个使用Go语言实现的示例代码：

package main

import "fmt"

type EdgeType int

const (
	TREE EdgeType = iota
	BACK
	FORWARD
	CROSS
)

type Graph struct {
	vertices []int
	edges    map[int][]int
}

func dfs(g *Graph, v int, visited map[int]bool, parent map[int]int, time *int, edgeTypes map[string]EdgeType) {
	visited[v] = true
	*time++
	for _, u := range g.edges[v] {
		if !visited[u] {
			fmt.Printf("Edge %d-%d is a TREE edge\n", v, u)
			edgeTypes[fmt.Sprintf("%d-%d", v, u)] = TREE
			parent[u] = v
			dfs(g, u, visited, parent, time, edgeTypes)
		} else if parent[v] != u && (*time - 1) < parent[u] {
			fmt.Printf("Edge %d-%d is a BACKWARD edge\n", v, u)
			edgeTypes[fmt.Sprintf("%d-%d", v, u)] = BACK
		} else if parent[v] != u && (*time - 1) >= parent[u] {
			fmt.Printf("Edge %d-%d is a FORWARD or CROSS edge\n", v, u)
			edgeTypes[fmt.Sprintf("%d-%d", v, u)] = FORWARD
		}
	}
	*time++
}

func main() {
	g := &Graph{
		vertices: []int{1, 2, 3, 4, 5},
		edges: map[int][]int{
			1: {2, 3},
			2: {4},
			3: {4},
			4: {5},
			5: {},
		},
	}

	visited := make(map[int]bool)
	parent := make(map[int]int)
	edgeTypes := make(map[string]EdgeType)
	time := 0

	for _, v := range g.vertices {
		if !visited[v] {
			parent[v] = -1
			dfs(g, v, visited, parent, &time, edgeTypes)
		}
	}
}

对于无向图，我们只需要将所有的边都看作是有向图中的双向边即可。也就是说，对于每条边(u, v)，我们需要分别处理u -> v和v -> u两种情况。我们可以通过在Graph结构体中添加一个isDirected字段来区分有向图和无向图，并在添加边时根据这个字段的值来决定是否需要添加反向边。然后在DFS过程中，我们只需要根据边的方向来判断其类型即可。

智谱清言：

以下是修改后的深度优先搜索（DFS）伪代码，用于打印有向图G的每条边及其分类（假设边分类可以是树边、前向边、后向边或横跨边）。在有向图中，我们通常使用时间戳来区分这些边。

DFS(G):
  for each vertex u in G:
    color[u] = WHITE
    parent[u] = NIL
  time = 0
  for each vertex u in G:
    if color[u] == WHITE:
      DFS-VISIT(G, u)
DFS-VISIT(G, u):
  time = time + 1 // Discovery time of u
  d[u] = time
  color[u] = GRAY
  for each v in Adj[u]: // Adj[u] is the adjacency list of u
    if color[v] == WHITE:
      parent[v] = u
      print "(u, v) is a tree edge"
      DFS-VISIT(G, v)
    else if color[v] == GRAY:
      print "(u, v) is a back edge"
    else if color[v] == BLACK and d[u] < d[v]:
      print "(u, v) is a forward edge"
    else if color[v] == BLACK and d[u] > d[v]:
      print "(u, v) is a cross edge"
  color[u] = BLACK
  time = time + 1 // Finish time of u
  f[u] = time

如果图G是无向图，我们不需要区分前向边和后向边，因为无向图中的边没有方向。以下是针对无向图的修改：

  • 当遇到一个未访问的顶点时，打印的是一条树边。
  • 当遇到一个已访问的顶点时，且这个顶点不是当前顶点的父节点时，打印的是一条横跨边。
    以下是使用Go语言实现的代码：
package main
import "fmt"
const (
	White = iota
	Gray
	Black
)
type Graph struct {
	Adj  map[int][]int
	d    map[int]int
	f    map[int]int
	color map[int]int
	parent map[int]int
	time int
}
func NewGraph(vertices []int) *Graph {
	g := &Graph{
		Adj:    make(map[int][]int),
		d:      make(map[int]int),
		f:      make(map[int]int),
		color:  make(map[int]int),
		parent: make(map[int]int),
		time:   0,
	}
	for _, v := range vertices {
		g.Adj[v] = []int{}
		g.color[v] = White
		g.parent[v] = -1
	}
	return g
}
func (g *Graph) AddEdge(u, v int) {
	g.Adj[u] = append(g.Adj[u], v)
}
func (g *Graph) DFS() {
	for u := range g.Adj {
		if g.color[u] == White {
			g.DFSVisit(u)
		}
	}
}
func (g *Graph) DFSVisit(u int) {
	g.time++
	g.d[u] = g.time
	g.color[u] = Gray
	for _, v := range g.Adj[u] {
		if g.color[v] == White {
			g.parent[v] = u
			fmt.Printf("(%d, %d) is a tree edge\n", u, v)
			g.DFSVisit(v)
		} else if g.color[v] == Gray {
			fmt.Printf("(%d, %d) is a back edge\n", u, v)
		} else if g.color[v] == Black {
			if g.d[u] < g.d[v] {
				fmt.Printf("(%d, %d) is a forward edge\n", u, v)
			} else {
				fmt.Printf("(%d, %d) is a cross edge\n", u, v)
			}
		}
	}
	g.color[u] = Black
	g.time++
	g.f[u] = g.time
}
func main() {
	vertices := []int{0, 1, 2, 3, 4}
	g := NewGraph(vertices)
	g.AddEdge(0, 1)
	g.AddEdge(0, 2)
	g.AddEdge(1, 2)
	g.AddEdge(2, 0)
	g.AddEdge(2, 3)
	g.AddEdge(3, 3)
	g.AddEdge(1, 4)
	g.DFS()
}

对于无向图，你可以移除前向边和后向边的检查，因为它们不会出现在无向图中。每次访问一个相邻的已访问顶点时，只需检查它不是当前顶点的父节点，然后打印横跨边。

天工：

要修改深度优先搜索（DFS）以打印出有向图G的每条边及其分类（树边、后向边、前向边、交叉边），我们可以稍微调整标准的DFS算法。对于有向图，我们可以在DFS遍历过程中记录边的类型，并在访问每条边时打印它们。对于无向图，我们需要注意避免重复打印边，因为无向图中的每条边会在两个方向上被访问到。

有向图的DFS边分类打印伪代码

DFS(G, start):
    for each vertex v in G:
        color[v] = WHITE
        π[v] = NIL
        time = 0

    color[start] = GRAY
    time = time + 1
    d[start] = time
    S = [start]  // 栈，用于DFS

    while S is not empty:
        u = S[-1]  // 栈顶元素
        foundUnvisitedNeighbor = False
        for each neighbor v of u:
            if color[v] == WHITE:
                foundUnvisitedNeighbor = True
                color[v] = GRAY
                π[v] = u
                time = time + 1
                d[v] = time
                S.append(v)
                if u != start:
                    print "Tree edge:", u, "to", v
                break
        if not foundUnvisitedNeighbor:
            color[u] = BLACK
            S.pop()
            for each neighbor w of u:
                if color[w] == BLACK and w != π[u]:  // 后向边
                    print "Back edge:", u, "to", w
                elif color[w] == GRAY and w != π[u]:  // 前向边/交叉边
                    print "Forward/Cross edge:", u, "to", w
            time = time + 1
            f[u] = time

无向图的修改

对于无向图，我们只需要在打印边时检查是否已经打印过这条边。这通常通过维护一个已打印边的集合来实现，确保每条边只被打印一次。

使用Go语言实现

package main

import (
	"fmt"
)

type EdgeType int

const (
	Tree EdgeType = iota
	Back
	Forward
	Cross
)

type Edge struct {
	From int
	To   int
	Type EdgeType
}

type Graph struct {
	AdjList map[int][]int
}

func (g *Graph) DFS() []Edge {
	edges := []Edge{}
	color := make(map[int]int)
	for vertex := range g.AdjList {
		color[vertex] = 0 // 0: White, 1: Gray, 2: Black
	}

	for start := range g.AdjList {
		if color[start] == 0 {
			g.DFSVisit(start, &edges, color)
		}
	}

	return edges
}

func (g *Graph) DFSVisit(start int, edges *[]Edge, color map[int]int) {
	color[start] = 1 // Gray
	for _, v := range g.AdjList[start] {
		if color[v] == 0 {
			*edges = append(*edges, Edge{From: start, To: v, Type: Tree})
			g.DFSVisit(v, edges, color)
		} else if color[v] == 1 {
			*edges = append(*edges, Edge{From: start, To: v, Type: Back})
		} else {
			*edges = append(*edges, Edge{From: start, To: v, Type: Forward})
		}
	}
	color[start] = 2 // Black
}

func printEdges(edges []Edge) {
	for _, e := range edges {
		switch e.Type {
		case Tree:
			fmt.Printf("Tree edge: %d to %d\n", e.From, e.To)
		case Back:
			fmt.Printf("Back edge: %d to %d\n", e.From, e.To)
		case Forward:
			fmt.Printf("Forward/Cross edge: %d to %d\n", e.From, e.To)
		default:
			fmt.Printf("Cross edge: %d to %d\n", e.From, e.To)
		}
	}
}

func main() {
	g := Graph{
		AdjList: map[int][]int{
			0: {1, 2},
			1: {0, 3},
			2: {0, 3},
			3: {1, 2},
		},
	}

	edges := g.DFS()
	printEdges(edges)
}

这个Go语言代码示例展示了如何对无向图进行DFS，并打印出所有边的类型。注意，这里的代码假设图是无向图，因此每条边会在两个方向上被访问，但代码中并未特别处理避免重复打印边的问题。如果需要避免重复打印，可以在打印之前检查边是否已存在于结果集中。

chatgpt：

以下是修改后的深度优先搜索（DFS）算法的伪代码，用于打印有向图 G 的每条边及其分类：

DFS(G, start):
    初始化一个栈 stack
    创建一个集合 visited，用于记录已经访问过的节点

    将 start 入栈
    将 start 加入 visited 集合

    while 栈不为空:
        current = stack.pop()
        
        for each neighbor in G.adjacentNodes(current):
            if neighbor not in visited:
                将 (current, neighbor) 添加到结果列表中，并标记为正向边
                将 neighbor 入栈
                将 neighbor 加入 visited 集合
    
            否则：
                如果 (current, neighbor) 不在结果列表中：
                    将 (current, neighbor) 添加到结果列表中，并标记为反向边

    打印结果列表中的每条边及其分类（正向或反向）

如果图 G 是无向图，需要对深度优先搜索算法进行修改才能达到相同的效果。可以通过添加一个 parent 参数来记录每个节点的父节点，并判断是否已经访问过该节点。以下是相应的修改后伪代码：

DFS(G, current, parent):
    初始化一个栈 stack
    创建一个集合 visited，用于记录已经访问过的节点

    将 (current, parent) 入栈
    将 current 加入 visited 集合

    while 栈不为空:
        (current, parent) = stack.pop()

        for each neighbor in G.adjacentNodes(current):
            if neighbor not in visited:
                将 (current, neighbor) 添加到结果列表中，并标记为正向边
                将 (neighbor, current) 入栈
                将 neighbor 加入 visited 集合
    
            否则：
                如果 parent != neighbor 并且 (current, neighbor) 不在结果列表中：
                    将 (current, neighbor) 添加到结果列表中，并标记为反向边

    打印结果列表中的每条边及其分类（正向或反向）

这是伪代码示例，如果要用 Go 语言编写实际的代码，可以根据上述伪代码进行相应的转换和具体实现。

kimi：

深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。在有向图中，DFS可以用于检测环、拓扑排序等。在无向图中，DFS同样可以用于这些目的，但需要稍作修改以适应无向图的特性。

首先，我们给出一个简化版的深度优先搜索伪代码，用于打印出有向图中的每条边及其分类（例如，是否是树上的边、前驱边、后继边、交叉边等）：

DFS(G, v):
    mark[v] = true
    for each vertex w in G.adjacent to v:
        if mark[w] is false:
            print("Discovering edge (", v, ", ", w, ")")
            parent[w] = v
            edgeType[w] = "tree edge"
            DFS(G, w)
        else if w != parent[v]:
            edgeType[w] = "back edge"
            print("Back edge (", v, ", ", w, ")")
    print("Finished edge (", v, ", ", w, ")")

在这个伪代码中，G 是图，v 是当前正在访问的顶点，mark 是一个布尔数组，用来标记顶点是否已被访问过，parent 是一个数组，用来记录每个顶点的父节点，edgeType 是一个数组，用来记录边的类型。

对于无向图，我们需要对DFS进行以下修改：

  1. 由于无向图中的边没有方向，我们需要在遍历时检查两个顶点之间的连接，而不是单向的边。
  2. 我们不能简单地使用parent数组来记录树结构，因为无向图中没有明确的树结构。

以下是使用Go语言编写的代码示例，用于打印无向图中的边：

package main

import (
	"fmt"
)

type Graph struct {
	adj [][]int
}

func (g *Graph) AddEdge(v, w int) {
	g.adj[v] = append(g.adj[v], w)
	g.adj[w] = append(g.adj[w], v) // 无向图需要添加双向连接
}

func DFS(g *Graph, v int, visited []bool, parent []int, edgeType []string) {
	visited[v] = true
	for _, w := range g.adj[v] {
		if !visited[w] {
			fmt.Printf("Discovering edge (%d, %d)\n", v, w)
			parent[w] = v
			edgeType[w] = "tree edge"
			DFS(g, w, visited, parent, edgeType)
		} else if w != parent[v] {
			edgeType[w] = "back edge"
			fmt.Printf("Back edge (%d, %d)\n", v, w)
		}
	}
}

func main() {
	g := &Graph{adj: make([][]int, 5)}
	g.AddEdge(0, 1)
	g.AddEdge(0, 2)
	g.AddEdge(1, 2)
	g.AddEdge(2, 0)
	g.AddEdge(2, 3)
	g.AddEdge(3, 4)

	visited := make([]bool, 5)
	parent := make([]int, 5)
	edgeType := make([]string, 5)

	DFS(g, 0, visited, parent, edgeType)
}

在这个Go语言的示例中，我们定义了一个Graph结构体来表示图，并实现了AddEdge方法来添加边。DFS函数用于执行深度优先搜索，并打印出每条边的发现情况。注意，由于是无向图，我们在AddEdge方法中添加了双向连接。在DFS函数中，我们检查了是否已经访问过相邻的顶点w，如果是，则打印出一条回边（back edge）。

混元：

为了实现这个功能，我们首先需要定义一个有向图的结构，然后实现深度优先搜索算法。在搜索过程中，我们将打印出每条边及其分类。对于无向图，我们需要对算法进行一些调整。

有向图的深度优先搜索伪代码及Go语言实现

伪代码
function dfs(G, v):
    visited[v] = true
    for each edge (v, w) in G:
        if not visited[w]:
            print "(v, w) is a tree edge"
            dfs(G, w)
        elif w is on the path from v to the root:
            print "(v, w) is a back edge"
        else:
            print "(v, w) is a cross or forward edge"

function print_edge_categories(G):
    for each vertex v in G:
        if not visited[v]:
            dfs(G, v)
Go语言实现
package main

import "fmt"

type Graph struct {
	vertices [][]int // 使用邻接表表示图
}

func (g *Graph) addEdge(u, v int) {
	g.vertices[u] = append(g.vertices[u], v)
}

func dfs(g *Graph, v int, visited []bool) {
	visited[v] = true
	for _, w := range g.vertices[v] {
		if !visited[w] {
			fmt.Printf("(%d, %d) is a tree edge\n", v, w)
			dfs(g, w, visited)
		} else if isOnPath(v, w, visited) {
			fmt.Printf("(%d, %d) is a back edge\n", v, w)
		} else {
			fmt.Printf("(%d, %d) is a cross or forward edge\n", v, w)
		}
	}
}

func isOnPath(v, w int, visited []bool) bool {
	// 这里需要实现一个辅助函数来判断w是否在从v到根节点的路径上
	// 实现细节略
	return false // 示例代码，实际应实现该逻辑
}

func printEdgeCategories(g *Graph) {
	visited := make([]bool, len(g.vertices))
	for v := range g.vertices {
		if !visited[v] {
			dfs(g, v, visited)
		}
	}
}

func main() {
	g := Graph{vertices: make([][]int, 6)}
	g.addEdge(0, 1)
	g.addEdge(0, 2)
	g.addEdge(1, 3)
	g.addEdge(1, 4)
	g.addEdge(2, 5)
	g.addEdge(3, 4)

	printEdgeCategories(&g)
}

无向图的深度优先搜索

对于无向图，我们需要对算法进行一些调整，因为无向图的边没有方向，所以我们不需要区分前向边和交叉边。伪代码和Go语言实现如下：

伪代码
function dfs(G, v):
    visited[v] = true
    for each edge (v, w) in G:
        if not visited[w]:
            print "(v, w) is a tree edge"
            dfs(G, w)
        else:
            print "(v, w) is a back edge"

function print_edge_categories(G):
    for each vertex v in G:
        if not visited[v]:
            dfs(G, v)
Go语言实现
package main

import "fmt"

type Graph struct {
	vertices [][]int // 使用邻接表表示图
}

func (g *Graph) addEdge(u, v int) {
	g.vertices[u] = append(g.vertices[u], v)
	g.vertices[v] = append(g.vertices[v], u) // 无向图需要添加两个方向的边
}

func dfs(g *Graph, v int, visited []bool) {
	visited[v] = true
	for _, w := range g.vertices[v] {
		if !visited[w] {
			fmt.Printf("(%d, %d) is a tree edge\n", v, w)
			dfs(g, w, visited)
		} else {
			fmt.Printf("(%d, %d) is a back edge\n", v, w)
		}
	}
}

func printEdgeCategories(g *Graph) {
	visited := make([]bool, len(g.vertices))
	for v := range g.vertices {
		if !visited[v] {
			dfs(g, v, visited)
		}
	}
}

func main() {
	g := Graph{vertices: make([][]int, 6)}
	g.addEdge(0, 1)
	g.addEdge(0, 2)
	g.addEdge(1, 3)
	g.addEdge(1, 4)
	g.addEdge(2, 5)
	g.addEdge(3, 4)

	printEdgeCategories(&g)
}

在无向图的实现中，我们在添加边时同时添加了两个方向的边，并且在打印边分类时不再区分前向边和交叉边。

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

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

相关文章

leetcode：汇总区间

leetcode：汇总区间

题目&#xff1a; 给定一个无重复元素的有序整数数组nums。返回恰好覆盖数组中所有数字的最小有序区间范围列表 。也就是说&#xff0c;nums的每个元素都恰好被某个区间范围所覆盖&#xff0c;并且不存在属于某个范围但不属于nums的数字X。列表中的每个区间范围[a,b]应该按…
阅读更多...
简单的docker学习 第2章 docker引擎

简单的docker学习 第2章 docker引擎

第2章docker引擎 2.1Docker 引擎发展历程 2.1.1 首发版本架构 Docker 在首次发布时&#xff0c;其引擎由两个核心组件构成&#xff1a;LXC&#xff08;Linux Container&#xff09;与 Docker Daemon。不过&#xff0c;该架构依赖于 LXC&#xff0c;使得 Docker 存在严重的问…
阅读更多...
人力资源杂志人力资源杂志社人力资源编辑部2024年第13期目录

人力资源杂志人力资源杂志社人力资源编辑部2024年第13期目录

看法_总编随笔 学会退步 齐向宇; 1 看法_热点聚焦 数说 7 司事 9 看法_热点聚焦_翻转 话题 “霸总”发言遭吐槽对职场年轻人多些体谅 8 看法_视界《人力资源》投稿&#xff1a;cn7kantougao163.com 养老保险改革及其对人事工作的启示 赵梓安; 12-13 做…
阅读更多...
潘展乐速度！滴滴无车赔，叫车就是快

潘展乐速度！滴滴无车赔，叫车就是快

8月5日&#xff0c;滴滴网约车“快”乐大使潘展乐在男子4x100米混合泳接力比赛中以45秒92的优异成绩在最后一棒反超&#xff0c;中国队夺得金牌&#xff01;恭喜潘展乐在本届比赛中和队友一起站上冠军的领奖台&#xff0c;用团队金牌为自己庆生&#xff01; 为进一步提升用户叫…
阅读更多...
三级等保测评如何顺利通过

三级等保测评如何顺利通过

三级等保认证&#xff0c;作为中国信息安全等级保护制度中的高级别认证&#xff0c;其标准之高、要求之严&#xff0c;在国内信息安全领域内堪称顶尖。根据《信息系统安全等级保护基本要求》&#xff0c;三级等保的测评内容覆盖了等级保护安全技术要求和安全管理要求的多个层面…
阅读更多...
android13 删除兼容性警告窗口 deprecation warning 去除弃用警告

android13 删除兼容性警告窗口 deprecation warning 去除弃用警告

总纲 android13 rom 开发总纲说明 目录 1.前言 2.情况 3.问题分析 4.代码更改 5.编译测试 6.彩蛋 1.前言 在 Android 13 中，为了提高用户体验和应用的兼容性，系统引入了一些新的隐私和安全特性。这些特性可能会影响旧版应用的行为，因此当用户运行可能不完全兼容 An…
阅读更多...
【HarmonyOS NEXT星河版开发学习】小型测试案例01-今日头条置顶练习

【HarmonyOS NEXT星河版开发学习】小型测试案例01-今日头条置顶练习

个人主页→VON 收录专栏→鸿蒙开发小型案例总结​​​​​ 基础语法部分会发布于github 和 gitee上面 ​ 前言 本系列可能是博客首发&#xff0c;鸿蒙开发星河版是一个全新的版本&#xff0c;由于参考视频较少鸿蒙开发不被重视导致csdn上面并没有全套的学习路线&#xff0c;…
阅读更多...
6款免费版文章生成器，为你的创作提供无限可能

6款免费版文章生成器，为你的创作提供无限可能

在这个信息发展迅速的时代&#xff0c;创作者们常常陷入时间和灵感的困境中。为了应对这一挑战&#xff0c;人工智能技术为我们提供了一种全新的解决方案——文章生成器。在这些文章生成器中可以帮助我们快速生成高质量的内容&#xff0c;为我们的创作提供无限可能。在本文中&a…
阅读更多...
json文件格式

json文件格式

json文件格式 格式介绍1格式介绍2格式3 格式介绍1 格式介绍2 格式3 参考地址
阅读更多...
全自动真空拌馅机 肠类肉丸类馅料搅拌机：

全自动真空拌馅机 肠类肉丸类馅料搅拌机：

拌馅机&#xff0c;作为现代厨房与食品加工行业不可或缺的利器&#xff0c;其优点繁多&#xff0c;宛如烹饪艺术中的魔术师&#xff0c;为食材的融合与美味的创造开辟了新的维度。 首先&#xff0c;拌馅机以其高效均匀的搅拌能力著称&#xff0c;能够瞬间将肉类、蔬菜、调料等多…
阅读更多...
微信小程序 - 自定义计数器 - 优化(键盘输入校验)

微信小程序 - 自定义计数器 - 优化(键盘输入校验)

微信小程序通过自定义组件&#xff0c;实现计数器值的增加、减少、清零、最大最小值限定、禁用等操作。通过按钮事件触发方式&#xff0c;更新计数器的值&#xff0c;并修改相关联的其它变量。通过提升用户体验&#xff0c;对计数器进行优化设计&#xff0c;使用户操作更加便捷…
阅读更多...
亚马逊测评：提升产品信誉与销量的关键

亚马逊测评：提升产品信誉与销量的关键

在亚马逊这样竞争激烈的环境中。通过有效的测评&#xff0c;卖家可以轻松为自己的产品添加评论、提高排名&#xff0c;进而打造出优质的产品。然而&#xff0c;亚马逊测评并不等同于刷单。今天&#xff0c;将深入探讨亚马逊测评的本质、与刷单的区别&#xff0c;以及如何在这个…
阅读更多...
新能源车燃料和动力电池及系统应用概述(上)

新能源车燃料和动力电池及系统应用概述(上)

随着化石能源的日益消耗和对环保的逐渐重视&#xff0c;利用电能取代化石能源作为动力的电动汽车受到了世界各国的关注和大力研发。电池技术作为电动汽车的核心和瓶颈&#xff0c;是电动汽车研究的重点和热点方向&#xff0c;也是关系到新能源汽车成本、续航里程、安全性及使用…
阅读更多...
【LLM大模型】一文掌握Prompt：万能框架+优化技巧+常用指标

【LLM大模型】一文掌握Prompt：万能框架+优化技巧+常用指标

随着大模型在2023年横空出世&#xff0c;“Prompt 工程” 应运而生&#xff0c;作为用好大模型最重要的武器&#xff0c;Prompt 的好坏对模型效果有着决定性的影响。然而&#xff0c;网络上大量相关文章多是罗列“Prompt 工程” 中的若干技巧&#xff0c;少有体系化的总结&…
阅读更多...
gym/Gymnasium强化学习玩推箱子游戏

gym/Gymnasium强化学习玩推箱子游戏

gym/Gymnasium强化学习玩推箱子游戏 gym 框架 源码 https://github.com/openai/gym 文档 https://www.gymlibrary.dev/ 自 2021 年以来一直维护 Gym 的团队已将所有未来的开发转移到 Gymnasium&#xff0c;这是 Gym 的替代品&#xff08;将 gymnasium 导入为 gym&#xff09;…
阅读更多...
k8s工作负载控制器--DaemonSet

k8s工作负载控制器--DaemonSet

文章目录 一、概述二、适用场景三、基本操作1、官网的DaemonSet资源清单2、字段解释3、编写DaemonSet资源清单4、基于yaml创建DaemonSet5、注意点5.1、必须字段5.2、DaemonSet 对象的名称5.3、.spec.selector 与 .spec.template.metadata.labels之间的关系 6、查看DaemonSet6.1…
阅读更多...
主成分分析和线性判别分析

主成分分析和线性判别分析

主成分分析 (PCA) PCA 是一种线性降维方法&#xff0c;通过投影到主成分空间&#xff0c;尽可能保留数据的方差。 原理 PCA 通过寻找数据投影后方差最大的方向&#xff0c;主成分是这些方向上的正交向量。 公式推理 对数据中心化&#xff1a; 其中&#xff0c;μ 是数据的…
阅读更多...
姿态矫正app-不良坐姿语音提示

姿态矫正app-不良坐姿语音提示

“让爷康康”是一款应用于安卓平台的手机应用&#xff0c;可以实时监测不良坐姿并给出语音提示。本项目主要基于 [Tensorflow Lite 官方示例 - 姿态估计] 文件结构 ├───android │ ├───app │ │ └───src │ └───gradle ├───doc_images ├───…
阅读更多...
科普文：JUC系列之Java中7种阻塞队列DelayQueue用法

科普文：JUC系列之Java中7种阻塞队列DelayQueue用法

阻塞队列DelayQueue是一种无界阻塞队列&#xff0c;‌用于放置实现了Delayed接口的对象。‌这些对象只能在其到期时才能从队列中取走&#xff0c;‌这种队列是有序的&#xff0c;‌即队头对象的延迟到期时间最长。‌如果没有任何延迟到期的对象&#xff0c;‌那么就不会有任何头…
阅读更多...
示例：在ML.NET中应用Model Builder模型生成器构建图片对象检测模型

示例：在ML.NET中应用Model Builder模型生成器构建图片对象检测模型

一、目的&#xff1a;ML.NET 是一个开源且跨平台的机器学习框架&#xff0c;专为 .NET 开发人员设计。它允许你在 .NET 应用程序中构建、训练和部署机器学习模型&#xff0c;而无需离开 .NET 生态系统。ML.NET 支持多种机器学习任务&#xff0c;包括分类、回归、聚类、异常检测…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023