4月14日

poj1862

题意：把一堆数两两合并为2*sqrt(m1*m2)，求最终的最小值

分析：类似哈夫曼树，不过这次要先将大的合并，用一个优先队列维护即可，优先队列默认就是从大到小，即大顶堆

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <queue>
#include <stack>
using namespace std;
int n;
int main()
{
    while(cin>>n)
    {
        priority_queue<double>que; //优先队列默认从大到小的顺序
        for(int i=0;i<n;i++)
        {
            double x;
            cin>>x;
            que.push(x);
        }
        double t1,t2,t;
        while(que.size()!=1)
        {
            t1=que.top();
            que.pop();
            t2=que.top();
            que.pop();
            t=2*sqrt(t1*t2);
            que.push(t);
        }
        printf("%.3lf
",que.top());
    }
    return 0;
}

 poj3262

题意:有n头牛，每头牛都有运输出去所需时间以及每分钟破坏的草的数量，每次运牛i出去需要时间2＊ti，这时其他牛在继续破坏草，问怎么才会使破坏的草的数量最小

分析:拿着题的第一思路，按照牛破坏草的数量排序，然后贪心，结果wa了，后来看了题解才知道。我们可以这样进行贪心：

对任意一头牛，例如：
2   7
可以看成两头 1 3.5的牛
也就是说任意一头牛都可以拆成T头
1   D/T
的牛
所以说，所有的牛就都变成了
1    X
按照应该就X从大到小排序，最后用优先队列搞定

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <queue>
#include <stack>
using namespace std;
const int maxn=100100;
typedef struct p
{
    int t,d;
    double num;
    friend bool operator<(p a,p b)
    {
        return a.num<b.num;  //大顶堆
    }
}p;
int main()
{
    int n;
    while(cin>>n)
    {
        priority_queue<p> que;
        long long sum=0;
        for(int i=0;i<n;i++)
        {
            p s;
            scanf("%d%d",&s.t,&s.d);
            sum+=s.d;
            s.num=(double)s.d/(double)s.t;
            que.push(s);
        }
        long long cnt=0;
        while(!que.empty())
        {
            p h=que.top();
            que.pop();
            sum-=h.d;
            cnt+=2*sum*h.t;
        }
        cout<<cnt<<endl;
    }
    return 0;
}

51nod 1163

题意:给出某件工作的最晚结束时间和完成这项工作所得得报酬，问如何选择才会获得最大报酬

分析：非常好的贪心题目。首先我们按照最晚结束时间进行排序，然后我们建立一个小跟堆。len表示小跟堆的元素个数。若len<s[i].t，则把当前元素加入堆中；若len=s[i].t,则判断优先队列的队首元素是否小于当前s[i].e，若小于，队首出队，再把s[i].e入队，最后对小跟堆中所有元素进行求和即可

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <queue>
#include <stack>
using namespace std;
const int maxn=50500;
typedef struct p
{
    int e,w;
}p;
p s[maxn];
bool cmp(p a,p b)
{
    return a.e<b.e;
}
int main()
{
    int n;
    while(cin>>n)
    {
        for(int i=0;i<n;i++)
            cin>>s[i].e>>s[i].w;
        sort(s,s+n,cmp);
        priority_queue<int,vector<int>,greater<int> > que;
        for(int i=0;i<n;i++)
        {
            if(s[i].e>que.size())
            {
                que.push(s[i].w);
            }else if(s[i].e==que.size())
            {
                int t=que.top();
                if(t<s[i].w)
                {
                    que.pop();
                    que.push(s[i].w);
                }
            }
        }
        long long sum=0;
        while(!que.empty())
        {
            sum+=que.top();
            que.pop();
        }
        cout<<sum<<endl;
    }
    return 0;
}