递归和迭代，以及汉诺塔，采用迭代法不容易实现的说明

这里拿一直被作为递归来举例而强行递归（无需递归就可求出的）的阶乘来说明

N！=N*(N-1)！

递归：就是要解决x(N)问题，转化成x(N-1)问题

他的展开：N！=N*(N-1)*(N-2)*...*3*2*1

迭代：N！=(N-1)！*N

他的展开：N=1*2*3...*(N-2)*(N-1)*N

个人的说明能力很有限，就是他们执行时，步骤是不同的，解决问题的结构是不同的。

递归在执行N！=N*(N-1)！时，实际(N-1)！是个什么值，是不知道的

迭代：N！=(N-1)！*N，时，(N-1)！的值已经是得出结果的

这个根节点可以看作是1！，因为从7到1，以及从1到7都是单行道，没分支。所以说这是一个最简单的例子。

汉诺塔是介绍递归最好的例子，因为移动N个盘子，可以转化成移动(N-1)个盘子的问题，最后归结到移动一个盘子的问题（这个是没有难度的）。通过递归，顺便找到了每一步演化的路线。

而迭代，就是不光不能用递归，而且不能用push，pop，因为这就是你手动实现了递归。而是要从根节点开始，一步一步迭代，推导到最后完成那一步。如果绕了一圈，我终于知道该怎么迭代，这个也是不行的，属于强行迭代。因为从问题开始节点，你不知道该怎么迭代。所以说这个用迭代是不明智的。

树形用递归，就属于一点浪费也没有，他不会多访问一个节点，因为不联通的，虽然是开多条分支，但每条分之都是必须的。如果是图，互相联通，用递归就完了，组合爆炸。比如LeetCode1143（强行递归，用了map解决，map有值，直接返回这个值，不再往下递归了，这样就基本消除了重复搜索）：

1143. 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

示例 1:

输入：text1 = "abcde", text2 = "ace"
输出：3
解释：最长公共子序列是 "ace"，它的长度为 3。

    class Solution1143(object):
        def longestCommonSubsequence(self, text1, text2):
            return self.longest_subsequence( text1, text2,0,0,{})
        def longest_subsequence(self, text1, text2,idx1,idx2,mapx):
            v = mapx.get(idx1*1000+idx2)
            if v != None:
                return v
                
            if idx1 == len(text1) or idx2 == len(text2): return 0
            
            maxv = 0
            if text1[idx1] == text2[idx2]:
                maxv = max(maxv,1+self.longest_subsequence(text1,text2,idx1+1,idx2+1,mapx))
            else:
                idx31 = text1.find(text2[idx2],idx1)
                idx32 = text2.find(text1[idx1],idx2)
                if idx31 != -1:
                    maxv = max(maxv,1+self.longest_subsequence(text1,text2,idx31+1,idx2+1,mapx))
                if idx32 != -1:
                    maxv = max(maxv,1+self.longest_subsequence(text1,text2,idx1+1,idx32+1,mapx))
                maxv = max(maxv,self.longest_subsequence(text1,text2,idx1+1,idx2+1,mapx))
                
            mapx.update({idx1*1000+idx2:maxv})
            return maxv
    print(Solution1143().longestCommonSubsequence("abcde","bde" ))
    print(Solution1143().longestCommonSubsequence("psnw","vozsh"))
    print(Solution1143().longestCommonSubsequence("oxcpqrsvwf","shmtulqrypy"))
    print(Solution1143().longestCommonSubsequence("bl","yby"))
    print(Solution1143().longestCommonSubsequence("hofubmnylkra","pqhgxgdofcvmr"))
    print(Solution1143().longestCommonSubsequence("abcdefghij","ace"))