NOIP 2012 试做

vigenere Vigenère 密码
简单的字符串处理，为什么在暑假的时候我要打400行的表= =

题目描述 Description
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。
输入描述 Input Description
输入共2行。

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

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

数据范围及提示 Data Size & Hint
对于 100%的数据，输入的密钥的长度不超过 100，输入的密文的长度不超过 1000，且都仅包含英文字母。

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
using namespace std;
char k[2006];
string a,b;
char mw[2006];
int dx[]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25};
int xx[]={0};
void deal()
{
    for(int i=1;i<=b.size();i++)
    {
        if('a'<=mw[i]&&mw[i]<='z')
        {
            if('a'<=k[i]&&k[i]<='z')
                mw[i]-=dx[k[i]-'a'];
            else
                mw[i]-=dx[k[i]-'A'];

            if(mw[i]<'a')
                mw[i]+=26;
        }
        else if('A'<=mw[i]&&mw[i]<='Z')
        {
            if('a'<=k[i]&&k[i]<='z')
                mw[i]-=dx[k[i]-'a'];
            else
                mw[i]-=dx[k[i]-'A'];

            if(mw[i]<'A')
                mw[i]+=26;
        }
        printf("%c",mw[i]);
    }
}
int main()
{

    cin>>a>>b;
    for(int i=0;i<a.size();i++)
        k[i+1]=a[i];
    for(int i=0;i<b.size();i++)
        mw[i+1]=b[i];

    for(int i=1;i<=b.size();i++)
        k[i+a.size()]=k[i];
    deal();
    return 0;
}

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

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

输入描述 Input Description
第一行包含一个整数 n，表示大臣的人数。

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

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

输出描述 Output Description
输出只有一行，包含一个整数，表示重新排列后的队伍中获奖赏最多的大臣所获得的
金币数。
【数据范围】
对于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 < 10000。

这个题是个贪心…并且对于100%的数据需要打高精= =。
很久以前做过但是忘了贪心的思路，所以我就写了6种贪心取最优解…并且成功60分了…

#include<algorithm>
#include<cstdio>
using namespace std;
typedef long long ll;
const int maxn=1005;
ll a,b;
struct meico
{
    ll l;
    ll r;
}sz[maxn];
int n;
ll anss=0x7ffffffffffffff;
bool cmp1(meico a,meico b)
{
    return a.l<b.l;
}
bool cmp2(meico a,meico b)
{
    return a.r<b.r;
}
bool cmp3(meico a,meico b)
{
    return (a.l*a.r)<(b.l*b.r);
}
bool cmp4(meico a,meico b)
{
    return a.l>b.l;
}
bool cmp5(meico a,meico b)
{
    return a.r>b.r;
}
bool cmp6(meico a,meico b)
{
    return (a.l*a.r)>(b.l*b.r);
}

void tx1()
{
    sort(sz+1,sz+1+n,cmp1);
    ll tmp=a;
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        meico m=i[sz];
        ll hah=tmp/m.r;
        ans=max(ans,hah),tmp*=m.l;
    }
    anss=min(ans,anss); 
}
void tx2()
{
    sort(sz+1,sz+1+n,cmp2);
    ll tmp=a;
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        meico m=i[sz];
        ll hah=tmp/m.r;
        ans=max(ans,hah);
        tmp*=m.l;
    }
    anss=min(ans,anss); 
}
void tx3()
{   
    sort(sz+1,sz+1+n,cmp3);
    ll tmp=a;
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        meico m=i[sz];
        ll hah=tmp/m.r;
        ans=max(ans,hah);
        tmp*=m.l;
    }
    anss=min(ans,anss); 
}
void tx4()
{   
    sort(sz+1,sz+1+n,cmp4);
    ll tmp=a;
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        meico m=i[sz];
        ll hah=tmp/m.r;
        ans=max(ans,hah);
        tmp*=m.l;
    }
    anss=min(ans,anss); 
}
void tx5()
{   
    sort(sz+1,sz+1+n,cmp5);
    ll tmp=a;
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        meico m=i[sz];
        ll hah=tmp/m.r;
        ans=max(ans,hah);
        tmp*=m.l;
    }
    anss=min(ans,anss); 
}
void tx6()
{   
    sort(sz+1,sz+1+n,cmp6);
    ll tmp=a;
    ll ans=0;
    for(int i=1;i<=n;i++)
    {
        meico m=i[sz];
        ll hah=tmp/m.r;
        ans=max(ans,hah);
        tmp*=m.l;
    }
    anss=min(ans,anss); 
}
int main()
{
    scanf("%d",&n);
    scanf("%lld %lld",&a,&b);
    for(int i=1;i<=n;i++)
        scanf("%lld%lld",&i[sz].l,&i[sz].r);
    tx1(),tx2(),tx3();
    tx4(),tx5(),tx6();
    printf("%lld",anss);
    return 0;
}

drive开车旅行

暴力分也恶心到不行…..暴力打ci了总共骗到5分，这里就不放代码了…

mod同余方程
exgcd裸题

classroom借教室

题目描述 Description
在大学期间，经常需要租借教室。大到院系举办活动，小到学习小组自习讨论，都需要
向学校申请借教室。教室的大小功能不同，借教室人的身份不同，借教室的手续也不一样。
面对海量租借教室的信息，我们自然希望编程解决这个问题。
我们需要处理接下来n天的借教室信息，其中第i天学校有ri个教室可供租借。共有m份
订单，每份订单用三个正整数描述，分别为dj, sj, tj，表示某租借者需要从第sj天到第tj天租
借教室（包括第sj天和第tj天），每天需要租借dj个教室。
我们假定，租借者对教室的大小、地点没有要求。即对于每份订单，我们只需要每天提
供dj个教室，而它们具体是哪些教室，每天是否是相同的教室则不用考虑
借教室的原则是先到先得，也就是说我们要按照订单的先后顺序依次为每份订单分配教
室。如果在分配的过程中遇到一份订单无法完全满足，则需要停止教室的分配，通知当前申
请人修改订单。这里的无法满足指从第sj天到第tj天中有至少一天剩余的教室数量不足dj个。
现在我们需要知道，是否会有订单无法完全满足。如果有，需要通知哪一个申请人修改
订单。

输入描述 Input Description
第一行包含两个正整数n, m，表示天数和订单的数量。
第二行包含n个正整数，其中第i个数为ri，表示第i天可用于租借的教室数量。
接下来有m行，每行包含三个正整数dj, sj, tj，表示租借的数量，租借开始、结束分别在
第几天。
每行相邻的两个数之间均用一个空格隔开。天数与订单均用从1开始的整数编号。

输出描述 Output Description
如果所有订单均可满足，则输出只有一行，包含一个整数 0。否则（订单无法完全满足）
输出两行，第一行输出一个负整数-1，第二行输出需要修改订单的申请人编号。

【数据范围】
对于 10%的数据，有1 ≤ n, m ≤ 10；
对于 30%的数据，有1 ≤ n, m ≤ 1000；
对于 70%的数据，有1 ≤ n, m ≤ 10^5；
对于 100%的数据，有1 ≤ n, m ≤ 10^6, 0 ≤ ri, dj≤ 10^9, 1 ≤ sj≤ tj≤ n。

这个题正解是二分….也可以用线段树来水分啊。昨天晚上一份打ci了的二分和打ci了的线段树拍了2600组 = =，内心是崩溃的。

二分AC代码

#include<algorithm> 
#include<cstdio>
using namespace std;
const int maxn=1e6+500;
typedef long long ll;
ll num[maxn];
int n,m;
void read(int &a)
{
    char c=getchar();
    while(c<'0'||c>'9')
        c=getchar();
    int ans=0;
    while(c<='9'&&c>='0')
        ans=ans*10+c-'0',c=getchar();
    a=ans;
    return;
}
void readl(ll &a)
{
    char c=getchar();
    while(c<'0'||c>'9')
        c=getchar();
    ll ans=0;
    while(c<='9'&&c>='0')
        ans=ans*10+c-'0',c=getchar();
    a=ans;
    return;
}
ll jie[maxn];
int ff[maxn],tt[maxn];
ll qzh[maxn];
bool can(int mid)
{
    for(int i=1;i<=n;i++)
        qzh[i]=0;
    for(int i=1;i<=mid;i++)
    {
        qzh[ff[i]]-=jie[i];
        qzh[tt[i]+1]+=jie[i];
    }
    for(int i=1;i<=n;i++)
        qzh[i]+=qzh[i-1];
    for(int i=1;i<=n;i++)
    {
        if(num[i]+qzh[i]<0)
            return false;
    }
    return true;
}
int divv()
{
    int l=1,r=n;
    int ans=n+1;
    while(l<=r)
    {
        int mid=l+r>>1;
        if(can(mid))
            l=mid+1;
        else
            r=mid-1,ans=min(ans,mid);
    }
    return ans;
}
int main()
{
    read(n),read(m); 
    for(int i=1;i<=n;i++)
        readl(num[i]);
    for(int i=1;i<=m;i++)
        readl(jie[i]),read(ff[i]),read(tt[i]);
    int hah=divv();
    if(hah==n+1)
        puts("0");
    else
        printf("-1\n%d",hah); 
    return 0;
}

线段树AC代码（然而仅限于CODEVS，并且还要加各种常数优化）

#include<algorithm>
#include<cstdio>
using namespace std;
const int maxn=1e6+500;
typedef long long ll;
struct Tree
{
    int l,r;
    ll add;
    ll min;
}t[maxn<<2];
ll num[maxn];
int n,m;
void up(int p)
{
    t[p].min=min(t[p<<1].min,t[p<<1|1].min);
}
void buff(int p)
{
    if(t[p].add)
    {
        t[p<<1].min-=t[p].add;
        t[p<<1|1].min-=t[p].add;
        t[p<<1].add+=t[p].add;
        t[p<<1|1].add+=t[p].add;
        t[p].add=0;
    }
}
void expand(int p,int l,int r)
{
    p[t].l=l,p[t].r=r;
    if(l==r)
    {
        p[t].min=l[num];
        return;
    }
    int mid=l+r>>1;
    expand(p<<1,l,mid);
    expand(p<<1|1,mid+1,r);
    up(p);  
}
void add(int p,int l,int r,ll v)
{
    if(l<=t[p].l&&t[p].r<=r)
    {
        t[p].min-=v;
        t[p].add=v;
        return;
    }
    int mid=t[p].r+t[p].l>>1;
    if(l<=mid)
        add(p<<1,l,r,v);
    if(mid+1<=r)
        add(p<<1|1,l,r,v);
    buff(p);
    up(p);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%lld",&i[num]);
    expand(1,1,n);
    bool flag=1;
    for(int j=1;j<=m;j++)
    {
        int a,b;
        ll c;
        scanf("%lld%d%d",&c,&a,&b);
        add(1,a,b,c);
        if(t[1].min<0)
        {
            printf("-1\n%d",j);
            flag=0;
            return 0;
        }
    }
    if(flag)
        puts("0");
    return 0;
}

疫情控制没时间做了啊….