AtCoder Beginner Contest 012

A

Problem

输入两个整数，交换他们，然后输出。

B

Problem

给 $N (0 \leq N < 60 \times 60 \times 24) $ 秒，按 xx:xx:xx \(24\) 时时间格式格式输出。

一天内小时的多项式

\[N \equiv a_0 \times 60 \times 60 + a_1 \times 60 + a_2 \times 1 (\bmod 86400) \]

左填充 'c' 、宽度 2 ，输出 \(a_0:a_1:a_2\) 。

思考：年月日不能简单地用多项式表示，因为系数会变。

std::cout << std::setw(2) << std::setfill('2') << a[0];

Solutions

view

    int n; std::cin >> n;
    n %= 86400;
    int a[3] = {0};
    a[0] = n / 3600 % 24;
    a[1] = n / 60 % 60;
    a[2] = n % 60;
    for (int i = 0; i < 3; i++) {
        std::cout << std::setw(2) << std::setfill('0') << a[i] << ":\n"[i == 2];
    }

C

Problem

输入一个数 \(N\) ，它是九九乘法表每个乘法数对的和。但实际上它少算了某个数对，按字典序大小输出哪个数对可能被少算。

Solutions

\[\begin{aligned} &\sum_{i = 1}^{9} \sum_{j = 1}^{9} i \times j = \sum_{i = 1}^{9} i \sum_{j = 1}^{9} j = \binom{10}{2} \times \binom{10}{2} = (\frac{10 \times 9}{2})^{2} = 2025 \\ \Rightarrow &p \times q = 2025 - N = M \\ \end{aligned} \]

然后 \(O(\sqrt{M})\) 分解 \(M\) 的约数就做完了。（然后注意一下约数需要约束在 \([1, 9]\) ）

怎么线性排序？把分解第一遍的约数对 \((x, y)\) ，倒着 push 一遍 \((y, x)\) ，跳过相等的数对。

或者直接排序。

时间复杂度 \(O(\sqrt{M})\) 或 \(O(\sqrt{M} \log \sqrt{M})\) 。

view

    int n; std::cin >> n; n = 2025 - n;
    std::vector<std::array<int, 2> > ans;
    for (int i = 1; i * i <= n; i++) {
        if (n / i * i != n) continue;
        if (1 <= i && i <= 9 && 1 <= n / i && n / i <= 9)
            ans.push_back({i, n / i});
    }
    int m = ans.size();
    for (int i = 0; i < m; i++) {
        int x = ans[m - 1 - i][0], y = ans[m - 1 - i][1];
        if (x != y)
            ans.push_back({y, x});
    }
    m = ans.size();
    for (int i = 0; i < m; i++) {
        std::cout << ans[i][0] << " x " << ans[i][1] << "\n";
    }

D

Problem

给一个 \(n\) 个点 \(m\) 条边的简单无向图。询问哪个点到其他所有点的最短路径的最大值最小。

\(1 \leq n \leq 300, 1 \leq m \leq \binom{n}{2}\) 。

Solutions

先 \(O(n^{3})\) 跑个 Floyd ，算出全源最短路。然后 \(O(n)\) 枚举起点，\(O(n)\) 检查最短路的最大值，维护这个最大值的 \(min\) 。就做完了，注意邻接矩阵判一下是否联通。

view

    int n, m; std::cin >> n >> m;
    const i64 INF = 1LL << 60;
    auto chkmin = [&] (i64 &a, i64 b) { a = a < b ? a : b; };
    auto chkmax = [&] (i64 &a, i64 b) { a = a > b ? a : b; };
    std::vector<std::vector<i64> > G(n + 1, std::vector<i64>(n + 1, INF));
    for (int i = 1; i <= n; i++) G[i][i] = 0;
    for (int i = 1; i <= m; i++) {
        int u, v, w; std::cin >> u >> v >> w;
        G[u][v] == INF ? chkmin(G[u][v], w) : chkmax(G[u][v], w);
        G[v][u] = G[u][v];
    }
    std::vector<std::vector<i64> > dist{G.begin(), G.end()};
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (dist[i][k] != INF && dist[k][j] != INF) {
                    chkmin(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
    }
    i64 ans = INF;
    for (int i = 1; i <= n; i++) {
        i64 mx = -INF;
        for (int j = 1; j <= n; j++) if (j != i) {
            if (dist[i][j] != INF)
                chkmax(mx, dist[i][j]);
        }
        if (mx != -INF)
            chkmin(ans, mx);
    }
    std::cout << ans << "\n";