Toyota Programming Contest 2025（AtCoder Beginner Contest 389)

A - 9x9

题意：给你一个长度为$3$的乘法式，求答案。

直接求即可。

点击查看代码

void solve() {
    std::string s;
    std::cin >> s;
    std::cout << (s[0] - '0') * (s[2] - '0') << "\n";
}

B - tcaF

题意：求一个$n$，使得$n!=x$。

模拟即可。

点击查看代码

void solve() {
    i64 x;
    std::cin >> x;
    i64 n = 1, ans = 1;
    while (n < x) {
    	++ ans;
    	n *= ans;
    }

    std::cout << ans << "\n";
}

C - Snake Queue

题意：三种操作:

1. 每次再结尾插入一个长度为$l$的蛇。
2. 删除第一条蛇。
3. 问当前第$k$条蛇蛇头的位置。

用数组累加前缀和，模拟即可。

点击查看代码

void solve() {
    int q;
    std::cin >> q;
    std::vector<i64> sum{0};
    int l = 0;
    while (q -- ) {
    	int op;
    	std::cin >> op;
    	if (op == 1) {
    		int x;
    		std::cin >> x;
    		sum.push_back({sum.back() + x});
    	} else if (op == 2) {
    		++ l;
    	} else {
    		int k;
    		std::cin >> k;
    		std::cout << sum[l + k - 1] - sum[l] << "\n";
    	}
    }
}

D - Squares in Circle

题意：有一个无限的平铺大小为$1\times 1$的正方形的排名，你从一个正方形中心画了一个半径为$R$的圆，问有多少正方形被包含。

每个象限的的数量都是一样的，我们计算第一象限的数量乘四即可，枚举$x$坐标，那么我们的正方形坐标是$x+0.5$，实际是要我们求一个$(x+0.5)\times (x+0.5)+(y+0.5)\times (y+0.5)<=n$的最大$y$。直接计算后向上取整就是有多少个$y+0.5$可以选，注意不要选在轴上的正方形，每次加的数减一即可。

点击查看代码

void solve() {
	i64 n;
	std::cin >> n;
	i64 ans = 0;
	for (i64 i = 1; i < n; ++ i) {
		double x = i + 0.5;
		i64 t = std::round(std::sqrt(n * n - x * x)) - 1;
		ans += t;
	}

	ans = ans * 4 + 1 + 4 * (n - 1);
	std::cout << ans << "\n";
}

E - Square Price

题意：有$n$个商品，价格为$p_i$，如果你买$k$件要花费$k^2{p}_i$，你有$m$块，问最多买多少件物品。

对于一个物品，在我们买了$k-1$件的前提下，购买第$k$件需要$(k^2-(k-1{)}^2))p_i=(2\times k-1)p_i$元。那么我们可以二分一个价格，把低于这个价格的都买上，剩下的钱尽可能买$x+1$元的物品。因为我们二分的是最大的价格，所以价值为$x+1$一定存在，而且我买不完。

点击查看代码

using i128 = __int128;

void solve() {
    i64 n, m;
    std::cin >> n >> m;
    std::vector<i64> a(n);
    for (int i = 0; i < n; ++ i) {
    	std::cin >> a[i];
    }

    auto check = [&](i64 x) -> std::pair<i64, i64> {
    	i128 sum = 0;
    	i64 res = 0;
    	for (int i = 0; i < n; ++ i) {
    		i128 k = (x + a[i]) / (2 * a[i]);
    		sum += k * k * a[i];
    		res += k;
    		if (sum > m) {
    			return {-1, 0};
    		} 
    	}

    	return {sum, res};
    };

   	i64 l = 1, r = m;
   	while (l < r) {
   		i64 mid = l + r + 1 >> 1ll;
   		if (check(mid).first != -1) {
   			l = mid;
   		} else {
   			r = mid - 1;
   		}
   	}

   	auto [x, y] = check(l);
   	std::cout << y + (m - x) / (l + 1) << "\n";
}

F - Rated Range

题意：有$n$场比赛，每场比赛计分范围为$[l_i,r_i]$，如果你的当前分数在这个范围里，那么分数加$1$，否则不变。$q$次询问，问你初始分为$x$是，参加完$n$场比赛后的分数。

每次单独计算是$O(n)$的，我们考虑预处理所有分数的结果。
假设$f_i$表示一开始分数为$i$的分数处理到当前比赛的分数。那么一开始，每个分数$i$的分数就是$i$，那么如果参加范围为$[l_i,r_i]$的比赛，所有在这个范围内的分数都要加$1$，注意加$1$后$f$依然是递增的，也就是$f_i$永远小于等于$f_{i+1}$。那么问题变成了，在一个递增序列中，每次找大于等于$l_i$的第一个和小于等于$r_i$的最后一个，让这个区间里的数都加$1$。可以用线段树维护。

点击查看代码

#define ls (u << 1)
#define rs (u << 1 | 1)

struct Node {
	int l, r;
	int max, min;
	int lazy;
};

struct SegmentTree {
	std::vector<Node> tr;
	SegmentTree(int _n) {
		tr.assign(_n << 2, {});
		build(1, 1, _n);
	}

	void pushup(int u) {
		tr[u].max = std::max(tr[ls].max, tr[rs].max);
		tr[u].min = std::min(tr[ls].min, tr[rs].min);
	}

	void pushdown(Node & u, int v) {
		u.max += v;
		u.min += v;
		u.lazy += v;
	}

	void pushdown(int u) {
		if (tr[u].lazy) {
			pushdown(tr[ls], tr[u].lazy);
			pushdown(tr[rs], tr[u].lazy);
			tr[u].lazy = 0;
		}
	}

	void build(int u, int l, int r) {
		tr[u] = {l, r};
		int mid = l + r >> 1;
		if (l == r) {
			tr[u].max = tr[u].min = l;
			return;
		}

		build(ls, l, mid); build(rs, mid + 1, r);
		pushup(u);
	}

	void modify(int u, int l, int r, int v) {
		if (l <= tr[u].l && tr[u].r <= r) {
			pushdown(tr[u], v);
			return;
		}

		pushdown(u);
		int mid = tr[u].l + tr[u].r >> 1;
		if (l <= mid) {
			modify(ls, l, r, v);
		}

		if (r > mid) {
			modify(rs, l, r, v);
		}

		pushup(u);
	}

	int find_first(int x) {
		int u = 1;
		while (tr[u].l != tr[u].r) {
			pushdown(u);
			if (tr[ls].max >= x) {
				u = ls;
			} else {
				u = rs;
			}
		}

		int res = tr[u].l;
		u >>= 1;
		while (u) {
			pushup(u);
			u >>= 1;
		}

		return res;
	}

	int find_end(int x) {
		int u = 1;
		while (tr[u].l != tr[u].r) {
			pushdown(u);
			if (tr[rs].min <= x) {
				u = rs;
			} else {
				u = ls;
			}
		}

		int res = tr[u].l;
		u >>= 1;
		while (u) {
			pushup(u);
			u >>= 1;
		}

		return res;
	}

	int query(int u, int p) {
		if (tr[u].l == tr[u].r) {
			return tr[u].max;
		}

		pushdown(u);
		int mid = tr[u].l + tr[u].r >> 1;
		if (p <= mid) {
			return query(ls, p);
		}

		return query(rs, p);
	}
};


void solve() {
    int n;
    std::cin >> n;
    std::vector<int> l(n), r(n);
    for (int i = 0; i < n; ++ i) {
    	std::cin >> l[i] >> r[i];
    }

    SegmentTree tr(500000);
    for (int i = 0; i < n; ++ i) {
    	int L = tr.find_first(l[i]);
    	int R = tr.find_end(r[i]);
    	tr.modify(1, L, R, 1);
    }

    int q;
    std::cin >> q;
    while (q -- ) {
    	int x;
    	std::cin >> x;
    	std::cout << tr.query(1, x) << "\n";
    }
}