HDU1068——Girls and Boys，HDU1069——Monkey and Banana，HDU1070——Milk

目录

HDU1068——Girls and Boys

题目描述

​编辑​编辑 运行代码

代码思路

HDU1069——Monkey and Banana

题目描述

运行代码

代码思路

HDU1070——Milk

题目描述

运行代码

代码思路

HDU1068——Girls and Boys

题目描述

Problem - 1068

 运行代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int k;
int vis[515];
int fr[515][515];
int f[515];

bool find(int x)
{
    for (int i = 0; i < k; i++)
    {
        if (!vis[i] && fr[x][i])
        {
            vis[i] = true;
            if (f[i] == -1 || find(f[i]))
            {
                f[i] = x;
                return true;
            }
        }
    }
    return false;
}

int main()
{
    int a, b;
    int ans;
    while (~scanf_s("%d", &k))
    {
        memset(f, -1, sizeof(f));
        memset(fr, false, sizeof(fr));
        for (int i = 0; i < k; i++)
        {
            scanf_s("%d: (%d)", &a, &b);
            while (b--)
            {
                int t;
                scanf_s("%d", &t);
                fr[a][t] = true;
                fr[t][a] = true;
            }
        }
        ans = 0;
        for (int i = 0; i < k; i++)
        {
            memset(vis, false, sizeof(vis));
            if (find(i))
                ans++;
        }
        ans = k - (ans / 2);
        printf("%d\n", ans);
    }
    return 0;
}

代码思路

1. 程序的主要目的是解决一个匹配问题，并计算最终的结果。
2. 在 main 函数中，通过循环不断读取输入的 k 值，并进行后续处理。

函数 find：

1. 这是一个用于查找匹配的递归函数。
2. 遍历从 0 到 k - 1 的每个位置。
3. 如果某个位置 i 未被访问过（!vis[i]）且与当前节点 x 存在连接（fr[x][i]），则将其标记为已访问（vis[i] = true）。
4. 然后检查该位置对应的匹配值 f[i]：
   • 如果 f[i] 为 -1，表示当前位置没有匹配，将 x 与 i 进行匹配，并返回 true。
   • 如果 f[i] 不为 -1，则递归调用 find(f[i]) 尝试重新匹配已匹配的节点，如果递归调用返回 true，则更新匹配并返回 true。

main 函数：

1. 首先读取一个 k 值。
2. 初始化 f 数组为 -1，fr 数组为 false。
3. 然后通过循环读取每个节点的连接信息。
4. 初始化匹配结果 ans 为 0 。
5. 再次通过循环，对每个节点调用 find 函数进行匹配尝试，并根据结果增加 ans 的值。
6. 最后计算并输出最终的结果 ans = k - (ans / 2) 。

HDU1069——Monkey and Banana

题目描述

Problem - 1069

运行代码

#include <iostream>
#include <algorithm>
#include <vector>

#define _ sync_with_stdio(false)
typedef long long ll;

struct Block {
    int x, y, z;
};

bool compareBlocks(const Block& b1, const Block& b2) {
    if (b1.y == b2.y)
        return b1.x > b2.x;
    return b1.y > b2.y;
}

int main() {
    int n;
    int caseNumber = 1;
    while (std::cin >> n && n) {
        std::vector<Block> blocks;
        int x, y, z;
        for (int i = 1; i <= n; ++i) {
            std::cin >> x >> y >> z;
            blocks.push_back({ x, y, z });
            blocks.push_back({ x, z, y });
            blocks.push_back({ y, x, z });
            blocks.push_back({ y, z, x });
            blocks.push_back({ z, x, y });
            blocks.push_back({ z, y, x });
        }
        std::sort(blocks.begin(), blocks.end(), compareBlocks);

        std::vector<int> dp(blocks.size(), 0);
        int res = 0;
        for (size_t i = 0; i < blocks.size(); ++i) {
            dp[i] = blocks[i].z;
            for (size_t j = 0; j < i; ++j) {
                if (blocks[j].x > blocks[i].x && blocks[j].y > blocks[i].y) {
                    dp[i] = std::max(dp[i], dp[j] + blocks[i].z);
                }
            }
            res = std::max(res, dp[i]);
        }
        std::cout << "Case " << caseNumber++ << ": maximum height = " << res << std::endl;
    }
    return 0;
}

代码思路

1. 程序通过一个循环不断处理输入的测试用例。只要输入的 n 不为 0，就进行处理。
2. 对于每个测试用例，读取每种类型积木的尺寸，并生成所有可能的排列（通过循环将每个尺寸的不同组合都放入 blocks 向量中）。
3. 对 blocks 向量按照自定义的比较规则（先比较 y ，若 y 相同再比较 x ）进行排序。
4. 创建一个与 blocks 向量大小相同的 dp 向量，用于存储以每个积木为顶部时所能达到的最大高度。
5. 通过两层循环计算 dp 向量的值。外层循环遍历每个积木，内层循环找到所有能放在当前积木下方的积木，并更新当前积木对应的最大高度。
6. 最终找到 dp 向量中的最大值作为结果输出。

函数和结构体：

• Block 结构体：用于表示积木的三个维度 x、y、z。
• compareBlocks 函数：用于定义积木排序的规则。

HDU1070——Milk

题目描述

Problem - 1070

运行代码

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

struct Milk {
    std::string brand;
    int volume;
    double costPerDay;

    Milk(std::string b, int v, double c) : brand(b), volume(v), costPerDay(c) {}
};

bool compare(const Milk& a, const Milk& b) {
    return a.costPerDay == b.costPerDay ? a.volume > b.volume : a.costPerDay > b.costPerDay;
}

int main() {
    int T;
    std::cin >> T;

    while (T--) {
        int N;
        std::cin >> N;

        std::vector<Milk> milks;
        int P;
        for (int i = 0; i < N; ++i) {
            std::string brand;
            int volume;
            std::cin >> brand >> P >> volume;

            int day;
            if (volume > 1000) {
                day = 5;
            }
            else {
                day = volume / 200;
            }
            if (day != 0) {
                double costPerDay = 1.0 * day / P;
                milks.emplace_back(brand, volume, costPerDay);
            }
        }

        std::sort(milks.begin(), milks.end(), compare);

        std::cout << milks[0].brand << std::endl;
    }

    return 0;
}

代码思路

整体流程：

1. 程序首先读取测试用例的数量 T 。
2. 对于每个测试用例：
   • 读取牛奶种类的数量 N 。
   • 然后通过一个循环读取每种牛奶的品牌、价格和体积。
   • 根据体积计算可以喝的天数 day ，如果 day 不为 0 ，计算每天的成本 costPerDay ，并创建一个 Milk 对象放入 milks 向量中。
3. 对 milks 向量按照自定义的比较规则（先比较每天成本，若相同则比较体积）进行排序。
4. 输出排序后的第一个元素（即最便宜且体积最大的牛奶品牌）。

结构体和比较函数：

• Milk 结构体用于存储牛奶的品牌、体积和每天的成本。
• compare 函数用于定义牛奶对象的比较规则，以便进行排序操作。