编程题汇总2

1.快速找出一个数组中的两个数字，让这两个数字之和等于一个给定的数字，时间复杂度要小于$O(N)^2$

微软编程之美上的一道题，实习笔试面试中经常出现

(a) 假设给定的和为Sum.对于每个数字arr[i],都需要查找对应的Sum-arr[i]是否存在在数组中.

首先将要排序的数组排序，然后用二分查找的方式进行查找

快速排序的时间复杂度是$O(Nlog_2N)$,二分查找的时间复杂度是$O(log_2N)$,对$n$个数的时间复杂度为$O(Nlog_2N)$,一共为$O(Nlog_2N)$。

代码如下：

def quicksort(array, left, right):
    if right<left:
        return
    value = array[left]
    i = left
    j = right 
    while i < j:
        # print array
        while i<j and value <= array[j]:
            j -= 1
        while i<j and value >= array[i]:
            i += 1
        array[i], array[j] = array[j], array[i]        
    array[i], array[left] = array[left], array[i]
    quicksort(array,left, i-1)
    quicksort(array,i+1, right)

def bisearch(array, target_value):
    max_index = len(array) - 1 
    min_index = 0
    while min_index < max_index-1:
        mid_index = (max_index + min_index)/2
        if target_value >= array[mid_index]:
            min_index = mid_index
        else:
            max_index = mid_index
    if array[max_index] == target_value:
        return max_index
    elif array[min_index] == target_value:
        return min_index
    else:
        return -1
if __name__ == '__main__':
    a = [1,4,3,9,7,8,11,5]
    target_value = 11
    quicksort(a,0,7)
    for i in xrange(len(a)):
        index = bisearch(a, target_value-a[i])
        if index is not -1 and index is not i:
            print a[i],a[index]
            break

执行结果
3 8

(b) 首先对数组进行快排，时间复杂度为$O(Nlog_2N)$.
然后令$i=0,j=n-1$.看arr[i]+arr[j]是否等于Sum,如果是，则结束，否则，如果和小于Sum，则i=i+1;如果大于Sum，则j=j-1。只要遍历一次就可以得到最后结果，时间复杂度为$O(N)$，总的时间复杂度为 $O(Nlog_2N)$.

利用python实现如下

if __name__ == '__main__':
    a = [1,4,3,9,7,8,11,5]
    target_value = 11
    quicksort(a,0,7)
    i = 0
    j = len(a)-1
    while i < j:
        sum = a[i]+a[j]
        if sum is target_value:
            print a[i],a[j]
            break
        elif sum > target_value:
            j = j - 1
        else:
            i = i + 1

(c)利用hash表，给定一个hash映射查找另一个数字是否在数组中，只需要用O(1)的时间，总体时间可以降低到O(N),但需要额外增加O(N)的hash存储空间。

2. 一个4*5的棋盘，在左下的格移动到右上的格 ，求有多少种移动方法。

(a) 用数学解法，从左下角走到右上角一共需要3(up)+4(right)=7步，7步中任意选择3步up有多少种走法就是一共的走法，$C_7^3=35$.

(b) 动态规划，f(m,n)表示从坐标(0,0)移动到(m,n)所需的方法，则
$f(m,n)=f(m-1,n)+f(m,n-1)$
$f(0,1)=1$
$f(1,0)=1$
利用Python写成递归

def n_move(m,n):
    if m is 0 or n is 0:
        return 1
    else:
        return n_move(m-1,n) + n_move(m,n-1)

if __name__ == '__main__':
    print n_move(3,4)

输出 35

(c)数学题. 甲、乙两人轮流掷一颗骰子，甲先掷．每当某人掷出1点时，则交给对方掷，否则此人继续掷，试求第n次由甲掷的概率
设f(n)为由甲掷的概率，则
$f(n)=\frac{5}{6}f(n-1)+\frac{1}{6}(1-f(n-1))$
$f(n)=\frac{2}{3}f(n-1)+\frac{1}{6}$
$f(n)-\frac{1}{2}=\frac{2}{3}(f(n-1)-\frac{1}{2})$
$f(n)=\frac{1}{2}+(\frac{2}{3})^{n-1}{(f(1)-\frac{1}{2})}$
$f(n)=1$
$f(n)=\frac{1}{2}+\frac{1}{2}(\frac{2}{3})^{n-1}$