codeforces round #413 C. Fountains

最新推荐文章于 2019-10-31 21:17:09 发布

原创最新推荐文章于 2019-10-31 21:17:09 发布 · 353 阅读

0 ·

CC 4.0 BY-SA版权

ACM 专栏收录该内容

101 篇文章

订阅专栏

本文探讨了在有限预算下购买两种类型喷泉的最大美观度问题。通过暴力算法与线段树优化方案对比，实现效率提升。适用于算法优化及数据结构学习。

题意：你有两种货币，分别可以买两种类型的喷泉，每个喷泉都有美观度，给你c个1货币和d个2货币，让你买两个喷泉，求最大美观度；

思路1：暴力，对于每个喷泉，买完这个喷泉后，剩下的钱来买另一个喷泉（这个喷泉的美观度要最大），时间：1700ms；

#include <iostream>
#include <algorithm>

using namespace std;
const int maxn = 100000+10;

struct node
{
    int bea;
    int pri;
}fc[maxn],fd[maxn];
bool cmp(node a,node b)
{
    return a.bea>b.bea;
}
int main()
{
    int n,c,d;
    cin>>n>>c>>d;
    int cl = 0,dl = 0;
    for(int i = 0;i<n;i++)
    {
        int b,p;
        char type;
        cin>>b>>p>>type;
        if(type=='C')
        {
            if(p<=c)
            {
                fc[cl].bea = b;
                fc[cl].pri = p;
                cl++;
            }
        }
        else if(type=='D')
        {
            if(p<=d)
            {
                fd[dl].bea = b;
                fd[dl].pri = p;
                dl++;
            }
        }
    }
    if(cl+dl<2)
    {
        cout<<'0';
        return 0;
    }
    sort(fc,fc+cl,cmp);
    sort(fd,fd+dl,cmp);
    int ans = 0;
    if(cl>=2)
    {
        for(int i = 0;i<cl;i++)
        {
            int maxx = 0;
            int p1 = fc[i].pri;
            for(int j=i+1;j<cl;j++)
            {
                if(fc[j].pri<=c-p1)
                {
                    maxx = fc[i].bea+fc[j].bea;
                    break;
                }
            }
            ans = max(ans,maxx);
        }
    }
    if(dl>=2)
    {
        for(int i = 0;i<dl;i++)
        {
            int maxx = 0;
            int p1 = fd[i].pri;
            for(int j=i+1;j<dl;j++)
            {
                if(fd[j].pri<=d-p1)
                {
                    maxx = fd[i].bea+fd[j].bea;
                    break;
                }
            }
            ans = max(ans,maxx);
        }
    }
    if(dl>0&&cl>0)
    {
        ans = max(ans,fc[0].bea+fd[0].bea);
    }
    cout<<ans;
    return 0;
}

思路2：用线段树维护区间最大值；时间：346ms；

#include <iostream>

using namespace std;
const int maxn = 100000+10;
int tree[2][maxn*4];

void build(int t,int rt,int l,int r)
{
    if(l==r)
    {
        tree[t][rt] = 0;
        return ;
    }
    int mid = (l+r)>>1;
    build(t,rt<<1,l,mid);
    build(t,(rt<<1)+1,mid+1,r);
}

void update(int t,int rt,int l,int r,int q,int v)
{
    if(l==r)
    {
        tree[t][rt] = max(tree[t][rt],v);
        return;
    }
    int mid = (l+r)>>1;
    if(q<=mid)
    {
        update(t,rt<<1,l,mid,q,v);
    }
    if(q>mid)
    {
        update(t,(rt<<1)+1,mid+1,r,q,v);
    }
    tree[t][rt] = max(tree[t][rt<<1],tree[t][(rt<<1)+1]);
}

int query(int t,int rt,int l,int r,int ql,int qr)
{
    if(ql<=l&&r<=qr)
    {
        return tree[t][rt];
    }
    int mid = (l+r)>>1;
    int ml = 0,mr = 0;
    if(ql<=mid)
    {
        ml = query(t,rt<<1,l,mid,ql,qr);
    }
    if(qr>mid)
    {
        mr = query(t,(rt<<1)+1,mid+1,r,ql,qr);
    }
    return max(ml,mr);
}

int main()
{
    int n,c,d;
    cin>>n>>c>>d;
    build(0,1,0,c);
    build(1,1,0,d);
    int maxc = 0,maxd = 0;
    int ans = 0;
    for(int i = 0;i<n;i++)
    {
        int b,p;
        char type;
        cin>>b>>p>>type;
        if(type=='C')
        {
            if(p<=c)
            {
                maxc = max(maxc,b);
                int p1 = c-p;
                int b1 = query(0,1,0,c,0,p1);
                if(b1!=0)
                {
                    ans = max(ans,b1+b);
                }
                update(0,1,0,c,p,b);
            }
        }
        else if(type=='D')
        {
            if(p<=d)
            {
                maxd = max(maxd,b);
                int p1 = d-p;
                int b1 = query(1,1,0,d,0,p1);
                if(b1!=0)
                    ans = max(ans,b1+b);
                update(1,1,0,d,p,b);
            }
        }
    }
    if(maxc&&maxd)
        ans = max(ans,maxc+maxd);
    cout<<ans;
    return 0;
}