【数据结构与算法】leetcode刷题记录(不同路径+柠檬水找零)------＞动态规划,数学分组,

不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：
        输入：m = 3, n = 7
        输出：28
示例 2：

	    输入：m = 3, n = 2
        输出：3
        解释：
        从左上角开始，总共有 3 条路径可以到达右下角。
        1. 向右 -> 向右 -> 向下
        2. 向右 -> 向下 -> 向右
        3. 向下 -> 向右 -> 向右
示例 3：

        输入：m = 7, n = 3
        输出：28
示例 4：

        输入：m = 3, n = 3
        输出：6

java

数学方法:

分析可得: 机器人从左上角走到右下角共需要走 m + n - 2 次

其中有 m - 1次是向下, n - 1次向右…

所以可得, 共有 c(m+n - 2 中取 m - 1)种 :

化解公式可得c = (m + n - 1)! /(m-1)!(n-1)!

class Solution {
    public int uniquePaths(int m, int n) {
        long res = 1;
        for(int y =1;y<m;y++){
            res = res * n/y;
            n++;
        }
        return (int)res;
    }
}

python

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        res = 1
        y = 1
        while y<m:
            res = res*n / y
            y+=1
            n+=1
        return int(res)

柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。

顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：

        输入：[5,5,5,10,20]
        输出：true
        解释：
        前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
        第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
        第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
        由于所有客户都得到了正确的找零，所以我们输出 true。
示例 2：

        输入：[5,5,10]
        输出：true
        示例 3：

        输入：[10,10]
输出：false
示例 4：

        输入：[5,5,10,10,20]
        输出：false
        解释：
        前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
        对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
        对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
        由于不是每位顾客都得到了正确的找零，所以答案是 false。

java

1.遍历数组

一开始上来声明了一个和输入数组大小相等的boolean型的数组, 用ture表示这张钱已经被找零, 每次比较只寻找10 元和20元,因为5元不用找零,

注意: 再找20元时,既可以找 10 和 5 也可以找 3个5,但是原则上优先10和5就可以更好的找零

    public static boolean lemonadeChange(int[] bills) {
        boolean[] state = new boolean[bills.length];
        for(int i = 0;i<bills.length;i++){
            if(bills[i]==10){
                int cout = 0;
                for(int j = 0;j<i;j++){
                    if(bills[j]==5&&!state[j]){
                        cout++;
                        state[j]=true;
                        break;
                    }
                }
                if(cout==0)return false;
                else continue;
            }
            if(bills[i]==20){
                int coutfive = 0;
                int coutten = 0;
                boolean flag = false;
                for(int j = 0;j<i;j++){
                    if(bills[j]==10&&!state[j]){
                        coutten++;
                        state[j]=true;
                        flag=true;
                        break;
                    }
                }
                for(int j = 0;j<i;j++){
                    if(bills[j]==5&&!state[j]){
                        coutfive++;
                        if(flag){
                            state[j]=true;
                            break;
                        }
                        state[j]=true;
                        if(coutfive>=3){
                            break;
                        }
                    }
                }
                if(coutfive>=3){
                    continue;
                }
                if(coutfive>=1&&coutten>=1){
                    continue;
                }
                else return false;
            }
        }
        return true;
    }

python

2.优化遍历

看了别人的感觉第一次自己是个瓜皮,只用统计每个钱的数量即可,并不用那么麻烦

class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        ten ,five = 0 , 0
        for i in bills:
            if i == 5:
                five+=1
            elif i == 10:
                ten+=1
                five-=1
            else:
                if ten > 0:
                    ten -=1
                    five-=1
                else:
                    five-=3
            if five<0 or ten <0:
                return False
        return True