NOIP2000 解题报告

Task1 进制转换

题面

【问题描述】

我们可以用这样的方式来表示一个十进制数：将每个阿拉伯数字乘以一个以该数字所处位置的（值减1）为指数，以10为底数的幂之和的形式。
例如，123可表示为1*102 +2*101 +3*100这样的形式。
与之相似的，对二进制数来说，也可表示成每个二进制数码乘以一个以该数字所处位置的（值-1）为指数，以2为底数的幂之和的形式。一般说来，任何一个正整数R或一个负整数-R都可以被选来作为一个数制系统的基数。如果是以R或-R为基数，则需要用到的数码为0，1，……，R-1。例如，当R=7时，所需用到的数码是0，1，2，3，4，5和6，这与其是R或-R无关。如果作为基数的数绝对值超过10，则为了表示这些数码，通常使用英文字母来表示那些大于9的数码。例如对16进制数来说，用A表示10，用B表示11，用C表示12，用D表示13，用E表示14，用F表示15。在负进制数中是用-R作为基数，例如-5（＋进制）相当于110001（-2进制），并且它可以被表示为2的幂级数的和数：
110001=1*(-2)^5+1*(-2)^4+0*(-2)^3+0*(-2)^2+0*(-2)^1+1*(-2)^0

【问题求解】

设计一个程序，读入一个十进制数的基数和一个负进制数的基数，并将此十进制数转换为此负进制下的数：-R∈{-2，-3，-4，……，-20}

【输入】

输入的每行有两个输入数据。
第一个是十进制数N（-32768<=N<=32767）；第二个是负进制数的基数-R。

【输出】

结果显示在屏幕上，相对于输入，应输出此负进制数及其基数，若此基数超过10，则参照16进制的方式处理。

【样例】

输入：

30000 -2
-20000 -2
28800 -16
-25000 -16

输出：

30000=1101101010111000（base –2）
-20000=1111011000100000（base –2）
28800=19180（base –16）
-25000=7FB8（base –16）

解法：

考虑对于正整数进制的分解，可以猜测到依旧使用短除法。但是同样由于进制位是负数，在作短除法的时候需手动令每一位的位权都取最接近0的正数。

#include <cstdio>
#include <iostream>
using namespace std;
char cache[1000];
int main()
 {
    int num,radix;
    while(scanf("%d%d",&num,&radix)==2)
       {
          cout << num << "=";
          int cnt=0,k=num;
          while(k<0 || k>=-radix)
            {
                cache[cnt]=k%radix;
                k/=radix;
                if(cache[cnt]<0)
                 {
                    cache[cnt]-=radix;
                        k++;
                     }
                cnt++;
                 }
         cache[cnt]=k;
          for ( ;cnt>=0;cnt--)
           if(cache[cnt]>=0 && cache[cnt]<=9)
            cout << (char)(cache[cnt]+'0');
           else
            cout << (char)(cache[cnt]-10+'A');
          cout << "(base " << radix << ")" << endl; 
        }
    return 0;
  }

Task2 乘积最大

题面

【问题描述】

今年是国际数学联盟确定的“2000——世界数学年”，又恰逢我国著名数学家华罗庚先生诞辰90周年。在华罗庚先生的家乡江苏金坛，组织了一场别开生面的数学智力竞赛的活动，你的一个好朋友XZ也有幸得以参加。活动中，主持人给所有参加活动的选手出了这样一道题目：
设有一个长度N的数字串，要求选手使用K个乘号将它分成K+1个部分，找出一种分法，使得这K+1个部分的乘积能够为最大。
同时，为了帮助选手能够正确理解题意，主持人还举了如下的一个例子：
有一个数字串：312，当N=3，K=1时会有以下两种分法：
1）3*12=36
2）31*2=62
这时，符合题目要求的结果是： 31*2=62
现在，请你帮助你的好朋友XZ设计一个程序，求得正确的答案。

【输入】

程序的输入共有两行：
第一行共有2个自然数N，K (6<=N<=40，1<=K<=6)
第二行是一个长度为N的数字串。

【输出】

结果显示在屏幕上，相对于输入，应输出所求得的最大乘积（一个自然数）。

【样例】

输入：

4 2
1231

输出：

62

解法：

由题意可以列出动态规划方程：
dp[j][i] = max⁡{dp[l][i-1]*sum[l+1][j]} (i<=l

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
long long a[100][100],dp[100][100];
int main()
{
 int n,k,i,j,l;
 long long sum;
 scanf("%d %d",&n,&k);
 scanf("%lld",&sum);
 for(i=n;i>=1;i--)
 {
  a[i][i]=sum%10;
  sum/=10;
 }
 for(i=2;i<=n;i++)
  for(j=i-1;j>=1;j--)
   a[j][i]=a[j][i-1]*10+a[i][i];
 for(i=1;i<=n;i++)    dp[i][0]=a[1][i];
 for(i=1;i<=k;i++)
  for(j=i+1;j<=n;j++)
   for(l=i;l<j;l++)
   dp[j][i]=std::max(dp[j][i],dp[l][i-1]*a[l+1][j]);
 printf("%lld",dp[n][k]);
 return 0;
}

Task3 单词接龙

题面

【问题描述】

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

【输入】

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

【输出】

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

【样例】

输入：

5
at
touch
cheat
choose
tact
a

输出：

23 （连成的“龙”为atoucheatactactouchoose）

解法：

一道非常明显的爆搜题，但是语言与算法知识考察非常厉害，同时考察了搜索，字符串匹配两大难点。细节方面也要注意。

#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
int visited[21];
int N;
string words[21],head;
int min( int a , int b )
 {
    return a>b?b:a;
 }
string min_merge( string Ans , string b , int pre_length)
 {
    bool flag;
    int st=Ans.length()-b.length()+1;
    st=st<0?0:st;
    for ( int i=Ans.length()-1;i>=st;i--)
      {
        flag=true;
        if(pre_length<Ans.length()-i-1)
          continue;
        for ( int j=min(Ans.length()-i-1,pre_length);j>=0;j--)
         {      
            if(Ans[j+i]!=b[j]) 
             {
                flag=false;
                break;
             }
           }
        if(flag)
          {
             for ( int j=Ans.length()-i;j<b.length();j++)
                 Ans=Ans+b[j];
             break;
          }
       } 
    return Ans;
 }
int dfs( string Now , int prelen )
  {
      int Ans=Now.length();
      string a;
      for(int i=1;i<=N;i++)
        if(visited[i]<2)
         {
            a=min_merge(Now,words[i],prelen);
            if(a.length()>Now.length()) 
             {
                visited[i]++;
                Ans=max(Ans,dfs(a,words[i].length()));
                visited[i]--;
              } 
          } 
      return Ans;
  }
int main()
 {
    ios::sync_with_stdio(false); 
    memset(visited,0,sizeof(visited));
    cin >> N;
    for ( int i=1;i<=N;i++)
       cin >> words[i];
    cin >> head;
    string ans="";
    int Ans=0;
    for ( int i=1;i<=N;i++)
      if(head[0]==words[i].at(0))
       {
           visited[i]++;
           Ans=max(dfs(ans+words[i],words[i].length()),Ans);
           ans="";
           visited[i]--;
       }
    cout << Ans << endl;
    return 0;
 }

Task4 方格取数

题面

【问题描述】

设有N*N的方格图(N≤8)，我们将其中的某些方格中填入正整数，而其他的方格中则放人数字0。如下图所示（见样例）：
某人从图的左上角的A点出发，可以向下行走，也可以向右走，直到到达右下角的B 点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。
此人从A点到B点共走两次，试找出2条这样的路径，使得取得的数之和为最大。

【输入】

输入的第一行为一个整数N（表示N*N的方格图），接下来的每行有三个整数，前两个表示位置，第三个数为该位置上所放的数。一行单独的0表示输入结束。

【输出】

只需输出一个整数，表示2条路径上取得的最大的和。

【样例】

输入：

8
2 3 13
2 6 6
3 5 7
4 4 14
5 2 21
5 6 4
6 3 15
7 2 14
0 0 0

输出：

67

解法：

有两种做法。

一种较为乱搞的四维做法：

考虑到只需走两次，不妨令状态为两次从左上走到某两个点，存储的则为路上能取到的数的最大值，此时无需考虑是否有同一个数被取二次的问题。如果两个点坐标相等，则当前坐标所在的格子的数只取一份即可。复杂度O(n^4)，范围较小，可以稳过

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
long long dp[11][11][11][11];
int map[11][11];
int main()
 {
    int N;
    cin >> N;
    int x,y,w;
    memset(dp,0,sizeof(dp));
    memset(map,0,sizeof(map));
    while( cin >> x >> y >> w && x && y && w)
       map[x][y]=w;
    for ( int i=1;i<=N;i++)
      for ( int j=1;j<=N;j++)
        for ( int k=1;k<=N;k++)
          for ( int l=1;l<=N;l++)
            {
                dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i][j-1][k-1][l]),max(dp[i-1][j][k][l-1],dp[i][j-1][k][l-1]));
                if(i!=k && j!=l)
                   dp[i][j][k][l]+=map[i][j]+map[k][l];
                else
                   dp[i][j][k][l]+=map[i][j]; 
             }
    cout << dp[N][N][N][N] << endl;
 }

一种可以推广的标准化做法(参考成都七中 高2002级8班 章云樵的解法)

阶段划分：对于N*N的矩形按其与对角线平行的直线划分为2*N+1个阶段。
此时即可计算出坐标。
状态：每个阶段有2维的状态，分别描述两次取数在该阶段的位置。记为F[K，I，J]。
规划方程：
F[K，I，J]=
(I<>J)=MAX{F[K-1,I’,J’]}+(第K阶段第I和J位置对应所取数字) (第K-1阶段I’位
置可达第K阶段I位置,第K-1阶段J位置可达第K阶段J位置).
(I=J)=MAX{F[K-1,I’,J’]}+(第K阶段第I位置对应所取数字) (第K-1阶段I’位置可
达第K阶段I位置,第K-1阶段J位置可达第K阶段J位置).

代码并没有写>_<