7月算法训练------第二十九天（分而治之）解题报告

题目类型：分而治之
题目难度：中等

1. 题目链接：21. 合并两个有序链表
2. 思路分析：
   这题思路很简单，就是申请一个结果数组：

• 当list1的值小时，就将list1的值加入到结果链表尾部，然后更新list1的头部和结果链表的尾部；
• 当list2的值小时，就将list2的值加入到结果链表尾部，然后更新list2的头部和结果链表的尾部。
• 当list1或list2不为null时，就将list1或list2直接加入到结果链表的尾部。

3. 代码：

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null){
            return list2;
        }
        if(list2 == null){
            return list1;
        }
        ListNode tail = new ListNode();
        ListNode head = tail;
        while(list1 != null && list2 != null){
            if(list1.val > list2.val){
                tail.next = new ListNode(list2.val);
                tail = tail.next;
                list2 = list2.next;
            }else{
                tail.next = new ListNode(list1.val);
                tail = tail.next;
                list1 = list1.next;
            }
        }
        if(list1 != null){
            tail.next = list1;
        }else if(list2 != null){
            tail.next = list2;
        }
        return head.next;

    }
}

1. 题目链接：1985. 找出数组中的第 K 大整数
2. 思路分析：
   这一题代码看着行数少，但却不简单，使用lambda表达式对nums数组进行排序。
   本来开始是想着把这个数组先变成long数组，但没想到这里面的数字给的非常大，已经超过long型表示的最大值了。
   所以只能用比较字符串位数的方式，如果a的长度比b的长度长就返回-1；如果b的长度比a的长度长就返回1。
   当a的长度和b相等时，就将他们两个字符串进行比较。
3. 代码：

class Solution {
    public String kthLargestNumber(String[] nums, int k) {
        Arrays.sort(nums,(a, b) ->{
            int la = a.length(), lb = b.length();
            if(la > lb) return -1;
            if(lb > la) return 1;
            return b.compareTo(a);
        });
        return nums[k-1];
    }
}

剑指offer
题目类型：动态规划
题目难度：中等

1. 题目链接：剑指 Offer 48. 最长不含重复字符的子字符串
2. 思路分析：
   这一题，之前用双指针的方法做过，今天用动态规划的方法来做，只能说这一题的动态规划确实不好想，虽然我之前思路和答案上的动态规划已初具雏形，但还是没有答案上的nb。
   开始想的是，当哈希表中不存在这个字母时，就将dp[i]=dp[i-1]+1；
   如果存在这个字母，就找到那个存在字母的下标，将当前下标减去那个下标就是重复长度，但很快就发现这样思考是不全面的，结果改了半天也没改出来，往往是顾此失彼。
   最后实在没办法了，就去看了一眼答案，发现思路和答案还是有一些出入的，并且答案上的这种方法确实很简洁，比较dp[i-1] + 1和index - lastIndex两者的值。

字符不重复：新字符可直接算一位长度
理论上最大子串长度 = 上一位的最大子串长度 + 1
f(n) = f(n - 1) + 1

存在字符重复：在不考虑中间存在其他重复的前提下
理论上最大子串长度 = 现在的位置 - 相同字符上一次出现的位置
f(n) = index - lastIndex

这种方法确实让我耳目一新，就是在处理这个字符重复这里，是在是自愧不如。
3. 代码：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int ans = 0, n = s.length(), last = 0;
        HashMap map = new HashMap<>();

        for (int i = 0; i < n; i++) {
            Character c = s.charAt(i);
            last = Math.min(i - map.getOrDefault(c, -1), last + 1);
            ans = Math.max(ans, last);
            map.put(c, i);
        }
        return ans;
    }
}

1. 题目链接：剑指 Offer 46. 把数字翻译成字符串
2. 思路分析：
   运用动态规划，类似于青蛙跳台阶问题，就是在加前面的情况时要选择性的加：

• 当前一位和本位组成的数字在10~25之间时，就将dp[i]=dp[i-1] + dp[i-2]；
• 当前一位和本位组成的数字不在10~25之间时，说明前一位和本位不能映射为一个单词，就将dp[i]=dp[i-1]；

3. 代码：

class Solution {
    public int translateNum(int num) {
        if(num < 10) return 1;
        String str = Integer.toString(num);
        char[] ch = str.toCharArray();
        int len = str.length();
        int[] dp = new int[len];
        int[] nums = new int[len];
        for(int i = 0; i < len; i++){
            nums[i] = Integer.parseInt(ch[i]+"");
        }
        dp[0] = 1;
        int a = nums[0] * 10 + nums[1];
        if(a <= 25 && a >=10){
            dp[1] = 2;
        }else{
            dp[1] = 1;
        }
        for(int i = 2; i < len; i++){
            int temp = nums[i - 1] * 10 + nums[i];
            if(temp <= 25 && temp >=10){
                dp[i] = dp[i-2] + dp[i-1];
            }else{
                dp[i] = dp[i-1];
            }
        }
        return dp[len-1];
    }
    
}