每周算法（week2）【leetcode11~30】

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量1.1k 收藏 13
点赞数 28
分类专栏： leecode 算法竞赛 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64261982/article/details/140121309
版权

 前言

        本该两周完成的30道算法题没想到5天就完成了，接下来继续刷算法，保持手感，对不熟悉的基础算法二分、搜索还得继续练。

leetcode 编号完成时间复习时间
11. 盛水最多的容器2024-07-02
12. 整数转罗马数字2024-07-02
13. 罗马数字转整数2024-07-02
14. 最长公共前缀2024-07-02
15. 三数之和2024-07-02
16、最接近的三数之和

2024-07-03

17、电话号码的字母组合2024-07-03
18、四数之和2024-07-03
19、删除链表倒数第N个节点2024-07-03
20、有效的括号2024-07-04
21、合并两个有序的链表2024-07-04
23、合并K个升序链表2024-07-05
24、两两交换链表中的节点2024-07-05
25、K个一组翻转链表2024-07-05
26、删除有序数组中的重复项2024-07-05
27、移除元素
28、找出字符串中第一个匹配项的下标2024-07-05
30、串联所有单词的子串2024-07-05

11、盛水最多的容器（双指针）

11.1、暴力枚举

思路💡：枚举每种左右高度的组合，直到取到最大值
时间复杂度🕖：O（n2）

class Solution {
    public int maxArea(int[] height) {
        int max = 0;
        for(int i=0;i<height.length-1;i++){
            for(int j=i+1;j<height.length;j++){
                int high = Math.min(height[i],height[j]);
                int width = j-i;
                max = Math.max(max,high*width);
            }
        }
        return max;
    }
}

 11.2、双指针

思路💡：左右指针

  • 虽然指针每移动一次，容器的宽度 -1，但是如果移动得到的"回报"——边界的高度变得更高，那就是值得的

时间复杂度🕖： O（N）

class Solution {
    public int maxArea(int[] height) {
        int max = 0;
        int left = 0,right = height.length - 1;
        while(left < right){
            int area = Math.min(height[left],height[right])*(right-left);
            if(height[left] <= height[right]){
                left++;
            }else{
                right--;
            }
            max = Math.max(max,area);
        }
        return max;
    }
}

12、整数转罗马数字（数学 + 模拟）

12.1、模拟

思路💡：从千位到个位，对每一位进行逻辑模拟
时间复杂度🕖：O（1）

class Solution {
    static Map<Integer,Character> map = new HashMap<>();
    static{
        map.put(1,'I');
        map.put(5,'V');
        map.put(10,'X');
        map.put(50,'L');
        map.put(100,'C');
        map.put(500,'D');
        map.put(1000,'M');
    }
    public String intToRoman(int num) {
        StringBuilder sb = new StringBuilder();
        if(String.valueOf(num).length()>3){
            int q = num/1000;
            while(q!=0){
                sb.append(map.get(1000));
                q--;
            }
            num %= 1000;
        }
        if(String.valueOf(num).length()>2){
            int b = num/100;
            while(b!=0) {
            	if(b >=5 && b < 9) {
                	sb.append(map.get(500));
                	b-=5;
                }else if(b==4) {
                	sb.append("CD");
                	break;
                }else if(b==9) {
                	sb.append("CM");
                	break;
                }else {
                	while(b!=0){
                        sb.append(map.get(100));
                        b--;
                    }	
                }	
            }  
            num %= 100;
        }
        if(String.valueOf(num).length()>1){
            int s = num/10;
            while(s!=0) {
            	if(s<9 &&  s>=5){
                    sb.append(map.get(50));
                    s-=5;
                }else if(s==4){
                    sb.append("XL");
                    break;
                }else if(s==9){
                    sb.append("XC");
                    break;
                }else{
                    while(s != 0){
	                    sb.append(map.get(10));
	                    s--;
                    }
                }
            }
            num %= 10;
        }
        while(String.valueOf(num).length()>0 && num>0){
            if(num <9 && num >= 5){
                sb.append(map.get(5));
                num-=5;
            }else if(num == 4){
                sb.append("IV");
                break;
            }else if(num == 9){
                sb.append("IX");
                break;
            }else{
                while(num!=0){
                    sb.append("I");
                    num--;
                }
            }
        }
        return sb.toString();
    }
}

13、罗马数字转整数（模拟）

13.1、模拟

思路💡：从高位到低位，在判断当前位对应数值的同时向低一位判断一下，因为罗马数字只有相邻位置可以进行减法表示（比如 49 可以表示为 IX）
时间复杂度🕖：O（1）

class Solution {
    static Map<Character,Integer> map = new HashMap<>();
    static{
        map.put('I',1);
        map.put('V',5);
        map.put('X',10);
        map.put('L',50);
        map.put('C',100);
        map.put('D',500);
        map.put('M',1000);
    }
    public int romanToInt(String s) {
        int res = 0;
        int index = 0;
        while(index+1<s.length()){
            if(map.get(s.charAt(index)) >= map.get(s.charAt(index+1))){
                res += map.get(s.charAt(index));
                index++;
            }else{
                res += (map.get(s.charAt(index+1)) - map.get(s.charAt(index)));
                index+=2;
            }
        }
        if(index < s.length()){
                res += map.get(s.charAt(index));
        }
        return res;
    }
}

14、最长公共前缀（二分搜索）

14.1、枚举

思路💡：木桶原理，最长公共前缀取决于"最混蛋"的那个字符串（任意一个字符串的第 1 个前缀字符和别的字符串不一样，就算别的 9999 个字符串都完全一样也没用，它们的公共前缀就是 0）。所以我们可以拿任意一个字符串当做模板和别的所有字符串进行对比。

时间复杂度🕖：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。

class Solution {
    public String longestCommonPrefix(String[] strs) {
        char[] prefix = strs[0].toCharArray();
        StringBuilder sb = new StringBuilder();
        for(char c : prefix){
            sb.append(c);
            for(String str : strs){
                if(!str.startsWith(sb.toString())){
                    return sb.substring(0,sb.length()-1).toString();
                }
            }
        }
        return sb.toString();
    }
}

14.2、二分搜索

思路💡：前缀的长度范围超不出数组中最短的字符串长度，所以使用二分不断寻找可能的 mid 值，也就是最长的前缀长度

时间复杂度🕖：二分查找的迭代执行次数是 O(logm)，每次迭代最多需要比较 mn 个字符，因此总时间复杂度是 O(mnlogm)。其中 m 是字符串数组中的字符串的最小长度，n 是字符串的数量。

知识点🙉：这里的二分搜索是左闭右闭的，所以 while 条件是 left < right，而不是 left <= right；

class Solution {
    public String longestCommonPrefix(String[] strs) {
        int minLength = Integer.MAX_VALUE;
        for(String str : strs)
            minLength = Math.min(minLength,str.length());
        int left = 0,right = minLength;
        while(left < right){
            // (right - left + 1) 中 +1 的原因是我们mid的意义是长度,而不是索引
            int mid = (right - left + 1) / 2 + left;
            if(isSamePrefix(strs,mid))
                left = mid;
            else
                right = mid - 1;
        }
        return strs[0].substring(0,left);
    }
    public boolean isSamePrefix(String[] strs,int length){
        String suffix = strs[0].substring(0,length);
        for(int i=1;i<strs.length;i++)
            if(!strs[i].startsWith(suffix))
                return false;
        return true;
    }
}

15、三数之和（双指针）

15.1、暴力枚举

思路💡：三层遍历

时间复杂度🕖：O（n3）

知识点🙉：这里唯一收获的东西就是：使用 list.contains() 判断元素相同的集合对象进行去重

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> threeSum(int[] nums) {
        for(int i=0;i < nums.length-2;i++){
            for(int j=i+1;j < nums.length-1;j++){
                for(int k=j+1;k < nums.length;k++){
                    if(nums[i]+nums[j]+nums[k]==0){
                        put(nums[i],nums[j],nums[k]);
                    }
                }
            }
        }
        return res;
    }
    public void put(int v1,int v2,int v3){
        List<Integer> list = new ArrayList<>();
        list.addAll(Arrays.asList(v1,v2,v3));
        Collections.sort(list);
        if(!res.contains(list)) res.add(list);
    }
}

15.2、双指针

思路💡：

  • 首先对数组排序，不然无法判断指针应该如何移动
  • 这道题在使用双指针时有一个特别需要注意的就是：当左指针或右指针对应当前值和下一个值相同时，得到的结果会有重复，所以在每次循环前后都会对重复值进行处理

时间复杂度🕖：O（n2）

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        List<List<Integer>> ans = new ArrayList<List<Integer>>();

        Arrays.sort(nums);
        //确定第一个数
        for(int i = 0;i < n ;i ++)
        {
            // 当起始的值等于前一个元素，那么得到的结果将会和前一次相同
            if(i != 0 && nums[i] == nums[i - 1]) continue;
            int l = i + 1,r = n - 1;

            while(l < r)
            {
                int sum = nums[i] + nums[l] + nums[r];
                if(sum > 0) 
                {
                    r --;
                    continue;
                }
                if(sum < 0)
                {
                    l ++;
                    continue;
                }
                //sum == 0时
                ans.add(Arrays.asList(nums[i],nums[l],nums[r]));
                //去除重复处理
                do {l ++;} while(l < r && nums[l] == nums[l - 1]);
                do {r --;} while(l < r && nums[r] == nums[r + 1]);
            }

        }
        return ans;
    }
}

16、最接近的三数之和（双指针）

16.1、双指针

思路💡：首先对数组进行排序，然后枚举三数之和中的第一个数字，剩下的两个数字用左右指针寻找，不断逼近和目标值最近的两个数

时间复杂度🕖：O（n2）

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int ans = Integer.MAX_VALUE;
        for(int i=0;i<nums.length;i++){
            int l = i+1,r = nums.length-1;
            while(l < r){
                int sum = nums[i] + nums[l] + nums[r];
                ans = Math.abs(sum-target)<Math.abs(ans-target)?sum:ans;
                if(sum > target)    r--;
                else if (sum < target)  l++;
                else if (sum == target) return target;
            }
        }
        return ans;
    }
}

17、电话号码的字母组合（深搜）

17.1、深度优先搜索

思路💡：组合问题，直接深搜

时间复杂度🕖：O(3^m ×4^n )，其中 m 是输入中对应 3 个字母的数字个数（包括数字 2、3、4、5、6、8），n 是输入中对应 4 个字母的数字个数（包括数字 7、9）

class Solution {
    Map<Integer, Character[]> map = new HashMap<Integer, Character[]>();
	{
		int index = 'a';
		for (int i = 2; i < 7; i++) {
			Character[] arr = new Character[3];
			for (int j = 0; j < arr.length; j++) arr[j] = (char)index++;
			map.put(i, arr);
		}
        map.put(7, new Character[]{'p','q','r','s'});
        map.put(8, new Character[]{'t','u','v'});
		map.put(9, new Character[]{'w','x','y','z'});
	}
	List<String> res = new ArrayList<>();
	List<String> letterCombinations(String digits) {
        if(digits.length()==0) return res;

        backtrack(digits,0,"");
		return res;
    }
	public void backtrack(String digits,int index,String str){
        if(index == digits.length()){
            res.add(str);
            return;
        }
        for(char s : map.get(Integer.parseInt(""+digits.charAt(index)))){
            backtrack(digits,index + 1,str + s);
        }
    }
}

18、四数之和（双指针）

18.1、双指针

思路💡：同样对数组先排序，前两个数使用枚举，后两个数用双指针优化

时间复杂度🕖：O（n3）

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<>();
        if(nums.length == 0) return new ArrayList<>();
        int n = nums.length;
        Arrays.sort(nums);
        // 定下nums[i]
        for(int i = 0;i < n;i++){
            // 去重
            if(i != 0 && nums[i] == nums[i - 1]) continue;
            // 定下nums[j]
            for(int j = i + 1;j < n - 2;j++){
                // 去重
                if(j != i+1 && nums[j] == nums[j-1]) continue;
                int k = j + 1,m = n-1;
                // 双指针
                while(k < m){
                    int sum = nums[i] + nums[j] + nums[k] + nums[m];
                    if(sum > target){
                        m--;
                        continue;
                    }
                    if(sum < target){
                        k++;
                        continue;
                    }else if(sum == target){
                        list.add(Arrays.asList(nums[i],nums[j],nums[k],nums[m]));
                    }
                    // 去重
                    do{k++;}while(k < m && nums[k] == nums[k - 1]);
                    do{m--;}while(k < m && nums[m] == nums[m + 1]);
                }
            }
        }
        return list;
    }
}

19、删除链表最后一个节点

思路💡：删除倒数第 N 个节点就是删除正数第 L - N +1 个节点

时间复杂度🕖：O（L），L 是链表的长度

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 如果链表只有一个元素还要删除就直接返回空
        if(head.next == null && n==1) return null;
        // 计算链表的长度
        ListNode t1 = head;
        int len = 1;
        while(t1.next != null){
            len++;
            t1 = t1.next;
        }
        int target = len - n + 1; // 倒数第n个就是正数第(len-n+1)个元素
        int cur = 1; // 当前节点位置
        if(cur == target) return head.next; // 如果当前位置就是要删除的元素就直接返回下一个节点
        t1 = head; // 重新初始化
        while(cur != target-1){ // 找到要删除的目标节点的前一个节点
            t1 = t1.next;
            cur++;
        }
        // 如果目标节点的下一个节点为空就置当前节点的下一个节点为空 否则连接下下一个节点
        if(t1.next.next != null) t1.next = t1.next.next; else t1.next = null;
        return head;
    }
}

20、有效的括号

20.1、栈

思路💡：右括号总是出现在第偶数次的，否则说明括号不合法

时间复杂度🕖：O（N）

class Solution {
    public boolean isValid(String s) {
        if(s.length() %2 != 0) return false;
        Map<Character,Character> map = new HashMap<>();
        map.put(')','(');
        map.put('}','{');
        map.put(']','[');
        Deque<Character> stack = new ArrayDeque<>(); 
        for(int i=0;i<s.length();i++){
            if(i!=0 && stack.peek()!=null && stack.peek() == map.get(s.charAt(i))){
                stack.pop();
                continue;
            }
            stack.push(s.charAt(i));
        }
        return stack.size() == 0;
    }
}

21、合并两个有序链表 

思路💡：借助一个中间指针，穿针引线

时间复杂度🕖：O（L），L 是链表的长度

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1==null) return list2;
        if(list2==null) return list1;

        ListNode dummy = new ListNode();
        ListNode cur = dummy;
        while(list1 != null && list2!=null){
            if(list1.val <= list2.val){
                cur.next = list1;
                list1 = list1.next;
            }else{
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        cur.next = list1==null?list2:list1;
        return dummy.next;
    }
}

23、合并K个有序链表

思路💡：把链表问题转为数组问题

时间复杂度🕖：O（n2）

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists ==null || lists.length==0) return null;
        List<Integer> list = new ArrayList<>();
        for(ListNode node : lists){
            while(node != null){
                list.add(node.val);
                node = node.next;
            }
        }
        Collections.sort(list);
        ListNode res = new ListNode();
        if(list.size()==0) return null;
        ListNode t = new ListNode(list.get(0));
        res.next = t;
        for(int n: list){
            t.next = new ListNode(n);
            t = t.next;
        }
        return res.next.next;
    }
}

24、两两交换链表中的节点

思路💡：把链表问题转为数组问题

时间复杂度🕖：O（n2）

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null || head.next==null) return head;
        // 1.把链表转为数组
        // 1.1求出链表的深度
        ListNode t = head;
        int len = 0;
        while(t != null){
            len++;
            t = t.next;
        }
        // 1.2 创建数组并赋值
        int[] arr = new int[len];
        int index = 0;
        t = head;
        while(t != null){
            arr[index++] = t.val;
            t = t.next;
        }
        // 2.交换数组(链表)中的节点
        for(int i=0;i+1<len;i+=2){
            swap(arr,i,i+1);
        }
        // 3. 把数组转为链表返回
        ListNode res =  new ListNode();
        ListNode a =  new ListNode(arr[0]);
        res.next = a;
        for(int i=1;i<len;i++){
            a.next = new ListNode(arr[i]);
            a = a.next;
        }
        return res.next;
    }
    void swap(int[] arr,int i, int j){
        arr[i] ^= arr[j];
        arr[j] ^= arr[i];
        arr[i] ^= arr[j];
    }
}

25、K个一组翻转链表

思路💡：把链表问题转为数组问题，使用双指针翻转元素

时间复杂度🕖：O（N）

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        // 1. 将链表转为数组
        ListNode t = head;
        int len = 0;
        while(t != null){
            len++;
            t = t.next;
        } 
        int[] nums = new int[len];
        t = head; // 重新初始化
        int index = 0;
        while(t!=null){
            nums[index++] = t.val;
            t = t.next;
        }
        // 比如3个一组，但是数组长度是5，我们只需要翻转前3个，因为剩下的凑不够一组
        int range = len/k*k;
        for(int i=0;i<range;i+=k){
            int l = i,r = i+k-1;
            while(l < r){ // 双指针翻转元素
                nums[l] ^= nums[r];
                nums[r] ^= nums[l];
                nums[l] ^= nums[r];
                l++;
                r--;
            }
        }
        ListNode res = new ListNode();
        ListNode a = new ListNode(nums[0]);
        res.next = a;
        // 把数组组合成链表
        for(int i=1;i<nums.length;i++){
            a.next = new ListNode(nums[i]);
            a = a.next;
        }
        return res.next;
    }

}

26、删除有序数组中的重复项

思路💡：快慢指针

时间复杂度🕖：O（N）

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length == 1) return 1;
        int l = 0,r = 0;
        while(r < nums.length){
            // 直到找到和左指针指向不同的值
            while(r<nums.length && nums[r]==nums[l])    r++;
            // 防止越界
            if(r >= nums.length) break;
            // 判断是否重复,把不重复的数据前移
            if(r - l > 1)   nums[l+1] = nums[r];
            l++;
            r++;
        }
        return l+1; // 返回去重后原数组的长度
    }
}

27、移除元素（快慢指针）

思路💡：使用两个指针，慢指针负责从索引 0 重新给数组赋值，快指针负责找非目标值

时间复杂度🕖：O（N）

class Solution {
    public int removeElement(int[] nums, int val) {
        int l = 0;
        for (int r = 0; r < nums.length; r++)
            if (nums[r] != val)
                nums[l++] = nums[r];
        return l;
    }
}

28、找出字符串中第一个匹配项的下标（字符串）

思路💡：substring 遍历

时间复杂度🕖：O（n * m），其中 n 是 haystack 的长度，m 是neddle 的长度

class Solution {
    public int strStr(String haystack, String needle) {
        for(int i=0;i<=haystack.length()-needle.length();i++){
            if(haystack.substring(i,i+needle.length()).equals(needle)){
                    return i;
            }
        }
        return -1;
    }
}

30、串联所有单词的子串

思路💡：使用回溯法得到数组元素的全排列，然后遍历字符串的子串查看是否能够匹配

时间复杂度🕖：

class Solution {
    boolean[] visits;
    HashSet<Integer> set = new HashSet<>(); // 因为数组中可能包含重复，所以全排列中可能有重复值
    List<Integer> ans;
    List<List<String>> tracks = new ArrayList<List<String>>();
    public List<Integer> findSubstring(String s, String[] words) {
        visits = new boolean[words.length];
        LinkedList<String> track = new LinkedList<>();
        backtrack(track,words);
        for (List<String> list : tracks) {
			StringBuilder sb = new StringBuilder();
			for(String word : list) {
				sb.append(word);
			}
			check(s,sb.toString());
		}
        ans = new ArrayList<Integer>(set);
        return ans;
    }
    public void check(String s,String ch) {
		for(int i=0;i<s.length();i++) {
			if(i+ch.length()<=s.length() && ch.charAt(0) == s.charAt(i) && s.substring(i,i+ch.length()).equals(ch)) {
				set.add(i);
			}
		}
	}
    public void backtrack(LinkedList<String> track,String[] words) {
		if(track.size()==words.length) {
			LinkedList<String> res = new LinkedList<>(track);
			tracks.add(res);
			return;
		}
		for (int i = 0; i < words.length; i++) {
			// if(track.contains(words[i])) continue; // 这里不能这么用，因为包含重复元素
			if(visits[i]) continue;
			track.add(words[i]);
			visits[i] = true;
			backtrack(track, words);
			track.removeLast();
			visits[i] = false;
		}
	}
}
让线程再跑一会
关注
  • 28
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode数组去重-algorithm::memo:解决算法问题
06-30
leetcode 算法研究 炫耀你的算法技能！ :) # 算法站点 您可以在 . #学习方法 每周选择 5-7 个问题并尝试解决它们！ 请查看彼此的代码以获得已解决问题的 PR。 当学习的顺利进行没有达到目标时 :money_bag: 注意有...
leetcode分类-Algorithm-Practice-EveryWeek:Algorithm-Practice-EveryWeek-算法
06-30
Algorithm-Practice-EveryWeek-算法更新每周 详细记录见 算法练习记录-天 目录 刷题时建议按类型刷题，参考刷题类型分类 同时已经这样在刷题的参考 2019Year 2019-07-06 更新TopN算法 参考文章见算法总结 2019-07-21...
每周算法（week 1）【leetcode1~10】
梦想是动物管理员
07-02 589
算法笔试练习 Week1：Leetcode 1~10
月のLeetCode 每周刷题之 Week1
sukiki09的博客
01-18 183
月のLeetCode 每周刷题之 Week1
月のLeetCode 每周刷题之 Week2
sukiki09的博客
01-26 635
月のLeetCode 每周刷题之 Week2
月のLeetCode 每周刷题之 Week4
sukiki09的博客
02-14 7787
目录 42. 接雨水 124. 二叉树中的最大路径和 剑指 Offer 03. 数组中重复的数字 剑指 Offer 04. 二维数组中的查找 剑指 Offer 05. 替换空格 剑指 Offer 06. 从尾到头打印链表 剑指 Offer 07. 重建二叉树 06. 从中序与后序遍历序列构造二叉树 剑指 Offer 09. 用两个栈实现队列 剑指 Offer 10- I. 斐波那契数列 剑指 Offer 11. 旋转数组的最小数字 剑指 Offer 13. 机器人的运动范围 剑指
月のLeetCode 每周刷题之 Week7
sukiki09的博客
03-06 302
目录 958. 二叉树的完全性检验 41. 缺失的第一个正数 918. 环形子数组的最大和 1114. 按序打印 1115. 交替打印 FooBar 329. 矩阵中的最长递增路径 7. 整数反转 24. 两两交换链表中的节点 1143. 最长公共子序列 最长公共子串 5. 最长回文子串 179. 最大数 129. 求根节点到叶节点数字之和 206. 反转链表 102. 二叉树的层序遍历 给定一个二叉树的root，确定它是否是一个完全二叉树。 在一个完...
月のLeetCode 每周刷题之 Week3
sukiki09的博客
02-04 687
142. 环形链表 II 给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 不允许修改 链表。 class Solution { public: ListNode *...
【LeetCode】每日算法-第2天
weixin_45088667的博客
01-15 259
题目1：计算银行的钱 Hercy 想要为购买第一辆车存钱。他 每天 都往力扣银行里存钱。 最开始，他在周一的时候存入 1 块钱。从周二到周日，他每天都比前一天多存入 1 块钱。在接下来每一个周一，他都会比 前一个周一 多存入 1 块钱。 给你 n ，请你返回在第 n 天结束的时候他在力扣银行总共存了多少块钱。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/calculate-money-in-leetcode-bank 著作权归领扣网络所有.
月のLeetCode 每周刷题之 Week6
sukiki09的博客
02-27 312
剑指 Offer 59 - I. 滑动窗口的最大值 目录 剑指 Offer 59 - I. 滑动窗口的最大值 剑指 Offer 59 - II. 队列的最大值 剑指 Offer 61. 扑克牌中的顺子 剑指 Offer 62. 圆圈中最后剩下的数字 剑指 Offer 63. 股票的最大利润 剑指 Offer 64. 求1+2+…+n 剑指 Offer 66. 构建乘积数组 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先 剑指 Offer 68 - II. 二叉树的最近公共祖先
月のLeetCode 每周刷题之 Week5
sukiki09的博客
02-20 209
目录 剑指 Offer 30. 包含min函数的栈 剑指 Offer 31. 栈的压入、弹出序列 面试题32 - I. 从上到下打印二叉树 剑指 Offer 32 - III. 从上到下打印二叉树 III 剑指 Offer 33. 二叉搜索树的后序遍历序列 剑指 Offer 34. 二叉树中和为某一值的路径 剑指 Offer 35. 复杂链表的复制 剑指 Offer 36. 二叉搜索树与双向链表 剑指 Offer 37. 序列化二叉树 剑指 Offer 38. 字符串的排列 剑指
leetcode题库-Algorithm:算法
06-29
leetcode题库 算法 leetcode 刷题历程，目录结构如下: [interview-questions]序号带面试的题目 [question-base]基础题库 [top-interview-questions-easy]初级算法 [util]Solution工具库，包含...[week*]每周的挑战赛
leetcode中国-quiz:每周小测
06-29
leetcode中国 每周小测 每周题目 week 1 adjust : 将数组中指定索引处的值替换为经函数变换的值 实现版本: ramda版本参考: groupAnagrams : 给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但...
左耳朵耗子leetcode-arts-week:ARTS=算法+评论+提示+分享
06-30
每周至少做一个LeetCode的算法题。主要是为了编程训练和学习。如果不训练看再多的算法书，依然不会做算法题。 R: Review 阅读并点评至少一篇英文技术文章。主要是为了学习英文，可以去或者各个公司的技术blog，找到...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 926
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 221
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 235
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 296
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

让线程再跑一会

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值