C++博客-啥也别说了-随笔分类-pku/acm

ACM 2402 Palindrome Numers

hunter — Sun, 30 Nov 2008 17:28:00 GMT

摘要: 计算第N位的形如12321的可逆数我是先把1位，2位~100位数中各含几个可逆数算出来，计入数组num，然后根据输入的N位置，算出该数有几位，并处于什么位置。依次通过取整取余得出结果。如要求出第24位，因为1位数和2位数中各含9个可逆数，所以所要求的数位于3位数中的第6个先用6对num【1】取整（三位数的个数其实就是最高和最低位从1到9，而中间只是1位数的个数加1（0）），取整后得0，而0代表第一... 阅读全文

hunter 2008-12-01 01:28 发表评论

ACM 2325 Persistent Number 大数相除

hunter — Sun, 30 Nov 2008 12:30:00 GMT

1000位的数字！！看来只能输入字符串了。。。

下面是某大大的代码，思路就是从2到9中找出能被N整除的数，然后打印出最小的组合

大数相那一段很值得学习！

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

#define  MAXCHAR 1002

void Div(char *ch1, char *ch2, char *ch3) {
    char temp[MAXCHAR];
    int i;
    memset(ch3,0,sizeof(ch3));
    int num=ch2[0]-'0';
    int len=strlen(ch1);
    int s=0;
    for(i=0;i<len;i++){       //大数相除
        s=s*10+ch1[i]-'0';
        ch3[i]=s/num+'0';
        s%=num;
    }
    int flag=0;
    int j=0;
    for(i=0;i<len;i++){
        if(flag==0&&ch3[i]=='0')
            continue;
        flag=1;
        temp[j]=ch3[i];
        j++;
    }
    temp[j]='\0';
    strcpy(ch3,temp);
}
bool op(char *num,int t){
    int len=strlen(num);
    int i,j,k;
    k=0;
    for(i=0;i<len;i++){
        k=k*10+num[i]-'0';
        k=k%t;
    }
    if(k==0)
        return true;
    else
        return false;
}
int main() {
    char num[MAXCHAR], s[300];
    char temp[MAXCHAR];
    char aaa[MAXCHAR];
    int i, j;
    int ans[10][2];
    while (1) {
        scanf("%s", &num);
        if(num[1]=='\0'){
            printf("1%c\n",num[0]);
            continue;
        }
        memset(ans, 0, sizeof (ans));
        if (num[0] == '-')
            break;
        for (i = 9; i >= 2; i--) {
            s[0]=i+'0';
            s[1]='\0';
            strcpy(temp, num);
            while (1) {
                if (op(temp,i) ) {
                    Div(temp,s,aaa);
                    strcpy(num,aaa);
                    ans[i][0]=1;
                    ans[i][1]++;
                    strcpy(temp,num);
                }
                else
                    break;
            }
            if(num[1]=='\0')
                break;
        }
        if(num[1]!='\0'){
            printf("There is no such number.\n");
            continue;
        }
        ans[num[0]-'0'][0]=1;
        ans[num[0]-'0'][1]++;
        for (i = 2; i < 10; i++) {
            if (ans[i][0] = 1) {
                for (j = 0; j < ans[i][1]; j++)
                    printf("%d", i);
            }
        }
        printf("\n");
    }
    return 0;
}

hunter 2008-11-30 20:30 发表评论

ACM 2316 SPIN

hunter — Sat, 29 Nov 2008 18:44:00 GMT

注意输入时并不知道有几位。。。有哪位大侠知道在自己电脑上运行怎么跳出循环吗？即scanf==EOF？
EOF自己输入什么？

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
    char input[15];char result[15];
    int len;
    scanf("%s",result);
    while (scanf("%s",input)!=EOF)
    {
        len=strlen(input);

        for (int i=0;i<len;i++)
        {
            result[i]=(result[i]-'0'+input[i]-'0')%10+'0';
        }
    }
    printf("%s",result);
}

hunter 2008-11-30 02:44 发表评论

ACM 2299 Ultra QuickSort 合并排序的应用

hunter — Sat, 29 Nov 2008 16:30:00 GMT

题目是快速排序，可用的居然是合并排序，排序中计算逆序数即可。。。

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

long long int count;

void Merge(long long int a[],long long int p,long long int k,long long int q)
{
    long long int num1=k-p+1;
    long long int num2=q-k;
    long long int i;
    long long int* b1=new long long int[num1+1];
    long long int* b2=new long long int[num2+1];
    for (i=0;i<num1;i++)
    {
        b1[i]=a[p+i];
    }
    b1[i]=9999999999;
    for (i=0;i<num2;i++)
    {
        b2[i]=a[k+i+1];
    }
    b2[i]=9999999999;
    int j=0;i=0;
    for(long long int kk=p;kk<=q;kk++)
    {
        if (b1[i]<=b2[j])
        {
            a[kk]=b1[i];
            i++;
        }
        else
        {
            a[kk]=b2[j];
            j++;
            count+=(num1-i);    //求逆序数，即若b中有元素比a小，插入后共有a数组大小减去当前指向a的位置个逆序
        }
    }
    delete [] b1;
    delete [] b2;
}
void MergeSort(long long int a[],long long int p,long long int q)
{
    if (p<q)
    {
        long long int k=(p+q)/2;
        MergeSort(a,p,k);
        MergeSort(a,k+1,q);
        Merge(a,p,k,q);
    }
}
int main()
{
    long int num;
    while (scanf("%ld",&num)!=EOF&&num)
    {
        long long int* input=new long long int[num];
        count=0;
        for (int i=0;i<num;i++)
        {
           scanf("%lld",&input[i]);
        }
        MergeSort(input,0,num-1);
        printf("%lld\n",count);
         delete [] input;
    }

}

hunter 2008-11-30 00:30 发表评论

ACM 2291 Rotten Ropes

hunter — Sat, 29 Nov 2008 13:20:00 GMT

很简单的一道题，先从小到大排序，依次比较最小值*当前绳子数目，得出最大值

#include "stdio.h"
#include "stdlib.h"
long rope[10001];

int cmp(const void *a,const void *b)
{
    long *x=(long *)a;
    long *y=(long *)b;
    return  *x-*y;
}

int main()
{
    int t,m,i,j;
    long max;
    scanf("%d",&t);
    while(t--)
    {
        max=0;
        scanf("%d",&m);
        for(i=0;i<m;i++)
            scanf("%d",&rope[i]);
        qsort(rope,m,sizeof(long),cmp);
        for(j=m,i=0;j>0;i++,j--)
        {
            if(max < rope[i] * j )
                max = rope[i] * j;
        }
        printf("%ld\n",max);
    }
    return 0;
}

hunter 2008-11-29 21:20 发表评论

ACM 2275 Flipping Pancake reverse()函数的应用

hunter — Sat, 29 Nov 2008 12:07:00 GMT

最烂的算法，先按大小排序，从最大的开始，如果不在最底，则先换到最上再换到最下，依次进行。。

还要注意数组越界问题，比如记录次数的数组大小可能为2*n-3.。。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[100],b[100],n;
bool big(int x,int y)
{
    return x>y;
}

int main()
{
    int i,j;
    while(scanf("%d",&n)&&n)
    {
        for(i=1;i<=n;i++)
            scanf("%d",&a[i]);
        reverse(&a[1],&a[n+1]);

        int tmp[100]={0},tp=1;
        for(i=1;i<=n;i++)
            b[i]=a[i];
        sort(b+1,b+n+1,big);

        for(i=1;i<=n;i++)
        {
            for(j=n;j>=i;j--)
            {
                if(b[i]==a[j])
                {
                    if(i==j)
                        ;
                    else
                    {
                        if(j!=n)
                        {
                            tmp[tp++]=n-j+1;
                            tmp[tp++]=n-i+1;
                            reverse(&a[j],&a[n+1]);

                            reverse(&a[i],&a[n+1]);
                        }
                        else
                        {
                            tmp[tp++]=n-i+1;
                            reverse(&a[i],&a[n+1]);
                        }
                    }
                    break;
                }
            }
        }
        printf("%d",tp-1);
        for(i=1;i<tp;i++)
            printf(" %d",tmp[i]);
        printf("\n");
    }
    return 0;
}

PS：还有个算法
设flip(k)是将前k个数反转的操作

就以sample output第二个为例，43251
从最大数放起，先放5
在放5之前看4在不在5前面的数里，如果不在就不管他了，只处理5一个数，把它放到最后去
实际上是4在5前面，则先flip(3)让4紧挨5，变成23451
然后看3在不在4前面，在，并且正好紧邻
2同上
看1在不在2前面，不在，所以这次处理就处理到2，flip(4);flip(5)把2345放到最后去，变成12345
然后处理1，它已经在该在的位置，结束

hunter 2008-11-29 20:07 发表评论

ACM 2273 An Excel-lent Problem

hunter — Fri, 28 Nov 2008 12:30:00 GMT

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
    char input[21];
    while (scanf("%s",input)!=EOF)
    {
        char row[10]="",coll[10]="";
        long int col;
        char output[21]="";
        if (input[1]=='0'&&input[3]=='0')
             break;
        int add=strchr(input,'C')-input;
        strncpy(row,input+1,add-1);
        int len=strlen(input)-add-1;
        strncpy(coll,input+add+1,len);
        col=(long int)atol(coll);
        int i=0;
        while (col)
        {
            output[i++]='A'+(col-1)%26;   //注意要-1，因为A此时代表的相当于十进制中的0
            col=(col-1)/26;               //当col取26时，应该给Z而不是AA
        }
        int olen=strlen(output);
        for (int j=0;j<olen/2;j++)
        {
            char temp=output[j];
            output[j]=output[olen-j-1];
            output[olen-j-1]=temp;
        }
        printf("%s%s\n",output,row);
    }
}

一道我虽然做出来，但自己还没领悟其转换本质的题，也许是测试数据太弱才让过的。

从1开始到26，分别用A到Z表示，27则是AA。。。。相当于十进制里面没有0

hunter 2008-11-28 20:30 发表评论

ACM 2183 Bovine Math Geniuses

hunter — Fri, 28 Nov 2008 07:39:00 GMT

根据题意一步一步做，注意找到就结束即可。。。

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
    long int input,output[100],temp;
    int count=0;
    scanf("%ld",&input);
    output[0]=input;
    bool find=false;
    for (int i=1;i<100;i++)
    {
        if(find==false)
        {
            temp=(output[i-1]%(long int)pow(10.0,5))/10;
            output[i]=(temp*temp)%(long int)pow(10.0,6);
            count++;
           for (int j=0;j<i;j++)
             {
               if (output[i]==output[j])
               {
                   printf("%ld %d %d",output[j],i-j,count);
                   find=true;
                   break;
               }
             }
        }
    }
}

hunter 2008-11-28 15:39 发表评论

ACM 2141 Message Decowding

hunter — Fri, 28 Nov 2008 06:59:00 GMT

另类解码，只是最后不能输出换行。。。

#include<iostream>
#include<cstring>
using namespace std;
char key[30];

int main()
{
cin>>key;
cin.ignore(100,'\n');
char text[100];
cin.getline(text,100);
int i,j,len;
len=strlen(text);
for(i=0;i<len;i++)
{
   if(text[i]!=' ')
   {
    if(text[i]>='A'&&text[i]<='Z')
     text[i]=key[text[i]-'A']-'a'+'A';
    else
     text[i]=key[text[i]-'a'];
   }
}
cout<<text<<endl;
}

hunter 2008-11-28 14:59 发表评论

ACM 2140 Herd Sums

hunter — Thu, 27 Nov 2008 18:51:00 GMT

计算一个数N由连续数相加的方案数，通过递归加上适当的剪枝可以实
勉强实现了，差点超时了。。。

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int count;
void getCount(long int current,long int start,bool fst)   //fst代表是否为第一轮查找，若不是，之后只要有一个数不连续则返回

{
    for (long int i=start;i>0;i--)
    {
        if(current>=i)
        {
            current-=i;
           if (current==0)
           {
               count++;
               current+=i;
               continue;
           }
           else
           {
               if(current>=i-1)
               {
                   getCount(current,i-1,false);
               }
               if(fst)
               {current+=i;continue;}
               else
                   return;
           }
           current+=i;
        }
    }
}
int main()
{
    long int n;
    while (scanf("%ld",&n)!=EOF)
    {
          count=0;
          getCount(n,n,true);
          printf("%ld\n",count);
    }
}

hunter 2008-11-28 02:51 发表评论

ACM 2126 Factoring a Polynomial

hunter — Thu, 27 Nov 2008 12:25:00 GMT

其实就是实系数多项式分解定理!n>=1的实系数多项式在实数域上都可以分解成一次因式与二次不可约因式的乘积!
在实数域上，奇次一定有一个根，偶次有共轭虚根,总是可以分解成两个n/2的多项式。

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    int a,b,c,n;
    while(cin>>n)
    {
        if(n<2)
        {
            while(n>=0)
            {
                n--;
                cin>>a;
            }
            cout<<"YES"<<endl;
        }
        else if(n==2)
        {
            cin>>a>>b>>c;
            if(b*b>=4*a*c)
                cout<<"NO"<<endl;
            else
                cout<<"YES"<<endl;
        }
        else
        {
            while(n>=0)
            {
                n--;
                cin>>a;
            }
            cout<<"NO"<<endl;
        }
    }
    return 0;
}

hunter 2008-11-27 20:25 发表评论

ACM 2105 IP Address

hunter — Thu, 27 Nov 2008 12:08:00 GMT

简单的进制转换

因为少了换行，贡献了一个PE。。

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int cmp(const void* a,const void* b)
{
    return *(long int*)a>*(long int*)b?1:-1;
}
int main()
{
    int n;
    scanf("%d",&n);
    while (n--)
    {
        char input[35];
        scanf("%s",input);
        int len=32;
        int count=0;
        for (int i=0;i<len;i++)
        {

           if (i%8==0&&i!=0)
           {
               printf("%d.",count);
               count=0;
           }
           if (input[i]=='1')
           {
               count+=pow(2.0,7-i%8);
           }
           if (i==len-1)
           {
               printf("%d",count);
               break;
           }
        }
        printf("\n");
    }
}

hunter 2008-11-27 20:08 发表评论

ACM 2070 Filling Out the Team

hunter — Thu, 27 Nov 2008 10:45:00 GMT

建议自己电脑上实现的就不要在这上面浪费时间了，估计判定又出问题了。。。

printf能AC,而cout就WA。。。

#include<stdio.h>
int main()
{
double speed,weight,strength;
bool flag;
while(scanf("%lf%lf%lf",&speed,&weight,&strength)&&speed&&weight&&strength)
{
  flag=0;
  if((speed<=4.5)&&(weight>=150)&&(strength>=200))
  {
   printf("Wide Receiver ");
   flag=1;
  }
  if((speed<=6.0)&&(weight>=300)&&(strength>=500))
  {
   printf("Lineman ");
   flag=1;
  }
  if((speed<=5.0)&&(weight>=200)&&(strength>=300))
  {
   printf("Quarterback ");
   flag=1;
  }
  if(!flag)printf("No positions");
  printf("\n");
}
return 0;
}

hunter 2008-11-27 18:45 发表评论

ACM 2042 Lagrange's Four-Square 剪枝快了2倍

hunter — Thu, 27 Nov 2008 08:13:00 GMT

这道题我刚下手就是递归，虽然一次成功但发现时间可能不够，提交果然TLE

分析后发现，如果一次计算后，剩余的值如果比下一次开始最大值的平方的剩余次数倍还大，那就不可能了，
于是剪枝，最后采用了313MS，快了至少2倍多

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int count;

void getCount(int current,int start,int times)
{
    if(times==0) return;
    for (int i=start;i>0;i--)
    {
         if (i*i<=current)
         {
             current-=i*i;
             if (current==0)
               count++;
             else
             {
                 if (i*i*(times-1)<current)    //重要剪枝，若下次递归的最大值平方的times-1倍还没当前值大则剪枝
                     return;
                 getCount(current,i,times-1);
             }
         current+=i*i;
         }
    }
}

int main()
{
    int n;
    while (scanf("%d",&n)!=EOF)
    {
        if (n==0)
          break;
        int start=(int)sqrt((double)n);
        count=0;
        getCount(n,start,4);
        printf("%d\n",count);
    }
}

hunter 2008-11-27 16:13 发表评论

ACM 2038 Team Rankings 全排的另一应用

hunter — Thu, 27 Nov 2008 05:36:00 GMT

STL里的next_permutation和strchr的配合使用，很方便

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
   int n;
   char input[100][6];
   while (scanf("%d",&n)!=EOF)
   {
      if (n==0)
         break;
      char team[6]={'A','B','C','D','E'};
      for (int i=0;i<n;i++)
      {
          scanf("%s",input[i]);
      }
      int count,min=9999;
      char output[6];
      do
      {
          count=0;
          for (int i=0;i<n;i++)
          {
              for (int j=0;j<4;j++)
              {
                  for (int k=j+1;k<5;k++)
                  {
                      if (strchr(input[i],team[j])>strchr(input[i],team[k]))
                      {
                          count++;
                      }
                  }
              }
          }
          if (count<min)
          {
              min=count;
              memcpy(output,team,6);
          }
      } while (next_permutation(team,team+5));
      printf("%s is the median ranking with value %d.\n",output,min);
   }
}

hunter 2008-11-27 13:36 发表评论

ACM 2027 No Brainer

hunter — Tue, 25 Nov 2008 15:31:00 GMT

如此水题，和第一题差不多了。。。

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
   int n,x,y;
   scanf("%d",&n);
   while (n--)
   {
      scanf("%d %d",&x,&y);
      if (x>=y)
      {
          printf("MMM BRAINS\n");
      }
      else
          printf("NO BRAINS\n");
   }
}

hunter 2008-11-25 23:31 发表评论

ACM 2021 Relative Relatives

hunter — Tue, 25 Nov 2008 15:02:00 GMT

计算Ted后代的年龄并排序

第一次用结构，居然一次AC了，很爽。。

运用递归查找相应节点的上一代年龄，没有则再向上查

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

struct descedant
{
    char father[20];
    char child[20];
    int age;    //child的年龄
    int differ;
    void init();
};

void descedant::init()   //初始化
{
    age=0;
    differ=0;
}

descedant des[100];

void getAge(descedant& d,int n)    //递归计算出年龄
{
    for (int j=0;j<n;j++)
    {
        if (strcmp(d.father,des[j].child)==0)
        {
            if (des[j].age==0)   //未计算则递归算上一代
            {
                getAge(des[j],n);
            }
                d.age=des[j].age-d.differ;
                break;
        }
    }
}

int cmp(const void* a,const void* b)    //排序，年龄从大到小，若年龄相同则按字典顺序
{
    descedant* c=(descedant*)a;
    descedant* d=(descedant*)b;
    if (c->age==d->age)
      return strcmp(c->child,d->child);
    return d->age-c->age;
}
int main()
{
   int n,num,count=1;
   scanf("%d",&n);
   while (n--)
   {
       scanf("%d",&num);
       int k=0;
       for (int i=0;i<num;i++)
       {
           des[k].init();
           scanf("%s %s %d",des[k].father,des[k].child,&des[k].differ);
           if (strcmp(des[k].father,"Ted")==0)
           {
               des[k].age=100-des[k].differ;
           }
           k++;
       }
       for (int i=0;i<num;i++)
       {
           if (des[i].age==0)
           {
               getAge(des[i],num);
           }
       }
       qsort(des,num,sizeof(descedant),cmp);
       printf("DATASET %d\n",count++);
       for (int i=0;i<num;i++)
       {
           printf("%s %d\n",des[i].child,des[i].age);
       }
   }
}

hunter 2008-11-25 23:02 发表评论

ACM 2017 Speed Limit

hunter — Tue, 25 Nov 2008 11:59:00 GMT

难的做不来，水的不好意思做。。。。

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
   int num,sum,left,v,t;
   while (scanf("%d",&num)!=EOF)
   {
       if(num==-1)break;
       sum=0;left=0;
       for (int i=0;i<num;i++)
       {
           scanf("%d %d",&v,&t);
           sum+=v*(t-left);
           left=t;
       }
       printf("%d miles\n",sum);
   }
}

hunter 2008-11-25 19:59 发表评论

ACM 2013 Symmetric Order

hunter — Tue, 25 Nov 2008 11:51:00 GMT

没啥说的

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
   int num,count=1;
   while (scanf("%d",&num)!=EOF)
   {
       if(num==0)break;
       char input[15][26];
       for (int i=0;i<num;i++)
       {
           scanf("%s",input[i]);
       }
       printf("SET %d\n",count++);
       for (int j=0;j<num;j+=2)
       {
           printf("%s\n",input[j]);
       }
       for (int k=num-1-num%2;k>0;k-=2)
       {
           printf("%s\n",input[k]);
       }
   }
}

hunter 2008-11-25 19:51 发表评论

ACM 2000 Gold Coins

hunter — Tue, 25 Nov 2008 11:21:00 GMT

今天挺郁闷的，做了几道都没啥结果，有点气馁了。
想想为了将来还是继续努力吧。。。碰到一道水题，气都撒这上了

解不等式
(for k = 1 to i)∑k = i * (i + 1) / 2 ≤ n，
注意到i是满足上式的最小正整数，得到
i = (√(8 * n + 1) - 1) / 2（取整数）
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
于是有：
金币数
= (for k = 1 to i)∑k^2 + (n - i) * (i + 1)
= (i + 1) * (6 * n - 2 * i - i^2) / 6

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

int main()
{
    long int sum;
    int num;
    while (scanf("%d",&num)!=EOF)
    {
        if (num==0)
          break;
        sum=0;
        int n=((int)(sqrt((double)(8*num+1)))-1)/2;
        for (int j=1;j<=n;j++)
        {
            sum+=j*j;
        }
        sum+=(num-n*(n+1)/2)*(n+1);
        printf("%ld %ld\n",num,sum);
    }
}

hunter 2008-11-25 19:21 发表评论

ACM 1995 Raising Modulo Numbers 很好的求幂算法

hunter — Mon, 24 Nov 2008 13:38:00 GMT

计算h个a的b次幂的和，然后对m取余。。。直接pow是不行的

查找《算法导论》后得到算法，太牛逼了

先将b转换成2进制，存放在一个数组bin里面
d<-1
for i=0 to k-1 k为bin中存放的个数
   d<-d*d mod m
   if bin[i]==1
      d<-d*a mod m
以上是a的b次幂的算法

#include <iostream>
#include <string>
#include <vector>
using namespace std;

vector<int> bin,rev;

void GetBinary(long long int b)
{
    long long int temp;
    while (b)
    {
        bin.push_back(b%2);
        b=b/2;
    }
    for (int i=bin.size()-1;i>=0;i--)
    {
        rev.push_back(bin[i]);
    }
}
int main()
{
    int num;
    long long int d,sum,h,m,a,b;
    scanf("%d",&num);
    while (num--)
    {
        sum=0;
        scanf("%lld",&m);
        scanf("%lld",&h);
        while (h--)
        {
            scanf("%lld %lld",&a,&b);
            bin.clear();rev.clear();
            GetBinary(b);
            d=1;
           for(int index=0;index<(size_t)rev.size();index++)
           {
               d=(d*d)%m;
               if (rev[index]==1)
                d=(d*a)%m;
           }
           sum+=d;
        }
        printf("%lld\n",sum%m);
    }
}

hunter 2008-11-24 21:38 发表评论

ACM 1979 Red and Black

hunter — Sun, 23 Nov 2008 08:47:00 GMT

类似走迷宫。。。简单的深度搜索，递归就行了

#include <iostream>
#include <string>
using namespace std;

char tiles[101][101];
int used[101][101];
int count,w,h;

void countstep(int i,int j)
{
    count++;
    if (i>1&&used[i-1][j]==0)  //向上
    {
        used[i-1][j]=1;countstep(i-1,j);
    }
    if (i<h&&used[i+1][j]==0)  //向下
    {
        used[i+1][j]=1;countstep(i+1,j);
    }
    if (j>0&&used[i][j-1]==0)  //向左
    {
        used[i][j-1]=1;countstep(i,j-1);
    }
    if (j<w-1&&used[i][j+1]==0)  //向右
    {
        used[i][j+1]=1;countstep(i,j+1);
    }
}
int main()
{
   int starti,startj;
   while (scanf("%d %d",&w,&h)!=EOF)
   {
       if (w==0||h==0)
          break;
       count=0;
       memset(used,0,sizeof(used));
       for (int i=1;i<=h;i++)
       {
           scanf("%s",&tiles[i]);
       }
       for(int i=1;i<=h;i++)
       {
           for (int j=0;j<w;j++)
           {
               if (tiles[i][j]=='#')
                  used[i][j]=1;
               else if (tiles[i][j]=='@')
               {
                   used[i][j]=1;
                   startj=j;
                   starti=i;
               }
           }
       }
       countstep(starti,startj);
       printf("%d\n",count);
   }
}

hunter 2008-11-23 16:47 发表评论

ACM 1970 The Game

hunter — Sun, 23 Nov 2008 07:46:00 GMT

摘要: 简单的五子棋判定游戏注意边界问题即可，5个以上的连续不算赢 #include #include using namespace std;int stone[20][20];bool match(int type,int j,int i){ ... 阅读全文

hunter 2008-11-23 15:46 发表评论

ACM 1969 Count on Canton

hunter — Sun, 23 Nov 2008 05:57:00 GMT

水题，只要找出规律就好做了。。。。

以斜列来看，列从下往上，分子分母依次递减和递增
但奇数列是从下往上数，而偶数列则相反

#include <iostream>
#include <string>
using namespace std;

int main()
{
   int n;
   while (scanf("%d",&n)!=EOF)
   {
       int k=0,raw=n;
       while (n>k)
       {
           n-=k;
           k++;
       }
       if (k%2==0)
           printf("TERM %d IS %d/%d\n",raw,n,k-n+1);
       else
           printf("TERM %d IS %d/%d\n",raw,k-n+1,n);
   }
}

hunter 2008-11-23 13:57 发表评论

ACM 1959 Darts

hunter — Sun, 23 Nov 2008 05:36:00 GMT

未完成。。。

想用穷举法做，但不知道怎么排除重复的情况，如3*1+1*3+0和1*3+3*1+0是一样的。。。

牛人请帮忙

#include <iostream>
#include <string>
using namespace std;

int darts[61];
int sum=0,everysum=1;

int dartscount(int current,int times,int start)
{
    for (int i=start;i>0;i--)
    {
          if (darts[i]>0)
          {
              current=current-i;
              if (current==0&&times>0)
              {
                  sum+=everysum*darts[i];
              }
              else if (current>0&&times>1)
              {
                  everysum*=darts[i];
                  sum=dartscount(current,times-1,i);
                  everysum/=darts[i];
              }
              current+=i;
          }
    }
    return sum;
}

int main()
{
   memset(darts,0,sizeof(darts));
   darts[25]=1;darts[50]=1;
   for (int i=1;i<=60;i++)
   {
       if (i<=20)
         darts[i]++;
       if (i%2==0&&i/2<=20)
         darts[i]++;
       if (i%3==0&&i/3<=20)
         darts[i]++;
   }
  int n,num,k=1;
  scanf("%d",&n);
  while (n>0)
  {
      printf("Scenario #%d:\n",k++);
      scanf("%d",&num);
      sum=0;everysum=1;
      printf("%d\n\n",dartscount(num,3,num));
      n--;
  }
}

hunter 2008-11-23 13:36 发表评论

ACM 1953 World Cup Noise

hunter — Sat, 22 Nov 2008 11:45:00 GMT

典型的DP打表输出水题。。。不过用递归却会超时，ORZ

对于这样一个0,1序列,a1,a2,a3,...a(i-2),a(i-1),a(i)...
设f(i)为输入的数对应的结果
用DP做的话,假设f(i-2),f(i-1)已经知道了,那么求f(i)应该如下:
当取a(i)=0,那么结果肯定和f(i-1)是一样的,因为在后面追加的是0,肯定不会导致存在相邻;
当取a(i)=1,那么此时只要知道a(i-2)就可以了,因为我们可以使a(i-1)为0,这样就不会导致相邻的1了;
所以a[i]=a[i-1]+a[i-2];

#include <iostream>
#include <string>
using namespace std;

int fabi[50];
void init()
{
    fabi[1]=2;
    fabi[2]=3;
    for (int j=3;j<=45;j++)
    {
        fabi[j]=fabi[j-1]+fabi[j-2];
    }
}

int main()
{
     int n,i=1,num;
     init();
     cin>>n;
     while (n>0)
     {
         cin>>num;
         printf("Scenario #%d:\n",i++);
         printf("%d\n\n",fabi[num]);
         n--;
     }
}

hunter 2008-11-22 19:45 发表评论

ACM 1951 Exta Krunch

hunter — Sat, 22 Nov 2008 09:49:00 GMT

又是一道恶心题。。。PE了N次

前后不能有空格，标点符号前没空格，标点符号可以重复

#include <iostream>
#include <string>
using namespace std;

int main()
{
    char check[30];
    check[0]='A';check[1]='E';check[2]='I';check[3]='O';check[4]='U';
    char input[100];
    int j=5;bool fst=true,cfst; //fst代表是否是第一个输入字符串，cfst代表输入字符串的第一个字符
    while (scanf("%s",input)!=EOF)
    {
        int len=strlen(input);
        cfst=true;
        for (int i=0;i<len;i++)
        {
            if (strchr(check,input[i])==0)
            {
                if (input[i]!='.'&&input[i]!=','&&input[i]!='?'&&cfst&&fst==false)
                {
                    printf(" %c",input[i]);
                    check[j++]=input[i];
                    cfst=false;
                }
                else if (input[i]!='.'&&input[i]!=','&&input[i]!='?')
                {
                    printf("%c",input[i]);
                    check[j++]=input[i];
                }
                else
                {
                    printf("%c",input[i]);
                }
                fst=false;
                cfst=false;
            }
        }

    }
}

hunter 2008-11-22 17:49 发表评论

ACM 1942 Paths on a Grid T路的计算

hunter — Sat, 22 Nov 2008 07:37:00 GMT

据说是组合数学中的T路问题C（m，m+n)

经同学解释，理解了，居然没反应过来。。。
一共走n+m步，只要从中间找出n步向上的组合，剩下的都是向右了。。。

#include < iostream >
using namespace std;
double com (double n,double m)
{
    double i;
    double result(1);
    if ( n >= m - n ){ n = m-n; }
    for ( i = m;i >= m-n+1;i-=1 )
    {
        result *= (i / (i - (m - n)));
    }
    return result;
}
int main()
{
    double n,m;
    while (1)
    {
        scanf("%lf%lf",&n,&m);
        if ( n==0 && m==0 ){ break; }
        printf("%.0lf\n",com (n,m+n));
    }
    return 0;
}

hunter 2008-11-22 15:37 发表评论

ACM 1936 All in All

hunter — Fri, 21 Nov 2008 06:37:00 GMT

极度恶心的题，貌似判定有问题。。。

   #include <iostream>
#include <vector>
#include <string>
#include <math.h>
#include <iomanip>
#include <stdlib.h>
#include <algorithm>
using namespace std;

int main()
{
    string str1,str2;
    int len1,len2,i,j;
    while(cin>>str1>>str2)
    {
        j=0;
        len1 = str1.length();
        len2 = str2.length();
        for(i = 0 ; i < len2 ; i ++)
        {
            if( str1[j] == str2[i])
            {
                j++;
            }
        }
        if(j == len1)
            cout<<"Yes\n";
        else
            cout<<"No\n";
    }
    return 0;
}

hunter 2008-11-21 14:37 发表评论

ACM 1929 Calories from Fat

hunter — Thu, 20 Nov 2008 15:51:00 GMT

为什么是runtime error？
网上也找不到相关的代码。。。

郁闷高手看了回复下哈

#include <iostream>
#include <vector>
#include <string>
#include <math.h>
#include <iomanip>
#include <stdlib.h>
#include <algorithm>
using namespace std;

int pround(float f)
{
    float eps=0.49;
    int i=(int)f;
    if((f-(float)i)<eps)
        return i;
    else
        return i+1;
}

int main()
{
    float sumall=0,fat=0;
    int i=0,percent=0;float sum=0;
    char input[1000][1000];bool end=false;
    while (1)
    {
        int temp,len;
        scanf("%s",input[i]);
        if (strcmp(input[i],"-")==0&&end==true)
             break;
        end=false;
        if (strcmp(input[i],"-")==0)
        {
            float per=fat*100/sumall;
            printf("%d",pround(per));
            printf("%%\n");
            sumall=0;fat=0;
            end=true;
            continue;
        }
        len=strlen(input[i]);
        sscanf(input[i],"%d",&temp);
        if (input[i][len-1]=='c')
        {
            sum+=temp;
            if (i%5==0)
            {
               fat+=temp;
            }
        }
        else if (input[i][len-1]=='g')
        {
            if (i%5==0)
            {
                sum+=temp*9;
                fat+=temp*9;
            }
            else if (i%5==4)
            {
                sum+=temp*7;
            }
            else
            {
                sum+=temp*4;
            }
        }
        else if (input[i][len-1]=='%')
        {
            if (temp>100)
               break;
            percent+=temp;
        }
        if (i%5==4)
        {
            if (percent!=0)
            {
                sum=sum*100/(float)(100-percent);
                len=strlen(input[i-4]);
                if(input[i-4][len-1]=='%')
                {
                    sscanf(input[i-4],"%d",&temp);
                    fat+=temp*sum/100.0;
                }
            }
            sumall+=sum;
            sum=0;percent=0;
        }
        i++;
    }
}

hunter 2008-11-20 23:51 发表评论