day2

第二天

leetcode 003题

求2个sorted的list合在一起的中位数

自己想了个思路：

在长的那个list上找到中点 然后找到这个中点的值在短的list上的位置这个位置，把这两个点连线， 这条线左边所有的值都小于中点的值， 然后过短线中点再画一条平行的， 第二条线右边的值都大于中点值 所以只要把中间剩下的值继续递归运算最后就能得到结果 - - 可是边界值貌似很不好确定。。

    class Solution:
    # @param {integer[]} nums1
    # @param {integer[]} nums2
    # @return {float}
    def findMedianSortedArrays(self, nums1, nums2):

        len1 = len(nums1)
        len2 = len(nums2)
        if len1 < len2:
            temp = len1
            len1 = len2
            len2 = temp
            temp = nums1
            nums1 = nums2
            nums2 = temp
        mid1 = len1/2
        mid2 = len2/2
        if len1 == 0:
            return nums2[mid2]
        if len2 == 0:
            return nums1[mid1]   
        a = nums1[mid1] 
        if a == nums2[mid2]:
            return a
        start = 0
        end = len2 - 1
        while 1:
            if a == nums2[(start + end)/2]:
                break
            if start == end:
                break
            if a < nums2[(start + end)/2]:
                end = (start + end)/2 - 1
            else:
                start = (start + end)/2 + 1
        left1 = mid1 - 1
        left2 = (start + end ) / 2 - 1
        right1 = len1 - mid1 - 1
        right2 = len2 - (start + end ) / 2 - 1
        x = right1 + right2 - left1 -left2
        def chu1(index):
            if index < left1 or index >right1:
                return False
            return True
        def chu2(index):
            if index < left2 or index >right2:
                return False
            return True
        num1 = filter( chu1 , nums1)
        num2 = filter( chu2 , nums2)
        self.findMedianSortedArrays( num1, num2)

到最后也没改好 于是想换一下思路，

上网搜大牛们的思路了。。= = 最简单的方法是求第k大的元素
在nums1 中取前x个元素 在nums2中取 前y的元素 要求满足x+y=k
在这里 也就是满足x + y = (m + n) / 2， 取的所有元素的总数是k个
如果 nums1[x] > nums2[y] 所以比 nums1[x]肯定是取的所有数中最大的 并且nums[x]一定大于要求的中位数 反过来 nums2[y]肯定小于要求的数 这样比nums[y]小的所有数都可以拿掉 然后求剩下数中的 k-（拿掉的个数） 这样就可以递归实现

    大牛的代码
    class Solution:
    def findMedianSortedArrays(self, A, B):
        totlen = len(A) + len(B)
        if (1 & totlen):    # 通过位运算判断奇偶数，nice
            return self.findK(A, B, (totlen+1)/2)
        else:
            return (self.findK(A, B, totlen/2) + self.findK(A, B, totlen/2+1))/2.0

    def findK(self, A, B, K):
        la, lb, pa, pb = len(A), len(B), min(K/2, len(A)), K - (min(K/2, len(A)))
        if (la > lb): return self.findK(B, A, K)
        if (la == 0): return B[K-1]
        if (K == 1): return min(A[0], B[0])
        if A[pa-1] < B[pb-1]: return self.findK(A[pa:], B, K-pa)
        elif A[pa-1] > B[pb-1]: return self.findK(A, B[pb:], K-pb)
        else: return A[pa-1]

原地址http://c4fun.cn/blog/2014/03/20/leetcode-solution-02/

通过位运算判断奇偶数 是以前没用过的，在这里学习了

今天打算再出一题

leetcode oj 004题 最长回文子串

能很简单的想到判断由i向两边伸展的回文子串长度是O（n方）

然后用了Manacher 线性算法 进一步优化 还有些小bug 明天改好bug 然后把思路贴上来

今天的代码(有bug）

    class Solution:
    # @param {string} s
    # @return {string}
    def longestPalindrome(self, s):
        max = 0
        temp = ['*']
        for x in s:
            temp.append('#')
            temp.append(x)
        temp.append('#')
        temp.append('\0')
        id = 0
        maxlen = 0
        lens = len( temp )
        p = []
        for i in range(lens):
            p.append(0)
        for i in range(2,lens -1):
            if p[id]+id>i:
                p[i]=min(p[2*id-i],p[id]+id-i); 
            else:
                p[i]=1; 
            while temp[i-p[i]] == temp[i+p[i]]:
                p[i] = p[i] + 1;
            if id+p[id]<i+p[i] :
                id=i; 
            if maxlen<p[i] :
                maxlen=p[i]
        s=''
        for i in range(id - +p[id],id + +p[id]):
            if temp[i]!='#' and temp[i]!='*':
                s = s + temp[i]
        return s

贵在坚持