网易首页 > 网易号 > 正文 申请入驻

文心一言 VS 讯飞星火 VS chatgpt (257)-- 算法导论19.2 1题

0
分享至

一、给出图19-4(m)中的斐波那契堆调用 FIB-HEAP-EXTRACT-MIN 后得到的斐波那契堆。如果要写代码,请用go语言。

文心一言:

由于我不能直接画出图19-4(m)中的斐波那契堆,我将基于斐波那契堆的基本结构和操作FIB-HEAP-EXTRACT-MIN的一般行为来描述如何更新斐波那契堆。

在斐波那契堆中,每个节点都有一个度(指向它的孩子节点的数量)、一个标记(用于合并操作)和一个键(用于确定节点的优先级)。斐波那契堆由一组根节点和一个最小节点(具有最小键值的节点)组成。

FIB-HEAP-EXTRACT-MIN操作从斐波那契堆中移除并返回具有最小键值的节点,同时更新堆的结构以保持其性质。以下是该操作的基本步骤:

如果堆为空,则报错。 否则,移除并返回最小节点。 如果最小节点有孩子节点,则将其孩子节点加入到根节点列表中,并设置它们的父节点为nil。 如果最小节点有兄弟节点(即它不是唯一的根节点),则执行合并操作: 遍历所有根节点,并将标记为true的节点的所有兄弟节点合并到该节点下。 更新合并后的节点的度。 如果在合并过程中有节点的度变为1并且其父节点不存在或者标记为false,则将该节点标记为true。 如果在合并过程中有节点的度变为0(即没有孩子节点),则将其从堆中移除。 找到新的最小节点,并更新堆的最小节点指针。 以下是一个简化的Go语言实现,仅用于说明FIB-HEAP-EXTRACT-MIN操作的基本逻辑(注意:这不是一个完整的斐波那契堆实现):

packagemain
import(
"container/heap"
"fmt"
)
//FibNode表示斐波那契堆中的一个节点
typeFibNodestruct{
keyint
degreeint
markbool
parent*FibNode
child*FibNode//简化起见,这里只表示一个孩子节点
sibling*FibNode
}
//FibHeap表示斐波那契堆
typeFibHeapstruct{
min*FibNode
//这里可以添加其他字段,如根节点列表等
}
//FIB-HEAP-EXTRACT-MIN的简化实现
func(h*FibHeap)ExtractMin()*FibNode{
ifh.min==nil{
returnnil//堆为空
}
min:=h.min
h.min=nil//假设这里只是简单地设置为nil,实际中需要找到新的最小节点
//假设这里处理孩子节点和合并操作...
//...
//返回最小节点
returnmin
}
//注意:这里省略了斐波那契堆的其他操作(如插入、合并、减小键等)
//以及处理孩子节点和合并操作的完整逻辑。
funcmain(){
//假设有一个斐波那契堆h,并且已经填充了数据...
//h:=FibHeap{...}
//提取最小节点
minNode:=h.ExtractMin()
ifminNode!=nil{
fmt.Printf("Extractedminnodewithkey:%d\n",minNode.key)
}
//...其他逻辑...
}

请注意,上面的代码是一个非常简化的示例,并没有实现斐波那契堆的所有功能和细节。在实际应用中,你需要实现完整的斐波那契堆数据结构,包括节点之间的链接、根节点列表、合并操作、减小键操作等。此外,由于斐波那契堆不是Go标准库中的一部分,你可能需要自己实现堆接口(如heap.Interface)的方法或使用其他数据结构来模拟斐波那契堆的行为。

讯飞星火:

在斐波那契堆中,FIB-HEAP-EXTRACT-MIN操作会移除并返回最小元素。以下是使用Go语言实现的代码:

typeNodestruct{
keyint
rankint
child*Node
next*Node
}
typeFibHeapstruct{
min*Node
sizeint
}
func(fh*FibHeap)ExtractMin()*Node{
z:=fh.min
ifz!=nil{
forx:=z.child;x!=nil;x=x.next{
fh._add(x,&fh.min)
}
ifz==z.next{
fh.min=nil
}else{
fh.min=z.next
fh._consolidate()
}
fh.size-=1
}
returnz
}
func(fh*FibHeap)_add(x,y*Node){
//省略具体实现...
}
func(fh*FibHeap)_consolidate(){
//省略具体实现...
}

在这个代码中,我们首先定义了节点和斐波那契堆的结构。然后实现了ExtractMin方法,该方法首先保存最小节点z,然后将z的所有子节点添加到堆中,最后从堆中删除z,并调用_consolidate方法来调整堆的结构。

360智脑:

抱歉,由于我无法看到具体的图19-4(m),所以无法直接提供调用后得到的斐波那契堆。斐波那契堆是一种数据结构,用于实现优先队列,它通过合并操作来提取最小元素。

FIB-HEAP-EXTRACT-MIN

下面是一个简单的 Go 语言示例,展示了如何定义一个基本的斐波那契堆结构以及函数的伪代码:

FIB-HEAP-EXTRACT-MIN

packagemain
import(
"fmt"
)
typeFibonacciHeapstruct{
root*Node
countint
minimum*Node
}
typeNodestruct{
keyint
valueinterface{}
parent*Node
children[]*Node
isMarkedbool
}
func(f*FibonacciHeap)ExtractMin()*Node{
iff.root==nil{
returnnil
}
min:=f.minimum
ifmin==nil{
returnnil
}
//删除最小节点并更新最小值
f.root=merge(f.root,min)
f.count--
f.updateMinimum()
//如果最小节点的孩子不为空,则将它们链接到根列表
ifmin.children!=nil{
for_,child:=rangemin.children{
child.parent=nil
f.root=insert(f.root,child)
}
}
returnmin
}
func(f*FibonacciHeap)updateMinimum(){
varnewMinimum*Node
varvisitfunc(*Node)bool
visit=func(n*Node)bool{
ifn==nil{
returnfalse
}
ifnewMinimum==nil||n.keynewMinimum=n
}
for_,child:=rangen.children{
ifvisit(child){
returntrue
}
}
returnfalse
}
visit(f.root)
f.minimum=newMinimum
}
funcinsert(node*Node,child*Node)*Node{
child.parent=node
node.children=append(node.children,child)
returnnode
}
funcmerge(x,y*Node)*Node{
ifx==nil{
returny
}
ify==nil{
returnx
}
ifx.keyx.children=append(x.children,y)
y.parent=x
returnx
}else{
y.children=append(y.children,x)
x.parent=y
returny
}
}
funcNewFibonacciHeap()*FibonacciHeap{
return&FibonacciHeap{
root:nil,
count:0,
minimum:nil,
}
}
funcmain(){
//假设我们有一个图示的斐波那契堆实例
//以下代码用于演示如何从该实例中提取最小元素
fibHeap:=NewFibonacciHeap()
//这里应该有插入元素的代码,但是由于没有图示,我们无法知道具体插入哪些元素
//提取最小元素
minNode:=fibHeap.ExtractMin()
fmt.Printf("提取的最小元素为:%v\n",minNode.value)
//这里应该有进一步操作的代码,但是由于没有图示,我们无法知道具体做什么操作
}

请注意,上面的代码仅提供了基本的斐波那契堆结构和方法的实现,并未涵盖所有功能。在实际应用中,还需要实现其他方法,如插入元素、显示堆中的元素等。此外,根据图19-4(m)的具体内容,您可能需要调整代码以适应特定的情况。

ExtractMin

智谱清言:

抱歉,由于您的请求中没有提供图19-4(m)中的斐波那契堆的初始结构,我无法直接给出操作后的堆。斐波那契堆是一种数据结构,用于实现优先队列,其中包含多种操作,如插入、提取最小元素、减少键值等。

FIB-HEAP-EXTRACT-MIN

在Go语言中实现斐波那契堆是一个相对复杂的任务,通常涉及对斐波那契堆算法的深入理解。下面是一个简化的Go语言代码示例,展示了如何实现斐波那契堆的基本结构以及操作的其中一个可能的实现。请注意,这段代码并不完整,也没有展示整个斐波那契堆的实现,而是为了展示如何开始构建此类数据结构。

FIB-HEAP-EXTRACT-MIN

packagemain
import(
"fmt"
)
//定义节点结构
typeFibonacciHeapNodestruct{
keyint
degreeint
parent*FibonacciHeapNode
child*FibonacciHeapNode
left*FibonacciHeapNode
right*FibonacciHeapNode
}
//斐波那契堆结构
typeFibonacciHeapstruct{
min*FibonacciHeapNode
root*FibonacciHeapNode
}
//新建节点
funcnewNode(keyint)*FibonacciHeapNode{
return&FibonacciHeapNode{
key:key,
degree:0,
parent:nil,
child:nil,
left:nil,
right:nil,
}
}
//插入操作
func(h*FibonacciHeap)Insert(keyint){
newNode:=newNode(key)
ifh.min==nil||keyh.min=newNode
}
h.root.left=newNode
newNode.right=h.root
h.root=newNode
}
//FIB-HEAP-EXTRACT-MIN操作的简化版本
func(h*FibonacciHeap)ExtractMin()*FibonacciHeapNode{
min:=h.min
ifmin==nil{
returnnil
}
//TODO:这里需要实现完整的提取最小元素逻辑
//包括重新组织斐波那契堆,合并子树等操作
returnmin
}
funcmain(){
heap:=&FibonacciHeap{}
heap.Insert(10)
heap.Insert(15)
heap.Insert(5)
heap.Insert(3)
min:=heap.ExtractMin()
fmt.Println("Extractedmin:",min.key)
}

请注意,上述代码仅为示例,操作的完整实现涉及到复杂的逻辑,包括合并子树、重新平衡堆等。完整的斐波那契堆实现需要更多的时间和空间来展示。 如果您需要关于如何实现整个斐波那契堆的详细指导或者具体的代码示例,请提供更多的上下文或者具体的请求。

FIB-HEAP-EXTRACT-MIN

天工:

以下是使用Go语言实现的斐波那契堆(Fibonacci heap)的函数的代码:

FIB-HEAP-EXTRACT-MIN

packagefibheap
import"fmt"
typenodestruct{
keyint
parent*node
childs[]*node
degreeint
}
func(n*node)String()string{
returnfmt.Sprintf("Node{key:%d,parent:%p,childs:%v,degree:%d}",n.key,n.parent,n.childs,n.degree)
}
typefibHeapstruct{
min*node
sizeint
nodesmap[*node]*node//反向映射,方便查找节点
}
func(fh*fibHeap)add(n*node){
ifn.keyfh.min=n
}
fh.nodes[n]=n
fh.size++
}
func(fh*fibHeap)removeMin()*node{
min:=fh.min
delete(fh.nodes,min)
fh.size--
returnmin
}
//这里只是一个示例,实际的FIB-HEAP-EXTRACT-MIN函数需要更复杂的逻辑来处理节点的合并等操作
func(fh*fibHeap)FIBHEAP_EXTRACT_MIN()*node{
min:=fh.removeMin()
returnmin
}
//创建一个空的斐波那契堆
funcNewFibonacciHeap()*fibHeap{
return&fibHeap{
min:nil,
size:0,
nodes:make(map[*node]*node),
}
}
//测试代码
funcmain(){
//创建一个空的斐波那契堆
fh:=NewFibonacciHeap()
//添加一些节点到斐波那契堆中
fori:=0;i<10;i++{
n:=&node{key:i}
fh.add(n)
}
//提取最小元素
min:=fh.FIBHEAP_EXTRACT_MIN()
fmt.Println("Extractedminimum:",min)
}

请注意,这段代码只是一个简单的示例,它并没有完全实现斐波那契堆的所有特性,比如节点的合并等操作。实际的函数需要更复杂的逻辑来处理这些情况。此外,为了简化代码,我在这里假设了一个全局的变量,并将其作为参数传递给了函数。在实际应用中,你可能需要将作为一个对象来处理。

FIB-HEAP-EXTRACT-MIN

fibHeap

fh

FIBHEAP_EXTRACT_MIN

fibHeap

灵小智:

很抱歉,我不能直接提供图像或编写代码。但是,我可以告诉你如何使用Go语言实现斐波那契堆和FIB-HEAP-EXTRACT-MIN操作。

首先,你需要定义一个结构体来表示斐波那契堆的节点:

typeNodestruct{
keyint
degreeint
parent*Node
child*Node
left*Node
right*Node
markbool
}

接下来,你可以创建一个斐波那契堆的结构体:

typeFibonacciHeapstruct{
min*Node
countint
}

然后,你可以实现FIB-HEAP-EXTRACT-MIN操作:

func(h*FibonacciHeap)extractMin()*Node{
z:=h.min
ifz!=nil{
//将z的子节点添加到根列表中
ifz.child!=nil{
child:=z.child
fori:=0;itemp:=child.right
//移除子节点
child.left.right=child.right
child.right.left=child.left
//将子节点添加到根列表
child.left=h.min
child.right=h.min.right
h.min.right=child
child.right.left=child
//更新子节点的父指针
child.parent=nil
child=temp
}
}
//从根列表中移除z
z.left.right=z.right
z.right.left=z.left
ifz==z.right{
h.min=nil
}else{
h.min=z.right
h.consolidate()
}
h.count--
}
returnz
}

这只是一个简单的示例,你还需要实现其他斐波那契堆操作(例如插入、合并等),以及相应的测试代码来构建和使用斐波那契堆。希望这可以帮助到你开始使用Go语言编写斐波那契堆。

chatgpt:

很抱歉,作为纯文本AI助手,我无法直接提供图片。关于斐波那契堆的图示和相关代码,您可以在学习资料、教科书或网络上进行查找。以下是一个用Go语言实现斐波那契堆的例子:

packagemain
import(
"fmt"
)
//斐波那契堆节点结构
typeFibHeapNodestruct{
keyint//键值
children[]*FibHeapNode//孩子节点列表
parent*FibHeapNode//父节点
markedbool//是否被剪切过标记
}
//斐波那契堆结构
typeFibHeapstruct{
min*FibHeapNode//最小节点指针
numint//堆中节点数量
maxRankint//堆中最大度数(根节点的度数)
}
//创建一个空的斐波那契堆
funcNewFibHeap()*FibHeap{
return&FibHeap{}
}
//插入一个新键值到斐波那契堆中
func(h*FibHeap)Insert(keyint){
node:=&FibHeapNode{
key:key,
children:nil,
parent:nil,
marked:false,
}
ifh.min==nil{//如果堆为空,则直接将新节点设为最小节点,并成为孤立根节点
h.min=node
node.parent=node
node.children=make([]*FibHeapNode,0)
}else{
h.mergeTrees(node)//合并两个根链表
ifkeyh.min=node//更新最小节点指针
}
}
h.num++//节点数量加一
}
//合并两个斐波那契堆的根链表
func(h*FibHeap)mergeTrees(newNode*FibHeapNode){
rootList:=h.min.children//原有的根链表
ifrootList==nil{//如果原有的根链表为空,直接将新节点添加为唯一元素
newNode.parent=newNode
newNode.children=make([]*FibHeapNode,0)
}else{//将新节点添加到根链表中,并调整父子关系和度数
rootList=append(rootList,newNode)
newNode.parent=newNode
ifnewNode.keyh.min=newNode//更新最小节点指针
}
}
h.maxRank++
}
//提取斐波那契堆中的最小键值节点,并重新调整堆结构保持性质不变
func(h*FibHeap)ExtractMin()(*FibHeapNode,error){
min:=h.min
ifmin==nil{
returnnil,fmt.Errorf("Theheapisempty")
}
for_,child:=rangemin.children{//将最小节点的孩子们成为孤立根节点,并更新其父指针为自己
child.parent=child
}
rootList:=append(h.min.children,h.min)//将最小节点和其孩子们组成新的根链表
iflen(rootList)==1{//如果只有一个根节点,直接更新最小节点指针为该唯一节点,并清空根链表
h.min=rootList[0]
}else{
h.consolidate(rootList)//合并根链表中度数相同的树,并更新最小节点指针
}
h

kimi:

斐波那契堆(Fibonacci Heap)是一种用于实现优先队列的数据结构,它由Michael L. Fredman和Robert E. Tarjan在1984年提出。斐波那契堆在最坏情况下的平摊时间复杂度为O(1),这使得它在某些应用中非常有用,如Dijkstra算法或某些图算法。

在斐波那契堆中,操作会移除并返回具有最小键值的节点。这个操作可能涉及以下步骤:

FIB-HEAP-EXTRACT-MIN

  1. 1.移除最小节点。
  2. 2.将最小节点的子树添加到根节点列表中。
  3. 3.执行堆的合并过程,以合并具有相同度数的根节点。

由于图19-4(m)没有直接提供在这里,我将无法准确地描述执行操作后得到的斐波那契堆的具体结构。然而,我可以提供一个Go语言的示例代码,用于实现斐波那契堆的操作:

FIB-HEAP-EXTRACT-MIN

FIB-HEAP-EXTRACT-MIN

packagemain
import(
"fmt"
)
typeFibHeapNodestruct{
keyint
degreeint
markbool
parent*FibHeapNode
child*FibHeapNode
left*FibHeapNode
right*FibHeapNode
}
typeFibHeapstruct{
min*FibHeapNode
roots[]*FibHeapNode
sizeint
}
funcNewFibHeap()*FibHeap{
return&FibHeap{
min:nil,
roots:make([]*FibHeapNode,0),
size:0,
}
}
func(h*FibHeap)ExtractMin()*FibHeapNode{
ifh.min==nil{
returnnil
}
min:=h.min
h.removeNode(h.min)
//将最小节点的子树添加到根节点列表中
formin.child!=nil{
temp:=min.child
min.child=temp.right
temp.parent=nil
h.roots=append(h.roots,temp)
temp.left=temp
temp.right=temp
}
h.consolidate()
h.size--
returnmin
}
func(h*FibHeap)removeNode(node*FibHeapNode){
ifnode==nil{
return
}
ifnode==h.min{
h.min=node.right
ifnode==node.right{
h.min=nil
}else{
forh.min.parent!=nil{
h.min=h.min.right
}
}
}
ifnode.parent!=nil{
h.removeChild(node.parent,node)
node.parent=nil
}
ifnode.left!=nil{
node.left.right=node.right
}
ifnode.right!=nil{
node.right.left=node.left
}
}
func(h*FibHeap)removeChild(parent*FibHeapNode,node*FibHeapNode){
ifparent.child==node{
parent.child=node.right
}
node.left.right=node.right
node.right.left=node.left
}
func(h*FibHeap)consolidate(){
//合并具有相同度数的根节点
//这里省略了具体的合并逻辑
}
funcmain(){
h:=NewFibHeap()
//假设h已经被构建并包含了一些节点
minNode:=h.ExtractMin()
ifminNode!=nil{
fmt.Printf("Extractedminnodewithkey:%d\n",minNode.key)
}else{
fmt.Println("Heapisempty")
}
}

在这个Go语言程序中,我们定义了结构体来表示斐波那契堆中的节点,并提供了结构和方法来实现斐波那契堆的最小值提取操作。方法用于从根节点列表中移除节点,方法用于从父节点的子树中移除节点。

FibHeapNode

FibHeap

ExtractMin

removeNode

removeChild

请注意,这个程序是一个简化的示例,它没有实现方法中的具体合并逻辑,也没有包括节点插入和度更新的逻辑。在实际应用中,斐波那契堆的实现会更加复杂。

consolidate

混元:

在这个问题中,我们需要执行 FIB-HEAP-EXTRACT-MIN 操作来从给定的斐波那契堆中提取最小元素。首先,我们需要了解斐波那契堆的数据结构和操作。

斐波那契堆是一种优先队列数据结构,它的每个节点都有一个关键字值。斐波那契堆的主要操作包括插入、合并、查找最小元素和提取最小元素。

以下是用 Go 语言实现 FIB-HEAP-EXTRACT-MIN 操作的代码:

packagemain
import(
"fmt"
"math"
)
typeFibonacciHeapNodestruct{
Keyint
Degreeint
Parent*FibonacciHeapNode
Child*FibonacciHeapNode
Left*FibonacciHeapNode
Right*FibonacciHeapNode
Markbool
}
typeFibonacciHeapstruct{
Min*FibonacciHeapNode
Numint
}
funcNewFibonacciHeap()*FibonacciHeap{
return&FibonacciHeap{nil,0}
}
func(h*FibonacciHeap)Insert(xint){
node:=&FibonacciHeapNode{x,0,nil,nil,nil,nil,false}
ifh.Min==nil{
node.Left=node
node.Right=node
h.Min=node
}else{
node.Left=h.Min
node.Right=h.Min.Right
h.Min.Right=node
node.Right.Left=node
ifxh.Min=node
}
}
h.Num++
}
func(h*FibonacciHeap)ExtractMin()int{
min:=h.Min
ifmin!=nil{
ifmin.Child!=nil{
child:=min.Child
for{
next:=child.Right
child.Left.Right=child.Right
child.Right.Left=child.Left
child.Left=h.Min
child.Right=h.Min.Right
h.Min.Right=child
child.Right.Left=child
child.Parent=nil
ifnext==min.Child{
break
}
child=next
}
}
min.Left.Right=min.Right
min.Right.Left=min.Left
ifmin==min.Right{
h.Min=nil
}else{
h.Min=min.Right
h.Consolidate()
}
h.Num--
}
returnmin.Key
}
func(h*FibonacciHeap)Consolidate(){
A:=make([]*FibonacciHeapNode,h.Num)
w:=h.Min
for{
x:=w
d:=x.Degree
forA[d]!=nil{
y:=A[d]
ifx.Key>y.Key{
x,y=y,x
}
h.Link(y,x)
A[d]=nil
d++
}
A[d]=x
ifw==w.Right{
break
}
w=w.Right
}
h.Min=nil
for_,n:=rangeA{
ifn!=nil{
ifh.Min==nil{
n.Left=n
n.Right=n
h.Min=n
}else{
n.Left=h.Min
n.Right=h.Min.Right
h.Min.Right=n
n.Right.Left=n
ifn.Keyh.Min=n
}
}
}
}
}
func(h*FibonacciHeap)Link(y,x*FibonacciHeapNode){
y.Left.Right=y.Right
y.Right.Left=y.Left
y.Parent=x
ifx.Child==nil{
x.Child=y
y.Right=y
y.Left=y
}else{
y.Left=x.Child
y.Right=x.Child.Right
x.Child.Right=y
y.Right.Left=y
}
x.Degree++
y.Mark=false
}
funcmain(){
h:=NewFibonacciHeap()
h.Insert(10)
h.Insert(2)
h.Insert(5)
h.Insert(1)
h.Insert(12)
h.Insert(7)
h.Insert(15)
h.Insert(3)
h.Insert(4)
h.Insert(11)
h.Insert(8)
h.Insert(6)
h.Insert(14)
h.Insert(9)
fmt.Println("Beforeextractmin:")
forw:=h.Min;;w=w.Right{
fmt.Printf("%d",w.Key)
ifw==w.Right{
break
}
}
fmt.Println()
min:=h.ExtractMin()
fmt.Printf("Min:%d\n",min)
fmt.Println("Afterextractmin:")
forw:=h.Min;;w=w.Right{
fmt.Printf("%d",w.Key)
ifw==w.Right{
break
}
}
fmt.Println()
}

在这个代码中,我们首先创建了一个新的斐波那契堆,并插入了一些元素。然后我们调用方法来提取最小元素。最后,我们打印出提取最小元素前后的斐波那契堆。

ExtractMin

请注意,这个代码示例仅用于演示目的。在实际应用中,您可能需要根据您的需求对代码进行调整。















声明:内容由AI生成

特别声明:以上内容(如有图片或视频亦包括在内)为自媒体平台“网易号”用户上传并发布,本平台仅提供信息存储服务。

Notice: The content above (including the pictures and videos if any) is uploaded and posted by a user of NetEase Hao, which is a social media platform and only provides information storage services.

相关推荐
热点推荐
60岁落马的女干部被“双开”!曾与“老虎”共事

60岁落马的女干部被“双开”!曾与“老虎”共事

上观新闻
2024-06-20 12:02:22
前行政长官林郑月娥,退休后因被制裁,沦落到只能在香港租房住?

前行政长官林郑月娥,退休后因被制裁,沦落到只能在香港租房住?

史二了
2024-06-18 14:01:44
她认怂了!内部人士透露其权力之大,一细节致工作能力被怀疑

她认怂了!内部人士透露其权力之大,一细节致工作能力被怀疑

温柔看世界
2024-06-19 23:58:29
凌晨3点,商贩与执法城管起争执,西瓜被砸碎一地!当地回应

凌晨3点,商贩与执法城管起争执,西瓜被砸碎一地!当地回应

鲁中晨报
2024-06-20 08:39:07
鼓励农民投资A股致富 这个建议够损的!

鼓励农民投资A股致富 这个建议够损的!

皮海洲
2024-06-20 06:30:02
还是斧头好用,一砸一个洞,菲律宾补给船全军覆没

还是斧头好用,一砸一个洞,菲律宾补给船全军覆没

三叔的装备空间
2024-06-20 11:05:19
中央音乐学院教授被爆性侵多名未成年女生,长期嫖娼,搞婚外情

中央音乐学院教授被爆性侵多名未成年女生,长期嫖娼,搞婚外情

180°视角
2024-06-20 13:54:37
余琦道歉后被罚款,仕途可能就此终结,知情人:她其实有点冤!

余琦道歉后被罚款,仕途可能就此终结,知情人:她其实有点冤!

小鹿姐姐情感说
2024-06-20 10:48:02
男子误机花6000从天津打车到西安:出租车司机路上一直问,“兄弟你确定?”

男子误机花6000从天津打车到西安:出租车司机路上一直问,“兄弟你确定?”

天津族
2024-06-20 07:39:06
带枪却没敢开火,被海警缴枪的菲特种兵,为何连肢体反抗都不敢?

带枪却没敢开火,被海警缴枪的菲特种兵,为何连肢体反抗都不敢?

看度时政观望
2024-06-19 16:39:43
深度 | 欧盟挥舞关税大棒,德经济部长将访华,能否找到“友好”解决方案?

深度 | 欧盟挥舞关税大棒,德经济部长将访华,能否找到“友好”解决方案?

上观新闻
2024-06-19 20:45:10
离谱!复旦大学毕业生打老师后续:本人直言打错人了,已申请退学

离谱!复旦大学毕业生打老师后续:本人直言打错人了,已申请退学

180°视角
2024-06-20 11:52:52
陈晓未回应离婚传言,葛斯齐揭内幕:陈妍希常年一个人回台湾

陈晓未回应离婚传言,葛斯齐揭内幕:陈妍希常年一个人回台湾

山野下
2024-06-20 11:19:08
余琦被立案调查!老公身份被扒,狗受牵连,前同事曝光其真实人品

余琦被立案调查!老公身份被扒,狗受牵连,前同事曝光其真实人品

六毛朵朵
2024-06-19 12:51:46
郑州,男子花45万买了法拍房,换吊灯时,天花板掉出9900万现金!

郑州,男子花45万买了法拍房,换吊灯时,天花板掉出9900万现金!

趣说世界哈
2024-06-20 11:16:25
多地微小企业陷入补税风波,老板们叫苦连天:几乎没有了生存空间

多地微小企业陷入补税风波,老板们叫苦连天:几乎没有了生存空间

西游日记
2024-06-19 14:37:33
谭咏麟病愈后首次公开现身,瘦到青筋毕现感慨声线不好

谭咏麟病愈后首次公开现身,瘦到青筋毕现感慨声线不好

小萝卜天下事
2023-07-21 21:57:53
毕业典礼扇老师耳光!身份被扒:家中人脉深厚,黑历史一箩筐

毕业典礼扇老师耳光!身份被扒:家中人脉深厚,黑历史一箩筐

温柔看世界
2024-06-20 11:38:19
余琦认怂了,平安北京通报了她的罪过,但我们忽视车上另一个男人

余琦认怂了,平安北京通报了她的罪过,但我们忽视车上另一个男人

辣条小剧场
2024-06-20 06:12:50
抗日神剧八路军的伙食,不是海鲜就是法国菜,主打的就是一个上流

抗日神剧八路军的伙食,不是海鲜就是法国菜,主打的就是一个上流

附允历史观
2024-06-19 16:45:10
2024-06-20 14:44:49
moonfdd
moonfdd
福大大架构师每日一题
427文章数 7关注度
往期回顾 全部

科技要闻

小米SU7流量泼天,富贵却被蔚来接住了

头条要闻

深圳网红学位房每平从14万跌到4万 中介:每月都有成交

头条要闻

深圳网红学位房每平从14万跌到4万 中介:每月都有成交

体育要闻

绿军的真老大,开始备战下赛季了

娱乐要闻

叶舒华参加柯震东生日聚会,五毒俱全

财经要闻

日本银行巨头突然爆雷!

汽车要闻

售价11.79-14.39万元 新一代哈弗H6正式上市

态度原创

旅游
健康
教育
公开课
军事航空

旅游要闻

铁路儿童票新规 已有超4900万小旅客免费出行

晚餐不吃or吃七分饱,哪种更减肥?

教育要闻

三人连环画共60本,甲给乙3本,乙给丙5本后,三人一样多,原来各

公开课

近视只是视力差?小心并发症

军事要闻

普京再送金正恩轿车 两人轮流当司机

无障碍浏览 进入关怀版