leetcode刷题日志

剑指Offer第四题 二维数组的查找

bool findNumberIn2DArray(int** matrix, int matrixSize, int* matrixColSize, int target){
    int rows=matrixSize/(*matrixColSize);
    int i=rows-1,j=0;
    int cols=*matrixColSize;
    while(i>=0&&j<cols){
        if(*((int*)matrix+i*cols+j)==target) return true;
        else if(*((int*)matrix+i*cols+j)<target) j++;
        else i--;
    }
    return false;
}
void main(){
    int matrixColSize=5;
    int a[5][5]={   {1,4,7,11,15},
                    {2,5,8,12,19},
                    {3,6,9,16,22},
                    {10,13,14,17,24},
                    {18,21,23,26,30}};
    bool result=findNumberIn2DArray((int **)a,25,&matrixColSize,5);
    if(result==1) printf("OK");
    else printf("NO");
}

提交一直错误，不知道哪里出了问题
知识点参考

1. 二维数组传参的格式

剑指Offer第六题

注意 刚定义的指针要初始化，不然程序会出现不可预知的错误。

每日一刷 994. 腐烂的橘子

思路：广度优先搜索

程序中的知识点:
Python中yield的用法

剑指Offer 10-2 青蛙跳台阶问题

斐波那契数列问题
$$f(n)=f(n-1)+f(n-2))$$
$\ast Note:f(0)=1,f(1)=1.$

算法工程师能力评估

题目链接

1. 题目9 卡特兰数的讲解
2. 题目10 递推问题算法复杂度，Master theorem。
3. 题目十二

一个有序数列，序列中的每一个值都能够被2或者3或者5所整除，这个序列的初始值从1开始，但是1并不在这个数列中。求第1500个值是多少？ 解法

4. 题目15

输出数组的全排列

解法 递归思想及几个经典题目

Python编程要注意的一个地方: 值传递与引用传递

def f(a):
	a[0]=a[0]+1
b=[1,2]

print(f(b))  
#输出结果为 [2,2]，此处为引用传递，因为b是一个复杂对象(List)

python中值传递还是引用传递

剑指Offer 面试题12. 矩阵中的路径

题目
递归和栈 两种做法
深度优先搜索Or深度优先遍历详解
尝试用栈的解法，但代码有问题，通不过测试用例。

[[“C”,“A”,“A”],[“A”,“A”,“A”],[“B”,“C”,“D”]]
“AAB”

剑指Offer13题 机器人的运动范围

def movingCount(self, m, n, k):
        """
        :type m: int
        :type n: int
        :type k: int
        :rtype: int
        """
        board=[[0 for i in range(n)] for j in range(m)] 
        for i in range(m):
            for j in range(n):
                if (i//10)+(i%10)+(j//10)+(j%10)>k:
                    board[i][j]=-1
        def move(i,j):
            if not 0<=i<m or not 0<=j<n or board[i][j]!=0:
                return 0
            if board[i][j]==0: board[i][j]=1
            return 1+move(i+1,j) + move(i-1,j) + move(i,j+1) + move(i,j-1)
        return move(0,0)

$return1+move(i+1,j)+move(i-1,j)+move(i,j+1)+move(i,j-1)$的含义要理解

美团笔试题1

给定一个整数数组，返回一个数组。该返回数组中第i个数字为，原数组中第i个位置的数字至少往右走多少步才能遇到比它大的数字。如果遇不到或者已经处于最右的位置，则置为-1。

List=[91,10,3,22,40]
stack=[]
for j in range(len(List)):
    if len(stack)==0 or List[stack[-1]]>List[j]:
        stack.extend([j])
    else:
        while List[j]>List[stack[-1]]:
            List[stack[-1]]=j-stack[-1]
            stack.pop()
        stack.extend([j])
while len(stack)>=1:
    List[stack.pop()]=-1
for item in List:
    print(item,'\n')

知识点：数据结构–单调栈

美团笔试题目2

一个正整数N可以分解为M(M>1)个正整数的和，即N=K+L，例如N=5、M=2时可以分解为(1+4,2+3)。
给定一个正整数N(1<N<200)及正整数M(1<M<200)，求有多少种可能的分解组合(注：K+L和L+K算一种)

待解决

网易笔试题目1

小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付x元的房屋租金。当前小易手中已经有f个水果和d元钱,小易也能去商店购买一些水果,商店每个水果售卖p元。小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。

解法：分两种情况

1. 不需要买水果
2. 需要买水果

import sys, math
for line in sys.stdin:
    inputItem=[int(i) for i in line.split()]
    priceRent,haveFruit,money,priceFruit=inputItem
    # 不需要卖水果
    if math.floor(money/priceRent)<=haveFruit:
        print(math.floor(money/priceRent))
    else:
        day=math.floor((money-haveFruit*priceRent)/(priceRent+priceFruit))+haveFruit
        print(day)

堆棋子

小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.
输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数
第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9)
第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)
输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格

曼哈顿距离的思想

球盒问题

放球问题在组合数学中是一个经典问题，在ACM比赛中也经常会出现类似的题目，这里做一个归纳。
参考1
参考2

实现快速排序遇到的问题

def swap(arr,i,j):
        temp=arr[i]
        arr[i]=arr[j]
        arr[j]=temp
    def Qsort(arr,low,high):
        i,j=low,high
        if low>=high:
            return
        while (i<j):
            pivot=arr[i]
            while j>i and arr[j]>=pivot:
                j=j-1
            swap(arr,i,j)
            while i<j and arr[i]<=pivot:
                i=i+1
            swap(arr,i,j)
        Qsort(arr,low,i-1)
        Qsort(arr,i+1,high)

注意程序中

while j>i and arr[j]>=pivot: 判断符应为 >=
	...
while i<j and arr[i]<=pivot: 判断符应为 <=
	...

否则遇到 如 [0,1,2,1] 例子时，i=1,j=3, 陷入死循环。 ** 为了程序正常运行，相同元素也要交换顺序，这也是快速排序不稳定的原因 **

大数求余运算

https://leetcode-cn.com/problems/jian-sheng-zi-ii-lcof/solution/mian-shi-ti-14-ii-jian-sheng-zi-iitan-xin-er-fen-f/

第 $k$ 个排列

寻找第$k$个排列，等价于寻找有序排列的下标为$k-1$的排列，这样就可以与整除运算兼容，简化程序复杂度。

def getPermutation(self, n, k):
    """
    :type n: int
    :type k: int
    :rtype: str
    """
    k-=1 # 理解为寻找第k个数，下标为k-1
    from math import factorial
    index = 0
    nums = [i for i in range(1, n + 1)]
    elements = []
    while index < n:
        ind = k // factorial(n - 1 - index)
        elements.append(str(nums.pop(ind)))
        k = k -ind * factorial(n - 1 - index)
        index += 1
    return ''.join(elements)