算法竞赛进阶指南——位运算

算法竞赛进阶指南——位运算

在m位二进制数中，通常称最低位为第0位，从右到左以此类推，最高位是第m-1位

补码：

unsigned int： 直接把这32位编码看作32位二进制数N。

int： 以最高位为符号位，0表示非负数，1表示负数。对于最高位为0的编码的每种编码C，直接看作32位二进制数。同时，定义该编码按位取反后得到的编码~C表示的数值是 -1 - S。

可以发现在补码下每个数值都有唯一的表示方式，并且任意两个数值做加减法运算，都等价于在32位补码下做最高位不进位的二进制加减法运算。发生算术溢出时，32位无符号整数相当于自动对 2^32 取模。这也解释了“有符号整数”算术上溢时出现负数的现象。

反码：

直接把C的每一位取反表示负C。补码与反码在负数表示中，绝对值相差1。例如，在上表中，第1、4行是一对反码，第2、3行是一对反码。

memset

移位运算：

左移： 在二进制表示下把数字同时向左移动，低位以0填充，高位越界后舍弃。

1 << n = 2的n次方，n << 1 = 2n。

算术右移：在二进制补码表示下把数字同时向右移动，高位以符号位填充，低位越界后舍弃。算术右移等于除以2向下取整，(-3) >> 1 = -2，3 >> 1 = 1。值得一提的是，“ 整数 / 2 ” 在C ++中实现为“ 除以2向零取整 ”， (-3) / 2 = - 1，3 / 2 = 1。

逻辑右移： 在二进制补码表示下把数字同时向右移动，高位以0填充，低位越界后舍弃。

例题1（快速幂）：https://www.acwing.com/problem/content/91/

LL qmi(LL a, LL b, LL p) {
	LL ans = 1;
    for( ; b; b >>= 1) {
        if(b & 1) ans = ans * a % p;
        a = a * a % p;
	}
    return ans;
}

例题2（64位整数乘法）：https://www.acwing.com/problem/content/92/

LL mul(LL a, LL b, LL p) {
	LL ans = 0;
    for( ; b; b >>= 1) {
        if(b & 1) ans = (ans + a) % p;
        a = a * 2 % p;
	}
    return ans;
}

方法二：

二进制状态压缩：

二进制状态压缩，是指将一个长度为m的bool数组用一个m位二进制整数表示并存储的方法。利用下列位运算操作可以实现原 bool 数组中对应下标元素的存取。

例题3（最短Hamilton路径）：https://www.acwing.com/problem/content/93/

给定一张n(n≤20)个点的带权无向图，点从0~n-1标号，求起点0到终点n-1 的最短Hamilton路径。
Hamilton路径的定义是从0到n-1不重不漏地经过每个点恰好一次。

很容易想到本题的一种“朴素”做法，就是枚举n个点的全排列，计算路径长度取最小值，时间复杂度为O(n * n!),使用下面的二进制状态压缩DP可以优化到O(n^2 * 2^n)。

#include <bits/stdc++.h>

using namespace std;

int weight[20][20], f[1 << 20][20];

int main() {
    int n;
    cin >> n;
    for(int i = 0; i < n; i ++) {
        for(int j = 0; j < n; j ++) {
            cin >> weight[i][j];
        }
    }

    memset(f, 0x3f, sizeof(f));
    f[1][0] = 0;

    for(int i = 1; i < 1 << n; i ++) {
        for(int j = 0; j < n; j ++) {
            if(i >> j & 1) {
                for(int k = 0; k < n; k ++) {
                    if(i ^ (1 << j) >> k & 1) {
                        f[i][j] = min(f[i][j], f[i ^ (1 << j)][k] + weight[k][j]);
                    }
                }
            }
        }
    }

    cout << f[(1 << n) - 1][n - 1] << endl;

    return 0;
}

暴力（超时）：

虽然超时，但我想敲一下全排列

#include <bits/stdc++.h>

using namespace std;

const int N = 25;
int n;
int g[N][N];
bool st[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n;
    for(int i = 0; i < n; i ++) {
        for(int j = 0; j < n; j ++) {
            cin >> g[i][j];
        }
    }
    vector<int> res;
    res.push_back(0);
    int dist = 0, ans = INT_MAX;

    auto dfs = [&](auto& dfs, int u) -> void {
        if(res.back() == n - 1 && res.size() != n) return;
        if(u == n - 1) {
            if(res.back() != n - 1) return;
            dist = 0;
            for(int i = 0; i < res.size() - 1; i ++) {
                dist += g[res[i]][res[i + 1]];
            }
            ans = min(ans, dist);
            return;
        }
        for(int i = 1; i < n; i ++) {
           if(!st[i]) {
               res.push_back(i);
               st[i] = true;
               dfs(dfs, u + 1);
               res.pop_back();
               st[i] = false;
           }
        }
    };

    dfs(dfs, 0);
    cout << ans << endl;

    return 0;
}

例题4：https://www.acwing.com/problem/content/1000/

位运算的主要特点是在二进制表示下不进位。正因如此，在x0随意选择下，参与位运算的各个位（bit）之间是独立无关的。换言之，对于任意的k（0 <= k < 30），ans的第k位是几只与x0的第k位是几有关，与其他位无关。

我们从高位到低位考虑，依次考虑x0的每一位怎么填。
之后就是贪心，我们要让答案中出现的1越多越好。所以如果开始是0最后变成了1，（也就是伤害变多了）一定是需要选取的。

如果开始是1最后变成了0，或者开始是0结果还是0这种无意义情况，都不选。

如果开始是1最后变成了1，只要初始伤害值比1 <<（1在这一位的位数）大（也就是满足题目条件），显然也是要选取的。

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;
int n, m;
int nums[N];
string str[N];

int calc(int bit, int now) {
    for(int i = 0; i < n; i ++) {
        int x = nums[i] >> bit & 1;
        if(str[i] == "AND") now &= x;
        else if(str[i] == "OR") now |= x;
        else now ^= x;
    }
    return now;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    cin >> n >> m;
    for(int i = 0; i < n; i ++) {
        cin >> str[i] >> nums[i];
    }
    int res = 0, val = 0;
    for(int bit = 29; bit >= 0; bit --) {
        int res0 = calc(bit, 0), res1 = calc(bit, 1);
        if(val + (1 << bit) <= m && res0 < res1) {
            res += (res1 << bit);
            val += (1 << bit);
        } else {
            res += (res0 << bit);
        }
    }
    cout << res << endl;
    return 0;
}

成对变换：

对于非负整数n

当n为偶数时，n ^ 1 = n + 1

当n为奇数时，n ^ 1 = n + 1

lowbit运算

lowbit(n)定义为非负整数 n 在二进制表示下“最低位的1及其后边所有的0”构成的数值。例如n = 10的二进制表示为1010,则lowbit(n) = 2 = 二进制10。下面我们来推导 lowbit(n)的公式。

设 n > 0，假设n的第k位是1，0 ~ k - 1位是0；

则~n为第k位是0， 0 ~ k - 1位是1；

则~n + 1为第k位是1， 0 ~ k - 1位是0；但比第k位高的位，即第k + 1位到最高位恰好与原来相反。所以，n & (~n + 1)仅有第k位为1，其余位全是0。

故lowbit(n) = n & (-n + 1) = n & (-n)

一些内置函数：

GCC编译器还提供了一些内置函数，可以高效计算lowbit以及二进制数中1的个数。不过,这些函数并非C语言标准,有的函数更是与机器或编译器版本相关的。另外，部分竞赛禁止使用下划线开头的库函数,故这些内置函数尽量不要随便使用。

int __builtin_ctz(unsigned int x)

int __builtin_ctzll(unsigned long long x)

返回 x 的二进制表示下最低位的1后边有多少个0。

int __builtin_popcount(unsigned int x)

int __builtin_popcount(unsigned long long x)

返回 x 的二进制表示下有多少位为1。

可以高效计算lowbit以及二进制数中1的个数。不过,这些函数并非C语言标准,有的函数更是与机器或编译器版本相关的。另外，部分竞赛禁止使用下划线开头的库函数,故这些内置函数尽量不要随便使用。

int __builtin_ctz(unsigned int x)

int __builtin_ctzll(unsigned long long x)

返回 x 的二进制表示下最低位的1后边有多少个0。

int __builtin_popcount(unsigned int x)

int __builtin_popcount(unsigned long long x)

返回 x 的二进制表示下有多少位为1。