NOIP模板总结

NOIP模板总结

　　进考场先打一份缺省源：

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

int main()
{

    return 0;
}

　　

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n=0;
    while(1)
    {
        printf("Test %d:
",++n);
        system("data.exe");
        system("my.exe");
        system("std.exe");
        if(system("fc std.out my.out"))
            puts("WA"),system("pause");
        else puts("AC");
    }
}

　　

# define r(a,b) (rand()*rand()%((b)-(a)+1)+(a))

　　

int read()
{
    int x=0,f=1;
    char c=getchar();
    while(!isdigit(c)) { if(c=='-') f=-f; c=getchar(); }
    while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}

　　重启一下电脑看看是哪些盘不清空。

调配置：

　　·工具->编译选项->代码警告->显示最多警告消息;

　　·工具->编译选项->连接器->产生调试信息;

　　·(如果$IDE$右边有奇怪的白色竖线):工具->编辑器属性->基本->右边缘->把勾去掉;

　　·工具->编辑器属性->高亮显示当前行->$Green$;

　　·工具->编辑器属性->显示->字体:$Andalus$->大小$10$;

　　·工具->编辑器属性->语法->预设$Obsidian$;

　　虽然比不上$Vscode$漂亮,但是至少挺清楚的.

　　本来想把数据结构都封装成结构体,后来发现没什么用处还容易错...等联赛完了再弄这些东西吧。

　　前几篇模板都是全套的，大多数还在$OJ$上交过,后面的一些来不及写了只写了主要的函数,但是思路肯定是对的.

图论:

　　关于最小生成树,实测还是$kruscal$比较快,而且内存小,而且代码短.

　　

for (R k=1;k<=n;++k)
    for (R i=1;i<=n;++i)
        for (R j=1;j<=n;++j)
            g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
            

　　

# include <cstdio>
# include <iostream>
# include <queue>
# include <cstring>
# define ll long long
# define R register int
# define pac(a,b) make_pair(a,b)

using namespace std;

const int maxn=100005;
const int maxm=200005;
int n,m,s,h,firs[maxn],vis[maxn],x,y,z;
ll d[maxn];
struct edge
{
    int too,nex,co;
}g[maxm<<1];
typedef pair <int,int> pii;
priority_queue <pii,vector<pii>,greater<pii> >q;

void add (int x,int y,int z)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
    g[h].co=z;
}

int read()
{
    int x=0;
    char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

void dij (int s)
{
    int beg,j;
    memset(d,1,sizeof(d));
    d[s]=0;
    q.push(pac(0,s));
    while(q.size())
    {
        beg=q.top().second;
        q.pop();
        if(vis[beg]) continue;
        vis[beg]=true;
        for (R i=firs[beg];i;i=g[i].nex)
        {
            j=g[i].too;
            if(d[beg]+g[i].co>=d[j]) continue;
            d[j]=d[beg]+g[i].co;
            q.push(pac(d[j],j));
        }
    }
}

int main()
{
    n=read(),m=read(),s=read();
    for (R i=1;i<=m;++i)
    {
        x=read(),y=read(),z=read();
        add(x,y,z);
    }
    dij(s);
    for (R i=1;i<=n;++i)
        printf("%lld ",d[i]);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <queue>
# include <cstring>
# define ll long long
# define R register int
# define pac(a,b) make_pair(a,b)

using namespace std;

const int maxn=100005;
const int maxm=200005;
int n,m,s,h,firs[maxn],vis[maxn],x,y,z;
ll d[maxn],f[maxn];
struct edge
{
    int too,nex,co;
}g[maxm<<1];
typedef pair <int,int> pii;
priority_queue <pii,vector<pii>,greater<pii> >q;

void add (int x,int y,int z)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
    g[h].co=z;
}

int read()
{
    int x=0;
    char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

void dij (int s)
{
    int beg,j;
    memset(d,1,sizeof(d));
    d[s]=0;
    f[s]=1;
    q.push(pac(0,s));
    while(q.size())
    {
        beg=q.top().second;
        q.pop();
        if(vis[beg]) continue;
        vis[beg]=true;
        for (R i=firs[beg];i;i=g[i].nex)
        {
            j=g[i].too;
            if(d[beg]+g[i].co>d[j]) continue;
            if(d[beg]+g[i].co==d[j]) f[j]+=f[beg];
            else
            {
                f[j]=f[beg];
                d[j]=d[beg]+g[i].co;
                q.push(pac(d[j],j));
            }
        }
    }
}

int main()
{
    n=read(),m=read(),s=read();
    for (R i=1;i<=m;++i)
    {
        x=read(),y=read(),z=read();
        add(x,y,z);
    }
    dij(s);
    for (R i=1;i<=n;++i)
        printf("%lld ",f[i]);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <queue>
# include <cstring>
# define ll long long
# define R register int

using namespace std;

const int maxn=100005;
const int maxm=200005;
int n,m,s,h,firs[maxn],vis[maxn],x,y,z;
ll d[maxn],f[maxn];
struct edge
{
    int too,nex,co;
}g[maxm<<1];
queue <int> q;

void add (int x,int y,int z)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
    g[h].co=z;
}

int read()
{
    int x=0;
    char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

void spfa (int s)
{
    int beg,j;
    memset(d,1,sizeof(d));
    d[s]=0;
    q.push(s);
    while(q.size())
    {
        beg=q.front();
        q.pop();
        vis[beg]=false;
        for (R i=firs[beg];i;i=g[i].nex)
        {
            j=g[i].too;
            if(d[beg]+g[i].co>d[j]) continue;
        d[j]=d[beg]+g[i].co;
        if(!vis[j]) q.push(j),vis[j]=true;
        }
    }
}

int main()
{
    n=read(),m=read(),s=read();
    for (R i=1;i<=m;++i)
    {
        x=read(),y=read(),z=read();
        add(x,y,z);
    }
    spfa(s);
    for (R i=1;i<=n;++i)
        printf("%lld ",d[i]);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <queue>
# define R register int
# define ll long long
# define pac(a,b) make_pair(a,b)

using namespace std;

const int maxn=5003;
const int maxm=200005;
int n,m,h,firs[maxn],d[maxn],vis[maxn],x,y,z,ed[maxn];
struct edge
{
    int too,nex,co;
}g[maxm<<1];
typedef pair <int,int> pii;
priority_queue <pii,vector<pii>,greater<pii> > q;

void add (int x,int y,int z)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
    g[h].co=z;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=m;++i)
    {
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
    }
    memset(d,1,sizeof(d));
    vis[1]=0,d[1]=0;
    q.push(pac(0,1));
    int j,beg;
    while(q.size())
    {
        beg=q.top().second;
        q.pop();
        if(vis[beg]) continue;
        vis[beg]=true;
        for (R i=firs[beg];i;i=g[i].nex)
        {
            j=g[i].too;
            if(vis[j]) continue;
            d[j]=min(d[j],g[i].co);
            q.push(pac(d[j],j));
        }
    }
    for (R i=1;i<=n;++i)
        if(!vis[j]) 
        {
            printf("orz");
            return 0;
        }
    int ans=0;
    for (R i=1;i<=n;++i)
        ans+=d[i];
    printf("%d",ans);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# define R register int
# define ll long long

using namespace std;

const int maxn=5003;
const int maxm=200005;
int n,m,h,f[maxn],z[maxn],S,fx,fy,ans;
struct ed
{
    int x,y,z;
}g[maxm];

bool cmp (ed a,ed b) { return a.z<b.z; }
int father (int x) { if(x!=f[x]) return f[x]=father(f[x]); return x; }

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=m;++i)
        scanf("%d%d%d",&g[i].x,&g[i].y,&g[i].z);
    sort(g+1,g+1+m,cmp);
    for (R i=1;i<=n;++i)
        f[i]=i,z[i]=1;
    S=n;
    for (R i=1;i<=m;++i)
    {
        fx=father(g[i].x);
        fy=father(g[i].y);
        if(fx==fy) continue;
        ans+=g[i].z;
        if(z[fx]>z[fy]) z[fx]+=z[fy],f[fy]=fx;
        else z[fy]+=z[fx],f[fx]=fy;
        S--;
    }
    if(S!=1) printf("orz");
    else printf("%d",ans);
    return 0;
}

　　

    差分约束其实还是最短路，考的主要是一些建图：
        如果给出的式子有的是小于有的是大于，要先移项后再做；
    举个栗子：a[i]-a[j]<=c -> a[i]<=a[j]+c
    可以认为做一遍最短路后a[j]向a[i]连一条边权为c的边无法更新dis[i],所以连边后跑最短路;
    如果图不保证联通可以加一个虚点向其他所有点连边,边权视情况而定.
    一些基本的性质题目可能不说,但是自己要记得写:a[i]全为正时,s[i]>s[i-1],etc...
    求最大值跑最短路,最小值跑最长路.
    如果有负权边就只能用spfa,无解一般表现为又负环或者正环,用spfa判断.
    虽然很假,但是考场上要是真的不会做了可以考虑"梦想spfa",即运行时间过长时直接认为是负环.
    板子就不写了,和最短路差不多的.

　　

bool spfa()
{
    memset(d,0x3f,sizeof(d));
    int j,beg;
    while (q.size()) q.pop();
    q.push(1);
    d[1]=0;
    while (q.size())
    {
        beg=q.front();
        q.pop();
        vis[beg]=0;
        for (int i=firs[beg];i;i=g[i].nex)
        {
            j=g[i].too;
            if(d[j]>d[beg]+g[i].co)
            {
                d[j]=d[beg]+g[i].co;
                s[j]=s[beg]+1;
                if(s[j]>=n) return 1;
                if(!vis[j])
                {
                    vis[j]=1;
                    q.push(j);
                }
            }
        }
    }
    return 0;
}
判断负环的方法很多，有时dfs的确实快，但是那个的复杂度根本不对，所以建议还是写这个。普通的spfa也有两种写法，一种是记录到每个点的最短路经过了几个点，还有一种是记录每个点入队几次，也许两者一起用是最好的吧，这里给出第一种做法。

　　

void init()
{
    for (R i=2;i<=n;++i) lg[i]=lg[i>>1]+1;
}

void dfs (int x)
{
    int j;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(dep[j]) continue;
        dep[j]=dep[x];
        f[j][0]=x;
        for (R k=1;k<=lg[ dep[j] ];++k)
            f[j][k]=f[ f[j][k-1] ][k-1];
        dfs(j);
    }
}

int lca (int x,int y)
{
    if(dep[x]>dep[y]) swap(x,y);
    for (R i=lg[ dep[y] ];i>=0;--i)
        if(dep[y]-(1<<i)>=dep[x]) y=f[y][i];
    if(x==y) return x;
    for (R i=lg[ dep[x] ];i>=0;--i)
    {
        if(f[x][i]=f[y][i]) continue;
        x=f[x][i];
        y=f[y][i];
    }
    return f[x][0];
}

　　

# include <cstdio>
# include <iostream>
# define R register int

using namespace std;

int n,m,h,firs[maxn],r[maxn],c[maxn],x,y;
struct edge
{
    略去.
};

void dfs (int x)
{
    int j,t;
    for (R &i=firs[x];i;i=g[i].nex) //这个&是优化时间复杂度的精髓所在啊！
    {
        if(vis[i]) continue;
        j=g[i].too;
        vis[i]=true;
        t=i;
        dfs(j);
        sta[++top]=t; //因为之前加过取地址符，所以i可能变了 ：（
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=m;++i)
    {
        scanf("%d%d",&x,&y);
        r[x]++,c[y]++;
        add(x,y);
    }
    for (R i=1;i<=n;++i)
        if(r[i]!=c[i])
        {
            printf("NO");
            return 0;
        }
    for (R i=1;i<=n;++i) //图中可能有一些孤立点，但是因为欧拉回路的关键是边所以没有关系
        if(firs[i])
        {
            dfs(i);
            break;
        }
    for (R i=Top;i>=1;--i) printf("%d ",sta[i]);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# define R register int

using namespace std;

int n,m,h,firs[maxn],r[maxn],c[maxn],x,y;
struct edge
{
    略去.
};

void dfs (int x)
{
    int j,ID;
    for (R &i=firs[x];i;i=g[i].nex) //这个&是优化时间复杂度的精髓所在啊！
    {
        ID=g[i].id;
        if(ID<0) ID=-ID;
        if(vis[ ID ]) continue;
        j=g[i].too;
        vis[ ID ]=true;
        dfs(j);
        sta[++top]=ID; //因为之前加过取地址符，所以i可能变了 ：（
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=m;++i)
    {
        scanf("%d%d",&x,&y);
        d[x]++,d[y]++;
        add(x,y,i);
        add(y,x,-i);
    }
    for (R i=1;i<=n;++i)
        if(d[i]%2)
        {
            printf("NO");
            return 0;
        }
    for (R i=1;i<=n;++i) //图中可能有一些孤立点，但是因为欧拉回路的关键是边所以没有关系
        if(firs[i])
        {
            dfs(i);
            break;
        }
    for (R i=Top;i>=1;--i) printf("%d ",sta[i]);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <cmath>
# include <algorithm>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005;
const int maxm=200005;
int n,m,x,y,h,firs[maxn],d[maxn],f[maxn],z[maxn],od[maxn];
struct edge
{
    int too,nex;
}g[maxm<<1];

int father (int x) { if(x!=f[x]) return f[x]=father(f[x]); return x; }

inline void uni (int x,int y)
{
    int fx=father(x);
    int fy=father(y);
    if(fx==fy) return ;
    if(z[fx]>z[fy]) f[fy]=fx,z[fx]+=z[fy];
    else f[fx]=fy,z[fy]+=z[fx];
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        h=1;
        memset(d,0,sizeof(d));
        memset(firs,0,sizeof(firs));
        memset(od,0,sizeof(od));
        for (R i=1;i<=n;++i) f[i]=i,z[i]=1;
        for (R i=1;i<=m;++i)
        {
            scanf("%d%d",&x,&y);
            d[x]++,d[y]++;
            uni(x,y);
        }
        for (R i=1;i<=n;++i) f[i]=father(i);        
        for (R i=1;i<=n;++i) if(d[i]&1) od[ f[i] ]++;
        int ans=0;
        for (R i=1;i<=n;++i)
            if(f[i]==i&&z[i]!=1) ans+=max(1,od[i]/2);
        printf("%d
",ans);
    }
    return 0;
}

　　

欧拉道路就是把每条边不重不漏的经过一次的道路啦。
无向图：1.图连通；
       2.有0/2个奇点；

有向图：1：图连通；
       2：所有点的入度出度均相等或一点的入度比出度大一，一点入度比出度小一。

　　

void dfs (int x,int f)
{
    id[x]=low[x]=++cnt;
    int j,son_cnt=0;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(!id[j])
        {
            dfs(j,x);
            son_cnt++;
            low[x]=min(low[x],low[j]);
            if(low[j]>=id[x]) cutt[x]=true;
        }
        else low[x]=min(low[x],id[j]);
    }
    if(f==0&&son_cnt>=2) cutt[x]=true;
}

　　

void dfs (int x,int las)
{
    id[x]=low[x]=++cnt;
    int j,son_cnt=0;
    for (R i=firs[x];i;i=g[i].nex)
    {
        if(i==(las^1)) continue;
        j=g[i].too;
        if(!id[j])
        {
            dfs(j,i);
            low[x]=min(low[x],low[j]);
            if(low[j]>id[x]) g[i].t=t[i^1].t=1;
        }
        else
            low[x]=min(low[x],id[j]);
    }
}

　　

void dfs (int x)
{
    id[x]=low[x]=++cnt;
    vis[x]=true;
    sta[++Top]=x;
    int j;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(!id[j])
        {
            dfs(j);
            low[x]=min(low[x],low[j]);
        }
        else if(vis[j]) low[x]=min(low[x],id[j]);
    }
    if(low[x]==id[x])
    {
        col[x]=++bp;
        vis[x]=0;
        while(sta[Top]!=x)
        {
            col[ sta[Top] ]=bp;
            vis[ sta[Top] ]=0;
            Top--;
        }
        Top--;
    }
}

　　

找出桥后删掉所有的桥，每个联通块就是一个边双。

　　

void dfs(int x,int f)
{
    id[x]=low[x]=++cnt;
    int j,sz=0,k;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(!id[j])
        {
            sz++,sta[++Top]=i;
            dfs(j,x);
            low[x]=min(low[j],low[x]);
            if(low[j]>=id[x])
            {
                v[x]=true;
                bp++;
                do
                {
                    k=sta[Top];
                    if(col[ g[k].fro ]!=bp)
                    {
                        col[ g[k].fro ]=bp;
                        v_dcc[bp].push_back(g[k].fro);
                        siz[bp]++;
                    }
                    if(col[ g[k].too ]!=bp)
                    {
                        col[ g[k].too ]=bp;
                        v_dcc[bp].push_back(g[k].too);
                        siz[bp]++;
                    }
                    Top--;
                }while(k!=i);
            }
        }else low[x]=min(low[x],id[j]);
    }
    if(f==0&&sz<=1) v[x]=false;
}

dp优化:

　　注意矩阵乘法时一定要把$k$写在最外层循环，因为每次访问的内存连续所以可以快很多,真的快很多！

　　

struct mat
{
    int n,m;
    ll a[maxn][maxn];
    void init()
    {
        memset(a,0,sizeof(a));
        for (R i=0;i<5;++i)
            a[i][i]=1;
    }
    void cler() { memset(a,0,sizeof(a)); }
    mat operator *  (const mat &a) const
    {
        mat c;
        c.cler();
        for (R k=0;k<a.m;++k)
            for (R i=0;i<this->n;++i)
                for (R j=0;j<this->m;++j)    
                    c.a[i][j]=(c.a[i][j]+this->a[i][k]*a.a[k][j]%m)%m;
        c.n=n;
        c.m=a.m;
        return c;
    }
};

mat qui (mat a,int p)
{
    mat ans;
    ans.init();
    ans.n=ans.m=5;
    while(p)
    {
        if(p&1) ans=ans*a;
        a=a*a;
        p>>=1;
    }
    return ans;
}

　　

ll X (int i) { return ; }
ll Y (int i) { return ; }
ll K (int i) { return ; }
ll B (int i) { return ; }
double KK (int a,int b) {    if(X(b)==X(a)) return 0; return (double)(Y(b,j)-Y(a,j))/(X(b)-X(a));    }

struct xq
{
    int q[maxn];
    int h,t;
    void ins (int i)
    {
        int a,b,c;
        if(h<t) a=q[t-1],b=q[t],c=i;
        while(h<t&&KK(a,b)>KK(a,c))
        {
            t--;
            if(h<t) a=q[t-1],b=q[t],c=i;
        }
        q[++t]=i;
    }
    void del (int i)
    {
        int a,b;
        if(h<t) a=q[h],b=q[h+1];
        while(h<t&&KK(a,b)<K(i))
        {
            h++;
            if(h<t) a=q[h],b=q[h+1];    
        }    
    }
    void init() { h=1,t=0; }
    int firs () { return q[h]; }
}q;

数论算法:

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

ll a,b,p;

int main()
{
    scanf("%lld%lld%lld",&a,&b,&p);
    ll s=1;
    while(b)
    {
        if(b&1LL) s=s*a%p;
        a=a*a%p;
        b=b>>1;
    }
    printf("%lld
",s%p);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

ll a,b,p;

int main()
{
    scanf("%lld%lld%lld",&a,&b,&p);
    ll s=0;
    while(b)
    {
        if(b&1LL) s=s+a%p;
        a=a+a%p;
        b=b>>1;
    }
    printf("%lld
",s%p);
    return 0;
}

　　

int ad (int a,int b)
{
    a+=b;
    if(a>=p) a-=p;
    return a;
}

　　

inv[1]=1;
for (R i=2;i<=n;++i)
    inv[i]=(mod-mod/i)*inv[mod%i]%mod;

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=10000007;
int f[maxn],pri[maxn],h;

void sieve()
{
    f[1]=1;
    for (R i=2;i<=n;++i)
    {
        if(!f[i]) pri[++h]=i;
        for (R j=1;j<=h&&i*pri[j]<=n;++j)
        {
            f[ i*pri[j] ]=1;
            if(i%pri[j]==0) break;
        }
    }
}

int main()
{

    return 0;
}

　　

void sdiv (int x)
{
    for (R i=2;i*i<=n;++i)
    {
        if(x%i==0) p[++h]=i;
        while(x%i==0) c[h]++,x/=i;
    }
    if(x!=1) p[h]=x,c[h]=1;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=10000007;
int f[maxn],pri[maxn],h,m[maxn],a[maxn];

void ldiv (int x)
{
    int cnt=0;
    while(x!=1)
    {
        a[++cnt]=m[x];
        x/=m[x];
    }
}

void sieve()
{
    f[1]=1;
    for (R i=2;i<=n;++i)
    {
        if(!f[i]) pri[++h]=i,m[i]=i;
        for (R j=1;j<=h&&i*pri[j]<=n;++j)
        {
            f[ i*pri[j] ]=1;
            m[ i*pri[j] ]=pri[j];
            if(i%pri[j]==0) break;
        }
    }
}

int main()
{
    sieve();
    return 0;
}

　　

f[1]=1,phi[1]=1;
for(re int i=2;i<=n;i++)
{
    if(!f[i]) p[++p[0]]=i,phi[i]=i-1;
    for(re int j=1;j<=p[0]&&p[j]*i<=n;j++)
    {
        f[p[j]*i]=1;
        if(i%p[j]==0)
        {
            phi[p[j]*i]=phi[i]*p[j];
            break;
        }
        phi[p[j]*i]=phi[i]*(p[j]-1);
    }
}
这个是抄的asuldb的.

　　

int gcd (int a,int b) { return b?gcd(b,a%b):a; }

　　

int gcd (int a,int b)
{
    int p=1;
    if(a<b) swap(a,b);
    while(a&&b)
    {
        if(a%2==0&&b%2==0) p*=2,a/=2,b/=2;
        else if(a%2&&b%2==0) b/=2;
        else if(a%2==0&&b%2) a/=2;
        else a-=b;
        if(a<b) swap(a,b);
    }
    return p*a;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int

using namespace std;

const int maxn=10005;
const int base=1e8;
char c[maxn];
struct big
{
    int a[maxn];
    int len;
    void write()
    {
        printf("%d",a[len]);
        for (R i=len-1;i>=1;--i)
            printf("%08d",a[i]);
        if(len==0) printf("0");
    }
    void div()
    {
        int mod=0;
        for (R i=len;i>=1;--i)
        {
            a[i]+=mod*base;
            mod=a[i]%2;
            a[i]/=2;
        }
        while (a[ len ]==0&&len) len--;
    }
    void clear()
    {
        memset(a,0,sizeof(a));
        len=0;
    }
    void mul()
    {
        for (R i=1;i<=len;++i)
            a[i]*=2;
        for (R i=1;i<=len+1;++i)
            a[i+1]+=a[i]/base,a[i]%=base;
        len++;
        while (a[ len ]==0&&len) len--;
    }
    bool operator < (const big &b) const
    {
        if(b.len!=len) return len<b.len;
        for (R i=len;i>=1;--i)
            if(b.a[i]==a[i]) continue;
            else return a[i]<b.a[i];
        return false;
    }
    void read()
    {
        scanf("%s",c+1);
        int l=strlen(c+1);
        len=l/8+((l%8)?1:0);
        int x=0,pos=0;
        for (R i=1;i<=l;++i)
        {
            x=x*10+c[i]-'0';
            if(i%8==l%8)
            {
                a[ len-pos ]=x;
                pos++;
                x=0;
            }
        }
        if(x) a[len-pos]=x;
    }
}A,B;

void sub()
{
    for (R i=1;i<=B.len;++i)
    {
        A.a[i]-=B.a[i];
        if(A.a[i]<0) A.a[i]+=base,A.a[i+1]--;
    }
    while (A.a[ A.len ]==0&&A.len) A.len--;
}

void gcd ()
{
    int cnt=0;
    if(A<B) swap(A,B);
    while (A.len&&B.len)
    {
        if(A.a[1]%2==0&&B.a[1]%2==0) cnt++,A.div(),B.div();
        else if (A.a[1]%2&&B.a[1]%2==0) B.div();
        else if (A.a[1]%2==0&&B.a[1]%2) A.div();
        else sub();
        if(A<B) swap(A,B);
    }
    for (R i=1;i<=cnt;++i)
        A.mul();
    A.write();
}

int main()
{
    A.read();
    B.read();
       gcd();
    return 0;
}

　　

void exgcd (int a,int b,int &x,int &y)
{
    if(b==0)
    {
        x=1,y=0;
        return;
    }
    exgcd(b,a%b,y,x);
    y-=a/b*x;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ll long long

using namespace std;

const int maxn=10000;
int a[maxn],b[maxn];
char c[maxn];

int main()
{
    scanf("%s",c+1);
    a[0]=strlen(c+1);
    for (R i=1;i<=a[0];++i)
        a[i]=c[ a[0]-i+1 ]-'0';
    scanf("%s",c+1);
    b[0]=strlen(c+1);
    for (R i=1;i<=b[0];++i)
        b[i]=c[ b[0]-i+1 ]-'0';
    a[0]=max(a[0],b[0])+1;
    for (R i=1;i<=a[0];++i)
    {
        a[i]+=b[i];
        a[i+1]+=a[i]/10;
        a[i]%=10;
    }
    while(a[ a[0] ]==0&&a[0]) a[0]--;
    for (R i=a[0];i>=1;--i)
        printf("%d",a[i]);
    if(a[0]==0) printf("0");
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ll long long

using namespace std;

const int maxn=10005;
int a[maxn],b[maxn];
char c[maxn];

bool smaller ()
{
    if(a[0]!=b[0]) return a[0]<b[0];
    for (R i=a[0];i>=1;--i)
        if(a[i]!=b[i]) return a[i]<b[i];
    return false;
}

void chan()
{
    int n=max(a[0],b[0]);
    for (R i=0;i<=n;++i)
        swap(a[i],b[i]);
}

int main()
{
    scanf("%s",c+1);
    a[0]=strlen(c+1);
    for (R i=1;i<=a[0];++i)
        a[i]=c[ a[0]-i+1 ]-'0';
    scanf("%s",c+1);
    b[0]=strlen(c+1);
    for (R i=1;i<=b[0];++i)
        b[i]=c[ b[0]-i+1 ]-'0';
    if(smaller())
    {
        printf("-");
        chan();
    } 
    for (R i=1;i<=a[0];++i)
    {  
        a[i]-=b[i];
        if(a[i]<0) a[i]+=10,a[i+1]--;
    }
    while(a[ a[0] ]==0&&a[0]) a[0]--;
    for (R i=a[0];i>=1;--i)
        printf("%d",a[i]);
    if(a[0]==0) printf("0");
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ll long long

using namespace std;

const int maxn=10005;
int a[maxn],b[maxn],d[maxn];
char c[maxn];

int main()
{
    scanf("%s",c+1);
    a[0]=strlen(c+1);
    for (R i=1;i<=a[0];++i)
        a[i]=c[ a[0]-i+1 ]-'0';
    scanf("%s",c+1);
    b[0]=strlen(c+1);
    for (R i=1;i<=b[0];++i)
        b[i]=c[ b[0]-i+1 ]-'0';
    d[0]=a[0]+b[0]+2;
    for (R i=1;i<=a[0];++i)
        for (R j=1;j<=b[0];++j)
            d[i+j-1]+=a[i]*b[j];
    for (R i=1;i<=d[0];++i)
    {
        d[i+1]+=d[i]/10;
        d[i]%=10;
    }
    while(d[ d[0] ]==0&&d[0]) d[0]--;
    for (R i=d[0];i>=1;--i)
        printf("%d",d[i]);
    if(d[0]==0) printf("0");
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# include <map>
# define R register int
# define ll long long

using namespace std;

const int maxn=100000;
int T,n,m,a[maxn],sta[maxn],Top;
char c[maxn];
map <char,int> m1;
map <int,char> m2;

int main() //模m取余，逆序输出，除法退位位时注意上一位的余数乘n即可 
{
    scanf("%d",&T);
    for (R i=0;i<=9;++i)
        m1[ i+'0' ]=i,m2[i]=i+'0';
    for (R i=10;i<=35;++i)
        m1[i-10+'A']=i,m2[i]=i-10+'A';
    for (R i=36;i<=61;++i)
        m1[i-36+'a']=i,m2[i]=i-36+'a';
    while (T--)
    {
        scanf("%d%d",&n,&m);
        scanf("%s",c+1);
        a[0]=strlen(c+1);
        Top=0;
        for (R i=1;i<=a[0];++i)
            a[a[0]-i+1]=m1[ c[i] ];
        printf("%d ",n);
        for (R i=a[0];i>=1;--i)
            printf("%c",m2[ a[i] ]);
        printf("
");
        while(a[0])
        {
            int r=0;
            for (R i=a[0];i>=1;--i)
            {
                a[i]=r*n+a[i];
                r=a[i]%m;
                a[i]/=m;
            }
            sta[++Top]=r;
            while(a[ a[0] ]==0&&a[0]) a[0]--;
        }
        printf("%d ",m);
        for (R i=Top;i>=1;--i)
            printf("%c",m2[ sta[i] ]);
        printf("

");
    }
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ll long long

using namespace std;

const int maxn=10005;
int a[maxn],b;
char c[maxn];

int main()
{
    scanf("%s",c+1);
    a[0]=strlen(c+1);
    for (R i=1;i<=a[0];++i)
        a[i]=c[ a[0]-i+1 ]-'0';
    scanf("%d",&b);
    ll r=0;
    for (R i=a[0];i>=1;--i)
    {
        a[i]+=r*10;
        r=a[i]%b;
        a[i]/=b;
    }
    while(a[ a[0] ]==0&&a[0]) a[0]--;
    for (R i=a[0];i>=1;--i)
        printf("%d",a[i]);
    if(a[0]==0) printf("0");
    printf("
%lld",r);
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

int T;
ll f[100005],inv[100005];
ll n,m,p;

ll c(ll n,ll m)
{
    if(n<m) return 0;  
    return (f[n]*inv[m]%p)*inv[n-m]%p;
}

ll lucas(ll n,ll m)
{
    if(m==0)
        return 1;
    else
        return (ll)lucas(n/p,m/p)*c(n%p,m%p)%p;
}

ll quick_pow(ll x,ll c)
{
    ll s=1;
    while (c)
    {
        if(c&1) s=s*x%p;
        x=x*x%p;
        c=c>>1;
    }
    return s%p;
}

void init()
{
    f[0]=inv[0]=1;
    for (int i=1;i<p;++i)
    {
        f[i]=f[i-1]*i%p;
        inv[i]=quick_pow(f[i],p-2);
    }
}

int main()
{
    scanf("%d",&T);
    while (T--)
    {
        scanf("%lld%lld%lld",&n,&m,&p);
        init();
        printf("%lld
",lucas(n+m,m));
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# define R register int
# define ll long long

using namespace std;

ll n,m,p;
int h;
ll a[12];
ll pr[12],po[12];
ll ans=1;

ll qui (ll a,ll b,ll p)
{
    ll s=1;
    while (b)
    {
        if(b&1LL) s=s*a%p;
        a=a*a%p;
        b=b>>1LL;
    }
    return s;
}

void ex_gcd (ll a,ll b,ll &x,ll &y)
{
    if(!b) { x=1LL,y=0LL; return ; }
    ex_gcd(b,a%b,y,x);
    y-=a/b*x;
}

ll inv (ll a,ll p)
{
    ll x,y;
    ex_gcd(a,p,x,y);
    return (x%p+p)%p;
}

ll crt ()
{
    ll ans=0;
    ll x,y,m,pri;
    for (R i=1;i<=h;++i)
    {
        pri=po[i];
        m=p/pri;
        m%=pri;
        ex_gcd(m,pri,x,y);
        x=(x%pri+pri)%pri;
        m=p/pri;
        x=x*m%p;
        ans=(ans+x*a[i])%p;
    }
    return ans;
}

ll fac (ll n,ll Pr,ll Po)
{
    if(n==0) return 1;
    ll ans=1;
    for (R i=2;i<=Po;++i)
        if(i%Pr) ans=ans*i%Po;
    ans=qui(ans,n/Po,Po);
    for (R i=2;i<=n%Po;++i)
        if(i%Pr) ans=ans*i%Po;
    return ans*fac(n/Pr,Pr,Po)%Po;
    
}

ll C (ll n,ll m,ll Pr,ll Po)
{
    if(m>n) return 0;
    ll t=0;
    ll a=fac(n,Pr,Po),b=fac(m,Pr,Po),c=fac(n-m,Pr,Po);
    for (ll i=n;i;i/=Pr) t+=i/Pr;
    for (ll i=m;i;i/=Pr) t-=i/Pr;
    for (ll i=n-m;i;i/=Pr) t-=i/Pr;
    return qui(Pr,t,Po)*a*inv(b,Po)%Po*inv(c,Po)%Po;
}


ll Lucas (ll n,ll m)
{
    for (R i=1;i<=h;++i)
        a[i]=C(n,m,pr[i],po[i])%p;
    return crt();
}

void div (ll p)
{
    for (R i=2;i*i<=p;++i)
    {
        if(p%i==0)
        {
            ++h;
            pr[h]=i;
            po[h]=1;
            while (p%i==0) po[h]*=i,p/=i;
        }
    }
    if(p>1) pr[++h]=p,po[h]=p;
}

int main()
{
    scanf("%lld%lld",&n,&m);
    scanf("%lld",&p),div(p);
    printf("%lld",Lucas(n,m));
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# define ll long long
# define R register int

using namespace std;

const int maxn=100005;
int n,f;
ll m[maxn],c[maxn],m1,m2,c1,c2,I,g,x,y;

inline char gc() {
    static char buf[100000],*p1,*p2;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
ll read() {
    ll x=0; 
    char c=gc();
    while(!isdigit(c)) c=gc();
    while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=gc();
    return x;
}

ll gcd (ll a,ll b) { return b?gcd(b,a%b):a; }
void exgcd (ll a,ll b,ll &x,ll &y)
{
    if(b==0)
    {
        x=1,y=0;
        return ;
    }
    exgcd(b,a%b,y,x);
    y-=a/b*x;
}
ll inv (ll a,ll b)
{
    ll x,y;
    exgcd(a,b,x,y);
    x=(x%b+b)%b;
    if(!x) x+=b;
    return x;
}

ll mul (ll a,ll b,ll p)
{
    ll s=0;
    a=(a%p+p)%p;
    b=(b%p+p)%p;
    while (b)
    {
        if(b&1LL) s=(s+a)%p;
        a=(a+a)%p;
        b=b>>1LL;
    }
    return s%p;
}

int main()
{
    scanf("%d",&n);
    f=0;
    for (R i=1;i<=n;++i)
        m[i]=read(),c[i]=read();
    for (R i=2;i<=n;++i)
    {
        m1=m[1],m2=m[i],c1=c[1],c2=c[i];
        exgcd(m1,m2,x,y);
        g=gcd(m1,m2);
        ll t=m[i]/g;
        x=mul(x,(c2-c1)/g,t);
        x=(x%t+t)%t;
        c[1]=(c[1]+mul(m[1],x,m[1]*t))%(m[1]*t);
        m[1]*=t;
        
    }
    printf("%lld",(c[1]%m[1]+m[1])%m[1]);
    return 0;
}

数据结构

　　

# include <cstdio>
# include <iostream>
# define R register int

using namespace std;

int c[500005]={0},n;

void add (int x,int v) 
{
    for (R i=x;i<=n;i+=(i&(-i))) c[i]+=v;
}

int ask (int x)
{
    int S=0;
    for (R i=x;i;i-=(i&(-i))) S+=c[i];
    return S;
}

int main()
{
    int m,x,a,b,v;
    scanf("%d%d",&n,&m);
    for (R i=1;i<=n;i++)
    {
        scanf("%d",&v);
        add(i,v); 
    }
    for (R i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&a,&b);
        if(x==1)
            add(a,b);
        if(x==2)
            printf("%d
",ask(b)-ask(a-1));
    }
    return 0; 
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

int n,m,x,y;
ll k,now,last=0;
ll t[500005]={0};
ll S=0;
int xx;

void add (int x,ll y)
{
    for (R i=x;i<=n;i+=(i&(-i))) t[i]+=y;
}

ll ask (int x)
{
    ll S=0;
    for (R i=x;i;i-=(i&(-i))) S+=t[i];
    return S;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
    {
        scanf("%lld",&now);
        add(i,now-last);
        last=now;
    }
    for (int i=1;i<=m;i++)
    {
        scanf("%d",&xx);
        if(xx==1)
        {
            scanf("%d%d",&x,&y);
            scanf("%lld",&k);
            add(x,k);
            add(y+1,-k);    
        }
        if (xx==2)
        {
            scanf("%d",&x);
            printf("%lld
",ask(x));
        }
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

int m,n,op,x,y,opt;
ll a[100004]={0},k,s1,s2;
ll c[100004]={0},c1[100004]={0};

void add (ll *t,int pos,ll v)
{
    for (R i=pos;i<=n;i+=(i&(-i)))
        t[i]+=v;
}

ll ask (ll *t,int pos)
{
    ll ans=0;
    for (R i=pos;i;i-=(i&(-i)))
        ans+=t[i];
    return ans;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=n;++i)
    {
        scanf("%lld",&a[i]);
        add(c,i,a[i]-a[i-1]);
        add(c1,i,(i-1)*(a[i]-a[i-1]));
    }
    for (R i=1;i<=m;++i)
    {
        scanf("%d",&opt);
        if (op==1) 
        {
            scanf("%d%d%lld",&x,&y,&k);
            add(c,x,k);
            add(c,y+1,-k);
            add(c1,x,k*(x-1));
            add(c1,y+1,-k*y);
        }
        if (op==2)
        {
            scanf("%d%d",&x,&y);
            s1=(x-1)*ask(c,x-1)-ask(c1,x-1);
            s2=y*ask(c,y)-ask(c1,y);
            printf("%lld
",s2-s1);
        }
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# define R register int
# define lowbit(x) (x&(-x))

using namespace std;

const int maxn=2050;
int a,b,c,d,n,m,s1,s2,s3,s4,v;
string st;
int c1[maxn][maxn],c2[maxn][maxn],c3[maxn][maxn],c4[maxn][maxn];

inline void add(int x,int y,int v)
{
    for (R i=x;i<=n;i+=lowbit(i))
        for (R j=y;j<=m;j+=lowbit(j))
        {
            c1[i][j]+=v;
            c2[i][j]+=v*x;
            c3[i][j]+=v*y;
            c4[i][j]+=v*x*y;
        }
}

inline int ask(int x,int y)
{
    int ans=0;
    for (R i=x;i;i-=lowbit(i))
        for (R j=y;j;j-=lowbit(j))
        {
            ans+=(x+1)*(y+1)*c1[i][j];
            ans-=(y+1)*c2[i][j];
            ans-=(x+1)*c3[i][j];
            ans+=c4[i][j];
        }
    return ans;
}

int main()
{
    scanf("X %d %d",&n,&m);
    while (cin>>st)
    {
        if(st[0]=='L') scanf("%d%d%d%d%d",&a,&b,&c,&d,&v);
        else    scanf("%d%d%d%d",&a,&b,&c,&d);
        if(st[0]=='L')
        {
            add(a,b,v);
            add(a,d+1,-v);
            add(c+1,b,-v);
            add(c+1,d+1,v);
        }
        else
            printf("%d
",ask(c,d)-ask(c,b-1)-ask(a-1,d)+ask(a-1,b-1));
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define LL long long
# define nl (n<<1)
# define nr (n<<1|1)

using namespace std;

const int maxn=100005;
int n,m,opt,x,y;
LL k,t[maxn<<2],delta[maxn<<2];

void pushdown (int n,int l,int r)
{
    int mid=(l+r)>>1;
    LL x=delta[n];
    delta[nl]+=x;
    delta[nr]+=x;
    delta[n]=0;
    t[nl]+=(mid-l+1)*x;
    t[nr]+=(r-mid)*x;
}

void build (int n,int l,int r)
{
    if(l==r)
    {
        scanf("%lld",&t[n]);
        return;
    }
    int mid=(l+r)>>1;
    build(nl,l,mid);
    build(nr,mid+1,r);
    t[n]=t[nl]+t[nr];
}

void add (int n,int l,int r,int ll,int rr,LL v)
{
    if(ll<=l&&r<=rr)
    {
        delta[n]+=v;
        t[n]+=(r-l+1)*v;
        return;
    }
    int mid=(l+r)>>1;
    if(delta[n]) pushdown(n,l,r);
    if(ll<=mid) add(nl,l,mid,ll,rr,v);
    if(rr>mid)  add(nr,mid+1,r,ll,rr,v);
    t[n]=t[nl]+t[nr];
}

LL ask (int n,int l,int r,int ll,int rr)
{
    if(ll<=l&&r<=rr)
        return t[n];
    if(delta[n]) pushdown(n,l,r);
    int mid=(l+r)>>1;
    LL ans=0;
    if(ll<=mid) ans=ans+ask(nl,l,mid,ll,rr);
    if(rr>mid)  ans=ans+ask(nr,mid+1,r,ll,rr);
    return ans;
}

int main()
{
    scanf("%d%d",&n,&m);
    build(1,1,n);
    for (R i=1;i<=m;++i)
    {
        scanf("%d",&opt);
        if(opt==1)
        {
            scanf("%d%d%lld",&x,&y,&k);
            add(1,1,n,x,y,k);
        }
        else
        {
            scanf("%d%d",&x,&y);
            printf("%lld
",ask(1,1,n,x,y));
        }
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define nl (n<<1)
# define nr (n<<1|1)

using namespace std;

const int maxn=100005;
int z,x,y,n,m,r,p,a[maxn],h,firs[maxn],dep[maxn],f[maxn],siz[maxn],son[maxn],id[maxn];
int cnt,top[maxn],c[maxn],t[maxn<<2],delta[maxn<<2];
struct edge
{
    int too,nex;
}g[maxn<<1];

int read ()
{
    int x=0,f=1;
    char c=getchar();
    while (!isdigit(c)) { if(c=='-') f=-f; c=getchar(); }
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}

void add_ed (int x,int y)
{
    g[++h].nex=firs[x];
    g[h].too=y;
    firs[x]=h;
}

void dfs1 (int x)
{
    siz[x]=1;
    int j,maxx=0;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(dep[j]) continue;
        dep[j]=dep[x]+1;
        dfs1(j);
        f[j]=x;
        siz[x]+=siz[j];
        if(siz[j]>maxx) maxx=siz[j],son[x]=j;
    }
}

void dfs2 (int x,int Tp)
{
    int j;
    id[x]=++cnt;
    c[cnt]=a[x];
    top[x]=Tp;
    if(!son[x]) return;
    dfs2(son[x],Tp);
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(j==f[x]||j==son[x]) continue;
        dfs2(j,j);
    }
}

void build (int n,int l,int r)
{
    if(l==r)
        t[n]=c[l]%p;
    else
    {
        int mid=(l+r)>>1;
        build(nl,l,mid);
        build(nr,mid+1,r);
        t[n]=(t[nl]+t[nr])%p;
    }
}

void pushdown (int n,int l,int r)
{
    int mid=(l+r)>>1,x=delta[n];
    delta[n]=0;
    delta[nl]+=x;
    delta[nr]+=x;
    t[nl]=(t[nl]+1LL*x*(mid-l+1)%p)%p;
    t[nr]=(t[nr]+1LL*x*(r-mid)%p)%p;
}

void add (int n,int l,int r,int ll,int rr,int z)
{
    if(ll<=l&&r<=rr)
    {
        delta[n]+=z;
        t[n]=(t[n]+1LL*z*(r-l+1)%p)%p;
        return;
    }
    int mid=(l+r)>>1;
    if(delta[n]) pushdown(n,l,r);
    if(ll<=mid) add(nl,l,mid,ll,rr,z);
    if(rr>mid) add(nr,mid+1,r,ll,rr,z);
    t[n]=(t[nl]+t[nr])%p;
}

int ask (int n,int l,int r,int ll,int rr)
{
    if(ll<=l&&r<=rr) return t[n];
    int mid=(l+r)>>1,ans=0;
    if(delta[n]) pushdown(n,l,r);
    if(ll<=mid) ans=(ans+ask(nl,l,mid,ll,rr))%p;
    if(rr>mid) ans=(ans+ask(nr,mid+1,r,ll,rr))%p;
    return ans;
}

void add_link (int x,int y,int z)
{
    z%=p;
    while(top[x]!=top[y])
    {
        if(dep[ top[x] ]>dep[ top[y] ]) swap(x,y);
        add(1,1,n,id[ top[y] ],id[y],z);
        y=f[ top[y] ];
    }
    if(dep[x]>dep[y]) swap(x,y);
    add(1,1,n,id[x],id[y],z);
}

int ask_link (int x,int y)
{
    int ans=0;
    while(top[x]!=top[y])
    {
        if(dep[ top[x] ]>dep[ top[y] ]) swap(x,y);
        ans=(ans+ask(1,1,n,id[ top[y] ],id[y]))%p;
        y=f[ top[y] ];
    }
    if(dep[x]>dep[y]) swap(x,y);
    ans=(ans+ask(1,1,n,id[x],id[y]))%p;
    return ans;
}

void add_st (int x,int z)
{
    z%=p;
    add(1,1,n,id[x],id[x]+siz[x]-1,z);
}

int ask_st (int x)
{
    return ask(1,1,n,id[x],id[x]+siz[x]-1);
}

int main()
{
    n=read(),m=read(),r=read(),p=read();
    for (R i=1;i<=n;++i) a[i]=read();
    for (R i=1;i<n;++i)
    {
        scanf("%d%d",&x,&y);
        add_ed(x,y);
        add_ed(y,x);
    }
    dep[r]=1;
    dfs1(r);
    dfs2(r,r);
    build(1,1,n);
    for (R i=1;i<=m;++i)
    {
        int opt=read();
        if(opt==1)
        {
            x=read(),y=read(),z=read();
            add_link(x,y,z);
        }
        else if(opt==2)
        {
            x=read(),y=read();
            printf("%d
",ask_link(x,y));
        }
        else if(opt==3)
        {
            x=read(),y=read();
            add_st(x,y);
        }
        else 
    {
        x=read();
        printf("%d
",ask_st(x));
        }
    }
    return 0;
}

　　

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#define R register int
#define ll long long

using namespace std;

const int maxn=100;
int f[maxn]={0},z[maxn],n;

int father(int x)
{
    if (f[x]!=x) return f[x]=father(f[x]);
    return x;
}

void Union(int x, int y)
{
    x=f(x);
    y=ff(y);
    if (x==y) return;
    if(z[x]>z[y]) z[x]+=z[y],f[y]=x;
    else z[y]+=z[x],f[x]=y;
}

void init()
{
    for (int i = 1; i <= n; i++)
        f[i]=i,z[i]=1;
}

int main()
{
    scanf("%d", &n);
    init();
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# include <cstdlib>
# define R register int
# define ll long long
# define inf 100000008

using namespace std;

const int maxn=100005;
int n,opt,x;
struct node
{
    int n,r,s,v;
    node *ch[2];
    void in (int x)
    {
        n=s=1;
        v=x;
        r=rand();
        ch[0]=ch[1]=NULL;
    }
    void update ()
    {
        s=n;
        if(ch[0]) s+=ch[0]->s;
        if(ch[1]) s+=ch[1]->s;
    }
    int cmp (int x)
    {
        if(x==v) return -1;
        return x>v;
    }
}*roo,pool[maxn];

node *newnode ()
{
    static int cnt=0;
    return &pool[++cnt];
}

void rotate (node *&n,int d)
{
    node *k=n->ch[d];
    n->ch[d]=k->ch[d^1];
    k->ch[d^1]=n;
    n->update();
    k->update();
    n=k;
}

void ins (node *&n,int x)
{
    if(!n) n=newnode(),n->in(x);    
    else
    {
        int d=n->cmp(x);
        if(d==-1) n->n++;        
        else
        {
            ins(n->ch[d],x);
            if(n->ch[d]->r > n->r) rotate(n,d);
        }
        n->update();
    }
}

void del (node *&n,int x)
{
    if(!n) return;
    int d=n->cmp(x);
    if(d==-1)
    {
        if(n->n > 1) --n->n;
        else if(!n->ch[1]) n=n->ch[0];
        else if(!n->ch[0]) n=n->ch[1];    
        else
        {
            int f=(n->ch[0]->r > n->ch[1]->r)?0:1;
            rotate(n,f);
            del(n->ch[f^1],x);
        }
        
    }else del(n->ch[d],x);
    if(n) n->update();
}

int ask_key (node *&n,int x)
{
    if(!n) return 1;
    if(n->v==x) return (n->ch[0]?n->ch[0]->s:0)+1;
    if(n->v<x) return (n->ch[0]?n->ch[0]->s:0)+n->n+ask_key(n->ch[1],x);
    return ask_key(n->ch[0],x);
}

int ask_value (node *&n,int x)
{
    if(!n||n->s<x||x<=0) return 0;
    int s=n->ch[0]?n->ch[0]->s:0;
    if(s<x&&x<=s+n->n) return n->v;
    if(s>=x) return ask_value(n->ch[0],x);
    return ask_value(n->ch[1],x-s-n->n);
}

int lef (node *&n,int x)
{
    if(!n) return -inf;
    if(n->v >= x) return lef(n->ch[0],x);
    return max(n->v,lef(n->ch[1],x)); 
}

int rig (node *&n,int x)
{
    if(!n) return inf;
    if (n->v <= x) return rig(n->ch[1], x);
    return min(n->v,rig(n->ch[0], x));
}

int main()
{
    scanf("%d",&n);
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d",&opt,&x);
        if(opt==1) ins(roo,x);
        else if(opt==2) del(roo,x);
        else if(opt==3) printf("%d
",ask_key(roo,x));
        else if(opt==4) printf("%d
",ask_value(roo,x));
        else if(opt==5) printf("%d
",lef(roo,x));
        else printf("%d
",rig(roo,x));
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <queue>
# include <cstring>
# include <string>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005;
int n,m,x,y,roo;
struct node
{
    int delta,ch[2],f,siz;
}t[maxn];

int read();

inline void update (int id)
{
    t[id].siz=t[ t[id].ch[0] ].siz+t[ t[id].ch[1] ].siz+1;
}

inline void lin (int x,int f,int d)
{
    t[x].f=f;
    t[f].ch[d]=x;
}

int build (int l,int r)
{
    if(l>r) return 0;
    int mid=(l+r)>>1;
    lin(build(l,mid-1),mid,0);
    lin(build(mid+1,r),mid,1);
    t[mid].delta=0;
    update(mid);
    return mid;
}

inline void pushdown (int n)
{
    t[n].delta=0;
    t[ t[n].ch[0] ].delta^=1;
    t[ t[n].ch[1] ].delta^=1;
    swap(t[n].ch[0],t[n].ch[1]);
}

void write (int x)
{
    if(!x) return;
    if(t[x].delta) pushdown(x);
    write(t[x].ch[0]);
    if(x!=1&&x!=n+2) printf("%d ",x-1);
    write(t[x].ch[1]);
}

inline int D (int x)
{
    return x==t[ t[x].f ].ch[1];
}

void rotate (int x)
{
    int f=t[x].f;
    if(f==roo) roo=x;
    int g=t[f].f;
    int mf=D(x),gf=D(f);
    int k=t[x].ch[mf^1];
    lin(k,f,mf),lin(f,x,mf^1),lin(x,g,gf);
    update(f),update(x);
}

void splay (int x,int g)
{
    while(t[x].f!=g)
    {
        if(t[ t[x].f ].f==g) rotate(x);
        else if(D(x)==D(t[x].f)) rotate(t[x].f),rotate(x);
        else rotate(x),rotate(x);
    }
    update(x);
}

inline int find (int x)
{
    int no=roo;
    x--;
    if(t[no].delta) pushdown(no);
    while (t[ t[no].ch[0] ].siz!=x)
    {
        if(t[ t[no].ch[0] ].siz<x)
            x-=t[ t[no].ch[0] ].siz+1,no=t[no].ch[1];
        else no=t[no].ch[0];
        if(t[no].delta) pushdown(no);
    }
    return no;
}

int main()
{
    n=read(),m=read();
    roo=build(1,n+2);
    while(m--)
    {
        x=read(),y=read();
        x=find(x);
        splay(x,0);
        y=find(y+2);
        splay(y,roo);
        t[ t[y].ch[0] ].delta^=1;
    }
    write(roo);
    return 0;
}

inline int read()
{
    int x=0;
    char c=getchar();
    while (!isdigit(c)) c=getchar();
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# include <cstdlib>
# include <queue>
# include <ctime>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005;
int n,m,v[maxn],h,f[maxn],x,y,k,Q,pos[maxn];
char s[2];
struct node
{
    int n,v,s,r;
    node *ch[2];
    void in (int x)
    {
        n=s=1;
        v=x;
        r=rand();
        ch[0]=ch[1]=NULL;
    }
    int cmp (int x)
    {
        if(x==v) return -1;
        return x>v;
    }
    void update()
    {
        s=n;
        if(ch[0]) s+=ch[0]->s;
        if(ch[1]) s+=ch[1]->s;
    }
}*roo[maxn],pool[maxn*50];
node *q[maxn];

inline int read();
node *newnode();
void ins (node *&node,int x);
inline void mer (int x,int y);
void rotate (node *&n,int d);
int father (int x);
int ask (node *&n,int k);

void write (int x)
{
    if(x<0) putchar('-'),write(-x);
    else
    {
        if(x>=10) write(x/10);
        putchar(x%10+'0');
    }
}

int main()
{
    srand(time(0));
    n=read(),m=read();
    for (R i=1;i<=n;++i)
        x=read(),f[i]=i,ins(roo[i],x),pos[x]=i;
    for (R i=1;i<=m;++i)
    {
        x=read(),y=read();
        if(x==0||y==0) continue;
        mer(x,y);
    }
    Q=read();
    int ans=0;
    while (Q--)
    {
        scanf("%s",s);
        x=read(),y=read();
        if(s[0]=='Q')
        {
            
            x=father(x);
            if(roo[x]->s<y) ans=-1;
            else ans=pos[ ask(roo[x],y) ];
            write(ans);
            putchar('
');
        }
        else
        {
            mer(x,y);
            if(x==0||y==0) continue;
        }
    }
    return 0;
}

inline int read()
{
    int x=0;
    char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

int father (int x) { if(x!=f[x]) return f[x]=father(f[x]); return x; }

node *newnode()
{
    static int cnt=0;
    return &pool[++cnt];
}

void ins (node *&n,int x)
{
    if(!n) n=newnode(),n->in(x);
    else
    {
        int d=n->cmp(x);
        if(d==-1) ++n->n;
        else
        {
            ins(n->ch[d],x);
            if(n->ch[d]->r > n->r) rotate(n,d);
        }
        n->update();
    }
}

void rotate (node *&n,int d) // rotate n->ch[d] to n
{
    node *k=n->ch[d];
    n->ch[d]=k->ch[d^1];
    k->ch[d^1]=n;
    n->update();
    k->update();
    n=k;
}

inline void mer (int x,int y)
{
    if(roo[x]->s<roo[y]->s) swap(x,y);
    x=father(x);
    y=father(y);
    if(x==y) return;
    f[y]=x;
    int h=1,t=0;
    q[++t]=roo[y];
    node *k;
    while(h<=t)
    {
        k=q[h];
        ins(roo[x],k->v);
        if(k->ch[0]) q[++t]=k->ch[0];
        if(k->ch[1]) q[++t]=k->ch[1];
        h++;
    }
    roo[y]=roo[x];
}

int ask (node *&n,int k)
{
    if(!n||k<0||n->s<k) return 0;
    int s=n->ch[0]?n->ch[0]->s:0;
    if(s<k&&k<=n->n+s) return n->v;
    if(s<k) return ask(n->ch[1],k-n->n-s);
    return ask(n->ch[0],k);
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=200005;
int n,m,t[maxn<<5],ch[maxn<<5][2],v[maxn],roo[maxn],nod_cnt,l,r,k,true_value[maxn];
struct node { int p,v; } a[maxn];

bool cmp (node a,node b)
{
    return a.v<b.v;
}

int build (int l,int r)
{
    int id=++nod_cnt;
    if(l==r)
        return id;
    int mid=(l+r)>>1;
    ch[id][0]=build(l,mid);
    ch[id][1]=build(mid+1,r);
    return id;
}

int ins (int las,int l,int r,int pos,int v)
{
    int id=++nod_cnt;
    if(l==r)
    {
        t[id]=t[las]+v;
        return id;
    }
    int mid=(l+r)>>1;
    ch[id][0]=ch[las][0];
    ch[id][1]=ch[las][1];
    if(pos<=mid) ch[id][0]=ins(ch[las][0],l,mid,pos,v);
    else ch[id][1]=ins(ch[las][1],mid+1,r,pos,v);
    t[id]=t[ ch[id][0] ]+t[ ch[id][1] ];
    return id;
}

int ask (int a,int b,int l,int r,int k)
{
    if(l==r) return l;
    int mid=(l+r)>>1,x;
    x=t[ ch[b][0] ]-t[ ch[a][0] ];
    if(x>=k) return ask(ch[a][0],ch[b][0],l,mid,k);
    return ask(ch[a][1],ch[b][1],mid+1,r,k-x); 
}

int main()
{
    scanf("%d%d",&n,&m);
    for (R i=1;i<=n;++i)
        scanf("%d",&a[i].v),a[i].p=i;
    sort(a+1,a+1+n,cmp);
    int cnt=0;
    a[0].v=a[1].v+1;
    for (R i=1;i<=n;++i)
    {
        if(a[i].v!=a[i-1].v) cnt++;
        v[ a[i].p ]=cnt;
        true_value[cnt]=a[i].v;
    }
    roo[0]=build(1,n);
    for (R i=1;i<=n;++i)
        roo[i]=ins(roo[i-1],1,n,v[i],1);
    for (R i=1;i<=m;++i)
    {
        scanf("%d%d%d",&l,&r,&k);
        if(l>r) swap(l,r);
        int x=ask(roo[l-1],roo[r],1,n,k);
        printf("%d
",true_value[x]);
    }
    return 0;
}
//又名根路径可持久化函数式权值线段树

　　

# include <cstdio>
# include <iostream>
# include <cmath>
# define R register int

using namespace std;

const int maxn=50004;
int l,r,c,opt,n,siz;
int a[maxn],b[maxn],delta[maxn];

void add (int l,int r,int v)
{
    if(b[l]==b[r])
    {
        for (R i=l;i<=r;++i)
            a[i]+=v;
    }
    else
    {
        if(b[l]*siz-l>l-(1+b[l]*siz-siz))
        {
            for (R i=1+b[l]*siz-siz;i<l;++i) a[i]-=v;
            delta[ b[l] ]+=v;
        }
        else
            for (R i=l;i<=b[l]*siz;++i) a[i]+=v;
        for (R i=b[l]+1;i<=b[r]-1;++i) delta[i]+=v;
        if(b[r]*siz-r>r-(1+b[r]*siz-siz))
            for (R i=1+b[r]*siz-siz;i<=r;++i) a[i]+=v;
        else
        {
            for (R i=r+1;i<=b[r]*siz;++i) a[i]-=v;
            delta[ b[r] ]+=v;
        }
    }
}

int main()
{
    scanf("%d",&n);
    for (R i=1;i<=n;++i) scanf("%d",&a[i]);
    siz=sqrt(n);
    for (R i=1;i<=n;++i) b[i]=(i-1)/siz+1;
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d%d%d",&opt,&l,&r,&c);
        if(opt==0)
            add(l,r,c);
        else
            printf("%d
",a[r]+delta[ b[r] ]);
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cmath>
# include <algorithm>
# define R register int
# define ll long long
# define P(i) sort(a+1+siz*(i-1),a+1+min(siz*i,n),cmp)

using namespace std;

const int maxn=100004;
int id,n,siz,opt,l,r,c,ans;
ll delta[maxn];
struct dig
{
    int b,k;
    ll v;
}a[maxn];

bool cmp (dig a,dig b) { return a.v<b.v; }

void add (int l,int r,ll c)
{
    if(a[l].b==a[r].b)
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(id*siz,n);++i)
            if(a[i].k>=l&&a[i].k<=r) a[i].v+=c;
        P(a[l].b);
    }
    else
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r)
                a[i].v+=c;
        P(id);
        for (R i=a[l].b+1;i<=a[r].b-1;++i) delta[i]+=c;
        id=a[r].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r)
                a[i].v+=c;
        P(id);
    }
}

int check (int x,ll c)
{
    int l=1+siz*(x-1),r=min(n,siz*x),mid,ans=siz*(x-1);
    while (l<=r)
    {
        mid=r+((l-r)>>1);
        if(a[mid].v+delta[ a[mid].b ]<c)
            l=mid+1,ans=max(ans,mid);
        else
            r=mid-1;            
    }
    return ans-siz*(x-1);
}

int ask (int l,int r,ll c)
{
    int ans=0,id;
    if(a[l].b==a[r].b)
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r&&a[i].v+delta[ a[i].b ]<c)
                ans++;
    }
    else
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r&&a[i].v+delta[ a[i].b ]<c)
                ans++;
        for (R i=a[l].b+1;i<=a[r].b-1;++i)
            ans+=check(i,c);    
        id=a[r].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r&&a[i].v+delta[ a[i].b ]<c)
                ans++;
    }
    return ans;
}

int main()
{
    scanf("%d",&n);
    siz=sqrt(n);
    for (R i=1;i<=n;++i)
    {
        scanf("%lld",&a[i].v);
        a[i].k=i;
        a[i].b=(i-1)/siz+1;
    }
    for (R i=1;i<=a[n].b;++i) P(i);
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d%d%d",&opt,&l,&r,&c);
        if(opt)
        {            
            ans=ask(l,r,1LL*c*c);
            printf("%d
",ans);
        }
        else 
            add(l,r,c);
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cmath>
# include <algorithm>
# define R register int

using namespace std;

const int maxn=50004;
int n,b[maxn],opt,l,r,c,siz;
long long a[maxn],delta[maxn],s[maxn];

void add (int l,int r,int c)
{
    if(b[l]==b[r]) for (R i=l;i<=r;++i) a[i]+=c,s[ b[i] ]+=c;
    else
    {
        for (R i=l;i<=siz*b[l];++i) a[i]+=c,s[ b[i] ]+=c;
        for (R i=b[l]+1;i<=b[r]-1;++i) delta[i]+=c,s[i]+=siz*c;
        for (R i=1+siz*(b[r]-1);i<=r;++i) a[i]+=c,s[ b[i] ]+=c;
    }
}

int ask (int l,int r,int mod)
{
    long long ans=0;
    if(b[l]==b[r]) for (R i=l;i<=r;++i) ans=(ans+a[i]+delta[ b[i] ])%mod;
    else
    {
        for (R i=l;i<=siz*b[l];++i) ans=(ans+a[i]+delta[ b[i] ])%mod;
        for (R i=b[l]+1;i<=b[r]-1;++i) ans=(ans+s[i])%mod;
        for (R i=1+siz*(b[r]-1);i<=r;++i) ans=(ans+a[i]+delta[ b[i] ])%mod;
    }
    return ans%mod;
}

int main()
{
    scanf("%d",&n);
    siz=sqrt(n);
    for (R i=1;i<=n;++i) scanf("%lld",&a[i]);
    for (R i=1;i<=n;++i) b[i]=(i-1)/siz+1,s[ b[i] ]+=a[i];
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d%d%d",&opt,&l,&r,&c);
        if(opt) printf("%d
",ask(l,r,c+1));
        else add(l,r,c);
    }
    return 0;
}

　　

void init()
{
    for (R i=1;i<=n;++i)
        st[i][0]=read();
    for (R k=1;k<=lg[n];++k)
        for (R i=1;i+(1<<k)-1<=n;++i)
            st[i][k]=max(st[i][k-1],st[i+(1<<(k-1))][k-1]);
}

int ask (int a,int b)
{
    int k=lg[b-a+1];
    return max(st[a][k],st[b-(1<<k)+1][k]);
}

制胡窜

　　好像$NOIP$从来没有考过真正的字符串算法啊，最多也就是读入输出，不过还是总结一下，反正会的也不多。那么就按照一本通的顺序好了。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long
# define ULL unsigned long long

using namespace std;

const int maxn=1000006;
const int base=233;
ULL po[maxn],Hash[maxn];
char c[maxn];
int n;

ULL div_Hash (int l,int r) //获取子串的Hashֵ值
{
    return Hash[r]-Hash[l]*po[r-l+1];
}

int main()
{
    scanf("%s",c+1);
    n=strlen(c+1);
    po[0]=1;
    for (R i=1;i<=n;++i) po[i]=po[i-1]*base;
    for (R i=1;i<=n;++i) Hash[i]=Hash[i-1]*base+c[i];
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long
# define ULL unsigned long long
# define mod 1000000007

using namespace std;

const int maxn=1000006;
const int base=233;
ll po[maxn],Hash[maxn];
char c[maxn];
int n;

ll div_Hash (int l,int r) //获取子串的Hashֵ值
{
    return ((Hash[r]-Hash[l]*po[r-l+1])%mod+mod)%mod;
}

int main()
{
    scanf("%s",c+1);
    n=strlen(c+1);
    po[0]=1;
    for (R i=1;i<=n;++i) po[i]=(po[i-1]*base)%mod;
    for (R i=1;i<=n;++i) Hash[i]=(Hash[i-1]*base+c[i])%mod;
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int mod=19260817;
const int maxn=1000005;
int h,n,p1=1,ans,p2=1,a[maxn],v[maxn],firs[mod+10],nex[mod+10];

bool que (int x)
{
    int hash=x;
    while (hash>mod) hash-=mod;
    for (R i=firs[hash];i;i=nex[i])
        if(v[i]==x) return true;
    return false;
}

void add (int x)
{
    int hash=x;
    while (hash>mod) hash-=mod;
    v[++h]=x;
    nex[h]=firs[hash];
    firs[hash]=h;
}

void del (int x)
{
    int hash=x;
    while (hash>mod) hash-=mod;
    for (R i=firs[hash];i;i=nex[i])
        if(v[i]==x)
        {
            v[i]=-1;
            return ;
        }
}

int main()
{

    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=1000006;
char s[maxn],t[maxn];
int p[maxn],ls,lt,j;

int main()
{
    scanf("%s",s+1);
    scanf("%s",t+1);
    ls=strlen(s+1);
    lt=strlen(t+1);
    p[1]=0;
    for (R i=2;i<=lt;++i)
    {
        j=p[i-1];
        while(j&&t[i]!=t[j+1]) j=p[j];
        if(t[i]==t[j+1]) p[i]=j+1;
        else p[i]=0;
    }
    j=0;
    for (R i=0;i<ls;++i)
    {
        while(j&&a[i+1]!=b[j+1]) j=p[j];
        if(a[i+1]==b[i+1]) j++;
        if(j==lt) ans++;
    }
    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005*32;
int n,cnt,h,a[40];
struct Trie_01
{
    int ch[maxn][2];
    int vis[maxn];
    void clear()
    {
        memset(ch,0,sizeof(ch));
        memset(vis,0,sizeof(vis));
    }
    void insert()
    {
        int x=1;
        for (R i=1;i<=32;++i)
        {
            if(!ch[x][ a[i] ])
                ch[ x ][ a[i] ]=++cnt;
            x=ch[x][ a[i] ];
        }
        vis[x]++;
    }
    int find()
    {
        int ans=0,x=1;
        for (R i=1;i<=32;++i)
        {
            if(ch[x][ a[i]^1 ])
            {
                ans=ans<<1|1;
                x=ch[x][ a[i]^1 ];
            }
            else x=ch[x][ a[i] ];
        }
        return ans;
    }
}t;

void spilt (int x)
{
    h=0;
    while(x) a[++h]=x,x/=2;
    for (R i=1;i<=h/2;++i) swap(a[i],a[h-i+1]);
}

int main()
{

    return 0;
}

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=100005;
int n,cnt,len;
char c[maxn];
struct Trie_char
{
    int ch[maxn][27];
    int vis[maxn];
    void clear()
    {
        memset(ch,0,sizeof(ch));
        memset(vis,0,sizeof(vis));
    }
    void insert()
    {
        int x=1,n;
        for (R i=1;i<=len;++i)
        {
            n=c[i]-'a';
            if(!ch[x][ no ])
                ch[ x ][ no ]=++cnt;
            x=ch[x][ no ];
        }
        vis[x]++;
    }
    bool find()
    {
        int no,x=1;
        for (R i=1;i<=len;++i)
        {
            no=a[i]-'a';
            if(!ch[x][no]) return false;
            x=ch[x][no];
        }
        return vis[x];
    }
}t;

int main()
{
    scanf("%s",c+1);
    len=strlen(c+1);
    return 0;
}

其它：

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <algorithm>
# include <cmath>
# define R register int
# define ll long long

using namespace std;

const int maxn=41;
int n,l,r;
ll m,a[maxn],ans,x;
ll lef[1<<21],rig[1<<21];

void dfs (int x,int l,int r,int col,ll S)
{
    if(x==r+1)
    {
        if(col==1) lef[ ++lef[0] ]=S;
        else rig[ ++rig[0] ]=S;
        return ;
    }
    dfs(x+1,l,r,col,S+a[x]);
    dfs(x+1,l,r,col,S);
}

int main()
{
    scanf("%d%lld",&n,&m);
    for (R i=1;i<=n;++i)
        scanf("%lld",&a[i]);
    int mid=n/2;
    dfs(1,1,mid,1,0);
    dfs(mid+1,mid+1,n,2,0);
    sort(lef+1,lef+lef[0]+1);
    sort(rig+1,rig+rig[0]+1);
    l=-1;
    r=rig[0];
    for (R i=1;i<=lef[0];++i)
    {
        x=lef[i];
        while(r&&x+rig[r]>m) r--;
        if(l==-1) l=r;
        while(l&&x+rig[l]<=m) l--;
        ans+=(r-l);
    }
    printf("%lld",ans);
    return 0;
}

　　

int find_lef (int x) //x的前驱
{
    int l=1,r=n,mid,ans=0;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]<x)
            ans=max(ans,mid),l=mid+1;
        else
            r=mid-1;
    }
    return ans;
}

int find_rig (int x) //x的后继
{
    int l=1,r=n,mid,ans=n;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(a[mid]>x)
            ans=min(ans,mid),r=mid-1;
        else
            l=mid+1;
    }
    return ans;
}

　　

double open_up () //开口朝上的函数
{
    double l=-inf,r=inf,lmid,rmid;
    while(r-l>=eps)
    {
        lmid=l+(l+r)/3.0;
        rmid=r-(l+r)/3.0;
        if(f(lmid)>f(rmid))
            l=lmid;
        else
            r=rmid;
    }
    return f(l);
}

double open_down()//开口朝下的函数
{
    double l=-inf,r=inf,lmid,rmid;
    while(r-l>=eps)
    {
        lmid=l+(l+r)/3.0;
        rmid=r-(l+r)/3.0;
        if(f(lmid)<f(rmid))
            l=lmid;
        else
            r=rmid;
    }
    return f(l);
}

建议:

　　1.每道题做完后可以开着$O_2$测一下,可能能查出来一些内存方面或者是局部变量忘记清零这样的错误.

　　2.多组数据的题一定要记得清空数组,可以把所有定义的数组都先清空再看哪些是不必要的,定义了$STL$的队列一定要用$q.pop()$清空,千万不要用$q.front()$.所有的变量也都要清为初始状态,注意初始状态不一定是$0$!

　　这里还有$asuldb$的模板库:https://35178.blog.luogu.org/noip-qian-di-ban-zi-men

　　最大值赋得不够大:$memset$一个 $int$ 数组全为 $1$ 还是比 $10^9$ 小的,可以记录$-1$作为初始状态或是直接用$ll$.

　　离线处理询问后忘了调回原来的顺序:记录$id$,处理完后重排序;

　　奇妙的$CE$:用命令行编译可以彻底杜绝此类问题,注意编译之前另存一份,防止被编译没了.

　　不要用英语单词做变量名,不要用除了$n,m,k,x,y,a,b,c,t$之外的单个字母做变量名.

　　树链剖分时不要用top做变量名.