AtCoder Beginner Contest 258 题解

AtCoder Beginner Contest 258 Solution

目录

• AtCoder Beginner Contest 258 Solution
  • 更好的阅读体验戳此进入
  • 题面链接
  • 题面 Luogu 链接
    • • abcd 跳了
  • [ABC258E] Packing Potatoes
    • 题面
    • Solution
    • Code
  • [ABC258F] Main Street
    • 题面
    • Solution
    • Code
  • [ABC258G] Triangle
    • 题面
    • Solution
    • Code
  • [ABC258Ex] Odd Steps
    • 题面
    • Solution
    • Code
  • UPD

更好的阅读体验戳此进入

题面链接

题面 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 $ 的合法序列个数，显然有转移：

\[dp(i) = dp(i - 1)+ dp(i - 3) + dp(i - 5) + \cdots \]

然后发现转移为 $ O(S^2) $ 无法通过，但显然可以通过前缀和优化，即：

\[dp(i) = sum(i - 1) \]

\[sum(i) = sum(i - 2) \]

边界为 $ dp(0) = 1 $。

然后复杂度是 $ O(S) $ 的，无法通过，但显然可以通过矩阵优化：

\[\begin{bmatrix} dp(i - 1) & sum(i - 2) & sum(i - 3) \end{bmatrix} \begin{bmatrix} 1 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 0 \end{bmatrix} = \begin{bmatrix} dp(i) & sum(i - 1) & sum(i - 2) \end{bmatrix} \]

矩阵快速幂优化即可。

然后对于第三个限制，我们只需要在维护的时候分段维护即可，每次维护到对应的 $ 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 初稿