Week4 CSP C可怕的宇宙射线

题目描述

众所周知，瑞神已经达到了CS本科生的天花板，但殊不知天外有天，人外有苟。在浩瀚的宇宙中，存在着一种叫做苟狗的生物，这种生物天生就能达到人类研究生的知识水平，并且天生擅长CSP，甚至有全国第一的水平！但最可怕的是，它可以发出宇宙射线！宇宙射线可以摧毁人的智商，进行降智打击！
宇宙射线会在无限的二维平面上传播（可以看做一个二维网格图），初始方向默认向上。宇宙射线会在发射出一段距离后分裂，向该方向的左右45°方向分裂出两条宇宙射线，同时威力不变！宇宙射线会分裂 次，每次分裂后会在分裂方向前进ai个单位长度。现在瑞神要带着他的小弟们挑战苟狗，但是瑞神不想让自己的智商降到普通本科生zjm那么菜的水平，所以瑞神来请求你帮他计算出共有多少个位置会被"降智打击"。

时间内存限制
每个测试点 1000ms 262144KB

输入说明
输入第一行包含一个正整数 n（n<=30)，表示宇宙射线会分裂n 次
第二行包含n个正整数a1,a2···an ，第ai 个数表示第 i次分裂的宇宙射线会在它原方向上继续走多少个单位长度

输出说明
输出一个数ans ，表示有多少个位置会被降智打击

输入样例
4
4 2 2 3
12
1
2
3
输出样例
39
1
1
2
测试点说明
10% n<=10
20% n<=20
30% n<=30

 

解题思路：

1.数据表示：

我们可以以坐标为单位，用一个结构体来存储每个经过的节点，但是考虑到后面数据量比较大，全部存储显然会MLE，另外，如果中间加上去重的步骤（这种表示形式只能遍历），又会导致超时。所以经过思考，我们发现，射线的范围可以框定咋一个矩形区域内（300*300），为此，我们不如用二维数组直接存储整个地图，然后给遍历过的做标记并且计数就ok了。

另外：根据算法的思路，时间复杂度过高如何解决？

我们还需要一个记录状态的数组！

2.算法：

很容易想到可以用dfs来解决，但是随着数据量的增大，问题时间复杂度呈指数级增长，300*300的地图上随着层数增加会有越来越多重复的情况出现，为此，需要采用记忆化搜索的思路，减少一些不必要的时间损耗。经过分析，我们可以用一个四维数组来表示某点在第i层是否朝某个方向发射过射线（因为层数决定了长度，长度不需要考虑了）。

#include<iostream>
#include<string.h>
using namespace std;
typedef struct node{
    int x,y;
}node;
int n,index=0;
int *a=new int[31];
bool dp[301][301]; 
bool p[301][301][8][31];     //(x,y,lens,direction,times)
//direction   0           1       2          3          4          5          6         7   
//           left-up   up     right-up   right    right-down  down left-down  left  
node sign(node start,int lens,int direction){
        node last;                
        if(direction==0)    
        {    
            for(int i=1;i<=lens;i++){                    
                if(!dp[start.x-i][start.y+i])  //遍历过的就不存了 
                {
                index++; 
                dp[start.x -i][start.y+i]=true;
                }            
             }    
            last.x=start.x-lens;last.y=start.y+lens; 
        }    
        else if(direction==1)        
        {
           for(int i=1;i<=lens;i++){                
                if(!dp[start.x][start.y+i])
                {
                index++; 
                dp[start.x][start.y+i]=true;  
                }
             }
            last.x=start.x;last.y=start.y+lens;
        }
        else if(direction==2)
        {    
            for(int i=1;i<=lens;i++){
            
                if(!dp[start.x+i][start.y+i])
                {    
                index++; 
                dp[start.x+i][start.y+i]=true;   
                }
            }
             last.x=start.x +lens;last.y=start.y+lens; 
        } 
        else if(direction==3)
        {
            for(int i=1;i<=lens;i++){
                if(!dp[start.x+i][start.y])
                {
                index++; 
                dp[start.x+i][start.y]=true;   
                }    
            } 
             last.x = start.x+lens;last.y = start.y;
        }
        else if(direction==4)
        {
            for(int i=1;i<=lens;i++){        
                if(!dp[start.x+i][start.y-i])
                {    
                index++; 
                dp[start.x+i][start.y-i]=true;   
                }
            }   
              last.x=start.x+lens;last.y = start.y -lens;
        }
        else if(direction==5)
        {
            for(int i=1;i<=lens;i++){            
                if(!dp[start.x][start.y-i])
                {
                index++; 
                dp[start.x][start.y-i]=true;   
                }            
            }
            last.x=start.x;last.y=start.y-lens;
        }
        else if(direction==6)
        {
            for(int i=1;i<=lens;i++){            
                if(!dp[start.x-i][start.y-i])
                {
                index++; 
                dp[start.x-i][start.y-i]=true;   
                }
            }
              last.x=start.x-lens;last.y=start.y-lens;
        }
        else if(direction==7)
        {
            for(int i=1;i<=lens;i++){
                if(!dp[start.x-i][start.y])
                {
                index++; 
                dp[start.x-i][start.y]=true;   
                }
            }
        last.x=start.x-lens;last.y=start.y;    
        }    
    return last;    
} 
void dfs(node start,int direction,int times)
{                                    
    if(times == n)//边界条件;
            return ;
    if(direction==-1)    direction=7;
    if(direction==8)    direction=0;                    
    //    (x,y,lens,direction,times)        
    p[start.x][start.y][direction][times]=true;                    
    node lastnode = sign(start,a[times],direction); 

    if(!p[lastnode.x][lastnode.y][(direction+1)%8][times+1])
        dfs(lastnode,(direction+1)%8,times+1);                

    if(direction==0) direction=8;
    if(!p[lastnode.x][lastnode.y][direction-1][times+1])
        dfs(lastnode,direction-1,times+1);
}
int main(){
    //while(cin>>n){  index=0;
    cin>>n;    
    for(int i=0;i<n;i++)    
    cin>>a[i];    
    memset(dp,0,sizeof(dp));
    memset(p,0,sizeof(p));    
    node start;    start.x=150;start.y=150;  
    dfs(start,1,0);     
    cout<<index<<endl;
//  }
    return 0;
}