vector oj题 和 位运算

知识点1：

lowbit(x)

        简介：众所周知，lowbit()操作是算法竞赛中的高级技巧，特别是高级数据结构，线段树的核心，还有什么二进制与位运算题目，而本文就用最通俗易懂的话，来教会大家lowbit的含义。

        含义：lowbit(x)是x的二进制表达式中最低位的1所对应的值。

        一般用于删除重复项上。

        什么意思呢：

        十进制 二进制 最低位的1所对应的值对应的二进制数 最低位的1所对应的值对应的十进制数

        1 1 1 1

        2 10 10 2

        3 111 1 1
        4 100 100 4

        5 101 1 1

        6 110 10 2

        7 111 1 1

        方法：我们得到lowbit的值，只需要得到最后一个1的位置，并且把除了这个位置之外的所有位置全部置成零。然后输出就可以。

        实现代码：

int lowbit(int x)
{
    return x&(-x);
}
long lowbit(long x)
{
    return x&(-x);
}

知识点2：

         将第bit位  置1

    x |= (1<<bit)

        将第bit位  置0

    x &= ~(1<<bit)

        测试bit位是否为1

    (x&= (1<<bit))!= 0

         删除从右边起第一个为1的bit

    A & (A - 1)

        得到所有为1的bit

    ~0

        判断一个数是否是2的幂次方(只有一个bit位为1)：

if(n & n - 1 == 0) return true;
else return false;

        判断一个数是否是4的幂次方

  bool isPowerOfFour(int n) 
    {
           return !(n&(n-1)) && (n&0x55555555);
    }

        判断一个十进制的数转化为二进制时包含的1的个数：

（因为每次N&(N-1)操作都是将n最末尾的1反转为0，因此反转个数即为1的个数）

public int hammingWeight(int n) 
    {
        int sum = 0;
        while(n != 0) 
        {
            sum ++;
            n &= n - 1;         
        }   
        return sum;
    }

---

第一题：杨辉三角

. - 力扣（LeetCode）

第二题：删除重复项

. - 力扣（LeetCode）

第三题：找出只出现一次的数

. - 力扣（LeetCode）

第四题：找出只出现一次的数

. - 力扣（LeetCode）

第一题

class Solution {
public:
    vector<vector<int>> generate(int numRows) 
    {
        vector<vector<int>> vv;
        vv.resize(numRows);
        for(size_t i=0;i<numRows;++i)
        {
                vv[i].resize(i+1,0);
                //每一行的第一个和最后一个置为1
                vv[i][0]=vv[i][i]=1;
        }
        for(size_t i=0;i<vv.size();++i)
        {
            for(size_t j=0 ;j<vv[i].size() ;++j)
            {
                if(vv[i][j]==0)
                {
                    vv[i][j]=vv[i-1][j]+vv[i-1][j-1];
                }
            }   
        }
        return vv;
    }
};

第二题

class Solution {
public:
    int removeDuplicates(vector<int>& nums) 
    {
        int fast=0;
        int slow=0;
        while(fast< nums.size())
        {
            if(nums[fast]!= nums[slow])
            {
                slow++;
                nums[slow]=nums[fast];
            }
            fast++;
        }
        return slow+1;
    }
};

第三题

class Solution {
public:
    long lowbit(long x)
    {
        return x&(-x);
    }

    vector<int> singleNumber(vector<int>& nums)
    {
        int n=0;
        for(auto e:nums)
        {
            n=n^e;
        }
        //int lowbit = n&(-n);//找到n为1的最低的bit位 lowbit()是一个宏
        int n1=0;
        int n2=0;
        for(auto x: nums)
        {
            if((x&lowbit(n)) == lowbit(n))
            {
                n1^=x;
            }
            else
            {
                n2^=x;
            }
        }
        return vector<int>{n1,n2};
    }
};

第四题

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans = 0;
        for (int i = 0; i < 32; ++i) {


            // 统计该每个数字第i个比特位为1的总数
            int total = 0;
            for (int num: nums) {
                total += ((num >> i) & 1);
            }


            // 如果total能够被3整除，说明只出现一次的数字在该位置上一定是0
            // 否则在该位置上一定是1
            if (total % 3) {
                ans |= (1 << i);
            }
        }
        return ans;
    }
};