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;
}
}