zoukankan      html  css  js  c++  java

  • 网易游戏2016实习生招聘在线笔试之连连看

    连连看

    时间限制:10000ms
    单点时限:1000ms
    内存限制:256MB

    描述

    小江最喜欢玩的游戏"天下3"最近推出了连连看的小玩法。玩家可以将2个相同图案的牌子连接起来，连接线不多于3根线段（即最多拐2折），就可以成功将这对牌子消除。如示意图所示，红色，黄色和蓝色的消除都是合法的，因为它们分别需要2个，0个和1个折。而黑色的消除是不合法的，因为这对牌至少需要拐3个折才能连接起来。

    但是小江并不满足于这个游戏规则，因为他觉得最多只能拐2折这个限制并不合理。好奇的小江想知道的是，给定一个连连看的状态以及某一个牌子，在K折以内可以到达的所有具有相同图案的牌子的数量是多少。

    输入

    每个输入数据包含多个测试点。

    第一行为测试点的个数S <= 20。之后是S个测试点的数据。

    每个测试点的第一行为1 <= N <= 200, 1 <= M <= 200，表示连连看的大小。接下来的N行，每一行有M个整数，表示连连看该行的状态，如果为0，则表示该格为空，否则代表一种图案的牌子。

    然后是三个整数X <= N, Y <= M，0 <= K <= 10000，表示查询(X, Y)这个牌子在K折以内能消除的所有相同牌子总数。其中连连看左上角的格子坐标为(1, 1)，右下角为(N, M)。保证查询的格子是有图案的。

    输出

    对于每个测试点，输出对应的能消除的所有牌子总数。

    提示

    样例第一个例子，第(1, 1), (2, 3)和(2, 5)为3个可以在3折内被消除的相同牌子。

    样例输入
    3
4 5
1 0 1 0 2
0 0 1 3 1
3 3 1 5 9
6 1 4 8 7
1 3 3
4 5
1 0 1 0 2
0 0 1 3 1
3 3 1 5 9
6 1 4 8 7
1 3 1
2 2
1 10
2 3
1 1 10
    样例输出
    3
2
0
    题目大意：最小转弯问题。（注意哪些是行哪些是列）
    算法思路：
    一种O(12nm)的算法，用dis[i][x][y]代表上一步走的是i方向，现处于(x, y)所需要的最小转弯数。用两个队列，一个记录探索到的道路，一个记录可以到达的目的点。
      1 import java.util.LinkedList;
  2 import java.util.Queue;
  3 import java.util.Scanner;
  4 
  5 
  6 public class Main {
  7 
  8     public static void main(String[] argv){
  9         Scanner in = new Scanner(System.in);
 10         int x = in.nextInt();
 11         int y = in.nextInt();
 12         int [][] source = new int[x+2][y+2];
 13         int [][] R_has = new int[x+2][y+2];
 14         for(int i=1; i<=x;i++){
 15             for(int j=1; j<=y;j++){
 16                 source[i][j]=in.nextInt();    
 17             }                            
 18         }
 19         int a = in.nextInt();
 20         int b = in.nextInt();
 21         int c = in.nextInt();
 22         in.close();
 23         int Num = source[a][b];
 24         int[][][] dis = new int[4][x+2][y+2];
 25         Queue<Integer> temp = new LinkedList<Integer>(); 
 26         Queue<Integer> result = new LinkedList<Integer>(); 
 27         temp.offer(a);
 28         temp.offer(b);
 29         dis[0][a][b]=1;
 30         dis[1][a][b]=1;
 31         dis[2][a][b]=1;
 32         dis[3][a][b]=1;
 33         while(true){
 34             if(temp.size()==0)
 35                 break;
 36             int N_x = temp.poll();
 37             int N_y = temp.poll();
 38             System.out.println("temp 出队:"+N_x+N_y+"      并开始匹配");
 39             //up adding
 40             if(N_x-1>=0&&(source[N_x-1][N_y]==0||source[N_x-1][N_y]==Num)){        
 41                 
 42                     System.out.println("up匹配:  ");
 43                     int min=0;            
 44                     if(dis[2][N_x][N_y]>0)                                        
 45                         min=dis[2][N_x][N_y];
 46                     if(dis[1][N_x][N_y]>0){
 47                         if(min==0)
 48                             min=dis[1][N_x][N_y]+1;
 49                         else{
 50                             if(dis[1][N_x][N_y]+1<min)
 51                                 min=dis[1][N_x][N_y]+1;
 52                         }
 53                     }
 54                     if(dis[3][N_x][N_y]>0){
 55                         if(min==0)
 56                             min=dis[3][N_x][N_y]+1;
 57                         else{
 58                             if(dis[3][N_x][N_y]+1<min)
 59                                 min=dis[3][N_x][N_y]+1;
 60                         }
 61                     }
 62                 if(min<=c){
 63                         if(source[N_x-1][N_y]==0){    
 64                     int S_up=dis[2][N_x-1][N_y];
 65                     dis[2][N_x-1][N_y]=min;
 66                     if( S_up!=min){    
 67                         System.out.println("temp 队列 add:"+(N_x-1)+" "+N_y);
 68                         temp.offer(N_x-1);
 69                         temp.offer(N_y);
 70                     }
 71                     
 72                 }
 73                 else{
 74                     if(R_has[N_x-1][N_y]==0){                        
 75                         result.add(N_x-1);
 76                         result.add(N_y);    
 77                         R_has[N_x-1][N_y]=1;                                                
 78                     }
 79                 }
 80                     }
 81                 
 82                     
 83             }
 84             
 85         //down adding
 86             if(N_x+1<x+2&&(source[N_x+1][N_y]==0||source[N_x+1][N_y]==Num)){        
 87                 
 88                 System.out.println("down匹配:  ");
 89                     int min=0;            
 90                     if(dis[0][N_x][N_y]>0)                                        
 91                         min=dis[0][N_x][N_y];
 92                     if(dis[1][N_x][N_y]>0){
 93                         if(min==0)
 94                             min=dis[1][N_x][N_y]+1;
 95                         else{
 96                             if(dis[1][N_x][N_y]+1<min)
 97                                 min=dis[1][N_x][N_y]+1;
 98                         }
 99                     }
100                     if(dis[3][N_x][N_y]>0){
101                         if(min==0)
102                             min=dis[3][N_x][N_y]+1;
103                         else{
104                             if(dis[3][N_x][N_y]+1<min)
105                                 min=dis[3][N_x][N_y]+1;
106                         }
107                     }
108                     if(min<=c){
109                         if(source[N_x+1][N_y]==0){
110                     int S_down=dis[0][N_x+1][N_y];
111                     dis[0][N_x+1][N_y]=min;
112                     if(S_down!=min){
113                     System.out.println("temp 队列 add:"+(N_x+1)+" "+N_y);
114                     temp.offer(N_x+1);
115                     temp.offer(N_y);
116                     }
117                     
118                 }
119                 else{
120                     if(R_has[N_x+1][N_y]==0){
121                         result.add(N_x+1);
122                         result.add(N_y);    
123                         R_has[N_x+1][N_y]=1;
124                     }
125                     
126                 }
127             }                                    
128         }
129             //right adding
130             if(N_y+1<y+2&&(source[N_x][N_y+1]==0||source[N_x][N_y+1]==Num)){        
131                 
132                 System.out.println("right匹配:  ");
133                     int min=0;            
134                     if(dis[3][N_x][N_y]>0)                                        
135                         min=dis[3][N_x][N_y];
136                     if(dis[0][N_x][N_y]>0){
137                         if(min==0)
138                             min=dis[0][N_x][N_y]+1;
139                         else{
140                             if(dis[0][N_x][N_y]+1<min)
141                                 min=dis[0][N_x][N_y]+1;
142                         }
143                     }
144                     if(dis[2][N_x][N_y]>0){
145                         if(min==0)
146                             min=dis[2][N_x][N_y]+1;
147                         else{
148                             if(dis[2][N_x][N_y]+1<min)
149                                 min=dis[2][N_x][N_y]+1;
150                         }
151                     }
152                 //System.out.println("min: "+min);
153                 if(min<=c){
154                         if(source[N_x][N_y+1]==0){        
155                     int S_right=dis[3][N_x][N_y+1];
156                     dis[3][N_x][N_y+1]=min;
157                     if(S_right!=min){
158                         System.out.println("temp 队列 add:"+N_x+" "+(N_y+1));
159                         temp.offer(N_x);
160                         temp.offer(N_y+1);
161                     }
162                     
163                 }
164                 else{
165                     if(R_has[N_x][N_y+1]==0){
166                         result.add(N_x);
167                         result.add(N_y+1);    
168                         R_has[N_x][N_y+1]=1;
169                     }
170                     
171                 }
172             }                
173         }
174             //left adding
175             if(N_y-1>=0&&(source[N_x][N_y-1]==0||source[N_x][N_y-1]==Num)){        
176                 
177                 System.out.println("left匹配:  ");
178                     int min=0;            
179                     if(dis[1][N_x][N_y]>0)                                        
180                         min=dis[1][N_x][N_y];
181                     if(dis[0][N_x][N_y]>0){
182                         if(min==0)
183                             min=dis[0][N_x][N_y]+1;
184                         else{
185                             if(dis[0][N_x][N_y]+1<min)
186                                 min=dis[0][N_x][N_y]+1;
187                         }
188                     }
189                     if(dis[2][N_x][N_y]>0){
190                         if(min==0)
191                             min=dis[2][N_x][N_y]+1;
192                         else{
193                             if(dis[2][N_x][N_y]+1<min)
194                                 min=dis[2][N_x][N_y]+1;
195                         }
196                     }    
197                 if(min<=c){
198                 if(source[N_x][N_y-1]==0){
199                     int S_left=dis[1][N_x][N_y-1];
200                     dis[1][N_x][N_y-1]=min;
201                     if(S_left!=min){
202                         System.out.println("temp 队列 add:"+N_x+" "+(N_y-1));
203                         temp.offer(N_x);
204                         temp.offer(N_y-1);
205                     }
206                     
207                 }
208                 else{
209                     if(R_has[N_x][N_y-1]==0){
210                         result.add(N_x);
211                         result.add(N_y-1);    
212                         R_has[N_x][N_y-1]=1;
213                     }
214                                     
215                 }
216                     
217              }        
218             }    
219             System.out.println("");
220         }
221         
222         /*
223         for(Integer string : result){
224             System.out.println(string);
225         }
226         */
227         System.out.println("最终的结果：  "+(result.size()-2)/2);
228     }
229     
230 
231 }
    View Code
     
  • 相关阅读:
    利用哈希map快速判断两个数组的交集
    TCP协议中的三次握手和四次挥手(图解)-转
    PC,移动端H5实现实现小球加入购物车效果
    HQL和SQL的区别
    Java泛型详解，通俗易懂只需5分钟
    经典的 Fork 炸弹解析
    Java并发之AQS详解
    Java不可重入锁和可重入锁的简单理解
    Codeforces 1215F. Radio Stations
    Codeforces 1215E. Marbles
  • 原文地址：https://www.cnblogs.com/udld/p/4512022.html
Copyright © 2011-2022 走看看