CodeForces 18 D.Seller Bob（dp+高精度）

最新推荐文章于 2024-12-01 03:34:23 发布

原创最新推荐文章于 2024-12-01 03:34:23 发布 · 435 阅读

1 ·

CC 4.0 BY-SA版权

Code Forces 同时被 3 个专栏收录

606 篇文章

订阅专栏

202 篇文章

订阅专栏

高精度

24 篇文章

订阅专栏

本文介绍了一种解决内存条买卖问题的算法，通过记录内存条的买卖操作，利用动态规划求解最大利润。文中提供了完整的代码实现及解析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description

两种操作：

$sell\ x:$ 有人来买内存为 $2^x$ 的内存条

$win\ x:$ 比赛赢得一个内存为 $2^x$ 的内存条

手里至多留一个内存条，一种内存条至多有一个人来买，有人来买 $2^x$ 的内存条且恰好留的内存条的内存是 $2^x$ 则交易成功，利润为 $2^x$ ，问最大利润

Input

第一行一整数 $n$ 表示操作数，之后 $n$ 行每行一个操作 $(1\le n\le 5000,0\le x\le 2000)$

Output

输出最大利润

Sample Input

7
win 10
win 5
win 3
sell 5
sell 3
win 10
sell 10

Sample Output

1056

Solution

一种内存条可能赢得多次但是至多卖一次，对于一个 $2^x$ 内存的内存条的购买操作 $i$ ，只需找到 $i$ 前面最近的赢得该内存条的操作 $pre[i]$ 即可，以 $dp[i]$ 表示到第 $i$ 次操作可以获得的最大利润值，如果第 $i$ 个操作是购买 $2^x$ 内存的内存条操作且 $pre[i]$ 存在，那么有转移 $dp[i]=max(dp[i-1],dp[pre[i]-1]+2^x)$ ，否则 $dp[i]=dp[i-1]$ ， $dp[n]$ 即为答案，由于很大所以要用高精度

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f,maxn=5005;
struct BigInt
{
    const static int mod=10000;
    const static int LEN=4;
    int a[200],len;
    BigInt() 
    {
        memset(a,0,sizeof(a));
        len=1;
    }
    void init(int x)
    {
        memset(a,0,sizeof(a));
        len=0;
        do
        {
            a[len++]=x%mod;
            x/=mod;
        }while(x);
    }
    void Init(const char s[])
    {
        memset(a,0,sizeof(a));
        int l=strlen(s),res=0;
        len=l/LEN;
        if(l%LEN)len++;
        for(int i=l-1;i>=0;i-=LEN)
        {
            int t=0,k=max(i-LEN+1,0);
            for(int j=k;j<=i;j++)t=t*10+s[j]-'0';
            a[res++]=t;
        }
    }
    int Compare(const BigInt &b)
    {
        if(len<b.len)return -1;
        if(len>b.len)return 1;
        for(int i=len-1;i>=0;i--)
            if(a[i]<b.a[i])return -1;
            else if(a[i]>b.a[i])return 1;
        return 0;
    }
    BigInt operator +(const BigInt &b)const
    {
        BigInt ans;
        ans.len=max(len,b.len);
        for(int i=0;i<=ans.len;i++)ans.a[i]=0;
        for(int i=0;i<ans.len;i++)
        {
            ans.a[i]+=((i<len)?a[i]:0)+((i<b.len)?b.a[i]:0);
            ans.a[i+1]+=ans.a[i]/mod;
            ans.a[i]%=mod;
        }
        if(ans.a[ans.len]>0)ans.len++;
        return ans;
    }
    BigInt operator -(const BigInt &b)const
    {
        BigInt ans;
        ans.len=len;
        int k=0;
        for(int i=0;i<ans.len;i++)
        {
            ans.a[i]=a[i]+k-b.a[i];
            if(ans.a[i]<0)ans.a[i]+=mod,k=-1;
            else k=0;           
        }
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    BigInt operator *(const BigInt &b)const
    {
        BigInt ans;
        for(int i=0;i<len;i++)
        {
            int k=0;
            for(int j=0;j<b.len;j++)
            {
                int temp=a[i]*b.a[j]+ans.a[i+j]+k;
                ans.a[i+j]=temp%mod;
                k=temp/mod;
            }
            if(k!=0)ans.a[i+b.len]=k;
        }
        ans.len=len+b.len;
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    void output()
    {
        printf("%d",a[len-1]);
        for(int i=len-2;i>=0;i--)
            printf("%04d",a[i]);
        printf("\n");
    }
};
int n,x[maxn],now[maxn],pre[maxn];
BigInt temp,f[maxn],dp[maxn];
int main()
{
    temp.init(2),f[0].init(1);
    for(int i=1;i<=2000;i++)f[i]=f[i-1]*temp;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        char op[5];
        scanf("%s%d",op,&x[i]);
        if(op[0]=='w')now[x[i]]=i;
        else if(now[x[i]])pre[i]=now[x[i]];
    }
    dp[0].init(0);
    for(int i=1;i<=n;i++)
    {
        dp[i]=dp[i-1];
        if(pre[i]&&dp[i].Compare(dp[pre[i]-1]+f[x[i]])<0)dp[i]=dp[pre[i]-1]+f[x[i]];
    }
    dp[n].output();
    return 0;
}