你这代码

#include <bits/stdc++.h>
using namespace std;
int main(){
    int a[10001],b[10001],som=0,m,n,i,j,q=0;
    cin>>m>>n;
    for(i=1;i<=n;i++){
        cin>>a[i]>>b[i];}
    for(i=1;i<n;i++){
        for(j=i+1;j<=n;j++){
            if(a[i]>a[j]){
                swap(a[i],a[j]);
                swap(b[i],b[j]);
}
    }}
    for(i=1;i<=n;i++){
        for(j=1;j<=b[i];j++){
            som+=a[i];
            if(som>=m)
            break;
            q++;}
    if(som>m)
            break;
    }
    cout<<q;
    return 0;
}

这段代码的目的是在给定的预算 m 下，购买尽可能多的物品。物品有单价和库存数量，代码通过贪心算法来实现这一目标。具体来说，它首先将物品按单价从小到大排序，然后依次购买单价最低的物品，直到预算用完。

代码分析

1. ​输入处理​：
   • 首先读取预算 m 和物品数量 n。
   • 然后读取每个物品的单价 a[i] 和库存数量 b[i]。
2. ​排序​：
   • 使用冒泡排序将物品按单价从小到大排序。这样做的目的是优先购买单价低的物品，以便在预算有限的情况下购买更多的物品。
3. ​购买物品​：
   • 遍历排序后的物品列表，逐个购买物品，直到预算用完。
   • 每购买一个物品，更新总花费 som 和已购买物品数量 q。
   • 如果总花费 som 超过预算 m，则停止购买。
4. ​输出结果​：
   • 输出最多可以购买的物品数量 q。

代码优化

虽然这段代码能够正确解决问题，但有一些可以优化的地方：

1. ​排序算法​：
   • 冒泡排序的时间复杂度为 O(n^2)，对于 n ≤ 100 的情况来说，性能还可以接受，但如果 n 更大，建议使用更高效的排序算法，如 std::sort。
2. ​提前终止​：
   • 在购买物品时，如果预算已经用完，可以提前终止循环，避免不必要的计算。
3. ​变量命名​：
   • 变量名可以更具描述性，以便于理解和维护代码。

优化后的代码

#include <bits/stdc++.h>
using namespace std;

int main() {
    int m, n;
    cin >> m >> n;
    
    vector<pair<int, int>> items(n); // 存储物品的单价和库存
    for (int i = 0; i < n; ++i) {
        cin >> items[i].first >> items[i].second;
    }
    
    // 按单价从小到大排序
    sort(items.begin(), items.end());
    
    int totalCost = 0; // 总花费
    int totalItems = 0; // 总物品数量
    
    for (const auto& item : items) {
        int price = item.first;
        int stock = item.second;
        
        // 计算可以购买的最大数量
        int buy = min(stock, (m - totalCost) / price);
        if (buy <= 0) break; // 如果买不起，提前终止
        
        totalCost += buy * price;
        totalItems += buy;
        
        if (totalCost >= m) break; // 如果预算用完，提前终止
    }
    
    cout << totalItems << endl;
    return 0;
}

优化点说明

1. ​** 使用 vector 和 pair**​：
   • 使用 vector<pair<int, int>> 来存储物品的单价和库存，代码更简洁。
2. ​**使用 std::sort**​：
   • 使用 std::sort 进行排序，时间复杂度为 O(n log n)，比冒泡排序更高效。
3. ​提前终止​：
   • 在购买物品时，如果预算已经用完，立即终止循环，避免不必要的计算。
4. ​变量命名​：
   • 使用更具描述性的变量名，如 totalCost 和 totalItems，使代码更易读。

总结

这段代码通过贪心算法解决了在预算有限的情况下购买最多物品的问题。优化后的代码在性能和可读性上都有所提升，适用于更大的数据集。

hhh你也卡了

#include<iostream> using namespace std; int main(){ int a,b,c,d; cin>>d; a=d%10; b=d/10%10; c=d/100; cout<<a100+b10+c; return 0; }