184 lines
No EOL
6.3 KiB
Markdown
184 lines
No EOL
6.3 KiB
Markdown
---
|
|
slug: /plat/bitset
|
|
title: "Bitset"
|
|
author: Benjamin Qi
|
|
order: 7
|
|
---
|
|
|
|
Three examples of how bitset leads to some unintended solutions on recent USACO problems.
|
|
|
|
<!-- END DESCRIPTION -->
|
|
|
|
## Tutorial
|
|
|
|
tl;dr some operations are 32x-64x faster compared to a boolean array
|
|
|
|
- [Cpp Reference](http://www.cplusplus.com/reference/bitset/bitset/)
|
|
- [Errichto Pt 2](https://codeforces.com/blog/entry/73558)
|
|
|
|
## Applications
|
|
|
|
### [Cowpatibility (Gold)](http://www.usaco.org/index.php?page=viewproblem2&cpid=862)
|
|
|
|
Label the cows from $0\ldots N-1$. For two cows `x` and `y` set `adj[x][y]=1` if they share a common flavor. Then the number of pairs of cows that are compatible (counting each pair where `x` and `y` are distinct twice) is equal to the sum of `adj[x].count()` over all `x`. It remains to compute `adj[x]` for all `x`.
|
|
|
|
Unfortunately, storing $N$ bitsets each with $N$ bits takes up $50000^2/32\cdot 4=312.5\cdot 10^6$ bytes of memory, which is too much. We can reduce the memory usage by half in exchange for a slight increase in time by first computing the adjacency bitsets for all `x` satisfying `0<=x<N/2`, and then for all `x` satisfying `N/2<=x<N` afterwards.
|
|
|
|
First, we read in all of the flavors.
|
|
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
|
|
typedef long long ll;
|
|
typedef bitset<50000> B;
|
|
const int HALF = 25000;
|
|
|
|
int N;
|
|
B adj[HALF];
|
|
vector<int> flav[1000001];
|
|
ll ans;
|
|
|
|
void input() {
|
|
ios_base::sync_with_stdio(0); cin.tie(0);
|
|
freopen("cowpatibility.in","r",stdin);
|
|
freopen("cowpatibility.out","w",stdout);
|
|
cin >> N;
|
|
for (int i = 0; i < N; ++i)
|
|
for (int j = 0; j < 5; ++j) {
|
|
int x; cin >> x;
|
|
flav[x].push_back(i);
|
|
}
|
|
}
|
|
```
|
|
|
|
Then for each flavor, we can look at all pairs of cows that share that flavor and update the adjacency lists (for those `x` satisfying `x<HALF`).
|
|
|
|
```cpp
|
|
int main() {
|
|
input();
|
|
for (int i = 1; i <= 1000000; ++i)
|
|
for (int x: flav[i]) if (x < HALF) for (int y: flav[i]) adj[x][y] = 1;
|
|
for (int i = 0; i < HALF; ++i) ans += adj[i].count();
|
|
}
|
|
```
|
|
|
|
`adj[i].count()` runs quickly enough since its runtime is divided by the bitset constant. However, looping over all cows in `flav[i]` is too slow if say, `flav[i]` contains all cows. Then the nested loop could take $\Theta(N^2)$ time! Of course, we can instead write the nested loop in a way that takes advantage of fast bitset operations once again.
|
|
|
|
```cpp
|
|
for (int i = 1; i <= 1000000; ++i) if (flav[i].size() > 0) {
|
|
B b; for (int x: flav[i]) b[x] = 1;
|
|
for (int x: flav[i]) if (x < HALF) adj[x] |= b;
|
|
}
|
|
```
|
|
|
|
The full main function is as follows:
|
|
|
|
```cpp
|
|
int main() {
|
|
input();
|
|
for (int i = 1; i <= 1000000; ++i) if (flav[i].size() > 0) {
|
|
B b; for (int x: flav[i]) b[x] = 1;
|
|
for (int x: flav[i]) if (x < HALF) adj[x] |= b;
|
|
}
|
|
for (int i = 0; i < HALF; ++i) ans += adj[i].count();
|
|
for (int i = 0; i < HALF; ++i) adj[i].reset();
|
|
for (int i = 1; i <= 1000000; ++i) if (flav[i].size() > 0) {
|
|
B b; for (int x: flav[i]) b[x] = 1;
|
|
for (int x: flav[i]) if (x >= HALF) adj[x-HALF] |= b;
|
|
}
|
|
for (int i = 0; i < HALF; ++i) ans += adj[i].count();
|
|
cout << ((ll)N*N-ans)/2 << "\n";
|
|
}
|
|
```
|
|
|
|
### [Lots of Triangles](http://www.usaco.org/index.php?page=viewproblem2&cpid=672)
|
|
|
|
First, we read in the input data. `cross(a,b,c)` is positive iff `c` lies to the left of the line from `a` to `b`.
|
|
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
|
|
typedef long long ll;
|
|
typedef pair<ll,ll> P;
|
|
|
|
#define f first
|
|
#define s second
|
|
|
|
ll cross(P a, P b, P c) {
|
|
b.f -= a.f, b.s -= a.s;
|
|
c.f -= a.f, c.s -= a.s;
|
|
return b.f*c.s-b.s*c.f;
|
|
}
|
|
|
|
vector<P> v;
|
|
int N;
|
|
|
|
void input() {
|
|
ios_base::sync_with_stdio(0); cin.tie(0);
|
|
freopen("triangles.in","r",stdin);
|
|
freopen("triangles.out","w",stdout);
|
|
cin >> N; v.resize(N);
|
|
for (P& p: v) cin >> p.f >> p.s;
|
|
}
|
|
```
|
|
|
|
There are $O(N^3)$ possible lots. Trying all possible lots and counting the number of trees that lie within each in $O(N)$ for a total time complexity of $O(N^4)$ should solve somewhere between 2 and 5 test cases. Given a triangle `t[0], t[1], t[2]` with positive area, tree `x` lies within it iff `x` is to the left of each of sides `(t[0],t[1])`,` (t[1],t[2])`, and `(t[2],t[0])`.
|
|
|
|
```cpp
|
|
int main() {
|
|
input();
|
|
vector<int> res(N-2);
|
|
for (int i = 0; i < N; ++i)
|
|
for (int j = i+1; j < N; ++j)
|
|
for (int k = j+1; k < N; ++k) {
|
|
vector<int> t = {i,j,k};
|
|
if (cross(v[t[0]],v[t[1]],v[t[2]]) < 0) swap(t[1],t[2]);
|
|
int cnt = 0;
|
|
for (int x = 0; x < N; ++x) {
|
|
if (cross(v[t[0]],v[t[1]],v[x]) <= 0) continue;
|
|
if (cross(v[t[1]],v[t[2]],v[x]) <= 0) continue;
|
|
if (cross(v[t[2]],v[t[0]],v[x]) <= 0) continue;
|
|
cnt ++;
|
|
}
|
|
res[cnt] ++;
|
|
}
|
|
for (int i = 0; i < N-2; ++i) cout << res[i] << "\n";
|
|
}
|
|
```
|
|
|
|
The analysis describes how to count the number of trees within a lot in $O(1)$, which is sufficient to solve the problem. However, $O(N)$ is actually sufficient as long as we divide by the bitset constant. Let `b[i][j][k]=1` if `k` lies to the left of side `(i,j)`. Then `x` lies within triangle `(t[0],t[1],t[2])` as long as `b[t[0]][t[1]][x]=b[t[1]][t[2]][x]=b[t[2]][t[0]][x]=1`. We can count the number of `x` such that this holds true by taking the bitwise AND of the bitsets for all three sides and then counting the number of bits in the result.
|
|
|
|
```cpp
|
|
bitset<300> b[300][300];
|
|
|
|
int main() {
|
|
input();
|
|
for (int i = 0; i < N; ++i)
|
|
for (int j = 0; j < N; ++j) if (j != i)
|
|
for (int k = 0; k < N; ++k) if (cross(v[i],v[j],v[k]) > 0)
|
|
b[i][j][k] = 1;
|
|
vector<int> res(N-2);
|
|
for (int i = 0; i < N; ++i)
|
|
for (int j = i+1; j < N; ++j)
|
|
for (int k = j+1; k < N; ++k) {
|
|
vector<int> t = {i,j,k};
|
|
if (cross(v[t[0]],v[t[1]],v[t[2]]) < 0) swap(t[1],t[2]);
|
|
auto z = b[t[0]][t[1]]&b[t[1]][t[2]]&b[t[2]][t[0]];
|
|
res[z.count()] ++;
|
|
}
|
|
for (int i = 0; i < N-2; ++i) cout << res[i] << "\n";
|
|
}
|
|
```
|
|
|
|
### [Equilateral Triangles](http://www.usaco.org/index.php?page=viewproblem2&cpid=1021)
|
|
|
|
Again, the intended solution runs in $O(N^3)$. Of course, it is still possible to pass $O(N^4)$ solutions with bitset! See the analysis [here](http://www.usaco.org/current/data/sol_triangles_platinum_feb20.html).
|
|
|
|
### Other Applications
|
|
|
|
Using operations such as `_Find_first()` and `_Find_next()` mentioned in Errichto's blog above (are these documented?), you can speed up the following:
|
|
|
|
- BFSing through a dense graph with $N$ vertices in $O(N^2)$
|
|
- bipartite matching in $O(N^3)$ |