2013华为第五届编程大赛 成都初赛题目和解答

昨天看到今年的报名，把隔壁zy同学的去年题目拿过来做了一下，http://blog.csdn.net/zy416548283/article/details/23712151

前两个解法差不多，第三个用dfs，bfs方法可参考zy同学

1、路灯统计：

    题目描述

某省会城市街道纵横交错，为了监控路灯的运行状况，每条街道使用一个数字字符串标识该街道上所有路灯的运行状况。

假设路灯只有如下3种状态（分别用数字0, 1, 2标识，一盏路灯只对应其中一种状态）：

0 标识路灯熄灭；

1 标识路灯开启；

2 标识路灯故障；

请根据输入的字符串，找出该街道上连续的处于相同状态的路灯的最大个数。若两种状态的路灯数量相同，则返回最先出现的路灯状态。

   输入：

街道上连续的路灯组成的状态字符串。字符串中只包含数字，每个路灯的状态为0，1，2中的一种状态。如“1101”代表4盏路灯，第3盏路灯为熄灭状态，其它3盏为开启状态。

   输出：

连续为相同状态的路灯的最大数量，上述路灯的状态；

要求：先输出数量，再输出状态，两个整数间采用一个空格间隔。如输出：53 2

样例输入

112200111

样例输出

3 1

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

#define MAX_LINE 1024

int main()
{
char str[MAX_LINE], result;
int i, max_len = -1, cur_len = 1;

fgets(str, MAX_LINE, stdin);

for (i = 0; str[i] != '\n'; i++)
{
if (str[i] == str[i+1])
cur_len++;
else {
if (cur_len > max_len) {
max_len = cur_len;
cur_len = 1;
result = str[i];
}
else if (cur_len == max_len)
cur_len = 1;
}
}
printf("%d %c", max_len, result);

return 0;
}

2. 求复数的平均值

    题目描述  由实部和虚部组成，形如(a,bi)这样的数，称为复数。

    通信系统中，通常用32bit数来表示复数（高16bit表示实部，低16bit表示虚部），如整数524295（16进制为0x00080007）

所代表的复数，实部为0x0008，虚部为0x0007。  有别于实数运算，复数加、减、乘、除运算定义如下： 

复数加公式：(a,bi) + (c,di) = (a + c),(b + d)i 复数减公式：(a,bi) + (c,di) = (a - c),(b - d)i  

复数乘公式：(a,bi) * (c,di) = (ac - bd),(ad + bc)i 复数除公式：(a,bi) / N = (a/N),(b/N)i  

题目要求，输入N个复数，计算这个N个复数的平均值，

复数Avg = (复数1*复数2 + 复数3*复数4 + … + 复数N-1*复数N) / N。 

 复数加、复数减、复数乘、复数除的结果仍然为复数，实部和虚部均为16bit有符号数，

计算过程中，当结果大于32767（0x7fff）时，输出32767；当计算结果小于-32768（0x8000）时，输出-32768。 

 输入  输入共计两行   有别于实数运算，复数加减乘除运算定义如下第一行包含1个整数，表示输入复数个数N（N为偶数，N不大于1000）   第一行包含1个整数，

表示输入复数个数N（N为偶数，N不大于1000）  输出  经计算得到的复数的平均值。 

 

样例输入  4  262149,393223,524297,655371 

样例输出  -458693

#include<stdio.h>

#define MAX_NUM 1024

typedef struct complx{
int real;
int img;
}complx;
complx comp_set[MAX_NUM];

int crossover(int m)
{
if (m > 32767)
return 32767;
else if (m < -32768)
return -32768;
else
return m;
}

complx convert(int m)
{
complx c_tmp;
c_tmp.real = (m & 0xffff0000) >> 16;
c_tmp.img =  m & 0x0000ffff;
return c_tmp;
}

int re_convert(complx a)
{
return ((a.real << 16) + a.img);
}

complx times(complx a, complx b)
{
complx tmp;
tmp.real = crossover(crossover(a.real*b.real) - crossover(a.img*b.img));
tmp.img = crossover(crossover(a.real*b.img) + crossover(a.img*b.real));
return tmp;
}

complx plus(complx a, complx b)
{
complx tmp;
tmp.real = crossover(a.real + b.real);
tmp.img = crossover(a.img + b.img);
return tmp;
}

complx div(complx a, int n)
{
complx tmp;
tmp.real = a.real / n;
tmp.img = a.img / n;
return tmp;
}

int main()
{
int n, i, i_tmp;
complx sum = {0,0}, com_tmp;

scanf("%d", &n);

if (n % 2 != 0)
return 0;

for(i = 0; i < n; i++)
{
scanf("%d", &i_tmp);
comp_set[i] = convert(i_tmp);
}

for (i = 0; i < n; i += 2)
{
com_tmp = times(comp_set[i], comp_set[i+1]);
sum = plus(sum, com_tmp);
}

sum = div(sum, n);
printf("%d", re_convert(sum));
return 0;
}

3. 连连看游戏：

题目描述

连连看，你不会？那就out了！

给定一个连连看棋盘，棋盘上每个点有各种图案（用非0数字表示），输入棋盘上的任意两个坐标，判断这两个坐标对应的图案是否可以消除，消除的条件是图案相同且图案间连线的转角数不得超过2 。

1    3    3    4

0    6    0    0

4    0    2    1

6    0    4    2

图中，(0,1)和(0,2)中的3没有转角可以消去，(1,1)和(3,0)中的6有一个转角可以消去，(2,0)和(3,2)中的4有两个转角可以消去，而(0,0)和(2，3)中的1不能消去。

输入

输入为连续的整数，第1个数为棋盘行数m，第2个数为棋盘列数n，然后依次是m*n个棋盘数据（先行后列），最后，是两个坐标对应的行号和列号，m行n列的棋盘，共计输入m*n+6个数。

输出

如果图案不能消除，输出0；如果图案可以消除，输出消除路线上图案个数（包含输入的两个图案，不考虑有多条可消除路径的情况）。

样例输入

4 4 1 3 3 4 0 6 0 0 4 0 2 1 6 0 4 2 2 0 3 2

样例输出

4

//2013 HuaWei 3 simon xia 2014.4.17
#include<stdio.h>
#include<string.h>

#define MAX_ROW 50
#define MAX_COL 50

#define UP 1
#define RIGHT 2
#define DOWN 3
#define LEFT 4

typedef struct {
int row;
int col;
int direction[5];
}position;

typedef struct {
int pathlen;
int direction;
int dir_cha_cnt;
}pathinfo;

position stack_pos[16];
pathinfo stack_info[16];

int top_pos = -1;
int top_info = -1;
int matrix[MAX_ROW][MAX_COL];

void push_pos(position pos)
{
stack_pos[++top_pos] = pos;
}

void push_info(pathinfo info)
{
stack_info[++top_info] = info;
}

position pop_pos()
{
return stack_pos[top_pos--];
}

pathinfo pop_info()
{
return stack_info[top_info--];
}

int set_dir(int row, int col, int dir[], int m, int n, int cur_dir)
{
if (!matrix[row][col+1] && col+1 < n && cur_dir != LEFT) dir[RIGHT] = 1;
if (!matrix[row][col-1] && col-1 >= 0 && cur_dir != RIGHT) dir[LEFT] = 1;
if (!matrix[row-1][col] && row-1 >= 0 && cur_dir != DOWN) dir[UP] = 1;
if (!matrix[row+1][col] && row+1 < m && cur_dir != UP) dir[DOWN] = 1;
}

int count_path(int dir[])
{
int count = 0, i = 0;
for (; i < 5; i++)
count += dir[i];
return count;
}

int get_end(int i, int j, int end, int start_row, int start_col)
{
if ( (matrix[i][j+1] == end && i != start_row && j+1 != start_col)
|| (matrix[i][j-1] == end && i != start_row && j-1 != start_col)
|| (matrix[i-1][j] == end && i-1 != start_row && j != start_col)
|| (matrix[i+1][j] == end && i+1 != start_row && j != start_col))
return 1;
else
return 0;
}

int main()
{
freopen("input_h3", "r", stdin);
int m, n, i, j, k, pathlen = 1, pathnum;
int dir_change = 0, cur_dir = 0;
int dir_tmp[5] = {0};
position a, b, pos_tmp;
pathinfo info_tmp;

memset(matrix, 0, sizeof(matrix));
scanf("%d%d", &m, &n);
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
scanf("%d", &matrix[i][j]);
scanf("%d%d%d%d", &a.row, &a.col, &b.row, &b.col);

if (matrix[b.row][b.col] != matrix[a.row][a.col] || matrix[a.row][a.col] == 0 || matrix[b.row][b.col] == 0)
return 0;

for (i = a.row, j = a.col; (!get_end(i,j,matrix[b.row][b.col],a.row,a.col)); )
{
if (!count_path(dir_tmp))
set_dir(i, j, dir_tmp, m, n, cur_dir);
pathnum = count_path(dir_tmp);

if (!pathnum) {
if (top_pos == -1) {
printf("%d", 0);
return 0;
}
else {
pos_tmp = pop_pos();
i = pos_tmp.row;
j = pos_tmp.col;
memcpy(dir_tmp, pos_tmp.direction, 5*sizeof(int));

info_tmp = pop_info();
pathlen = info_tmp.pathlen;
cur_dir = info_tmp.direction;
dir_change = info_tmp.dir_cha_cnt;
}
}else if (pathnum == 1) {
for (k = 1; k < 5; k++)
if (dir_tmp[k]) break;
if (k != cur_dir)
dir_change++;
switch (k) {
case 1:{i--; break;}
case 2:{j++; break;}
case 3:{i++; break;}
case 4:{j--; break;}
}
pathlen++;
memset(dir_tmp, 0, sizeof(dir_tmp));
}
else
{
pos_tmp.row = i;
pos_tmp.col = j;
for (k = 1; k < 5; k++)
if (dir_tmp[k]) break;
dir_tmp[k] = 0;
memcpy(pos_tmp.direction, dir_tmp, 5*sizeof(int));
push_pos(pos_tmp);

info_tmp.pathlen = pathlen;
info_tmp.direction = cur_dir;
info_tmp.dir_cha_cnt = dir_change;
push_info(info_tmp);

if (k != cur_dir)
dir_change++;
cur_dir = k;
switch (k) {
case 1:{i--; break;}
case 2:{j++; break;}
case 3:{i++; break;}
case 4:{j--; break;}
}
pathlen++;
memset(dir_tmp, 0, sizeof(dir_tmp));
}

if (dir_change > 3 && top_pos != -1) //第一次初始化0
{
pos_tmp = pop_pos();
i = pos_tmp.row;
j = pos_tmp.col;

info_tmp = pop_info();
pathlen = info_tmp.pathlen;
cur_dir = info_tmp.direction;
dir_change = info_tmp.dir_cha_cnt;
}
}
printf("%d\n", ++pathlen);
return 0;
}

边写边改，代码有点乱，跑出结果就没有改了。。。上述代码中2个栈可以合为一个