15.3 最大容量問題¶

Question

配列 \(ht\) が与えられ、各要素は垂直な仕切り板の高さを表します。配列内の任意の 2 枚の仕切り板と、その間の空間で容器を構成できます。

容器の容量は高さと幅の積（面積）に等しく、高さは短い方の仕切り板で決まり、幅は 2 枚の仕切り板の配列インデックスの差です。

配列から 2 枚の仕切り板を選び、構成される容器の容量が最大となるようにしてください。最大容量を返します。例を以下の図に示します。

最大容量問題のサンプルデータ

図 15-7 最大容量問題のサンプルデータ

容器は任意の 2 枚の仕切り板で囲まれるため、本問の状態は 2 枚の仕切り板のインデックスで表され、\([i, j]\) と記します。

問題の条件より、容量は高さと幅の積に等しく、高さは短い板で決まり、幅は 2 枚の仕切り板の配列インデックスの差です。容量を \(cap[i, j]\) とすると、計算式は次のようになります。

\[ cap[i, j] = \min(ht[i], ht[j]) \times (j - i) \]

配列の長さを \(n\) とすると、2 枚の仕切り板の組合せ数（状態総数）は \(C_n^2 = \frac{n(n - 1)}{2}\) 個です。最も直接的には、すべての状態を総当たりできます。これにより最大容量を求められ、時間計算量は \(O(n^2)\) です。

1. 貪欲戦略の決定¶

この問題にはさらに効率的な解法があります。以下の図のように、状態 \([i, j]\) を 1 つ選び、インデックスが \(i < j\) かつ高さが \(ht[i] < ht[j]\) を満たすとします。つまり、\(i\) が短い板、\(j\) が長い板です。

初期状態

図 15-8 初期状態

以下の図のように、このとき長い板 \(j\) を短い板 \(i\) に近づけると、容量は必ず小さくなります。

これは、長い板 \(j\) を動かした後は幅 \(j-i\) が必ず小さくなるためです。また、高さは短い板で決まるので、高さは変わらない（ \(i\) が依然として短い板）か、小さくなる（移動後の \(j\) が短い板になる）ことしかありません。

長い板を内側へ動かした後の状態

図 15-9 長い板を内側へ動かした後の状態

逆に考えると、短い板 \(i\) を内側へ縮めた場合にのみ、容量が大きくなる可能性があります。幅は必ず小さくなりますが、**高さは大きくなる可能性がある**からです（移動後の短い板 \(i\) がより長くなる可能性があります）。たとえば次の図では、短い板を動かした後に面積が大きくなっています。

短い板を内側へ動かした後の状態

図 15-10 短い板を内側へ動かした後の状態

以上から、本問の貪欲戦略を導けます。2 本のポインタを初期化して容器の両端に置き、各ラウンドで短い板に対応するポインタを内側へ縮め、2 本のポインタが出会うまで続けます。

以下の図は、貪欲戦略の実行過程を示しています。

初期状態では、ポインタ \(i\) と \(j\) は配列の両端にあります。
現在の状態の容量 \(cap[i, j]\) を計算し、最大容量を更新します。
板 \(i\) と板 \(j\) の高さを比較し、短い板を内側へ 1 マス移動します。
2. と 3. を繰り返し実行し、\(i\) と \(j\) が出会ったら終了します。

図 15-11 最大容量問題の貪欲な過程

2. コード実装¶

コードのループ回数は最大でも \(n\) 回であるため、時間計算量は \(O(n)\) です。

変数 \(i\)、\(j\)、\(res\) が使う追加領域は定数サイズなので、空間計算量は \(O(1)\) です。

PythonC++JavaC#GoSwiftJSTSDartRustCKotlinRuby

max_capacity.py

def max_capacity(ht: list[int]) -> int:
    """最大容量：貪欲法"""
    # i, j を初期化し、それぞれ配列の両端に置く
    i, j = 0, len(ht) - 1
    # 初期の最大容量は 0
    res = 0
    # 2 枚の板が出会うまで貪欲選択を繰り返す
    while i < j:
        # 最大容量を更新する
        cap = min(ht[i], ht[j]) * (j - i)
        res = max(res, cap)
        # 短い方を内側へ動かす
        if ht[i] < ht[j]:
            i += 1
        else:
            j -= 1
    return res

max_capacity.cpp

/* 最大容量：貪欲法 */
int maxCapacity(vector<int> &ht) {
    // i, j を初期化し、それぞれ配列の両端に置く
    int i = 0, j = ht.size() - 1;
    // 初期の最大容量は 0
    int res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        int cap = min(ht[i], ht[j]) * (j - i);
        res = max(res, cap);
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i++;
        } else {
            j--;
        }
    }
    return res;
}

max_capacity.java

/* 最大容量：貪欲法 */
int maxCapacity(int[] ht) {
    // i, j を初期化し、それぞれ配列の両端に置く
    int i = 0, j = ht.length - 1;
    // 初期の最大容量は 0
    int res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        int cap = Math.min(ht[i], ht[j]) * (j - i);
        res = Math.max(res, cap);
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i++;
        } else {
            j--;
        }
    }
    return res;
}

max_capacity.cs

/* 最大容量：貪欲法 */
int MaxCapacity(int[] ht) {
    // i, j を初期化し、それぞれ配列の両端に置く
    int i = 0, j = ht.Length - 1;
    // 初期の最大容量は 0
    int res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        int cap = Math.Min(ht[i], ht[j]) * (j - i);
        res = Math.Max(res, cap);
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i++;
        } else {
            j--;
        }
    }
    return res;
}

max_capacity.go

/* 最大容量：貪欲法 */
func maxCapacity(ht []int) int {
    // i, j を初期化し、それぞれ配列の両端に置く
    i, j := 0, len(ht)-1
    // 初期の最大容量は 0
    res := 0
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    for i < j {
        // 最大容量を更新する
        capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)
        res = int(math.Max(float64(res), float64(capacity)))
        // 短い方を内側へ動かす
        if ht[i] < ht[j] {
            i++
        } else {
            j--
        }
    }
    return res
}

max_capacity.swift

/* 最大容量：貪欲法 */
func maxCapacity(ht: [Int]) -> Int {
    // i, j を初期化し、それぞれ配列の両端に置く
    var i = ht.startIndex, j = ht.endIndex - 1
    // 初期の最大容量は 0
    var res = 0
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while i < j {
        // 最大容量を更新する
        let cap = min(ht[i], ht[j]) * (j - i)
        res = max(res, cap)
        // 短い方を内側へ動かす
        if ht[i] < ht[j] {
            i += 1
        } else {
            j -= 1
        }
    }
    return res
}

max_capacity.js

/* 最大容量：貪欲法 */
function maxCapacity(ht) {
    // i, j を初期化し、それぞれ配列の両端に置く
    let i = 0,
        j = ht.length - 1;
    // 初期の最大容量は 0
    let res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        const cap = Math.min(ht[i], ht[j]) * (j - i);
        res = Math.max(res, cap);
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i += 1;
        } else {
            j -= 1;
        }
    }
    return res;
}

max_capacity.ts

/* 最大容量：貪欲法 */
function maxCapacity(ht: number[]): number {
    // i, j を初期化し、それぞれ配列の両端に置く
    let i = 0,
        j = ht.length - 1;
    // 初期の最大容量は 0
    let res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        const cap: number = Math.min(ht[i], ht[j]) * (j - i);
        res = Math.max(res, cap);
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i += 1;
        } else {
            j -= 1;
        }
    }
    return res;
}

max_capacity.dart

/* 最大容量：貪欲法 */
int maxCapacity(List<int> ht) {
  // i, j を初期化し、それぞれ配列の両端に置く
  int i = 0, j = ht.length - 1;
  // 初期の最大容量は 0
  int res = 0;
  // 2 枚の板が出会うまで貪欲選択を繰り返す
  while (i < j) {
    // 最大容量を更新する
    int cap = min(ht[i], ht[j]) * (j - i);
    res = max(res, cap);
    // 短い方を内側へ動かす
    if (ht[i] < ht[j]) {
      i++;
    } else {
      j--;
    }
  }
  return res;
}

max_capacity.rs

/* 最大容量：貪欲法 */
fn max_capacity(ht: &[i32]) -> i32 {
    // i, j を初期化し、それぞれ配列の両端に置く
    let mut i = 0;
    let mut j = ht.len() - 1;
    // 初期の最大容量は 0
    let mut res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while i < j {
        // 最大容量を更新する
        let cap = std::cmp::min(ht[i], ht[j]) * (j - i) as i32;
        res = std::cmp::max(res, cap);
        // 短い方を内側へ動かす
        if ht[i] < ht[j] {
            i += 1;
        } else {
            j -= 1;
        }
    }
    res
}

max_capacity.c

/* 最大容量：貪欲法 */
int maxCapacity(int ht[], int htLength) {
    // i, j を初期化し、それぞれ配列の両端に置く
    int i = 0;
    int j = htLength - 1;
    // 初期の最大容量は 0
    int res = 0;
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        int capacity = myMin(ht[i], ht[j]) * (j - i);
        res = myMax(res, capacity);
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i++;
        } else {
            j--;
        }
    }
    return res;
}

max_capacity.kt

/* 最大容量：貪欲法 */
fun maxCapacity(ht: IntArray): Int {
    // i, j を初期化し、それぞれ配列の両端に置く
    var i = 0
    var j = ht.size - 1
    // 初期の最大容量は 0
    var res = 0
    // 2 枚の板が出会うまで貪欲選択を繰り返す
    while (i < j) {
        // 最大容量を更新する
        val cap = min(ht[i], ht[j]) * (j - i)
        res = max(res, cap)
        // 短い方を内側へ動かす
        if (ht[i] < ht[j]) {
            i++
        } else {
            j--
        }
    }
    return res
}

max_capacity.rb

### 最大容量：貪欲法 ###
def max_capacity(ht)
  # i, j を初期化し、それぞれ配列の両端に置く
  i, j = 0, ht.length - 1
  # 初期の最大容量は 0
  res = 0

  # 2 枚の板が出会うまで貪欲選択を繰り返す
  while i < j
    # 最大容量を更新する
    cap = [ht[i], ht[j]].min * (j - i)
    res = [res, cap].max
    # 短い方を内側へ動かす
    if ht[i] < ht[j]
      i += 1
    else
      j -= 1
    end
  end

  res
end

コードの可視化

全画面で見る >

3. 正しさの証明¶

貪欲法が総当たりより速いのは、各ラウンドの貪欲な選択がいくつかの状態を「スキップ」するためです。

たとえば状態 \(cap[i, j]\) において、\(i\) が短い板、\(j\) が長い板だとします。貪欲に短い板 \(i\) を内側へ 1 マス動かすと、次の図に示す状態が「スキップ」されます。これは、その後それらの状態の容量を検証できないことを意味します。

\[ cap[i, i+1], cap[i, i+2], \dots, cap[i, j-2], cap[i, j-1] \]

短い板の移動によってスキップされる状態

図 15-12 短い板の移動によってスキップされる状態

観察すると、これらのスキップされた状態は、実際には長い板 \(j\) を内側へ動かしたすべての状態そのものです。前述のとおり、長い板を内側へ動かすと容量は必ず小さくなります。つまり、スキップされた状態はいずれも最適解にはなりえず、それらを飛ばしても最適解を逃すことはありません。

以上の分析から、短い板を動かす操作は「安全」であり、貪欲戦略は有効であると分かります。

15.3 最大容量問題¶

1. 貪欲戦略の決定¶

2. コード実装¶

3. 正しさの証明¶

ご意見、ご質問、ご提案があればぜひコメントしてください