COCI2008 解题报告

最新推荐文章于 2024-02-04 20:55:44 发布

Cold_Chair

最新推荐文章于 2024-02-04 20:55:44 发布

阅读量1.7k

点赞数 2

文章标签： COCI 信息学

本文链接：https://blog.csdn.net/cold_chair/article/details/51900702

版权

T1：佳肴

Description

　　佳肴就是非常美味的菜的意思，佳肴最关键的是选择好原料。
　　现在有N种原料，每种原料都有酸度S和苦度B两个属性，当选择多种原料时，总酸度为每种原料的酸度之积，总苦度为每种原料的苦度之和。
　　正如大家所知，佳肴是既不酸也不苦的，因为要保证所选的原料使得总酸度和总苦度差的绝对值最小。
　　由于佳肴不能只有水，所以必须至少选择一种佳肴。

Input

　　输入第一行包含一个整数N（1<=N<=10），表示原料的种数。
　　接下来N行每行包含两个用一个空格隔开的整数，分别表示酸度和苦度。
　　输入数据保证如果所有原料都选上，总酸度和总苦度不会超过10^9。

Output

　　输出总酸度和总苦度最小的差。

Sample Input

输入1：

3 10

输入2：

3 8

5 8

输入3：

1 7

2 6

3 8

4 9

Sample Output

输出1：

输出2：

输出3：

Hint

样例3中选择最后三种原料，这样总酸度为2×3×4=24，总苦度为6+8+9=23，差为1。

这是一道小学生都能秒掉的题。如果看到这篇博客的您不会，建议后面的也不用看了。
$2^n$ 枚举每种佳肴是否选，最后统计答案。

Code：

#include<cstdio>
#define fo(i,x,y) for(int i=x;i<=y;i++)
#define maxlongint 2147483647
using namespace std;

int n,s[1001],k[1001],ans=maxlongint;

void dg(int x,int a,int b,int p){
    if(x>n){
        if(!p)
            return;
        int t=a-b<0?b-a:a-b;
        if(t<ans)   
            ans=t;
        return;
    }
    dg(x+1,a,b,p);
    dg(x+1,a*s[x],b+k[x],1);
}

int main(){
    scanf("%d",&n);
    fo(i,1,n)
        scanf("%d%d",&s[i],&k[i]);
    dg(1,1,0,0);
    printf("%d",ans);
}

T2：二叉树

Description

　　在一个无穷的满二叉树中，有以下几个特点：
　　(1) 每个节点都有两个儿子——左儿子和右儿子；
　　(2) 如果一个节点的编号为X，则它的左儿子编号为2X，右儿子为2X+1；
　　(3) 根节点编号为1。
　　现在从根结点开始走，每一步有三种选择：走到左儿子、走到右儿子和停在原地。
　　用字母“L”表示走到左儿子，“R”表示走到右儿子，“P”表示停在原地，用这三个字母组成的字符串表示一个明确的行走路线。
一个明确的行走路线的价值为最终到达节点的编号，例如LR的价值为5，而RPP的价值为3。
　　我们用字符“L”、“R”、“P”和“ $*$ ”组成的字符串表示一组行走路线，其中“*”可以是“L”、“R”、“P”中的任意一种，所有跟这个行走路线匹配的字符串都认为是可行的。
　　例如L*R包含LLR、LRR和LPR。而**包含LL、LR、LP、RL、RR、RP、PL、PR和PP这9种路线。
　　一组行走路线的价值等于所有匹配该模式的路线的价值之和。请你编程计算给定路线的价值。

Input

输入一个字符串表示一组行走路线，里面只含有“L”、“R”、“P”和“*”四种字符，长度不会超过10000。

Output

输出该路线的价值。

Sample Input

输入1:

P*P

输入2：

L*R

输入3：

输入4：

LLLLLRRRRRLLLLLRRRRRLLLLLRRRRRLLLLL

Sample Output

输出1：

输出2：

输出3：

输出4：

35400942560

Hint

30%的数据满足路线中不含“*”;
50%的数据满足最多只有3个“*”。

简单的递推。
设f[i],s[i]分别表示到第i个字符，路线价值之和，路线总类数。

c[i]=’L’:{ f[i]=f[i-1]×2, s[i]=s[i-1] }
c[i]=’R’:{ f[i]=f[i-1]×2+s[i-1], s[i]=s[i-1] }
c[i]=’P’:{ f[i]=f[i-1], s[i]=s[i-1] }
c[i]=’ $*$ ’:{ f[i]=f[i-1]×5+s[i-1], s[i]=s[i-1]×3}

注意开滚动数组，压位会更好。

Code：

#include<cstring>
#include<cstdio>
#define fo(i,x,y) for(int i=x;i<=y;i++)
#define fd(i,x,y) for(int i=x;i>=y;i--)
#define mo 10000
using namespace std;

char rp[10005];
int o,f[2][2000],s[2][2000];

void write(int *a){
    printf("%d",a[a[0]]);
    fd(i,a[0]-1,1)
        printf("%04d",a[i]);
}

void pus(int *a,int *b){
    if(a[0]<b[0])
        a[0]=b[0];
    fo(i,1,a[0]){
        a[i]+=b[i];
        a[i+1]+=a[i]/mo;
        a[i]%=mo;
    }
    while(a[a[0]+1]>0)
        a[0]++;
}

void time(int *a,int *b){
    int c[2000];
    memset(c,0,sizeof(c));
    fo(i,1,a[0])
        fo(j,1,b[0]){
            c[i+j-1]+=a[i]*b[j];
            c[i+j]+=c[i+j-1]/mo;
            c[i+j-1]%=mo;
        }
    c[0]=a[0]+b[0]-1;
    while(c[c[0]+1]>0)
        c[0]++;
    fo(i,0,c[0])
        a[i]=c[i];
}   

int main(){
    scanf("%s",rp);
    f[0][0]=f[0][1]=s[0][0]=s[0][1]=1;
    fo(i,0,strlen(rp)-1){
        o=!o;
        memset(f[o],0,sizeof(f[o]));
        memset(s[o],sizeof(s[o]),0);
        if(rp[i]=='L'){
            fo(j,0,s[!o][0])
                s[o][j]=s[!o][j];
            f[o][0]=1; f[o][1]=2;
            time(f[o],f[!o]);
        }
        if(rp[i]=='R'){
            fo(j,0,s[!o][0])
                s[o][j]=s[!o][j];
            f[o][0]=1; f[o][1]=2;
            time(f[o],f[!o]);
            pus(f[o],s[o]);
        }
        if(rp[i]=='P'){
            fo(j,0,s[!o][0])
                s[o][j]=s[!o][j];
            fo(j,0,f[!o][0])
                f[o][j]=f[!o][j];
        }
        if(rp[i]=='*'){
            s[o][0]=1; s[o][1]=3;
            time(s[o],s[!o]);
            f[o][0]=1; f[o][1]=5;
            time(f[o],f[!o]);
            pus(f[o],s[!o]);
        }
    }
    write(f[o]);
}

T3：猴子摘桃

Description

　　动物园内最受欢迎就是猴子了，因为它们除了能爬能跳外还会很多技能。其中A类猴子特别擅长爬树摘桃，而B类猴子擅长把桃子掰成两半。
　　A类猴子有N只,编号为1到N，B类猴子有M只，编号为1到M。A类猴子中的第K只摘到第一个桃子需要花费A_k秒，此后每B_k秒就能摘到桃子；B类猴子中的第K只掰开第一个桃子需要花费C_k秒，此后每D_k秒就能掰开一个桃子。
　　不幸的是，B类猴子非常具有侵略性，两种猴子不能同时待在场地内，因此，园长必须在A类猴子摘完所有桃子后立刻把它们带走，然后立刻让B类猴子进园；同样当B类猴子把所有桃子全部掰开后也不能待在场地内太久，因为它们之间也会发生冲突，所有园长将在B类猴子掰开所有桃子后立刻送走它们。
　　园长带走猴子和猴子进园的速度非常快，时间忽略不计。
　　Alice非常喜欢看B类猴子掰桃子，告诉你表演的总时间，但不知道一共有多少个桃子，请你帮Alice计算B类猴子进入动物园的时刻。

Input

　　输入文件第一行包含一个整数T(1<=T<=1000000000)，表示猴子表演的总时间。
　　接下来一行包含一个整数N(1<=N<=100)，表示A类猴子的数量。
　　接下来N行，每行包含两个整数A_k和B_k（1<=A_k,B_k<=1000000000），描述A类每只猴子摘桃的速度。
　　接下来一行包含一个整数M(1<=M<=100)，表示B类猴子的数量。
　　接下来M行，每行包含两个整数C_k和D_k(1<=C_k,D_k<=1000000000)，描述B类每只猴子掰桃的速度。

Output

　　输出两类猴子进园的时刻相差多少秒。

Sample Input

输入1：

3 1

5 1

输入2：

3 2

1 3

3 1

4 1

5 1

Sample Output

输出1：

输出2：

Hint

　　样例1中，树上有3个桃子：
　　(1) A类猴子在3秒时摘下第一个桃子，在4秒时摘下第二个桃子，在5秒时摘下第三个桃子；
　　(2) 在第5秒，园长把A类猴子带走，此时B类猴子进园；
　　(3) B类猴子在10秒时掰开第一个桃子，在11秒时掰开第二个桃子，在第12秒时掰开第三个桃子；
　　(4) 在12秒时园长进园带走B类猴子。
　
比较容易想到二分答案。

然后求出A和B能搞的桃子数，分别是s1，s2。

s1<=s2,ans=mid,l=mid+1;
s1>s2,r=mid-1;

自己yy为什么是这样？

Code：

#include<cstdio>
#define fo(i,x,y) for(int i=x;i<=y;i++)
using namespace std;

int t,n,m,l,r,s1,s2,mid,ans;
struct cc{
    int a,b;
}a[101],b[101];

int main(){
    scanf("%d",&t);
    scanf("%d",&n);
    fo(i,1,n)
        scanf("%d%d",&a[i].a,&a[i].b);
    scanf("%d",&m);
    fo(i,1,m)
        scanf("%d%d",&b[i].a,&b[i].b);
    l=0; r=t;
    while(l<=r){
        mid=(l+r)/2;
        s1=s2=0;
        fo(i,1,n)
            if(mid>=a[i].a)
                s1+=1+(mid-a[i].a)/a[i].b;
        fo(i,1,m)
            if(t-mid>=b[i].a)
                s2+=1+(t-mid-b[i].a)/b[i].b;
        if(s1<=s2){
            ans=mid;
            l=mid+1;
        } else r=mid-1;
    }
    printf("%d",ans);
}