CIDR合并（CCF 201812-3）

最新推荐文章于 2020-08-04 19:11:51 发布
最新推荐文章于 2020-08-04 19:11:51 发布
阅读量134 收藏
点赞数
分类专栏： 算法刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42319408/article/details/103513613
版权

最终的100分代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

class IP{
	int[] value;
	int mask;
	
	public IP() {
		this.value = new int[4];
		for(int i=0;i<4;i++) {
			this.value[i]=0;
		}
	}

	@Override
	public String toString() {
		return value[0]+"."+value[1]+"."+value[2]+"."+value[3]+"/"+mask;
	}

}

public class Main {

	public static void main(String[] args) throws IOException{
		
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		
		int n = Integer.parseInt(bf.readLine());
		String rawIp;
		// 转换为标准形式
		ArrayList<IP> ipArr = new ArrayList<IP>();
		for(int i=0;i<n;i++) {
			rawIp = bf.readLine();
			ipArr.add(toIp(rawIp));
		}
		
		// 排序
		Collections.sort(ipArr, new Comparator<IP>() {
			@Override
			public int compare(IP o1,IP o2) {
				int flag = greaterThan(o1,o2);
				if(flag==0) {
					// 前缀长度
					if(o1.mask>o2.mask) {
						flag = 1;
					}else {
						flag = -1;
					}
				}
				return flag;
			}
		});
		
		IP[] newArr = new IP[ipArr.size()];            // 转为数组
		boolean[] delete = new boolean[ipArr.size()];  // 是否被删除
		ipArr.toArray(newArr);
		
		int relation;
		int right = 0;
		int len = newArr.length;
		boolean flag = false;
		for(int i=0;i<len-1;) {
			// 删除跳过
			if(delete[i]) {
				i++;
				continue;
			}

			// 找到右边一个
			do {
				right++;
				if(right>=len) {
					flag = true;
					break;
				}
			}while(delete[right] || right==i);
			if(flag) {
				break;
			}

			relation = relation(newArr[i],newArr[right]);

			if(relation==1) {
				// 包含
//				System.out.println("吞 "+newArr[i]+" <- "+newArr[right]+" 删"+right);
				delete[right] = true;
			}else if(relation==2) {
				// 合并
//				System.out.println("合 "+newArr[i]+" & "+newArr[right]+" 删"+right);
				newArr[i].mask -= 1;
				delete[right] = true;
				if(i>0) {
					right=i-1;
					i--;
					while(delete[i]) {
						i--;
					}
				}
			}else {
				i++;
			}
		}

		for(int i=0;i<newArr.length;i++) {
			if(!delete[i]) {
				System.out.println(newArr[i]);
			}
		}
	}
	
	// 包含返回1，合并返回2
	public static int relation(IP a,IP b) {

		if(a.mask<=b.mask) {
			int part = (a.mask-1)/8;
			int digit = a.mask - part*8;
			
			for(int i=0;i<part;i++) {
				if(a.value[i]!=b.value[i]) {
					return 0;
				}
			}
			
			int ap = a.value[part] >> (8-digit);
			int bp = b.value[part] >> (8-digit);

			if(ap==bp) {
				return 1;
			}
			
			if(a.mask==b.mask && bp-ap==1 && ((ap>>1)==(bp>>1))) {
				return 2;
			}

		}
		
		return 0;
	}
	
	// 比较两个IP
	public static int greaterThan(IP o1,IP o2) {	
		int flag = 1;
		
		int a = (o1.value[0]<<8) + o1.value[1] - (o2.value[0]<<8) - o2.value[1];
		
		if(a>0) {
		}else if(a<0) {
			flag = -1;
		}else {
			int b = (o1.value[2]<<8) + o1.value[3] - (o2.value[2]<<8) - o2.value[3];
			flag = b;
		}
		
		return flag;
	}
	
	// 处理输入的ip
	public static IP toIp(String rawIp) {
		int split = rawIp.indexOf('/');
		String value = rawIp;
		int mask = 0;
		// 含有'/'，分割
		if(split>0) {
			value = rawIp.substring(0, split);
			mask = Integer.parseInt(rawIp.substring(split+1, rawIp.length()));
		}

		IP ip = new IP();
		ip.mask = mask;
		
		// 处理地址
		for(int i=0;i<4;i++) {
			if(value.contains(".")) {
				// 继续分割
				split = value.indexOf('.');
				ip.value[i] = Integer.parseInt(value.substring(0,split));
				value = value.substring(split+1,value.length());
			}else if(value.length()>0) {
				// 只有数字
				ip.value[i] = Integer.parseInt(value);
				value = "";
				// 若无前缀长度
				if(ip.mask==0) {
					ip.mask = (i+1)*8;
				}
			}else {
				// 空
				ip.value[i] = 0;
			}
		}
		
		return ip;
	}
	
}

踩的两个最大的坑：

  1. 同级合并的细节
  2. 超时

悲惨的改代码过程：

第一步，处理不同格式ip输入
测试输入

7
101.6.6.0/24
101.6.6/23
101/8
1/32
101.6.6.0
101.6
1

标准形式

101.6.6.0/24
101.6.6.0/23
101.0.0.0/8
1.0.0.0/32
101.6.6.0/32
101.6.0.0/16
1.0.0.0/8

第二步，排序

1.0.0.0/8
1.0.0.0/32
101.0.0.0/8
101.6.0.0/16
101.6.6.0/23
101.6.6.0/24
101.6.6.0/32

此时提交可通过测试点1-4，有60分

下一步，从小到大合并，80分

最后一步，同级合并

测试1

输入

4
206.0.68.0/25
206.0.68.128/25
206.0.69.0/25
206.0.69.128/25

输出

206.0.68.0/23
测试2

输入

12
206.0.68.0/25
206.0.68.128/25
206.0.69.0/25
206.0.69.128/25
206.0.70.0/26
206.0.70.64/26
206.0.70.128/26
206.0.70.192/26
206.0.71.128/26
206.0.71.64/26
206.0.71.192/26
206.0.71.0/26

输出

206.0.68.0/22
测试3

输入

3
206.0.71.64/25
206.0.71.192/26
206.0.71.0/26

这种也可以合并，不过似乎不用考虑？

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

class IP{
	int[] value;
	int mask;
	
	public IP() {
		this.value = new int[4];
		for(int i=0;i<4;i++) {
			this.value[i]=0;
		}
	}

	@Override
	public String toString() {
		return value[0]+"."+value[1]+"."+value[2]+"."+value[3]+"/"+mask;
	}

}

public class Main {

	public static void main(String[] args) {
		
		Scanner s = new Scanner(System.in);
		
		int n = Integer.parseInt(s.nextLine());
		String rawIp;
		
		// 转换为标准形式
		ArrayList<IP> ipArr = new ArrayList<IP>();
		for(int i=0;i<n;i++) {
			rawIp = s.nextLine();
			ipArr.add(toIp(rawIp));
		}
		
		// 排序
		Collections.sort(ipArr, new Comparator<IP>() {
			@Override
			public int compare(IP o1,IP o2) {
				int flag = greaterThan(o1,o2);
				if(flag==0) {
					// 前缀长度
					if(o1.mask>o2.mask) {
						flag = 1;
					}else {
						flag = -1;
					}
				}
				return flag;
			}
		});
		
		// 从小到大合并
		for(int i=0;i<ipArr.size()-1;i++) {
			if(contain(ipArr.get(i),ipArr.get(i+1))) {
				ipArr.remove(i+1);
			}
		}
		
		// 同级合并
		for(int i=0;i<ipArr.size()-1;i++) {
			if(canMerge(ipArr.get(i),ipArr.get(i+1))) {
				ipArr.get(i).mask -= 1;
				ipArr.remove(i+1);
				if(i>0) {
					i -= 2;
				}
			}
		}
		
		for(int i=0;i<ipArr.size();i++) {
			System.out.println(ipArr.get(i));
		}
	}
	
	// 检查是否可以合并
	public static boolean canMerge(IP a,IP b) {
		boolean flag = false;
		
		if(a.mask==b.mask) {
			int part = (a.mask-1)/8;
			int digit = a.mask - part*8;
			
			IP newA = new IP();
			for(int i=0;i<4;i++) {
				newA.value[i] = a.value[i];
			}
			newA.value[part] += 1<<(8-digit);
			
			if(greaterThan(newA,b)==0) {
				flag=true;
			}
		}
		
		return flag;
	}
	
	// 检查a是否包含b
	public static boolean contain(IP a,IP b) {
		boolean flag = false;
		
		if(a.mask<=b.mask) {
			IP aMax = getMaxIp(a);
			IP bMax = getMaxIp(b);
			
			if(greaterThan(b,a)>=0 && greaterThan(aMax,bMax)>=0) {
				flag = true;
			}
		}
		
		return flag;
	}
	
	// 比较两个IP
	public static int greaterThan(IP o1,IP o2) {
		int flag = 1;
		int a = (o1.value[0]*256 + o1.value[1]) - (o2.value[0]*256 + o2.value[1]);
		if(a>0) {
		}else if(a<0) {
			flag = -1;
		}else {
			int b = (o1.value[2]*256 + o1.value[3]) - (o2.value[2]*256 + o2.value[3]);
			if(b<0){
				flag = -1;
			}else if(b==0) {
				flag = 0;
			}
		}
		return flag;
	}
	
	// 根据mask获取最大IP
	public static IP getMaxIp(IP ip) {
		IP maxIP = new IP();
		
		int ms = 32-ip.mask;
		int[] m = new int[4];
		for(int i=3;i>=0;i--) {
			if(ms>=8) {
				m[i]=8;
				ms-=8;
			}else {
				m[i]=ms;
				break;
			}
		}
		
		for(int i=0;i<4;i++) {
			maxIP.value[i] = ip.value[i] + (1<<m[i]) - 1;
		}
		
		return maxIP;
	}
	
	// 处理输入的ip
	public static IP toIp(String rawIp) {
		int split = rawIp.indexOf('/');
		String value = rawIp;
		int mask = 0;
		// 含有'/'，分割
		if(split>0) {
			value = rawIp.substring(0, split);
			mask = Integer.parseInt(rawIp.substring(split+1, rawIp.length()));
		}

		IP ip = new IP();
		ip.mask = mask;
		
		// 处理地址
		for(int i=0;i<4;i++) {
			if(value.contains(".")) {
				// 继续分割
				split = value.indexOf('.');
				ip.value[i] = Integer.parseInt(value.substring(0,split));
				value = value.substring(split+1,value.length());
			}else if(value.length()>0) {
				// 只有数字
				ip.value[i] = Integer.parseInt(value);
				value = "";
				// 若无前缀长度
				if(ip.mask==0) {
					ip.mask = (i+1)*8;
				}
			}else {
				// 空
				ip.value[i] = 0;
			}
		}
		
		return ip;
	}
	
}

结果：得分80，时间使用1.39s，空间使用171.7MB

把Scanner改成BufferedReader
结果：得分80，时间使用1.234s，空间使用103.4MB

难道是超时
心好痛

修改从小到大合并的方法

一些测试数据

10.0/9
10.28/18

10.0/9
10.1/9

10.0/1
10.0/32

101.6.6.0/24
101.6.7.0/24

101.6.6.0/24
101.6.6.128/24

结果：得分80，时间使用890ms，空间使用95.19MB

快了一些，但是还是80分，说明前面不是超时的问题，还是同级合并有问题

改啊改啊改

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

class IP{
	int[] value;
	int mask;
	
	public IP() {
		this.value = new int[4];
		for(int i=0;i<4;i++) {
			this.value[i]=0;
		}
	}

	@Override
	public String toString() {
		return value[0]+"."+value[1]+"."+value[2]+"."+value[3]+"/"+mask;
	}

}

public class Main {

	public static void main(String[] args) throws IOException{
		
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		
		int n = Integer.parseInt(bf.readLine());
		String rawIp;
		
		// 转换为标准形式
		ArrayList<IP> ipArr = new ArrayList<IP>();
		for(int i=0;i<n;i++) {
			rawIp = bf.readLine();
			ipArr.add(toIp(rawIp));
		}
		
		// 排序
		Collections.sort(ipArr, new Comparator<IP>() {
			@Override
			public int compare(IP o1,IP o2) {
				int flag = greaterThan(o1,o2);
				if(flag==0) {
					// 前缀长度
					if(o1.mask>o2.mask) {
						flag = 1;
					}else {
						flag = -1;
					}
				}
				return flag;
			}
		});
		
		int relation;
		for(int i=0;i<ipArr.size()-1;) {
			relation = relation(ipArr.get(i),ipArr.get(i+1));
			if(relation==1) {
//				System.out.println("吞 "+ipArr.get(i)+" <- "+ipArr.get(i+1));
				ipArr.remove(i+1);
			}else if(relation==2) {
//				System.out.println("合 "+ipArr.get(i)+" & "+ipArr.get(i+1));
				ipArr.get(i).mask -= 1;
				ipArr.remove(i+1);
				if(i>0) {
					i--;
				}
			}else {
				i++;
			}
		}

		for(int i=0;i<ipArr.size();i++) {
			System.out.println(ipArr.get(i));
		}
	}
	
	// 包含返回1，合并返回2
	public static int relation(IP a,IP b) {
		
		if(a.mask<=b.mask) {
			int part = (a.mask-1)/8;
			int digit = a.mask - part*8;
			
			for(int i=0;i<part;i++) {
				if(a.value[i]!=b.value[i]) {
					return 0;
				}
			}
			
			int ap = a.value[part] >> (8-digit);
			int bp = b.value[part] >> (8-digit);
			
			if(ap==bp) {
				return 1;
			}
			
			if(a.mask==b.mask && bp-ap==1 && ((ap>>1)==(bp>>1))) {
				return 2;
			}

		}
		
		return 0;
	}
	
	// 比较两个IP
	public static int greaterThan(IP o1,IP o2) {
		int flag = 1;
		int a = (o1.value[0]*256 + o1.value[1]) - (o2.value[0]*256 + o2.value[1]);
		if(a>0) {
		}else if(a<0) {
			flag = -1;
		}else {
			int b = (o1.value[2]*256 + o1.value[3]) - (o2.value[2]*256 + o2.value[3]);
			if(b<0){
				flag = -1;
			}else if(b==0) {
				flag = 0;
			}
		}
		return flag;
	}
	
	// 处理输入的ip
	public static IP toIp(String rawIp) {
		int split = rawIp.indexOf('/');
		String value = rawIp;
		int mask = 0;
		// 含有'/'，分割
		if(split>0) {
			value = rawIp.substring(0, split);
			mask = Integer.parseInt(rawIp.substring(split+1, rawIp.length()));
		}

		IP ip = new IP();
		ip.mask = mask;
		
		// 处理地址
		for(int i=0;i<4;i++) {
			if(value.contains(".")) {
				// 继续分割
				split = value.indexOf('.');
				ip.value[i] = Integer.parseInt(value.substring(0,split));
				value = value.substring(split+1,value.length());
			}else if(value.length()>0) {
				// 只有数字
				ip.value[i] = Integer.parseInt(value);
				value = "";
				// 若无前缀长度
				if(ip.mask==0) {
					ip.mask = (i+1)*8;
				}
			}else {
				// 空
				ip.value[i] = 0;
			}
		}
		
		return ip;
	}
	
}

呜呜呜90了
终于把同级合并改对了

看看还能不能快一点

把最后的遍历从链表改成了数组，成功！

awsl

_CoCoNutNut_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cidr-tools:与IPv4和IPv6 CIDR网络列表配合使用的工具
05-08
$ npm i cidr-tools 例子 const cidrTools = require ( 'cidr-tools' ) ; cidrTools . merge ( [ '1.0.0.0/24' , '1.0.1.0/24' ] ) ; //=> ['1.0.0.0/23'] cidrTools . exclude ( [ '::1/127' ] , [ '::1/128' ] ) /...
CCF201812-3 CIDR合并
逐梦者
01-27 7038
试题编号： 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 样例输出 1...
CCF 201812-3 CIDR合并
昂昂累世士的博客
02-19 1553
  样例输入 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最烦人的第三题大模拟，往往耗费几小时还得不到满分，代码越简洁越不容易扣分。 分析： 本题较以往的大模拟更为复杂，要求我...
CIDR的IP地址的表示与划分方法
热门推荐
han156的博客
09-03 9万+
早期的ip地址划分： 最初设计互联网络时，为了便于寻址以及层次化构造网络，每个IP地址包括两个标识码（ID），即网络ID和主机ID。同一个物理网络上的所有主机都使用同一个网络ID，网络上的一个主机（包括网络上工作站，服务器和路由器等）有一个主机ID与其对应。 IP地址是一个32位的二进制字符，为了方便人类的记忆，所以，通常人们会将二进制的IP地址表示成十进制的格式，没每八位分割一下，即分成四段...
CCF认证 csp第15次 第3题 CIDR合并 （java 100分）
xuzonghao的博客
04-16 556
开始搜的题解是90分的，因为对java不熟悉，就从里面学了很多东西，indexOf，split，还有处理合并的方法。 最后一个点过不了，我开始我的优化之路。 题解的排序是插入排序，这样是O(n*n*log(n))，我用sort，就可以降到O(n*log(n))。 在合并的过程中，题解的方法模拟的时候用remove操作，这样加上本来需要O(n)的扫描时间，就是O(n*n)复杂度。 把它优化成...
解析CIDR表示的IP段表示的范围
lihaiyong92的博客
12-04 1万+
需求：给定一个ip：172.28.68.0和一个CIDR格式的ip配置项ipConfig="172.28.64.0/22,172.28.72.11;172.16.0.0/12,172.28.80.27"，判断该IP是在哪个cidr表示的地址段，并获取cidr格式后面的一个ip地址。      首先，要对cidr表示法要有所了解。      例如：172.28.64.0/22表示前22位不变，用1表...
cidr-js-noflo
05-31
CIDR-RANGE-NOFLO
IBlockator:互联网 IP / CIDR 表拦截器-开源
06-01
脚本下载并自动应用 ipset 和 iptables 规则来阻止几个大的 IP/CIDR 列表。
cidr-split:CIDR的拆分设施
05-15
npm install cidr-split 用法 要运行以下示例，请运行： npm run readme "use strict" ; const CIDR = require ( "../index.js" ) ; console . log ( "Split 10.0.0.0/16 into two and print out" ) ; CIDR . ...
Net-CIDR-Lite-0.20.tar.gz_CIDR_lite
09-23
net cidr lite 相关源包算法
ccf csp 201812-3 CIDR合并
lalala_HFUT的博客
02-05 650
我使用了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计算机软件能力认证试题练习：201812-3 CIDR合并
WINGREZ‘S BLOG
01-23 4169
CIDR合并 来源：CCF 标签： 参考资料： 相似题目： 题目 输入 输入的第一行包含空格分隔的三个正整数 r、y、g，表示红绿灯的设置。这三个数均不超过 106。 输入的第二行包含一个正整数 n，表示小明总共经过的道路段数和路过的红绿灯数目。 接下来的 n 行，每行包含空格分隔的两个整数 k、t。k=0 表示经过了一段道路，将会耗时 t 秒，此处 t 不超过 106；k=1、2、3 时...
CIDR合并
weixin_43731369的博客
09-05 313
参考CCF认证2018123-CIDR合并 这脑子是真滴强 ！！ 这道题不需要考虑算法设计,题目中给出如下实现要求的步骤，只需要具体实现。 代码用到大量C++ STL的知识 ,看懂至少要知道： 1.Pair pair 是一个比较简单的模板类型，它只有两个 public 数据成员 first 和 second 定义:pair<int ,char> p; p = {5,'5'}...
IP地址介绍及VLSM、CIDR
qq_38135115的博客
08-04 3778
2-IP地址介绍及VLSM A类 10.0.0.0~10.255.255.255 B类 172.16.0.0~172.31.255.255 C类 192.168.0.0~192.168.255.255 D类 224.0.0.1—239.255.255.254，用作组播地址。 E类 240.0.0.1-255.255.255.254，用于科学研究。 一、IPv4编址方案 IP地址由32位二进制数组成，这些位被划分为4个字节，中间用“.”号隔开，每组8位，以十进制数形式表示。 分为网络地址和主机地址
CIDR
weixin_33897722的博客
04-30 1324
CIDR的介绍： CIDR（Classless Inter-Domain Routing，无类域间路由选择）它消除了传统的A类、B类和C类地址以及划分子网的概念，因而可以更加有效地分配IPv4的地址空间。它可以将好几个IP网络结合在一起，使用一种无类别的域际路由选择算法，使它们合并成一条路由从而较少路由表中的路由条目减轻Internet路由器的负担。 CIDR 还使用“斜线记法”，它又称为CI...
CSP认证201812-3 CIDR合并（超详细解析---大模拟）
qq_41645482的博客
03-03 2272
题目链接粘贴读者需要账号才能看到，所以这里不再张贴。 （本人模拟黑洞，如有口胡错误不要介意，嘻嘻
ccf 201812-3 CIDR合并(100分)
jinduo16的博客
01-31 1971
提交后得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,...
201812-3 CIDR合并
qq_38344538的博客
03-17 120
试题编号： 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 90分 运行超时 可能是将点分十进制转换为二进制字符串形式，最后输出的时候...
[root@controllerljh ~]# nova network-list +----+-------+------+ | ID | Label | Cidr | +----+-------+------+ +----+-------+------+
最新发布
04-11
根据提供的引用内容，你正在运行一个名为OpenStack的云计算平台。你想要获取当前的网络列表。你可以使用以下命令来获取网络列表： ```shell [root@controllerljh ~]# nova network-list ``` 然而，根据提供的引用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值