《Leetcode 3.10》

1. 合并排序的数组

题目描述：
给定两个排序后的数组 A 和 B，其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法，将 B 合并入 A 并排序。
初始化 A 和 B 的元素数量分别为 m 和 n。
示例:
输入:
A = [1,2,3,0,0,0], m = 3
B = [2,5,6], n = 3
输出: [1,2,2,3,5,6]

代码：

package leetcode.week10;


/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-03-10 20:23
 * @desc
 */
public class t10_01 {
    public static void merge(int[] A, int m, int[] B, int n) {
        int p1 = m - 1;
        int p2 = n - 1;
        int cur = m + n - 1;
        while (p1 >= 0 && p2 >= 0) {
            A[cur--] = A[p1] > B[p2] ? A[p1--] : B[p2--];
        }

        while (p2 >= 0) {
            A[cur--] = B[p2--];
        }
    }

    public static void main(String[] args) {
        int[] A = {4, 5, 6, 0, 0, 0};
        int[] B = {1, 2, 3};
        merge(A, 3, B, 3);

    }

}

2. 连续数列

题目描述：

给定一个整数数组（有正数有负数），找出总和最大的连续数列，并返回总和。
示例：
输入： [-2,1,-3,4,-1,2,1,-5,4]
输出： 6
解释： 连续子数组 [4,-1,2,1] 的和最大，为 6。

代码：

package leetcode.week10;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-03-10 19:57
 * @desc
 */
public class t16_17 {

    public static int maxSubArray(int[] nums) {
        int temp = nums[0];
        int sum = temp;
        for (int i = 1; i < nums.length; i++) {
            if (temp < 0) {
                temp = nums[i];
            } else {
                temp += nums[i];
            }
            if (temp > sum) {
                sum = temp;
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        System.out.println(maxSubArray(nums));
    }
}

3. 最长单词

题目描述：
给定一组单词words，编写一个程序，找出其中的最长单词，且该单词由这组单词中的其他单词组合而成。若有多个长度相同的结果，返回其中字典序最小的一项，若没有符合要求的单词则返回空字符串。
示例：
输入： [“cat”,“banana”,“dog”,“nana”,“walk”,“walker”,“dogwalker”]
输出： “dogwalker”
解释： "dogwalker"可由"dog"和"walker"组成。

代码：

package leetcode.week10;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-03-09 20:45
 * @desc
 */
public class t17_15 {

    Set<String> set = new HashSet<>();
    int minLen = 100;

    public String longestWord(String[] words) {
        for (String w : words) {
            minLen = Math.min(minLen, w.length());
            set.add(w);
        }
        Arrays.sort(words, new Comparator<String>() {
            public int compare(String s1, String s2) {
                if (s1.length() == s2.length())
                    return s1.compareTo(s2);
                return s2.length() - s1.length();
            }
        });
        for (String w : words) {
            if (w.length() < minLen * 2)
                break;
            if (check(w, 0, 0))
                return w;
        }
        return "";
    }

    public boolean check(String str, int l, int k) {
        if (k != 0 && set.contains(str.substring(l)))
            return true;
        for (int i = l + minLen; i + minLen <= str.length(); i++)
            if (set.contains(str.substring(l, i)) && check(str, i, k + 1))
                return true;
        return false;
    }

    public static void main(String[] args) {

        String[] strs = {"cat", "banana", "dog", "nana", "walk", "walker", "dogwalker"};
        t17_15 demo = new t17_15();
        System.out.println(demo.longestWord(strs));
    }
}

4. 前 K 个高频元素

题目描述：
给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

代码：

package leetcode.week10;

import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-03-09 20:09
 * @desc
 */
public class t347 {
    public static List<Integer> topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer str : nums) {
            map.put(str, map.getOrDefault(str, 0) + 1);
        }

        return map.entrySet().stream()
                .sorted(Comparator.comparing(Map.Entry<Integer, Integer>::getValue).reversed())
                .limit(k)
                .map(Map.Entry<Integer, Integer>::getKey)
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        int[] nums = {1, 1, 1, 1, 2, 2, 3};
        List<Integer> res = topKFrequent(nums, 2);
        for (Integer i : res) {
            System.out.println(i);
        }

    }
}

5. 最长和谐子序列

题目描述：
和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。
现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。

示例 1:
输入: [1,3,2,2,5,2,3,7]
输出: 5
原因: 最长的和谐数组是：[3,2,2,2,3].

代码：

package leetcode.week10;

import java.util.HashMap;
import java.util.Map;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-03-09 20:20
 * @desc
 */
public class t594 {
    public static int findLHS(int[] nums) {
        int res = 0;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }

        for (int key : map.keySet()) {
            if (map.containsKey(key + 1)) {
                res = Math.max(res, map.get(key) + map.get(key + 1));
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] nums = {1, 3, 2, 2, 5, 2, 3, 7};
        System.out.println(findLHS(nums));

    }
}