HJ39 判断两个IP是否属于同一子网

描述

IP地址是由4个0-255之间的整数构成的，用"."符号相连。

二进制的IP地址格式有32位，例如：10000011，01101011，00000011，00011000;每八位用十进制表示就是131.107.3.24

子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。

子网掩码与IP地址结构相同，是32位二进制数，由1和0组成，且1和0分别连续，其中网络号部分全为“1”和主机号部分全为“0”。

你可以简单的认为子网掩码是一串连续的1和一串连续的0拼接而成的32位二进制数，左边部分都是1，右边部分都是0。

利用子网掩码可以判断两台主机是否在同一子网中。

若两台主机的IP地址分别与它们的子网掩码进行逻辑“与”运算（按位与/AND）后的结果相同，则说明这两台主机在同一子网中。

示例：
I P 地址　 192.168.0.1
子网掩码　 255.255.255.0

转化为二进制进行运算：

I P 地址　  11000000.10101000.00000000.00000001
子网掩码　11111111.11111111.11111111.00000000

AND运算   11000000.10101000.00000000.00000000

转化为十进制后为：
192.168.0.0

I P 地址　 192.168.0.254
子网掩码　 255.255.255.0
转化为二进制进行运算：

I P 地址　11000000.10101000.00000000.11111110
子网掩码  11111111.11111111.11111111.00000000

AND运算  11000000.10101000.00000000.00000000

转化为十进制后为：
192.168.0.0

通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。

输入一个子网掩码以及两个ip地址，判断这两个ip地址是否是一个子网络。

若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2。

注:

有效掩码与IP的性质为：
1. 掩码与IP每一段在 0 - 255 之间
2. 掩码的二进制字符串前缀为网络号，都由‘1’组成；后缀为主机号，都由'0'组成

输入描述：

3行输入，第1行是输入子网掩码、第2，3行是输入两个ip地址
题目的示例中给出了三组数据，但是在实际提交时，你的程序可以只处理一组数据（3行）。

输出描述：

若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2

示例1

输入：

255.255.255.0
192.168.224.256
192.168.10.4

255.0.0.0
193.194.202.15
232.43.7.59

255.255.255.0
192.168.0.254
192.168.0.1

输出：

1
2
0

说明：

对于第一个例子:
255.255.255.0
192.168.224.256
192.168.10.4
其中IP:192.168.224.256不合法，输出1

对于第二个例子:
255.0.0.0
193.194.202.15
232.43.7.59
2个与运算之后，不在同一个子网，输出2

对于第三个例子，2个与运算之后，如题目描述所示，在同一个子网，输出0        

---

#include<cstdio>
#include<string>
#include<vector>
using namespace std;

// 十进制 --> 8位二进制
vector<int> transf(int n)
{
    vector<int> B_vec;
    vector<int> reverse;
    while (n) {
        B_vec.push_back(n%2);
        n/=2;
    }
    // 不足8位补0
    while (B_vec.size()<8) {
        B_vec.push_back(0);
    }
    // 注意下面记得翻转过来，上面得到的是低位->高位
    for(int i=B_vec.size()-1;i>=0;i--) 
    {
        reverse.push_back(B_vec[i]);
    }
    return reverse;
}

int main()
{
    // 1.输入
    char buf1[100]; 
    char buf2[100];
    char buf3[100];
    fgets(buf1,100,stdin); // 输入子网掩码
    fgets(buf2,100,stdin); // 输入IP地址1
    fgets(buf3,100,stdin); // 输入IP地址2

    string mask=buf1;
    string ip1=buf2;
    string ip2=buf3;
    mask.pop_back();
    ip1.pop_back();
    ip2.pop_back();

    // 2.mask、IP1、IP2分别提取对应的十进制数
    vector<int> MASK;
    vector<int> IP1;
    vector<int> IP2;
    string num="";
    int mask_flag=1; //用于判断掩码合法性
    int ip1_flag=1; //用于判断IP地址1合法性
    int ip2_flag=1; //用于判断IP地址2合法性

    // 1）掩码MASK
    mask.push_back('.');//末尾补充一个'.'
    for(int i=0;i<mask.size();i++)
    {
        if(mask[i]=='.')
        {
            MASK.push_back(stoi(num));
            // 记录掩码是否在范围
            if(stoi(num)>255 || stoi(num)<0)
            {
                mask_flag=0;
            }
            num="";
        }
        else {
            num.push_back(mask[i]);
        }
        
    }
    // 2）IP1
    ip1.push_back('.');//末尾补充一个'.'
    for(int i=0;i<ip1.size();i++)
    {
        if(ip1[i]=='.')
        {
            IP1.push_back(stoi(num));
            //记录IP地址是否有不合法
            if(stoi(num)>255 || stoi(num)<0)
            {
                ip1_flag=0;
            }
            num="";
        }
        else {
            num.push_back(ip1[i]);
        }
        
    }
    // 3）IP2
    ip2.push_back('.');//末尾补充一个'.'
    for(int i=0;i<ip2.size();i++)
    {
        if(ip2[i]=='.')
        {
            IP2.push_back(stoi(num));
            // 记录IP地址是否有不合法
            if(stoi(num)>255 || stoi(num)<0)
            {
                ip2_flag=0;
            }
            num="";
        }
        else {
            num.push_back(ip2[i]);
        }
        
    }

    // 3.mask、IP1、IP2分别转换为对应的二进制
    int MASK_to_B[32];
    int IP1_to_B[32];
    int IP2_to_B[32];
    // 1）掩码mask
    for(int i=0;i<MASK.size();i++)
    {
        for(int j=0;j<transf(MASK[i]).size();j++)
        {
            MASK_to_B[i*8+j]=transf(MASK[i])[j];
        }
    }
    for(int i=0;i<32;i++)
    {
        // 记录mask是否合法
        if(i>0 && MASK_to_B[i]==1 && MASK_to_B[i-1]==0)
        {
            mask_flag=0;
        }
    }

    // 2）IP地址1
    for(int i=0;i<IP1.size();i++)
    {
        for(int j=0;j<transf(IP1[i]).size();j++)
        {
            IP1_to_B[i*8+j]=transf(IP1[i])[j];
        }
    }
    // 3）IP地址2
    for(int i=0;i<IP2.size();i++)
    {
        for(int j=0;j<transf(IP2[i]).size();j++)
        {
            IP2_to_B[i*8+j]=transf(IP2[i])[j];
        }
    }
    
    // 若mask、ip有不合法的，则输出1
    if(mask_flag==0 || ip1_flag==0 || ip2_flag==0)
    {
        printf("1");
    }
    // 都合法则判断IP地址是否在同一子网
    else {
        // 4.判断是否同一子网
        int flag=1;
        int i=0;
        while (MASK_to_B[i]!=0) {
            if(IP1_to_B[i]!=IP2_to_B[i]) 
            {
                flag=0;
            }
            i++;
        }
        if(flag==1)//同一子网
        {
            printf("0");
        }
        else {//非同一子网
            printf("2");
        }
    }

}