C++数据结构与算法——双指针法

news2024/11/26 0:30:27

C++第二阶段——数据结构和算法，之前学过一点点数据结构，当时是基于Python来学习的，现在基于C++查漏补缺，尤其是树的部分。这一部分计划一个月，主要利用代码随想录来学习，刷题使用力扣网站，不定时更新，欢迎关注！

文章目录

  • 一、移除元素（力扣27）
  • 二、反转字符串（力扣344）
  • 三、替换数字（卡码网 54）
  • 四、翻转字符串里的单词（力扣151）
  • 五、反转链表（力扣206）
  • 六、删除链表的倒数第 N 个结点（力扣19）
  • 七、链表相交（力扣面试题 02.07）
  • 八、环形链表 II（力扣142）
  • 九、三数之和（力扣15）
  • 十、四数之和（力扣18）

一、移除元素（力扣27）

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 利用快慢指针进行删除
        // 1. 判断是否只有零个或一个元素，防止索引超出数组长度
        if(nums.size()==1){
            if(nums[0]==val){
                return 0;
            }
            else{
                return 1;
            }
        }
        if (nums.size()==0){
            return 0;
        }

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

在这里插入图片描述

二、反转字符串（力扣344）

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：
输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：
输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]
提示：
1 <= s.length <= 105
s[i] 都是 ASCII 码表中的可打印字符

class Solution {
public:
    void reverseString(vector<char>& s) {
        // 双指针解决
        int begin =0;
        int end = s.size()-1;
        while(begin<end){
            // 交换
            char temp = s[begin];
            s[begin] = s[end];
            s[end] = temp;
            begin++;
            end--;
        }
    }
};

在这里插入图片描述

三、替换数字（卡码网 54）

题目描述
给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。 例如，对于输入字符串 “a1b2c3”，函数应该将其转换为 “anumberbnumbercnumber”。
输入描述
输入一个字符串 s,s 仅包含小写字母和数字字符。
输出描述
打印一个新的字符串，其中每个数字字符都被替换为了number
输入示例
a1b2c3
输出示例
anumberbnumbercnumber
提示信息
数据范围：
1 <= s.length < 10000。

#include <iostream>
using namespace std;
 
 
int main() {
    string inputS;
    cin >> inputS;
    int count = 0;
    // 遍历原来数组,记录其中数字的个数
    for (int i = 0; i < inputS.length(); i++) {
        if (inputS[i] <= '9' && inputS[i]>='0') {
            count++;
        }
    }
    int FLength = inputS.length();
    // resize 原来的字符串
    inputS.resize(FLength + count * 5);
    // 替换原来字符串中的字符，从后向前替换
    int j = inputS.length()-1;
    for (int i = FLength - 1; j>i; i--,j--) {
        if (inputS[i] <= '9' && inputS[i]>='0') {
            // 是数字要替换
            inputS[j] = 'r';
            inputS[j-1] = 'e';
            inputS[j-2] = 'b';
            inputS[j-3] = 'm';
            inputS[j-4] = 'u';
            inputS[j-5] = 'n';
            j -= 5;
        }
        else {
            inputS[j] = inputS[i];
        }
    }
    cout << inputS << endl;
    system("pause");
    return 0;
 
}

在这里插入图片描述

四、翻转字符串里的单词（力扣151）

给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：
输入: “the sky is blue”
输出: “blue is sky the”
示例 2：
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

class Solution {
public:
    string reverseWords(string s) {
        // 去除空格
        removeSpace(s);
        // // 翻转整个句子
        reverse(s.begin(), s.end());
        // 翻转每个单词
        // 首先找到每个单词的位置
        int slow=0;
        for(int fast=0;fast<s.length();fast++){
            if(s[fast+1]==' ' || fast==s.length()-1){
                reverseWord(s,slow,fast);
                slow = fast+2;
            }
        }
        return s;
    }
    // 翻转每个单词
    void reverseWord(string& s, int begin, int end) {
        while (begin < end) {
            swap(s[begin], s[end]);
            begin++;
            end--;
        }
    }
    // 去除字符串中多余的空格
    void removeSpace(string& s) {
        // 快慢指针去除空格
        int slow = 0;
        for (int fast = 0; fast < s.length(); fast++) {
            if (s[fast] != ' ') {
                // 不为空格才进行下面的操作
                // 添加每个单词之间的空格，句子开头不加
                if (slow != 0) {
                    s[slow] = ' ';
                    slow++;
                }
                while (fast<s.size() && s[fast] != ' ') {
                    s[slow] = s[fast];
                    slow++;
                    fast++;
                }
            }
        }
    s.resize(slow);
    }

};

在这里插入图片描述

五、反转链表（力扣206）

这里是引用

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL){
            // 只有一个结点
            return head;
        }
        // 定义两个指针，一个指前面的，一指后面的
        ListNode *pre = NULL;
        ListNode *cur = head;
        while(cur!=NULL){
            // 用一个值去接收cur
            ListNode *temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }

};

在这里插入图片描述

六、删除链表的倒数第 N 个结点（力扣19）

这里是引用

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if (head==NULL){
            return head;
        }

        ListNode * dummyNode = new ListNode(0);
        dummyNode->next = head;
        // 使用快慢指针
        ListNode* fast = dummyNode;
        ListNode* slow = dummyNode;
        while(n--){
            // 快指针先走n个
            fast = fast->next;
        }
        while(fast!=NULL&&fast->next!=NULL){
            fast = fast->next;
            slow = slow->next;
        }
        // 删除元素
        ListNode * temp = slow->next;
        slow->next = slow->next->next;
        delete temp; // 删除
        return dummyNode->next;
    }
};

在这里插入图片描述

七、链表相交（力扣面试题 02.07）

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 实际上是找相等的结点，不是值相等，而是 是同一个结点
        // 将两个链表右对齐
        // 求两个链表的长度
        if(headA==NULL||headB==NULL){
            return NULL;
        }
        int lenA =1;
        int lenB =1;
        ListNode * curA = headA;
        ListNode * curB = headB;
        while(curA->next!=NULL){
            lenA++;
            curA = curA->next;
        }
        while(curB->next!=NULL){
            lenB++;
            curB = curB->next;
        }
        // 找最短的链表
        int minLen =min(lenA,lenB);
        // AB需要移动的长度
        int needA= lenA-minLen;
        int needB = lenB - minLen;
        // 右对齐两个节点
        while(needA--){
            headA = headA->next;
        }
        while(needB--){
            headB = headB->next;
        }
        // 比较之后的链表是否相同
        while(headA!=NULL||headB!=NULL){
            if(headA== headB){
                return headA;
            }
            else{
                headA = headA->next;
                headB = headB ->next;
            }
        }
        return NULL;
    }
};

在这里插入图片描述

八、环形链表 II（力扣142）

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode * first = head;
        ListNode * slow = head;
        while(first!=NULL&&first->next!=NULL){
            first = first->next->next;
            slow = slow->next;
            if(first==slow){
                // 此时相遇
                ListNode * index1 = first;
                ListNode * index2 = head;
                // 找入环口
                while(index1!=index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;

    }
};

在这里插入图片描述

九、三数之和（力扣15）

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
示例 2：
输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。
示例 3：
输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        // 先对数组排序
        sort(nums.begin(),nums.end());
        // 定义结果数组
        vector<vector<int>> result;
        // 剪枝操作
        if(nums[0]>0){
            return {}; // 第一个元素都大于0了，说明不可能加起来等于0，直接返回空
        }
        for(int i=0;i<nums.size();i++){
            // 定义两个指针
            int begin = i+1;
            int end = nums.size()-1;
            // 去重操作
            if(i>0&&nums[i]==nums[i-1]){
                // 当前的i和i-1的元素是一样的
                continue; // 跳过当前循环
            }
            while(begin<end){
                if((nums[i]+nums[begin]+nums[end])==0){
                    result.push_back({nums[i],nums[begin],nums[end]});
                    while(begin<end&&nums[begin]==nums[begin+1]){
                        begin++;
                    }
                    while(begin<end&&nums[end]==nums[end-1]){
                        end--;
                    }
                    begin++;
                    end--;
                }
                else if((nums[i]+nums[begin]+nums[end])>0){
                    end--;
                }
                else{
                    begin++;
                }

            }


        }
        return result;
    }
};

在这里插入图片描述

十、四数之和（力扣18）

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：
输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]
提示：
1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        // 先排序
        sort(nums.begin(),nums.end());
        // 定义最终返回数组
        vector<vector<int>> result;
        // 类似于三数之和，多了一层循环
        for (int i=0;i<nums.size();i++){
            // 剪枝
            if(nums[0]>=0&&nums[0]>target){
                break;
            }
            // 去重
            if(i>0&&nums[i]==nums[i-1]){
                continue;
            }
            for(int j=i+1;j<nums.size();j++){
                // 剪枝
                if(nums[i]+nums[j]>target&&nums[j]>=0){
                    break;
                }
                // 去重
                if(j>i+1&&nums[j]==nums[j-1]){
                    continue;
                }
                // 类似于三数之和
                int begin = j+1;
                int end = nums.size()-1;
                while(begin<end){
                    if((long) nums[i]+nums[j]+nums[begin]+nums[end]==target){
                        // 找到符合要求的数组，记录
                        result.push_back({nums[i],nums[j],nums[begin],nums[end]});
                        while(begin<end&&nums[begin]==nums[begin+1]){
                            begin++;
                        }
                        while(begin<end&&nums[end]==nums[end-1]){
                            end--;
                        }
                        begin++;
                        end--;
                    }
                    else if((long)nums[i]+nums[j]+nums[begin]+nums[end]>target){
                        end--;
                    }
                    else{
                        begin++;
                    }
                }
            }
        }
        return result;
    }
};

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1451385.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

0901多元函数的基本概念-多元函数微分法及其应用

0901多元函数的基本概念-多元函数微分法及其应用

文章目录 1 平面点集1.1 坐标平面1.2 平面点集1.3 邻域1.4 电与点集的关系1.5 聚点1.6 点集所属点的特征定义的平面点集 2 多元函数的概念2.1 定义2.2 值域2.3推广2.4 自然定义域2.5 二元函数的图形 3 多元函数的极限4 多元函数的连续性4.1 连续函数定义4.2 间断点定义4.3 多元…
阅读更多...
【教程】C++语言基础学习笔记（八）——函数

【教程】C++语言基础学习笔记（八）——函数

写在前面&#xff1a; 如果文章对你有帮助&#xff0c;记得点赞关注加收藏一波&#xff0c;利于以后需要的时候复习&#xff0c;多谢支持&#xff01; 【C语言基础学习】系列文章 第一章 《项目与程序结构》 第二章 《数据类型》 第三章 《运算符》 第四章 《流程控制》 第五章…
阅读更多...
2024】前端，该卷什么呢？_2024-02-16

2024】前端，该卷什么呢？_2024-02-16

2024已来&#xff0c;过去的 2023 可以说是具有里程碑意义的一年&#xff0c;ChatGPT 的炸裂式发展&#xff0c;很多大佬都亲自入场整活儿&#xff0c;你不得不说&#xff0c;人工智能时代的未来已来&#xff0c;大势所趋&#xff0c;不可阻挡。随着生成式AI的迅猛发展&#xf…
阅读更多...
Spring AMQP(3.1.1)设置ConfirmCallback和ReturnsCallback

Spring AMQP(3.1.1)设置ConfirmCallback和ReturnsCallback

文章目录 一、起因二、代码1. 定义exchange和queue2. RabbitTemplate3. EnhancedCorrelationData4. 发送消息 环境如下 VersionSpringBoot3.2.1spring-amqp3.1.1RabbitMq3-management 一、起因 老版本的spring-amqp在CorrelationData上设置ConfirmCallback。但是今天却突然发…
阅读更多...
RCS系统之：浅谈系统设计与开发

RCS系统之：浅谈系统设计与开发

这是我在开发RCS系统中的一些个人感悟与心得&#xff0c;写出来与大家一起分享下。是想到什么写到什么&#xff0c;如果有什么不对的&#xff0c;欢迎大家一起探讨。 有些人喜欢把WMS系统下面的系统统称为RCS系统。 但我不是这么想的&#xff0c;我这里把WMS/ERP系统与AGV之间…
阅读更多...
[office] Excel 数据库函数条件区域怎样设置 #笔记#笔记

[office] Excel 数据库函数条件区域怎样设置 #笔记#笔记

Excel 数据库函数条件区域怎样设置 以下面的数据表格为例&#xff0c;对于条件区域的设置&#xff0c;有几方面需要注意的内容&#xff0c;下面就一起看看如何对Excel 数据库函数条件区域设置的吧。希望会大家有所帮助 以下面的数据表格为例&#xff0c;对于条件区域的设置&am…
阅读更多...
Java：如何判断一个链表是否为回文结构？（画图+代码 详解）

Java：如何判断一个链表是否为回文结构？（画图+代码 详解）

一、判断思想 我们设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法&#xff0c;我们在不创建额外空间的基础上来判断是否为回文结构。 思想&#xff1a; 1、使用快慢指针法&#xff0c;找到链表的中间节点。 2、翻转中间节点的后半部分。 3、分别从头节点和尾节点向中间遍…
阅读更多...
网课：数独挑战——牛客（题解与疑问）

网课：数独挑战——牛客（题解与疑问）

涉及知识点&#xff1a;打表 题目描述 数独是一种填数字游戏&#xff0c;英文名叫 Sudoku&#xff0c;起源于瑞士&#xff0c;上世纪 70 年代由美国一家数学逻辑游戏杂志首先发表&#xff0c;名为 Number Place&#xff0c;后在日本流行&#xff0c;1984 年将 Sudoku 命名为…
阅读更多...
《合成孔径雷达成像算法与实现》Figure6.13

《合成孔径雷达成像算法与实现》Figure6.13

clc clear close all参数设置 距离向参数设置 R_eta_c 20e3; % 景中心斜距 Tr 2.5e-6; % 发射脉冲时宽 Kr 20e12; % 距离向调频率 alpha_os_r 1.2; % 距离过采样率 Nrg 320; % 距离线采样数 距离向…
阅读更多...
springboot190基于springboot框架的工作流程管理系统的设计与实现

springboot190基于springboot框架的工作流程管理系统的设计与实现

简介 【毕设源码推荐 javaweb 项目】基于springbootvue 的 适用于计算机类毕业设计&#xff0c;课程设计参考与学习用途。仅供学习参考&#xff0c; 不得用于商业或者非法用途&#xff0c;否则&#xff0c;一切后果请用户自负。 看运行截图看 第五章 第四章 获取资料方式 **项…
阅读更多...
项目管理工具软件Maven趣闻

项目管理工具软件Maven趣闻

版权声明 本文原创作者&#xff1a;谷哥的小弟作者博客地址&#xff1a;http://blog.csdn.net/lfdfhl Maven这个单词来自于意第绪语&#xff08;Yiddish&#xff09;&#xff0c;这是一种与德语和希伯来语有密切关系的犹太民族语言。在这个语境中&#xff0c;Maven意为“知识的…
阅读更多...
分布式文件系统 SpringBoot+FastDFS+Vue.js【四】

分布式文件系统 SpringBoot+FastDFS+Vue.js【四】

分布式文件系统 SpringBootFastDFSVue.js【四】 八、文件的下载和删除功能8.1.FastDFSClient.java8.2.FileServerController.java8.3.Vue的fast.js8.4.fastdfsimg.vue8.5.效果 九、总结endl 八、文件的下载和删除功能 8.1.FastDFSClient.java Slf4j public class FastDFSClie…
阅读更多...
Midjourney绘图欣赏系列（三）

Midjourney绘图欣赏系列（三）

Midjourney介绍 Midjourney 是生成式人工智能的一个很好的例子&#xff0c;它根据文本提示创建图像。它与 Dall-E 和 Stable Diffusion 一起成为最流行的 AI 艺术创作工具之一。与竞争对手不同&#xff0c;Midjourney 是自筹资金且闭源的&#xff0c;因此确切了解其幕后内容尚不…
阅读更多...
【机器学习笔记】8 决策树

【机器学习笔记】8 决策树

决策树原理 决策树是从训练数据中学习得出一个树状结构的模型。 决策树属于判别模型。 决策树是一种树状结构&#xff0c;通过做出一系列决策&#xff08;选择&#xff09;来对数据进行划分&#xff0c;这类似于针对一系列问题进行选择。决策树的决策过程就是从根节点开始&…
阅读更多...
指针的经典笔试题

指针的经典笔试题

经典的指针试题&#xff0c;让你彻底理解指针 前言 之前对于指针做了一个详解&#xff0c;现在来看一些关于指针的经典面试题。 再次说一下数组名 数组名通常表示的都是首元素的地址&#xff0c;但是有两个意外&#xff0c;1.sizeof&#xff08;数组名&#xff09;这里数组名…
阅读更多...
Chat with RTX 安装

Chat with RTX 安装

1、Chat With RTX 介绍 Chat With RTX 是一个 Demo&#xff0c;用来将您自己的资料&#xff08;文档、笔记、视频或其他数据&#xff09;与大语言模型建立连接&#xff0c;从而令 LLM 更具个性化。利用检索增强生成 (RAG)、TensorRT-LLM 和 RTX 加速&#xff0c;您可以与自定义…
阅读更多...
GiantPandaCV | 视觉类表面缺陷检测项目相关技术总结

GiantPandaCV | 视觉类表面缺陷检测项目相关技术总结

本文来源公众号“GiantPandaCV”&#xff0c;仅用于学术分享&#xff0c;侵权删&#xff0c;干货满满。 原文链接&#xff1a;视觉类表面缺陷检测项目相关技术总结 本文由海滨撰写&#xff0c;首发于GaintPandaCV。 零、前言 做这个方向的项目也有一段时间了&#xff0c;作为…
阅读更多...
第9章 网络编程

第9章 网络编程

9.1 网络通信协议 通过计算机网络可以实现多台计算机连接&#xff0c;但是不同计算机的操作系统和硬件体系结构不同&#xff0c;为了提供通信支持&#xff0c;位于同一个网络中的计算机在进行连接和通信时必须要遵守一定的规则&#xff0c;这就好比在道路中行驶的汽车一定要遵…
阅读更多...
代码随想录算法训练营第二十四天｜回溯算法理论 77.组合

代码随想录算法训练营第二十四天｜回溯算法理论 77.组合

回溯算法理论 回溯和递归式相辅相成的&#xff0c;只要有递归就会有回溯一般 递归函数的下面就是 回溯的逻辑 回溯相当于穷举搜索的巧妙实现 回溯算法常解决的问题&#xff1a; 组合切割子集排列棋盘回溯代码的框架 void backtracking(参数) {if (终止条件) {存放结果;retu…
阅读更多...
线性注意力机制全新升级！性能显著提高，速度、精度更优

线性注意力机制全新升级！性能显著提高，速度、精度更优

线性注意力机制通过对传统注意力机制中的Softmax操作进行线性化处理&#xff0c;可以提高Transformer模型的并行性能、降低复杂度&#xff0c;在计算效率、模型表达能力等方面都具有优势。 作为一种常用有效的优化方法&#xff0c;线性注意力机制可以在保证模型性能的同时提高…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023