【六个模板】简单数据结构整洁模板

最新推荐文章于 2023-03-23 23:08:00 发布
最新推荐文章于 2023-03-23 23:08:00 发布
阅读量147 收藏
点赞数 1
分类专栏： 【算法/知识点 浅谈】 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45775438/article/details/118658123
版权

【一些模板】简单数据结构整洁模板

区间加法线段树

洛谷 P3372

#include<bits/stdc++.h>
using namespace std;
#define md ((l+r)>>1)
#define ls (p<<1)
#define rs (p<<1|1)
#define ll long long
const int MAX = 1e5+50;
ll aa[MAX];
ll tree[MAX*4];
ll lazy[MAX*4];
void push_up(int p){
    tree[p]=tree[ls]+tree[rs];
}
void build(int p,int l,int r){
    lazy[p] = 0;
    if(l == r){
        tree[p] = aa[l];
        return;
    }
    build(ls,l,md);
    build(rs,md+1,r);
    push_up(p);
}
void add(int p,int l,int r,ll k){
    lazy[p] += k;
    tree[p] += k * (r - l + 1);
}
void push_down(int p,int l,int r){
    add(ls,l,md,lazy[p]);
    add(rs,md+1,r,lazy[p]);
    lazy[p] = 0;
}
void update(int p,int l,int r,int ux,int uy,ll k){
    if(ux <= l && uy >= r){
        add(p,l,r,k);
        return;
    }
    push_down(p,l,r);
    if(ux <= md)update(ls,l,md,ux,uy,k);
    if(uy >  md)update(rs,md+1,r,ux,uy,k);
    push_up(p);
}
ll query(int p,int l,int r,int qx,int qy){
    ll res = 0;
    if(qx <= l && r <= qy)return tree[p];
    push_down(p,l,r);
    if(qx <= md)res += query(ls,l,md,qx,qy);
    if(qy >  md)res += query(rs,md+1,r,qx,qy);
    return res;
}
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;++i)scanf("%lld",&aa[i]);
    build(1,1,n);
    for(int i = 1;i <= m;++i){
        ll op,t1,t2,t3;
        scanf("%lld",&op);
        if(op == 1){
            scanf("%lld%lld%lld",&t1,&t2,&t3);
            update(1,1,n,t1,t2,t3);
        }else{
            scanf("%lld%lld",&t1,&t2);
            printf("%lld\n",query(1,1,n,t1,t2));
        }
    }
    return 0;
}

区间加/乘线段树

洛谷 P3373

#include<bits/stdc++.h>
using namespace std;
#define md ((l+r)>>1)
#define ls (p<<1)
#define rs (p<<1|1)
#define ll long long
const int MAX = 1e5+50;
ll tmod;
ll aa[MAX];
ll tree[MAX*4];
ll tadd[MAX*4];
ll tmul[MAX*4];
void push_up(int p){
    tree[p]=(tree[ls]+tree[rs]) % tmod;
}
void build(int p,int l,int r){
    tadd[p] = 0;
    tmul[p] = 1;
    if(l == r){
        tree[p] = aa[l] % tmod;
        return;
    }
    build(ls,l,md);
    build(rs,md+1,r);
    push_up(p);
}
void add(int p,int l,int r,ll add,ll mul){
    tree[p] = (tree[p] * mul % tmod + add * (r - l + 1) % tmod ) % tmod;
    tmul[p] = tmul[p] * mul % tmod;
    tadd[p] = (tadd[p] * mul % tmod + add) % tmod;
}
void push_down(int p,int l,int r){
    add(ls,l,md,tadd[p],tmul[p]);
    add(rs,md+1,r,tadd[p],tmul[p]);
    tadd[p] = 0;
    tmul[p] = 1;
}
void updateMul(int p,int l,int r,int ux,int uy,ll k){
    if(ux <= l && uy >= r){
        add(p,l,r,0,k);
        return;
    }
    push_down(p,l,r);
    if(ux <= md)updateMul(ls,l,md,ux,uy,k);
    if(uy >  md)updateMul(rs,md+1,r,ux,uy,k);
    push_up(p);
}
void updateAdd(int p,int l,int r,int ux,int uy,ll k){
    if(ux <= l && uy >= r){
        add(p,l,r,k,1);
        return;
    }
    push_down(p,l,r);
    if(ux <= md)updateAdd(ls,l,md,ux,uy,k);
    if(uy >  md)updateAdd(rs,md+1,r,ux,uy,k);
    push_up(p);
}
ll query(int p,int l,int r,int qx,int qy){
    ll res = 0;
    if(qx <= l && r <= qy)return tree[p];
    push_down(p,l,r);
    if(qx <= md)res += query(ls,l,md,qx,qy);
    if(qy >  md)res += query(rs,md+1,r,qx,qy);
    res %= tmod;
    return res;
}
int main()
{
    int n,m;scanf("%d%d%lld",&n,&m,&tmod);
    for(int i = 1;i <= n;++i)scanf("%lld",&aa[i]);
    build(1,1,n);
    for(int i = 1;i <= m;++i){
        ll op,t1,t2,t3;
        scanf("%lld",&op);
        if(op == 1){
            scanf("%lld%lld%lld",&t1,&t2,&t3);
            updateMul(1,1,n,t1,t2,t3);
        }else if(op == 2){
            scanf("%lld%lld%lld",&t1,&t2,&t3);
            updateAdd(1,1,n,t1,t2,t3);
        }else{
            scanf("%lld%lld",&t1,&t2);
            printf("%lld\n",query(1,1,n,t1,t2));
        }
    }
    return 0;
}

Treap 及其相关操作

洛谷 P3369

介绍的博客

#include<bits/stdc++.h>
using namespace std;
#define md ((l+r)>>1)
#define ls (p<<1)
#define rs (p<<1|1)
#define ll long long
const int MAX = 1e5+50;
const int INF = 0x3f3f3f3f;
int na;
int ch[MAX][2];
int val[MAX],dat[MAX],siz[MAX],cnt[MAX];
int tot,root;
int New(int v){
    val[++tot] = v;
    dat[tot] = rand();
    siz[tot] = 1;
    cnt[tot] = 1;
    return tot;
}
void push_up(int id){
    siz[id] = siz[ch[id][0]] + siz[ch[id][1]] + cnt[id];
}
void build(){
    root = New(-INF),ch[root][1] = New(INF);
    push_up(root);
}
void Rotate(int &id,int d){ // d=0 left-rotate d=1 right-rotate
    int temp = ch[id][d^1];
    ch[id][d^1] = ch[temp][d];
    ch[temp][d] = id;
    id = temp;
    push_up(ch[id][d]),push_up(id);
}
void Insert(int &id,int v){
    if(!id){
        id = New(v);
        return;
    }
    if(v == val[id])cnt[id]++;
    else{
        int d = v < val[id] ? 0 : 1;
        Insert(ch[id][d],v);
        if(dat[id] < dat[ch[id][d]])Rotate(id,d^1);
    }
    push_up(id);
}
void Remove(int &id,int v){
    if(!id)return;
    if(v == val[id]){
        if(cnt[id] > 1){
            cnt[id]--;push_up(id);
            return;
        }
        if(ch[id][0] || ch[id][1]){
            if(!ch[id][1] || dat[ch[id][0]] > dat[ch[id][1]]){
                Rotate(id,1);Remove(ch[id][1],v);
            }else{
                Rotate(id,0);Remove(ch[id][0],v);
            }
            push_up(id);
        }else{
            id = 0;
        }
        return;
    }
    v < val[id] ? Remove(ch[id][0],v) : Remove(ch[id][1],v);
    push_up(id);
}
int get_rank(int id,int v){
    if(!id)return -2;
    if(v == val[id])return siz[ch[id][0]]+1;
    if(v < val[id])return get_rank(ch[id][0],v);
    return siz[ch[id][0]] + cnt[id] + get_rank(ch[id][1],v);
}
int get_val(int id,int rk){
    if(!id)return INF;
    if(rk <= siz[ch[id][0]])return get_val(ch[id][0],rk);
    if(rk <= siz[ch[id][0]] + cnt[id])return val[id];
    return get_val(ch[id][1],rk - siz[ch[id][0]] - cnt[id]);
}
int get_pre(int v){
    int id = root,pre;
    while(id){
        if(val[id] < v)pre = val[id],id=ch[id][1];
        else id = ch[id][0];
    }
    return pre;
}
int get_nxt(int v){
    int id = root,nxt;
    while(id){
        if(val[id] > v)nxt = val[id],id = ch[id][0];
        else id = ch[id][1];
    }
    return nxt;
}
int main()
{
    build();
    scanf("%d",&na);
    for(int i = 1;i <= na;++i){
        int op,x;
        scanf("%d%d",&op,&x);
        switch(op){
        case 1:
            Insert(root,x);
            break;
        case 2:
            Remove(root,x);
            break;
        case 3:
            printf("%d\n",get_rank(root,x)-1);
            break;
        case 4:
            printf("%d\n",get_val(root,x+1));
            break;
        case 5:
            printf("%d\n",get_pre(x));
            break;
        case 6:
            printf("%d\n",get_nxt(x));
            break;
        }
    }
    return 0;
}

区间最值操作 区间最值 区间加 区间和

这个模板是别人的， 还没有自己交过题目

#include<bits/stdc++.h>
#define ll long long
#define N 500005
#define lc (p<<1)
#define rc (p<<1|1)
#define mid (T[p].l+T[p].r>>1)
#define inf (1<<30)
using namespace std;
inline ll read(){
    ll ans=0,w=1;
    char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')w=-1;ch=getchar();}
    while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch^48),ch=getchar();
    return ans*w;
}
inline void write(ll x){
    if(x<0)x=-x,putchar('-');
    if(x>9)write(x/10);
    putchar((x%10)^48);
}
int n,m;
ll a[N];
struct Node{int l,r;ll mx,mn,mxx,mnx,cmx,cmn;ll sum,lz;}T[N*3];
inline ll max(ll a,ll b){return a>b?a:b;}
inline ll min(ll a,ll b){return a<b?a:b;}
inline void pushup(int p){
    T[p].sum=T[lc].sum+T[rc].sum;
    T[p].mx=max(T[lc].mx,T[rc].mx);
    T[p].cmx=(T[p].mx==T[lc].mx?T[lc].cmx:0)+(T[p].mx==T[rc].mx?T[rc].cmx:0);
    T[p].mxx=max(T[p].mx==T[lc].mx?T[lc].mxx:T[lc].mx,T[p].mx==T[rc].mx?T[rc].mxx:T[rc].mx);
    T[p].mn=min(T[lc].mn,T[rc].mn);
    T[p].cmn=(T[p].mn==T[lc].mn?T[lc].cmn:0)+(T[p].mn==T[rc].mn?T[rc].cmn:0);
    T[p].mnx=min(T[p].mn==T[lc].mn?T[lc].mnx:T[lc].mn,T[p].mn==T[rc].mn?T[rc].mnx:T[rc].mn);
}
inline void pushnow_mn(int p,ll v){
    if(T[p].mn>=v)return;
    T[p].sum+=T[p].cmn*(v-T[p].mn);
    T[p].mn=v,T[p].mx=max(T[p].mx,v);
    if(T[p].mn==T[p].mx)T[p].sum=1ll*(T[p].cmn=T[p].cmx=(T[p].r-T[p].l+1))*(T[p].mx=T[p].mn=v),T[p].mxx=-inf,T[p].mnx=inf;
    else T[p].mxx=max(T[p].mxx,v);
}
inline void pushnow_mx(int p,ll v){
    if(T[p].mx<=v)return;
    T[p].sum+=T[p].cmx*(v-T[p].mx);
    T[p].mx=v,T[p].mn=min(T[p].mn,v);
    if(T[p].mn==T[p].mx)T[p].sum=1ll*(T[p].cmn=T[p].cmx=(T[p].r-T[p].l+1))*(T[p].mx=T[p].mn=v),T[p].mxx=-inf,T[p].mnx=inf;
    else T[p].mnx=min(T[p].mnx,v);
}
inline void pushnow(int p,ll v){
    T[p].lz+=v,T[p].sum+=1ll*(T[p].r-T[p].l+1)*v;
    T[p].mn+=v,T[p].mx+=v,T[p].mxx+=v,T[p].mnx+=v;
}
inline void pushdown(int p){
    if(T[p].lz)pushnow(lc,T[p].lz),pushnow(rc,T[p].lz),T[p].lz=0;
    pushnow_mn(lc,T[p].mn),pushnow_mn(rc,T[p].mn);
    pushnow_mx(lc,T[p].mx),pushnow_mx(rc,T[p].mx);
}
inline void build(int p,int l,int r){
    T[p].l=l,T[p].r=r,T[p].lz=0;
    if(l==r){
        T[p].mx=T[p].mn=T[p].sum=a[l];
        T[p].cmx=T[p].cmn=1;
        T[p].mxx=-inf,T[p].mnx=inf;
        return;
    }
    build(lc,l,mid),build(rc,mid+1,r),pushup(p);
}
inline void update(int p,int ql,int qr,ll v){
    if(ql>T[p].r||qr<T[p].l)return;
    if(ql<=T[p].l&&T[p].r<=qr){pushnow(p,v);return;}
    pushdown(p);
    if(qr<=mid)update(lc,ql,qr,v);
    else if(ql>mid)update(rc,ql,qr,v);
    else update(lc,ql,mid,v),update(rc,mid+1,qr,v);
    pushup(p);
}
inline void modify1(int p,int ql,int qr,ll v){
    if(ql>T[p].r||qr<T[p].l||T[p].mn>=v)return;
    if(ql<=T[p].l&&T[p].r<=qr&&T[p].mnx>v){pushnow_mn(p,v);return;}
    pushdown(p);
    if(qr<=mid)modify1(lc,ql,qr,v);
    else if(ql>mid)modify1(rc,ql,qr,v);
    else modify1(lc,ql,mid,v),modify1(rc,mid+1,qr,v);
    pushup(p);
}
inline void modify2(int p,int ql,int qr,ll v){
    if(ql>T[p].r||qr<T[p].l||T[p].mx<=v)return;
    if(ql<=T[p].l&&T[p].r<=qr&&T[p].mxx<v){pushnow_mx(p,v);return;}
    pushdown(p);
    if(qr<=mid)modify2(lc,ql,qr,v);
    else if(ql>mid)modify2(rc,ql,qr,v);
    else modify2(lc,ql,mid,v),modify2(rc,mid+1,qr,v);
    pushup(p);
}
inline ll query_sum(int p,int ql,int qr){
    if(ql>T[p].r||qr<T[p].l)return 0;
    if(ql<=T[p].l&&T[p].r<=qr)return T[p].sum;
    pushdown(p);
    if(qr<=mid)return query_sum(lc,ql,qr);
    if(ql>mid)return query_sum(rc,ql,qr);
    return query_sum(lc,ql,mid)+query_sum(rc,mid+1,qr);
}
inline ll query_max(int p,int ql,int qr){
    if(ql>T[p].r||qr<T[p].l)return -inf;
    if(ql<=T[p].l&&T[p].r<=qr)return T[p].mx;
    pushdown(p);
    if(qr<=mid)return query_max(lc,ql,qr);
    if(ql>mid)return query_max(rc,ql,qr);
    return max(query_max(lc,ql,mid),query_max(rc,mid+1,qr));
}
inline ll query_min(int p,int ql,int qr){
    if(ql>T[p].r||qr<T[p].l)return inf;
    if(ql<=T[p].l&&T[p].r<=qr)return T[p].mn;
    pushdown(p);
    if(qr<=mid)return query_min(lc,ql,qr);
    if(ql>mid)return query_min(rc,ql,qr);
    return min(query_min(lc,ql,mid),query_min(rc,mid+1,qr));
}
int main(){
    n=read();
    for(int i=1;i<=n;++i)a[i]=read();
    build(1,1,n);
    m=read();
    while(m--){
        int op=read(),l=read(),r=read();
        switch(op){
            case 1:{ll v=read();update(1,l,r,v);break;}
            case 2:{ll v=read();modify1(1,l,r,v);break;}
            case 3:{ll v=read();modify2(1,l,r,v);break;}
            case 4:{write(query_sum(1,l,r)),puts("");break;}
            case 5:{write(query_max(1,l,r)),puts("");break;}
            default:{write(query_min(1,l,r)),puts("");break;}
        }
    }
    return 0;
}

树链剖分 （路径加 路径求和 子树加 子树求和）

洛谷 P3384

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ls (p<<1)
#define rs (p<<1|1)
#define md ((l+r)>>1)
const int MAX = 1e5+50;
int MOD;

int n,m;
vector<int>V[MAX];
int dep[MAX],fa[MAX],siz[MAX],son[MAX];
void dfs1(int x,int f,int deep){
    dep[x] = deep;
    fa[x] = f;
    siz[x] = 1;
    int maxson = -1;
    for(auto it : V[x]){
        if(it == f)continue;
        dfs1(it,x,deep+1);
        siz[x] += siz[it];
        if(siz[it] > maxson){
            maxson = siz[it];
            son[x] = it;
        }
    }
}
int cnt;
int id[MAX],top[MAX];
ll aa[MAX],bb[MAX];
void dfs2(int x,int topf){
    id[x] = ++cnt;
    bb[cnt] = aa[x];
    top[x] = topf;
    if(!son[x])return;
    dfs2(son[x],topf);
    for(auto it : V[x]){
        if(it == fa[x] || it == son[x])continue;
        dfs2(it,it);
    }
}

ll tree[MAX*4],lazy[MAX*4];
void push_up(int p){
    tree[p] = (tree[ls] + tree[rs]) % MOD;
}
void build(int p,int l,int r){
    lazy[p] = 0;
    if(l == r){
        tree[p] = bb[l] % MOD;
        return;
    }
    build(ls,l,md);
    build(rs,md+1,r);
    push_up(p);
}
void add(int p,int l,int r,ll k){
    tree[p] = (tree[p] + k * (r - l + 1) % MOD) % MOD;
    lazy[p] = (lazy[p] + k) % MOD;
}
void push_down(int p,int l,int r){
    add(ls,l,md,lazy[p]);
    add(rs,md+1,r,lazy[p]);
    lazy[p] = 0;
}
void update(int p,int l,int r,int ux,int uy,ll k){
    if(ux <= l && uy >= r){
        add(p,l,r,k);
        return;
    }
    push_down(p,l,r);
    if(md >= ux)update(ls,l,md,ux,uy,k);
    if(md <  uy)update(rs,md+1,r,ux,uy,k);
    push_up(p);
}
ll query(int p,int l,int r,int qx,int qy){
    if(qx <= l && qy >= r){
        return tree[p] % MOD;
    }
    push_down(p,l,r);
    ll res = 0;
    if(md >= qx)res = (res + query(ls,l,md,qx,qy)) % MOD;
    if(md <  qy)res = (res + query(rs,md+1,r,qx,qy)) % MOD;
    return res;
}


int qRange(int x,int y){
    ll ans = 0;
    while(top[x] != top[y]){
        if(dep[top[x]] < dep[top[y]])swap(x,y);
        ans = (ans + query(1,1,n,id[top[x]],id[x])) % MOD;
        x = fa[top[x]];
    }
    if(dep[x] > dep[y])swap(x,y);
    ans = (query(1,1,n,id[x],id[y]) + ans) % MOD;
    return ans;
}
int qSon(int x){
    return query(1,1,n,id[x],id[x] + siz[x] - 1);
}
void uRange(int x,int y,int k){
    k %= MOD;
    while(top[x] != top[y]){
        if(dep[top[x]] < dep[top[y]])swap(x,y);
        update(1,1,n,id[top[x]],id[x],k);
        x = fa[top[x]];
    }
    if(dep[x] > dep[y])swap(x,y);
    update(1,1,n,id[x],id[y],k);
}
void uSon(int x,int k){
    update(1,1,n,id[x],id[x]+siz[x]-1,k);
}
int main(){
    int root;
    scanf("%d%d%d%d",&n,&m,&root,&MOD);
    for(int i = 1;i <= n;++i){
        scanf("%lld",&aa[i]);
    }
    for(int i = 1;i < n;++i){
        int ta,tb;scanf("%d%d",&ta,&tb);
        V[ta].push_back(tb);
        V[tb].push_back(ta);
    }
    dfs1(root,0,1);
    dfs2(root,root);
    build(1,1,n);
    while(m--){
        int op,x,y,z;
        scanf("%d",&op);
        if(op == 1){
            scanf("%d%d%d",&x,&y,&z);
            uRange(x,y,z);
        }else if(op == 2){
            scanf("%d%d",&x,&y);
            printf("%lld\n",qRange(x,y));
        }else if(op == 3){
            scanf("%d%d",&x,&y);
            uSon(x,y);
        }else{
            scanf("%d",&x);
            printf("%lld\n",qSon(x));
        }
    }
    return 0;
}

Rope 实现区间翻转

洛谷 P3391

#include <bits/stdc++.h>
#include<ext/rope>
using namespace std;
using namespace __gnu_cxx;
#define ll long long
const int MAX = 1e5+50;
rope<int>str,rstr;
int n,m;
void rev(int st,int ed){
    ed++;
    rope<int>tmp = str.substr(st+str.begin(),ed+str.begin());
    str = str.substr(str.begin(), st + str.begin()) + rstr.substr(n - ed + rstr.begin(), n - st + rstr.begin()) + str.substr(ed + str.begin(), str.length() + str.begin());
    rstr = rstr.substr(rstr.begin(), n - ed + rstr.begin()) + tmp + rstr.substr(n - st + rstr.begin(), rstr.length() + rstr.begin());
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;++i){
        str.append(i);
        rstr.append(n-i+1);
    }
    for(int i = 1;i <= m;++i){
        int s,t;scanf("%d%d",&s,&t);
        rev(s-1,t-1);
    }
    for(int i = 0;i < n;++i){
        printf("%d ",str[i]);
    }
    return 0;
}
溢流眼泪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
史上最强最全数据结构课设题目及模板
12-29
对数据结构课程设计模板不清楚的童鞋进来看一哈，最新10版数据结构课设模板 很好很强大
Spring数据访问模板化方法
08-26
由于模板方法已经规定了执行的顺序和结构，子类只需要关注自己的特有部分，这也有助于保持代码的整洁和一致性。 总的来说，Spring数据访问模板化方法是Spring框架为了提高开发效率和代码质量而引入的一种设计模式，...
数据结构模板汇总
HHSSASS的博客
03-23 442
数据结构模板汇总
数据结构模板合集
weixin_30344131的博客
12-05 310
1、线段树 线段树Lazy操作模板(区间修改,区间查询) class Segment_Tree_Lazy{ private: #define ls (p<<1) #define rs ((p<<1)|1) #define mid ((l+r)>>1) int val[100010],cnt[100010]; inl...
数据结构的一些基本模板（顺序栈，队列）
Gary_werewolf的博客
10-08 299
数据结构基操
数据结构模板总结
qq_41729237的博客
09-06 268
并查集 基础并查集： using namespace std; int bin[N] int findd(int x){//查找根节点 int next=x; while(bin[next]!=next) next=bin[next]; return next; } void merge(int x,int y){//合并 int fx,fy; fy=findd(y); fx=findd(x); if(fx!=fy) bin
分享一个Go项目的整洁架构模板
kevin_tech的博客，微信搜「网管叨bi叨」
10-02 796
本文翻译自 https://github.com/evrone/go-clean-template，由于本人翻译水平有限，翻译不当之处烦请指出。希望大家看了这篇文章能有所帮助。感谢捧场。概...
codesmith 模板集合+简单教程
最新发布
07-06
这个资源集合包含了多个实用的模板，涵盖了.net三层架构、Oracle数据导出、T-SQL存储过程等多个方面，为程序员提供了极大的便利。 一、.NET三层架构模板 .NET三层架构是软件设计中的常见模式，包括Model（模型）、...
电脑软件50个Word简历模板表格.rar
10-17
这些模板通常由专业的设计师或人力资源专家精心设计，符合行业标准，包含清晰的结构和布局，确保信息的呈现既有序又醒目。模板中的色彩搭配、字体选择和图形元素都是经过深思熟虑的，旨在使简历看起来既专业又有视觉...
50个Word简历模板表格
07-01
- 专业的外观：使用预设的模板可以确保简历具有整洁、专业的外观，从而给招聘经理留下良好印象。 - 节省时间：相比于从头开始设计，模板大大节省了求职者的时间，让他们可以专注于内容的编写。 - 结构化内容：...
Excel模板简易送货单EXCEL打印模板.zip
06-15
【描述】：描述中的“Excel模板简易送货单EXCEL打印模板.zip”进一步确认了这是一个专为打印送货单而设计的Excel模板，它已经预设好了合适的格式，用户只需填写相关数据，就可以快速生成清晰、规范的送货单，大大...
常用数据结构及其模板
qq_35299223的博客
07-24 442
最近为了面试，在自写一些常用数据结构。目前打算写的包括BST,list,string，heap，并查集，Trie树。 string类模板 #include<iostream> #include<ostream> #pragma warning disable:4996 using namespace std; class mystring { private: char* data; int size; public: mystring() { data = new c
数据结构模板（持续更新）
qq_23096319的博客
01-07 340
【代码】数据结构模板（持续更新）
【算法讲15：多项式卷积】FFT | NTT
溢流眼泪的博客
02-17 4031
【算法讲15：多项式】多项式的表示法多项式的乘法与卷积多项式乘法FFTFFTFFT单位根离散傅里叶变换 DFTDFTDFTDFTDFTDFT 的详细讨论离散傅里叶逆变换 IDFTIDFTIDFT参考与查阅 多项式的表示法 系数表示：nnn 个系数确定一个 n−1n-1n−1 次多项式 (a0,a1,a2,⋯ ,an−1) (a_0,a_1,a_2,\cdots,a_{n-1}) (a0​,a1​,a2​,⋯,an−1​) 点值表示：nnn 个点确定一个 n−1n-1n−1 刺多项式 (x0,x1,x1,⋯
【小组专题二：博弈论入门综述（1）】NP状态 | SG函数 | 巴什博奕、威佐夫博弈、斐波那契博弈、Nim游戏、SJ定理
溢流眼泪的博客
09-03 2479
博弈论综述【1】前言博弈与博弈论博弈树NP状态SG函数(Sprague-Grundy)Sprague-Grundy Theorem巴什博奕 Bash Game威佐夫博弈扩展威佐夫博弈斐波那契博弈Nim博弈拓展Nim博弈与Nim博弈的各个变种（1）拓展维度（2）先手怎么取（3）求先手一开始有多少种取得方式能够赢（4） 变形：有拿取上限（NYOJ-135）（5） 阶梯博弈（**Nim Staircase**博弈）最后的最后：SJ定理与Anti-SG游戏各种练习题啦！可能下期会将的内容（？） 博弈与博弈论
【算法讲13：高斯约旦消元法】改进：判断无解与无穷解
溢流眼泪的博客
02-13 2161
前置 在线性代数的课程中，我们就学过基本的矩阵及其行初等变化。 根据这些初等变化，我们的老师就高速我们怎么样去进行消元，然后求解线性方程组。 模板题 【模板】高斯消元法 | 洛谷 P3389 挺基础的蓝题，虽然是个模板但是思路很简单可以手敲。 ⌈\lceil⌈高斯约旦消元法⌋\rfloor⌋ 首先，我们获得一个系数矩阵 An×nA_{n\times n}An×n​ 和一个列向量 Bn×1B_{n\times 1}Bn×1​ 我们把它合并成一个增广矩阵 An×(n+1)A_{n\times (n+1
【算法讲10：自适应辛普森法】求平滑曲线积分近似 | 洛谷 P4526 | HDU1724 | QLU Youmu with Master spark
溢流眼泪的博客
02-09 1980
自适应辛普森法参考引入⌈\lceil⌈辛普森法求积分⌋\rfloor⌋原理思考⌈\lceil⌈自适应辛普森法求积分⌋\rfloor⌋原理代码例题模板：洛谷 P4526椭圆：HDU1724Youmu with Master spark：QLU contest 003 参考 [学习笔记]自适应辛普森（Simpson）积分 [1][1][1] 引入 【模板】自适应辛普森法2 | 洛谷 P4526 给定 aaa 为小于等于 505050 的实数，求 ∫0∞xax−xdx\int_0^\infin x^{\fr
【算法讲18：二次剩余】勒让德符号 | 欧拉判别法 | Cipolla 算法
溢流眼泪的博客
02-26 1612
【算法讲18：二次剩余】Source\mathfrak{Source}Source⌈\lceil⌈二次剩余⌋\rfloor⌋与⌈\lceil⌈二次非剩余⌋\rfloor⌋⌈\lceil⌈二次互反律⌋\rfloor⌋⌈Cipolla⌋\lceil\mathfrak{Cipolla}\rfloor⌈Cipolla⌋ 算法引入CipollaCipollaCipolla 算法CipollaCipollaCipolla 算法的证明代码中怎么求 (a+ω)(p+1)/2(a+\omega)^{(p+1)/2}(a+ω)
【算法讲2：拓展欧几里得（简略讲）】求解 ax+by=c
溢流眼泪的博客
11-01 1574
拓展欧几里得算法欧几里得算法简介拓展欧几里得算法简介【递归方法：倒序带入法】【递归代码】【递推方法：滚动变量记录法】【递推代码】应用：如何解 ax+by=c测试代码 欧几里得算法简介 大部分参考与查阅：《初等数论及其基本应用》原书第六版。 指辗转相除法。 令整数 r0=a，r1=br_0=a，r_1=br0​=a，r1​=b，满足 a≥b>0a\ge b>0a≥b>0，连续做除法得到： rj=rj+1qj+1+rj+2（j=0 to n−2），rn+1=0r_j=r_
软件工程课程设计模板与数据结构应用实例
项目采用C++编程语言和Borland C++Builder 6.0工具，设计的是一个数据结构算法演示程序，涵盖了链表、栈、队列、树、搜索、图和排序等基本数据结构的典型算法，通过面向对象编程实现，并通过动态演示帮助学生理解和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值