AtCoder Beginner Contest 258 题解
AtCoder Beginner Contest 258 Solution
更好的阅读体验戳此进入
题面链接
题面 Luogu 链接
abcd 跳了
[ABC258E] Packing Potatoes
题面
给定序列 $ W $,下标范围为 $ [0, n - 1] $。存在一个长度为 $ 10^{100} $ 的土豆序列,循环节为 $ n $,第 $ i $ 个土豆的重量为 $ W_{(i - 1) \bmod{n}} $。现在你需要用箱子装土豆,每个箱子装满则停止,即土豆重量恰好大于等于 $ X $ 时则停止。$ Q $ 组询问求第 $ k_i $ 个箱子装了多少个土豆。
Solution
一道细节不少的找规律题。
首先不难发现,对于这个箱子,当你确定了从哪里开始装后,其最远能装到的位置也就确定了。我们考虑如何确定这个东西,不难想到做个前缀和然后二分,找到对应点开始的最长能取的长度,细节较多,如需要注意若长度仅为一初值需要判断。因为可能转回去所以可以将序列复制一份然后在这上面跑即可。
此时仍需要注意 $ X $ 可能很大以至于横跨多段,此处需要记录。此时我们即有 $ nxt $ 数组表示从该点开始取完土豆之后下一次需要从哪开始取。不难发现每个点有且仅有一条出边,则一定会成环,我们找到从 $ 1 $ 开始多少步后进入环,以及环长和每个位置的元素,最后对于每个询问判断一下是否进入环,未进入则直接调用,进入了则模一下找对应位置。中间细节很多,这道题本身的难度也就在细节上了,具体可以看代码。
复杂度卡在预处理上,最终复杂度 $ O(n \log n) $。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
template < typename T = int >
inline T read(void);
int N, Q, X;
int W[410000];
ll sum[410000];
int nxt[210000];
ll siz[210000];
ll lftans(0);
bitset < 210000 > vis;
int pos[210000];
int mark[210000];
int pre[210000];
int main(){
// freopen("in.txt", "r", stdin);
N = read(), Q = read(), X = read();
for(int i = 1; i <= N; ++i)sum[i] = sum[i - 1] + (W[i] = read());
copy(W + 1, W + N + 1, W + N + 1);
for(int i = N + 1; i <= N << 1; ++i)sum[i] = sum[i - 1] + W[i];
ll tot = sum[N];
lftans += ll(X / tot) * N;
X %= tot;
if(!X)lftans -= N, X += tot;
for(int i = 1; i <= N; ++i){
int l = i, r = N << 1, ans(i - 1);
while(l <= r){
int mid = (l + r) >> 1;
if(sum[mid] - sum[i - 1] < X)ans = mid, l = mid + 1;
else r = mid - 1;
}nxt[i] = ans += 2;
siz[i] = lftans + (nxt[i] - i);
if(nxt[i] > N)nxt[i] -= N;
}
queue < int > path;
int cur = 1, len = 0;
while(!vis[cur]){
path.push(cur);
vis[cur] = true;
mark[++len] = cur;
cur = nxt[cur];
}int cnt(0);
while(path.front() != cur)pre[++cnt] = path.front(), path.pop();
len = 0;
while(!path.empty())pos[++len] = path.front(), path.pop();
pos[0] = pos[len];
while(Q--){
ll K = read < ll >();
if(K <= cnt)printf("%lld\n", siz[pre[K]]);
else printf("%lld\n", siz[pos[(K - cnt) % len]]);
}
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
[ABC258F] Main Street
题面
你要在平面直角坐标系中行走,每一步可以上下左右四个方向任意移动 $ 1 $,耗时 $ k $ 秒。特别地,存在若干条快速通道,若该步起点和终点均满足 $ x \equiv 0 \pmod{B} $ 或 $ y \equiv 0 \pmod{B} $,则认为该步是在快速通道上进行,仅需耗时 $ 1 $ 秒。询问从 $ (S_x, S_y) $ 到 $ (G_x, G_y) $ 最少需要多少秒。存在多组数据。
Solution
显然可以选择直接走,或者走到起点附近的某个快速通道即终点附近的某个快速通道,共有 $ 4 \times 4 + 1 = 17 $ 中方案,枚举计算取一下最小值即可。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
template < typename T = int >
inline T read(void);
int B, K;
int Sx, Sy, Tx, Ty;
int main(){
int T = read();
while(T--){
B = read(), K = read();
Sx = read(), Sy = read(), Tx = read(), Ty = read();
pair < int, int > S[10] = {
{0, 0},
{Sx / B * B, Sy},
{Sx, int(ceil((double)Sy / B)) * B},
{int(ceil((double)Sx / B)) * B, Sy},
{Sx, Sy / B * B}
};
pair < int, int > T[10] = {
{0, 0},
{Tx / B * B, Ty},
{Tx, int(ceil((double)Ty / B)) * B},
{int(ceil((double)Tx / B)) * B, Ty},
{Tx, Ty / B * B}
};
ll ans = ll(abs(Sx - Tx) + abs(Sy - Ty)) * K;
for(int s = 1; s <= 4; ++s)
for(int t = 1; t <= 4; ++t)
ans = min(
ans,
abs(S[s].first - T[t].first) + abs(S[s].second - T[t].second) +
(
(ll)(abs(S[s].first - Sx) + abs(S[s].second - Sy)) * K +
(ll)(abs(T[t].first - Tx) + abs(T[t].second - Ty)) * K
)
);
printf("%lld\n", ans);
}
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
[ABC258G] Triangle
题面
给你一个简单的无向图,其中有 \(N\) 个顶点。用一个 的 \(N\times N\) 邻接矩阵 \(A\) 来表示。如果 \(A_{i,j}=1\) ,则表示 \(i\) 到 \(j\) 有边相连,如果 \(A_{i,j}=0\) ,则表示 \(i\) 到 \(j\) 无边相连。
求三角形 \((i,j,k)\) 的个数,满足 \(1\leq i < j < k\leq n\),且 \(i\) 与 \(j\) 有边相连,\(i\) 与 \(k\) 有边相连,\(j\) 与 \(k\) 有边相连。
Solution
枚举 $ i, j $,然后 $ k $ 可以通过 bitset
优化,最终复杂度 $ O(\dfrac{n^3}{w}) $。记得需要把邻接矩阵重复部分去掉。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
template < typename T = int >
inline T read(void);
int N;
ll ans(0);
bitset < 3100 > G[3100];
int main(){
N = read();
for(int i = 1; i <= N; ++i)for(int j = 1; j <= N; ++j){
char c = getchar(); while(!isdigit(c))c = getchar();
G[i][j] = c == '1' && j > i ? true : false;
}
for(int i = 1; i <= N; ++i)for(int j = i + 1; j <= N; ++j)
if(G[i][j])ans += (G[i] & G[j]).count();
printf("%lld\n", ans);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
[ABC258Ex] Odd Steps
题面
给定 $ n, S $ 和序列 $ A_n $,求任意长度的满足以下条件的序列个数:
- 仅由奇数组成。
- 所有数之和为 $ S $。
- 序列的任意前缀和均不能为 $ A_n $ 中任意数。
答案对 $ 998244353 $ 取模。
Solution
首先不考虑最后一个限制,则不难想到 DP,即设 $ dp(i) $ 表示和为 $ i $ 的合法序列个数,显然有转移:
然后发现转移为 $ O(S^2) $ 无法通过,但显然可以通过前缀和优化,即:
边界为 $ dp(0) = 1 $。
然后复杂度是 $ O(S) $ 的,无法通过,但显然可以通过矩阵优化:
矩阵快速幂优化即可。
然后对于第三个限制,我们只需要在维护的时候分段维护即可,每次维护到对应的 $ A_i $,然后令该次 $ dp(A_i) = 0 $,再接着转移下去即可。
最终复杂度 $ O(3^3 n \log S) $。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
#define MOD (998244353ll)
template < typename T = int >
inline T read(void);
int N;
ll S;
ll P[110000];
class Matrix3{
private:
public:
ll v[3][3];
Matrix3(ll v11 = 0, ll v12 = 0, ll v13 = 0, ll v21 = 0, ll v22 = 0, ll v23 = 0, ll v31 = 0, ll v32 = 0, ll v33 = 0){
v[0][0] = v11, v[0][1] = v12, v[0][2] = v13,
v[1][0] = v21, v[1][1] = v22, v[1][2] = v23,
v[2][0] = v31, v[2][1] = v32, v[2][2] = v33;
}
friend const Matrix3 operator * (const Matrix3 &a, const Matrix3 &b){
Matrix3 ret;
for(int i = 0; i <= 2; ++i)for(int j = 0; j <= 2; ++j)for(int k = 0; k <= 2; ++k)
(ret.v[i][j] += a.v[i][k] * b.v[k][j] % MOD) %= MOD;
return ret;
}
friend const Matrix3 operator ^ (const Matrix3 &a, ll b){
Matrix3 ret(1, 0, 0, 0, 1, 0, 0, 0, 1), mul(a);
while(b){
if(b & 1)ret = ret * mul;
b >>= 1;
mul = mul * mul;
}return ret;
}
};
int main(){
N = read(), S = read < ll >();
for(int i = 1; i <= N; ++i)P[i] = read < ll >();
Matrix3 base(1, 1, 0, 0, 0, 1, 1, 1, 0);
Matrix3 ans(1, 0, 0);
for(int i = 1; i <= N; ++i)ans = ans * (base ^ (P[i] - P[i - 1])), ans.v[0][0] = 0;
ans = ans * (base ^ (S - P[N]));
printf("%lld\n", ans.v[0][0]);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
UPD
update-2022_12_17 初稿