T1、投票
\(n \ (n \leq 2000)\) 个事件，第 \(i\) 件事发生的概率为 \(p_i\)，选出 \(k \ (k \leq 2000, 2 | k)\) 件事，求使得发生与不发生的事件数量相同的最大概率；
精度误差需保证在 \(10^{-6}\) 以内。
\(Sol\)：
一定是选按概率排好序的一段前缀和一段后缀比较优秀，这一点并不显然。
\(prf\)：
假定现在已经确定了 \(k - 1\) 个事件，未确定的事件设为 \(x\)；
那么概率为：
\[ \sum_{for \ all \ situation} \Big[ p_x \cdot \prod_{i = 1} ^ {\frac{k}{2} - 1} p_{a_i} \cdot \prod_{j = 1} ^ {\frac{k}{2}}(1 - p_{b_j}) + (1 - p_x) \cdot \prod_{i = 1} ^ {\frac{k}{2}} p_{b_i} \cdot \prod_{j = 1} ^ {\frac{k}{2} - 1}(1 - p_{a_j})\Big] , \ \{ a_i \} \bigcap \{ b_i \} = \varnothing \]
这是一个关于 \(p_x\) 的一次幂函数，所以一定是取能取到的最大或最小值比较优。
\(Q.E.D.\)
先将概率从小到大排序；
记 \(f_{i,j}\) 表示前 \(i\) 件事恰好发生 \(j\) 件的概率，转移是显然的；
记一个前缀和一个后缀的 \(dp\)，再枚举一边选择了多少人，求出概率取最大即可。
\(Source\)：
//#pragma GCC optimize(3,"Ofast","inline")
#include
#include
typedef double db;
templateinline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 2e3 + 5;
int n, m;
db pre[N][N], suf[N][N], p[N], res;
int main() {
//freopen("in", "r", stdin);
freopen("vote.in", "r", stdin);
freopen("vote.out", "w", stdout);
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%lf", &p[i]);
std::sort(p + 1, p + 1 + n);
pre[0][0] = 1;
for (int i = 1; i <= m; ++i) {
pre[i][0] = pre[i - 1][0] * (1 - p[i]);
for (int j = 1; j <= i; ++j)
pre[i][j] = pre[i - 1][j - 1] * p[i] + pre[i - 1][j] * (1 - p[i]);
}
std::reverse(p + 1, p + 1 + n);
suf[0][0] = 1;
for (int i = 1; i <= m; ++i) {
suf[i][0] = suf[i - 1][0] * (1 - p[i]);
for (int j = 1; j <= i; ++j)
suf[i][j] = suf[i - 1][j - 1] * p[i] + suf[i - 1][j] * (1 - p[i]);
}
for (int i = 0; i <= m; ++i) {
db tmp = 0;
for (int j = std::max(0, m / 2 - (m - i)); j <= i && j <= m / 2; ++j)
tmp += pre[i][j] * suf[m - i][m / 2 - j];
chk_max(res, tmp);
}
printf("%.7lf\n", res);
return 0;
} T2、动态数点
给定一个长度为 \(n \ (n \leq 5 \times 10 ^ 5)\) 的序列 \(\{ a_i \} \ (a_i \leq 2 ^ {32} - 1)\)，如果对于一个区间 \([l, r]\)，存在 \(k \in [l, r]\) 使得 \(\forall i \in [l,r] \ a_k | a_i\)，那么它有 \(r - l\) 的价值，求最大价值。
\(Sol\)：
\(gcd\) 的 \(\log\) 比较小，直接 \(st\) 表可过。
时间复杂度 \(O(n \log_2 n \log_2a_i)\)。
对于两个区间里可以作为除数的数 \(a_x, a_y \ (x \ne y)\)；
若 \(a_x = a_y\)，他们一定会被包含在同一个区间；
否则包含其中一个点的区间不会包含另一个点，很容易证明这两点。
所以从左到右枚举除数 \(a_i\)，向左右扩展，找到包含它的极大区间 \([l, r]\)，更新答案，并把除数设为 \(a_{r + 1}\) 即可；
根据上述引理，\(l\) 一定在上一个除数的位置的右边，所以每个点只会被算到两次。
时间复杂度 \(O(n)\)。
\(Source\)：
#include
#include
#include
unsigned in() {
unsigned x = 0; char c = getchar();
while (c < '0' || c > '9')
c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x;
}
templateinline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
templateinline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 5e5 + 5;
unsigned n, a[N], res[N];
int main() {
//freopen("in", "r", stdin);
freopen("point.in", "r", stdin);
freopen("point.out", "w", stdout);
n = in();
for (unsigned i = 1; i <= n; ++i)
a[i] = in();
unsigned max = 0, num = 0, tmp;
for (unsigned i = 1, l, r; i <= n; i = r + 1) {
l = r = i;
while (r < n && a[r + 1] % a[i] == 0)
++r;
while (l > 1 && a[l - 1] % a[i] == 0)
--l;
tmp = r - l;
if (tmp == max)
res[++num] = l;
if (tmp > max)
max = tmp, res[num = 1] = l;
}
printf("%u %u\n", num, max);
for (unsigned i = 1; i <= num; ++i)
printf("%u ", res[i]);
puts("");
return 0;
} T3、演员
一道让我咕博客的题，然而理解后也咕了很久十分简单。
老虎蒜头神仙题。
给 \(m \ (m \leq 300)\) 个演员排 \(n \ (n \leq 10 ^ 6)\) 天班；
每次选择一个演员，并选择区间 \([l, r]\)，给他安排 \([l,r]\) 里没有还被分配给其他演员的天；
每天都要被分配，演员可以不被安排，求分配方案数，对 \(10 ^ 9 + 7\) 取模。
\(Sol\)：
显然可以发现，两个演员被安排的天一定不存在相交但不包含的情况；
那么按时间顺序来看正在工作的演员，可以把它看成一个栈，工作的演员在栈顶；
可以 \(dp\)，记 \(f_{i,j,k}\) 表示前 \(i\) 天，已经有 \(j\) 个演员入过栈，栈里还有 \(k\) 个人的方案数，转移是显然的，不再赘述。
由于 \(n\) 很大，这样显然不行，但是注意到时间被不同演员分成了最多 \(2m - 1\) 段；
可以把第一维状态改为上述时间段，对每个状态组合数计算贡献即可。
时间复杂度 \(O(m ^ 3)\)。
\(Source\)：
//#pragma GCC optimize(3,"Ofast","inline")
#include
#include
#include
int in() {
int x = 0; char c = getchar(); bool f = 0;
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
templateinline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
templateinline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int M = 305, mod = 1e9 + 7;
int n, m, res;
int fac[N], inv[N], f[M + M][M][M];
inline void add(int &_, int __) {
_ += __;
if (_ >= mod)
_ -= mod;
}
int qpow(int base, int b, int ret = 1) {
for (; b; b >>= 1, base = 1ll * base * base % mod)
if (b & 1)
ret = 1ll * ret * base % mod;
return ret;
}
void prep() {
int nn = std::max(n, m);
fac[0] = inv[0] = 1;
for (int i = 1; i <= nn; ++i)
fac[i] = 1ll * fac[i - 1] * i % mod;
inv[nn] = qpow(fac[nn], mod - 2);
for (int i = nn - 1; i; --i)
inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
inline int C(const int n, const int m) {
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
inline int A(const int n, const int m) {
return 1ll * fac[n] * inv[n - m] % mod;
}
int main() {
//freopen("in", "r", stdin);
freopen("actor.in", "r", stdin);
freopen("actor.out", "w", stdout);
n = in(), m = in();
prep();
f[0][0][0] = 1;
for (int i = 1; i <= n && i <= m + m; ++i) {
for (int j = 1; j <= m; ++j)
for (int k = j, sum = 0, tmp; k; --k) {
tmp = f[i - 1][j - 1][k - 1]; add(tmp, sum);
add(f[i][j][k], tmp);
add(sum, f[i - 1][j][k]);
add(res, 1ll * A(m, j) * C(n - 1, i - 1) % mod * f[i][j][k] % mod);
}
}
printf("%d\n", res);
return 0;
}