#853734 (C++23) No.2506 Sum of Weighted Powers

• 問題: No.2506 Sum of Weighted Powers
• ユーザー: 👑 emthrm
• 提出日時: 2023-03-29 00:20:14
• 言語: C++23 (gcc 13.3.0 + boost 1.87.0)
• 結果: WA
• 実行時間: -
• コード長: 2,174 bytes
• コンパイル時間: 2,948 ms
• コンパイル使用メモリ: 166,768 KB
• 実行使用メモリ: 14,508 KB
• 最終ジャッジ日時: 2024-10-02 20:40:33
• 合計ジャッジ時間: 6,235 ms
• ジャッジサーバーID （参考情報）: judge3 / judge4

ファイルパターン	結果
other	AC * 5 WA * 37

ソースコード

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 <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
#include <atcoder/convolution>
#include <atcoder/modint>
using mint = atcoder::modint998244353;
// <嘘解法 (WA)>
// 943718401 とすべき法を 998244353 としている。
mint S(const int n, const mint& x,
       std::vector<mint> a, std::vector<mint> b, std::vector<mint> c) {
  assert(n == std::ssize(a) - 1 &&
         n == std::ssize(b) - 1 &&
         n == std::ssize(c) - 1);
  if (x == 0) {
    mint s = 0;
    s += std::inner_product(a.begin(), a.end(), b.begin(), mint::raw(0)) * c[0];
    s += std::inner_product(std::next(a.begin()), a.end(),
                            std::next(c.begin()), mint::raw(0)) * b[0];
    return s;
  }
  const auto MakeWeights = [n](mint base) -> std::vector<mint> {
    base *= base;
    mint single_exp = 1, double_exp = 1;
    std::vector<mint> weights(n + 1, 1);
    for (int i = 0; i < n; ++i) {
      double_exp *= single_exp;
      single_exp *= base;
      weights[i + 1] = weights[i] * double_exp;
    }
    return weights;
  };
  std::ranges::transform(a, MakeWeights(x), a.begin(), std::multiplies<mint>());
  const std::vector<mint> weights_inv = MakeWeights(x.inv());
  std::ranges::transform(b, weights_inv, b.begin(), std::multiplies<mint>());
  std::ranges::transform(c, weights_inv, c.begin(), std::multiplies<mint>());
  const std::vector<mint> s = atcoder::convolution(b, c);
  return std::inner_product(a.begin(), a.end(), s.begin(), mint::raw(0));
}
int main() {
  constexpr int kMaxN = 200000;
  const auto GetMint = []() -> mint {
    int x;
    std::cin >> x;
    assert(0 <= x && x < mint::mod());
    return mint::raw(x);
  };
  int n;
  std::cin >> n;
  assert(0 <= n && n <= kMaxN);
  const mint x = GetMint();
  std::vector<mint> a(n + 1), b(n + 1), c(n + 1);
  std::ranges::for_each(a, [GetMint](mint& x) -> void { x = GetMint(); });
  std::ranges::for_each(b, [GetMint](mint& x) -> void { x = GetMint(); });
  std::ranges::for_each(c, [GetMint](mint& x) -> void { x = GetMint(); });
  std::cout << S(n, x, a, b, c).val() << '\n';
  return 0;
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX