Mooncake (25)

n, d = map(int, input().split())
a = list(map(int, input().split()))
p = list(map(float, input().split()))
m = sorted(zip(a,p), key=lambda x: x[1]/x[0] if x[0] else float('Inf'), reverse=True)

ans = 0.0
for x in m:
    if x[0] < d:
        d -= x[0]
        ans += x[1]
    else:
        ans += x[1]/x[0]*d
        break
print('%.2f' % ans)

/*库存为0考虑到了，没想到没库存也能收利润，空手套白狼属实牛逼嗷*/
#include <bits/stdc++.h>
using namespace std;
const int AX = 1e3 + 66 ;
struct Node{
	double inv , p ; 
	bool operator < ( const Node &a )const{
		return ( ( p / inv ) - ( a.p / a.inv ) ) > 0 ;
	}
}a[AX];
vector<Node>v;
int main(){
	int n ;
	double d , x ;	
	scanf("%d%lf",&n,&d);
	for( int i = 0 ; i < n ; i++ ){
		scanf("%lf",&a[i].inv);
	}
	for( int i = 0 ; i < n ; i++ ){
		scanf("%lf",&a[i].p);
		if( a[i].inv ) v.push_back(a[i]);
	}
	sort( v.begin() , v.end() );
	double res = 0.0 ; 
	for( int i = 0 ; i < (int)v.size() ; i++ ){
		if( d <= 0 ) break ;
		double tmp = ( ( d >= v[i].inv ) ? v[i].inv : d ) ;
		res += ( tmp / v[i].inv * v[i].p ) ;
		d -= tmp ; 
	}
	for( int i = 0 ; i < n ; i++ ){
		if( !a[i].inv ){
			res += a[i].p ; 
		}
	}
	printf("%.2lf",res);
	return 0 ;
}

/java 有好多过不了pat官网上主要原因是浮点精度用double 剩余的库存也用double
注意他是问平均最高而不是总价格 /

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

public static void main(String[] args) throws IOException {
    BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer stringTokenizer,str2;
    stringTokenizer =new StringTokenizer(reader.readLine());
    int N=Integer.parseInt(stringTokenizer.nextToken());
    int D=Integer.parseInt(stringTokenizer.nextToken());
    stringTokenizer =new StringTokenizer(reader.readLine());
    str2=new StringTokenizer(reader.readLine());
    cake [] mokcake =new cake[N];
    for(int i=0;i<N;i++)
    {
        mokcake[i]=new cake();
        mokcake[i].amount=Double.parseDouble(stringTokenizer.nextToken());
        mokcake[i].price=Double.parseDouble(str2.nextToken());
        mokcake[i].ave_price=mokcake[i].price/mokcake[i].amount;
    }
    double count=0f;
    Arrays.sort(mokcake);

    for (int i = 0; i < N; i++) {
        if (D <= 0) break;
        if (D >= mokcake[i].amount) {
            count += mokcake[i].price;
            D-= mokcake[i].amount;
        } else {
            count += D * mokcake[i].ave_price;
            D = 0;
        }
    }
    System.out.printf("%.2f\n",count);
}
public  static class cake implements Comparable<cake>
{
    double amount;
    double price;
    double ave_price;
    public int compareTo(cake p)
    {
        return this.ave_price-p.ave_price>0? -1:1;
    }
}

}

import java.util.*;

class MoonCake{
    double price;
    double amount;
    double totalPrice;
    public MoonCake(double price,double amount,double totalPrice){
        this.price=price;
        this.amount=amount;
        this.totalPrice=totalPrice;
    }
}

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int d=sc.nextInt();
        ArrayList<MoonCake> cakeList=new ArrayList<MoonCake>();
        for(int i=0;i<n;i++){
            MoonCake moonCake=new MoonCake(0,sc.nextInt(),0);
            cakeList.add(moonCake);
        }
        for(int i=0;i<n;i++){
            double price=sc.nextDouble();
            MoonCake moonCake=cakeList.get(i);
            moonCake.totalPrice=price;
            moonCake.price=price/moonCake.amount;
        }
        Collections.sort(cakeList,new Comparator<MoonCake>(){
            public int compare(MoonCake o1,MoonCake o2){
                if(o1.price>o2.price)
                    return -1;
                else if(o1.price==o2.price)
                    return 0;
                else
                    return 1;
            }
        });
        double totalPrice=0;
        for(int i=0;i<n;i++){
            if(d>cakeList.get(i).amount){
                d-=cakeList.get(i).amount;
                totalPrice+=cakeList.get(i).totalPrice;
            }else{
                totalPrice+=cakeList.get(i).price*d;
                break;
            }
        }
        System.out.printf("%.2f",totalPrice);
    }
}

#include<cstdio>
#include<algorithm>
using namespace std;
struct st{
	float am;
	float p;
};
bool fun(st x1,st x2)
{return x1.p/x1.am>x2.p/x2.am;}
int main()
{
	int n,i,j,a,b;
	float sum=0,d;
	st p0[1001];
	scanf("%d%f",&n,&d);
	for(i=1;i<=n;i++)
		scanf("%f",&p0[i].am);
	for(i=1;i<=n;i++)
		scanf("%f",&p0[i].p);
	sort(p0+1,p0+n+1,fun);
	for(i=1;i<=n;i++)
	{
		if(d<=0)break;
		if(p0[i].am<=d)
		{
			d=d-p0[i].am;
			sum=sum+p0[i].p;
		}
		else {
			sum=sum+p0[i].p*d/p0[i].am;
			break;
		}
	}
	printf("%.2f",sum);
	return 0;
}

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

struct Cake{
    double price,amount,perprice;
};
bool com(Cake c1,Cake c2){ return c1.perprice>c2.perprice;
}

int main(){
    int n,i;
    d,total=0,temp=0;
    Cake cake[1010];
    scanf("%d %lf",&n,&d);
    for(i=0;i<n;i++) scanf("%lf",&cake[i].amount);
    for(i=0;i<n;i++){
        scanf("%lf",&cake[i].price);
        cake[i].perprice=cake[i].price/cake[i].amount;
    }
    sort(cake,cake+n,com);
    for(i=0;i<n;i++){
        if(temp+cake[i].amount<=d){
            total+=cake[i].price;
            temp+=cake[i].amount;
        }else{
            total+=cake[i].perprice*(d-temp);
            temp=d;
        }
        if(temp>=d) break;
    }
    printf("%.2f",total);
    return 0;
}

import sys
n,d = map(int,input().split())
zong = list(map(int,input().split()))
price = list(map(int,input().split()))
for i in range(0,len(zong)):
    zong[i] = [zong[i]]
    zong[i].append(price[i])
    if zong[i][0]!=0:
        zong[i].append(zong[i][1]/zong[i][0])
    else:
        zong[i].append(sys.maxsize)
zong.sort(key=lambda x:(-x[2]))
pri,cur = 0,zong[0][0]
i = 0
while d>cur:
    pri = pri + zong[i][1]
    d = d-cur
    i+=1
    cur = zong[i][0] 
pri = pri+(zong[i][2]*d)
print("%.2f"%pri)

N,D=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
res,L=0,[]
for i in range(len(A)):
    if A[i]==0:
        res+=B[i]
    else:
        L.append([A[i],B[i]])
L.sort(key=lambda x:-x[1]/x[0])
for e in L:
    res+=min(D,e[0])*(e[1]/e[0])
    D=max(0,D-e[0])
    if not D:
        break
print('{:.2f}'.format(res))

PAT上测试点2说答案错误。不知道为什么。。。

# include <cstdio>
# include <cstdlib>

struct mooncake {
    int inv;
    double price;
    double unitPrice;
} mooncakes[1010];

int N, D;

int compar(const void *a, const void *b) {
    double ans = ((mooncake*)b)->unitPrice - ((mooncake*)a)->unitPrice;
    return (ans > 0 ? 1 : (ans < 0 ? -1 : 0));
}

int main() {
    scanf("%d %d", &N, &D);
    for (int i = 0; i < N; i++) {
        scanf("%d", &(mooncakes[i].inv));
    }
    for (int i = 0; i < N; i++) {
        scanf("%lf", &(mooncakes[i].price));
        mooncakes[i].unitPrice = mooncakes[i].price / mooncakes[i].inv;
    }

    qsort(mooncakes, N, sizeof(mooncake), compar);

    int need = D;
    double profit = 0;
    for (int i = 0; i < N && need > 0; i++) {
        if (need >= mooncakes[i].inv) { //全部卖也不够
            profit += mooncakes[i].price;
            need -= mooncakes[i].inv;
        }
        else { //卖一部分
            profit += need * mooncakes[i].price / mooncakes[i].inv;
            need = 0;
        }
    }

    printf("%.2lf", profit);

    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1000 + 10;
struct Mooncake{
    int inventory; //庫存量
    int all_price;
    double per_price;
    void init(){
        per_price = (all_price * 1.0) / (inventory * 1.0);
    }
    Mooncake() {}
}cake[maxn];

bool compare(Mooncake m1, Mooncake m2){
    return m1.per_price > m2.per_price;
}

int main(){
    int n, d;
    scanf("%d %d", &n, &d);
    for(int i=0; i<n; i++){
        int num;
        scanf("%d", &num);
        cake[i].inventory = num;
    }
    for(int i=0; i<n; i++){
        int price;
        scanf("%d", &price);
        cake[i].all_price = price;
        cake[i].init();
    }
    sort(cake, cake+n, compare);
    double ans = 0;
    for(int i=0; i<n; i++){
        if(cake[i].inventory < d){
            d -= cake[i].inventory;
            ans += cake[i].all_price;
        }
        else{
            ans += cake[i].per_price * d;
            break;
        }
    }
    printf("%.2f", ans);
    return 0;
}

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

using namespace std;

struct Mooncake
{
    int inventory, price;
    double unitPrice;
    bool operator<(const Mooncake& that) const {
        return (unitPrice > that.unitPrice);
    }
};

int main()
{
    ios::sync_with_stdio(false);
    // 读入数据
    int N, D; cin >> N >> D;
    vector<Mooncake> mooncakes(N);
    for(int i=0; i<N; i++) {
        cin >> mooncakes[i].inventory;
    }
    for(int i=0; i<N; i++) {
        cin >> mooncakes[i].price;
    }
    for(int i=0; i<N; i++) {
        mooncakes[i].unitPrice = (double)mooncakes[i].price/mooncakes[i].inventory;
    }

    // 排序并处理请求
    sort(mooncakes.begin(), mooncakes.end());
    double profit = 0.0;
    for(int i=0; i<N; i++) {
        if(mooncakes[i].inventory <= D) {
            D -= mooncakes[i].inventory;
            profit += mooncakes[i].price;
        } else {
            profit += (mooncakes[i].unitPrice*D);
            break;
        }
    }
    cout << fixed << setprecision(2) << profit << endl;
    return 0;
}