BFS-hdu-3533-Escape

关注

原创最新推荐文章于 2025-01-11 07:00:00 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

极化码自适应CA-SCL译码（极化码译码）我们知道最初极化码提出来是运用SC译码，但短码和中等长度其译码性（误码率）能不如LDPC码码，，为了提升有限长度极化码的译码性能，我们主要从译码器的性能和极化码的纠错性能来考虑。 SCL：在增加复杂度的情况下，大幅度增加极化码纠错性能，在高信噪比下，与最优ML性能相同（L=32） CA-SCL：改善最小汉明距离（最小汉明距离增大），增加其纠错性能。把CRC和极化码极联。自适应CA-SCL：CA-SCL译码虽然提升几乎没的纠错性能，但是导致复杂度大幅度增加，为了降低其复杂度，让L自适应，从而降低其复杂度阅读详情

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=3533

题目大意：

给一个m*n的矩阵方格，有k门大炮，每门大炮以t为周期向c方向发射炮弹，炮弹速度为v.

求从(0,0)到(m,n)位置最短的时间，中间不能被炮弹打到，时间不能超过d.

解题思路：

预处理好后就是简单的BFS。

先预处理每个点能够被炮弹射击的所有时刻，然后用vis[x][y][t]判重，表示到达(x,y)位置时刻为t时是否被访问。

代码：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#define eps 1e-6
#define INF 0x1f1f1f1f
#define PI acos(-1.0)
#define ll __int64
#define lson l,m,(rt<<1)
#define rson m+1,r,(rt<<1)|1
//#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

/*
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
*/
bool iscan[120][120][1100]; //预处理所有点，不能停留的时间
bool cas[120][120]; //是否炮弹
bool vis[120][120][1100]; //是否被访问
int m,n,k,d,dir[5][2]={{-1,0},{0,1},{1,0},{0,-1},{0,0}}; //最后一个方向为呆在原地
map<char,int>myp;
char sa[5];

bool isin(int x,int y) //判断是否在网格里
{
   if(x<0||x>m||y<0||y>n)
      return false;
   return true;
}
struct Node
{
   int x,y,t;
   friend bool operator <(const Node & a,const Node & b)
   {
      return a.t>b.t;
   }
};
struct Bome
{
   int x,y,t,v;
   char sa[5];
}bom[110];

void bfs()
{
   memset(vis,false,sizeof(vis));
   Node s;
   s.x=0,s.y=0,s.t=0;
   priority_queue<Node>myq; //以时间为优先因素
   myq.push(s);
   vis[0][0][0]=true;
   while(!myq.empty())
   {
      Node cur=myq.top();
      myq.pop();
      for(int i=0;i<5;i++)
      {
         int x=cur.x+dir[i][0],y=cur.y+dir[i][1];
         int t=cur.t+1;
         if(!isin(x,y)||cas[x][y]||vis[x][y][t])
            continue;
         if(!iscan[x][y][t]||t>d)
            continue;
         if(x==m&&y==n)
         {
            printf("%d\n",t);
            return ;
         }
         vis[x][y][t]=true;
         Node tmp;
         tmp.x=x,tmp.y=y,tmp.t=t;
         myq.push(tmp);
      }
   }
   printf("Bad luck!\n");
}

int main()
{
   int x,y,t,v;
   myp['N']=0,myp['E']=1,myp['S']=2,myp['W']=3;
   while(scanf("%d%d%d%d",&m,&n,&k,&d)!=EOF)
   {
      memset(iscan,true,sizeof(iscan));
      memset(cas,false,sizeof(cas));
      for(int i=1;i<=k;i++)
      {
         scanf("%s%d%d%d%d",bom[i].sa,&bom[i].t,&bom[i].v,&bom[i].x,&bom[i].y);
         cas[bom[i].x][bom[i].y]=true;
      }
      for(int i=1;i<=k;i++)
      {
         x=bom[i].x,y=bom[i].y,v=bom[i].v,t=bom[i].t;
         strcpy(sa,bom[i].sa);
         int dd=myp[*sa],xx,yy,sumt=0;
         while(true)
         {
            sumt++; //枚举时间
            xx=x+dir[dd][0]*v*sumt,yy=y+dir[dd][1]*v*sumt; //到达的位置
            if(!isin(xx,yy)) //跑到了外面
               break;
            bool flag=true;
            for(int j=0;j<v;j++) //这之间是否有大炮
            {
               if(cas[xx-j*dir[dd][0]][yy-j*dir[dd][1]])
               {
                  flag=false; //如果有 则这门大炮到此无用
                  break;
               }
            }
            if(!flag)
               break;
            int tmpt=sumt;
            while(tmpt<=d) //大炮是周期性，所以每隔t时间，又有一门大炮射来
            {
               iscan[xx][yy][tmpt]=false;
               tmpt+=t;
            }
         }
      }
      bfs();
   }
   return 0;
}