精华内容
下载资源
问答
  • DFS生成森林代码

    2020-12-16 15:18:02
    DFS生成森林代码 typedef char TElemType; typedef struct CSNode{ TElemType data; CSNode *firstChild, *nextSibling; }CSNode,*CSTree; void DFSForest(Graph G,CSTree &T) { T = NULL; //生成森林的...

    DFS生成森林代码

    
    typedef char TElemType;
    
    typedef struct CSNode{
    	TElemType data;
    	CSNode *firstChild, *nextSibling;
    }CSNode,*CSTree; 
    
    void DFSForest(Graph G,CSTree &T)
    {
    	T = NULL; //生成森林的根 
    	bool visited[MAXSIZE]; //标记 
    	for(int i = 0; i < G.vexnum; i++)
    		visited[i] = false;
    	CSNode pre; //保存前一个兄弟 
    	for(int v = 0; v < G.vexnum; v++)
    	{
    		if(!visited[v])
    		{
    			CSNode* p = (CSNode*)malloc(sizeof(CSNode)); //创建结点 
    			*p = {getValue(G,v), NULL, NULL}; //赋值 
    			if(!T) T = p;   //v是生成森林的第一棵子树 
    			else pre->nextSibling = p;  //后一棵树做前棵的兄弟 
    			pre = p;  //第一次后赋值 
    			DFSTree(G, v, p);  //以p为根创建其子树 
    		}
    	} 
    }
    
    void DFSTree(Graph G, int v, CSTree &T)
    {
    	visited[v] = true;
    	bool first = true; //标记是否第一个兄弟 
    	CSNode *pre;
    	for(int w = FirstNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w))
    	{
    		if(!visited[w])
    		{
    			CSNode *p = (CSNode*)malloc(sizeof(CSNode));
    			*p = {getValue(G,w), NULL, NULL};
    			if(first)
    			{
    				T->firstChild = p; first = false; 
    			}
    			else pre->nextSibling = p;
    			pre = p;
    			DFSTree(G,w,p);
    		}
    	}
    } 
    
    展开全文
  • 生成树和生成森林

    千次阅读 2017-10-20 13:44:49
    1、无向图的生成树和生成森林 对于无向连通图,在图的深度优先遍历或广度优先遍历过程中经历的边的集合和 图中的所有顶点一起构成图的极小连通子图,就是一颗生成树(深度优先生成树、广度优先生成树)。 对非连通无...

    1、无向图的生成树和生成森林

    对于无向连通图,在图的深度优先遍历广度优先搜索遍历过程中经历的边的集合和 图中的所有顶点一起构成图的极小连通子图,就是一颗生成树(深度优先生成树、广度优先生成树)。

    对非连通无向图,深度优先搜索遍历或广度优先搜索遍历,每个连通分量中的顶点集合遍历时走过的边一起构成若干颗生成树,这些连通分量的生成树组成非连通图的生成森林(深度优先生成森林、广度优先生成森林)。

    深度优先搜索中的图7-25和图7-26的DFS生成树、BFS生成树、生成森林如下:

    DFS生成树:


    BFS生成树、BFS生成森林:


    2、有向图的生成树和生成森林

    对强连通有向图,用DFS和BFS算法可分别求得DFS和BFS生成树。对非强连通图,则一般只能得到生成森林。

    无向图或有向图的生成树或生成森林不唯一(选出发点不唯一)。


    展开全文
  • [图] 无向图的连通分量和生成树-DFS

    千次阅读 2018-08-14 10:58:28
    DFS生成森林 生成【非连通图】的【深度优先生成森林】 【存储方式】孩子兄弟链表 // 建立无向图G的深度优先生成森林的 (最左)孩子(右)兄弟链表T void DFSForest(Graph G, CSTree &amp;amp;amp...

    DFS生成森林

    生成【非连通图】的【深度优先生成森林】

    【存储方式】孩子兄弟链表

    typedef struct CSNode{
    	TElemType data;
    	struct CSNode *firstchild, *nextsibling;
    }CSNode, *CSTree;
    
    
    // 建立无向图G的深度优先生成森林的 (最左)孩子(右)兄弟链表T
    void DFSForest(Graph G, CSTree &T) {
    	T = NULL;
    	for (v=0; v<G.vexnum; ++v) {
    		visited[v] = FALSE;
    	}
    	for (v=0; v<G.vexnum; ++v) {
    		if (!visited[v]) { //第v顶点为新的生成树的根结点
    			p = (CSTree)malloc(sizeof(CSNode) ); //分配根结点
    			*p = {GetVex(G,v), NULL, NULL}; //给该结点赋值
    			if (!T) T=p; //是第一棵生成树的根(T的根)
    			else q->nextsibling = p; //是其他生成树的根(前一棵的根的"兄弟")
    			q = p; //q指示当前生成树的根
    			DFSTree(G, v, p); //建立以P为根的生成树
    		}
    	}
    }
    
    // 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树
    void DFSTree(Graph G, int v, CSTree &T) {
    	visited[v] = True;
    	first = True;
    	for (w=FirstAdjvex(G, v); w>=0; w=NextAdjvex(G, v, w)) {
    		if (!visited[w]) {
    			p = (CSTree)malloc(sizeof(CSNode)); //分配孩子结点
    			*p = {GetVex(G, w), NULL, NULL};
    			if (first) { //w是v的第一个未访问的邻接顶点
    				T->lchild = p; //是根的左孩子结点
    				first = False;
    			} else { //w是v的其他未被访问的邻接顶点
    				q->nextsibling = p; //是上一邻接顶点的右兄弟结点
    			}
    			q = p;
    			DFSTree(G, w, q);  //从第w个顶点出发深度优先遍历图G,建立子生成树q
    		}
    	}
    }
    
    展开全文
  • void DFS(ALGraph G, int i) { ArcNode *p; VisitTag[i] = true; VisitVex(G.VLnode[i]); p = G.VLnode[i].pFirstArc; while (p) { if (!VisitTag[p->adjvex]) DFS(G, p->adjvex); p = p->pNextArc; } } ...

    
    #include<iostream>
    using namespace std;
    #define MAXVEX 100
    typedef char VType;
    typedef struct ArcNode
    {
     int adjvex;
     ArcNode *pNextArc;
    }ArcNode;
    
    typedef struct VexNode
    {
     VType data;
     ArcNode *pFirstArc;
    }VexNode;
    
    typedef struct
    {
     VexNode VLnode[MAXVEX];
     int Vnums;
     int Anums;
    }ALGraph;
    
    void CreateGraph(ALGraph &G)
    {
     int i, j, k;
     ArcNode *pA;
     cin >> G.Vnums >> G.Anums;
     for (i = 0; i < G.Vnums; ++i)
     {
      cin >> G.VLnode[i].data;
      G.VLnode[i].pFirstArc = NULL;
     }
     for (k = 0; k < G.Anums; ++k)
     {
      cin >> i >> j;
      pA = new ArcNode;
      pA->adjvex = i;
      pA->pNextArc = G.VLnode[j].pFirstArc;
      G.VLnode[j].pFirstArc = pA;
      pA = new ArcNode;
      pA->adjvex = j;
      pA->pNextArc = G.VLnode[i].pFirstArc;
      G.VLnode[i].pFirstArc = pA;
     }
    }
    
    void DestroyGraph(ALGraph &G)
    {
     int i;
     ArcNode *p, *q;
     for (i = 0; i < G.Vnums; ++i)
     {
      p = G.VLnode[i].pFirstArc;
      while (p)
      {
       q = p->pNextArc;
       delete p;
       p = q;
      }
     }
     G.Anums = 0;
    }
    
    int LocateVex(ALGraph G, VexNode v)
    {
     int i;
     for (i = 0; i < G.Vnums; ++i)
      if (G.VLnode[i].data = v.data)
       return i;
     return -1;
    }
    
    VType GetVex(ALGraph G, int i)
    {
     if (i >= G.Vnums || i < 0)
      exit(-1);
     return G.VLnode[i].data;
    }
    
    bool PutVex(ALGraph &G, int i, VType value)
    {
     i = LocateVex(G, G.VLnode[i]);
     if (i > -1)
     {
      G.VLnode[i].data = value;
      return true;
     }
     else
      return false;
    }
    
    int FirstAdjVex(ALGraph G, VexNode v)
    {
     int i;
     ArcNode *pA;
     i = LocateVex(G, v);
     pA = G.VLnode[i].pFirstArc;
     if (pA)
      return pA->adjvex;
     else
      return -1;
    }
    
    int NextAdjVex(ALGraph G, VexNode v, VexNode w)
    {
     int i, j;
     ArcNode *pA;
     i = LocateVex(G, v);
     j = LocateVex(G, w);
     pA = G.VLnode[i].pFirstArc;
     while (pA&&pA->adjvex != j)
      pA = pA->pNextArc;
     if (!pA || !(pA->pNextArc))
      return -1;
     else
     {
      pA = pA->pNextArc;
      return pA->adjvex;
     }
    
    }
    
    void InsertVex(ALGraph &G, VexNode v)
    {
     G.VLnode[G.Vnums].data = v.data;
     G.VLnode[G.Vnums].pFirstArc = NULL;
     G.Vnums++;
    }
    
    bool DeleteVex(ALGraph &G, VexNode v)
    {
     int i, j;
     ArcNode *p, *q = NULL;
     j = LocateVex(G, v);
     if (j < 0)
      return false;
     p = G.VLnode[j].pFirstArc;
     while (p)
     {
      q = p;
      p = p->pNextArc;
      delete q;
      G.Anums--;
     }
     G.Vnums--;
     for (i = j; i < G.Vnums; ++i)
     {
      G.VLnode[i] = G.VLnode[i + 1];
     }
     for (i = 0; i < G.Vnums; ++i)
     {
      p = G.VLnode[i].pFirstArc;
      while (p)
      {
       if (p->adjvex == j)
       {
        if (p == G.VLnode[i].pFirstArc)
        {
         G.VLnode[i].pFirstArc = p->pNextArc;
         delete p;
        }
        else
        {
         q->pNextArc = p->pNextArc;
         delete p;
         p = q->pNextArc;
        }
       }
       else
       {
        if (p->adjvex>j)
         p->adjvex--;
        q = p;
        p = p->pNextArc;
       }
      }
     }
     return true;
    }
    
    bool InsertArc(ALGraph &G, VexNode v, VexNode w)
    {
     ArcNode *pA;
     int i, j;
     i = LocateVex(G, v);
     j = LocateVex(G, w);
     if (i < 0 || j < 0)
      return false;
     G.Anums++;
     pA = new ArcNode;
     pA->adjvex = i;
     pA->pNextArc = G.VLnode[j].pFirstArc;
     G.VLnode[j].pFirstArc = pA;
     pA = new ArcNode;
     pA->adjvex = j;
     pA->pNextArc = G.VLnode[i].pFirstArc;
     G.VLnode[i].pFirstArc = pA;
     return true;
    }
    
    bool DeleteArc(ALGraph &G, VexNode v, VexNode w)
    {
     ArcNode *p, *q = NULL;
     int i, j;
     i = LocateVex(G, v);
     j = LocateVex(G, w);
     p = G.VLnode[i].pFirstArc;
     while (p&&p->adjvex != j)
     {
      q = p;
      p = p->pNextArc;
     }
     if (p&&p->adjvex == j)
     {
      if (p == G.VLnode[i].pFirstArc)
       G.VLnode[i].pFirstArc = p->pNextArc;
      else
       q->pNextArc = p->pNextArc;
      delete p;
     }
     p = G.VLnode[j].pFirstArc;
     while (p&&p->adjvex != i)
     {
      q = p;
      p = p->pNextArc;
     }
     if (p&&p->adjvex == i)
     {
      if (p == G.VLnode[j].pFirstArc)
       G.VLnode[j].pFirstArc = p->pNextArc;
      else
       q->pNextArc = p->pNextArc;
      delete p;
      G.Anums--;
     }
     return true;
    }
    
    void VisitVex(VexNode v)
    {
     cout << v.data << " ";
    }
    
    void VisitArc(VexNode v, VexNode w)
    {
     cout << "(" << v.data << "->" << w.data << ")" << " ";
    }
    
    void PrintGraph(ALGraph G)
    {
     int i;
     ArcNode *p;
     for (i = 0; i < G.Vnums; ++i)
      VisitVex(G.VLnode[i]);
     cout << endl;
     for (i = 0; i < G.Vnums; ++i)
     {
      p = G.VLnode[i].pFirstArc;
      while (p)
      {
       VisitArc(G.VLnode[i], G.VLnode[p->adjvex]);
       p = p->pNextArc;
      }
     }
     cout << endl;
    }
    
    bool VisitTag[MAXVEX];
    
    void DFS(ALGraph G, int i)
    {
     ArcNode *p;
     VisitTag[i] = true;
     VisitVex(G.VLnode[i]);
     p = G.VLnode[i].pFirstArc;
     while (p)
     {
      if (!VisitTag[p->adjvex])
       DFS(G, p->adjvex);
      p = p->pNextArc;
     }
    }
    
    void DFSEqual(ALGraph G, int i)
    {
     int j;
     VisitTag[i] = true;
     VisitVex(G.VLnode[i]);
     for (j = FirstAdjVex(G, G.VLnode[i]); j >= 0; j = NextAdjVex(G, G.VLnode[i], G.VLnode[j]))
      if (!VisitTag[j])
       DFSEqual(G, j);
    }
    
    void DFST(ALGraph G)
    {
     int i;
     for (i = 0; i < G.Vnums; ++i)
      VisitTag[i] = false;
     for (i = 0; i < G.Vnums; ++i)
      if (!VisitTag[i])
       DFSEqual(G, i);//or DFSEqual(G,i);
     cout << endl;
    }
    
    /*******************************************/
    #define QSIZE MAXVEX
    
    typedef struct Queue
    {
     int *pBase;
     int Front;
     int Rear;
    }Queue;
    
    void InitQueue(Queue &Q)
    {
     Q.pBase = new int[QSIZE];
     Q.Front = 0;
     Q.Rear = 0;
    }
    
    bool QueueFull(Queue Q)
    {
     if ((Q.Rear + 1) % QSIZE == Q.Front)
      return true;
     else
      return false;
    }
    
    bool QueueEmpty(Queue Q)
    {
     if (Q.Rear == Q.Front)
      return true;
     else
      return false;
    }
    
    void EnQueue(Queue &Q, int i)
    {
     if (QueueFull(Q))
      return;
     Q.pBase[Q.Rear] = i;
     Q.Rear = (Q.Rear + 1) % QSIZE;
    }
    
    void DeQueue(Queue &Q, int &i)
    {
     if (QueueEmpty(Q))
      return;
     i = Q.pBase[Q.Front];
     Q.Front = (Q.Front + 1) % QSIZE;
    }
    
    void BFST(ALGraph G)
    {
     Queue Q;
     int i, j;
     InitQueue(Q);
     for (i = 0; i < G.Vnums; ++i)
      VisitTag[i] = false;
     for (i = 0; i < G.Vnums; ++i)
     {
      if (!VisitTag[i])
      {
       VisitTag[i] = true;
       VisitVex(G.VLnode[i]);
       EnQueue(Q, i);
       while (!QueueEmpty(Q))
       {
        DeQueue(Q, i);
        for (j = FirstAdjVex(G, G.VLnode[i]); j != -1; j = NextAdjVex(G, G.VLnode[i], G.VLnode[j]))
        {
         if (!VisitTag[j])
         {
          VisitTag[j] = true;
          VisitVex(G.VLnode[j]);
          EnQueue(Q, j);
         }
        }
       }
      }
     }
     cout << endl;
    }//测试有错误
    
    void BFST1(ALGraph G)
    {
     Queue Q;
     int i;
     ArcNode *p;
     InitQueue(Q);
     for (i = 0; i < G.Vnums; ++i)
      VisitTag[i] = false;
     for (i = 0; i < G.Vnums; ++i)
     {
      if (!VisitTag[i])
      {
       VisitTag[i] = true;
       VisitVex(G.VLnode[i]);
       EnQueue(Q, i);
       while (!QueueEmpty(Q))
       {
        DeQueue(Q, i);
        p = G.VLnode[i].pFirstArc;
        while (p)
        {
         if (!VisitTag[p->adjvex])
         {
          VisitTag[p->adjvex] = true;
          VisitVex(G.VLnode[p->adjvex]);
         }
         p = p->pNextArc;
        }
       }
      }
     }
     cout << endl;
    }
    
    /*******************************************/
    typedef VType ElemType;
    
    typedef struct CSNode
    {
     ElemType data;
     CSNode *pFchild;
     CSNode *pNsibling;
    }CSNode, *CSTree;
    
    void DFSTree(ALGraph G, int i, CSTree &T)
    {//从第i+1个顶点出发深度优先遍历图G,建立以T为根
    //的生成树.
     bool first = true;
     int j;
     CSTree p, q=NULL;
     VisitTag[i] = true; 
     for (j = FirstAdjVex(G, G.VLnode[i]); j != -1; j = NextAdjVex(G, G.VLnode[i], G.VLnode[j]))
     {
      if (!VisitTag[j])
      {
       p = new CSNode;
       p->data = GetVex(G,j);
       p->pFchild = NULL;
       p->pNsibling = NULL;
       if (first)
       {//根的第一个孩子
        T->pFchild = p;
        first = false;
       }
       else   
        q->pNsibling = p; 
       q = p;
       DFSTree(G, j, q);
      }
     }
    }
    
    void DFSForest(ALGraph G, CSTree &T)
    {//如果为连通图的话,则只建立一棵生成树
    //如果为非连通图的话,则建立二叉树式的生成森林
    //如果为树,则T指向该树的根结点;如果为森林,则T
    //指向第一棵树的根结点
     CSTree p;
     CSTree q = NULL;//如果为连通图的话,不需要
     int i;
     T = NULL;
     for (i = 0; i < G.Vnums; ++i)
      VisitTag[i] = false;
     for (i = 0; i < G.Vnums; ++i)
     {//一次循环对应一棵生成.如果原先的为连通图,那么
      //只进行一次循环,只生成一棵生成树.
      if (!VisitTag[i])
      {//如果是连通图的话,那么无需if,直接执行下面语句
       p = new CSNode;
       p->data = GetVex(G, i);
       p->pFchild = NULL;
       p->pNsibling = NULL;
       if (!T)//第一棵生成树的根  
        T = p;
       else//是其他生成树的根,当然势必有大于1棵树,势必为非连通图
        q->pNsibling = p;
       q = p;//q指示当前生成树的根,如果为连通图的话,则不需要该句
       DFSTree(G, i, p);//建立以p为根的生成树
      }
     }
    }
    
    void Visit(CSTree T)
    {
     cout << T->data << " ";
    }
    
    void PreOrder(CSTree T)
    {//树先根遍历(森林先序遍历)
     if (T)
     {
      Visit(T);
      PreOrder(T->pFchild);
      PreOrder(T->pNsibling);
     }
    }
    
    int main(void)
    {
     ALGraph G;
     CSTree T;
     CreateGraph(G);
     DFST(G);//深度优先遍历图
     DFSForest(G, T);//深度优先搜索创建二叉生成森林
     PreOrder(T);//先根遍历二叉生成森林
     return(0);
    }
    
    
    
    
    
    
    
    

    展开全文
  • 图-生成树和生成森林算法C语言

    千次阅读 2016-12-13 10:00:35
    对于用邻接表储存有向图或无向图,基于深度优先遍历算法生成树和生成森林,储存在孩子兄弟链表中: #include #include #include   #define MAXVERTEXNUM 100   typedef char VertexType; typedef int ...
  • DFS \BFS生成

    2009-06-28 15:25:10
    使用邻接表结构,进行广度优先搜索、深度优先搜索并生成树或生成森林,并打印树的边
  • //以孩子兄弟链表作为生成森林的存储结构,以下算法生成非连通图的深度优先生成森林。 //算法的时间复杂度为遍历算法相同. #include <stdio.h> #include <stdlib.h> #define MAX 20 typedef...
  • 深度优先生成森林 对于无向非连通图, 对其每一个连通分量的DFS搜索, 所经过V点集和E边集合,就会构成一个生成树。 所有生成树就会组成一个生成森林, 这个森林就叫深度优先生成森林。 代码: 改代码 是 通过深度...
  • 图之深度优先生成森林

    千次阅读 2017-01-04 21:36:05
    无向图的深度优先生成森林算法Java实现
  • 无向图生成森林

    2016-09-05 20:50:32
    无向图的深度优先森林(孩子兄弟链表表示)
  • 无向图的生成树和生成森林算法

    千次阅读 2011-12-14 13:26:20
    对图的深度优先搜索遍历DFS(或BFS)算法稍作修改,就可得到构造图的DFS生成树算法。 在算法中,树的存储结构采用孩子—兄弟表示法。首先建立从某个顶点V出发,建立一个树结点,然后再分别以V的邻接点为起始点,建立...
  • 有向图DFS森林

    2012-02-23 18:59:00
    在收尾的时候把两棵树的显示分开了,更有“森林”的感觉。 但是美中不足的每棵树的最后一个节点还是有“->",虽然我已经模仿Yan版教材加上了begin&end,稍微看着不那么突兀。 本想写个判断把最后那个箭头删...
  • 1、求图的生成树(或生成森林)  生成树:是一个极小连通子图,它含有图中全部n个顶点,但只有n-1条边。  生成森林: 由若干棵生成树组成,含全部顶点,但构成这些树的边是最少的。  深度优先搜索生成树: 由...
  • 连通图可通过遍历构造生成树,非连通图的每个连通分量可构造一棵生成树,整个非连通图构造为生成森林。 下面程序调用算法 7.7、7.8,将无向图构造为生成森林,并以孩子—兄弟二叉链表存储之。 typedef int ...
  • 给出一个无向图,求出最小生成树 typedef pair<int,int> PII; const int N = 2e5+7; struct node{ int x,y,z; bool operator<(node &t)const{ return z < t.z; } }edge[N]; int fa[N],n,m,ans...
  • 无向图中的深度优先生成森林

    千次阅读 2015-10-14 15:50:33
    在对无向图进行遍历时,对于连通图,仅需要从图中的...对于非连通图,每个连通分量中的顶点集,和遍历时走过的边一起构成若干棵生成树,这些连通分量的生成树组成非连通图的生成森林。我们以孩子兄弟链表作为深度优先
  •  建最大生成森林,因为图不一定是联通的,所以不一定是一棵树。这个地方用克鲁斯卡尔就好了  然后给这个森林跑一遍DFS,顺便倍增  然后对于每个询问跑LCA,倍增的时候已经顺便求出了最小边权,所以往上跳的同时...
  • 传送门 题意:有 nn 座城市,编号从 ...题解:由于要装尽量多的货物,所以先用kruskal跑一个最大生成森林,然后再因为存在短板效应,所以在这些生成的树上跑倍增(可参考倍增求LCA),求出每条询问的路径上的最...
  • 扩充深度优先搜索算法,在遍历图的过程中建立生成森林的左子女-右兄弟链表。 【想法】 首先得出这个结构为一个树的结构,然后思考这个树应该用什么样的结构来存储呢? 任务里给出答案——链表,当然在图的章节里...
  • 第七章(5).非连通图的生成森林

    千次阅读 2015-04-26 17:23:43
    //对于非连通图,每个连通分量中的顶点集,和遍历时走过的边一起构成若干颗生成树,这些连通分量的生成树组成非连通图的生成森林。//在对无向图进行遍历时,对于连通图,仅从图中任一点出发,进行深度优先搜索或广度...
  • 深度优先的生成树和生成森林:与广度优先...当然,这是有条件的,即对连通图调用DFS才可以产生深度优先生成树,否则产生的将是深度优先生成森林,如下。与BFS类似,基于邻接表存储的深度优先生成树是不唯一的。 ...
  • 具有n 个顶点的无向连通图至少有n-1 条边,如果只有n-1 条边,则不会形成环,...一棵生成树,整个非连通图构造为生成森林。algo7-1.cpp 调用算法7.7、7.8,将无向图 构造为生成森林,并以孩子—兄弟二叉链表存储之。
  • 首先根据题意,我们应该对这张无向图做一遍最小生成树,判断这张图是否能生成一棵最小生成树,而不是一片森林。 这题选用的最小生成树算法是Kruskal,在做Kruskal的同时我们应该把所有边权相同的边归为一类,并统计...
  • 图的深度优先搜索算法并生成DFS

    万次阅读 2017-12-04 00:59:53
    前面一篇文章介绍了图的广度优先搜索算法和BFS树,这篇文件笔者将介绍另一种图的遍历算法-深度优先算法概述深度优先搜索(Depth-First Search,DFS)选取下一顶点的策略,可概括为:优先选取最后一个被访问到的顶点...
  • dfs(node.right, False) to_delete = set(to_delete) if not root: return [] if not to_delete: return [] if root.val in to_delete: self.ans = [] dfs(root, True) else: self.ans = [root] dfs(root, False) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,747
精华内容 1,098
关键字:

dfs生成森林