【LGR-176-Div.2】[yLCPC2024] 洛谷 3 月月赛 I（A~C and G＜oeis＞）

news2025/2/27 1:08:14

[yLCPC2024] A. dx 分计算

前缀和提前处理一下区间和，做到O（1）访问就可以过。

#include <bits/stdc++.h>
//#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

void solve(){
    string s;
    cin>>s;

    int a[s.length()+1];
    a[0]=0;
    per(i,0,s.length()-1){
        if(s[i]=='P')a[i+1]=3;
        else if(s[i]=='p')a[i+1]=2;
        else if(s[i]=='G')a[i+1]=1;
        else a[i+1]=0;
        if(i>=1)a[i+1]+=a[i];
    }

    int q;
    cin>>q;
    per(i,1,q){
        int l,r;
        cin>>l>>r;
        cout<<a[r]-a[l-1]<<endl;
    }
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

[yLCPC2024] B. 找机厅

可以走四个方向，从左上角到右下角，问最少步数，和输出任意一条最短路径。

第一次BFS，把到每个点的步数都求一下，即下一个点.step=前一个点.step+1

如果终点有最短步数，那么有解，再根据最短步数BFS一次，四个方向的下一步必须步数比当前刚好大1，再走，顺便输出方向即可。

#include <bits/stdc++.h>
//#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

void solve(){
    int n,m;
    cin>>n>>m;

    int a[n+1][m+1],step[n+1][m+1];
    string s[n+1];
    per(i,1,n)cin>>s[i];

    per(i,1,n){
        per(j,0,m-1){
            if(s[i][j]=='0')
                a[i][j+1]=0;
            else a[i][j+1]=1;
        }
    }

    per(i,1,n){
        per(j,1,m){
            step[i][j]=INT_MAX;
        }
    }

    bool vis[n+1][m+1];
    per(i,1,n){
        per(j,1,m){
            vis[i][j]=false;
        }
    }

    struct Node{
        int x,y,val;
    };

    queue<Node>q;//终点开始BFS（起点应该一样的）
    q.push({n,m,1});

    auto inSec=[&](Node x){
        return x.x>=1 and x.x<=n and x.y>=1 and x.y<=m;
    };

    int dx[4]={0,0,1,-1};
    int dy[4]={1,-1,0,0};
    char dc[4]={'R','L','D','U'};
    map<pair<int,int>,char>d;
    per(i,0,3){
        d[{dx[i],dy[i]}]=dc[i];
    }

    while(q.size()){
        Node now=q.front();
        q.pop();
        if(vis[now.x][now.y])continue;
        vis[now.x][now.y]=true;
        step[now.x][now.y]=min(step[now.x][now.y],now.val);

        //四个方向
        per(i,0,3){
            Node next={now.x+dx[i],now.y+dy[i],now.val+1};
            //是否越界
            if(!inSec(next))continue;
            //是否可走
            if(a[next.x][next.y]==a[now.x][now.y])continue;
            q.push(next);
        }
    }

//    per(i,1,n){
//        per(j,1,m){
//            cout<<step[i][j]<<" ";
//        }cout<<endl;
//    }

    if(vis[1][1]){
        cout<<step[1][1]-1<<endl;

        Node now={1,1};
        Node END={n,m};
        while(true){
            if(now.x==END.x and now.y==END.y)break;

            per(i,0,3){
                Node next={now.x+dx[i],now.y+dy[i]};
                if(!inSec(next))continue;
                if(step[next.x][next.y]==step[now.x][now.y]-1){
                    cout<<d[{dx[i],dy[i]}];
                    now=next;
                    break;
                }
            }
        }
        cout<<endl;
    }else cout<<-1<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

[yLCPC2024] C. 舞萌基本练习

via z01prime.某某最大值里面的最小值，分成几段是否可行，没有思路的话就要考虑是二分答案了。

直接从二分不优美度入手，如果大优美度可以，那就往小的接着试。

线段树系数太大了过不了这道题，只能过第一个测试点。（要用树状数组）

每次加入一个数，访问比当前大的数已经存在了几个（即逆序对），根据这个去写check函数，分出组，如果组<=k 即合理，显然组越多 不优美度才有可能更小，让组更贴近k即为答案。

维护的时候记得离散化。

再加上不优美度最大极限可以达到1e10左右，所以这道题r至少要1e11才保险，也就是开long long。线段树基本上就似了。

比如下面这个线段树TLE

#include <bits/stdc++.h>
//#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

void solve(){
    int n,k;
    cin>>n>>k;

    int a[n+1];
    per(i,1,n)cin>>a[i];

    struct{
        int val;
    }seg[n<<2];

    auto init=[&](){
        per(i,1,(n<<2)-1){
            seg[i].val=0;
        }
        return;
    };

    auto lc=[&](int i){
        return i<<1;
    };
    auto rc=[&](int i){
        return i<<1|1;
    };

    auto update=[&](int i){
        seg[i].val=seg[lc(i)].val+seg[rc(i)].val;
    };

    function<void(int l,int r,int i,int x)>insert=[&](int l,int r,int i,int x){
        if(l==r){
            if(l==x)seg[i].val=1;
            return;
        }
        int mid=(l+r)>>1;
        if(x<=mid)insert(l,mid,lc(i),x);
        if(x>mid)insert(mid+1,r,rc(i),x);
        update(i);
    };

    function<int(int l,int r,int i,int x,int y)>query=[&](int l,int r,int i,int x,int y){
        int ans=0;
        if(l>=x and r<=y)return seg[i].val;
        int mid=(l+r)>>1;
        if(x<=mid)ans+=query(l,mid,lc(i),x,y);
        if(y>mid)ans+=query(mid+1,r,rc(i),x,y);
        return ans;
    };

    function<void(int l,int r,int i,int x)>del=[&](int l,int r,int i,int x){
        if(l==r){
            if(l==x)seg[i].val=0;
            return;
        }
        int mid=(l+r)>>1;
        if(x<=mid)del(l,mid,lc(i),x);
        if(x>mid)del(mid+1,r,rc(i),x);
        update(i);
    };

    int b[n+1];
    per(i,1,n)b[i]=a[i];
    sort(b+1,b+1+n);

    //离散化
    map<int,int>f;//原数值,对应离散化
    per(i,1,n)f[b[i]]=i;

    init();

    auto check=[&](int x){
        int cnt=0,res=0,nxd=0;

        per(i,1,n){//划分
            res++;
            if(res==1){
                insert(1,n,1,f[a[i]]);
            }else{
                int add=query(1,n,1,f[a[i]]+1,n);
                if(nxd+add>x){
                    cnt++;
                    per(j,i-res,i-1){
                        del(1,n,1,f[a[j]]);
                    }
                    nxd=0;
                    res=0;
                }else{
                    nxd+=add;
                    insert(1,n,1,f[a[i]]);
                }
            }
        }
        per(i,n-res+1,n){
            del(1,n,1,f[a[i]]);
        }

        return cnt+1;
    };

    int l=0,r=INT_MAX;
    while(l<r){
        int mid=(l+r)>>1;
        int cnt=check(mid);
        if(cnt<=k){// mid越大  cnt越少
            r=mid;//合理的时候 cnt越多越好
        }else{
            l=mid+1;
        }
    }
    cout<<r<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

所以我们只需要稍加（全部）修改，把线段树的内容改成树状数组的内容。

#include <bits/stdc++.h>
#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;
const int N=1e5+5;

int a[N],n,k,c[N],b[N];
unordered_map<int,int>f;//原数值,对应离散化

void solve(){
    cin>>n>>k;
    per(i,1,n)cin>>a[i];

    per(i,1,n)b[i]=a[i];
    sort(b+1,b+1+n);

    //离散化
    f.clear();
    per(i,1,n)f[b[i]]=i;

    auto lowbit=[&](int x){
        return x&-x;
    };

    auto insert=[&](int x){
        while(x<=n){
            c[x]++;
            x+=lowbit(x);
        }
    };

    auto del=[&](int x){
        while(x<=n){
            c[x]--;
            x+=lowbit(x);
        }
    };

    auto sum=[&](int i){
        int res=0;
        while(i>=1){
            res+=c[i];
            i-=lowbit(i);
        }
        return res;
    };

    auto check=[&](int x){
        int cnt=0,res=0,nxd=0;

        per(i,1,n){//划分
            res++;
            if(res==1){
                insert(f[a[i]]);
            }else{
                int add=sum(n)-sum(f[a[i]]);
                if(nxd+add>x){
                    cnt++;
                    per(j,i-res+1,i-1){
                        del(f[a[j]]);
                    }
                    i--;
                    nxd=0;
                    res=0;
                }else{
                    nxd+=add;
                    insert(f[a[i]]);
                }
            }
        }
        per(i,n-res+1,n){
            del(f[a[i]]);
        }

        return cnt+1;
    };

    int l=0,r=1e11;
    while(l<r){
        int mid=(l+r)>>1;
        int cnt=check(mid);
        if(cnt<=k){// mid越大  cnt越少
            r=mid;//合理的时候 cnt越多越好
        }else{
            l=mid+1;
        }
    }
    cout<<r<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

即可AC。

离散化的时候使用unordered_map，插入和查询的复杂度都是O（1），当然，如果出题人对着STL的散列表的内部哈希值出数据，能把复杂度卡到O（n），当然这道题没这么毒瘤，用散列表即可AC（map过不了的，查询插入复杂度都是logn）当然就算出题人不卡散列表离散化，也有可能会超时。

763ms为散列表，178ms就是正常的离散化。

但是如果你很担心的话，就使用正常版本的。

首先复制一份你要离散化的数组，如c[i]=a[i]。

对c 先升序排序，然后去重（unique，返回值是压缩后的末尾迭代器，即新end）。

遍历 a 数组，在 c 数组中 lower_bound 自身值（即二分定位）在 c 中的排名。

总复杂度为nlogn，显然查询为稳定的O（1）

#include <bits/stdc++.h>
#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;
const int N=1e5+5;

int a[N],n,k,c[N],b[N];

void solve(){
    cin>>n>>k;
    per(i,1,n)cin>>a[i];

    per(i,1,n)b[i]=a[i];
    sort(b+1,b+1+n);
    int p=unique(b+1,b+1+n)-b;
    //离散化
    per(i,1,n)a[i]= lower_bound(b+1,b+1+p,a[i])-b+1;

    auto lowbit=[&](int x){
        return x&-x;
    };

    auto insert=[&](int x){
        while(x<=n){
            c[x]++;
            x+=lowbit(x);
        }
    };

    auto del=[&](int x){
        while(x<=n){
            c[x]--;
            x+=lowbit(x);
        }
    };

    auto sum=[&](int i){
        int res=0;
        while(i>=1){
            res+=c[i];
            i-=lowbit(i);
        }
        return res;
    };

    auto check=[&](int x){
        int cnt=0,res=0,nxd=0;

        per(i,1,n){//划分
            res++;
            if(res==1){
                insert(a[i]);
            }else{
                int add=sum(n)-sum(a[i]);
                if(nxd+add>x){
                    cnt++;
                    per(j,i-res+1,i-1){
                        del(a[j]);
                    }
                    i--;
                    nxd=0;
                    res=0;
                }else{
                    nxd+=add;
                    insert(a[i]);
                }
            }
        }
        per(i,n-res+1,n){
            del(a[i]);
        }

        return cnt+1;
    };

    int l=0,r=1e11;
    while(l<r){
        int mid=(l+r)>>1;
        int cnt=check(mid);
        if(cnt<=k){// mid越大  cnt越少
            r=mid;//合理的时候 cnt越多越好
        }else{
            l=mid+1;
        }
    }
    cout<<r<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    cin>>t;
    while(t--)solve();
    return 0;
}

最后实测线段树打上所有178ms里面的优化，照样过不了第一个点，会TLE。（系数太大了）

[yLCPC2024] G. 系ぎて

直接上暴力！

void solve(){
    int n;
    cin>>n;

    auto cul=[&](int x){
        int res=0;
        per(i,1,x){
            per(j,1,x){
                per(k,1,x){
                    if(i*j*k==x)
                        res++;
                }
            }
        }
        return res;
    };

    int ans=0;
    per(i,1,n){
        ans+=cul(i);
    }
    cout<<ans<<endl;
}

100算的就有点慢了，显然i*j*k==x可以变成，x%(i*j)==0优化掉一个循环

void solve(){
    int n;
    cin>>n;

    auto cul=[&](int x){
        int res=0;
        per(i,1,x){
            per(j,1,x){
                if(x%(i*j)==0)res++;
            }
        }
        return res;
    };

    int ans=0;
    per(i,1,n){
        ans+=cul(i);
    }
    cout<<ans<<endl;
}

但是这样1e5的数据都跑不出来，1e10更是天方夜谭（，哪怕遍历每个数就得出res，也要遍历到1e10，差不多可以得出结论这是一道数学题，或许有可能是一个有规律的数列。

直接把前10个答案放到oeis网站上让网站帮忙找规律（

拉到下面有一个Python版本的代码

然后让Chat8帮忙改成C++代码，然后提交，AC..

#include <bits/stdc++.h>
#define int long long
#define per(i,j,k) for(int (i)=(j);(i)<=(k);++(i))
#define rep(i,j,k) for(int (i)=(j);(i)>=(k);--(i))
#define debug(a) cout<<#a<<"="<<a<<endl
#define fr first
#define se second
#define endl '\n'
using namespace std;

int ans(int n){
    int m = cbrt(n);
    int sum = 0;

    for (int i = 1; i <= m; ++i) {
        int r = n / i;
        int s = sqrt(r);

        int term1 = -s * s;

        int term2 = 0;
        for (int k = 1; k <= s; ++k) {
            term2 += r / k;
        }
        term2 *= 2;
        
        int term3 = 0;
        for (int j = 1; j <= m; ++j) {
            term3 += n / (i * j);
        }

        sum += term1 + term2 - term3;
    }

    return m * m * m + 3 * sum;
}

void solve(){
    int n;
    cin>>n;

    cout<<ans(n)<<endl;
}

signed main(){
    ios::sync_with_stdio(false),cin.tie(nullptr);
    int t=1;
    while(t--)solve();
    return 0;
}

正解移步P10239 [yLCPC2024] G. 系ぎて - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

邪∩写法仅供参考。

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

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

相关文章

【数学】【组合数学】1830. 使字符串有序的最少操作次数

【数学】【组合数学】1830. 使字符串有序的最少操作次数

作者推荐 视频算法专题 本博文涉及知识点 数学 组合数学 LeetCode1830. 使字符串有序的最少操作次数 给你一个字符串 s &#xff08;下标从 0 开始&#xff09;。你需要对 s 执行以下操作直到它变为一个有序字符串&#xff1a; 找到 最大下标 i &#xff0c;使得 1 < i…
阅读更多...
深入理解 Webpack 热更新原理：提升开发效率的关键

深入理解 Webpack 热更新原理：提升开发效率的关键

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
基于php的用户登录实现（v2版）（持续迭代）

基于php的用户登录实现（v2版）（持续迭代）

目录 版本说明 数据库连接 登录页面&#xff1a;login.html 登录处理实现&#xff1a;login.php 用户欢迎页面&#xff1a;welcome.php 密码修改页面&#xff1a;change_password.html 修改执行&#xff1a;change_password.php 用户注册页面&#xff1a;register.html …
阅读更多...
报错Importing ArkTS files to JS and TS files is not allowed. ＜etsLint＞

报错Importing ArkTS files to JS and TS files is not allowed. ＜etsLint＞

ts文件并不支持导入ets文件&#xff0c;为了方便开发应用卡片&#xff0c;entryformAbility创建的时候默认是ts文件&#xff0c;这里只需要把ts文件改成ets便可以轻松的导入所需要的ets即可 我创建了一个鸿蒙开发的交流群&#xff0c;喜欢的鸿蒙朋友可以扫码或者写群号&#xf…
阅读更多...
指针详解（从基础到入门）

指针详解（从基础到入门）

一、什么是指针 在计算机科学中&#xff0c;指针是编程语言中的一个对象&#xff0c;利用地址&#xff0c;它直接指向存在电脑储存器中另一个地方的值。由于通过地址能找到所需的变量单元&#xff0c;可以说&#xff0c;指针指向该变量单元。因此&#xff0c;将地址形象化地称…
阅读更多...
如何使用Hexo搭建个人博客

如何使用Hexo搭建个人博客

文章目录 如何使用Hexo搭建个人博客环境搭建连接 Github创建 Github Pages 仓库本地安装 Hexo 博客程序安装 HexoHexo 初始化和本地预览 部署 Hexo 到 GitHub Pages开始使用发布文章网站设置更换主题常用命令 插件安装解决成功上传github但是web不更新不想上传文章处理方式链接…
阅读更多...
python处理geojson为本地shp文件

python处理geojson为本地shp文件

一.成果展示 二.环境 我是在Anaconda下的jupyter notebook完成代码的编写&#xff0c;下面是我对应的版本号&#xff0c;我建议大家在这个环境下编写&#xff0c;因为在下载gdal等包的时候会更方便。 二.参考网站 osgeo.osr module — GDAL documentation osgeo.ogr module …
阅读更多...
Codesys的Memory存储区数据定义

Codesys的Memory存储区数据定义

以上为例&#xff1a; 假定&#xff0c;数据整个大小为131072个字节 即存在 MB0-MB131071个地址 MW0-65534个地址 MD0-32766个地址 每一个MD2个MW4个MB 即MD0MW0-MW1MB0-MB1-MB2-MB3。 即MD75MW150-MW151MB300-MB301-MB302-MB303。 对以上地址赋值时&#xff0c;会同时…
阅读更多...
SQL中常见的DDL操作及示例，数据库操作及表操作

SQL中常见的DDL操作及示例，数据库操作及表操作

目录 一、数据库操作 1、创建数据库 2、查看所有数据库 3、使用数据库 4、删除数据库 二、表操作&#xff1a; 1、创建表 2、查看表结构 3、修改表结构 3.1 添加列 3.2 修改列数据类型 3.3 修改列名 3.4 删除列 3.5 修改表名 3.6 删除表 注意&#xff1a; 在数…
阅读更多...
2.15SRAM,DRAM，ROM，主存与CPU连接

2.15SRAM,DRAM，ROM，主存与CPU连接

MDR取出数据&#xff0c;然后通过数据总线传递给CPU&#xff0c; 地址总线传递信号给到MAR 就是说片选线是用来选择操作哪个芯片 8*8位 第一个代表存储单元的数量&#xff0c;第二个代表存储字长 有几个存储单元&#xff0c;就对应多少位地址以及多少的地址线 存储字长决定数…
阅读更多...
【兔子机器人】修改GO电机id（软件方法、硬件方法）

【兔子机器人】修改GO电机id（软件方法、硬件方法）

一、硬件方法 利用上位机直接修改GO电机的id号&#xff1a; 打开调试助手&#xff0c;点击“调试”&#xff0c;查询电机&#xff0c;修改id号&#xff0c;即可。 但先将四个GO电机连接线拔掉&#xff0c;不然会将连接的电机一并修改。 利用24V电源给GO电机供电。 二、软件方…
阅读更多...
Swift 入门学习：集合（Collection）类型趣谈-上

Swift 入门学习：集合（Collection）类型趣谈-上

概览 集合的概念在任何编程语言中都占有重要的位置&#xff0c;正所谓&#xff1a;“古来聚散地&#xff0c;宿昔长荆棘&#xff1b;游人聚散中&#xff0c;一片湖光里”。把那一片片、一瓣瓣、一粒粒“可耐”的小精灵全部收拢、吸纳的井然有序、条条有理&#xff0c;怎能不让…
阅读更多...
政安晨：【深度学习处理实践】（四）—— 实施一个温度预测示例

政安晨：【深度学习处理实践】（四）—— 实施一个温度预测示例

在开始使用像黑盒子一样的深度学习模型解决温度预测问题之前&#xff0c;我们先尝试一种基于常识的简单方法。 它可以作为一种合理性检查&#xff0c;还可以建立一个基准&#xff0c;更高级的机器学习模型需要超越这个基准才能证明其有效性。对于一个尚没有已知解决方案的新问…
阅读更多...
从零开始：神经网络（1）——神经元和梯度下降

从零开始：神经网络（1）——神经元和梯度下降

声明&#xff1a;本文章是根据网上资料&#xff0c;加上自己整理和理解而成&#xff0c;仅为记录自己学习的点点滴滴。可能有错误&#xff0c;欢迎大家指正。 一. 神经网络 1. 神经网络的发展 先了解一下神经网络发展的历程。从单层神经网络&#xff08;感知器&#xff09;开…
阅读更多...
【Java网络编程】TCP核心特性（下）

【Java网络编程】TCP核心特性（下）

1. 拥塞控制 拥塞控制&#xff1a;是基于滑动窗口机制下的一大特性&#xff0c;与流量控制类似都是用来限制发送方的传送速率的 区别就在于&#xff1a;"流量控制"是从接收方的角度出发&#xff0c;根据接收方剩余接收缓冲区大小来动态调整发送窗口的&#xff1b;而…
阅读更多...
【编译原理】1、python 实现一个 JSON parser：lex 词法分析、parser 句法分析

【编译原理】1、python 实现一个 JSON parser：lex 词法分析、parser 句法分析

文章目录 一、实现 JSON lexer&#xff08;词法解析器&#xff09;二、lex 词法分析2.1 lex string 解析2.2 lex number 解析2.3 lex bool 和 null 解析 三、syntax parser 句法分析3.1 parse array 解析数组3.2 parse object 解析对象 四、封装接口 一、实现 JSON lexer&#…
阅读更多...
论文阅读：Diffusion Model-Based Image Editing: A Survey

论文阅读：Diffusion Model-Based Image Editing: A Survey

Diffusion Model-Based Image Editing: A Survey 论文链接 GitHub仓库 摘要 这篇文章是一篇基于扩散模型&#xff08;Diffusion Model&#xff09;的图片编辑&#xff08;image editing&#xff09;方法综述。作者从多个方面对当前的方法进行分类和分析&#xff0c;包括学习…
阅读更多...
时间感知自适应RAG（TA-ARE）

时间感知自适应RAG（TA-ARE）

原文地址&#xff1a;Time-Aware Adaptive RAG (TA-ARE) 2024 年 3 月 1 日 介绍 随着大型语言模型&#xff08;LLM&#xff09;的出现&#xff0c;出现了新兴能力的概念。前提或假设是LLMs具有隐藏的和未知的能力&#xff0c;等待被发现。企业家们渴望在LLMs中发现一些无人知晓…
阅读更多...
LLM实施的五个阶段

LLM实施的五个阶段

原文地址&#xff1a;Five Stages Of LLM Implementation 大型语言模型显着提高了对话式人工智能系统的能力&#xff0c;实现了更自然和上下文感知的交互。这导致各个行业越来越多地采用人工智能驱动的聊天机器人和虚拟助手。 2024 年 2 月 20 日 介绍 从LLMs的市场采用情况可以…
阅读更多...
Day26：安全开发-PHP应用模版引用Smarty渲染MVC模型数据联动RCE安全

Day26：安全开发-PHP应用模版引用Smarty渲染MVC模型数据联动RCE安全

目录 新闻列表 自写模版引用 Smarty模版引用 代码RCE安全测试 思维导图 PHP知识点&#xff1a; 功能&#xff1a;新闻列表&#xff0c;会员中心&#xff0c;资源下载&#xff0c;留言版&#xff0c;后台模块&#xff0c;模版引用&#xff0c;框架开发等 技术&#xff1a;输…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023