P1208 [USACO1.3]混合牛奶 Mixing Milk

倚窗倾听风吹雨

https://www.luogu.org/problemnew/show/P1208

题目描述
由于乳制品产业利润很低，所以降低原材料（牛奶）价格就变得十分重要。帮助Marry乳业找到最优的牛奶采购方案。

Marry乳业从一些奶农手中采购牛奶，并且每一位奶农为乳制品加工企业提供的价格是不同的。此外，就像每头奶牛每天只能挤出固定数量的奶，每位奶农每天能提供的牛奶数量是一定的。每天Marry乳业可以从奶农手中采购到小于或者等于奶农最大产量的整数数量的牛奶。

给出Marry乳业每天对牛奶的需求量，还有每位奶农提供的牛奶单价和产量。计算采购足够数量的牛奶所需的最小花费。

注：每天所有奶农的总产量大于Marry乳业的需求量。

输入输出格式
输入格式：
第 1 行共二个数值:N,(0<=N<=2,000,000)是需要牛奶的总数；M,(0<= M<=5,000)是提供牛奶的农民个数。

第 2 到 M+1 行:每行二个整数i 和 Ai。

Pi(0<= Pi<=1,000) 是农民 i 的牛奶的单价。

Ai(0 <= Ai <= 2,000,000)是农民 i 一天能卖给Marry的牛奶制造公司的牛奶数量。

输出格式：
单独的一行包含单独的一个整数，表示Marry的牛奶制造公司拿到所需的牛奶所要的最小费用。

输入输出样例
输入样例#1：
100 5
5 20
9 40
3 10
8 80
6 30
输出样例#1：
630
说明
题目翻译来自NOCOW。

USACO Training Section 1.3

倚窗倾听风吹雨

1. #include<iostream>
   
2. #include<algorithm>
   
3. using namespace std;
   
4. int n,m,ans;
   
5. struct node
   
6. {
   
7.     int c,a;
   
8. }p[5010];
   
9. bool cmp(node x,node y)
   
10. {
    
11.     return x.c<y.c;
    
12. }
    
13. int main()
    
14. {
    
15.     cin>>n>>m;
    
16.     for(int i=1;i<=m;i++)
    
17.         cin>>p[i].c>>p[i].a;
    
18.     sort(p+1,p+m+1,cmp);
    
19.     int j=1;
    
20.     while(n-p[j].a>0)
    
21.     {
    
22.         n-=p[j].a;
    
23.         ans+=p[j].a*p[j++].c;
    
24.     }
    
25.     ans+=n*p[j].c;
    
26.     cout<<ans<<endl;
    
27.     return 0;
    
28. }
    

复制代码

黄煦喆

1. #include<iostream>
   
2. #include<algorithm>
   
3. using namespace std;
   
4. int all,n,ans;
   
5. struct milk
   
6. {
   
7.     int price;
   
8.     int s;
   
9. }a[5001];
   
10. bool operator<(milk &x,milk &y)
    
11. {
    
12.     return x.price<y.price;
    
13. }
    
14. int main()
    
15. {
    
16.     cin>>all>>n;
    
17.     for(int i=1;i<=n;i++)cin>>a[i].price>>a[i].s;
    
18.     sort(a+1,a+n+1);
    
19.     for(int i=1;all;i++)
    
20.     {
    
21.         ans+=a[i].price*min(a[i].s,all);
    
22.         all-=min(a[i].s,all);
    
23.     }
    
24.     cout<<ans;
    
25.     return 0;
    
26. }
    

复制代码

universehyf

1. #pragma GCC optimize(2)
   
2. #pragma GCC optimize(3)
   
3. #pragma GCC optimize("Ofast")
   
4. #pragma GCC optimize("inline")
   
5. #pragma GCC optimize("-fgcse")
   
6. #pragma GCC optimize("-fgcse-lm")
   
7. #pragma GCC optimize("-fipa-sra")
   
8. #pragma GCC optimize("-ftree-pre")
   
9. #pragma GCC optimize("-ftree-vrp")
   
10. #pragma GCC optimize("-fpeephole2")
    
11. #pragma GCC optimize("-ffast-math")
    
12. #pragma GCC optimize("-fsched-spec")
    
13. #pragma GCC optimize("unroll-loops")
    
14. #pragma GCC optimize("-falign-jumps")
    
15. #pragma GCC optimize("-falign-loops")
    
16. #pragma GCC optimize("-falign-labels")
    
17. #pragma GCC optimize("-fdevirtualize")
    
18. #pragma GCC optimize("-fcaller-saves")
    
19. #pragma GCC optimize("-fcrossjumping")
    
20. #pragma GCC optimize("-fthread-jumps")
    
21. #pragma GCC optimize("-funroll-loops")
    
22. #pragma GCC optimize("-fwhole-program")
    
23. #pragma GCC optimize("-freorder-blocks")
    
24. #pragma GCC optimize("-fschedule-insns")
    
25. #pragma GCC optimize("inline-functions")
    
26. #pragma GCC optimize("-ftree-tail-merge")
    
27. #pragma GCC optimize("-fschedule-insns2")
    
28. #pragma GCC optimize("-fstrict-aliasing")
    
29. #pragma GCC optimize("-fstrict-overflow")
    
30. #pragma GCC optimize("-falign-functions")
    
31. #pragma GCC optimize("-fcse-skip-blocks")
    
32. #pragma GCC optimize("-fcse-follow-jumps")
    
33. #pragma GCC optimize("-fsched-interblock")
    
34. #pragma GCC optimize("-fpartial-inlining")
    
35. #pragma GCC optimize("no-stack-protector")
    
36. #pragma GCC optimize("-freorder-functions")
    
37. #pragma GCC optimize("-findirect-inlining")
    
38. #pragma GCC optimize("-fhoist-adjacent-loads")
    
39. #pragma GCC optimize("-frerun-cse-after-loop")
    
40. #pragma GCC optimize("inline-small-functions")
    
41. #pragma GCC optimize("-finline-small-functions")
    
42. #pragma GCC optimize("-ftree-switch-conversion")
    
43. #pragma GCC optimize("-foptimize-sibling-calls")
    
44. #pragma GCC optimize("-fexpensive-optimizations")
    
45. #pragma GCC optimize("-funsafe-loop-optimizations")
    
46. #pragma GCC optimize("inline-functions-called-once")
    
47. #pragma GCC optimize("-fdelete-null-pointer-checks")
    
48. #include<iostream>
    
49. #include<cstdio>
    
50. #include<algorithm>
    
51. using namespace std;
    
52. typedef long long ll;
    
53. int n,m,i;
    
54. struct farmer
    
55. {
    
56.     int p,a;
    
57. }f[5010];
    
58. ll c;
    
59. bool cmp(farmer x,farmer y){return x.p<y.p;}
    
60. int getint()
    
61. {
    
62.     int w = 0, q = 0;
    
63.     char c = getchar();
    
64.     while ((c < '0' || c > '9') && c != '-') c = getchar();
    
65.     if (c == '-')  q = 1, c = getchar();
    
66.     while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
    
67.     return q ? -w : w;
    
68. }
    
69. int main()
    
70. {
    
71.     n=getint();m=getint();
    
72.     for(i=1;i<=m;i++) f[i].p=getint(),f[i].a=getint();
    
73.     sort(f+1,f+m+1,cmp);
    
74.     i=1;while(n>0)
    
75.     {
    
76.         if(n>f[i].a) {n-=f[i].a;c+=f[i].p*f[i].a;i++;}
    
77.         else {c+=n*f[i].p;n=0;}
    
78.     }
    
79.     cout<<c;
    
80.     return 0;
    
81. }

复制代码

type尧

1. //
   
2. #include<iostream>
   
3. #include<cstdio>
   
4. #include<cstdlib>
   
5. #include<algorithm>
   
6. #define maxm 5010
   
7. using namespace std;
   
8. int n,m;
   
9. int ans;
   
10. struct node{
    
11.         int maxv,money;
    
12. }farmer[maxm];
    
13. bool cmp(node a,node b)
    
14. {
    
15.         return a.money<b.money;
    
16. }
    
17. void read()
    
18. {
    
19.         cin>>n>>m;
    
20.         for(int i=1;i<=m;i++)
    
21.                 cin>>farmer[i].money>>farmer[i].maxv;
    
22.         return;
    
23. }
    
24. void work()
    
25. {
    
26.         int pos=0;
    
27.         read();
    
28.         sort(farmer+1,farmer+1+m,cmp);
    
29.         while(n>0){
    
30.                 pos++;
    
31.                 if(n>=farmer[pos].maxv) n-=farmer[pos].maxv,ans+=farmer[pos].money*farmer[pos].maxv;
    
32.                 else ans+=farmer[pos].money*n,n=0;
    
33.         }
    
34.         cout<<ans;
    
35.         return;
    
36. }
    
37. int main()
    
38. {
    
39.         work();
    
40.         return 0;
    
41. }
    

复制代码