P4119 [Ynoi2018] 未来日记

最新推荐文章于 2024-08-10 07:14:43 发布
最新推荐文章于 2024-08-10 07:14:43 发布
阅读量299 收藏 4
点赞数 8
分类专栏： ynoi_ds题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lanthamum/article/details/137698657
版权
文章介绍了如何使用值域分块和并查集优化数据结构，解决k值查询的问题，涉及整块处理、散块计数、差分修改等技术，以提高时间效率。
摘要由CSDN通过智能技术生成

它来了！

分析一下第一个操作，不是写过嘛，并查集

分析一下第二个操作，二分套二分答案

拿下了这题

仔细分析，貌似时间复杂度是错的O(sqrt(n)*nlognlogv)

我们考虑块套块 时间复杂度O(n*sqrt(n))

对1e5的值域进行分块

求k值我们可以先找是第几个块，再找到是块内第几个数

如何做？

散块

我们可以做一个桶来临时存数量

整块

我们可以做一个前缀和，O(1)询问范围内的数量与k的关系，小于k我们就累加，否则我们就找到了那个块，找到第几个数也是一样的原理

因此我们维护bc[i][j] i个块内 j个值域块内的数量，c[i][j] i个块内j个数值的数量，那么散块也需要临时维护t1[i]第i个值域块的数量,t2[i]第i个数值的数量，提前预处理

如果只有一个散块可以直接找nth_element

inline int kth(int l,int r,int k){
    int p=pos[l];
    int q=pos[r];
    ll res=0;
    ll sum=0;
    if(p==q){
        pushdown(p);
        for(int i=l;i<=r;i++){
            t2[i]=a[i];
        }
        nth_element(t2+l,t2+l+k-1,t2+r+1);
        res=t2[l+k-1];//0->k
        for(int i=l;i<=r;i++){
            t2[i]=0;//清空
        }
    }else{
        //散块计数
        pushdown(p);
        for(int i=l;i<=R[p];i++){
            t1[PP[a[i]]]++;
            t2[a[i]]++;
        }
        pushdown(q);
        for(int i=L[q];i<=r;i++){
            t1[PP[a[i]]]++;
            t2[a[i]]++;
        }
        //整块处理
        for(int i=1;i<=tt;i++){//枚举值域块
            if(sum+t1[i]+bc[q-1][i]-bc[p][i]>=k){//[p+1,q-1]
                for(int j=LL[i];j<=RR[i];j++){//枚举块内值域
                    if(sum+t2[j]+c[q-1][j]-c[p][j]>=k){//找到位置
                        //查询结束前清空
                        for(int o=l;o<=R[p];o++){//[l,R[p]]
                            t1[PP[a[o]]]--;
                            t2[a[o]]--;
                        }
                        for(int o=L[q];o<=r;o++){//[R[q],r]
                            t1[PP[a[o]]]--;
                            t2[a[o]]--;
                        }
                        //返回答案
                        return j;//kth
                    }else{
                        sum+=(t2[j]+c[q-1][j]-c[p][j]);
                    }
                }
            }else{
                sum+=(t1[i]+bc[q-1][i]-bc[p][i]);//累加
            }
        }
    }
    return res;
}

结合操作一

我们维护val[i][j] 记录在第i块内的第j个位置的值，index[i][j]记录在第i个块内的a[j]在什么位置

loc[i]记录index[i][a[i]]

预处理

inline void build(int id){//建立关系
    int cur=0;//根标号
    for(int i=1;i<=blo;i++){//清空关系
        index[id][val[id][i]]=0;
    }
    for(int i=L[id];i<=R[id];i++){
        if(!index[id][a[i]]){
            cur++;
            index[id][a[i]]=cur;
            val[id][cur]=a[i];
        }
        loc[i]=index[id][a[i]];
    }
}

这样我们可以通过3个数组推出a[i]的真实值

inline void pushdown(int id){//还原数组
    for(int i=L[id];i<=R[id];i++){
        a[i]=val[id][loc[i]];//
    }
}

合并操作

inline void merge(int id,int x,int y){//合并
    index[id][y]=index[id][x];
    val[id][index[id][x]]=y;
    index[id][x]=0;
}

 修改我们考虑差分，再单块处理后，前缀和，时间复杂度不变

散块

直接modify

整块

如果没有x,直接跳过

如果没有x,有y  转移贡献

如果有x,有y  +合并

inline void modify(int l,int r,int x,int y){//散块
    for(int i=l;i<=r;i++){
        if(a[i]==x){
            bc[pos[i]][PP[x]]--;
            bc[pos[i]][PP[y]]++;
            c[pos[i]][x]--;
            c[pos[i]][y]++;
            a[i]=y;
        }
    }
}
inline void update(int l,int r,int x,int y){//处理每个块的数据可以差分处理
    if((x==y) || c[pos[r]][x]-c[pos[l]-1][x]==0 ){//x==y 或者是 区间内没有x
        return;
    }
    //差分单独处理这块的答案
    for(int i=t;i>=pos[l];i--){
        bc[i][PP[x]]-=bc[i-1][PP[x]];
        bc[i][PP[y]]-=bc[i-1][PP[y]];
        c[i][x]-=c[i-1][x];
        c[i][y]-=c[i-1][y];
    }
    int p=pos[l];
    int q=pos[r];
    if(p==q){
        pushdown(p);
        modify(l,r,x,y);//散块
        build(p);
        for(int i=p;i<=t;i++){
            bc[i][PP[x]]+=bc[i-1][PP[x]];
            bc[i][PP[y]]+=bc[i-1][PP[y]];
            c[i][x]+=c[i-1][x];
            c[i][y]+=c[i-1][y]; 
        }
    }else{
        pushdown(p);
        modify(l,R[p],x,y);//散块
        build(p);
        pushdown(q);
        modify(L[q],r,x,y);//散块
        build(q);
        for(int i=p+1;i<=q-1;i++){
            if(!c[i][x]){//不存在x 
                continue;
            }else if(c[i][y]){
                pushdown(i);
                modify(L[i],R[i],x,y);
                build(i);	
            }else{
                bc[i][PP[y]]+=c[i][x];
                bc[i][PP[x]]-=c[i][x];
                c[i][y]+=c[i][x];
                c[i][x]=0;
                merge(i,x,y);
            }
        }
        for(int i=p;i<=t;i++){
            bc[i][PP[x]]+=bc[i-1][PP[x]];
            bc[i][PP[y]]+=bc[i-1][PP[y]];
            c[i][x]+=c[i-1][x];
            c[i][y]+=c[i-1][y]; 
        }
    }
}

完整代码

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#define INF (1ll<<60)
using namespace std;
typedef long long ll;
namespace Lan {
    inline string sread() {
        string s=" ";char e=getchar();
        while(e==' '||e=='\n')e=getchar();
        while(e!=' '&&e!='\n')s+=e,e=getchar();
        return s;
    }
    inline void swrite(string s){
        for(char e:s)putchar(e);
        printf("\n");
    }
    inline ll read() {
        ll x=0,y=1;char c=getchar();
        while(!isdigit(c)){if(c=='-')y=-1;c=getchar();}
        while(isdigit(c)){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
        return x*=y;
    }
    inline void write(ll x) {
        if(x<0){x=-x,putchar('-');}ll sta[35],top=0;
        do sta[top++]=x%10,x/=10;while(x);
        while(top)putchar(sta[--top]+'0');
    }
}using namespace Lan;
const int N=1e5+9;
const int M=1e5+2;
const int B=5e2+9;
int a[N],bc[B][N],c[B][N];//块内的值域块中的数的数量，以及该数值的数
int L[B],R[B],pos[N];
int LL[B],RR[B],PP[N];
int index[B][N],val[B][N],loc[N];
int t1[B],t2[N];//散块查kth
int blo,t,tt;
inline void merge(int id,int x,int y){//合并
    index[id][y]=index[id][x];
    val[id][index[id][x]]=y;
    index[id][x]=0;
}
inline void pushdown(int id){//还原数组
    for(int i=L[id];i<=R[id];i++){
        a[i]=val[id][loc[i]];//
    }
}
inline void build(int id){//建立关系
    int cur=0;//根标号
    for(int i=1;i<=blo;i++){//清空关系
        index[id][val[id][i]]=0;
    }
    for(int i=L[id];i<=R[id];i++){
        if(!index[id][a[i]]){
            cur++;
            index[id][a[i]]=cur;
            val[id][cur]=a[i];
        }
        loc[i]=index[id][a[i]];
    }
}
inline void modify(int l,int r,int x,int y){//散块
    for(int i=l;i<=r;i++){
        if(a[i]==x){
            bc[pos[i]][PP[x]]--;
            bc[pos[i]][PP[y]]++;
            c[pos[i]][x]--;
            c[pos[i]][y]++;
            a[i]=y;
        }
    }
}
inline void update(int l,int r,int x,int y){//处理每个块的数据可以差分处理
    if((x==y) || c[pos[r]][x]-c[pos[l]-1][x]==0 ){//x==y 或者是 区间内没有x
        return;
    }
    //差分单独处理这块的答案
    for(int i=t;i>=pos[l];i--){
        bc[i][PP[x]]-=bc[i-1][PP[x]];
        bc[i][PP[y]]-=bc[i-1][PP[y]];
        c[i][x]-=c[i-1][x];
        c[i][y]-=c[i-1][y];
    }
    int p=pos[l];
    int q=pos[r];
    if(p==q){
        pushdown(p);
        modify(l,r,x,y);//散块
        build(p);
        for(int i=p;i<=t;i++){
            bc[i][PP[x]]+=bc[i-1][PP[x]];
            bc[i][PP[y]]+=bc[i-1][PP[y]];
            c[i][x]+=c[i-1][x];
            c[i][y]+=c[i-1][y]; 
        }
    }else{
        pushdown(p);
        modify(l,R[p],x,y);//散块
        build(p);
        pushdown(q);
        modify(L[q],r,x,y);//散块
        build(q);
        for(int i=p+1;i<=q-1;i++){
            if(!c[i][x]){//不存在x 
                continue;
            }else if(c[i][y]){
                pushdown(i);
                modify(L[i],R[i],x,y);
                build(i);	
            }else{
                bc[i][PP[y]]+=c[i][x];
                bc[i][PP[x]]-=c[i][x];
                c[i][y]+=c[i][x];
                c[i][x]=0;
                merge(i,x,y);
            }
        }
        for(int i=p;i<=t;i++){
            bc[i][PP[x]]+=bc[i-1][PP[x]];
            bc[i][PP[y]]+=bc[i-1][PP[y]];
            c[i][x]+=c[i-1][x];
            c[i][y]+=c[i-1][y]; 
        }
    }
}
inline int kth(int l,int r,int k){
    int p=pos[l];
    int q=pos[r];
    ll res=0;
    ll sum=0;
    if(p==q){
        pushdown(p);
        for(int i=l;i<=r;i++){
            t2[i]=a[i];
        }
        nth_element(t2+l,t2+l+k-1,t2+r+1);
        res=t2[l+k-1];//0->k
        for(int i=l;i<=r;i++){
            t2[i]=0;//清空
        }
    }else{
        //散块计数
        pushdown(p);
        for(int i=l;i<=R[p];i++){
            t1[PP[a[i]]]++;
            t2[a[i]]++;
        }
        pushdown(q);
        for(int i=L[q];i<=r;i++){
            t1[PP[a[i]]]++;
            t2[a[i]]++;
        }
        //整块处理
        for(int i=1;i<=tt;i++){//枚举值域块
            if(sum+t1[i]+bc[q-1][i]-bc[p][i]>=k){//[p+1,q-1]
                for(int j=LL[i];j<=RR[i];j++){//枚举块内值域
                    if(sum+t2[j]+c[q-1][j]-c[p][j]>=k){//找到位置
                        //查询结束前清空
                        for(int o=l;o<=R[p];o++){//[l,R[p]]
                            t1[PP[a[o]]]--;
                            t2[a[o]]--;
                        }
                        for(int o=L[q];o<=r;o++){//[R[q],r]
                            t1[PP[a[o]]]--;
                            t2[a[o]]--;
                        }
                        //返回答案
                        return j;//kth
                    }else{
                        sum+=(t2[j]+c[q-1][j]-c[p][j]);
                    }
                }
            }else{
                sum+=(t1[i]+bc[q-1][i]-bc[p][i]);//累加
            }
        }
    }
    return res;
}
int main(){
    // ios::sync_with_stdio(false);
    // cin.tie(0),cout.tie(0);
    int n,m;
    n=read(),m=read();
    for(int i=1;i<=n;i++){
        a[i]=read();
    }
    //分块
    blo=sqrt(n);
    t=sqrt(n);
    for(int i=1;i<=t;i++){
        L[i]=(i-1)*t+1;
        R[i]=i*t;
    }
    if(R[t]<n){
        t++;
        L[t]=R[t-1]+1;
        R[t]=n;
    }
    for(int i=1;i<=t;i++){
        for(int j=L[i];j<=R[i];j++){
            pos[j]=i;
        }
    }
    //值域分块
    tt=sqrt(M);
    for(int i=1;i<=tt;i++){
        LL[i]=(i-1)*tt+1;
        RR[i]=i*tt;
    }
    if(RR[tt]<M){
        tt++;
        LL[tt]=RR[tt-1]+1;
        RR[tt]=M;
    }
    for(int i=1;i<=tt;i++){
        for(int j=LL[i];j<=RR[i];j++){
            PP[j]=i;
        }
    }
    //预处理
    //值域分块
    for(int i=1;i<=t;i++){
        for(int j=1;j<=t+100;j++){
            bc[i][j]=bc[i-1][j];//块继承
        }
        for(int j=1;j<M;j++){
            c[i][j]=c[i-1][j];//数量继承
        }
        for(int j=L[i];j<=R[i];j++){
            bc[i][PP[a[j]]]++;//继续记录
            c[i][a[j]]++;
        }
    }
    //并查集
    for(int i=1;i<=t;i++){
        build(i);
    }
    for(int i=1;i<=m;i++){
        int op;
        op=read();
        int l,r;
        l=read(),r=read();
        if(op==1){
            int x,y;
            x=read(),y=read();
            update(l,r,x,y);
        }else{
            int k;
            k=read();
            cout<<kth(l,r,k)<<'\n';
        }
    }
    return 0;
}

学会了值域分块求k值，学完第二分块并查集，感觉第一分块的操作一并查集那块挺好写的

差分修改还是很妙的

下一个大分块 maybe 天降之物？

Lanthanmum
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
quebec-power-grid-talk::performing_arts:魁北克的735kv电力线可以在世界末日中幸存下来，但是它们可以运行TCP吗？
05-02
魁北克的735kv电力线路可以承受世界末日的考验， 但是他们可以运行TCP吗？！ 设计和维护地球上最高效的电网涉及的挑战， 软件工程师可以从电网运营商那里学到一些经验教训。 #bangbangcon2020 #virtualbangbangcon ...
WEB服务器安检员C#源程序
11-05
WEB服务器安检员C#源程序，下载后用VS2008打开在开发，共享了！ WEB服务器安检员是我用C#开发的一个web网站...功能还是不错，杀马查马速度很快。适合服务器商使用！开发不是很完美，但是可以使用，希望有朋友在开发！！
离线算法.pptx
01-30
离线算法离线算法是指在不知道未来信息的情况下，对当前信息进行处理和分析的一种算法思想。offline算法在竞赛中应用广泛，涵盖了线段树、分治、CDQ分治、整体二分、莫队等多种算法思想。离线算法的主要特点是根据...
P1145 约瑟夫
zty20120913的博客
08-06 435
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 949
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
m0_73924943的博客
08-08 280
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 592
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
备战秋招60天算法挑战，Day13
溜达虎的博客
08-06 770
在我们刷题的时候，适当的借助现有的数据结构往往会起到事半功倍的效果，今天我们讨论一下栈的使用。栈的特点是先进后出，利用栈的这个特点可以巧妙的解决很多问题，借助下面这道题我们进一步来体会一下栈的妙用。给定一个只包括 ，，，，， 的字符串 ，判断字符串是否有效。有效字符串需满足：举个例子： 视频题解 有效的括号 思路来源 思路来源 思路解析 首先要理解题意，什么才是题目中描述的有效括号，比如, 如下图，把同类型的括号单独按顺序拆出来，每种类型的括号都是能闭合的，但是并不是合法的。因为最先和闭合的是，违背了
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 903
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
基于LQR算法的机器人轨迹跟踪控制详解
最新发布
慕羽★的博客
08-10 1541
本文详细介绍了基于线性二次型调节器（LQR）算法的机器人轨迹跟踪控制方法。首先，文章通过建立基于运动学模型的离散状态方程，来描述机器人的当前状态与目标状态之间的关系，并利用此模型进行状态误差的计算。接着，通过设定状态量和控制量的权重矩阵（Q和R），使用LQR算法求解控制输入u，旨在最小化状态偏差和控制成本，以实现精确的轨迹跟踪。此外，文章还分析了LQR算法在ros_motion_planning运动规划库中的实现，通过源代码详解了误差量化、状态方程动态矩阵的建立、反馈控制增益的计算以及最终控制向量的生成等关
用霍夫变换算法来识别图像中圆形的轮廓cv::HoughCircles
追赶时代的博客
08-06 432
霍夫变换 圆形轮廓检测 cv::HoughCircles
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 297
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
文本加密工具类-支持MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPMD160算法
张三博客
08-06 239
【代码】文本加密工具类-支持MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPMD160算法。
代码随想录算法训练营day37｜动态规划part05
qq_39065682的博客
08-08 216
感觉今天学的技巧性都挺强的，完全背包的还得再看看；
算法日记day 33（动归之斐波那契数|爬楼梯）
m0_74980681的博客
08-08 360
要求每次可以爬1阶或者2阶，逆向思维可以理解为，当我们上到最后一阶楼梯时，可以迈一阶楼梯dp[n-1]，或者迈两阶楼梯上dp[n-2]，因此可得最终爬上去n阶台阶的方法共有dp[n-1]+dp[n-2]种方法，dp的方法是爬到第n阶台阶总共有多少种方法，而不是走了几步，因此递推关系仍是斐波那契数列。已知斐波那契数列递推式为dp[i]=dp[i-1]+dp[i-2]，因此求第n个数只需要逐渐相加获得。1. 1 阶 + 1 阶 + 1 阶。1. 1 阶 + 1 阶。2. 1 阶 + 2 阶。
力扣：3132. 找出与数组相加的整数 II（Java，枚举）
jungleirim的博客
08-09 219
移除 nums1 中下标为 [0,4] 的两个元素，并且每个元素与 -2 相加后，nums1 变为 [18,14,10] ，与 nums2 相等。移除 nums1 中下标为 [0,3] 的两个元素，并且每个元素与 2 相加后，nums1 变为 [7,7] ，与 nums2 相等。执行上述操作后，nums1 和 nums2 相等。输入：nums1 = [4,20,16,12,8], nums2 = [14,18,10]输入：nums1 = [3,5,5,3], nums2 = [7,7]
算法测试.
cxj0695的博客
08-06 387
现在，尼克需要在公司中建立一个 "主管-同级 "关系的树状层次结构(也就是说，除了一名员工外，每名员工都有一名主管)。有N种豆子，这些豆子只能靠颜色来区分，每个豆子都有它的美味度；题目要求的是每种颜色豆子里面的美味度最小值的最大值；题目意思就是给你t个字符串，让你找出每个串与codeforces这个串有多少不同的字母；贪心，把m条关系按照代价排序，当x的大于y的，且y没有主管即可能让x当y的主管；运用map来存储最小的美味度，然后循环遍历找最大的美味度就好；的主管，但需支付额外费用。
LeetCode——3131.找出与数组相加的整数I
玄昌盛不会编程
08-08 231
LeetCode——3131.找出与数组相加的整数I
CSP-J 复赛 模拟题7 and 解析
xingdjk888的博客
08-08 812
素数，又称质数，是指除 11 和其自身之外，没有其他约数的正整数。例如 2,3,5,132,3,5,13 都是素数，而 4,9,12,184,9,12,18 则不是。特别地，规定 11 不是素数（因此自然数的质因数分解就是唯一的）。如果一个数字的任意前缀所对应的数字都是一个素数，那么我们称这个数字是一个超级素数，例如：233233是一个超级素数，因为它的三个不同的前缀2,23,2332,23,233都是素数。而457457本身虽然是一个素数，但是它的前缀4,454,45却不是素数，所以457457不是一个超
P4690 [Ynoi2016] 镜中的昆虫
06-01
TokenType.SYMBOL_LEFT_PAREN) { match(TokenType.SYMBOL_LEFT_PAREN); expression(); match(TokenType.SYMBOL_RIGHT_PAREN); } else { throw new Exception("Syntax error"); } } private void match(TokenType type) throws Exception { if (tokenList.get(index).getType() == type) { index++; } else { throw new Exception("Syntax error"); } } private int getVariableAddress(String identifier) throws Exception { if (!symbolTable.containsKey(identifier)) { 这是一道程序设计竞赛题目，需要设计算法来解决。题目描述为： 有一个大小为 $ throw new Exception("Undefined variable"); } return symbolTable.get(identifier); } } ``` 在语义分析程序n\times m$ 的网格图，每个格子中有一个整数。定义一个点 $(i,j)$ 的权中，我们首先定义了四个成员变量：词法单元列表、当前处理的词法单元下标、符号表和四元式列表。其中符号表用于存储变量名和对应的内存地址，值为 $a_{i,j}$ 与其上下左右四个点权值的和的乘积，即 $a四元式列表用于存储生成的四元式。 然后，我们定义了一系列方法来进行语义分_{i,j}\times (a_{i-1,j}+a_{i+1,j}+a_{i,j-1}析和生成四元式。这些方法分别对应PL/0语言的不同语法结构，例如程序+a_{i,j+1})$。现在你需要找到一个点 $(i,j)$，使得其权值最、块、语句、表达式、项和因子。在处理每个语法结构时，我们先判断当前大，输出这个最大权值。 需要用到搜索算法或动态规划算法来解决这个问题，具体实现可以参考题目解析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值