CIDR合併（CCF 201812-3）

原創 _CoCoNutNut_ 2020-07-05 00:02

最終的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

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

數據結構之樹的3種深度遍歷(DFS)

樹的三種深度遍歷方式 樹的深度遍歷（DFS）: 這與層次遍歷相對應（BFS），這是一種使用固定規則，從根節點出發以遍歷每條子樹從而遍歷完整棵樹的方式。 這種思想，在圖的遍歷方式上也存在。 一、三大方式 對於上面的圖，深度遍歷

一名假人 2020-07-05 15:57:34

數據中心（CCF 201812-4）

第一波嘗試 思路：Kruskal算法求最小生成樹 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; imp

_CoCoNutNut_ 2020-07-05 00:02:12

參加考試的最大學生數 (LeetCode 1349)

狀態壓縮動態規劃 用二進制數表示每個座位有沒有人坐 如0011 表示 無無有有，記爲3 dp[row][pre]表示當row-1行的坐法爲pre時，第row行及後面所有行最多坐多少人 狀態轉移方程： dp[row][pre] =

_CoCoNutNut_ 2020-07-05 00:02:12

常見類型相互轉換和排序

https://blog.csdn.net/xHibiki/article/details/82938480 https://blog.csdn.net/my_precious/article/details/53010232

_CoCoNutNut_ 2020-07-05 00:02:12

灌溉花園的最少水龍頭數目 (LeetCode 5318)

一開始準備用貪心 先算出每一個位置可以被多少個水龍頭澆到，存在數組int[] water，如果有任何一處值爲0，直接返回-1 然後按水龍頭澆灌範圍從小到大排列，依次判斷能否刪去（如果刪去後，不會出現能被0個水龍頭澆灌到的位置，即可

_CoCoNutNut_ 2020-07-05 00:02:12

動態規劃 最長公共子序列&最小編輯距離

https://leetcode-cn.com/problems/edit-distance/ https://leetcode-cn.com/problems/edit-distance/solution/zi-di-xian

_CoCoNutNut_ 2020-07-05 00:02:12

劍指offer刷題記錄（一）

我的解法如下：  class Solution { public String reverseLeftWords(String s, int n) { Solution solution = new Solut

半城抹茶 2020-07-02 18:21:42

劍指offer刷題記錄（五）

1. 這道題確實有難度，因爲它的限制條件非常多了，所以難度大大提升了。我想到了遞歸，但這裏不讓用if語句來判斷何時跳出遞歸。 這裏貼出一個大佬的解法，使用了一個&&短路的特性，就是比如（關係式a）&&(關係式b)，如果a爲真，就會去驗證

半城抹茶 2020-07-02 18:21:42

劍指offer刷題記錄（二）

    1. 我的解法：將樹中節點以遞歸的方式放入ArrayList這個容器中，然後調用Collection.sort()方法將其排序，然後輸出第k大的節點。 這種方法相當於沒有利用好二叉查找樹的特點，導致速度較慢。 6ms /**

半城抹茶 2020-07-02 18:21:42

劍指offer刷題記錄（四）

1. 我的解法很簡答：1ms class Solution { public int search(int[] nums, int target) { if(nums.length == 0) return 0

半城抹茶 2020-07-02 18:21:42

劍指offer——刪除鏈表的某一個節點

                                                                     刪除鏈表的某一個節點 題目：給定單鏈表的頭指針和一個節點指針，定義一個函數在O（1）時間內刪除該節點

丿灬慕容笑笑 2020-07-02 02:32:24

3、數組中重複的數字

數組中重複的數字 一：題目描述： 在一個長度爲 n 的數組裏的所有數字都在 0 到 n-1 的範圍內。數組中某些數字是重複的，但不知道有幾個數字是重複的，也不知道每個數字重複幾次。請找出數組中任意一個重複的數字。 Input: {

Juwenile 2020-07-01 05:25:00

10.2.矩形覆蓋+跳臺階

一：矩形覆蓋 一：題目描述： 我們可以用 2*1 的小矩形橫着或者豎着去覆蓋更大的矩形。請問用 n 個 2*1 的小矩形無重疊地覆蓋一個 2*n 的大矩形，總共有多少種方法？ 二：解題思路： 通過題目我們可以發現當n變化是會有以下

Juwenile 2020-07-01 05:25:00

【leetcode】leetcode刷題彙總

熬過了期末整個人都懶懶的 要不斷學習，勤更新鴨? 之前開過一個掛在github上的博客記錄leetcode的刷題 但當時覺得博客是很神聖的東西，花了很多時間在不必要的事情上，後來太忙也就沒刷題了。現在要重拾起之前的這個項目，希望自

韩梅梅meimei 2020-06-27 05:54:23

day_8——LeetCode1：兩數之和

Day_8 —— LeetCode練習題：兩數之和 1. 兩數之和 給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和爲目標值的那兩個整數，並返回他們的數組下標。 你可以假設每種輸入只會對應一個答案。但是

田纳尔多 2020-06-26 23:02:50