結果

問題 No.378 名声値を稼ごう
ユーザー CyanmondCyanmond
提出日時 2021-03-17 00:41:51
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 2 ms / 2,000 ms
コード長 4,478 bytes
コンパイル時間 6,307 ms
コンパイル使用メモリ 305,864 KB
実行使用メモリ 6,944 KB
最終ジャッジ日時 2024-04-27 03:44:39
合計ジャッジ時間 5,747 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,812 KB
testcase_01 AC 2 ms
6,940 KB
testcase_02 AC 2 ms
6,940 KB
testcase_03 AC 2 ms
6,940 KB
testcase_04 AC 2 ms
6,940 KB
testcase_05 AC 2 ms
6,944 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#pragma region library
#if defined(__GNUC__) && !defined(__llvm__) && !defined(__clang__)
#pragma GCC optimize("O3")
#pragma GCC target("avx512f")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#endif
#if __has_include(<atcoder/all>)
#include <atcoder/all>
#endif
#pragma region
#define itrall(x) std::begin(x), std::end(x)

#define rep32(i, l, r) for (int i = (int)(l); (i) < (int)(r); ++(i))
#define rep64(i, l, r) for (long long i = (long long)(l); i < (long long)(r); ++(i))
#define revrep32(i, r, l) for (int i = (int)(r); (i) >= (int)(l); --(i))
#define revrep64(i, r, l) for (long long i = (long long)(r); i >= (long long)(l); --(i))

using u32 = unsigned int;
using usize = size_t;
using index_t = size_t;
using i64 = long long;
using u64 = unsigned long long;
constexpr size_t operator "" _uz(unsigned long long v) { return static_cast<size_t>(v); }

template <class T> using Heap = std::priority_queue<T>;
template <class T> using RevHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T, class F> using SHeap = std::priority_queue<T, std::vector<T>, F>;

constexpr int dx[] = { 1, 0, -1, 0 };
constexpr int dy[] = { 0, 1, 0, -1 };

constexpr int INF32 = 1001001001;
constexpr long long INF64 = 1501501501501501501ll;

constexpr int mod = 1000000007;
constexpr int mod2 = 998244353;

#pragma endregion

template <class T, class U, class Comp = std::less<>>
constexpr bool chmin(T& xmin, const U& x, Comp comp = {}) noexcept {
  return comp(x, xmin) ? xmin = x, true : false;
}
template <class T, class U, class Comp = std::greater<>>
constexpr bool chmax(T& xmax, const U& x, Comp comp = {}) noexcept {
  return comp(x, xmax) ? xmax = x, true : false;
}
template <class type = size_t, class T> constexpr type len(const T& v) noexcept { return (type)(v.size()); }

namespace nlb {
  template <class T, class U> constexpr T Pow(T A, U B) {
    T res = 1;
    while (B) {
      if (B & 1) { res *= A; }
      A *= A; B >>= 1;
    }
    return res;
  }

  template <class T, class U, class M = int> constexpr T modpow(T A, U B, M MOD = 1000000007) {
    A %= MOD;
    T res = 1;
    while (B) {
      if (B & 1) { res *= A; res %= MOD; }
      A *= A; A %= MOD;
      B >>= 1;
    }
    return res;
  }

  template <class T, class M = int> constexpr T inverse(T A, const M MOD = 1000000007) {
    T B = MOD, U = 1, V = 0;
    while (B) {
      T t = A / B;
      A -= t * B; std::swap(A, B);
      U -= t * V; std::swap(U, V);
    }
    U %= MOD;
    return U < 0 ? U += MOD, U : U;
  }

  template <class T> constexpr T gcd(T A, T B) {
    while (B) {
      const T C = A;
      A = B;
      B = C % B;
    }
    return A;
  }

  template <class T> constexpr T lcm(const T A, const T B) { return A / gcd(A, B) * B; }

  template <class T> constexpr bool isprime(const T N) {
    if (N == 1) return false;
    for (T i = 2; i * i <= N; i++) if (N % i == 0) return false;
    return true;
  }

  inline std::tuple<long long, long long, long long> extgcd(const long long a, const long long b) {
    if (b == 0) return { a,1,0 };
    long long g, x, y;
    std::tie(g, x, y) = extgcd(b, a % b);
    return std::make_tuple(g, y, x - a / b * y);
  }

  inline std::pair<long long, long long> Chinese_Rem(const std::vector<long long>& b, const std::vector<long long>& m) {
    long long r = 0, M = 1;
    for (int i = 0; i < (int)b.size(); ++i) {
      long long p, q, d;
      std::tie(d, p, q) = extgcd(M, m[i]);
      if ((b[i] - r) % d != 0) return std::make_pair(0, -1);
      long long tmp = (b[i] - r) / d * p % (m[i] / d);
      r += M * tmp;
      M *= m[i] / d;
    }
    return std::make_pair((r % M + M) % M, M);
  }
}

class ProCon_all_init {
  static constexpr bool float_fixed = true;
  static constexpr int ios_perc = 15;
  static constexpr bool ios_fast = true;
  static constexpr bool auto_flush = false;
public:
  ProCon_all_init() {
    if (ios_fast) { std::cin.tie(nullptr); std::cout.tie(nullptr); std::ios::sync_with_stdio(false); }
    if (float_fixed) { std::cout << std::fixed << std::setprecision(ios_perc); }
    if (auto_flush) { std::cout << std::unitbuf; }
  }
} ProCon_;
#pragma endregion

class Problem {
public:

  void solve() {
    i64 N; std::cin >> N;
    std::vector<i64> Score;
    i64 sum = 0;

    while (N != 0) {
      Score.emplace_back(N);
      sum += N;
      N /= 2;
    }

    std::cout << Score[0] * 2 - sum << std::endl;
  }
};

int main(void) {
  Problem solver;
  solver.solve();
}
0