题目本质：通过将字符串A的字母之间的连续交换位置，达到 两个字符串之间完全相同的情况

解析：通过将不相等处的字母，发现之后找到想等的，然后进行位置替换。如此反复。

   问题在于慢，慢在于只要不相等，就会遍历字符串之后所有的字符，大量重复的无意义的计算比较，所以将遍历过的计算过的存在于memo字符串中间。

错误：没有找到效率低的问题所在，在于比较过的无意义的比较。

   没有发现字符串的遍历，一种向前，一种向后。
   对付效率低，一种有效的方式就是缓存，将比较过的先储存起来

应用：缓存意识，发现大量比较，可能有重复，储存。

   递归函数，利用返回结果的话，返回结果是递归到最后，结束遍历以后，得到的结果才有效。  
             

import sys
class Solution:
    def kSimilarity(self, A, B):
        memo=dict()
        self.ans=sys.maxsize
        def helper(a,b):
            if len(a)!=len(b):
                return 0
            elif a==b:
                return 0
            elif (a,b) in memo:
                print(a,b,memo[(a,b)])
                return memo[(a,b)]
            elif a[-1]==b[-1]:
                self.ans=min(self.ans,helper(a[:-1],b[:-1]))
            else:
                for i in range(0,len(a)-1):
                    # print(a,b)
                    if a[i]==b[-1]:
                        # print(a[:i],b[-1],a[i+1:])
                        a_new=a[:i]+a[-1]+a[i+1:-1]
                        # print(a_new,b[:-1])
                        self.ans=min(self.ans,1+helper(a_new,b[:-1]))
                        # self.ans=1+helper(a_new,b[:-1])
                        # break
                        # print(self.ans)
            memo[(a,b)]=self.ans
            return self.ans
        self.ans=helper(A,B)
        return self.ans

if __name__=='__main__':
    A = "aabc"
    B = "abca"
    A="abbcac"
    B="abcbca"
    A="abccaacceecdeea"
    B="bcaacceeccdeaae"
    A="fffeaacbdbdafcfbbafb"
    B="abcbdfafffefabdbbafc"
    # A="abfdfacbd b d a f cfbbafb"
    # B="abcbdfaff f e f a bdbbafc"
    # A="abccab"
    # B="abccab"
    st=Solution()
    # out=st.kSimilarity(A,B)
    out=st.kSimilarity(A,B)
    print(out)