leetcode位运算专题

最新推荐文章于 2022-04-10 21:09:01 发布
最新推荐文章于 2022-04-10 21:09:01 发布
阅读量301 收藏 1
点赞数
分类专栏： 练习题记录 文章标签： leetcode 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foreverboss/article/details/106201456
版权

前篇知识：

位运算得用途：

&运算

一个数 and 1的结果就是取二进制的最末位，用于判断数得奇偶性

一个数and 该数的负数，保留位中最右边 1 ，且将其余的 1 设位 0 

|运算

可以给二进制指定位置得值变成1，例如or 1，就是把最末位改成1，然后再减一就是0。这样可以这个数强行变成最接近的偶数。当然or (1 << n)就是末位得前 n  - 1 位变成1。

^运算

两次异或同一个数最后结果不变，即（a xor b) xor b = a。这样可以用来加密文件，把a当作目标值，b当作密钥，c（a^b）为加密值

a xor a = 0;

0 xor a = a;

 

交换a，b值

a:=a xor b;

b:=a xor b;

a:=a xor b;

~运算

如果not的对象是无符号整数（不能表示负数），那么得到的值就是它与该类型上界的差，即-res = ~res + 1

<< 和 >>运算

<<二进制数向左移动多少位  >>向右移动多少位

或运算的最小翻转次数

题目：

给你三个正整数 a、b 和 c。

你可以对 a 和 b 的二进制表示进行位翻转操作，返回能够使按位或运算   a OR b == c  成立的最小翻转次数。

「位翻转操作」是指将一个数的二进制表示任何单个位上的 1 变成 0 或者 0 变成 1 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

每个位置的求值之间没有存在联系，对比每个二进制各个位中得位数，不用管a，b，c变成多少，只要翻转得最小次数即可。

代码：

class Solution {
public:
    int minFlips(int a, int b, int c) {
        int res=0;
        while(c!=0 || b!=0 || a!=0) {    //易略点1
            int n1=a%2,n2=b%2,n3=c%2;
            if( (n1 | n2) != n3) {    //难点1
                if(n3 == 1) {
                    res++;
                } else if(n1==0 || n2==0) {
                    res++;
                } else {
                    res+=2;
                }
            }
            a = a >> 1;
            b = b >> 1;
            c = c >> 1;
        }
        return res;
    }
};

总结：

易略点1：这里我们对a，b，c进行判断，不能只对单一数进行判断就跳出循环，因为三个数得位数量可能不同

难点1：如果n1，n2之间没有括号，这时得优先级就不对，表达式中会先计算n2！=n3，再计算n1得或运算

 

只出现一次的数字 III

题目：

给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

能AC很简单，直接使用map即可。但是要用位运算就很难了

代码：

map方法：

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        map<int,int> mii;
        vector<int> res;
        for(int i=0;i<nums.size();i++) {
            mii[nums[i]]++;
        }
        map<int,int>::iterator iter;
        for(iter=mii.begin();iter!=mii.end();iter++) {
            if(iter->second == 1) {
                res.push_back(iter->first);
            }
            if(res.size()==2) {
                return res;
            }
        }
        return res;
    }
};

位运算法1：

//优化leetcode上的输入输出
static const auto _ = [](){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return nullptr;
}();

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        int xorVal=0;
        for(int num : nums) xorVal ^= num;  //难点1
        int diff = xorVal & (-xorval);    //难点2
        int a=0 , b=0;
        for(int val : nums) {
            //难点3
            if(val & diff) a ^= val;
            else b ^= val;
        }
        return {a,b};
    }
};

位运算2：

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        int res = 0;
        for(int num : nums) res ^= num;
        int x = 0, diff = res & (-res);
        for(int num : nums) {
            if(num & diff) x ^= num;
        }
        return vector<int>{x, res ^ x};    //难点4
    }
};

总结：

map方法没啥好说的，就是map[数值]=出现次数，这个方法时间空间复杂度都比位运算大

难点1：题目中只存在2个不同数，同一个数 xor 该数为 0，0 xor 任何数为该数，所以xorVal值为2个不同数的异或运算值

难点2：求得xorVal中第一次出现1的位置，例如 xorVal = 276（1010100），那么diff = 0000100 

难点3：用diff进行分类，假设两个不同数为a、b，val & diff中，a，b在diff位上的数一定是不同的，所以就可以进行分类。

res求出了两个唯一数的不同位数，我们以最右边出现1的位置来记作标识位 diff 来进行分类

难点4：第二种方法和第一个方法类似，就是使用的（a xor b) xor b = a 来求值，res为a ^ b ，只要求出a，即可得到b

 

得分最高的单词集合

题目：

你将会得到一份单词表 words，一个字母表 letters （可能会有重复字母），以及每个字母对应的得分情况表 score。

请你帮忙计算玩家在单词拼写游戏中所能获得的「最高得分」：能够由 letters 里的字母拼写出的 任意 属于 words 单词子集中，分数最高的单词集合的得分。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

1.回溯法：

使用递归思路，每个单词就是选择与不选的关系，然后我们就分别求出该单词选与不选的大小，对于后面的就使用递归函数计算，最后就是比较选与不选的大小进行返回

2.位压缩法：

规则：二进制位数为0，表示不使用该单词，反则使用。一共有(1 << words.size() )种情况，对于第i 种情况，使用 i & (1 << j )验证在i情况中，第 j 个单词有没有被使用到。用来求得这种情况符不符合题目条件

3.动态规划法：

这个就是最直观得方法，就是对于每个letter字典中有得字符都加上求值，若在中间发现不符合条件后，就再使用循环来回溯为原始状态。思路简单但是需要注意得细节很多

代码：

1.回溯法：

class Solution {
public:
    int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
        vector<int> m(26);
        for(int i=0;i<letters.size();i++) {
            m[letters[i]-'a']++;
        }
        return backtrack(0 , m , words , score);
    }
    int backtrack(int index , vector<int> &m , vector<string>& words , vector<int>& score) {
            if(index >= words.size()) return 0;
            vector<int> t(m);
            int ret = spell(t , words[index] , score);
            int left = ret==0 ? 0 : ret + backtrack(index+1 , t , words , score);
            int right = backtrack(index+1 , m , words , score);
            return max(left , right);
    }
    int spell(vector<int> &t , string str , vector<int>& score) {
        int res=0;
        for(char c : str) {
            if(!t[c - 'a'])  return 0;
            res += score[c - 'a'];
            t[c - 'a']--;
        }
        return res;
    }
};

2.位压缩法：

class Solution {
public:
    vector<int> group(vector<string> &words , int bit) {
        vector<int> g(26,0);
        for(int i=0;i<words.size();i++) {
            if(! (bit & (1 << i)) ) continue;
            for(char c : words[i]) {
                g[c - 'a']++;
            }
        }
        return g;
    }

    int calaScore(vector<int> &group , vector<int> &letterscnt , vector<int>& score) {
        int res=0;
        for(int i=0;i<26;i++) {
            if(letterscnt[i] < group[i]) return 0;
            res += group[i] * score[i];
        }
        return res;
    }

    int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
        vector<int> letterscnt(26,0);
        int res=0;
        for(int i=0;i<letters.size();i++) {
            letterscnt[letters[i] - 'a']++;
        }
        for(int i=0;i< (1 << words.size() ); i++) {
            auto g = group(words , i);
            res = max(res , calaScore(g , letterscnt , score));
        }
        return res;
    }
};

3.动态规划法：

int lines[26],nums[26];
class Solution {
public:
    int res=0;
    int maxScoreWords(vector<string>& words, vector<char>& letters, vector<int>& score) {
        //memset(lines, 0, sizeof(lines));
        //memset(nums, 0, sizeof(nums));
        for(int i=0;i<letters.size();i++) {
            lines[letters[i] - 'a']++;
        }
        dfs(0 , score , words , 0);
        return res;
    }

    void dfs(int p , vector<int> &score , vector<string> &words,int s) {
        res = max(res , s);
        while(p < words.size()) {
            bool flag = true;
            int news = s;
            for(char c : words[p]) {
                int ch = c - 'a';
                news += score[ch];
                if(++nums[ch] > lines[ch])  flag = false;
            }
            if(flag) {
                dfs(p + 1 , score , words , news);
            }
            for(char c : words[p])   nums[c - 'a']--;
            p++;
        }
    }
};

 

UTF-8 编码验证

题目：

UTF-8 中的一个字符可能的长度为 1 到 4 字节，遵循以下的规则：

对于 1 字节的字符，字节的第一位设为0，后面7位为这个符号的unicode码。
对于 n 字节的字符 (n > 1)，第一个字节的前 n 位都设为1，第 n+1 位设为0，后面字节的前两位一律设为10。剩下的没有提及的二进制位，全部为这个符号的unicode码。

输入是整数数组。只有每个整数的最低 8 个有效位用来存储数据。这意味着每个整数只表示 1 字节的数据。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/utf-8-validation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

1.字符串法：

思路很简单，就是把十进制整数转化成二进制得字符串类型，然后在第一个数判断0得位置，以后得数判断是否以10开头即可

2.位运算法：

位运算就使用到了&操作来判断第一个数的头部有多少个1，然后一样用&操作判断以后得数判断是否以10开头。

代码：

1.字符串法：

class Solution {
    public boolean validUtf8(int[] data) {
        int res=0;
        for(int n : data) {
            //String bir = Integer.toBinayString(n);
            String bir = Integer.toBinaryString(n);     
            bir = bir.length() >= 8 ? bir.substring(bir.length()-8) : "00000000".substring(8 - bir.length()) +  bir;    //易错点1
            if( res == 0 ) {
                for(int i=0;i<bir.length();i++) {
                    if(bir.charAt(i) == '0')    break;
                    res++;
                }
                if(res == 0)    continue;       //易漏点1
                if(res > 4 || res == 1)     return false;
            } else {
                if(! (bir.charAt(0) == '1' && bir.charAt(1) == '0'))    return false;
            }
            res--;      //易错点2
        }
        return res == 0;
    }
}

2.位运算法：

class Solution {
public:
    bool validUtf8(vector<int>& data) {
        int res = 0;
        for(int n : data) {
            if(res == 0) {
                int mask1 = 1 << 7;
                while(mask1 & n) {
                    res++;
                    mask1 >>= 1;        //易错点1
                }
                if(res == 0)    continue;
                if(res > 4 || res == 1)     return false;
            } else {
                //int mask1 = 1 << 7 , mask2 = 1 << 6;      优化
                if( (!((n & (1 << 7)) != 0 && (n & (1 << 6)) == 0)) )     return false;
            }
            res--;
        }
        return res == 0;
    }
};

总结：

第一个方法用的是java编写代码，因为java更加方便，有一些直接符合题意得源函数

1.字符串法：

易错点1：length()方法是针对字符串得，length属性是针对数组得。当不足8位时，需要在前面补0。补位数量也可以使用（bir.length() % 8）

易漏点1：边界情况：若数组以若干个0开头，直接跳过即可

易错点2：字节数得计算，不要忘记了在第一个数计算完后，也要减一。

2.位运算法：

易错点1：mask1对num从左到右判断1得数量，所以循环条件应该是mask>>1

 

插入

题目：

给定两个32位的整数N与M，以及表示比特位置的i与j。编写一种方法，将M插入N，使得M从N的第j位开始，到第i位结束。假定从j位到i位足以容纳M。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/insert-into-bits-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

只要把N 的 i到j位全部重置然后加上M << i 即可

代码：

class Solution {
public:
    int insertBits(int N, int M, int i, int j) {
        for(int k = i;k <= j; k++) {
            if(N & (1 << k))    N -= (1 << k);
        }
        N += (M << i);
        return N;
    }
};
class Solution {
public:
    int insertBits(int N, int M, int i, int j) {
        int temp = (1 << (j - i + 1)) - 1 << i;
        return (N & ~temp) | M << i;
    }
};

总结：

1.我们先考虑会不会溢出的问题，例如1143207437 1017033 11 31，可以看出我们是在N位上替换成M的数，所以不存在溢出INT_MAX的情况。

2.把N 的 i到j位全部重置的方法，当然我们可以像第一个代码一样使用循环，用&运算判断是否为1，再减去即可。但是用"00..00"&N来重置更加快捷。

幂集

题目：

编写一种方法，返回某集合的所有子集。集合中不包含重复的元素。

思路：

1.回溯法：

num：记录一个集合的数量，以此为结束回溯的条件。每次都在上次回溯的基础上添加新的元素

2.位运算法：

一共有1<<nums.size()种情况，一样的每一个元素都是只有选与不选。用&运算来做选择条件

代码：

1.回溯法：

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        return backtrack(nums , 0);
    }
    vector<vector<int>> backtrack(vector<int> &nums , int num) {
        if(num >= nums.size())  return {{}};
        vector<vector<int>> ivec = backtrack(nums , num+1);
        int sz = ivec.size();
        for(int i=0; i<sz; i++) {
            vector<int> vec = ivec[i];
            vec.push_back(nums[num]);
            ivec.push_back(vec);
        }
        return ivec;
    }
};

2.位运算法：

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        const int sz = nums.size();
        const int binCount = 1 << sz;

        vector<vector<int>> res;
        vector<int> vec;

        for(int i=0; i<binCount; i++) {
            for(int j=0;j<sz;j++) 
                if((i >> j) & 1)    vec.push_back(nums[j]);
            res.push_back(vec);
            vec.clear();
        }
        
        return res;
    }
};

总结：

回溯法没啥好说的，就是逻辑问题，什么时候以什么参数来完成回溯条件。

在回溯法转化位运算法中，都是用 1 << size 来记录一共有多少种情况，然后根据题意使用& 或者 | 运算来完成运算。 

 

子数组按位或操作

题目：

我们有一个非负整数数组 A。

对于每个（连续的）子数组 B = [A[i], A[i+1], ..., A[j]] （ i <= j），我们对 B 中的每个元素进行按位或操作，获得结果 A[i] | A[i+1] | ... | A[j]。

返回可能结果的数量。 （多次出现的结果在最终答案中仅计算一次。）

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/bitwise-ors-of-subarrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

求出每个子集全部的或操作，直接暴力法简单，但是要使用剪枝技巧来提高效率。

代码：

class Solution {
public:
    int subarrayBitwiseORs(vector<int>& A) {
        int sz = A.size();
        unordered_set<int> res;
        if(sz < 2) return sz;

        for(int i = 0; i < sz; i++) {
            res.insert(A[i]);
            for(int j = i - 1; j >= 0; j--) {
                if((A[j] | A[i]) == A[j])   break;        //剪枝条件
                A[j] |= A[i];
                res.insert(A[j]);
            }
        }
        return res.size();
    }
};

总结：

 

 

字母大小写全排列

题目：

给定一个字符串S，通过将字符串S中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。

思路：

在前面已经修改好了的基础上，每次改变一个字母，以达到递归的效果

代码：

class Solution {
public:
    vector<string> letterCasePermutation(string S) {
        vector<string> res{S};
        for(int i = 0; i<S.size(); i++) {
            if(isalpha(S[i])) {
                for(int j = res.size()-1; j >= 0;j--) {
                    res.push_back(res[j]);
                    if(isupper(res[j][i]))  res[j][i] = tolower(res[j][i]);
                    else    res[j][i] = toupper(res[j][i]);
                }
            }
        }
        return res;
    }
};

总结：

思路很简单，循环体的条件定义和什么时候添加string。这题与位运算好像没啥关系，但是这个代码编写一开始没有想到，所以也记录一下。

 

 

foreveryao123
关注
专栏目录
【LeetCode系列】位运算专题
qq_36417014的博客
12-09 438
位运算专题 目录 位运算专题 LeetCode 231 2的幂 1、分析 2、代码 LeetCode 762 二进制表示中质数个数计算置位 1、分析 LeetCode 136 只出现一次的数 1、分析 2、 代码 LeetCode 476 数字的补数 1、分析 2、代码 LeetCode 137 只出现一次的数字II 1、分析 2、代码 LeetCode 260...
Python 刷题笔记：位运算专题一
TEDxPY
05-09 457
学 Python 初接触 &、| 等运算符时，只大概了解它们被称为位运算符，并不同于逻辑运算符 and、or，今天就通过基础知识点和几道题目来熟悉下。 知识点 我们都知道所有数值在计算机底层是以二进制形式存在的，首先要明确几个概念： 原码：直接将一个数值转化为二进制，其首位代表符号，0 为正 1 为负 反码：最高位符号位不变，其余为取反，即 1 变 0、0 变 1 补码：正数的补码与原码相同；负数的补码为其反码 +1 以正数 4 和负数 -5 为例，其 32 位二进制形式如下： 关键点来了，我
leetcode位运算
qq_42920313的博客
08-21 604
1.位运算 &与 |或 ^异或 ～取反 <<左移 ">>"有符号右移 ">>>"无符号右移 2.有符号整数和无符号整数 0000 1010 正数 1000 1010 负数 第一位为符号位，正数的符号位为0，负数的符号位为1 byte 8位 short 16位 int 32位 long 64位 -->有符号整数 整数一般使用补码表示 3.原码、反码、补码 原码 10: 00000000 00000000 00000000 00001010 -10: 1
LeetCode总结 -- 位运算篇
Code Ganker
09-10 9954
位运算一直编程和面试中的一个必须准备的主题。 不过现在面试中关于位运算的出现得不多，主要原因还是位运算太考察技巧了，很多时候很难在短时间内想出来，所以作为面试的题目显得有点太花时间了。LeetCode中关于位运算的题目有以下几道：Single NumberSingle Number IIDivide Two IntegersPow(x, n)先来说说Single Number， 这应该LeetCo
leetcode136.只出现一次的数字
没有感情的刷题机器
11-25 171
1.题目描述 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明： 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 示例 1: 输入: [2,2,1] 输出: 1 示例2: 输入: [4,1,2,1,2] 输出: 4 2.解题思路 交换律：a ^ b ^ c <=> a ^ c ^ b...
LeetCode——位运算
weixin_42589774的博客
06-19 382
LeetCode——位运算 1、统计两个数的二进制表示有多少位不同 T461 Hamming Distance (Easy) class Solution { public: int hammingDistance(int x, int y) { int res=0; for(int i=0; i<32; ++i){ if(x & (1<<i) ^ y & (1<<i)){
leetcode-位运算
许诗宇的博客
10-18 379
leetcode-191-位1的个数(number of one bits)-java 与1与运算，为1为奇数，为0位偶数 之后n&amp;amp;gt;&amp;amp;gt;2，相当于/2 将&amp;amp;gt;&amp;amp;gt;改为&amp;amp;gt;&amp;amp;gt;&amp;amp;gt;因为&amp;amp;gt;&amp;amp;gt;如果全为1（也就是-1）的话0不会填位，而&amp;a
位运算专题
WMXNLFD的博客
06-04 242
LeetCode 231. Power of Two 给定一个整数，编写一个函数来判断它是否是 2 的幂次方。 示例 1: 输入: 1 输出: true 解释: 20 = 1 示例 2: 输入: 16 输出: true 解释: 24 = 16 示例 3: 输入: 218 输出: false /* & | ^ 异或 相同为0 不同为1 相当于加法 0^0 0 1 0 1 0 1 1 1...
leetcode递归专题-leetcode:不定期发布leetcode解题思路和代码
06-30
位运算 并查集 二分 数组 滑动窗口 递归 字符串 栈与队列（单调栈） 堆 树状数组、线段树 跳表 哈希链表 水池抽样 milestone 2020年6月9日，800题 √ 2020年6月21日，在这个特别的日子里（不仅仅是Eclipse），完成度...
Python 刷题笔记：位运算专题二
TEDxPY
05-10 505
昨天笔记里对原码、反码、补码的描述有误，这里更正下： 正数三码相同，负数的反码才会除了首位符号位不变、其余位取反。位运算都是基于数字的补码来进行运算的。 昨天题目中代码结尾处有个特殊处理没来得及验证，今天细说下： 由于 Python 3 中整数是动态长度，并不是像其它语言中一般被限制到 32 位，所以通常如果涉及到复杂些的位运算，会通过整除一个 33 位的首位为 1、其余位全部为 0 的数来限制到 32 位——而这个除数在十进制中也就是 2 的 32 次方、用 16 进制则表示为 0x100000000，
【LeetCode】位运算
bobshui的博客
02-09 5840
最近刷了几道算法题，有一些是和位运算有关的，虽然位运算在源码中较多的出现，但个人仍认为其实操意义不大。不过不得不说，基于位运算的一些算法处理，有时候确实很神奇。因此做一个记录。
LeetCode--位运算篇
Free的午后
08-22 740
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 位运算 基本原理 0s 表示一串 0，1s 表示一串 1。 x ^ 0s = x x & 0s = 0 x | 0s = x x ^ 1s = ~x x & 1s = x x | 1s = 1s x ^ x = 0 x & x = x x | x = x 位与运算技巧 n&(n-1) 去除 n 的位级表示中最.
leetcode 位运算小结
SanfordZhu的博客
05-24 1521
leetcode 136 只出现一次的数字 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明： 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 示例 1: 输入: [2,2,1] 输出: 1 示例2: 输入: [4,1,2,1,2] 输出: 4 解题思路： 异或的计算性质：2 ^ 3 ^ 2 ^...
LeetCode 位运算操作集锦（一）
玉界尺的博客
06-01 938
大家好，我是刘天昊，这次给大家带来的是leetcode中位运算的操作集锦 那么一次放出三题，并且我会总结其中的位运算的操作 那么直接开始（推荐直接在leetcode上找题目，先做做看再看我的blog，要有自己思考的过程） 36. Valid Sudoku Determine if a Sudoku is valid, according to: Sudoku Puzzles -
LeetCode常见题型——位运算
贫道绝缘子的博客
04-10 543
位运算是算法题里比较特殊的一种类型，它们利用二进制位运算的特性进行一些奇妙的优化 和计算。
常见位运算总结及LeetCode相关题目
NayelyA的博客
05-07 714
文章目录常见的位运算**1.位操作实现乘除法****2.位操作交换两个数****3.位操作判断奇偶****4.位操作交换符号****5.位操作求绝对值****6.位操作进行高低位交换****7.位操作进行二进制逆序****8.位操作统计二进制中1的个数****9.a^b^b=a**相关题目**[231. 2的幂](https://leetcode-cn.com/problems/power-of-...
《位运算技巧以及Leetcode的一些位运算题目》
hanhan的博客
04-27 892
技巧 位运算的一些基础技巧： x ^ 0... = x x ^ 1... = ~x x ^ x = 0 x & 0... = 0 x & 1... = x x & x = x x | 0... = x x | 1... = 1... x | x = x 进阶技巧： n & (n-1) 可以去除n的位级表示中最低的一位： 如 n = 11110100 , n - 1 = 11110011 n & (n-1) = 11110000 n & (-
27.位运算（位或）进阶
m0_57210881的博客
01-18 312
题目： 给你三个正整数 a、b 和 c。 你可以对 a 和 b 的二进制表示进行位翻转操作，返回能够使按位或运算 a OR b == c 成立的最小翻转次数。 「位翻转操作」是指将一个数的二进制表示任何单个位上的 1 变成 0 或者 0 变成 1 。 private int 最小翻转次数(int left, int right, int ruselt) { int Count = 0; for (int i = 0; i < 31; i++)
Leetcode :1318. 或运算的最小翻转次数(位运算）
stackempty2的博客
05-24 348
1318. 或运算的最小翻转次数 给你三个正整数 a、b 和 c。 你可以对 a 和 b 的二进制表示进行位翻转操作，返回能够使按位或运算 a OR b == c 成立的最小翻转次数。 「位翻转操作」是指将一个数的二进制表示任何单个位上的 1 变成 0 或者 0 变成 1 。 示例 1： 输入：a = 2, b = 6, c = 5 输出：3 解释：翻转后 a = 1 , b = 4 , c = 5 使得 a OR b == c 示例 2： 输入：a = 4, b = 2, c = 7 输出：1 示例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值