2024.11.26 CW 模拟赛

题面 & 题解

T1

原题链接

算法

树的直径, 贪心.

思路

考虑每一颗树, 它的最长链即为它的直径.

题目中输入一张图, 且保证无环, 那么可以考虑在每一颗树中求出直径.

最后将这些树拼起来即为最长链的长度.

#include "iostream"

using namespace std;

namespace FastIO
{
    template <typename T>
    inline void read(T &x)
    {
        x = 0;
        bool f = 0;
        char ch = getchar();
        while (ch < '0' or ch > '9')
        {
            if (ch == '-')
                f = 1;
            ch = getchar();
        }
        while (ch >= '0' and ch <= '9')
            x = x * 10 + ch - 48, ch = getchar();
        x = (f ? -x : x);
        return;
    }
    template <typename T, typename... Args>
    inline void read(T &x, Args &...args)
    {
        read(x), read(args...);
        return;
    }

    template <typename T>
    void print(T x)
    {
        if (x < 0)
            putchar('-'), x = -x;
        if (x > 9)
            print(x / 10);
        putchar(x % 10 + '0');
        return;
    }
}
using namespace FastIO;

constexpr int N = 1e5 + 10;

int n, m;
basic_string<int> g[N];

inline void init()
{
    read(n, m);
#pragma GCC unroll 8
    for (int i = 1; i <= m; ++i)
    {
        int u, v;
        read(u, v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    return;
}

int pos, mx;
bool vis[N];

void dfs(int u, int fa, int len)
{
    vis[u] = 1;
    if (len > mx)
    {
        mx = len;
        pos = u;
    }
    for (int v : g[u])
    {
        if (v == fa)
            continue;
        dfs(v, u, len + 1);
    }
    return;
}

inline void calculate()
{
    int ans = 0;
    for (int i = 1; i <= n; ++i)
        if (!vis[i])
        {
            pos = mx = 0;
            dfs(i, 0, 1);
            mx = 0;
            dfs(pos, 0, 1);
            ans += mx;
        }
    print(ans);
    return;
}

inline void solve()
{
    init();
    calculate();
    return;
}

int main()
{
    solve();
    return 0;
}

---

T2

原题链接

算法

二分, ST 表.

思路

直接暴力是 \(\mathcal{O}(n^2 \log n)\) 的, 不足以通过此题.

可以发现每一次 \(\gcd\) 变化至少都是折半(不可能从 3 变到 2 吧),

意思就是说一段区间的 \(\gcd\) 最多只会变化 \(\log_2 n\) 次.

同时, 如果固定左端点, 随着右端点的增大, 该段区间的 \(\gcd\) 一定单调不增.

那么就可以二分查找每次变化的位置, 更新答案.

那么如何得到一段区间的 \(\gcd\) 呢?

直接枚举肯定是不行的.
静态查询区间, 想到可以用 ST 表.

这样我们就可以用 \(\mathcal{O}(n \log^2 n)\) 的时间预处理出每一个区间的 \(\gcd\).

查询是 \(\mathcal{O}(\log n)\) 的.

因为还要枚举左端点的位置, 所以总的时间复杂度是 \(\mathcal{O}(n \log^2 n + n \log^3 n)\).

#include "iostream"
#include "algorithm"

using namespace std;

namespace FastIO
{
    template <typename T>
    inline void read(T &x)
    {
        x = 0;
        bool f = 0;
        char ch = getchar();
        while (ch < '0' or ch > '9')
        {
            if (ch == '-')
                f = 1;
            ch = getchar();
        }
        while (ch >= '0' and ch <= '9')
            x = x * 10 + ch - 48, ch = getchar();
        x = (f ? -x : x);
        return;
    }
    template <typename T, typename... Args>
    inline void read(T &x, Args &...args)
    {
        read(x), read(args...);
        return;
    }

    template <typename T>
    void print(T x)
    {
        if (x < 0)
            putchar('-'), x = -x;
        if (x > 9)
            print(x / 10);
        putchar(x % 10 + '0');
        return;
    }
}
using namespace FastIO;

constexpr int N = 1e6 + 1;

int n, k, h[N];
long long sum[N];

class ST
{

protected:
    int lg2[N];
    int f[20][N];

public:
    inline void init()
    {
        lg2[0] = -1;
        for (int i = 1; i <= n; ++i)
            lg2[i] = lg2[i >> 1] + 1, f[0][i] = h[i];
        for (int j = 0; j < lg2[n]; ++j)
            for (int i = 1; i + (2 << j) - 1 <= n; ++i)
                f[j + 1][i] = __gcd(f[j][i], f[j][i + (1 << j)]);
        return;
    }

    inline int query(int l, int r)
    {
        int x = lg2[r - l + 1];
        return __gcd(f[x][l], f[x][r - (1 << x) + 1]);
    }

} st;

inline void init()
{
    read(n, k);
    for (int i = 0; i ^ n; ++i)
    {
        read(h[i + 1]);
        sum[i + 1] = sum[i] + h[i + 1];
    }
    st.init();
    return;
}

long long ans = 0;

inline void calculate()
{
    for (int i = k; i <= n; ++i)
    {
        int x = 1, y = i;
        while (x <= y - k + 1)
        {
            int g = st.query(x, y);
            ans = max(ans, g * (sum[y] - sum[x - 1]));
            if (g == h[y])
                break;
            int l = x + 1, r = y, pos;
            while (l <= r)
            {
                int mid = l + r >> 1;
                if (st.query(mid, y) > g)
                    pos = mid, r = mid - 1;
                else
                    l = mid + 1;
            }
            x = pos;
        }
    }
    print(ans);
    return;
}

inline void solve()
{
    init();
    calculate();
    return;
}

int main()
{
    solve();
    return 0;
}

---

T4

题解