【2024华为OD-E卷-100分-机房布局】（题目+思路+Java&C++&Python解析)

题目描述

机房布局

机房内有若干台服务器，每台服务器有一个固定大小的占地面积（长和宽）。机房的地面是一个二维平面，每个格子代表一个单位面积。你需要合理布局这些服务器，使得它们不重叠并且都在机房内。机房的大小是固定的，为 m x n 的网格。

输入

1. 第一行两个整数 m 和 n，表示机房的大小（m 行 n 列）。
2. 接下来一个整数 k，表示服务器的数量。
3. 接下来 k 行，每行两个整数 length 和 width，表示每台服务器的长和宽。

输出

输出一个整数，表示最多能放下多少台服务器。

约束条件

• 1 <= m, n <= 100
• 1 <= k <= 100
• 1 <= length, width <= 100

思路分析

这是一个典型的二维空间中的矩形放置问题。我们可以使用回溯算法（Backtracking）来解决这个问题。具体思路如下：

1. 定义状态：用一个二维数组 grid 表示机房的网格，初始时所有格子都为空（即值为 0）。
2. 递归函数：定义一个递归函数 backtrack(k, index, grid)，其中 k 是服务器总数，index 是当前处理的服务器编号（从 0 开始），grid 是当前机房的网格状态。
3. 尝试放置：对于每台服务器，遍历机房中的每一个可能的左上角位置 (i, j)，判断从 (i, j) 开始是否能完整放下该服务器（即 grid[i][j...i+length-1][j+width-1] 区域内全为 0）。
4. 更新状态：如果能放下，则将服务器的区域在 grid 中标记为 1（或其他非零值表示占用），并递归调用 backtrack 处理下一台服务器。
5. 回溯：如果当前服务器无法放下或者所有服务器都已处理完毕，则回溯，即恢复 grid 的状态并尝试其他位置。
6. 计数：用一个全局变量记录放置成功的最大服务器数量。

Java 编码解析

public class Main {
    private static int maxServers = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int k = scanner.nextInt();

        int[][] grid = new int[m][n];
        int[][] servers = new int[k][2];

        for (int i = 0; i < k; i++) {
            servers[i][0] = scanner.nextInt();
            servers[i][1] = scanner.nextInt();
        }

        backtrack(grid, servers, 0, k, m, n);
        System.out.println(maxServers);
    }

    private static void backtrack(int[][] grid, int[][] servers, int index, int k, int m, int n) {
        if (index == k) {
            maxServers = Math.max(maxServers, index);
            return;
        }

        for (int i = 0; i <= m - servers[index][0]; i++) {
            for (int j = 0; j <= n - servers[index][1]; j++) {
                if (canPlace(grid, servers[index], i, j, m, n)) {
                    placeServer(grid, servers[index], i, j);
                    backtrack(grid, servers, index + 1, k, m, n);
                    removeServer(grid, servers[index], i, j);
                }
            }
        }
    }

    private static boolean canPlace(int[][] grid, int[] server, int i, int j, int m, int n) {
        int length = server[0];
        int width = server[1];
        for (int x = i; x < i + length; x++) {
            for (int y = j; y < j + width; y++) {
                if (x >= m || y >= n || grid[x][y] == 1) {
                    return false;
                }
            }
        }
        return true;
    }

    private static void placeServer(int[][] grid, int[] server, int i, int j) {
        int length = server[0];
        int width = server[1];
        for (int x = i; x < i + length; x++) {
            for (int y = j; y < j + width; y++) {
                grid[x][y] = 1;
            }
        }
    }

    private static void removeServer(int[][] grid, int[] server, int i, int j) {
        int length = server[0];
        int width = server[1];
        for (int x = i; x < i + length; x++) {
            for (int y = j; y < j + width; y++) {
                grid[x][y] = 0;
            }
        }
    }
}

C++ 编码解析

#include <iostream>
#include <vector>

using namespace std;

int maxServers = 0;

bool canPlace(vector<vector<int>>& grid, const vector<int>& server, int i, int j, int m, int n) {
    int length = server[0];
    int width = server[1];
    for (int x = i; x < i + length; x++) {
        for (int y = j; y < j + width; y++) {
            if (x >= m || y >= n || grid[x][y] == 1) {
                return false;
            }
        }
    }
    return true;
}

void placeServer(vector<vector<int>>& grid, const vector<int>& server, int i, int j) {
    int length = server[0];
    int width = server[1];
    for (int x = i; x < i + length; x++) {
        for (int y = j; y < j + width; y++) {
            grid[x][y] = 1;
        }
    }
}

void removeServer(vector<vector<int>>& grid, const vector<int>& server, int i, int j) {
    int length = server[0];
    int width = server[1];
    for (int x = i; x < i + length; x++) {
        for (int y = j; y < j + width; y++) {
            grid[x][y] = 0;
        }
    }
}

void backtrack(vector<vector<int>>& grid, const vector<vector<int>>& servers, int index, int k, int m, int n) {
    if (index == k) {
        maxServers = max(maxServers, index);
        return;
    }

    for (int i = 0; i <= m - servers[index][0]; i++) {
        for (int j = 0; j <= n - servers[index][1]; j++) {
            if (canPlace(grid, servers[index], i, j, m, n)) {
                placeServer(grid, servers[index], i, j);
                backtrack(grid, servers, index + 1, k, m, n);
                removeServer(grid, servers[index], i, j);
            }
        }
    }
}

int main() {
    int m, n, k;
    cin >> m >> n >> k;

    vector<vector<int>> grid(m, vector<int>(n, 0));
    vector<vector<int>> servers(k, vector<int>(2));

    for (int i = 0; i < k; i++) {
        cin >> servers[i][0] >> servers[i][1];
    }

    backtrack(grid, servers, 0, k, m, n);
    cout << maxServers << endl;

    return 0;
}

Python 编码解析

def can_place(grid, server, i, j, m, n):
    length, width = server
    for x in range(i, i + length):
        for y in range(j, j + width):
            if x >= m or y >= n or grid[x][y] == 1:
                return False
    return True

def place_server(grid, server, i, j):
    length, width = server
    for x in range(i, i + length):
        for y in range(