POJ 1862 Stripies

 

Stripies

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 13661		Accepted: 6413

 

Description

Our chemical biologists have invented a new very useful form of life called stripies (in fact, they were first called in Russian - polosatiki, but the scientists had to invent an English name to apply for an international patent). The stripies are transparent amorphous amebiform creatures that live in flat colonies in a jelly-like nutrient medium. Most of the time the stripies are moving. When two of them collide a new stripie appears instead of them. Long observations made by our scientists enabled them to establish that the weight of the new stripie isn't equal to the sum of weights of two disappeared stripies that collided; nevertheless, they soon learned that when two stripies of weights m1 and m2 collide the weight of resulting stripie equals to 2*sqrt(m1*m2). Our chemical biologists are very anxious to know to what limits can decrease the total weight of a given colony of stripies. 
You are to write a program that will help them to answer this question. You may assume that 3 or more stipies never collide together. 

Input

The first line of the input contains one integer N (1 <= N <= 100) - the number of stripies in a colony. Each of next N lines contains one integer ranging from 1 to 10000 - the weight of the corresponding stripie.

Output

The output must contain one line with the minimal possible total weight of colony with the accuracy of three decimal digits after the point.

Sample Input

3
72
30
50

Sample Output

120.000

 

今天《算法》看到了优先队列的内容了，于是搜了道ACM的有关优先队列的题。

 

题意是有一种生物，两两碰撞会合体，但质量并不是单纯的相加，而是遵循了这个公式：m=2*sqrt(m1+m2)。给你输入：3（生物的个数） 72 30 50（各个生物的质量），让你输出：120.000（生物们合体后能产生的最小的质量）。

用一个最大优先队列把所有的生物的质量存起来，然后最大的2个出队，并计算他们合体后的质量并入队，直到只剩一个生物在最大优先队列中，就把这个生物的质量按格式化输出即可。

我这里使用的是自己实现的最大优先队列，实际上可以直接使用Java类库里的PriorityQueue类，因为它是最小优先队列，所以你还需要实现一个Comparator类来改变它的比较方式。

 

import java.util.Scanner;

/**
 * Created by 小粤 on 2015/8/6.
 */
public class Main
{
    private static MaxPriorityQueue maxPriorityQueue;

    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int numberOfStripies = scanner.nextInt();

        maxPriorityQueue = new MaxPriorityQueue(numberOfStripies);

        for (int i = 0; i < numberOfStripies; i++)
        {
            maxPriorityQueue.insert(scanner.nextInt());
        }

        double a = 0.0, b = 0.0, c = 0.0;
        for (int i = 0; i < numberOfStripies - 1; i++)
        {
            a = maxPriorityQueue.deleteMax();
            b = maxPriorityQueue.deleteMax();
            c = 2 * Math.sqrt(a * b);

            maxPriorityQueue.insert(c);
        }

        System.out.printf("%.3f", maxPriorityQueue.deleteMax());
    }
}

class MaxPriorityQueue
{
    private double[] maxPriorityQueue;
    private int size;

    public MaxPriorityQueue(int capacity)
    {
        maxPriorityQueue = new double[capacity + 1];
        size = 0;
    }

    public void insert(double item)
    {
        maxPriorityQueue[++size] = item;
        swim(size);
    }

    public double deleteMax()
    {
        double maxItem = maxPriorityQueue[1];
        exch(1, size--);
        sink(1);
        return maxItem;
    }

    /***************************************************************************
     * Helper functions to restore the heap invariant.
     ***************************************************************************/
    private void swim(int index)
    {
        while (index > 1 && less(index / 2, index))
        {
            exch(index / 2, index);
            index = index / 2;
        }
    }

    private void sink(int index)
    {
        while (index <= size / 2)
        {
            int i = index * 2;
            if (i < size && less(i, i + 1))
            {
                i++;
            }

            if (!less(index, i))
            {
                break;
            }

            exch(index, i);
            index = i;
        }
    }

    /***************************************************************************
     * Helper functions for compares and swaps.
     ***************************************************************************/
    private boolean less(int i, int j)
    {
        return maxPriorityQueue[i] < maxPriorityQueue[j];
    }

    private void exch(int i, int j)
    {
        double temp = maxPriorityQueue[i];
        maxPriorityQueue[i] = maxPriorityQueue[j];
        maxPriorityQueue[j] = temp;
    }
}