けんちょんの競プロ精進記録

競プロの精進記録や小ネタを書いていきます

AtCoder ABC 246 D - 2-variable Function (緑色, 400 点)

前回の ABC に続いて、D 問題が数学っぽい。でも実際には今回は探索問題ですね。

問題概要

非負整数  a, b を用いて

 X = a^{3} + a^{2}b + a b^{2} + b^{3}

と表せる整数  X を「特別数」と呼ぶことにします。

非負整数  N が与えられますので、 N 以上である最小の「特別数」を求めてください。

制約

  •  0 \le N \le 10^{18}

変数が複数あるときは 1 つを固定する

見た目は確かに数学色の強い問題だけど、考えるべき基礎は決して特別なものではない。

このように  a, b という 2 つの変数が絡む問題で考えるべきことは、1 つの変数を固定して考えるというもの。

ここでは  a を固定してみよう。たとえば  a = 5 としたとしてみよう。このとき、

 X = b^{3} + 5 b^{2} + 25 b + 125

となる。これが  N 以上となるような最小の  b を求めたいと思ったら、それはまさに二分探索法がどんぴしゃだ!!

つまり次のように求められる。

// 式計算
long long func(long long a, long long b) {
    return a*a*a + a*a*b + a*b*b + b*b*b;
}

// a を固定したときの N 以上の最小の特別数を求める
long long solve(long long a) {
    long long low = -1, high = (十分大きな値);
    while (high - low > 1) {
        long long b = (low + high) / 2;
        if (func(a, b) >= N) high = b;
        else low = b;
    }
    return func(a, high);
}

変数の範囲を考える

最後に検討すべきことは以下の 2 点だ

  • 変数  a の調べるべき範囲
  • 変数  a を固定したとき、二分探索法の初期値の決め方

これを考える前に、 X = 10^{18} が「特別数」であることを確認しよう。具体的には  a = 10^{6},  b = 0 としたとき

 a^{3} + a^{2} b + a b^{2} + b^{3} = 10^{18}

となるのだ。よって  N \le 10^{18} という制約を考えると、 N 以上の最小の特別数が  10^{18} より大きくなる可能性は考えなくて良いのだ!!!

そのことから、 a \gt 10^{6} の範囲を調べる必要がないことが言える。なぜなら  a \gt 10^{6} とすると

 a^{3} + a^{2} b + a b^{2} + b^{3} \ge a^{3} \gt 10^{18}

となるためだ。 10^{18} より大きくなる範囲は考慮不要なので、 a \gt 10^{6} は考えなくてよい。

同様に  a を固定したとき、 a^{3} + a^{2} b + a b^{2} + b^{3} N 以上となる最小の  b を求めるための二分探索法の上限値も、 10^{6} より大きく取る必要はない!!

以上より、次の結論が言える


  • 変数  a 0, 1, 2, \dots, 10^{6} まで調べれば十分
  • 変数  a を固定したとき、二分探索法の上限値の初期値は  10^{6} とすればよい

計算時間的にも十分に間に合う。一応計算量をちゃんと書くと、 O(N^{\frac{1}{3}} \log N) と評価できる。

コード

#include <bits/stdc++.h>
using namespace std;

long long func(long long a, long long b) {
    return a*a*a + a*a*b + a*b*b + b*b*b;
}

long long solve(long long N, long long a) {
    long long low = -1, high = 1000000;
    while (high - low > 1) {
        long long b = (low + high) / 2;
        if (func(a, b) >= N) high = b;
        else low = b;
    }
    return func(a, high);
}

int main() {
    long long N;
    cin >> N;

    long long res = 1000000000000000000LL;  // 10^18 が上限値
    for (long long a = 0; a <= 1000000; ++a) {
        res = min(res, solve(N, a));
    }
    cout << res << endl;
}

 

別解:尺取り法

上述の「変数固定 + 二分探索」が比較的思いつきやすいと思う。一方そのような問題の多くは、尺取り法でも解けることが多いと思う。

そうすると計算量は  O(N^{\frac{1}{3}}) に落ちる。注目することは

  •  a を増やしていくとき、
  •  a^{3} + a^{2} b + a b^{2} + b^{3} N 以上となるような最小の  b は単調減少していく

ということだ。よって、 a を増やしながら、 b を減らしていくという「尺取り法」で十分高速に解ける。詳しくは公式解説へ!!

atcoder.jp

AtCoder ABC 246 C - Coupon (灰色, 300 点)

ソートが必要になるところが少し難しいかもしれない。

問題概要

 N 個の商品があって、それぞれ  A_{1}, A_{2}, \dots, A_{N} 円である。

またクーポンが  K 枚あって、1 枚のクーポンを使って次のことができる。

  • 商品を 1 つ選ぶ
  • その商品の価格を  X 円減少させる
  • ただしもとの価格が  X 円未満の場合は、0 円にする

クーポンを効率よく活用したとき、 N 個の商品をすべて購入するのに要する最小費用を求めよ。

制約

  •  1 \le N \le 2 \times 10^{5}
  •  1 \le K \le 10^{9}

手を動かしてみる

まずは手を動かして問題の様子をつかんでみよう。たとえば  A = (12, 16, 18) K = 10,  X = 5 としてみよう。

このとき、たとえばまず 1 個目の商品にクーポンを適用してみよう。そうすると 2 回適用することで価格は、

12 → 7 → 2

となる。このときさらにクーポンを適用するのは少しもったいない。なぜならその場合、

  • 1 回目のクーポンによる価格減少分は、12 → 7 で「-5」
  • 2 回目のクーポンによる価格減少分は、7 → 2 で「-5」
  • 3 回目のクーポンによる価格減少分は、2 → 0 で「-2」

ということになる。1, 2 回目は「-5」を達成したのに対して、3 回目は「-2」にとどまってしまう。

それをするくらいなら、2 個目の商品の 16 円にクーポンを適用した方がいい。そうすることで「-5」の達成を継続できる。

 

最後のあまりを処理

以上の話を一般化しよう。一般に「$-X$ 円」を達成できるところを優先的に減らしていこう。具体的には、各  A_{i} に対して、A[i] / X (あまりを切り捨てた値) の総和回だけ「$-X$ 円」を実施できることになる。

この総和を  S としたとき、もし  S \ge K ならば、 K 回のクーポンはすべて「$-X$ 円」を達成できるので、それが答えになる。

よって  S \lt K の場合を考えよう。この場合、まずは「$-X$ 円」を達成できる部分は使い切ってしまおう。そうすると

  • K -= S
  • i に対して A[i] %= X

という状態になったものと考えてよい。たとえば  A = (12, 16, 18),  K = 10,  X = 5 のとき、下図のように、 A = (2, 1, 3) K = 2 の問題に帰着される。

こうなったら、余ったクーポンを有効活用するために、「減らせる金額が大きいところを優先的に使っていく」のがよいと言える。具体的には次のように求められる。


  • 配列 A (あまりを取った値) を大きい順にソートして
  • 大きい順に  K 個を 0 にする (ただし  K \ge N の場合はすべて 0 にして終了)
  • 残った A の総和が答え

計算量は「ソート」に最も時間がかかるので、 O(N \log N)

 

コード

#include <bits/stdc++.h>
using namespace std;

long long solve() {
    // 入力 (sum は最初の総額)
    long long N, K, X, sum = 0;
    cin >> N >> K >> X;
    vector<long long> A(N);
    for (int i = 0; i < N; ++i) cin >> A[i], sum += A[i];

    // 「-X」を適用できるところを先に適用してしまう
    long long S = 0;
    vector<long long> amari(N);
    for (int i = 0; i < N; ++i) {
        S += A[i] / X;
        A[i] %= X;
    }

    // S >= K のときはすべてのクーポンを
    if (S >= K) return sum - K * X;

    // K > S のときは、減らせる金額が大きいところを優先的に
    K -= S;
    sort(A.begin(), A.end(), greater<long long>());
    for (int i = 0; i < min(N, K); ++i) A[i] = 0;
    long long res = 0;
    for (int i = 0; i < N; ++i) res += A[i];
    return res;
}

int main() {
    cout << solve() << endl;
}

類題情報

似た感じで解ける問題!

drken1215.hatenablog.com

JOIG 2021 D - 展覧会 2 (AOJ 0704, 難易度 6)

競プロ典型 90 問 001 - Yokan Party」とよく似た問題!

前提知識

問題概要

 N 枚の絵が一直線上に順に並んでいます。 i 枚目の絵は座標  X_{i} の位置にあり、その価値は  V_{i} です。

今これらの絵から  M 枚の絵を選びます。このとき次の制約を満たさなければなりません。

  • どの 2 枚の絵も、距離が  D 以上離れなれければならない

「選んだ  M 枚の絵の価値の最小値」として考えられる最大値を求めてください。ただし制約条件を満たすように  M 枚を選ぶことが不可能である場合は -1 と出力してください。

制約

  •  1 \le M \le N \le 10^{5}

判定問題に帰着する

今回の問題は「最小値を最大化してください」という問題になっています。そのように「最大値を最小化」や「最小値や最大化」な問題では、二分探索法が有効なことが多いですね。まずは今回の問題を判定問題化*してみましょう!


選んだすべての絵の価値が  x 以上となるように、 M 枚の絵を選べるかどうかを判定してください。ただしどの 2 枚の絵の間隔も  D 以上離す必要があります。


 x が小さいときは "Yes" になります (ならないことも) し、 x が大きいときは "No" になります。二分探索法によってその境界が特定できます

この判定の問題の答えが "Yes" となる最大の  x が答えです。

具体的には次のコードのようにできます。絵の間隔としてありうる最大値を  Y として、二分探索法の反復回数は  O(\log Y) 回となります。

long long low = -1, high = 1LL<<30;
while (high - low > 1) {
    long long x = (low + high) / 2;
    if (絵の価値をすべて x にできる) low = x;
    else high = x;
}
return x;

 

判定問題を解く

まずは絵を左から順に並び替えておきます。

このとき判定問題を解くのは、次のような Greedy 解法でできます。絵を左から順に見ていき、

  • 前回選んだ絵から距離が  D 以上離れている
  • 価値が  x 以上ある

という条件をともに満たす最左の絵を選ぶことを繰り返していけばよいでしょう。そのように絵を選んでいき、 M 枚選べたら "Yes"、 M 枚に達しないうちに絵の右端に達してしまったら "No" と判定できます。

具体的な処理については、下のコードを参考にしましょう。判定問題を解くのは  O(N) の計算量でできます。

よって全体として  O(N (\log N + \log Y)) の計算量で解けます。

コード

そもそも  M 枚を選べない場合もあります。その場合であっても下のコードのように low = -1 と初期化しておくことで統一的に解けます。

#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL<<40;

int main() {
    long long N, M, D;
    cin >> N >> M >> D;
    vector<long long> X(N), V(N);
    for (int i = 0; i < N; ++i) cin >> X[i] >> V[i];

    // 一直線上に左から順に並び替える (ここでは id を並び替える)
    vector<int> ids(N);
    iota(ids.begin(), ids.end(), 0);
    sort(ids.begin(), ids.end(), [&](int i, int j) {
        return X[i] < X[j];
    });

    // 二分探索
    long long low = -1, high = INF;
    while (high - low > 1) {
        long long x = (low + high) / 2;

        int con = 0;  // 選んだ枚数
        long long prev = -INF;  // 最後に選んだ絵の位置
        for (auto id : ids) {
            if (X[id] - prev >= D && V[id] >= x) {
                ++con; 
                prev = X[id];
            }
        }
        if (con >= M) low = x;
        else high = x;
    }
    cout << low << endl;
}

JOIG 2021 C - イルミネーション 2 (AOJ 0703, 難易度 4)

落ち着いて整理して考えましょう。問題自体は「累積和」が使える良い問題ですね!

問題概要

 N 個の電球を一列に並べていて、オンオフ状態が  A_{1}, A_{2}, \dots, A_{N} であるような状態を作りたいとします。ただし  A_{i} = 1 i 番目の電球をオンにしたいことを表し、 A_{i} = 0 i 番目の電球をオフにしたいことを表します。

初期状態では、すべての電球がオフの状態です。あなたはまず、左から連続する何個かの電球をオンにすることができます。すべてオフのままでもよいですし、すべてをオンにしてもよいです。

その後、1 つの電球のオンオフ操作 (オンの電球はオフにして、オフの電球はオンにする) を実行していきます。このオンオフ操作の回数として考えられる最小値を答えてください。

制約

  •  1 \le N \le 2 \times 10^{5}

問題を整理する

まず、「最初に左から何個分の電球をオンにするか」を決めると、その後の操作回数が決まることに注意しましょう。たとえば

  •  A = (0, 1, 1, 0, 0, 1) に対して、
  • 左から 4 個分の電球をあらかじめオンにする

としたとしましょう。このとき操作回数は  A = (0, 1, 1, 0, 0, 1) (1, 1, 1, 1, 0, 0) とを比較して、相異なる箇所の個数に一致します。この場合は 3 回です。

0 1 1 0 0 1
1 1 1 1 0 0

よってまず次のような解法が考えられるでしょう。

  • 「最初にオンにする電球の個数」を全探索して、
  • それぞれについて「相異なる箇所の個数」を調べる

しかしこれは  O(N^{2}) の計算量となり、満点は得られません。

前処理で高速化

このようなとき、前処理で高速化するのが有効です。今回は次のような配列を用意しましょう。

  • left[i] A_{1}, A_{2}, \dots, A_{N} のうち、左から  i 個分の中の、オフである電球の個数
  • right[j] A_{1}, A_{2}, \dots, A_{N} のうち、右から  j 個分の中の、オンである電球の個数

これらの配列自体は  O(N) の計算量で計算できます。そしてこれらの配列が求められていると、なんと先ほどの探索が簡単に実行できます。

「最初に左から連続でオンにする個数」を  i 個としたとき、その後の必要な操作回数は

left[i] + right[N-i]

と簡単に表せるのです!! たとえば先ほどの例 ( A = (0, 1, 1, 0, 0, 1) i = 4) の場合、下図のようになります。

よって次の解法で答えが求められます。今度は「最初に左から連続でオンにする個数」を決めたときの操作回数が  O(1) で求められるので、計算量は  O(N) となります。


  1. 配列 leftright を求める
  2. i = 0, 1, ..., N に対する left[i] + right[N-i] の最小値を求める

コード

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N;
    cin >> N;
    vector<int> A(N);
    for (int i = 0; i < N; ++i) cin >> A[i];

    // 前処理
    vector<int> left(N+1, 0), right(N+1, 0);
    for (int i = 0; i < N; ++i) {
        left[i+1] = left[i] + (A[i] == 0);
        right[i+1] = right[i] + (A[N-i-1] == 1);
    }

    // 最適化
    int res = N;  // 理論上の上限値
    for (int i = 0; i <= N; ++i) {
        res = min(res, left[i] + right[N-i]);
    }
    cout << res << endl;
}

AtCoder ABC 245 E - Wrapping Chocolate (水色, 500 点)

これ!!!
ABC 091 C - 2D Plane 2N Point とほとんど同じ!!
ただ制約が大きいので、貪欲法を高速化する必要がありますね。

問題概要

 N 個のチョコレートと、 M 個の箱があります。

  •  i 番目のチョコレートはサイズ  A_{i} \times B_{i} であり、
  •  j 番目の箱はサイズ  C_{j} \times D_{j} です

チョコレート  i は、 A_{i} \le C_{j} かつ  B_{i} \le D_{j} を満たすとき、箱  j に入れることができます。

すべてのチョコレートをいずれかの箱に入れた状態にすることができるかどうか判定してください。

ただし、1 つの箱には 1 つのチョコレートしか入れることができません。

制約

  •  1 \le N \le M \le 2 \times 10^{5}

貪欲法

貪欲法自体は、以前記事に書いたとおりです!!
最大マッチングを求めて、その値が  N に一致するかどうかを判定すればよいでしょう。

drken1215.hatenablog.com

箱を縦  C_{j} が小さい順に見ていきます。そして、チョコレートの縦  A_{i} C_{j} 以下であるようなチョコレートのうち、

「横の長さ  B_{i} D_{j} を超えない範囲で最大となるようなチョコレート  i

を選んで、そのチョコレート  i を箱  j に入れていきます。そのチョコレート  i は今後使えなくなります。

このアルゴリズムは、各箱に対して、該当するチョコレートを選ぼうとすると  O(NM) の計算量となります。このままでは間に合いません。

データ構造を使う

ここでは std::multiset を利用して高速化しましょう。

 j について考えているとき、 A_{i} \le C_{j} を満たすチョコレートについての  B_{i} をかきあつめた集合を multiset S で管理していたとします。

このとき、この集合の要素のうち、 D_{j} を超えない範囲で最大のものは S.upper_bound(D[j]) で取得できるイテレータをデクリメントすることで取得できます。

これによって全体の計算量は  O(N + M \log N) となります。

コード

#include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;

int main() {
    int N, M;
    cin >> N >> M;
    vector<pll> cho(N), box(M);
    for (int i = 0; i < N; ++i) cin >> cho[i].first;
    for (int i = 0; i < N; ++i) cin >> cho[i].second;
    for (int i = 0; i < M; ++i) cin >> box[i].first;
    for (int i = 0; i < M; ++i) cin >> box[i].second;

    // A, C が小さい順にソート
    sort(cho.begin(), cho.end());
    sort(box.begin(), box.end());

    // C が小さい順に見ていく
    multiset<int> S;
    int res = 0;
    int i = 0;
    for (int j = 0; j < M; ++j) {
        // A[i] <= C[j] となる範囲の i をすべて動かす
        while (i < N && cho[i].first <= box[j].first) {
            S.insert(cho[i].second);
            ++i;
        }

        // その範囲で最大値を取り出す
        if (S.empty()) continue;
        auto it = S.upper_bound(box[j].second);
        if (it == S.begin()) continue;
        --it;
        S.erase(it);
        ++res;
    }
    if (res == N) cout << "Yes" << endl;
    else cout << "No" << endl;
}