C++博客-【♂Not The Triumph♂O(∩_∩)O哈哈~But The Struggle♂】-文章分类-NOIP历届题目

【NOIP 2005 等价表达式】

开拓者 — Sun, 30 Aug 2009 03:47:00 GMT

【问题描述】
明明进了中学之后，学到了代数表达式。有一天，他碰到一个很麻烦的选择题。这个题目的题干中首先给出了一个代数表达式，然后列出了若干选项，每个选项也是一个代数表达式，题目的要求是判断选项中哪些代数表达式是和题干中的表达式等价的。

这个题目手算很麻烦，因为明明对计算机编程很感兴趣，所以他想是不是可以用计算机来解决这个问题。假设你是明明，能完成这个任务吗？

这个选择题中的每个表达式都满足下面的性质：
1．表达式只可能包含一个变量‘a’。
2．表达式中出现的数都是正整数，而且都小于10000。
3．表达式中可以包括四种运算‘+’（加），‘-’（减），‘*’（乘），‘^’（乘幂），以及小括号‘(’，‘)’。小括号的优先级最高，其次是‘^’，然后是‘*’，最后是‘+’和‘-’。‘+’和‘-’的优先级是相同的。相同优先级的运算从左到右进行。（注意：运算符‘+’，‘-’，‘*’，‘^’以及小括号‘(’，‘)’都是英文字符）
4．幂指数只可能是1到10之间的正整数（包括1和10）。
5．表达式内部，头部或者尾部都可能有一些多余的空格。

下面是一些合理的表达式的例子：

((a^1) ^ 2)^3，a*a+a-a，((a+a))，9999+(a-a)*a，1 + (a -1)^3，1^10^9……

【输入文件】
输入文件equal.in的第一行给出的是题干中的表达式。第二行是一个整数n（2 <= n <= 26），表示选项的个数。后面n行，每行包括一个选项中的表达式。这n个选项的标号分别是A，B，C，D……
输入中的表达式的长度都不超过50个字符，而且保证选项中总有表达式和题干中的表达式是等价的。

【输出文件】
输出文件equal.out包括一行，这一行包括一系列选项的标号，表示哪些选项是和题干中的表达式等价的。选项的标号按照字母顺序排列，而且之间没有空格。

【样例输入】
( a + 1) ^2
3
(a-1)^2+4*a
a + 1+ a
a^2 + 2 * a * 1 + 1^2 + 10 -10 +a –a

【样例输出】
AC

【数据规模】
对于30%的数据，表达式中只可能出现两种运算符‘+’和‘-’；
对于其它的数据，四种运算符‘+’，‘-’，‘*’，‘^’在表达式中都可能出现。
对于全部的数据，表达式中都可能出现小括号‘(’和‘)’。

【参考程序】：

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;

typedef struct
{
    char op;
    long long v;
    bool ok;
}node1;

typedef struct
{
    int cnt;
    node1 I[1010];
}node2;

node2 E[30],H[30];
int w[255];
int N;

bool big(char o1,char o2)
{
    if (o1=='(') return true;
    if (o2=='(') return true;
    return w[o1]>w[o2];
}
void postfix(int Q)
{
    char stack1[1010];
    int top=0,p=0;
    stack1[0]='@';
    for (int i=1;i<=E[Q].cnt;i++)
    {
        if (E[Q].I[i].op==0)
        {
            H[Q].I[++p].v=E[Q].I[i].v;
            H[Q].I[p].ok=E[Q].I[i].ok;
        }
        else
        {
            if (E[Q].I[i].op==')')
            {
                while (stack1[top]!='(')
                {
                    H[Q].I[++p].op=stack1[top];
                    stack1[top--]=0;
                }
                stack1[top--]=0;
            }
            else if (big(E[Q].I[i].op,stack1[top]))
                stack1[++top]=E[Q].I[i].op;
            else
            {
                while (!big(E[Q].I[i].op,stack1[top]) && top>0)
                {
                    H[Q].I[++p].op=stack1[top];
                    stack1[top--]=0;
                }
                stack1[++top]=E[Q].I[i].op;
            }
        }
    }
    H[Q].cnt=p;
}

long long power(long long a,long long b)
{
    long long Q=1;
    for (int i=1;i<=b;i++) Q*=a;
    return Q;
}
long long evaluate(int Q)
{
    int top=-1;
    long long stack1[1010],a,b;
    for (int i=1;i<=H[Q].cnt;i++)
    {
        if (H[Q].I[i].op==0)
        {
            stack1[++top]=H[Q].I[i].v;
        }
        else
        {
            b=stack1[top--]; a=stack1[top--];
            switch(H[Q].I[i].op)
            {
                case '+':
                    stack1[++top]=a+b;
                    break;
                case '-':
                    stack1[++top]=a-b;
                    break;
                case '*':
                    stack1[++top]=a*b;
                    break;
                case '/':
                    stack1[++top]=a/b;
                    break;
                case '^':
                    stack1[++top]=power(a,b);
                    break;
            }
        }
    }
    return stack1[0];
}
bool is_operator(char c)
{
    return (c=='+' || c=='-' || c=='*' || c=='/' || c=='^' || c=='(' ||c==')');
}

void readf(int Q)
{
    int i=0; char c;
    while (!cin.eof())
    {
        while ((c=cin.get())==' ');
            if (c==10 || c==13 || cin.eof()) break;
        i++;
        if (is_operator(c)) E[Q].I[i].op=c;
        else if (c=='a') E[Q].I[i].ok=true;
        else
        {
            cin.putback(c);
            E[Q].I[i].op=0;
            cin >> E[Q].I[i].v;
        }
    }
    E[Q].I[ E[Q].cnt=i+1 ].op='@';
}
void replace_letter(int P)
{
    int i,j;
    for (i=0;i<=N;i++)
        for (j=1;j<=H[i].cnt;j++)
            if (H[i].I[j].ok) H[i].I[j].v=P;
}

void solve()
{
    long long A,B,C;
    bool right[30];
    for (int i=1;i<=N;i++) right[i]=true;
    for (int i=1;i<=10;i++)
    {
        replace_letter(rand()%100);
        A=evaluate(0);
        for (int j=1;j<=N;j++)
        {
            B=evaluate(j); C=A-B;
            if (C<0) C=-C;
            if (C>0.1) right[j]=false;
        }
    }
    for (int i=1;i<=N;i++)
        if (right[i]) printf("%c",i-1+'A');
    printf("\n");
}

int main()
{
    w['@']=0; w['^']=3;
    w['+']=w['-']=1;
    w['*']=w['/']=2;
    readf(0); postfix(0);
    cin>>N; getchar();
    for (int i=1;i<=N;i++)
    {
        readf(i); postfix(i);
    }
    solve();
    return 0;
}

开拓者 2009-08-30 11:47 发表评论

【NOIP 2006 2^k进制数】

开拓者 — Fri, 28 Aug 2009 06:25:00 GMT

Description
设r是个2^k 进制数，并满足以下条件：
(1)r至少是个2位的2^k 进制数。
(2)作为2^k 进制数，除最后一位外，r的每一位严格小于它右边相邻的那一位。
(3)将r转换为2进制数q后，则q的总位数不超过w。
在这里，正整数k(1<=k<=9)和w(k问：满足上述条件的不同的r共有多少个？

我们再从另一角度作些解释：设S是长度为w 的01字符串(即字符串S由w个“0”或“1”组成)，S对应于上述条件(3)中的q。将S从右起划分为若干个长度为k 的段，每段对应一位2^k进制的数，如果S至少可分成2段，则S所对应的二进制数又可以转换为上述的2^k 进制数r。

例：设k=3，w=7。则r是个八进制数（2^3=8）。由于w=7，长度为7的01字符串按3位一段分，可分为3段(即1，3，3，左边第一段只有一个二进制位)，则满足条件的八进制数有：
2位数：高位为1：6个(即12，13，14，15，16，17)，高位为2：5个，…，高位为6：1个(即67)。共6+5+…+1=21个。
3位数：高位只能是1，第2位为2：5个(即123，124，125，126，127)，第2位为3：4个，…，第2位为6：1个(即167)。共5+4+…+1=15个。
所以，满足要求的r共有36个。

Input
输入文件只有1行，为两个正整数，用一个空格隔开：
k W

Output
输出文件为1行，是一个正整数，为所求的计算结果，即满足条件的不同的r的个数(用十进制数表示)，要求最高位不得为0，各数字之间不得插入数字以外的其他字符(例如空格、换行符、逗号等)。
(提示：作为结果的正整数可能很大，但不会超过200位)

Sample Input
3 7

Sample Output
36

分析：
对于这种统计问题，很容易想到的方法就是递推。
我们先尝试着列出递推式：F[i,j]=F[i-1,0]+F[i-1,1]+F[i-1,2]+...F[i-1,j-1]
这里F[i,j]表示递第i位是j的数有多少种。

边界条件是:
1.F[1,t]=1 (1<=t<=limit)
(1)w%k>0时 limit=2^(w%k)-1
(2)w%k=0时 limit=2^k-1

2.F[i,0]=1 (i F[i,0]=0 (i>=len-1) PS:至少是两位数

当然，如果直接这样做，肯定会严重超时。
注意到F[i,j-1]=F[i-1,1]+..F[i-1,j-2]
我们可以将原递推式转换成：
F[i,j]=F[i-1,j-1] + F[i,j-1] j>1
F[i-1,j-1] j=1
这样程序效率就大幅度提高了。
最后注意使用高精度计算即可

【参考程序】：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int f[10][1050][201],blank[201],ans[201];
int k,w;
int Max(int a,int b)
{
    if(a>b) return a;
    else return b;
}
void add(int c[],int a[],int b[])
{
    c[0]=max(a[0],b[0]);
    for(int i=1;i<=c[0];i++)
    {
        c[i]=a[i]+b[i];
        c[i+1]+=c[i]/10;
        c[i]%=10;
    }
    while(c[c[0]+1])
    {
        c[0]++;
        c[c[0]+1]+=c[c[0]]/10;
        c[c[0]]%=10;
    }
}
void print(int a[])
{
    for(int i=a[0];i>=1;i--) printf("%d",a[i]);
    printf(" ");
}
int main()
{
    blank[0]=1;
    scanf("%d%d",&k,&w);
    int limit;
    limit=w%k;
    if(limit==0) limit=k;
    w=(w-limit)/k;
    limit=(1<<limit)-1;
    memset(f,0,sizeof(f));
    memset(blank,0,sizeof(blank));
    memset(ans,0,sizeof(ans));
    for(int i=0;i<=limit;i++)
    {
        f[1][i][0]=1; f[1][i][1]=1;
    }
     if(w<=1)
     {
         f[1][0][0]=1; f[1][0][1]=0;
     }
     for(int i=2;i<=w+1;i++)
    {
        if(i<w)
        {
            f[i%2][0][0]=1; f[i%2][0][1]=1;
        }
        else
        {
            f[i%2][0][0]=1; f[i%2][0][1]=0;
        }
        for(int j=1;j<=(1<<k)-1;j++)
        {
            memcpy(f[i%2][j],blank,sizeof(blank));
            add(f[i%2][j],f[(i-1)%2][j-1],f[i%2][j]);
            if(j>1) add(f[i%2][j],f[i%2][j-1],f[i%2][j]);
        }
    }
    for(int i=0;i<=(1<<k)-1;i++)
        add(ans,ans,f[(w+1)%2][i]);
    for(int i=ans[0];i>=1;i--)
        printf("%d",ans[i]);
    printf("\n");
    return 0;
}

开拓者 2009-08-28 14:25 发表评论

【NOIP 2006 作业调度方案】

开拓者 — Fri, 28 Aug 2009 02:20:00 GMT

Description
我们现在要利用m台机器加工n个工件，每个工件都有m道工序，每道工序都在不同的指定的机器上完成。每个工件的每道工序都有指定的加工时间。
每个工件的每个工序称为一个操作，我们用记号j-k表示一个操作，其中j为1到n中的某个数字，为工件号；k为1到m中的某个数字，为工序号，例如2-4表示第2个工件第4道工序的这个操作。在本题中，我们还给定对于各操作的一个安排顺序。
例如，当n=3，m=2时，“1-1，1-2，2-1，3-1，3-2，2-2”就是一个给定的安排顺序，即先安排第1个工件的第1个工序，再安排第1个工件的第2个工序，然后再安排第2个工件的第1个工序，等等。
一方面，每个操作的安排都要满足以下的两个约束条件。
(1) 对同一个工件，每道工序必须在它前面的工序完成后才能开始；
(2) 同一时刻每一台机器至多只能加工一个工件。
另一方面，在安排后面的操作时，不能改动前面已安排的操作的工作状态。

　　由于同一工件都是按工序的顺序安排的，因此，只按原顺序给出工件号，仍可得到同样的安排顺序，于是，在输入数据中，我们将这个安排顺序简写为“1 1 2 3 3 2”。
还要注意，“安排顺序”只要求按照给定的顺序安排每个操作。不一定是各机器上的实际操作顺序。在具体实施时，有可能排在后面的某个操作比前面的某个操作先完成。
例如，取n=3,m=2，已知数据如下：
工件号机器号/加工时间
工序1 工序2
1 1/3 2/2
2 1/2 2/5
3 2/2 1/4
则对于安排顺序“1 1 2 3 3 2”，下图中的两个实施方案都是正确的。但所需要的总时间分别是10与12。
当一个操作插入到某台机器的某个空档时(机器上最后的尚未安排操作的部分也可以看作一个空档)，可以靠前插入，也可以靠后或居中插入。为了使问题简单一些，我们约定：在保证约束条件(1)(2)的条件下，尽量靠前插入。并且，我们还约定，如果有多个空档可以插入，就在保证约束条件(1)(2)的条件下，插入到最前面的一个空档。于是，在这些约定下，上例中的方案一是正确的，而方案二是不正确的。显然，在这些约定下，对于给定的安排顺序，符合该安排顺序的实施方案是唯一的，请你计算出该方案完成全部任务所需的总时间。

Input
输入文件的第1行为两个正整数，用一个空格隔开：
m n (其中m(<20)表示机器数，n(<20)表示工件数)
第2行：m*n个用空格隔开的数，为给定的安排顺序。
接下来的2n行，每行都是用空格隔开的m个正整数，每个数不超过20。
其中前n行依次表示每个工件的每个工序所使用的机器号，第1个数为第1个工序的机器号，第2个数为第2个工序机器号，等等。
后n行依次表示每个工件的每个工序的加工时间。
可以保证，以上各数据都是正确的，不必检验。

Output
输出文件只有一个正整数，为最少的加工时间。

Sample Input
2 3
1 1 2 3 3 2
1 2
1 2
2 1
3 2
2 5
2 4

Sample Output
10

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int s[30][10010];
int a[400],F[30],t[30][30],d[30][30],p[30];
int n,m;
int main()
{
    scanf("%d%d",&m,&n);
    for (int i=1;i<=n*m;i++) scanf("%d",&a[i]);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            scanf("%d",&d[i][j]);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            scanf("%d",&t[i][j]);
    memset(s,0,sizeof(s));
    memset(F,0,sizeof(F));
    memset(p,0,sizeof(p));
    int Max,odle,pos;
    Max=-1;
    for (int i=1;i<=n*m;i++)
    {
        odle=0; p[a[i]]++;
        for (int j=F[a[i]]+1;;j++)
        {
            if (s[d[a[i]][p[a[i]]]][j]) odle=0;
            else odle++;
            if (odle>=t[a[i]][p[a[i]]])
            {
                pos=j; break;
            }
        }
        for (int k=pos-odle+1;k<=pos;k++)
            s[d[a[i]][p[a[i]]]][k]=1;
        F[a[i]]=pos;
        if (pos>Max) Max=pos;
    }
    printf("%d\n",Max);
    return 0;
}

开拓者 2009-08-28 10:20 发表评论

【NOIP 2003 神经网络】

开拓者 — Thu, 27 Aug 2009 01:54:00 GMT

【问题背景】
人工神经网络（Artificial Neural Network）是一种新兴的具有自我学习能力的计算系统，在模式识别、函数逼近及贷款风险评估等诸多领域有广泛的应用。对神经网络的研究一直是当今的热门方向，兰兰同学在自学了一本神经网络的入门书籍后，提出了一个简化模型，他希望你能帮助他用程序检验这个神经网络模型的实用性。
【问题描述】
在兰兰的模型中，神经网络就是一张有向图，图中的节点称为神经元，而且两个神经
元之间至多有一条边相连，下图是一个神经元的例子：

神经元〔编号为1）
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，
Ui是阈值，可视为神经元的一个内在参数。
神经元按一定的顺序排列，构成整个神经网络。在兰兰的模型之中，神经网络中的神
经无分为几层；称为输入层、输出层，和若干个中间层。每层神经元只向下一层的神经元
输出信息，只从上一层神经元接受信息。下图是一个简单的三层神经网络的例子。

兰兰规定，Ci服从公式：（其中n是网络中所有神经元的数目）

公式中的Wji（可能为负值）表示连接j号神经元和 i号神经元的边的权值。当 Ci大于0时，该神经元处于兴奋状态，否则就处于平静状态。当神经元处于兴奋状态时，下一秒它会向其他神经元传送信号，信号的强度为Ci。
如此．在输入层神经元被激发之后，整个网络系统就在信息传输的推动下进行运作。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。

【输入格式】
输入文件第一行是两个整数n（1≤n≤200）和p。接下来n行，每行两个整数，第i＋1行是神经元i最初状态和其阈值（Ui），非输入层的神经元开始时状态必然为0。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。

【输出格式】
输出文件包含若干行，每行有两个整数，分别对应一个神经元的编号，及其最后的状态，两个整数间以空格分隔。仅输出最后状态非零的输出层神经元状态，并且按照编号由小到大顺序输出！
若输出层的神经元最后状态均为 0，则输出 NULL。

【输入样例】
5 6
1 0
1 0
0 1
0 1
0 1
1 3 1
1 4 1
1 5 1
2 3 1
2 4 1
2 5 1

【输出样例】
3 1
4 1
5 1

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int w[210],s[210],t[210],u[210],c[210],l[210];
int n,p,maxl;
int main()
{
    scanf("%d%d",&n,&p);
    for (int i=1;i<=n;i++) scanf("%d%d",&c[i],&u[i]);
    memset(l,0,sizeof(l));
    for (int i=1;i<=p;i++)
    {
        scanf("%d%d%d",&s[i],&t[i],&w[i]);
        l[t[i]]=l[s[i]]+1;
    }
    maxl=l[t[p]];
    for (int i=1;i<=n;i++)
        if (l[i]>0)
        {
            for (int j=1;j<=p;j++)
                if (t[j]==i && c[s[j]]>0)
                    c[i]+=w[j]*c[s[j]];
            c[i]-=u[i];
        }
    bool bk=true;
    for (int i=1;i<=n;i++)
        if (l[i]==maxl && c[i]>0)
        {
            printf("%d %d\n",i,c[i]); bk=false;
        }
    if (bk) printf("NULL\n");
    return 0;
}

开拓者 2009-08-27 09:54 发表评论

【NOIP 2003 传染病控制】

开拓者 — Thu, 27 Aug 2009 01:25:00 GMT

【问题背景】
近来，一种新的传染病肆虐全球。蓬莱国也发现了零星感染者，为防止该病在蓬莱国大范围流行，该国政府决定不惜一切代价控制传染病的蔓延。不幸的是，由于人们尚未完全认识这种传染病，难以准确判别病毒携带者，更没有研制出疫苗以保护易感人群。于是，蓬莱国的疾病控制中心决定采取切断传播途径的方法控制疾病传播。经过 WHO（世界卫生组织）以及全球各国科研部门的努力，这种新兴传染病的传播途径和控制方法已经研究消楚，剩下的任务就是由你协助蓬莱国疾控中心制定一个有效的控制办法。
【问题描述】
研究表明，这种传染病的传播具有两种很特殊的性质；
第一是它的传播途径是树型的，一个人X只可能被某个特定的人Y感染，只要Y不得病，或者是XY之间的传播途径被切断，则X就不会得病。
第二是，这种疾病的传播有周期性，在一个疾病传播周期之内，传染病将只会感染一代患者，而不会再传播给下一代。
这些性质大大减轻了蓬莱国疾病防控的压力，并且他们已经得到了国内部分易感人群的潜在传播途径图（一棵树）。但是，麻烦还没有结束。由于蓬莱国疾控中心人手不够，同时也缺乏强大的技术，以致他们在一个疾病传播周期内，只能设法切断一条传播途径，而没有被控制的传播途径就会引起更多的易感人群被感染（也就是与当前已经被感染的人有传播途径相连，且连接途径没有被切断的人群）。当不可能有健康人被感染时，疾病就中止传播。所以，蓬莱国疾控中心要制定出一个切断传播途径的顺序，以使尽量少的人被感染。你的程序要针对给定的树，找出合适的切断顺序。

【输入格式】
输入格式的第一行是两个整数n（1≤n≤300）和p。接下来p行，每一行有两个整数i和j，表示节点i和j间有边相连（意即，第i人和第j人之间有传播途径相连）。其中节点1是已经被感染的患者。

【输出格式】
只有一行，输出总共被感染的人数。

【输入样例】
7 6
1 2
1 3
2 4
2 5
3 6
3 7

【输出样例】
3

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int w[310],F[310],jl[310][310];
int n,p,Max,tot;
void make_tree(int k)
{
    int j,x;
    for (int i=1;i<=w[k];i++)
    {
        j=jl[k][i];
        for (int e=1;e<=w[j];e++)
            if (jl[j][e]==k)
            {
                x=e; break;
            }
        w[j]--;
        jl[j][x]=jl[j][w[j]+1];
        make_tree(j);
    }
}
void Find(int k)
{
    bool get;
    if (tot>Max) return ;
    get=false;
    for (int i=1;i<=n;i++)
        if (F[i]==k)
            for (int j=1;j<=w[i];j++)
            {
                F[jl[i][j]]=k+1;
                tot++;
                get=true;
            }
    tot--;
    for (int i=1;i<=n;i++)
        if (F[i]==k+1)
        {
            F[i]=0; Find(k+1);
            F[i]=k+1;
        }
    tot++;
    for (int i=1;i<=n;i++)
        if (F[i]==k+1)
        {
            F[i]=0;
            tot--;
        }
    if (!get && tot<Max) Max=tot;
}
int main()
{
    scanf("%d%d",&n,&p);
    memset(w,0,sizeof(w));
    int a,b;
    for (int i=1;i<=p;i++)
    {
        scanf("%d%d",&a,&b);
        w[a]++; jl[a][w[a]]=b;
        w[b]++; jl[b][w[b]]=a;
    }
    make_tree(1);
    Max=0xFFFFFFF; tot=1;
    memset(F,0,sizeof(F)); F[1]=1;
    Find(1);
    printf("%d\n",Max);
    return 0;
}

开拓者 2009-08-27 09:25 发表评论

【NOIP 2002 过河卒】

开拓者 — Wed, 26 Aug 2009 08:23:00 GMT

[问题描述]:
如图，A 点有一个过河卒，需要走到目标 B 点。卒行走规则：可以向下、或者向右。同时在棋盘上的任一点有一个对方的马（如上图的C点），该马所在的点和所有跳跃一步可达的点称为对方马的控制点。例如上图 C 点上的马可以控制 9 个点（图中的P1，P2 … P8 和 C）。卒不能通过对方马的控制点。

棋盘用坐标表示，A 点（0，0）、B 点（n,m）(n,m 为不超过 20 的整数，并由键盘输入)，同样马的位置坐标是需要给出的（约定: C<>A，同时C<>B）。现在要求你计算出卒从 A 点能够到达 B 点的路径的条数。
[输入]:
键盘输入
B点的坐标（n,m）以及对方马的坐标（X,Y）{不用判错}

[输出]:
屏幕输出
一个整数（路径的条数）。
[输入输出样例]:
输入：
6 6 3 2

输出：
17

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

const int dx[8]={2,1,-1,-2,-2,-1,1,2};
const int dy[8]={1,2,2,1,-1,-2,-2,-1};
__int64 F[30][30];
int g[30][30];
int n,m,x2,y2;
int main()
{
    //freopen("p41.in","r",stdin);
    //freopen("p41.out","w",stdout);
    scanf("%d%d%d%d",&n,&m,&x2,&y2);
    memset(g,0,sizeof(g));
    int tx,ty;
    g[x2][y2]=1;
    for (int i=0;i<=7;i++)
    {
        tx=x2+dx[i]; ty=y2+dy[i];
        if (tx>=0 && tx<=n && ty>=0 && ty<=m)
            g[tx][ty]=1;
    }
    if (g[0][0]==0) F[0][0]=1;
    for (int i=1;i<=n;i++)
        if (g[i][0]==0) F[i][0]=F[i-1][0];
        else F[i][0]=0;
    for (int i=1;i<=m;i++)
        if (g[0][i]==0) F[0][i]=F[0][i-1];
        else F[0][i]=0;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            if (g[i][j]==0) F[i][j]=F[i-1][j]+F[i][j-1];
            else F[i][j]=0;
    printf("%I64d\n",F[n][m]);
    return 0;
}

开拓者 2009-08-26 16:23 发表评论

【NOIP 2001 装箱问题】

开拓者 — Wed, 26 Aug 2009 07:30:00 GMT

[问题描述]
有一个箱子容量为v(正整数，o≤v≤20000)，同时有n个物品(o≤n≤30)，每个物品有一个体积 (正整数)。要求从 n 个物品中，任取若千个装入箱内，使箱子的剩余空间为最小。
[样例]
输入：
24      一个整数，表示箱子容量
6       一个整数，表示有n个物品
8       接下来n行，分别表示这n个物品的各自体积。
3
12
7
9
7

输出：
0(一个整数，表示箱子剩余空间)

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

bool bo[20010];
int w[40];
int v,n;
int main()
{
    scanf("%d",&v); scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&w[i]);
    for (int i=1;i<=v;i++) bo[i]=false;
    bo[0]=true;
    for (int i=1;i<=n;i++)
        for (int j=v;j>=w[i];j--)
            bo[j]=bo[j] || bo[j-w[i]];
    int m=v;
    while (!bo[m]) m--;
    printf("%d\n",v-m);
    return 0;
}

开拓者 2009-08-26 15:30 发表评论

【NOIP 2001 求先序排列】

开拓者 — Wed, 26 Aug 2009 07:28:00 GMT

[问题描述]
给出一棵二叉树的中序与后序排列。求出它的先序排列。(约定树结点用不同的大写字母表示，长度≤8)。
[样例]
输入：
BADC BDCA

输出：
ABCD

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

string s1,s2,ans;
void cal(int x1,int y1,int x2,int y2)
{
    if (x2==y2) ans+=s2[x2];
    else
    {
        int k=0;
        for (int i=x1;i<=y1;i++)
            if (s1[i]==s2[y2])
            {
                k=i; break;
            }
        if (k==x1)
        {
            ans+=s2[y2];
            cal(x1+1,y1,x2,y2-1);
        }
        else if (k==y1)
        {
            ans+=s2[y2];
            cal(x1,y1-1,x2,y2-1);
        }
        else
        {
            ans+=s2[y2];
            cal(x1,k-1,x2,x2+(k-1-x1+1)-1);
            cal(k+1,y2,x2+(k-1-x1+1)-1+1,y2-1);
        }
    }
}
int main()
{
    cin>>s1>>s2;
    int len=s1.length();
    s1=' '+s1; s2=' '+s2;
    ans="";
    cal(1,len,1,len);
    cout<<ans<<endl;
    return 0;
}

开拓者 2009-08-26 15:28 发表评论

【NOIP 2001 最大公约数与最小公倍数问题】

开拓者 — Wed, 26 Aug 2009 07:26:00 GMT

[问题描述]
输入二个正整数x0,y0(2≤x0≤100000，2≤y0≤1000000)，求出满足下列条件的P、Q的个数。
条件:1.P、Q是正整数
二要求P、Q以xO为最大公约数，以yO为最小公倍数。
试求，满足条件的所有可能的两个正整数的个数。
[样例]
输入：x0=3       y0=60
输出：4
说明：(不用输出)此时的
P   Q分别为，
3   60
15   12
12   15
60   3
所以，满足条件的所有可能的两个正整数的个数共4种。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int y,x,ans;
int main()
{
    freopen("gygb.in","r",stdin);
    freopen("gygb.out","w",stdout);
    scanf("%d%d",&x,&y);
    if (y%x!=0)
    {
        printf("0\n"); exit(0);
    }
    int p,k,s;
    p=y/x; k=0; s=2;
    while (p>1)
    {
        if (p%s==0)
        {
            k++;
            while (p%s==0) p/=s;
        }
        s++;
    }
    ans=1;
    for (int i=1;i<=k;i++) ans*=2;
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-26 15:26 发表评论

【NOIP 2002 产生数】

开拓者 — Wed, 26 Aug 2009 07:22:00 GMT

[问题描述]:
给出一个整数 n（n<10^30) 和 k 个变换规则（k<=15）。
规则：
一位数可变换成另一个一位数：
规则的右部不能为零。
例如：n=234。有规则（k＝2）：
　　　2－> 5
　　　3－> 6
上面的整数 234 经过变换后可能产生出的整数为（包括原数）:
　　　234
　　　534
　　　264
　　　564
共 4 种不同的产生数
问题：
给出一个整数 n 和 k 个规则。
求出：
经过任意次的变换（0次或多次），能产生出多少个不同整数。
仅要求输出个数。
[输入]:
键盘输人，格式为：
n k
x1 y1
x2 y2
... ...
xn yn
[输出]:
屏幕输出，格式为：
一个整数（满足条件的个数）：

[输入输出样例]:
输入:
234 2
2 5
3 6

输出：
4

分析：
对以一串数字，每个数字都有变换的次数为ni，那么整个数字的全部变换次数就是n1*n2*n3*n4...(乘法原理)

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

typedef int array[50];
array ans;
int g[10][10],F[10];
int k;
char s[50];
int main()
{
    scanf("%s",s); scanf("%d",&k);
    int a,b;
    memset(g,0,sizeof(g));
    for (int i=1;i<=k;i++)
    {
        scanf("%d%d",&a,&b);
        g[a][b]=1;
    }
    for (int k=0;k<=9;k++)
        for (int i=0;i<=9;i++)
            if (k!=i)
                for (int j=0;j<=9;j++)
                    if (i!=j && k!=j)
                        g[i][j]=g[i][j] || (g[i][k] && g[k][j]);
    for (int i=0;i<=9;i++)
    {
        F[i]=1;
        for (int j=0;j<=9;j++) F[i]+=g[i][j];
    }
    memset(ans,0,sizeof(ans));
    ans[0]=1;ans[1]=1;
    for (int i=0;i<strlen(s);i++)
    {
        for (int j=1;j<=ans[0];j++) ans[j]*=F[s[i]-'0'];
        for (int j=1;j<=ans[0];j++)
        {
            ans[j+1]+=ans[j]/10;
            ans[j]%=10;
        }
        while (ans[ans[0]+1])
        {
            ans[0]++;
            ans[ans[0]+1]+=ans[ans[0]]/10;
            ans[ans[0]]%=10;
        }
    }
    for (int i=ans[0];i>=1;i--) printf("%d",ans[i]);
    printf("\n");
    return 0;
}

开拓者 2009-08-26 15:22 发表评论

【NOIP 2002 选数】

开拓者 — Wed, 26 Aug 2009 07:16:00 GMT

[问题描述]:
已知 n 个整数 x1,x2,…,xn，以及一个整数 k（k＜n）。从 n 个整数中任选 k 个整数相加，可分别得到一系列的和。例如当 n=4，k＝3，4 个整数分别为 3，7，12，19 时，可得全部的组合与它们的和为：
3＋7＋12=22　　3＋7＋19＝29　　7＋12＋19＝38　　3＋12＋19＝34。
现在，要求你计算出和为素数共有多少种。
例如上例，只有一种的和为素数：3＋7＋19＝29）。

[输入]：
键盘输入，格式为：
n , k （1<=n<=20，k＜n）
x1,x2，…,xn （1<=xi<=5000000）

[输出]：
屏幕输出，格式为：
一个整数（满足条件的种数）。

[输入输出样例]:
输入：
4 3
3 7 12 19

输出：
1

【参考程序】：

#include<cstring>
#include<cmath>
#include<cstdio>
#include<iostream>
using namespace std;

const int Max=500000;
int bo[Max+1],a[30];
int n,k,ans,sum;
void make_prime()
{
    memset(bo,true,sizeof(bo));
    bo[0]=bo[1]=false;
    for (int i=2;i<=Max;i++)
        if (bo[i])
        {
            int j=i*2;
            while (j<=Max)
            {
                bo[j]=false; j+=i;
            }
        }
}
void check(int s)
{
    if (s<=Max && bo[s]) ans++;
    else
    {
        for (int i=2;i<=(int)sqrt(s);i++)
            if (s%i==0) return ;
        ans++;
    }
}
void dfs(int dep,int d)
{
    for (int i=d+1;i<=n-(k-dep);i++)
    {
        sum+=a[i];
        if (dep==k) check(sum);
        else dfs(dep+1,i);
        sum-=a[i];
    }
}
int main()
{
    //freopen("p21.in","r",stdin);
    //freopen("p21.out","w",stdout);
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    make_prime();
    ans=0; sum=0;
    dfs(1,0);
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-26 15:16 发表评论

【NOIP 2003 加分二叉树】

开拓者 — Sun, 23 Aug 2009 13:14:00 GMT

Description
【问题描述】
设一个n个节点的二叉树tree的中序遍历为(l,2,3,…,n)，其中数字1,2,3,…,n为节点编号。每个节点都有一个分数(均为正整数)，记第i个节点的分数为di，tree及它的每个子树都有一个加分，任一棵子树subtree(也包含tree本身)的加分计算方法如下：
subtree的左子树的加分× subtree的右子树的加分＋subtree的根的分数
若某个子树为空，规定其加分为1，叶子的加分就是叶节点本身的分数。不考虑它的空子树。
试求一棵符合中序遍历为(1,2,3,…,n)且加分最高的二叉树tree。要求输出；
(1)tree的最高加分
(2)tree的前序遍历

Input
第1行：一个整数n(n＜30)，为节点个数。
第2行：n个用空格隔开的整数，为每个节点的分数(分数＜100)。

Output
第1行：一个整数，为最高加分(结果不会超过4,000,000,000)。
第2行：n个用空格隔开的整数，为该树的前序遍历。

Sample Input
5
5 7 1 2 10

Sample Output
145
3 1 2 4 5

分析：
用树形DP可解(叶子-->树根类型).
F[i][j]表示以i为开始节点到j的末尾节点的最大加分数。
状态方程：F[i][j]=max(F[i][k-1]*F[k+1][j]+a[k]){k为i,j的根}
最后只需枚举一个开始节点,节点个数,末尾节点,根四个元素即可求出F[i][j]间的最大加分数。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int a[40],F[40][40],root[40][40];
int n;
void out(int l,int r)
{
    if (r>=l)
    {
        printf("%d ",root[l][r]);
        out(l,root[l][r]-1);
        out(root[l][r]+1,r);
    }
}
int main()
{
    scanf("%d",&n);
    for (int i=0;i<=n;i++)
        for (int j=0;j<=n;j++)
            F[i][j]=1;
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        F[i][i]=a[i]; root[i][i]=i;
    }
    for (int len=2;len<=n;len++)/*枚举节点的个数*/
        for (int i=1;i<=n-len+1;i++)
        {
            int j=i+len-1;
            for (int k=i;k<=j;k++)
            /*以K为根i到k-1为左子树和k+1到j为右子树的最大加分*/
                if (F[i][j]<F[i][k-1]*F[k+1][j]+a[k])
                {
                    F[i][j]=F[i][k-1]*F[k+1][j]+a[k];
                    root[i][j]=k;
                }
        }
    printf("%d\n",F[1][n]);
    out(1,n);
    printf("\n");
    return 0;
}

开拓者 2009-08-23 21:14 发表评论

【NOIP 2006 开心的金明】

开拓者 — Sat, 22 Aug 2009 09:10:00 GMT

Description
金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间他自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就行”。今天一早金明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的N元。于是，他把每件物品规定了一个重要度，分为5等：用整数1~5表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是整数元）。他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。
设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：
v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。（其中*为乘号）
请你帮助金明设计一个满足要求的购物单。

Input
输入文件happy.in 的第1行，为两个正整数，用一个空格隔开：N m(其中N（<30000）表示总钱数，m（<25）为希望购买物品的个数。)
从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有2个非负整数v p(其中v表示该物品的价格(v<=10000)，p表示该物品的重要度(1~5))

Output
输出文件happy.out只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<100000000)。

Sample Input
1000 5
800 2
400 5
300 5
400 3
200 2

Sample Output
3900

【参考程序】：

#include<cstring>
#include<cstdio>
using namespace std;

long long f[30010];
int n,m;
int main()
{
    scanf("%d%d",&n,&m);
    memset(f,0,sizeof(f));
    for (int i=0;i<=n;i++) f[i]=0;
    int w,v;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d",&w,&v);
        for (int j=n;j>=w;j--)
            if (f[j]<f[j-w]+w*v)
                f[j]=f[j-w]+w*v;
    }
    printf("%lld\n",f[n]);
    return 0;
}

开拓者 2009-08-22 17:10 发表评论

【NOIP 2001 一元三次方程求解】

开拓者 — Sat, 22 Aug 2009 09:00:00 GMT

有形如：ax^3+bx^2+cx+d=0 这样的一个一元三次方程。给出该方程中各项的系数(a，b，c，d 均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)，且根与根之差的绝对值>=1。要求由小到大依次在同一行输出这三个实根(根与根之间留有空格)，并精确到小数点后2位。
提示：记方程f(x)=0，若存在2个数x1和x2，且x1

input：
输入该方程中各项的系数(a，b，c，d 均为实数)，

output：
由小到大依次在同一行输出这三个实根(根与根之间留有空格)，并精确到小数点后2位。

input：
1 -5 -4 20

output：
-2.00 2.00 5.00

【参考程序】：

#include<cstring>
#include<cstdio>
using namespace std;

double ans[4];
double a,b,c,d;
double f(double xt)
{
    double s;
    s=xt*xt*xt+b*xt*xt+c*xt+d;
    return s;
}
int main()
{
    scanf("%lf%lf%lf%lf",&a,&b,&c,&d);
    b/=a; c/=a; d/=a;
    double x1,x2; int p=0;
    for (int x=-10000;x<=10000;x++)
    {
        x1=(x-0.05)/100.0; x2=(x+0.05)/100.0;
        if (f(x/100.0)==0 || f(x1)*f(x2)<0)
        {
            p++; ans[p]=x/100.0;
        }
        if (p==3) break;
    }
    for (int i=1;i<=2;i++)
        for (int j=2;j<=3;j++)
            if (ans[i]>ans[j])
            {
                double t=ans[i];ans[i]=ans[j];ans[j]=t;
            }
    for (int i=1;i<=p-1;i++)
        printf("%.2lf ",ans[i]);
    printf("%0.2lf\n",ans[p]);
    return 0;
}

【参考程序】：

var a,b,c,d,x1,x2,tt:double;
    x,i,j,k:longint;
    ans:array[1..3]of double;
function f(xx:double):double;
begin
    f:=xx*xx*xx+b*xx*xx+c*xx+d;
end;
begin
    //while not eof do
    //begin
        read(a,b,c,d);
        b:=b/a;c:=c/a;d:=d/a;a:=1;
        k:=0;
        for x:=-10000 to 10000 do
        begin
            x1:=(x-0.005)/100;x2:=(x+0.005)/100;
            if (f(x1)*f(x2)<0)or(f(x2)=0) then
            begin
                inc(k);
                ans[k]:=x/100;
            end;
        end;
        for i:=1 to 2 do
          for j:=i+1 to 3 do
            if ans[i]>ans[j] then
            begin
               tt:=ans[i];ans[i]:=ans[j];ans[j]:=tt;
            end;
        for i:=1 to 2 do write(ans[i]:0:2,' ');
        writeln(ans[3]:0:2);
    //end;
end.

开拓者 2009-08-22 17:00 发表评论

【NOIP 2006 金明的预算方案】

开拓者 — Sat, 22 Aug 2009 08:46:00 GMT

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
主件附件
电脑打印机，扫描仪
书柜图书
书桌台灯，文具
工作椅无
　如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的N元。于是，他把每件物品规定了一个重要度，分为5等：用整数1~5表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是10元的整数倍）。他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

　　设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。（其中*为乘号）请你帮助金明设计一个满足要求的购物单。

input：
输入文件的第1行，为两个正整数，用一个空格隔开：N m
其中N（<32000）表示总钱数，m（<60）为希望购买物品的个数。）
从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有3个非负整数v p q
(其中v表示该物品的价格(v<10000)，p表示该物品的重要度(1~5)，q表示该物品是主件还是附件。如果q=0，表示该物品为主件，如果q>0，表示该物品为附件，q是所属主件的编号)

output：
输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<200000)。

【参考程序】：

#include<cstring>
#include<cstdio>
using namespace std;

struct node
{
    int x;
    int v[5],w[5];
} a[70];
int f[100][4000];
int n,m,k;
void dp()
{
    memset(f,0,sizeof(f));
    for (int i=1;i<=m;i++)
        for (int j=1;j<=n;j++)
        {
            f[i][j]=f[i-1][j];
            if (j-a[i].v[0]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]]+a[i].w[0])
                    f[i][j]=f[i-1][j-a[i].v[0]]+a[i].w[0];
            }
            if (j-a[i].v[0]-a[i].v[1]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]-a[i].v[1]]+a[i].w[0]+a[i].w[1])
                    f[i][j]=f[i-1][j-a[i].v[0]-a[i].v[1]]+a[i].w[0]+a[i].w[1];
            }
            if (j-a[i].v[0]-a[i].v[2]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]-a[i].v[2]]+a[i].w[0]+a[i].w[2])
                    f[i][j]=f[i-1][j-a[i].v[0]-a[i].v[2]]+a[i].w[0]+a[i].w[2];
            }
            if (j-a[i].v[0]-a[i].v[1]-a[i].v[2]>=0)
            {
                if (f[i][j]<f[i-1][j-a[i].v[0]-a[i].v[1]-a[i].v[2]]+a[i].w[0]+a[i].w[1]+a[i].w[2])
                    f[i][j]=f[i-1][j-a[i].v[0]-a[i].v[1]-a[i].v[2]]+a[i].w[0]+a[i].w[1]+a[i].w[2];
            }
        }
}
int main()
{
    for (int i=1;i<=m;i++) a[i].x=0;
    scanf("%d%d",&n,&m);
    n/=10;
    int v1,p1,q1;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&v1,&p1,&q1);
        v1/=10;
        if (q1==0)
        {
            a[i].v[0]=v1; a[i].w[0]=p1*v1;
        }
        else
        {
            a[q1].x++;
            a[q1].v[a[q1].x]=v1;
            a[q1].w[a[q1].x]=p1*v1;
        }
    }
    dp();
    printf("%d\n",f[m][n]*10);
    return 0;
}

【参考程序】：//pascal

type tt=record
     money,jia,zong:longint;
    end;
var b:array[1..100] of longint;
    a:array[1..100,1..3] of tt;
    f:array[0..100,0..4000] of longint;
    i,j,n,m,c,x,z:longint;
function findmax(a,b,c,d,e:integer):integer;
var max:longint;
begin
   max:=a;
   if b>max then max:=b;
   if c>max then max:=c;
   if d>max then max:=d;
   if e>max then max:=e;
   findmax:=max;
end;
procedure dp;
var i,j,max1,max2,max3,max4,max:longint;
begin
   for i:=1 to m do
     for j:=1 to n do
     begin
        max1:=0;max2:=0;max3:=0;max4:=0;
        max:=f[i-1,j];
        if (j-a[i,1].money)>=0 then
           max1:=f[i-1,j-a[i,1].money]+a[i,1].zong;
        if (j-a[i,1].money-a[i,2].money)>=0 then
           max2:=f[i-1,j-a[i,1].money-a[i,2].money]+a[i,1].zong+a[i,2].zong;
        if (j-a[i,1].money-a[i,3].money)>=0 then
           max3:=f[i-1,j-a[i,1].money-a[i,3].money]+a[i,1].zong+a[i,3].zong;
        if (j-a[i,1].money-a[i,2].money-a[i,3].money)>=0 then
           max4:=f[i-1,j-a[i,1].money-a[i,2].money-a[i,3].money]+a[i,1].zong+a[i,2].zong+a[i,3].zong;
        f[i,j]:=findmax(max1,max2,max3,max4,max);
     end;
end;
begin
   //while not eof do
   //begin
    readln(n,m);
    n:=n div 10;
    for i:=1 to 60 do
      for j:=1 to 3 do
      begin
         a[i,j].money:=0;
         a[i,j].jia:=0;
         a[i,j].zong:=0;
      end;
    for i:=1 to m do b[i]:=1;
    fillchar(f,sizeof(f),0);
    for i:=1 to m do
    begin
        readln(z,x,c);
        z:=z div 10;
        if c=0 then
        begin
            a[i,1].money:=z;
            a[i,1].jia:=x;
            a[i,1].zong:=z*x;
        end
        else
        begin
            a[c,b[c]+1].money:=z;
            a[c,b[c]+1].jia:=x;
            a[c,b[c]+1].zong:=z*x;
            inc(b[c]);
        end;
    end;
    dp;
    writeln(f[m,n]*10);
   //end;
end.

开拓者 2009-08-22 16:46 发表评论

【NOIP 2001 数的计数】

开拓者 — Sat, 22 Aug 2009 08:32:00 GMT

Description
先输入一个自然数n(n≤3000000)，然后对此自然数按照如下方法进行处理
1•不作任何处理:
2•在它的左边加上一个自然数，但该自然数不能超过原数的一半;
3•加上数后，继续按此规则进行处理，直到不能再而自然数为止。
例如
n=6
6
16
26
126
36
136
所以满足要求的个数为6。

Input
一个整数n(1<=n<=3000000)

Output
一个整数,表示解的个数(保证不超过50位)

Sample Input
6

Sample Output
6

分析：
用f[n]表示最后一个数是n时，可以构造出的数的总数。规定f[0]=1，则显然有f[n]=f[0]+f[1]+...+f[n div 2]。
　但若直接使用这个方程，则会既TLE又MLE。注意到右边其实是f数组开头若干个元素的和，因此可开一个s数组，用s[n]来存储f[0]至f[n]的和。这样时间上显然没有问题。实际上，现在f数组已经不必要了，因为用s数组可写出如下状态转移方程：s[n]=s[n-1]+f[n]=s[n-1]+s[n div 2]。当读入n时，输出s[n div 2]即可。
　结果很大，高精度是当然的。可以用3个int64来存储一个数。这里我们看到用s数组代替f数组同样解决了MLE的问题，因为s数组的大小只有f数组的一半，题目允许的内存不能容纳f数组，却恰好可以容纳s数组。

【参考程序1】：//NOIP 2001 普及组 n<=1000

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

int n,ans;
void dfs(int n)
{
    ans++;
    for (int i=1;i<=n/2;i++)
        dfs(i);
}
int main()
{
    scanf("%d",&n);
    ans=0;
    dfs(n);
    printf("%d\n",ans);
    return 0;
}

【参考程序2】://加强版

#include<cstring>
#include<cstdio>
#include<cmath>
#include<iostream>
using namespace std;

const int maxn=1500002;
__int64 s[maxn][3];
int n;
void print(__int64 a)
{
    char ch[60];
    sprintf(ch,"%I64d",a);
    for (int i=strlen(ch);i<=17;i++) printf("0");
    printf("%s",ch);
}
void cout_ans(__int64 a,__int64 b,__int64 c)
{
    if (a>0)
    {
        printf("%I64d",a);
        print(b);print(c);
    }
    else if (b>0)
    {
        printf("%I64d",b); print(c);
    }
    else printf("%I64d",c);
    printf("\n");
}
int main()
{
    __int64 base;
    base=(__int64)(pow(10.0,9.0)); base*=base;
    memset(s,0,sizeof(s));
    s[0][0]=1;
    for (int i=1;i<=maxn;i++)
        for (int j=0;j<=2;j++)
        {
            s[i][j]+=s[i-1][j]+s[i>>1][j];
            if (s[i][j]>=base)
            {
                s[i][j+1]++; s[i][j]-=base;
            }
        }
    while (scanf("%d",&n)!=EOF)
    {
        n=n>>1;
        cout_ans(s[n][2],s[n][1],s[n][0]);
    }
    return 0;
}

【参考程序】：//pascal

const maxb=1000000000;
      maxn=1500000;
var f:array[0..maxn+1,0..7] of longint;
    i,j,t,n:longint;
    s:string;
begin
    f[0,1]:=1;f[0,0]:=1;
    for i:=1 to maxn do
    begin
        f[i]:=f[i-1];
        t:=i shr 1;
        for j:=1 to f[i,0] do
        begin
            inc(f[i,j],f[t,j]);
            if f[i,j]>=maxb then
            begin
                inc(f[i,j+1],f[i,j]div maxb);
                f[i,j]:=f[i,j] mod maxb;
            end;
        end;
        if f[i,f[i,0]+1]<>0 then inc(f[i,0]);
    end;
    while not (eof) do
    begin
        readln(n);
        i:=n shr 1;
        t:=f[i,0];
        write(f[i,t]);
        for j:=t-1 downto 1 do
        begin
            str(f[i,j],s);
            while length(s)<9 do s:='0'+s;
            write(s);
        end;
        writeln;
    end;
end.

开拓者 2009-08-22 16:32 发表评论

【NOIP 2008 传纸条】

开拓者 — Sat, 22 Aug 2009 02:51:00 GMT

Description
小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。一次素质拓展活动中，班上同学安排做成一个m行n列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标 (1,1)，小轩坐在矩阵的右下角，坐标(m,n)。从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。
　在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。
　还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用0表示），可以用一个 0-100的自然数来表示，数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这两条路径上同学的好心程度只和最大。现在，请你帮助小渊和小轩找到这样的两条路径。

Input
输入文件message.in的第一行有2个用空格隔开的整数m和n，表示班里有m行n列（1 < m,n <= 50）。
接下来的m行是一个m*n的矩阵，矩阵中第i行j列的整数表示坐在第i行j列的学生的好心程度。每行的n个整数之间用空格隔开。

Output
输出文件message.out共一行，包含一个整数，表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。

Sample Input
3 3
0 3 9
2 8 5
5 7 0

Sample Output
34

Hint
30%的数据满足：1 < m,n <= 10
100%的数据满足：1 < m,n <= 50

【参考程序】：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;

const int dir[2][4]={{-1,-1,0,0},{-1,0,-1,0}};
int F[120][60][60],a[60][60];
int n,m;
int Max(int x,int y)
{
    if (x>y) return x;
    else return y;
}
int Min(int x,int y)
{
    if (x>y) return y;
    else return x;
}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
            scanf("%d",&a[i][j]);
    memset(F,0,sizeof(F));
    int x;
    for (int k=2;k<=n+m;k++)
        for (int i1=1;i1<=Min(n,k-1);i1++)
            for (int i2=1;i2<=Min(n,k-1);i2++)
            {
                x=a[i1][k-i1]+a[i2][k-i2];
                if (i1==i2) x=a[i1][k-i1];
                for (int i=0;i<=3;i++)
                    F[k][i1][i2]=Max(F[k][i1][i2],F[k-1][i1+dir[0][i]][i2+dir[1][i]]);
                F[k][i1][i2]+=x;
            }
    printf("%d\n",F[n+m][n][n]);
    return 0;
}

开拓者 2009-08-22 10:51 发表评论

【NOIP 2000 单词接龙】

开拓者 — Thu, 20 Aug 2009 01:30:00 GMT

问题描述：
单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们己知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙" 中出现两次），在两个单词相连时，其重合部分合为一部分，例如beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at和atide间不能相连。

输入:
输入的第一行为一个单独的整数n(n<=20）表示单词数，以下n行每行有一个单词，输入的最后一行为一个单个字符，表来“龙”开头的字母。你可以假定以此字母开头的“龙"一定存在

输出:
只需输出以此字母开头的最长的“龙”的长度

样例输入:
5
at
touch
cheat
choose
tact
a

输出
23 (连成的“龙”为atoucheatactactouchoose)

分析：
建立一个无向图，用来保存各个单词之间连接的最大增加长度，glen[i][j]表示i与j连成一个龙是可以增加的最大长度，再进行回溯求出最大长度即可。
优化：其实是题目中有的，每个单词最多用2次。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;

char s[30][300],head;
int glen[30][30],used[30];
int n,ans;
void make_g()
{
    memset(glen,0,sizeof(glen));
    int Min,pos,bk;
    for (int i=1;i<=n;i++)
        for (int j=1;j<=n;j++)
        {
            if (strlen(s[i])<strlen(s[j])) Min=strlen(s[i]);
            else Min=strlen(s[j]);
            for (int k=1;k<=Min-1;k++)
            {
                bk=1;
                for (int t=1;t<=k;t++)
                    if (s[j][t-1]!=s[i][strlen(s[i])-k+t-1])
                    {
                        bk=0; break;
                    }
                if (bk)
                {
                    pos=k; break;
                }
            }
            if (bk) glen[i][j]=strlen(s[j])-pos;
            else glen[i][j]=0;
        }
}
void Search(int last,int len)
{
    if (len>ans) ans=len;
    for (int j=1;j<=n;j++)
        if (glen[last][j] && used[j]<2)
        {
            used[j]++;
            Search(j,len+glen[last][j]);
            used[j]--;
        }
}
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%s",s[i]);
    getchar();
    scanf("%c",&head);
    make_g();
    ans=0;
    memset(used,0,sizeof(used));
    for (int i=1;i<=n;i++)
        if (s[i][0]==head)
        {
            used[i]=1;
            Search(i,strlen(s[i]));
            used[i]=0;
        }
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-20 09:30 发表评论

【NOIP 2005 过河】

开拓者 — Sat, 15 Aug 2009 03:30:00 GMT

【问题描述】
在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。

题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数

【输入文件】
输入文件river.in的第一行有一个正整数L（1 <= L <= 109），表示独木桥的长度。第二行有三个正整数S，T，M，分别表示青蛙一次跳跃的最小距离，最大距离，及桥上石子的个数，其中1 <= S <= T <= 10，1 <= M <= 100。第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。

【输出文件】
输出文件river.out只包括一个整数，表示青蛙过河最少需要踩到的石子数。

【样例输入】
10
2 3 5
2 3 5 6 7

【样例输出】
2

【数据规模】
对于30%的数据，L <= 10000；
对于全部的数据，L <= 10^9。

分析：
动态规划，需要状态压缩。
状态：F[i] 跳到距离i处碰到的最少的石子数。

状态转移方程：F[i]=min{ F[i-k] } + F[i] (S<=k<=T i-k>=0)
边界条件：F[i]=1 i处有石子

目标结果：min{ F[k] } (L+1<=k<=L+T-1)

状态压缩
由于L最大为10^9，直接线性递推会超时。发现石子数很少，这意味着路径上有许多很长的空白段。我们可以把长度大于S*T的空白段都缩小到S*T，这样最长只有10090了。

【参考程序】：

#include<cstring>
#include<cstdio>
#include<iostream>
#define maxint 0xFFFFFFF;
using namespace std;

int F[10100],stone[110];
int n,m,s,t,ans;
int cmp(const void *s,const void *t)
{
    int i=*(int *)s,j=*(int *)t;
    return i-j;
}
void reduce()
{
    int p=s*t,k;
    stone[0]=0; stone[m+1]=n;
    memset(F,0,sizeof(F));
    for (int i=1;i<=m+1;i++)
    {
        if (stone[i]-stone[i-1]>p)
        {
            k=stone[i]-stone[i-1]-p;
            for (int j=i;j<=m+1;j++)
                stone[j]-=k;
            stone[i]=stone[i-1]+p;
        }
        F[stone[i]]=1;
    }
    n=stone[m+1];
}
void dp()
{
    int mins;
    for (int i=1;i<=n+t-1;i++)
    {
        mins=maxint;
        for (int j=s;j<=t;j++)
            if (i-j>=0 && F[i-j]<mins)
                mins=F[i-j];
        F[i]+=mins;
    }
}
int main()
{
    scanf("%d",&n);
    scanf("%d%d%d",&s,&t,&m);
    for (int i=1;i<=m;i++) scanf("%d",&stone[i]);
    if (s==t)
    {
        ans=0;
        for (int i=1;i<=m;i++)
            if (stone[i]%s==0) ans++;
        printf("%d\n",ans);
        exit(0);
    }
    qsort(stone+1,m,sizeof(int),cmp);
    reduce();
    dp();
    ans=maxint;
    for (int i=n+1;i<=n+t-1;i++)
        if (ans>F[i]) ans=F[i];
    printf("%d\n",ans);
    return 0;
}

开拓者 2009-08-15 11:30 发表评论

【NOIP 2003 麦森数】

开拓者 — Fri, 01 May 2009 08:33:00 GMT

形如2^P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2^P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。
任务：从文件中输入P（1000
input:
文件中只包含一个整数P（1000
output:
第一行：十进制高精度数2^P-1的位数。
第2-11行：十进制高精度数2^P-1的最后500位数字。（一行输出，不足500位时高位补0）
不必验证2^P-1与P是否为素数。

input:
1279

output:
386
00000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000
00000000000000104079321946643990819252403273640855
38615262247266704805319112350403608059673360298012
23944173232418484242161395428100779138356624832346
49081399066056773207629241295093892203457731833496
61583550472959420547689811211693677147548478866962
50138443826029173234888531116082853841658502825560
46662248318909188018470682222031405210266984354887
32958028878050869736186900714720710555703168729087

【参考程序】：

#include<iostream>
#include<cmath>
using namespace std;
int a[502];
int n;
void work(int p)
{
        int b[1001];
        if (p==1)
        {
                a[1]=2;
                return ;
        }
        memset(b,0,sizeof(b));
        if (p%2==1)
        {
                work(p/2);
                for (int i=1;i<=500;i++)
                        for (int j=1;j<=500;j++)
                                b[i+j-1]+=a[i]*a[j];
                for (int i=1;i<=501;i++)
                {
                        a[i]=b[i]*2;
                        a[i]+=a[i-1]/10;
                        a[i-1]%=10;
                }
        }
        else
        {
                work(p/2);
                for (int i=1;i<=500;i++)
                        for (int j=1;j<=500;j++)
                                b[i+j-1]+=a[i]*a[j];
                for (int i=1;i<=501;i++)
                {
                        a[i]=b[i]+a[i-1]/10;
                        a[i-1]%=10;
                }
        }
        a[501]=0;
}
int main()
{
        scanf("%d",&n);
        printf("%0.0lf\n",floor(n*log(2.0)/log(10.0))+1);
        work(n);
        for (int i=500;i>=2;i--) printf("%d",a[i]);
        printf("%d\n",a[1]-1);
        return 0;
}

开拓者 2009-05-01 16:33 发表评论