2012北邮网研院上机题

A 打印字符串
时间限制 1000 ms 内存限制 65536 KB
题目描述
老师有一个问题想考考mabo，但是mabo不会，所以想请你来帮帮忙。

问题如下：

给一串字符串，统计其中某个字符的个数。

输入格式
首先输入一个整数T，表示一共有T组数据 0＜T<=10。

接下来每行一个字母x(x为’a’-‘z’或者‘A’-‘Z’)。

然后下面一行输入一个字符串s(0＜s的长度<1000)。

输出格式
统计这个字母在这个字符串中出现的次数

输入样例
2
a
absd
b
bbssb
输出样例
1
3
　　思路：略。

#include<stdio.h>

int main() {
    int T;
    scanf("%d",&T);
    while(T--) {
        char ch[2];
        char s[1000];
        scanf("%s",ch);
        scanf("%s",s);
        int i = 0,num = 0;
        while(s[i]) {
            if(s[i] == ch[0]) {
                num++;
            }
            i++;
        }
        printf("%d\n",num);
    }
}

Ｂ　二叉树的层数
时间限制 1000 ms 内存限制 65536 KB
题目描述
老师有一个问题想考考mabo，但是mabo不会，所以想请你来帮帮忙。

问题如下：

给一个二叉树

请把这个棵二叉树按层来打印。如果为相同层，需要从左到右打印。一个节点是先添加左节点后添加右节点，即添加顺序与输入顺序一致。

输入格式
首先输入一个整数T，表示一共有T组数据 0＜T<=10

再输入两个整数N,M(0<=N,M<=100)

表示下面有N行，这个树有M个节点(1号节点是这棵树的根节点)

每一行两个整数a,b(1<=a,b<=M)

表示节点a的父亲是节点b

输出格式
对于每组

先输出一行 “Qi:”表示第i个问题

然后接下来输出每个问题二叉树每层的节点，在同一层的节点用空格分开，同一层输出在一行（每一行末尾没有空格），不同的层输出在不同行（入下面Sample Ouput所示）

输入样例
2
4 5
2 1
3 1
4 2
5 4
1 2
2 1
输出样例
Q1:
1
2 3
4
5
Q2:
1
2
　　思路：队列实现二叉树的层次遍历

#include<stdio.h>
#include<queue>

using namespace std;

struct Node {
    int ID,depth;
    Node *lchild;
    Node *rchild;
}tree[101];

int main() {
    int T;
    scanf("%d",&T);
    int t = T;
    while(T--) {
        int N,M;
        scanf("%d%d",&N,&M);
        for(int i = 1;i <= M;i++) {
            tree[i].ID = i;
            tree[i].depth = 0;
            tree[i].lchild = NULL;
            tree[i].rchild = NULL;
        } 
        tree[1].depth = 1;
        while(N--) {
            int a,b;
            scanf("%d%d",&a,&b);
            if(!tree[b].lchild) {
                tree[b].lchild = &tree[a];
            } else {
                tree[b].rchild = &tree[a];
            }
            tree[a].depth = tree[b].depth + 1;   
        }
        printf("Q%d:",t - T);
        queue<Node *> Q;
        Q.push(&tree[1]);
        int level = 0;
        Node *temp;
        bool flag = false;
        while(!Q.empty()) {
            temp = Q.front();
            Q.pop();
            if(temp->depth == level) {
                printf(" %d",temp->ID);   
            } else {
                level++;
                printf("\n%d",temp->ID);  
            }
            if(temp->lchild) {
                Q.push(temp->lchild);
            }
            if(temp->rchild) {
                Q.push(temp->rchild);
            }
        }
        printf("\n");
    }
}

C IP地址
时间限制 1000 ms 内存限制 65536 KB
题目描述
我们都学过计算机网络，了解IPV4地址的点分十进制表示法。

你的任务很简单：判断一个字符串是否是一个合法的点分十进制表示的IPV4地址。

最低的IP地址是0.0.0.0，最高的IP地址是255.255.255.255。

PS ：方便起见，认为形似00.00.00.00的IP地址也是合法的。

输入格式
第一行是一个整数T，代表输入还剩下T行

以下的T行，每行都是一个字符串（不含空白字符）。字符串的长度保证不超过15，不小于1.

输出格式
对于每个字符串，输出一行。

如果它是一个合法的IPV4地址，输出Yes。

否则，输出No。

输入样例
3
59.64.130.18
f.a.t.e
1.23.45.678
输出样例
Yes
No
No
　　思路：参考了网上的代码，sscanf用的好，能大大简化问题。

#include<stdio.h>

int main() {
    int T;
    scanf("%d",&T);
    char s[16];
    while(T--) {
        scanf("%s",s);
        int a,b,c,d,e;
        if(sscanf(s,"%d.%d.%d.%d%c",&a,&b,&c,&d,&e) == 4) {
            if(a >= 0 && a <= 255 && b >= 0 && b <= 255 && c >= 0 && c <= 255 
            && d >= 0 && d <= 255) {    
                printf("Yes\n");
            } else {
                printf("No\n");
            }
        } else {
            printf("No\n");
        }
    }
}

D. 最远距离
时间限制 1000 ms 内存限制 65536 KB
题目描述
正义的伙伴褋祈和葬仪社的机器人Fuyuneru正在被邪恶的GHQ部队追杀。眼看着快要逃不掉了，祈就把重要的东西塞到了机器人体内，让它先跑，自己吸引火力。

假设Fuyuneru带上东西开始逃跑时所处的点为原点，朝向为正北。操纵FuyuNeru的指令有如下四种：

right X: X是1-359之间的整数，Fuyuneru的前进方向顺时针转X度。

left X: X是1-359之间的整数，Fuyuneru的前进方向逆时针转X度。

forward X: X是整数(0<=X<=1000)，Fuyuneru向当前朝向前进X米。

backward X: X是整数(0<=X<=1000)，Fuyuneru向当前朝向后退X米。

现在祈向Fuyuneru体内输入了N(1<=N<=50)个这样的指令。可是由于此前Fuyuneru被GHQ部队击中，它出了一点小问题：这N个指令执行的顺序是不确定的。

问：Fuyuneru最远可能逃出多远？

即，Fuyuneru在执行完N条指令之后，距离原点最远的可能距离是多少？

输入格式
第一行是一个整数T，代表测试数据有T组。

每组测试数据中，第一行是一个整数N，代表指令有N条；

随后紧跟N行，每一行代表一个指令（格式保证是上述四种中的一种，数据保证合法）

输出格式
对于每组数据，输出一行：最远的可能逃亡距离，精确到小数点后3位。

输入样例
3
3
forward 100
backward 100
left 90
4
left 45
forward 100
right 45
forward 100
6
left 10
forward 40
right 30
left 10
backward 4
forward 4
输出样例
141.421
200.000
40.585
　　思路：应该是用动态规划来解的，目前没时间，以后再写吧。。。