算法系统练习

已于 2023-11-05 22:43:05 修改
阅读量132 收藏
点赞数 1
文章标签： 算法 开发语言 柔性数组
于 2023-10-17 22:48:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN1QWE/article/details/133895682
版权

学习目标：

  • 一周算法训练 （10.17-10.22）
  • 一周算法训练（10.23-10.29）{未完成，一周不知道在忙啥}
  • 一周算法训练（10.30-11.5）

学习内容：

每天至少刷一道题

学习时间：

Everyday

学习产出：

一周至少五篇算法笔记

力扣： 27. 移除元素

题目：
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

题目分析：
这是一个时间复杂度为O(n)的双指针算法
定义了两个指针：
1.快指针：用于扫描初始数组元素
2.慢指针：为了更新数组（也可以称为新数组赋值）
首先用快指针遍历数组，当fast指针指向的数组元素不是目标元素时，就让low指针为新数组赋值为fast指针指向的元素 。

 public int removeElement(int[] nums, int val) {
        int slow=0;
        for(int fast=0;fast<nums.length;fast++){
            if(nums[fast]!=val){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        return slow;
    }

力扣：977. 有序数组的平方

题目：
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
题目分析：

  1. Reading problem ：得知会给你一个数组并且是一个递增数组（包含正数负数的递增数组），要求返回一个数组每个元素平方后的递增数组
  2. To begin with：我们会第一时间想到暴力方法：先将数组每个元素平方，然后再来个快排。其时间复杂度取决于排序方法的时间复杂度
  3. What’s more : 我们将使用一个时间复杂度仅为O(n)的方法，那就是双指针法
    1.首先创建一个新数组和传入的数组长度一样，目的是将原数组由大到小处理
    2.定义k用于指向新数组的尾部，由大到小处理的缘故
    3.for循环定义两个指针，用于分别指向原数组的头部和尾部，循环条件是这两个指针不能超过对方
    4.执行条件为当头指针指向元素的平方大于尾指针指向元素的平方时将较大的那个数的平方存到k指针指向的位置，头指针++
    5.另一个条件即为上面条件相反的情况，尾指针–
  4. 上面两个条件任意一个条件都可包含相等的情况：因为当指向的那两个元素只会出现先存入一个的情况，未存入的元素会进行下一次循环（这边是需要理解一下，其实糊里糊涂写完发现还是能过的不过要搞清楚才好）
class Solution {
    public int[] sortedSquares(int[] nums) {
        int [] result=new int [nums.length];
        //指向新数组的最后一个元素
        int k=nums.length-1;
        for(int i=0,j=nums.length-1;i<=j;){
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                result[k--]=nums[i]*nums[i];
                i++;
            }else{
                result[k--]=nums[j]*nums[j];
                j--;
            }
        }
        return result;
    }
}

LCR 008. 长度最小的子数组

题目：
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
题目分析：

  1. Reading problem :给定一个数组和整数，要求在数组中找到连续的元素和大于等于这个给定的整数，符合条件则返回最短长度，不符合条件则返回0

  2. 首先想到的思路就是双层for循环，接着找两个存储元素个数的变量，里层for循环获取元素和，外层for循环控制每层for循环的元素减少。不过要及时控制里层for循环的结束。

  3. 这里我们用到的是双指针法-滑动窗口。

  4. 要明白i 和 j 的两个变量的含义 ；j具体代表的是初始位置呢还是结束位置呢？
    1.假设j代表的是初始位置那么和暴力解法有啥区别呢？

  5. 因此i代表滑动起始位置，j代表结束位置：

  6. 首先遍历元素，并求和，当sum>=给定的整数时进行滑动窗口或者说剪枝，从头部开始滑动，（可能有人问为什么不从尾部滑动，因为尾部是我们刚好满足sum>=target的条件，滑动尾部不就马上不满足条件了）

  7. 滑动的思路大概就是：先获取你目前窗口的长度，并且与你之前的窗口做比较，紧接着就是滑动：sum-窗口第一个元素，窗口索引++

  8. 我们需要考虑滑动窗口的执行是if 还是 while 呢？

  9. 想当然那就是while，因为你不确定你执行一次剪枝后是否为最短长度，只有执行到不满足条件结束才能确保不满足条件的前一次是最短的。

  10. 有些人看到代码还是有些不明白 。可能会考虑到这个j不是从0遍历到数组最后一个元素吗？那为什么会有j会有固定结束位置呢？其实固定结束位置（窗口最短长度）是我们用变量保存起来的，当你在前面数组元素中遍历到最短窗口但是你不清楚后门数组是否有更短的窗口，所以我们提前将我们目前已知最短长度保存起来了，到后面我们获取到后半部分数组中最短窗口长度后进行一个比较。因此这个j的位置是与你所参考的位置不同导致j的含义不同的。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //i是滑动窗口的起始位置
        int i=0;
        //result初始化值为自定义的最大值
        int result=Integer.MAX_VALUE;
        int sum=0;
        int sub=0;
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];
            while(sum>=target){
                sub=j-i+1;
                //与之前的最短窗口进行比较
                result=Math.min(result,sub);
                //剪枝或者滑动
                sum=sum-nums[i];
                //滑动
                i++;
            }
        }
     
        return result==Integer.MAX_VALUE ? 0:result;
    }
}

LCR203. 移除链表元素

**题目：
**给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
题目分析：

  1. 就是一道最基本的单链表元素删除，一定要看清楚题目是单链表，这三个测试案例基本上涵盖了所有的特殊情况
  2. 首先看第二个测试案例，当我们的头节点为空时直接返回头节点就行；
  3. 看第三个测试案例，当头节点和其他结点的值都为目标值，这时我们需要额外注意的特殊情况，我们的操作条件就是当头节点等于目标值并且当头节点的下一个结点不为空时，我们直接将下一个结点覆盖为头节点即可，返回执行直至不满足条件，那就需要用到while。
  4. 第一个测试案例就是我们最基本的删除元素情况。这个情况时我们需要用到一个临时结点来遍历整个链表，如果不使用临时结点，用头节点遍历会出现啥情况呢？当我们有三个结点时，第三个结点为要删除的目标结点，那该如何遍历到第三个结点呢？用head=head.next。那就会导致头部结点被覆盖，最终会导致整条链表混乱。所以单链表遍历必须用到临时结点。
  5. 有些人不懂我们创建一个临时变量存储初始值为头节点，那这个临时结点为什么还有.next？因为头节点封装时就是有两个属性一个为int值另一个为next属性。当将临时结点存储头节点时，同时具备了头节点的所有能力和所有关系。
  6. 删除头节点的操作在上面我们已经进行了，接下来操作就是删除除头节点的操作。 因此第三个测试用例，我们该如何遍历删除呢，首先创建临时结点保存头节点，我们执行的条件是啥呢？必然有一个当前节点不为空，另一个可想而知就是当前节点的下一个结点不为空（必须要有一个条件，当我们用到下一个结点时并且下一个结点不为空，那么就会出现空指针异常），在这当前节点就是临时结点。当我们遍历到当前结点的下一个结点为目标结点时，直接将当前结点的下一个结点指向当前结点的下下个结点。如果当前结点的下一个结点不是目标结点，要向下继续遍历那么就是当前结点指向当前节点的下一个结点。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
    while(head!=null&&head.val==val){
        head=head.next;
    }
    if(head==null){
        return head;
    }
    ListNode cur=head;
    //利用临时结点删除，因为是单链表
    while(cur.next != null){
        if(cur.next.val==val){
            cur.next=cur.next.next;
        }else{
             cur=cur.next;
        }
        }
    return head;
    }
}

LCR82. 删除排序链表中的重复元素 II

题目：
给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。
示例 1：
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
示例 2：
输入：head = [1,1,1,2,3]
输出：[2,3]
初做反思：

  1. 刚拿到题目时，我认为需要几种特殊情况，当头节点与后续节点相同时，当后续节点有相同值。但是没想到合适的变量来处理这些关系，怎么删除也删除不干净。
  2. 我发现行不通，接着转换思想，那我们在数组中如何删掉重复元素，只留下不同数字呢？我就打开Idea操作？发现需要用到一个新的容器来存放不同数字。那该如何对比相不相同的数字呢？
  3. 获取第一个元素，并保留第一个元素的值，接着向下遍历，遇到不同则保存，相同则跳过。
  4. 但是我无法将数组的思想应用到链表中，原因归咎于本身对链表的掌握程度不够

题目分析：

  1. 我们需要一个虚拟节点放在头节点的前面，因为我们无法像数组那么直接操作第一个元素。接着创建辅助结点用来遍历虚拟结点。
  2. 我们从指针 cur 指向链表的虚拟节点，随后开始对链表进行遍历。当cur.next和cur.next.next的值相等时，我们将cur.next及以后所有的相同元素的节点全部删掉。具体如何删掉呢，我们需要将判断相等后的值存储下来，然后向后遍历，当相等时将自身指向下一个节点，直至cur.next节点不等于存储下来的值。
  3. 当两个节点元素不相等时，我们直接向下遍历。
  4. 最后返回虚拟节点的下一个节点。

时间复杂度为O（n），空间复杂度为O（1）。即使两个嵌套while但是每次循环要么删除一个节点，要么向右移动，所以循环次数为O(n)

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null){
            return head;
        }
       ListNode dunny=new ListNode(0,head);
       ListNode cur=dunny;
       //第一个结点和下一个结点
       while(cur.next!=null&&cur.next.next!=null){
            if(cur.next.val==cur.next.next.val){
                int x=cur.next.val;
                while(cur.next!=null && cur.next.val==x){
                    cur.next=cur.next.next;
                }
            }else{
                cur=cur.next;
            }
         }
        return dunny.next;
    }
}

LCR707. 设计链表

**题目：**你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

思路：

  1. 本题目我是用了单链表结构，运用前驱节点的思想
  2. 首先创建节点类，补充成员变量和1构造方法。
  3. 初始化链表
  4. int get(int index) 方法。首先处理特殊情况当传入的索引不合法则直接返回。接着就用到了前驱节点：ListNode pred=head; 这并不是将head的值赋值给前驱节点，而是将前驱节点指向head（目前我是这么理解点，其实还是有点不懂）。接着往下遍历直至遍历到目标索引的前驱节点。
  5. void addAtIndex(int index, int val)。首先判断特殊情况和题目要求的特殊情况。还是利用前驱节点。遍历到目标位置是需要执行的操作为 ：
    toAdd.next = pred.next;
    pred.next = toAdd;
  6. void deleteAtIndex。和前几个思想基本一致，前驱节点的思想。
class ListNode{
        int val;
        ListNode next;
        ListNode(){}
        ListNode(int val){
            this.val=val;
        }
    }
class MyLinkedList {
    int size;
    ListNode head;
   
    public MyLinkedList() {
        size=0;
        head=new ListNode(0);
    }
    
    public int get(int index) {
        //索引下标非法 返回-1;
        if(index < 0 || index >=size){
            return -1;
        }
        //
        ListNode pred=head;
        for(int i=0;i<=index;i++){
            pred=pred.next;
        }
        return pred.val;
    
    }
    
    public void addAtHead(int val) {
        addAtIndex(0, val);
         
    }
    
    public void addAtTail(int val) {
         addAtIndex(size, val);
       
    }
    
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }
    
    public void deleteAtIndex(int index) {
     if (index < 0 || index >= size) {
            return;
        }
        size--;
       if (index == 0) {
            head = head.next;
	    return;
       }
       ListNode pred=head;
       for(int i=0;i<index;i++){
           pred=pred.next;
       }
       pred.next=pred.next.next;
       
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

LCR 024. 反转链表

题目：
给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例2：
输入：head = []
输出：[]
思路：

  1. 双指针的思想，前面我们对数组的操作很多都是双指针操作，那么本题难度其实不是思想，而是当把对数组的操作改为对链表的操作
    这是双指针的操作流程
  2. 这里其实有很多细节需要我们注意。首先是当我们什么时候结束遍历 1.cur.next!=null（这样会导致空指针异常，其实很好理解。当我们head头节点为空时，那么引用了head.next那么必然会导致空指针异常。）2.cur！=null(只能用这个条件了)
  3. 另外个需要注意的是：在第一次操作后我们该如何为cur 和 pre 赋值呢 ？ 这里我们用到了temp遍历存储cur.next的值。（为什么要先将值存起来呢？？）因为当我们将cur.next指向pre时这个节点的原本指向下一个节点的这个线就会断了，导致失去联系，所以我们需要先将后一个节点存储来。
  4. 下一步就是将pre后移，在将temp赋值给cur。这个操作顺序是不可以改变的。要不然会导致cur数据丢失。
  5. 最后返回pre节点。为什么要返回pre看图就可明白了。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 //双指针
class Solution {
    public ListNode reverseList(ListNode head) {
    ListNode cur=head;
    ListNode pre=null;
    ListNode temp=null;
    while(cur!=null){
        temp=cur.next;
        cur.next=pre;
        pre=cur;
        cur=temp;
    }
    return pre;
    }
    
    //递归写法
     public static ListNode recursion(ListNode cur,ListNode pre ,ListNode temp){
        if(cur==null){
            return pre;
        }
        temp=cur.next;
        cur.next=pre;
        pre=cur;
        cur=temp;
        return recursion(cur,pre,temp);
    }
}

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

题目：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
题目分析：
这里我们用到了虚拟头节点的方法：
在这里插入图片描述

  1. 这里我们先定义了一个虚拟头节点，用来指向head节点。
  2. 我们只能操作两个节点。当为链表节点个数为奇数时，最后一个节点我们是不需要操作的。只有个数为偶数个时才会全部操作
  3. 当我们要修改第一个节点的指向（不包括虚拟节点）一定要直到前一个结点的指向，因此我们需要用到虚拟头节点.
  4. 我们只有先将虚拟结点指向第二个节点（除虚拟节点外的）,这里需要提前存储一下第一个节点和第三个节点。只有这样才能保持连接。因为我们保存了第一个节点我们就可以直接将第二个节点指向第一个节点，
  5. 最后需要更新cur的值，为被操作节点的前一个节点。
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy= new ListNode(-1);
        dummy.next=head;
        ListNode cur=dummy;

        ListNode temp1=null;
        ListNode temp2=null;
        while(cur.next!=null&&cur.next.next!=null){
            temp1=cur.next;
            temp2=cur.next.next.next;
            cur.next=cur.next.next;
            cur.next.next=temp1;
            temp1.next=temp2;
            cur=temp1;
        }
        return dummy.next;
    }
}

19. 删除链表的倒数第 N 个结点

题目：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
题目分析：

  1. 首先我拿到题目的思路是：自定义一个方法获取链表的总长度，然后总长度减去n，得到的不就是我们正方向的顺序吗？但是用这个思路你会陷入很多坑，分不清第一步是0还是1，让人头大，还会时不时的空指针。
  2. 接下来就是另一种思路。我们打个比方在一列孩子中找出倒数第n个孩子。并且我们我们无法得知这一列孩子的总数。我们该怎么办呢？（每个孩子之间间隔一米）
  3. 我们可以向别的班借两个孩子，先让第一个孩子跑n米（停下），接着让第二个孩子和第一个孩子同时以同样的速度起跑，当第一个孩子到达终点时停止运动。这时第二个孩子所在的位置就是我们要找的倒数第n个孩子
  4. 那么我们在链表中该如何操作呢？在之前我们知道删除节点需要知道要删除节点的前一个节点，让前一个节点指向要删除节点的下一个节点。删除工作及完成
  5. 用到了虚拟头节点的思想，我们要知道删除节点的前一个结点，即我们需要快指针先走n+1步
  6. 那当什么时候我们停止快指针的运动，然后和慢指针一起运动呢？那就是当n–>0并且快指针并未到达末尾。（这里我们需要考虑为什么不是n–>=0?其实当它等于0时还是满足条件还会接着往下走一步，这一步就会影响慢指针的位置，）
  7. 如果理解不了可以画图看看
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode fast=dummy;
        ListNode low=dummy;
        n++;//让fast指针多走一步，提前进入空节点（即末尾的后面的空节点
        while(n-->0&&fast!=null){
            fast=fast.next;
        }
        while(fast!=null){
            fast=fast.next;
            low=low.next;
        }
        low.next=low.next.next;
        return dummy.next;
    }
}

LCR 022. 环形链表 II

题目：
给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

题目分析：

  1. 本题依旧是双指针的思想。定义快慢指针，快指针一次走两个结点，慢指针一次走一个结点。如果有环他们必定相遇，否则就不会相遇。当有环时：快指针的速度想对于慢指针只走了快走了一个节点，不会把慢指针绕过去，但是当快指针一次走三节点可能就会出先问题
  2. 看下图，标出了x,y,z分别表示：头节点到入口的距离，入口到第一次相遇的距离，相遇点到入口的距离。我们可以根据速度差得出:2*(x+y)=x+y+n*(y+z)。接着我们根据公式推出x到底与哪个整数有关系，如下图
    在这里插入图片描述
  3. 基本的关系都在图上。加上当第一圈就会相遇。我们令n=1则得出x=z。（不是说只能令n=1也可以是别的，只是没有当等于1时直观罢了。）
  4. 代码如下，基本上看上图思路就可以写出来了。
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast=head;
        ListNode low=head;
        while(fast!=null&&fast.next!=null){//因为fast指针在low指针的前面仅需这个条件即可
            fast=fast.next.next;
            low=low.next;
            if(fast==low){
                ListNode index1=fast;
                ListNode index2=head;
                while(index1!=index2){//这个条件判定是否到达入口
                    index1=index1.next;
                    index2=index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

哈希表应用

  1. 当什么情况下会用到哈希表呢？当题目给出元素是否在某一个序列中存在的这种情况，我们需要考虑用哈希表篇
  2. 哈希表有三种应用情况：1.数组 2.set 3.map
  3. 数组的应用情况：当给出的数据分布较集中，可以考虑到数组映射
  4. set的应用情况：给出的数据较为分散，容易导致空间浪费
不勤奋
关注
整理了适合新手的20个Python练手小程序
QGH9507的博客
11-18 5382
100个Python练手小程序，学习python的很好的资料，覆盖了python中的每一部分，可以边学习边练习，更容易掌握python。 本文附带基础视频教程：私信回复【基础】就可以获取的 【程序1】 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条...
【蓝桥杯练习题】入门训练
(｡◕‿◕｡)
03-13 1536
序列求和 问题描述 求1+2+3+…+n的值。 输入格式 输入包括一个整数n。 输出格式 输出一行，包括一个整数，表示1+2+3+…+n的值。 样例输入 4 样例输出 10 样例输入 100 样例输出 5050 数据规模与约定 1 &lt;= n &lt;= 1,000,000,000 这个题如果是累加计算提交会显示超时，所以最好的方法是用数学公式计算。。。。。还...
蓝桥杯练习系统（算法训练）ALGO-973 唯一的傻子
m0_73801775的博客
03-12 333
这样一个过程持续了n-1次，那么显然，最后只剩下了一个人。腿铮找2255有点事，但2255太丑了，所以腿铮不知道他的长相。思路：剩下的最后一个即为2255，所以第n-1次输入的两个数中一定有2255，而他是剩下的，因此要删除另一个，所以，前面的那个就是2255。内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s。每次走有效的k步（被删除的也要走，但是是无效的），但是会运行超时。第一行一个n，表示计33班的人数。
练习C简单的代码
m0_69952128的博客
07-23 7585
1.判断一个数是否为奇数 2.输出1-100之间的奇数 3.计算n的阶乘4.计算1！+2！+3！...+10! 5.在一个有序数组中查找具体的某个数字n 6.编写代码，演示多个字符从两端移动，向中间汇聚 7.获得月份天数 8.统计输入的10个数，正数、负数、零的个数...9.调整奇数偶数顺序............
Java 小实验题
qq_40307529的博客
06-03 350
子类KY4_4继承父类 KY4_3，其不仅具有父类的成员变量 xm（姓名）、xh（学号），还定义了新的成员变量 xy（学院）、xi（系）。在子类KY4_4中重写了父类的方法print()，在该方法中不仅输出学生的姓名和学号，而且还输出学生的学院和系。另外，在子类KY4_4中还定义了一个主方法main。首先，在主方法中创建一个父类 KY4_3的对象f，设置f的姓名为"帅零"，学号为"12321"，并...
蓝桥杯练习系统——算法训练解答
m0_49074706的博客
04-01 1022
练习1：Sereja and Equality 问题描述： (注：这是codechef上的官方翻译) 　　佳佳称两个长度为n的数组A,B相似，如果对于所有i(1≤i≤n)，满足C(A,Ai)=C(B,Bi)。其中C(X,x)等于满足X[j]<x(1≤j≤n)的j的数目。 　　对于两个排列P1,P2，佳佳定义函数F(P1,P2)等于满足P1[l…r]相似于P2l…r并且P1[l…r]包含不超过E个逆序对的数对(l,r)的数目。 　　现在佳佳对下面这个问题发生了兴趣：对P1,P2取遍所有n个元素的排列F(
处理机调度算法巩固练习
四块的博客
12-21 1475
处理机调度算法巩固练习 1.单道批处理系统中，有3个作业的部分数据如下表所示（单位为h）,采用先来先服务和高响应比优先算法进行调度，求平均作业周转时间和平均作业带权周转时间，问哪一种算法性能比较好。 答： 通过上述过程得到的结果，我们可以看出，高响应比优先调度算法比先来先服务调度算法要好；因为：相比较之下，平均作业周转时间高响应比优先调度算法低，说明，系统的利用率比使用先来先服务调度算法高，系统的吞吐量也得到了明显改善。 2.单道批处理系统中，有如表的4个作业，约定从9:00开始调度,忽略系统开销。请分
前端数据结构和算法系统练习，冲击一线大厂.zip
06-17
这个压缩包“前端数据结构和算法系统练习，冲击一线大厂.zip”显然是为了帮助开发者提升这方面的能力，以应对顶级互联网公司的面试和工作需求。其中的ljg_resource1可能是包含各种练习题、教程或者代码示例的资源...
前端数据结构和算法系统练习，字节跳动企业题库。.zip
05-01
这个"前端数据结构和算法系统练习，字节跳动企业题库。.zip"文件很可能是为应聘者或员工准备的一系列练习题目，帮助他们提升在实际工作中的能力。 首先，让我们探讨一下数据结构。数据结构是组织和存储数据的方式，...
lrucacheleetcode-leetcode-js:前端数据结构和算法系统练习，冲击一线大厂
06-29
前端算法系统练习指南 适用人群 如果你正在为面试做准备，却对于庞杂的数据结构和算法知识，不知道何从下手； 如果你以前曾经学过一些基础的数据结构或者算法的基础知识，却根本没有理解清楚，更不能独立完成算法的...
CSDN每日一练技巧
shikongren的博客
12-05 431
看似很难的东西，其实很容易。别被它的样子吓跑了。复杂的算法思想其实根本没有看到，这是一道选择题找不同就可以了。通常在代码的循环条件，选择条件处，了解变量定义的目的和算法要实现的功能，很快就可以搞定。CSDN的练习设置，从本意上是想激发新手的兴趣，希望咱们就可以亲自动手实现一下，像是教学而不是考察。 日子越来越近了，遇到一些糟心的事，本想emo的，但心脏一直在安慰大脑，你根本没有时间，告别那些一切损耗你元气的事，别去过度猜测，有时要做一个健忘的脑。看似出乎意料的事，其实都在情理之中。 ...
CSDN博客练习
陈家豪的博客
06-28 239
目录（一）创建自己第一篇文章（1）创作文章1.1 编辑题目1.2编辑内容(2)发布文章(二)插入图片 （一）创建自己第一篇文章 （1）创作文章 1.1 编辑题目 引用文本//常用代码、注释。 1.2编辑内容 博客书写练习//- 练习如何使用博客，以及一些基本操作。 再次练习//"*’" 练习如何使用博客 (2)发布文章 xxxxxxxxx 背景颜色是Orange 中间想说的 中间写上想说的话 黑体字示例 华文彩云示例 color=#0099ff size6 face=“黑体” package co
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 553
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 750
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 859
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
生成哈夫曼树
最新发布
TTz012的博客
10-08 119
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 805
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1240
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
matlab控制系统算法练习
06-02
好的，下面是几个 MATLAB 控制系统算法的练习题： 1. 设计一个 PI 控制器，使得一个二阶系统的超调量小于 5%，并且调节时间小于 1 秒。 2. 设计一个 LQR 控制器，使得一个二阶系统的稳定裕度大于 1.5，并且最小化系统状态的加权和。 3. 设计一个 H∞ 控制器，使得一个二阶系统的鲁棒稳定裕度大于 1.2，并且最小化从扰动到输出的传递函数的 H∞ 范数。 4. 设计一个 MPC 控制器，使得一个二阶系统的输出能够在一段时间内跟踪一个给定的参考信号，并且在跟踪过程中不会产生过多的控制输入。 以上这些练习题都需要一定的控制系统基础知识和 MATLAB 编程技巧，建议你先学习相关知识再进行练习。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值