题目主要信息

1、给出两个ip地址及掩码

2、判断ip地址及掩码是否规范

3、判断两个ip地址是否属于同一子网

方法一:字符串比较

具体方法

首先本题中包括两个目标，一个是判断ip地址及掩码是否规范 第二个是判断两个ip地址是否属于同一子网 对于判断是否规范问题，首先题目中给出了要求： 1、掩码与IP每一段在0-255之间 2、掩码的二进制字符串，前缀全为1，后缀全为0 直接按照字面意思判断即可 对于判断是否属于同一子网，我们可以将ip地址转换成二进制字符串，通过字符串的比较进行判断

Java代码

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String mask = sc.nextLine();
            String ip1 = sc.nextLine();
            String ip2 = sc.nextLine();
            String[] _mask = mask.split("\\.");
            String[] iip1 = ip1.split("\\.");
            String[] iip2 = ip2.split("\\.");
            StringBuilder mask_sb = new StringBuilder();
            StringBuilder ip1_sb = new StringBuilder();
            StringBuilder ip2_sb = new StringBuilder();
            boolean flag = true;  //判断是否有大于255的不规范
            for(int i=0; i<4; i++){
                int num = Integer.parseInt(_mask[i]);
                if(num>255 || num<0){
                    flag = false;
                    break;
                }
                String num2 = Integer.toBinaryString(num);
                while(num2.length()<8){
                    num2 = "0" + num2;
                }
                mask_sb.append(num2);

                num = Integer.parseInt(iip1[i]);
                if(num>255 || num<0){
                    flag = false;
                    break;
                }
                num2 = Integer.toBinaryString(num);
                while(num2.length()<8){
                    num2 = "0" + num2;
                }
                ip1_sb.append(num2);

                num = Integer.parseInt(iip2[i]);
                if(num>255 || num<0){
                    flag = false;
                    break;
                }
                num2 = Integer.toBinaryString(num);
                while(num2.length()<8){
                    num2 = "0" + num2;
                }
                ip2_sb.append(num2);
            }
            if(!flag){
                System.out.println(1);
                continue;
            }
            mask = mask_sb.toString();
            ip1 = ip1_sb.toString();
            ip2 = ip2_sb.toString();
            int left = 0, right = 31;
            while(mask.charAt(left)=='1'){
                left++;
            }
            while(mask.charAt(right)=='0'){
                right--;
            }
            if(left!=right+1){  //判断掩码是否规范
                System.out.println(1);
                continue;
            }

            boolean ans = true;
            for(int i=0; i<32 && mask.charAt(i)=='1'; i++){
                if(ip1.charAt(i) != ip2.charAt(i)){
                    ans = false;
                    break;
                }
            }

            if(ans){
                System.out.println(0);
            }else{
                System.out.println(2);
            }
        }
    }
}

复杂度分析

• 时间复杂度：$O(1)O(1)$，全部为常数循环
• 空间复杂度：$O(1)O(1)$

方法二：与运算判断

具体方法

对于规范问题判断同上 对于是否属于同一子网的问题，我们可以通过与运算的方式，转化成二进制，然后进行与运算

Java代码

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String mask = sc.nextLine();
            String ip1 = sc.nextLine();
            String ip2 = sc.nextLine();
            String[] _mask = mask.split("\\.");
            String[] iip1 = ip1.split("\\.");
            String[] iip2 = ip2.split("\\.");
            StringBuilder mask_sb = new StringBuilder();
            StringBuilder ip1_sb = new StringBuilder();
            StringBuilder ip2_sb = new StringBuilder();
            boolean flag = true;  //判断是否有大于255的不规范
            for(int i=0; i<4; i++){
                int num = Integer.parseInt(_mask[i]);
                if(num>255 || num<0){
                    flag = false;
                    break;
                }
                String num2 = Integer.toBinaryString(num);
                while(num2.length()<8){
                    num2 = "0" + num2;
                }
                mask_sb.append(num2);

                num = Integer.parseInt(iip1[i]);
                if(num>255 || num<0){
                    flag = false;
                    break;
                }
                num2 = Integer.toBinaryString(num);
                while(num2.length()<8){
                    num2 = "0" + num2;
                }
                ip1_sb.append(num2);

                num = Integer.parseInt(iip2[i]);
                if(num>255 || num<0){
                    flag = false;
                    break;
                }
                num2 = Integer.toBinaryString(num);
                while(num2.length()<8){
                    num2 = "0" + num2;
                }
                ip2_sb.append(num2);
            }
            if(!flag){
                System.out.println(1);
                continue;
            }
            mask = mask_sb.toString();
            ip1 = ip1_sb.toString();
            ip2 = ip2_sb.toString();
            int left = 0, right = 31;
            while(mask.charAt(left)=='1'){
                left++;
            }
            while(mask.charAt(right)=='0'){
                right--;
            }
            if(left!=right+1){  //判断掩码是否规范
                System.out.println(1);
                continue;
            }

            boolean ans = true;
            long mask_num = Long.parseLong(mask, 2);
            long ip1_num = Long.parseLong(ip1, 2);
            long ip2_num = Long.parseLong(ip2, 2);
            ans = (mask_num & ip1_num) == (mask_num & ip2_num);
            if(ans){
                System.out.println(0);
            }else{
                System.out.println(2);
            }
        }
    }
}

复杂度分析

• 时间复杂度：$O(1)O(1)$，全部为常数循环
• 空间复杂度：$O(1)O(1)$