T1：区间交集（二）
这种统计有多少对满足题意，首先想下暴力
\(O(n^2)\) 复杂度
正解：
判断区间是否有交集，其实比较麻烦，怎么简单判断？
- 如果已知左端点的大小顺序，那么判断是否有交集会很简单
- 由此可以得到一个思路，即对所有区间按照左端点从小到大排序，那么我们对于第 \(i\) 个区间考虑第 \(i+1 \sim n\) 个区间，这些区间的左端点都比第 \(i\) 个区间的左端点大，那么只需判断右端点 \(y\) 和这些左端点的关系（二分）
代码实现
#include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
struct Interval {
int l, r;
Interval() {}
Interval(int l, int r): l(l), r(r) {}
bool operator<(const Interval& o) const {
return l < o.l;
}
};
inline int read() {
int x = 0;
char c;
while (c < '0' or c > '9') c = getchar();
while ('0' <= c and c <= '9') {
x = x*10+c-'0';
c = getchar();
}
return x;
}
int main() {
int n = read();
vector<Interval> intervals(n);
rep(i, n) {
intervals[i].l = read();
intervals[i].r = read();
}
sort(intervals.begin(), intervals.end());
ll ans = 0;
rep(i, n) {
// 每次找出有多少个 j>i 满足第 j 个区间和第 i 个区间相交 （intervals[j].l <= intervals[i].r）
int ac = i, wa = n;
while (abs(ac-wa) > 1) {
int wj = (ac+wa)/2;
if (intervals[wj].l <= intervals[i].r) ac = wj; else wa = wj;
}
ans += ac-i;
}
cout << ans << '\n';
return 0;
}
T2：树的直径
模板题，求树的直径是一个很经典的问题
它需要一些数学结论
暴力：我们可以用一次 bfs 或者 dfs 求出所有点和 \(v\) 的距离 \(O(n)\)
\(n\) 次搜索，就能找出所有点两两之间的距离
\(O(n^2)\) 会超时
需要使用数学结论：任选一个点 \(v\)，找到离 \(v\) 最远的一个点 \(u\)，再找到离 \(u\) 最远的点 \(w\)，则 \((u, w)\) 是一条直径
有了这个结论之后怎么做？
所以两次搜索可以解决本题，但是注意如果所有的点是一路悬挂下来的，则对于 dfs，它的栈空间开销量是很大的，冗余发生运行时错误（栈溢出）
最好使用 bfs （全局变量队列）
代码实现
#include <bits/extc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<vector<int>> to(n);
rep(i, n-1) {
int a, b;
cin >> a >> b;
to[a].push_back(b);
to[b].push_back(a);
}
queue<P> q;
vector<bool> used(n);
int last = 0, dist = 0;
auto bfs = [&](int s) {
rep(i, n) used[i] = false;
used[s] = true;
q.emplace(s, 0);
while (q.size()) {
auto [v, d] = q.front(); q.pop();
last = v;
dist = d;
for (int u : to[v]) {
if (used[u]) continue;
used[u] = true;
q.emplace(u, d+1);
##### }
}
};
bfs(0);
bfs(last);
cout << dist << '\n';
return 0;
}
T3：棋盘问题
最朴素的想法：搜索 search(int i) 表示前 \(n-i\) 行已经定下来了
mp[i][j] 来表示某一个格子里面是否有棋子，col[i] 表示第 \(i\) 列已经用了多少个棋子
重点其实不在于哪一列用了多少个棋子，而是有多少列用了 \(0\) 个棋子，多少列用了 \(1\) 个棋子，多少列用了 \(2\) 个棋子
search(i, x, y, z)：\(i\) 表示在填第 \(i\) 行，前 \(n-i\) 行已经填好了，\(x\) 表示有多少列用了 \(0\) 个棋子，\(y\) 表示有多少列用了 \(1\) 个棋子，\(z\) 表示有多少列用了 \(2\) 个棋子
稍微进行一些优化：其实可以不搜索，本质上是一个递推的过程
记 dp[i][x][y][z] 表示前 \(n-i\) 行都已经按题意填好，其中有 \(x\) 列用了 \(0\) 个棋子，\(y\) 列用了 \(1\) 个棋子，\(z\) 列用了 \(2\) 个棋子，此时剩下的 \(i\) 行有多少种填法
最后的答案就是 dp[n][m][0][0]
如何转移？
其实就是一个分类讨论的问题：
- 第 \(i\) 行用了 \(0\) 个 棋子：
\(dp[i-1][x][y][z]\) - 第 \(i\) 行用了 \(1\) 个 棋子：
占用 \(1\) 个只有 \(0\) 个棋子的列：\(dp[i-1][x-1][y+1][z]\)
占用 \(1\) 个只有 \(1\) 个棋子的列：\(dp[i-1][x][y-1][z+1]\) - 第 \(i\) 行用了 \(2\) 个 棋子：
占用 \(2\) 个有 \(0\) 个棋子的列: \(dp[i-1][x-2][y+2][z]\)
占用 \(2\) 个有 \(1\) 个棋子的列：\(dp[i-1][x][y-2][z+2]\)
占用 \(1\) 个有 \(0\) 个棋子的列和 \(1\) 个有 \(1\) 个棋子的列：\(dp[i-1][x-1][y][z+1]\)
代码实现
#include <bits/extc++.h>
#define rep(i, s, t) for (int i = (s); i <= (t); ++i)
using namespace std;
using ll = long long;
//const int mod = 998244353;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x=0):x((x%mod+mod)%mod) {}
mint operator-() const {
return mint(-x);
}
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod-a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
return mint(*this) += a;
}
mint operator-(const mint a) const {
return mint(*this) -= a;
}
mint operator*(const mint a) const {
return mint(*this) *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t>>1);
a *= a;
if (t&1) a *= *this;
return a;
}
// for prime mod
mint inv() const {
return pow(mod-2);
}
mint& operator/=(const mint a) {
return *this *= a.inv();
}
mint operator/(const mint a) const {
return mint(*this) /= a;
}
};
istream& operator>>(istream& is, mint& a) {
return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
return os << a.x;
}
mint dp[2][101][101][101];
int main() {
int n, m;
cin >> n >> m;
// 先初始化 dp[0]
rep(x, 0, m)rep(y, 0, m) {
if (x+y > m) break;
int z = m-x-y;
dp[0][x][y][z] = 1;
}
rep(i, 1, n) {
rep(x, 0, m)rep(y, 0, m) {
if (x+y > m) break;
int z = m-x-y;
if (y+2*z > 2*(n-i)) continue;
mint now;
// 1) 第 i 行用了 0 个棋子
now = dp[i-1&1][x][y][z];
// 2) 第 i 行用了 1 个棋子
if (x) now += mint(x)*dp[i-1&1][x-1][y+1][z];
if (y) now += mint(y)*dp[i-1&1][x][y-1][z+1];
// 3) 第 i 行用了 2 个棋子
if (x > 1) now += mint(x)*(x-1)/2 * dp[i-1&1][x-2][y+2][z];
if (y > 1) now += mint(y)*(y-1)/2 * dp[i-1&1][x][y-2][z+2];
if (x) now += mint(x)*y * dp[i-1&1][x-1][y][z+1];
dp[i&1][x][y][z] = now;
}
}
cout << dp[n&1][m][0][0] << '\n';
return 0;
}
T4：购买商品
最暴力的做法：
枚举这 \(k\) 张卡的支付顺序，对于每一个顺序，模拟购买过程，复杂度是 \(O(n*k!)\)
优化1：预处理出商品价格的前缀和 sum，二分去寻找新添加一张卡后可以一路买到第几个商品
优化2：
状压dp思想：
我们用一个 \(k\) 位的二进制数来表示卡的使用情况
第 \(i\) 位为 1 表示使用第 \(i\) 张卡
则我们用 dp[state] 表示使用掉 \(state\) 中代表的若干张卡后可购买完的最大商品数量
dp[state] 怎么求呢？
其实可以枚举 \(state\) 中 1 的位置
假设这个位置代表的卡是最后一个使用的卡
dp[state] = max(dp[state], sum 中不超过 sum[dp[state ^ 1<<i]]+v[i] 的最大商品数量)
代码实现
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
template<typename T>
inline void chmax(T& x, T y) { if (x < y) x = y; }
int main() {
int n;
cin >> n;
vector<int> p(n);
rep(i, n) cin >> p[i];
vector<int> sum(n+1);
rep(i, n) sum[i+1] = sum[i]+p[i];
int k;
cin >> k;
vector<int> v(k);
rep(i, k) cin >> v[i];
int k2 = 1<<k;
vector<int> dp(k2);
rep(s, k2) {
rep(i, k) { // 枚举 k 张卡
if (s>>i&1) { // 表示 state 中有这张卡，则考虑把这张卡作为最后一个使用的卡
int x = dp[s^(1<<i)]; // 不使用第 i 张卡，最多买下前 x 件商品
int now = upper_bound(sum.begin()+1, sum.end(), sum[x]+v[i]) - sum.begin()-1;
chmax(dp[s], now);
}
}
}
ll ans = 0;
bool ok = false;
rep(s, k2) {
if (dp[s] != n) continue;
ok = true;
ll money = 0;
rep(i, k) if (~s>>i&1) money += v[i];
chmax(ans, money);
}
if (ok) cout << ans << '\n';
else puts("Balance is insufficient");
return 0;
}
