CCF201812-3 CIDR合并

最新推荐文章于 2024-07-27 20:47:28 发布
最新推荐文章于 2024-07-27 20:47:28 发布
阅读量7k 收藏 25
点赞数 9
分类专栏： CCF CSP
听说这里要写版权声明
本文链接：https://blog.csdn.net/SongBai1997/article/details/86663794
版权

 

试题编号：201812-3
试题名称：CIDR合并
时间限制：1.0s
内存限制：512.0MB
问题描述：



样例输入

2
1
2

样例输出

1.0.0.0/8
2.0.0.0/8

样例输入

2
10/9
10.128/9

样例输出

10.0.0.0/8

样例输入

2
0/1
128/1

样例输出

0.0.0.0/0

 

分析

  

 

自定义数据类型

由于IP地址需要排序、匹配等，因此使用字符串类存储32位IP地址，整型len表示前缀长度。在struct IP中对<运算符进行了重载，以IP地址为第一关键字，前缀长度为第二关键字，从小到大排序。

struct IP{
	IP(string s,int len):s(s),len(len){}
	string s;
	int len;
	//以IP地址为第一关键字，前缀长度为第二关键字，从小到大排序
	bool operator <(const IP &a)const
	{
		return s==a.s?(len<a.len):(s<a.s);
	}
};

 

数据结构的选择

由于要频繁进行删除、插入操作，选择链表是一个合适的选择，因此可使用STL提供的list数据结构。

list<IP>v;

 

第一步：将各种形式的IP前缀用自定义数据类型表示

输入的IP前缀包括标准型、省略后缀型以及省略长度型，我们需要将它们用struct IP统一表示，并逐条插入到list<IP>v数据结构中。IP前缀是由字符串存储的点分十进制，我们需要将省略的部分都补齐，最后进行统一处理。

//字符串转换成base进制的整数 
int stoi(string s,int base)
{
	int res=0;
	for(int i=0;i<s.length();i++)
	  res=res*base+s[i]-'0';
	return res;
}

//将读入的IP前缀用struct<IP>类型的数据表示，并插入到数据结构list<IP>v中 
void f(char str[])//str为字符串存储的点分十进制 
{
	vector<string>vec;
	char *sp=strtok(str,".");//先用"."对str进行分割，将分割的各个部分放在vec中 
	while(sp)
	{
		vec.push_back(sp);
		sp=strtok(NULL,".");
	}
	int num=vec.size();//形成了num个部分
	//确定是否有前缀，如果有一定是在最后一部分分，且含有"/"符号 
	string s=vec.back(),l="";//l存储表示长度的字符串 
	vec.pop_back();
	int pos=s.find("/");
	//含有"/"说明有长度 
	if(pos!=string::npos)
	{
		string ss=s;
		//将长度分割出来 
		s=ss.substr(0,pos);
		l=ss.substr(pos+1);
	}
	int len; 
	if(l=="")//如果l为空，说明没有长度，是省略长度型，那么它的长度为num*8
	  len=num*8;
	else//l不为空，即l表示长度，把它转换成十进制整数 
	  len=stoi(l,10);
	vec.push_back(s);//将最后一部分重新压入vec中 
	while(num<4)//如果不足4部分，就加0 
	{
		vec.push_back("0");
	    num++;
	}
	//将4个部分换成字符串存储的32位二进制 
	string res="";
	for(int i=0;i<vec.size();i++)
	{
		string t="00000000";
		int temp=stoi(vec[i],10);//转换成十进制整数 
		//将temp转换成二进制
		int k=7;
		while(temp)
		{
			t[k--]=temp%2+'0';
			temp/=2;
		}
		res+=t;
	} 
	//插入到数据结构list<IP>中 
	v.push_back(IP(res,len));
}

第一步之后大部分工作就OK了。

 

第二步：排序

	//1.排序 
	v.sort();

 

第三步：从小到大合并

问题的关键是如何判断b的匹配集是否为a的匹配集的子集，其实很简单，设a的前缀长度为len，那么如果b的前len个字符和a相同，则b的匹配集是a的匹配集的子集，否则不是。

//判断q的匹配集是否为p的匹配集的子集,len为p的前缀长度 
bool check(string p,string q,int len)
{
	if(len>p.length()||len>q.length()) return false;
 	for(int i=0;i<len;i++)
 	  if(p[i]!=q[i])
 	    return false;
 	return true;
}

 

第四步：同级合并

//3.同级合并 
	for(list<IP>::iterator cur=v.begin();cur!=v.end();)//遍历列表 
	{
		list<IP>::iterator next=cur;
		next++;
		if(next==v.end())
		  break; 
		  
		IP p1=*cur; //当前元素 
		IP p2=*next;//下一个元素 
		//p1.len==p2.len且p1前缀长度减一后依然合法（只要p1.s[p1.len-1]=0就是合法的） 
		if(p1.len==p2.len&&p1.len>0&&p1.s[p1.len-1]=='0')
		{
			IP tmp=p1;
			tmp.len--;
			//能合并 
			if(check(tmp.s,p2.s,tmp.len))
		    {
			  v.erase(next);//删除下一个元素 
			  *(cur)=tmp;//删除当前元素，并插入tmp，等价于将当前元素的值变为tmp 
			  if(cur!=v.begin())//如果cur所指的不是第一个元素，那么就要从cur的前一个元素考虑，就cur-- 
			    cur--;
		    }
		    //不能合并，直接考虑下一个元素 
		    else
		      cur++;
		}
		//减一后不合法，直接考虑下一个元素 
		else
		  cur++; 
	}

 

第五步：输出

由于输出形式为点分十进制，因此需要一个打印函数

//打印输出 
void print(string s,int len)
{
	string s1=s.substr(0,8);
	string s2=s.substr(8,8);
	string s3=s.substr(16,8);
	string s4=s.substr(24,8);
	cout<<stoi(s1,2)<<"."<<stoi(s2,2)<<"."<<stoi(s3,2)<<"."<<stoi(s4,2)<<"/"<<len<<endl;
}
	//输出 
	for(list<IP>::iterator cur=v.begin();cur!=v.end();cur++)
	  print((*cur).s,(*cur).len);

至此，问题解决！！！

 

C++程序

第一版（时间：2019.1.27）

#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<vector>
#include<list>

using namespace std;

struct IP{
	IP(string s,int len):s(s),len(len){}
	string s;
	int len;
	//以IP地址为第一关键字，前缀长度为第二关键字，从小到大排序
	bool operator <(const IP &a)const
	{
		return s==a.s?(len<a.len):(s<a.s);
	}
};

list<IP>v;


//字符串转换成base进制的整数 
int stoi(string s,int base)
{
	int res=0;
	for(int i=0;i<s.length();i++)
	  res=res*base+s[i]-'0';
	return res;
}

//将读入的IP前缀用struct<IP>类型的数据表示，并插入到数据结构list<IP>v中 
void f(char str[])//str为字符串存储的点分十进制 
{
	vector<string>vec;
	char *sp=strtok(str,".");//先用"."对str进行分割，将分割的各个部分放在vec中 
	while(sp)
	{
		vec.push_back(sp);
		sp=strtok(NULL,".");
	}
	int num=vec.size();//形成了num个部分
	//确定是否有前缀，如果有一定是在最后一部分分，且含有"/"符号 
	string s=vec.back(),l="";//l存储表示长度的字符串 
	vec.pop_back();
	int pos=s.find("/");
	//含有"/"说明有长度 
	if(pos!=string::npos)
	{
		string ss=s;
		//将长度分割出来 
		s=ss.substr(0,pos);
		l=ss.substr(pos+1);
	}
	int len; 
	if(l=="")//如果l为空，说明没有长度，是省略长度型，那么它的长度为num*8
	  len=num*8;
	else//l不为空，即l表示长度，把它转换成十进制整数 
	  len=stoi(l,10);
	vec.push_back(s);//将最后一部分重新压入vec中 
	while(num<4)//如果不足4部分，就加0 
	{
		vec.push_back("0");
	    num++;
	}
	//将4个部分换成字符串存储的32位二进制 
	string res="";
	for(int i=0;i<vec.size();i++)
	{
		string t="00000000";
		int temp=stoi(vec[i],10);//转换成十进制整数 
		//将temp转换成二进制
		int k=7;
		while(temp)
		{
			t[k--]=temp%2+'0';
			temp/=2;
		}
		res+=t;
	} 
	//插入到数据结构list<IP>中 
	v.push_back(IP(res,len));
}

//判断q的匹配集是否为p的匹配集的子集,len为p的前缀长度 
bool check(string p,string q,int len)
{
	if(len>p.length()||len>q.length()) return false;
 	for(int i=0;i<len;i++)
 	  if(p[i]!=q[i])
 	    return false;
 	return true;
} 

//打印输出 
void print(string s,int len)
{
	string s1=s.substr(0,8);
	string s2=s.substr(8,8);
	string s3=s.substr(16,8);
	string s4=s.substr(24,8);
	cout<<stoi(s1,2)<<"."<<stoi(s2,2)<<"."<<stoi(s3,2)<<"."<<stoi(s4,2)<<"/"<<len<<endl;
}

int main()
{
	char s[200];
	int n;
	scanf("%d",&n);
	while(n--)
	{
		scanf(" %s",s);
		f(s);
	}
	//1.排序 
	v.sort();
	//2.从小到大合并 
	for(list<IP>::iterator cur=v.begin();cur!=v.end();)//遍历列表 
	{
		list<IP>::iterator next=cur;
		next++; 
		if(next==v.end())
		  break; 
		  
		IP p1=*cur;//当前元素 
		IP p2=*next;//下一个元素 
		if(check(p1.s,p2.s,p1.len))
		{//如果p2的匹配集是p1的匹配集的子集,就删除p2，即 next所指元素 
			v.erase(next);
		}
		else//否则直接考虑下一个元素 
		  cur++;
	}	
	//3.同级合并 
	for(list<IP>::iterator cur=v.begin();cur!=v.end();)//遍历列表 
	{
		list<IP>::iterator next=cur;
		next++;
		if(next==v.end())
		  break; 
		  
		IP p1=*cur; //当前元素 
		IP p2=*next;//下一个元素 
		//p1.len==p2.len且p1前缀长度减一后依然合法（只要p1.s[p1.len-1]=0就是合法的） 
		if(p1.len==p2.len&&p1.len>0&&p1.s[p1.len-1]=='0')
		{
			IP tmp=p1;
			tmp.len--;
			//能合并 
			if(check(tmp.s,p2.s,tmp.len))
		    {
			  v.erase(next);//删除下一个元素 
			  *(cur)=tmp;//删除当前元素，并插入tmp，等价于将当前元素的值变为tmp 
			  if(cur!=v.begin())//如果cur所指的不是第一个元素，那么就要从cur的前一个元素考虑，就cur-- 
			    cur--;
		    }
		    //不能合并，直接考虑下一个元素 
		    else
		      cur++;
		}
		//减一后不合法，直接考虑下一个元素 
		else
		  cur++; 
	}
	//输出 
	for(list<IP>::iterator cur=v.begin();cur!=v.end();cur++)
	  print((*cur).s,(*cur).len);
	return 0; 
}

 

第二版（时间：2019.3.4）

#include<iostream>
#include<list>
#include<string>

using namespace std;

struct IP{
	string ip;//ip地址 
	int len;//前缀长度 
	IP(){}
	//以IP地址为第一关键字，前缀长度为第二关键字，从小到大排序
	IP(string ip,int len):ip(ip),len(len){}
    bool operator <(const IP &a)const
    {
    	return ip==a.ip?(len<a.len):(ip<a.ip);
	}
};

list<IP>l;

//将整数n(0<=n<256)化成二进制数 
string itos(int  n)
{
	string res="00000000";
	int k=7;
	while(n)
	{
		res[k--]=n%2+'0';
		n/=2;
	}
	return res;
}

//读取ip前缀 
void read()
{
	string ip="";
	char ch;
	int len=0,k=0,val=0;//k记录小数点的数量 
	bool flag=false;
	while((ch=getchar())!='\n')//读入'\n'退出 
	{
		if(ch=='.')//读入小数点 
		{
			k++;
			ip+=itos(val);
			val=0; 
		}
		else if(ch=='/')
		{
			ip+=itos(val);
			val=0;
			flag=true;
		}
		else
		  val=val*10+ch-'0';
	}
	len=(flag?val:(k+1)*8);//如果flag=true len就等于val，否则就是省略长度型 
	if(!flag) ip+=itos(val);//flag=false,表示是省略后缀型，那么val就是ip前缀的一部分 
	while(k<3)//补齐 
	{
		ip+=itos(0);
		k++;
	}
	l.insert(l.end(),IP(ip,len));//将元素插入list中 
}

int main()
{
	int n,i;
	scanf("%d",&n);
	getchar();//读取空白符 
	for(int i=1;i<=n;i++)//读入n个ip前缀 
	  read();
	l.sort();//第一步：排序 
	for(list<IP>::iterator cur=l.begin(),next;cur!=l.end();)//第二步：从小到大合并 
	{
		next=cur;
		next++;
		if(next==l.end()) break;//如果cur已经是最后一个元素了就退出 
		for(i=0;i<cur->len;i++)
		  if(cur->ip[i]!=next->ip[i])
		    break;
		if(i==cur->len)//如果next是cur的子集，就删除next 
		  l.erase(next);
		else 
		  cur++;//查看下一个元素 
	}
	for(list<IP>::iterator cur=l.begin(),next;cur!=l.end();)//第三步：统计合并 
	{
		next=cur;
		next++;
		if(next==l.end()) break;
		if(cur->len==next->len&&cur->len>0&&cur->ip[cur->len-1]=='0')
		{
			for(i=0;i<cur->len-1;i++)
			  if(cur->ip[i]!=next->ip[i])
			    break;
			if(i==cur->len-1)
			{
				l.erase(next);
				cur->len-=1;
				if(cur!=l.begin())//如果cur的前面还有元素，则让cur-- 
				{
					cur--;
					continue;
				}
			}
		}
		cur++;//考虑下一个元素 
	}
	//输出 
	for(list<IP>::iterator cur=l.begin();cur!=l.end();cur++)
	{
		for(i=7;i<32;i+=8)
		{
			int temp=0;
			for(int j=i-7;j<=i;j++)
			  temp=temp*2+cur->ip[j]-'0';//注意权值为2 
			printf("%d",temp);
			if(i!=31) printf(".");
		}
		printf("/%d\n",cur->len);
	}
	return 0;
}

 

SongBai1997
关注
专栏目录
CCF计算机软件能力认证试题练习：201812-3 CIDR合并
WINGREZ‘S BLOG
01-23 4194
CIDR合并 来源：CCF 标签： 参考资料： 相似题目： 题目 输入 输入的第一行包含空格分隔的三个正整数 r、y、g，表示红绿灯的设置。这三个数均不超过 106。 输入的第二行包含一个正整数 n，表示小明总共经过的道路段数和路过的红绿灯数目。 接下来的 n 行，每行包含空格分隔的两个整数 k、t。k=0 表示经过了一段道路，将会耗时 t 秒，此处 t 不超过 106；k=1、2、3 时...
CCF认证 201812-3CIDR合并-带注释
鹏鹏的博客
03-03 866
/* 1、排序：IP作为第一关键字，前缀长度作为第二关键字 2、从小到大合并：考虑相邻元素，但是需要注意，要知道他们的表示范围，要能判断包含关系 3、同级合并： 要能求并集。 */ #include&lt;bits/stdc++.h&gt; typedef long long ll; using namespace std; //存储结构 typedef struct { string ip=...
CCF201812-3 CIDR合并（100分）【位运算+文本】
海岛Blog
08-18 852
试题编号： 201812-3 试题名称： CIDR合并 时间限制： 1.0s 内存限制： 512.0MB 样例输入 2 1 2 样例输出 1.0.0.0/8 2.0.0.0/8 样例输入 2 10/9 10.128/9 样例输出 10.0.0.0/8 样例输入 2 0/1 128/1 样例输出 0.0.0.0/0 问题链接：CCF202104-1 灰度直方图 问题简述：（略） 问题分析：按题意进行处理即可，有2次合并处理。 程序说明：（略） 参考链接：（略） 题记：位运算巧妙，输入文本处理简洁。 A
什么是IP-无类别域间路由（CIDR）
最新发布
liangkk的博客
07-27 534
CIDR的核心思想是将IP地址划分为两部分：网络前缀和主机标识符。网络前缀用于标识IP地址所属的网络，而主机标识符则用于标识网络中的具体主机。CIDR使用“IP地址/前缀长度”的表示方法来标识一个IP地址块，其中IP地址是网络的起始地址，前缀长度表示了网络前缀中包含的连续比特数。
CCF 201812-3 CIDR合并 注释非常详细
qq_43749262的博客
09-01 292
ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzQ5MjYy,size_16,color_FFFFFF,t_70#pic_center) 题记 这题用位运算可以很好的解决，但是注意一个坑:>>运算符的优先级比较低，如果不注意可能算的顺序跟你的思路不一致，所以没有把握就多加括号!!!多加括号!!!注释快能顶过代码行数了，就不赘述了。 #include <iostream> #in..
CCF 201812-3CIDR合并
Onwaier的博客
11-08 336
题目描述 题解 ip的存储用一个结构体，int 数组存储ip，len是ip的前缀长度。 第一步：ip排序就是结构体排序，可自定义cmp或重载operator <。 第二步：从大到小合并。相邻ip，只有在前一个len1小于后一个len2且两个ip的前len1位异或等于0才表示后一个是前一个的子集。 第三步：同级归并，相邻ip只有两个前缀长度相等且前len1位异或等于1表示它俩可以合并...
CCF 201812-3 CIDR合并
昂昂累世士的博客
02-19 1584
  样例输入 2 1 2 样例输出 1.0.0.0/8 2.0.0.0/8 样例输入 2 10/9 10.128/9 样例输出 10.0.0.0/8 样例输入 2 0/1 128/1 样例输出 0.0.0.0/0 PS：又到了ccf最烦人的第三题大模拟，往往耗费几小时还得不到满分，代码越简洁越不容易扣分。 分析： 本题较以往的大模拟更为复杂，要求我...
ccf 201812-3 CIDR合并(100分)
jinduo16的博客
01-31 1990
提交后得100分的C++程序如下: #include&lt;iostream&gt; #include&lt;string&gt; #include&lt;cstring&gt; #include&lt;vector&gt; #include&lt;algorithm&gt; #include&lt;list&gt; using namespace std; int pow[]={128,64,...
CCF CIDR合并【201812-3】【python解法】
q19149的博客
08-11 363
题目 http://118.190.20.162/view.page?gpid=T82 思路 没有思路，按照题目描述就行…关键是得读懂题目 代码 import re def dvismerge(ip1:tuple,ip2:tuple) -> bool: # 大小合并 # True 1 > 2 minlen = min(ip1[1], ip2[1]) ...
CCF认证 2018-12 CIDR合并
wl16wzl的博客
02-12 6631
题目挺长，但是说的挺清楚，最后还直接给出了算法，直接按照给出的算法就能得出答案 我们只需要处理输入和输出，将格式转化为自己熟悉的格式方便接下来的处理即可 这次的第三题对时间卡的挺紧，在同级合并那里我用了链表优化，不然会超时 还有一开始我用string保存ip，结果最后一组数据过不去 之后改用了整型保存，再用特定的方法处理，比string快很多 #include&lt;iostream&...
201812-3 CIDR合并
Yoc Lu
03-06 604
201812-3 CIDR合并 题解思路 计算包含IP前缀数目最少的等价前缀列表 第一步：排序 将所有IP前缀进行排序，以其IP地址为第一关键字，以前缀长度为第二关键字从小到大排序，形成一个列表。 第二步：从小到大合并 从头到尾扫描该列表，依次考虑其相邻的两个元素a,b：如果b的匹配集是a的匹配集的子集，则将b从列表中移除。如果b后仍有元素c，则此时a与c变为相邻的元素，应当继续考虑这对新的相邻...
CCF 201812-3 CIDR合并--vector排序+list合并
Slifer the Sky Dragon
02-07 203
思路： 如题，用vector存储ip排序，之后再装入list链表中进行插入删除，可避免因大量插入删除而导致的运行超时。 易错点： 之前发布的文章有详细说明，还有一些自己编写的例子，有需要的可以查阅使用。 链接： https://blog.csdn.net/qq_26873647/article/details/104188744. 关于stl标准模板库中的list容器具体函数功能和使用可以参考： ...
【CCF 201812-3】CIDR合并（链表，位运算）
Salmon_lee的博客
02-15 334
写在前面 本题考查的是对STL::list的熟练运用，以及对位运算的思考；思路在题目中给出的提示当中已经非常清晰。 解题思路 将输入转化为list<前缀IP> struct Prefix { vector<unsigned> ip; int len; } 这里要分两种特殊情况：省略后缀型和省略长度型； 我们使用的技术包括：字符串流stringstream、子串...
CCF201812-3,CIDR合并
sailist的记录站
08-13 222
嗯，折腾了一上午，终于过了，这个题说难也难，说简单也简单，如果看着分数调bug满分还是挺容易的，但是考试时候一次性通过的可能就比较低了。。。 要写出来主要是要意识到两点，一个是从小到大合并的时候，要比较的是小的那个ip的前缀长度范围内两个ip是否相等，如果前缀长度范围内相等，那么另外一个一定是子集；二是同级合并的时候，存在递归合并的可能性，比如先一个23，然后两个24，两个24合并之后会生成一个2...
ccf 2018-12-3 CIDR合并
qq_41914302的博客
01-18 1144
这是第一次参加ccf考试，当时考场上只得了50分，思路有点不清晰，回来整理了一下思路 其实考试题目都给了思路了 我的思路就是一个结构体，记录IP地址四段中的每一段的大小，还有一个len记录IP地址的长度 排序操作使用sort函数自动 从小到大合并使用另一个list来存储 统计合并就像进栈出栈一样 其实这两个我都想用list直接删除的好，但并不会这种操作 下面是满分代码，附带了两个...
CCF认证 201812-3 CIDR合并
策马奔腾向前冲
06-06 290
#include <iostream> #include <algorithm> #include <cstring> #include <vector> using namespace std; const int N = 100005; int cnt; struct IP{ string info; unsigned int val; int a[4], len; bool operator< (const IP.
ccf csp 201812-3 CIDR合并
lalala_HFUT的博客
02-05 664
我使用了to_string()函数，所以提交的时候，请选择c++11标准，不然会出现编译报错。 先附上80分代码，之后再补完整版。 #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;set&gt; #include&lt;string&gt; #include&lt;algorithm&gt; #include&lt;cc...
CCF CIDR合并
Glasier的博客
02-21 787
按照题目所给的方法就可以完成。 #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;string&gt; using namespace std; int mask[9]={0,128,192,224,240,248,252,254,255}; //掩码 struct IP_add{ int a[...
ccf201812-2
10-12
题目描述： 给定一个长度为 n 的序列 a1,a2,…,an，你需要求出一个最长的连续子序列，使得这个子序列中任意两个相邻元素的差的绝对值都为 1。 输入格式： 第一行包含整数 n。 第二行包含 n 个整数 a1,a2,…,an。...3
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值