template <typename DataType>

class QueueClass

{

private:

    struct BodyNodeStruct

    {

        DataType Data;

        BodyNodeStruct *Pre,*Next;

    } *Front,*Rear;

public:

    QueueClass();  //构造函数。

    bool Empty();  //判断队列是否为空，若为空则返回true，否则返回false。

    int Push(DataType Data);  //将Data压入队尾，如果压入成功则返回0，否则返回1。

    int Pop(DataType &Data);  //弹出队头元素，保存在Data中，若队列不为空则返回0，否则返回1。

    int GetFront(DataType &Data);  //读取队头元素，保存在Data中，若队列不为空则返回0，否则返回1。

    int Size();  //返回队列中元素个数。

    void Clear();  //清空队列。

    ~QueueClass();  //析构函数。

} ;

template <typename DataType>

QueueClass<DataType>::QueueClass()

{

    Front=new BodyNodeStruct;

    Front->Pre=NULL;

    Front->Next=NULL;

    Rear=Front;

}

template <typename DataType>

bool QueueClass<DataType>::Empty()

{

    if (Front==Rear) return true;

    else return false;

}

template <typename DataType>

int QueueClass<DataType>::Push(DataType Data)

{

    BodyNodeStruct *Temp=new BodyNodeStruct;

    if (Temp!=NULL)

    {

        Temp->Pre=Rear;

        Temp->Next=NULL;

        Rear->Next=Temp;

        Rear->Data=Data;

        Rear=Temp;

        return 0;

    }

    else return 1;

}

template <typename DataType>

int QueueClass<DataType>::Pop(DataType &Data)

{

    if (!Empty())

    {

        Data=Front->Data;

        Front=Front->Next;

        delete Front->Pre;

        Front->Pre=NULL;

        return 0;

    }

    else return 1;

}

template <typename DataType>

int QueueClass<DataType>::GetFront(DataType &Data)

{

    if (!Empty())

    {

        Data=Front->Data;

        return 0;

    }

    else return 1;

}

template <typename DataType>

int QueueClass<DataType>::Size()

{

    BodyNodeStruct *Temp=Front;

    int Count=0;

    while (Temp!=Rear)

    {

        Count++;

        Temp=Temp->Next;

    }

    return Count;

}

template <typename DataType>

void QueueClass<DataType>::Clear()

{

    DataType Temp;

    while (!Empty()) Pop(Temp);

}

template <typename DataType>

QueueClass<DataType>::~QueueClass()

{

    Clear();

    delete Front;

template <typename DataType>

class StackClass

{

private:

    struct BodyNodeStruct

    {

        DataType Data;

        BodyNodeStruct *Pre,*Next;

    } Bottom,*Top;

public:

    StackClass();  //构造函数。

    bool Empty();  //判断栈是否为空，若为空则返回true，否则返回false。

    int Push(DataType Data);  //将Data压栈，如果压栈成功则返回0，否则返回1。

    int Pop(DataType &Data);  //弹出栈顶元素，保存在Data中，若栈不为空则返回0，否则返回1。

    int GetTop(DataType &Data);  //读取栈顶元素，保存在Data中，若栈不为空则返回0，否则返回1。

    int Size();  //返回栈中元素个数

    void Clear();  //清空栈

    ~StackClass();  //析构函数

} ;

template <typename DataType>

StackClass<DataType>::StackClass()

{

    Top=&Bottom;

    Top->Pre=NULL;

    Top->Next=NULL;

}

template <typename DataType>

bool StackClass<DataType>::Empty()

{

    if (Top==&Bottom) return true;

    else return false;

}

template <typename DataType>

int StackClass<DataType>::Push(DataType Data)

{

    BodyNodeStruct *Temp=new BodyNodeStruct;

    if (Temp!=NULL)

    {

        Temp->Pre=Top;

        Temp->Next=NULL;

        Top->Next=Temp;

        Top->Data=Data;

        Top=Temp;

        return 0;

    }

    else return 1;

}

template <typename DataType>

int StackClass<DataType>::Pop(DataType &Data)

{

    if (!Empty())

    {

        Top=Top->Pre;

        Data=Top->Data;

        delete Top->Next;

        Top->Next=NULL;

        return 0;

    }

    else return 1;

}

template <typename DataType>

int StackClass<DataType>::GetTop(DataType &Data)

{

    if (!Empty())

    {

        Data=Top->Pre->Data;

        return 0;

    }

    else return 1;

}

template <typename DataType>

int StackClass<DataType>::Size()

{

    BodyNodeStruct *Temp=&Bottom;

    int Count=0;

    while (Temp!=Top)

    {

        Count++;

        Temp=Temp->Next;

    }

    return Count;

}

template <typename DataType>

void StackClass<DataType>::Clear()

{

    DataType Temp;

    while (!Empty()) Pop(Temp);

}

template <typename DataType>

StackClass<DataType>::~StackClass()

{

    Clear();

}

    今天下午考试期末考试的第二科——《计算机基本技能训练》，说白了就是OFFICE及WINDOWS基本操作。这个对我来说应该是极其小儿科的事了。

    试卷发下来一看，两道题目：第一题是在WORD里面整张表格，第二题是一些基本的文件操作，时间一个小时。看完的第一个想法就是这个居然要一个小时，半个小时都多了点。第二个想法就是，做表格在WORD里面做，除非那个人不会EXCEL。很显然的问题，用EXCEL做表格要比直接在WORD里面做方便得多。先在EXCEL里面把表做好，直接选中“Ctrl+C”->“Ctrl+V”就搞定了，最多贴过来再改下格式。按照上面的思路，三下五除二，第一题搞定。然后是第二题，在E盘建个文件，设置属性为只读，复制五份，在资源管理器中直接拖到D盘。第二题更没难度嘛，很快就搞定，然后老师下来打成绩，毫无悬念的满分。这时看下时间，考试刚好过去20分钟。

   今天下午，正在写程序，顺便整理磁盘碎片(弄了一个下午，郁闷死)。然后耳机中响起了QQ那熟悉的“嘀嘀”声。习惯性的“Ctrl”+“Alt”+“Z”，弹出聊天窗口。一看，是很久没见的朋友，寒碜了几句，得知她手机丢了。我就说咋最近联系不上了-_-!。       

    回想高三暑假，我在一次乘车上车时手机被“摸”，由于发现及时以及采取一定措施给找了回来；而前段时间，我的自行车锁被撬，由于运气很好，没被撬开，也被我侥幸找了回来（具体情况见《今天幸运啊，车只是差点被偷》）。不过，我这朋友就没这么幸运了……为什么我的好运没带给我的朋友们呢？

    总的来说，出门在外还是小心一点好啊。最后，预祝大家新年快乐！o(∩_∩)o...

    本来准备昨天出发的，但是昨天雾太大，能见度暴低，考虑到骑行安全问题未能成行。于是推迟，正好集训队这周没集体安排，所以就推迟到今天了，呵呵。不过天气也不太理想，还是雾蒙蒙的。

    上午九点十多分，和同行的人（WY-一个爱好运动的MM）从学校出发。干完一些杂七杂八的诸如租自行车（我是自带，呵呵）及买东西的事（差不多九点四十左右)，向着绵阳市区前进。首先取道长虹大道，上剑南路西段，通过东方红大桥，到剑南路东段，然后上绵梓公路(108国道)。跟着上次去仙海的路线，一切进行的很顺利（中途在博物馆作短暂停留）。

绵阳博物馆，明年5.1开放

绵梓公路的一个很长的上坡上休息时拍的

    经过21公里、两个多小时的骑行我们终于到达仙海风景区大门。如果我一人21公里一个小时完全够了，不过由于WY体力问题加上租来的车性能方面的问题，在路上多次休息，导致花了平时两倍的时间（所以出去玩还是骑自己的车好啊，租来的始终不爽）。

仙海风景区大门

    进入仙海风景区（又爬了一坡。。），已经是12点一刻了，我们在一家小吃点一人吃了碗饺子后开始了环湖之旅。

雾中的仙海（是否有种仙境的感觉呢？）

环湖路上景点（古驿道）

狭窄（相对绵梓公路）的环湖路(弯道多的地方颇有“头文字D”的感觉)

我们铁驴(羡慕环湖路上那些骑好车的朋友啊)

再来两张雾中仙海

下午3点过，环湖结束回到中午吃饭的地方，稍作休息后于是开始往回走了。休息过程中又看到几辆好车啊。离开仙海的时候大概是三点半，同样经过两个小时的骑行，于五点半平安抵达学校。这样，我的第二次仙海行圆满结束了！

格雷码

Time Limit:1000MS  Memory Limit:65536K
Total Submit:13 Accepted:11

Description

　在数字系统中只能识别0和1，各种数据要转换为二进制代码才能进行处理，格雷码是一种无权码，采用绝对编码方式，典型格雷码是一种具有反射特性和循环特性的单步自补码，它的循环、单步特性消除了随机取数时出现重大误差的可能，它的反射、自补特性使得求反非常方便。格雷码属于可靠性编码，是一种错误最小化的编码方式，因为，自然二进制码可以直接由数/模转换器转换成模拟信号，但某些情况，例如从十进制的3转换成4时二进制码的每一位都要变，使数字电路产生很大的尖峰电流脉冲。而格雷码则没有这一缺点，它是一种数字排序系统，其中的所有相邻整数在它们的数字表示中只有一个数字不同。它在任意两个相邻的数之间转换时，只有一个数位发生变化。它大大地减少了由一个状态到下一个状态时逻辑的混淆。另外由于最大数与最小数之间也仅一个数不同，故通常又叫雷反射码或循环码。下表为几种自然二进制码与格雷码的对照表：


二进制格雷码与自然二进制码的互换
1、自然二进制码转换成二进制格雷码
　自然二进制码转换成二进制格雷码，其法则是保留自然二进制码的最高位作为格雷码的最高位，而次高位格雷码为二进制码的高位与次高位相异或，而格雷码其余各位与次高位的求法相类似。
2、二进制格雷码转换成自然二进制码
　　二进制格雷码转换成自然二进制码,其法则是保留格雷码的最高位作为自然二进制码的最高位，而次高位自然二进制码为高位自然二进制码与次高位格雷码相异或，而自然二进制码的其余各位与次高位自然二进制码的求法相类似。

Input

输入一个十进制整数M

Output

输出十进制整数M对应的格雷码

Sample Input

2
13

Sample Output

11
1011

Source

#include <iostream>
#include <string>

using namespace std;

template <typename DataType>
string DecToN(DataType x, int n)
{
 string Ans;
 int Count,i,j=0,a[64];

 Count=0;
 if (x==0)
 {
  Ans[0]='0';
  Ans[1]='\0';
 }
 else
 {
  while (x>0)
  {
   a[Count++]=x%n;
   x=x/n;
  }
  for (i=Count-1;i>=0;i--)
   if (a[i]<10) Ans.append(1,a[i]+'0');
   else Ans.append(1,a[i]+'A'-10);
 }
 return Ans;
}

string BinToGray(const string &Bin)
{
 string Ans;
 int i,Length;

 Ans.append(1,Bin[0]);
 Length=int(Bin.length());
 for (i=1;i<=Length-1;i++)
  if (Bin[i-1]!=Bin[i]) Ans.append(1,'1');
  else Ans.append(1,'0');
 return Ans;
}

int main()
{
 int Num;

 while (cin>>Num) cout<<BinToGray(DecToN(Num,2))<<endl;
 return 0;
}

寻找部分序列

Time Limit:1000MS  Memory Limit:65536K
Total Submit:139 Accepted:17

Description

若s为一个字符串，把其中(任何位置)的字符去掉，留下的内容为s的一个子序列，也叫部分序列。例如：s为"abcdefg", 去掉b,d,f,剩下"aceg"；去掉a,b,c,剩下"defg"；于是"aceg","defg"都是字符串s的部分序列。请编程判断一个字符串是不是另一个的部分序列。

Input

输入两行：(输入的字符串均不为空字符串，且长度都不大于255)
第一行为字符串s。
第二行为一个字符串p。
判断p是不是s的一个部分序列。

Output

如果p不是s的部分序列，输出No；如果是，则输出两行，第一行为Yes，第二行为字符串p中各个字符在s中的序号(从1开始)。

Sample Input

aabbccdd
abc

abcdefg
agh

Sample Output

Yes
1 3 5
(注意不能是1 3 5以外的，比如2 3 5， 1 4 6等，也即是最左边匹配的部分序列的序号,本句不输出，呵呵~~~)
No

Source

#include <iostream>
#include <string>

using namespace std;

int main()
{
 char Source[300],Str[300];
 int i,j,LenSource,LenStr,Pos[300];
 bool Find;

 gets(Source);
 gets(Str);
 LenStr=int(strlen(Str));
 LenSource=int(strlen(Source));
 Pos[0]=-1;
 for (i=0;i<=LenStr-1;i++)
 {
  Find=false;
  for (j=Pos[i]+1;j<=LenSource-1;j++)
   if (Source[j]==Str[i])
   {
    Pos[i+1]=j;
    Find=true;
    break;
   }
   if (!Find) break;
 }
 if (Find)
 {
  cout<<"Yes\n";
  for (i=1;i<=LenStr;i++) cout<<Pos[i]+1<<' ';
  cout<<'\n';
 }
 else cout<<"No"<<endl;
 return 0;
}

宴会

Time Limit:1000MS  Memory Limit:65536K
Total Submit:76 Accepted:24

Description

在一个宴会中一共有n位来宾，依照来宾的到达时间和离开时间登记。知道第i位来宾在Xi时刻到达，在Yi时刻离开。因此第i位来宾在宴会场的时间为[Xi，Yi)，编写一程序。读入Xi，Yi，1<= i<= n;找出同一时刻之内最多会有多少人同时在宴会场中。

Input

第一行为一个正整数n。表示来宾总数。
接下来n行。每行两个整数Xi，Yi,(Xi < Yi)。表示第i位来宾到达和离开的时间。

Output

在某一时刻宴会场的人数会达到最多。输出此时宴会场中的人数。

Sample Input

3
1 3
3 4
2 3

Sample Output

2

Source

#include <iostream>

using namespace std;

int main()
{
 int n,Begin[1000],End[1000],i,j,MaxCount=0,Count;

 cin>>n;
 for (i=0;i<=n-1;i++) cin>>Begin[i]>>End[i];
 for (i=0;i<=n-1;i++)
 {
  Count=0;
  for (j=0;j<=n-1;j++)
   if (Begin[j]<=Begin[i] && Begin[i]<End[j]) Count++;
  if (Count>MaxCount) MaxCount=Count;
 }
 cout<<MaxCount<<endl;
 return 0;
}

Sum

Time Limit:1000MS  Memory Limit:65536K
Total Submit:33 Accepted:19

Description

Your task is to find the sum of all integer numbers lying between 1 and N inclusive.

Input

An integer number that is not greater than 10000

Output

The sum according to the rule above.

Sample Input

-3

Sample Output

-5

Source

#include <iostream>

using namespace std;

int main()
{
 int n;

 cin>>n;
 if (n>0) cout<<(1+n)*n/2<<endl;
 else cout<<(-1+n)*(-n)/2+1<<endl;
 return 0;
}

做一名聪明的CS玩家

Time Limit:1000MS  Memory Limit:65536K
Total Submit:17 Accepted:8

Description

作为计算机学院的学生，CS应该是大家都很熟悉的一款游戏。那么如果你是一个真正的CS玩家，不如来试下这道题目吧。
当你在CSing的时候，什么事情最让你郁闷呢，估计就是当你与敌人刚要开战的时候，发现自己没有子弹了吧^_^。这个时候最聪明的选择就是赶快回到老家去买子弹继续战斗。那么怎样回到老家需要的时间最短呢？？

Input

输入的第一行有两个整数N,M分别表示的是地图的宽和长(1 =< M =< N <= 100)，接下来的N行分别输入CS地图的具体情况。‘@’表示的是你现在所在的位置,‘#’表示的你老家的位置，‘X’表示的是敌人可能出现的位置，虽然是可能出现的位置，但是没有子弹的你显然不愿意冒险走这个位置，即使要节省时间。 ‘*’表示的是你可以放心走过的安全位置。

Output

求出在保证安全的条件下从‘@’到老家‘#’所需要的最小时间并且输出，假设每走一步需要一个单位的时间，且你只能向上下左右四个方向走，并且不能走出CS地图的范围。如果通过安全的位置点无法到达老家，则输出“GAME OVER”

Sample Input

5 5
***XX
*@XXX
**XX#
***X*
*****

Sample Output

8

Hint

Archmager：看来henry是很爱玩cs了，这道题看似比较难，不过大家还是有能力解决的，提示一下，Archmager在解决时用到了类似处理迷宫问题的回朔法。

PS：我（游侠UFO）是用宽搜做的，所以代码很长，呵呵。

Source

#include <iostream>

using namespace std;

struct CoordinateType
{
 int X,Y;
} ;

struct QueueNode
{
 CoordinateType Data;
 struct QueueNode *Next;
} ;

struct QueueType
{
 struct QueueNode *Front,*Rear;
} ;

int InitQueue(struct QueueType *Queue)
{
 Queue->Front=(struct QueueNode *)malloc(sizeof(struct QueueNode));
 Queue->Rear=Queue->Front;
 if (Queue->Front==NULL) return 1;
 else
 {
  Queue->Front->Next=NULL;
  return 0;
 }
}

void DestroyQueue(struct QueueType *Queue)
{
 while (Queue->Front!=NULL)
 {
  Queue->Rear=Queue->Front->Next;
  free(Queue->Front);
  Queue->Front=Queue->Rear;
 }
}

int EnQueue(struct QueueType *Queue, CoordinateType x)
{
 struct QueueNode *Temp;

 Temp=(struct QueueNode *)malloc(sizeof(struct QueueNode));
 if (Temp==NULL) return 1;
 else
 {
  Temp->Data=x;
  Temp->Next=NULL;
  Queue->Rear->Next=Temp;
  Queue->Rear=Temp;
  return 0;
 }
}

int DeQueue(struct QueueType *Queue, CoordinateType *x)
{
 struct QueueNode *Temp;

 if (Queue->Front==Queue->Rear) return 1;
 else
 {
  Temp=Queue->Front->Next;
  *x=Temp->Data;
  Queue->Front->Next=Temp->Next;
  if (Queue->Rear==Temp) Queue->Rear=Queue->Front;
  free(Temp);
  return 0;
 }
}

int BFS(int Map[][102], int Width, int Height, CoordinateType Start)
{
 struct QueueType Queue;
 CoordinateType Temp;
 int i,j,Visited[102][102];

 for (i=0;i<=Height+1;i++)
  for (j=0;j<=Width+1;j++) Visited[i][j]=0;
 InitQueue(&Queue);
 EnQueue(&Queue,Start);
 Visited[Start.X][Start.Y]=1;
 while (Queue.Front!=Queue.Rear)
 {
  DeQueue(&Queue,&Temp);
  if (Map[Temp.X][Temp.Y]==2)
  {
   DestroyQueue(&Queue);
   return Visited[Temp.X][Temp.Y];
  }
  if (Map[Temp.X+1][Temp.Y]!=1 && Visited[Temp.X+1][Temp.Y]==0)
  {
   Visited[Temp.X+1][Temp.Y]=Visited[Temp.X][Temp.Y]+1;
   Temp.X++;
   EnQueue(&Queue,Temp);
   Temp.X--;
  }
  if (Map[Temp.X-1][Temp.Y]!=1 && Visited[Temp.X-1][Temp.Y]==0)
  {
   Visited[Temp.X-1][Temp.Y]=Visited[Temp.X][Temp.Y]+1;
   Temp.X--;
   EnQueue(&Queue,Temp);
   Temp.X++;
  }
  if (Map[Temp.X][Temp.Y+1]!=1 && Visited[Temp.X][Temp.Y+1]==0)
  {
   Visited[Temp.X][Temp.Y+1]=Visited[Temp.X][Temp.Y]+1;
   Temp.Y++;
   EnQueue(&Queue,Temp);
   Temp.Y--;
  }
  if (Map[Temp.X][Temp.Y-1]!=1 && Visited[Temp.X][Temp.Y-1]==0)
  {
   Visited[Temp.X][Temp.Y-1]=Visited[Temp.X][Temp.Y]+1;
   Temp.Y--;
   EnQueue(&Queue,Temp);
   Temp.Y++;
  }
 }
 DestroyQueue(&Queue);
 return 0;
}

int main()
{
 char Temp;
 CoordinateType Start;
 int Map[102][102],i,j,Width,Height,Ans;
 
 cin>>Height>>Width;
 for (i=0;i<=Width+1;i++)
 {
  Map[0][i]=1;
  Map[Height+1][i]=1;
 }
 for (i=0;i<=Height+1;i++)
 {
  Map[i][0]=1;
  Map[i][Width+1]=1;
 }
 for (i=1;i<=Height;i++)
  for (j=1;j<=Width;j++)
  {
   cin>>Temp;
   switch (Temp)
   {
   case '*':
    Map[i][j]=0;
    break;
   case 'X':
    Map[i][j]=1;
    break;
   case '@':
    Start.X=i;
    Start.Y=j;
    Map[i][j]=0;
    break;
   case '#':
    Map[i][j]=2;
   }
  }
 Ans=BFS(Map,Width,Height,Start);
 if (Ans>0) cout<<Ans-1<<endl;
 else cout<<"GAME OVER"<<endl;
 return 0;
}

字符大小写转化问题

Time Limit:1000MS  Memory Limit:65536K
Total Submit:17 Accepted:13

Description

字符串处理问题是程序设计中要求细心的一个环节，细心和良好的RP是你AC这道题目的关键^_^！
题目的意思很简单，对于我的每个输入的字符串（长度小于20个字符），对于其中的每一个字符，如果它是大写的英文字母，把它转化为小写输出，如果它是小写的字母，转化为大写，如果不是字母，则用’@’代替并输出即可。

Input

输入的第一行为要测试的字符串的数目N，接下来的2到N+1行输入的是字符串，对于每个输入。

Output

按照上述规则输出相应的内容,每个输出占一行。那样，你就会看到ACCEPT的字符串了^_^!

Sample Input

3
cDS
DDD
&aS

Sample Output

Cds
ddd
@As

Source

#include <iostream>
#include <string>

using namespace std;

int main()
{
 char Str[256];
 int n,i,j,Len;

 cin>>n;
 getchar();
 for (i=1;i<=n;i++)
 {
  gets(Str);
  Len=(int)strlen(Str);
  for (j=0;j<=Len-1;j++)
   if (65<=Str[j] && Str[j]<=90) printf("%c",Str[j]+32);
   else
    if (97<=Str[j] && Str[j]<=122) printf("%c",Str[j]-32);
    else cout<<'@';
  cout<<'\n';
 }
 return 0;
}

多级排序问题

Time Limit:1000MS  Memory Limit:65536K
Total Submit:23 Accepted:14

Description

经过了一个前一段时间对数据结构中排序一章的学习，相信大家对排序也有了较深的感情。
当然，这就是一个简单的排序问题，try to do it ^_^！在众多的排序算法中，你会如何选择呢？
假设现在需要你实现一个小学生成绩管理系统，要求把成绩好的同学放到前面的。我们首先是按个人的总成绩进行排名，如果某两个人的总分相同，则按他们的语文成绩进行排名，如果总成绩和语文成绩都相同时，对于这两个人，我们是按照他们的数学成绩进行排名的，他们每个人都有三门课程，语文，数学和英语！

Input

现在首先输入一行为总共输入学生的数目N，然后在2到N+1行中分别输入学生姓名和对应学生的总分，语文和数学成绩（每个数据之间有一个空格）

Output

输出最后排序顺序的名字序列。每个名字占一行。我们保证不会存在两个人总成绩和各门的成绩均分别相同的情况。

Sample Input

3
Henry 225 100 98
Marry 210 95 100
Jhon 210 98 85

Sample Output

Henry 
Jhon 
Marry

Source

#include <iostream>
#include <string>

using namespace std;

class StudentClass
{
private:
 string Name;
 int Total,Chinese,Math;

public:
 void Input()
 {
  cin>>Name>>Total>>Chinese>>Math;
 }

 void Output()
 {
  cout<<Name<<'\n';
 }

 friend void SortName(StudentClass Student[], int Count);
 friend void SortMath(StudentClass Student[], int Count);
 friend void SortChinese(StudentClass Student[], int Count);
 friend void SortTotal(StudentClass Student[], int Count);
} ;

void SortName(StudentClass Student[], int Count)
{
 int i,j;
 StudentClass k;

 for (i=0;i<=Count-2;i++)
  for (j=Count-1;j>=i+1;j--)
   if (Student[j-1].Name>Student[j].Name)
   {
    k=Student[j-1];
    Student[j-1]=Student[j];
    Student[j]=k;
   }
}

void SortMath(StudentClass Student[], int Count)
{
 int i,j;
 StudentClass k;

 for (i=0;i<=Count-2;i++)
  for (j=Count-1;j>=i+1;j--)
   if (Student[j-1].Math<Student[j].Math)
   {
    k=Student[j-1];
    Student[j-1]=Student[j];
    Student[j]=k;
   }
}

void SortChinese(StudentClass Student[], int Count)
{
 int i,j;
 StudentClass k;

 for (i=0;i<=Count-2;i++)
  for (j=Count-1;j>=i+1;j--)
   if (Student[j-1].Chinese<Student[j].Chinese)
   {
    k=Student[j-1];
    Student[j-1]=Student[j];
    Student[j]=k;
   }
}

void SortTotal(StudentClass Student[], int Count)
{
 int i,j;
 StudentClass k;

 for (i=0;i<=Count-2;i++)
  for (j=Count-1;j>=i+1;j--)
   if (Student[j-1].Total<Student[j].Total)
   {
    k=Student[j-1];
    Student[j-1]=Student[j];
    Student[j]=k;
   }
}

int main()
{
 StudentClass Student[256];
 int i,Count;
 
 cin>>Count;
 for (i=0;i<=Count-1;i++) Student[i].Input();
 SortName(Student,Count);
 SortMath(Student,Count);
 SortChinese(Student,Count);
 SortTotal(Student,Count);
 for (i=0;i<=Count-1;i++) Student[i].Output();
 return 0;
}

拉丁方阵

Time Limit:1000MS  Memory Limit:65536K
Total Submit:24 Accepted:18

Description

还是Archmager的题了，这次就没有那么多废话了，请大家构造 N*N 阶的拉丁方阵(2<=N<=9)，使方阵中的每一行和每一列中数字1到N只出现一次。如N=4时：
1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3
这可是送分的题哦，抓紧把！！！

Input

输入n;

Output

输出对应的拉丁矩阵，每两个数字之间间隔一个空格，每输出n个数后换行。

Sample Input

4

Sample Output

1 2 3 4
2 3 4 1
3 4 1 2
4 1 2 3 

Source

#include <iostream>

using namespace std;

int main()
{
 int n,i,j,Temp;

 cin>>n;
 for (i=1;i<=n;i++)
 {
  Temp=i;
  for (j=1;j<=n;j++)
  {
   cout<<Temp<<' ';
   Temp++;
   if (Temp>n) Temp=Temp-n;
  }
  cout<<'\n';
 }
 return 0;
}

【简单图形】三角形识别

Time Limit:1000MS  Memory Limit:65536K
Total Submit:32 Accepted:17

Description

这是一个很简单的问题,就是给有一个打印好的三角形.但我们需要知道它有多少行和列.
其中三角形的图形如下:

Input

只有一组测试数据，如上面图形类似的一个三角形。见sample input

Output

输出只有一行，为其行数row(row>=2)和列数col(col>= 2*row)，两个数字间隔一个空格；见sample output

Sample Input

0000000000000000000000000
0000000000000000000000000
0000000000001000000000000
0000000000011100000000000
0000000000111110000000000
0000000001111111000000000
0000000011111111100000000
0000000111111111110000000
0000001111111111111000000
0000011111111111111100000
0000111111111111111110000
0001111111111111111111000
0000000000000000000000000
0000000000000000000000000

00000000000000000000
00000000000000000000
0000000001000000000
0000000011100000000
0000000111110000000
0000001111111000000
0000011111111100000
0000111111111110000
0001111111111111000
0011111111111111100
00000000000000000000
00000000000000000000

Sample Output

10 19
8 15

Source

#include <iostream>
#include <string>

using namespace std;

int main()
{
 string Row;
 int ColCount=0,RowCount=0,Len,Count,i;

 while (cin>>Row)
 {
  Count=0;
  Len=(int)Row.length();
  for (i=0;i<=Len;i++)
   if (Row[i]=='1') Count++;
  if (Count>0) RowCount++;
  if (Count>ColCount) ColCount=Count;
 }
 cout<<RowCount<<' '<<ColCount;
 return 0;
}

【简单2进制】Lowest Bit Lowest Bit

Time Limit:1000MS  Memory Limit:65536K
Total Submit:43 Accepted:31

Description

Given an positive integer A (1 <= A <= 1000), output the lowest bit of A.

For example, given A = 26, we can write A in binary form as 11010, so the lowest bit of A is 10, so the output should be 2.

Another example goes like this: given A = 88, we can write A in binary form as 1011000, so the lowest bit of A is 1000, so the output should be 8.

Input

Each line of input contains only an integer A (1 <= A <= 1000). A line containing "0" indicates the end of input, and this line is not a part of the input data

Output

For each A in the input, output a line containing only its lowest bit

Sample Input

26
88
0

Sample Output

2
8

Source

#include <iostream>
#include <string>

using namespace std;

template <typename DataType>
string DecToN(DataType x, int n)
{
 string Ans;
 int Count,i,j=0,a[64];

 Count=0;
 if (x==0)
 {
  Ans[0]='0';
  Ans[1]='\0';
 }
 else
 {
  while (x>0)
  {
   a[Count++]=x%n;
   x=x/n;
  }
  for (i=Count-1;i>=0;i--)
   if (a[i]<10) Ans.append(1,a[i]+'0');
   else Ans.append(1,a[i]+'A'-10);
 }
 return Ans;
}

long NToDec(string x, int n)
{
 int a[64],y,Count,i,j;
 long Ans;

 Ans=0;
 for (i=0;i<=(int)x.length()-1;i++)
  if ('0'<=x[i] && x[i]<='9') a[i]=x[i]-'0';
  else a[i]=toupper(x[i])-'A'+10;
 Count=0;
 for (i=(int)x.length()-1;i>=0;i--)
 {
  y=1;
  for (j=1;j<=Count;j++) y=y*n;
  Count++;
  Ans=Ans+y*a[i];
 }
 return Ans;
}

int main()
{
 string Str;
 int Num,i,Pos,Len;

 cin>>Num;
 while (Num>0)
 {
  Str=DecToN(Num,2);
  Len=1;
  Pos=(int)Str.length();
  for (i=(int)Str.length()-1;i>=0;i--)
   if (Str[i]=='1')
   {
    Pos=i;
    break;
   }
   else Len++;
  Str.assign(Str,Pos,Len);
  cout<<NToDec(Str,2)<<'\n';
  cin>>Num;
 }
 return 0;
}

【递归】Special array

Time Limit:1000MS  Memory Limit:65536K
Total Submit:67 Accepted:20

Description

输入n和m(20>=m>=n>0)求出所有满足以下方程的正整数数列 i1,i2,...,in，使i1+i2+...+in=m，且i1>=i2...>=in。例如：当n=4, m=8时，将得到如下5 个数列：
5 1 1 1
4 2 1 1
3 3 1 1
3 2 2 1
2 2 2 2

Input

输入只有一行，包含每个数列的元素个数n和数列元素的和m。

Output

按照字典逆序输出所有的数列，每个数列输出一行，每个数列元素用一个空格分开。

Sample Input

4 8

Sample Output

5 1 1 1
4 2 1 1
3 3 1 1
3 2 2 1
2 2 2 2

Source

#include <iostream>

using namespace std;

void Split(int Array[], int n, int r, int Len)
{
 int i;

 if(n==0)
 {
  for(i=0;i<=r-1;i++) printf("%d ",Array[i]);
  printf("\n");
 }
 else
  for(i=n-Len+1;i>=1;i--)
   if(r==0||i<=Array[r-1])
   {
    Array[r]=i;
    if (Len>0) Split(Array,n-i,r+1,Len-1);
   }
}

int main()
{
 int Len,Num,Array[20]={0};

 scanf("%d%d",&Len,&Num);
 Split(Array,Num,0,Len);
 return 0;
}

【简单】分解因式

Time Limit:1000MS  Memory Limit:65536K
Total Submit:54 Accepted:20

Description

一个自然数N的正因子个数记为F(N)，例如18的所有正因子为1、2、3、6、9、18，所以F(18)=6。现在给出K，求所有满足F(N)=K的N中最小的数。

Input

从文件读入数据，第一行为K，其中0 < K <= 80。

Output

输出到文件第一行，如果存在不大于20000的解，则输出这个N，否则输出“NO SOLUTION”。

Sample Input

9

Sample Output

36

Hint

输入：17
输出：NO SOLUTION

Source

#include <stdio.h>

main()
{
 int k,Ans[81]={-1,0,2,4,6,16,12,64,24,36,48,1024,60,4096,192,144,120,-1,180,-1,240,576,3072,-1,360,1296,12288,900,960,-1,720,-1,840,9216,-1,5184,1260,-1,-1,-1,1680,-1,2880,-1,15360,3600,-1,-1,2520,-1,6480,-1,-1,-1,6300,-1,6720,-1,-1,-1,5040,-1,-1,14400,7560,-1,-1,-1,-1,-1,-1,-1,10080,-1,-1,-1,-1,-1,-1,-1,15120};

 scanf("%d",&k);
 if (Ans[k]>=0) printf("%d",Ans[k]);
 else printf("NO SOLUTION");
}

求最大公约数

#include <stdio.h>

void GCDandLCM(int m, int n, int *GCD, int *LCM)
{
        int Temp,TempM,TempN;
        
        TempM=m;
        TempN=n;
        Temp=TempM%TempN;
        while (Temp!=0)
        {
                TempM=TempN;
                TempN=Temp;
                Temp=TempM%TempN;
        }
        *GCD=TempN;
        *LCM=m*n/(*GCD);
}

main()
{
        int m,n,GCD,LCM;

        scanf("%d %d",&m,&n);
        GCDandLCM(m,n,&GCD,&LCM);
        printf("%d",GCD);
}