Posts on GoodCoder's Blog

katac4: An Exploration of Reinforcement Learning Based on AlphaZero

Sat, 28 Jun 2025 23:49:50 +0800

Preface

As the title suggests, this is an exploratory project of mine. Its purpose is not to achieve any specific result, but to learn through the process of experimentation. This article includes a brief technical report, as well as some insights and experiences gained along the way. The comment system is not yet set up, so if you have any thoughts or questions, please feel free to post them directly in the project’s Issues / Discussions.

Recently, I’ve been studying Reinforcement Learning (RL), and I’m particularly fond of the AlphaZero algorithm. It’s a general reinforcement learning algorithm that evolved from AlphaGo, which defeated world Go champion Lee Sedol in 2016. Some mainstream introductory books on reinforcement learning typically stop at methods like PPO, SAC, or DDPG (without covering the AlphaZero, MuZero series), which I personally believe is a significant omission.

Fundamentally, AlphaZero belongs to the category of Model-Based RL, which is inherently different from Model-Free RL represented by Q-learning and Actor-Critic. The key difference is its use of an environment model (a game simulator) to deduce the optimal policy through tree search, rather than gradually improving expected returns through extensive trial and error. A good environment model is crucial for the success of such algorithms; in board games, clear rules directly provide a perfect environment model. In contrast, the real physical world is incredibly complex and difficult to describe with simple rules, which has become a key bottleneck hindering the practical application of reinforcement learning. Meta’s recently open-sourced V-JEPA 2 is an important step towards building world models, and I highly recommend looking into it.

Due to limited computational resources, I chose Saiblo Connect Four as the game environment ¹. Its state space is relatively small, yet it has a certain level of complexity with no known winning strategy. Additionally, the platform features excellent traditional methods for comparison, allowing for a relatively objective assessment of the algorithm’s playing strength. I am very grateful to Tsinghua University for providing this platform, which not only meets the experimental needs of its students but also offers great convenience to enthusiasts outside the university.

Since my AI uses some algorithmic improvements from KataGo, I named it katac4. The code is fully open-source on GitHub.

As of the time of writing (2025.06.27), katac4 is firmly in first place on the game’s ladder with a commanding lead:

A Quick Look at AlphaZero

There are many easy-to-understand articles about AlphaZero online, so I will only provide a brief, more abstract overview here (with ideas referenced from the KataGo paper).

The algorithm generates training data through self-play guided by Monte Carlo Tree Search (MCTS). The search process involves repeatedly expanding the game tree: each time, starting from the root node, a path is followed to a leaf node. At node $n$, the child node $c$ that maximizes the following formula is chosen for the visit:

$$ \mathrm{PUCT}(c)=V(c)+c_\mathrm{PUCT}P(c) \frac{\sqrt{\sum_{c'}N(c')}}{1+N(c)} $$

Here, $V(c)$ is the average predicted utility value of all nodes in the subtree of $c$, $P(c)$ is the prior probability for the action corresponding to $c$ given by the neural network, $N(c)$ is the number of simulations previously run through node $c$, and the constant $c_\mathrm{PUCT}=1.1$; $c'$ represents all child nodes of $n$.

Unlike the $\epsilon$-greedy algorithm, AlphaZero enhances exploration by applying Dirichlet noise to the prior probabilities at the root node:

$$ P(c)=0.75P_{\text{raw}}(c)+0.25\eta $$

where $\eta$ is sampled from a Dirichlet distribution with parameter $\alpha=0.8$, and $P_{\text{raw}}$ represents the raw policy distribution given by the neural network.

Let the root of the search tree have $k$ child nodes $u_1,\dots,u_k$, corresponding to actions $a_1,\dots,a_k$. Then the visit distribution of MCTS is proportional to $N(u_i)$:

$$ \pi(a_k|s_t)=\frac{N(u_k)}{\sum_{i=1}^k N(u_i)} $$

This is the training target for the neural network and is also used to select the next move during self-play (sampled with a dynamically changing temperature $T$). Self-play starts from the initial board position. During inference (actual matches), the action with the highest probability in this distribution, i.e., the most visited one, is typically chosen directly.

The neural network takes the current board state $s_t$ as input and predicts the probability distribution of the next move $\pi$ and the win rate of the position $z$. Its loss function is:

$$ L=-c_g \sum_r z(r) \log(\hat z(r))-\sum_m \pi(m) \log(\hat \pi(m))+c_{L2} ||\boldsymbol\theta||^2 $$

where $r \in \{\text{win}, \text{loss}, \text{draw}\}$ represents the game outcome from the current player’s perspective, and the constants are $c_g=1.5, c_{L2}=3\times 10^{-5}$. The entire loss function is a weighted sum of the following three parts:

Cross Entropy between the win rate prediction and the actual result ²;
Soft Cross Entropy between the policy distribution prediction and the MCTS visit distribution;
L2 regularization on the neural network parameters $\boldsymbol\theta$.

Policy updates are done in an Off-policy manner, maintaining a replay buffer. After each self-play game is completed, the new experience data is added to the replay buffer, from which a mini-batch of size $B$ is sampled for gradient descent updates. The SGD with Momentum optimizer is used, with the learning rate adjusted according to the training phase.

Overall, AlphaZero is consistent with the core idea of policy iteration algorithms, but it uses MCTS to perform both policy evaluation and policy improvement tasks simultaneously.

Training, Annealing

The concept of annealing is crucial for successfully training an AlphaZero agent. This involves many details, and I recommend referring to the code. Here, I list a few key points:

The temperature for sampling actions from the visit distribution is $T=0.8^{1+step/boardsize}$. AlphaZero_Gomoku uses a constant $T=1$, which in practice proves to be completely wrong. In the late game, “one false move can lose the whole game.” Directly sampling actions based on the visit distribution would generate a large number of incorrect game outcome samples, causing the entire training to collapse.
For the policy given by the neural network, apply a temperature $T=\max(1.03,1.35\times0.66^{step/boardsize})$ at the root node. This ensures a certain level of exploration and enhances training stability.
Learning rate annealing. For the early stage of training ($5\%$ of iterations), use $1/3$ of the normal learning rate (to prevent large fluctuations). After $72\%$ of iterations, use $1/10$ of the normal learning rate (to maximize playing strength improvement).

Many of these hyperparameters are not necessarily optimal and were set somewhat arbitrarily, but their combination has proven effective. I hope they can provide some reference value.

Algorithm Optimizations

This sentence is from the Leela Zero project’s README. AlphaZero’s exploration process is inherently inefficient, but well-designed algorithmic optimizations can significantly shorten its training cycle. The methods in the KataGo paper, when used together, can improve training efficiency by ~50x. Below are some of the optimizations I used, some of which are from KataGo.

Gradient Accumulation

Our game environment, Saiblo Connect Four, has variable board sizes, with both width and height ranging in $[9,12]$. This results in a total of $16$ different board sizes.

To adapt to different board sizes, two improvements were made:

The neural network uses a fully convolutional (FCN) architecture ³, with the policy head’s output size matching the input state size.
When sampling from the replay buffer, instead of directly sampling $256$ examples, we sample $16$ examples for each board size. We perform a forward pass for the samples of each board size, calculate the gradients, and accumulate them. Then, a normal backward + step is performed.

KataGo uses board masking to adapt to different inputs, which involves tedious implementation details. I chose the simpler approach of gradient accumulation, which, although slightly less efficient, is much more convenient.

Action Space Pruning

The motivation for this method is very simple: manually filter out moves that can be proven to be strictly wrong, treating them as illegal moves and excluding them from MCTS calculations.

The implementation requires very minor code changes and can be summarized by two rules:

If I can win in one move, I must make that move;
If the opponent can win in their next move, I must block it.

This optimization is very simple yet significantly speeds up exploration in the early stages of training, allowing the model to quickly understand the game’s rules. It also helps avoid some bad blind spots, especially when an opponent forms a threat of three near the edge of the board, which a CNN might overlook.

First Play Urgency (FPU)

A careful reader might ask: when calculating PUCT, if a child node has not been visited, i.e., $N(c)=0$, how is $V(c)$ defined?

AlphaGo Zero provides the standard answer: $V(c)=0$. However, the Leela Zero community found that this is not the optimal choice. They chose:

$$ V(c)=V(n)-c_\text{FPU}\sqrt{P_\text{explored}} $$

where $n$ is the parent node, the constant $c_\text{FPU}=0.2$, and $P_\text{explored}$ is the sum of the prior probabilities of all child nodes that have been visited at least once:

$$ P_\text{explored}=\sum_{c'|N(c')>0} P(c') $$

Readers can ponder the rationale behind this approach. A discussion on Lc0’s GitHub points out that for a strong neural network, this method can lead to an improvement of ~200 Elo.

Playout Cap Randomization

The two output heads in AlphaZero require different numbers of playouts for optimal training. Some informal studies suggest that the most efficient number of simulations for training the policy head is very close to AlphaZero’s $N=800$, but in the first version of AlphaGo, even $N=1$ was sufficient to train a decent value head. To alleviate the tension between the two, we choose a smaller number of simulations $n < N$ and perform a fast search ($n$ simulations) with probability $p$, and a normal full search ($N$ simulations) otherwise. Samples generated from fast searches are not used for policy training⁴.

My hyperparameter choices are $(N,n)=(800,160)$ and $p=0.25$. I personally feel that for a game like Connect Four, the number of simulations could probably be even smaller.

Forced Playouts & Policy Target Pruning

As mentioned earlier, AlphaZero introduces Dirichlet noise at the root node to enhance exploration. However, this method does not guarantee that good moves will definitely be discovered.

Imagine the following scenario:

Game state $s_t$. The current neural network strongly favors move $a$, while the actual optimal move is $a^*$. In the output policy distribution, $a$ gets over $80\%$ probability, while $a^*$ gets less than $5\%$.
Dirichlet noise is introduced. The probability of $a$ is still very high, while $a^*$ is “selected” and rises to $10\%$. Let’s assume $P(a)$ is now exactly $80\%$.
MCTS visits $a$ and $a^*$ in sequence. The value network still doesn’t favor the state $s^*$ reached by $a^*$, preferring the state $s$ from move $a$, giving $V(s^*)=-0.8$ and $V(s)=-0.1$.
The total number of simulations is now $N=2$. According to the PUCT formula, we have $\text{PUCT}(a)=0.34$ and $\text{PUCT}(a^*)=-0.745$. The PUCT values are already vastly different. If MCTS continuously selects $a$ for visits and $V(s)$ remains unchanged, it would take nearly $200$ simulations before $\text{PUCT}(a^*)\ge\text{PUCT}(a)$. By then, $1/4$ of the simulations have been wasted. And if $a^*$ is given a poor evaluation again, it would take a long time to get another visit.

This shows that even if Dirichlet noise luckily falls on the correct move, the combined blind spots of the policy and value networks may still not be handled correctly. Therefore, we introduce a Forced Playouts mechanism to ensure that each child of the root node receives at least $\lceil n_\text{forced} \rceil$ visits:

$$ n_\text{forced}(c)=\left(kP(c)\sum_{c'}N(c')\right)^{1/2} $$

Following KataGo’s setting, the constant is $k=2$.

At the same time, to eliminate the significant noise introduced by both Dirichlet noise and Forced Playouts, we perform policy target pruning on the visit distribution after MCTS is complete:

Find the child $c^*$ with the most visits $N(c)$.
For other child nodes $c$, subtract as many visits as possible, ensuring that $\text{PUCT}(a^*) > \text{PUCT}(a)$ and that the number of subtracted visits does not exceed $n_\text{forced}(c)$.

I chose to directly solve the inequality to find the pruned visit count:

$$ N'(c)=\mathrm{clip}\left(\left\lceil\frac{P\sqrt N}{V+\text{PUCT}(c^*)}-1\right\rceil,N-n_\text{forced},N\right) $$

For readability, the formula above uses $N$ for $N(c)$, $P$ for $P(c)$, etc.

Below is a comparison of the effect with/without policy pruning from the KataGo paper. Black: $p \approx 2\times 10^{-4}$; Green: $p \approx 1$.


With Policy Pruning	Without Policy Pruning

Dynamic Replay Buffer

In off-policy reinforcement learning algorithms, the size of the replay buffer (number of samples it can hold) is mostly fixed, often set in the range of $[2^{14},2^{20}]$. We, however, adopt a sub-linear growth strategy:

$$ N_{\text{window}} = c \left( 1 + \beta \frac{ ( N_{\text{total}} / c ) ^ \alpha - 1} { \alpha } \right) $$

where $N_{\text{total}}$ is the total number of samples generated so far in the training process, and $c=250000, \alpha=0.75, \beta=0.4$. This is essentially applying a linear transformation to $f(n)=n^\alpha$ such that $f(c)=c$ and $f'(c)=\beta$. This allows for the rapid discarding of low-quality moves generated in the early stages and increases the diversity of training samples later on, effectively suppressing overfitting.

Monte Carlo Graph Search (MCGS)

See KataGo/docs/GraphSearch.md. Many thanks to David Wu for the easy-to-understand explanation; during this project, I even found a typo in it and fixed it with a PR 😆

The overall idea:

Implement Zobrist hashing for board positions. When expanding leaves, prioritize looking up identical state nodes in a hash table, turning the search tree into a DAG;
Calculate PUCT based on the visit counts of action edges (not nodes);
Use incremental updates during backpropagation:
$$ V(n) \larr \frac{1}{N(n)} \left(U(n)+\sum_c N(c)V(c)\right) $$
Note that $U(n)$, the utility estimate from the value network, is essential.

In practice, memory management for MCGS can be tricky. Fortunately, the search trees generated by AlphaZero are not very large, so I just do a DFS cleanup. Currently, MCTS is still used for training, while MCGS is used for inference.

Engineering Optimizations

Since the project code is 100% Python, achieving full resource utilization is nearly impossible. However, there are still some tricks to improve training efficiency.

Parallel Self-Play

This idea is easy to understand and can be applied to most mainstream reinforcement learning algorithms. Use multiple processes in parallel on different GPUs to collect training data and send the results to a main process for model updates.

Currently, I use a total of 20 different processes for self-play, distributed evenly across 4 GPUs. Note that you should use torch.multiprocessing instead of Python’s built-in multiprocessing module.

CUDA Graphs

This is another relatively general optimization technique that can be used in many machine learning applications. The principle is to send the entire computation graph to the GPU for execution, significantly reducing front-end/back-end interaction and kernel launch overhead ⁵. For smaller networks and batch sizes, CUDA Graphs can provide an unexpected speed boost.

The project’s root directory provides a (rudimentary) benchmark script. The results on a single RTX 4090 are as follows (batch_size=1 to simulate the self-play environment):

Category	Inference Method	Computation Speed (FPS)
Base	`torch.no_grad`	$249.1$
Base	`torch.inference_mode`	$265.9$
TorchScript	`torch.jit.script`	$271.5$
TorchScript	`torch.jit.trace`	$501.4$
CUDA Graphs	`torch.cuda.graph`	$3184.5$

Additionally, torch.compile(mode='reduce-overhead') can also achieve CUDA Graph-based inference. However, this API is not supported on Windows and has a compilation-time cost, making it less convenient than torch.cuda.graph.

Test Results

Training lasted for about 14 days, totaling $30000 \times 16$ iterations. First, here are the curves for Loss, Entropy (policy entropy), and episode_len (self-play game length) during training:

The loss and entropy decrease rapidly at the beginning and then stabilize (they don’t converge to $0$ because the data distribution is constantly changing); episode_len increases initially and then slightly decreases (possibly due to finding faster winning lines). Overall, this is in line with intuition and shows no unexpected behavior.

Next is the Elo⁶ rating curve, reflecting the actual playing strength:

Overall, the training process was very stable (approximately sub-linear growth), and the training eventually reached near-saturation.

The best traditional method for the same task, under the same computational power, has only about a 26% win rate against katac4’s best checkpoint, corresponding to a -182 Elo difference. As seen in the graph, we reached a comparable level with just 1/4 of the iterations (3 days of training).

In reality, this estimate is not precise—the Epoch 6500 checkpoint can also achieve a win rate of over 50% against it. The above graph is for reference only.

I am very grateful to this predecessor for recently open-sourcing his method; in the early stages of my project’s development, I was always curious how he managed to lead the leaderboard by such a margin. A few days ago, I read his project report and was surprised to learn that even traditional methods perform better with PUCT than with UCT. To be honest, if I weren’t allowed to use a neural network, I probably wouldn’t even make it to the first page of the overall rankings.

Here are the test results against the Saiblo platform’s sample AIs:

This result sometimes fails to run due to TLE. The strongest checkpoint has never lost (tested for $6\times100$ games), except for TLEs. The platform only has CPUs, so the inference solution uses TorchScript. However, import torch and torch.jit.load both have time overhead. When the evaluation server is under heavy load, it might TLE before the model even finishes loading. There’s really nothing I can do about this. (Sigh)

A few suggestions for the platform:

Support LibTorch, so I can write inference in C++ and eliminate the import time;
Provide some lightweight inference frameworks (like ONNX Runtime) to also alleviate slow loading issues.
As a fallback, the time limit for the first move could be relaxed a bit…

I also created a for-fun version called fastc4, which directly selects the move with the highest probability from the neural network’s output. This version is actually not bad either:

97% win rate against the sample AIs;
65% win rate against jiegec/FourChess;
48% win rate against frvdec (former rank 2);
45% win rate against Lionjump0723/connect4 (former rank 1).

After manually observing some games, I feel that the neural network cares more about long-term gains—it plans for many moves ahead and doesn’t care about local gains or losses. Traditional methods are naturally focused on short-term tactical calculations and appear much weaker when there is no obvious winning sequence. My AI often loses to other AIs in the first 25 moves due to a tactical blind spot, but by move 50, the position is almost completely under its control. The traditional algorithms are powerless in the late game due to early strategic mistakes. This is somewhat similar to the difference between Stockfish and Leela Chess Zero in chess engines—the former is a meticulous calculator, while the latter relies more on intuition.

I hope these insights can help with the future development of traditional AI methods. I also welcome everyone to play against and test katac4 on the platform:

katac4 (Epoch 29000): 96c96ac2389547958141d932d9279efc
katac4 (Epoch 30000): 2c9bd80e1e0e480a8f32214448880a62
katac4 (Epoch 6500): d4e85acaf1ab4025b3c6a7ebec4fd0f0
fastc4 (Epoch 29000): 941dafdce03640bfb7ceb3aa32613252

Future Improvement Directions

There are currently two main issues:

Low hardware utilization efficiency;
Many early-game blind spots in the model.

In the future, I will consider merging leaf states from different self-play games into one large batch, which should largely solve the first problem.

For the second problem, besides increasing the model size (the next model is planned to be b5c128nbt), there are some algorithmic optimizations yet to be implemented:

Add auxiliary policy heads (opponent’s next move distribution, game’s final move location, soft policy) to aid training;
Optimize the board state representation (positions of moves from more previous turns, positions of threats of two or three, etc.);
Discard fast game policy samples from Playout Cap Randomization;
Use importance sampling proportional to $D_\mathrm{KL}(\hat{\boldsymbol\pi}||\boldsymbol\pi)$ to focus training on incorrectly predicted positions;
Replace Batch Norm with Batch Renorm to prevent inconsistencies between the model’s training and inference behavior.

I’ll try to implement some of these if I have time this summer. Anyone who is interested is also welcome to contribute PRs with improvements. You are always welcome!

Getting Started with Wolfram Mathematica

Fri, 26 Jan 2024 17:12:00 +0800

Preface

Wolfram Mathematica (abbreviated as MMA) is a scientific computing software developed by Wolfram Research. This article introduces Mathematica’s interface, syntax, and basic applications. Similar software includes MATLAB and Maple.

Official MMA website: https://www.wolfram.com/mathematica/

Installation and activation guide: Mathematica Installation and Activation Tutorial - 科研小飞 (Zhihu)

This article is suitable for readers with basic programming knowledge. However, you can skip programming-related sections if needed. All screenshots are taken from Windows 11, Mathematica 13.3. (The latest version 14.0 was released in December 2023 with backward compatibility)

Interface

After installation and activation, create a new notebook to see the following interface:

Quick overview of MMA interface:

Key points:

Enter creates new lines; use Shift+Enter to execute code.
The red triangle on the left palette also executes code; the gray square stops computations.
MMA’s Notebook feature is primarily for computation rather than note-taking. Refer to official documentation for details.

Use Ctrl+Shift+I to show input form (code) and Ctrl+Shift+N for mathematical form. Detailed explanations follow.

Syntax

Mathematica is essentially a Wolfram Language (WL) interpreter. Let’s explore basic syntax and common commands.

Help Documentation

Query function documentation using ? Solve:

The ? operator displays brief help for any function. Click the i icon for detailed documentation (prioritizes offline docs, falls back to online docs). Access full documentation via Help -> Wolfram Documentation.

Comments

1

(* Comment *)

Comments use (* and *), similar to C/C++ /* */. Examples:

1
2


1 + 1 (*Hello*)
1 + (*World*)1 

Both lines execute as 1 + 1:

Brackets

Master bracket usage before learning functions!
Official reference: Using Brackets and Braces Correctly

Four bracket types in MMA:

Parentheses `()`

Group expressions and set operation precedence:

Square Brackets `[]`

Function calls and parameters:

Curly Braces `{}`

Create lists:

List operations will be explained later.

Double Brackets `[[]]`

Access list elements (shorthand for Part function):

Operations and Expressions

MMA supports basic mathematical operations:

Name	Symbol	Function Form	Math Form
Addition	`a + b`	`Plus[a, b]`	$a+b$
Subtraction	`a - b`	`Subtract[a, b]`	$a-b$
Multiplication	`a * b`¹	`Times[a, b]`	$a\times b$
Division	`a / b`	`Divide[a, b]`	$\frac ab$
Power	`a ^ b`	`Power[a, b]`	$a^b$
Modulo	-	`Mod[a, b]`	$a\bmod b$

Examples with numbers and symbols:

Expressions combine operations/function calls. MMA automatically reduces fractions and combines like terms but doesn’t expand expressions. Use Simplify or FullSimplify:

Boolean Expressions

Comparisons return True/False:

Variables and Constants

Declare variables with variable = value:

All declared variables in expressions get substituted. Variables can reference other variables:

Use Clear[variable] to unset variables:

Built-in constants:

Constant	Name	Approx. Value	Math Form
`Pi`	Pi	3.141592654	$\pi$
`E`	Euler’s number	2.718281828	$\mathrm e$
`I`	Imaginary unit	-	$i$
`Infinity`	Infinity	-	$\infty$
`Degree`	Degree	-	$\degree$

Functions

Invocation

Call functions using FunctionName[param1, param2, ...]:

Single-parameter functions can use postfix notation param // FunctionName:

Supports chaining:

Definition

Define functions with FunctionName[param1_, param2_, ...] := returnValue. Each parameter requires trailing underscore:

Built-in Functions

MMA has nearly 6000 built-in functions². Common ones include:

Numerical Evaluation N

N[expr]: Numerical value
N[expr, n]: n-digit precision

Trigonometric Functions

All trigonometric functions use radians. Add Degree for angles:

Equation Solving Solve/Reduce

Solve equations with Solve:

Solve inequalities with Reduce:

Reduce handles complex expressions:

Alternative Solvers NSolve/FindInstance

NSolve: Numerical solutions
FindInstance: Find specific solution instances

Optimization Maximize/Minimize

Minimize finds minima with conditions:

Maximize works similarly.

Differentiation D

D[f, x]: First derivative
D[f, {x, n}]: nth derivative
f'[x]: Shorthand

Integration Integrate

Integrate[f, x]: Indefinite integral
Integrate[f, {x, min, max}]: Definite integral
Multiple integrals supported

Expansion Expand/ExpandAll

Expand: Expands products and powers
ExpandAll: Expands nested expressions

Factorization Factor

Factor[poly]: Factor polynomials over integers.

Plotting Plot/Plot3D

Basic plotting examples:

Conclusion

When learning MMA, I struggled with fragmented tutorials online. This guide consolidates essential syntax and common pitfalls into one resource. Originally intended as a concise tutorial, it grew to 8000+ characters. Thanks for reading!

Future articles may explore Mathematica applications in mathematics and real-world problems. Stay tuned!

Multiplication can be written as a b (with space). Most spaces are optional in MMA, but multiplication spaces are mandatory (ab would be a single variable). ↩︎
https://www.wolfram.com/language/fast-introduction-for-programmers/en/built-in-functions/ ↩︎

UNIQUE VISION Programming Contest 2023 Christmas (AtCoder Beginner Contest 334) A~G Solutions

Sun, 24 Dec 2023 12:05:00 +0800

A - Christmas Present

Problem Summary

Given two positive integers $B,G$ ($1\le B,G\le 1000$ and $B\ne G$), determine which is larger.

Analysis

Just simulate.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int b, g;
 scanf("%d%d", &b, &g);
 puts(b > g? "Bat": "Glove");
 return 0;
}

B - Christmas Trees

Problem Summary

Given $A,M,L,R$.
For any integer $k$, Snuke places a Christmas tree at position $A+kM$ on the number line.
Find the number of trees in the interval $[L,R]$.

$-10^{18}\le A\le 10^{18}$
$1\le M\le 10^9$
$-10^{18}\le L\le R\le 10^{18}$

Analysis

Notice that for any integer $x$, there’s a tree at $x$ if and only if $x \equiv A \ (\bmod \ M)$. This can be transformed to $(x-A) \mid M$. Therefore, shift coordinates by $A$ and count multiples of $M$ in $[L-A, R-A]$.

Code

Note the handling of negative numbers in C++.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <cstdio>
using namespace std;

using LL = long long;

int main()
{
 LL a, l, r;
 int m;
 scanf("%lld%d%lld%lld", &a, &m, &l, &r);
 l -= a, r -= a;
 if(l < 0) l = -((-l) / m * m);
 else l = (l + m - 1) / m * m;
 if(r < 0) r = -((-r + m - 1) / m * m);
 else r = r / m * m;
 printf("%lld\n", (r - l) / m + 1);
 return 0;
}

C - Socks 2

Problem Summary

Given a sequence $S=(1,1,2,2,\dots,N,N)$ of length $2N$.
Remove one occurrence of each $A_1,\dots,A_K$ from $S$, leaving $2N-K$ numbers.
Pair these remaining numbers (possibly with one unpaired) to minimize the sum of absolute differences. Output this minimum sum.

$1\le K\le N\le 2\times 10^5$
$1\le A_1 < A_2 < \dots < A_K\le N$

Analysis

The $N-K$ complete pairs can be optimally matched as self-pairs. The remaining $K$ single elements must be paired optimally.

For even $K$, pair adjacent elements. For odd $K$, precompute prefix and suffix sums to efficiently find the optimal single element to exclude.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#define maxn 200005
using namespace std;

inline void setmin(int& x, int y)
{
 if(y < x) x = y;
}

int a[maxn], pre[maxn], suf[maxn];

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=1; i<=k; i++)
 scanf("%d", a + i);
 if(!(k & 1))
 {
 int ans = 0;
 for(int i=1; i<=k; i+=2)
 ans += a[i + 1] - a[i];
 printf("%d\n", ans);
 return 0;
 }
 for(int i=1; i<k; i+=2)
 pre[i] = pre[i + 1] = pre[i - 1] + a[i + 1] - a[i];
 for(int i=k-1; i>0; i-=2)
 suf[i] = suf[i + 1] = suf[i + 2] + a[i + 1] - a[i];
 int ans = 1e9;
 for(int i=1; i<=k; i++)
 {
 int cur = i & 1? pre[i - 1] + suf[i + 1]
 : a[i + 1] - a[i - 1] + pre[i - 2] + suf[i + 2];
 setmin(ans, cur);
 }
 printf("%d\n", ans);
 return 0;
}

D - Reindeer and Sleigh

Problem Summary

Given $N$ sleighs with reindeer requirements $R_i$ and $Q$ queries, each asking the maximum number of sleighs that can be pulled with $X$ reindeer.

Analysis

Sort $R_i$ and compute prefix sums. For each query, use binary search to find the largest prefix sum ≤ $X$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#include <algorithm>
#define maxn 200005
using namespace std;

using LL = long long;
LL s[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%lld", s + i);
 sort(s, s + n);
 for(int i=1; i<n; i++)
 s[i] += s[i - 1];
 while(q--)
 {
 LL x;
 scanf("%lld", &x);
 printf("%d\n", int(upper_bound(s, s + n, x) - s));
 }
 return 0;
}

E - Christmas Color Grid 1

Problem Summary

A grid has red (.) and green (#) cells. Randomly paint one red cell green and compute the expected number of green connected components modulo 998244353.

Analysis

Use Union-Find to precompute green components. For each red cell, count adjacent distinct green components. The contribution to the expectation is the original count minus (adjacent components - 1).

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


#include <cstdio>
#include <unordered_map>
#include <set>
#include <atcoder/modint>
#define maxn 1005
using namespace std;

using modint = atcoder::modint998244353;

int n, m, fa[maxn * maxn];
char s[maxn][maxn];

int find(int x) { return fa[x] == x? fa[x]: fa[x] = find(fa[x]); }
inline int calc(int x, int y) { return x * m + y; }
inline int fc(int x, int y) { return find(calc(x, y)); }
inline void merge(int x, int y) { fa[find(x)] = find(y); }

int main()
{
 scanf("%d%d", &n, &m);
 for(int i=0; i<n; i++)
 scanf("%s", s[i]);
 int k = n * m;
 for(int i=0; i<k; i++)
 fa[i] = i;
 for(int i=0; i<n; i++)
 for(int j=0; j<m; j++)
 {
 if(s[i][j] != '#') continue;
 if(i && s[i - 1][j] == '#') merge(calc(i, j), calc(i - 1, j));
 if(j && s[i][j - 1] == '#') merge(calc(i, j), calc(i, j - 1));
 }
 int cnt = 0, tot = 0;
 for(int i=0; i<n; i++)
 for(int j=0; j<m; j++)
 if(s[i][j] == '#' && fc(i, j) == calc(i, j))
 cnt ++;
 modint ans = 0;
 for(int i=0; i<n; i++)
 for(int j=0; j<m; j++)
 if(s[i][j] == '.')
 {
 set<int> S;
 if(i && s[i - 1][j] == '#') S.insert(fc(i - 1, j));
 if(s[i + 1][j] == '#') S.insert(fc(i + 1, j));
 if(j && s[i][j - 1] == '#') S.insert(fc(i, j - 1));
 if(s[i][j + 1] == '#') S.insert(fc(i, j + 1));
 int cur = cnt - (int)S.size() + 1;
 ans += cur, tot ++;
 }
 printf("%d\n", (ans / tot).val());
 return 0;
}

F - Christmas Present 2

Problem Summary

Santa delivers gifts in sequence, carrying up to $K$ gifts. Find the minimal travel distance starting and ending at home.

Analysis

Dynamic programming optimized with a deque and prefix sums. Maintain the minimal distance for each possible remaining gift count.

Code

Implementation 1: deque + multiset

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#include <deque>
#include <set>
#define maxn 200005
using namespace std;

using ld = long double;
const ld INF = 2e18l;

int x[maxn], y[maxn];

inline ld dis(int i, int j)
{
 return __builtin_hypotl(x[i] - x[j], y[i] - y[j]);
}

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<=n; i++)
 scanf("%d%d", x + i, y + i);
 deque<ld> f;
 multiset<ld> s;
 k --;
 for(int i=0; i<k; i++)
 f.push_back(INF), s.insert(INF);
 f.push_back(dis(0, 1)), s.insert(dis(0, 1));
 ld dt = 0;
 for(int i=2; i<=n; i++)
 {
 ld lt = *s.begin() + dis(i - 1, 0) + dis(0, i) + dt;
 s.erase(s.find(f.front())), f.pop_front();
 dt += dis(i - 1, i), lt -= dt;
 f.push_back(lt), s.insert(lt);
 }
 printf("%.15Lf\n", dt + *s.begin() + dis(n, 0));
 return 0;
}

Implementation 2: Monotonic Queue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
#include <deque>
#define maxn 200005
using namespace std;

int x[maxn], y[maxn];

inline double dis(int i, int j)
{
 return __builtin_hypotl(x[i] - x[j], y[i] - y[j]);
}

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<=n; i++)
 scanf("%d%d", x + i, y + i);
 deque<pair<double, int>> f;
 f.emplace_back(dis(0, 1), 1);
 double dt = 0;
 for(int i=2; i<=n; i++)
 {
 double lt = f.front().first + dis(i - 1, 0) + dis(0, i) + dt;
 if(f.front().second == i - k) f.pop_front();
 dt += dis(i - 1, i), lt -= dt;
 while(!f.empty() && f.back().first >= lt) f.pop_back();
 f.emplace_back(lt, i);
 }
 printf("%.15lf\n", dt + f.front().first + dis(n, 0));
 return 0;
}

G - Christmas Color Grid 2

Problem Summary

Randomly paint a green cell red and compute the expected number of green connected components modulo 998244353.

Analysis

Use Tarjan’s algorithm to identify articulation points. The removal of a non-articulation point increases the component count by its degree minus one.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <cstdio>
#include <vector>
#include <atcoder/modint>
#define maxn 1000005
using namespace std;

using modint = atcoder::modint998244353;

inline void setmin(int& x, int y)
{
 if(y < x) x = y;
}

vector<int> G[maxn];

inline void add(int x, int y)
{
 G[x].push_back(y);
 G[y].push_back(x);
}

int root, low[maxn], cnt, dfn[maxn], ncut[maxn];

void tarjan(int v)
{
 low[v] = dfn[v] = ++cnt;
 ncut[v] = v != root;
 for(int u: G[v])
 if(!dfn[u])
 {
 tarjan(u);
 if(low[u] >= dfn[v])
 ncut[v] ++;
 setmin(low[v], low[u]);
 }
 else setmin(low[v], dfn[u]);
}

char s[1005][1005];
int id[1005][1005];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=n; i++)
 scanf("%s", s[i] + 1);
 int num = 0;
 for(int i=1; i<=n; i++)
 for(int j=1; j<=m; j++)
 if(s[i][j] == '#')
 {
 id[i][j] = ++num;
 if(s[i - 1][j] == '#') add(num, id[i - 1][j]);
 if(s[i][j - 1] == '#') add(num, id[i][j - 1]);
 }
 int cc = -1;
 for(int i=1; i<=num; i++)
 if(!dfn[i])
 tarjan(root = i), cc ++;
 modint ans = 0;
 for(int i=1; i<=num; i++)
 ans += cc + ncut[i];
 printf("%d\n", (ans / num).val());
 return 0;
}

Postscript

First, wishing everyone a Merry Christmas in advance 🎉! From the title to the problem settings, this contest is intricately tied to Christmas, showing AtCoder’s meticulous preparation for this festive event 🎄.

Regrettably, during the contest, I solved A~E and G, submitting F just 51 seconds after the contest ended, which was AC. A near AK, but narrowly missed by under a minute 😅. Hoping to perform better next time, and best wishes to all contestants. Keep striving! 💪

Luogu P9754 [CSP-S 2023] Struct Solution

Sat, 02 Dec 2023 22:21:00 +0800

Problem Link
Luogu Blog Blog Garden

Basic Approach

This problem tests coding implementation skills. The core ideas are:

Recursive element creation allows up to $100^{100}$ distinct base-type elements. Even considering address limits, elements can reach $10^{18}$. Iteratively constructing each element is infeasible in time and space.
However, queries are limited. Only a small subset of elements are accessed during queries. Thus, maintain a list of top-level elements (not nested within others) and traverse hierarchically based on query addresses/names. Specific handling for four operations:
- For $op=1$: Store type info, compute size and alignment requirements, then output.
- For $op=2$: Track the first allocatable address. Align, compute, then output.
- For $op=3$: Start from top-level, traverse layers to compute address.
- For $op=4$: Start from top-level, compare current address ranges with target, then output element name.

Based on this, three storage approaches emerge:

Type names as identifiers: Intuitive but inefficient, discarded.
Map type names to indices: More efficient but cumbersome, discarded.
Store types as structs with pointers: Efficient and intuitive. Adopted.

Step-by-Step Explanation

Preparation

Define LL as long long, setmax(x, y) as x = max(x, y):

1
2
3
4
5
6


inline void setmax(int& x, int y)
{
 if(x < y) x = y;
}

using LL = long long;

Data Type Storage

Define struct DataType:

1
2
3
4
5
6
7


struct DataType
{
 const string name; // Type name
 LL size, actual_size; // Aligned size and actual data length
 int indent; // Alignment requirement
 vector<pair<DataType*, string>> members; // Members stored as <type pointer, name>
};

Alignment formula:

$$ {aligned\_addr} = \lceil \frac {addr} {indent} \rceil \times indent $$

1
2
3
4


inline LL shift(LL addr)
{
 return addr % indent? (addr / indent + 1) * indent: addr;
}

Maintenance after type definition:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


inline void maintain()
{
 size = indent = 0;
 for(const auto& m: members)
 {
 setmax(indent, m.first->indent);
 size = m.first->shift(size) + m.first->size;
 }
 actual_size = size;
 size = shift(size);
}

Store types via unordered_map:

1

unordered_map<string, DataType*> types;

Add base types:

1
2
3
4
5
6
7
8
9


auto add_base_type = [&](string name, int size) -> void {
 DataType* t = new DataType(name);
 t->size = t->indent = t->actual_size = size;
 types[name] = t;
};
add_base_type("byte", 1);
add_base_type("short", 2);
add_base_type("int", 4);
add_base_type("long", 8);

Operation 1: Define Type

Process input and compute alignment:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


string s;
int k;
cin >> s >> k;
DataType* type = new DataType(s);
types[s] = type;
type->members.resize(k);
for(auto& m: type->members)
{
 string t;
 cin >> t >> m.second;
 m.first = types[t];
}
type->maintain();
cout << type->size << ' ' << type->indent << '\n';

Operation 2: Define Element

Track current address and top-level elements:

1
2


LL cur_addr = 0LL;
vector<Object> toplevel_objects;

Object definition:

1
2
3
4
5
6


struct Object
{
 DataType* type; // Element type
 string name; // Element name
 LL addr; // Start address
};

Compute and save element:

1
2
3
4
5
6
7
8


Object obj;
string t;
cin >> t >> obj.name;
obj.type = types[t];
obj.addr = obj.type->shift(cur_addr);
cur_addr = obj.addr + obj.type->size;
toplevel_objects.push_back(obj);
cout << obj.addr << '\n';

Operation 3: Access Element

Split path and traverse layers:

1
2
3
4
5
6
7
8
9


inline void split(const string& s, char sep, vector<string>& res)
{
 string t;
 for(char c: s)
 if(c == sep)
 res.push_back(t), t.clear();
 else t += c;
 res.push_back(t);
}

Locate top-level element:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


string s;
cin >> s;
vector<string> ord;
split(s, '.', ord);
LL addr;
DataType* type;
for(auto& obj: toplevel_objects)
 if(obj.name == ord[0])
 {
 addr = obj.addr;
 type = obj.type;
 break;
 }

Traverse members:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


ord.erase(ord.begin());
for(string& s: ord)
 for(auto& m: type->members)
 {
 addr = m.first->shift(addr);
 if(m.second == s)
 {
 type = m.first;
 break;
 }
 addr += m.first->size;
 }
cout << addr << '\n';

Operation 4: Access Address

Locate containing top-level element:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


LL addr;
cin >> addr;
if(addr >= cur_addr)
{
 cout << "ERR\n";
 continue;
}
DataType* type = nullptr;
LL f_addr = 0LL;
string res;
for(auto& obj: toplevel_objects)
{
 if(addr < obj.addr) goto bad;
 if(addr < obj.addr + obj.type->size)
 {
 type = obj.type;
 res = obj.name;
 f_addr = obj.addr;
 break;
 }
}

Traverse nested members:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


while(addr < f_addr + type->actual_size && !type->members.empty())
 for(auto& m: type->members)
 {
 f_addr = m.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + m.first->size)
 {
 type = m.first;
 res.push_back('.');
 res += m.second;
 break;
 }
 f_addr += m.first->size;
 }
if(addr < f_addr + type->actual_size) cout << res << '\n';
else cout << "ERR\n";
continue;
bad: cout << "ERR\n";

Full Code

Contest code (as explained):

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180


#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

inline void setmax(int& x, int y)
{
 if(x < y) x = y;
}

using LL = long long;

struct DataType
{
 const string name;
 LL size, actual_size;
 int indent;
 vector<pair<DataType*, string>> members;
 inline DataType(const string& n): name(n) {}
 inline LL shift(LL addr)
 {
 return addr % indent? (addr / indent + 1) * indent: addr;
 }
 inline void maintain()
 {
 size = indent = 0;
 for(const auto& m: members)
 {
 setmax(indent, m.first->indent);
 size = m.first->shift(size) + m.first->size;
 }
 actual_size = size;
 size = shift(size);
 }
};

struct Object
{
 DataType* type;
 string name;
 LL addr;
};

inline void split(const string& s, char sep, vector<string>& res)
{
 string t;
 for(char c: s)
 if(c == sep)
 res.push_back(t), t.clear();
 else t += c;
 res.push_back(t);
}

int main()
{
 ios::sync_with_stdio(false); cin.tie(nullptr);
 unordered_map<string, DataType*> types;
 auto add_base_type = [&](string name, int size) -> void {
 DataType* t = new DataType(name);
 t->size = t->indent = t->actual_size = size;
 types[name] = t;
 };
 add_base_type("byte", 1);
 add_base_type("short", 2);
 add_base_type("int", 4);
 add_base_type("long", 8);
 int q;
 cin >> q;
 vector<Object> toplevel_objects;
 LL cur_addr = 0LL;
 while(q--)
 {
 int op;
 cin >> op;
 if(op == 1)
 {
 string s;
 int k;
 cin >> s >> k;
 DataType* type = new DataType(s);
 types[s] = type;
 type->members.resize(k);
 for(auto& m: type->members)
 {
 string t;
 cin >> t >> m.second;
 m.first = types[t];
 }
 type->maintain();
 cout << type->size << ' ' << type->indent << '\n';
 }
 else if(op == 2)
 {
 Object obj;
 string t;
 cin >> t >> obj.name;
 obj.type = types[t];
 obj.addr = obj.type->shift(cur_addr);
 cur_addr = obj.addr + obj.type->size;
 toplevel_objects.push_back(obj);
 cout << obj.addr << '\n';
 }
 else if(op == 3)
 {
 string s;
 cin >> s;
 vector<string> ord;
 split(s, '.', ord);
 LL addr;
 DataType* type;
 for(auto& obj: toplevel_objects)
 if(obj.name == ord[0])
 {
 addr = obj.addr;
 type = obj.type;
 break;
 }
 ord.erase(ord.begin());
 for(string& s: ord)
 for(auto& m: type->members)
 {
 addr = m.first->shift(addr);
 if(m.second == s)
 {
 type = m.first;
 break;
 }
 addr += m.first->size;
 }
 cout << addr << '\n';
 }
 else // op == 4
 {
 LL addr;
 cin >> addr;
 if(addr >= cur_addr)
 {
 cout << "ERR\n";
 continue;
 }
 DataType* type = nullptr;
 LL f_addr = 0LL;
 string res;
 for(auto& obj: toplevel_objects)
 {
 if(addr < obj.addr) goto bad;
 if(addr < obj.addr + obj.type->size)
 {
 type = obj.type;
 res = obj.name;
 f_addr = obj.addr;
 break;
 }
 }
 while(addr < f_addr + type->actual_size && !type->members.empty())
 for(auto& m: type->members)
 {
 f_addr = m.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + m.first->size)
 {
 type = m.first;
 res.push_back('.');
 res += m.second;
 break;
 }
 f_addr += m.first->size;
 }
 if(addr < f_addr + type->actual_size) cout << res << '\n';
 else cout << "ERR\n";
 continue;
 bad: cout << "ERR\n";
 }
 }
 for(auto it=types.begin(); it!=types.end(); it++)
 delete it->second;
 return 0;
}

Total: 180 lines (4.64KB), runtime 73ms.

Optimized version:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146


#include <bits/stdc++.h>
using namespace std;

using LL = long long;

struct DataType {
 const string name;
 LL size, actual_size;
 int indent;
 vector<pair<DataType*, string>> members;
 inline DataType(const string& n): name(n) {}
 inline LL shift(LL addr) {
 return addr % indent? (addr / indent + 1) * indent: addr;
 }
 inline void maintain() {
 size = indent = 0;
 for(const auto& m: members)
 {
 indent = max(indent, m.first->indent);
 size = m.first->shift(size) + m.first->size;
 }
 actual_size = size;
 size = shift(size);
 }
};

inline void split(const string& s, char sep, vector<string>& res) {
 string t;
 for(char c: s)
 if(c == sep) res.push_back(t), t.clear();
 else t += c;
 res.push_back(t);
}

int main() {
 ios::sync_with_stdio(false); cin.tie(nullptr);
 unordered_map<string, DataType*> types;
 auto add_base_type = [&](string name, int size) -> void {
 DataType* t = new DataType(name);
 t->size = t->indent = t->actual_size = size;
 types[name] = t;
 };
 add_base_type("byte", 1);
 add_base_type("short", 2);
 add_base_type("int", 4);
 add_base_type("long", 8);
 int q;
 cin >> q;
 vector<pair<DataType*, string>> toplevel_objects;
 LL cur_addr = 0LL;
 while(q--) {
 int op;
 cin >> op;
 if(op == 1) {
 string s;
 int k;
 cin >> s >> k;
 DataType* type = new DataType(s);
 types[s] = type;
 type->members.resize(k);
 for(auto& m: type->members) {
 string t;
 cin >> t >> m.second;
 m.first = types[t];
 }
 type->maintain();
 cout << type->size << ' ' << type->indent << '\n';
 }
 else if(op == 2) {
 string t, name;
 cin >> t >> name;
 DataType* type = types[t];
 cur_addr = type->shift(cur_addr);
 cout << cur_addr << '\n';
 cur_addr += type->size;
 toplevel_objects.emplace_back(type, name);
 }
 else if(op == 3) {
 string s;
 cin >> s;
 vector<string> ord;
 split(s, '.', ord);
 LL addr = 0LL;
 DataType* type;
 for(auto& obj: toplevel_objects) {
 addr = obj.first->shift(addr);
 if(obj.second == ord[0]) {
 type = obj.first;
 break;
 }
 addr += obj.first->size;
 }
 ord.erase(ord.begin());
 for(string& s: ord)
 for(auto& m: type->members) {
 addr = m.first->shift(addr);
 if(m.second == s) {
 type = m.first;
 break;
 }
 addr += m.first->size;
 }
 cout << addr << '\n';
 }
 else {
 LL addr;
 cin >> addr;
 if(addr >= cur_addr) {
 cout << "ERR\n";
 continue;
 }
 DataType* type = nullptr;
 LL f_addr = 0LL;
 string res;
 for(auto& obj: toplevel_objects) {
 f_addr = obj.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + obj.first->size) {
 type = obj.first;
 res = obj.second;
 break;
 }
 f_addr += obj.first->size;
 }
 while(addr < f_addr + type->actual_size && !type->members.empty())
 for(auto& m: type->members) {
 f_addr = m.first->shift(f_addr);
 if(addr < f_addr) goto bad;
 if(addr < f_addr + m.first->size) {
 type = m.first;
 res.push_back('.');
 res += m.second;
 break;
 }
 f_addr += m.first->size;
 }
 if(addr < f_addr + type->actual_size) cout << res << '\n';
 else cout << "ERR\n";
 continue;
 bad: cout << "ERR\n";
 }
 }
 for(auto it=types.begin(); it!=types.end(); it++)
 delete it->second;
 return 0;
}

146 lines (4.51KB).

Prefer Object struct for clarity, but optimized code is concise.

Postscript

Algorithms matter, but coding skills are equally crucial! OIers should practice heavy implementation problems to avoid penalties.

Key points for large simulations:

Clear variable names: Avoid unreadable single-letter names.
Use pointers confidently: They simplify type associations.
Structs over arrays: Improve readability when possible.
Readability over micro-optimizations: Unless necessary for time constraints.

Best wishes for NOIP 2023! ~~Please give a like qwq~~

AtCoder Beginner Contest 318 G - Typical Path Problem Solution

Sun, 03 Sep 2023 13:28:00 +0800

G - Typical Path Problem

Problem Statement

Given a simple undirected graph $G$ with $N$ vertices and $M$ edges, and three integers $A$, $B$, $C$.

Does there exist a simple path from vertex $A$ to $C$ that passes through $B$?

Constraints:

$3\le N\le 2\times 10^5$
$N-1\le M\le \min(\frac{N(N-1)}2,2\times 10^5)$
$1\le A,B,C\le N$ ($A$, $B$, $C$ are distinct)

Solution 1: Maximum Flow

We observe that a simple path $A\to B\to C$ exists if and only if there are two paths $B\to A$ and $B\to C$ that share no vertices except $B$. This can be modeled as a maximum flow problem.

Construct a directed graph $G'$ with $(2N+2)$ vertices:

Source: $s$
Sink: $t$
Entry points for each vertex in $G$: $x_1,\dots,x_N$
Exit points for each vertex in $G$: $y_1,\dots,y_N$

Edges are added as follows:

For each $1\le i\le N$, connect entry $x_i$ to exit $y_i$ with capacity $1$;
Connect source $s$ to $x_B$ (entry of $B$) with capacity $2$;
Connect exits $y_A$ and $y_C$ to sink $t$ with capacity $1$ each;
For each original edge $(u,v)\in E_G$, connect $y_u \to x_v$ and $y_v \to x_u$ with capacity $1$.

Compute the maximum flow from $s$ to $t$. If the flow equals $2$, the required paths exist.

Using Dinic’s algorithm, the time complexity is $\mathcal O(N+M)$ since the maximum flow is $2$.

Code Implementation

Notations:

Source: $s=0$
Sink: $t=2n+1$
Entry of $i$: $x_i=i$
Exit of $i$: $y_i=n+i$

AC Library Implementation

AtCoder Library provides a Dinic-based max flow implementation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#include <atcoder/maxflow>
using namespace std;

int main()
{
 int n, m, a, b, c;
 scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
 int s = 0, t = (n << 1) + 1;
 atcoder::mf_graph<int> G(t + 1);
 G.add_edge(s, b + n, 2);
 G.add_edge(a + n, t, 1);
 G.add_edge(c + n, t, 1);
 for(int i=1; i<=n; i++)
 G.add_edge(i, i + n, 1);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G.add_edge(x + n, y, 1);
 G.add_edge(y + n, x, 1);
 }
 puts(G.flow(s, t, 2) == 2? "Yes": "No");
 return 0;
}

Manual Dinic Implementation

Dinic’s algorithm achieves $\mathcal O(N+M)$ complexity for this graph. For algorithm details, refer to OI Wiki.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#define maxn 400005
#define maxm 1250005
using namespace std;

int n, s, t, head[maxn], cur[maxn], dis[maxn],
 cnt, w[maxm], to[maxm], nxt[maxm];

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

inline void add_flow(int u, int v, int f)
{
 add(u, v, f);
 add(v, u, 0);
}

inline bool bfs()
{
 memset(dis, -1, sizeof(int) * n);
 dis[s] = 0, cur[s] = head[s];
 queue<int> q;
 q.push(s);
 while(!q.empty())
 {
 int v = q.front(); q.pop();
 for(int i=head[v]; ~i; i=nxt[i])
 if(w[i])
 {
 int u = to[i];
 if(dis[u] == -1)
 {
 dis[u] = dis[v] + 1, cur[u] = head[u];
 if(u == t) return true;
 q.push(u);
 }
 }
 }
 return false;
}

int dfs(int v, int flow)
{
 if(v == t) return flow;
 int res = 0;
 for(int i=cur[v]; ~i && flow; i=nxt[i])
 {
 cur[v] = i;
 int u = to[i];
 if(w[i] && dis[u] == dis[v] + 1)
 {
 int k = dfs(u, min(flow, w[i]));
 w[i] -= k;
 w[i ^ 1] += k;
 flow -= k;
 res += k;
 }
 }
 return res;
}

int main()
{
 int n, m, a, b, c;
 scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
 s = 0, t = (n << 1) + 1, ::n = t + 1;
 memset(head, -1, sizeof(int) * ::n);
 add_flow(s, b + n, 2);
 add_flow(a + n, t, 1);
 add_flow(c + n, t, 1);
 for(int i=1; i<=n; i++)
 add_flow(i, i + n, 1);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 add_flow(x + n, y, 1);
 add_flow(y + n, x, 1);
 }
 int mf = 0;
 while(bfs()) mf += dfs(s, 2);
 puts(mf == 2? "Yes": "No");
 return 0;
}

Solution 2: Block Forest (Round-square Tree)

Correctness relies on:

For any simple path $A\to C$, if $B$ lies in any biconnected component along this path, then $A\to B\to C$ exists. Otherwise, no such path exists.

Construct the block forest (round-square tree) using Tarjan’s algorithm:

Build the block forest $T$ of $G$.
Find the unique simple path $A\to C$ in $T$.
Check if $B$ is adjacent to any square node (biconnected component) on this path.

Time complexity: $\mathcal O(N+M)$, with better practical performance than flow-based solutions.

Code Implementation

Tip: Allocate double-sized arrays for block forest nodes to avoid RE.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73


#include <cstdio>
#include <cstdlib>
#include <vector>
#define maxn 200005
using namespace std;

inline void setmin(int& x, int y)
{
 if(y < x) x = y;
}

vector<int> G[maxn], T[maxn << 1];

inline void add_edge(vector<int>* G, int x, int y)
{
 G[x].push_back(y);
 G[y].push_back(x);
}

int dfc, dfn[maxn], low[maxn], top, st[maxn], cnt;

void tarjan(int v)
{
 low[v] = dfn[v] = ++dfc;
 st[++top] = v;
 for(int u: G[v])
 if(!dfn[u])
 {
 tarjan(u);
 setmin(low[v], low[u]);
 if(low[u] == dfn[v])
 {
 add_edge(T, v, ++cnt);
 do add_edge(T, st[top], cnt);
 while(st[top--] != u);
 }
 }
 else setmin(low[v], dfn[u]);
}

int n, m, a, b, c, ct[maxn << 1];
void dfs(int v, int par)
{
 if(v > n)
 for(int u: T[v])
 ct[u] ++;
 if(v == c)
 {
 puts(ct[b]? "Yes": "No");
 exit(0);
 }
 for(int u: T[v])
 if(u != par)
 dfs(u, v);
 if(v > n)
 for(int u: T[v])
 ct[u] --;
}

int main()
{
 scanf("%d%d%d%d%d", &n, &m, &a, &b, &c);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 add_edge(G, x, y);
 }
 cnt = n;
 tarjan(1);
 dfs(a, -1);
 return 0;
}

Comparison

Comparison of three solutions:

Solution	Code Length	Running Time	Memory Usage
Max Flow (AC Library)¹	$523~\mathrm{B}$	$337~\mathrm{ms}$	$106480~\mathrm{KB}$
Max Flow (Dinic)²	$1650~\mathrm{B}$	$334~\mathrm{ms}$	$46980~\mathrm{KB}$
Block Forest³	$1142~\mathrm{B}$	$162~\mathrm{ms}$	$57824~\mathrm{KB}$

The block forest solution has the fastest runtime. AC Library implementation offers the shortest code, while manual Dinic uses the least memory.

TOYOTA MOTOR CORPORATION Programming Contest 2023#1 (AtCoder Beginner Contest 298) A~G Solutions

Wed, 19 Apr 2023 18:34:00 +0800

Long time no write-up. Here’s a quick one.

A - Job Interview

Problem Summary

Given a string $S$ of length $N$ consisting of o, -, and x.

Determine if $S$ satisfies:

Contains at least one o.
Contains no x.

$1\le N\le 100$

Approach

Straightforward simulation.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
using namespace std;

int main()
{
 while(getchar() != '\n');
 char c;
 bool ok = false;
 while((c = getchar()) != '\n')
 {
 if(c == 'x')
 {
 puts("No");
 return 0;
 }
 if(c == 'o')
 ok = true;
 }
 puts(ok? "Yes": "No");
 return 0;
}

Python ~~quick pass~~ one-liner

1
2
3


input()
s = input()
print('Yes' if 'o' in s and 'x' not in s else 'No')

Saved 208 characters (~~flees~~

B - Coloring Matrix

Problem Summary

Given two $N\times N$ binary matrices $A$ and $B$.

Rotate $A$ by 0°, 90°, 180°, or 270°, then check if for every cell where $A_{i,j}=1$, $B_{i,j}=1$.

$1\le N\le 100$

Approach

Simulate all four rotations as described in the problem statement.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#define maxn 105
using namespace std;

int a[maxn][maxn], b[maxn][maxn], c[maxn][maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 scanf("%d", a[i] + j);
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 scanf("%d", b[i] + j);
 for(int x=0; x<4; x++)
 {
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 c[i][j] = a[i][j];
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 a[i][j] = c[n - 1 - j][i];
 for(int i=0; i<n; i++)
 for(int j=0; j<n; j++)
 if(a[i][j] && !b[i][j])
 goto bad; // Avoid using goto (old habit), don't learn this
 puts("Yes");
 return 0;
 bad:;
 }
 puts("No");
 return 0;
}

C - Cards Query Problem

Problem Summary

Process $Q$ queries on $N$ boxes:

Insert card with number $i$ into box $j$.
Output all cards in box $i$ in sorted order (duplicates allowed).
Output all boxes containing card $i$ in sorted order (no duplicates).

$1\le N,Q\le 2\times 10^5$

Approach

Maintain a multiset per box for query type 2.
Maintain a set per card for query type 3.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
#include <set>
#define maxn 200005
using namespace std;

multiset<int> box[maxn];
set<int> has[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 while(q--)
 {
 int op, i;
 scanf("%d%d", &op, &i);
 if(op == 1)
 {
 int j;
 scanf("%d", &j);
 box[j].insert(i);
 has[i].insert(j);
 }
 else if(op == 2)
 {
 for(int x: box[i])
 printf("%d ", x);
 putchar('\n');
 }
 else if(op == 3)
 {
 for(int x: has[i])
 printf("%d ", x);
 putchar('\n');
 }
 }
 return 0;
}

D - Writing a Numeral

Problem Summary

Maintain a string $S$ (initially “1”) through $Q$ operations:

Append digit $x$ to $S$.
Remove the first character of $S$.
Output $S$ modulo $998244353$.

$1\le Q\le 6\times 10^5$

Approach

Maintain the current value modulo $P=998244353$ and track $10^{|S|}\bmod P$ to handle removals efficiently.

Code

Implementation 1: Using atcoder::modint and deque

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <cstdio>
#include <deque>
#include <atcoder/modint>
using namespace std;

using modint = atcoder::modint998244353;

int main()
{
 deque<int> s;
 s.push_back(1);
 int q;
 scanf("%d", &q);
 modint ans = 1;
 while(q--)
 {
 int op;
 scanf("%d", &op);
 if(op == 1)
 {
 int x;
 scanf("%d", &x);
 s.push_back(x);
 ans = ans * 10 + x;
 }
 else if(op == 2)
 {
 int x = s.front(); s.pop_front();
 ans -= x * modint(10).pow((int)s.size());
 }
 else printf("%d\n", ans.val());
 }
 return 0;
}

Implementation 2: Manual modular arithmetic with queue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <cstdio>
#include <queue>
#define MOD 998244353
using namespace std;

int main()
{
 int Q;
 scanf("%d", &Q);
 queue<int> q;
 q.push(1);
 int ans = 1, p = 1;
 while(Q--)
 {
 int op;
 scanf("%d", &op);
 if(op == 1)
 {
 int x;
 scanf("%d", &x);
 q.push(x);
 ans = (ans * 10LL + x) % MOD;
 p = p * 10LL % MOD;
 }
 else if(op == 2)
 {
 ans -= (long long) q.front() * p % MOD; q.pop();
 p = p * 299473306LL % MOD; // 299473306 is inverse of 10 modulo MOD
 if(ans < 0) ans += MOD;
 }
 else printf("%d\n", ans);
 }
 return 0;
}

E - Unfair Sugoroku

Problem Summary

Two players move on a board of $N$ cells. Takahashi starts at $A$, Aoki at $B$. Takahashi’s die has $P$ faces, Aoki’s has $Q$ faces. Compute Takahashi’s winning probability modulo $998244353$.

$2\le N\le 100$

Approach

DP with states $f_{i,j}$ (Takahashi’s turn) and $g_{i,j}$ (Aoki’s turn). Transition by averaging over possible dice outcomes.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <cstdio>
#include <algorithm>
#define MOD 998244353
#define maxn 105
using namespace std;

using LL = long long;
inline LL inv(LL x)
{
 int y = MOD - 2;
 LL res = 1LL;
 while(y)
 {
 if(y & 1) (res *= x) %= MOD;
 (x *= x) %= MOD, y >>= 1;
 }
 return res;
}

inline void add(int& x, int y)
{
 if((x += y) >= MOD)
 x -= MOD;
}

int f[maxn][maxn], g[maxn][maxn];

int main()
{
 int n, a, b, p, q;
 scanf("%d%d%d%d%d", &n, &a, &b, &p, &q);
 for(int i=0; i<n; i++)
 f[n][i] = g[n][i] = 1, f[i][n] = g[i][n] = 0;
 LL prob_p = inv(p), prob_q = inv(q);
 for(int i=n-1; i>=a; i--)
 for(int j=n-1; j>=b; j--)
 {
 for(int k=1; k<=p; k++)
 add(f[i][j], g[min(i + k, n)][j]);
 f[i][j] = f[i][j] * prob_p % MOD;
 for(int k=1; k<=q; k++)
 add(g[i][j], f[i][min(j + k, n)]);
 g[i][j] = g[i][j] * prob_q % MOD;
 }
 printf("%d\n", f[a][b]);
 return 0;
}

F - Rook Score

Problem Summary

Given $N$ non-zero grid cells, compute the maximum sum of a row and column (minus overlap) for any chosen cell.

$1\le N\le 2\times 10^5$

Approach

Track row sums and column sums. Use a max-heap to maintain column contributions adjusted for overlaps.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <vector>
#include <set>
#include <unordered_map>
using namespace std;

using LL = long long;
using pii = pair<int, int>;

unordered_map<int, vector<pii>> rows;
unordered_map<int, LL> col_sum;

template <typename T>
class MaxSet {
private:
 multiset<T> s;
public:
 inline void insert(const T& x) { s.insert(x); }
 inline void update(const T& old, const T& New) {
 s.erase(s.find(old));
 s.insert(New);
 }
 inline T max() { return *s.rbegin(); }
};

int main()
{
 int n;
 scanf("%d", &n);
 while(n--)
 {
 int x, y, v;
 scanf("%d%d%d", &x, &y, &v);
 rows[x].emplace_back(y, v);
 col_sum[y] += v;
 }
 MaxSet<LL> s;
 for(auto [_, sum]: col_sum)
 s.insert(sum);
 LL ans = 0LL;
 for(auto& [x, v]: rows)
 {
 for(auto [y, val]: v)
 s.update(col_sum[y], col_sum[y] - val);
 LL cur = s.max();
 for(auto [y, val]: v)
 s.update(col_sum[y] - val, col_sum[y]), cur += val;
 if(cur > ans) ans = cur;
 }
 printf("%lld\n", ans);
 return 0;
}

G - Strawberry War

Problem Summary

Partition a $H\times W$ grid into $T+1$ rectangles via $T$ cuts. Minimize the difference between maximum and minimum strawberry counts.

$1\le H,W\le 6$

Approach

Dynamic programming tracking minimal maximum value for each subrectangle and cut count. Enumerate all possible minimum values.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000000;
int main(){
 int H, W, T;
 cin >> H >> W >> T;
 vector<vector<long long>> s(H, vector<long long>(W));
 for (int i = 0; i < H; i++){
 for (int j = 0; j < W; j++){
 cin >> s[i][j];
 }
 }
 vector<vector<vector<vector<long long>>>> sum(H, vector<vector<vector<long long>>>(H + 1, vector<vector<long long>>(W, vector<long long>(W + 1, 0)));
 vector<long long> x;
 for (int i = 0; i < H; i++){
 for (int j = i + 1; j <= H; j++){
 for (int k = 0; k < W; k++){
 for (int l = k + 1; l <= W; l++){
 for (int m = i; m < j; m++){
 for (int n = k; n < l; n++){
 sum[i][j][k][l] += s[m][n];
 }
 }
 x.push_back(sum[i][j][k][l]);
 }
 }
 }
 }
 int cnt = x.size();
 long long ans = INF;
 for (int i = 0; i < cnt; i++){
 vector<vector<vector<vector<vector<long long>>>>> dp(T + 1, vector<vector<vector<vector<long long>>>>(H, vector<vector<vector<long long>>>(H + 1, vector<vector<long long>>(W, vector<long long>(W + 1, INF)))));
 for (int j = H - 1; j >= 0; j--){
 for (int k = j + 1; k <= H; k++){
 for (int l = W - 1; l >= 0; l--){
 for (int m = l + 1; m <= W; m++){
 if (sum[j][k][l][m] >= x[i]){
 dp[0][j][k][l][m] = sum[j][k][l][m];
 }
 for (int n = j + 1; n < k; n++){
 for (int o = 0; o < (n - j) * (m - l); o++){
 for (int p = 0; p < (k - n) * (m - l) && o + p < T; p++){
 dp[o + p + 1][j][k][l][m] = min(dp[o + p + 1][j][k][l][m], max(dp[o][j][n][l][m], dp[p][n][k][l][m]));
 }
 }
 }
 for (int n = l + 1; n < m; n++){
 for (int o = 0; o < (k - j) * (n - l); o++){
 for (int p = 0; p < (k - j) * (m - n) && o + p < T; p++){
 dp[o + p + 1][j][k][l][m] = min(dp[o + p + 1][j][k][l][m], max(dp[o][j][k][l][n], dp[p][j][k][n][m]));
 }
 }
 }
 }
 }
 }
 }
 ans = min(ans, dp[T][0][H][0][W] - x[i]);
 }
 cout << ans << endl;
}

[Algorithm Notes] Solving the Lowest Common Ancestor (LCA) Problem – Doubling Algorithm

Fri, 06 Jan 2023 23:03:00 +0800

Preface

The Lowest Common Ancestor, abbreviated as LCA, is the deepest node that is a common ancestor of two given nodes in a tree.

This algorithm has wide applications, such as efficiently solving the shortest path problem on trees.

For convenience, we denote the LCA of a node set $S=\{v_1,v_2,\ldots,v_n\}$ as $\text{LCA}(v_1,v_2,\ldots,v_n)$ or $\text{LCA}(S)$.

Example Problem: Luogu P3379 【Template】Lowest Common Ancestor (LCA)

Properties

$\text{LCA}(\{u\})=u$;
$u$ is an ancestor of $v$ if and only if $\text{LCA}(u,v)=u$;
If neither $u$ is an ancestor of $v$ nor $v$ is an ancestor of $u$, then $u$ and $v$ reside in two different subtrees of $\text{LCA}(u,v)$;
In pre-order traversal, $\text{LCA}(S)$ appears before all elements in $S$, while in post-order traversal, it appears after all elements in $S$;
The LCA of the union of two node sets is the LCA of their individual LCAs: $\text{LCA}(A\cup B)=\text{LCA}(\text{LCA}(A), \text{LCA}(B))$;
The LCA of two nodes always lies on the shortest path between them;
$d(u,v)=h(u)+h(v)-2h(\text{LCA}(u,v))$, where $d$ is the distance between two nodes on the tree, and $h$ represents the distance from a node to the root.

Solving Algorithms

Prerequisite 1: Adjacency List Storage of Trees

In simple terms, adjacency list storage means for each node, store all nodes directly reachable via one directed or undirected edge.

Traditional implementations use linked lists (or simulated linked lists), which can be cumbersome and error-prone. For better readability, we use vector from the STL.

1
2
3
4


#include <vector> // Requires STL vector
#define maxn 100005 // Maximum number of nodes

std::vector<int> G[maxn];

To add an undirected edge $u\leftrightarrow v$:

1
2


G[u].push_back(v);
G[v].push_back(u);

To add a directed edge $u\to v$:

1

G[u].push_back(v);

Traverse all nodes directly reachable from $v$:

1
2


for(int u: G[v])
 cout << u << endl;

Prerequisite 2: DFS Traversal & Node Depth Calculation

Both algorithms require preprocessing node depths.
The depth of a node is defined as its distance from the root.

Preprocessing all node depths is straightforward using a tree DP approach. Let $h_u$ denote the depth of node $u$:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#include <vector>
#define maxn 100005
using namespace std;

vector<int> G[maxn]; // Adjacency list
int depth[maxn]; // Depth of each node

void dfs(int v, int par) // dfs(current node, parent node)
{
 int d = depth[v] + 1; // Child depth = current depth + 1
 for(int u: G[v])
 if(u != par) // Without this check, infinite recursion occurs
 {
 depth[u] = d; // Update child depth
 dfs(u, v); // Continue DFS
 }
}

int main()
{
 // Build the graph
 // ...
 // Assume graph is stored in G:
 int root = 0; // Default root is node 0; adjust as needed
 dfs(root, -1); // Root has no parent (-1)
 return 0;
}

Naive Algorithm

Let $u,v$ be the nodes whose LCA is sought. Preprocess each node’s parent (denoted as $f_v$).

Steps:

Equalize depths of $u$ and $v$: Move the deeper node upward until both depths match.
While $u \ne v$: Set $u \gets f_u$, $v \gets f_v$.
When $u = v$, this value is the LCA.

Time Complexity:

Preprocessing: $\mathcal O(N)$ via DFS.
Per Query: Worst-case $\mathcal O(N)$, average $\mathcal O(\log N)$ (for random trees with height $\lceil\log N\rceil$).

Reference Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 500005
using namespace std;

vector<int> G[maxn];
int depth[maxn], par[maxn];

void dfs(int v)
{
 int d = depth[v] + 1;
 for(int u: G[v])
 if(u != par[v])
 {
 par[u] = v, depth[u] = d;
 dfs(u);
 }
}

int lca(int u, int v)
{
 if(depth[u] < depth[v])
 swap(u, v);
 while(depth[u] > depth[v])
 u = par[u];
 while(u != v)
 u = par[u], v = par[v];
 return u;
}

int main()
{
 int n, q, root;
 scanf("%d%d%d", &n, &q, &root);
 for(int i=1; i<n; i++)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[u].push_back(v);
 G[v].push_back(u);
 }
 par[root] = -1, depth[root] = 0;
 dfs(root);
 while(q--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 printf("%d\n", lca(u, v));
 }
 return 0;
}

This code results in TLE on the last four test cases due to worst-case $\mathcal O(NQ)$ complexity when $N,Q\le 5\times 10^5$.

Doubling Algorithm

The doubling algorithm improves the naive approach and is the classic LCA solution.

Preprocessing:

Let $\text{fa}_{x,i}$ denote the $2^i$-th ancestor of node $x$.
During DFS, preprocess $\text{fa}_{x,i}$:
- For $i=0$, $\text{fa}_{x,0}$ is the parent of $x$.
- For $i>0$, $\text{fa}_{x,i} = \text{fa}_{\text{fa}_{x,i-1}, i-1}$.

Query Steps:

Equalize depths using binary lifting.
If $u = v$ after equalizing, return $u$.
Simultaneously move $u$ and $v$ upward until their ancestors converge. The LCA is $\text{fa}_{u,0}$.

Time Complexity:

Preprocessing: $\mathcal O(N \log N)$.
Per Query: $\mathcal O(\log N)$.

Reference Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <cstdio>
#include <vector>
#include <cmath>
#define maxn 500005
using namespace std;

vector<int> G[maxn];
int fa[maxn][19]; // 2^19=524288
int depth[maxn];

void dfs(int v, int par)
{
 fa[v][0] = par;
 int d = depth[v] + 1;
 for(int i=1; (1<<i)<d; i++)
 fa[v][i] = fa[fa[v][i - 1]][i - 1];
 for(int u: G[v])
 if(u != par)
 depth[u] = d, dfs(u, v);
}

inline int lca(int u, int v)
{
 if(depth[u] < depth[v])
 u ^= v ^= u ^= v;
 int m = depth[u] - depth[v];
 for(int i=0; m; i++, m>>=1)
 if(m & 1)
 u = fa[u][i];
 if(u == v) return u; // This line is essential
 for(int i=log2(depth[u]); i>=0; i--)
 if(fa[u][i] != fa[v][i])
 u = fa[u][i], v = fa[v][i];
 return fa[u][0];
}

int main()
{
 int n, q, root;
 scanf("%d%d%d", &n, &q, &root);
 for(int i=1; i<n; i++)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[--x].push_back(--y);
 G[y].push_back(x);
 }
 depth[--root] = 0;
 dfs(root, -1);
 while(q--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 printf("%d\n", lca(--u, --v) + 1);
 }
 return 0;
}

Exercises

Problem: Luogu P8805 [Blue Bridge Cup 2022 National B] Computer Room
Solution: https://best-blogs.blog.luogu.org/solution-p8805

Summary

This article details LCA problem-solving using two algorithms. Comparison:

Algorithm	Preprocessing Time	Per Query Time¹	Space	Passes Example²?
Naive	$\mathcal O(N)$	$\mathcal O(N)$	$\mathcal O(N)$	❌
Doubling	$\mathcal O(N \log N)$	$\mathcal O(\log N)$	$\mathcal O(N \log N)$	✔️

Your support through likes and shares is appreciated!

Worst-case time complexity. ↩︎
Example: Luogu P3379 【Template】Lowest Common Ancestor (LCA) ↩︎

【Algorithm Notes】【Special Topic】RMQ Problems: Sparse Table/Fenwick Tree/Segment Tree

Thu, 05 Jan 2023 22:48:00 +0800

Preface

It’s been a while since the last update to the algorithm notes column. Just learned a new algorithm, so here’s an update…
This is also the first special topic of this column, covering three data structures. If you spot any issues, please feel free to point them out. Thanks!

About RMQ Problems

RMQ stands for Range Minimum/Maximum Query.

In this article, our algorithms focus on finding maximum values (minimum values follow similar logic). The problem statement is as follows:

Below, we’ll start with a brute-force approach and gradually introduce common solutions for RMQ problems.

Standard RMQ problems (all algorithms except brute-force can pass):

Luogu P1816 Loyalty (classic RMQ)
Luogu P2880 [USACO07JAN] Balanced Lineup G
Luogu P2251 Quality Inspection
Luogu P8818 [CSP-S 2022] Strategy Game (requires more thinking)

Solutions

Brute-Force

We first read the sequence $A$, then process each query by directly iterating through $A_l\dots A_r$.
Time complexity: $\mathcal O(\sum r_i-l_i)=\mathcal O(NQ)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio> 
#define maxn 100005 
using namespace std; 

int a[maxn]; 

int main() 
{ 
 int n, q; 
 scanf("%d%d", &n, &q); 
 for(int i=0; i<n; i++) 
 scanf("%d", a + i); 
 while(q--) 
 { 
 int l, r; 
 scanf("%d%d", &l, &r); 
 l --, r --; 
 int res = a[l]; 
 for(int i=l+1; i<=r; i++) 
 if(a[i] < res) 
 res = a[i]; 
 printf("%d ", res); 
 } 
 return 0; 
} 

However, when submitting to Luogu P1816…

Clearly, the time complexity is too high. Further optimization is needed.

Sparse Table

Sparse Table (ST) is a data structure for static RMQ problems.

ST table initialization takes $\mathcal O(N\log N)$, and each query takes $\mathcal O(1)$.

Storage Structure

ST table is essentially a 2D array of size $N\times\lceil\log N\rceil$, defined as:

$$ st[i][j]=\max\{A_i,A_{i+1},\dots,A_{i+2^j-1}\} $$

Here, $st[i][j]$ represents the maximum value of $2^j$ elements starting from $A_i$, using a doubling strategy.

Initialization

Fill the table using a DP-like approach:

$$ st[i][j]=\max\{st[i][j-1],st[i+2^{j-1}][j-1]\} $$

Fill by iterating $j$ first, then $i$. Total initialization time: $\mathcal O(N\log N)$.

Pseudocode:

1
2
3
4
5
6
7


function init() { 
 for i = 1 to N 
 st[i][0] = A[i] 
 for j = 1 to log2(N) 
 for i = 1 to (N + 1 - 2^j) 
 st[i][j] = max(st[i][j - 1], st[i + 2^(j-1)][j - 1]) 
} 

C++ implementation:

1
2
3
4
5
6
7
8


void init() 
{ 
 for(int i=0; i<n; i++) 
 st[i][0] = A[i]; 
 for(int j=1; j<=log2(n); j++) 
 for(int i=0; i+(1<<j)<=n; i++) // Note: <=n 
 st[i][j] = max(st[i][j - 1], st[i + (1 << j - 1)][j - 1]); 
} 

Query

For interval $[l,r)$, find two intervals $[l,a)$ and $[b,r)$ such that their union is exactly $[l,r)$. Let $k=\lfloor\log_2(r-l)\rfloor$:

1
2
3
4
5
6


// query(l, r) = max(A[l], ..., A[r - 1]) 
inline int query(int l, int r) 
{ 
 int k = log2(r - l); 
 return max(st[l][k], st[r - (1 << k)][k]); 
} 

Full Implementation

Complete code for Luogu P1816. Time complexity: $\mathcal O(Q+N\log N)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <cstdio> 
#include <cmath> 
#include <algorithm> 
#define maxn 100005 
using namespace std; 

int st[maxn][17]; // 2^17=131072 

void init(int n) 
{ 
 for(int j=1, t=log2(n); j<=t; j++) 
 for(int i=0; i+(1<<j)<=n; i++) 
 st[i][j] = min(st[i][j - 1], st[i + (1 << j - 1)][j - 1]); 
} 

inline int query(int l, int r) 
{ 
 int k = log2(r - l); 
 return min(st[l][k], st[r - (1 << k)][k]); // Note: min for this problem 
} 

int main() 
{ 
 int n, q; 
 scanf("%d%d", &n, &q); 
 for(int i=0; i<n; i++) 
 scanf("%d", st[i]); // Directly read into ST table 
 init(n); 
 while(q--) 
 { 
 int l, r; 
 scanf("%d%d", &l, &r); 
 printf("%d ", query(--l, r)); 
 } 
 return 0; 
} 

Runtime: $128\mathrm{ms}$
Memory: $6.90\mathrm{MB}$

Fenwick Tree

For Fenwick Tree basics, see this article. Here, we adapt it for RMQ.

Original Algorithm

Fenwick Tree supports prefixSum and update in $\mathcal O(\log N)$. It works for any associative operation.

Implementing prefixMax and update:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#define INF 2147483647 
#define lowbit(x) ((x) & -(x)) 
inline void setmax(int& x, int y) { if(y > x) x = y; } 

int n, A[N], bit[N]; 

// max(A[1], ..., A[i]) 
inline int prefixMax(int i) 
{ 
 int res = -INF; 
 for(; i>0; i-=lowbit(i)) 
 setmax(res, bit[i]); 
 return res; 
} 

// A[i] = max(A[i], val) 
inline void update(int i, int val) 
{ 
 for(; i<=n; i+=lowbit(i)) 
 setmax(bit[i], val); 
} 

RMQ Fenwick Tree

Define recursive rangeMax:

1
2
3
4
5
6
7
8


int rangeMax(int l, int r) 
{ 
 if(l == r) return A[l]; 
 int t = r - lowbit(r); 
 return t < l? 
 max(A[r], rangeMax(l, r - 1)): 
 max(bit[r], rangeMax(l, t)); 
} 

Non-recursive version for efficiency:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int rangeMin(int l, int r) 
{ 
 int res = INF; 
 while(l <= r) 
 { 
 int t = r - lowbit(r); 
 if(t < l) setmin(res, a[r--]); 
 else setmin(res, bit[r]), r = t; 
 } 
 return res; 
} 

Full Implementation

Solution for Luogu P1816. Time complexity: $\mathcal O(N+Q\log N)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <cstdio> 
#define maxn 100005 
using namespace std; 

#define INF 2147483647 
#define lowbit(x) ((x) & -(x)) 
inline void setmin(int& x, int y) { if(y < x) x = y; } 

int a[maxn], bit[maxn]; 

int rangeMin(int l, int r) 
{ 
 int res = INF; 
 while(l <= r) 
 { 
 int t = r - lowbit(r); 
 if(t < l) setmin(res, a[r--]); 
 else setmin(res, bit[r]), r = t; 
 } 
 return res; 
} 

inline void init(int n) 
{ 
 for(int i=1; i<=n; i++) 
 bit[i] = a[i]; 
 for(int i=1; i<=n; i++) 
 { 
 int j = i + lowbit(i); 
 if(j <= n) setmin(bit[j], bit[i]); 
 } 
} 

int main() 
{ 
 int n, q; 
 scanf("%d%d", &n, &q); 
 for(int i=1; i<=n; i++) 
 scanf("%d", a + i); 
 init(n); 
 while(q--) 
 { 
 int l, r; 
 scanf("%d%d", &l, &r); 
 printf("%d ", rangeMin(l, r)); 
 } 
 return 0; 
} 

Runtime: $135\mathrm{ms}$
Memory: $1.14\mathrm{MB}$

Segment Tree

Segment Trees handle a wider range of problems with $\mathcal O(N)$ initialization and $\mathcal O(\log N)$ per query.

Storage Structure

Stored as a heap-like array. Each node represents an interval.

1
2
3


#define ls(x) (x << 1) 
#define rs(x) (x << 1 | 1) 
#define par(x) (x >> 1) 

Build

Recursively construct left and right subtrees:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


void build(int l, int r, int p) 
{ 
 if(l == r) 
 { 
 c[p] = a[l]; 
 return; 
 } 
 int m = l + r >> 1; 
 build(l, m, ls(p)); 
 build(m + 1, r, rs(p)); 
 c[p] = min(c[ls(p)], c[rs(p)]); 
} 

Query

Recursively check overlapping intervals:

1
2
3
4
5
6
7
8


int query(int l, int r, int a, int b, int p) 
{ 
 if(a <= l && r <= b) return c[p]; 
 int m = l + r >> 1, res = INF; 
 if(m >= a) res = min(res, query(l, m, a, b, ls(p))); 
 if(m < b) res = min(res, query(m + 1, r, a, b, rs(p))); 
 return res; 
} 

Full Implementation

Solution for Luogu P1816. Time complexity: $\mathcal O(N+Q\log N)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio> 
#include <algorithm> 
#define maxn 100005 
using namespace std; 

#define INF 2147483647 
#define ls(x) (x << 1) 
#define rs(x) (x << 1 | 1) 
#define par(x) (x >> 1) 

int a[maxn], c[maxn << 2]; 

void build(int l, int r, int p) 
{ 
 if(l == r) 
 { 
 c[p] = a[l]; 
 return; 
 } 
 int m = l + r >> 1; 
 build(l, m, ls(p)); 
 build(m + 1, r, rs(p)); 
 c[p] = min(c[ls(p)], c[rs(p)]); 
} 

int query(int l, int r, int a, int b, int p) 
{ 
 if(a <= l && r <= b) return c[p]; 
 int m = l + r >> 1, res = INF; 
 if(m >= a) res = min(res, query(l, m, a, b, ls(p))); 
 if(m < b) res = min(res, query(m + 1, r, a, b, rs(p))); 
 return res; 
} 

int main() 
{ 
 int n, q; 
 scanf("%d%d", &n, &q); 
 for(int i=0; i<n; i++) 
 scanf("%d", a + i); 
 build(0, n - 1, 1); 
 while(q--) 
 { 
 int l, r; 
 scanf("%d%d", &l, &r); 
 printf("%d ", query(0, n - 1, --l, --r, 1)); 
 } 
 return 0; 
} 

Runtime: $163\mathrm{ms}$
Memory: $1.78\mathrm{MB}$

Summary

Comparison of algorithms:

Algorithm	Preprocessing Time	Query Time	Space	Passes Constraints?
Brute-Force	$\mathcal O(1)$	$\mathcal O(N)$	$\mathcal O(N)$	❌
Sparse Table	$\mathcal O(N\log N)$	$\mathcal O(1)$	$\mathcal O(N\log N)$	✔️
Fenwick Tree	$\mathcal O(N)$	$\mathcal O(\log N)$	$\mathcal O(N)$	✔️
Segment Tree	$\mathcal O(N)$	$\mathcal O(\log N)$	$\mathcal O(N)$	✔️

Performance on Luogu P1816:

Algorithm	Runtime	Memory	Code Length
Sparse Table	$128\mathrm{ms}$	$6.90\mathrm{MB}$	$625\mathrm B$
Fenwick Tree (non-recursive)	$135\mathrm{ms}$	$1.14\mathrm{MB}$	$786\mathrm B$
Segment Tree	$163\mathrm{ms}$	$1.78\mathrm{MB}$	$905\mathrm B$

ST Table is fastest but memory-heavy. Fenwick Tree balances speed and space. Segment Tree is versatile but slightly slower.

This concludes the article. Hope you found it helpful!
This is my first 10k-word article in 2023. Happy New Year!

AtCoder Beginner Contest 274 A~E Solution

Mon, 24 Oct 2022 08:30:00 +0800

Note: Why doesn’t this contest have an English name…

A - Batting Average

Problem Summary

Given integers $A$ and $B$, output $\frac BA$ rounded to three decimal places.

$1\le A\le 10$
$0\le B\le A$

Analysis

A warm-up problem. Use formatted output with printf or cout.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b;
 scanf("%d%d", &a, &b);
 printf("%.3Lf\n", (long double)b / a);
 return 0;
}

B - Line Sensor

Problem Summary

Given an $H\times W$ grid where each cell is . or #, count the number of # in each column and output the results.

$1\le H,W\le 1000$

Analysis

Maintain an array ans[W] to track counts per column. Accumulate during input.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <cstdio>
#define maxn 1005
using namespace std;

char s[maxn];
int ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(n--)
 {
 scanf("%s", s);
 for(int i=0; i<m; i++)
 if(s[i] == '#')
 ans[i] ++;
 }
 for(int i=0; i<m; i++)
 printf("%d ", ans[i]);
 return 0;
}

C - Ameba

Problem Summary

A tree with $2N+1$ nodes has root node 1. The tree is defined by sequence $A=(A_1,A_2,\dots,A_N)$:

Node $A_i$ is the parent of $2i$ and $2i+1$.

Compute the depth of each node.

$1\le N\le 2\times 10^5$
$1\le A_i\le 2i-1$

Solution 1

Construct the tree’s adjacency list from the sequence and compute depths via DFS from the root.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

vector<int> G[maxn << 1];
int dep[maxn << 1];

void dfs(int v, int par)
{
 for(int u: G[v])
 if(u != par)
 {
 dep[u] = dep[v] + 1;
 dfs(u, v);
 }
}

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<=n; i++)
 {
 int x;
 scanf("%d", &x);
 G[x].push_back(i << 1);
 G[x].push_back(i << 1 | 1);
 }
 dep[1] = 0;
 dfs(1, -1);
 for(int i=1; i<=(n<<1)+1; i++)
 printf("%d\n", dep[i]);
 return 0;
}

Solution 2 (Optimal)

Since $A_i$ is always processed before $2i$ and $2i+1$, compute depths directly during input:
depth[2*i] = depth[2*i+1] = depth[A[i]] + 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

int dep[maxn << 1];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<=n; i++)
 {
 int x;
 scanf("%d", &x);
 dep[i << 1] = dep[i << 1 | 1] = dep[x] + 1;
 }
 for(int i=1; i<=(n<<1)+1; i++)
 printf("%d\n", dep[i]);
 return 0;
}

D - Robot Arms 2

Problem Summary

Given $N$ and sequence $A=(A_1,A_2,\dots,A_N)$, determine if we can reach $(x,y)$ from $(0,0)$ in $N$ steps:

Step 1: Move $A_1$ units right to $(A_1,0)$
Step $i$ ($i>1$): Turn 90° left/right, then move $A_i$ units.

$2\le N\le 10^3$
$1\le A_i\le 10$
$-10^4\le x,y\le 10^4$

Analysis

Split the problem into independent x and y axes:

For the x-axis: Start at $A_1$, target $x$, moves $A_3,A_5,\dots$
For the y-axis: Start at $0$, target $y$, moves $A_2,A_4,\dots$

Use set-based DP to track reachable positions for each axis. Both axes must satisfy their targets.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <vector>
#include <set>
using namespace std;

inline bool check(vector<int>& v, int start, int target)
{
 set<int> s;
 s.insert(start);
 for(int d: v)
 {
 set<int> ls = s;
 s.clear();
 for(int x: ls)
 s.insert(x + d), s.insert(x - d);
 }
 return s.count(target);
}

int main()
{
 int n, x, y;
 scanf("%d%d%d", &n, &x, &y);
 vector<int> a(n);
 for(int& t: a) scanf("%d", &t);
 vector<int> dx;
 for(int i=2; i<n; i+=2)
 dx.push_back(a[i]);
 if(!check(dx, a[0], x)) { puts("No"); return 0; }
 vector<int> dy;
 for(int i=1; i<n; i+=2)
 dy.push_back(a[i]);
 puts(check(dy, 0, y)? "Yes": "No");
 return 0;
}

E - Booster

Problem Summary

In a 2D plane, visit all $N$ cities starting from $(0,0)$. Optional $M$ boosters double speed when collected. Compute the minimum time required.

Each city has coordinates $(X_i,Y_i)$, boosters $(P_i,Q_i)$. Initial speed is 1.

Analysis

Refer to Official Editorial for detailed approach.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <cmath>
#define maxn 17
using namespace std;

inline double ppow(int x) { return 1.0 / (1 << __builtin_popcount(x)); }
inline void setmin(double& x, double y)
{
 if(y < x) x = y;
}

double x[maxn], y[maxn], dp[maxn][1 << maxn];

int main()
{
 // Input
 int n, m;
 scanf("%d%d", &n, &m);
 m += n;
 for(int i=0; i<m; i++)
 scanf("%lf%lf", x + i, y + i);
 int mx = 1 << m;
 for(int i=0; i<m; i++)
 for(int s=0; s<mx; s++)
 dp[i][s] = 1e18;

 // DP: Initial state
 for(int i=0; i<m; i++)
 dp[i][1 << i] = hypot(x[i], y[i]);

 // DP: Transfer
 for(int s=1; s<mx; s++)
 {
 double coef = ppow(s >> n);
 for(int i=0; i<m; i++)
 {
 if(!(s >> i & 1)) continue;
 for(int j=0; j<m; j++)
 {
 if(s >> j & 1) continue;
 setmin(dp[j][s | (1 << j)],
 dp[i][s] + hypot(x[i] - x[j], y[i] - y[j])*coef);
 }
 }
 }

 // Output
 double ans = 1e18;
 for(int i=0, t=1<<n; i<m; i++)
 for(int s=t-1; s<mx; s+=t)
 setmin(ans, dp[i][s] + dp[i][1 << i] * ppow(s >> n));
 printf("%.10f\n", ans);
 return 0;
}

【Algorithm Notes】Detailed Explanation of Bitwise Operations

Tue, 18 Oct 2022 08:30:00 +0800

Preface

Suddenly realized that bitwise operations are quite useful, so I’m writing this article to share some insights…

Note: I’ve included all the bitwise operation concepts I could think of, so this article is quite lengthy, please bear with me! If any part is unclear or insufficiently detailed, feel free to supplement in the comments section. Thanks for your support!

Reference code in this article is written in C++.

Without further ado, let’s get started.

Basic Operations

Those with prior knowledge can skip this section.

Brief rules of bitwise operations:

Symbol	Name	Rule
`&`	Bitwise AND	1 only when both bits are 1
`\|`	Bitwise OR	0 only when both bits are 0
`^`	XOR	1 when bits differ, 0 when same
`~`	Bitwise NOT	Flip 0 to 1, 1 to 0
`<<`	Left Shift	Shift bits left, discard high bits, pad 0s on right
`>>`	Right Shift	Shift bits right, discard low bits, pad 0s on left (for unsigned)

Detailed explanations:

Bitwise NOT

Bitwise NOT (~x) is the simplest unary operation. Simply flip each bit of the operand. Examples:
~0011 = 1100
~1011 = 0100
Property: ~(~x) = x

Bitwise AND

Bitwise AND (x & y) takes two operands. For each corresponding bit pair:

x	y	`x & y`
0	0	0
0	1	0
1	0	0
1	1	1

Examples:
0011 & 1100 = 0000
1010 & 1011 = 1010

Properties:

Commutative: a & b = b & a
Associative: a & b & c = a & (b & c)
Idempotent: a & a = a
AND with 0: 0 & a1 & a2 & ... = 0
AND with all-1s: a & inf = a

Bitwise OR

Bitwise OR (x | y) takes two operands. For each corresponding bit pair:

x	y	`x \| y`
0	0	0
0	1	1
1	0	1
1	1	1

Examples:
1100 | 0011 = 1111
1010 | 0001 = 1011

Properties:

Commutative: a | b = b | a
Associative: a | b | c = a | (b | c)
Idempotent: a | a = a
OR with 0: a | 0 = a
OR with all-1s: a | inf = inf

XOR

XOR (x ^ y or $x\oplus y$) takes two operands. For each corresponding bit pair:

x	y	$x\oplus y$
0	0	0
0	1	1
1	0	1
1	1	0

Examples:
1000 ^ 1011 = 0011
0101 ^ 1010 = 1111

Properties:

Commutative: $a\oplus b=b\oplus a$
Associative: $a\oplus b\oplus c=a\oplus(b\oplus c)$
Self-inverse: $a\oplus a=0$
XOR with 0: $a\oplus 0=a$
Multiple XOR: $a\oplus b\oplus b=a\oplus 0=a$
XOR with all-1s: $a\oplus \infty=~a$
If $a\oplus b=c$, then $a\oplus c=b$.

Shifts

Shifts include left shift (<<) and right shift (>>).

a << b: Append b zeros to the right of a’s binary.
a >> b: Remove b bits from the right of a’s binary.

Properties:

(a << b) >> b = a (when no overflow)
a << b ≈ $a\times 2^b$
a >> b ≈ $\lfloor\frac{a}{2^b}\rfloor$

Exercises

Determine Power of Two

Problem: Given integer N, check if it’s a power of two.

Luogu P1100 High-Low Swap

Problem: Given 32-bit integer x, swap its high 16 bits and low 16 bits.

Solution: ans = (x >> 16) | (x << 16) Explanation:

Value	High 16	Low 16
x	A	B
x »16	0s	A
x «16	B	0s
ans	B	A

Note: Use 32-bit unsigned integer to allow natural overflow when shifting.

Reference code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 unsigned int x;
 scanf("%u", &x);
 printf("%u\n", (x >> 16) | (x << 16));
 return 0;
}

Find Unique Number

Given sequence A=(A₁,A₂,…,A₂ₙ₊₁) where N numbers appear twice and one appears once. Find the unique number.

- O(N) time, O(N) space solution
Count occurrences and find the singleton.

- O(N) time, O(1) space solution
Compute XOR sum S = A₁^A₂^…^A₂ₙ₊₁. All duplicates cancel out, leaving the unique number.

Reference code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <cstdio>
using namespace std;

int main()
{
 int n;
 scanf("%d", &n);
 n = (n << 1) + 1;
 int ans = 0;
 while(n--)
 {
 int x;
 scanf("%d", &x);
 ans ^= x;
 }
 printf("%d\n", ans);
 return 0;
}

AtCoder ABC 261 E - Many Operations

Solution: For each i=1..N, track how each bit of 0/1 transforms after first i operations using prefix-like approach. Time complexity O(N).

Reference code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// https://atcoder.jp/contests/abc261/submissions/33495431
#include <cstdio>
using namespace std;

int main()
{
 unsigned n, c, zero = 0, one = 0xffffffff;
 scanf("%d%d", &n, &c);
 while(n--)
 {
 int t, a;
 scanf("%d%d", &t, &a);
 if(t == 1) one &= a, zero &= a;
 else if(t == 2) one |= a, zero |= a;
 else one ^= a, zero ^= a;
 printf("%d\n", c = (c & one) | (~c & zero));
 }
 return 0;
}

Extended Concepts & Operations

lowbit

lowbit(x) returns the least significant 1-bit, e.g., lowbit(10010) = 10, lowbit(1) = 1. Used in Fenwick Trees.

Calculating lowbit

Brute force:

1
2
3
4
5
6
7


int lowbit(int x)
{
 int res = 1;
 while(x && !(x & 1))
 x >>= 1, res <<= 1;
 return res;
}

x & -x
x & (x - 1) gives x - lowbit(x).

popcount

popcount(x) counts the number of 1-bits.

Calculating popcount

Brute force:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


int popcount(int x)
{
 int res = 0;
 while(x)
 {
 res += x & 1;
 x >>= 1;
 }
 return res;
}

Optimized with lowbit:

1
2
3
4
5
6


int popcount(int x)
{
 int res = 0;
 for(; x; x&=x-1) res ++;
 return res;
}

Builtin functions (fastest)

Builtin Bitwise Functions

Note: Functions with ll suffix take long long arguments.

Reference: https://blog.csdn.net/zeekliu/article/details/124848210

__builtin_popcount/__builtin_popcountll

Returns number of 1-bits.

__builtin_ctz / __buitlin_ctzll

Count trailing zeros.

__buitlin_clz / __buitlin_clzll

Count leading zeros.

__builtin_ffs / __buitlin_ffsll

Find position of last set bit (1-indexed).

__builtin_parity / __builtin_parityll

Return parity (even/odd) of 1-bit count.

Applications of Bitwise Operations

Subset Representation

For set {0,1,…,N-1}, use N-bit integer S to represent subsets. Operations:

Empty set: 0
Full set: 2ᴺ-1
Size: __builtin_popcount(S)
Check element i: S >> i & 1
Add i: S |= 1 << i
Remove i (must exist): S ^= 1 << i
Remove i (any case): S &= ~(1 << i)
Intersection: S & T
Union: S | T
Symmetric difference: S ^ T

Subset Enumeration

- Enumerate all subsets

1

for(int s=0; s<(1<<N); s++)

- Enumerate subsets of a subset

1
2


for(int S=0; S<(1<<N); S++)
 for(int T=S; T; T=(T-1)&S)

Time complexity O(3ᴺ).

- Enumerate K-sized subsets
Optimized method from “Competitive Programming”:

1
2
3
4
5
6
7


int S = (1 << k) - 1;
while(S < 1 << n)
{
 // Process S
 int x = S & -S, y = S + x;
 S = ((S & ~y) / x >> 1) | y;
}

Extension: std::bitset

C++ STL’s bitset for large N:

Operation	Description
`b.any()`	True if any bit is set
`b.none()`	True if no bits are set
`b.count()`	Number of set bits
`b.size()`	Total bits
`b[pos]`	Access bit at pos
`b.test(pos)`	Check bit at pos
`b.set(pos)`	Set bit at pos
`b.set()`	Set all bits
`b.reset(pos)`	Clear bit at pos
`b.reset()`	Clear all bits
`b.flip()`	Flip all bits
`b.flip(pos)`	Flip bit at pos
`b.to_ulong()`	Convert to unsigned long
`os << b`	Output bit pattern

Exercise: AtCoder ABC 258 G - Triangle

Solution using bitset optimizations. See my explanation.

DFS Optimization with Bitwise Operations

N-Queens problem solved with bitwise optimizations:

Standard backtracking vs. optimized version:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// Standard backtracking
bool row[maxn], diag_left[maxn << 1], diag_right[maxn << 1];
void dfs(int i) { /* ... */ }

// Bitwise optimized
void dfs(int row, int diag_left, int diag_right)
{
 if(row == mx) { ans++; return; }
 int a = mx & ~(row | diag_left | diag_right);
 while(a) {
 int p = a & -a; a ^= p;
 dfs(row | p, (diag_left | p) >> 1, (diag_right | p) << 1);
 }
}

Performance comparison (for N=16):

Standard: 53.4s
Optimized: 6.23s

Exercise: Luogu P1092 [NOIP2004] Alphametic

Other Applications

Swap two numbers

1

void swap(int& a, int& b) { a ^= b ^= a ^= b; }

Average without overflow

1
2


int average1(int x, int y) { return (x >> 1) + (y >> 1) + (x & y & 1); }
int average2(int x, int y) { return (x & y) + ((x ^ y) >> 1); }

Check power of two

1

bool ispowof2(int x) { return x > 0 && !(x & x - 1); }

Conclusion

This article thoroughly explains bitwise operations and their applications.

If you found this helpful, please give a like and share! Thanks for reading!

【Algorithm Notes】Fenwick Tree/Binary Indexed Tree

Sat, 20 Aug 2022 20:08:00 +0800

Introduction

The Fenwick Tree, also known as Binary Indexed Tree (BIT), is a tree-like data structure. Despite its name, its applications often seem unrelated to trees:

To optimize summation, prefix sums come to mind, offering $\mathcal O(1)$ query time but $\mathcal O(N)$ update time. Conversely, naively storing all elements allows $\mathcal O(1)$ updates but $\mathcal O(N)$ queries. The solution? The Fenwick Tree.

Basic Algorithm

With $n,m\le 10^5$, an $\mathcal O(nm)$ brute-force approach is infeasible. The Fenwick Tree achieves $\mathcal O(M\log N)$ time. Its structure is illustrated below:

Let $B$ represent the internal storage. From the diagram:

$B_1=A_1$
$B_2=A_1+A_2$
$B_3=A_3$
$B_4=A_1+A_2+A_3+A_4$
…

Here, $B_i$ stores the sum $A_{i-2^k+1}+A_{i-2^k+2}+\dots+A_i$, where $k$ is the number of trailing zeros in $i$’s binary representation. This $2^k$ is the lowbit of $i$.

Using lowbit, we define:

$$ l:=i-\mathrm{lowbit}(i)+1\\ r:=i\\ B_i=\sum_{j=l}^{r} A_j $$

This allows $\mathcal O(\log n)$ prefix sums (prefixSum(x)) and updates (update(x, k)). Interval sums $[L,R]$ are computed as segmentSum(l, r) = prefixSum(r) - prefixSum(l - 1). Code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


#include <cstdio>
using namespace std;

template <typename value_type>
class fenwick_tree {
private:
 const int n;
 value_type* a;
 inline int lowbit(int x) { return x & -x; }
public:
 inline fenwick_tree(int m): n(m) {
 a = new value_type[n + 1];
 for(int i=0; i<=n; i++)
 a[i] = 0;
 }
 inline ~fenwick_tree() { delete[] a; }
 inline value_type prefixSum(int i) {
 value_type res = 0;
 for(; i; i-=lowbit(i)) res += a[i];
 return res;
 }
 inline value_type segmentSum(int l, int r) {
 return prefixSum(r) - prefixSum(l - 1);
 }
 inline void update(int i, const value_type& d) {
 for(; i<=n; i+=lowbit(i))
 a[i] += d;
 }
};

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 fenwick_tree<int> bit(n);
 for(int i=1; i<=n; i++)
 {
 int a;
 scanf("%d", &a);
 bit.update(i, a);
 }
 while(m--)
 {
 int op, x, y;
 scanf("%d%d%d", &op, &x, &y);
 if(op == 1) bit.update(x, y);
 else printf("%d\n", bit.segmentSum(x, y));
 }
 return 0;
}

On Luogu P3374, this code runs in $572\mathrm{ms}$, compared to ~$2.5\mathrm{s}$ for a segment tree implementation, highlighting the Fenwick Tree’s efficiency.

Extended Applications

Knowledge Prerequisite: Discretization
Given a sequence $A$, discretization maps elements to $[1,N]$ while preserving order. For $A=(A_1,\dots,A_N)$, discretized sequence $B=(B_1,\dots,B_N)$ satisfies:

$1\le B_i\le N$
$A_i < A_j \Rightarrow B_i < B_j$, $A_i = A_j \Rightarrow B_i = B_j$, $A_i > A_j \Rightarrow B_i > B_j$.

Counting Inversions

Inversion pairs can be counted using a Fenwick Tree after discretization.

After discretizing $A$ to $B$, use a Fenwick Tree to track occurrences. Traverse $B$ while maintaining a running count of elements ≤ current $B_i$, subtracting from the total possible pairs $\frac{N(N-1)}{2}$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


#include <cstdio>
#include <algorithm>
#define maxn 500005
using namespace std;

inline int read() {
 static char c;
 while((c = getchar()) < '0' && c > '9');
 int res = c ^ 48;
 while((c = getchar()) >= '0' && c <= '9')
 res = (res << 3) + (res << 1) + (c ^ 48);
 return res;
}

template <typename value_type>
class fenwick_tree {
private:
 const int n;
 value_type* a;
 inline int lowbit(int x) { return x & -x; }
public:
 inline fenwick_tree(int m): n(m) {
 a = new value_type[n + 1];
 for(int i=0; i<=n; i++)
 a[i] = 0;
 }
 inline ~fenwick_tree() { delete[] a; }
 inline value_type prefixSum(int i) {
 value_type res = 0;
 for(++i; i; i-=lowbit(i)) res += a[i];
 return res;
 }
 inline void update(int i, const value_type& d) {
 for(++i; i<=n; i+=lowbit(i))
 a[i] += d;
 }
};

int a[maxn], rk[maxn];

int main()
{
 int n = read();
 for(int i=0; i<n; i++)
 a[rk[i] = i] = read();
 stable_sort(rk, rk + n, [&](int x, int y) -> bool {
 return a[x] < a[y];
 }); // Use stable_sort to handle duplicates
 fenwick_tree<int> bit(n);
 long long ans = n * (n - 1LL) >> 1LL;
 for(int i=0; i<n; i++)
 {
 ans -= bit.prefixSum(rk[i]); // Subtract non-inversion pairs
 bit.update(rk[i], 1); // Dynamically update occurrence count
 }
 printf("%lld\n", ans);
 return 0;
}

Exercise: CF1676H2 Maximum Crossings (Hard Version)

Range Updates

While Fenwick Trees don’t directly support range updates, difference arrays can help:

Maintain a difference array $B$ where $B_i = A_i - A_{i-1}$. Range updates become:

$B_x \mathrel{+}=k$
$B_{y+1} \mathrel{-}=k$

Querying $A_x$ is equivalent to summing $B_1$ to $B_x$ via prefixSum(x).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <cstdio>
#define maxn 500005
using namespace std;

template <typename value_type>
class fenwick_tree {
private:
 const int n;
 value_type* a;
 inline int lowbit(int x) { return x & -x; }
public:
 inline fenwick_tree(int m): n(m) {
 a = new value_type[n + 1];
 for(int i=0; i<=n; i++)
 a[i] = 0;
 }
 inline ~fenwick_tree() { delete[] a; }
 inline value_type prefixSum(int i) {
 value_type res = 0;
 for(; i; i-=lowbit(i)) res += a[i];
 return res;
 }
 inline void update(int i, const value_type& d) {
 for(; i<=n; i+=lowbit(i))
 a[i] += d;
 }
};

int a[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=n; i++)
 scanf("%d", a + i);
 fenwick_tree<int> bit(n);
 while(m--)
 {
 int op;
 scanf("%d", &op);
 if(op == 1)
 {
 int l, r, k;
 scanf("%d%d%d", &l, &r, &k);
 bit.update(l, k);
 if(r < n) bit.update(r + 1, -k);
 }
 else
 {
 int x;
 scanf("%d", &x);
 printf("%d\n", a[x] + bit.prefixSum(x));
 }
 }
 return 0;
}

Exercises

Luogu P1168 Median (Finding the $k$-th largest)
Luogu P1637 Triples
Luogu P6477 Subsequence Issues
Luogu P8253 Correct Sorting
ABC256 F - Cumulative Cumulative Cumulative Sum
Luogu P3372 Segment Tree Template (Try a “Super Fenwick Tree” approach?)

Conclusion

The Fenwick Tree efficiently handles point updates and prefix sums. Questions and suggestions are welcome!
~~Please like and share!~~

Three Types of Knapsack Problems — Knapsack DP

Thu, 18 Aug 2022 19:05:00 +0800

Preface

The Knapsack Problem is a classic dynamic programming problem with practical significance.

0-1 Knapsack

This is the fundamental 0-1 Knapsack Problem (each item can be chosen either 0 or 1 times). Let’s explore its solution.

Let $f_{i,j}$ denote the maximum total value achievable by considering the first $i$ items with a knapsack capacity of $j$. The final answer is $f_{n,W}$, and the state transition equation is:

$$ f_{i,j}=\begin{cases} 0 & (i=0/j=0) \\ \max(f_{i-1,j},f_{i-1,j-w_i}+v_i) & (i>0,j\ge w_i) \end{cases} $$

By incrementally increasing $i$ and expanding the problem scale, we can solve it. Both time and space complexity are $\mathcal O(nW)$.
In practice, $\mathcal O(nW)$ space may cause MLE. Hence, we optimize by reusing arrays or using rolling tables.

Compress the first dimension of $f$, resulting in:

$$ f_j=\max(f_j,f_{j-w_i}+v_i) $$

Now space complexity reduces to $\mathcal O(W)$.
Remember to iterate $j$ in reverse order to prevent overlapping transitions. Reference code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define setmax(x, y) if(x < y) x = y
using namespace std;

int f[12881];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(n--)
 {
 int w, v;
 scanf("%d%d", &w, &v);
 for(int i=m; i>=w; i--)
 setmax(f[i], f[i - w] + v);
 }
 printf("%d\n", f[m]);
 return 0;
}

A variant of 0-1 Knapsack is finding minimum remaining space, where the answer is $(total\ space - maximum\ occupied\ space)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define setmax(x, y) if(x < y) x = y
using namespace std;

int f[20005];

int main()
{
 int n, v;
 scanf("%d%d", &v, &n);
 while(n--)
 {
 int w;
 scanf("%d", &w);
 for(int i=v; i>=w; i--)
 setmax(f[i], f[i - w] + w);
 }
 printf("%d\n", v - f[v]);
 return 0;
}

Extension: Handling Larger $W$

Given $W\le 10^9$, storing such large arrays is impossible. We reverse the DP state: instead of tracking weight to maximize value, track value to minimize weight. Let $f_{i,j}$ denote the minimum capacity required to achieve total value $j$ using the first $i$ items. Since $\sum v_i\le 10^5$, the DP array size becomes manageable ($\approx10^7$). The state transition equation is:

$$ f_{i,j}=\begin{cases} +\infin & (i=0,j\ne0) \\ 0 & (i\ge 0,j=0) \\ \min(f_{i-1,j},f_{i-1,j-v_i}+w_i) & (i>0,j>0) \end{cases} $$

The final answer is the maximum $j$ where $f_{n,j}\le W$. Optimizations include:

Time: For each $i$, iterate $j$ only up to cumulative value $v_1+\dots+v_i$
Space: Compress the first dimension and iterate $j$ in reverse

Optimized code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#include <cstring>
using namespace std;

long long f[100005], t, tot, ans;

int main()
{
 int n, sz;
 scanf("%d%d", &n, &sz);
 memset(f, 0x3f, sizeof f);
 f[0] = 0;
 while(n--)
 {
 int w, v;
 scanf("%d%d", &w, &v);
 tot += v;
 for(int i=tot; i>=v; i--)
 if((t = f[i - v] + w) < f[i] && t <= sz)
 {
 f[i] = t;
 if(i > ans) ans = i;
 }
 }
 printf("%lld\n", ans);
 return 0;
}

Unbounded Knapsack

The key difference lies in unlimited item usage. For DP state $f_{i,j}$:

$$ f_{i,j}=\max(f_{i-1,j},f_{i,j-w_i}+v_i) $$

Compare with 0-1 Knapsack’s transition:

$$ \begin{aligned} 0\text{-}1: & \max(f_{i-1,j},f_{i-1,j-w_i}+v_i) \\ \text{Unbounded}: & \max(f_{i-1,j},f_{i,j-w_i}+v_i) \end{aligned} $$

By changing loop order (forward iteration), we achieve this. Don’t forget long long:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define setmax(x, y) if(x < y) x = y
using namespace std;

long long f[10000005];

int main()
{
 int sz, n;
 scanf("%d%d", &sz, &n);
 while(n--)
 {
 int w, v;
 scanf("%d%d", &w, &v);
 for(int i=w; i<=sz; i++)
 setmax(f[i], f[i - w] + v);
 }
 printf("%lld\n", f[sz]);
 return 0;
}

Bounded Knapsack

Naive approach (convert to 0-1 Knapsack with $N=\sum m_i$) yields $\mathcal O(W\sum m_i)$ complexity. Optimize via binary splitting: decompose $m_i$ into binary components (e.g., $5=1+2+2$). This reduces time to $\mathcal O(W\sum\log m_i)$. Reference code using binary optimization:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#define maxw 40004
#define setmax(x, y) if(x < y) x = y
using namespace std;

int n, w, f[maxw];

inline void add(int a, int b) // a: value, b: weight
{
 for(int i=w; i>=b; i--)
 setmax(f[i], f[i - b] + a);
}

int main()
{
 scanf("%d%d", &n, &w);
 while(n--)
 {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 for(int i=0; (1<<i)<=c; i++)
 add(a << i, b << i), c -= 1 << i;
 if(c) add(a * c, b * c);
 }
 printf("%d\n", f[w]);
 return 0;
}

Hybrid Knapsack

Combine all three knapsack types. For example, Luogu P1833 Cherry Blossoms. Handle via conditional branches:

1
2
3
4
5
6
7
8


for (each item type) {
 if (0-1 knapsack)
 apply 0-1 code;
 else if (unbounded)
 apply unbounded code;
 else if (bounded)
 apply bounded code;
}

Alternatively, unify handling by setting selection limits:

0-1: $k_i=1$
Unbounded: $k_i=\lceil\frac W{w_i}\rceil$

Summary

Comparison of three basic knapsack DP types:

Aspect	0-1 Knapsack	Unbounded Knapsack	Bounded Knapsack
Scenario	Each item once	Unlimited items	Limited items
State Transition¹	$\max(f_j,f_{j-w_i}+v_i)$	$\max(f_j,f_{j-w_i}+v_i)$	Similar to 0-1
Time Complexity²	$\mathcal O(nW)$	$\mathcal O(nW)$	$\mathcal O(W\sum\log k_i)$
Space Complexity	$\mathcal O(W)$	$\mathcal O(W)$	$\mathcal O(W)$
Coding Difficulty	Low	Low	Medium

Like this article? Please support with a 👍⭐💬!

Compressed $f_j$; 0-1 uses reverse iteration, unbounded uses forward ↩︎
Unbounded uses optimized complexity; bounded uses binary optimization ↩︎

【Algorithm Notes】Kruskal/Prim Algorithms — Solving Minimum Spanning Tree Problems

Mon, 15 Aug 2022 11:43:00 +0800

Preface

We often encounter problems like this in real life:

We can abstract this problem by representing cities as graph vertices and roads as weighted undirected edges, forming a weighted undirected graph. Since we want minimal total cost, the constructed roads must form a spanning tree, transforming the problem into:

This is the well-known Minimum Spanning Tree (MST) problem.
Consider the following graph:

The green edges form its minimum spanning tree.

Mathematicians have studied this problem extensively. However, focusing only on correctness without considering simplicity, feasibility, and efficiency led many algorithms to obsolescence. Two algorithms stood out: Kruskal and Prim.

Template Problem: Luogu P3366 【Template】Minimum Spanning Tree
Data Constraints: $N\le5000,M\le2\times10^5,w\le 10^4$.

Kruskal

The Kruskal algorithm, proposed by Joseph Kruskal in 1956, has a time complexity of $\mathcal O(m\log m)$. Let’s examine its workflow.

Kruskal Algorithm Workflow

Sort all edges in ascending order of weight and iterate through them.
For each edge, if adding it to the current subgraph doesn’t form a cycle, include it as part of the MST.
The algorithm terminates after selecting $N-1$ edges.

Disjoint-Set Union (DSU) — Accelerating the Algorithm

Before implementing Kruskal, we need DSU. Using DFS for cycle detection would result in $\mathcal O(nm + m\log m)$ time complexity, which is inefficient. DSU reduces this to $\mathcal O(m\log m)$ (dominated by sorting). DSU Template:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class dsu
{
private:
 const int n;
 int* fa;
public:
 inline dsu(int count): n(count) // Initialize DSU with size n
 {
 fa = new int[n]; // Allocate memory
 for(int i=0; i<n; i++)
 fa[i] = i; // Initialize fa[i]=i
 }
 inline ~dsu() { delete[] fa; } // Prevent memory leaks
 inline int size() { return n; } // Return DSU size
 int find(int x) { return fa[x] == x? x: fa[x] = find(fa[x]); } // Find with path compression
 inline bool same(int x, int y) { return find(x) == find(y); } // Check connectivity
 inline void merge(int x, int y) { fa[find(x)] = find(y); } // Merge two components
 inline bool connected() // Check if the entire graph is connected
 {
 int p = find(0);
 for(int i=0; i<n; i++)
 if(find(i) != p)
 return false;
 return true;
 }
};

Using DSU, the algorithm’s time complexity becomes $\mathcal O(m\log m)$. Now, let’s see the code.

Reference Code

For readers unfamiliar with DSU, feel free to copy the template first.~~Study it later~~
For single Kruskal runs, use priority_queue (more efficient than sort). For multiple runs, pre-sort edges.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


#include <cstdio>
#include <queue>
using namespace std;

// Represents an edge for sorting
struct Edge
{
 int from, to, weight;
 inline bool operator <(const Edge& e2) const
 {
 return weight > e2.weight; // Note: Reverse order for priority_queue
 }
 inline void read()
 {
 scanf("%d%d%d", &from, &to, &weight);
 from --, to --;
 }
};

// DSU Template
class dsu
{
private:
 const int n;
 int* fa;
public:
 inline dsu(int count): n(count)
 {
 fa = new int[n];
 for(int i=0; i<n; i++)
 fa[i] = i;
 }
 inline ~dsu() { delete[] fa; }
 inline int size() { return n; }
 int find(int x) { return fa[x] == x? x: fa[x] = find(fa[x]); }
 inline bool same(int x, int y) { return find(x) == find(y); }
 inline void merge(int x, int y) { fa[find(x)] = find(y); }
 inline bool connected()
 {
 int p = find(0);
 for(int i=0; i<n; i++)
 if(find(i) != p)
 return false;
 return true;
 }
};

int main()
{
 int n, m;
 scanf("%d%d", &n, &m); // Read vertices and edges
 priority_queue<Edge> q; // Priority queue for sorting
 while(m--)
 {
 Edge e;
 e.read(); // Read edge
 q.push(e); // Enqueue
 }
 int ans = 0, // Total weight
 cnt = 0; // Edge count
 dsu d(n); // Initialize DSU
 while(!q.empty() && cnt < n - 1) // Process edges until n-1 selected
 {
 auto [u, v, w] = q.top(); q.pop(); // Extract minimum edge
 if(!d.same(u, v)) // No cycle formed
 {
 d.merge(u, v); // Add edge
 ans += w, cnt ++; // Update
 }
 }
 if(cnt == n - 1) printf("%d\n", ans); // Output if MST exists
 else puts("orz"); // Otherwise...
 return 0;
}

Alternative ending (slower but concise):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


int ans = 0;
dsu d(n);
while(!q.empty())
{
 auto [u, v, w] = q.top(); q.pop();
 if(!d.same(u, v))
 {
 d.merge(u, v);
 ans += w;
 }
}
if(d.connected()) printf("%d\n", ans);
else puts("orz");

Prim

The Prim algorithm was discovered by Czech mathematician Vojtěch Jarník in 1930, independently by Robert C. Prim in 1957, and rediscovered by Edsger W. Dijkstra in 1959. Hence, it’s also called DJP, Jarník, or Prim-Jarník algorithm.

Prim Algorithm Workflow

Similar to Dijkstra, vertices are divided into sets $S$ and $T$:

Initially, all vertices are in $S$, $T$ is empty.
Move any vertex from $S$ to $T$.
Repeat until all vertices are in $T$:
- Select edge $(u,v,w)$ where $u\in S$, $v\in T$, with minimal $w$.
- Add this edge to MST and move $u$ to $T$.

We present optimized versions using priority_queue and set.

Priority Queue Optimization

Runtime: $328\mathrm{ms}$
Time Complexity: $\mathcal O(n\log m)$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <cstdio>
#include <queue>
#define maxn 5005
#define INF 2147483647
using namespace std;

using pii = pair<int, int>;
vector<pii> G[maxn];
int dis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, w;
 scanf("%d%d%d", &u, &v, &w);
 G[--u].emplace_back(--v, w);
 G[v].emplace_back(u, w);
 }
 for(int i=1; i<n; i++)
 dis[i] = INF;
 priority_queue<pii, vector<pii>, greater<pii>> q;
 q.emplace(0, 0);
 int ans = 0, left = n;
 while(!q.empty() && left > 0)
 {
 auto [d, v] = q.top(); q.pop();
 if(d != dis[v]) continue;
 dis[v] = -INF, left --, ans += d;
 for(auto [u, w]: G[v])
 if(w < dis[u])
 q.emplace(dis[u] = w, u);
 }
 if(left) puts("orz");
 else printf("%d\n", ans);
 return 0;
}

Set Optimization

Runtime: $351\mathrm{ms}$
Time Complexity: $\mathcal O(n\log n)$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <cstdio>
#include <vector>
#include <set>
#define maxn 5005
#define INF 2147483647
using namespace std;

using pii = pair<int, int>;
vector<pii> G[maxn];
int dis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, w;
 scanf("%d%d%d", &u, &v, &w);
 G[--u].emplace_back(--v, w);
 G[v].emplace_back(u, w);
 }
 for(int i=1; i<n; i++)
 dis[i] = INF;
 set<pii> s;
 s.emplace(0, 0);
 int ans = 0, left = n;
 while(!s.empty() && left > 0)
 {
 auto it = s.begin();
 auto [d, v] = *it; s.erase(it);
 dis[v] = -INF, left --, ans += d;
 for(auto [u, w]: G[v])
 if(w < dis[u])
 {
 if(dis[u] != INF)
 s.erase(pii(dis[u], u));
 s.emplace(dis[u] = w, u);
 }
 }
 if(left) puts("orz");
 else printf("%d\n", ans);
 return 0;
}

Exercises

Summary

Comparison of Kruskal and Prim:

Metric	Kruskal	Prim
Time Complexity	$\mathcal O(m\log m)$	$\mathcal O(n\log m)$¹
Runtime²	$255\mathrm{ms}$	$328\mathrm{ms}$
Code Complexity	Low	Medium
Applicability	Sparse Graphs	Dense Graphs

In most cases, Kruskal is preferred. Use Prim for specific requirements.
If you find this article helpful, please like/share/bookmark. Thanks for your support!

For priority_queue optimization. Set optimization is $\mathcal O(n\log n)$. ↩︎
Results from Luogu P3366. Kruskal uses DSU+priority_queue; Prim uses priority_queue. ↩︎

[Algorithm Notes] Single-Source Shortest Path Problem — Dijkstra's Algorithm (Unoptimized/Priority Queue/Set Optimized)

Sat, 13 Aug 2022 12:37:00 +0800

Introduction

Dijkstra’s algorithm solves the single-source shortest path problem with non-negative edge weights in $\mathcal O(m\log m)$ or $\mathcal O(m\log n)$ time. This article details the algorithm’s principles, implementations, and two common optimizations.

Additionally, Dijkstra’s algorithm should not be overused. For multi-source shortest paths, while Dijkstra’s complexity is $\mathcal O(nm\log m)$, it’s often simpler to use Floyd with $\mathcal O(n^3)$ time if feasible.

Without further ado, let’s dive into the algorithm’s workflow.

Workflow

Divide nodes into two sets: $S$ (nodes with determined shortest path lengths) and $T$ (nodes with undetermined lengths). Initially, all nodes belong to $T$.

Let $d_v$ denote the distance from node $v$ to the source, and $s$ be the source. Initialize $d_s=0$ and $d=+\infin$ for all other nodes.

Repeat these steps until $T$ is empty:

Select the node $v$ with the smallest $d$ from $T$ and move it to $S$.
For each neighbor $u$ of $v$, perform relaxation: dis[u] = min(dis[u], dis[v] + G[v][u]).

The simplest implementation follows below.

Implementations

Sample code is applicable to CF20C/Luogu. Input/output formats align with this problem. Constraints: $n,m\le 10^5,w_i\le 10^6$.

To output the shortest path, define an array $\mathrm{par}$ where $\mathrm{par}[i]$ represents the predecessor of node $i$ in the shortest path. Initialize $\mathrm{par}[s]=-1$.

When updating dis[u] = dis[v] + G[v][u], also set par[u] = v. Finally, backtrack from the destination using par.

Unoptimized Implementation

This brute-force approach strictly follows the algorithm with $\mathcal O(n^2)$ complexity, which fails the test case.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


#include <cstdio>
#include <cstring>
#include <vector>
#define maxn 100005
using namespace std;

vector<pair<int, int>> G[maxn];

long long dis[maxn];
int par[maxn];
bool vis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, c;
 scanf("%d%d%d", &u, &v, &c);
 G[--u].emplace_back(--v, c);
 G[v].emplace_back(u, c);
 }
 // Dijkstra algorithm steps
 // Initialization
 memset(dis, 0x3f, sizeof dis);
 memset(vis, 0, sizeof vis);
 dis[0] = 0LL, par[0] = -1; // Distance of the starting point is 0
 while(true)
 {
 int v = n; // Virtual node with +INF distance
 for(int i=0; i<n; i++)
 if(!vis[i] && dis[i] < dis[v])
 v = i;
 if(v >= n - 1) break; // Exit if no valid node found
 vis[v] = true; // Mark as visited
 for(auto [u, d]: G[v])
 if(dis[v] + d < dis[u]) // Check for a better path?
 {
 dis[u] = dis[v] + d; // Update distance
 par[u] = v; // Update path
 }
 }
 if(dis[n - 1] == dis[n]) // No solution (disconnected graph)
 {
 puts("-1");
 return 0;
 }
 vector<int> path; // Store reversed path
 int v = n - 1; // Backtrack from destination
 while(v != -1)
 {
 path.push_back(v); // Add to path
 v = par[v]; // Backtrack
 }
 for(int i=path.size()-1; i>=0; i--)
 printf("%d ", path[i] + 1); // Output
 return 0;
}

Test Result:

Priority Queue Optimization

Priority queues (binary heaps) support:

Extracting min/max elements in $\mathcal O(\log n)$
Inserting elements in $\mathcal O(\log n)$

This achieves $\mathcal O(m\log m)$ complexity:

Initialize with $(s,0)$ in the queue.
While queue not empty:
- Extract $(v,d)$. If $d \ne \mathrm{dis}[v]$, skip.
- Otherwise, relax edges and enqueue updated nodes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <queue>
#define maxn 100005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

vector<pair<int, int>> G[maxn];
LL dis[maxn];
int par[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, c;
 scanf("%d%d%d", &u, &v, &c);
 G[--u].emplace_back(--v, c);
 G[v].emplace_back(u, c);
 }
 for(int i=1; i<n; i++) dis[i] = INF;
 par[0] = -1;
 priority_queue<pli, vector<pli>, greater<pli>> q;
 q.emplace(0LL, 0);
 while(!q.empty())
 {
 auto [d, v] = q.top(); q.pop();
 if(dis[v] == d)
 for(auto [u, w]: G[v])
 if(d + w < dis[u])
 par[u] = v,
 q.emplace(dis[u] = d + w, u);
 }
 if(dis[n - 1] == INF) { puts("-1"); return 0; }
 vector<int> path;
 int v = n - 1;
 while(v != -1)
 {
 path.push_back(v);
 v = par[v];
 }
 for(int i=path.size()-1; i>=0; i--)
 printf("%d ", ++path[i]);
 return 0;
}

AC, runtime: $93\text{ms}$

Set Optimization

Sets allow deletion of arbitrary elements in $\mathcal O(\log n)$. By removing obsolete entries, the set size never exceeds $N$, yielding $\mathcal O(m\log n)$ complexity. Generally less used but provided below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <vector>
#include <set>
#define maxn 100005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

vector<pair<int, int>> G[maxn];
LL dis[maxn];
int par[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v, c;
 scanf("%d%d%d", &u, &v, &c);
 G[--u].emplace_back(--v, c);
 G[v].emplace_back(u, c);
 }
 for(int i=1; i<n; i++) dis[i] = INF;
 par[0] = -1;
 set<pli> s;
 s.emplace(0LL, 0);
 while(!s.empty())
 {
 auto it = s.begin(); s.erase(it);
 auto [d, v] = *it;
 for(auto [u, w]: G[v])
 if(d + w < dis[u])
 {
 par[u] = v;
 if(dis[u] != INF)
 s.erase(pli(dis[u], u));
 s.emplace(dis[u] = d + w, u);
 }
 }
 if(dis[n - 1] == INF) { puts("-1"); return 0; }
 vector<int> path;
 int v = n - 1;
 while(v != -1)
 {
 path.push_back(v);
 v = par[v];
 }
 for(int i=path.size()-1; i>=0; i--)
 printf("%d ", ++path[i]);
 return 0;
}

AC, runtime: $78\text{ms}$

Conclusion

Dijkstra’s implementations summarized:

Brute-force ($\mathcal O(n^2)$, TLE ;()
Priority queue ($\mathcal O(m\log m)$, $93\text{ms}$ :|)
Set ($\mathcal O(m\log n)$, $78\text{ms}$ :))

【Algorithm Notes】Multi-source Shortest Path Problem——Floyd's Algorithm

Fri, 12 Aug 2022 21:07:00 +0800

Preface

In graphs, when requiring distances between any two points, we can use Floyd ($\mathcal O(N^3)$;)）and Dijkstra ($\mathcal O(NM\log M)$:)). For relatively small data ranges (typically vertex count $N\le 150$), Floyd’s algorithm is suitable. This article explains the principles, implementation, and extended applications of Floyd’s algorithm.

If there are any shortcomings, please feel free to provide feedback. Thank you!

Principle

Unlike Dijkstra, Floyd’s algorithm also works for shortest path problems with negative edge weights. Its principle is:
Let $f(x,y)$ be the shortest path from vertex $x$ to $y$. Initially:

$$ f(x,y)= \begin{cases} 0 & (x=y) \\ G[x][y] & (G[x][y]\ne0)\\ +\infty & (x\ne y,G[x][y]=0) \end{cases} $$

where $G$ is the adjacency matrix of the graph, $G[x][y]$ represents the edge weight from vertex $x$ to $y$, and $0$ indicates no edge between $x$ and $y$.
Next, consider enumerating intermediate points $k$ and calculating the shortest path via the route $x\to k\to y$. The pseudocode is:

1
2
3
4


for k = 1, 2, ..., n
 for x = 1, 2, ..., n
 for y = 1, 2, ..., n
 f[x][y] = min(f[x][y], f[x][k] + f[k][y])

At this point, the algorithm concludes, and the final $f(x,y)$ represents the shortest path from $x$ to $y$.

Note: When the given graph is undirected, for any $(x,y)$, $G[x][y]=G[y][x]$, so $f(x,y)=f(y,x)$. The computation process can be adjusted (e.g., using f[k][x]+f[k][y]). However, for directed graphs, strictly follow the order in the pseudocode!

Code

The code for Floyd’s algorithm can be submitted on Luogu B3647. Below is the AC code for this problem (note edge-based input):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#include <cstring>
#define maxn 100
using namespace std;

int dis[maxn][maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 // Initialize, note that initial values should not exceed INT_MAX/2 (to prevent overflow from adding two INFs)
 memset(dis, 0x3f, sizeof dis); 
 // Distance from each point to itself is 0
 for(int i=0; i<n; i++)
 dis[i][i] = 0;
 // Read edges
 while(m--)
 {
 int u, v, d;
 scanf("%d%d%d", &u, &v, &d);
 u --, v --; // 0-index
 dis[u][v] = dis[v][u] = d; // Note both values need to be set
 }
 // Floyd algorithm process
 for(int k=0; k<n; k++) // Intermediate point
 for(int i=0; i<n; i++) // Start point
 for(int j=0; j<n; j++) // End point
 {
 int d = dis[i][k] + dis[k][j]; // i->k->j
 if(d < dis[i][j]) dis[i][j] = d; // Take shortest length
 }
 for(int i=0; i<n; i++, putchar('\n'))
 for(int j=0; j<n; j++)
 printf("%d ", dis[i][j]);
 return 0;
}

Extension

Now the question arises: How to output the result path? The method is simple. Similar to Dijkstra but slightly different, let $\text{path}(x, y)$ be a point on the shortest path from $x\to y$. When updating $f(x,y)$ during state transition if $f(x,k)+f(k,y) < f(x,y)$, not only update $f(x,y)$ but also set $\text{path}(x,y):=k$. Finally, recursively output the result.

Problem Statement

Given a simple undirected graph with $N$ vertices and $M$ edges, for every pair $(i,j)$ ($1\le i < j\le N$), output every vertex on the shortest path from $i\to j$.

Sample

Input:

Output:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


1->2: 1 2
1->3: 1 4 3
1->4: 1 4
1->5: 1 4 5
2->3: 2 1 4 3
2->4: 2 1 4
2->5: 2 1 4 5
3->4: 3 4
3->5: 3 4 5
4->5: 4 5

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <cstring>
#define maxn 100
using namespace std;

int dis[maxn][maxn], path[maxn][maxn];
void print(int x, int y) // Recursively output path x->y, excluding y
{
 int k = path[x][y]; // x->k->y
 if(k == x || k == y) // Adjacent vertices, output directly
 printf(" %d", x);
 else
 {
 // Split into two recursive parts
 print(x, k); // x->k
 print(k, y); // k->y
 }
}

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 // Initialize
 memset(dis, 0x3f, sizeof dis); 
 for(int i=0; i<n; i++)
 dis[i][i] = 0;
 // Read edges
 while(m--)
 {
 int u, v, d;
 scanf("%d%d%d", &u, &v, &d);
 dis[u][v] = dis[v][u] = d; // Note both values need to be set
 path[u][v] = path[v][u] = u; // Initialize path
 }
 // Floyd algorithm process, using 1-index for easier output
 for(int k=1; k<=n; k++) // Intermediate point
 for(int i=1; i<=n; i++) // Start point
 for(int j=1; j<=n; j++) // End point
 {
 int d = dis[i][k] + dis[k][j]; // i->k->j
 if(d < dis[i][j]) // Update shortest path
 dis[i][j] = d, path[i][j] = k;
 }
 // Enumerate (i,j) and output paths
 for(int i=1; i<n; i++)
 for(int j=i+1; j<=n; j++)
 {
 printf("%d->%d:", i, j);
 print(i, j);
 printf(" %d\n", j);
 }
 return 0;
}

Note: Since the length of each path won’t exceed $N$, the overall time complexity remains $\mathcal O(N^3)$.

Epilogue

Summary: Floyd’s algorithm has a time complexity of $\mathcal O(N^3)$ and is convenient to implement. If you found this helpful, please give a like/share/follow—thank you for your support!

【Algorithm Notes】Tree DP Algorithm Summary & Detailed Explanation

Fri, 12 Aug 2022 10:15:00 +0800

Definition

Tree DP, also known as Tree-shaped DP, refers to DP (Dynamic Programming) performed on trees, and is one of the more complex types in DP algorithms.

Basics

Let $f[u]=~$data related to tree node $u$, and perform $\text{DP}$ in topological order (from leaf nodes up to the root) to ensure a node’s children have updated DP values before updating the current node. Typically implemented via DFS:

1
2
3
4
5
6
7


void dfs(int v) { // Traverse node v
 dp[v] = ...; // Initialize
 for(int u: G[v]) { // Traverse all children of v
 dfs(u);
 update(u, v); // Update current node's DP value using child's DP value
 }
}

【Example 1.1】Subtree Size

Let $f[v]=~$size of subtree rooted at $v$. Then:

$$ f[v]=1+\sum_{i=1}^{\text{deg}_v} G[v][i] $$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <cstdio>
#include <vector>
#define maxn 100
using namespace std;

vector<int> G[maxn]; // Adjacency list
int sz[maxn]; // DP array, sz[v] = size of subtree v

void dfs(int v)
{
 sz[v] = 1; // Initial size is 1
 for(int u: G[v]) // Traverse children
 {
 dfs(u); 
 sz[v] += sz[u]; // Update subtree size
 }
}

int main()
{
 int n;
 scanf("%d", &n); 
 for(int i=1; i<n; i++) 
 {
 int u, v;
 scanf("%d%d", &u, &v); 
 G[u].push_back(v); 
 }
 dfs(1);
 for(int i=1; i<=n; i++)
 printf("%d\n", sz[i]);
 return 0;
}

【Example 1.2】Luogu P1352 No Boss’s Party

This is the Maximum Independent Set on a Tree problem.

Let $f(v)$ be the optimal solution when selecting $v$, and $g(v)$ when not selecting $v$. Transitions:

$g(v)=\sum\max\{f(u),g(u)\}$;
$f(v)=r_i+\sum g(u)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <cstdio>
#include <vector>
#define maxn 6005
using namespace std;

inline int max(int x, int y) { return x > y? x: y; }

vector<int> G[maxn]; 
bool bad[maxn]; 
int f[maxn], g[maxn]; 

void dfs(int v) 
{
 for(int u: G[v]) 
 {
 dfs(u); 
 f[v] += g[u]; 
 g[v] += max(f[u], g[u]); 
 }
}

int main()
{
 int n;
 scanf("%d", &n); 
 for(int i=0; i<n; i++)
 scanf("%d", f + i); 
 for(int i=1; i<n; i++) 
 {
 int u, v;
 scanf("%d%d", &u, &v); 
 G[--v].push_back(--u); 
 bad[u] = true; 
 }
 int root = -1; 
 for(int i=0; i<n; i++)
 if(!bad[i]) 
 {
 root = i; 
 break;
 }
 dfs(root); 
 printf("%d\n", max(f[root], g[root])); 
 return 0;
}

Exercises

Tree Knapsack

【Example 2.1】Luogu P2014 / AcWing 286 Course Selection

Construct a tree with virtual root 0. Let $f[i][j]$ be the maximum credit when selecting $j$ courses in subtree $i$. Add 1 to $M$ since root 0 must be selected.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 305
using namespace std;

inline void setmax(int& x, int y)
{
 if(x < y) x = y;
}

vector<int> G[maxn]; 
int n, m, f[maxn][maxn];

int dfs(int u) 
{
 int tot = 1; 
 for(int v: G[u]) 
 {
 int sz = dfs(v); 
 for(int i=min(tot, m); i>0; i--) 
 for(int j=1, lim=min(sz, m-i); j<=lim; j++)
 setmax(f[u][i + j], f[u][i] + f[v][j]); 
 tot += sz; 
 }
 return tot; 
}

int main()
{
 scanf("%d%d", &n, &m);
 for(int i=1; i<=n; i++)
 {
 int a;
 scanf("%d%d", &a, f[i] + 1); 
 G[a].push_back(i);
 }
 m ++; 
 dfs(0);
 printf("%d\n", f[0][m]);
 return 0;
}

Exercises

Rerooting DP

【Example 3.1】Luogu P3478 [POI2008] STA-Station

Compute depth sum for all nodes when treating each node as root. Use two-pass DFS for $\mathcal O(N)$ solution.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <cstdio>
#include <vector>
#define maxn 1000005
using namespace std;

using LL = long long;

vector<int> G[maxn];
LL sz[maxn], f[maxn];
int n, ans;

LL dfs1(int v, int d, int par)
{
 sz[v] = 1;
 LL s = d;
 for(int u: G[v])
 if(u != par)
 s += dfs1(u, d + 1, v), sz[v] += sz[u];
 return s;
}

void dfs2(int v, int par)
{
 if(f[v] > f[ans]) ans = v;
 for(int u: G[v])
 if(u != par)
 {
 f[u] = f[v] + n - (sz[u] << 1LL);
 dfs2(u, v);
 }
}

int main()
{
 scanf("%d", &n);
 for(int t=n; --t; )
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 f[0] = dfs1(0, 0, -1);
 dfs2(0, -1);
 printf("%d\n", ++ans);
 return 0;
}

Exercises

Postscript

~~Turns out it’s not as hard as it initially seemed… Remember to like and share!~~

References:

LINE Verda Programming Contest (AtCoder Beginner Contest 263) A-E Solutions

Sun, 07 Aug 2022 19:45:00 +0800

A - Full House

Problem Summary

~~Translation from a passionate card game enthusiast qwq~~

Given five card numbers $A,B,C,D,E$ from a poker deck, determine if they form a “three-of-a-kind plus a pair”. ~~(Baidu it if unclear~~

Constraints: $1\le A,B,C,D,E\le 13$, and not all $A,B,C,D,E$ are identical.

Input Format

$A~B~C~D~E$

Output Format

Print Yes if a full house, otherwise No.

Sample Cases

$A$	$B$	$C$	$D$	$E$	Output
$1$	$2$	$1$	$2$	$1$	`Yes`
$12$	$12$	$11$	$1$	$2$	`No`

Analysis

Hehe, ~~amused by~~ startled by my own translation—never seen such a ~~good~~ terrible one!
Straightforward problem. Count frequencies and check for exactly two and three counts. See code.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
using namespace std;

int cnt[13];

int main()
{
 for(int i=0; i<5; i++)
 {
 int x;
 scanf("%d", &x);
 cnt[--x] ++;
 }
 bool has2 = false, has3 = false;
 for(int i=0; i<13; i++)
 if(cnt[i] == 2) has2 = true;
 else if(cnt[i] == 3) has3 = true;
 puts(has2 && has3? "Yes": "No");
 return 0;
}

B - Ancestor

Problem Summary

There are $N$ people. The parent of the $i$-th person is $P_i$, guaranteed $P_i < i$.
Find how many generations apart the $N$-th person is from the 1st person.

$2\le N\le 50$
$1\le P_i < i$

Input Format

$N$
$P_2~P_3~\dots~P_N$

Output Format

Print the answer.

Analysis

No DFS needed. Compute depth iteratively: $\text{depth}_i = \text{depth}_{P_i} + 1$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <cstdio>
#define maxn 55
using namespace std;

int dep[maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<n; i++)
 {
 int f;
 scanf("%d", &f);
 dep[i] = dep[--f] + 1;
 }
 printf("%d\n", dep[n - 1]);
 return 0;
}

C - Monotonically Increasing

Problem Summary

Print all strictly increasing sequences of length $N$ with elements in $[1,M]$ in lex order. $1\le N\le M\le 10$.

Input Format

$N~M$

Output Format

Print each sequence in lex order, one per line, space-separated.

Analysis

Basic backtracking problem. See code.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define maxn 15
using namespace std;

int n, m, ans[maxn];

void dfs(int pos, int last)
{
 if(pos == n)
 {
 for(int i=0; i<n; i++)
 printf("%d ", ans[i]);
 putchar('\n');
 return;
 }
 while(++last <= m)
 {
 ans[pos] = last;
 dfs(pos + 1, last);
 }
}

int main()
{
 scanf("%d%d", &n, &m);
 dfs(0, 0);
 return 0;
}

D - Left Right Operation

Problem Summary

Given integer sequence $A=(A_1,A_2,\dots,A_N)$, perform at most one left operation (replace first $x$ elements with $L$) and one right operation (replace last $y$ elements with $R$). Find the minimal possible sum.

$1\le N\le 2\times 10^5$
$-10^9\le L,R,A_i\le 10^9$

Input Format

$N~L~R$
$A_1~A_2~\dots~A_N$

Output Format

Print the minimal sum.

Analysis

Precompute prefix $f_i$ (min sum for first $i$ elements using left operations) and suffix $g_i$ (min sum for last $i$ elements using right operations). Answer is $\min(f_i + g_{N-i})$.

Time complexity: $\mathcal O(N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
#define maxn 200005
using namespace std;

using LL = long long;
inline LL min(const LL& x, const LL& y)
{
 return x < y? x: y;
}

int a[maxn];
LL f[maxn], g[maxn];

int main()
{
 int n, l, r;
 scanf("%d%d%d", &n, &l, &r);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 f[0] = min(l, a[0]);
 for(int i=1; i<n; i++)
 f[i] = min(f[i - 1] + a[i], (i + 1LL) * l);
 for(int i=n-1; i>=0; i--)
 g[i] = min(g[i + 1] + a[i], LL(n - i) * r);
 LL ans = g[0];
 for(int i=0; i<n; i++)
 ans = min(ans, f[i] + g[i + 1]);
 printf("%lld\n", ans);
 return 0;
}

E - Sugoroku 3

Problem Summary

$N$ squares. On squares $1$ to $N-1$, a die outputs $0,1,\dots,A_i$ uniformly. Move forward by the die result. Find the expected steps to reach square $N$, modulo $998244353$.

$2\le N\le 2\times 10^5$
$1\le A_i\le N-i$ ($1\le i < N$)

Input Format

$N$
$A_1~A_2~\dots~A_{N-1}$

Output Format

Print the answer modulo $998244353$.

Analysis

Let $\text{dp}_i$ be the expected steps from $i$ to $N$. Compute backward:

$$ \text{dp}_i = \frac{\sum_{j=i}^{i+A_i} \text{dp}_j}{A_i+1} + 1 $$

Solve for $\text{dp}_i$ and use suffix sums for optimization. Time complexity: $\mathcal O(N \log P)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#define maxn 200005
#define MOD 998244353
using namespace std;

using LL = long long;
int a[maxn], suf[maxn];

inline int inv(LL x)
{
 LL res = 1LL;
 int p = MOD - 2;
 while(p)
 {
 if(p & 1) (res *= x) %= MOD;
 (x *= x) %= MOD, p >>= 1;
 }
 return res;
}

int main()
{
 int n, cur;
 scanf("%d", &n);
 for(int i=0; i<n-1; i++)
 scanf("%d", a + i);
 for(int i=n-2; i>=0; i--)
 {
 int t = suf[i + 1] - suf[i + 1 + a[i]];
 if(t < 0) t += MOD;
 cur = (a[i] + t + 1LL) % MOD * inv(a[i]) % MOD;
 if((suf[i] = suf[i + 1] + cur) >= MOD)
 suf[i] -= MOD;
 }
 printf("%d\n", cur);
 return 0;
}

PyQt6/PySide6: Building an Account Book Frontend

Sat, 23 Jul 2022 08:00:00 +0800

Preface

Recently being idle at home, I came across a friend @studentWheat who shared a Tkinter-based account book. I decided to collaborate with him to improve the program.

Screenshots:

Backend

The backend was mainly developed by my friend. Here’s the core code:
src/api.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


from collections import defaultdict

class ApiError(RuntimeError):
 pass

def openFile(filename):
 '''
 Open file.
 File format: 4 lines per record for date, event type, money delta, and note.
 Such as:
 (file.example, encoding=utf-8)
 (Record 1)
 (ln 1) date1
 (ln 2) event_type1
 (ln 3) money_delta1
 (ln 4) note1
 (Record 2)
 (ln 5) date2
 (ln 6) event_type2
 (ln 7) money_delta2
 (ln 8) note2
 @param filename: File name.
 Returns: data in the format [[date1, event_type1, money_delta1, note1], ...]
 '''
 with open(filename, 'r', encoding='utf-8') as f:
 res = []
 while date := f.readline():
 if (etype := f.readline()) and (mdelta := f.readline()) and (note := f.readline()):
 res.append([date.rstrip('\n'), etype.rstrip('\n'), mdelta.rstrip('\n'), note.rstrip('\n')])
 else:
 raise ApiError('Unexpected EOF at ' + filename)
 return res

def saveFile(filename, data): # Save
 '''
 Save with the same format mentioned in openFile().
 @param filename: File name.
 @param data: Data with the same format returned in openFile().
 '''
 with open(filename, 'w', encoding='utf-8') as f:
 for line in data:
 print(*line, sep='\n', file=f)

def query(data, key):
 return [record for record in data if any(key in x for x in record)] if key else data

def total(data):
 in_total = out_total = 0
 for _, _, mdelta, _ in data:
 mdelta = int(mdelta)
 if mdelta < 0:
 out_total -= mdelta
 else:
 in_total += mdelta
 return in_total, out_total

def totalByEvent(data):
 cnt = defaultdict(lambda: [0, 0])
 for _, event, mdelta, _ in data:
 mdelta = int(mdelta)
 if mdelta < 0:
 cnt[event][1] -= mdelta
 else:
 cnt[event][0] += mdelta
 return cnt

def totalByDate(data):
 cnt = defaultdict(lambda: [0, 0])
 for date, _, mdelta, _ in data:
 mdelta = int(mdelta)
 if mdelta < 0:
 cnt[date][1] -= mdelta
 else:
 cnt[date][0] += mdelta
 return cnt

For details, see https://blog.csdn.net/qq_67190987/article/details/125918530.

Frontend

As stated in the title, we used Qt6+Python with two framework options (PyQt6 and PySide6). Here we chose PySide6.

Resource Preparation

Store all image resources under src/icons:

Designer Window Layout

Use Qt Designer to create windows:

Dependency Installation

Create requirements.txt with:

1

PySide6>=6.3.1

Then run in cmd:

1

pip install -r requirements.txt

Resource and UI Compilation

Compile files using pyside6-uic and pyside6-rcc. Output structure:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


AccountBook
└─src
 │ dlgAdd.ui
 │ dlgCharts.ui
 │ MainWindow.ui
 │ res.qrc
 │ res_rc.py
 │ ui_dlgAdd.py
 │ ui_dlgCharts.py
 │ ui_dlgHelp.py
 │ ui_MainWindow.py

Code Implementation

src/dlgAdd.py
“Add Account” window - a simple QDialog instance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from PySide6.QtWidgets import *
from PySide6.QtCore import QDate, QRegularExpression
from PySide6.QtGui import QRegularExpressionValidator
from ui_dlgAdd import Ui_Dialog

class dlgAdd(QDialog):
 def __init__(self, parent=None):
 super().__init__(parent)
 self.ui = Ui_Dialog()
 self.ui.setupUi(self)
 self.ui.dateEdit.setDate(QDate.currentDate())
 self.ui.moneyEdit.setValidator(QRegularExpressionValidator(QRegularExpression(r'(\+|\-)[1-9]+[0-9]*')))
 self.ui.buttonBox.button(QDialogButtonBox.Ok).setText('Confirm')
 self.ui.buttonBox.button(QDialogButtonBox.Cancel).setText('Cancel')
 
 def getRow(self):
 date = self.ui.dateEdit.text()
 event = self.ui.eventEdit.text()
 money = self.ui.moneyEdit.text()
 note = self.ui.noteEdit.text()
 return [date, event, money, note]

 def accept(self):
 if not self.ui.eventEdit.text():
 QMessageBox.critical(self, "Error", "Event cannot be empty. Please fill in.")
 return
 if self.ui.moneyEdit.text() in ('', '+', '-'):
 QMessageBox.critical(self, "Error", "Amount cannot be empty. Please fill in.")
 return
 return super().accept()

src/dlgCharts.py
Chart display window using QtCharts (usage differs slightly from PyQt5/PySide2). More chart types may be added later.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97


from bisect import bisect_left, bisect_right

from PySide6.QtCore import QDate, Qt
from PySide6.QtWidgets import *
from PySide6.QtCharts import QBarCategoryAxis, QBarSeries, QBarSet, QChart, QChartView, QValueAxis

from api import total, totalByDate, totalByEvent
from ui_dlgCharts import Ui_Dialog

class dlgCharts(QDialog):
 def __init__(self, data, parent=None):
 super().__init__(parent)
 self.ui = Ui_Dialog()
 self.ui.setupUi(self)
 self.showMaximized()

 self.data = data
 minDate = QDate.fromString(data[0][0], 'yyyy/MM/dd')
 maxDate = QDate.fromString(data[-1][0], 'yyyy/MM/dd')
 self.ui.startDateEdit.setDateRange(minDate, maxDate)
 self.ui.endDateEdit.setDateRange(minDate, maxDate)
 self.ui.startDateEdit.setDate(minDate)
 self.ui.endDateEdit.setDate(maxDate)

 self.__update_totalChart(*total(data))
 self.__update_eventChart(totalByEvent(data))
 self.__update_dateChart(totalByDate(data))

 self.ui.startDateEdit.editingFinished.connect(self.__updateCharts)
 self.ui.endDateEdit.editingFinished.connect(self.__updateCharts)

 @staticmethod
 def createChart(chartView: QChartView, title, xAxis, yAxisList):
 chart = QChart()
 chart.setTitle(title)
 chart.setAnimationOptions(QChart.SeriesAnimations)

 series = QBarSeries()
 for axisName, data in yAxisList:
 barSet = QBarSet(axisName)
 barSet.append(data)
 series.append(barSet)
 chart.addSeries(series)

 axisX = QBarCategoryAxis()
 axisX.append(xAxis)
 chart.addAxis(axisX, Qt.AlignBottom)
 series.attachAxis(axisX)

 axisY = QValueAxis()
 axisY.setLabelFormat('%d')
 chart.addAxis(axisY, Qt.AlignLeft)
 series.attachAxis(axisY)

 chartView.setChart(chart)

 def __update_totalChart(self, total_in, total_out):
 self.createChart(
 chartView = self.ui.totalView,
 title = 'Total Income & Expense',
 xAxis = ['Income', 'Expense'], 
 yAxisList = [
 ('Amount', [total_in, total_out])
 ]
 )

 def __update_eventChart(self, events):
 self.createChart(
 chartView = self.ui.eventView,
 title = 'Category Statistics',
 xAxis = list(events.keys()),
 yAxisList = [
 ('Income', list(map(lambda x: x[0], events.values()))),
 ('Expense', list(map(lambda x: x[1], events.values())))
 ]
 )

 def __update_dateChart(self, dates):
 self.createChart(
 chartView = self.ui.dateView,
 title = 'Daily Statistics',
 xAxis = list(dates.keys()),
 yAxisList = [
 ('Income', list(map(lambda x: x[0], dates.values()))),
 ('Expense', list(map(lambda x: x[1], dates.values())))
 ]
 )

 def __updateCharts(self):
 startDate = self.ui.startDateEdit.text()
 endDate = self.ui.endDateEdit.text()
 left = bisect_left(self.data, startDate, key=lambda x: x[0])
 right = bisect_right(self.data, endDate, key=lambda x: x[0])
 data = self.data[left:right]
 self.__update_totalChart(*total(data))
 self.__update_eventChart(totalByEvent(data))
 self.__update_dateChart(totalByDate(data))

src/main.py
Main program handling the main window. The most complex part is QTableView with search and sorting features.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181


import sys
from bisect import insort_right
from functools import partial
from os.path import basename
from webbrowser import open_new_tab

from PySide6.QtWidgets import *
from PySide6.QtCore import Slot, QDate
from PySide6.QtGui import QStandardItem, QStandardItemModel

from api import ApiError, openFile, query, saveFile
from dlgAdd import dlgAdd
from dlgCharts import dlgCharts
from ui_dlgHelp import Ui_Dialog as Ui_dlgHelp
from ui_MainWindow import Ui_MainWindow

# Version info
VERSION = '1.0.1'
CHANNEL = 'stable'
BUILD_DATE = '2022-07-01'
FULL_VERSION = f'{VERSION}-{CHANNEL} ({BUILD_DATE}) on {sys.platform}'

app = QApplication(sys.argv)

class AccountBookMainWindow(QMainWindow):
 version_str = 'Account Book ' + VERSION
 unsaved_tip = '*'
 SUPPORTED_FILTERS = 'Account Book Files(*.abf);;Text Files(*.txt);;All Files(*.*)'

 def __init__(self, parent=None):
 # Initialize window
 super().__init__(parent)
 self.ui = Ui_MainWindow()
 self.ui.setupUi(self)
 self.setWindowTitle('Account Book ' + VERSION)
 self.labStatus = QLabel(self)
 self.ui.statusBar.addWidget(self.labStatus)

 # Initialize table
 self.model = QStandardItemModel(0, 4, self)
 self.model.setHorizontalHeaderLabels(['Date', 'Event', 'Amount', 'Note'])
 self.ui.table.setModel(self.model)
 self.ui.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)

 self.__data = []
 self.on_actFile_New_triggered()
 self.ui.actEdit_Remove.setEnabled(False)

 # Connect slots
 self.ui.table.selectionModel().selectionChanged.connect(self.__selectionChanged)
 self.model.itemChanged.connect(self.__itemChanged)

 def __updateTable(self, data):
 self.model.itemChanged.disconnect(self.__itemChanged)
 self.model.setRowCount(len(data))
 for row in range(len(data)):
 for col in range(len(data[row])):
 self.model.setItem(row, col, QStandardItem(data[row][col]))
 self.model.itemChanged.connect(self.__itemChanged)

 def __openFile(self, filename):
 try:
 self.__data = openFile(filename)
 except IOError:
 QMessageBox.critical(self, 'Error', 'Failed to open file. Please try again.')
 except ApiError:
 QMessageBox.critical(self, 'Error', 'File format error. Check file integrity.')
 except Exception as e:
 QMessageBox.critical(self, 'Error', 'Unknown error: ' + str(e.with_traceback()))
 else:
 self.ui.searchEdit.clear()
 self.__key = ''
 self.__updateTable(self.__data)
 self.labStatus.setText(filename)
 self.setWindowTitle(self.version_str)
 self.__filename = filename

 def __saveFile(self, filename):
 try:
 saveFile(filename, self.__data)
 except IOError:
 QMessageBox.critical(self, 'Error', 'Failed to save file. Please try again.')
 except Exception as e:
 QMessageBox.critical(self, 'Error', 'Unknown error: ' + str(e.with_traceback()))
 else:
 self.labStatus.setText('Saved: ' + filename)
 self.setWindowTitle(self.version_str)
 self.__filename = filename

 @Slot()
 def on_actFile_New_triggered(self):
 self.__filename = self.__key = ''
 self.setWindowTitle(self.unsaved_tip + self.version_str)
 self.labStatus.setText('New File')
 self.model.setRowCount(0)
 self.__data.clear()

 @Slot()
 def on_actFile_Open_triggered(self):
 filename, _ = QFileDialog.getOpenFileName(self, 'Open', filter=self.SUPPORTED_FILTERS)
 if filename:
 self.__openFile(filename)

 @Slot()
 def on_actFile_Save_triggered(self):
 if self.__filename:
 self.__saveFile(self.__filename)
 else:
 filename, _ = QFileDialog.getSaveFileName(self, 'Save', filter=self.SUPPORTED_FILTERS)
 if filename:
 self.__saveFile(filename)

 @Slot()
 def on_actFile_SaveAs_triggered(self):
 filename, _ = QFileDialog.getSaveFileName(self, 'Save As', filter=self.SUPPORTED_FILTERS)
 if filename:
 self.__saveFile(filename)

 @Slot()
 def on_actHelp_About_triggered(self):
 dialog = QDialog(self)
 ui = Ui_dlgHelp()
 ui.setupUi(dialog)
 for link in (ui.githubLink, ui.giteeLink, ui.licenseLink, ui.readmeLink):
 link.clicked.connect(partial(open_new_tab, link.description()))
 ui.labVersion.setText('Version: ' + FULL_VERSION)
 ui.btnUpdate.clicked.connect(partial(open_new_tab, 'https://github.com/GoodCoder666/AccountBook/releases'))
 dialog.exec()

 @Slot()
 def on_actHelp_AboutQt_triggered(self):
 QMessageBox.aboutQt(self, 'About Qt')

 @Slot()
 def on_actEdit_Add_triggered(self):
 dialog = dlgAdd(self)
 if dialog.exec() == QDialog.Accepted:
 row = dialog.getRow()
 insort_right(self.__data, row)
 self.__updateTable(query(self.__data, self.__key))
 self.setWindowTitle(self.unsaved_tip + self.version_str)

 @Slot()
 def on_actEdit_Remove_triggered(self):
 rows = list(set(map(lambda idx: idx.row(), self.ui.table.selectedIndexes())))
 for row in rows:
 self.__data.remove([self.model.item(row, col).text() for col in range(self.model.columnCount())])
 self.model.itemChanged.disconnect(self.__itemChanged)
 self.model.removeRows(rows[0], len(rows))
 self.model.itemChanged.connect(self.__itemChanged)
 self.setWindowTitle(self.unsaved_tip + self.version_str)

 def __selectionChanged(self):
 self.ui.actEdit_Remove.setEnabled(self.ui.table.selectionModel().hasSelection())

 def __itemChanged(self, item: QStandardItem):
 i, j, new = item.row(), item.column(), item.text()
 if (old := self.__data[i][j]) == new: return
 if j == 0 and not QDate.fromString(new, 'yyyy/MM/dd').isValid():
 QMessageBox.critical(self, 'Error', 'Invalid date format.')
 self.model.itemChanged.disconnect(self.__itemChanged)
 item.setText(old)
 self.model.itemChanged.connect(self.__itemChanged)
 return
 row = self.__data.pop(i)
 row[j] = new
 insort_right(self.__data, row)
 self.__updateTable(query(self.__data, self.__key))
 self.setWindowTitle(self.unsaved_tip + self.version_str)

 @Slot()
 def on_searchEdit_textChanged(self):
 self.__key = self.ui.searchEdit.text()
 self.__updateTable(query(self.__data, self.__key))

 @Slot()
 def on_actStat_Show_triggered(self):
 if self.__data:
 dlgCharts(self.__data, self).exec()
 else:
 QMessageBox.information(self, 'Info',

AtCoder Beginner Contest 260 A~F Solutions

Tue, 19 Jul 2022 20:31:00 +0800

A - A Unique Letter

Problem Summary

Given a string $S$ of length 3.
Output any character that appears exactly once in $S$ (e.g., in abc, any of the three characters can be the answer).

If no such character exists, output -1.

Constraints:

$S$ has length 3
$S$ consists of lowercase English letters.

Input Format

$S$

Output Format

Output any valid answer.

Samples

$S$	Output
`pop`	`o`
`abc`	`a`/`b`/`c`
`xxx`	`-1`

Analysis

Let the three input characters be a, b, c.

If $a = b = c$, output -1.
Check for two equal characters in different positions:

xxy pattern ($a = b$): output $c$
xyx pattern ($a = c$): output $b$
yxx pattern ($b = c$): output $a$
xyz pattern (all distinct): output any character

In the code, the last two cases are merged (handled by a single else, outputting $a$).

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <cstdio>
using namespace std;

int main()
{
 char a = getchar(), b = getchar(), c = getchar();
 if(a == b && b == c) puts("-1");
 else if(a == c) putchar(b);
 else if(a == b) putchar(c);
 else putchar(a);
 return 0;
}

B - Better Students Are Needed!

Problem Summary

$N$ candidates took an exam.
Candidate $i$ scored $A_i$ in math and $B_i$ in English.

The company selects candidates in three stages:

Top $X$ math scores are selected.
From remaining candidates, top $Y$ English scores are selected.
From remaining candidates, top $Z$ total scores (math + English) are selected.

Note: Candidates with equal scores are ordered by their IDs.

Output all selected candidate IDs in ascending order.

Constraints:
$1\le N\le 1000$
$0\le X,Y,Z\le N$
$1\le X+Y+Z\le N$
$0\le A_i,B_i\le 100$

Input Format

$N~X~Y~Z$
$A_1~A_2~\dots~A_N$
$B_1~B_2~\dots~B_N$

Output Format

Output selected candidate IDs in ascending order, one per line.

Analysis

Two approaches:

Use pair<int, int> for candidates and sort vectors/use priority queues for each selection stage.
Use a struct to store candidate data and sort three times with different criteria.

See Code 1 and Code 2.

Code

Code 1 (vector + sort)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 1005
using namespace std;
 
int a[maxn], b[maxn];
bool used[maxn];
 
int main()
{
 int n, x, y, z;
 scanf("%d%d%d%d", &n, &x, &y, &z);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 for(int i=0; i<n; i++)
 scanf("%d", b + i);
 
 // Math
 vector<pair<int, int>> sel_a;
 for(int i=0; i<n; i++)
 sel_a.emplace_back(-a[i], i);
 sort(sel_a.begin(), sel_a.end());
 for(int i=0; i<x; i++)
 used[sel_a[i].second] = true;
 
 // English
 vector<pair<int, int>> sel_b;
 for(int i=0; i<n; i++)
 if(!used[i])
 sel_b.emplace_back(-b[i], i);
 sort(sel_b.begin(), sel_b.end());
 for(int i=0; i<y; i++)
 used[sel_b[i].second] = true;
 
 // Total
 vector<pair<int, int>> sel_t;
 for(int i=0; i<n; i++)
 if(!used[i])
 sel_t.emplace_back(-(a[i] + b[i]), i);
 sort(sel_t.begin(), sel_t.end());
 for(int i=0; i<z; i++)
 used[sel_t[i].second] = true;
 
 for(int i=0; i<n; i++)
 if(used[i])
 printf("%d\n", i + 1);
 return 0;
}

Code 2 (struct-based sorting)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 1005
using namespace std;

struct Emp {
 int math, eng, id;
} emps[maxn];

inline bool cmp1(const Emp& e1, const Emp& e2) {
 return e1.math == e2.math?
 e1.id < e2.id:
 e1.math > e2.math;
}

inline bool cmp2(const Emp& e1, const Emp& e2) {
 return e1.eng == e2.eng?
 e1.id < e2.id:
 e1.eng > e2.eng;
}

inline bool cmp3(const Emp& e1, const Emp& e2) {
 int tot1 = e1.math + e1.eng, tot2 = e2.eng + e2.math;
 return tot1 == tot2?
 e1.id < e2.id:
 tot1 > tot2;
}

inline bool cmp4(const Emp& e1, const Emp& e2) {
 return e1.id < e2.id;
}

int main()
{
 int n, x, y, z;
 scanf("%d%d%d%d", &n, &x, &y, &z);
 
 for(int i=0; i<n; i++)
 scanf("%d", &emps[i].math),
 emps[i].id = i;
 for(int i=0; i<n; i++)
 scanf("%d", &emps[i].eng);
 
 auto last = emps + n;
 sort(emps, last, cmp1);
 sort(emps + x, last, cmp2);
 sort(emps + x + y, last, cmp3);
 sort(emps, emps + x + y + z, cmp4);
 
 for(int i=0; i<x+y+z; i++)
 printf("%d\n", emps[i].id + 1);
 return 0;
}

C - Changing Jewels

Problem Summary

Takahashi has an level $N$ red jewel.
He can perform the following operations any number of times:

Convert a level $N$ red jewel into “1 level $N-1$ red jewel + $X$ level $N$ blue jewels”.
Convert a level $N$ blue jewel into “1 level $N-1$ red jewel + $Y$ level $N-1$ blue jewels”.

What’s the maximum number of level 1 blue jewels he can obtain?

Constraints:
$1\le N\le 10$
$1\le X,Y\le 5$

Input Format

$N~X~Y$

Output Format

Output the maximum count of level 1 blue jewels.

Samples

$N$	$X$	$Y$	Output
$2$	$3$	$4$	$12$
$10$	$5$	$5$	$3942349900$

Note: Beware of 32-bit integer overflow.

Analysis

To maximize level 1 blue jewels, process jewels from higher levels downwards.
Maintain two variables: red (level $k$ red jewels) and blue (level $k$ blue jewels).
For each level from $N$ down to 2:

Convert all red jewels to lower-level red and blue jewels.
Convert all blue jewels to lower-level red and blue jewels.

Time complexity: $\mathcal O(N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <cstdio>
using namespace std;

int main()
{
 int n, x, y;
 scanf("%d%d%d", &n, &x, &y);
 long long red = 1LL, blue = 0LL;
 while(--n)
 {
 blue += red * x;
 red += blue, blue *= y;
 }
 printf("%lld\n", blue);
 return 0;
}

D - Draw Your Cards

Problem Summary

Process $N$ cards with unique numbers $P_1,\dots,P_N$ in order.
For each card $P_i$:

Find the topmost card in existing piles that is $\ge P_i$. Place $P_i$ on it.
If no such pile exists, create a new pile.
If a pile reaches $K$ cards, remove all its cards immediately.

Output the time each card is removed (or -1 if never removed).

Constraints:
$1\le K\le N \le 2\times 10^5$
$P$ is a permutation of $(1,2,\dots,N)$.

Analysis

Use a Union-Find structure to track parent cards and set-based operations to find the correct pile.
Maintain a set of current pile tops for efficient lookups.
For each card, track the pile size and update when merged.

Time complexity: $\mathcal O(N \log N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <cstdio>
#include <set>
#define maxn 200005
using namespace std;

int fa[maxn], eat[maxn], sz[maxn];

int find(int x) {
 return fa[x] == x? x: fa[x] = find(fa[x]);
}

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 set<int> cards;
 for(int i=0; i<n; i++)
 {
 int x;
 scanf("%d", &x);
 x --;
 eat[x] = -1, fa[x] = x;
 if(k == 1)
 {
 eat[x] = i + 1;
 continue;
 }
 auto it = cards.upper_bound(x);
 if(it == cards.end())
 cards.insert(x), sz[x] = 1;
 else
 {
 fa[*it] = x;
 cards.erase(it);
 if((sz[x] = sz[*it] + 1) == k)
 eat[x] = i + 1;
 else cards.insert(x);
 }
 }
 for(int i=0; i<n; i++)
 printf("%d\n", eat[find(i)]);
 return 0;
}

E - At Least One

Problem Summary

Given $M$ and $N$ pairs $(A_i,B_i)$, count all consecutive subarrays $[l,r]$ of $[1,M]$ such that for each $i$, $A_i$ or $B_i$ is in $[l,r]$.

Let $f(k)$ be the count of valid subarrays of length $k$. Output $f(1),\dots,f(M)$.

Constraints:
$1\le N\le 2\times 10^5$
$2\le M\le 2\times 10^5$
$1\le A_i < B_i\le M$

Analysis

Use a sliding window approach. For each $l$, find the smallest $r$ where all pairs are covered.
Preprocess each position’s contribution to coverage and track counts using difference arrays.

Time complexity: $\mathcal O(N + M)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

vector<int> inv[maxn];
int cnt[maxn], ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=0; i<n; i++)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 inv[a].push_back(i);
 inv[b].push_back(i);
 }
 int left = n;
 for(int i=1, j=1; i<=m; i++)
 {
 for(; j <= m && left > 0; j++)
 for(int x: inv[j])
 if(++cnt[x] == 1)
 left --;
 if(left > 0) break;
 ans[j - i] ++, ans[m - i + 2] --;
 for(int x: inv[i])
 if(--cnt[x] == 0)
 left ++;
 }
 for(int i=1; i<=m; i++)
 printf("%d ", ans[i] += ans[i - 1]);
 return 0;
}

F - Find 4-cycle

Problem Summary

Given a bipartite graph between sets $U$ and $V$, find any 4-cycle (four nodes forming a cycle). Output the nodes or -1.

Constraints:
$2\le |U| \le 3\times 10^5$
$2\le |V| \le 3000$
$4\le M\le \min(|U|\times|V|,3\times 10^5)$

Analysis

Exploit the small size of $V$. For each node in $V$, track pairs of nodes in $U$ connected to it. Use a matrix to record pairs and detect overlaps.

Time complexity: $\mathcal O(T^2)$, feasible due to $T \le 3000$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#include <cstring>
#include <vector>
#define maxs 300005
#define maxt 3005
using namespace std;

vector<int> G[maxs];
int f[maxt][maxt];

int main()
{
 int s, t, m;
 scanf("%d%d%d", &s, &t, &m);
 while(m--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v - s);
 }
 memset(f, -1, sizeof(f));
 for(int i=0; i<s; i++)
 for(int j=0; j+1<G[i].size(); j++)
 for(int k=j+1; k<G[i].size(); k++)
 {
 int u = G[i][j], v = G[i][k];
 if(u > v) u ^= v ^= u ^= v;
 if(f[u][v] != -1)
 {
 printf("%d %d %d %d\n", f[u][v] + 1, i + 1, u + s + 1, v + s + 1);
 return 0;
 }
 f[u][v] = i;
 }
 puts("-1");
 return 0;
}

AtCoder Beginner Contest 258 A~Ex Solutions

Mon, 04 Jul 2022 22:15:00 +0800

D - Trophy

Problem Statement

A game consists of $N$ stages. The $i$-th stage is represented by a pair $(A_i, B_i)$.

To clear a stage, you must first spend $A_i$ time watching an introduction. Then, it takes $B_i$ time to clear the stage. For subsequent clears of the same stage, the introduction is skipped (i.e., clearing the $i$-th stage $M$ times in total requires $A_i + M \times B_i$ time).

Initially, only the first stage is unlocked. After clearing any stage, the next stage is automatically unlocked (except the last stage). Find the minimum time required to clear exactly $X$ stages (repeats count).

$1\le N\le 2\times 10^5$
$1\le A_i,B_i\le 10^9$
$1\le X\le N$

Input Format

$N~X$
$A_1~B_1$
$\vdots$
$A_N~B_N$

Output Format

Print the answer.

Sample

Refer to AtCoder.

Analysis

The optimal strategy involves clearing some initial stages once, then repeatedly clearing a particular stage. Using prefix sums and enumerating each stage, we achieve $\mathcal O(n)$ time complexity.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define INF 0x7FFFFFFFFFFFFFFFLL
using namespace std;

int main()
{
 int n, x;
 scanf("%d%d", &n, &x);
 if(x < n) n = x;
 long long s = 0LL, ans = INF, cur;
 for(int i=1; i<=n; i++)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 if((cur = (s += a + b) + (long long)(x - i) * b) < ans)
 ans = cur;
 }
 printf("%lld\n", ans);
 return 0;
}

E - Packing Potatoes

Problem Statement

There are $10^{100}$ potatoes arranged in a sequence. The weight of the $i$-th potato is $W_{i \bmod N}$ (weights cycle every $N$ elements).

Takahashi packs potatoes into boxes sequentially. When the total weight in a box reaches at least $X$, he starts a new box.

Given $Q$ queries, each asking for the number of potatoes in the $K_i$-th box.

$1\le N,Q\le 2\times 10^5$
$1\le X,W_i\le 10^9$
$1\le K_i\le 10^{12}$

Input Format

$N~Q~X$
$W_0~\dots~W_{N-1}$
$K_1$
$\vdots$
$K_Q$

Output Format

Print $Q$ lines, each containing the answer.

Sample

Refer to AtCoder.

Analysis

Cyclic pattern problem.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


#include <cstdio>
#include <vector>
#define maxn 200005
using namespace std;

using LL = long long;
int cnt[maxn], ord[maxn], w[maxn << 1];

template <typename T>
inline T read()
{
 char c;
 while((c = getchar()) < '0' || c > '9');
 T res = c ^ 48;
 while((c = getchar()) >= '0' && c <= '9')
 res = (res << T(3)) + (res << T(1)) + (c ^ 48);
 return res;
}

inline void print(int x)
{
 if(x > 9) print(x / 10);
 putchar(x % 10 ^ 48);
}

inline void println(int x)
{
 print(x);
 putchar('\n');
}

int main()
{
 int n = read<int>(), q = read<int>(), x = read<int>();
 LL sum = 0LL;
 for(int i=0; i<n; i++)
 sum += w[i + n] = w[i] = read<int>();
 int fill = x / sum * n;
 for(int i=0; i<n; i++)
 cnt[i] = fill, ord[i] = -1;
 x %= sum;
 for(int i=0, j=0, s=0; i<n; i++)
 {
 if(j < i) j = i, s = 0;
 while(s < x)
 {
 s += w[j];
 j += 1;
 }
 cnt[i] += j - i;
 s -= w[i];
 }
 vector<int> path;
 int loop = -1;
 for(int u=0, k=0; ; k++)
 {
 if(ord[u] != -1)
 {
 loop = k - ord[u];
 break;
 }
 ord[u] = k;
 path.push_back(u);
 (u += cnt[u]) %= n;
 }
 int non_loop = path.size() - loop;
 while(q--)
 {
 LL k = read<LL>();
 println(cnt[path[--k < non_loop? k:
 non_loop + (k - non_loop) % loop]]);
 }
 return 0;
}

F - Main Street

WJ...

G - Triangle

Problem Statement

Given a simple undirected graph $G$ with $N$ vertices and its adjacency matrix $A$:

$A_{i,j}=1$ indicates an edge between vertices $i$ and $j$
$A_{i,j}=0$ otherwise (with $A_{i,i}=0$ for all $i$)

Count the number of triples $(i,j,k)$ satisfying:

$1\le i < j < k \le N$
$A_{i,j}=A_{i,k}=A_{j,k}=1$

$3\le N\le 3000$

Input Format

$N$
$A_{1,1}A_{1,2}\dots A_{1,N}$
$A_{2,1}A_{2,2}\dots A_{2,N}$
$\vdots$
$A_{N,1}A_{N,2}\dots A_{N,N}$ (e.g., 10110)

Output Format

Print the count.

Sample

Refer to AtCoder.

Analysis

The naive $\mathcal O(N^3)$ approach can be optimized using bitset operations. For each edge $(i,j)$, compute the intersection of $i$’s and $j$’s adjacency lists, then sum all intersections and divide by 3. Time complexity: $\mathcal O(N^3 / w)$ where $w$ is bitset width (64).

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <cstdio>
#include <bitset>
#define maxn 3000
using namespace std;

bitset<maxn> a[maxn];

int main()
{
 int n = 0; char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 for(int i=0; i<n; i++, getchar())
 for(int j=0; j<n; j++)
 if(getchar() == '1')
 a[i].set(j);
 long long ans = 0LL;
 for(int i=0; i+1<n; i++)
 for(int j=i+1; j<n; j++)
 if(a[i][j])
 ans += (a[i] & a[j]).count();
 printf("%lld\n", ans / 3LL);
 return 0;
}

AtCoder Beginner Contest 254 A~E Solutions

Sat, 04 Jun 2022 22:41:00 +0800

A - Last Two Digits

Problem Statement

Given a positive integer $N$, output its last two digits.
$100\le N\le 999$

Input Format

$N$

Output Format

Print the last two digits of $N$. Note that the output may have leading 0s.

Sample

$N$	Output
$254$	`54`
$101$	`01`

Analysis

Since $N$ is guaranteed to be a three-digit number, we can directly treat the input as a string and output its last two characters.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 getchar();
 putchar(getchar());
 putchar(getchar());
 return 0;
}

B - Practical Computing

Problem Statement

Output $N$ integer sequences $A_0,\dots,A_{N-1}$ defined as:

Length of $A_i$ is $i+1$.
The $(j+1)$-th element of $A_i$, denoted $a_{i,j}$ ($0\le j\le i < N$), is:
- $1$ if $j=0$ or $j=i$;
- $a_{i-1,j-1}+a_{i-1,j}$ otherwise.

$1\le N\le 30$

Input Format

$N$

Output Format

Print $N$ lines. The $i$-th line contains $i$ numbers from $A_{i-1}$, separated by spaces.

Sample

Sample Input 1

1

3

Sample Output 1

Sample Input 2

1

10

Sample Output 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

Analysis

The problem essentially describes the Yang Hui Triangle (Pascal’s Triangle). We can compute the elements sequentially as per the rules. Time complexity $\mathcal O(n^2)$, space complexity $\mathcal O(n)$ or $\mathcal O(n^2)$. See Code 1 and 2.

Alternatively, since $a_{i,j} = \binom{i}{j}$, we can compute it with $\mathcal O(1)$ space (code to be added).

Code

Code 1 (Standard approach without optimization, cin/cout, $7\text{ms}~3604\text{KB}$)
Time: $\mathcal O(n^2)$
Space: $\mathcal O(n^2)$
Difficulty: Low

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <iostream>
using namespace std;

int arr[35][35];

int main()
{
 int n;
 cin >> n;
 for (int i = 0; i < n; i++)
 {
 arr[i][0] = 1;
 arr[i][i] = 1;
 }
 for (int i = 2; i < n; i++)
 {
 for (int j = 1; j < i; j++)
 {
 arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
 }
 }
 for (int i = 0; i < n; i++)
 {
 for (int j = 0; j <= i; j++)
 {
 cout << arr[i][j] << " ";
 }
 cout << endl;
 }
 return 0;
}

Code 2 (Standard approach + rolling array, scanf/printf, $6\text{ms}~1656\text{KB}$)
Time: $\mathcal O(n^2)$
Space: $\mathcal O(n)$
Difficulty: Medium-Low

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
using namespace std;

int a[35];

int main()
{
 int n;
 scanf("%d", &n);
 a[0] = 1, puts("1");
 for(int i=1; i<n; i++)
 {
 putchar('1');
 for(int j=i-1; j>0; j--)
 a[j] += a[j - 1];
 for(int j=1; j<i; j++)
 printf(" %d", a[j]);
 a[i] = 1, puts(" 1");
 }
 return 0;
}

C - K Swap

Problem Statement

Given a sequence $A=(a_1,a_2,\dots,a_N)$ of length $N$ and an integer $K$, you can perform the following operation any number of times:

Choose an integer $1\le i\le N-K$, swap $a_i$ and $a_{i+K}$.

Determine if $A$ can be sorted in non-decreasing order through these operations.

$2\le N\le 2\times 10^5$
$1\le K\le N-1$
$1\le a_i\le 10^9$

Input Format

$N~K$
$a_1~\dots~a_N$

Output Format

Print Yes if possible, otherwise No.

Sample

Sample Input 1

Sample Output 1

1

Yes

Explanation: After two swaps, $A$ becomes sorted.

Sample Input 2

Sample Output 2

1

No

Sample Input 3

1
2


7 5
1 2 3 4 5 5 10

Sample Output 3

1

Yes

Analysis

Elements at positions $i, i+K, i+2K, \dots$ (for $0 \le i < K$) can be freely rearranged. For each such group, sort them and check if the entire array becomes sorted.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <set>
#include <algorithm>
#define maxn 200005
using namespace std;

int a[maxn], b[maxn];

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<n; i++)
 {
 scanf("%d", a + i);
 b[i] = a[i];
 }
 sort(b, b + n);
 for(int i=0; i<k; i++)
 {
 multiset<int> s1, s2;
 for(int j=i; j<n; j+=k)
 {
 s1.insert(a[j]);
 s2.insert(b[j]);
 }
 if(s1 != s2)
 {
 puts("No");
 return 0;
 }
 }
 puts("Yes");
 return 0;
}

Note: Python’s array slicing makes this problem concise. Example Python code:

1
2
3
4
5


n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(k):
 a[i::k] = sorted(a[i::k])
print('Yes' if a == sorted(a) else 'No')

D - Together Square

Problem Statement

Given $N$, count the number of positive integer pairs $(i,j)$ satisfying:

$1\le i,j\le N$
$i\times j$ is a perfect square.

$1\le N\le 2\times 10^5$

Input Format

$N$

Output Format

Print the answer.

Sample

$N$	Output
$4$	$6$
$254$	$896$

Analysis

For $i \times j$ to be a square, the product’s prime factors must have even exponents. Enumerate coprime pairs $(x,y)$ where $x,y \le \sqrt{N}$, and count valid $(i,j)$ pairs derived from them. Time complexity $\mathcal O(N \log \sqrt N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

inline int gcd(int a, int b)
{
 while(b ^= a ^= b ^= a %= b);
 return a;
}

int main()
{
 int n = 0; char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 int t = __builtin_sqrt(n);
 long long ans = 0LL, x;
 for(int i=1; i<=t; i++)
 for(int j=i; j<=t; j++)
 if(gcd(i, j) == 1)
 {
 ans += (x = n / (i > j? i * i: j * j));
 if(i != j) ans += x;
 }
 printf("%lld\n", ans);
 return 0;
}

E - Small d and k

Problem Statement

Given an undirected graph with $N$ vertices and $M$ edges, where each vertex has degree ≤3. Answer $Q$ queries:

Find the sum of indices of vertices within distance $k_i$ from $x_i$.

$1\le N,Q\le 1.5\times 10^5$
$0\le M\le \min\{\frac{N(N-1)}2,\frac32N\}$
$0\le k_i\le 3$

Input Format

$N~M$
$a_1~b_1$
$\vdots$
$a_M~b_M$
$Q$
$x_1~k_1$
$\vdots$
$x_Q~k_Q$

Output Format

Print $Q$ lines with answers.

Sample

Sample Input

Sample Output

Analysis

Leverage the constraints:

Maximum reachable nodes per query: 3⁴ = 81 (practical limit ≈28)
Use BFS up to depth 3 for each query. Reset visited markers efficiently.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <queue>
#define maxn 150005
using namespace std;

vector<int> G[maxn];
int dis[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 G[a].push_back(b);
 G[b].push_back(a);
 }
 int Q; scanf("%d", &Q);
 for(int i=1; i<=n; i++) dis[i] = -1;
 while(Q--)
 {
 int x, k;
 scanf("%d%d", &x, &k);
 vector<int> ans;
 queue<int> q;
 q.push(x);
 dis[x] = 0;
 while(!q.empty())
 {
 int v = q.front(); q.pop();
 int d = dis[v];
 if(d <= k) ans.push_back(v);
 if(++d > k) continue;
 for(int u: G[v])
 if(dis[u] == -1)
 {
 dis[u] = d;
 q.push(u);
 }
 }
 int res = 0;
 for(int v: ans)
 res += v, dis[v] = -1;
 printf("%d\n", res);
 }
 return 0;
}

AtCoder Beginner Contest 253 A~E Solutions

Sun, 29 May 2022 16:07:00 +0800

A - Median?

Problem Statement

Given three positive integers $a$, $b$, and $c$, determine whether $b$ is the median of the three numbers (i.e., the second value when sorted in non-decreasing order, not the average).

Constraints:
$1 \le a, b, c \le 100$

Input Format

$a~b~c$

Output Format

Print Yes if $b$ is the median; otherwise, print No.

Sample Cases

$a$	$b$	$c$	Output
5	3	2	`Yes`
2	5	3	`No`
100	100	100	`No`

Analysis

Since this is an A-level problem, the solution is straightforward. ~~I misread it as the average during the contest and got WA..~~ (The description should be clear enough.)

We can directly sort the three numbers or check if either $a \le b \le c$ or $c \le b \le a$ holds.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 puts((a <= b && b <= c) || (c <= b && b <= a)? "Yes": "No");
 return 0;
}

B - Distance Between Tokens

Problem Statement

On an $H \times W$ grid, exactly two cells contain tokens, and the rest are empty. Starting from either token, find the minimum number of moves required to reach the other token by moving up, down, left, or right.

Input Format

The first line contains $H$ and $W$ separated by a space. The next $H$ lines each contain a string of length $W, where -denotes an empty cell ando` denotes a token.

Output Format

Print the minimum number of moves required.

Sample Cases

Sample Input 1

1
2
3


2 3
--o
o--

Sample Output 1

1

3

Sample Input 2

1
2
3
4
5
6


5 4
-o--
----
----
----
-o--

Sample Output 2

1

4

Analysis

No BFS is needed. Since there are no obstacles, directly compute the Manhattan distance between the two tokens: $|x_1 - x_2| + |y_1 - y_2|$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#include <vector>
using namespace std;

int main()
{
 int h = 0, w = 0, x1 = -1, y1 = -1, x2 = -1, y2 = -1;
 char c;
 while((c = getchar()) != ' ')
 h = (h << 3) + (h << 1) + (c ^ 48);
 while((c = getchar()) != '\n')
 w = (w << 3) + (w << 1) + (c ^ 48);
 for(; h--; getchar())
 for(int i=w; i--; )
 if(getchar() == 'o')
 if(x1 == -1) x1 = h, y1 = i;
 else { x2 = h, y2 = i; break; }
 printf("%d\n", x1 - x2 + (y1 > y2? y1 - y2: y2 - y1));
 return 0;
}

C - Max - Min Query

Problem Statement

Given an initially empty sequence $S$, process $Q$ operations:

1 x: Append $x$ to $S$.
2 x c: Remove $\min(c, \text{count of } x)$ occurrences of $x$ from $S$.
3: Print the difference between the maximum and minimum values in $S`.

Constraints:
$1 \le Q \le 2 \times 10^5$
$0 \le x \le 10^9$
$1 \le c \le Q$

Input Format

$Q$
$\text{query}_1$
$\text{query}_2$
$\vdots$
$\text{query}_Q$

Output Format

For each 3 operation, print the difference.

Analysis

~~A classic STL exercise.~~

Use a multiset or map (C++ specific). Here’s a map approach:

mp[x] returns the count of $x$ (auto-initialized to 0).
mp.begin()->first gives the minimum element.
mp.rbegin()->first gives the maximum element.
mp.erase(x) removes all occurrences of $x$.

Each query can be handled efficiently with these operations.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
#include <map>
using namespace std;

int main()
{
 int q;
 scanf("%d", &q);
 map<int, int> cnt;
 while(q--)
 {
 int op;
 scanf("%d", &op);
 if(op == 3) printf("%d\n", cnt.rbegin()->first - cnt.begin()->first);
 else if(op == 1)
 {
 int x;
 scanf("%d", &x);
 cnt[x] ++;
 }
 else if(op == 2)
 {
 int x, m;
 scanf("%d%d", &x, &m);
 if(cnt[x] > m) cnt[x] -= m;
 else cnt.erase(x);
 }
 }
 return 0;
}

D - FizzBuzz Sum Hard

Problem Statement

Compute the sum of integers from $1$ to $N$ that are not multiples of $A$ or $B$.

Constraints:
$1 \le N, A, B \le 10^9$

Input Format

$N~A~B$

Output Format

Print the answer.

Analysis

By inclusion-exclusion principle, the sum of multiples of $A$ or $B$ is:
$\text{sum}(A) + \text{sum}(B) - \text{sum}(\text{lcm}(A,B))$.

Define:

$f(n) = 1 + 2 + \dots + n = \frac{n(n+1)}{2}$
$\text{sum}(x) = x \cdot f(\lfloor N/x \rfloor)$ (sum of multiples of $x$ up to $N$)

The final answer is:
$f(N) - \text{sum}(A) - \text{sum}(B) + \text{sum}(\text{lcm}(A,B))$

Time complexity is dominated by computing $\text{lcm}(A,B)$ using GCD.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
using namespace std;

using LL = long long;
inline LL sum(const LL& x, const LL& n)
{
 LL cnt = n / x;
 return x * cnt * (cnt + 1LL) >> 1LL;
}

int main()
{
 int n, a, b;
 scanf("%d%d%d", &n, &a, &b);
 LL x = b, y = a;
 while(b ^= a ^= b ^= a %= b);
 LL t = x / a * y; // t = lcm(a, b)
 printf("%lld\n", sum(1, n) - sum(x, n) - sum(y, n) + sum(t, n));
 return 0;
}

E - Distance Sequence

Problem Statement

Count the number of sequences $A = (A_1, \dots, A_N)$ modulo $998244353$ that satisfy:

$1 \le A_i \le M$ for all $i$
$|A_i - A_{i+1}| \ge K$ for all $1 \le i < N$

Constraints:
$2 \le N \le 1000$
$1 \le M \le 5000$
$0 \le K < M$

Input Format

$N~M~K$

Output Format

Print the count modulo $998244353$.

Analysis

Dynamic Programming (DP) approach:

Define $\text{dp}(i, j)$ as the number of valid sequences ending with $j$ at position $i$.
Transition: $\text{dp}(i, j) = \sum \text{dp}(i-1, p)$ where $|j - p| \ge K$.

Optimize using prefix/suffix sums to reduce time complexity from $\mathcal{O}(NM^2)$ to $\mathcal{O}(NM)$. Special case $K=0$ has answer $M^N \bmod 998244353$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <cstdio>
#define maxn 1002
#define maxm 5005
#define MOD 998244353
using namespace std;

using LL = long long;
int qpow(LL a, LL b)
{
 LL ans = 1LL;
 while(b > 0)
 {
 if(b & 1LL) ans = ans * a % MOD;
 a = a * a % MOD, b >>= 1LL;
 }
 return ans;
}

inline void mod(int& x) { if(x >= MOD) x -= MOD; }
int dp[2][maxm];

int main()
{
 int n, m, k;
 scanf("%d%d%d", &n, &m, &k);
 if(k == 0)
 {
 printf("%d\n", qpow(m, n));
 return 0;
 }
 for(int i=1; i<=m; i++)
 dp[0][i] = 1;
 for(int i=1; i<n; i++)
 {
 int c = i & 1, p = c ^ 1, s = 0;
 for(int j=k+1; j<=m; j++)
 mod(s += dp[p][j]);
 for(int j=1; j<=m; j++)
 {
 if(j > k) mod(s += dp[p][j - k]);
 mod(dp[c][j] = s);
 if(j + k <= m)
 {
 mod(s -= dp[p][j + k]);
 if(s < 0) s += MOD;
 }
 }
 }
 int ans = 0, t = n & 1 ^ 1;
 for(int i=1; i<=m; i++)
 mod(ans += dp[t][i]);
 printf("%d\n", ans);
 return 0;
}

AtCoder Beginner Contest 252 A~G Solutions

Sun, 22 May 2022 11:31:00 +0800

A - ASCII code

Problem Statement

Given a positive integer $N$, output the character whose ASCII code is $N$.
$97\le N\le 122$

Input Format

$N$

Output Format

Print the character corresponding to ASCII code $N$.

Analysis

Note a corresponds to 97, b to 98, …, z to 122. Beginner conversion examples:

C
1 2

int n = 97; putchar(n); /* Output: a */
putchar automatically converts to character. printf("%c", n) works similarly.

C++

1
2


int n = 97;
cout << char(n) << endl; // Output: a

Direct cout << n outputs 97, requires char conversion.

Python
1 2

n = 97 print(chr(n)) # Output: a
Requires chr conversion.

Java

1
2
3


int n = 97;
char c = (char) n;
System.out.print(c);

Casting required.

JavaScript

1
2
3


var n = 97;
var c = String.fromCharCode(n);
console.log(c); // Output: a

Uses String.fromCharCode.

Need more examples?

Code

Straightforward Python (AC in 25s):

1

print(chr(int(input())))

B - Takahashi’s Failure

Problem Statement

Takahashi’s house has $N$ foods. The $i$-th food has deliciousness $A_i$.
He dislikes $K$ foods: $B_1,B_2,\dots,B_K$.
Takahashi will randomly select a food with maximum deliciousness and eat it.
Is it possible for him to eat a disliked food?

$1\le K\le N\le 100$
$1\le A_i\le 100$
$1\le B_i\le N$

Input Format

$N~K$
$A_1~\dots~A_N$
$B_1~\dots~B_K$

Output Format

Print Yes if possible, No otherwise.

Analysis

Check if any disliked food has maximum deliciousness. See code.

Code

Note convert to 0-indexed for $B_i$:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

int a[105];

int main()
{
 int n, k, mx = 0;
 scanf("%d%d", &n, &k);
 for(int i=0; i<n; i++)
 {
 scanf("%d", a + i);
 if(a[i] > mx) mx = a[i];
 }
 while(k--)
 {
 scanf("%d", &n);
 if(a[--n] == mx)
 {
 puts("Yes");
 return 0;
 }
 }
 puts("No");
 return 0;
}

C - Slot Strategy

Problem Statement

Refer to AtCoder.

$2\le N\le 100$

Input Format

$N$
$S_1$
$\vdots$
$S_N$

Output Format

Print the answer.

Analysis

Let $\text{cnt}[i][j]$ be the count of $S_k[j] = i$. Compute cost for each target digit. See code.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
using namespace std;

int cnt[10][10]; // cnt[i][j] = number of (s[j]=i)

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 char s[15];
 scanf("%s", s);
 for(int j=0; j<10; j++)
 cnt[s[j] ^ 48][j] ++;
 }
 int ans = 1000;
 for(int i=0; i<10; i++)
 {
 int cur = 0;
 for(int j=0; j<10; j++)
 {
 int c = j + (cnt[i][j] - 1) * 10;
 if(c > cur) cur = c;
 }
 if(cur < ans) ans = cur;
 }
 printf("%d\n", ans);
 return 0;
}

D - Distinct Trio

Problem Statement

Given integer sequence $A=(A_1,\dots,A_N)$, count triples $(i,j,k)$ where:

$1\le i < j < k\le N$
$A_i \ne A_j \ne A_k$

$3\le N\le 2\times 10^5$
$1\le A_i\le 2\times 10^5$

Input Format

$N$
$A_1~\dots~A_N$

Output Format

Print the count.

Analysis

Approach:

Total triples $C_n^3$ minus invalid ones.
For each $x$ in $A$:
- Subtract $C_{\text{cnt}_x}^2 \times (N-\text{cnt}_x)$ for pairs (x,x,y)
- Subtract $C_{\text{cnt}_x}^3$ for triples (x,x,x)

Time: $O(N + \max A)$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#include <cstdio>
#define maxn 200005
using namespace std;

using LL = long long;
int cnt[maxn];

inline LL C2(int n) { return n * (n - 1LL) >> 1LL; }
inline LL C3(int n) { return C2(n) * (n - 2LL) / 3LL; }

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 cnt[a] ++;
 }
 LL ans = C3(n);
 for(int i=1; i<maxn; i++)
 if(cnt[i] > 1)
 {
 ans -= C2(cnt[i]) * (n - cnt[i]);
 if(cnt[i] > 2) ans -= C3(cnt[i]);
 }
 printf("%lld\n", ans);
 return 0;
}

E - Road Reduction

Problem Statement

Given undirected graph with $N$ nodes and $M$ edges. Find a spanning tree minimizing the sum of distances from node 1 to all others.

$2\le N\le 2\times 10^5$
$N-1\le M\le 2\times 10^5$
$1\le C_i\le 10^9$

Input Format

$N~M$
$A_1~B_1~C_1$
$\vdots$
$A_M~B_M~C_M$

Output Format

Print indices of $N-1$ edges in the tree.

Analysis

Optimal tree preserves shortest paths from node 1. Use Dijkstra’s algorithm and track edges.

Code

Priority queue (182ms):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <cstdio>
#include <queue>
#define maxn 200005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

struct Edge
{
 int v, id; LL d;
 inline Edge(int u, int l, int i): v(u), d(l), id(i) {}
};

vector<Edge> G[maxn];
LL dis[maxn];
int ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=m; i++)
 {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 G[--a].emplace_back(--b, c, i);
 G[b].emplace_back(a, c, i);
 }
 priority_queue<pli, vector<pli>, greater<pli>> q;
 for(int i=1; i<n; i++) dis[i] = INF;
 q.emplace(0LL, 0);
 while(!q.empty())
 {
 auto [d, v] = q.top(); q.pop();
 if(dis[v] == d)
 for(const Edge& e: G[v])
 {
 LL nd = d + e.d;
 if(nd < dis[e.v])
 q.emplace(dis[e.v] = nd, e.v),
 ans[e.v] = e.id;
 }
 }
 for(int i=1; i<n; i++) printf("%d ", ans[i]);
 return 0;
}

Set (202ms):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <vector>
#include <set>
#define maxn 200005
#define INF 9223372036854775807LL
using namespace std;

using LL = long long;
using pli = pair<LL, int>;

struct Edge
{
 int v, id; LL d;
 inline Edge(int u, int l, int i): v(u), d(l), id(i) {}
};

vector<Edge> G[maxn];
LL dis[maxn];
int ans[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=1; i<=m; i++)
 {
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 G[--a].emplace_back(--b, c, i);
 G[b].emplace_back(a, c, i);
 }
 set<pli> s; // <distance, vertex>
 for(int i=1; i<n; i++) dis[i] = INF;
 s.emplace(0LL, 0);
 while(!s.empty())
 {
 auto [d, v] = *s.begin(); s.erase(s.begin());
 for(const Edge& e: G[v])
 {
 LL nd = d + e.d;
 if(nd < dis[e.v])
 {
 if(dis[e.v] < INF)
 s.erase(pli(dis[e.v], e.v));
 s.emplace(dis[e.v] = nd, e.v);
 ans[e.v] = e.id;
 }
 }
 }
 for(int i=1; i<n; i++) printf("%d ", ans[i]);
 return 0;
}

F - Bread

Problem Statement

Given initial loaf of length $L$, split into parts including all elements of array $A$. Each split of $k$ costs $k$. Find minimum total cost.

$2\le N\le 2\times 10^5$
$1\le A_i\le 10^9$
$A_1+\dots+A_N\le L\le 10^{15}$

Input Format

$N~L$
$A_1~\dots~A_N$

Output Format

Print the minimal cost.

Analysis

Merge all elements (plus remaining $L-\sum A$ if needed) using a min-heap. Always merge smallest two elements.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <cstdio>
#include <queue>
using namespace std;

using LL = long long;

int main()
{
 int n;
 LL l;
 scanf("%d%lld", &n, &l);
 priority_queue<LL, vector<LL>, greater<LL>> q;
 for(int i=0; i<n; i++)
 {
 int x;
 scanf("%d", &x);
 q.push(x);
 l -= x;
 }
 if(l > 0) q.push(l);
 LL ans = 0LL;
 while(q.size() > 1)
 {
 LL x = q.top(); q.pop();
 x += q.top(); q.pop();
 ans += x;
 q.push(x);
 }
 printf("%lld\n", ans);
 return 0;
}

G - Pre-Order

Problem Statement

Count valid rooted trees with given pre-order traversal $P_1,\dots,P_N$, where children are visited in ascending order. Modulo 998244353.

$2\le N\le 500$
$P_1=1$
$P$ is permutation.

Input Format

$N$
$P_1~\dots~P_N$

Output Format

Print the count modulo 998244353.

Analysis

Let $dp(l,r)$ be the count for subarray $A_l,\dots,A_{r-1}$. Transition:

$dp(l,r) = dp(l+1,r) + \sum_{k} dp(l+1,k) \times dp(k,r)$ if $A_l < A_k$

Code

Version 1 (59ms):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define MOD 998244353
#define maxn 505
using namespace std;

using LL = long long;
int p[maxn], dp[maxn][maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 scanf("%d", p + i);
 for(int l=n; l>0; l--)
 {
 dp[l][l] = 1;
 for(int r=l+1; r<=n; r++)
 {
 dp[l][r] = dp[l + 1][r];
 for(int k=l+1; k<r; k++)
 if(p[l] < p[k] && (dp[l][r] += LL(dp[l + 1][k]) * dp[k][r] % MOD) >= MOD)
 dp[l][r] -= MOD;
 }
 }
 printf("%d\n", dp[1][n]);
 return 0;
}

Version 2 (66ms):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#define MOD 998244353
#define maxn 505
using namespace std;

using LL = long long;
int p[maxn], dp[maxn][maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 scanf("%d", p + i);
 for(int i=1; i<=n; i++)
 dp[i][i] = 1;
 for(int d=1; d<=n; d++)
 for(int l=1, r=d+1; r<=n; l++, r++)
 {
 dp[l][r] = dp[l + 1][r];
 for(int k=l+1; k<r; k++)
 if(p[l] < p[k] && (dp[l][r] += LL(dp[l + 1][k]) * dp[k][r] % MOD) >= MOD)
 dp[l][r] -= MOD;
 }
 printf("%d\n", dp[1][n]);
 return 0;
}

AtCoder Beginner Contest 250 C~E Solution

Wed, 11 May 2022 07:45:00 +0800

C - Adjacent Swaps

Problem Statement

$N$ balls are arranged in a row from left to right. Initially, the $i$-th ball from the left has the number $i$ written on it.
Perform $Q$ operations, where the $i$-th operation is as follows:

Let $j$ be the position of the ball with number $x_i$ written on it among the $N$ balls.
If $j=N$, swap it with the $(j-1)$-th ball; otherwise, swap it with the $(j+1)$-th ball.

Output the numbers written on the balls after all operations. See the output format for details.

$2\le N\le 2\times 10^5$
$1\le Q\le 2\times 10^5$
$1\le x_i\le N$

Input Format

$N~Q$
$x_1$
$\vdots$
$x_Q$

Output Format

Let $a_i$ be the number written on the $i$-th ball from the left after all operations. Output in the following format:
$a_1~a_2~\dots~a_n$
That is, output $a_1,\dots,a_n$ in order on a single line, separated by spaces.

Sample

Refer to AtCoder for samples.

Analysis

Given the constraints, only algorithms with time complexity $\mathcal O(N+Q\log n)$ or better are acceptable.
Brute-force simulation (searching for positions in $\mathcal O(NQ)$) is infeasible.

An efficient approach is to maintain index arrays $p$, where $p_x=i$ when $a_i=x$.
This allows finding the position of $x_i$ in $\mathcal O(1)$ per operation.
When swapping, update both $a$ and $p$. Total time complexity is $\mathcal O(N+Q)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <cstdio>
#define maxn 200005
using namespace std;

inline void swap(int& x, int& y) { x ^= y ^= x ^= y; }

int pos[maxn], ans[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=1; i<=n; i++)
 ans[i] = pos[i] = i;
 while(q--)
 {
 int x;
 scanf("%d", &x);
 int p1 = pos[x];
 int p2 = p1 == n? p1 - 1: p1 + 1;
 swap(pos[x], pos[ans[p2]]);
 swap(ans[p1], ans[p2]);
 }
 for(int i=1; i<=n; i++)
 printf("%d ", ans[i]);
 return 0;
}

D - 250-like Number

Problem Statement

A positive integer $k$ is called “250-like” if:

$k=p\times q^3$ where $p$ and $q$ are primes with $p < q$.

Count the number of 250-like numbers $k$ that do not exceed $N$.

$1\le N\le 10^{18}$

Input Format

$N$

Output Format

Output the answer as an integer.

Sample

$N$	Output
$250$	$2$
$1$	$0$
$123456789012345$	$226863$

Analysis

Given the large $N$, we note that $q$ is bounded by $\sqrt[3]{N/2}\approx794000$.

Sieve primes up to this bound. For each prime $p$, compute the maximum $q$ such that $p\times q^3\le N$, then add the count of primes in $(p, q]$. Terminate when $p\ge q$.

Use binary search or a two-pointer technique. Total time complexity is approximately $\mathcal O(n^{\frac{7}{22}})$.

Code

This implementation uses a two-pointer approach.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>
#include <cmath>
#include <vector>
#define maxp 794000
using namespace std;

using LL = long long;

bool bad[maxp];
vector<int> primes;

inline LL pow3(LL x) { return x * x * x; }

int main()
{
 bad[0] = bad[1] = true;
 for(int i=2; i<maxp; i++)
 if(!bad[i])
 {
 primes.push_back(i);
 for(int j=i<<1; j<maxp; j+=i)
 bad[j] = true;
 }
 LL n;
 scanf("%lld", &n);
 LL ans = 0LL;
 for(int i=0, j=primes.size()-1; i<j; i++)
 {
 while(j >= 0 && primes[i] * pow3(primes[j]) > n) j --;
 if(i >= j) break;
 ans += j - i;
 }
 printf("%lld\n", ans);
 return 0;
}

E - Prefix Equality

Problem Statement

Given two length-$N$ sequences $A=(A_1,\dots,A_N)$ and $B=(B_1,\dots,B_N)$.
For $1\le i\le Q$, answer queries of the form:

Determine if the sets $\{A_1,\dots,A_{x_i}\}$ and $\{B_1,\dots,B_{y_i}\}$ are equal.

$1\le N,Q\le 2\times 10^5$
$1\le A_i\le B_i\le 10^9$

Input Format

$N$
$A_1~\dots~A_N$
$B_1~\dots~B_N$
$Q$
$x_1~y_1$
$\vdots$
$x_Q~y_Q$

Sample

Sample Input

Sample Output

1
2
3
4
5
6
7


Yes
Yes
Yes
No
No
Yes
No

Analysis

We use a hashing approach to solve this efficiently.

Compute prefix hashes for $A$ and $B$ by accumulating hash values of newly encountered elements. For each index $i$, maintain:

$$ P_A(i) = \text{hash of } \{A_1,\dots,A_i\} \\ P_B(i) = \text{hash of } \{B_1,\dots,B_i\} $$

A query $(x,y)$ is answered by checking $P_A(x) == P_B(y)$.

To mitigate hash collisions, use a robust hash function like $H(x)=x(x+93)(x+117) \bmod (2^{32}-1)$. Time complexity is $\mathcal O(N+Q)$ with unordered sets.

Code

This code uses natural overflow for modular arithmetic.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <cstdio>
#include <unordered_set>
#define maxn 200005
using namespace std;

inline int read()
{
 char c;
 while((c = getchar()) < '0' || c > '9');
 int res = c ^ 48;
 while((c = getchar()) >= '0' && c <= '9')
 res = (res << 3) + (res << 1) + (c ^ 48);
 return res;
}

unsigned suma[maxn], sumb[maxn];
inline void hread(unsigned* psum, int n)
{
 unordered_set<int> s;
 for(int i=1, x; i<=n; i++)
 {
 psum[i] = psum[i - 1];
 if(s.insert(x = read()).second)
 psum[i] += x * unsigned(x + 93) * unsigned(x + 117);
 }
}

int main()
{
 int n = read();
 hread(suma, n);
 hread(sumb, n);
 for(int q=read(); q--;)
 puts(suma[read()] == sumb[read()]? "Yes": "No");
 return 0;
}

UNIQUE VISION Programming Contest 2022（AtCoder Beginner Contest 248）Solutions for Problems C~D

Sun, 17 Apr 2022 15:45:00 +0800

C - Dice Sum

Problem Statement

How many integer sequences $A=(A_1,\dots,A_N)$ satisfy the following conditions:

$1\le A_i\le M$
$\sum\limits_{i=1}^NA_i\le K$

Output the answer modulo $998244353$.

$1\le N,M\le 50$
$N\le K\le NM$

Input Format

$N~M~K$

Output Format

Print the answer modulo $998244353$.

Analysis

~~Damn, another DP problem for C~~

We use dynamic programming. Let $\text{dp}(i,j)$ denote the number of valid sequences for the first $i$ elements with sum $j$ ($1\le A_x\le M$). The pseudocode is as follows:

1
2
3
4
5
6


dp[0][0] = 1
for i = 0 to N-1 // consider each position one by one
 for j = 0 to K-1 // consider all possible sums (up to K-1)
 for k = 1 to M // each choice from 1-M
 if j + k <= K: // constraint
 dp[i + 1][j + k] += dp[i][j] // update dp[i+1]

Time complexity is $\mathcal O(NMK)$, which is acceptable.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define MOD 998244353
#define maxn 200005
using namespace std;

inline void mod(int& x) { if(x >= MOD) x -= MOD; }
int dp[2][maxn];

int main()
{
 int n, m, k;
 scanf("%d%d%d", &n, &m, &k);
 dp[0][0] = 1;
 for(int i=0; i<n; i++)
 {
 int c = i & 1, p = c ^ 1;
 for(int j=0; j<=k; j++)
 dp[p][j] = 0;
 for(int j=0; j<k; j++)
 for(int d=1; d<=m && d<=k-j; d++)
 mod(dp[p][j + d] += dp[c][j]);
 }
 int ans = 0;
 for(int i=1; i<=k; i++)
 mod(ans += dp[n & 1][i]);
 printf("%d\n", ans);
 return 0;
}

D - Range Count Query

Problem Statement

Given an integer sequence $A=(A_1,\dots,A_N)$.
Process $Q$ queries. Each query is formatted as:

Given integers $L,R,X$, count the occurrences of $X$ in $A_L,\dots,A_R$.

$1\le A_i,X\le N\le 2\times10^5$
$1\le L\le R\le N$

Input Format

$N$
$A_1~\dots~A_N$
$Q$
$L_1~R_1~X_1$
$\vdots$
$L_Q~R_Q~X_Q$

Output Format

Print $Q$ lines, each containing the answer to a query.

Analysis

The problem reduces to: For each $X$, count how many of its positions lie within $[L,R]$.
Thus, we preprocess the positions where each number appears using a vector, then answer queries via binary search.

Code

Note the binary search boundaries.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 200005
using namespace std;

vector<int> pos[maxn];

int main()
{
 int n, q;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a; scanf("%d", &a);
 pos[a].push_back(i);
 }
 scanf("%d", &q);
 while(q--)
 {
 int l, r, x;
 scanf("%d%d%d", &l, &r, &x);
 printf("%d\n", int(
 lower_bound(pos[x].begin(), pos[x].end(), r) -
 lower_bound(pos[x].begin(), pos[x].end(), --l)
 ));
 }
 return 0;
}

AtCoder Solution Collection

Fri, 15 Apr 2022 22:27:00 +0800

Note: This article was originally published on CSDN and has ceased updates. Original text follows:

AtCoder Solution Collection

A curated collection of high-quality AtCoder solutions from various sources, currently covering C~F problems of ABC (AtCoder Beginner Contest). Periodically updated.

If you need more solutions, feel free to DM me or leave a comment!
$\rarr$ Solution List Portal

Usage

Table Lookup
1. Locate the corresponding contest row
2. Find the target problem column
3. The cell contains the solution link
Problem Number Search
1. Press Ctrl+F in your browser to open the search box.
2. Enter the problem ID, e.g., 244F
3. Locate the solution
Title Search
1. Press Ctrl+F in your browser to open the search box.
2. Enter the problem title, e.g., Shortest Good Path
3. Locate the solution

Solution Selection Criteria:

Prioritize Chinese solutions
Use official AtCoder editorials if no good Chinese solutions exist
Select high-quality submission records if no solutions are available shortly after contests

Problem List

Sorted by contest date ascending, starting from ABC195.

Contest	C	D	E	F
ABC195	195C - Comma	195D - Shipping Center	195E - Lucky 7 Battle	195F - Coprime Present
ABC196	196C - Doubled	196D - Hanjo	196E - Filters	196F - Substring 2
ABC197	197C - ORXOR	197D - Opposite	197E - Traveler	197F - Construct a Palindrome
ABC198	198C - Compass Walking	198D - Send More Money	198E - Unique Color	198F - Cube
ABC199	199C - IPFL	199D - RGB Coloring 2	199E - Permutation	199F - Graph Smoothing
ABC200	200C - Ringo’s Favorite Numbers 2	200D - Happy Birthday! 2	200E - Patisserie ABC 2	200F - Minflip Summation
ABC201	201C - Secret Number	201D - Game in Momotetsu World	201E - Xor Distances	201F - Insertion Sort
ABC202	202C - Made Up	202D - aab aba baa	202E - Count Descendants	202F - Integer Convex Hull
ABC203	203C - Friends and Travel costs	203D - Pond	203E - White Pawn	203F - Weed
ABC204	204C - Tour	204D - Cooking	204E - Rush Hour 2	204F - Hanjo 2
ABC205	205C - POW	205D - Kth Excluded	205E - White and Black Balls	205F - Grid and Tokens
ABC206	206C - Swappable	206D - KAIBUNsyo	206E - Divide Both	206F - Interval Game 2
ABC207	207C - Many Segments	207D - Congruence Points	207E - Mod i	207F - Tree Patrolling
ABC208	208C - Fair Candy Distribution	208D - Shortest Path Queries 2	208E - Digit Products	208F - Cumulative Sum
ABC209	209C - Not Equal	209D - Collision	209E - Shiritori	209F - Deforestation
ABC210	210C - Colorful Candies	210D - National Railway	210E - Ring MST	210F - Coprime Solitaire
ABC211	211C - chokudai	211D - Number of Shortest paths	211E - Red Polyomino	211F - Rectilinear Polygons
ABC212	212C - Min Difference	212D - Querying Multiset	212E - Safety Journey	212F - Greedy Takahashi
ABC213	213C - Reorder Cards	213D - Takahashi Tour	213E - Stronger Takahashi	213F - Common Prefixes
ABC214	214C - Distribution	214D - Sum of Maximum Weights	214E - Packing Under Range Regulations	214F - Substrings
ABC215	215C - One More aab aba baa	215D - Coprime 2	215E - Chain Contestant	215F - Dist Max 2
ABC216	216C - Many Balls	216D - Pair of Balls	216E - Amusement Park	216F - Max Sum Counting
ABC217	217C - Inverse of Permutation	217D - Cutting Woods	217E - Sorting Queries	217F - Make Pair
ABC218	218C - Shapes	218D - Rectangles	218E - Destruction	218F - Blocked Roads
ABC219	219C - Neo-lexicographic Ordering	219D - Strange Lunchbox	219E - Moat	219F - Cleaning Robot
ABC220	220C - Long Sequence	220D - FG operation	220E - Distance on Large Perfect Binary Tree	220F - Distance Sums 2
ABC221	221C - Select Mul	221D - Online games	221E - LEQ	221F - Diameter set
ABC222	222C - Swiss-System Tournament	222D - Between Two Arrays	222E - Red and Blue Tree	222F - Expensive Expense
ABC223	223C - Doukasen	223D - Restricted Permutation	223E - Placing Rectangles	223F - Parenthesis Checking
ABC224	224C - Triangle?	224D - 8 Puzzle on Graph	224E - Integers on Grid	224F - Problem where +s Separate Digits
ABC225	225C - Calendar Validator	225D - Play Train	225E - フ/7	225F - String Cards
ABC226	226C - Martial artist	226D - Teleportation	226E - Just one	226F - Score of Permutations
ABC227	[227C - ABC conjecture

ARC138 B - 01 Generation Solution

Thu, 14 Apr 2022 22:37:00 +0800

ARC138 B - 01 Generation

Approach

Consider reverse thinking. We can prioritize removing trailing 0s (reverse operation of Operation B), then remove the leading 0 and flip the sequence if present (reverse operation of Operation A). Repeat these steps until the sequence becomes empty. If the process gets stuck, output No; otherwise, output Yes.

Proof of correctness:

Assume there exists a sequence $A$ where our method outputs No but the correct answer is Yes;
Then there must exist a step (possibly the first) where only reverse Operation A can be applied first instead of Operation B. Let the sequence before this step be $S$;
Let $N=|S|$, then $S_1=S_N=0$;
If we apply reverse Operation A first, we get $(S_2,S_3,\dots,S_{N-1},1)$;
If we apply reverse Operation B first, we get $(S_1,S_2,\dots,S_{N-1})$;
Comparing both results, performing reverse Operation B first does not block subsequent reverse Operation A, hence such sequence $S$ cannot exist;
Conclusion: The approach is correct.

Code

In implementation, no actual sequence flipping is needed. Track the flip state using a boolean flipped. The actual value at position $i$ is $A_i = A_i' \oplus \text{flipped}$ (where $A_i'$ is the input sequence, $\oplus$ denotes XOR).

Use deque or track endpoints with l and r.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <cstdio>
#define maxn 200005
using namespace std;

bool a[maxn];

int main()
{
 int n = 0;
 char c;
 while((c = getchar()) != '\n')
 n = (n << 3) + (n << 1) + (c ^ 48);
 for(int i=0; i<n; i++, getchar())
 a[i] = getchar() ^ 48;
 bool flipped = false;
 for(int l=0, r=n-1; a[l]==flipped; flipped^=1, l++)
 while(!a[r] ^ flipped)
 if(l > --r)
 return puts("Yes"), 0;
 puts("No");
 return 0;
}

AtCoder Beginner Contest 245 A~E Solutions

Mon, 28 Mar 2022 21:00:00 +0800

A - Good morning

Problem Summary

On the same day, Takahashi wakes up at $A$ hours $B$ minutes, and Aoki wakes up at $C$ hours $D$ minutes 1 second. Who wakes up earlier?

$0\le A,C < 24$
$0\le B,D < 60$

Input Format

$A~B~C~D$

Output Format

Output the name of the earlier riser (Takahashi or Aoki).

Samples

$A$	$B$	$C$	$D$	Output
$7$	$0$	$6$	$30$	`Aoki`
$7$	$30$	$7$	$30$	`Takahashi`
$0$	$0$	$23$	$59$	`Takahashi`

Analysis

The approach is straightforward: directly check whether $(A,B)\le(C,D)$ holds.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c, d;
 scanf("%d%d%d%d", &a, &b, &c, &d);
 puts((a == c? b <= d: a < c)? "Takahashi": "Aoki");
 return 0;
}

B - Mex

Problem Summary

Given an integer sequence $A=(A_1,\dots,A_N)$, find the smallest natural number not present in $A$.

$1\le N\le 2000$
$0\le A_i\le 2000$

Input Format

$N$
$A_1~\dots~A_N$

Output Format

Output the smallest natural number not in $A$.

Samples

Samples omitted; please visit AtCoder.

Analysis

Since $0\le A_i\le 2000$, we can use an array to track occurrences of numbers in $[0,2001]$.
There are multiple approaches for this problem; here we present the fastest algorithm with $\mathcal O(N)$ time complexity.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
using namespace std;

bool used[2005];

int main()
{
 int n;
 scanf("%d", &n);
 while(n--)
 {
 int a;
 scanf("%d", &a);
 used[a] = true;
 }
 int i = -1;
 while(used[++i]);
 printf("%d\n", i);
 return 0;
}

C - Choose Elements

Problem Summary

Given two integer sequences $A=(A_1,\dots,A_N)$ and $B=(B_1,\dots,B_N)$, determine if there exists a sequence $X=(X_1,\dots,X_N)$ satisfying:

$X_i=A_i$ or $X_i=B_i$
$|X_i-X_{i+1}|\le K$ for all $1\le i < N$

$1\le N\le 2\times 10^5$
$1\le K\le 10^9$
$1\le A_i,B_i\le 10^9$

Input Format

$N~K$
$A_1~\dots~A_N$
$B_1~\dots~B_N$

Output Format

Output Yes if such $X$ exists; otherwise, output No.

Samples

Samples omitted; please visit AtCoder.

Analysis

This problem can be solved using dynamic programming.
Let $f(i)$ denote whether $X_i$ can be $A_i$, and $g(i)$ denote whether $X_i$ can be $B_i$.
State transitions are straightforward; see code for details.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <cstdio>
#define maxn 200005
using namespace std;

int a[maxn], b[maxn];
bool f[maxn], g[maxn];

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 for(int i=0; i<n; i++)
 scanf("%d", b + i);
 f[0] = g[0] = true;
#define set(x, y, z) x |= y - z <= k && z - y <= k
 for(int i=1; i<n; i++)
 {
 if(f[i - 1])
 set(f[i], a[i - 1], a[i]),
 set(g[i], a[i - 1], b[i]);
 if(g[i - 1])
 set(f[i], b[i - 1], a[i]),
 set(g[i], b[i - 1], b[i]);
 }
 puts(f[n - 1] || g[n - 1]? "Yes": "No");
 return 0;
}

Note: There’s a peculiar alternative solution that checks if at least one of the four adjacent connections exists, such as in #30453703. If anyone can prove its correctness, please comment below!

D - Polynomial division

Problem Summary

Given three polynomials:

$$ A(x)=\sum_{i=0}^N A_iX^i\\ B(x)=\sum_{i=0}^M B_iX^i\\ C(x)=\sum_{i=0}^{N+M} C_iX^i $$

where $A$ and $C$ coefficients are known and $A(x)\times B(x)=C(x)$, find coefficients $B_0,\dots,B_M$.

$1\le N,M < 100$
$|A_i|\le 100$
$|C_i|\le 10^6$
$A_N\ne0$, $C_{N+M}\ne0$
A valid $B$ is guaranteed.

Input Format

$N~M$
$A_0~\dots~A_N$
$C_0~\dots~C_{N+M}$

Output Format

Output $B_0,\dots~B_M$ separated by spaces.

Samples

Samples omitted; please visit AtCoder.

Analysis

Simulate the polynomial long division process by tracking coefficients.
Reference: Polynomial long division

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <cstdio>
#define maxn 105
using namespace std;

int a[maxn], b[maxn], c[maxn << 1];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 for(int i=0; i<=n; i++) scanf("%d", a + i);
 for(int i=0; i<=n+m; i++) scanf("%d", c + i);
 for(int i=m; i>=0; i--) // NOTE: must process in reverse order!
 {
 b[i] = c[n + i] / a[n];
 for(int j=0; j<=n; j++)
 c[i + j] -= a[j] * b[i];
 }
 for(int i=0; i<=m; i++)
 printf("%d ", b[i]);
 return 0;
}

E - Wrapping Chocolate

Problem Summary

We have $N$ chocolates and $M$ boxes. The $i$-th chocolate has dimensions $A_i\times B_i$, and the $j$-th box has dimensions $C_j\times D_j$. Determine if all chocolates can be packed into boxes such that:

Each box contains exactly one chocolate.
For chocolate $i$ in box $j$, $A_i\le C_j$ and $B_i\le D_j$ must hold.

$1\le N\le M\le 2\times10^5$
$1\le A_i,B_i,C_i,D_i\le 10^9$

Input Format

$N~M$
$A_1~\dots~A_N$
$B_1~\dots~B_N$
$C_1~\dots~C_M$
$D_1~\dots~D_M$

Output Format

Output Yes if possible; otherwise, No.

Analysis

Greedy algorithm steps:

Sort all items (chocolates and boxes) in descending order of length. When lengths are equal, boxes come first.
Use a multiset to track available box heights. For each chocolate, remove the smallest box height ≥ its height.
Time complexity: $\mathcal O((N+M)\log(N+M))$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <cstdio>
#include <set>
#include <algorithm>
using namespace std;

struct Item {
 int w, h;
 bool type;
 inline bool operator <(const Item& i2) const {
 return w == i2.w? type > i2.type: w > i2.w;
 // Note: The sort must have strict ordering. Initially, writing type==1 here caused RE, see:
 // https://atcoder.jp/contests/abc245/submissions/30526563
 }
} v[400005];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 // Chocolate
 for(int i=0; i<n; i++) scanf("%d", &v[i].w);
 for(int i=0; i<n; i++) scanf("%d", &v[i].h);
 // Box
 m += n;
 for(int i=n; i<m; i++) scanf("%d", &v[i].w);
 for(int i=n; i<m; i++) scanf("%d", &v[i].h);
 for(int i=n; i<m; i++) v[i].type = 1;
 // Algorithm
 sort(v, v + m);
 multiset<int> s;
 for(int i=0; i<m; i++)
 {
 const Item& it = v[i];
 if(it.type) s.insert(it.h); // Box
 else
 {
 auto itr = s.lower_bound(it.h);
 if(itr == s.end())
 {
 puts("No");
 return 0;
 }
 s.erase(itr);
 }
 }
 puts("Yes");
 return 0;
}

AtCoder Beginner Contest 244 D~F Solutions

Sun, 20 Mar 2022 21:49:00 +0800

D - Swap Hats

Problem Statement

There are 3 Takahashis wearing hats colored $S_1$, $S_2$, and $S_3$ respectively.
We want to perform exactly $10^{18}$ swap operations to make $S_i = T_i$.
Each operation is defined as:

Select a pair $(i,j)$ and swap $S_i$ and $S_j$.

Determine if the goal can be achieved.

Input Format

$S_1~S_2~S_3$
$T_1~T_2~T_3$

Output Format

Print Yes if possible; otherwise, print No.

Sample

Sample Input

1
2


R G B
R G B

Sample Output

1

Yes

Analysis

We manually enumerate all cases. The solution outputs Yes when all $S_i=T_i$ or all $S_i\ne T_i$ (requiring even parity after $10^{18}$ swaps), otherwise No.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 char a, b, c, d, e, f;
 scanf("%c %c %c %c %c %c", &a, &b, &c, &d, &e, &f);
 puts(((a == d) + (b == e) + (c == f)) == 1? "No": "Yes");
 return 0;
}

E - King Bombee

Problem Statement

Given a simple undirected graph with $N$ vertices and $M$ edges. The $i$-th edge connects vertices $U_i$ and $V_i$.
Count the number of paths from $S$ to $T$ with length $K$ that pass through vertex $X$ an even number of times, modulo $998244353$.

Constraints:
$2\le N\le 2000$
$1\le M\le 2000$
$1\le K\le 2000$
$1\le S,T,X\le N$
$X\ne S,X\ne T$
$1\le U_i < V_i\le N$
All edges are distinct.

Input Format

$N~M~K~S~T~X$
$U_1~V_1$
$\vdots$
$U_M~V_M$

Output Format

Print the count modulo $998244353$.

Sample

Sample Input 1

1
2
3
4
5


4 4 4 1 3 2
1 2
2 3
3 4
1 4

Sample Output 1

1

4

Valid paths:

$1\to2\to1\to2\to3$
$1\to2\to3\to2\to3$
$1\to4\to1\to4\to3$
$1\to4\to3\to4\to3$

Each path visits $X=2$ even times.

Sample Input 2

1
2
3
4
5
6


6 5 10 1 2 3
2 3
2 4
4 6
3 6
1 5

Sample Output 2

1

0

Disconnected graph.

Sample Input 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


10 15 20 4 4 6
2 6
2 7
5 7
4 5
2 4
3 7
1 7
1 4
2 9
5 10
1 3
7 8
7 9
1 6
1 2

Sample Output 3

1

952504739

Result modulo $998244353$.

Analysis

Define $\mathrm{dp}(i,j,k)$ as the number of paths reaching vertex $j$ in $i$ steps with $k$ being the parity (even/odd) of visits to $X$. Transitions occur via adjacency list:

When moving to vertex $v$, if $v=X$, toggle the parity bit.
Use rolling array optimization for space efficiency.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include <cstdio>
#include <vector>
#define maxn 2005
#define MOD 998244353
using namespace std;

inline void mod(int& x)
{
 if(x >= MOD) x -= MOD;
}

vector<int> G[maxn];
int dp[2][maxn][2];

int main()
{
 int n, m, k, s, t, x;
 scanf("%d%d%d%d%d%d", &n, &m, &k, &s, &t, &x);
 x --;
 while(m--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 dp[0][--s][0] = 1;
 for(int i=1; i<=k; i++)
 {
 bool c = i & 1, p = i & 1 ^ 1;
 for(int v=0; v<n; v++)
 {
 dp[c][v][0] = dp[c][v][1] = 0;
 for(int u: G[v])
 mod(dp[c][v][0] += dp[p][u][u == x]),
 mod(dp[c][v][1] += dp[p][u][u != x]);
 }
 }
 printf("%d\n", dp[k & 1][--t][0]);
 return 0;
}

F - Shortest Good Path

Analysis

Let $\mathrm{dis}[S][j]$ be the shortest length of a good path with respect to bitmask $S$ ending at vertex $j$. Perform BFS where each state $(S, v)$ represents the current bitmask and position. Use bitmask compression for efficiency.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <queue>
#define INF 2147483647
#define maxn 17
using namespace std;

using ULL = unsigned long long;

int dis[1 << maxn][maxn];
vector<int> G[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int u, v;
 scanf("%d%d", &u, &v);
 G[--u].push_back(--v);
 G[v].push_back(u);
 }
 queue<ULL> q;
 for(int i=0; i<n; i++)
 dis[1 << i][i] = 1, q.push(1ULL<<i+32^i);
 while(!q.empty())
 {
 ULL pkg = q.front(); q.pop();
 int st = pkg >> 32ULL, v = pkg & 0x7fffffff;
 int nd = dis[st][v] + 1;
 for(int u: G[v])
 {
 int nst = st ^ (1 << u);
 if(dis[nst][u] == 0)
 {
 dis[nst][u] = nd;
 q.push(ULL(nst) << 32ULL ^ u);
 }
 }
 }
 long long ans = 0LL;
 for(int i=1, lim=1<<n; i<lim; i++)
 {
 int cur = INF;
 for(int j=0; j<n; j++)
 if(dis[i][j] > 0 && dis[i][j] < cur)
 cur = dis[i][j];
 ans += cur;
 }
 printf("%lld\n", ans);
 return 0;
}

【Python】72-Line Code Lines Counter, Simple and Practical!

Tue, 15 Mar 2022 15:24:00 +0800

Preface

Recently I suddenly wanted to know how many lines of code I’ve written, so I created this little tool…

Preparation

First consider the desired output:

Language	Lines	Size	Files
A	12345	300 KB	193
B	2345	165 KB	98

The program outputs a table sorted by code lines.
Basic code framework:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# -*- encoding: utf-8 -*-
import ...

# Code lines counter class
class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages # Languages (dict, {file_extension: language})
 self._codelines = {suffix: (0, 0, 0) for suffix in languages} # Results, {suffix: (lines, size, files)}
 self._successful = self._error = 0 # Success/Error file counts
 
 # @param directory: Directory to scan
 # @param log: Whether to print logs
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 pass
 
 def report(self): # Output results
 pass

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/') # Scan E drive (Note: cannot use 'E:')
counter.report()

Now let’s move to the ==core implementation==

Implementation

File Scanning

First, we need to get file lists under root directory using os.walk:
os.walk(rootdir) returns a walker (iterable) containing file/directory lists for each subdirectory. Example:
For folder structure:

1
2
3
4
5
6
7
8


Folder
| file1
| Folder1
| file2
| file3
| Folder2
 | file4
 | Folder3

Running:

1
2
3
4


import os

for root, dirs, files in os.walk('Folder'):
 print(root, dirs, files)

Output:

1
2
3
4


Folder					['Folder1', 'Folder2']	['file1']
Folder\Folder1			[]						['file2', 'file3']
Folder\Folder2			['Folder3']				['file4']
Folder\Folder2\Folder3	[]						[]

First element is current root, second is subdirectories, third is files.
Implementation code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk

class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages
 self._results = {suffix: (0, 0, 0) for suffix in languages}
 self._successful = self._error = 0
 
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 try:
 for root, _, files in walk(abspath(directory)):
 for filename in files:
 suffix = filename[filename.rfind('.') + 1:]
 filename = join(root, filename)
 if suffix in self._results:
 lines, size, numFiles = self._results[suffix]
 lines += 1 # Temporary line count, set to 1 first
 numFiles += 1
 size += getsize(filename) # getsize returns bytes
 self._results[suffix] = (lines, size, numFiles)
 if log: print(filename)
 except KeyboardInterrupt:
 print('\nUser stopped operation')
 else:
 if log: print('Scan finished')
 
 def report(self):
 print('Language\tLines\tSize\tFiles')
 for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
 print(self._languages[suffix], lines, self.__format_size(size), files, sep='\t')

 # Unit conversion
 def __format_size(self, bytes):
 for suffix, size in self.SIZES:
 if bytes < size * 1024:
 return '%.2f %s' % (bytes / size, suffix)
 return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

Sample output (manually formatted):

1
2
3
4
5
6
7
8
9


Language Lines Size Files
C++ 667 671.51 KB 667
Python 317 981.01 KB 317
HTML 38 466.52 KB 38
Plain text 34 90.69 KB 34
JavaScript 19 1.43 MB 19
CSS 9 341.04 KB 9
C 2 20.45 KB 2
Java 1 676.00 B 1

Next step: actual line counting.

Line Counting

Empty lines shouldn’t be counted. Modify line 23:

1
2
3
4


with open(filename, 'r', encoding='utf-8') as f: # Open with utf-8
 for line in f:
 if line and not line.isspace(): # Skip empty lines
 lines += 1

But when running:

1
2
3


Traceback (most recent call last):
 ...
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb5 in position 355: invalid start byte

Some files use GBK encoding. Improved code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


try:
 ln = 0
 with open(filename, 'r', encoding='utf-8') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
except UnicodeDecodeError: # Try GBK
 try:
 ln = 0
 with open(filename, 'r', encoding='gbk') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except:
 print(filename, '[Error: unknown encoding]')
 self._error += 1
 else:
 lines += ln
except Exception as e:
 print(filename, '[Unknown error: %s]' % e)
 self._error += 1
 continue
lines += ln
if log: print(f'{filename} [{ln}]')
self._successful += 1

Now correct results:

1
2
3
4
5
6
7
8
9


Language Lines Size Files
C++ 35595 671.51 KB 667
JavaScript 24485 1.43 MB 19
Python 24130 982.16 KB 317
CSS 8203 341.04 KB 9
HTML 6138 466.52 KB 38
Plain text 741 90.69 KB 34
C 557 20.45 KB 2
Java 29 676.00 B 1

Final step: table formatting.

Table Formatting

Use PrettyTable library:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk
from prettytable import PrettyTable

class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages
 self._results = {suffix: (0, 0, 0) for suffix in languages}
 self._successful = self._error = 0
 
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 try:
 for root, _, files in walk(abspath(directory)):
 for filename in files:
 suffix = filename[filename.rfind('.') + 1:]
 filename = join(root, filename)
 if suffix in self._results:
 lines, size, numFiles = self._results[suffix]
 numFiles += 1
 size += getsize(filename)
 try:
 ln = 0
 with open(filename, 'r', encoding='utf-8') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except UnicodeDecodeError:
 try:
 ln = 0
 with open(filename, 'r', encoding='gbk') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except:
 print(filename, '[Error: unknown encoding]')
 self._error += 1
 else:
 lines += ln
 except Exception as e:
 print(filename, '[Unknown error: %s]' % e)
 self._error += 1
 continue
 lines += ln
 if log: print(f'{filename} [{ln}]')
 self._successful += 1
 self._results[suffix] = (lines, size, numFiles)
 elif log:
 print(filename, '[None]')
 except KeyboardInterrupt:
 print('\nUser stopped operation')
 else:
 if log: print('Scan finished')
 
 def report(self):
 table = PrettyTable(['Language', 'Lines', 'Size', 'Files'], title=f'Scan result (OK {self._successful}, Error {self._error})')
 for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
 table.add_row([self._languages[suffix], lines, self.__format_size(size), files])
 print(table)
 
 def __format_size(self, bytes):
 for suffix, size in self.SIZES:
 if bytes < size * 1024:
 return '%.2f %s' % (bytes / size, suffix)
 return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

Output:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


+----------------------------------------+
| Scan result (OK 1087, Error 0) |
+------------+-------+-----------+-------+
| Language | Lines | Size | Files |
+------------+-------+-----------+-------+
| C++ | 35595 | 671.51 KB | 667 |
| JavaScript | 24485 | 1.43 MB | 19 |
| Python | 24130 | 982.16 KB | 317 |
| CSS | 8203 | 341.04 KB | 9 |
| HTML | 6138 | 466.52 KB | 38 |
| Plain text | 741 | 90.69 KB | 34 |
| C | 557 | 20.45 KB | 2 |
| Java | 29 | 676.00 B | 1 |
+------------+-------+-----------+-------+

Conclusion

Final code (without comments):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


# -*- encoding: utf-8 -*-
from os.path import join, getsize, abspath
from os import walk
from prettytable import PrettyTable

class CodeLinesCounter(object):
 SIZES = [('B', 1), ('KB', 1024), ('MB', 1024**2), ('GB', 1024**3), ('TB', 1024**4)]
 
 def __init__(self, languages):
 self._languages = languages
 self._results = {suffix: (0, 0, 0) for suffix in languages}
 self._successful = self._error = 0
 
 def scan(self, directory, log=False):
 if log: print('Scanning', directory)
 try:
 for root, _, files in walk(abspath(directory)):
 for filename in files:
 suffix = filename[filename.rfind('.') + 1:]
 filename = join(root, filename)
 if suffix in self._results:
 lines, size, numFiles = self._results[suffix]
 numFiles += 1
 size += getsize(filename)
 try:
 ln = 0
 with open(filename, 'r', encoding='utf-8') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except UnicodeDecodeError:
 try:
 ln = 0
 with open(filename, 'r', encoding='gbk') as f:
 for line in f:
 if line and not line.isspace():
 ln += 1
 except:
 print(filename, '[Error: unknown encoding]')
 self._error += 1
 else:
 lines += ln
 except Exception as e:
 print(filename, '[Unknown error: %s]' % e)
 self._error += 1
 continue
 lines += ln
 if log: print(f'{filename} [{ln}]')
 self._successful += 1
 self._results[suffix] = (lines, size, numFiles)
 elif log:
 print(filename, '[None]')
 except KeyboardInterrupt:
 print('\nUser stopped operation')
 else:
 if log: print('Scan finished')
 
 def report(self):
 table = PrettyTable(['Language', 'Lines', 'Size', 'Files'], title=f'Scan result (OK {self._successful}, Error {self._error})')
 for suffix, (lines, size, files) in sorted(self._results.items(), key=lambda x: x[1], reverse=True):
 table.add_row([self._languages[suffix], lines, self.__format_size(size), files])
 print(table)
 
 def __format_size(self, bytes):
 for suffix, size in self.SIZES:
 if bytes < size * 1024:
 return '%.2f %s' % (bytes / size, suffix)
 return '%.2f %s' % (bytes / self.SIZES[-1][1], 2, self.SIZES[-1][0])

counter = CodeLinesCounter(languages={'py': 'Python', 'c': 'C', 'cpp': 'C++', 'java': 'Java', 'js': 'JavaScript', 'html': 'HTML', 'css': 'CSS', 'txt': 'Plain text'})
counter.scan('E:/')
counter.report()

Future improvements:

Add regex file ignore
matplotlib visualization
PyQt5 GUI
… (Welcome valuable suggestions!)

AtCoder Beginner Contest 242 C~E Solutions

Tue, 08 Mar 2022 22:30:00 +0800

C - 1111gal password

Problem Statement

Given a positive integer $N$, find the number of integers $X$ satisfying the following conditions, modulo $998244353$:

$X$ is an $N$-digit positive integer
Every digit of $X$ is between $[1,9]$ (==0 is forbidden==)
The absolute difference between adjacent digits in $X$ is at most 1.

$2\le N\le 10^6$

Input Format

$N$

Output Format

Print the answer.

Sample

$N$	Output
$4$	$203$
$2$	$25$
$1000000$	$248860093$

Analysis

By the multiplication principle, the maximum possible count of valid $N$-digit numbers is $9^N$, which is clearly infeasible for brute force. However, since each digit is constrained by its predecessor, a dynamic programming (DP) approach is natural.

Let $f(i,j)$ denote the number of valid numbers where the $i$-th digit is $j$. The transitions are:

$$ f(i,j)=\begin{cases} 1&(i=1)\\ f(i-1,1)+f(i-1,2)&(j=1)\\ f(i-1,8)+f(i-1,9)&(j=9)\\ f(i-1,j-1)+f(i-1,j)+f(i-1,j+1)&(i>1,2\le j\le8) \end{cases} $$

The final answer is $\sum\limits_{i=1}^9f(n,i)$.

Code

This code employs rolling table optimization to reduce memory usage. Directly allocating an $N\times9$ array is possible but memory-intensive.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
#define MOD 998244353
using namespace std;

inline void mod(int& x)
{
 if(x >= MOD) x -= MOD;
}

int dp[9], ldp[9];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<9; i++)
 dp[i] = 1;
 while(--n)
 {
 for(int i=0; i<9; i++)
 ldp[i] = dp[i];
 mod(dp[0] += dp[1]), mod(dp[8] += dp[7]);
 for(int i=1; i<8; i++)
 mod(dp[i] += ldp[i - 1]),
 mod(dp[i] += ldp[i + 1]);
 }
 int ans = 0;
 for(int i=0; i<9; i++)
 mod(ans += dp[i]);
 printf("%d\n", ans);
 return 0;
}

D - ABC Transform

Problem Statement

Given a string $S$ composed of A, B, C. Define $S_0=S$ and $S_i$ as the string formed by replacing each character in $S_{i-1}$:

A → BC
B → CA
C → AB

Answer $Q$ queries where the $i$-th query asks for the $k_i$-th character in $S_{t_i}$.

$1\le |S|\le 10^5$
$1\le Q\le 10^5$
$1\le t_i\le 10^{18}$
$1\le k_i\le min(10^{18},$ length of $S_{t_i})$

Input Format

$S$
$Q$
$t_1~k_1$
$\vdots$
$t_Q~k_Q$

Sample

Sample Input 1

Sample Output 1

1
2
3
4


A
B
C
B

$S_0=~$ABC
$S_1=~$AABCB

Sample Input 2

1
2
3
4
5
6
7


CBBAACCCCC
5
57530144230160008 659279164847814847
29622990657296329 861239705300265164
509705228051901259 994708708957785197
176678501072691541 655134104344481648
827291290937314275 4071211144297426665

Sample Output 2

1
2
3
4
5


A
A
C
A
A

Beware of integer overflow issues.

Analysis

Define $f(t,k)$ as the character at position $k$ (0-based) in $S_t$ when $S_0$ is all As (modeled as 0, 1, 2 for A,B,C). Through pattern observation:

$$ f(t,k)=\begin{cases} 0 & (t=0)\\ g(0,t) & (k=0)\\ g(f(t-1,\lfloor\frac k2\rfloor),(k\bmod2)+1) & (t>0,k>0) \end{cases} $$

where $g(c,x)$ returns the $(c+x)$-th character modulo 3 in the cyclic sequence A→B→C→A....

The solution involves determining which original character in $S$ generates the queried position. The final answer is $\mathrm{ans}=g(f(t,(k-1)\bmod2^t),S_{\lfloor\frac {k-1}{2^t}\rfloor})$.

Code

Both implementations below use iterative approaches. Recursive versions are also feasible.

Code 1 (Standard)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

char s[100005];

int main()
{
 scanf("%s", s);
 int q;
 scanf("%d", &q);
 while(q--)
 {
 long long t, k;
 scanf("%lld%lld", &t, &k);
 k --;
 int x = s[t < 64? k >> t: 0] - 'A'; // Prevent t from being too large causing RE
 while(t > 0 && k > 0)
 {
 x = (x + int(k & 1LL) + 1) % 3;
 k >>= 1LL, t --;
 }
 putchar((t + x) % 3 + 'A');
 putchar('\n');
 }
 return 0;
}

Code 2 (Optimized)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
using namespace std;

char s[100005];

int main()
{
 scanf("%s", s);
 int q;
 scanf("%d", &q);
 while(q--)
 {
 long long t, k;
 scanf("%lld%lld", &t, &k);
 k --;
 int c = 0;
 if(t < 64)
 {
 c = s[k >> t] - 'A';
 k &= (1LL << t) - 1LL;
 }
 else c = s[0] - 'A';
 for(c+=t%3; k>0; k&=k-1) c ++;
 putchar(c % 3 + 'A');
 putchar('\n');
 }
 return 0;
}

E - (∀x∀)

Problem Statement

For $T$ test cases, solve the following:
Given integer $N$ and string $S$, count the number of valid palindromic strings $X$ satisfying:

$|X|=N$
$X$ consists of uppercase letters
$X\le S$ lexicographically

$1\le T\le 250000$
$1\le N\le 10^6$
$1\le \sum N\le 10^6$
$|S|=N$ with uppercase letters.

Analysis

The palindrome $X$ is uniquely determined by its first $\lceil\frac N2\rceil$ characters. Consider ABCDE:

The first 3 characters are ABC
There are $28$ valid prefixes lex-order smaller than ABC (treated as a base-26 number)
Check if ABCBA ≤ ABCDE
If valid, total becomes $28+1=29$

Thus, output $29$. Other cases follow similarly.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
#define maxn 1000005
#define MOD 998244353
using namespace std;

using LL = long long;
char s[maxn];

int main()
{
 int T;
 scanf("%d", &T);
 while(T--)
 {
 int n;
 scanf("%d%s", &n, &s);
 long long x = 0LL;
 int j = n - 1 >> 1;
 for(int i=0; i<=j; i++)
 (x = x * 26LL + s[i] - 'A') %= MOD;
 bool ok = true;
 while(j >= 0)
 {
 if(s[j] < s[n - 1 - j]) break;
 if(s[j] > s[n - 1 - j]) { ok = false; break;}
 j --;
 }
 if(ok && ++x == MOD) x -= MOD;
 printf("%lld\n", x);
 }
 return 0;
}

AtCoder Beginner Contest 241 (Sponsored by Panasonic) D~F Solution

Sat, 05 Mar 2022 23:01:00 +0800

D - Sequence Query

Problem Summary

We have an empty sequence $A$. Process $Q$ commands in order, each of three types:

1 x: Add $x$ to $A$ (without deduplication)
2 x k: Find the $k$-th largest value among elements $\le x$ in $A$.
3 x k: Find the $k$-th smallest value among elements $\ge x$ in $A$.

$1\le Q\le 2\times 10^5$
$1\le x\le 10^{18}$
==$1\le k\le 5$==

Analysis

Given $1\le k\le 5$, we can use multiset.
multiset supports binary search. For details, see here.
For each query:

1 x: Directly insert into multiset
2 x k: Use upper_bound, then move iterator backward $k$ steps
3 x k: Use lower_bound, then move iterator forward $k$ steps

Due to small $k$, moving iterators is negligible.
Time complexity: Optimal $\mathcal O(Q)$, average $\mathcal O(Q\log Q)$, worst $\mathcal O(Q\log Q)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <cstdio>
#include <set>
using namespace std;

int main()
{
 multiset<long long> s;
 int q;
 scanf("%d", &q);
 while(q--)
 {
 int op;
 long long x;
 scanf("%d%lld", &op, &x);
 if(op == 1) s.insert(x);
 else
 {
 int k;
 scanf("%d", &k);
 if(op == 2)
 {
 bool bad = false;
 auto it = s.upper_bound(x);
 for(; k--; --it)
 if(it == s.begin())
 {
 bad = true;
 break;
 }
 if(bad) puts("-1");
 else printf("%lld\n", *it);
 }
 else
 {
 auto it = s.lower_bound(x);
 for(; --k; ++it)
 if(it == s.end())
 break;
 if(it == s.end()) puts("-1");
 else printf("%lld\n", *it);
 }
 }
 }
 return 0;
}

E - Putting Candies

Problem Summary

Given sequence $A=(A_0,A_1,\dots,A_{N-1})$.
Start with an empty plate. Takahashi adds $A_{(X\bmod N)}$ candies each time (where $X$ is current candy count).
Find total candies after $K$ operations.

$2\le N\le 2\times 10^5$
$1\le K\le 10^{12}$
$1\le A_i\le 10^6$

Analysis

By pigeonhole principle, $A_{(X\bmod N)}$ must repeat within $N$ operations.
This becomes a periodic problem. We record time mappings to reconstruct cycles.
Time complexity: $\mathcal O(n)$, space complexity: $\mathcal O(n)$.

Code

Code reference: AtCoder Editorial

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
#define maxn 200005
using namespace std;

using LL = long long;
LL A[maxn], S[maxn];
int pre[maxn];

int main()
{
 int n;
 LL k;
 scanf("%d%lld", &n, &k);
 for(int i=0; i<n; i++)
 scanf("%lld", A + i);
 for(int i=1; i<n; i++)
 pre[i] = -1;
 int time, s;
 for(int i=0; i<n; i++)
 {
 S[i + 1] = S[i] + A[S[i] % n];
 if(pre[S[i + 1] % n] != -1)
 {
 s = pre[S[i + 1] % n];
 time = i + 1;
 break;
 }
 pre[S[i + 1] % n] = i + 1;
 }
 if(k <= s) printf("%lld\n", S[k]);
 else
 {
 int p = time - s;
 LL X = S[time] - S[s], t = k - s - 1;
 printf("%lld\n", S[s + t % p + 1] + t / p * X);
 }
 return 0;
}

F - Skate

Problem Summary

Given $H\times W$ grid with $N$ obstacles at $(X_i,Y_i)$.
Start at $(s_x,s_y)$, slide in up/down/left/right until hitting an obstacle, stopping at the preceding cell. Find minimum steps to reach $(g_x,g_y)$. Output -1 if impossible.

$1\le H,W\le 10^9$
==$1\le N\le 10^5$==
$1\le s_x,g_x,X_i\le H$
$1\le s_y,g_y,Y_i\le W$
$(s_x,s_y)\ne(g_x,g_y)\ne(X_i,Y_i)$
All $(X_i,Y_i)$ are distinct.

Analysis

Despite large grid dimensions, $N$ is manageable. Use BFS with map/set to track rows/columns. For each coordinate, binary search nearby obstacles.

Code

Notes:

Row/column coordinates must be sorted (can use set)
Handle binary search boundaries carefully

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <queue>
#include <set>
#include <unordered_map>
using namespace std;

using LL = long long;
unordered_map<int, set<int>> row, col;
unordered_map<LL, int> dis;

inline LL pack(LL x, int y) { return x << 31LL | y; }
inline void unpack(const LL& b, int& x, int& y) { x = b >> 31LL, y = b & 0x7fffffff; }

int main()
{
 int h, w, n, sx, sy, gx, gy;
 scanf("%d%d%d%d%d%d%d", &h, &w, &n, &sx, &sy, &gx, &gy);
 for(int i=0; i<n; i++)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 row[x].insert(y);
 col[y].insert(x);
 }
 LL target = pack(gx, gy);
 queue<pair<LL, int>> q;
 q.emplace(pack(sx, sy), 0);
 while(!q.empty())
 {
 auto [p, d] = q.front(); q.pop();
 if(!dis.emplace(p, d).second) continue;
 if(p == target) { printf("%d\n", d); return 0; }
 int x, y;
 unpack(p, x, y), ++d;
 if(row.count(x))
 {
 auto& s = row[x];
 auto it = s.lower_bound(y);
 if(it != s.end()) q.emplace(pack(x, *it - 1), d);
 if(it != s.begin()) q.emplace(pack(x, *--it + 1), d);
 }
 if(col.count(y))
 {
 auto& s = col[y];
 auto it = s.lower_bound(x);
 if(it != s.end()) q.emplace(pack(*it - 1, y), d);
 if(it != s.begin()) q.emplace(pack(*--it + 1, y), d);
 }
 }
 puts("-1");
 return 0;
}

Denso Create Programming Contest 2022 (AtCoder Beginner Contest 239) Solutions to Problems C~E

Fri, 25 Feb 2022 23:08:00 +0800

C - Knight Fork

Problem Statement

Determine if there exists an integer coordinate point on the 2D plane whose Euclidean distances to both $(x_1,y_1)$ and $(x_2,y_2)$ are $\sqrt{5}$.

Input Format

$x_1~y_1~x_2~y_2$

Output Format

Print Yes if such a point exists; otherwise, print No.

Sample Cases

$x_1$	$y_1$	$x_2$	$y_2$	Output
$0$	$0$	$3$	$3$	`Yes`
$0$	$1$	$2$	$3$	`No`
$1000000000$	$1000000000$	$999999999$	$999999999$	`Yes`

Analysis

First, we need to understand the condition for “distance being $\sqrt{5}$”. Let $\sqrt{(a-c)^2+(b-d)^2}=\sqrt{5}$ (where $a,b,c,d$ are integers). This implies:

$$ (a-c)^2+(b-d)^2=5\\ \{a-c,b-d\}=\{1,2\} $$

Thus, for the point $(0,0)$, the points with distance $\sqrt{5}$ are shown below (similar for other points):

We generate all points with distance $\sqrt{5}$ from $(x_1,y_1)$ and check their distances to $(x_2,y_2)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
using namespace std;

using LL = long long;
const int d[8] = {-1, 1, 2, 2, 1, -1, -2, -2};

inline LL sqr2(const LL& x, const LL& y)
{
 return x * x + y * y;
}

int main()
{
 LL x1, y1, x2, y2;
 scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2);
 x1 -= x2, y1 -= y2;
 for(int i=0; i<8; i++)
 if(sqr2(x1 + d[i], y1 + d[(i + 2) & 7]) == 5)
 {
 puts("Yes");
 return 0;
 }
 puts("No");
 return 0;
}

D - Prime Sum Game

~~==Water problem warning==~~

Problem Statement

Takahashi and Aoki play a game as follows:

Takahashi selects an integer $A\le N\le B$.
Aoki selects an integer $C\le M\le D$.
If $N+M$ is prime, Aoki wins. Otherwise, Takahashi wins.

Determine the winner when both play optimally.

$1\le A\le B\le 100$
$1\le C\le D\le 100$

Input Format

$A~B~C~D$

Output Format

Print the winner’s name: Takahashi or Aoki.

Sample Cases

$A$	$B$	$C$	$D$	Output
$2$	$3$	$3$	$4$	`Aoki`
$1$	$100$	$50$	$60$	`Takahashi`
$3$	$14$	$1$	$5$	`Aoki`

Analysis

The key is understanding “optimal play”:

Takahashi wins if there exists an $N$ such that $N+M$ is never prime for any $M$.
Aoki wins if for every $N$, there exists an $M$ making $N+M$ prime.

Given small constraints, we brute-force all pairs. Time complexity is $\mathcal O(BD)$.

Code

P.S. Surprisingly, runtime is 4ms (expected ~30ms).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <cstdio>
using namespace std;

inline bool isprime(int x)
{
 for(int t=__builtin_sqrt(x), i=2; i<=t; i++)
 if(x % i == 0)
 return false;
 return true;
}

int main()
{
 int a, b, c, d;
 scanf("%d%d%d%d", &a, &b, &c, &d);
 for(int i=a; i<=b; i++)
 {
 int j = c;
 for(; j<=d; j++)
 if(isprime(i + j))
 break;
 if(j > d) { puts("Takahashi"); return 0; }
 }
 puts("Aoki");
 return 0;
}

E - Subtree K-th Max

Problem Statement

Given a tree with $N$ nodes (1-based) rooted at node 1. Each node $v$ has a value $X_v$.
Answer $Q$ queries $(V_i,K_i)$:

Find the K-th largest value (without deduplication) in the subtree rooted at $V_i$.

$2\le N,Q\le 10^5$
$0\le X_i\le 10^9$
$1\le A_i,B_i,V_i\le N$
==$1\le K_i\le 20$==

Input Format

$N~Q$
$X_1~\dots~X_N$
$A_1~B_1$
$\vdots$
$A_{N-1}~B_{N-1}$
$V_1~K_1$
$\vdots$
$V_Q~K_Q$

Output Format

Print $Q$ lines. The i-th line contains the answer to the i-th query.

Sample Cases

See AtCoder for details.

Analysis

Given $1\le K\le 20$, precompute the top-20 values for each node’s subtree. Use DFS to merge node values and children’s top-20 lists. Sorting can be optimized with priority_queue. Time complexity is $\mathcal O(N+Q)$.

Code

Sample implementation uses DFS with priority_queue (190ms runtime):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <cstdio>
#include <queue>
#define maxn 100005
using namespace std;

int x[maxn];
vector<int> G[maxn], dp[maxn];

void dfs(int v, int par)
{
 priority_queue<int, vector<int>, greater<int>> q;
 q.push(x[v]);
 for(int u: G[v])
 if(u != par)
 {
 dfs(u, v);
 for(int val: dp[u])
 {
 q.push(val);
 if(q.size() > 20) q.pop();
 }
 }
 while(!q.empty())
 {
 dp[v].push_back(q.top());
 q.pop();
 }
}

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 scanf("%d", x + i);
 for(int i=1; i<n; i++)
 {
 int a, b;
 scanf("%d%d", &a, &b);
 G[--a].push_back(--b);
 G[b].push_back(a);
 }
 dfs(0, -1);
 while(q--)
 {
 int v, k;
 scanf("%d%d", &v, &k);
 const auto& d = dp[--v];
 printf("%d\n", d[d.size() - k]);
 }
 return 0;
}

AtCoder Beginner Contest 205 A~E Solutions

Wed, 07 Jul 2021 16:40:00 +0800

A - kcal

Problem Statement

We have a beverage that contains $A$ kilocalories per 100 milliliters. How many kilocalories does $B$ milliliters of this beverage contain?

$0\le A, B\le 1000$

Input Format

$A~B$

Output Format

Output the number of kilocalories in $B$ milliliters. Maximum allowable floating-point precision error is $10^{-6}$.

Samples

$A$	$B$	Output
$45$	$200$	$90$
$37$	$450$	$166.5$
$0$	$1000$	$0$
$50$	$0$	$0$

Analysis

The answer is simply $\frac{AB}{100}$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <cstdio>
using namespace std;

int main()
{
 int a, b;
 scanf("%d%d", &a, &b);
 a *= b;
 printf("%d.%d\n", a / 100, a % 100);
 return 0;
}

B - Permutation Check

Problem Statement

Given a sequence $A=(A_1,A_2,\dots,A_N)$ of length $N$, determine whether $A$ is a permutation of $(1, 2, \dots, N)$.

$1\le A_i\le N\le 10^3$

Input Format

$N$
$A_1~A_2~\dots~A_N$

Output Format

Print Yes if $A$ is a permutation of $(1, 2, \dots, N)$, otherwise print No.

Samples

Sample Input 1

Sample Output 1

1

Yes

$(3,1,2,4,5)$ is a permutation of $(1,2,3,4,5)$, so output Yes.

Sample Input 2

1
2


6
3 1 4 1 5 2

Sample Output 2

1

No

$(3,1,4,1,5,2)$ is not a permutation of $(1,2,3,4,5,6)$, so output No.

Sample Input 3

Sample Output 3

1

Yes

Sample Input 4

Sample Output 4

1

Yes

Analysis

Since $1\le A_i\le N$, $A$ is a permutation if and only if all numbers from $1$ to $N$ appear exactly once. We can track occurrences using an array with $\mathcal O(n)$ time complexity.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <cstdio>
#define maxn 1005
using namespace std;

bool used[maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 if(used[a])
 {
 puts("No");
 return 0;
 }
 used[a] = true;
 }
 puts("Yes");
 return 0;
}

C - POW

Problem Statement

Given integers $A$, $B$, and $C$, determine whether $A^C$ is less than, greater than, or equal to $B^C$.

$-10^9\le A,B\le 10^9$
$1\le C\le 10^9$

Input Format

$A~B~C$

Output Format

Output:

< if $A^C < B^C$,
> if $A^C > B^C$,
= if $A^C = B^C$.

Samples

$A$	$B$	$C$	Output
$3$	$2$	$4$	`>`
$-7$	$7$	$2$	`=`
$-8$	$6$	$3$	`<`

Analysis

For even $C$, compare absolute values. For odd $C$, compare original values. This simplifies to comparing $|A|$ vs $|B|$ (if $C$ is even) or $A$ vs $B$ (if $C$ is odd).

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 if(!(c & 1))
 {
 if(a < 0) a = -a;
 if(b < 0) b = -b;
 }
 puts(a < b? "<": a > b? ">": "=");
 return 0;
}

D - Kth Excluded

Problem Statement

Given a sorted sequence $A=(A_1,A_2,\dots,A_N)$ of positive integers and $Q$ queries, find the $K_i$-th smallest positive integer not present in $A$.

$1\le N,Q\le 10^5$
$1\le A_1 < A_2 < \dots < A_N\le10^{18}$
$1\le K_i\le 10^{18}$

Input Format

$N~Q$
$A_1~A_2~\dots~A_N$
$K_1$
$K_2$
$\hspace{5pt}\vdots$
$K_Q$

Output Format

Output $Q$ lines, each containing the answer for the corresponding query.

Samples

Sample Input 1

Sample Output 1

The missing positive integers are $1,2,4,8,9,10,11,\dots$. The 2nd, 5th, and 3rd smallest are $2$, $9$, $4$.

Sample Input 2

Sample Output 2

Analysis

Precompute how many elements in $A$ are less than each possible $k$, then use binary search to find the position where $k$ falls. Time complexity: $\mathcal O(Q \log N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <cstdio>
#include <algorithm>
#define maxn 100005
using namespace std;

using LL = long long;
LL a[maxn];

int main()
{
 int n, q;
 scanf("%d%d", &n, &q);
 for(int i=0; i<n; i++)
 {
 scanf("%lld", a + i);
 a[i] -= i;
 }
 while(q--)
 {
 LL k;
 scanf("%lld", &k);
 printf("%lld\n", k + (upper_bound(a, a + n, k) - a));
 }
 return 0;
}

E - White and Black Balls

Problem Statement

Count the number of valid arrangements of $N$ white and $M$ black balls such that for every prefix of length $i$, the number of white balls $w_i$ and black balls $b_i$ satisfy $w_i \le b_i + K$. Modulo $10^9+7$.

$0\le N,M\le10^6$
$1\le N+M$
$0\le K\le N$

Input Format

$N~M~K$

Output Format

Output the count modulo $10^9+7$.

Samples

$N$	$M$	$K$	Output
$2$	$3$	$1$	$9$
$1$	$0$	$0$	$0$
$1000000$	$1000000$	$1000000$	$192151600$

Analysis

The valid count equals the Catalan-like number $\binom{N+M}{N} - \binom{N+M}{M+K+1}$ when $N \le M + K$, otherwise $0$. This uses combinatorial subtraction for paths crossing a boundary.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
#include <atcoder/modint>
using namespace std;

using modint = atcoder::modint1000000007;

modint f(int n, int m)
{
 if(n < 0 || m < 0)
 return 0;
 modint ret = 1;
 for(int i=1; i<=m; i++)
 ret = ret * (n + i) / i;
 return ret;
}

int main()
{
 int n, m, k;
 scanf("%d%d%d", &n, &m, &k);
 if(n > m + k) puts("0");
 else printf("%d\n", (f(n, m) - f(n - k - 1, m + k + 1)).val());
 return 0;
}

AtCoder Beginner Contest 199 (Sponsored by Panasonic) A~E Solutions

Sun, 13 Jun 2021 11:31:00 +0800

A - Square Inequality

Problem Statement

Given three integers $A$, $B$, and $C$, determine if $A^2 + B^2 < C^2$ holds.

$0 \le A,B,C \le 1000$

Input Format

$A~B~C$

Output Format

Print Yes if $A^2 + B^2 < C^2$; otherwise, print No.

Samples

$A$	$B$	$C$	Output
$2$	$2$	$4$	`Yes`
$10$	$10$	$10$	`No`
$3$	$4$	$5$	`No`

Analysis

Directly compute according to the problem statement.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 puts(a * a + b * b < c * c? "Yes": "No");
 return 0;
}

B - Intersection

Problem Statement

Given two sequences of length $N$: $A = (A_1, A_2, A_3, \dots, A_N)$ and $B = (B_1, B_2, B_3, \dots, B_N)$. Find the number of integers $x$ satisfying:

For all $1 \le i \le N$, $A_i \le x \le B_i$.

$1 \le N \le 100$
$1 \le A_i \le B_i \le 1000$

Input Format

$N$
$A_1~A_2~\dots~A_N$
$B_1~B_2~\dots~B_N$

Output Format

Print the answer.

Samples

Sample Input1

Sample Output1

1

3

Possible $x$ values: $3$, $4$, $5$.

Sample Input2

Sample Output2

1

0

No valid $x$ exists.

Sample Input3

Sample Output3

1

2

Analysis

The constraints can be decomposed into:

For all $1 \le i \le N$, $A_i \le x$.
For all $1 \le i \le N$, $x \le B_i$.

This simplifies to $\max(A) \le x \le \min(B)$. The valid count is $\max(0, \min(B) - \max(A) + 1)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <cstdio>
using namespace std;

int main()
{
 int n, maxa = 1, minb = 1000;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 if(a > maxa) maxa = a;
 }
 while(n--)
 {
 int b;
 scanf("%d", &b);
 if(b < minb) minb = b;
 }
 if(maxa > minb) puts("0");
 else printf("%d\n", minb - maxa + 1);
 return 0;
}

C - IPFL

Problem Statement

Given a string $S$ of length $2N$ consisting of uppercase letters. Process $Q$ queries. Each query consists of three integers $T_i, A_i, B_i$:

If $T_i = 1$: swap the $A_i$-th and $B_i$-th characters of $S$.
If $T_i = 2$: swap the first $N$ and last $N$ characters of $S$.

Output $S$ after all queries.

$1 \le N \le 2 \times 10^5$
$|S| = 2N$
$1 \le Q \le 3 \times 10^5$
$1 \le T_i \le 2$, $1 \le A_i < B_i \le 2N$ if $T_i = 1$; $A_i = B_i = 0$ if $T_i = 2$.

Input Format

$N$
$S$
$Q$
$T_1~A_1~B_1$
$T_2~A_2~B_2$
$\hspace{18pt}\vdots$
$T_Q~A_Q~B_Q$

Samples

Sample Input1

Sample Output1

1

LPFI

$\text{FLIP} \to \text{IPFL} \to \text{LPFI}$

Sample Input2

Sample Output2

1

ILPF

Analysis

The $\mathcal O(NQ)$ simulation approach would TLE. Optimize by tracking flip state:

Maintain flipped flag. For $T_i = 2$, toggle flipped.
For $T_i = 1$, adjust indices based on flipped status to compute actual positions.

Time complexity: $\mathcal O(N + Q)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <cstdio>
#define maxn 400005
using namespace std;

char s[maxn];
int n;

inline void swap(char& x, char& y) { x ^= y ^= x ^= y; }
inline char& calc(int pos) { return s[pos < n? pos + n: pos - n]; }

int main()
{
 scanf("%d%s", &n, s);
 int q;
 scanf("%d", &q);
 bool flipped = false;
 while(q--)
 {
 int t, a, b;
 scanf("%d%d%d", &t, &a, &b);
 a --, b --;
 if(t == 2) flipped = !flipped;
 else if(flipped) swap(calc(a), calc(b));
 else swap(s[a], s[b]);
 }
 if(flipped)
 for(int i=0; i<n; i++)
 swap(s[i], s[n + i]);
 puts(s);
 return 0;
}

D - RGB Coloring 2

Problem Statement

Given a simple undirected graph with $N$ vertices and $M$ edges. Count valid colorings using three colors where adjacent vertices have different colors.

$1 \le N \le 20$
$0 \le M \le \frac{N(N-1)}{2}$

Input Format

$N~M$
$A_1~B_1$
$A_2~B_2$
$\hspace{12pt}\vdots$
$A_M~B_M$

Output Format

Print the answer.

Samples

Sample Input1

Sample Output1

1

6

Valid colorings: RGB, RBG, GRB, GBR, BRG, BGR.

Sample Input2

1

3 0

Sample Output2

1

27

Sample Input3

Sample Output3

1

0

Sample Input4

1

20 0

Sample Output4

1

3486784401

Analysis

For each connected component, count valid colorings via DFS. Multiply results across components. Total attempts are bounded by $3 \times 2^{N-1}$.

Code

~~Seems no one noticed that unsigned int could be used…~~

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


#include <cstdio>
#include <vector>
#define maxn 25
using namespace std;

vector<int> G[maxn];
int col[maxn], dep[maxn];

inline int next(int c) { return (c + 1) % 3; }

int paint(int v)
{
 for(int u: G[v])
 if(col[v] == col[u])
 return 0;
 int ans = 1;
 for(int u: G[v])
 {
 if(dep[u] == -1) dep[u] = dep[v] + 1;
 if(dep[u] == dep[v] + 1)
 {
 col[u] = next(col[v]);
 int res = paint(u);
 col[u] = next(col[u]);
 res += paint(u);
 col[u] = -1;
 if(res == 0) return 0;
 ans *= res;
 }
 }
 return ans;
}

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[--x].push_back(--y);
 G[y].push_back(x);
 }
 for(int i=0; i<n; i++)
 col[i] = dep[i] = -1;
 unsigned int ans = 1;
 for(int i=0; i<n; i++)
 if(dep[i] == -1)
 {
 col[i] = dep[i] = 0;
 ans *= 3U * paint(i);
 }
 printf("%u\n", ans);
 return 0;
}

E - Permutation

Problem Statement

Count permutations of $(1, 2, \dots, N)$ satisfying:

For each $1 \le i \le M$, among the first $X_i$ elements, at most $Z_i$ are $\le Y_i$.

$2 \le N \le 18$
$0 \le M \le 100$
$1 \le X_i, Y_i < N$
$0 \le Z_i < N$

Input Format

$N~M$
$X_1~Y_1~Z_1$
$X_2~Y_2~Z_2$
$\hspace{18pt}\vdots$
$X_M~Y_M~Z_M$

Output Format

Print the count.

Samples

Sample Input1

Sample Output1

1

4

Valid permutations: $(1,2,3)$, $(2,3,1)$, $(3,1,2)$, $(3,2,1)$.

Sample Input2

Sample Output2

1

90

Sample Input3

1

18 0

Sample Output3

1

6402373705728000

Analysis

Use bitmask DP. Let dp[mask] represent the number of valid ways to select the subset mask. For each bit added, check constraints. Time complexity: $\mathcal O(2^N \cdot (N + M))$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


#include <cstdio>
#include <vector>
#define maxn 20
using namespace std;

using LL = long long;

vector<pair<int, int>> lim[maxn];
LL dp[1 << maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int x, y, z;
 scanf("%d%d%d", &x, &y, &z);
 if(z < y) lim[x].emplace_back(y, z);
 }
 int mx = 1 << n;
 dp[0] = 1LL;
 for(int st=0; st<mx; st++)
 {
 vector<int> s;
 for(int i=0; i<n; i++)
 if(st >> i & 1)
 s.push_back(i);
 int cnt = __builtin_popcount(st);
 bool ok = true;
 for(auto [y, z]: lim[cnt])
 {
 int tot = 0;
 for(auto x: s)
 if(x < y && ++tot > z)
 {
 ok = false;
 break;
 }
 if(!ok) break;
 }
 if(ok) for(int x: s) dp[st] += dp[st ^ (1 << x)];
 }
 printf("%lld\n", dp[mx - 1]);
 return 0;
}

KYOCERA Programming Contest 2021 (AtCoder Beginner Contest 200) A~E Problem Solutions

Thu, 10 Jun 2021 22:16:00 +0800

A - Century

Problem Statement

In which century does the year $N$ fall?

$1\le N\le 3000$

Input Format

$N$

Output Format

Print the answer as an integer.

Sample Cases

$N$	Output
$2021$	$21$
$200$	$2$

Analysis

We can derive that year $N$ belongs to the $\lceil \frac N {100}\rceil$ century.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int n;
 scanf("%d", &n);
 printf("%d\n", n % 100 == 0? n / 100: n / 100 + 1);
 return 0;
}

B - 200th ABC-200

Problem Statement

Perform the following operations $K$ times on integer $N$:

If $N$ is a multiple of 200, divide it by 200.
Otherwise, append 200 to $N$ (e.g., 123 becomes 123200).

$1\le N\le 10^5$
$1\le K\le 20$

Input Format

$N~K$

Output Format

Print the final $N$.

Sample Cases

$N$	$K$	Output
$2021$	$4$	$50531$
$40000$	$2$	$1$
$8691$	$20$	$84875488281$

Analysis

We simulate the process while proving the result fits in long long:

Appending 200 to any $N$ makes it divisible by 200 (ends with two zeros).
After appending, dividing by 200 reduces digit count. Thus, $N$ remains strictly below $2^{63}$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <cstdio>
using namespace std;

int main()
{
 long long n;
 int k;
 scanf("%lld%d", &n, &k);
 while(k--)
 n = n % 200LL == 0LL? n / 200LL: n * 1000LL + 200LL;
 printf("%lld\n", n);
 return 0;
}

C - Ringo’s Favorite Numbers 2

Problem Statement

Given sequence $A=(A_1,A_2,\dots,A_N)$, find all pairs $(i,j)$ satisfying:

$1\le i < j\le N$
$|A_i-A_j|$ is a multiple of 200.

$2\le N\le 2\times 10^5$
$1\le A_i\le 10^9$

Output Format

$N$
$A_1~A_2~\dots~A_N$

Sample Cases

$A$	Output
$(123,223,123,523,200,2000)$	$4$
$(1,2,3,4,5)$	$0$
$(199,100,200,400,300,500,600,200)$	$9$

Analysis

We use modulo 200 buckets to count pairs in $\mathcal O(n)$ time:

Elements in the same remainder bucket form valid pairs.
For each element, add current bucket count to the answer before updating the bucket.

Note: The answer must be of type long long!

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <cstdio>
#define MOD 200
using namespace std;

int cnt[MOD];

int main()
{
 int n;
 scanf("%d", &n);
 long long ans = 0LL;
 while(n--)
 {
 int x;
 scanf("%d", &x);
 ans += cnt[x %= MOD] ++;
 }
 printf("%lld\n", ans);
 return 0;
}

D - Happy Birthday! 2

Problem Statement

Given sequence $A=(A_1,A_2,\dots,A_N)$, find two distinct subsequences $B$ and $C$ (different indices, not necessarily contiguous) such that $\sum B\equiv \sum C\pmod{200}$.

$2\le N\le 200$
$1\le A_i\le 10^9$

Input Format

$N$
$A_1~A_2~\dots~A_N$

Output

If no solution exists, print No.
Otherwise, output:
$\text{Yes}$
$x~B'_1~B'_2~\dots~B'_x$
$y~C'_1~C'_2~\dots~C'_y$

Sample Cases

See AtCoder for details.

Analysis

When $N\ge 8$, pigeonhole principle guarantees a solution (255 subsets mod 200). For $N<8$, brute-force all subsets.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <cstdio>
#include <vector>
#define maxn 10
#define MOD 200
using namespace std;

int a[maxn];
vector<int> bkt[MOD];

inline void print(const vector<int>& v)
{
 printf("%llu", v.size());
 for(int x: v)
 printf(" %d", x + 1);
 putchar('\n');
}

int main()
{
 int n;
 scanf("%d", &n);
 if(n > 8) n = 8;
 for(int i=0; i<n; i++)
 scanf("%d", a + i);
 int lim = 1 << n;
 for(int st=0; st<lim; st++)
 {
 int s = 0;
 vector<int> pos;
 for(int i=0; i<n; i++)
 if(st >> i & 1)
 s = (s + a[i]) % MOD, pos.push_back(i);
 if(!bkt[s].empty())
 {
 puts("Yes");
 print(bkt[s]);
 print(pos);
 return 0;
 }
 else bkt[s] = pos;
 }
 puts("No");
 return 0;
}

E - Patisserie ABC 2

Problem Statement

There are $N^3$ triples $(i,j,k)$ ($1\le i,j,k\le N$), ordered by:

Ascending $i+j+k$
For equal sums, ascending $i$, then $j$

Find the $K$-th triple.

$1\le N\le 10^6$
$1\le K\le N^3$

Input Format

$N~K$

Output Format

Print the $K$-th triple separated by spaces.

Sample Cases

$N$	$K$	Output
$2$	$5$	$1 2 2$
$1000000$	$1000000000000000000$	$1000000 1000000 1000000$
$9$	$47$	$3 1 4$

Analysis

Iterate possible sums $s$ and compute valid triples count using inclusion-exclusion:

Number of solutions to $i+j+k=s$ in $[1,N]$ is $f(s) - 3f(s-N) + 3f(s-2N)$ where $f(n) = \binom{n-1}{2}$ for $n\ge3$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
using namespace std;

using LL = long long;
int n;

inline int max(int x, int y) { return x > y? x: y; }
inline int min(int x, int y) { return x < y? x: y; }

inline LL f(LL n) { return n-- > 2? n * (n - 1LL) >> 1LL: 0LL; }
inline LL count(int s) { return f(s) - 3 * (f(s - n) - f(s - (n << 1))); }

int main()
{
 LL k;
 scanf("%d%lld", &n, &k);
 int lim = n * 3;
 for(int sum=3; sum<=lim; sum++)
 {
 LL cnt = count(sum);
 if(k > cnt) { k -= cnt; continue; }
 for(int a=1; a<=n; a++)
 {
 int minb = max(1, sum - a - n), maxb = min(n, sum - a - 1);
 if(minb > maxb) continue;
 int num = maxb - minb + 1;
 if(k <= num)
 {
 int b = minb + k - 1;
 int c = sum - a - b;
 printf("%d %d %d\n", a, b, c);
 return 0;
 }
 k -= num;
 }
 }
 return 0;
}

AtCoder Beginner Contest 204 A~E Solutions

Mon, 07 Jun 2021 19:02:00 +0800

A - Rock-paper-scissors

Three people play rock-paper-scissors to a draw. Two of them chose $x$ and $y$ respectively. Determine the third person’s choice.

$0\le x,y\le 2$ (0=Rock, 1=Scissors, 2=Paper)

Input Format

$x,y$

Output Format

Output the integer representing the third person’s choice.

Samples

$x$	$y$	Output
$0$	$1$	$2$
$0$	$0$	$0$

Analysis

A three-way draw occurs in two cases (let $z$ be the third person’s choice):

$x=y=z$
All three choices are distinct

The formula can be derived as:
$z=\begin{cases}x & (x=y)\\3-x-y & (x\ne y)\end{cases}$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int x, y;
 scanf("%d%d", &x, &y);
 printf("%d\n", x == y? x: 3 - x - y);
 return 0;
}

B - Nuts

There are $N$ trees. The $i$-th tree has $A_i$ nuts. A person collects $\max(0,A_i-10)$ nuts from each tree. Calculate the total collected nuts.

$1\le N,A_i\le 1000$

Input Format

$N$
$A_1~\dots~A_N$

Output Format

Output the total.

Samples

Sample Input 1

Sample Output 1

1

25

Collected nuts: $0+7+18=25$

Sample Input 2

Sample Output 2

1

1

Only the last tree contributes 1 nut.

Analysis

Simulate according to the problem statement.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <cstdio>
using namespace std;

int main()
{
 int n, ans = 0;
 scanf("%d", &n);
 while(n--)
 {
 int a;
 scanf("%d", &a);
 if(a > 10) ans += a - 10;
 }
 printf("%d\n", ans);
 return 0;
}

C - Tour

A country has $N$ cities and $M$ one-way roads. Count the number of valid ordered pairs $(X,Y)$ where one can travel from city $X$ to city $Y$ through any number of roads (including staying at the same city).

$2\le N\le 2000$
$0\le M\le \min(2000,N(N-1))$
All roads are distinct and not self-looping.

Input Format

$N~M$
$A_1~B_1$
$\vdots$
$A_M~B_M$

Output Format

Output the count.

Samples

Sample Input 1

Sample Output 1

1

7

Valid pairs: (1,1), (1,2), (1,3), (2,2), (2,3), (3,2), (3,3)

Sample Input 2

1

3 0

Sample Output 2

1

3

Only self-pairs are valid.

Analysis

Model the country as a directed unweighted graph. Perform DFS from each node to count reachable nodes. Time complexity: $\mathcal O(n^2)$.

Code

Note: Reset the vis array before each DFS!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <cstdio>
#include <vector>
#define maxn 2005
using namespace std;

vector<int> G[maxn];
bool vis[maxn];

int ans;

void dfs(int v)
{
 if(vis[v]) return;
 vis[v] = true, ans ++;
 for(int u: G[v])
 dfs(u);
}

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[--x].push_back(--y);
 }
 ans = 0;
 for(int i=0; i<n; i++)
 {
 for(int j=0; j<n; j++)
 vis[j] = false;
 dfs(i);
 }
 printf("%d\n", ans);
 return 0;
}

D - Cooking

Two people wash $N$ dishes. Dish $i$ takes $T_i$ minutes. Calculate the minimum time to wash all dishes when working in parallel.

$1\le N\le 100$
$1\le T_i\le 10^3$

Input Format

$N$
$T_1~T_2~\dots~T_N$

Output Format

Output the minimal total time.

Samples

Sample Input 1

Sample Output 1

1

13

Optimal split: 13 (8+5) vs 10 (3+7+2)

Sample Input 2

Sample Output 2

1

1000

Sample Input 3

1
2


9
3 14 15 9 26 5 35 89 79

Sample Output 3

1

138

Analysis

Classic 0-1 knapsack problem. Find the maximum subset sum not exceeding half of total time. Answer is total minus this subset sum.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <cstdio>
#define maxn 105
#define maxv 100005
using namespace std;

int dp[maxv], w[maxn];

inline void setmax(int& x, int y)
{
 if(y > x) x = y;
}

int main()
{
 int n, v = 0;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 scanf("%d", w + i);
 v += w[i];
 }
 int t = v;
 v >>= 1;
 for(int i=0; i<n; i++)
 for(int j=v; j>=w[i]; j--)
 setmax(dp[j], dp[j - w[i]] + w[i]);
 printf("%d\n", t - dp[v]);
 return 0;
}

E - Rush Hour 2

A country has $N$ cities and $M$ bidirectional roads. The travel time through road $i$ at time $t$ is $C_i+\lfloor\frac{D_i}{t+1}\rfloor$. Find the earliest time to reach city $N$ from city $1$, or output -1.

$2\le N\le 10^5$
$2\le M\le 10^5$
$0\le C_i,D_i\le 10^9$

Input Format

$N~M$
$A_1~B_1~C_1~D_1$
$\vdots$
$A_M~B_M~C_M~D_M$

Output Format

Output the minimal time or -1.

Samples

Sample Input 1

Sample Output 1

1

4

Depart at t=1: 1+2+⌊3/2⌋=4

Sample Input 2

Sample Output 2

1

3

Multiple roads and self-loops allowed.

Sample Input 3

Sample Output 3

1

-1

No valid path exists.

Analysis

Model as graph and use Dijkstra’s algorithm. For each edge, optimal departure time is around $\lfloor\sqrt{D}\rfloor-1$. Time complexity: $\mathcal O(M\log N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <cstdio>
#include <cmath>
#include <vector>
#include <queue>
#include <tuple>
#define maxn 100005
#define INF 9223372036854775807LL
using namespace std;

using Road = tuple<int, int, int>;
using LL = long long;
using pli = pair<LL, int>;

vector<Road> G[maxn];
LL dist[maxn];

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 while(m--)
 {
 int a, b, c, d;
 scanf("%d%d%d%d", &a, &b, &c, &d);
 if(--a == --b) continue;
 G[a].emplace_back(b, c, d);
 G[b].emplace_back(a, c, d);
 }
 dist[0] = 0LL;
 for(int i=1; i<n; i++) dist[i] = INF;
 priority_queue<pli, vector<pli>, greater<pli>> q;
 q.emplace(0LL, 0);
 while(!q.empty())
 {
 auto [t, u] = q.top(); q.pop();
 if(dist[u] != t) continue;
 for(auto [v, c, d]: G[u])
 {
 LL t2 = sqrt((long double) d) - 0.5;
 if(t2 < t) t2 = t;
 t2 += LL(c) + LL(d) / (t2 + 1LL);
 if(t2 < dist[v])
 q.emplace(dist[v] = t2, v);
 }
 }
 if(dist[n - 1] == INF) puts("-1");
 else printf("%lld\n", dist[n - 1]);
 return 0;
}

AISing Programming Contest 2021 (AtCoder Beginner Contest 202) A~E Problem Solutions

Sun, 06 Jun 2021 11:28:00 +0800

A - Three Dice

A person rolled three dice with top faces showing $a$, $b$, and $c$. Find the sum of their bottom faces.
The dice used are standard, meaning the sum of opposite faces is $7$.

$1\le a,b,c\le 6$

Input Format

$a~b~c$

Output Format

Print the answer.

Samples

$a$	$b$	$c$	Answer
$1$	$4$	$3$	$13$
$5$	$6$	$4$	$6$

Analysis

Since opposite faces sum to $7$, the answer is $(7-a)+(7-b)+(7-c)=21-a-b-c$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 printf("%d\n", 21 - a - b - c);
 return 0;
}

B - 180°

Given a string $S$ consisting of 0, 1, 6, 8, 9. Rotate it 180° and output the result.

$1\le |S|\le10^5$

Input Format

$S$

Output Format

Print the rotated string.

Samples

$S$	Output
`0601889`	`6881090`
`86910`	`01698`
`01010`	`01010`

Analysis

Directly simulate the rotation process.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <cstdio>
#define maxn 100005
using namespace std;

char s[maxn];

int main()
{
 int n = 0;
 char c;
 while((c = getchar()) != '\n')
 s[n++] = c;
 while(n--)
 putchar(s[n] == '6'? '9': s[n] == '9'? '6': s[n]);
 putchar('\n');
 return 0;
}

C - Made Up

Given three sequences $A$, $B$, $C$ of length $N$. Count the number of pairs $(i,j)$ satisfying $A_i=B_{C_j}$.

$1\le N\le 10^5$
$1\le A_i,B_i,C_i\le N$

Input Format

$N$
$A_1~A_2~\dots~A_N$
$B_1~B_2~\dots~B_N$
$C_1~C_2~\dots~C_N$

Output Format

Print the count.

Samples

Sample Input 1

Sample Output 1

1

4

Valid pairs: $(1,1),(1,3),(2,2),(3,2)$.

Sample Input 2

Sample Output 2

1

16

All pairs are valid.

Sample Input 3

Sample Output 3

1

0

No valid pairs.

Analysis

An $O(n^2)$ brute-force approach would TLE. Instead, count frequencies using bucket arrays $\mathrm{acnt}$ and $\mathrm{bcnt}$, then compute the sum $\sum_{i=1}^n\mathrm{acnt}_i\mathrm{bcnt}_i$.

Code

Note: Use long long to avoid overflow!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <cstdio>
#define maxn 100005
using namespace std;

using LL = long long;
int acnt[maxn], b[maxn], bcnt[maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=0; i<n; i++)
 {
 int a;
 scanf("%d", &a);
 acnt[a] ++;
 }
 for(int i=0; i<n; i++)
 scanf("%d", b + i);
 for(int i=0; i<n; i++)
 {
 int c;
 scanf("%d", &c);
 bcnt[b[--c]] ++;
 }
 LL ans = 0LL;
 for(int i=1; i<=n; i++)
 ans += LL(acnt[i]) * LL(bcnt[i]);
 printf("%lld\n", ans);
 return 0;
}

D - aab aba baa

Find the $K$-th lexicographically smallest string consisting of $A$ as and $B b`s.

$1\le A,B\le30$
$1\le K\le S$ ($S$ is the total number of valid strings)

Input Format

$A~B~K$

Output Format

Print the required string.

Samples

$A$	$B$	$K$	Output
$2$	$2$	$4$	`baab`
$30$	$30$	$118264581564861424$	(30 `b`s + 30 `a`s)

Analysis

Let $\mathrm{dp}(a,b)$ be the count of strings with $a$ as and $b` `b`s. The recursive formula is: $\mathrm{dp}(a,b)=\mathrm{dp}(a-1,b)+\mathrm{dp}(a,b-1)$. Construct the string greedily by comparing $K$ with $\mathrm{dp}(a-1,b)$ at each step.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <cstdio>
#define maxn 35
using namespace std;

using LL = long long;
LL dp[maxn][maxn];

int main()
{
 int a, b;
 LL k;
 scanf("%d%d%lld", &a, &b, &k);
 for(int i=0; i<=a; i++) dp[i][0] = 1;
 for(int i=0; i<=b; i++) dp[0][i] = 1;
 for(int i=1; i<=a; i++)
 for(int j=1; j<=b; j++)
 dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
 while(a && b)
 {
 LL t = dp[a - 1][b];
 if(k <= t) putchar('a'), a --;
 else putchar('b'), b --, k -= t;
 }
 while(a--) putchar('a');
 while(b--) putchar('b');
 putchar('\n');
 return 0;
}

E - Count Descendants

Given an $N$-node tree rooted at node 1. The parent of node $i$ ($2\le i\le N$) is $P_i$. Answer $Q$ queries: count nodes $u$ where:

The path from $u$ to root has exactly $D_i$ edges.
$U_i$ lies on this path (including endpoints).

$1\le N\le 2\times10^5$
$1\le P_i $1\le Q\le 2\times10^5$
$1\le U_i\le N$
$0\le D_i < N$

Input Format

$N$
$P_2~P_3~\dots~P_N$
$Q$
$U_1~D_1$
$U_2~D_2$
$\vdots$
$U_Q~D_Q$

Output Format

Print $Q$ lines, each containing the answer.

Samples

Sample Input

1
2
3
4
5
6
7


7
1 1 2 2 4 2
4
1 2
7 2
4 1
5 5

Sample Output

Explanation:

Query 1: Nodes 4,5,7.
Query 2: Node 7.
Queries 3-4: No valid nodes.

Analysis

Preprocess each node’s entry/exit timestamps via DFS. For each depth $d$, collect all entry times. For a query $(U_i,D_i)$, count nodes at depth $D_i$ whose entry time is between $U_i$’s entry and exit times using binary search.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <cstdio>
#include <vector>
#include <algorithm>
#define maxn 200005
using namespace std;

int in[maxn], out[maxn], dep[maxn], cnt;
vector<int> G[maxn], depin[maxn];

void dfs(int v)
{
 depin[dep[v]].push_back(in[v] = cnt++);
 for(int u: G[v])
 dfs(u);
 out[v] = cnt++;
}

int main()
{
 int n;
 scanf("%d", &n);
 dep[0] = cnt = 0;
 for(int i=1; i<n; i++)
 {
 int p;
 scanf("%d", &p);
 dep[i] = dep[--p] + 1;
 G[p].push_back(i);
 }
 dfs(0);
 int q;
 scanf("%d", &q);
 while(q--)
 {
 int u, d;
 scanf("%d%d", &u, &d);
 const auto& din = depin[d];
 auto first = lower_bound(din.begin(), din.end(), in[--u]);
 auto last = lower_bound(din.begin(), din.end(), out[u]);
 printf("%lld\n", last - first);
 }
 return 0;
}

AtCoder Beginner Contest 203 (Sponsored by Panasonic) A~E Problem Solutions

Thu, 03 Jun 2021 21:11:00 +0800

A - Chinchirorin

Problem Statement

Given three integers $a,b,c$, if two of them are equal, output the third one; otherwise, output $0$.

$1\le a,b,c\le 6$

Input Format

$a~b~c$

Output Format

Output the third value if two of $a,b,c$ are equal; otherwise, output $0$.

Samples

$a$	$b$	$c$	Output
$2$	$5$	$2$	$5$
$4$	$5$	$6$	$0$
$1$	$1$	$1$	$1$

Analysis

Problem A remains straightforward. Directly check the three possible equality cases.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <cstdio>
using namespace std;

int main()
{
 int a, b, c;
 scanf("%d%d%d", &a, &b, &c);
 if(a == b) printf("%d\n", c);
 else if(b == c) printf("%d\n", a);
 else if(a == c) printf("%d\n", b);
 else puts("0");
 return 0;
}

B - AtCoder Condominium

Problem Statement

Given $N$ and $K$, compute $\sum\limits_{i=1}^N\sum\limits_{j=1}^K \overline{i0j}$.

$1\le N,K\le 9$

Input Format

$N~K$

Output Format

Output $\sum\limits_{i=1}^N\sum\limits_{j=1}^K \overline{i0j}$.

Samples

$N$	$K$	Output
$1$	$2$	$203$
$3$	$3$	$1818$

Analysis

Brute-force works, but here’s an $\mathcal O(1)$ approach:
Since $\overline{i0j}=100i+j$ and $1+2+\dots+N=\frac{N(N+1)}2$, we derive:

$\sum\limits_{i=1}^N\sum\limits_{j=1}^K \overline{i0j}=\frac{100N(N+1)K+K(K+1)N}2$

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <cstdio>
using namespace std;

inline int sum(int x) { return x * (x + 1) >> 1; }

int main()
{
 int n, k;
 scanf("%d%d", &n, &k);
 printf("%d\n", sum(n) * k * 100 + sum(k) * n);
 return 0;
}

C - Friends and Travel costs

Problem Statement

There are $10^{100}+1$ villages numbered $0,1,\dots,10^{100}$. Moving between adjacent villages costs $1$ yen.
Taro starts at village $0$ with $K$ yen and wants to reach the highest possible village.
He has $N$ friends. The $i$-th friend gives $B_i$ yen when Taro reaches village $A_i$.
Find the highest village Taro can reach.

$1\le N\le 2\times10^5$
$1\le K\le 10^9$
$1\le A_i\le 10^{18}$
$1\le B_i\le 10^9$

Input Format

$N~K$
$A_1~B_1$
$A_2~B_2$
$\dots$
$A_N~B_N$

Output

Output the highest village number Taro can reach.

Samples

Sample Input 1

Sample Output 1

1

4

Sample Input 2

1
2
3
4
5
6


5 1000000000
1 1000000000
2 1000000000
3 1000000000
4 1000000000
5 1000000000

Sample Output 2

1

6000000000

Use 64-bit integers.

Sample Input 3

Sample Output 3

1

10

A village may contain multiple friends.

Analysis

Sort friends by $A_i$. Process intervals between friends, checking if Taro can reach each $A_i$ with remaining funds.

Code

Note: Sorting uses a priority queue.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#include <cstdio>
#include <queue>
#define maxn 200005
#define INF 18446744073709551615ULL
using namespace std;

using ULL = unsigned long long;
using pll = pair<ULL, ULL>;

int main()
{
 int n;
 ULL k;
 scanf("%d%llu", &n, &k);
 priority_queue<pll, vector<pll>, greater<pll> > q;
 for(int i=0; i<n; i++)
 {
 ULL a, b;
 scanf("%llu%llu", &a, &b);
 q.emplace(a, b);
 }
 ULL lastv = 0ULL;
 q.emplace(INF, 0ULL);
 while(!q.empty())
 {
 auto [a, b] = q.top(); q.pop();
 ULL cost = a - lastv;
 if(k < cost)
 {
 printf("%llu\n", lastv + k);
 return 0;
 }
 k -= cost;
 lastv = a, k += b;
 }
 return 0;
}

D - Pond

Problem Statement

Given an $N\times N$ matrix $A$, find the minimum median among all $K\times K$ submatrices. The median is the $(\left\lfloor\frac{K^2}2\right\rfloor+1)$-th largest value.

$1\le K\le N\le 800$
$1\le A_{i,j}\le 10^9$

Example illustration:

Input Format

$N~K$
$A_{1,1}~A_{1,2}~\dots~A_{1,N}$
$\vdots$
$A_{N,1}~A_{N,2}~\dots~A_{N,N}$

Output Format

Output the answer.

Samples

Sample Input 1

Sample Output 1

1

4

Sample Input 2

Sample Output 2

1

5

Analysis

Binary search the answer. For each candidate value, use matrix prefix sums to count elements exceeding it in each submatrix. Time complexity $\mathcal O(n^2\log\max\{A\})$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <cstdio>
#define maxn 805
#define INF 2147483647
using namespace std;

int a[maxn][maxn], dp[maxn][maxn], n, k, target;

inline int count(int x1, int y1, int x2, int y2)
{
 return dp[x2][y2] - dp[x1 - 1][y2] - dp[x2][y1 - 1] + dp[x1 - 1][y1 - 1];
}

inline bool check(int x)
{
 for(int i=1; i<=n; i++)
 for(int j=1; j<=n; j++)
 dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + (a[i][j] > x);
 for(int x2=k; x2<=n; x2++)
 for(int y2=k; y2<=n; y2++)
 {
 int x1 = x2 - k + 1, y1 = y2 - k + 1;
 if(count(x1, y1, x2, y2) < target)
 return true;
 }
 return false;
}

int main()
{
 scanf("%d%d", &n, &k);
 target = (k * k >> 1) + 1;
 int l = INF, r = 0, ans = 0;
 for(int i=1; i<=n; i++)
 for(int j=1; j<=n; j++)
 {
 scanf("%d", a[i] + j);
 if(a[i][j] > r) r = a[i][j];
 if(a[i][j] < l) l = a[i][j];
 }
 while(l <= r)
 {
 int mid = l + r >> 1;
 if(check(mid)) ans = mid, r = mid - 1;
 else l = mid + 1;
 }
 printf("%d\n", ans);
 return 0;
}

E - White Pawn

Problem Statement

On a $(2N+1)\times(2N+1)$ chessboard, a white pawn starts at $(0,N)$. $M$ black squares exist at $(X_i,Y_i)$. The pawn moves:

Down to white $(i+1,j)$,
Diagonally down-left to black $(i+1,j-1)$,
Diagonally down-right to black $(i+1,j+1)$.

Find how many columns in the last row are reachable.

$1\le N\le 10^9$
$0\le M\le 2\times 10^5$

Input Format

$N~M$
$X_1~Y_1$
$\vdots$
$X_M~Y_M$

Output Format

Output the count.

Samples

Sample Input 1

Sample Output 1

1

3

Sample Input 2

Sample Output 2

1

0

Analysis

Process black squares row-wise. Maintain reachable columns using a set. For each black row, update reachable positions based on adjacent cells.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
#pragma GCC optimize("Ofast")
using namespace std;

int main()
{
 int n, m;
 scanf("%d%d", &n, &m);
 vector<pair<int, int> > black;
 black.reserve(m);
 while(m--)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 black.emplace_back(x, y);
 }
 m = black.size();
 sort(black.begin(), black.end());
 set<int> cols;
 cols.insert(n);
 for(int l=0, r=0; l<m; l=r)
 {
 while(r < m && black[r].first == black[l].first) r ++;
 vector<int> rem, add;
 for(int i=l; i<r; i++)
 {
 int y = black[i].second;
 bool ok = cols.count(y - 1) || cols.count(y + 1);
 if(cols.count(y))
 {
 if(!ok)
 rem.push_back(y);
 }
 else if(ok)
 add.push_back(y);
 }
 for(int y: rem) cols.erase(y);
 for(int y: add) cols.insert(y);
 }
 printf("%llu\n", cols.size());
 return 0;
}

Mynavi Programming Contest 2021 (AtCoder Beginner Contest 201) A~E Solutions

Tue, 18 May 2021 19:30:00 +0800

A - Tiny Arithmetic Sequence

Problem Statement

Given a sequence $A=(A_1,A_2,A_3)$, can it be rearranged such that $A_3-A_2=A_2-A_1$?

$1\le A_i\le 100$

Input Format

$A_1~A_2~A_3$

Output Format

Print Yes if possible; otherwise, print No.

Sample Cases

$A$	Output
$(5,1,3)$	`Yes`
$(1,4,3)$	`No`
$(5,5,5)$	`Yes`

Analysis

It’s easy to observe that if $A_3-A_2=A_2-A_1$ holds, then $A_1\le A_2\le A_3$ or $A_3\le A_2\le A_1$ must be true. Thus, we can sort $A$ in ascending order and check if the condition holds.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <cstdio>
#include <algorithm>
using namespace std;

int main()
{
 int a[3];
 scanf("%d%d%d", a, a + 1, a + 2);
 sort(a, a + 3);
 puts(a[2] - a[1] == a[1] - a[0]? "Yes": "No");
 return 0;
}

B - Do you know the second highest mountain?

Problem Statement

There are $N$ mountains. The $i$-th mountain has a name $S_i$ and height $T_i$. Output the name of the second highest mountain.

$2\le N\le 1000$
$1\le |S_i|\le 15$
$1\le T_i\le 10^5$
$S_i\ne S_j~(i\ne j)$
$T_i\ne T_j~(i\ne j)$
$S_i$ consists of uppercase/lowercase letters and digits.

Input Format

$N$
$S_1~T_1$
$S_2~T_2$
$\vdots$
$S_N~T_N$

Output Format

Print the name of the second highest mountain.

Sample Cases

Sample Input 1

1
2
3
4


3
Everest 8849
K2 8611
Kangchenjunga 8586

Sample Output 1

1

K2

The second highest mountain is K2.

Sample Input 2

1
2
3
4
5


4
Kita 3193
Aino 3189
Fuji 3776
Okuhotaka 3190

Sample Output 2

1

Kita

The second highest mountain is Kita.

Sample Input 3

1
2
3
4
5


4
QCFium 2846
chokudai 2992
kyoprofriends 2432
penguinman 2390

Sample Output 3

1

QCFium

The second highest mountain is QCFium.

Analysis

This problem requires finding the $S_i$ corresponding to the second largest element in $T$. We can use a priority queue to maintain the top two elements efficiently.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
#include <queue>
#include <string>
using namespace std;

using pis = pair<int, string>;

int main()
{
 ios::sync_with_stdio(false); cin.tie(0);
 int n;
 cin >> n;
 priority_queue<pis, vector<pis>, greater<pis> > q;
 while(n--)
 {
 string s;
 int h;
 cin >> s >> h;
 q.emplace(h, s);
 if(q.size() > 2) q.pop();
 }
 cout << q.top().second << endl;
 return 0;
}

C - Secret Number

Problem Statement

A 4-digit PIN consists of digits 0-9 (may start with 0). A string $S_0S_1\dots S_9$ determines the presence of each digit:

If $S_i=$ o, the PIN must contain digit $i$;
If $S_i=$ x, the PIN must not contain digit $i$;
If $S_i=$ ?, the PIN may or may not contain digit $i$.

Count the number of valid PINs.

$S$ is a 10-character string of o, x, or ?.

Input Format

$S$

Output Format

Print the total count as an integer.

Sample Cases

$S$	Answer
`ooo???xxxx`	$108$
`o?oo?oxoxo`	$0$
`xxxxx?xxxo`	$15$
Edge Case: $S=$ `??????????`, Answer: $10000$

Analysis

Since there are only 10000 possible PINs, we can brute-force all combinations. For each candidate PIN, check compliance with $S$ in $\mathcal O(|S|)$ time.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <cstdio>
using namespace std;

char s[15];

inline bool valid(int a, int b, int c, int d)
{
 bool used[10] = {false};
 used[a] = used[b] = used[c] = used[d] = true;
 for(int i=0; i<10; i++)
 if(s[i] == 'o')
 {
 if(!used[i])
 return false;
 }
 else if(s[i] == 'x' && used[i])
 return false;
 return true;
}

int main()
{
 scanf("%s", s);
 int ans = 0;
 for(int a=0; a<10; a++)
 for(int b=0; b<10; b++)
 for(int c=0; c<10; c++)
 for(int d=0; d<10; d++)
 ans += valid(a, b, c, d);
 printf("%d\n", ans);
 return 0;
}

D - Game in Momotetsu World

Problem Statement

A $H\times W$ grid has cells colored blue (+) or red (-). A token starts at $(1,1)$. Takahashi and Aoki take turns moving it right or down. The current player gains 1 point for blue cells or loses 1 point for red cells. The game ends at $(H,W)$. Determine the winner if both play optimally.

$1\le H,W\le 2000$

Input Format

$H~W$
$A_{1,1}A_{1,2}\dots A_{1,W}$
$A_{2,1}A_{2,2}\dots A_{2,W}$
$\vdots$
$A_{H,1}A_{H,2}\dots A_{H,W}$

Output Format

Print Takahashi, Aoki, or Draw.

Analysis

Define $d$ as the score difference (Takahashi − Aoki). Using dynamic programming:

For $(i+j)$ even (Aoki’s turn): $dp(i,j) = \min(dp(i+1,j) - add(i+1,j), dp(i,j+1) - add(i,j+1))$
For $(i+j)$ odd (Takahashi’s turn): $dp(i,j) = \max(dp(i+1,j) + add(i+1,j), dp(i,j+1) + add(i,j+1))$

$add(i,j)$ is the score change upon entering $(i,j)$. The result depends on $dp(0,0)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <cstdio>
#include <algorithm>
#define maxn 2005
using namespace std;

int dp[maxn], add[maxn][maxn];

int main()
{
 int h, w;
 scanf("%d%d", &h, &w);
 for(int i=0; i<h; i++)
 {
 char tmp[maxn];
 scanf("%s", tmp);
 for(int j=0; j<w; j++)
 add[i][j] = tmp[j] == '+'? 1: -1;
 }
 dp[w - 1] = 0;
 for(int j=w-2; j>=0; j--)
 dp[j] = j + h & 1? dp[j + 1] + add[h - 1][j + 1]: dp[j + 1] - add[h - 1][j + 1];
 for(int i=h-2; i>=0; i--)
 {
 dp[w - 1] = i + w & 1? dp[w - 1] + add[i + 1][w - 1]: dp[w - 1] - add[i + 1][w - 1];
 for(int j=w-2; j>=0; j--)
 if(i + j & 1)
 dp[j] = min(dp[j] - add[i + 1][j], dp[j + 1] - add[i][j + 1]);
 else dp[j] = max(dp[j] + add[i + 1][j], dp[j + 1] + add[i][j + 1]);
 }
 if(dp[0] > 0) puts("Takahashi");
 else if(dp[0] < 0) puts("Aoki");
 else puts("Draw");
 return 0;
}

E - Xor Distances

Problem Statement

Given a tree with $N$ nodes and edge weights, compute $\sum_{1\le i

$1\le N\le 2\times10^5$
$0\le w_i < 2^{60}$

Input Format

$N$
$u_1~v_1~w_1$
$\vdots$
$u_{N-1}~v_{N-1}~w_{N-1}$

Output Format

Print the sum modulo $10^9+7$.

Analysis

Leverage XOR properties: $\mathrm{dist}(x,y) = \mathrm{dist}(r,x) \oplus \mathrm{dist}(r,y)$ for any root $r$. Compute XOR from root to all nodes. For each bit position, count the number of nodes with that bit set. The contribution to the total sum is $(count) \times (N-count) \times 2^{bit}$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


#include <cstdio>
#include <queue>
#pragma GCC optimize("Ofast")
#define maxn 200005
#define MOD 1000000007LL
using namespace std;

using LL = long long;
vector<pair<int, LL>> G[maxn];
LL d[maxn];

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<n; i++)
 {
 int u, v;
 LL w;
 scanf("%d%d%lld", &u, &v, &w);
 G[--u].emplace_back(--v, w);
 G[v].emplace_back(u, w);
 }
 queue<int> q;
 q.push(0);
 for(int i=1; i<n; i++) d[i] = -1;
 while(!q.empty())
 {
 int v = q.front(); q.pop();
 for(auto [u, w]: G[v])
 if(d[u] == -1)
 q.push(u), d[u] = d[v] ^ w;
 }
 LL ans = 0LL;
 for(int i=0; i<60; i++)
 {
 int cnt = 0;
 for(int j=0; j<n; j++)
 if(d[j] >> i & 1LL)
 cnt ++;
 if((ans += (1LL << i) % MOD * cnt % MOD * (n - cnt) % MOD) > MOD)
 ans -= MOD;
 }
 printf("%lld\n", ans);
 return 0;
}

AtCoder Beginner Contest 198 A~E Solutions

Tue, 13 Apr 2021 21:29:00 +0800

A - Div

Problem Statement

Two boys want to divide $N$ candies. How many ways are there to distribute them (each boy must get at least one candy)?

$1\le N\le 15$

Input Format

$N$

Output Format

Print the answer as an integer.

Sample

$N$	Output
$2$	$1$
$1$	$0$
$3$	$2$

Analysis

The problem reduces to splitting $N$ into two positive integers $A$ and $B$ (where $A+B$ and $B+A$ count as distinct). The possible pairs are:

$A$	$B$
$1$	$N-1$
$2$	$N-2$
$\dots$	$\dots$
$N-1$	$1$
This table has $N-1$ entries, so we directly output $N-1$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <cstdio>
using namespace std;

int main()
{
 int n;
 scanf("%d", &n);
 printf("%d\n", n - 1);
 return 0;
}

B - Palindrome with leading zeros

Problem Statement

Given an integer $N$, can we prepend any number (including zero) of 0s to its decimal representation to make it a palindrome?

$0\le N\le 10^9$

Input Format

$N$

Output Format

Print Yes or No.

Sample

$N$	Output
$1210$	`Yes`
$777$	`Yes`
$123456789$	`No`

Analysis

If prepending zeros can make $N$ a palindrome, then trimming all trailing zeros from $N$ must also yield a palindrome. Thus, we trim trailing zeros and check if the resulting string is a palindrome.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <cstdio>
using namespace std;

char s[10];

int main()
{
 char c;
 int len = 0;
 while((c = getchar()) != '\n')
 s[len++] = c;
 while(len > 0 && s[--len] == '0');
 for(int i=0; i<=len; i++)
 if(s[i] != s[len - i])
 {
 puts("No");
 return 0;
 }
 puts("Yes");
 return 0;
}

C - Compass Walking

Problem Statement

In a 2D plane, a person moves exactly $R$ units per step. What is the minimum steps needed to go from $(0,0)$ to $(X,Y)$?
Note: The distance between $(x_1, y_1)$ and $(x_2,y_2)$ is $\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$.

$1\le R\le 10^5$
$0\le X,Y\le 10^5$
$(X,Y)\ne(0,0)$

Input Format

$R~X~Y$

Output Format

Print the minimum number of steps.

Sample

$R$	$X$	$Y$	Output
$5$	$15$	$0$	$3$
$5$	$11$	$0$	$3$
$3$	$4$	$4$	$2$

Analysis

Let $d=\sqrt{X^2+Y^2}$ (Euclidean distance). The solution depends on:

If $d = R$: 1 step.
If $d < R$: 2 steps (two orthogonal steps form a hypotenuse).
If $d > R$: $\lceil\frac{d}{R}\rceil$ steps.

Code

Precision issues were tricky, but using long double worked.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <cstdio>
#include <cmath>
using namespace std;

int main()
{
 int r, x, y;
 scanf("%d%d%d", &r, &x, &y);
 long double dist = hypotl(x, y);
 if(dist == r) puts("1");
 else if(dist < r) puts("2");
 else printf("%d\n", int(ceill(dist / r)));
 return 0;
}

D - Send More Money

Problem Statement

Given three lowercase strings $S_1,S_2,S_3$, assign each unique letter a distinct digit (0-9) such that $N_1 + N_2 = N_3$ when converted to numbers (no leading zeros). Output any solution or UNSOLVABLE.

$1\le |S_1|,|S_2|,|S_3|\le 10$
Time Limit: 5 sec

Input Format

$S_1$
$S_2$
$S_3$

Output Format

Print $N_1$, $N_2$, $N_3$ on three lines, or UNSOLVABLE.

Sample

$S_1$	$S_2$	$S_3$	Output
`a`	`b`	`c`	`1 2 3`
`x`	`x`	`y`	`1 1 2`
`p`	`q`	`p`	`UNSOLVABLE`

Analysis

If the total unique letters exceed 10, output UNSOLVABLE. Otherwise, brute-force all permutations of digit assignments (up to $10!$ possibilities) and validate.

Code

Using permutations for enumeration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <cstdio>
#include <set>
#include <algorithm>
#define maxl 15
using namespace std;

using LL = long long;

char s1[maxl], s2[maxl], s3[maxl], ch[maxl];

set<char> chars;
int pos[26], num[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

#define N (num[pos[str[i] - 'a']])
inline LL parse(const char* str)
{
 LL res = 0LL;
 for(int i=0; str[i]; i++)
 res = res * 10LL + N;
 return res;
}

inline void print(const char* str)
{
 for(int i=0; str[i]; i++)
 putchar(N + '0');
 putchar('\n');
}
#undef N

inline void add(const char* str)
{
 for(int i=0; str[i]; i++)
 chars.insert(str[i]);
}

inline bool isok(const char* str)
{
 return num[pos[str[0] - 'a']] != 0;
}

int main()
{
 scanf("%s%s%s", s1, s2, s3);
 add(s1), add(s2), add(s3);
 if(chars.size() > 11)
 {
 puts("UNSOLVABLE");
 return 0;
 }
 int cnt = 0;
 for(char x: chars)
 pos[x - 'a'] = cnt++;
 do
 {
 if(isok(s1) && isok(s2) && isok(s3) && (parse(s1) + parse(s2) == parse(s3)))
 {
 print(s1);
 print(s2);
 print(s3);
 return 0;
 }
 } while(next_permutation(num, num + 10));
 puts("UNSOLVABLE");
 return 0;
}

E - Unique Color

Problem Statement

Given a tree with $N$ vertices, each vertex has a color $C_i$. A vertex $x$ is good if:

The shortest path from vertex $1$ to $x$ contains no duplicate colors (excluding $x$ itself).

Output all good vertices in ascending order.

$2\le N\le 10^5$
$1\le C_i\le 10^5$

Input Format

$N$
$C_1~\dots~C_N$
$A_1~B_1$
$\vdots$
$A_{N-1}~B_{N-1}$

Output Format

List all good vertices, one per line.

Analysis

Use DFS to track colors along the path. Maintain a used array to check color uniqueness. Time complexity: $\mathcal O(N)$.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <cstdio>
#include <vector>
#include <set>
#define maxn 100005
using namespace std;

vector<int> G[maxn];
bool used[maxn];
int color[maxn];

set<int> res;

void dfs(int v, int par)
{
 if(used[color[v]])
 {
 for(int u: G[v])
 if(u != par)
 dfs(u, v);
 return;
 }
 used[color[v]] = true;
 res.insert(v);
 for(int u: G[v])
 if(u != par)
 dfs(u, v);
 used[color[v]] = false;
}

int main()
{
 int n;
 scanf("%d", &n);
 for(int i=1; i<=n; i++)
 scanf("%d", color + i);
 while(--n)
 {
 int x, y;
 scanf("%d%d", &x, &y);
 G[x].push_back(y);
 G[y].push_back(x);
 }
 dfs(1, -1);
 for(int v: res)
 printf("%d\n", v);
 return 0;
}

Posts on GoodCoder's Blog

katac4: An Exploration of Reinforcement Learning Based on AlphaZero

Preface

A Quick Look at AlphaZero

Training, Annealing

Algorithm Optimizations

Gradient Accumulation

Action Space Pruning

First Play Urgency (FPU)

Playout Cap Randomization

Forced Playouts & Policy Target Pruning

Dynamic Replay Buffer

Monte Carlo Graph Search (MCGS)

Engineering Optimizations

Parallel Self-Play

CUDA Graphs

Test Results

Future Improvement Directions

Further Reading

Getting Started with Wolfram Mathematica

Preface

Interface

Syntax

Help Documentation

Comments

Brackets

Parentheses ()

Square Brackets []

Curly Braces {}

Double Brackets [[]]

Operations and Expressions

Boolean Expressions

Variables and Constants

Functions

Invocation

Definition

Built-in Functions

Numerical Evaluation N

Trigonometric Functions

Equation Solving Solve/Reduce

Alternative Solvers NSolve/FindInstance

Optimization Maximize/Minimize

Differentiation D

Integration Integrate

Expansion Expand/ExpandAll

Factorization Factor

Plotting Plot/Plot3D

Conclusion

UNIQUE VISION Programming Contest 2023 Christmas (AtCoder Beginner Contest 334) A~G Solutions

Problem Summary

Analysis

Code

Problem Summary

Analysis

Code

Problem Summary

Analysis

Code

Problem Summary

Analysis

Code

Problem Summary

Analysis

Code

Problem Summary

Analysis

Code

Implementation 1: deque + multiset

Implementation 2: Monotonic Queue

Problem Summary

Analysis

Code

Postscript

Luogu P9754 [CSP-S 2023] Struct Solution

Basic Approach

Step-by-Step Explanation

Preparation

Data Type Storage

Operation 1: Define Type

Operation 2: Define Element

Parentheses `()`

Square Brackets `[]`

Curly Braces `{}`

Double Brackets `[[]]`