物联网校企联盟程序设计每周练习赛（二）

题目A: 原站地址http://acm.fzu.edu.cn/problem.php?pid=1056

该题以大家熟悉的扫雷游戏为背景，让我们完成已知地雷出现位置的情况下，得到各个方块中的数据。

结合实例我们不难看出程序的意思让我们输出除地雷以外所有其他方格周围的八个方格上的地雷总数。

实现方法：统计每个‘.’处周围的八个位置的地雷总数，然后输出即可。

PS：多实例输入，结束条件为n和m都为0；

需要注意的是每个实例后有一个空格。

 

参考代码：

#include<stdio.h>
#include<string.h>
#define N 105
char map[N][N];
int ans[N][N];
int n,m;
int dir[8][2]={-1,-1, 0,-1, 1,-1, 1,0, 1,1, 0,1, -1,1, -1,0};//枚举其周围的8个方向位置
void handle(int x,int y)
{
    int i;
    int l,c;
    int count=0;
    for(i=0;i<8;i++)//对周围的8个位置依次进行判断是否是地雷
    {
        l=x+dir[i][0];
        c=y+dir[i][1];
        if(l>=0&&l<n&&c>=0&&c<m)
        {
            if(map[l][c]=='*')
                count++;
        }
    }
    ans[x][y]=count;

}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        getchar();//接受输入行的最后的回车
        if(n==0&&m==0)  break;//测试结束条件
        int i,j;
        for(i=0;i<n;i++)
            scanf("%s",map[i]);
        memset(ans,0,sizeof(ans));
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(map[i][j]=='*')//如果是地雷将其标记
                    ans[i][j]=-1;
                else//否则统计其周围的地雷数
                    handle(i,j);
            }
        }

        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
            {
                if(ans[i][j]==-1)
                    printf("*");
                else
                    printf("%d",ans[i][j]);
            }
            printf("\n");
        }
        printf("\n");//每组实例后的空格
    }
    return 0;
}


        

 

题目B： 题目地址http://acm.uestc.edu.cn/problem.php?pid=1023

本题可以不用多实例输入；

参考代码：

#include<stdio.h>
#include<string.h>
int handle(int m)
{
    if(m>=90)
        return 4;
    else if(m>=80)
        return 3;
    else if(m>=70)
        return 2;
    else if(m>=60)
        return 1;
    else
        return 0;
}
int main()
{
    int n;
    int sum,t;
    double ans;
    scanf("%d",&n);
    
        sum=0;t=0;
        int i;
        for(i=0;i<n;i++)
        {
            int c,s;
            scanf("%d%d",&c,&s);
            sum+=c*handle(s);
            t+=c;
        }
        ans=1.0*sum/t;
        printf("%.2lf\n",ans);
    
    return 0;
}

 

题目C：题目地址http://acm.fzu.edu.cn/problem.php?pid=1205

题意：在一个n*m的迷宫里，找出从a到b的最短路径的长度，和有多少种这样的最短路径。

这里介绍一种比较易于理解的做法：先用BFS计算出最短路的长度，得出长度后，用DFS搜出有多少种不同的最短路径。

不过这种做法如果不做任何优化就会超时，需要做相应的优化。

PS：BFS（广度优先搜索）算法常用于这种迷宫的搜索，即前一步到下一步花费的代价（时间）是相同的，BFS算法是一种由原点向四周步步搜索层层推进的算法，这样直到目的地。所以在这种迷宫的搜索中用BFS计算出的两点的距离就是最短距离。在搜索的过程中需要把走过的方格标记，防止程序走向死循环。

DFS（深搜优先搜索）算法是由当前的搜索点一直搜索到本轮搜索结束，然后进行下一个点的搜索，同样进行BFS时也需要标记，但是当上一个搜索点压人搜索队列中后，被压入点的标记就要取消，防止影响下一轮的搜索。BFS是非常耗时的，需要根据具体的题目做出优化。不然往往会超时。

参考代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
int dir[4][2]={0,1,0,-1,1,0,-1,0};
struct node//记录迷宫原点到x，y位置所走步数
{
    int x,y,step;
};
#define N 100 
int n,m,k;
int map[N][N];//DFS中标记数组
int mark[N][N];//BFS中标记数组
int x1,x2,y1,y2;//起始位置坐标
int ways,min_step;//记录最短路径的不同种类 最短步数
int BFS()//最短路计算最短路径的长度
{
    node cur,next;
    queue<node>q;
    int x,y,i;
    cur.x=x1;cur.y=y1;cur.step=0;
    q.push(cur);
    mark[x1][y1]=1;
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        for(i=0;i<4;i++)
        {
            next.x=x=cur.x+dir[i][0];
            next.y=y=cur.y+dir[i][1];
            if(x>=1&&x<=n&&y>=1&&y<=m&&mark[x][y]==0)
            {
                if(x==x2&&y==y2)
                {
                    printf("%d\n",cur.step+1);
                    min_step=cur.step+1;
                    return 1;
                }
                next.step=cur.step+1;
                q.push(next);
                mark[x][y]=1;
            }

        }

    }
    printf("No Solution!\n");
    return 0;
}
void DFS(int x,int y,int step)
{
    if(x==x2&&y==y2&&step==min_step)
    {
        ways++;
        return ;
    }
    if(step+(x2>x?x2-x:x-x2)+(y2>y?y2-y:y-y2)>min_step)  return ;//DFS的优化，如果少了这个事会超时的
    int xx,yy,i;
    for(i=0;i<4;i++)
    {
        xx=x+dir[i][0];
        yy=y+dir[i][1];
        if(xx>=1&&xx<=n&&yy>=1&&yy<=m&&map[xx][yy]==0)
        {
            map[xx][yy]=1;//标记
            DFS(xx,yy,step+1);//压入搜索队列
            map[xx][yy]=0;//取消标记
        }
    }

}
    
int main()
{
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        memset(mark,0,sizeof(mark));
        memset(map,0,sizeof(mark));
        int i;
        for(i=1;i<=k;i++)//标记不能走的门
        {
            int a,b;
            scanf("%d%d",&a,&b);
            map[a][b]=1;
            mark[a][b]=1;
        }
        scanf("%d%d",&x1,&y1);
        scanf("%d%d",&x2,&y2);
        ways=0;
        int flag;
        if(x1==x2&&y1==y2)//考虑起点和原点重合的情况
            printf("%d\n%d\n",0,0);
        else
          flag=BFS();
        if(flag)
        {
            DFS(x1,y1,0);
            printf("%d\n",ways);
        }
        
    }
    return 0;
}

 

 题目D:http://acm.hdu.edu.cn/showproblem.php?pid=2093

呵呵！很有意思的一题，很实用的。

本题应该归于排序+字符串处理。

本题的关键两点 sscanf函数的使用   排序算法 

好吧！我的习惯不是很好，喜欢C、C++混合使用；

参考代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
struct node{
    char name[15];
    int ac;
    int time;
}s[500];
int n,m;
bool cmp(node a,node b)
{
    if(a.ac!=b.ac)
        return a.ac>b.ac;
    else if(a.time!=b.time)
        return a.time<b.time;
    else
        return strcmp(a.name,b.name)<0;
}

int main()
{
    memset(s,0,sizeof(s));
    scanf("%d%d",&n,&m);
    getchar();
    int i=0;
    while(scanf("%s",s[i].name)!=EOF)
    {
        if(strcmp(s[i].name,"end")==0)  break;//为了调试观查结果，特意加了一句
        char str[15];
        int j;

        for(j=0;j<n;j++)
        {
            scanf("%s",str);
            int a,b;
            int ans;
            ans=sscanf(str,"%d(%d)",&a,&b);
            if(ans==2)
            {
                s[i].ac++;
                s[i].time=s[i].time+a+b*m;
            }
            else if(ans==1&&a>0)
            {
                    s[i].ac++;
                    s[i].time+=a;
            }
        }
        i++;
    }
    sort(s,s+i,cmp);
    for(int k=0;k<i;k++)
     printf("%-10s %2d %4d\n",s[k].name,s[k].ac,s[k].time);
    return 0;
}