2018-2019 Russia Open High School Programming Contest (Unrated, Online Mirror, ICPC Rules, Teams Pre...

最新推荐文章于 2024-07-12 16:35:20 发布
最新推荐文章于 2024-07-12 16:35:20 发布
阅读量734 收藏
点赞数
文章标签： 数据结构与算法 ux
原文链接：http://www.cnblogs.com/shanxieng/p/10093518.html
版权
前言

有一场下午的cf，很滋磁啊，然后又和dalao(见右面链接)组队打了，dalao直接带飞我啊。

这是一篇题解，也是一篇总结，当然，让我把所有的题目都写个题解是不可能的了。

按照开题顺序讲吧。

在开始前有现场赛的成绩，所以可以看出来哪道是傻逼题，当然还是滋磁啊。

M - The Pleasant Walk

我被分到了这道题，当然是因为我太弱了啊，dalao当然是要去做神仙题了。

好像没什么可说的了，直接扫不就行了。。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

//const int Maxn=;

int main() {
//  freopen("test.in","r",stdin);
    int n,k;
    scanf("%d%d",&n,&k);
    int las=1,ans=1,x,last;
    scanf("%d",&last);
    for(int i=2;i<=n;i++) {
        scanf("%d",&x);
        ans=max(ans,i-las);
        if(x==last) las=i;
        last=x;
    }
    ans=max(ans,n+1-las);
    printf("%d",ans);
    return 0;
}
A - Company Merging

%%%zhy

#include<map>
#include<queue>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=2e5+100;
int siz[maxn],n,m,top[maxn],maxx;
ll ans;
int main(){
//  freopen("1.in","r",stdin);
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&m);
        int maxt=0,a;
        for(int i=1;i<=m;i++)
            scanf("%d",&a),maxt=max(maxt,a);
        top[i]=maxt,siz[i]=m;
        maxx=max(maxx,maxt);
    }
    for(int i=1;i<=n;i++)
        ans+=1ll*(maxx-top[i])*siz[i];
    printf("%I64d\n",ans);
    return 0;
}

然后就卡了题。我滚去看D，dalao去看L，然而发现D是个构造，似乎是转化成图然后搞搞？好像找到两个点之间没有边然后强制令这两个点编号为1,2，然后从这两个点广搜，依次标号为3到n，这就是互不重复的。然后把2改成1就有重复的了。

然后 Wrong answer on test 2 ?我连样例都没过？我明明过了啊。。再交一次还是WA？然后就只能用肉眼调试了。。好像没错啊。。woc，我没输出YES！加上了再交，A了。。

瞬间有种自杀的冲动。。

D - Similar Arrays
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int Maxn=210000;

int to[Maxn],nxt[Maxn],first[Maxn],vis[Maxn],n,m,u,v,sxz,zhy,d[Maxn],tot=1,cnt;

inline void add(int u,int v) {
    to[tot]=v;
    nxt[tot]=first[u];
    first[u]=tot++;
    to[tot]=u;
    nxt[tot]=first[v];
    first[v]=tot++;
}

int main() {
//  freopen("test.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++) {
        scanf("%d%d",&u,&v);
        add(u,v);
        d[u]++;
        d[v]++;
    }
    int flag=0;
    for(int i=1;i<=n;i++)
        if(d[i]<n-1) {
            flag=1;vis[sxz=i]=1;
            for(int j=first[i];j;j=nxt[j]) vis[to[j]]=1;
            for(int j=1;j<=n;j++)
                if(!vis[j]) {zhy=j;break;}
            break;
        }
    if(flag==0) {
        puts("NO");
        return 0;
    }
    queue<int>q;
    memset(vis,0,sizeof(vis));
    vis[sxz]=1;vis[zhy]=2;
    q.push(sxz),q.push(zhy);
    cnt=3;
    while(!q.empty()) {
        int now=q.front();q.pop();
        for(int i=first[now];i;i=nxt[i])
            if(!vis[to[i]]) {
                vis[to[i]]=cnt++;
                q.push(to[i]);
            }
    }
    for(int i=1;i<=n;i++)
        if(vis[i]==0) {
            vis[i]=cnt++;
            q.push(i);
            while(!q.empty()) {
                int now=q.front();q.pop();
                for(int i=first[now];i;i=nxt[i])
                    if(!vis[to[i]]) {
                        vis[to[i]]=cnt++;
                        q.push(to[i]);
                    }
            }
        }
    puts("YES");
    printf("%d",vis[1]);
    for(int i=2;i<=n;i++) printf(" %d",vis[i]);
    putchar('\n');
    vis[zhy]=1;
    printf("%d",vis[1]);
    for(int i=2;i<=n;i++) printf(" %d",vis[i]);
    putchar('\n');
    return 0;
}

然后dalao给我讲了L的题意，他还说他看不懂样例？太fake了吧。我来看看，这不是能一眼秒掉啊，直接二分不就好了。。

L - Berland University
#include<map>
#include<queue>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
ll n,m,x,y,a,b,k;
bool check(ll t){
    ll p=min(t,a);
    ll siz=p*x;
    p=min(t,b);
    siz+=p*y;
    return siz>=t*k;
}
int main(){
//  freopen("1.in","r",stdin);
    scanf("%I64d%I64d%I64d%I64d%I64d",&n,&m,&a,&b,&k);
    if(m%2) x=m/2+1,y=m/2;
    else x=y=m/2;
    if(a>b) swap(a,b),swap(x,y);
    ll l=0,r=n+1,mid,ans;
    while(l<r){
        mid=l+r>>1;
        if(check(mid))
            ans=mid,l=mid+1;
        else
            r=mid;
    }
    printf("%I64d\n",ans);
    return 0;
}

然后dalao说B很不可做啊。。我看看，这不是直接模拟吗？秒掉秒掉。。

B - LaTeX Expert
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

const int Maxn=210000;

char s[Maxn],a[100][Maxn];
vector<char> c[100];
int b[Maxn],cnt;

void readf() {
    while(getchar()!='\\');
}

int len;

void readw() {
    len=0;
    char ch=getchar();memset(s,0,sizeof(s));
    while(!isalpha(ch)) ch=getchar();
    while(isalpha(ch)) s[len++]=ch,ch=getchar();
}

void readl() {
    len=0;
    char ch=getchar();memset(s,0,sizeof(s));
    while(ch!='\\') s[len++]=ch,ch=getchar();
}

int main() {
//  freopen("test.in","r",stdin);
    while(1) {
        readf();readw();
        if(strcmp(s,"begin")==0) break;
        readw();
        cnt++;
        strcpy(a[cnt],s);
    }readf();readw();
    for(int i=1;i<=cnt;i++) {
        readw();
        for(int j=1;j<=cnt;j++)
            if(strcmp(s,a[j])==0)
                b[j]=i;
        readl();
        for(int j=0;j<len;j++) c[i].push_back(s[j]);
        readw();
    }
    int flag=0;
    for(int i=1;i<=cnt;i++) if(b[i]!=i) flag=1;
    if(flag) {
        puts("Incorrect");
        puts("\\begin{thebibliography}{99}");
        for(int i=1;i<=cnt;i++) {
            printf("\\bibitem{%s}",a[i]);
            for(int j=0;j<c[b[i]].size();j++)
                printf("%c",c[b[i]][j]);
        }
        puts("\\end{thebibliography}");
    }
    else puts("Correct");
    return 0;
}

然后dalao说I题是水题？(orz)我看看。。好的真是水题，读入好麻烦啊，那就让dalao先看看读入怎么读(%%%)，我这种蒟蒻就只能打打杂了。好了，过了样例了，WA了？写个拍看看。。拍了几处错之后怎么还没A？都拍了两千组了好吧。。在用肉眼调调吧。这个读入怎么可能错呢...woc，我读入错了。。改上就A了。。我怎么又有种想要自杀的冲动？

I - Minimal Product
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

typedef long long ll;
const int Maxn=21000000;

int t;
ll n,l,r,x,y,z,b[Maxn],a[Maxn];

int main() {
//  freopen("test.in","r",stdin);
    scanf("%d",&t);
    while(t--) {
        scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d",&n,&l,&r,&x,&y,&z,&b[1],&b[2]);
        for(int i=3;i<=n;i++) b[i]=b[i-2]*x+b[i-1]*y+z;
        for(int i=1;i<=n;i++) b[i]&=0xffffffff;
        for(int i=1;i<=n;i++) a[i]=b[i]%(r-l+1)+l;
//scanf("%I64d",&n);
//for(int i=1;i<=n;i++) 
//scanf("%I64d",&a[i]);
        ll zhy=a[1],ans=0x7fffffffffffffff;
        for(int i=2;i<=n;i++)
            if(zhy<a[i]) ans=min(ans,a[i]*zhy);
            else zhy=a[i];
        while(a[n]>=0&&n) n--;
        zhy=a[n];
        for(int i=n-1;i>0;i--)
            if(a[i]<0) {
                if(zhy>a[i]) ans=min(ans,a[i]*zhy);
                else zhy=a[i];
            }
        if(ans==0x7fffffffffffffff) puts("IMPOSSIBLE");
        else printf("%I64d\n",ans);
    }
    return 0;
}

听说dalao看到了一个字符串？我再看看有什么可做的吧。

这里有个象棋？马的遍历？普及-？好吧，是让他们归位，并且步数不超过1300？写个爆搜先。。

好像。。一只马从这个点走到另一个点最多7步？那不就随便水水就好了？于是就让dalao做这道题(orz)，我再去看看还有什么可做的。

好像C做的也很多，再看一眼。这不是傻逼题吗，怎么没有人做？于是就随便写了写，然而WA了，只过了样例？

好吧，这个好像是有毛病的，改好了，TLE？被卡常了吗？500000很有可能卡set啊，那就换成unordered_set。

还是T？再从网上抄个输入输出优化，还T？

dalao已经A了。%%%%%%%%

E - Horseback Riding
#include<map>
#include<queue>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
struct node{
    int x,y;
}zhy;
struct nod{
    int a,b,c,d;
};
nod ac[2000];
queue<node>q;
int f[10][10][10][10],num;
int u[8]={1,2,-1,-2,-1,2,1,-2};
int v[8]={2,1,-2,-1,2,-1,-2,1};
int ok[10][10],ans;
void bfs(int x,int y){
    f[x][y][x][y]=1;
    zhy.x=x,zhy.y=y;
    q.push(zhy);
    while(!q.empty()){
        zhy=q.front(),q.pop();
        int ux=zhy.x,uy=zhy.y;
        for(int i=0;i<8;i++){
            int vx=ux+u[i],vy=uy+v[i];
            if(vx>0&&vx<9&&vy>0&&vy<9&&!f[x][y][vx][vy]){
                f[x][y][vx][vy]=f[x][y][ux][uy]+1;
                zhy.x=vx,zhy.y=vy;
                ans=max(ans,f[x][y][vx][vy]);
                q.push(zhy);
            }
        }
    }
}
char s[10];
void mov(int a,int b,int c,int d){
    if(a==c&&b==d) return;
    for(int i=0;i<8;i++){
        int vx=a+u[i],vy=b+v[i];
        if(vx>0&&vx<9&&vy>0&&vy<9&&f[a][b][c][d]-1==f[vx][vy][c][d]){
            if(ok[vx][vy]){
                mov(vx,vy,c,d);
                num++;
                ac[num].a=a,ac[num].b=b,ac[num].c=vx,ac[num].d=vy;
            }
            else{
                num++;
                ac[num].a=a,ac[num].b=b,ac[num].c=vx,ac[num].d=vy;
                mov(vx,vy,c,d);
            }
            break;
        }
    }
}
int main(){
//  freopen("1.in","r",stdin);
//  freopen("1.out","w",stdout);
    for(int i=1;i<=8;i++)
        for(int j=1;j<=8;j++)
            bfs(i,j);
    int n;
    scanf("%d",&n);
    int nx=1,ny=1;
    for(int i=1;i<=n;i++){
        scanf("%s",s);
        int x=s[0]-'a'+1,y=s[1]-'0';
        ok[x][y]=1;
    }
    while(ok[nx][ny]){
        nx++;
        if(nx==9) nx=1,ny++;
        if(ny>8){
            printf("0\n");
            return 0;
        }
    }
    int err=0;
    for(int y=1;y<=8;y++){
        for(int x=1;x<=8;x++)
            if(ok[x][y]&&(y>ny||(y==ny&&x>nx))){
                mov(x,y,nx,ny);
                ok[x][y]=0,ok[nx][ny]=1;
                while(ok[nx][ny]){
                    nx++;
                    if(nx==9) nx=1,ny++;
                    if(ny>8){
                        err=1;
                        break; 
                    } 
                }
                if(err==1) break;
            }
        if(err==1) break;
    }
    printf("%d\n",num);
    for(int i=1;i<=num;i++)
        printf("%c%c-%c%c\n",ac[i].a+'a'-1,ac[i].b+'0',ac[i].c+'a'-1,ac[i].d+'0');
    return 0;
}

然而我还没过啊。。dalao没事干也来帮我看，我就向他讲我的复杂度为什么是对的。。等等，我写的好像是n方啊。。好像再开个set就好了。改上WA了，连样例都没过？然后改了许多地方，还是WA？完了啊，还有十分钟了。。

哎，我好像看出来哪里错了，改上，woc，cf打不开了啊。。gg。dalao就去试试vpn，结果试了半天，还是不行，完了，这次真凉了。再看看，woc，能打开了。。

最后终于在结束前4分钟A了。。竟然还有罚时比我们少的？

C - New Year Presents
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<unordered_set>
#include<assert.h>
#include<set>
using namespace std;

const int Maxn=110000;

int tt,n,x,tot[Maxn],zhy[Maxn],s[Maxn],t[Maxn],top,num,sum,bs,m,a[Maxn];
vector<int> vi[Maxn];
unordered_set<int> se[Maxn];
set<int> b;
set<int>::iterator nh[Maxn];

const int InputBufferSize = 67108864;//输入缓冲区大小
const int OutputBufferSize = 67108864;//输出缓冲区大小
 
namespace input
{
    char buffer[InputBufferSize],*ss,*eof;
    inline void init()
    {
        assert(stdin!=NULL);
        ss=buffer;
        eof=ss+fread(buffer,1,InputBufferSize,stdin);
    }
    inline bool read(int &x)
    {
        x=0;
        int flag=1;
        while(!isdigit(*ss))ss++;
        if(eof<=ss)return false;
        if(*ss=='-')flag=-1,ss++;
        while(isdigit(*ss))x=x*10+*ss++-'0';
        x*=flag;
        return true;
    }
}
 
namespace output
{
    char buffer[OutputBufferSize];
    char *ss=buffer;
    inline void flush()
    {
        assert(stdout!=NULL);
        fwrite(buffer,1,ss-buffer,stdout);
        ss=buffer;
        fflush(stdout);
    }
    inline void print(const char ch)
    {
        if(ss-buffer>OutputBufferSize-2)flush();
        *ss++=ch;
    }
    inline void print(int x)
    {
        char buf[25]= {0},*p=buf;
        if(x<0)print('-'),x=-x;
        if(x==0)print('0');
        while(x)*(++p)=x%10,x/=10;
        while(p!=buf)print(char(*(p--)+'0'));
    }
}
 
using namespace input;
using namespace output;

int main() {
//  freopen("test.in","r",stdin);
    init();
    read(tt),read(m);
    for(int i=1;i<=tt;i++) {
        read(n);
        for(int j=1;j<=n;j++) {
            read(x);
            vi[i].push_back(x);
        }
        sum+=n;
    }
    int mo=sum%tt;
    sum/=tt;
    for(int i=1;i<=tt;i++)
        if(vi[i].size()<=sum) {
            s[++top]=i;int len=vi[i].size();tot[top]=len;
            for(int j=0;j<len;j++) se[top].insert(vi[i][j]);
        }
        else t[++num]=i;
    for(int i=1;i<=num;bs+=vi[t[i]].size()-a[t[i]],i++)
        if(mo) a[t[i]]=sum+1,mo--;
        else a[t[i]]=sum;
    for(int i=1;i<=top;i++)
        if(mo) a[s[i]]=sum+1,mo--;
        else a[s[i]]=sum;
    for(int i=1;i<=top;i++) {
        int x=s[i];
        if(tot[i]!=a[x]) b.insert(i);
    }
    print(bs);print('\n');
    for(int i=1;i<=m;i++) zhy[i]=*b.begin(),nh[i]=b.begin();
    for(int i=1;i<=num;i++) {
        int len=vi[t[i]].size(),sxz=len-a[t[i]];
        for(vector<int>::iterator j=vi[t[i]].begin();j!=vi[t[i]].end()&&sxz;j++) {
            int x=*j;
            nh[x]=b.lower_bound(zhy[x]);
            if(nh[x]!=b.end()) zhy[x]=*nh[x];
            while(nh[x]!=b.end()&&se[zhy[x]].count(x)) {
                nh[x]++;if(nh[x]!=b.end()) zhy[x]=*nh[x];
            }
            if(nh[x]!=b.end()) {
                tot[zhy[x]]++;
                if(tot[zhy[x]]==a[s[zhy[x]]]) b.erase(nh[x]);
                se[zhy[x]].insert(x);
                sxz--;
                print(t[i]),print(' '),print(s[zhy[x]]),print(' '),print(x),print('\n');
            }
        }
    }
    flush();
    return 0;
}

于是就这么滚粗了。

orz zhy %%%%%%%%%%%%%%%%%%%%%%%%

K - Right Expansion Of The Mind

原来K这么简单啊。。先判断第一个串里面第一个在第二个串里没出现的字符的位置，如果第一个串从开始到这个字符与另一个相等，并且第二个串出现的字符集合相同的话就是互为子序列。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<unordered_set>
#include<map>
#include<set>
using namespace std;

const int Maxn=1100000;
const int Maxm=110000;

int n,num,tot=100000,ch[Maxn][26],zhy,rot[Maxm],sum;
char a[Maxn],s[Maxn];
vector<int> vi[Maxm];
map<int,int> ma;
map<int,int> mb;

int main() {
//  freopen("test.in","r",stdin);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
        scanf("%s%s",a,s);
        int lena=strlen(a),lens=strlen(s),st=0;
        for(int j=0;j<lens;j++) st|=(1<<(s[j]-'a'));
        if(!mb.count(st)) mb[st]=++sum,rot[sum]=sum;
        zhy=0;
        for(int j=lena-1;j>=0;j--)
            if((st&(1<<a[j]-'a'))==0) {
                zhy=j+1;
                break;
            }
        int now=rot[mb[st]],temp=0;
        while(temp!=zhy) {
            int x=a[temp]-'a';
            if(ch[now][x]==0) {
                tot++;ch[now][x]=tot;
            }
            now=ch[now][x];
            temp++;
        }
        if(!ma.count(now)) {
            num++;
            ma[now]=num;
        }
        vi[ma[now]].push_back(i);
    }
    printf("%d\n",num);
    for(int i=1;i<=num;i++) {
        int len=vi[i].size();
        printf("%d",len);
        for(auto j:vi[i]) printf(" %d",j);
        putchar('\n');
    }
    return 0;
}

转载于:https://www.cnblogs.com/shanxieng/p/10093518.html

weixin_33755554
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2018-2019 Russia Open High School Programming Contest 9/13
BPM136(BPMThor)
01-23 570
A Solved: 00:10 zkp #include &amp;lt;bits/stdc++.h&amp;gt; using namespace std; long long a[200010],b[200010]; int main() { int n,m; long long ans=0,sum,t; cin&amp;gt;&amp;gt;n; for(int i=0;i&amp;lt;n;i++) { sum=0...
题解 (The 2019 ICPC Asia Shanghai Regional Contest - Online Contest).pdf
01-12
题解 (The 2019 ICPC Asia Shanghai Regional Contest - Online Contest).pdf
CF_2018-2019 Russia Open High School Programming Contest (Unrated, Online Mirror, ICPC Rules, Teams ...
weixin_30901729的博客
12-10 173
只做了两个就去上课去啦... A. Company Merging time limit per test 1 second memory limit per test 512 megabytes input standard input output standard output A conglomerate consists ofnncom...
2018-2019 Russia Open High School Programming Contest
banshen0201的博客
02-27 822
A. Company Merging Solved. 温暖的签到。 1 #include<bits/stdc++.h> 2 3 using namespace std; 4 5 const int maxn = 2e5 + 10; 6 7 typedef long long ll; 8 9 struct node{ 1...
【补题日记】2020-2021 Russia Team Open, High School Programming Contest (VKOSHP 20)
cls1277的博客
10-26 1215
Pro 2020-2021 Russia Team Open, High School Programming Contest (VKOSHP 20) Sol B. Bacteria 其实只要保证对于第i轮分裂后的细菌，前i轮产生的细菌互不相同即可。 怎么保证呢？第i轮细菌的数量为2i2^i2i，长度则为2n−i2^{n-i}2n−i，所以第i轮的01串共有22n−i2^{2^{n-i}}22n−i种。 所以只需要找到一个最大的k，满足2k≤22n−i2^k\leq 2^{2^{n-i}}2k≤22n−i，
一份不太简短的LaTeX2e介绍最新版地址2019 The Not So Short In­tro­duc­tion To LATEX (Chi­nese Edi­tion)
热门推荐
cxrsdn的博客
03-21 1万+
相关链接、pdf链接地址记录（最新版2019），更新至v6.0 2018年9月发布 1.官方CTAN站点 (Comprehensive TEX Archive Network) CTAN://info/lshort/chinese https://ctan.org/tex-archive/info/lshort/chinese pdf链接直达下载： http://mirror...
2021-2022 ICPC, NERC, Northern Eurasia Onsite (Unrated, Online Mirror, ICPC Rules, Teams Preferred)
feiguon的博客
04-22 944
2021-2022 ICPC, NERC, Northern Eurasia Onsite (Unrated, Online Mirror, ICPC Rules, Teams Preferred) C. Connect the Points 本场比赛的小水题。 题目大意：给定平面上3个点，要求给出至多100条横或竖的线段使3个点连通。 本题最大的难点在于理解题意：我一开始以为这道题的意思是要用这些线段构造一条简单路径把三个点连起来，然后WA飞了；后来才知道不一定非得是简单路径，只要连通就行了，然后这题的做
java-programming-contest.zip_java programming
09-24
这个名为"java-programming-contest.zip"的压缩包显然是为准备Java编程竞赛而设计的，其中包含了一份文档——"竞赛java编程题50题(有答案).doc"。这份文档很可能包含了50个不同的编程题目，每个题目都旨在测试参赛者...
ACM.rar_ACM_acm icpc _icpc_site:www.pudn.com_visual c
09-23
标题中的“ACM.rar”可能是指一个包含与ACM（美国计算机协会）国际大学生程序设计竞赛（International Collegiate Programming Contest, ICPC）相关的资源的压缩文件。"acm icpc icpc"这些标签进一步强调了文件内容...
nss-settlement-nasa-Contest-Results-2018-TouristGuide.pdf
03-14
PDF文档资源下载
seerc-2019-editorial.pdf
11-11
ACM-2019-2020 ICPC Southeastern European Regional Programming Contest (SEERC 2019)题解
LCR 155. 将二叉搜索树转化为排序的双向链表
weixin_61067952的博客
07-09 265
中序遍历可以得到排序的序列，遍历时维护当前节点和前一个节点，改变左右指针。头节点设为null，遍历开始判断一下然后初始化。尾节点中序遍历时一直更新。
7.10飞书一面面经
东篱君的博客
07-10 1140
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
leetcode--验证二叉搜索树
liulanba的博客
07-09 660
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
[高频 SQL 50 题(基础版)]第一千七百五十七题，可回收且低脂产品
weixin_45201305的博客
07-10 269
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。没什么难度，作为基础题五十题的第一题练手，现在也开始陆续写一些SQL，作为记录，和leetcode一起，大家都加油。编写解决方案找出既是低脂又是可回收的产品编号。是该表的主键（具有唯一值的列）。
Redis数据结构-String篇
最新发布
时间如瑾 代码如诗
07-12 661
对⼀个内部表示成long型的string执行append, setbit, getrange这些命令，针对的仍然是string的值（即⼗进制表示的字符串），而不是针对内部表⽰的long型进⾏操作。因此，在这些命令的实现中，会把long型先转成字符串再进行相应的操作。String 的内部存储结构⼀般是 sds（Simple Dynamic String，可以动态扩展内存），但是如果⼀个String 类型的 value 的值是数字，那么 Redis 内部会把它转成 long 类型来存储，从⽽减少内存的使用。
文章检查敏感词速度提升10倍+
陈海龙的格物之路
07-09 697
如何对文章进行高效的敏感词检查？
7.深度学习概述
MechMaster
07-10 943
1. 线性回归 1.1 线性回归一般表达式 1.2 线性回归内积表达方式： 1.3 多个样本时，线性回归的进一步表达： 1.4 线性回归方程的解析 1.5 线性回归就是求loss函数的最小值 2. 如何求函数最小值 2.1 一个例子 2.2 求导法——求最小值 2.3 求导法存在的问题 2.4 迭代法——求最小值 3. 代码实现 3.1 手动求函数最小值 3.2 使用pytorch求函数最小值
2020-2021 icpc southeastern european regional programming contest (seerc 2020)
03-16
202-2021 ICPC 东南欧洲区域编程竞赛（SEERC 202）是一项国际性的编程竞赛，旨在促进全球范围内的计算机科学和编程技能的发展。该竞赛由国际大学生程序设计竞赛（ICPC）组织，吸引了来自世界各地的优秀程序员参加。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值