2021-6-7剑指笔记02

最新推荐文章于 2021-06-20 10:42:49 发布
最新推荐文章于 2021-06-20 10:42:49 发布
阅读量90 收藏 2
点赞数
分类专栏： 发发 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45020051/article/details/117669059
版权

笔记02

_21_和为s的连续正数序列

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]
示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

限制：

1 <= target <= 10^5

package LeetCode.笔记02;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class _21_和为s的连续正数序列 {
    /*
    借鉴和为s的两个数的方法：采用首尾双指针来求解，有序列至少有两个数，所以big最大为(1+target)/2
    * */
    public int[][] findContinuousSequence(int target) {
         if (target<3) return null;
        List<int[]> lists= new ArrayList<>();
        int small=1,big=2;
        int mid=(1+target)/2;
        while (small<big&&small<mid){
            //1~small-1   small~big
            // int sum=big*(big+1)/2-(small-1)*small/2;
            int sum=((small+big)*(big-small+1))>>1;//提交超时的原因是这里，两个乘法比一个乘法耗时间

            if (sum>target) small++;
            else if (sum<target) big++;//都是++
            else {
                int[] res=new int[big-small+1];
                 //int start=small; 少一个加法的时间
                 for (int i=small;i<=big;i++) res[i-small]=i;
                 lists.add(res);
                 small++;//继续寻找下一组
            }
        }
        return lists.toArray(new int[lists.size()][]);
    }

    @Test
    public void test(){
        int[][] res= findContinuousSequence(108160);
        for (int[] re : res) {
            for (int i : re) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }

}

_22_翻转句子中单词的顺序

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. “，则输出"student. a am I”。

示例 1：

输入: “the sky is blue”
输出: “blue is sky the”
示例 2：

输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：

输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

无空格字符构成一个单词。
输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

package LeetCode.笔记02;

import java.util.Arrays;

public class _22_翻转句子中单词的顺序 {

    /*
    官方解法：先旋转句子，再旋转单词
    左旋字符串：先旋转单词，再旋转句子，都是读句子的顺序罢了

    Java解法：直接用不加锁的stringbuild从后往前添加单词，左旋就是从前往后添加单词
    * */

    //从后往前，双指针定位，直接扫描一次
    public String reverseWords01(String s) {
        s=s.trim();//删除首尾空格
        int i=s.length()-1;
        int j=i;
        StringBuffer res = new StringBuffer();

        while (i>=0){
            while (i>=0&&s.charAt(i)!=' ') i--;//首个空格
            //[,)
            res.append(s.substring(i + 1, j + 1)).append(" ");//添加单词
            while (i>=0&&s.charAt(i)==' ') i--;//若前面还有空格，跳过单词间空格
            j=i;
        }
        return res.toString().trim();//去掉首尾空格
    }

}

_23_左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = “abcdefg”, k = 2
输出: “cdefgab”
示例 2：

输入: s = “lrloseumgh”, k = 6
输出: “umghlrlose”

限制：

1 <= k < s.length <= 10000

package LeetCode.笔记02;

public class _23_左旋转字符串 {

    public String reverseLeftWords(String s, int n) {
         if (s==null) return null;
         if (s.length()<n) return null;

        StringBuilder res = new StringBuilder();
        s=s.trim();
        //n=2 i=1 [0,2) [2,)
        res.append(s.substring(n,s.length())).append(s.substring(0,n));
        return res.toString().trim();
    }

}

_24_滑动窗口的最大值

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:

滑动窗口的位置 最大值

[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

package LeetCode.笔记02;

import org.junit.Test;

import java.util.ArrayDeque;
import java.util.Arrays;

public class _24_滑动窗口的最大值 {

    /*
    O(N)算法：单调队列    两端开口队列队列
    首部保留最大值，队列保存的下标，当首部元素下标与当前元素下标相差k即移出
    * */
    public int[] maxSlidingWindow(int[] nums, int k) {
            if (nums==null) return null;
            int len=nums.length;
            if (len<k) return null;
            if (len==0&&k==0) return new int[]{};//特殊
            if (k==1) return nums;
            ArrayDeque<Integer> deque = new ArrayDeque<>();
            int[] res=new int[len-k+1];
            deque.addFirst(0);
            int i=1;
            //先处理第一个窗口
            while (i<k){
                //和队首元素比较，看能不能直接替代
                if (nums[i]>=nums[deque.getFirst()]){
                    //说明之前的都不可能是最大值，，应该清空，因为有他们的窗口必有它
                    deque.clear();
                    deque.addFirst(i++);
                }
                //和队尾元素比较
                else {
                    //说明前面这个队尾不可能是最大值，应该去除
                    while (nums[i]>=nums[deque.getLast()]) deque.removeLast();
                    deque.addLast(i++);
                }
            }
            int j=0;
            res[j]=nums[deque.getFirst()];
            j++;
            //窗口移动i++ (不是队列移动)
            while (i<len){

                //入队前处理
                //1.判断队首元素还该不该存在
                if (i-deque.getFirst()>=k) deque.removeFirst();
                //2.
                if (nums[i]>=nums[deque.getFirst()]){//当k=1时会导致空
                    deque.clear();
                    deque.addFirst(i++);
                }
                else {
                    while (nums[i]>=nums[deque.getLast()]) deque.removeLast();
                    deque.addLast(i++);
                }
                res[j]=nums[deque.getFirst()];
                j++;
            }
            return res;
    }

    @Test
    public void test(){
        int[] nums={1,-1};
        int[] ints = maxSlidingWindow(nums, 1);
        System.out.println(Arrays.toString(ints));
    }

}

_25_队列的最大值

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入:
[“MaxQueue”,“push_back”,“push_back”,“max_value”,“pop_front”,“max_value”]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]
示例 2：

输入:
[“MaxQueue”,“pop_front”,“max_value”]
[[],[],[]]
输出: [null,-1,-1]

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5

package LeetCode.笔记02;


import java.util.ArrayDeque;

public class _25_队列的最大值 {

    //队列本身就有先进先出的特性，这点是不能改变的，所以需要借助上题滑动窗口增加一个队列保存最大值
    public ArrayDeque<Integer> deque=null;
    public ArrayDeque<Integer> dequeMax=null;

    public _25_队列的最大值() {
        deque= new ArrayDeque<>();
        dequeMax= new ArrayDeque<>();
    }

    public int max_value() {
        if (deque.size()==0) return -1;
        return dequeMax.getFirst();
    }

    //滑动窗口，单调队列思想
    public void push_back(int value) {
         deque.addLast(value);

         if (dequeMax.isEmpty()) dequeMax.addFirst(value);
         else {
             if (value>=dequeMax.getFirst()){
                 dequeMax.clear();
                 dequeMax.addFirst(value);
             }
             else {
                 while (value>=dequeMax.getLast()) dequeMax.removeLast();
                 dequeMax.addLast(value);
             }
         }

    }

    public int pop_front() {
        if (deque.isEmpty()) return -1;
        int value = deque.removeFirst();

        if (value==dequeMax.getFirst()) dequeMax.removeFirst();

        return value;
    }

}

_26_n个骰子的点数概率

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。

你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

示例 1:

输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]
示例 2:

输入: 2
输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]

限制：

1 <= n <= 11

package LeetCode.笔记02;
import org.junit.Test;

import java.util.Arrays;

public class _26_n个骰子的点数概率 {

    //可以将6提取出来，这样当厂商改变点数的时候可以拓展，但是面试写代码的时候为了简洁易懂就直接写6了

    /*
    基于循环实现：添加一个筛子，则点数和n是上一个次点数和n-1,n-2,n-3,n-4,n-5,n-6的和
    所以需要用两个数组循环实现
    * */
    public double[] dicesProbability(int n){
        if (n<1) return null;
        int[][]  point=new int[2][6*n+1];
        int flag=0;
        //扔第一个筛子初始化数组
        for (int i=1;i<=6;i++) point[flag][i]=1;
        //循环
        for (int k=2;k<=n;k++){
            flag=1-flag;
            //全部归零
            Arrays.fill(point[flag],0);
            for (int i=k;i<=k*6;i++){
                for (int p=1;p<=6;p++){
                  if (i-p>=(k-1)) point[flag][i]+=point[1-flag][i-p];
                }
            }
        }

        double[] res = new double[6 * n - n + 1];
        double all=Math.pow(6,n);
        for (int i = 0; i < 6 * n - n + 1; i++) {
            res[i]=(double) point[flag][i+n]/all;
        }
        return res;
    }


    @Test
    public void test(){

        double[] doubles = dicesProbability(3);
        System.out.println(Arrays.toString(doubles));

    }




    //点数和：n~6n 用一个6n-n+1的数组存
    public double[] dicesProbability02(int n) {
         point=new int[6*n-n+1];
         N=n;
         int[] sum=new int[1];
         pointSum(1);
         double[] res = new double[6 * n - n + 1];
         double all=Math.pow(6,n);
         for (int i = 0; i < 6 * n - n + 1; i++) {
            res[i]=(double) point[i]/all;
         }
         return res;
    }
    public int N=0;
    public int Sum=0;//设为全局变量，提交通过，设为参数超时
    public int[] point=null;
    public void pointSum(int n){//1-n的骰子的点数和
        if (n==N+1){
            point[Sum-N]++;
            return;
        }
        for (int i=1;i<=6;i++){
            Sum+=i;
            pointSum(n+1);
            //回溯
            Sum-=i;
        }

    }


}

_27_扑克牌中的顺子

从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

示例 1:

输入: [1,2,3,4,5]
输出: True

示例 2:

输入: [0,0,1,2,5]
输出: True

限制：

数组长度为 5

数组的数取值为 [0, 13] .

package LeetCode.笔记02;

import java.util.Arrays;

public class _27_扑克牌中的顺子 {

    /*
    这几道题考查的都是对实际问题的数学建模能力:
    0 2 4 5 6
    1.排序
    2.统计0的个数
    3.统计空缺的个数(相邻两个数，如果相等的则直接false) 4-2-1=1
    4.0的个数大于等于空缺的个数
    * */
    public boolean isStraight(int[] nums) {
          if (nums==null) return false;
          if (nums.length<5) return false;
          Arrays.sort(nums);
          int count0=0;
          int i=0;
          while (i<5){
              if (nums[i]==0){
                  count0++;
                  i++;
              }
              else break;
          }
          int vacant=0;
          while (i<4){
              if (nums[i]==nums[i+1]) return false;
              vacant+=nums[i+1]-nums[i]-1;
              i++;
          }
          return count0>=vacant;
    }

}

_28_圆圈中最后剩下的数字

0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

示例 1：

输入: n = 5, m = 3
输出: 3
示例 2：

输入: n = 10, m = 17
输出: 2

限制：

1 <= n <= 10^5
1 <= m <= 10^6

package LeetCode.笔记02;

import java.util.ArrayList;

public class _28_圆圈中最后剩下的数字 {
    /*
    约瑟夫问题：两种解决方案
    1.环形链表  O(n)
    2.找规律  找映射
    * */
    public int lastRemaining02(int n, int m) {
        if (n==0) return -1;
        //LinkedList<Integer> list = new LinkedList<>();
        ArrayList<Integer> list = new ArrayList<>();
        for (int i=0;i<n;i++) list.add(i);
        int p=0;
        while (n>1){
            p=(p+m-1)%n;//循环的正确表示方式
            //查找时间用数组会更好
            list.remove(p);
            n--;
        }
        return list.get(0);
    }

    public int lastRemaining(int n, int m){

        int ans=0;
        //最后一轮只剩下2个人，所以从2开始反推
        for (int i=2;i<=n;i++) ans=(ans+m)%i;
        return ans;
    }


}

_29_股票的最大利润

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

package LeetCode.笔记02;

import org.junit.Test;

public class _29_股票的最大利润 {
    /*
    O(N):一次扫描，用d(i)保存第i个数字卖出，需要一个临时变量记录前面的最小值，还有一个最大值
    * */
    public int maxProfit(int[] prices) {

        if (prices==null) return -1;
        if (prices.length==0) return 0;

        int min=prices[0];
        int max=Integer.MIN_VALUE;
        for (int i=1;i<prices.length;i++){
            if (prices[i]-min>max) max=prices[i]-min;
            if (prices[i]<min) min=prices[i];
        }
        return Math.max(max, 0);//利润有可能为负
    }

    @Test
    public void test(){
        int[] prices={7,6,4,3,1};
        int i = maxProfit(prices);
        System.out.println(i);
    }

}

_30_不用乘除循环求1到n的和

求 1+2+…+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

示例 1：

输入: n = 3
输出: 6
示例 2：

输入: n = 9
输出: 45

限制：

1 <= n <= 10000
通过次数113,271提交次

package LeetCode.笔记02;

import org.junit.Test;

public class _30_不用乘除循环求1到n的和 {
    /*
    return  (int) (Math.pow(n,2)+n)>>1;
    要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）
    1.利用构造函数(C++)
    2.递归  O(N)
    3.利用二进制位运算：俄罗斯农民乘法 O(logN)
    * */

    public int sumNums01(int n) {

        //return n==0?0:n+sumNums(n-1);
        //可用&&和||来替换 A&&B A为false B不执行， A||B A为true B不执行
        boolean flag=n>0&&(n+=sumNums01(n-1))>0;
        return n;
    }

    /*
    (n+1)n>>1  考虑A*B使用位运算
    如果B的二进制表示下第i位为 1，那么这一位对最后结果的贡献就是 A*(1<<i)A∗(1<<i) ，即 A<<i,最后累加即可
    又因为不能用循环，但是n<10,000 二进制表示 14位绰绰有余
     */
    public int sumNums(int n) {
        int ans=0,A=n,B=n+1;
        boolean flag;
        // 有贡献吗？
        int i=0;
        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        flag = ((B & 1) > 0) && (ans += (A<<i)) > 0;
        B>>=1;
        i++;

        return ans >> 1;

    }

    @Test
    public void test(){

//        System.out.println(sumNums01(4));
        int i = sumNums(4);
        System.out.println(i);

    }


}
轻舟一曲
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第一次作业
weixin_44387346的博客
01-04 235
一：两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1...
lrucacheleetcode-LeetCode:JavaSolutionforLeetCode&剑指Offer
06-29
lru缓存leetcode剑指报价题库列表 --> IO实践--> 力扣问题列表 二进制搜索 解决方案 问题编号 困难 笔记 简单的 简单的 排序数组中最近的 赖十七： 中等的 中等的 找到 K 个最近的元素 中等的 找到大于目标的...
力扣刷题记录 （七）动态规划（五）子序列系列
是鲤鱼啊
06-15 539
① 题号300.最长递增子序列 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：num...
leetcode刷题——算法（7）:动态规划
qq_37772475的博客
02-20 1277
动态规划 斐波那契数列 1. 爬楼梯 第一次做出Ok 注意递归可能超时 2. 强盗抢劫 修改后Ok， 可简化 3. 强盗在环形街区抢劫（2.19） ...
leetcode解题思路分析（三十）214—220题
ty的博客
06-25 492
最短回文串 给定一个字符串 s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。 本题可以用马拉车去取最长回文子串，然后反向添加。也可以采用KMP解决 class Solution { public: string shortestPalindrome(string s) { int n = s.size(); string rev(s); reverse(rev.begin(), rev.end(.
Leetcode 每日一练
lkking的博客
07-26 179
数组中两元素的最大乘积 给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使 (nums[i]-1)*(nums[j]-1) 取得最大值。 请你计算并返回该式的最大值。 示例 1： 输入：nums = [3,4,5,2] 输出：12 解释：如果选择下标 i=1 和 j=2（下标从 0 开始），则可以获得最大值，(nums[1]-1)(nums[2]-1) = (4-1)(5-1) = 3*4 = 12 。 示例 2： 输入：nums = [1,5,4,5] 输出：16 解释：选择下标 i=
leetcode好还是牛客网好-jianzhi-offer-js:剑指Offer笔记本JS版本
07-06
剑指Offer createdAt modifiedAt tags pinned 2020-05-14 10:48:10 UTC 2020-05-18 13:37:24 UTC true 剑指Offer 笔记本 JS 版本 - 可离线阅读 我打好了一些标签。 由于 Leetcode 的题目太多，所以这里选中了《剑指...
leetcode分类-LeetCode:力扣笔记/剑指offer
06-30
leetcode 分类 LeetCode 力扣笔记，语言为c++ 其中有根据题目难度划分的Easy、Medium分类，多为模拟题目 除此外还有根据题目类型的专项分类，多涉及数据结构、基础算法 剑指offer
303-java-offter:「剑指Java面试-Offer直通车」学习原始码及笔记
03-23
2-6 TCP的滑窗试看 2-7 HTTP相关 2-8 HTTP相关_2 2-9 HTTP和HTTPS的区别 2-10插座相关 2-11网络知识总结 2-12彩蛋之走进面试官的世界 3-1数据库架构 3-2优化您的索引-使用二叉查找树 3-3优化你的索引-运用B树 3-4...
《剑指offer笔记》
09-21
在找工作的时候，经常会遇到算法题，剑指offer从头到尾的每一题的代码笔记全有记录，希望能帮到大家，谢谢； 《剑指Offer:名企面试官精讲典型编程题》剖析了50个典型的程序员面试题，从基础知识、代码质量、解题思路...
给定一个按照升序排列的整数数组 nums，和一个目标值 x。找出给定目标值在数组中的开始位置和结束位置。
qq_51339153的博客
10-31 1624
先从前面找这个数字的第一次出现，然后从后往前找这个数字的出现最后一次（当第一次找不到，就没必要继续找了） public int[] searchRange(int[] nums, x) { int[] array = {-1,-1}; for(int i = 0;i < nums.length;i++) { if(nums[i] == x){ array[0] = i ; break; } if(array[0] == -1){ //当第一次找不到的时候，就不用再找了； return array;
LeetCode第53题 最大子序和 动态规划
覃会程的博客
02-03 189
文章目录问题描述：解题思路：代码实现： 问题描述： 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 解题思路：   使用动态规划求解，这题需要注意的是dp[i]表示的是以nums[i]结尾的所有子序列中的最大和；即dp[length-1]并不是想要的结果，结果应该是dp数组中的最大值，我
10.28 LeetCode周总结(1~7题)
wsxye18730291676的博客
10-28 217
10.28 LeetCode周总结 1、两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 =...
六大搜索算法
m0_45020051的博客
12-04 4452
宽度优先搜索算法BFS题目描述图信息存储树的构建以及图的实现代码无信息搜索策略宽度优先搜索算法BFS 题目描述 使用搜索算法实现罗马尼亚问题的求解 1：创建搜索树； 2：实现搜索树的宽度优先搜索，深度优先搜索，一致代价搜索，迭代加深的深度优先搜索算法； 3：实现贪婪最佳优先搜索和A*搜索 4：使用编写的搜索算法代码求解罗马尼亚问题； 5：记录各种算法的时间复杂度并绘制直方图 图信息存储 树的构建以及图的实现代码 搜索树中的树结点定义： 在搜索树中，每一个树结点应该记录的信息包括： 该树结点的代价估计
计网学习笔记
m0_45020051的博客
06-20 812
百度，阿里，腾讯，美团，京东。 练题不要瞎练习：要有针对性 面试记录 2021.6.2 介绍项目， 数据库(聚簇索引，引擎有哪些，特点是什么，底层实现结构B+)； 数据结构(用过哪些数据结构HashMap,PriorityQueue,ArrayList)，没答：LinkedList,HashSet,Vector,ArrayDeque…HashMap回答的时候因为不懂所以没有回答得很仔细，但是正常面试中这个应该可以扯很多。 算法题(堆查找，堆是完全二叉树吗)，没考虑剪枝，函数返回值为b.
2021-6-14-DRAPA网
m0_45020051的博客
06-14 184
DRAPA网DRAPA网IP层基础目标二级目标面对网络失败的应对服务类型广泛的网络技术其他目标数据报 述：以下为计算机网络老师笔记，暂存以后阅读。 Internet最早来源于美国国防部高级研究计划局DARPA(Defense advanced Research Projects Agency)的前身ARPA建立的ARPAnet，该网于1969年投入使用。从60年代开始，ARPA就开始向美国国内大学的计算机系和一些私人有限公司提供经费，以促进基于分组交换技术的计算机网络的研究。1968年，ARPA为ARPAn
2021-6-11-HashMap面试笔记
m0_45020051的博客
06-11 139
HashMap 红黑树原理源码讲解 HashMap源码分析系列 基础 散列表：数组+链表； 整合了数组快速索引和链表快速插入扩容的特性。 散列表–>哈希 哈希：也称散列，哈希对应的英文都是hash，基本原理就是把任意长度的输入，通过哈希算法变成固定长度的输出。这个压缩映射规则就是对应的哈希算法，而原始的数据映射后的二进制串就是哈希值。 Hash特点： 从hash值不可以反向推导hash原始的数据； 输入数据的微小变化会得到完全不同的hash值，相同的数据会得到相同的值； 哈希算法的执行效率要高效
2021-6-13-剑指笔记01
m0_45020051的博客
06-13 81
笔记01 _11_返回倒数第k个节点 实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。 注意：本题相对原题稍作改动 示例： 输入： 1->2->3->4->5 和 k = 2 输出： 4 说明： 给定的 k 保证是有效的。 package LeetCode._面试经典.笔记01; public class _11_返回倒数第k个节点 { public class ListNode { int val; ListNode ne
Cortex-M3 Embedded Software Development - Application Note 179
最新发布
02-26
"Cortex-M3嵌入式软件开发 - 应用笔记179" 本文档，"Cortex-M3 Embedded Software Development - Application Note 179"是ARM Limited发布的一份技术应用笔记，主要针对Cortex-M3微处理器的嵌入式软件开发。文档...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值