C++ 堆放木板 有n块木板,每块木板有长度li和重量wi,现在要把这些木板分成两堆a和b (允许空堆)

**解决方案**
由于需要将木板分成两堆，并且要求最小化最大长度和最大重量的和，我们可以使用动态规划来解决这个问题。我们可以用一个二维数组dp来保存中间结果，其中dp[i][j]表示使用前i块木板时，长度的最大值Max(li) + 重量的最大值Max(wi)的最小值。

算法的具体步骤如下：

1. 遍历所有的木板，将它们按照长度进行排序。
2. 初始化二维数组dp，将dp的所有元素初始化为无穷大。
3. 设置dp[0][0]=0，表示没有木板时长度和重量的最大值为0。
4. 从第一个木板开始遍历，对于每个木板，进行以下操作：
   1. 计算当前木板的长度和重量的最大值为max_length和max_weight。
   2. 对于每个可能的堆a和b的长度和重量的最大值max_total，更新dp[i][j]为dp[i-1][j-max_total]+max_total，表示使用当前木板后长度和重量的最大值最小为dp[i-1][j-max_total]+max_total。
5. 遍历所有的木板后，最终的结果为dp[n][0]，其中n表示木板的总数。

下面是该问题的C++代码实现：

```cpp
#include <iostream>
#include <algorithm>
#include <cmath>
#include <climits>
using namespace std;

const int MAX_N = 100000;
const int MAX_L = 1000000000;

int solve(int n, pair<int, int> boards[]) {
    // Sort the boards by length
    sort(boards, boards + n);

    // Initialize the dp array
    int dp[n + 1][MAX_N + 1];
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= MAX_N; j++) {
            dp[i][j] = INT_MAX;
        }
    }

    // Set the base case
    dp[0][0] = 0;

    // Compute the dp values
    for (int i = 1; i <= n; i++) {
        int max_length = boards[i - 1].first;
        int max_weight = boards[i - 1].second;

        for (int j = 0; j <= MAX_N; j++) {
            int max_total = min(max_length, j);
            dp[i][j] = min(dp[i][j], dp[i - 1][j - max_total] + max_total);
            dp[i][j] = min(dp[i][j], dp[i - 1][j] + max_weight);
        }
    }

    // Find the minimum value of the dp array
    int min_total = INT_MAX;
    for (int j = 0; j <= MAX_N; j++) {
        min_total = min(min_total, dp[n][j]);
    }

    return min_total;
}

int main() {
    int t;
    cin >> t;

    for (int i = 0; i < t; i++) {
        int n;
        cin >> n;

        pair<int, int> boards[n];
        for (int j = 0; j < n; j++) {
            cin >> boards[j].first >> boards[j].second;
        }

        int result = solve(n, boards);
        cout << result << endl;
    }

    return 0;
}