文心一言 VS 讯飞星火 VS chatgpt （282）-- 算法导论20.4 3题

news2024/11/23 15:23:50

三、在 CONNECTED-COMPONENTS 作用于一个有 k 个连通分量的无向图 G=(V，E) 的过程中，FIND-SET 需要调用多少次？ UNION 需要调用多少次？用 |V| 、 |E| 和 k 来表示你的答案。如果要写代码，请用go语言。

文心一言：

在并查集（Union-Find）算法中，CONNECTED-COMPONENTS 通常指的是一个过程，它遍历图中的所有边，并对每个边调用 UNION 操作以合并两个顶点所属的集合，直到没有边需要处理为止。这个过程中，FIND-SET 操作通常在 UNION 操作之前被调用，以确定两个顶点当前所属的集合。

对于一个有 k 个连通分量的无向图 G=(V, E)：

  • FIND-SET 的调用次数取决于 UNION 的实现和图的特性。在最基本的情况下，每次调用 UNION 时，我们都需要两次 FIND-SET 调用（一次用于每个顶点），以确定它们当前的集合。因此，FIND-SET 的调用次数至少是 2|E|，因为每条边都可能导致两次 FIND-SET 调用。但是，请注意，在某些优化版本的并查集算法中（如路径压缩），FIND-SET 的实际调用次数可能会少于这个值。

  • UNION 的调用次数则直接等于图的边数 |E|，因为每条边都需要调用一次 UNION 来尝试合并其两个端点所属的集合。

用 |V|、|E| 和 k 来表示答案，我们可以说：

  • FIND-SET 至少被调用 2|E| 次（在没有优化的情况下）。
  • UNION 被调用 |E| 次。

下面是一个简化的 Go 语言实现，它模拟了 FIND-SET 和 UNION 的基本行为（没有路径压缩或按秩合并等优化）：

package main

import (
	"fmt"
)

type UnionFind struct {
	parent []int
}

func NewUnionFind(n int) *UnionFind {
	parent := make([]int, n)
	for i := 0; i < n; i++ {
		parent[i] = i // 初始时每个元素都是自己的根
	}
	return &UnionFind{parent: parent}
}

func (uf *UnionFind) FindSet(x int) int {
	if uf.parent[x] != x {
		// 这里可以添加路径压缩优化
		uf.parent[x] = uf.FindSet(uf.parent[x]) // 递归查找根节点
	}
	return uf.parent[x]
}

func (uf *UnionFind) Union(x, y int) {
	rootX := uf.FindSet(x)
	rootY := uf.FindSet(y)
	if rootX != rootY {
		uf.parent[rootX] = rootY // 合并集合
	}
}

func ConnectedComponents(V, E int, edges [][]int) int {
	uf := NewUnionFind(V)
	k := V // 初始连通分量数量等于顶点数

	for _, edge := range edges {
		uf.Union(edge[0], edge[1])
		// 在这里，我们可以计数FIND-SET的调用次数，但通常我们不会这样做，因为它取决于实现
		// 假设每次UNION都调用两次FIND-SET
		// findSetCount += 2 // 假设的FIND-SET调用计数器

		// 检查连通分量是否减少（仅用于演示目的）
		if uf.FindSet(edge[0]) != uf.FindSet(edge[1]) {
			// 合并前它们属于不同集合，合并后减少一个连通分量
			k--
		}
	}

	// 返回最终的连通分量数量k，但题目要求的是FIND-SET和UNION的调用次数
	// 我们假设FIND-SET被调用了2|E|次（没有优化），UNION被调用了|E|次
	// return k, 2*E, E // 如果需要返回这些值的话

	// 这里我们只打印结果，因为题目只问调用次数
	fmt.Printf("FIND-SET was called at least %d times (without optimizations).\n", 2*E)
	fmt.Printf("UNION was called %d times.\n", E)
	return k // 但我们仍然返回连通分量数量k以保持函数完整性
}

func main() {
	V := 5 // 顶点数
	E := 4 // 边数
	edges := [][]int{{0, 1}, {1, 2}, {3, 4}, {0, 3}} // 示例边
	k := ConnectedComponents(V, E, edges)

讯飞星火：

在无向图 G=(V，E) 中，如果存在 k 个连通分量，那么 FIND-SET 和 UNION 操作的调用次数如下：

FIND-SET 需要调用 |V| 次。因为我们需要遍历图中的所有顶点，以确定每个顶点所在的集合或连通分量。

UNION 需要调用 |E| 次。因为我们需要遍历图中的所有边，以合并每条边连接的两个顶点所在的集合或连通分量。

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

package main

import (
	"fmt"
)

type UnionFind struct {
	parent []int
}

func NewUnionFind(size int) *UnionFind {
	parent := make([]int, size)
	for i := range parent {
		parent[i] = i
	}
	return &UnionFind{parent: parent}
}

func (uf *UnionFind) Find(x int) int {
	if uf.parent[x] != x {
		uf.parent[x] = uf.Find(uf.parent[x])
	}
	return uf.parent[x]
}

func (uf *UnionFind) Union(x, y int) {
	rootX := uf.Find(x)
	rootY := uf.Find(y)
	if rootX != rootY {
		uf.parent[rootX] = rootY
	}
}

func main() {
	vertices := [][]int{{0, 1}, {1, 2}, {3, 4}}
	k := 2
	n := 5

	uf := NewUnionFind(n)

	for _, edge := range vertices {
		uf.Union(edge[0], edge[1])
	}

	findCount := 0
	unionCount := len(vertices)

	for i := 0; i < n; i++ {
		if uf.Find(i) == i {
			findCount++
		}
	}

	fmt.Printf("FIND-SET 调用次数： %d\n", findCount)
	fmt.Printf("UNION 调用次数： %d\n", unionCount)
}

在这个示例中，我们首先创建了一个并查集结构，然后遍历所有边进行合并操作。最后，我们统计了 FIND-SET 和 UNION 的调用次数。

360智脑：

在连接组件算法（CONNECTED-COMPONENTS）中，FIND-SET 和 UNION 是用于合并和查找集合的两个基本操作。对于一个无向图 G=(V, E)，我们可以通过以下步骤来找出其连通分量的数量：

  1. 遍历整个图，对每个顶点执行一次 FIND-SET 操作，以确定它们当前属于哪个连通分量。
  2. 对于每条边 (u, v)，如果 u 和 v 属于不同的连通分量（即 FIND-SET(u) != FIND-SET(v)），则执行一次 UNION 操作将它们合并。

因此，FIND-Set 的调用次数最多为 |V|，因为每个顶点至少被访问一次。而 UNION 的调用次数最多为 |E|，因为每条边都会导致一次或多次 UNION 操作（取决于它连接了多少个连通分量）。

所以，我们可以用 |V| 表示 FIND-Set 的调用次数，用 |E| 表示 UNION 的调用次数。

在 Go 语言中，实现上述算法的伪代码可能如下：

type UnionFind struct {
    parent []int
    size []int
}

func NewUnionFind(n int) *UnionFind {
    uf := &UnionFind{
        parent: make([]int, n),
        size:   make([]int, n),
    }
    for i := range uf.parent {
        uf.parent[i] = i
    }
    return uf
}

func (uf *UnionFind) FindSet(x int) int {
    if uf.parent[x] != x {
        uf.parent[x] = uf.FindSet(uf.parent[x])
    }
    return uf.parent[x]
}

func (uf *UnionFind) Union(x int, y int) {
    rootX := uf.FindSet(x)
    rootY := uf.FindSet(y)

    if rootX == rootY {
        return
    }

    if uf.size[rootX] < uf.size[rootY] {
        uf.parent[rootX] = rootY
        uf.size[rootY] += uf.size[rootX]
    } else {
        uf.parent[rootY] = rootX
        uf.size[rootX] += uf.size[rootY]
    }
}

func ConnectedComponents(graph [][]int) int {
    n := len(graph)
    uf := NewUnionFind(n)

    var count int

    for i := range graph {
        for j := range graph[i] {
            if graph[i][j] == 1 {
                u := uf.FindSet(i)
                v := uf.FindSet(j)
                if u != v {
                    uf.Union(u, v)
                    count++
                }
            }
        }
    }
    return count
}

在这个例子中，ConnectedComponents 函数返回的是连通分量的数量 k，FindSet 被调用不超过 |V| 次，而 Union 被调用不超过 |E| 次。

智谱清言：

在处理包含 k 个连通分量的无向图 G 的 connected-components 算法中，FIND-SET 和 UNION 操作的调用次数取决于图的大小和连通分量的数量。

  • FIND-SET 操作用于确定一个顶点所属的连通分量。对于图中的每个顶点，我们只需执行一次 FIND-SET，因为每个顶点只属于一个连通分量。所以，FIND-SET 会被调用 |V| 次。
  • UNION 操作用于将两个不同连通分量中的顶点合并到同一个连通分量中。在最坏的情况下，即图是完全非连通的，每个连通分量都只有一个顶点时，每个连通分量在合并过程中都会与其他所有连通分量执行一次 UNION 操作。因此，第一个连通分量需要 (k-1) 次 UNION，第二个连通分量需要 (k-2) 次，以此类推，直到最后一个连通分量不需要任何 UNION 操作。所以，UNION 操作的总调用次数是 ( \frac{k(k-1)}{2} )。
    下面是使用 Go 语言实现的 connected-components 算法：
package main
import (
	"fmt"
)
// 定义并查集的结构体
type UnionFind struct {
	parent []int
	rank   []int
}
// 初始化并查集
func (uf *UnionFind) Init(size int) {
	uf.parent = make([]int, size)
	uf.rank = make([]int, size)
	for i := range uf.parent {
		uf.parent[i] = i
		uf.rank[i] = 1
	}
}
// 查找操作
func (uf *UnionFind) Find(x int) int {
	if uf.parent[x] != x {
		uf.parent[x] = uf.Find(uf.parent[x])
	}
	return uf.parent[x]
}
// 合并操作
func (uf *UnionFind) Union(x, y int) {
	rootX := uf.Find(x)
	rootY := uf.Find(y)
	if rootX != rootY {
		if uf.rank[rootX] > uf.rank[rootY] {
			uf.parent[rootY] = rootX
		} else if uf.rank[rootX] < uf.rank[rootY] {
			uf.parent[rootX] = rootY
		} else {
			uf.parent[rootY] = rootX
			uf.rank[rootX]++
		}
	}
}
// 主函数
func main() {
	// 假设图中有 6 个顶点，2 个连通分量
	size := 6
	k := 2
	uf := UnionFind{}
	uf.Init(size)
	// 模拟图的边，进行合并操作
	edges := [][]int{{0, 1}, {2, 3}, {4, 5}}
	for _, edge := range edges {
		uf.Union(edge[0], edge[1])
	}
	// 输出每个顶点所属的连通分量
	for i := 0; i < size; i++ {
		fmt.Println("顶点", i, "属于连通分量", uf.Find(i))
	}
	fmt.Println("FIND-SET 调用次数：", size)
	fmt.Println("UNION 调用次数：", (k-1)*(k/2))
}

在上述代码中，我们首先初始化了一个并查集，然后模拟了图的边，进行了合并操作。最后，我们输出每个顶点所属的连通分量，并打印了 FIND-SET 和 UNION 的调用次数。

天工：

在分析这个问题之前，我们需要明确CONNECTED-COMPONENTS、FIND-SET和UNION的概念。CONNECTED-COMPONENTS通常是指在图算法中找到所有连通分量的过程。FIND-SET是一种操作，用于确定一个元素属于哪个集合，而UNION是将两个集合合并为一个的操作。这些操作通常与并查集（Disjoint Set Union, DSU）数据结构相关联。

对于一个有k个连通分量的无向图G=(V, E)，我们可以这样分析：

  1. FIND-SET的调用次数：在最坏情况下，每个顶点都需要调用一次FIND-SET来确定它所属的连通分量。因此，FIND-SET的调用次数将是|V|。

  2. UNION的调用次数：由于我们已经有k个连通分量，为了合并它们，我们需要进行k-1次UNION操作。这是因为每次UNION都会减少一个连通分量，直到只剩下一个连通分量为止。

综上所述，FIND-SET的调用次数为|V|，而UNION的调用次数为k-1。

至于用Go语言编写代码，这里提供一个简单的并查集实现示例：

package main

import "fmt"

type UnionFind struct {
	parent []int
	size   []int
}

func NewUnionFind(n int) *UnionFind {
	uf := &UnionFind{
		parent: make([]int, n),
		size:   make([]int, n),
	}
	for i := 0; i < n; i++ {
		uf.parent[i] = i
		uf.size[i] = 1
	}
	return uf
}

func (uf *UnionFind) FindSet(x int) int {
	if uf.parent[x] != x {
		uf.parent[x] = uf.FindSet(uf.parent[x])
	}
	return uf.parent[x]
}

func (uf *UnionFind) Union(x, y int) {
	xRoot := uf.FindSet(x)
	yRoot := uf.FindSet(y)
	if xRoot != yRoot {
		if uf.size[xRoot] < uf.size[yRoot] {
			uf.parent[xRoot] = yRoot
			uf.size[yRoot] += uf.size[xRoot]
		} else {
			uf.parent[yRoot] = xRoot
			uf.size[xRoot] += uf.size[yRoot]
		}
	}
}

func main() {
	// 假设有一个图有5个顶点和3个连通分量
	uf := NewUnionFind(5)
	// 进行3-1=2次UNION操作来合并连通分量
	uf.Union(0, 1)
	uf.Union(2, 3)
	// 打印每个顶点的父节点，即所属的连通分量
	for i := 0; i < 5; i++ {
		fmt.Printf("Vertex %d belongs to set %d\n", i, uf.FindSet(i))
	}
}

在这个示例中，我们创建了一个具有5个顶点的并查集，并进行了两次UNION操作来模拟合并连通分量的过程。最后，我们通过FIND-SET操作来确定每个顶点所属的连通分量。

灵小智：

在 CONNECTED-COMPONENTS 过程中，FIND-SET 需要调用 k 次，因为对于每个连通分量，都需要调用一次 FIND-SET 来查找其代表元素。而 UNION 需要调用 k-1 次，因为将 k 个连通分量合并成一个连通分量需要 k-1 次 UNION 操作。

用 |V| 表示图 G 的顶点数，|E| 表示边数，k 表示连通分量数。

以下是用 Go 语言伪代码表示 CONNECTED-COMPONENTS 过程中 FIND-SET 和 UNION 的调用次数：

package main

import "fmt"

type DisjointSet struct {
    parent []int
}

func NewDisjointSet(size int) *DisjointSet {
    ds := &DisjointSet{
        parent: make([]int, size),
    }
    for i := range ds.parent {
        ds.parent[i] = i
    }
    return ds
}

func (ds *DisjointSet) Find(x int) int {
    if ds.parent[x] != x {
        ds.parent[x] = ds.Find(ds.parent[x])
    }
    return ds.parent[x]
}

func (ds *DisjointSet) Union(x, y int) {
    rootX := ds.Find(x)
    rootY := ds.Find(y)
    if rootX != rootY {
        ds.parent[rootX] = rootY
    }
}

func main() {
    // 假设已经构建了图 G，顶点数为 |V|，边数为 |E|，有 k 个连通分量
    V := 10  // 顶点数
    E := 15  // 边数
    k := 3   // 连通分量数

    // 创建一个大小为 |V| 的并查集
    ds := NewDisjointSet(V)

    // 进行 k 次 FIND-SET 调用
    for i := 0; i < k; i++ {
        _ = ds.Find(i)
    }

    // 进行 k-1 次 UNION 调用
    for i := 0; i < k-1; i++ {
        ds.Union(i, i+1)
    }

    fmt.Println("FIND-SET 调用次数:", k)
    fmt.Println("UNION 调用次数:", k-1)
}

希望这个回答对您有帮助！如果您有任何其他问题或需要进一步解释，请随时告诉我。

chatgpt：

在Connected-Components过程中，FIND-SET需要调用|V|次，而UNION需要调用k-1次。

下面是使用Go语言编写的代码示例：

package main

import (
	"fmt"
)

type UnionFind struct {
	parent []int
	rank   []int
}

func NewUnionFind(n int) *UnionFind {
	parent := make([]int, n)
	rank := make([]int, n)

	for i := 0; i < n; i++ {
		parent[i] = i
		rank[i] = 0
	}

	return &UnionFind{
		parent: parent,
		rank:   rank,
	}
}

func (uf *UnionFind) Find(x int) int {
	if uf.parent[x] != x {
		uf.parent[x] = uf.Find(uf.parent[x])
	}
	return uf.parent[x]
}

func (uf *UnionFind) Union(x, y int) {
	rootX := uf.Find(x)
	rootY := uf.Find(y)

	if rootX == rootY {
		return
	}

	if uf.rank[rootX] < uf.rank[rootY] {
		uf.parent[rootX] = rootY
	} else if uf.rank[rootX] > uf.rank[rootY] {
		uf.parent[rootY] = rootX
	} else {
		uf.parent[rootY] = rootX
		uf.rank[rootX]++
	}
}

func ConnectedComponents(V int, E [][]int) int {
	unionFind := NewUnionFind(V)

	for _, edge := range E {
	    // 将边的两个节点进行合并操作
	    unionFind.Union(edge[0], edge[1])
    }
    
    count := 0
    
    for i := 0; i < V; i++ {
        if unionFind.parent[i] == i {
            count++
        }
    }

	return count
}

func main() {
	V := 8 // 图的节点数
	E := [][]int{
		{0, 1},
		{2, 3},
		{4, 5},
		{6, 7},
	}

	k := ConnectedComponents(V, E)

	fmt.Printf("FIND-SET调用次数：%d\n", V)
	fmt.Printf("UNION调用次数：%d\n", k-1)
}

这段代码中，我们使用了并查集（Union-Find）数据结构来进行连通分量的计算。在ConnectedComponents函数中，首先创建了一个UnionFind对象，并依次将边上的两个节点进行合并操作。最后通过遍历parent数组统计有多少个根节点，即为连通分量的个数。
零声教育专注于linux c/c++的底层技术原理分享：https://it.0voice.com

kimi：

在CONNECTED-COMPONENTS算法中，FIND-SET和UNION是两个关键操作。FIND-SET用于找出一个顶点所在的集合（即连通分量），而UNION用于合并两个集合。以下是这两个操作在算法中调用次数的分析：

  1. FIND-SET调用次数：对于图中的每个顶点，FIND-SET至少被调用一次，因为我们在算法开始时需要确定每个顶点的初始集合。此外，每当我们处理一条边并发现两个顶点不在同一个集合时，我们也需要调用FIND-SET来确定它们的集合。因此，FIND-SET的调用次数至少是顶点数|V|。在最坏的情况下，如果每条边连接的两个顶点都在不同的集合中，FIND-SET的调用次数最多是边数|E|加上顶点数|V|。

  2. UNION调用次数：UNION操作在每次两个不同集合的顶点通过边连接时被调用。由于初始时有k个连通分量，每次调用UNION会减少一个连通分量。因此，UNION的调用次数等于边数|E|减去连通分量数k加1（因为最后一个连通分量不需要调用UNION）。

综上所述，FIND-SET和UNION的调用次数可以表示为：

  • FIND-SET调用次数：至少|V|
  • UNION调用次数：|E| - k + 1

以下是使用Go语言实现的CONNECTED-COMPONENTS算法的示例代码，包括对FIND-SET和UNION调用次数的计数：

package main

import (
	"fmt"
)

const (
	N = 5 // 假设有5个顶点
	k = 3 // 假设有3个连通分量
	E = 6 // 假设有6条边
)

// 假设其他数据结构和函数定义

func main() {
	// 初始化图和连通分量
	// ...

	fmt.Printf("FIND-SET is called at least %d times.\n", N)
	fmt.Printf("UNION is called %d times.\n", E-k+1)
}

请注意，这个示例代码仅用于说明FIND-SET和UNION调用次数的计算方法，并没有实现完整的CONNECTED-COMPONENTS算法。在实际应用中，你需要根据具体需求实现图的数据结构和算法逻辑。此外，实际的调用次数可能会因图的具体结构和算法实现细节而有所不同。

在这里插入图片描述

在这里插入图片描述

混元：

在无向图中，使用并查集（UNION-FIND）算法处理连通分量问题时，FIND-SET 和 UNION 操作的次数与图的边数和连通分量的数量有关。下面我们来分析这两种操作需要的调用次数。

FIND-SET 调用次数

FIND-SET 操作通常用于查找元素所在集合的代表元素。在处理连通分量时，每个节点都会被调用一次 FIND-SET 以确定它所属的连通分量。因此，FIND-SET 的调用次数等于图中节点的数量，即：

FIND-SET 调用次数 = |V|

UNION 调用次数

UNION 操作用于合并两个集合。在处理连通分量时，每一条边都可能会导致两个不同的连通分量合并。因此，理想情况下，UNION 的调用次数等于边的数量，即：

UNION 调用次数 = |E|

然而，需要注意的是，在某些实现中，当两个元素已经属于同一个集合时，UNION 操作可能不会执行任何操作（因为它们已经是连通的）。在实际应用中，这可能会减少不必要的 UNION 调用。但是，在最坏的情况下，每条边都需要进行一次 UNION 操作，所以上面的公式仍然成立。

Go 语言代码示例

以下是一个简单的 Go 语言实现，展示了如何使用并查集来计算无向图的连通分量数量：

package main

import (
	"fmt"
)

type UnionFind struct {
	parent []int
}

func NewUnionFind(n int) *UnionFind {
	parent := make([]int, n)
	for i := range parent {
		parent[i] = i
	}
	return &UnionFind{parent: parent}
}

func (uf *UnionFind) FindSet(x int) int {
	if uf.parent[x] != x {
		uf.parent[x] = uf.FindSet(uf.parent[x]) // Path compression
	}
	return uf.parent[x]
}

func (uf *UnionFind) Union(x, y int) {
	rootX := uf.FindSet(x)
	rootY := uf.FindSet(y)
	if rootX != rootY {
		uf.parent[rootX] = rootY // Merge sets
	}
}

func main() {
	// 假设我们有一个无向图，节点数为 |V|，边数为 |E|，并且我们知道它有 k 个连通分量
	var V, E, k int
	// ... 初始化 V, E, k ...

	uf := NewUnionFind(V)
	for i := 0; i < E; i++ {
		// 假设 edges 是一个包含所有边的切片，每个边由一对节点表示
		// uf.Union(edges[i][0], edges[i][1])
	}

	// 计算连通分量的数量
	components := make(map[int]bool)
	for i := 0; i < V; i++ {
		components[uf.FindSet(i)] = true
	}
	k = len(components)

	fmt.Printf("Number of connected components: %d\n", k)
}

在这个代码示例中，我们没有直接计算 FIND-SET 和 UNION 的调用次数，但你可以通过在 FindSet 和 Union 方法中添加计数器来跟踪它们的调用次数。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

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

相关文章

【Java】过滤器/拦截器

【Java】过滤器/拦截器

文章目录 两者区别request链路全过程 在实际开发中&#xff0c;过滤器和拦截器都是经常使用的技术&#xff0c;但一被提及到其区别时&#xff0c;整个人就愣住了&#xff0c;好像没有认真地对两者进行区别和总结&#xff0c;这两者之间也确实很容易混淆&#xff0c;因此结合了很…
阅读更多...
C++ 54 之 继承中同名的静态成员处理

C++ 54 之 继承中同名的静态成员处理

#include <iostream> using namespace std;// 父类 class Base07{ public:static int m_a; // 静态成员&#xff0c;类内定义static void fun(){cout << "Base中的fun"<< endl;}static void fun(int a){cout << "Base中的fun(int a)&qu…
阅读更多...
53. QT插件开发--插件(动态库so)的调用与加载

53. QT插件开发--插件(动态库so)的调用与加载

1. 说明 在使用QT进行插件库的开发之后，还需要将这个插件库程序生成的so动态链接库加载到主程序框架中进行使用，才能达到主程序的模块化开发的效果。在前一篇文章插件创建中介绍了如何在QT中开发插件库，并提供外部接口调用。本篇博客的主要作用是模拟在主程序框架中加载动态…
阅读更多...
EasyRecovery2024数据恢复神器#电脑必备良品

EasyRecovery2024数据恢复神器#电脑必备良品

EasyRecovery数据恢复软件&#xff0c;让你的数据重见天日&#xff01; 大家好&#xff01;今天我要给大家种草一个非常实用的软件——EasyRecovery数据恢复软件&#xff01;你是不是也曾经遇到过不小心删除了重要的文件&#xff0c;或者电脑突然崩溃导致数据丢失的尴尬情况呢&…
阅读更多...
element-ui input输入框和多行文字输入框字体不一样

element-ui input输入框和多行文字输入框字体不一样

页面中未作样式修改&#xff0c;但是在项目中使用element-ui input输入框和多行文字输入框字体不一样&#xff0c;如下图所示&#xff1a; 这是因为字体不一致引起的&#xff0c;如果想要为Element UI的输入框设置特定的字体&#xff0c;你可以在你的样式表中添加以下CSS代码…
阅读更多...
快速UDP网络连接之QUIC协议介绍

快速UDP网络连接之QUIC协议介绍

文章目录 一、QUIC协议历史1.1 问题&#xff1a;QUIC为什么在应用层实现1.2 QUIC协议相关术语1.3 QUIC和TCP对比1.4 QUIC报文格式1.4.1 QUIC报文格式-Stream帧11.4.2 QUIC报文格式-Stream帧2 二、QUIC的特点2.1 连接建立低时延&#xff0c;2.2 多路复用流复用-HTTP1.1流复用-HT…
阅读更多...
SpringBoot整合H2数据库并将其打包成jar包、转换成exe文件二（补充）

SpringBoot整合H2数据库并将其打包成jar包、转换成exe文件二（补充）

SpringBoot整合H2数据库并将其打包成jar包、转换成exe文件二&#xff08;补充&#xff09; 如果你想在cmd命令窗口内看到程序运行&#xff0c;即点开弹出运行窗口&#xff0c;关闭时exe自动关闭。 需要再launch4j上进行如下操作&#xff1a; 这样转换好的exe就可以有控制台了…
阅读更多...
springboot + Vue前后端项目（第十六记）

springboot + Vue前后端项目（第十六记）

项目实战第十六记 写在前面1 第一个bug1.1 完整的Role.vue 2 第二个bug2.1 修改路由router下面的index.js 总结写在最后 写在前面 发现bug&#xff0c;修复bug 1 第一个bug 分配菜单时未加入父id&#xff0c;导致分配菜单失效 <!-- :check-strictly"true" 默…
阅读更多...
人工智能对零售业的影响

人工智能对零售业的影响

机器人、人工智能相关领域 news/events &#xff08;专栏目录&#xff09; 本文目录 一、人工智能如何改变零售格局二、利用人工智能实现购物体验自动化三、利用人工智能改善库存管理四、通过人工智能解决方案增强客户服务五、利用人工智能分析消费者行为六、利用 AI 打造个性化…
阅读更多...
C++前期概念（重）

C++前期概念（重）

目录 命名空间 命名空间定义 1. 正常的命名空间定义 2. 命名空间可以嵌套 3.头文件中的合并 命名空间使用 命名空间的使用有三种方式&#xff1a; 1:加命名空间名称及作用域限定符&#xff08;::&#xff09; 2:用using将命名空间中某个成员引入 3:使用using namespa…
阅读更多...
TCP协议报头详解

TCP协议报头详解

目录 前言 TCP特点 TCP报头 1.源端口和目的端口 2.序号 3.确认号 4.数据偏移 5.保留 6.控制位 ① 紧急URG&#xff08;URGent&#xff09; ② 确认ACK&#xff08;ACKnowledgment&#xff09; ③ 推送PSH&#xff08;PuSH&#xff09; ④复位RST&#xff08;ReSeT&…
阅读更多...
【数据结构】初识集合深入剖析顺序表（Arraylist）

【数据结构】初识集合深入剖析顺序表（Arraylist）

【数据结构】初识集合&深入剖析顺序表&#xff08;Arraylist&#xff09; 集合体系结构集合的遍历迭代器增强for遍历lambda表达式 List接口中的增删查改List的5种遍历ArrayList详解ArrayList的创建ArrayList的增删查改ArrayList的遍历ArrayList的底层原理 &#x1f680;所属…
阅读更多...
UnityAPI学习之 播放游戏音频的类（AudioSource）

UnityAPI学习之 播放游戏音频的类（AudioSource）

播放游戏音频的类&#xff08;AudioSource&#xff09; using System.Collections; using System.Collections.Generic; using UnityEngine;public class NO17AudioSource : MonoBehaviour {private AudioSource audioSource;//音频组件public AudioClip clip;//音频文件public…
阅读更多...
预编译、函数变量提升

预编译、函数变量提升

函数声明会覆盖变量的声明&#xff0c;也就是会提升到最前面。 形参传进来相当于变量声明&#xff0c;所以当有函数声明时&#xff0c;会被覆盖。
阅读更多...
情绪管理：大我则定，小我则乱（王阳明）

情绪管理：大我则定，小我则乱（王阳明）

学了很多知识&#xff0c;却还是感物易动&#xff1f;如何让心回归中正&#xff1f;王阳明一言以蔽之&#xff1a; —— 大我&#xff0c;大我则定&#xff0c;小我则乱 保持心静的方法&#xff1a;有大爱&#xff0c;为大局着想
阅读更多...
Spark-Shuffle阶段优化-Bypass机制详解

Spark-Shuffle阶段优化-Bypass机制详解

Spark概述 Spark-Shuffle阶段优化-Bypass机制详解 Spark的Bypass机制是一种特定情况下的优化策略&#xff0c;目的是减少Shuffle过程中不必要的排序开销&#xff0c;从而提升性能。当Shuffle分区数较少且数据量不大时&#xff0c;Bypass机制可以显著加快Shuffle速度。 1.什么…
阅读更多...
使用 Nginx 和 SSL 访问 Python Flask 应用的教程

使用 Nginx 和 SSL 访问 Python Flask 应用的教程

在本教程中&#xff0c;我们将介绍如何使用 Nginx 和 SSL 来访问 Python Flask 应用。通过这种方式&#xff0c;你可以在提高安全性的同时&#xff0c;也能利用 Nginx 的反向代理功能来优化应用的性能和稳定性。 环境准备 在开始之前&#xff0c;请确保你的系统已经安装了以…
阅读更多...
准备离职了 电脑怎么清理？离职最干净的电脑清理办法

准备离职了 电脑怎么清理？离职最干净的电脑清理办法

准备离职了 电脑怎么清理&#xff1f;离职最干净的电脑清理办法 人在江湖身不由己&#xff0c;离职这个事情&#xff0c;所有人都要面对。无论是出于个人发展、工作环境、薪资待遇还是其他原因&#xff0c;离职都是人生和职业道路上的一种常态。离职是一个残酷的事实&#xff…
阅读更多...
【每日刷题】Day66

【每日刷题】Day66

【每日刷题】Day66 &#x1f955;个人主页&#xff1a;开敲&#x1f349; &#x1f525;所属专栏&#xff1a;每日刷题&#x1f34d; &#x1f33c;文章目录&#x1f33c; 1. 小乐乐改数字_牛客题霸_牛客网 (nowcoder.com) 2. 牛牛的递增之旅_牛客题霸_牛客网 (nowcoder.com)…
阅读更多...
Zabbix Centos8 安装笔记

Zabbix Centos8 安装笔记

Zabbix 安装笔记 安装环境 Centos 8 正常发行版 安装版本 Zabbix 7 (LTS) 安装步骤 1、关闭防火墙 systemctl stop firewalld && systemctl disable firewalld && setenforce 0 && sed -i s/SELINUXenforcing/SELINUXdisabled/g /etc/selinux/c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023