depth

111. Minimum Depth of Binary Tree（二叉树的最小深度） 链接 https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/ 题目 给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明: 叶子节点是指没有子节点的节点。 示例: 给定二叉树 [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回它的最小深度 2. 思路 二叉树的问题，不过比起最大深度麻烦了不少。 首先还是空节点直接返回0； 如果左右两个子节点有一个为空，最大深度分别为a和b，那么空的那个就应该等于0，返回另外一个深度+0+1； 如果两个都不为空节点，那么返回二者中的较小值+1. （这题我本来的代码对于[1,2]的结果为1，是错误的，之后参考了题解，才发现我对于题目的理解出了问题） 代码 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } public static int minDepth(TreeNode root) { if (root == null) { return 0; } if (root.left

定义：   最近公共祖先简称 LCA（Lowest Common Ancestor）。两个节点的最近公共祖先，就是这两个点的公共祖先里面，离根最远的那个。 性质： 1. L C A ( u ) = u LCA(u)=u L C A ( u ) = u ; 2. u u u 是 v v v 的祖先，当且仅当 L C A ( u , v ) = u LCA(u,v)=u L C A ( u , v ) = u ； 3. 如果 u u u 不为 v v v 的祖先并且 v v v 不为 u u u 的祖先，那么 u , v u,v u , v 分别处于 L C A ( u , v ) LCA(u,v) L C A ( u , v ) 的两棵不同子树中； 4. 前序遍历中, L C A ( S ) LCA(S) L C A ( S ) 出现在所有 S S S 中元素之前，后序遍历中 L C A ( S ) LCA(S) L C A ( S ) 则出现在所有 S S S 中元素之后； 5. 两点的最近公共祖先必定处在树上两点间的最短路上； 6. d ( u , v ) = h ( u ) + h ( v ) − 2 h ( L C A ( u , v ) ) d(u,v) = h(u) + h (v) - 2 h(LCA(u,v)) d ( u , v ) = h ( u ) + h ( v

把这几天学的搜索做一个初步总结。 一、 深度优先搜索（DFS）：从起点出发，走过的点要做标记，发现有没走过的点，就随意挑一个往前走，走不动了就回退。不能走已经走过的点（需要判重）。 举几个栗子： 1.判断从V出发是否能走到终点： bool Dfs(V) { if( V 为终点） return true; if( V 为旧点) return false; 将V标记为旧点; 对和V相邻的每个节点U { if( Dfs(U) == true) return true; } return false; } 判断从v出发是否能走到终点时，返回值有意义。 因为有回溯的过程，所以会把k出发能走到的点都走一遍。 2.判断从v出发是否能走到终点，如果能，要记录路径。 bool Dfs(V) { if( V为终点） { path[depth] = V; return true; } if( V 为旧点) return false; 将V标记为旧点; path[depth]=V; ++depth; 对和V相邻的每个节点U { if( Dfs(U) == true) return true; } --depth; return false; } --depth的过程就是回溯的过程。 3.在图中寻找最优（步数最少路径） void Dfs(V) { if( V为终点） { path[depth] = V;

使用C++来编写json生成器的使用来熟悉C++区别于C的使用方法和语法。 头文件 /* json-writer.cpp */ #ifndef _JSONWRITER_H_ #define _JSONWRITER_H_ #include<iostream> #include<string> #include<stack> #include<cstdint> using namespace std; class JsonWriter { public: enum ContainerType { CONTAINER_TYPE_ARRAY, CONTAINER_TYPE_OBJECT }; enum ContainerLayout { CONTAINER_LAYOUT_INHERIT, CONTAINER_LAYOUT_MULTI_LINE, CONTAINER_LAYOUT_SINGLE_LINE }; explicit JsonWriter(): writer(NULL), initialIndentDepth(0), indent(" "), containerPadding(" "), keyPaddingLeft(""), keyPaddingRight(" "), defaultContainerLayout(CONTAINER_LAYOUT_MULTI_LINE),

求LCA(u，v)的三种方法： 1：rmq+dfs()序 2：并查集+dfs() 3：树上倍增 然而听说1，2两种方法不怎么火热，3是目前最受欢迎的，故我就跟随大众潮流，学了树上倍增求 LCA(u，v) 的方法 树上倍增：利用了 rmq 的思想，首先定义一个 pre[i][j] 数组， pre[i][j] 表示 i 往上走 2^j 层所表示的父辈，根据倍增关系，我们可以得到： pre[i][j]=pre[pre[i][j-1]][j-1] ，然后我们利用 dfs() 处理每一个点的深度： depth [ u ] = depth [ fa ] + 1 并根节当前节点的深度，倍增u所能达到的点 代码： void dfs ( int u , int fa ) //求深度 { depth [ u ] = depth [ fa ] + 1 ; pre [ u ] [ 0 ] = fa ; for ( int i = 1 ; ( 1 << i ) <= depth [ u ] ; i ++ ) pre [ u ] [ i ] = pre [ pre [ u ] [ i - 1 ] ] [ i - 1 ] ; for ( int i = head [ u ] ; ~ i ; i = edge [ i ] . nex ) { int v = edge [ i ] . to ; if ( fa !=

from PIL import Image import numpy as np import os import cv2 as cv def mulhanpicture(path): filelist = os.listdir(path) for item in filelist: if item.endswith('.png') or item.endswith('.jpg'): item = path + '/' + item item_save = item[:-4] + '_hand' + item[-4:] a = np.asarray(Image.open(item,).convert('L')).astype('float') depth = 5 #改值可改变程度（0-100） grad = np.gradient(a) grad_x,grad_y = grad grad_x = grad_x*depth/100.0 grad_y = grad_y*depth/100.0 A = np.sqrt(grad_x**2+grad_y**2+1.0) unix = grad_x/A uniy = grad_y/A uniz = 1.0/A vecaz = np.pi/2.2 vecel = np.pi/4.0 dx = np.cos(vecel)*np.cos(vecaz

文 Akisann@CNblogs / zhaihj@Github 本篇文章同时发布在Github上：http://zhaihj.github.io/a-first-look-at-rust.html 过去的一年半多，我一直沉迷与 OOC ，原因倒是很简单，OOC是目前为止我所能见到的最容易理解和最容易书写的语言。并且另外一个极其重要的地方是，它可以编译成C代码。 编译成C代码 ，也就意味着优化可以交给高度发展的C语言编译器来做，听起来似乎适合十分高效的方法。 最近几年类似的语言越来越多，从很久很久之前就存在却一直没出名的 Haxe ，还有最近的 Nim-lang ，以及采用了类似ruby语法的 Crystal ，甚至包括编译成C++的 felix 。这些语言都号称自己考虑了速度（运行速度），至少从编译成C/C++的层面上。 可惜的是，在改进OOC编译器 rock 的过程中，我遇到了越来越多的问题，这些问题让喜欢速度的人泄气。一个最明显的事情是，这些语言几乎都用了GC，不论是libGC还是自己写的，并且更重要的是，很多语言特性是基于GC设计的——比如闭包，比如iterator的unwrap，在有没GC的情况下，这些东西的设计要复杂的多。在OOC里，由于Generics不是Template，更多的东西开始依存GC，在用了它一年后，当我真正开始在工作里使用的时候，这些问题开始出现

此文首发于我的个人博客： LeetCode 111. Minimum Depth of Binary Tree–Python解法–二叉树最小高度–迭代，递归 — zhang0peter的个人博客 LeetCode题解文章分类： LeetCode题解 LeetCode 所有题目总结： LeetCode 所有题目总结 题目地址： Minimum Depth of Binary Tree - LeetCode Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Note: A leaf is a node with no children. Example: Given binary tree [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 这道题目是计算二叉树最小高度，可以用迭代或者递归来做。 递归解法如下。 Python解法如下： # Definition for a binary tree node. # class TreeNode: # def __init__(self,