高频算法和数据结构（三）

题目一

https://leetcode.com/problems/longest-substring-without-repeating-characters/

求一个字符串中，最长无重复字符子串长度

解题： 

求子串和子数组的问题：先求以0结尾的答案，然后求1结尾的答案

1）当前字符串上一次出现的位置

2）i-1位置往左推的距离

两个条件，哪个长要哪个

public static int lengthOfLongestSubstring(String s) {
		if (s == null || s.equals("")) {
			return 0;
		}
		char[] str = s.toCharArray();
		int[] map = new int[256];
		for (int i = 0; i < 256; i++) {
			map[i] = -1;
		}
		map[str[0]] = 0;
		int N = str.length;
		int ans = 1;
		int pre = 1;
		for (int i = 1; i < N; i++) {
			pre = Math.min(i - map[str[i]], pre + 1);
			ans = Math.max(ans, pre);
			map[str[i]] = i;
		}
		return ans;
	}

---

题目二

只由小写字母（a~z）组成的一批字符串

都放在字符类型的数组String[] arr中

如果其中某两个字符串所含有的字符种类完全一样

就将两个字符串算作一类

比如：baacbba和bac就算作一类

返回arr中有多少类？

解题：

 a~z总共字符26个，一个整数32位，将每个字符的摘要变成整数存入set中，最后统计set的个数

public static int types1(String[] arr) {
		HashSet<String> types = new HashSet<>();
		for (String str : arr) {
			char[] chs = str.toCharArray();
			boolean[] map = new boolean[26];
			for (int i = 0; i < chs.length; i++) {
				map[chs[i] - 'a'] = true;
			}
			String key = "";
			for (int i = 0; i < 26; i++) {
				if (map[i]) {
					key += String.valueOf((char) (i + 'a'));
				}
			}
			types.add(key);
		}
		return types.size();
	}

	public static int types2(String[] arr) {
		HashSet<Integer> types = new HashSet<>();
		for (String str : arr) {
			char[] chs = str.toCharArray();
			int key = 0;
			for(int i = 0 ; i < chs.length;i++) {
				key |= (1 << (chs[i] - 'a'));
			}
			types.add(key);
		}
		return types.size();
	}

---

题目三

 https://leetcode.com/problems/largest-1-bordered-square/

给定一个只有0和1组成的二维数组

返回边框全是1的最大正方形面积

解题：

 一个N*N的矩阵中，长方形的个数为N^4量级，正方形的个数为N^3量级

因此求解方法在N^3次方时就是最有方法

前置数据准备：

down[i，j]表示这个点向下有几个连续的1

right[i，j]表示这个点向右右几个连续的1

这样任何一个点，就可以以O（1）的代价得到，该点的最大正方形

public static int largest1BorderedSquare(int[][] m) {
		int[][] right = new int[m.length][m[0].length];
		int[][] down = new int[m.length][m[0].length];
		setBorderMap(m, right, down);
		for (int size = Math.min(m.length, m[0].length); size != 0; size--) {
			if (hasSizeOfBorder(size, right, down)) {
				return size * size;
			}
		}
		return 0;
	}

	public static void setBorderMap(int[][] m, int[][] right, int[][] down) {
		int r = m.length;
		int c = m[0].length;
		if (m[r - 1][c - 1] == 1) {
			right[r - 1][c - 1] = 1;
			down[r - 1][c - 1] = 1;
		}
		for (int i = r - 2; i != -1; i--) {
			if (m[i][c - 1] == 1) {
				right[i][c - 1] = 1;
				down[i][c - 1] = down[i + 1][c - 1] + 1;
			}
		}
		for (int i = c - 2; i != -1; i--) {
			if (m[r - 1][i] == 1) {
				right[r - 1][i] = right[r - 1][i + 1] + 1;
				down[r - 1][i] = 1;
			}
		}
		for (int i = r - 2; i != -1; i--) {
			for (int j = c - 2; j != -1; j--) {
				if (m[i][j] == 1) {
					right[i][j] = right[i][j + 1] + 1;
					down[i][j] = down[i + 1][j] + 1;
				}
			}
		}
	}

	public static boolean hasSizeOfBorder(int size, int[][] right, int[][] down) {
		for (int i = 0; i != right.length - size + 1; i++) {
			for (int j = 0; j != right[0].length - size + 1; j++) {
				if (right[i][j] >= size && down[i][j] >= size && right[i + size - 1][j] >= size
						&& down[i][j + size - 1] >= size) {
					return true;
				}
			}
		}
		return false;
	}

---

题目四

 给定一个数组arr，代表每个人的能力值。再给定一个非负数k

如果两个人能力差值正好为k，那么可以凑在一起比赛

一局比赛只有两个人

返回最多可以同时有多少场比赛

 解题：

贪心+窗口：左右指针依次向右扫描

// 时间复杂度O(N*logN)
	public static int maxPairNum2(int[] arr, int k) {
		if (k < 0 || arr == null || arr.length < 2) {
			return 0;
		}
		Arrays.sort(arr);
		int ans = 0;
		int N = arr.length;
		int L = 0;
		int R = 0;
		boolean[] usedR = new boolean[N];
		while (L < N && R < N) {
			if (usedR[L]) {
				L++;
			} else if (L >= R) {
				R++;
			} else { // 不止一个数，而且都没用过！
				int distance = arr[R] - arr[L];
				if (distance == k) {
					ans++;
					usedR[R++] = true;
					L++;
				} else if (distance < k) {
					R++;
				} else {
					L++;
				}
			}
		}
		return ans;
	}

---

题目五

给定一个正数数组arr，代表若干人的体重

再给定一个正数limit，表示所有船共同拥有的载重量

每艘船最多坐两人，且不能超过载重

想让所有的人同时过河，并且用最好的分配方法让船尽量少

返回最少的船数

 解题：

线排序，从中间分界点，开始往两边滑动

贪心的核心点：从3出发往左边数6个，用这6个去消化右边这6个，一定是最值的

public static int minBoat(int[] arr, int limit) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		int N = arr.length;
		Arrays.sort(arr);
		if (arr[N - 1] > limit) {
			return -1;
		}
		int lessR = -1;
		for (int i = N - 1; i >= 0; i--) {
			if (arr[i] <= (limit / 2)) {
				lessR = i;
				break;
			}
		}
		if (lessR == -1) {
			return N;
		}
		int L = lessR;
		int R = lessR + 1;
		int noUsed = 0;
		while (L >= 0) {
			int solved = 0;
			while (R < N && arr[L] + arr[R] <= limit) {
				R++;
				solved++;
			}
			if (solved == 0) {
				noUsed++;
				L--;
			} else {
				L = Math.max(-1, L - solved);
			}
		}
		int all = lessR + 1;
		int used = all - noUsed;
		int moreUnsolved = (N - all) - used;
		return used + ((noUsed + 1) >> 1) + moreUnsolved;
	}

---

题目六

https://leetcode.com/problems/closest-subsequence-sum/

 最接近sum的子序列累加和问题

 解题：

1 <= nums.length <= 40
-10^7 <= nums[i] <= 10^7
-10^9 <= goal <= 10^9
通过这个数据量描述可知，需要用到分治，因为数组长度不大
而值很大，用动态规划的话，表会爆

左边20个，右边20个：答案要么来自左边，要么来自右边，或者使用左边的任何的值二分去右边逐一比对，总的复杂度O(2^20)+O(2^20)+O(2^20*log（2^20）)，没有超过10^8

public static int[] l = new int[1 << 20];
	public static int[] r = new int[1 << 20];

	public static int minAbsDifference(int[] nums, int goal) {
		if (nums == null || nums.length == 0) {
			return goal;
		}
		int le = process(nums, 0, nums.length >> 1, 0, 0, l);
		int re = process(nums, nums.length >> 1, nums.length, 0, 0, r);
		Arrays.sort(l, 0, le);
		Arrays.sort(r, 0, re--);
		int ans = Math.abs(goal);
		for (int i = 0; i < le; i++) {
			int rest = goal - l[i];
			while (re > 0 && Math.abs(rest - r[re - 1]) <= Math.abs(rest - r[re])) {
				re--;
			}
			ans = Math.min(ans, Math.abs(rest - r[re]));
		}
		return ans;
	}

	public static int process(int[] nums, int index, int end, int sum, int fill, int[] arr) {
		if (index == end) {
			arr[fill++] = sum;
		} else {
			fill = process(nums, index + 1, end, sum, fill, arr);
			fill = process(nums, index + 1, end, sum + nums[index], fill, arr);
		}
		return fill;
	}

---

题目七

https://leetcode.com/problems/freedom-trail/

 自由之路

解题：

遍历电话一次，生成一张表，每个字符的所有位置

小函数：从i出发，要求j位置，要么顺时针要么逆时针，选最小代价

使用傻缓存将暴力递归改动态规划 

public static int findRotateSteps(String r, String k) {
		char[] ring = r.toCharArray();
		int N = ring.length;
		HashMap<Character, ArrayList<Integer>> map = new HashMap<>();
		for (int i = 0; i < N; i++) {
			if (!map.containsKey(ring[i])) {
				map.put(ring[i], new ArrayList<>());
			}
			map.get(ring[i]).add(i);
		}
		char[] str = k.toCharArray();
		int M = str.length;
		int[][] dp = new int[N][M + 1];
		// hashmap
		// dp[][] == -1 : 表示没算过！
		for (int i = 0; i < N; i++) {
			for (int j = 0; j <= M; j++) {
				dp[i][j] = -1;
			}
		}
		return process(0, 0, str, map, N, dp);
	}

	// 电话里：指针指着的上一个按键preButton
	// 目标里：此时要搞定哪个字符？keyIndex
	// map : key 一种字符 value: 哪些位置拥有这个字符
	// N: 电话大小
	// f(0, 0, aim, map, N)
	public static int process(int preButton, int index, char[] str, HashMap<Character, ArrayList<Integer>> map, int N,
			int[][] dp) {
		if (dp[preButton][index] != -1) {
			return dp[preButton][index];
		}
		int ans = Integer.MAX_VALUE;
		if (index == str.length) {
			ans = 0;
		} else {
			// 还有字符需要搞定呢！
			char cur = str[index];
			ArrayList<Integer> nextPositions = map.get(cur);
			for (int next : nextPositions) {
				int cost = dial(preButton, next, N) + 1 + process(next, index + 1, str, map, N, dp);
				ans = Math.min(ans, cost);
			}
		}
		dp[preButton][index] = ans;
		return ans;
	}

	public static int dial(int i1, int i2, int size) {
		return Math.min(Math.abs(i1 - i2), Math.min(i1, i2) + size - Math.max(i1, i2));
	}

---

题目八

 给定三个参数：

二叉树的头节点head，树上某个节点target，正数K

从target开始，可以向上走或者向下走

返回与target的距离是K的所有节点

 解题：

先生成一个parentMap，然后使用宽度优先遍历，该点的左子树、右子树和parentMap，层数为指定的k则收集数据

public static class Node {
		public int value;
		public Node left;
		public Node right;

		public Node(int v) {
			value = v;
		}
	}

	public static List<Node> distanceKNodes(Node root, Node target, int K) {
		HashMap<Node, Node> parents = new HashMap<>();
		parents.put(root, null);
		createParentMap(root, parents);
		Queue<Node> queue = new LinkedList<>();
		HashSet<Node> visited = new HashSet<>();
		queue.offer(target);
		visited.add(target);
		int curLevel = 0;
		List<Node> ans = new ArrayList<>();
		while (!queue.isEmpty()) {
			int size = queue.size();
			while (size-- > 0) {
				Node cur = queue.poll();
				if (curLevel == K) {
					ans.add(cur);
				}
				if (cur.left != null && !visited.contains(cur.left)) {
					visited.add(cur.left);
					queue.offer(cur.left);
				}
				if (cur.right != null && !visited.contains(cur.right)) {
					visited.add(cur.right);
					queue.offer(cur.right);
				}
				if (parents.get(cur) != null && !visited.contains(parents.get(cur))) {
					visited.add(parents.get(cur));
					queue.offer(parents.get(cur));
				}
			}
			curLevel++;
			if (curLevel > K) {
				break;
			}
		}
		return ans;
	}

	public static void createParentMap(Node cur, HashMap<Node, Node> parents) {
		if (cur == null) {
			return;
		}
		if (cur.left != null) {
			parents.put(cur.left, cur);
			createParentMap(cur.left, parents);
		}
		if (cur.right != null) {
			parents.put(cur.right, cur);
			createParentMap(cur.right, parents);
		}
	}