NOIP2012复赛DAY1

NOIP2012——DAY1

1、Vigenère 密码

【题目分析】
这就是一道找规律的题目，可别忘了将自己找出的规律多模拟几次，不然就有可能悲剧了。

【代码】

#include<cstdio>
#include<cstring>
char A[1005],a[1005],B[1005];
int main(){
    scanf("%s %s",a,B);
    int n=strlen(a),m=strlen(B);
    for(int i=0;i<m;i++){
        int ok=0;
        A[i]=a[i%n];
        if(A[i]<='Z')A[i]+=32;
        if(B[i]<='Z')B[i]+=32,ok=32;
        int k=B[i]-A[i]+27;
        if(k>=1&&k<=26)printf("%c",k-ok+'a'-1);
        else printf("%c",k-ok+'a'-27);
    }puts("");
    return 0;
}

2、国王游戏

【题目分析】
看到数据的范围，只有40%数据是可以用二进制过的。然而这也打消我们暴力枚举的念头。
思路从枚举到了贪心。
如果相邻的两个大臣进行交换，对之后的区间的答案并不影响。
就要进行神奇的数学推导%&*%&……（）&
推得—>如果

$$ai*bi<a(i+1)*b(i+1)$$
那么答案会更优。
如果就这样也挺好，但为什么还要考我的臭臭的高精！！

【代码】

#define M 1005
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define P 10000
using namespace std;
struct node{
    int l,r;
}a[M];
bool cmp(node x,node y){
    int m1=x.l*x.r;
    int m2=y.l*y.r;
    if(m1!=m2)return m1<m2;
    return x.r>y.r;
}
struct Bint{
    int num[5005],sz;
    Bint(){
        memset(num,0,sizeof(num));
        sz=0;
    }
    Bint operator*(const Bint &x){
        Bint t;
        for(int i=0;i<sz;i++){
            for(int j=0;j<x.sz;j++){
                t.num[i+j]+=num[i]*x.num[j];
                t.num[i+j+1]+=t.num[i+j]/P;
                t.num[i+j]%=P;
            }
        }
        int SZ=sz+x.sz-1;
        if(t.num[SZ])SZ++;
        t.sz=SZ;
        return t;
    }
    Bint operator/(const int &x){
        Bint t;
        for(int i=0;i<sz;i++)t.num[i]=num[i];
        t.sz=sz;
        int an=0;
        for(int i=sz-1;i>=0;i--)
            if(i)t.num[i-1]+=(t.num[i]%x)*P;
        for(int i=sz-1;i>=0;i--)
            t.num[i]/=x;
        while(!t.num[t.sz-1]&&t.sz>1)t.sz--;
        return t;
    }
    bool operator>(const Bint &x)const{
        if(sz>x.sz)return 1;
        else if(sz<x.sz)return 0;
        for(int i=sz-1;i>=0;i--){
            if(num[i]>x.num[i])return 1;
            else if(num[i]<x.num[i])return 0;
        }return 0;
    }
    void Print(){
        printf("%d",num[sz-1]);
        for(int i=sz-2;i>=0;i--)printf("%04d",num[i]);
        puts("");
    }//事实证明，这个十分好用
}sum,ans;
int main(){
    int i,j,n;
    scanf("%d",&n);
    for(i=0;i<=n;i++)scanf("%d %d",&a[i].l,&a[i].r);
    sort(a+1,a+n+1,cmp);
    int k=a[0].l;
    int len=0;
    while(k){
        sum.num[len++]=k%P;
        k/=P;
    }sum.sz=len;
    for(i=1;i<=n;i++){
        Bint res=sum/a[i].r;
        if(res>ans)ans=res;
        Bint w;
        k=a[i].l,len=0;
        while(k){
            w.num[len++]=k%P;
            k/=P;
        }w.sz=len;
        sum=sum*w;
    }
    ans.Print();
    return 0;   
}

3、开车旅行

【题目分析】
看了几遍题目，发现这是一道模拟题，可普通的去模拟，超时是妥妥的。首先，我们一定要先预处理出在当前这个点，A和B会去向那个城市（否则每次在模拟的时候，还要先知道要去哪里，这也太鬼畜了）。我们可以用一个对来维护高度有序，A和B要去的点一定是大于等于h[i]的两个和小于h[i]的两个点。
其次，我们也可以知道需要花费的时间。我们基于以往做LCA等在树上操作的题目的想法，知道了可以用倍增来”跳”（花费的时间也同理可以处理出来）。这一题也就解决了。

【代码】

#include<set>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#define M 1000005
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
void Rd(int &res){
    char c;res=0;int k=1;
    while(c=getchar(),!isdigit(c)&&c!='-');
    if(c=='-')k=-1,c=getchar();
    do{res=(res<<3)+(res<<1)+(c^48);}while(c=getchar(),isdigit(c));
    res*=k;
}
template<class T>void Pt(T x){
    if(x==0)return;
    Pt(x/10);
    putchar(x%10^48);
}
template<class T>void Ps(T x){
    if(x==0)putchar('0');
    else Pt(x);
}
struct City{
    int h,p;
    bool operator<(const City rhs)const{return h<rhs.h;}
}h[M];
set<City>S;
set<City>::iterator it,it1;
int n,x0,m,next[2][M],dist[2][M],g[M][21];
ll f[M][21][2];
void update(City x,City y){
    ll cha=abs(x.h-y.h);
    if(!next[0][x.p]){
        next[0][x.p]=y.p;
        dist[0][x.p]=cha;
    }
    else if(cha<dist[0][x.p]||(cha==dist[0][x.p]&&y.h<h[next[0][x.p]].h)){
        next[1][x.p]=next[0][x.p];
        dist[1][x.p]=dist[0][x.p];
        next[0][x.p]=y.p;
        dist[0][x.p]=cha;
    }
    else if(cha<dist[1][x.p]||(cha==dist[1][x.p]&&y.h<h[next[1][x.p]].h)){
        next[1][x.p]=y.p;
        dist[1][x.p]=cha;
    }
    else if(!next[1][x.p]){
        next[1][x.p]=y.p;
        dist[1][x.p]=cha;
    }
}
void ask(int s,int x,ll &dista,ll &distb){
    for(int i=18;i>=0;i--){
        if(f[s][i][0]+f[s][i][1]<=x&&g[s][i]){
            dista+=f[s][i][0];
            distb+=f[s][i][1];
            x-=f[s][i][0]+f[s][i][1];
            s=g[s][i];
        }
    }if(next[1][s]&&dist[1][s]<=x)dista+=dist[1][s];
}
void Init(){
    Rd(n);
    for(int i=1;i<=n;i++)Rd(h[i].h),h[i].p=i;
    for(int i=n;i;i--){
        S.insert(h[i]);
        it=S.find(h[i]);it1=it;
        if(it!=S.begin()){
            it--;//前一个 
            update(h[i],*it);
            if(it!=S.begin()){
                it--;//再前一个 
                update(h[i],*it);
            }
        }
        if((++it1)!=S.end()){//后一个，等等 
            update(h[i],*it1);
            if((++it1)!=S.end())update(h[i],*it1);
        }
    }
    for(int i=1;i<=n;i++){
        f[i][0][0]=dist[1][i];
        g[i][0]=next[0][next[1][i]];
        f[i][0][1]=dist[0][next[1][i]];
    }
    for(int j=1;j<=18;j++){
        for(int i=1;i<=n;i++){
            g[i][j]=g[g[i][j-1]][j-1];
            f[i][j][0]=f[i][j-1][0]+f[g[i][j-1]][j-1][0];
            f[i][j][1]=f[i][j-1][1]+f[g[i][j-1]][j-1][1];
        }
    }
}
int main(){
    Init();
    int s0=1;
    ll a=1e15,b=0;
    Rd(x0);
    for(int i=1;i<=n;i++){
        ll dista=0,distb=0;
        ask(i,x0,dista,distb);
        if(!distb){
            if(!b&&h[i].h>h[s0].h)s0=i;
        }//else if(!b)
        else if(distb&&(!s0||1.0*a*distb>1.0*b*dista))s0=i,a=dista,b=distb;//防止精度不够，故用乘 
        else if(distb&&(!s0||1.0*a*distb==1.0*b*dista)){
            if(h[i].h>h[s0].h)s0=i;
        }   
    }Ps(s0);putchar('\n');

    Rd(m);
    while(m--){
        int s,x;
        Rd(s),Rd(x);
        ll dista=0,distb=0;
        ask(s,x,dista,distb);
        Ps(dista),putchar(' '),Ps(distb),putchar('\n');
    }return 0;
}

【思路】
1、模拟。
2、枚举->贪心。
3、模拟->倍增。

总的来说，第一题不会占用太多的时间。至于第二题，要跟着解题的思路（枚举->贪心）来想，也是比较容易想清楚的。而第三题，从单纯的模拟出发，然后着手于复杂度堆积的地方的优化，也就解决了。