华为2020招聘笔试 8.27号场第二道

希望有问题能多多指正！

2020招聘笔试题比往届难度提升了一个档次，尤其是27号的那一场，感觉已经不能把华为保底了，真担心毕业找不到工作。。。

第二道题应该是三道中最难的一道了

一个矩阵，5*5，取相邻（二个成员有一个边是相同的）的6个，输入一个6个成员列表，判断是否满足？

矩阵成员如下：

[[1,2,3,4,5],

[11,12,13,14,15],

[21,22,23,24,25,26],

[31,32,33,34,35],

[41,42,43,44,45]]

输入描述

包含6个矩阵成员的数组，如：1 2 3 4 5 11以一个空格分隔，支持多行

1 2 3 4 5 11

1 2 11 14 25 15 

输出描述 

满足输出1，否则输出0，每一行输入一个输出

1

0 

输入 

1 2 3 4 5 11

1 2 11 14 25 15

输出

1

0 

一看到这个题目其实思路也是比较明显的，使用DFS，和leetcode200题求连通分量的个数原理比较相似，我也是在基础上稍微改了一下，但是题目中的矩阵明显有一个行递增，列递增 的特点，而我在解题的过程中并没有利用到这个特点。

简单思路：有输入一个6个元素的数组，为了把这道题转化为求连通矩阵的问题，先用原矩阵初始化新的矩阵，根据6元素数组，将6元素的位置重新赋值为1，其他地方赋值为0。这样就可以转化为连通矩阵问题。

package practice;
import java.util.ArrayList;
import java.util.Scanner;

class Solution {
    public static int numIslands(int[][] grid,ArrayList path) {
        if (grid == null || grid.length == 0 || grid[0].length == 0)
            return 0 ;
            
        int row = grid.length;//行数
        int column = grid[0].length;//列数
 
        int count = 0;

        
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
            	//只有当元素等于1的时候去遍历，元素等于2或0时不需要
                if (grid[i][j] == 1){
                    count ++;
                    combine(grid,i,j);
                }
                //因为题目没有要求求连通分量的个数，所以这里就当count大于1时就赋值为0直接break
                if(count>1){
                	count=0;
                	break;
                }
            }
        }
        return count;
    }
    //关键的函数，DFS，grid是一个只有0和1的矩阵，x,y是当前要遍历的位置
    public static void combine(int[][] grid, int x, int y){
 
        grid[x][y] = 2;//遍历之后都变成2
        //如果元素位置超出矩阵，直接return
        if (x > grid.length-1 && y > grid[0].length-1 ) {
            return;
        }
        //在向下遍历的时候要注意x的大小是否小于length-1
        if (x < grid.length-1 && grid[x+1][y] == 1) {//向下
            combine(grid,x+1,y);
        }
        if (y < grid[0].length-1 && grid[x][y+1] == 1){//向右
            combine(grid,x,y+1);
        }
        if (x > 0 && grid[x-1][y] == 1 ){//向上
            combine(grid,x-1,y);
        }
        if (y > 0 && grid[x][y-1] == 1) {//向左
            combine(grid,x,y-1);
        }
    }
    /*11110
    11010
    11000
    00000*/
    public static void main(String[] args) {
    	int[][] grid=new int[][]{
    		{1,2,3,4,5},
    		{11,12,13,14,15},
    		{21,22,23,24,25},
    		{31,32,33,34,35},
    		{41,42,43,44,45}
    		
    	};
    	
    	int row = grid.length;//行数
        int column = grid[0].length;//列数
        
    	Scanner in = new Scanner(System.in);
    	while(in.hasNext()){
    		int num=6;
    		ArrayList path =new ArrayList<Integer>();
    		for(int i=0;i<num;i++){
    			path.add(in.nextInt());
    		}
    		
    		int[][] temp = grid;
    		//遍历矩阵，根据6元素数组，将矩阵中6元素对应的位置重新赋值为1，其他地方赋值为0
            for(int i=0;i<row;i++){
            	for(int j=0;j<column;j++){
            		if(path.contains(temp[i][j])){
            			temp[i][j]=1;
            		}
            		else{
            			temp[i][j]=0;
            		}
            	}
            }
            int result=numIslands(temp,path);
            System.out.println(result);
    		
    	}
    	
    	
    }
    
}