一、选择题

（1）tcp套接字中，不会阻塞的是哪一种操作（D）
A.read
B.write
C.accept
D.bind

bind函数不会阻塞执行流的

（2）如果将网络IP段40.15.128.0/17划分成两个子网，则第一个子网IP段为40.15.128.0/18，则第二个子网为（D）
A.40.15.129.0/18
B.40.15.128.128/18
C.40.15.192.0/17
D.40.15.192.0/18

40.15.128.0/17 -> 00101000 00001111 10000000 00000000
40.15.128.0/18 -> 00101000 00001111 10000000 00000000
另一个子网，第18位为1 即 00101000 00001111 11000000 00000000

（3）下面对Host文件描述正确的是（C）
A.这个文件是批处理文件，用来指定域名的访问IP
B.一个DNS域名解析器文件，用于解析域名对应的IP地址
C.作用是网址域名与其对应的IP地址建立一个关联"数据库"
D.当用户输入网址后，系统首先到DNS服务器中寻找对应的IP地址，如果不存在回到Host文件中确定最终访问地址

当用户输入一个需要登录的网址时，系统就会先去Host文件中查找，如果找到了就立即打开该网址，如果找不到就去DNS域名服务器中查找

二、编程题

2.1 解读密码

2.1.1 题目

2.1.2 题解

代码：

import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(scanner.hasNext()){
      
      String str=scanner.nextLine();
      StringBuffer sb=new StringBuffer();
      for(int i=0;i<str.length();i++){
        char ch=str.charAt(i);
        if(ch>='0' && ch<='9'){
          sb.append(ch);
        }
      }
      System.out.println(sb.toString());
    }
  }
}

2.2 走迷宫

2.2.1 题目

2.2.2 题解

思路：深度优先遍历
cnt数组保存的是，走到i，j位置所需的最少步数
对于i，j位置来说，依次向上下左右四个方向尝试
如果从i，j位置到nexti，nextj位置所需的步数更少，就更新cnt[nexti][nextj]

代码:

import java.util.*;
public class Main{
  private static int[][] dirs={{0,1},{0,-1},{-1,0},{1,0}};
    private static char[][] map=new char[10][10];
  private static  int[][] cnt=new int[10][10];
  public static void main(String[] args){
    Scanner scanner=new Scanner(System.in);
    while(scanner.hasNext()){
      for(int i=0;i<10;i++){
          map[i]=scanner.nextLine().toCharArray();
      }
       for(int i=0;i<10;i++){
         for(int j=0;j<10;j++){
           cnt[i][j]=Integer.MAX_VALUE;
         }
     }
      cnt[0][1]=0;
      dfs(0,1);
      System.out.println(cnt[9][8]);
  } 
}
   private static void dfs(int i,int j){
      for(int k=0;k<4;k++){
        int nexti=i+dirs[k][0];
        int nextj=j+dirs[k][1];
        if(nextj>=0 && nextj<10 && nexti>=0 && nexti<10 && map[nexti][nextj]=='.'
          && cnt[nexti][nextj]>cnt[i][j]+1){
           cnt[nexti][nextj]=cnt[i][j]+1;
          dfs(nexti,nextj);
        }
      }
   }
}