T1、矩阵乘法
题目链接
给定一个 \(n \times n \ (n \leq 500)\) 的矩阵 \((a_{i,j} \leq 10 ^ 9)\)，\(q \ (q \leq 6 \times 10 ^ 5)\) 组询问，每次询问一个子矩阵的第 \(k\) 大元素 (保证存在)。
\(Sol\)：
整体二分主席树，注意常数因子带来的影响；
全场只有我一个常数怪 \(95\) 分。
时间复杂度 \(O(q \log_2^2 n)\)。
\(Source\)：
//#pragma GCC optimize(2)
#include
#include
#include
inline 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 N = 505, Q = 60005;
struct info {
int id, x1, y1, x2, y2, k;
} b[N * N + Q];
int n, m, q, id[N * N + Q], tmp1[N * N + Q], tmp2[N * N + Q], pos[N * N], res[Q];
int nn, mp[N * N];
struct persistable_segment_tree {
int sum[N * N * 11], c[N * N * 11][2], rt[N * N], tot;
void clear() {
tot = 0;
}
int new_node() {
++tot;
sum[tot] = c[tot][0] = c[tot][1] = 0;
return tot;
}
void modify(int pos, int tl, int tr, int pre, int &p) {
p = new_node(), sum[p] = sum[pre];
++sum[p];
if (tl == tr)
return ;
int mid = (tl + tr) >> 1;
if (mid >= pos) {
c[p][1] = c[pre][1];
modify(pos, tl, mid, c[pre][0], c[p][0]);
} else {
c[p][0] = c[pre][0];
modify(pos, mid + 1, tr, c[pre][1], c[p][1]);
}
}
int query(int l, int r, int tl, int tr, int pre, int p) {
if (l <= tl && tr <= r)
return sum[p] - sum[pre];
int mid = (tl + tr) >> 1;
if (mid < l)
return query(l, r, mid + 1, tr, c[pre][1], c[p][1]);
if (mid >= r)
return query(l, r, tl, mid, c[pre][0], c[p][0]);
return query(l, r, tl, mid, c[pre][0], c[p][0]) +
query(l, r, mid + 1, tr, c[pre][1], c[p][1]);
}
} T;
void binary_search(int l, int r, int s, int t) {
if (l > r || s > t)
return ;
if (l == r) {
for (int i = s; i <= t; ++i)
if (b[id[i]].id)
res[b[id[i]].id] = mp[l];
return ;
}
int mid = (l + r) >> 1, p1 = 0, p2 = 0, tot = 0;
T.clear();
for (int i = s; i <= t; ++i) {
if (!b[id[i]].id) {
if (b[id[i]].k <= mp[mid]) {
T.modify(b[id[i]].y1, 1, n, T.rt[tot], T.rt[tot + 1]);
tmp1[++p1] = id[i];
pos[++tot] = b[id[i]].x1;
} else {
tmp2[++p2] = id[i];
}
} else {
int x, y, w;
x = std::lower_bound(pos + 1, pos + 1 + tot, b[id[i]].x1) - pos;
y = std::upper_bound(pos + 1, pos + 1 + tot, b[id[i]].x2) - pos - 1;
w = T.query(b[id[i]].y1, b[id[i]].y2, 1, n, T.rt[x - 1], T.rt[y]);
if (w >= b[id[i]].k) {
tmp1[++p1] = id[i];
} else {
b[id[i]].k -= w;
tmp2[++p2] = id[i];
}
}
}
for (int i = 1; i <= p1; ++i)
id[s + i - 1] = tmp1[i];
for (int i = 1; i <= p2; ++i)
id[s + p1 + i - 1] = tmp2[i];
binary_search(l, mid, s, s + p1 - 1);
binary_search(mid + 1, r, s + p1, t);
}
int main() {
//freopen("in", "r", stdin);
n = in(), q = in();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
b[++m] = (info){0, i, j, 0, 0, in()};
mp[++nn] = b[m].k;
}
for (int i = 1; i <= q; ++i)
b[++m] = (info){i, in(), in(), in(), in(), in()};
for (int i = 1; i <= m; ++i)
id[i] = i;
std::sort(mp + 1, mp + 1 + nn);
nn = std::unique(mp + 1, mp + 1 + nn) - mp - 1;
binary_search(0, nn, 1, m);
for (int i = 1; i <= q; ++i)
printf("%d\n", res[i]);
return 0;
} T2、Tree
题目链接
给定一张 \(n \ (n \leq 100)\) 个点 \(m \ (m \leq 2000)\) 条边的无相连通图，有边权 \(C_i \ (0 \leq C_i \leq 100)\)，求最小标准差生成树。
\(Sol\)：
可以将答案看做一个关于平均数的函数：
\[ f(x) = \sqrt{ \frac{\sum (C_i - x) ^ 2}{n - 1} } \]
枚举 \(x\)，将边权设为 \(C_i - x\)，求最小生成树，再按最小生成树的真实平均数更新答案。
具体证明我不会，大概是对于每个 \(x\) 得到的真实平均值一定是与 \(x\) 相邻的。
时间复杂度 \(O(\)能跑多少跑多少\()\)。
\(Source\)：
#include
#include
#include
typedef double db;
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 N = 105, M = 2005;
const db eps = 1e-5;
db res, now;
int n, m;
int fa[N];
struct edge {
int u, v, w;
inline bool operator < (const edge &b) const {
return (this->w - now) * (this->w - now) < (b.w - now) * (b.w - now);
}
} e[M];
int get_fa(int u) {
return fa[u] == u ? u : fa[u] = get_fa(fa[u]);
}
void calc() {
res = 1 << 30;
for (now = 100; now > 0; now -= 0.25) {
std::sort(e + 1, e + 1 + m);
int now_edge = 0, _sum = 0, sum = 0;
for (int i = 1; i <= n; ++i)
fa[i] = i;
for (int i = 1; i <= m && now_edge < n - 1; ++i) {
int fx = get_fa(e[i].u), fy = get_fa(e[i].v);
if (fx == fy)
continue;
fa[fx] = fy;
++now_edge;
_sum += e[i].w * e[i].w, sum += e[i].w;
}
db tmp = sqrt(((db)(n - 1) * _sum - sum * sum) / (n - 1) / (n - 1));
if (res - tmp > eps)
res = tmp;
}
}
int main() {
//freopen("in", "r", stdin);
n = in(), m = in();
if (n == 1) {
puts("0.0000");
return 0;
}
for (int i = 1; i <= m; ++i)
e[i] = (edge){in(), in(), in()};
calc();
printf("%.4lf\n", res);
return 0;
} T3、Points and Segments
题目链接
数轴上给定 \(n \ (n \leq 10 ^ 5)\) 条线段，每条线段为红色或蓝色，给出一种颜色方案，使得数轴上所有点被不同颜色覆盖的次数差绝对值不超过 \(1\)。
\(Sol\)：
可以把原数轴上的点看作线段，点被颜色覆盖可以看作线段被覆盖；
题目中\([l,r]\) 线段就可以当作新图中 \([l,r + 1]\) 中所有线段被覆盖。
问题转化为所有线段被覆盖的绝对值不超过 \(1\)；
\(l\) 向 \(r + 1\) 连无向边，\(l\) 到 \(r + 1\) 即为染成蓝色，否则染成红色；
这样如果该图有欧拉回路 (所有点都是偶点)，则两色覆盖次数都相等；
若有奇点，那么奇点个数一定是偶数 (一条线段有两个端点)，则从左到右第 \(2i\) 和 \(2i + 1\) 个奇点连边；
该图一定有欧拉回路，所有被覆盖的次数都相等；
因为新加的边之间一定不会相交，所以把他们删掉后每个点只会少覆盖一次。
时间复杂度 \(O(n)\)。
\(Source\)：
#include
#include
#include
inline 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 N = 1e5 + 5;
struct node {
int l, r;
} a[N];
struct edge {
int next, to;
} e[N << 2];
int ecnt = 1, head[N << 1];
int n, nn, mp[N << 1], res[N], deg[N << 1];
bool vis[N << 1], used[N << 1];
inline void jb(const int u, const int v) {
e[++ecnt] = (edge){head[u], v}, head[u] = ecnt;
e[++ecnt] = (edge){head[v], u}, head[v] = ecnt;
++deg[u], ++deg[v];
}
void prep() {
for (int i = 1; i <= n; ++i) {
a[i] = (node){in(), in()};
mp[++nn] = a[i].l, mp[++nn] = a[i].r;
}
std::sort(mp + 1, mp + 1 + nn);
nn = std::unique(mp + 1, mp + 1 + nn) - mp - 1;
for (int i = 1; i <= n; ++i) {
a[i].l = std::lower_bound(mp + 1, mp + 1 + nn, a[i].l) - mp;
a[i].r = std::lower_bound(mp + 1, mp + 1 + nn, a[i].r) - mp;
jb(a[i].l, a[i].r);
}
int last = 0;
for (int i = 1; i <= nn; ++i)
if (deg[i] & 1) {
if (!last)
last = i;
else
jb(last, i), last = 0;
}
}
void dfs(const int u) {
used[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
if (!vis[i >> 1]) {
vis[i >> 1] = 1;
dfs(e[i].to);
if (u > e[i].to)
res[i >> 1] = 1;
else
res[i >> 1] = 0;
}
}
}
void work() {
for (int i = 1; i <= nn; ++i)
if (!used[i])
dfs(i);
}
int main() {
//freopen("in", "r", stdin);
n = in();
prep();
work();
for (int i = 1; i <= n; ++i)
printf("%d ", res[i]);
puts("");
return 0;
}