2024.9.15 J组模拟赛

T1矩阵赋值

算法分析

记录每行 / 列最后一次修改的值与时间，对于每个位置$（i,j）$ ，该位置的值仅取决于 $i$ 行 / 第 $j$ 列中最晚的修改。

时间复杂度为 $O(nm)$。

#include <bits/stdc++.h>

template < typename T >
inline void read(T &cnt) {
    cnt = 0; char ch = getchar(); bool op = 1;
    for (; ! isdigit(ch); ch = getchar())
        if (ch == '-') op = 0;
    for (; isdigit(ch); ch = getchar())
        cnt = cnt * 10 + ch - 48;
    cnt = op ? cnt : -cnt;
}

const int N = 1e3 + 10;

int n, m, q;
int l[N], h[N], timh[N], timl[N];

int main() {
    freopen("matrix.in", "r", stdin);
    freopen("matrix.out", "w", stdout);

    read(n), read(m), read(q);

    for (int i = 1; i <= q; ++ i) { // 记录时间戳
        int t, x, y;
        read(t), read(x), read(y);
        if (t == 1) h[x] = y, timh[x] = i;
        if (t == 2) l[x] = y, timl[x] = i;
    }

    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j)
            std::cout << ((timh[i] > timl[j]) ? h[i] : l[j]) << ' ';
        std::cout << '\n';
    }
    return 0;
}

T2 统计数字

算法分析

首先有个结论：Rabbit Number 各个数位上的数字一定$\le 3$ 。

证明如下：

若数字 $x$ 存在某数位 $a\ge 4$，则它在该位的贡献为 $a^2$，而原数的平方会导致该位自乘时进位，贡献变为 $a^2-10+1<a^2$，进而导致 $S(x^2)<S(x)\ast S(x)$，证毕。

利用上述结论枚举各个数位爆搜即可。

时间复杂度为 $O(4^9)$。

参考程序

#include <bits/stdc++.h>

template < typename T >
inline void read(T &cnt) {
    cnt = 0; char ch = getchar(); bool op = 1;
    for (; ! isdigit(ch); ch = getchar())
        if (ch == '-') op = 0;
    for (; isdigit(ch); ch = getchar())
        cnt = cnt * 10 + ch - 48;
    cnt = op ? cnt : -cnt;
}

int l, r, ans;

inline int S(long long x) {
    int res = 0;
    while (x) {
        res += x % 10;
        x /= 10;
    }
    return res;
}

inline void check(long long x) {
    if (S(x) * S(x) == S(x * x)) ans ++;
}

inline void dfs(long long x) { // 爆搜
    if (x > r) return;
    if (x >= l && x <= r) check(x);
    for (int i = (x) ? 0 : 1; i <= 3; ++ i) {
        dfs(x * 10 + i);
    }
}

int main() {
    freopen("rabbit.in", "r", stdin);
    freopen("rabbit.out", "w", stdout);
    read(l), read(r);
    dfs(0);
    std::cout << ans << '\n';
    return 0;
}

T3 摘果问题

算法分析

将时间当作边权，分两种情况连边：

1、 $i$向 $fi$ 连双向边，边权为欧几里得距离除以速度；
2、 $i$向 $j$ 连一条单向边（需要满足 $xi=xj$ 且 $yi>yj$），边权为$sqrt(2\ast (yi-yj)/g)$ 。

跑 Dijkstra 算法求出最短路即可（是否堆优化均可）。

时间复杂度为：$O(n^2)$（不进行堆优化） / $O(mlogm)$（进行堆优化，其中 $m$ 为边数）。

参考程序

#include <bits/stdc++.h>

template < typename T >
inline void read(T &cnt) {
    cnt = 0; char ch = getchar(); bool op = 1;
    for (; ! isdigit(ch); ch = getchar())
        if (ch == '-') op = 0;
    for (; isdigit(ch); ch = getchar())
        cnt = cnt * 10 + ch - 48;
    cnt = op ? cnt : -cnt;
}
const int N = 5000 + 5;
const int M = 25e6 + 5;
const double INF = 1e9;

int n, v;
int x[N], y[N], f[N];
int head[N], nxt[M], to[M], tot;
double val[M], dis[N];
bool vis[N];
std::priority_queue < std::pair < int, int > > Q;

inline void add(int u, int v, double w) {
    nxt[++ tot] = head[u];
    head[u] = tot;
    to[tot] = v;
    val[tot] = w;
}

inline double dist(int i, int j) {
    return std::sqrt(1.0 * (x[i] - x[j]) * (x[i] - x[j]) + 
                     1.0 * (y[i] - y[j]) * (y[i] - y[j]));
}

int main() {
    freopen("clever.in", "r", stdin);
    freopen("clever.out", "w", stdout);
    read(n), read(v);
    for (int i = 1; i <= n; ++ i)
        read(x[i]), read(y[i]), read(f[i]);
    for (int i = 1; i <= n; ++ i) { // 分两种情况连边
        if (f[i] != 0)
            add(i, f[i], dist(i, f[i]) / v),
            add(f[i], i, dist(f[i], i) / v);
        for (int j = 1; j <= n; ++ j)
            if (x[i] == x[j] && y[i] > y[j])
                add(i, j, std::sqrt(2.0 * (y[i] - y[j]) / 10));
    }
    for (int i = 2; i <= n; ++ i)
        dis[i] = 1.0 * INF;
    Q.push(std::make_pair(0, 1));
    while (Q.size()) { // Dijkstra 算法
        int u = Q.top().second; Q.pop();
        if (vis[u]) continue;
        vis[u] = 1;

        for (int i = head[u]; i; i = nxt[i]) {
            int v = to[i];
            if (dis[v] > dis[u] + val[i]) {
                dis[v] = dis[u] + val[i];
                if (! vis[v]) 
                    Q.push(std::make_pair(-dis[v], v));
            }
        }
    }

    printf("%.2lf\n", dis[n]);

    return 0;
}

T4 阴阳怪气

算法分析

算法一
特殊性质：$n\le 10$。

瞎暴搜，乱搞一下就有 $30$ 分了。

参考程序

#include <bits/stdc++.h>

template < typename T >
inline void read(T &cnt) {
    cnt = 0; char ch = getchar(); bool op = 1;
    for (; ! isdigit(ch); ch = getchar())
        if (ch == '-') op = 0;
    for (; isdigit(ch); ch = getchar())
        cnt = cnt * 10 + ch - 48;
    cnt = op ? cnt : - cnt;
}

const int N = 100100;

int n, m, d;
int a[N];
long long S[N], f[N];

int main() {
	freopen("sophistry.in", "r", stdin);
	freopen("sophistry.out", "w", stdout);

	read(n), read(d), read(m);
	for (int i = 1; i <= n; i ++)
		read(a[i]);

	for (int i = 1; i <= n; i ++) { // 预处理 S 数组
		S[i] = S[i - 1];
		if (a[i] <= m) S[i] += a[i];
	}
	for (int i = 1; i <= d + 1; i ++) // 决策集合为空，特殊处理
		f[i] = S[i - 1] + a[i];
	long long val = 0;
	for (int i = d + 2, j = 1; i <= n; i ++, j ++) { // 双指针
		if (a[j] > m) val = std::max(val, f[j] - S[j + d]); // 更新决策集合
		f[i] = S[i - 1] + a[i] + val; // 直接转移
	}

	long long ans = 0;
	for (int i = 1; i <= n; i ++) // 取最大值
		ans = std::max(ans, f[i]);

	printf("%lld\n", ans);

	return 0;
}