关于划分树

最新推荐文章于 2022-01-11 17:00:06 发布
最新推荐文章于 2022-01-11 17:00:06 发布
阅读量383 收藏
点赞数
分类专栏： 数据结构。 线段树。
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/natsuyu/article/details/44901003
版权

断断续续看了几天。。。。事实证明这种东西一定要时间集中一点看，不然出活很慢。。。

看的时候主要是这么几个问题：

第一，为什么这样建树

第二，为什么这样查询，区间控制的理由是什么


先科普一下基本概念：（转）

划分树的定义

         划分树定义为，它的每一个节点保存区间[lft,rht]所有元素，元素顺序与原数组（输入）相同，但是，两个子树的元素为该节点所有元素排序后(rht-lft+1)/2个进入左子树，其余的到右子树，同时维护一个num域，num[i]表示lft->i这个点有多少个进入了左子树。


划分树包括两个部分，一个是每一层存放的数（排序不同）（val），一个是在每个数之前（包括它自己）进入左子树的个数（num）。

在得到一串数列之后，对其进行sort，之后每层树的比较，都是通过与相对区间中的中位数进行比较。通过这种方式，可以得到每个数相对的排序，比如说在第i层，在左子树内，有tree[i].val[j],tree[i].val[k]，通过比较j,k的num值可以得到相对的大小关系。

定义：

constint N=1e5+5;
int sorted[N];            //对原来集合中的元素排序后的值
struct node
{
         int valu[N];       //val记录第k层当前位置元素的值
         int num[N];                //num记录元素所在区间的当前位置之前进入左孩子的个数
        
}t[20];     对于10万左右的数列是没问题的。（2^20）


建树：

</pre><pre style="font-family: 'Courier New';"><strong><span style="color:blue;">void</span></strong> create<strong><span style="color:#FF00FF;">(</span><span style="color:blue;">int</span></strong> l<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> r<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> rt<strong><span style="color:#FF00FF;">)
{</span></strong>
    num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong><span style="color:#CC3300;">0</span><strong><span style="color:#FF00FF;">]=</span></strong><span style="color:#CC3300;">0</span><strong><span style="color:#FF00FF;">;</span><span style="color:#0000FF;">
    if</span><span style="color:#FF00FF;">(</span></strong>l<strong><span style="color:#FF00FF;">==</span></strong>r<strong><span style="color:#FF00FF;">)</span><span style="color:#0000FF;"> return</span><span style="color:#FF00FF;">;</span><span style="color:blue;">
    int</span></strong> mid<strong><span style="color:#FF00FF;">=(</span></strong>l<strong><span style="color:#FF00FF;">+</span></strong>r<strong><span style="color:#FF00FF;">)>></span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">;</span><span style="color:blue;">
    int</span></strong> ll<strong><span style="color:#FF00FF;">=</span></strong>l<strong><span style="color:#FF00FF;">,</span></strong>rr<strong><span style="color:#FF00FF;">=</span></strong>mid<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">;</span><span style="color:blue;">
    int</span></strong> same<strong><span style="color:#FF00FF;">=</span></strong>mid<strong><span style="color:#FF00FF;">-</span></strong>l<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">;</span><span style="color:blue;">

    int</span></strong> i<strong><span style="color:#FF00FF;">;</span><span style="color:#0000FF;">
    for</span><span style="color:#FF00FF;">(</span></strong>i<strong><span style="color:#FF00FF;">=</span></strong>l<strong><span style="color:#FF00FF;">;</span></strong>i<strong><span style="color:#FF00FF;"><=</span></strong>r<strong><span style="color:#FF00FF;">;</span></strong>i<strong><span style="color:#FF00FF;">++)</span><span style="color:#0000FF;"> if</span><span style="color:#FF00FF;">(</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]<</span></strong>sorted<strong><span style="color:#FF00FF;">[</span></strong>mid<strong><span style="color:#FF00FF;">])</span></strong> same<strong><span style="color:#FF00FF;">--;</span><span style="color:#0000FF;">
    for</span><span style="color:#FF00FF;">(</span></strong>i<strong><span style="color:#FF00FF;">=</span></strong>l<strong><span style="color:#FF00FF;">;</span></strong>i<strong><span style="color:#FF00FF;"><=</span></strong>r<strong><span style="color:#FF00FF;">;</span></strong>i<strong><span style="color:#FF00FF;">++)
    {</span><span style="color:#0000FF;">
        if</span><span style="color:#FF00FF;">(</span></strong>i<strong><span style="color:#FF00FF;">==</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">)</span></strong> num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]=</span></strong><span style="color:#CC3300;">0</span><strong><span style="color:#FF00FF;">;</span><span style="color:#0000FF;">
        else</span></strong> num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]=</span></strong>num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">-</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">];</span><span style="color:#0000FF;">
        
        if</span><span style="color:#FF00FF;">(</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]<</span></strong>sorted<strong><span style="color:#FF00FF;">[</span></strong>mid<strong><span style="color:#FF00FF;">])
        {</span></strong>
            num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]++;</span></strong>
            val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">][</span></strong>ll<strong><span style="color:#FF00FF;">++]=</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">];
        }</span><span style="color:#0000FF;">
        else if</span><span style="color:#FF00FF;">(</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]></span></strong>sorted<strong><span style="color:#FF00FF;">[</span></strong>mid<strong><span style="color:#FF00FF;">])</span></strong> val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">][</span></strong>rr<strong><span style="color:#FF00FF;">++]=</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">];</span><span style="color:#0000FF;">
        else</span><span style="color:#FF00FF;">
        {</span><span style="color:#0000FF;">
            if</span><span style="color:#FF00FF;">(</span></strong>same<strong><span style="color:#FF00FF;">) {</span></strong>same<strong><span style="color:#FF00FF;">--;</span></strong>num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">]++;</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">][</span></strong>ll<strong><span style="color:#FF00FF;">++]=</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">];}</span><span style="color:#0000FF;">
            else</span></strong> val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">][</span></strong>rr<strong><span style="color:#FF00FF;">++]=</span></strong>val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>i<strong><span style="color:#FF00FF;">];
        }
    }</span></strong>
        create<strong><span style="color:#FF00FF;">(</span></strong>l<strong><span style="color:#FF00FF;">,</span></strong>mid<strong><span style="color:#FF00FF;">,</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">);</span></strong>
        create<strong><span style="color:#FF00FF;">(</span></strong>mid<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">,</span></strong>r<strong><span style="color:#FF00FF;">,</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">);
}</span></strong>

查询： 

<pre style="font-family: 'Courier New';"><strong><span style="color:blue;">int</span></strong> query<strong><span style="color:#FF00FF;">(</span><span style="color:blue;">int</span></strong> ll<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> rr<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> l<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> r<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> rt<strong><span style="color:#FF00FF;">,</span><span style="color:blue;">int</span></strong> k<strong><span style="color:#FF00FF;">) // ll,rr是目标区间
{</span><span style="color:#0000FF;">
    if</span><span style="color:#FF00FF;">(</span></strong>ll<strong><span style="color:#FF00FF;">==</span></strong>rr<strong><span style="color:#FF00FF;">)</span><span style="color:#0000FF;"> return</span></strong> val<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>ll<strong><span style="color:#FF00FF;">];</span><span style="color:blue;">
    int</span></strong> mid<strong><span style="color:#FF00FF;">=(</span></strong>l<strong><span style="color:#FF00FF;">+</span></strong>r<strong><span style="color:#FF00FF;">)>></span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">;</span><span style="color:blue;">
    int</span></strong> cnt<strong><span style="color:#FF00FF;">=</span></strong>num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>rr<strong><span style="color:#FF00FF;">]-</span></strong>num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>ll<strong><span style="color:#FF00FF;">-</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">];</span><span style="color:blue;">
    int</span></strong> newl<strong><span style="color:#FF00FF;">,</span></strong> newr<strong><span style="color:#FF00FF;">;</span><span style="color:#0000FF;">
    if</span><span style="color:#FF00FF;">(</span></strong>cnt<strong><span style="color:#FF00FF;">>=</span></strong>k<strong><span style="color:#FF00FF;">)
    {</span></strong>
        newl<strong><span style="color:#FF00FF;">=</span></strong>l<strong><span style="color:#FF00FF;">+</span></strong>num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>ll<strong><span style="color:#FF00FF;">-</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">]-</span></strong>num<strong><span style="color:#FF00FF;">[</span></strong>rt<strong><span style="color:#FF00FF;">][</span></strong>l<strong><span style="color:#FF00FF;">-</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">];</span></strong>
        newr<strong><span style="color:#FF00FF;">=</span></strong>newl<strong><span style="color:#FF00FF;">+</span></strong>cnt<strong><span style="color:#FF00FF;">-</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">;</span><span style="color:#0000FF;">
        return</span></strong> query<strong><span style="color:#FF00FF;">(</span></strong>newl<strong><span style="color:#FF00FF;">,</span></strong>newr<strong><span style="color:#FF00FF;">,</span></strong>l<strong><span style="color:#FF00FF;">,</span></strong>mid<strong><span style="color:#FF00FF;">,</span></strong>rt<strong><span style="color:#FF00FF;">+</span></strong><span style="color:#CC3300;">1</span><strong><span style="color:#FF00FF;">,</span></strong>k<strong><span style="color:#FF00FF;">);  </span></strong>
//好吧。。再来一遍。。不知道别人看这个的时候会不会觉得很难理解。。但是像我这样的笨蛋。。。看查询的时候着实花了些功夫。知道怎么建树后看了这块代码很久不知道问什么这样。。。。。然后就问我自己，如果我这样建树了，那么在查询的时候，我要通过什么方式来缩小我查询的空间？为什么新的查询范围是这样的？
建树的时候应该意识到，对于每一层的i,他的坐标取决于在原序列中，他前面有几个mid小（大）的数插入到他前面了。所以，如果我们要往左子树上查找，我们要确定下一层的范围，那就是现在的l加上在[l,ll)前插入左子树的个数，就是下层中ll的值了，之后的同理。
    }
    else
    {
        newr=rr+num[rt][r]-num[rt][rr];
        newl=newr-(rr-ll-cnt);
        return query(newl,newr,mid+1,r,rt+1,k-cnt);
    }
    
}
 嗯。。代码是转的，。。。。 

 


 看懂之后的感觉就是……这么简单的一个问题居然会想不明白！！傻逼！！！！QAQ。
 

其实应该是在建树的时候没有想明白过程，所以在查询的时候就更糊涂了。
 

在想问题的时候，不断问自己为什么是这样，感觉会促进大脑的……思考………………
 

 

*******************************************
 

拿了一道题练练手，结果发现之前看的代码有错！表示很生气！ 划分树的资料不多，看知识介绍的时候代码只有那一份，每个贴代码的人为什么都没有仔细验证过。。。
 

表示看代码还是去搜模板比较好！恩！
 

然后，，，，刚开始一直RE，，，不知道为什么，但是建树的时候same的处理问题，坑了我一下午！！！然后，，，，在区间更新哪里的小细节还不能把握好，比如说加一减一 的问题……谁能教教我……………………
 

**************************************************
 

把上面的代码换成AC过的代码了。果然要自己敲一遍更好，不然都不知道自己有这么多的漏洞。
 

啊啊啊啊之前自己的想法都被del掉了QAQ、。。。。。。

                

        

        

    

  


    

      

        

            

              
                
                  natsuyu
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
数据结构----划分树

				
			

			

				

					Lin_disguiser的博客
				

				

					08-02
					
					2534
					
				

			

		

		

			
				
今晚又学了另外一种树----划分树。看了一晚上了，也是大概明白一些而已，对于一些细节还是不太理解。


划分树是一种基于线段树的数据结构。主要用于快速求出(在log(n)的时间复杂度内）序列区间的第k大值 。（主席树也可以，早就听过主席树这个词，感觉好高大上，准备学习一下，下面的例题也是主席树入门）




划分树的定义




         划分树定义为，它的每一个

			
		

	



                

              
                



	

		

			

				
					
划分树  详解及模板

				
			

			

				

					bestsort
				

				

					08-08
					
					551
					
				

			

		

		

			
				
划分树的目的：求区间内第K大数。对于此类问题，暴力的话直接对区间进行sort，但是时间复杂度很高，如果q次查询的话嘛，时间复杂度O(q*n*log(n))
为了降低时间复杂度，我们采取将数组构造成树的形式，这样,时间复杂度能降到log(n),但是空间复杂度为n*log(n).
建树规则为：`小于等于中位数的放在左子树，大于中位数的放在右子树`，以1-9的随机数组为例，建树方式如下：

			
		

	



                


  
              

                


	

		

			

				
					
划分数

				
			

			

				

					weixin_43442778的博客
				

				

					02-25
					
					1790
					
				

			

		

		

			
				
有n个无区别的物品，将它们划分为不超过m组，求出划分方法数模M的余数。

限制条件：

1≤m≤n≤1000

2≤M≤10000

输入

n = 4

m = 3

M = 10000

输出

4 （1+1+2=1+3=2+2=4）


分析：

设dp[i][j]为j的i的划分总数。

递推方法  

dp[i][j]= dp[i][j-i]（当前位不为0，因此先从j中间每个i位都分到1，...

			
		

	





	

		

			

				
					
牛客-数的划分——详解dp划分数问题

				
			

			

				

					CppYyds的博客
				

				

					01-11
					
					1561
					
				

			

		

		

			
				
文章目录题目题目详解解题代码
题目
题目链接

题目详解
划分数类型题目都是dp解决，而且都有固定的套路和公式，但我们还是需要在前人的公式上加以理解！
划分数问题dp总结
我这里就提两个比较常见的划分数问题的dp原理：

如果对数字划分较为抽象，那么我们把这个数字可以比作苹果，即有n个苹果需要划分到m个盘子里面，而这几个盘子的顺序肯定是不考虑的，也就是5个苹果划分给3个盘子，则1 2 2和2 1 2是完全一样的情况，只看具体的数字组合不看内部排列！



将n划分成不大于m的划分。
dp[n][m]=dp[

			
		

	



		

			
		



	

		

			

				
					
幸运数的划分

					
热门推荐

				
			

			

				

					Rosiness^的博客
				

				

					02-09
					
					2万+
					
				

			

		

		

			
				
题目描述

​ 判断一个正整数n是否能被一个"幸运数"整除。幸运数是指一个只包含4或7的正整数。如：7、47、477等都是幸运数，17、42则不是幸运数。

输入

​ 一行一个正整数n，1≤n≤1000。

输出

​ 一行一个字符串，如果能被幸运数整除输出"YES"；否则，输出"NO"。

样例输入


47

样例输出


YES

数据规模与约定

​ 时间限制：1 s

​ 内存限制：2...

			
		

	





	

		

			

				
					
关于划分数P(n)的Cohen不等式的再改进 (1998年)

				
			

			

				

					05-11
				

			

		

		

			
				
根据给定文件信息，本文将详细介绍划分数P(n)以及Cohen不等式在1998年进行的再改进。  首先，我们需要了解“划分数”的概念。在组合数学中，划分数是指将正整数n划分为若干正整数的和的方式数。例如，n=4的划分数有5...

			
		

	





	

		

			

				
					
GN.rar_MATLAB 网络划分_社区划分_社区划分 matlab_边介数

				
			

			

				

					07-15
				

			

		

		

			
				
复杂网络中社区划分算法中利用边介数的经典GN算法

			
		

	





	

		

			

				
					
数的划分1

				
			

			

				

					08-08
				

			

		

		

			
				
在描述中，我们看到这是一道关于算法的题目，具体是询问给定正整数有多少种不同的划分方式。  问题描述明确指出，当给定的正整数为n时，例如n等于3，那么可以有以下几种划分方法： 1. 3（直接用原数） 2. 1+2（两个...

			
		

	





	

		

			

				
					
关于图的符号边划分数 (2009年)

				
			

			

				

					05-19
				

			

		

		

			
				
在讨论图的符号边划分数之前，我们需要先了解图论中的一些基础概念。图是由顶点（节点）和连接顶点的边构成的数学结构，在计算机科学和数学中被广泛研究。对于无向图而言，边是两个顶点之间的无向连接。在该文档中，...

			
		

	





	

		

			

				
					
数的划分2

				
			

			

				

					08-08
				

			

		

		

			
				
标题“数的划分2”指的是一个算法问题，其核心是探讨如何将一个整数n划分为k个非空且互不相同的子集。这个问题属于组合数学和计算机算法设计的范畴，尤其是在动态规划或回溯搜索等领域有应用。下面将详细阐述这个...

			
		

	





	

		

			

				
					
leetcode 110 【判断是否是AVL】

				
			

			

				

					The Summer, The Winter
				

				

					06-06
					
					918
					
				

			

		

		

			
				
额。。。代码不是很漂亮，递归查看每棵子树是否是平衡树。以当前节点为根的子树是平衡树的条件是左右子树都是平衡树，并且两者的高度差不超过1.
原先在纠结怎么一边传树的高度，一边判断是否是AVL。然后发现。。。可以传引用进去！这样每次都可以回溯得到子树的高度，又可以进行判断。
/**
 * Definition for a binary tree node.
 * struct TreeNode {

			
		

	





	

		

			

				
					
HUFFMAN编码进行压缩---【数据结构】

				
			

			

				

					The Summer, The Winter
				

				

					05-06
					
					771
					
				

			

		

		

			
				
说到HUFFMAN编码可以用来进行压缩，然后就想试试。拖了一周才开始写。纠结了两天。现在有点样子了，但是。。有BUG。。。有的时候可以有的时候不可以。。。。正在找原因。对文件操作和计算机原理这一块还不是很熟。
理一下思路吧。
先从一个文件中读取数据，进行频数统计，然后根据统计的频数建立HUFFMAN树。再扫描一遍文件，利用HUFFMAN树进行编码。此处有技巧！因为要进行压缩，所以对于每个字符的

			
		

	





	

		

			

				
					
HDU 4514 【非联通无向图判环，树直径】

				
			

			

				

					The Summer, The Winter
				

				

					06-04
					
					675
					
				

			

		

		

			
				
题目很明显是判环+树直径。
然后自己有这么几个坑点。
第一是没有搞清楚tarjan判的是有向图是否有环，无向图判环要用并查集。第二是没想到图可能是不连通的，需要循环寻找每棵树进行直径的寻找。第三是在找直径上的dfs上有错。。。
恩，然后就是手动扩栈了一下。
#pragma comment(linker, "/STACK:102400000,102400000")
#include 
#in

			
		

	





	

		

			

				
					
PAT 1064 【建立BST树】

				
			

			

				

					The Summer, The Winter
				

				

					06-09
					
					633
					
				

			

		

		

			
				
把给定的数组排序，然后按照中序遍历的方法存到数组中。
因为可以发现对于BST树中序遍历的结果就是数组的升序。
于是用中序遍历的方法建树。
#include 
#include 
#include 
using namespace std;
#define maxn 1100
int n,a[maxn],b[maxn];
void create(int node,int &index)
{
 

			
		

	





	

		

			

				
					
leetcode 105【前序，中序建树】

				
			

			

				

					The Summer, The Winter
				

				

					06-06
					
					574
					
				

			

		

		

			
				
有简洁版的。。可是懒得看。。。。
自己写的这个算是模拟手酸过程了吧，恩。感觉碰到这样的例子，就是涉及长度加减的，都要拿小数据测一测。
class Solution {
public:
    TreeNode* find(int l,int r,int ll,int rr,vector&preorder,vector&inorder)
    {
        if(lr||ll>rr) r

			
		

	





	

		

			

				
					
leetcode 124 【树直径】

				
			

			

				

					The Summer, The Winter
				

				

					06-09
					
					542
					
				

			

		

		

			
				
class Solution {
public:
    mapdp1,dp2;
    int ans;
    void help(TreeNode*x)
    {
        dp1[x]=dp2[x]=x->val;
        if(x->left)
        {
            help(x->left);
            int tmp=dp1[x->

			
		

	





	

		

			

				
					
leetcode 212 【trie+dfs】

				
			

			

				

					The Summer, The Winter
				

				

					06-06
					
					515
					
				

			

		

		

			
				
好多bug。。好醉。
不知道怎么写题解了。。。应该说就是tire树的应用吧，给你一个map，然后在map中找到存在的指定串。。。
但是感觉还有很多的。。地方不能好好优化，因为并不知道这个函数确切的使用情况！！！不开心。。没有数据大小。。。
class Solution {
public:
    class node
    {
    public:
        int have;
 

			
		

	





	

		

			

				
					
leetcode 98 【查询是否是平衡树】

				
			

			

				

					The Summer, The Winter
				

				

					06-08
					
					504
					
				

			

		

		

			
				
讨厌自己晕晕乎乎的，这么简单的题也debug了好久，之前自己的思路都没有想好，这么简答的逻辑关系也理不清楚，活该做这么久。
这几天怨气怎么这么大。。。
对于每个节点，需要左子树的最大值，右子树的最小值，及两者是否都是AVL。
但是应该记录子树上所有值的最大值，最小值。因为对于该节点的父节点，你不知道他是要最大值，还是最小值。
/**
 * Definition for a binary t

			
		

	





	

		

			

				
					
HDU 3999 BST基础

				
			

			

				

					The Summer, The Winter
				

				

					04-08
					
					494
					
				

			

		

		

			
				
初学BST树，拿来练练手。
题目是你一个序列，叫你求出建同样的树所用的最少字典序的序列。。。。
嗯。。应该就是前序了。。。
然后。。恩恩。。。。
#include 
#define maxn 100100
struct node
{
    int val;
    node *left,*right;
}tree[maxn];
void insert(node *rt,node *x)


			
		

	





	

		

			

				
					
动态规划关于数的划分

					
最新发布

				
			

			

				

					07-18
				

			

		

		

			
				
对于数的划分问题，比如著名的“零一背包”或“整数分割”问题，动态规划的应用是这样的：  假设有一个非负整数数组 `weights` 和一个容量限制 `capacity`，目标是确定能否通过将数组中的元素合理地加起来，使得总和...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值