题意

给定一个长宽为 $a$ 和 $b$ 的目标矩形、一个宽高为 $h$ 和 $w$ 的初始矩形及 $n$ 个操作 $a_{i}$ 。对于每个操作，可以将初始矩形的宽或高乘以 $a_{i}$ ，求使目标矩形能放入初始矩形的最少操作（目标矩形可以旋转 90 度）。

解析

这题算是一道有趣的背包题。

由于 $a, b \leq 10^{5}$ ，不可能直接进行二维 dp。考虑到 $a_{i} \geq 2$ ，又有 $⌈ \log 10^{5} ⌉ = 17$ ，可以得出结论————至多只需要进行 34 个操作。

我们可以将操作数从大到小进行排序，设 $i$ 为当前进行第几个操作， $j$ 为初始矩形宽度， $d p_{i, j}$ 为进行到第 $i$ 个操作时初始矩形宽为 $j$ 时高最大为多少。则可以得到转移方程：

d p_{i, j \times a_{i}} = max (d p_{i - 1, j \times a_{i}} \times a_{i}, d p_{i - 1, j})

初始化 $d p_{0, w} = h$ 。当 $j \times a_{i} > max (a, b)$ 时，可以将 $j \times a_{i}$ 并入 $max (a, b)$ ，此做法不会对决策造成影响。

在每次计算转移之后对 $d p_{i, j \times a_{i}}$ 进行判定是否符合题目要求，若符合，输出当前的 $i$ 即为答案。要注意目标矩形可以做 90 度旋转（测试点 27 会卡）。

另外，观察每次转移时都只和 $i - 1$ 有关，且 $j < a_{i}$ ，可以用类似 01 背包的方式对数组进行滚动优化。

代码

#include <bits/stdc++.h>
#define LL long long
#define pii pair<int, int>
#define pll pair<LL, LL>

using namespace std;

vector<LL> dp(100005, 0);
LL a[100005];

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    LL h0, w0, h, w, n;
    cin >> h0 >> w0 >> h >> w >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];

    //判定是否已符合条件
    if (h >= h0 && w >= w0 || h >= w0 && w >= h0)
    {
        cout << "0\n";
        return 0;
    }

    sort(a + 1, a + n + 1, greater<LL>());
    if (h >= h0 || h >= w0 || w >= h0 || w >= w0) //判断有一条边已符合条件的情况
    {
        a[0] = 1;
        for (int i = 1; i <= n; i++)
            a[i] *= a[i - 1];

        int ans = n + 5;
        if (h >= h0)
        {
            for (int i = 1; i <= n; i++)
                if (w * a[i] >= w0)
                {
                    ans = min(ans, i);
                    break;
                }
        }
        if (h >= w0)
        {
            for (int i = 1; i <= n; i++)
                if (w * a[i] >= h0)
                {
                    ans = min(ans, i);
                    break;
                }
        }
        if (w >= h0)
        {
            for (int i = 1; i <= n; i++)
                if (h * a[i] >= w0)
                {
                    ans = min(ans, i);
                    break;
                }
        }
        if (w >= w0)
        {
            for (int i = 1; i <= n; i++)
                if (h * a[i] >= h0)
                {
                    ans = min(ans, i);
                    break;
                }
        }

        cout << (ans > n ? -1 : ans) << "\n";
        return 0;
    }

    dp[w] = h; //dp数组初始化
    for (int i = 1; i <= n; i++)
        for (int j = max(w0, h0); j >= w; j--)
        {
            dp[min(j * a[i], max(w0, h0))] = max(dp[j], dp[min(j * a[i], max(w0, h0))]);
            dp[j] *= a[i];
            if (j * a[i] >= w0 && dp[min(j * a[i], max(w0, h0))] >= h0 || j >= w0 && dp[j] >= h0) //判断正放目标矩形的情况
            {
                cout << i << "\n";
                return 0;
            }
            if (j * a[i] >= h0 && dp[min(j * a[i], max(w0, h0))] >= w0 || j >= h0 && dp[j] >= w0) //判断旋转目标矩形的情况
            {
                cout << i << "\n";
                return 0;
            }
        }

    cout << "-1\n";
}