月饼 (25)

刚接触在线编程，很多地方还处理不好。以下这段代码，PTA给出的错误提示是 返回为零
我自己用的是Idea，没有出现错误，运行结果也正确，而且因为这个错误好像是跟语法有关，所以
也没有测试点的错误提示，希望有常常在网上编程的同学能帮我答疑解惑。

为了方便大家快速了解代码结构，我简述一下思路：
    两个数组，分别调用一个方法，把控制台的输入依次存入数组。之后两个数组调用排序方法，
    根据单价的不同，进行冒泡排序（两个数组同时排序，可以保证，库存和价格的索引一直相同）。
     之后就是if语句去循环判断是否达到总需求量，并依次记录利润值了，最后返回利润值，并输出。



import java.util.*;
public class Main {
    public double doTest(){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();//得到月饼的总的种类数
        int D = sc.nextInt();//得到市场最大需求量
        double stoke[] = new double[N];
        double price[] = new double[N];
        double profit = 0;//利润总额
        input(stoke);
        input(price);
        getUnitPrice(stoke,price);//按照单价升序排列的数组
        /*for(double x:stoke){
            System.out.println("here"+x);
        }*/
        for(int i=stoke.length-1;i>=0;i--){
            if(stoke[i]<D){
                profit += price[i];//72+
                D -= stoke[i];
            }
            else{
                profit += D * (price[i]/stoke[i]);
                break;
            }
        }
        return profit;
    }

    public void getUnitPrice(double array1[],double array2[]){
        for(int i=0;i<array1.length-1;i++) {
            for (int j = 0; j < array1.length - i - 1; j++) {
                if (array2[j] / array1[j] > array2[j + 1] / array1[j + 1]) {
                    double temp = array1[j];
                    array1[j] = array1[j + 1];
                    array1[j + 1] = temp;
                    temp = array2[j];
                    array2[j] = array2[j + 1];
                    array2[j + 1] = temp;
                }
            }
        }
    }

    public void input(double temp[]){
        Scanner sc = new Scanner(System.in);
        for(int i=0;i<temp.length;i++){
            temp[i] = sc.nextInt();
        }
    }

    public static void main(String []args){
        Main ws = new Main();
        double profit = ws.doTest();
        System.out.println(String.format("%.2f",profit));
    }
}

#include <iostream>
(720)#include <algorithm>
using namespace std;

struct MoonCake
{
    double stock;
    double total_price;
    static bool cmp(const MoonCake& a, const MoonCake& b) { return (a.total_price / a.stock) > (b.total_price / b.stock); }
};

int main()
{
    long long int N, sum;
    double total = 0;

    scanf("%lld %lld", &N, &sum);

    MoonCake moonCakes[N];

    for (int i = 0; i < N; ++i) {
        scanf("%lf", &moonCakes[i].stock);
    }

    for (int i = 0; i < N; ++i) {
        scanf("%lf", &moonCakes[i].total_price);
    }

    sort(moonCakes, moonCakes + N, MoonCake::cmp);

    for (int i = 0; i < N; ++i) {
        if (sum <= moonCakes[i].stock) {
            total += (sum / moonCakes[i].stock * moonCakes[i].total_price);
            break;
        } else {
            sum -= moonCakes[i].stock;
            total += moonCakes[i].total_price;
        }
    }

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

    return 0;
}

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

struct node
{
	double price;//单价 
	double sum;//总库存 
	double Sprice;//总售价 
}r[1000]; 

bool cmp(node &a,node &b){return a.price>b.price;}

int main()
{
	int n;
	double d;
	while(cin>>n>>d)
	{
		double num=0;
		for(int i=0;i<n;i++)cin>>r[i].sum;
		for(int i=0;i<n;i++)cin>>r[i].Sprice;
		for(int i=0;i<n;i++)
		{
			r[i].price=r[i].Sprice/r[i].sum;
		}
		sort(r,r+n,cmp);
		for(int i=0;i<n&&d>0;i++)
		{
			if(r[i].sum>d)
			{
				num+=d*r[i].price;
				d-=d;
			}
			else 
			{
				num+=r[i].Sprice;
				d-=r[i].sum;
			}
		}
		printf("%.2lf\n",num);
	}
}

import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/**
 * 
 * @author Sirice 贪心典型题
 */
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int kind = sc.nextInt(); // kind <= 1000
		Cake[] arr = new Cake[kind];

		int d = sc.nextInt(); // capacity <= 500
		
		for (int i = 0; i < arr.length; i++) {
			arr[i] = new Cake();
			arr[i].setCap(sc.nextInt());
		}
		for (int i = 0; i < arr.length; i++) {
			arr[i].setPrice(sc.nextInt());
		}

		Arrays.sort(arr, new Comparator<Cake>() {
			@Override
			public int compare(Cake o1, Cake o2) {
				if ((float) o1.getPrice() / (float) o1.getCap() > (float) o2.getPrice() / (float) o2.getCap()) {
					return -1;
				} else {
					return 1;
				}
			}
		});
		
		float ans = 0;
		for(int i =0;i<arr.length;i++) {
			if(arr[i].getCap()<d) {
				d-=arr[i].getCap();
				ans+=(float)arr[i].getPrice();
			}else {
				ans+=(float)arr[i].getPrice()/(float)arr[i].getCap() * d;
				break;
			}
		}
		DecimalFormat df = new DecimalFormat(".00");
	    System.out.println(df.format(ans));

	}

}

class Cake {
	private int cap;
	private int price;

	public int getCap() {
		return cap;
	}

	public void setCap(int cap) {
		this.cap = cap;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public Cake(int cap, int price) {
		super();
		this.cap = cap;
		this.price = price;
	}

	public Cake() {
		super();
	}

}

#include <iostream>
#include<iomanip>
using namespace std;
struct Sale
{
    int kucun;
    int sum;
    float ave;

}yuebing[1001];
int main()
{
    int N,M,i;
    int a,b;
    float Sum=0;
    cin>>N>>M;
    for(i=0;i<N;i++)
    {
        cin>>a;
        yuebing[i].kucun=a;
    }
    for(i=0;i<N;i++)
    {
        cin>>b;
        yuebing[i].sum=b;
        yuebing[i].ave=(float)b/(float)yuebing[i].kucun;
    }
    for(i=0;i<N;i++)//按均价从高到低排，方便后续计算
    {
        for(int j=i+1;j<N;j++)
        {
            if(yuebing[i].ave<yuebing[j].ave)
            {
                yuebing[1001]=yuebing[i];
                yuebing[i]=yuebing[j];
                yuebing[j]=yuebing[1001];
            }
        }
    }
    i=0;
    while(M>=yuebing[i].kucun)
    {
        Sum+=(float)yuebing[i].sum;
        M-=yuebing[i].kucun;
        i++;
    }
    Sum+=(float)M*yuebing[i].ave;
    cout<<fixed<<setprecision(2)<<Sum;
}

	

//敬请指教

	import java.util.*;



	



	



	class  pie implements Comparable<pie>{



	public int l;//数量



	public int m;//收益



	public double y;



	public int compareTo(pie p){



	if(this.y>p.y) return 1;



	else if(this.y<p.y) return -1;



	else return 0;



	}



	}



	



	public class Main {



	



	public static void main(String[] args) {



	Scanner input=new Scanner(System.in);



	int n=input.nextInt();



	int d=input.nextInt();



	pie[] p=new pie[n];



	for(inti=0;i<n;i++){



	p[i]=new pie();



	p[i].l=input.nextInt();



	}



	for(inti=0;i<n;i++){



	p[i].m=input.nextInt();



	if(p[i].m==0) p[i].y=0;



	elsep[i].y=(double)p[i].m/p[i].l;



	}



	java.util.Arrays.sort(p);



	



	double max=0;



	for(inti=n-1;i>=0;i--){



	if(d<=p[i].l){



	max=max+d*p[i].y;



	break;



	}



	max=max+p[i].m;



	d=d-p[i].l;



	}



	String r=String.format("%.2f", max);



	System.out.println(r);



	input.close();



	}



	



	}

import java.util.Arrays;
import java.util.Scanner;

public class _t394 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		while(in.hasNext()){
			int n=in.nextInt(),req=in.nextInt();
			int[] total=new int[n];
			double[] money=new double[n];
			double[] per=new double[n];
			for (int i = 0; i < n; i++) {
				total[i]=in.nextInt();
			}
			for (int i = 0; i < n; i++) {
				money[i]=in.nextDouble();
				per[i]=money[i]/total[i];
			}
			
			double temp=0;
			for (int i = n-1; i > 0; i--) {
				for (int j = 0; j < i; j++) {
					if(per[j]<per[j+1]){
						temp=per[j];
						per[j]=per[j+1];
						per[j+1]=temp;
						
						temp=total[j];
						total[j]=total[j+1];
						total[j+1]=(int) temp;
					}
				}
			}
//			System.out.println(Arrays.toString(per));
			
			int sum=0;
			double rs=0;
			for (int i = 0; i < n; i++) {
				sum+=total[i];
				if(req>sum){
					rs+=total[i]*per[i];
				}
				else{
					rs+=(req-sum+total[i])*per[i];
					break;
				}
			}
			System.out.printf("%.2f\n",rs);
		}
	}
}

//大家好，这个可以算是贪心思想的应用；
#include <iostream>
#include <algorithm>
using namespace std;
typedef struct yuebin
{
	int dun;
	int price;
	double pre;
}yb;
static bool comp(yb a,yb b)
{
	return (a.pre>b.pre);
}
void helper(int count,int max)
{
	yb* arr=new yb[count];
	for(int i=0;i<count;i++)
	{
		cin>>arr[i].dun;
	}
	for(int i=0;i<count;i++)
	{
		cin>>arr[i].price;
	}
	for(int i=0;i<count;i++)
	{
		arr[i].pre=(double)arr[i].price/arr[i].dun;
	}
	//按照单价排序 
	sort(arr,arr+count,comp);
	int temp=max;
	double total=0.0;
	for(int i=0;i<count;i++)
	{
		if(temp==0) break;
		if(arr[i].dun>=temp && temp>0)
		{
			total+=(double)temp*arr[i].price/arr[i].dun;
			break;
		}
		else if(arr[i].dun<temp && temp>0)
		{
			temp = temp-arr[i].dun;
			total+=arr[i].price;
		}
	}
	printf("%.2f",total);
}
int main()
 {
 	int count,max;
 	while(cin>>count>>max)
 	{
 		helper(count,max);
	 }

    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
const int n = 1005;
struct m {
	double a, b, c;
	bool operator <(const m& l)const{
		return c > l.c;
	}
};
m A[n];
int main()
{
	int x, y, i = 0;
	double sum = 0;
	cin >> x >> y;
	for (int i = 0; i != x; i++){
		cin >> A[i].a;
	}
	for (int i = 0; i != x; i++){
		cin >> A[i].b;
		A[i].c = A[i].b / A[i].a;
	}
	sort(A, A + x);
	while (y){
		if (y >= A[i].a){
			sum += A[i].b;
			y -= A[i].a;
		}else{
			sum += A[i].c*y;
			y = 0;
		}
		i++;
	}
	printf("%.2lf", sum);
	return 0;
}

#include <iostream>
#include <vector>
#include <set>
#include <iomanip>

using namespace std;

class MoonCake
{
public:
    int inventory;  // 库存
    int price;      // 总售价
    double density; // 单价
    MoonCake(int inventory, int price) {
        this->inventory = inventory;
        this->price = price;
        density = (double) price/inventory;
    }
    bool operator <(const MoonCake& another)const {
        return density < another.density;
    }
};

int main()
{
    // 读入数据
    int N, requirement;
    cin >> N >> requirement;
    vector<int> inventories(N, 0);
    multiset<MoonCake> moonCakes;
    for(int i=0; i<N; i++) {
        cin >> inventories[i];
    }
    for(int i=0; i<N; i++) {
        int tempPrice;
        cin >> tempPrice;
        MoonCake moonCake(inventories[i], tempPrice);
        moonCakes.insert(moonCake);
    }

    // 统计最大收益
    double earnings = 0.0; int sum =0;
    multiset<MoonCake>::reverse_iterator iter;
    for(iter=moonCakes.rbegin(); iter!=moonCakes.rend(); iter++) {
        int currentInventory = (*iter).inventory;
        if(currentInventory < (requirement-sum)) {
            sum += currentInventory;
            earnings += (*iter).price;
        } else {
            earnings += (requirement-sum)*((*iter).density);
            break;
        }
    }
    cout << fixed << setprecision(2) << earnings << endl;
    return 0;
} 

N, D = [int(i) for i in input().split()]
storage = [float(i) for i in input().split()]
price = [float(i) for i in input().split()]

def cacu_profit():
    data = list(map(lambda x: (x[1] / x[0], x[0]), filter(lambda x: x[0] != 0, zip(storage, price))))
    data.sort(key=lambda x: x[0], reverse=True)
    profit, weight= 0, 0
    while weight < D:
        temp = data.pop(0)
        if temp[1] + weight <= D:
            weight += temp[1]
            profit += temp[0] * temp[1]
        else:
            profit += temp[0] * (D - weight)
            weight = D
        if data == []:
            break
    print('%.2f' % profit)
    
cacu_profit()

#include <algorithm>
#include <iostream>
using namespace std;
struct mc{
    double quantity,pay,spay;     
}s[1010];
bool cmp(mc a,mc b){
    return a.spay>b.spay;
}
int main(){
    int x,y,i;double max=0;
    cin>>x>>y;
    for(i=0;i<x;i++)
        cin>>s[i].quantity;
    for(i=0;i<x;i++){
        cin>>s[i].pay;
        s[i].spay=s[i].pay/s[i].quantity;
    }
    sort(s,s+x,cmp);       //按单价从高到低排序
    for(i=0;i<x;i++){
        if(s[i].quantity<=y){   //需求量高于库存量，卖出第i种所有月饼
            y-=s[i].quantity;
            max+=s[i].pay;
        }
        else{
            max+=y*s[i].spay;   //库存量高于需求量，卖出剩余需求量的月饼
            break;
        }
    }
    printf("%.2f",max);

    return 0;
}