Leetcode面T16(11-20)树

最新推荐文章于 2021-12-28 17:26:06 发布

augfun

最新推荐文章于 2021-12-28 17:26:06 发布

阅读量188

点赞数

分类专栏： algorithm

原文链接：https://leetcode-cn.com/problemset/all/

版权

algorithm 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Q16.11 跳水板

你正在使用一堆木板建造跳水板。有两种类型的木板，其中长度较短的木板长度为shorter，长度较长的木板长度为longer。你必须正好使用k块木板。编写一个方法，生成跳水板所有可能的长度。

返回的长度需要从小到大排列。

示例 1

输入：
shorter = 1
longer = 2
k = 3
输出： [3,4,5,6]
解释：
可以使用 3 次 shorter，得到结果 3；使用 2 次 shorter 和 1 次 longer，得到结果 4 。以此类推，得到最终结果。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/diving-board-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

抛开k =0和shorter=longer这两种情况,

最短: shorter * k

第二短: shorter * k + (longer - shorter) * 1

第三短: shorter * k + (longer - shorter) * 2

...

最长:shorter * k + (longer - shorter) * k

class Solution {
    public int[] divingBoard(int shorter, int longer, int k) {
        if(k == 0) return new int[]{};
        if(shorter == longer) return new int[]{shorter * k};
        int[] result = new int[k+1];
        int start = shorter * k;
        for(int i = 0; i <= k; i++){
            result[i] = start + (longer - shorter) * i;
        }
        return result;
    }
}

Q16.14 最佳直线

给定一个二维平面及平面上的 N 个点列表Points，其中第i个点的坐标为Points[i]=[Xi,Yi]。请找出一条直线，其通过的点的数目最多。

设穿过最多点的直线所穿过的全部点编号从小到大排序的列表为S，你仅需返回[S[0],S[1]]作为答案，若有多条直线穿过了相同数量的点，则选择S[0]值较小的直线返回，S[0]相同则选择S[1]值较小的直线返回。

示例：

输入： [[0,0],[1,1],[1,0],[2,0]]
输出： [0,2]
解释：所求直线穿过的3个点的编号为[0,2,3]
提示：

2 <= len(Points) <= 300
len(Points[i]) = 2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-line-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

public int[] bestLine(int[][] points) {
        int max = 0;
        int [] res = new int [2];
        int len = points.length;
        int curr ;
        for(int i=0;i<len-1;i++){
            for(int j=i+1;j<len;j++){
                curr = 2;

                long x1 = points[j][0]-points[i][0];
                long y1 = points[j][1]-points[i][1];
                for(int k = j+1;k<len;k++){
                    long x2 = points[k][0]-points[i][0];
                    long y2 = points[k][1]-points[i][1];
                    if(x1*y2==x2*y1)    curr++;
                }
                if(curr>max){
                    max = curr;
                    res[0] = i;
                    res[1] = j;
                }
            }      
        }
        return res;
    }

Q16.15 最佳直线

珠玑妙算游戏（the game of master mind）的玩法如下。

计算机有4个槽，每个槽放一个球，颜色可能是红色（R）、黄色（Y）、绿色（G）或蓝色（B）。例如，计算机可能有RGGB 4种（槽1为红色，槽2、3为绿色，槽4为蓝色）。作为用户，你试图猜出颜色组合。打个比方，你可能会猜YRGB。要是猜对某个槽的颜色，则算一次“猜中”；要是只猜对颜色但槽位猜错了，则算一次“伪猜中”。注意，“猜中”不能算入“伪猜中”。

给定一种颜色组合solution和一个猜测guess，编写一个方法，返回猜中和伪猜中的次数answer，其中answer[0]为猜中的次数，answer[1]为伪猜中的次数。

示例：

输入： solution="RGBY",guess="GGRR"
输出： [1,1]
解释：猜中1次，伪猜中1次。
提示：

len(solution) = len(guess) = 4
solution和guess仅包含"R","G","B","Y"这4种字符

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/master-mind-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int[] masterMind(String solution, String guess) {
        int[] answer = new int[2];
        Map<Character, Integer> smap = new HashMap<>();
        Map<Character, Integer> gmap = new HashMap<>();
        int cnt = 0;
        for(int i = 0; i < solution.length(); i++){
            if(solution.charAt(i) == guess.charAt(i)){
                cnt++;
            }else{
                smap.put(solution.charAt(i), smap.getOrDefault(solution.charAt(i),0)+1);
                gmap.put(guess.charAt(i), gmap.getOrDefault(guess.charAt(i),0)+1);
            }
        }
        answer[0] = cnt;
        cnt = 0;
        for(char key: smap.keySet()){
            if(gmap.containsKey(key)){
                cnt += Math.min(smap.get(key), gmap.get(key));
            }
        }
        answer[1] = cnt;
        return answer;
    }
}

Q16.16 部分排序

给定一个整数数组，编写一个函数，找出索引m和n，只要将索引区间[m,n]的元素排好序，整个数组就是有序的。注意：n-m尽量最小，也就是说，找出符合条件的最短序列。函数返回值为[m,n]，若不存在这样的m和n（例如整个数组是有序的），请返回[-1,-1]。

示例：

输入： [1,2,4,7,10,11,7,12,6,7,16,18,19]
输出： [3,9]
提示：

0 <= len(array) <= 1000000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sub-sort-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int[] subSort(int[] array) {
        int[] clone = array.clone();
        Arrays.sort(clone);
        int left = -1;
        int right = -1;
        for (int i = 0; i < array.length; i++) {
            if (array[i] != clone[i]) {
                if (left == -1) {
                    left = i;
                }
                right = i;
            }
        }
        return new int[]{left, right};
    }
}

Q16.17 连续数列

给定一个整数数组，找出总和最大的连续数列，并返回总和。

示例：

输入： [-2,1,-3,4,-1,2,1,-5,4]
输出： 6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶：

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/contiguous-sequence-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

public int maxSubArray(int[] nums) {
    int max=Integer.MIN_VALUE, i=0,sum=0;
	while (i<nums.length) {
		if (sum+nums[i]<nums[i]) {
			sum=0;
		}
		sum+=nums[i];
		if (sum>max) {
			max=sum;
		}
		i++;
    }	
	return max;  
}

Q16.18 模式匹配

你有两个字符串，即pattern和value。 pattern字符串由字母"a"和"b"组成，用于描述字符串中的模式。例如，字符串"catcatgocatgo"匹配模式"aabab"（其中"cat"是"a"，"go"是"b"），该字符串也匹配像"a"、"ab"和"b"这样的模式。但需注意"a"和"b"不能同时表示相同的字符串。编写一个方法判断value字符串是否匹配pattern字符串。

示例 1：

输入： pattern = "abba", value = "dogcatcatdog"
输出： true
示例 2：

输入： pattern = "abba", value = "dogcatcatfish"
输出： false
示例 3：

输入： pattern = "aaaa", value = "dogcatcatdog"
输出： false
示例 4：

输入： pattern = "abba", value = "dogdogdogdog"
输出： true
解释： "a"="dogdog",b=""，反之也符合规则
提示：

1 <= len(pattern) <= 1000
0 <= len(value) <= 1000
你可以假设pattern只包含字母"a"和"b"，value仅包含小写字母。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pattern-matching-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
        public boolean patternMatching(String pattern, String value) {
            if (pattern.isEmpty() && value.isEmpty()) {
                return true;
            }
            // 计算a和b的个数
            int aNum = 0;
            int bNum = 0;
            for (int i = 0; i < pattern.length(); i++) {
                char c = pattern.charAt(i);
                if (c == 'a') {
                    aNum++;
                } else {
                    bNum++;
                }
            }
            if (value.isEmpty()) {
                if (aNum > 0 && bNum > 0) {
                    return false;
                } else {
                    return true;
                }
            }
            if (aNum == 1 || bNum == 1) {
                return true;
            }
            // 暴力枚举
            for (int aLen = 0; aLen < value.length(); aLen++) {
                for (int bLen = 0; bLen < value.length(); bLen++) {
                    if (aLen * aNum + bLen * bNum != value.length()) {
                        continue;
                    }
                    String aStr = "";
                    int aIndex = pattern.indexOf('a');
                    if (aIndex >= 0) {
                        aStr = value.substring(bLen * aIndex, bLen * aIndex + aLen);
                    }
                    String bStr = "";
                    int bIndex = pattern.indexOf('b');
                    if (bIndex >= 0) {
                        bStr = value.substring(aLen * bIndex, aLen * bIndex + bLen);
                    }
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < pattern.length(); i++) {
                        if (pattern.charAt(i) == 'a') {
                            sb.append(aStr);
                        } else {
                            sb.append(bStr);
                        }
                    }
                    if (value.equals(sb.toString())) {
                        if (!aStr.equals(bStr)) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    }

Q16.19 水域大小

你有一个用于表示一片土地的整数矩阵land，该矩阵中每个点的值代表对应地点的海拔高度。若值为0则表示水域。由垂直、水平或对角连接的水域为池塘。池塘的大小是指相连接的水域的个数。编写一个方法来计算矩阵中所有池塘的大小，返回值需要从小到大排序。

示例：

输入：
[
[0,2,1,0],
[0,1,0,1],
[1,1,0,1],
[0,1,0,1]
]
输出： [1,2,4]
提示：

0 < len(land) <= 1000
0 < len(land[i]) <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/pond-sizes-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int[] pondSizes(int[][] land) {
        int count=0;
        ArrayList<Integer> resList=new ArrayList<>();
        for(int i=0;i<land.length;i++){
            for(int j=0;j<land[0].length;j++){
                if(land[i][j]==0){
                    count=dfs(land, i, j);
                    resList.add(count);
                }
            }
        }
        int[] res=new int[resList.size()];
        for(int i=0;i<resList.size();i++){
            res[i]=resList.get(i);
        }
        Arrays.sort(res);
        return res;
    }
    public int dfs(int[][] land, int i, int j){
        if(i<0 || i>=land.length || j<0 || j>=land[0].length || land[i][j]!=0){
            return 0;
        }
        land[i][j]=-1;
        int count=1;
        count+=dfs(land, i+1, j);
        count+=dfs(land, i-1, j);
        count+=dfs(land, i, j+1);
        count+=dfs(land, i, j-1);
        count+=dfs(land, i+1, j+1);
        count+=dfs(land, i-1, j+1);
        count+=dfs(land, i-1, j-1);
        count+=dfs(land, i+1, j-1);
        return count;
    }
}

Q16.20 T9键盘

在老式手机上，用户通过数字键盘输入，手机将提供与这些数字相匹配的单词列表。每个数字映射到0至4个字母。给定一个数字序列，实现一个算法来返回匹配单词的列表。你会得到一张含有有效单词的列表。映射如下图所示：

示例 1:

输入: num = "8733", words = ["tree", "used"]
输出: ["tree", "used"]
示例 2:

输入: num = "2", words = ["a", "b", "c", "d"]
输出: ["a", "b", "c"]
提示：

num.length <= 1000
words.length <= 500
words[i].length == num.length
num中不会出现 0, 1 这两个数字

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/t9-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    int[] charToNum = new int[]{2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,9,9,9,9};
    public List<String> getValidT9Words(String num, String[] words) {
        List<String> result = new ArrayList<String>();
        for(String s : words){
            if(getNum(s).equals(num)){
                result.add(s);
            }
        }
        return result;
    }

    public String getNum(String s){
        StringBuilder sb = new StringBuilder();
        for(int i = 0 ; i < s.length() ; i++){
            sb.append(charToNum[s.charAt(i) - 'a']);
        }
        return sb.toString();
    }
}