Time Limit:1000MS  Memory Limit:65536K
Total Submit:86 Accepted:66

Description

"Well, it seems the first problem is too easy. I will let you know how foolish you are later." feng5166 says.

"The second problem is, given an positive integer N, we define an equation like this:
N=a[1]+a[2]+a[3]+...+a[m];
a[i]>0,1<=m<=N;
My question is how many different equations you can find for a given N.
For example, assume N is 4, we can find:
4 = 4;
4 = 3 + 1;
4 = 2 + 2;
4 = 2 + 1 + 1;
4 = 1 + 1 + 1 + 1;
so the result is 5 when N is 4. Note that "4 = 3 + 1" and "4 = 1 + 3" is the same in this problem. Now, you do it!"

Input

The input contains several test cases. Each test case contains a positive integer N(1<=N<=120) which is mentioned above. The input is terminated by the end of file.

Output

For each test case, you have to output a line contains an integer P which indicate the different equations you have found.

Sample Input

4
10
20

Sample Output

5
42
627
      就是这个题目上次我写整数划分的时候半天也没找到。。。直接用递归会超时！！
代买如下：
#include<cstdio>
int main()
{
    int i,j,n,c[121][121];
    for(i=1;i<121;i++)
        for(j=1;j<121;j++)
        {
            if(i==1||j==1)
                c[i][j]=1;
            else if(i<j)
                c[i][j]=c[i][i];
            else if(i==j)
                c[i][j]=c[i][j-1]+1;
            else
                c[i][j]=c[i][j-1]+c[i-j][j];
        }
    while(scanf("%d",&n)!=EOF)
    {
        printf("%d\n",c[n][n]);
    }
    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:160 Accepted:71

Description

在一个标准8*8的国际象棋棋盘上，棋盘中有些格子可能是有障碍物的。已知骑士的初始位置和目标位置，你的任务是计算出骑士最少需要多少步可以从初始位置到达目标位置。
有障碍物的格子当然不可以到达。
标准的8*8的国际象棋棋盘中每个格子可以用唯一的编号确定。行用1~8这8个数字一次表示，列用a~h这8个字母依次表示如a4,b5等。骑士走日字型。

Input

多组测试数据。
每个测试数据的第一行是一个整数b( -1 <= b <= 62)表示棋盘中有障碍物的格子的数目，当b=-1时表示输入结束。
第二行含b个不同的有障碍物的格子编号，用空格隔开，当b=0时，此行为空行。
第三行是骑士的初始格子和目标格子的编号，也用空格隔开。

Output

每组输出一行格式：
Board n: m moves
其中n表示数据的序号，m表示最少步数
如果骑士无法到达，则输出
Board n: not reachable

Sample Input

10
c1 d1 d5 c2 c3 c4 d2 d3 d4 c5
a1 f1
0
c1 b3
2
b3 c2
a1 b2
-1

Sample Output

Board 1: 7 moves
Board 2: 1 moves
Board 3: not reachable

      广度搜索！

代码如下：

#include<stdio.h>
#include<string.h>
int a[8]={-2,-2,-1,-1,1,1,2,2};
int b[8]={1,-1,2,-2,2,-2,1,-1};
int p[2][1000];
int s[9][9];
int head;
int tail;
int count;
int x3,y3;
int temp;
#define cr(x) memset(x,0,sizeof(x));
int fun(int x,int y)
{
    int x1,y1;
    int i;
    int x2,y2;
    while(head<tail)
    {
        x1=p[0][head];
        y1=p[1][head];
        for(i=0;i<8;i++)
        {
            x2=x1+a[i];
            y2=y1+b[i];
            if(x2==x3&&y2==y3)
            {
                return 1;
            }
            else    if(s[x2][y2]==0&&x2>0&&y2>0&&x2<9&&y2<9)
            {
                p[0][tail]=x2;
                p[1][tail]=y2;
                tail++;
                s[x2][y2]=1;
            }

        }

        if(head==temp)//统计步数
        {
            temp=tail-1;
            count++;
        }
        head++;    
    }
    return 0;
}
int main()
{
    int x,y;
    int i,j;
    int d;
    char c[2];
    int x1,y1;
    int z=0;
while(scanf("%d",&d)!=EOF&&d!=-1)
    {
        z++;
        for(i=1;i<9;i++)
            for(j=1;j<9;j++)
            {
                s[i][j]=0;
            }
        for(i=0;i<d;i++)
        {
            scanf("%s",c);
            x=c[1]-48;
            y=c[0]-96;
            s[x][y]=1;
        }
        scanf("%s",c);
        x1=c[1]-48;
        y1=c[0]-96;
        scanf("%s",c);
        x3=c[1]-48;
        y3=c[0]-96;
        p[0][0]=x1;
        p[1][0]=y1;
        s[x1][y1]=1;
        count=0;
        head=0;
        tail=1;
        temp=0;
        if(fun(x1,y1)==1)
        {
            printf("Board %d: %d moves\n",z,count+1);
        }
        else
        {
            printf("Board %d: not reachable\n",z);
        }
    }

    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:127 Accepted:80

Description

在一个4*5的棋盘上，输入马的起始位置坐标（纵、横），求马能返回初始位置的所有不同走法的总数（马走过的位置不能重复,马走“日”字）。

Input

多个测试数据。
每组2个数字

Output

输出不同走法的总数。

Sample Input

2 2

Sample Output

4596

               穷举法！也可以看做深搜！角度不同。。这与前面一题过河卒不同，在过河卒中如果用深搜的话会超时，我试过了。。。
代码如下：

#include<stdio.h>
#include<string.h>
int count;
int s[4][5];
int a[8]={-2,-2,-1,-1,1,1,2,2};
int b[8]={1,-1,2,-2,2,-2,1,-1};
int x1,y1;
void fun(int x,int y)
{
    int i;
    int x2,y2;
    for(i=0;i<8;i++)
    {
        x2=x+a[i];
        y2=y+b[i];
        if((x2>=0)&&(y2>=0)&&(y2<=4)&&(x2<=3)&&(s[x2][y2]==0))
        {
            s[x2][y2]=1;
            fun(x2,y2);
            s[x2][y2]=0;
        }
        else if((x2==x1)&&(y2==y1))
            count++;
    }
}
int main()
{

    while((scanf("%d %d",&x1,&y1)!=EOF))
    {
        count=0;
        if((x1<=4)&&(y1<=5)&&(y1>0)&&(x1>0))
        {
            x1=x1-1;
            y1=y1-1;
            memset(s,0,sizeof(s));
            s[x1][y1]=1;
            fun(x1,y1);
            printf("%d\n",count);
        }
        else
        {
            printf("%d\n",count);
        }
    }
    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:691 Accepted:155

Description

棋盘上A点有一个过河卒，需要走到目标B点。卒行走的规则：可以向下、或者向右。同时在棋盘上的任一点有一个对方的马（如C点），该马所在的点和所有跳跃一步可达的点称为对方马的控制点，如图中的C点和P1，……，P8，卒不能通过对方马的控制点。棋盘用坐标表示，A点(0,0)、B点(n, m) (n,m为不超过20的整数),同样马的位置坐标是需要给出的，C≠A且C≠B。现在要求你计算出卒从A点能够到达B点的路径的条数。

           1   2   3   4   5   6   7    8

     A +---+---+---o---+---o---+---+----+--------->Y

       |   |   |   |   |   |   |   |    |

     1 +---+---o---+---+---+---o---+----+

       |   |   |   |   |   |   |   |    |

     2 +---+---+---+---C---+---+---+----+

       |   |   |   |   |   |   |   |    |

     3 +---+---o---+---+---+---o---+----+

       |   |   |   |   |   |   |   |    |

     4 +---+---+---o---+---o---+---+----+ B(4,8)

       |

       |

       V



       X

Input

多个测试案例，每个案例一行，处理到文件末尾
B点坐标（n,m）以及对马的坐标（X,Y）{不用判错}

Output

一个整数(路径的条数)

Sample Input

6 6 3 2 

Sample Output

17

         这个题目还是不错的。。。

代码如下：

#include<stdio.h>


int s[21][21];
__int64 c[21][21];


int a0[8]={-2,-2,-1,-1,1,1,2,2};
int b0[8]={1,-1,2,-2,2,-2,1,-1};

int x1,y1;
int x3,y3;

int main()
{
    int x2,y2;
    int i,j;
    int test;
    while((scanf("%d %d %d %d",&x1,&y1,&x3,&y3)!=EOF))
    {

        for(i=0;i<21;i++)
            for(j=0;j<21;j++)
            {
                s[i][j]=1;
                c[i][j]=0;
            }
        s[x3][y3]=0;
        for(i=0;i<8;i++)//计算受马控制的点
        {
            x2=x3+a0[i];
            y2=y3+b0[i];
            if((x2>=0)&&(y2>=0)&&(y2<=20)&&(x2<=20))
            {
                s[x2][y2]=0;
            }
        }


        test=1;
        for(j=0;j<21;j++)//初始化边上的走法
        {
            if(test)
            {
                if(s[0][j]==0)
                {
                    test=0;
                }
                else
                {
                    c[0][j]=1;
                }
            }

        }
        test=1;
        for(j=0;j<21;j++)
        {
            if(test)
            {
                if(s[j][0]==0)
                {
                    test=0;
                }
                else
                {
                    c[j][0]=1;
                }
            }
        }


        for(i=1;i<21;i++)//计算一个点上的走法，上方点的走法数+左方点的走法数
            for(j=1;j<21;j++)
            {
                if(s[i][j])
                {
                    
                    c[i][j]=c[i-1][j]*s[i-1][j]+c[i][j-1]*s[i][j-1];
                }
            }
        

            printf("%I64d\n",c[x1][y1]); 
    }
    return 0;
}

设有n 种不同面值的硬币，各硬币的面值存于数组T［1:n］中。现要用这些面值的硬币来找钱。可以使用的各种面值的硬币个数存于数组Coins［1:n］中。
对任意钱数0≤m≤20001，设计一个用最少硬币找钱m的方法。

编程任务：
对于给定的1≤n≤10，硬币面值数组T和可以使用的各种面值的硬币个数数组Coins，以及钱数m，0≤m≤20001，编程计算找钱m的最少硬币数。

Input

输入包括多组测试数据，每组输入的第一行中只有1 个整数给出n的值,第2 行起每
行2 个数，分别是T[j]和Coins[j]。每组输入最后1 行是要找的钱数m。

Output

Sample Input

3
1 3
2 3
5 3
18

Sample Output

5

         动态规划题。

代码如下：

#include<cstdio>
int main()
{
    int t[11],coins[11],c[11][20002];//c[i][j]前i种硬币找j块钱最少硬币数
    int i,j,n,m,k;
    while(scanf("%d",&n)!=EOF)
    {
        for(i=1;i<=n;i++)
        {
            scanf("%d %d",&t[i],&coins[i]);
        }
        scanf("%d",&m);
        for(i=1;i<=n;i++)        //初始化
            for(j=0;j<=m;j++)
            {
                if(j==0)
                    c[i][j]=0;
                else if(i==1)  
                    if(j%t[i]==0&&j/t[i]<=coins[i])
                        c[1][j]=j/t[i];
                    else
                        c[1][j]=1000000;
                else
                    c[i][j]=1000000;
            }

        for(i=2;i<=n;i++)        //构造c数组
            for(j=1;j<=m;j++)
                for(k=0;k<=coins[i];k++)
                {
                    if(c[i][j]>(c[i-1][j-k*t[i]]+k)&&(j-k*t[i])>=0)
                            c[i][j]=c[i-1][j-k*t[i]]+k;
                }
        if(c[n][m]!=1000000)
        {
            printf("%d\n",c[n][m]);
        }
        else
            printf("-1\n");
    }
    return 0;
}

题目地址：http://acm.nankai.edu.cn/p1132.html

Time Limit:1000MS  Memory Limit:65536K
Total Submit:488 Accepted:197

Description

有由n个不相同的整数组成的数列，记为a(1)、a(2)、...a(n),当i!=j时，a(i)!=a(j)。若存在i1 < i2 < i3 < ... < ie,且有a(i1) < a(i2) < ... < a(ie), 则称为长度为e的不下降序列。
如 3，18，7，14，10，12，23，41，16，24
则有3，18，23，24是一个长度为4的不下降子序列
3，7，10，12，23，24是长度为6的不下降子序列。
现要求你求最长的不下降子序列。

Input

多组测试数据
每组一行，先输入一个数列长度n （1 <= n <= 1000),然后是n个整数
处理到文件末尾

Output

输出最长不下降子序列的长度

Sample Input

10 3 18 7 14 10 12 23 41 16 24

Sample Output

6

         简单动态规划题，给予我们一种思想！！

代码如下：

#include<stdio.h>
int Longest_Increasing(int num[],int List[],int n)//List[i]为包含i项在内的最长不下降子序列
{
    int i,j;
    for(i=1;i<n;i++)
    {
        for(j=0;j<i;j++)
        {
            if(num[i]>num[j]&&List[i]<List[j]+1)
                    List[i]=List[j]+1;
        }
    }
    return 0;
}

int main()
{
    int n,i,ans;
    int num[1001],List[1001];
    while(scanf("%d",&n)!=EOF)
    {
        for(i=0;i<n;i++)
        {
            List[i]=1;
            scanf("%d",&num[i]);
        }

        Longest_Increasing(num,List,n);
        
/**//*        printf("最优解：\n");
        for(i=0;i<n;i++)
            printf("%d ",List[i]);
        printf("\n");*/

        ans=0;
        for(i=0;i<n;i++)
            if(List[i]>ans)
                ans=List[i];

        printf("%d\n",ans);
    }
    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:394 Accepted:183

Description

要求找出具有下列性质数的个数（包括输入的自然数n):
先输入一个自然数n( n <= 1000),然后对此自然数按照如下方法进行处理：
（1）不作任何处理
（2）在它的左边加上一个自然数，但该数不能超过原数的一半
（3）加上数后，继续按此处理，直到不能再加自然数为止

Input

多个测试案例，每个测试案例
输入一个自然数n

Output

输出满足以上条件的所有数的个数

Sample Input

6

Sample Output

6

Hint

对于6，满足条件的数有
6
16
26
126
36
136

#include<string.h>
#include<stdio.h>
int main()
{
    int s[1001];
    int i,j,n;
    memset(s,0,sizeof(s));
    s[1]=1;
    s[2]=2;
    for(i=3;i<1001;i++)
    {
        for(j=1;j<=i/2;j++)
        {
            s[i]=s[j]+s[i];
        }
        s[i]++;
    }
    while(scanf("%d",&n)!=EOF)
    {
        printf("%d\n",s[n]);
    }
    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:615 Accepted:149

Description

都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下身上的背包去接。但由于小径两侧都不能站人，所以他只能在小径上接。由于gameboy平时老呆在房间里玩游戏，虽然在游戏中是个身手敏捷的高手，但在现实中运动神经特别迟钝，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。现在给这条小径如图标上坐标：

Input

输入数据有多组。每组数据的第一行为以正整数n(0 < n < 100000)，表示有n个馅饼掉在这条小径上。在结下来的n行中，每行有两个整数x,T(0 <= T < 100000),表示在第T秒有一个馅饼掉在x点上。同一秒钟在同一点上可能掉下多个馅饼。n=0时输入结束。

Output

每一组输入数据对应一行输出。输出一个整数m，表示gameboy最多可能接到m个馅饼。
提示：本题的输入数据量比较大，建议用scanf读入，用cin可能会超时。

Sample Input

6
5 1
4 1
6 1
7 2
7 2
8 3
0

Sample Output

4

Source

hdu1176

#include<cstdio>
#include<cstdlib>
#include<cstring>
int time[100001][11];
int max(int x,int y,int z)
{
    if(x>y)
        if(x>z)
            return x;
        else
            return z;
    else
        if(y>z)
            return y;
        else
            return z;
}
int main()
{
    int i,j,k,n,x,y;
    while(scanf("%d",&n)!=EOF&&n!=0)
    {
        memset(time,0,sizeof(time));
        k=0;
        for(i=0;i<n;i++)
        {
            scanf("%d %d",&y,&x);
            time[x][y]++;
            if(x>k)
                k=x;
        }
        
/**//*        for(i=2;i<k'i++)
        {
            for(j=0;j<11;j++)
            {
                if(j>0&&j<10)
                    time[i][j]+=max(time[i-1][j-1],time[i-1][j],time[i-1][j+1]);
                else if(j==0)
                    time[i][j]+=max(0,time[i-1][j],time[i-1][j+1]);
                else
                    time[i][j]+=max(0,time[i-1][j-1],time[i-1][j]);
            }
        }*/
        for(i=k-1;i>=0;i--)
        {
            for(j=0;j<11;j++)
            {
                if(j>0&&j<10)
                    time[i][j]+=max(time[i+1][j-1],time[i+1][j],time[i+1][j+1]);
                else if(j==0)
                    time[i][j]+=max(0,time[i+1][j],time[i+1][j+1]);
                else
                    time[i][j]+=max(0,time[i+1][j-1],time[i+1][j]);
            }
        }
        printf("%d\n",time[0][5]);
    }
    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:260 Accepted:119

Description

平面上有n条直线，且无三线共点，问这些直线能有多少种不同交点数。
比如,如果n=2,则可能的交点数量为0(平行)或者1(不平行)。

Input

输入数据包含多个测试实例,每个测试实例占一行,每行包含一个正整数n（n <= 20）,n表示直线的数量.

Output

每个测试实例对应一行输出，从小到大列出所有相交方案，其中每个数为可能的交点数,每行的整数之间用一个空格隔开。

Sample Input

2
3

Sample Output

0 1
0 2 3

Source

hdu1466

#include<stdio.h>
#include<string.h>
int main()
{ 
    int i,j,n,f[21][191];    //f[i][j]代表i条直线是否能产生j个交点，如果能f[i][j]=1，否则为0；
    
    memset(f,0,sizeof(f));

    for(i=0;i<21;i++)            //零个交点置零
        f[i][0]=1;

    for(n=2;n<21;n++)        //从两条直线开始求
       for(i=n-1;i>=1;i--)    //取出n-i条做变化
            for(j=0;j<191;j++)    //j变化
                if(f[n-i][j]==1)  //如果取出的n-i条能过产生j个交点，置f[n][j+(n-i)*i]=1，j+(n-i)*i为取出n-i条直线做变化情况下的交点数
                     f[n][j+(n-i)*i]=1;   

     while(scanf("%d",&n)!=EOF)
     {
         printf("0");

         for(j=1;j<=n*(n-1)/2;j++)    //统计
              if(f[n][j])
                printf(" %d",j);

        printf("\n");
     }

    return 0;
}

#include<string.h>
#include<stdio.h>
int main()
{
    int i,j,n;
    int f[21][191];

    memset(f,0,sizeof(f));

    for(i=1;i<21;i++)
        f[i][0]=1;

    for(j=1;j<191;j++)
        f[1][j]=0;

    for(n=2;n<21;n++)
    {
        for(i=1;i<n;i++)
        {
            for(j=0;j<191;j++)
            {
                if(f[i][j])
                {
                    f[n][j+i*(n-i)]=1;
                }
            }
        }
    }

    while(scanf("%d",&n)!=EOF)
    {
        printf("0");
        for(j=1;j<=n*(n-1)/2;j++)
        {
            if(f[n][j])
                printf(" %d",j);
        }
        printf("\n");
    }
    return 0;
}

Time Limit:1000MS  Memory Limit:65536K
Total Submit:398 Accepted:116

Description

2008年将到，王飞同学化了九牛二虎之力搞到了2张2008年奥运会足球赛决赛的门票。真是开心啊！他爸爸准备开车跟他一起去北京看球赛。不过门票费好贵啊，所以他爸爸说了，这个钱要在下学期的生活费里扣（好抠门），不过如果他能让从杭州去北京的油费最省（油价最近涨的好厉害啊），那么就不扣生活费了。
哈哈，这个就难不倒他了。在ACM里可不是白混的。
很快他算出了汽车从杭州到北京必须要加几次油，并查出了到北京要经过哪几个城市，每个城市有哪些加油站以及从某城市各加油站到另一城市各加油站的距离和路况算出了各加油站之间的耗油量。
下面是不是很easy?

Input

有多个测试案例。第一行先输入测试案例的数目T。
对于每个测试案例，第一行输入一个整数n表示将在中途n（0 < n < 40)个城市中加油，后面紧跟着是n个整数代表每个城市有几个加油站(每个城市加油站不超过10个）。
以下n+1行，每行由3个S_i,E_j,L一组组成的好几对整数，该行以0结束。表示从前一城市S_i第i个加油站（杭州的话就是家拉）出发到该城市第j个加油站消耗的油量为L升。

Output

对于每个测试，输出一行，内容为最小总耗油量。

Sample Input

1
2 2 3
1 1 3 1 2 1 0
1 1 2 1 2 7 2 1 8 2 2 9 2 3 4 0
1 1 5 2 1 6 3 1 6 0

Sample Output

10

         中文题，这种是最简单的动态规划问题了，从左往右折，每次求得各个加油站上最小耗油量！！！

         看代码的时候发现自己写的看不懂了。。。。悲剧！！！代码实现能力仍然是个话题啊！！

代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
    int num1[50];
    int num2[50];            //暂时存储中间结果
    int num3[50];            //结果数组
    int t,n,k,s,e,i,g,m,j;
    int l;
    scanf("%d",&t);            //组数
    for(m=0;m<t;m++)
    {
        for(j=0;j<15;j++)    //初始化num3
            num3[j]=0;

        scanf("%d",&n);        //城市个数

        for(i=0;i<n;i++)    //城市加油站个数没用。。。
            scanf("%d",&k);

        for(i=0;i<n+1;i++)    //n个城市要走n步
        {
            for(j=0;j<15;j++)    //初始化
                num2[j]=1000000;

            for(j=0;j<15;j++)    //初始化
                num1[j]=0;

            while(scanf("%d",&g)!=EOF&&g!=0)//参数判定
            {    
                s=g;
                scanf("%d %d",&e,&l);    
                
                if(num2[e]==1000000)        
                {
                    num1[e]=num3[s]+l;
                    num2[e]=num1[e];
                }

                else if(num3[s]+l<=num2[e])
                {
                    num1[e]=num3[s]+l;
                    num2[e]=num1[e];
                }            

            }

            for(j=0;j<50;j++)            //结果存储
                num3[j]=num2[j];

        }                

        printf("%d\n",num3[1]);            //输出结果
    }
    return 0;
}

Description

设有n个正整数，将他们连接成一排，组成一个最大的多位整数。例如:n=3时，3个整数13,312,343,连成的最大整数为:34331213

又如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613

Input

N
N个数

Output

连接成的多位数

Sample Input

3
13 312 343
0

Sample Output

34331213

      这个题目意思应该很好理解，至少会想有两种解题思路，

         一、把数组从大到小排列，这样是最大吗？  显然不是，例如：123 9，应该输出9123；

         二、把数组按字符串排序，这样是最大吗？这问题可能会然我们困惑，但是这也是错的，例如：120，12；应该输出12120；

这个题目不知道毒害了多少人（当然我指的是ACM新人），尤其是第二种思路去写代码的。。这只是一个悲剧的开始，你把一条弯路在直走！

其实这个题目应该是属于动态规划的最简单应用！子问题，给你两个数，让你连成最大数，一定非常简单，只能组成两个数，比较一下大小就成！这就是解题思路！

如果给你三个数呢？一直递推下去！悲剧啊，尽然怎么简单！

代码如下：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int main()
{
    int n,i,j,l,k;
    char s[1000][100];
    char s1[200],s2[200];
    while(scanf("%d",&n)!=EOF&&n!=0)
    {
        for(i=0;i<n;i++)
        {
            scanf("%s",s[i]);
            while(s[i][0]=='0')
            {
                if(strlen(s[i])==1)
                    break;
                strcpy(s[i],s[i]+1);
            }
        }
        for(i=0;i<n;i++)
        {            
            for(j=i+1;j<n;j++)
            {
                strcpy(s1,s[i]);
                strcat(s1,s[j]);
                strcpy(s2,s[j]);
                strcat(s2,s[i]);
                if(strcmp(s1,s2)<0)
                {
                    strcpy(s1,s[i]);
                    strcpy(s[i],s[j]);
                    strcpy(s[j],s1);
                }
            }
        }
        for(i=0;i<n;i++)
        {
            if(s[0][0]=='0')
            {
                printf("0");
                break;
            }
            else
            {
                printf("%s",s[i]);
            }
        }
        printf("\n");
    }
    return 0;
}

本来我也是第二种思路的，我看了感觉不像，因为以前写过了！

早上的几点收获：

1、<string>头文件和<string.h>头文件是不一样的！运行时的一个错误，弄了一个早上，最后发现这什么个问题！

2、运用容器，排序字符串

 
    vector<string> words;
    string str;
    while(scanf("%s",str)!=EOF)  
        words.push_back(str);

    sort(words.begin(),words.end(),greater<string>());


    for(vector<string>::size_type i=0;i<words.size();i++)
    {
            cout<<words[i]<<endl;
    }

不过会有很多警告，让我很苦恼！有谁知道呢？

警告如下：

--------------------Configuration: rongqi - Win32 Debug--------------------
Compiling
rongqi.cpp
c:\documents and settings\administrator\桌面\rongqi\rongqi.cpp(81) : warning C4786: 'std::reverse_iterator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > const *,std::basic_string<char,std::char_traits<char>,std::allocator<char
> >,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > const *,int>' : identifier was truncated to '255' characters in the debug information
c:\documents and settings\administrator\桌面\rongqi\rongqi.cpp(81) : warning C4786: 'std::reverse_iterator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > *,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,st
d::basic_string<char,std::char_traits<char>,std::allocator<char> > &,std::basic_string<char,std::char_traits<char>,std::allocator<char> > *,int>' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\vector(39) : warning C4786: 'std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >
 >::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >' : identifier was truncated to '255' characters in the debug information
c:\program files\microsoft visual studio\vc98\include\vector(60) : warning C4786: 'std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >
 >::~vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >' : identifier was truncated to '255' characters in the debug information

rongqi.obj - 0 error(s), 0 warning(s)

3、在程序头上写#pragma   warning  (disable:   4786)，可以注销4786以后警告！

Description

Famous Harry Potter,who seemd to be a normal and poor boy,is actually a wizard.Everything changed when he had his birthday of ten years old.A huge man called 'Hagrid' found Harry and lead him to a new world full of magic power.
If you've read this story,you probably know that Harry's parents had left him a lot of gold coins.Hagrid lead Harry to Gringotts(the bank hold up by Goblins). And they stepped into the room which stored the fortune from his father.Harry was astonishing ,coz there were piles of gold coins.
The way of packing these coins by Goblins was really special.Only one coin was on the top,and three coins consisted an triangle were on the next lower layer.The third layer has six coins which were also consisted an triangle,and so on.On the ith layer there was an triangle have i coins each edge(totally i*(i+1)/2).The whole heap seemed just like a pyramid.Goblin still knew the total num of the layers,so it's up you to help Harry to figure out the sum of all the coins.

Input

The input will consist of some cases,each case takes a line with only one integer N( 0 < N < 2^31).It ends with a single 0.

Output

For each test case, output a line contains the number of all the coins, the format like the sample out(2 decimal digits).

Sample Input

1
3
0

Sample Output

1.00E0
1.00E1

Hint

when N=1 ,There is 1 gold coins.
when N=3 ,There is 1+3+6=10 gold coins.

#include<stdio.h>
#include<math.h>
int  main()
{

    double test,sum;
    int i;

    scanf("%lf",&test);

    while(test!=0)
    {
        sum=((test*(test+1)*(2*test+1))/6+(test*(test+1))/2)/2;
        i=0;
        while(sum>=10)
        {
            i++;
            sum=sum/10;
        }
        printf("%.2fE%d\n",sum,i);
          scanf("%lf",&test);
    }
    return 0;
}

Description

The Double Seventh Festival, on the 7th day of the 7th lunar month, is a traditional festival full of romance. On that day, the God of the Love came to the digital kingdom, and annunciated to the people:

                             Do you want to know who is your fere? You can find him or her by this means:

                       Please add all the factors of your ID-Card-Number, and you can find this is your fere's

                       ID-Card-Number.

Input

The fist line is the number T (1 <= T <= 500000), indicated the number of the test cases.
The next T lines, each line has one integer N( 1 <= N <= 500000), meaning the ID-Card-Number.

Output

For each test case, you should output the fere's ID-Card-Number on a line.

Sample Input

3
2
10
20

Sample Output

1
8
22

      这个题目在我刚开始接触ACM的时候做出来最有成就的一个！求各因子之和！

代码如下：

#include<cstdio>
int main()
{
    int i,j,n,m,sum;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        sum=0;
        scanf("%d",&m);
        for(j=1;j*j<=m;j++)
        {
            if(m%j==0)
            {
                sum=sum+j+m/j;
            }
            if(j*j==m)
                sum-=j;
        }
        printf("%d\n",sum-m);
    }
    return 0;
}

Description

A triangle field is numbered with successive integers in the way shown on the picture below.



The traveller needs to go from the cell with number M to the cell with number N. The traveller is able to enter the cell through cell edges only, he can not travel from cell to cell through vertices. The number of edges the traveller passes makes the length of the traveller's route.



Write the program to determine the length of the shortest route connecting cells with numbers N and M.

Input

Input contains two integer numbers M and N in the range from 1 to 1000000000 separated with space(s).

Output

Output should contain the length of the shortest route.

Sample Input

6 12 

Sample Output

3

Source

Ural Collegiate Programming Contest 1998


      这是我大学里真正老师教的第一个题目，在我映像里老师很犀利，几句话就把题目意思和解题思路讲清楚了，老师追求的是效率，现在想起来是这样的！但是我当时并没有怎么听懂，回去也没好好研究过，直到后来老师给答案了才粗粗的看了一下，知道了解题思路，但是自己又没去写过，再后来有一天我发现了这个题目把它干掉了。。。

      题目大意：从右侧三角中任去两个数，求他们之间的最短路劲。例如取出3和7他们之间的最短路劲为3，6到12他们之间的最短路劲为3。。

      解题思路：
                           1、很明显我们可以求出给出的两个数的行号和列号；
                           2、思考怎么走才算是最短，在一个三角形中顶点上的数走到下边行中的奇数列的最短路径是相等的，例如：1走到2，4；1走到5，7，9；1走到11，13，15；偶数列也同样！根据这一点我们可以用较小的数构造一个最小上三角，然后一层层往下映射，求出最短路劲，直到到达较大数所在行！如果该数在映射三角中，直接输出，否者，从映射三角的最右端或者最左端往右走或者往左走！
      写代码的时候需要注意的几点：
                           1、M，N的数据比较大，在计算的时候可能会超出int范围，最好用__int64;
                           2、构造三角的时候，如果较小数在奇数列，可以直接向下映射，如果是偶数的话，可以向上翻，最后结果减1就行；
                           3、事实上我们可以根据已知行号和列号，直接求得在大数行上的映射三角的最短路劲；
       代码如下（老师给的）：

#include<stdio.h>
#include<math.h>
__int64 leve(__int64 x)   
{
    double y;
    __int64 k;
    if(x==1)
        return 1;
    else
    {
        y=sqrt(x);
        k=sqrt(x);
        if(y==k)
            return k;
        else
            return k+1;
    }
}
int main()
{
    __int64 n,m,temp,ln,lm,pm,pn,tm,mr,ml,tlm,len;
    while(scanf("%I64d %I64d",&m,&n)!=EOF)
    {
        if(m>n)
        {
            temp=n;
            n=m;
            m=temp;
        }
        //求的行号和列号
        lm=leve(m);
        ln=leve(n);
        pm=m-(lm-1)*(lm-1);
        pn=n-(ln-1)*(ln-1);
            
        if(lm==ln) //同行，直接输出
            printf("%I64d\n",pn-pm);
        else
        {
            tm=(pm%2)?m:(m-2*(lm-1));  //求的三角形顶点数，偶数的往上翻一下
            tlm=leve(tm);            
            ml=tm+(ln+tlm-2)*(ln-tlm); //求得映射三角在较大数所在行的最左侧数
            mr=tm+(ln+tlm)*(ln-tlm);   //求得映射三角在较大数所在行的最右侧数
            if(ml<=n&&n<=mr)           //若较大数在区间内，则求的结果
                len=(pn%2)?(2*(ln-tlm)):(2*(ln-tlm)-1);
            else                        //否则再向左走或者向右走
            {
                len=2*(ln-tlm);
                if(n<ml)
                    len+=(ml-n);
                if(n>mr)
                    len+=(n-mr);
            }
            if(pm%2==0)                  //偶数减回去！！！
                len--;
            printf("%I64d\n",len);
        }
    }
    return 0;
}