文心一言 VS 讯飞星火 VS chatgpt （291）-- 算法导论21.3 4题

四、假设想要增加一个 PRINT-SET(x) 操作，它是对于给定的结点 x 打印出 x 所在集合的所有成员，顺序可以任意。如何对一棵不相交集合森林的每个结点仅增加一个属性，使得 PRINT-SET(x) 所花费的时间同 x 所在集合元素的个数呈线性关系，并且其他操作的渐近运行时间不改变。这里假设我们可在 O(1) 的时间内打印出集合的每个成员。如果要写代码，请用go语言。

文心一言：

在不相交集合森林（也称为并查集或Disjoint Set Forest）中，通常每个结点（或称为元素）会包含一个指向其父结点的指针，这个结构用于高效地执行合并（UNION）和查找（FIND-SET）操作。为了支持 PRINT-SET(x) 操作，同时保持其他操作的渐近运行时间不变，我们可以在每个结点中增加一个指向集合中下一个元素的指针，形成一个循环链表。

下面是使用Go语言实现这一结构的例子：

package mainimport ("fmt"
)// DisjointSetNode 表示并查集中的结点
type DisjointSetNode struct {parent   *DisjointSetNode // 父结点指针rank     int              // 用于优化UNION操作的秩next     *DisjointSetNode // 指向集合中下一个元素的指针，用于PRINT-SETvalue    interface{}      // 结点值，可以是任意类型
}// FindSet 查找元素x所属的集合的代表元素（根结点）
func FindSet(x *DisjointSetNode) *DisjointSetNode {if x.parent != x {x.parent = FindSet(x.parent) // 路径压缩}return x.parent
}// Union 合并两个集合（通过它们的代表元素）
func Union(x, y *DisjointSetNode) {rootX, rootY := FindSet(x), FindSet(y)if rootX == rootY {return // 已经是同一个集合}if rootX.rank < rootY.rank {rootX.parent = rootY} else if rootX.rank > rootY.rank {rootY.parent = rootX} else { // 如果秩相同，将y的秩加1以确保树的高度尽可能平衡rootY.parent = rootXrootX.rank++}// 在这里不需要更新next指针，因为PRINT-SET操作会重新构建循环链表
}// PrintSet 打印元素x所在集合的所有成员
func PrintSet(x *DisjointSetNode) {root := FindSet(x)current := rootvisited := make(map[*DisjointSetNode]bool) // 用于检查是否已访问过，防止循环visited[root] = truefmt.Printf("Set of %v: ", x.value)for current != nil {fmt.Print(current.value, " ")next := current.next// 如果遇到nil或已访问过的结点，说明循环结束for next != nil && visited[next] {next = next.next}current.next = next // 临时修改next指针以形成循环链表current = nextif next != nil {visited[next] = true}}fmt.Println()// 恢复next指针为nil（可选）current = rootfor current != nil {current.next = nilcurrent = current.next // 注意这里使用原始的next值，它现在是nil}
}func main() {// 示例用法a := &DisjointSetNode{value: 'a', parent: nil, rank: 0, next: nil}b := &DisjointSetNode{value: 'b', parent: nil, rank: 0, next: nil}c := &DisjointSetNode{value: 'c', parent: nil, rank: 0, next: nil}Union(a, b)Union(b, c)PrintSet(a) // 应该打印出 'a b c 'PrintSet(b) // 应该打印出 'a b c 'PrintSet(c) // 应该打印出 'a b c '
}

注意，在上面的 PrintSet 函数中，我们使用了 visited 映射来避免在循环链表中重复访问元素。因为 next 指针在集合合并时不会被更新，所以我们在打印集合时需要手动构建循环链表。打印完集合后，我们将 next 指针恢复为 nil（这是可选的，取决于你是否想在打印后保持集合的内部状态不变）。

此外，上述代码中的 FindSet 使用了路径压缩技术来优化查找操作，使得 FindSet 的平均时间复杂度接近于常数。而 Union 操作则通过比较秩来

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火：

为了实现 PRINT-SET(x) 操作，我们可以在每个结点上添加一个指向其父节点的指针。这样，当我们想要打印一个集合的所有成员时，我们可以通过遍历这个集合的所有结点并打印它们来实现。具体来说，我们可以从给定的结点 x 开始，沿着父节点指针向上遍历，直到找到一个没有父节点的结点（即根节点）。然后，我们可以再次遍历从根节点到 x 的所有路径，打印出所有遇到的结点。

以下是使用 Go 语言实现的代码：

package mainimport "fmt"type Node struct {parent *Nodevalue  int
}func NewNode(value int) *Node {return &Node{parent: nil, value: value}
}func (n *Node) SetParent(p *Node) {n.parent = p
}func PrintSet(x *Node) {if x == nil {return}// 找到根节点for x.parent != nil {x = x.parent}// 打印从根节点到当前结点的所有路径上的结点for y := x; y != nil; y = y.parent {fmt.Println(y.value)}
}func main() {// 创建一个简单的不相交集合森林示例node1 := NewNode(1)node2 := NewNode(2)node3 := NewNode(3)node4 := NewNode(4)node2.SetParent(node1)node3.SetParent(node1)node4.SetParent(node2)// 测试 PRINT-SET 操作PrintSet(node4) // 输出：1, 2, 4
}

在这个实现中，我们为每个结点添加了一个指向其父节点的指针。PrintSet 函数首先找到给定结点的根节点，然后遍历从根节点到给定结点的所有路径，打印出所有遇到的结点。这样，PRINT-SET(x) 的时间复杂度就是 O(log n)，其中 n 是树的高度。其他操作的时间复杂度保持不变。

360智脑：

为了实现 PRINT-SET(x) 操作，我们可以为每个结点添加一个额外的属性，即指向其所在集合的代表结点的指针。这样，当我们需要打印一个集合时，我们可以通过遍历从给定结点到代表结点的路径上的所有结点来实现。由于路径上的结点数量等于集合中的元素数量，因此这个操作的时间复杂度与集合的大小成线性关系。

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

type Node struct {parent *Node // 父节点指针rank   int   // 用于路径压缩和按秩合并的秩setRep *Node // 指向集合代表的指针
}// 初始化结点
func MakeSet(x *Node) {x.parent = xx.rank = 0x.setRep = x // 初始时，每个结点都是自己集合的代表
}// 查找结点的代表结点，并进行路径压缩
func FindSet(x *Node) *Node {if x != x.parent {x.parent = FindSet(x.parent)}return x.parent
}// 合并两个集合
func Union(x *Node, y *Node) {link(FindSet(x), FindSet(y))
}// 链接两个结点，按秩合并
func link(x *Node, y *Node) {if x.rank > y.rank {y.parent = xy.setRep = x // 更新 y 的集合代表指针} else {x.parent = yx.setRep = y // 更新 x 的集合代表指针if x.rank == y.rank {y.rank++}}
}// 打印集合
func PrintSet(x *Node) {rep := FindSet(x)printSetRecursive(rep)
}// 递归打印集合
func printSetRecursive(node *Node) {fmt.Println(node)current := nodefor current.parent != current {current = current.parentfmt.Println(current)}
}// 测试代码
func main() {nodes := []*Node{&Node{}, &Node{}, &Node{}, &Node{}}for _, node := range nodes {MakeSet(node)}Union(nodes[0], nodes[1])Union(nodes[2], nodes[3])Union(nodes[1], nodes[2])PrintSet(nodes[0])
}

在这个实现中，MakeSet、FindSet 和 Union 函数保持了原有的时间复杂度不变，而 PrintSet 函数通过递归地打印从给定结点到代表结点的路径上的所有结点来实现打印集合的操作。由于每次递归都会打印一个结点，因此打印整个集合的时间复杂度与集合的大小成线性关系。

智谱清言：

为了实现 PRINT-SET(x) 操作，我们可以为每个结点添加一个额外的属性，即指向其所在集合的代表结点的指针。这样，当我们需要打印一个集合时，我们可以通过遍历从给定结点到代表结点的路径上的所有结点来实现。由于路径上的结点数量等于集合中的元素数量，因此这个操作的时间复杂度与集合的大小成线性关系。

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

type Node struct {parent *Node // 父节点指针rank   int   // 用于路径压缩和按秩合并的秩setRep *Node // 指向集合代表的指针
}// 初始化结点
func MakeSet(x *Node) {x.parent = xx.rank = 0x.setRep = x // 初始时，每个结点都是自己集合的代表
}// 查找结点的代表结点，并进行路径压缩
func FindSet(x *Node) *Node {if x != x.parent {x.parent = FindSet(x.parent)}return x.parent
}// 合并两个集合
func Union(x *Node, y *Node) {link(FindSet(x), FindSet(y))
}// 链接两个结点，按秩合并
func link(x *Node, y *Node) {if x.rank > y.rank {y.parent = xy.setRep = x // 更新 y 的集合代表指针} else {x.parent = yx.setRep = y // 更新 x 的集合代表指针if x.rank == y.rank {y.rank++}}
}// 打印集合
func PrintSet(x *Node) {rep := FindSet(x)printSetRecursive(rep)
}// 递归打印集合
func printSetRecursive(node *Node) {fmt.Println(node)current := nodefor current.parent != current {current = current.parentfmt.Println(current)}
}// 测试代码
func main() {nodes := []*Node{&Node{}, &Node{}, &Node{}, &Node{}}for _, node := range nodes {MakeSet(node)}Union(nodes[0], nodes[1])Union(nodes[2], nodes[3])Union(nodes[1], nodes[2])PrintSet(nodes[0])
}

在这个实现中，MakeSet、FindSet 和 Union 函数保持了原有的时间复杂度不变，而 PrintSet 函数通过递归地打印从给定结点到代表结点的路径上的所有结点来实现打印集合的操作。由于每次递归都会打印一个结点，因此打印整个集合的时间复杂度与集合的大小成线性关系。

天工：

为了实现 PRINT-SET(x) 操作，我们需要在不相交集合森林中的每个结点上增加一个指向其父节点的指针。这样，我们可以通过沿着树的路径从结点 x 向上遍历到根节点，然后从根节点向下遍历到所有叶子节点来打印出集合的所有成员。这种遍历可以在每个结点上花费常数时间，因此总时间是线性的。

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

type DisjointSetNode struct {parent *DisjointSetNode // 指向父节点的指针rank   int              // 用于路径压缩和按秩合并的秩value  string           // 结点的值
}func MakeSet(x *DisjointSetNode) {x.parent = xx.rank = 0
}func FindSet(x *DisjointSetNode) *DisjointSetNode {if x.parent != x {x.parent = FindSet(x.parent) // 路径压缩}return x.parent
}func Union(x *DisjointSetNode, y *DisjointSetNode) {link(FindSet(x), FindSet(y))
}func link(x *DisjointSetNode, y *DisjointSetNode) {if x.rank > y.rank {y.parent = x} else {x.parent = yif x.rank == y.rank {y.rank++}}
}func PrintSet(x *DisjointSetNode) {root := FindSet(x)printHelper(root)
}func printHelper(node *DisjointSetNode) {if node != nil {fmt.Println(node.value)printHelper(node.parent)}
}// 示例用法
func main() {nodes := []*DisjointSetNode{&DisjointSetNode{value: "A"},&DisjointSetNode{value: "B"},&DisjointSetNode{value: "C"},&DisjointSetNode{value: "D"},}for _, node := range nodes {MakeSet(node)}Union(nodes[0], nodes[1])Union(nodes[2], nodes[3])Union(nodes[0], nodes[2])PrintSet(nodes[1]) // 打印出集合 {"A", "B", "C", "D"}
}

在这个实现中，MakeSet 函数创建一个新的集合，其中包含单个元素。FindSet 函数找到一个元素的集合的代表，并在返回之前执行路径压缩。Union 函数将两个集合合并为一个。PrintSet 函数打印出给定结点所在集合的所有成员。

请注意，这个实现假设我们可以在常数时间内打印出集合的每个成员。如果打印操作不是常数时间，那么 PrintSet 的总时间将与集合的大小成正比。此外，这个实现没有改变其他操作（如 MakeSet、FindSet 和 Union）的渐近运行时间。

灵小智：

为了实现 PRINT-SET(x) 操作，我们可以通过修改不相交集合森林的每个结点，使其具有指向集合中所有成员的指针。这样，当调用 PRINT-SET(x) 时，只需遍历该结点指向的所有成员并打印出来，时间复杂度与集合元素个数成线性关系。

以下是一个示例的 Go 代码，演示如何修改不相交集合森林的结点以支持 PRINT-SET(x) 操作：

package mainimport "fmt"type Node struct {parent *Noderank   intmembers []int
}func MakeSet(x int) *Node {return &Node{parent: nil, rank: 0, members: []int{x}}
}func Find(node *Node) *Node {if node.parent == nil {return node}return Find(node.parent)
}func Union(x, y *Node) {rootX := Find(x)rootY := Find(y)if rootX == rootY {return}if rootX.rank < rootY.rank {rootX, rootY = rootY, rootX}rootY.parent = rootXrootX.members = append(rootX.members, rootY.members...)if rootY.rank == rootX.rank {rootX.rank++}
}func PrintSet(x *Node) {for _, member := range x.members {fmt.Println(member)}
}func main() {// 示例用法node1 := MakeSet(1)node2 := MakeSet(2)Union(node1, node2)PrintSet(node1)
}

通过将每个结点扩展为包含成员列表，我们可以在 O(1) 的时间内打印出集合的每个成员，同时保持其他操作的渐近运行时间不变。

chatgpt：

为了实现给每个节点增加一个属性以支持 PRINT-SET(x) 操作的线性时间复杂度，可以使用路径压缩和按秩合并的思想。具体代码如下（Go语言）：

package mainimport "fmt"type Node struct {parent *Noderank   intvalue  interface{} // 节点的值，可以根据需求修改类型
}func MakeSet(x *Node) {x.parent = xx.rank = 0
}func Find(x *Node) *Node {if x != x.parent {x.parent = Find(x.parent) // 路径压缩}return x.parent
}func Union(x, y *Node) {rootX := Find(x)rootY := Find(y)if rootX == rootY {return}if rootX.rank < rootY.rank {rootX.parent = rootY} else if rootX.rank > rootY.rank {rootY.parent = rootX} else {rootY.parent = rootXrootX.rank++}
}// 增加一个属性用于记录集合元素数量，并在合并时更新该属性值
func AddPrintSetAttribute(root *Node, value interface{}) {root.value = value // 设置节点值为集合元素数量
}// 打印出给定节点所在集合的所有成员（遍历打印）
func PrintSet(root *Node) {current := Find(root)for current != nil {fmt.Println(current.value)current = current.parent}
}func main() {node1 := &Node{}node2 := &Node{}node3 := &Node{}node4 := &Node{}MakeSet(node1)MakeSet(node2)MakeSet(node3)MakeSet(node4)AddPrintSetAttribute(node1, 1)AddPrintSetAttribute(node2, 2)AddPrintSetAttribute(node3, 3)AddPrintSetAttribute(node4, 4)Union(node1, node2) // 合并集合 {1, 2}Union(node3, node4) // 合并集合 {3, 4}PrintSet(Find(node1)) // 打印出集合 {1, 2} 的所有成员PrintSet(Find(node3)) // 打印出集合 {3, 4} 的所有成员
}

上述代码使用不相交集合森林的数据结构，并在每个节点中增加一个属性来记录集合元素数量。通过路径压缩和按秩合并的策略，使得 PRINT-SET(x) 操作的时间复杂度与 x 所在集合元素个数成线性关系，并且其他操作（如 MakeSet、Find、Union）的渐近运行时间不变。最后，在打印时遍历打印出给定节点所在集合的所有成员。

混元：

为了实现 PRINT-SET(x) 操作，我们可以在每个结点 x 上增加一个属性 parent，用来记录 x 的父结点。同时，我们需要一个字典（或哈希表）来存储每个集合的根结点及其成员列表。这样，在执行 PRINT-SET(x) 时，我们可以从 x 开始向上查找其根结点，然后打印出该集合的所有成员。

首先，我们需要定义一个结构体来表示结点，并包含 parent 属性：

type Node struct {value intparent *Node
}

接下来，我们需要实现以下几个操作：

  1. 初始化不相交集合森林
  2. 查找结点的根结点
  3. 合并两个集合
  4. 执行 PRINT-SET(x) 操作

以下是相应的 Go 语言实现：

package mainimport "fmt"type Node struct {value intparent *Node
}// 初始化不相交集合森林
func initDisjointSetForest(size int) []*Node {nodes := make([]*Node, size)for i := range nodes {nodes[i] = &Node{value: i}}return nodes
}// 查找结点的根结点
func find(node *Node) *Node {if node.parent == nil {return node}node.parent = find(node.parent) // 路径压缩return node.parent
}// 合并两个集合
func union(node1, node2 *Node) {root1 := find(node1)root2 := find(node2)if root1 != root2 {root1.parent = root2}
}// 执行 PRINT-SET(x) 操作
func printSet(node *Node, sets map[int][]*Node) {root := find(node)for _, n := range sets[root.value] {fmt.Printf("%d ", n.value)}fmt.Println()
}func main() {nodes := initDisjointSetForest(10)sets := make(map[int][]*Node)for _, node := range nodes {sets[node.value] = append(sets[node.value], node)}union(nodes[1], nodes[2])union(nodes[3], nodes[4])union(nodes[5], nodes[6])printSet(nodes[1], sets) // 输出: 1 2printSet(nodes[3], sets) // 输出: 3 4printSet(nodes[5], sets) // 输出: 5 6
}

在这个实现中，PRINT-SET(x) 操作的时间复杂度为 O(n)，其中 n 是 x 所在集合的元素个数。其他操作的渐近运行时间保持不变。

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

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

相关文章

金顺心贸易有限公司简介

金顺心贸易有限公司简介

金顺心贸易有限公司成立于2015年&#xff0c;注册地位于风景如画的广西壮族自治区防城港市东兴市。 金顺心贸易如他们的名字一样&#xff0c;有着实实在在的业绩和口碑的。他们专注于国际贸易&#xff0c;主营越南进口食品&#xff1a;果汁饮料、春卷皮、调味品、汤底、米粉、…
阅读更多...
定制聚四氟乙烯架子离心管架子消解管样品架

定制聚四氟乙烯架子离心管架子消解管样品架

南京瑞尼克定制离心管架子、消解管架子、微波罐架子等&#xff0c;各种实验室所需器皿样品架。 我司聚四氟乙烯架子优势&#xff1a; 1.耐强腐蚀&#xff08;耐各种强酸强碱和有机溶剂&#xff09; 2.耐高低温&#xff1a;-200至250℃ 3.工艺精制&#xff0c;尺寸&#xff0…
阅读更多...
算法设计与分析--考试真题

算法设计与分析--考试真题

分布式算法试题汇总选择题简答题算法题 2013级试题2019级试题2021年秋考卷 根据考试范围找相应题目做。 分布式算法试题汇总 选择题 下述说法错误的是___ A 异步系统中的消息延迟是不确定的 B 分布式算法的消息复杂性是指在所有合法的执行上发送消息总数的最大值 C 在一个异步…
阅读更多...
如何实现高精度PCB切割？— 在线式激光切割机解决方案

如何实现高精度PCB切割？— 在线式激光切割机解决方案

在线式PCB精密激光切割机是一种专门用于电子行业中印刷电路板&#xff08;PCB&#xff09;切割的高精度设备。以下是关于在线式PCB精密激光切割机的详细信息和特点&#xff1a; 1. 工作原理&#xff1a; 在线式PCB精密激光切割机主要通过激光束的高能量密度对PCB板进行瞬时加热…
阅读更多...
新手必备！短视频剪辑常用的18个技巧——剪映篇

新手必备！短视频剪辑常用的18个技巧——剪映篇

导入素材&#xff1a;这里我们可以选择自己拍摄好的素材&#xff08;图片、视频或录制好的音频&#xff09;&#xff0c;按照顺序导入剪辑区剪辑。这一步是剪辑的基础&#xff0c;确定剪辑的大体思路与成片框架&#xff01;别忽略了&#xff0c;剪映官方素材库提供的素材&#…
阅读更多...
私域流量的深度解析与电商应用

私域流量的深度解析与电商应用

一、私域流量的核心价值 在当今数字化时代&#xff0c;流量成为了企业发展的重要资源。与公域流量相比&#xff0c;私域流量以其独有的私有性和可复用性&#xff0c;为企业提供了与用户建立深度联系的机会。私域流量不仅有助于企业精准触达目标用户&#xff0c;还能通过数据分…
阅读更多...
python办公自动化之excel

python办公自动化之excel

用到的库&#xff1a;openpyxl 实现效果&#xff1a;读取单元格的值&#xff0c;写入单元格 代码&#xff1a; import openpyxl # 打开现有工作簿 workbookopenpyxl.load_workbook(现有工作簿.xlsx) # 选择一个工作表 sheetworkbook[交易表] # 读取单元格的值 cell_valueshe…
阅读更多...
甄选版“论软件系统架构评估”，软考高级，系统架构设计师

甄选版“论软件系统架构评估”，软考高级，系统架构设计师

论文真题 对于软件系统，尤其是大规模的复杂软件系统来说，软件的系统架构对于确保最终系统的质量具有十分重要的意义，不恰当的系统架构将给项目开发带来高昂的代价和难以避免的灾难。对一个系统架构进行评估，是为了:分析现有架构存在的潜在风险，检验设计中提出的质量需求，…
阅读更多...
一名HR，在招聘嵌入式开发岗位，为什么感觉一年比一年难？

一名HR，在招聘嵌入式开发岗位，为什么感觉一年比一年难？

在开始前刚好我有一些资料&#xff0c;是我根据网友给的问题精心整理了一份「嵌入式的资料从专业入门到高级教程」&#xff0c; 点个关注在评论区回复“888”之后私信回复“888”&#xff0c;全部无偿共享给大家&#xff01;&#xff01;&#xff01; 1.嵌入式学用不一致, 高…
阅读更多...
Dubbo快速入门

Dubbo快速入门

1. Dubbo概述 官网地址&#xff1a;https://cn.dubbo.apache.org/zh-cn/ Apache Dubbo 是一款高性能的轻量级的Java RPC框架&#xff0c;可以和Spring框架无缝集成。 本地调用&#xff1a;本机调用&#xff0c;指同个JVM内部的方法调用&#xff0c;例如三层架构之间的方法调用…
阅读更多...
白话EAGLE2：解锁大模型的“打草稿”技术

白话EAGLE2：解锁大模型的“打草稿”技术

实时了解业内动态&#xff0c;论文是最好的桥梁&#xff0c;专栏精选论文重点解读热点论文&#xff0c;围绕着行业实践和工程量产。若在某个环节出现卡点&#xff0c;可以回到大模型必备腔调或者LLM背后的基础模型重新阅读。而最新科技&#xff08;Mamba,xLSTM,KAN&#xff09;…
阅读更多...
通义灵码上线 Visual Studio 插件市场啦！

通义灵码上线 Visual Studio 插件市场啦！

通义灵码&#xff0c;是阿里云出品的一款基于通义大模型的智能编码辅助工具&#xff0c;提供行级/函数级实时续写、自然语言生成代码、单元测试生成、代码优化、注释生成、代码解释、研发智能问答、异常报错排查等能力&#xff0c;提供代码智能生成、研发智能问答能力。 通义灵…
阅读更多...
flutter开发实战-ListWheelScrollView与自定义TimePicker时间选择器

flutter开发实战-ListWheelScrollView与自定义TimePicker时间选择器

flutter开发实战-ListWheelScrollView与自定义TimePicker 最近在使用时间选择器的时候&#xff0c;需要自定义一个TimePicker效果&#xff0c;当然这里就使用了ListWheelScrollView。ListWheelScrollView与ListView类似&#xff0c;但ListWheelScrollView渲染效果类似滚筒效果…
阅读更多...
【vue3】【vant】 移动端中国传统文化和民间传说案例

【vue3】【vant】 移动端中国传统文化和民间传说案例

更多项目点击&#x1f446;&#x1f446;&#x1f446;完整项目成品专栏 【vue3】【vant】 移动端中国传统文化和民间传说案例 获取源码方式项目说明&#xff1a;其中功能包括项目包含&#xff1a;项目运行环境运行截图和视频 获取源码方式 加Q群&#xff1a;632562109项目说…
阅读更多...
Vip-智能预估+大数据标签+人群全选=用户分群！

Vip-智能预估+大数据标签+人群全选=用户分群！

Mobpush用户分群功能升级&#xff0c;创建推送入口vip用户可进入自有选择标签创建“用户分群”&#xff0c;相比于免费标签&#xff0c;“用户标签”维度更丰富。在应用基础属性上&#xff0c;增加“品牌”、“网络状态”、“运营商”&#xff0c;众所周知&#xff0c;不同厂商…
阅读更多...
MJ可以SD就不行么？Stable Diffusion 轻松复刻12生肖水果拼盘，我被AI水果拼盘惊艳到了！

MJ可以SD就不行么？Stable Diffusion 轻松复刻12生肖水果拼盘，我被AI水果拼盘惊艳到了！

有人用MJ可以轻松生成AI水果拼盘&#xff0c;今天老徐就带大家试试用Stable Diffusion**如何轻松复刻实现。 提示词模版&#xff1a; fruit shapes for chinese new year a wonderful example of edible art, in the style of hyperrealistic wildlife portraits, 1 piece ma…
阅读更多...
为什么ISO 45001职业健康安全管理体系是企业发展的基石

为什么ISO 45001职业健康安全管理体系是企业发展的基石

ISO 45001源自OHSAS 18001职业健康和安全管理体系&#xff0c;是全球第一个国际职业健康和安全管理标准。ISO&#xff08;国际标准化组织&#xff09;于2018年发布了这一标准&#xff0c;旨在帮助各类组织为员工提供一个更安全、更健康的工作环境。与OHSAS 18001相比&#xff0…
阅读更多...
2024年跨境电商关键数据统计：市场规模将达到1.976万亿美元

2024年跨境电商关键数据统计：市场规模将达到1.976万亿美元

预计2024年跨境电商消费市场规模将达到1.976万亿美元&#xff0c;占全球网上销售总额的31.2%。这一数据无疑展示了跨境电商市场的巨大潜力和迅猛增长趋势。 全球跨境电商的现状与未来 现状 2023年&#xff0c;全球跨境电商市场规模预计达到1.56万亿美元&#xff0c;占全球电子…
阅读更多...
【网络安全学习】漏洞利用：BurpSuite的使用-02-常用的标签

【网络安全学习】漏洞利用：BurpSuite的使用-02-常用的标签

下面介绍一下BurpSuite各个标签的用法&#x1f447; 1️⃣ Dashboard标签 Dashboard&#xff0c;顾名思义就是BurpSuite的仪表盘&#xff0c;可以通过Dashboard进行漏洞扫描&#xff0c;不过该功能需要升级到pro版本&#xff0c;也就是得交钱&#x1f62d;。 2️⃣ Target标签…
阅读更多...
借助AI写代码，使用通义灵码智能编写Java和Vue3项目，在Idea和vscode里用AI写代码

借助AI写代码，使用通义灵码智能编写Java和Vue3项目，在Idea和vscode里用AI写代码

在人工智能技术越来越成熟的当下&#xff0c;好多人说AI会取代程序员&#xff0c;这句话石头哥不知可否。但是有一点可以肯定&#xff0c;会熟练使用Ai&#xff0c;驾驭Ai的程序员肯定不会被时代所淘汰。所以今天石头哥就来教大家如何借助Ai来提升自己的代码编写效率。 一&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023