剑指offer 解题思路简述总结篇11-20

面试题11:旋转数组的最小数字

方法：设两个指针，分别位于数组的开头和结尾，while循环，若开头的数小于结尾的数，直接返回开头数，否则找到中间的数，若中间数大于开头数，范围缩小到中间数+1到结尾数，若中间数小于开头数，则范围缩小到前半部分，若相等则直接return该段的最小值，如此反复，直到两个指针指向同一个元素元素，循环结束，返回。

class Solution(object):
    def minArray(self, rotateArray):
        # write code here
        if len(rotateArray)==0:return 0
        if len(rotateArray)==1:return rotateArray[0]
        lengh = len(rotateArray)
        front = 0
        end = lengh-1        
        while front!=end:
            if rotateArray[end]>rotateArray[front]:return rotateArray[front]
            mid = (front+end)//2
            if rotateArray[front]<rotateArray[mid]:
                front = mid+1
            elif rotateArray[front]>rotateArray[mid]:
                end = mid
            else: #110111的情况
                return min(rotateArray[front:end+1])
        return rotateArray[end]

• 面试题12:矩阵中的路径

方法：haspath函数里挨个遍历找到和第一个数相同的起始位置，然后调用find函数遍历接下来的四个位置，并将刚才相等的位置的数置0，find中递归调用自己，return的条件是path为空

class Solution:
    def hasPath(self, matrix, rows, cols, path):
        # write code here
        for i in range(rows):
            for j in range(cols):
                if matrix[i*cols+j]==path[0]:
                    if self.find(list(matrix),rows,cols,path[1:],i,j):
                        return True
        return False
    def find(self,matrix,rows,cols,path,i,j):
        if not path:
            return True
        matrix[i*cols+j]='0'
        if j+1<cols and matrix[i*cols+(j+1)]==path[0]:
            return self.find(matrix,rows,cols,path[1:],i,j+1)
        elif j-1>=0 and matrix[i*cols+(j-1)]==path[0]:
            return self.find(matrix,rows,cols,path[1:],i,j-1)
        elif i+1<rows and matrix[(i+1)*cols+j]==path[0]:
            return self.find(matrix,rows,cols,path[1:],i+1,j)
        elif i-1>=0 and matrix[(i-1)*cols+j]==path[0]:
            return self.find(matrix,rows,cols,path[1:],i-1,j)
        else:
            return False

• 面试题13:机器人的运动范围

方法：block函数判断是否超过阈值，traverse函数中判断四个方向是否可行，递归调用自己，返回条件是和超过阈值或者到达了矩阵的边界，需要把经过的位置设置标记

class Solution:
    def movingCount(self, threshold, rows, cols):
        # write code here
        board=[[0 for i in range(cols)]for j in range(rows)]
        global acc
        acc=0
        def block(r,c):
            s=sum(map(int,str(r)+str(c)))
            #s = r+c
            return s>threshold
         
        def traverse(r,c):
            global acc
            if not (0<=r<rows and 0<=c<cols):
                return
            if board[r][c]!=0:
                return
            if block(r,c):
                board[r][c]=-1 #超出门限的点记录-1
                return
            board[r][c]=1 #符合规定的点记录1，并计数加一
            acc+=1
            traverse(r+1,c)
            traverse(r-1,c)
            traverse(r,c+1)
            traverse(r,c-1)
             
        traverse(0,0)
        return acc

• 面试题14:剪绳子

方法一：从下往上，动态规划，先得到f(2),f(3)，再得到f(4),f(5)，再f(n)

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 2:
            return 1
        if n == 3:
            return 2
        dp = [1]*(n+1)#建立dp数组
        dp[1] = 1#初始化base
        dp[2] = 2 #2只能分成1和1，但实际上不分解更大
        dp[3] = 3 #3分成2和1最大，但实际上不分解最大，
        #进行状态转移
        for i in range(4,n+1):#对每个状态4～n
            for j in range(1,i//2+1):#对每种选择
                dp[i] = max(dp[i],dp[i-j]*dp[j])#状态转移方程
        return dp[-1]

方法二：贪婪算法，尽可能多的剪出长度为3的绳子，当剩下是4的时候，剪成2*2的绳子

class Solution:
    def cutRope(self, number):
        if number < 5:
            return [0, 0, 1, 2, 4][number]
        return number % 3 * 3 ** (number // 3)

• 面试题15:二进制中1的个数

方法一：与运算，共32与运算，每次将所给的数与1，若结果为1则count+1

方法二：把一个数减去1，再与原整数做与运算，会把该整数最右边的1变成0，所以统计可以做多少次这样的运算

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        # write code here
        #减去1再与上原数，相当于最右边的1变成0，看能有多少次这种运算
        '''
        num = 0
        while n!=0:
            n = (n-1)&n
            num = num+1
        return num
        '''
        count = 0
        for i in range(32):
            if n&1==1:
                count = count+1
            n = n>>1
        return count 

相关题目：

• 面试题16:数值的整数次方

方法：很简单需要注意细节，指数是负数的时候先取正再倒数，为0的情况单独考虑

# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        # write code here
        if base ==0: return 0
        if exponent==0:return 1
        result = 1
        for i in range (abs(exponent)):
            result = result *base
        if exponent>0:
            return result
        else: 
            return 1/result

• 面试17:打印从1到最大的n位数

方法：大数问题，需要用字符串表示数字,相当于n个空位将0到9全排列，注意只保存左边起不为0的数字

class Solution:
    def printNumbers(self, n: int) -> [int]:
        def dfs(x):
            if x == n:
                s = ''.join(num[self.start:])
                if s != '0': res.append(int(s))
                if n - self.start == self.nine: self.start -= 1
                return
            for i in range(10):
                if i == 9: self.nine += 1
                num[x] = str(i)
                dfs(x + 1)
            self.nine -= 1
        
        num, res = ['0'] * n, []
        self.nine = 0
        self.start = n - 1
        dfs(0)
        return res
    def printNumbers_2(self, n):
        """
        :type n: int
        :rtype: List[int]
        """
        return [i for i in range(1, 10 ** n)]

• 面试题18:删除链表的节点

方法一：每次都比较next.val，如果相同直接将现在的指向之后的之后

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        # 如果头结点为空，直接返回
        if not head:
            return head
        # 如果头结点值等于val，直接返回head.next（题设中有注明链表中元素不重复）
        if  head.val == val:
            return head.next
        # 定义一个指针
        cur = head
        while cur.next:
            # 关键步骤，如果next的值等于val，跳过该节点
            if cur.next.val == val:
                cur.next = cur.next.next
                break
            cur = cur.next
        return head

方法二：设置两个指针，前面那个指针比较是否相等，若果相等，直接将前面的指向后面的后面。

class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        if head.val == val: return head.next
        pre, cur = head, head.next
        while cur and cur.val != val:
            pre, cur = cur, cur.next
        if cur: pre.next = cur.next
        return head

方法：需要设置一个节点pre指向头节点以免头节点重复被删除，先判断是否有重复，有的话再while循环往后比较，设置pre.next = cur, cur.next=temp

class Solution:
    def deleteDuplication(self, pHead):
        # write code here
        d = ListNode(-1)
        d.next = pHead
        pre = d
        cur = pHead
        while cur:
            if cur.next and cur.next.val == cur.val:
                temp = cur.next
                while temp and temp.val == cur.val:
                    temp = temp.next
                pre.next = temp
                cur = temp
            else:
                pre = cur
                cur = cur.next
        return d.next