2021-03-13表示数值的字符串 字符串的排列 剪绳子 在排序树组中查找数字I 丑数 扑克牌中的顺子 最近公共祖先 字符串转整数 剪绳子II 构建乘积数组 二进制中1的个数

class Solution {
    public boolean isNumber(String s) {
        if(s == null || s.length() == 0) return false;
        boolean isnum = false, isdot = false, iseE = false;
        if(s.trim().length()==0){
            return false;
        }
        char[] str = s.trim().toCharArray();
        int len = str.length;
        for(int i=0; i<len; i++){
            if(str[i]>='0'&&str[i]<='9'){
                isnum = true;
            }
            else if(str[i]=='.'){
                if(isdot==true||iseE==true){
                    return false;
                }
                isdot = true;
            }
            else if(str[i]=='e'||str[i]=='E'){
                if(isnum==false||iseE==true){
                    return false;
                }
                iseE=true;
                isnum = false;
            }
            else if(str[i]=='+'||str[i]=='-'){
                if(i!=0 && str[i-1] != 'E' && str[i-1]!='e'){
                    return false;
                }
            }
            else{
                return false;
            }
        }
        return isnum;
    }
}

class Solution {
    List<String> res = new LinkedList<>();
    char[] c;
    public String[] permutation(String s) {
        c = s.toCharArray();
        dfs(0);
        return res.toArray(new String[res.size()]);
    }
    void dfs(int x) {
        if(x == c.length - 1) {
            res.add(String.valueOf(c));      // 添加排列方案
            return;
        }
        HashSet<Character> set = new HashSet<>();
        for(int i = x; i < c.length; i++) {
            if(set.contains(c[i])) continue; // 重复，因此剪枝
            set.add(c[i]);
            swap(i, x);                      // 交换，将 c[i] 固定在第 x 位
            dfs(x + 1);                      // 开启固定第 x + 1 位字符
            swap(i, x);                      // 恢复交换
        }
    }
    void swap(int a, int b) {
        char tmp = c[a];
        c[a] = c[b];
        c[b] = tmp;
    }
}

class Solution {
    public int cuttingRope(int n) {
        if(n <= 3) return n - 1;
        int a = n / 3, b = n % 3;
        if(b == 0) return (int)Math.pow(3, a);
        if(b == 1) return (int)Math.pow(3, a - 1) * 4;
        return (int)Math.pow(3, a) * 2;
    }
}

考虑的问题：
二分查找找到了几个相同元素中间怎么确定 ，实际上可以通过寻找元素target+1的第一个位置

实际上找的是>target的第一个元素的位置，所以
实际target找的是target+1第一个元素的位置
target-1找的是target的第一个元素的位置

class Solution {
    public int search(int[] nums, int target) {
        return helper(nums, target) - helper(nums, target - 1);
    }
    int helper(int[] nums, int tar) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= tar) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}

class Solution {
    public int nthUglyNumber(int n) {
        int p2=0,p3=0,p5=0;
        int[] dp=new int[n];
        dp[0]=1;
        for(int i=1;i<n;i++){
            dp[i]=Math.min(dp[p2]*2,Math.min(dp[p3]*3,dp[p5]*5));
            if(dp[i]==dp[p2]*2) p2++;
            if(dp[i]==dp[p3]*3) p3++;
            if(dp[i]==dp[p5]*5) p5++; 
        }
        return dp[n-1];
    }
    // 一个十分巧妙的动态规划问题
    // 1.我们将前面求得的丑数记录下来，后面的丑数就是前面的丑数*2，*3，*5
    // 2.但是问题来了，我怎么确定已知前面k-1个丑数，我怎么确定第k个丑数呢
    // 3.采取用三个指针的方法，p2,p3,p5
    // 4.index2指向的数字下一次永远*2，p3指向的数字下一次永远*3，p5指向的数字永远*5
    // 5.我们从2*p2 3*p3 5*p5选取最小的一个数字，作为第k个丑数
    // 6.如果第K个丑数==2*p2，也就是说前面0-p2个丑数*2不可能产生比第K个丑数更大的丑数了，所以p2++
    // 7.p3,p5同理
    // 8.返回第n个丑数

}

信息：统计最大值与最小值和0的个数，
当最大值与最小值之间没有重复数出现，且最大值-最小值差<5时，说明可以构成顺子
构成方式有两种： 直接是顺子，可以用癞子顶
class Solution {
    public boolean isStraight(int[] nums) {
        int joker = 0;
        Arrays.sort(nums); // 数组排序
        for(int i = 0; i < 4; i++) {
            if(nums[i] == 0) joker++; // 统计大小王数量
            else if(nums[i] == nums[i + 1]) return false; // 若有重复，提前返回 false
        }
        return nums[4] - nums[joker] < 5; // 最大牌 - 最小牌 < 5 则可构成顺子
    }
}

n&n-1会使得最后一位置0，统计一共置0的次数，直到n为0为止
public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int count = 0;
        while(n!=0){
            n&=n-1;
            count++;
        }
        return count;
    }
}

class Solution {
    public int[] constructArr(int[] a) {
        if (a == null || a.length <= 0) {
            return new int[0];
        }

        int[] b = new int[a.length];
        b[0] = 1;   // 先给第一个元素赋值为 1，以便之后的 左边界操作

        /*
            先给 当前元素 乘以 左边界（之前的元素）
        */
        for (int i = 1; i < a.length; i++) {
            b[i] = b[i - 1] * a[i - 1];
        }

        /*
            再给 当前元素 乘以 右边界（之后的元素）
            因为b[a.length-1]右侧没有元素，所以第二次循环不需要从a.length-1开始，因此开始为a.length-1
        */
        int temp = 1;
        for (int i = a.length - 2; i >= 0; i--) {
            temp *= a[i + 1];
            b[i] *= temp;
        }

        return b;
    }
}



class Solution {
    public int[] constructArr(int[] a) {
        int len = a.length;`在这里插入代码片`
        if(len==0){
            return  new int[len];
        }
        int[] b = new int[len];
        b[0] = 1;
        for(int i=1; i<len; i++){
            b[i] = b[i-1] * a[i-1];
        }
        int temp = 1;
        for(int i=len-2; i>=0; i--){
            temp *= a[i+1];
            b[i] *= temp;
        }
        return b;
    }
}

class Solution {
    public int cuttingRope(int n) {
        if(n <= 3) return n - 1;
        long res=1L;
        int p=(int)1e9+7;
        //贪心算法，优先切三，其次切二
        while(n>4){
            res=res*3%p;
            n-=3;
        }
        //出来循环只有三种情况，分别是n=2、3、4
        return (int)(res*n%p);
    }
}

class Solution {
    public int strToInt(String str) {
        char[] ret = str.trim().toCharArray();
        if(ret.length == 0){
            return 0;
        }
        int sign = 1;
        int bdny = Integer.MAX_VALUE/10;
        int i=0;
        if(ret[0]=='-'){
            sign = -1;
            i = 1;
        }
        if(ret[0]=='+'){
            sign = 1;
            i = 1;
        }
        int ans = 0;
        for(int j=i; j<ret.length; j++){
            if(ret[j]<'0'||ret[j]>'9'){
                break;
            }
            if(ans > bdny || (ans==bdny && ret[j]>'7')){
                return sign==1?Integer.MAX_VALUE:Integer.MIN_VALUE;
            }
            ans = ans*10 + ret[j] - '0';
        }
        return sign*ans;

    }
}

刚做完又忘了
递归
用&&作为递归终止条件，当左边成立，则需要执行右边进行递归，
当左边不成立，由于&&的存在，不会执行右边，直接进行下一步的运算
class Solution {
    public int sumNums(int n) {
        boolean x=n>1 && (n += sumNums(n-1))>0;
        return n;
    }
}

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        TreeNode ancestor = root;
        while(true){
            if (p.val < ancestor.val && q.val < ancestor.val) {
                ancestor = ancestor.left;
            } else if (p.val > ancestor.val && q.val > ancestor.val) {
                ancestor = ancestor.right;
            } else {
                break;
            }
        }
        return ancestor;

    }
}