2012 Noip提高组 Day1

1262. [NOIP2012] Vigenère 密码

★ 输入文件：vigenere.in 输出文件：vigenere.out 简单对比
时间限制：1 s 内存限制：128 MB

【题目描述】

16 世纪法国外交家Blaise de Vigenère设计了一种多表密码加密算法——Vigenère密码。Vigenère 密码的加密解密算法简单易用，且破译难度比较高，曾在美国南北战争中为南军所广泛使用。

在密码学中，我们称需要加密的信息为明文，用 M 表示；称加密后的信息为密文，用C 表示；而密钥是一种参数，是将明文转换为密文或将密文转换为明文的算法中输入的数据，记为k。在Vigenère密码中，密钥k是一个字母串， k=k1k2…kn。当明文M=m1m2…mn时，得到的密文C=c1c2…cn，其中ci=mi®ki，运算®的规则如下表所示：

Vigenère加密在操作时需要注意：

1. ®运算忽略参与运算的字母的大小写，并保持字母在明文 M中的大小写形式；

2. 当明文M的长度大于密钥k的长度时，将密钥k 重复使用。

例如，明文M=Helloworld，密钥k=abc 时，密文C=Hfnlpyosnd。

明文	H	e	l	l	o	w	o	r	l	d
密钥	a	b	c	a	b	c	a	b	c	a
密文	H	f	n	l	p	y	o	s	n	d

【输入格式】

输入共2行。

第一行为一个字符串，表示密钥k，长度不超过100，其中仅包含大小写字母。第二为一个字符串，表示经加密后的密文，长度不超过1000，其中仅包含大小写字母。

【输出格式】

输出共1行，一个字符串，表示输入密钥和密文所对应的明文。

【样例输入】

CompleteVictory

Yvqgpxaimmklongnzfwpvxmniytm

【样例输出】

Wherethereisawillthereisaway

【数据说明】

对于 100%的数据，输入的密钥的长度不超过 100，输入的密文的长度不超过 1000，且都仅包含英文字母。

自动选择评测机

打开 O2 优化
COGS Grader
无优化开关

提交代码 Pascal C C++

/*

    用a数组记录密钥与明文之间的联系（题中所给表）

    b数组则记录秘钥与秘闻之间的联系

*/

#include<iostream>

#include<cstdio>

#include<cstring>

using namespace std;

int a[][],b[][],c[],a1[][],a2[][];

char s[],c1[],ans[];

int main(){

    //freopen("Cola.txt","r",stdin);

    freopen("vigenere.in","r",stdin);

    freopen("vigenere.out","w",stdout);

    for(int i=;i>=;i--)

        for(int j=;j>=i;j--)

            a1[i][j]=a1[j][i]=(i+j)%;

    for(int i=;i<=;i++)

        for(int j=;j<=i;j++)

            a2[i][j]=a2[j][i]=i+j-;

    for(int i=;i<=;i++)

        for(int j=;j<=-i+;j++)

        a[i][j]=a2[i][j];

    for(int i=;i<=;i++){

        for(int j=-i;j<=;j++)

        a[i][j]=a1[i][j];

    }

    for(int i=;i<=;i++)

        for(int j=;j<=;j++)

            b[i][a[i][j]]=j;

    scanf("%s",c1+);scanf("%s",s+);

    int lenc=strlen(c1+),len=strlen(s+);

    for(int i=;i<=lenc;i++){

        if(c1[i]<'a')c[i]=c1[i]-'A'+;

        else c[i]=c1[i]-'a'+;

    }

    int cnt=;

    for(int i=;i<=len;i++){

        bool flag=;int tp;

        if(s[i]<'a')flag=,s[i]=s[i]-'A'+;

        else s[i]=s[i]-'a'+;tp=s[i];

        cnt++;if(cnt>lenc)cnt=;

        int tmp=c[cnt];

        ans[i]=b[tmp][tp];

        if(flag)ans[i]+='A'-;

        else ans[i]+='a'-;

    }

    for(int i=;i<=len;i++)cout<<ans[i];

}

1263. [NOIP2012] 国王游戏

★★☆ 输入文件：kinggame.in 输出文件：kinggame.out 简单对比
时间限制：1 s 内存限制：128 MB

【题目描述】

恰逢 H 国国庆，国王邀请 n 位大臣来玩一个有奖游戏。首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。然后，让这
n位大臣排成一排，国王站在队伍的最前面。排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是：排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。

国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。注意，国王的位置始终在队伍的最前面。

【输入格式】

第一行包含一个整数 n，表示大臣的人数。

第二行包含两个整数a和b，之间用一个空格隔开，分别表示国王左手和右手上的整数。

接下来n行，每行包含两个整数a和b，之间用一个空格隔开，分别表示每个大臣左手和右手上的整数。

【输出格式】

输出只有一行，包含一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。

【样例输入】

【样例输出】

【输入输出样例说明】

按 1、2、3号大臣这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 1、3、2这样排列队伍，获得奖赏最多的大臣所获得金币数为2；

按 2、1、3这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 2、3、1这样排列队伍，获得奖赏最多的大臣所获得金币数为 9；

按 3、1、2这样排列队伍，获得奖赏最多的大臣所获得金币数为 2；

按 3、2、1这样排列队伍，获得奖赏最多的大臣所获得金币数为 9。

因此，奖赏最多的大臣最少获得 2 个金币，答案输出 2。

【数据范围】

对于20%的数据，有1≤ n≤ 10，0 < a、b < 8；

对于40%的数据，有1≤ n≤20，0 < a、b < 8；

对于60%的数据，有1≤ n≤100；

对于60%的数据，保证答案不超过 10^9；

对于100%的数据，有 1 ≤ n ≤1,000，0 < a、b < 10^5。

自动选择评测机
打开 O2 优化
COGS Grader
无优化开关

提交代码 Pascal C C++

贪心策略：左右手乘积最小排在前

　　证：x1　　y1

　　　　x2　　y2　　

　　　　...　　 ...

　　　　-----------　　

　　　　xa　　ya

　　　　xb　　yb

　　　　----------

　　　　...　　...

　　　　按 (xi*yi) 从小到大排序

　　　　如果相邻的两个人交换位置，只会影响到这两个人的值，不会影响他人

　　　　在xa之前的乘积是一定的我们假设为 S

　　　　xa，ya 和xb，yb交换前

　　　 xa 获得的金币为(S/ya) 记为 X

　　　　xb 获得的金币为((S*xa)/yb) 记为 Y

　　　　xa，ya 和xb，yb交换后

　　　　xa 获得的金币为(S/yb) 记为 P

　　　　xb 获得的金币为((S*xb)/ya) 记为 Q

　　　　结果是找 max(X,Y) 和max(P,Q)之中小的那个数

　　　　两个max同乘yayb之后

　　　　X 为(S*yb) Y为 (S*xa*ya)

　　　　P 为(S*ya) Q为 (S*xb*yb)

　　　　由于要让最大值尽量小那么

　　　　　　　因为，xa*ya <= xb*yb

　　　　所以，S*xa/yb<= S*xb/ya

　　　　又因为，S/yb <= S*xa/yb

　　　　所以，ans2=S* xb/ya

　　　　ans1=max{S/ya,S*xa/yb}

　　　　所以，ans1<=ans2

　　　　所以我们可以得出 xi*yi 最小时策略最优

/*

    写个60分的散了，高妮马精啊

*/

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstdlib>

using namespace std;

#define ll long long

int n,x,y;

struct node{

    ll l,r,mul;

}a[];

int cmp(node c,node d){

    return c.mul<d.mul;

}

int main(){

    freopen("kinggame.in","r",stdin);

    freopen("kinggame.out","w",stdout);

    scanf("%d%d%d",&n,&x,&y);

    int cnt=;

    for(int i=;i<=n;i++){

        cnt++;

        scanf("%lld%lld",&a[cnt].l,&a[cnt].r);

        a[cnt].mul=a[cnt].l*a[cnt].r;

    }

    sort(a+,a+n+,cmp);

    ll ans=,sum=x;

    for(int i=;i<=n;i++){

        ans=max(ans,sum/a[i].r);

        sum*=a[i].l;

    }

    cout<<ans;

}

60分不加高精

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstring>

using namespace std;

const int maxn=;

int n,kingz,kingy,a1[maxn],b1[maxn];

struct node1{

    int zuo,you;

}e[maxn];

struct node2{

    int zu[maxn];

    int len;

    node2 operator * (const int x)const{

        memset(a1,,sizeof(a1));

        memset(b1,,sizeof(b1));

        node2 res;res.len=;

        for(int i=,j=len;i<=len;++i,--j)a1[i]=zu[j];

        for(int i=;i<=len;i++){

            b1[i]+=a1[i]*x;

            b1[i+]+=b1[i]/;

            b1[i]%=;

        }

        int Len=len;

        while(b1[Len+]>=){

            b1[Len+]+=b1[Len+]/;

            b1[Len+]%=;

            Len++;

        }

        if(b1[Len+])Len++;

        res.len=Len;

        for(int i=,j=Len;i<=Len;++i,--j)res.zu[i]=b1[j];

        return res;

    }

    node2 operator / (const int x)const{

        memset(a1,,sizeof(a1));

        node2 res;res.len=;

        int y=;

        for(int i=;i<=len;i++){

            a1[i]=(y*+zu[i])/x;

            y=(y*+zu[i])-a1[i]*x;

        }

        int l=;

        while(a1[l]==)l++;

        for(int i=l;i<=len;++i)

            res.zu[++res.len]=a1[i];

        return res;

    }

}p,ans;

int cmp(node1 x,node1 y){

    return x.zuo*x.you<y.zuo*y.you;

}

void Insert(int x){

    memset(a1,,sizeof(a1));

    int len=;

    while(x){

        a1[++len]=x%;

        x/=;

    }

    p.len=len;

    for(int i=,j=len;i<=len;i++,j--)

        p.zu[i]=a1[j];

}

inline node2 Max(node2 x,node2 y){

    if(x.len>y.len)return x;

    if(x.len<y.len)return y;

    for(register int i=;i<=x.len;i++){

        if(x.zu[i]>y.zu[i])return x;

        if(x.zu[i]<y.zu[i])return y;

    }

    return x;

}

int main(){

    //freopen("Cola.txt","r",stdin);

    scanf("%d%d%d",&n,&kingz,&kingy);

    for(int i=;i<=n;++i)

        scanf("%d%d",&e[i].zuo,&e[i].you);

    sort(e+,e+n+,cmp);

    Insert(kingz);

    for(int i=;i<=n;++i){

        node2 now=p/e[i].you;

        ans=Max(ans,now);

        p=p*e[i].zuo;

    }

    for(int i=;i<=ans.len;++i)

        printf("%d",ans.zu[i]);

    return ;

}

100分高精

1264. [NOIP2012] 开车旅行

★★☆ 输入文件：drive.in 输出文件：drive.out 简单对比
时间限制：2 s 内存限制：128 MB

【题目描述】

小A 和小B决定利用假期外出旅行，他们将想去的城市从1到N 编号，且编号较小的城市在编号较大的城市的西边，已知各个城市的海拔高度互不相同，记城市 i的海拔高度为Hi，城市 i 和城市 j 之间的距离 d[i,j]恰好是这两个城市海拔高度之差的绝对值，即d[i, j] = |Hi − Hj|。

旅行过程中，小A 和小B轮流开车，第一天小A 开车，之后每天轮换一次。他们计划选择一个城市 S 作为起点，一直向东行驶，并且最多行驶 X 公里就结束旅行。小 A 和小B的驾驶风格不同，小 B 总是沿着前进方向选择一个最近的城市作为目的地，而小 A 总是沿着前进方向选择第二近的城市作为目的地（注意：本题中如果当前城市到两个城市的距离相同，则认为离海拔低的那个城市更近）。如果其中任何一人无法按照自己的原则选择目的城市，或者到达目的地会使行驶的总距离超出X公里，他们就会结束旅行。

在启程之前，小A 想知道两个问题：

1．对于一个给定的 X=X0，从哪一个城市出发，小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值最小（如果小 B的行驶路程为0，此时的比值可视为无穷大，且两个无穷大视为相等）。如果从多个城市出发，小A 开车行驶的路程总数与小B行驶的路程总数的比值都最小，则输出海拔最高的那个城市。

2.对任意给定的 X=Xi和出发城市 Si，小 A 开车行驶的路程总数以及小 B 行驶的路程总数。

【输入格式】

第一行包含一个整数 N，表示城市的数目。

第二行有 N 个整数，每两个整数之间用一个空格隔开，依次表示城市 1 到城市 N 的海拔高度，即H1，H2，……，Hn，且每个Hi都是不同的。

第三行包含一个整数 X0。

第四行为一个整数 M，表示给定M组Si和 Xi。

接下来的M行，每行包含2个整数Si和Xi，表示从城市 Si出发，最多行驶Xi公里。

【输出格式】

输出共M+1 行。

第一行包含一个整数S0，表示对于给定的X0，从编号为S0的城市出发，小A开车行驶的路程总数与小B行驶的路程总数的比值最小。

接下来的 M 行，每行包含 2 个整数，之间用一个空格隔开，依次表示在给定的 Si和Xi下小A行驶的里程总数和小B 行驶的里程总数。

【样例输入 1】

【样例输出 1】

【输入输出样例 1 说明】

各个城市的海拔高度以及两个城市间的距离如上图所示。

如果从城市1出发，可以到达的城市为2,3,4，这几个城市与城市 1的距离分别为 1,1,2，但是由于城市3的海拔高度低于城市 2，所以我们认为城市 3离城市 1最近，城市 2离城市1 第二近，所以小 A 会走到城市 2。到达城市 2 后，前面可以到达的城市为 3,4，这两个城市与城市 2 的距离分别为 2,1，所以城市 4离城市 2最近，因此小 B 会走到城市 4。到达城市4后，前面已没有可到达的城市，所以旅行结束。

如果从城市2出发，可以到达的城市为3,4，这两个城市与城市 2 的距离分别为 2,1，由于城市3离城市2第二近，所以小A会走到城市 3。到达城市3后，前面尚未旅行的城市为4，所以城市 4 离城市 3 最近，但是如果要到达城市 4，则总路程为 2+3=5>3，所以小 B 会直接在城市3结束旅行。

如果从城市3出发，可以到达的城市为4，由于没有离城市3 第二近的城市，因此旅行还未开始就结束了。

如果从城市4出发，没有可以到达的城市，因此旅行还未开始就结束了。

【样例输入 2】

10

4 5 6 1 2 3 7 8 9 10

7

10

1 7

2 7

3 7

4 7

5 7

6 7

7 7

8 7

9 7

10 7

【样例输出 2】

【输入输出样例 2 说明】

当 X=7时，

如果从城市1出发，则路线为 1 -> 2 -> 3 -> 8 -> 9，小A 走的距离为1+2=3，小B走的距离为 1+1=2。（在城市 1 时，距离小 A 最近的城市是 2 和 6，但是城市 2 的海拔更高，视为与城市1第二近的城市，所以小A 最终选择城市 2；走到9后，小A只有城市10 可以走，没有第2选择可以选，所以没法做出选择，结束旅行）

如果从城市2出发，则路线为 2 -> 6 -> 7 ，小A 和小B走的距离分别为 2，4。

如果从城市3出发，则路线为 3 -> 8 -> 9，小A和小B走的距离分别为 2，1。

如果从城市4出发，则路线为 4 -> 6 -> 7，小A和小B走的距离分别为 2，4。

如果从城市5出发，则路线为 5 -> 7 -> 8 ，小A 和小B走的距离分别为 5，1。

如果从城市6出发，则路线为 6 -> 8 -> 9，小A和小B走的距离分别为 5，1。

如果从城市7出发，则路线为 7 -> 9 -> 10，小A 和小B走的距离分别为 2，1。

如果从城市8出发，则路线为 8 -> 10，小A 和小B走的距离分别为2，0。

如果从城市 9 出发，则路线为 9，小 A 和小 B 走的距离分别为 0，0（旅行一开始就结束了）。

如果从城市10出发，则路线为 10，小A 和小B 走的距离分别为0，0。

从城市 2 或者城市 4 出发小 A 行驶的路程总数与小 B 行驶的路程总数的比值都最小，但是城市2的海拔更高，所以输出第一行为2。

【数据范围】

对于30%的数据，有1≤N≤20，1≤M≤20；

对于40%的数据，有1≤N≤100，1≤M≤100；

对于50%的数据，有1≤N≤100，1≤M≤1,000；

对于70%的数据，有1≤N≤1,000，1≤M≤10,000；

对于100%的数据，有1≤N≤100,000， 1≤M≤10,000， -1,000,000,000≤Hi≤1,000,000,000，0≤X0≤1,000,000,000，1≤Si≤N，0≤Xi≤1,000,000,000，数据保证Hi互不相同。

自动选择评测机

打开 O2 优化
COGS Grader
无优化开关

提交代码 Pascal C C++

/*

    首先想到的是模拟，第一问枚举起点，然后一二问都让A和B一步一步来

    发现，A和B的移动类似于寻找lca，让两个点同时向上移动

    寻找lca可以用倍增的方法节约大把时间，同样的，这里也可以用倍增处理

    把A和B的一个轮换看成一个最小周期，进行倍增，go[j][i]表示从j出发2^i个周期后到达的点

    disA[j][i]是从j出发第2^i个周期中A开车移动的最短路程

    disB[j][i]是从j出发第2^i个周期中A开车移动到的点再由B开车向后移动一次的最短路程

*/

#include<iostream>

#include<algorithm>

#include<cstdio>

using namespace std;

#define N 110000

#define inf 1000000010

int n,m,H[N],a[N],x[N];

int pre[N],ne[N],neA[N],neB[N];

int go[N][],disA[N][],disB[N][];

int cmp(int x,int y){

    return H[x]<H[y];

}

void updata(int k1,int k2){

    if(neA[k1]==n+||(abs(H[k1]-H[k2])<abs(H[k1]-H[neA[k1]]))||(abs(H[k1]-H[k2])==abs(H[k1]-H[neA[k1]])&&H[k1]<H[neA[k1]]))

        neB[k1]=neA[k1],neA[k1]=k2;

    else if(neB[k1]==n+||(abs(H[k1]-H[k2])<abs(H[k1]-H[neB[k1]]))||(abs(H[k1]-H[k2])==abs(H[k1]-H[neB[k1]])&&H[k1]<H[neB[k1]]))

        neB[k1]=k2;

}

int main(){

    freopen("drive.in","r",stdin);

    freopen("drive.out","w",stdout);

    //freopen("Cola.txt","r",stdin);

    scanf("%d",&n);

    for(int i=;i<=n;i++)scanf("%d",&H[i]);

    for(int i=;i<=n;i++)a[i]=i;

    sort(a+,a+n+,cmp);

    for(int i=;i<=n;i++)x[a[i]]=i;

    for(int i=;i<=n;i++)pre[i]=i-,ne[i]=i+;

    pre[n+]=n,ne[]=;

    int k1;

    for(int now=;now<=n;now++){

        neA[now]=n+;neB[now]=n+;

        k1=ne[x[now]];

        for(int i=;i<=&&k1!=n+;k1=ne[k1],i++)updata(now,a[k1]);

        k1=pre[x[now]];

        for(int i=;i<=&&k1!=;k1=pre[k1],i++)updata(now,a[k1]);

        k1=x[now];

        pre[ne[k1]]=pre[k1];ne[pre[k1]]=ne[k1];

        swap(neA[now],neB[now]);

    }

    neA[n+]=n+;neB[n+]=n+;

    for(int i=;i<=n+;i++){

        int k1=neA[i],k2=neB[k1];

        go[i][]=k2;

        disA[i][]=min(inf,abs(H[k1]-H[i]));

        disB[i][]=min(inf,abs(H[k2]-H[k1]));

        if(k1>n)disA[i][]=inf;

        if(k2>n)disB[i][]=inf;

    }

    for(int i=;i<=;i++){

        for(int j=;j<=n+;j++){

            go[j][i]=go[go[j][i-]][i-];

            disA[j][i]=min(inf,disA[j][i-]+disA[go[j][i-]][i-]);

            disB[j][i]=min(inf,disB[j][i-]+disB[go[j][i-]][i-]);

        }

    }

    int x0;

    scanf("%d",&x0);

    int ans=,ansA=,ansB=;

    for(int now=;now<=n;now++){//第一问，枚举起点

        int k1=,k2=,k=now,rem=x0;

        for(int i=;i>=;i--){

            if(disA[k][i]+disB[k][i]<=rem){

                rem-=disA[k][i]+disB[k][i];

                k1+=disA[k][i];

                k2+=disB[k][i];

                k=go[k][i];

            }

        }

        if(disA[k][]<=rem){

            rem-=disA[k][];

            k1+=disA[k][];

        }

        if(k2==){

            if(ans==||(ansB==&&H[now]>H[ans])){

                ans=now;

                ansA=k1;

                ansB=k2;

            }

            continue;

        }

        if(ans==||(1LL*k1*ansB<1LL*k2*ansA)||(1LL*k1*ansB==1LL*k2*ansA&&H[now]>H[ans])){

            ans=now;

            ansA=k1;

            ansB=k2;

        }

    }

    printf("%d\n",ans);

    scanf("%d",&m);

    while(m--){

        int k1=,k2=,k,rem;

        scanf("%d%d",&k,&rem);

        for(int i=;i>=;i--){

            if(disA[k][i]+disB[k][i]<=rem){

                rem-=disA[k][i]+disB[k][i];

                k1+=disA[k][i];

                k2+=disB[k][i];

                k=go[k][i];

            }

        }

        if(disA[k][]<=rem){

            rem-=disA[k][];

            k1+=disA[k][];

        }

        printf("%d %d\n",k1,k2);

    }

    return ;

}