力扣119心得(仅是心得，不讲解，也就是我自己看，持续更新)

LCR 001.两数相除

注意结果溢出，将被除数和除数都变为负数，就不会有溢出的问题

快速幂

class Solution{
public:
    double quickMul(double x,long long N){//递归
        if(N==0){
            return 1.0;//0次幂为1
        }
        double y=quickMul(x,N/2);
        return N%2 ==0 ? y*y : y*y*x;
    }
    
    double myPow(double x,int n){
        long long N=n;
        return N>=0 ?quick(x,N) : 1.0/quickMul(x,-N);//负数返回倒数
    }
}

快速乘

auto quickAdd=[](int y,int z,int x)
{
    //x和y是负数，z是正数
    //需要判断z*y>=x是否成立
    int result=0,add=y;
    while(z)
    {
        if(z&1)
        {//需要保证result+add>=x
            if(result<x-add)
            {
                return false;
            }
            result+=add;

        }
        if(z!=1)
    {//需要保证add+add>=x
        if(add<x-add)
        {
            return false;
        }
        add+=add;

    }
    //不能使用除法
    z>>=1;
    }
    return true;
    

};

auto quickAdd =[](int y,int z,int x)是C++11以后的版本引入的特性

定义一个名为 quickAdd 的变量，该变量是一个函数对象（由lambda表达式创建），该函数对象接受三个整数类型的参数，并根据这些参数执行一些操作后返回一个布尔值。这个lambda表达式的具体行为（即它如何根据输入参数计算返回值）由lambda表达式内的函数体定义。

方法一：将除法转换为乘法X/Y->Z(注意X和Y都为负数)

即找到最大的Z满足Z*Y>=X，进而通过快速乘得出结果

通过二分法找到Z;

int mid=left+((right-left)>>1)

不能使用除法，右移一位实现除以2的操作

初刷力扣真是啥也不会啊 呜呜呜呜，一道题看半天。。。。。。

LCR 002 二进制求和

可以对二进制进位进行模拟，逢二进一

这道题还算比较简单😋

size_t:表示无符号数，其大小足以保证存储内存中对象的大小

注意字符要加上' '

LCR 003.比特位计数

投机取巧哈哈哈哈哈哈哈哈(bushi)

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> v;
        for(int i=0;i<=n;i++)
        {
            int num=__builtin_popcount(i);
            v.push_back(num);
        }
        return v;
    }
};

Brian Kernighan算法

对于任意整数 x，令 x=x & (x−1)，该运算将 x 的二进制表示的最后一个 1 变成 0。因此，对 x 重复该操作，直到 x 变成 0，则操作次数即为 x 的「一比特数」。

x&=(x-1);

动态规划还没学就先不看了

LCR004.只出现一次的数字

哈希哈嘻

初始：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        unordered_map<int,int> m;
        int len=nums.size();
        for(int num:nums)
        {
            m[num]++;
        }
        int ans=0;
        for(int i=0;i<len;i++)
        {
            int occ=m[nums[i]];
            if(occ==1)
            {
                ans=nums[i];
                break;
            }
        }
        return ans;
    }
};

优化：结构化绑定

for(auto [num,occ]:m)
        {
            if(occ==1)
            {
                ans=num;
                break;
            }
        }

C++17引入结构化绑定这一用法。上述代码直接将m中的每个元素解包为num和occ，使得我们可以直接访问他们，无需额外的解构或访问步骤。

力扣题解牛逼，都干出数字电路设计了

二进制位

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans=0;
        for(int i=0;i<32;i++)
        {
            int total=0;
            for(int num:nums)
            {
                total+=((num>>i)&1);
            }
            if(total%3)
            {
                ans|=(1<<i);
            }
        }
        return ans;
    }
};

关键性语句：

total+=((num>>i)&1);将数字num向右移动i位,&1检查最右边的那一位是否为1

ans|=(1<<i);按位或赋值

LCR 005.最大单词长度乘积

位运算：

int maxProduct(vector<string>& words) {
        int len=words.size();
        vector<int> num(len);
        for(int i=0;i<len;i++)
        {
            int wordlen=words[i].size();
            string str=words[i];
            for(int j=0;j<wordlen;j++)
            {
                num[i]|=1<<(str[j]-'a');
            }
        }
        int maxch=0;
        for(int i=0;i<len-1;i++)
        {
            for(int j=i+1;j<len;j++)
            {
                if((num[i]&num[j])==0)
                {
                    maxch=max(maxch,int(words[i].size()*words[j].size()));
                }
            }
        }
        return maxch;
    }

int(words[i].size()*words[j].size())注意转化成int类型

LCR 006.两数之和

使用双指针还是比较简单的