hdoj5024【BFS/暴力】

最新推荐文章于 2020-06-27 23:08:28 发布

keyboarder_zsq

最新推荐文章于 2020-06-27 23:08:28 发布

阅读量415

点赞数

CC 4.0 BY-SA版权

分类专栏： BFS 文章标签： bfs

本文链接：https://blog.youkuaiyun.com/KEYboarderQQ/article/details/52192186

BFS 专栏收录该内容

36 篇文章

订阅专栏

本文介绍了一种寻找在网格中允许转一次90度弯情况下的最长路径算法。通过遍历每个点并使用BFS搜索八个方向，计算特定方向上的路径长度，最终找出最长的路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：
在可以行走的区域内，只能转一次90度的弯，问你最长这条路可以多长。
思路：
我们可以看到

/*
123
8 4
765
*/

转90度的路径会是横竖，也就是1-3-5-7;
还有斜的：2-4-6-8；
我们可以对一个点直接BFS/暴力一下，方向是八个方向，然后计算对应的90度方向上的距离和，开个数组表示某方向上的路径长度，我们可以发现90度方向在数组上的规律，然后再暴力找个最大。
复杂度也不高。
贴一发挫code…….

//#include<bits/stdc++.h>
#include<cstdio>
#include<iostream>
#include<math.h>
#include<string.h>
#include<algorithm>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const double eps=1e-5;
const double pi=acos(-1.0);
const int mod=1e8+7;
const LL INF=0x3f3f3f3f;

const int N=1e2+7;
char ma[N][N];
int n;

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


int Judge(int x,int y)
{
    if(x<0||y<0||x>=n||y>=n||ma[x][y]=='#')
        return 0;
    return 1;
}

int bfs(int i,int j)
{
    int sum[8];
    for(int k=0;k<8;k++)
        sum[k]=1;

    for(int k=0;k<8;k++)
    {
        int aa=i+dx[k];
        int bb=j+dy[k];
        while(Judge(aa,bb)){
            sum[k]++;
            aa+=dx[k];
            bb+=dy[k];
        }
    }

    int ans=0;
//    for(int k1=0;k1<8;k1+=2)
//        for(int k2=1;k2<8;k2+=2)
//            ans=max(ans,sum[k1]+sum[k2]);

    for(int k1=0;k1<8;++k1)
        for(int k2=0;k2<8;++k2)
            if((k1%2==k2%2)&&k1!=k2)    //对于数组的特性，奇数都是斜方向，偶数都是竖直方向。 
                ans=max(ans,sum[k1]+sum[k2]);

    return ans-1;
}

int main()
{
    while(~scanf("%d",&n))
    {
        if(!n) break;
        int i,j,ans;
        for(i=0;i<n;i++)
            scanf("%s",ma[i]);
        ans=0;
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                if(ma[i][j]=='.')
                    ans=max(ans,bfs(i,j));
        printf("%d\n",ans);
    }
    return 0;
}