模拟行走

可以重复行走

 

包括多个数据集合。每个数据集合的第一行是两个整数W和H，分别表示x方向和y方向瓷砖的数量。W和H都不超过20。

在接下来的H行中，每行包括W个字符。

每个字符表示一个区域的状态，规则如下

1）‘.’：代表紫色迷雾；

2）‘#’：代表红墙；

3）‘@’：代表林克的起始位置(该字符在每个数据集合中唯一出现一次。）

当在一行中读入的是两个零时，表示输入结束。

 

输出

 

对每个数据集合，分别输出一行，显示林克从初始位置出发能净化的迷雾数(记数时包括初始位置的迷雾)。

 

输入样例 1 

6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
0 0

输出样例 1

45

#include<iostream>
using namespace std;
int w,h;
char fogforest[27][27];
int res=0;

int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};

int dfs(int i,int j)
{
    int res=1;
    fogforest[i][j]='#';    //防止重复计算
    for(int k=0;k<4;k++)
    {
        int x=i+dx[k],y=j+dy[k];
        if(x>=0&&y>=0&&x<h&&y<w&&fogforest[x][y]=='.')
        res+=dfs(x,y);
    }
    return res;
}
//上一层函数与下一层函数的res不一样
 
int main()
{
    while(cin>>w>>h,w||h)
    {
        int startx,starty;
        for(int i=0;i<h;i++)
        {
            for(int j=0;j<w;j++)
            {
                cin>>fogforest[i][j];
                if(fogforest[i][j]=='@')
                {
                    startx=i;
                    starty=j;
                }
            }
        }
        cout<<dfs(startx,starty)<<endl;
    }
}

 

 

有一个m行和n列的方阵区域(m＊n)，横纵坐标范围分别是0∼m−1和0∼n−1。

一只红色的波克布林从坐标0,0的格子开始巡逻，每一次只能向左，右，上，下四个方向移动一格。

但是不能进入行坐标和列坐标的数位之和大于k的格子。

请问该红色波克布林能够达到多少个格子？

假如输入：k=18, m=40, n=40

则输出是：1484

根据题意思：当k为18时，波克布林能够进入方格（35,37），因为3+5+3+7 = 18。 但是，它不能进入方格（35,38），因为3+5+3+8 = 19。

 

输入

 

输入一行，三个整数，由空格隔开，代表k m n

其中：

0<=k<=100

0<=m<=50

0<=n<=50

 

输出

 

一个整数，表示红色波克布林能达到的多少格子。





 

输入样例 1 

18 40 40

输出样例 1

1484

#include<iostream>
#include<queue>
#include<vector>
using namespace std;
int k,m,n;

int get_int_sum(int x)
{
    int s=0;
    while(x)
        s+=x%10,x/=10;
    return s;
}

int get_pair_sum(pair<int,int> p)
{
    int s=0;
    s+=get_int_sum(p.first);
    s+=get_int_sum(p.second);
    return s;
}

int bfs(int threshold,int rows,int cols)
{
    if(!rows||!cols)
    return 0;
    vector<vector<bool>> st(rows,vector<bool>(cols,false));
    queue<pair<int,int>>q;
    
    int direction[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
    int res=0;
    q.push({0,0});
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        if(st[t.first][t.second]||get_pair_sum(t)>threshold)
            continue;
        res++;
        st[t.first][t.second]=true;
        for(int i=0;i<4;i++)
        {
            int x=t.first+direction[i][0],y=t.second+direction[i][1];
            if(x>=0&&x<rows&&y>=0&&y<cols)
                q.push({x,y});
        }
    }
    return res;
}
int main()
{
    int ans;
    cin>>k>>m>>n;
    ans=bfs(k,m,n);
    cout<<ans;    
}