bitset

bitset

序

从暑假开始就一直听到 $bitset$ 优化, 而且好像还挺厉害, 虽然只是常数优化, 但是却非常的好用.

bitset 是啥

$bitset$ 其实就是一个二进制数, 包含在 $bitset$ 库里(万能头也有), 声明如下:

bitset <N> B;

表示声明了一个位长为 $N$ 的 $bitset$ , 所占用的内存也仅仅是 $N$ 位, 也就是说, $bitset$ 的每一位占用仅仅是 $1$ 位, 与同样是表示 $01$ 的 $bool$ 相比, 小了 $8$ 倍 ( $bool$ 最小时是 $1\ bit$, $bitset$ 一位只要 $1\ Byte$).

所以当我们只需要 $01$ 时, $bitset$ 是不二之选, 空间复杂度大大减小.

$bitset$ 不止能优化空间, 还能优化时间, 我们 $n$ 个 $bool$ 做位运算, 时间复杂度是 $O(n)$ , 而一个 $n$ 位的 $bitset$ 做位运算, 时间复杂度仅为 $n / w$ . 这个 $w$ 是一个常数, 取决于你的计算机位数, 如果你是 $32$ 位系统, 那就是 $32$ , $64$ 位系统就是 $64$ .

尽管只是常数优化, 但是这个优化已经非常大了, 可以让我们原本复杂度 $1e9 \sim 1e10$ 左右的代码卡到 $1e8$ 左右.

bitset 咋用

$bitset$ 支持的操作:

B = 10; //赋值
B[0]; // 访问某一位

/* 相同大小的 bitset 可以进行运算符操作 */
/* == != & &= | |= ^ ^= ~ << <<= >> >>=  */

B.count();     // 返回 1 的数量
B.size();      // 返回 bitset 的大小
B.any();       // 若有 1, 返回 1
B.none();      // 若无 1, 返回 1
B.all();       // 若全是 1, 返回 1
B.set();       // 全部设为 1
B.set(pos, k); // 将第 pos 位设为 k
B.reset();     // 全部设为 0
B.flip();      // 翻转每一位
B.flip(0);     // 翻转某一位

$bitset$ 主要是应用于我们的状态仅有 $01$ 两种时, 就我见过的题来看, 通常是 $DP$ .

就以今天模拟赛的一道区间 $DP$ 为例, 详细的讲解一下 $bitset$ 到底咋用.

题目给出 $n$ 个人按照 $1 \sim n$ 的顺序站成一排, , 给出 $n$ 个人之间 $pk$ 的胜负关系, 求哪些人最终可以赢.

$\operatorname{subtask}\ 1(10pts): n \leq 10$ .

$\operatorname{subtask}\ 2(10pts): n \leq 50$ .

$\operatorname{subtask}\ 3(20pts): n \leq 120$ .

$\operatorname{subtask}\ 4(20pts): n \leq 300$ .

$\operatorname{subtask}\ 5(20pts): n \leq 700$ .

$\operatorname{subtask}\ 6(20pts): n \leq 2000$ .

时间限制: $2s$
空间限制: $512MB$

我一上来想成了拓扑排序 + 缩点, 后来发现不行, 然后觉得是个 $DP$ , 于是开始想 $DP$ .

想了好久, 感觉是个区间 $DP$ , 但是暂时没有头绪, 所以我就干脆点, 先把状态设出来, 于是状态就出来了: $f(i, j, k)$ 表示 $k$ 在 $[i, j]$ 中能不能赢.

先把状态设出来, 管他会不会转移.

然而状态出来之后, 转移也就自然而然的出来了.

设 $a[i][j]$ 表示 $i$ 与 $j$ $pk$ 的结果.

我们考虑在区间 $[i, j]$ 中, 什么情况下 $k$ 才能赢, 于是我们找到了 $k$ 赢的充要条件: 当且仅当在 $[i, k - 1]$ 中存在能够被 $k$ 打败的人, 并且这个人能够在 $[i, k - 1]$ 中赢, 也就是 $a[k][o]\ \And\ f[i][k - 1][o]$ , 右边也是同理, $a[k][o]\ \And\ f[k + 1][j][o]$ .

因为需要枚举 $o$ , 所以复杂度 $O(n^4)$ . 期望得分 $60pts$ .

$code:$

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
  return x * f;
}

const int N = 705;

int n, a[N][N], f[N][N][N];
char s[N];

int main() {
  n = read();
  for (int i = 1; i <= n; i++) {
    scanf("%s", s + 1);
    for (int j = 1; j <= n; j++) {
      a[i][j] = s[j] ^ 48;
    }
  }
  for (int i = 1; i <= n; i++) f[i][i][i] = 1;
  for (int i = 1; i < n; i++) {
    f[i][i + 1][i] = a[i][i + 1];
    f[i][i + 1][i + 1] = a[i + 1][i];
  }
  for (int l = 3; l <= n; l++) {
    for (int i = 1, j = l; j <= n; i++, j++) {
      for (int k = i; k <= j; k++) {
        if (k == i) {
          for (int o = i + 1; o <= j; o++) {
            if (a[k][o] && f[i + 1][j][o]) {
              f[i][j][k] = 1;
              break;
            }
          }
        } else if (k == j) {
          for (int o = i; o < j; o++) {
            if (a[k][o] && f[i][j - 1][o]) {
              f[i][j][k] = 1;
              break;
            }
          }
        } else {
          if (f[i][k][k] && f[k][j][k]) f[i][j][k] = 1;
        }
      }
    }
  }
  for (int i = 1; i <= n; i++) {
    if (f[1][n][i]) printf("%d ", i);
  }
  return 0;
}

在还有十几分钟的时候, 本来我都放弃优化了的, 已经关掉我的 $Linux$ 去 $Windows$ 了, 然后突然, 我在给别人讲述我的思路的时候, 他重复了一下我的思路, "也就是说, 只要 $k$ 能在 $[i, k]$ 中赢, 并且能在 $[k, j]$ 中赢就行是吧." , "woc! 你是天才!" 然后我突然就悟了!!!我说我会 $n^3$ 的了, 然后想了一会, 好像不是 $n^3$ , 仔细思索片刻, 确实是 $n^3$ , 但是由于我太菜了, 有人拿我当蛐蛐, 押宝, 赌我能不能写出来. 由于非常好写, 我直接打开 $vs\ code$ , 不到 $2min$ 就写完了, 然后直接提交, 激动片刻, 没过大样例, 但是时间快了很多, 我还在想是不是只是常数优化? 然后打开一看, $MLE$ , 我直接打开 $vs\ code$ , 把 $int$ 的状态改成了 $bool$ , 然后提交, 漂亮! 过了. 那个人已经走了, 那个瞧我不起的人. 我的心脏怦怦直跳...一路从五楼冲到一楼, 吃饭去了.

$n^3$ 其实很简单, 状态不变, 我们发现我们其实没必要枚举 $o$ , 因为我们已经知道了 $k$ 在 $[i, k]$ 中以及 $[k, j]$ 中能不能赢了, 所以我们就可以 $O(1)$ 转移了, 只需要特判一下 $k = i$ 以及 $k = j$ 的情况就行了.

复杂度 $O(n^3)$ , 期望得分 $80pts$ .

$code:$

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) +(ch ^ 48);
  return x * f;
}

const int N = 705;

int n, a[N][N];
bool f[N][N][N];
char s[N];

int main() {
  n = read();
  for (int i = 1; i <= n; i++) {
    scanf("%s", s + 1);
    for (int j = 1; j <= n; j++) {
      a[i][j] = s[j] ^ 48;
    }
  }
  for (int i = 1; i <= n; i++) f[i][i][i] = 1;
  for (int i = 1; i < n; i++) {
    f[i][i + 1][i] = a[i][i + 1];
    f[i][i + 1][i + 1] = a[i + 1][i];
  }
  for (int l = 3; l <= n; l++) {
    for (int i = 1, j = l; j <= n; i++, j++) {
      for (int k = i + 1; k < j; k++) f[i][j][k] = f[i][k][k] & f[k][j][k];
      for (int k = i + 1; k <= j; k++) {
        f[i][j][i] = a[i][k] & f[i + 1][j][k];
        if (f[i][j][i]) break;
      }
      for (int k = i; k < j; k++) {
        f[i][j][j] = a[j][k] & f[i][j - 1][k];
        if (f[i][j][j]) break;
      }
    }
  }
  for (int i = 1; i <= n; i++) {
    if (f[1][n][i]) printf("%d ", i);
  }
  return 0;
}

接下来考虑正解, 其实正解已经不需要脑子了, 只可惜我当时不会 $bitset$ , 加之过于激动, 就没想.

我们想一下, 我们的状态存的都只是 $01$ , 所以我们完全可以开一个 $bitset$ , 这样首先就解决了我们内存的问题, 因为 $bool$ 是开不下 $2000^3$ 的.

然后我们看一下我们的转移: $f[i][j][k] = f[i][k][k] \And f[k][j][k]$ .

我们发现 $k$ 是这三个变量的共同值, 我们就可以开两个 $bitset$ , $f1[i][j]$ 表示 $j$ 在 $[i, j]$ 里能不能赢, $f2[i][j]$ 表示 $j$ 在 $[j][i]$ 里能不能赢, 这样我们就可以用 $f1$ 和 $f2$ 来分别表示 $f[i][k][k]$ 和 $f[k][j][k]$ 了, 由于第三维相同, 所以转移可以写成: $f[i][j] = f1[i] \And f2[j]$ . 然后特判一下 $k = i$ 和 $k = j$ 的情况就行了, 顺便处理 $f1$ 和 $f2$ .

$code:$

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
  return x * f;
}

const int N = 2005;

int n;
bitset <N> f[N][N], f1[N], f2[N], a[N];
char s[N];

int main() {
  n = read();
  for (int i = 1; i <= n; i++) {
    scanf("%s", s + 1);
    for (int j = 1; j <= n; j++) {
      a[i][j] = s[j] ^ 48;
    }
  }
  for (int i = 1; i <= n; i++) f[i][i][i] = 1;
  for (int l = 2; l <= n; l++) {
    for (int i = 1, j = l; j <= n; i++, j++) {
      f[i][j] = f1[i] & f2[j];
      if ((f[i + 1][j] & a[i]).any()) f[i][j][i] = f2[j][i] = 1;
      if ((f[i][j - 1] & a[j]).any()) f[i][j][j] = f1[i][j] = 1;
    }
  }
  for (int i = 1; i <= n; i++) {
    if (f[1][n][i]) printf("%d ", i);
  }
  return 0;
}

转移 $O(n/w)$ , 复杂度 $O(n^3 / w)$ , 期望得分 $100pts$ .

总结

其实 $bitset$ 真的是个好东西, 当我们的操作只需要两个数组进行位运算, 并且状态只有 $01$ 时, 复杂度可以在常数上有非常大的优化.