NOIP的模板--考前复习

距离NOIP还有-1天

可以去放弃一些巨难得题目去搞一些模板了

　　　　　　　　　　　　　　-------在校老师的原话

一·快排

虽然可以手打，最好用STL，里面有很多优化，会快很多

#include<iostream>
#include<algorithm>
using namespace std;
struct node
{
    int x,y;
}a[maxn];
bool cmp(node a,node b)
{
    return a.x<b.x;
}
int main()
{
    sort(a+1,a+1+n,cmp);
    return 0;
 } 

二·冰茶姬

一个很好用，很好压行的神奇初级（虽然难题是真的不会）黑科技。

 int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}

三·快速幂||取模运算（就是快速幂里要取模）

int KSM(int a,int b,int c)
{
    int ans=1;a%=c;
    while(b>0)
    {
        if(b%2==1)ans=ans*a%c;
        b/=2;a=a*a%c;
    }
    return ans;    
}

四·线性筛素数

这题有很多方法，比如瞎搞，因为大于10的素数一定都在6的倍数的两边，至于证明什么的可以去找数竞。

或者可以用埃筛（几乎是线性），或者用欧筛

• 以6的倍数来搞事的判断方法：

• bool prime(int n)
  {
      if(n==1)return false;
      if(n==2||n==3)return true;
      if(n%6!=1&&n%6!=5)return false;
      for(int i=5;i*i<=n;i+=6)
      if(n%i==0||n%(i+2)==0)retrun false;
      return true;
  }

  埃筛

• void make_prime()
  {
      memset(prime,true,sizeof(prime));
      prime[0]=prime[1]=false;
      int t=sqrt(MAXN);
      for(register int i=2;i<=t;i++)if(prime[i])
      for(register int j=2*i;j<MAXN,j+=i)
      prime[j]=false;
  }

  欧筛

• void make_prime()
  {
      memset(prime,true,sizeof(prime));
      prime[0] = prime[1] = false;
      for( int i = 2; i <= MAXN; i++) {
          if( prime[i] ) Prime[ num ++ ] = i;
          for(int j = 0;j<num && i*Prime[j] < MAXN; j++) {
              prime[ i*Prime[j] ] = false;
              if( !( i%Prime[j] ) ) break;
          }
      }
      return;
  }

  还有一些其他搞事的办法，但埃筛，一般就够用了

五·最小生成树

人生信条能打kruskal永远不打prim!!!!!!

void kruskal()
{
    int f1,f2,k,i;
    k=0;
    for(i=1;i<=n;i++)
    prt[i]=i;
    for(i=1;i<=m;i++)
    {
        f1=find(a[i].x);
        f2=find(a[i].y);
        if(f1!=f2)
        {
            ans=ans+a[i].z;
            prt[f1]=f2;
            k++;
            if(k==n-1)
            break;
        }
    }
    if(k<n-1)
    {
        cout<<"orz"<<endl;
        bj=0;
        return ;
    }
}

六·单源最短路弱化版（SPFA）

能打SPFA不打dijkstra!!!!!!!!

inline void spfa(int k)
{
    queue< int >q;
    dis[k] = 0; q.push(k); vis[k] = 0;
    while(!q.empty()) {
        x = q.front(); q.pop(); vis[x] = 0;
        for(int i = head[x]; i != 0; i = way[i].next ) {
            if(dis[x] + way[i].w < dis[way[i].to]) {
                dis[way[i].to] = dis[x] + way[i].w;
                if(vis[way[i].to] == 0) {
                    q.push(way[i].to);
                    vis[way[i].to] = 1;
                }
            }
        }
    }
}

七·树状数组

int lowbit(int x)
{
    return x&(-x);
}
int add(int x,int y)
{
    while(x<=n)
    {
        c[x]+=y;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int res=0;
    while(x>0)
    {
        res+=c[x];
        x-=lowbit(x);
    }
    return res;
}

八·乘法逆元

线性的，还有什么费马小，感觉没什么用，就没打

int CFNY(int n)
{
    inv[1]=1;
    cout<<1<<endl;
    for(int i=2;i<=n;i++)
    {
        inv[i]=(long long )(p-p/i)*inv[p%i]%p;
        cout<<inv[i]<<endl;
    }
}

九·康托展开

绝对没人会在NOIP考这个东西，要是他考了，以后就可以说 这很NOIP。。。。

 

ll kangtuo(ll x[])
{
    ll p=0;
    for(ll i=1;i<=n;i++)
    {
        ll t=0;
        for(ll j=i+1;j<=n;j++)
        {
            if(x[i]>x[j])
            {
                t++;
            }
        }
        p+=t*fc[n-i];
    }
    return p+1;
}

十·最近公共祖先（LCA）

void dfs(int x,int father)//x为当前节点，father为其父节点 
{
    deep[x]=deep[father]+1;//当前点的深度为其父节点深度加1 
    parents[x][0]=father;//当前点的2^0祖先(也就是上1级祖先)就是其父节点 
    for(int i=1;(1<<i)<=deep[x];i++)
    {
        parents[x][i]=parents[parents[x][i-1]][i-1];
        //这里应该是整个预处理阶段中最有灵魂的部分了
        //x的2^i级祖先就是x的2^(i-1)级祖先的2^(i-1)级的祖先 。
        //2^i==2^(i-1)+2^(i-1),这个式子好像没什么可说的 
    }
    for(int i=head[x];i;i=way[i].next)
    {
        int to=way[i].to;
        if(to!=father)
        dfs(to,x);
     } 
 } 
 
int lca(int a,int b)//a,b为两个要查询的点 
{
    if(deep[a]>deep[b])//我时刻保证a的深度比b的小 
    {
        swap(a,b); //如果反了就换一下 
    }
    for(int i=20;i>=0;i--)
    {
         if(deep[a]<=deep[b]-(1<<i)) 
         b=parents[b][i];//将a和b跳的同一高度 
    } 
    if(a==b)//如果b在跳上来时和a一样了，那说明a就是a和b的LCA，直接返回就行了 
    return a;
    for(int i=20;i>=0;i--)
    {
        if(parents[a][i]==parents[b][i])
        continue;
        else
        {
            a=parents[a][i];
            b=parents[b][i];//将a和b一起往上跳 
        }
    }
    return parents[a][0];//找出最后的答案 
}

十一·卢卡斯

只存在于组合数里的东西

long long CC(long long n,long long m){
    if(m>n)
    return 0;
    return ((c[n]*KSM(c[m],p-2,p))%p*KSM(c[n-m],p-2,p)%p);
}
long long  Lucas(long long n,long long m){
    if(!m)
    return 1;
    return CC(n%p,m%p)*Lucas(n/p,m/p)%p;
}

十二·二分图匹配

int dfs(int t)
{
    for (int i=1; i<=n2; ++i)
        if (a[t][i] == 1 && check[i] == 0)
        {
            check[i] = 1;
            if (p[i] == 0 || dfs(p[i]) == 1)
            {
                p[i] = t;
                return 1;
            }
        }
    return 0;
}

十三·强连通分量（tarjan）

void tarjan(int s)
{
    dfn[s]=low[s]=++tim;
    in[s]=1,stack[++top]=s;
    for(int i=head[s];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[s]=min(low[v],low[s]);
        }
        else if(in[v]&&low[s]>dfn[v])low[s]=dfn[v];
    }
    if(dfn[s]==low[s])
    {
        int p;
        belong[s]=++cnt;
        do
        {
            p=stack[top--];
            in[p]=0;
            belong[p]=cnt;
        }while(p!=s);
    }
}

 十四·割点（还是那个有名的tarjan）

int tarjan(int x,int y)
{
    low[x]=dfn[x]=++tim;
    int child=0;
    for(int i=head[x];i;i=way[i].next)
    {
        int v=way[i].to ;
        if(!dfn[v])
        {
            tarjan(v,y);
            low[x]=min(low[x],low[v]);
            if(dfn[x]<=low[v]&&x!=y)
            {
                cut[x]=1;
            }
            if(x==y)
            {
                child++;
            }
        }
        low[x]=min(low[x],dfn[v]);
        if(child>=2&&x==y)
        {
            cut[x]=1;
        }
    }
}

 

 十五·对拍之造数据（maker）Windows下

eg. 2个正整数x0​,y0​

#include<bits/stdc++.h>
using namespace std;
int main()
{
    freopen("data.in","w",stdout);
    srand(time(NULL));
    int n=rand();
    int m=rand();//可以在这里加模数来控制范围 
    cout<<n<<" "<<m<<endl;
}

 

 十六·对拍之检查（check）Windows下

这个在用之前一定要先把所有的程序先跑一下，然后一定要在同一各根目录下，不然有可能会用一些很神奇的东西把源程序给覆盖掉

#include<bits/stdc++.h>
using namespace std;
int main()
{
    while(1)
    {
        system("maker");
        system("true");
        system("false");
        if(system("fc false.out true.out")
        {
            cout<<"WA"<<endl;
            break;
        }
        cout<<"AC"<<endl;
    }
    return 0;
 } 

 十七·缩点（还是那个tarjan）

void tarjan(int x)
{
    low[x]=dfn[x]=++tim;
    stac[++top]=x;
    vis[x]=1;
    for(int i=head[x];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(!dfn[v])
        {
            tarjan(v);
            low[x]=min(low[x],low[v]);
        }
        else if(vis[v])
        {
            low[x]=min(low[x],dfn[v]);
        }
    }
    if(dfn[x]==low[x])
    {
        int y;
        while(y=stac[top--])
        {
            sd[y]=x;
            vis[y]=0;
            if(x==y)
            break;
            p[x]+=p[y];
        }
    }
}

 

 十八·网络最大流（很NOIP的一个东西）

int bfs()
{
    memset(deep,0x3f,sizeof(deep));
    memset(in,0,sizeof(in));
    deep[s]=0;
    queue<int >q;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        in[x]=0;
        for(int i=head[x];i;i=way[i].next)
        {
            int v=way[i].to;
            if(deep[v]>deep[x]+1&&way[i].value)
            {
                deep[v]=deep[x]+1;
                if(in[v]==0)
                {
                    q.push(v);
                    in[v]=1;
                }
            }
        }
    }
    if(deep[t]!=0x3f3f3f3f)
    return 1;
    return 0;
}
int dfs(int x,int y)
{
    ans=0;
    if(x==t)
    return y;
    for(int i=head[x];i;i=way[i].next)
    {
        int v=way[i].to;
        if(way[i].value&&deep[v]==deep[x]+1)
        {
            if(ans=dfs(v,min(y,way[i].value)))
            {
                way[i].value-=ans;
                way[i^1].value+=ans;
                return ans;
            }
        }
    }
    return 0;
}
int dinic()
{
    low=0;
    while(bfs())
    {
        while(low=dfs(s,inf))
        maxnn+=low;
    }
    return maxnn;
}

 

十九·最小费用最大流

int spfa()
{
    memset(dis,0x3f,sizeof(dis));
    memset(pre,0,sizeof(pre));
    memset(in,0,sizeof(in));
    queue<int >q;
    q.push(s);
    in[s]=1;
    dis[s]=0;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        in[x]=0;
        for(int i=head[x];i;i=way[i].next)
        {
            int v=way[i].to;
            int w=way[i].cost;
            if(way[i].value>0&&dis[v]>dis[x]+w)
            {
                dis[v]=dis[x]+w;
                pre[v].from=x;
                pre[v].edge=i;
                if(in[v]==0)
                {
                    q.push(v);
                    in[v]=1;
                }
            }
        }
    }
    return dis[t]!=0x3f3f3f3f;
}
int ek()
{
    ans=0;
    cost=0;
    int mi;
    int i;
    while(spfa())
    {
        mi=inf;
        for(i=t;i!=s;i=pre[i].from)
        {
            mi=min(mi,way[pre[i].edge].value);
        }
        for(i=t;i!=s;i=pre[i].from)
        {
            way[pre[i].edge].value-=mi;
            way[pre[i].edge^1].value+=mi;
        }
        ans+=mi;
        cost+=mi*dis[t];
    }    
    return ans;
}

 

二十·高精度加减乘除模

 

#include <bits/stdc++.h>
using namespace std;
struct Big
{
    static const int BASE = 100000000;
    static const int WIDTH = 8;
    vector<long long> s;
    Big()
    {
        *this = 0;
    }
    Big(const int &num)
    {
        *this = num;
    }

    Big operator=(int num)
    {
        s.clear();
        do
        {
            s.push_back(num % BASE);
            num /= BASE;
        } while (num > 0);
        return *this;
    }
    Big operator=(const string &str)
    {
        s.clear();
        int x, len = (str.length() - 1) / WIDTH + 1;
        for (int i = 0; i < len; i++)
        {
            int end = str.length() - i * WIDTH;
            int start = max(0, end - WIDTH);
            sscanf(str.substr(start, end - start).c_str(), "%lld", &x);
            s.push_back(x);
        }
        return *this;
    }
    bool operator<(const Big &b)
    {
        if (s.size() < b.s.size())
            return true;
        if (s.size() > b.s.size())
            return false;
        for (int i = s.size() - 1; i >= 0; i--)
        {
            if (s[i] < b.s[i])
                return true;
            if (s[i] > b.s[i])
                return false;
        }
        return false;
    }
    bool operator>=(const Big &b)
    {
        return !(*this < b);
    }
    bool operator==(const Big &b)
    {
        if (s.size() != b.s.size())
            return false;
        for (int i = 0; i < s.size(); i++)
            if (s[i] != b.s[i])
                return false;
        return true;
    }
    Big operator+(const Big &b)
    {
        Big c;
        c.s.clear();
        for (int i = 0, g = 0;; i++)
        {
            if (g == 0 && i >= s.size() && i >= b.s.size())
                break;
            int x = g;
            if (i < s.size())
                x += s[i];
            if (i < b.s.size())
                x += b.s[i];
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c;
    }
    Big operator-(const Big &b)
    {
        Big c;
        c = *this;
        for (int i = 0; i < c.s.size(); i++)
        {
            int tmp;
            if (i >= b.s.size())
                tmp = 0;
            else
                tmp = b.s[i];
            if (c.s[i] < tmp)
            {
                c.s[i + 1] -= 1;
                c.s[i] += BASE;
            }
            c.s[i] -= tmp;
        }
        while (c.s.back() == 0 && c.s.size() > 1)
            c.s.pop_back();
        return c;
    }
    void operator-=(const Big &b)
    {
        *this = *this - b;
    }
    Big operator*(const Big &b)
    {
        Big c;
        c.s.resize(s.size() + b.s.size());
        for (int i = 0; i < s.size(); i++)
            for (int j = 0; j < b.s.size(); j++)
                c.s[i + j] += s[i] * b.s[j];
        for (int i = 0; i < c.s.size() - 1; i++)
        {
            c.s[i + 1] += c.s[i] / BASE;
            c.s[i] %= BASE;
        }
        while (c.s.back() == 0 && c.s.size() > 1)
            c.s.pop_back();
        return c;
    }
    friend istream &operator>>(istream &input, Big &x)
    {
        string s;
        if (!(input >> s))
            return input;
        x = s;
        return input;
    }
    friend ostream &operator<<(ostream &output, const Big &x)
    {
        output << x.s.back();
        for (int i = x.s.size() - 2; i >= 0; i--)
        {
            char buf[20];
            sprintf(buf, "%08d", x.s[i]);
            for (int j = 0; j < strlen(buf); j++)
                output << buf[j];
        }
        return output;
    }
};
Big Copy(const Big &b, int x)
{
    Big t;
    t.s.resize(b.s.size() + x);
    for (int i = 0; i < b.s.size(); i++)
        t.s[i + x] = b.s[i];
    return t;
}
Big Divide(const Big &a, const Big &b, Big &mod)
{
    Big c;
    c.s.resize(a.s.size() - b.s.size() + 1);
    mod = a;
    int Pow[(int)log2(Big::BASE) + 5];
    Pow[0] = 1;
    for (int i = 1; i <= log2(Big::BASE); i++)
        Pow[i] = Pow[i - 1] * 2;
    for (int i = c.s.size() - 1; i >= 0; i--)
    {
        Big t;
        t = Copy(b, i);
        for (int j = log2(Big::BASE); j >= 0; j--)
            if (mod >= t * Pow[j])
            {
                c.s[i] += Pow[j];
                mod -= t * Pow[j];
            }
    }
    while (c.s.back() == 0 && c.s.size() > 1)
        c.s.pop_back();
    return c;
}
Big a, b;
int main()
{
    cin >> a >> b;
    if (a < b)
        cout << a + b << endl << '-' << b - a << endl<< a * b << endl << 0 << endl << a << endl;
    else
    {
        Big c, d;
        c = Divide(a, b, d);
        cout << a + b << endl << a - b << endl << a * b << endl << c << endl << d << endl;
    }
    return 0;
}

 

 

 

 二十一. 最大公约数和最小公倍数

int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a,int b)
{
    a * b / gcd(a, b);
}

 二十二.简单乘法（防止因为乘数过大而爆long long）和快速幂

int muti(int a,int b)//乘法，防止乘数太大爆long long 
{
    int ans=0;
    while(b)
    {
        if(b&1)
        {
            ans=(ans+a)%mod;
        }
        a=(a+a)%mod;
        b>>=1;
    }
    return ans;
}
int KSM(int a,int b)//快速幂 
{
    int ans=1;
    while(b)
    {
        if(b&1)
        {
            ans=nuti(ans,a);
        }
        a=muti(a,a);
        b>>=1;
    }
    return ans;
}

二十三.质因数分解

int devide(int x)//质因数分解 
{
    for(int i=1;i<=sum&&prime[i]*prime[i]<=x;++i)
    {
        while(x%prime[i]==0)
        {
            x/=prime[i];
            cout<<prime[i]<<" ";
        }
    }
    if(x!=1)
    {
        cout<<x<<" ";
    }
    
}

二十四.拓展欧里几德

void exgcd(int a,int b,int &x,int &y)//拓展欧里几德 
{
    if(!b)
    {
        x=1;
        y=0;
        return ;
    }
    exgcd(b,a%b,y,x);
    y-=a/b*x;
} 

 

二十五.逆元的几种求法

• 快速幂版

 inv=KSM(x,Mod-2);//逆元 (快速幂版） 

• 拓展欧里几德版

 exgcd(x,Mod,inv,y); 2 inv=(inv+Mod)%Mod; //（x必须与mod互质） 

• 线性求逆元，公式版

inv[1]=1;//线性公式 
for(i=2;i<=n;++i)
    inv[i]=1ll*(Mod-Mod/i)*inv[Mod%i]%Mod; 

二十六.floyd

int floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                a[i][j]=min(a[i][j],a[i][k]+a[k][j]);
            }
        }
    }
}

二十七·最短路之几个瞎搞模板

void spfa(int s)
{
    int x, y, i;
    memset(dis, 0x3f, sizeof(dis));
    queue<int> q;
    q.push(s);
    dis[s] = 0;
    while (!q.empty())
    {
        x = q.front();
        q.pop();
        vis[x] = false;
        for (i = head[x]; i; i = way[i].next)
        {
            y = way[i].to;
            if (dis[y] > dis[x] + way[i].value)
            {
                dis[y] = dis[x] + way[i].value;
                if (!vis[y])
                {
                    q.push(y);
                    vis[y] = true;
                }
            }
        }
    }
}

priority_queue<pair<int, int>> q;
void dijkstra(int s)
{
    int x, y, i;
    memset(dis, 0x3f, sizeof(dis));
    q.push(make_pair(0, s));
    dis[s] = 0;
    while (!q.empty())
    {
        x = q.top().second;
        q.pop();
        for (i = head[x]; i; i = way[i].next)
        {
            y = way[i].to;
            if (dis[y] > dis[x] + way[i].value)
            {
                dis[y] = dis[x] + way[i].value;
                q.push(make_pair(-dis[y], y));
            }
        }
    }
}

 

二十八· 二分集合

int l = 0;
    int r = maxx;
    while (l < r) 
    {
        int mid = (l + r) >> 1;
        if (check(mid))
        {
            r = mid;
        }
        else
        {
            l = mid + 1;
        }
    }

while (l < r)
    {
        int mid = (l + r) >> 1;
        if (check(mid))
        {
            l = mid;
        }
        else
        {
            r = mid - 1;
        }
    }

while (l + eps < r) 
    {
        double mid = (l + r) >> 1;
        if (check(mid))
        {
            r = mid;
        }
        else
        {
            l = mid;
        }
    }

二十九· 树状数组求逆序对个数

   for (int i = 1; i <= n; ++i)
    {
        cin >> x;
        add(x, 1);
        ans += i - sum(x);
    }

三十·01背包

for (i = 1; i <= n; ++i)//背包 n为物品数，m为物品体积
    {
        cin >> v >> w;
        for (j = m; j >= v; --j)
            f[j] = max(f[j], f[j - v] + w);
    }
    cout << f[m] << endl;

 

三十一·完全背包

 for (i = 1; i <= n; ++i)
    {
        cin >> v >> w; //背包 n为物品数，m为物品体积
        for (j = v; j <= m; ++j)
            f[j] = max(f[j], f[j - v] + w);
    }
    cout << f[m] << endl;

 

三十二 ·最长上升子序列

d[k = 1] = a[1];//a是原序列，n为长度，k为最长上升子序列的长度
    for (i = 2; i <= n; ++i)
    {
        if (d[k] < a[i])
            d[++k] = a[i];
        else
            d[lower_bound(d + 1, d + k + 1, a[i]) - d] = a[i];
    }
    cout << k << endl;

 

三十三·最长公共子序列长度

for (i = 1; i <= n; ++i)//串为a b,长度为n m
    {
        for (j = 1; j <= m; ++j)
        {
            if (A[i] == B[j])
                f[i][j] = f[i - 1][j - 1] + 1;
            else
                f[i][j] = max(f[i - 1][j], f[i][j - 1]);
        }
    }
    cout << f[n][m] << endl;

 

三十三·最长公共上升子序列

B[0] = -inf;//一切概念均同上；
    for (i = 1; i <= n; ++i)
    {
        if (B[0] < A[i])
            num = f[i - 1][0];
        for (j = 1; j <= m; ++j)
        {
            if (A[i] == B[j])
                f[i][j] = num + 1;
            else
                f[i][j] = f[i - 1][j];
            if (B[j] < A[i])
                num = max(num, f[i - 1][j]);
        }
    }
    int ans = -inf;
    for (i = 1; i <= m; ++i)
        ans = max(ans, f[n][i]);
    printf("%d", ans);

三十四· 倍增求LCA（必背，容易打错，一定要return）

int pre() //LCA
{
    for (int j = 1; j <= 18; j++)
    {
        for (int i = 1; i <= n; i++)
        {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }
}
int lca(int x)
{
    int i;
    if (deep[x] < deep[y])
    {
        swap(x, y);
    }
    for (int i = 18; ~i; --i)
    {
        if (deep[fa[x][i]] >= deep[y])
        {
            x = fa[x][i];
        }
    }
    if (x == y)
    {
        return x;
    }
    for (int i = 18; ~i; --i)
    {
        if (fa[x][i] != fa[y][i])
        {
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    return fa[x][0];
}

 

三十五·树的直径（两次dfs就可以了）

int dfs(int x) //树的直径 只要两次dfs就可以了。
{
    int i, j;
    if (ans < d[x])
    {
        ans = d[x];
        p = x;
    }
    for (int i = head[x]; i; i = way[i].next)
    {
        j = v[i];
        if (j != father)
        {
            d[j] = d[x] += w[i];
            dfs(j, x);
        }
    }
}
void solve()
{
    ans = 0;
    d[1] = 0;
    dfs(1, 0);
    ans = 0;
    d[p] = 0;
    dfs(p, 0);
    cout << ans << endl;
}

 三十六·树的重心

void dfs(int x, int father)//树的重心
{
    int i, j;
    Max[x] = 0, size[x] = 1;
    for (i = head[x]; i; i = way[i].next)
    {
        j = way[i].to;
        if (j != father)
        {
            dfs(j, x);
            size[x] += size[j];
            Max[x] = max(Max[x], size[j]);
        }
    }
    Max[x] = max(Max[x], n - size[x]);
    if (num > Max[x])
    {
        pos = x;
        num = Max[x];
    }
}

 

 三十七·LCA树链剖分版，要稳定一些

#include <iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 5e5 + 10;

int num, size[maxn], deep[maxn], fa[maxn], top[maxn], n, m, p, a, b;
struct node
{
    int to;
    int value;
    int next;
}way[maxn<<1];
int tot = 0;
int head[maxn];
int add(int x,int y)
{
    way[++tot].next = head[x];
    way[tot].to = y;
    head[x] = tot;
}
int dfs1(int x)
{
    size[x] = 1;
    deep[x] = deep[fa[x]] + 1;
    for (int i = head[x]; i;i=way[i].next)
    {
        if(fa[x]!=way[i].to)
        {
            fa[way[i].to] = x;
            dfs1(way[i].to);
            size[x] += size[way[i].to];
        }
    }
}
int dfs2(int x)
{
    int maxx = 0;
    if(!top[x])
    {
        top[x] = x;
    }
    for (int i = head[x]; i;i=way[i].next)
    {
        if (fa[x] != way[i].to && size[way[i].to] > size[maxx])
        {
            maxx = way[i].to;
        }
    }
    if(maxx)
    {
        top[maxx] = top[x];
        dfs2(maxx);
    }
    for (int i = head[x]; i; i = way[i].next)
    {
        if(way[i].to!=maxx&&fa[x]!=way[i].to)
        {
            dfs2(way[i].to);
        }
    }
}
int lca(int x,int y)
{
    while(top[x]!=top[y])
    {
        if(deep[top[x]]<deep[top[y]])
        {
            swap(x, y);
        }
        x = fa[top[x]];
    }
    if(deep[x]<deep[y])
    {
        return x;
    }
    return y;
}
int main()
{
    ios::sync_with_stdio(false);
    cin >> n >> m >> p;
    for (int i = 1; i < n;i++)
    {
        cin >> a >> b;
        add(a, b);
        add(b, a);
    }
    dfs1(p);
    dfs2(p);
    for (int i = 1; i <= m;i++)
    {
        cin >> a >> b;
        cout << lca(a, b) << endl;
    }
    return 0;
}

 三十八·字典树

• 存树

struct node
{
    int son[26];
    int num;
} a[maxn];

 

• 插入

void Insert()
{
    int l, i, p = 0;
    l = strlen(s);
    for (i = 0; i < l; ++i)
    {
        if (a[p].son[s[i] - 'a'] == 0)
            a[p].son[s[i] - 'a'] = ++t;
        p = a[p].son[s[i] - 'a'];
        a[p].num++;

    }
}

 

• 查询

int find()
{
    int l, i, p = 0;
    l = strlen(s);
    for (i = 0; i < l; ++i)
    {
        if (a[p].son[s[i] - 'a'] == 0)
            return 0;
        p = a[p].son[s[i] - 'a'];
    }
    return a[p].num;
}

三十九· 字符串hash

long long Hash()//base 是基数 ans 是hash值 l是长度 s[i]是第i个字符
{
    long long  ans = 0;
    for (int i = 0; i < l; ++i)
        ans = ans * base + s[i];
    return ans;
}

 四十·线段树1

 

#include<iostream>
using namespace std;
const int maxn = 1e6 + 10;
int a[maxn + 2];
struct node
{
    int l, r;
    long long pre, add;
} tree[maxn];

void build(int x,int l,int r)
{
    tree[x].l = l;
    tree[x].r = r;
    if(l==r)
    {
        tree[x].pre = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(x * 2, l, mid);
    build(x * 2 + 1, mid + 1, r);
    tree[x].pre = tree[x * 2].pre + tree[x * 2 + 1].pre;
}
void spread(int p)
{
    if (tree[p].add)
    {
        tree[p * 2].pre += tree[p].add * (tree[p * 2].r - tree[p * 2].l + 1);
        tree[p * 2 + 1].pre += tree[p].add * (tree[p * 2 + 1].r - tree[p * 2 + 1].l + 1);
        tree[p * 2].add += tree[p].add;
        tree[p * 2 + 1].add += tree[p].add;
        tree[p].add = 0;
    }
}
void add(int p, int x, int y, int z)
{
    if (x <= tree[p].l && y >= tree[p].r)
    {
        tree[p].pre += (long long)z * (tree[p].r - tree[p].l + 1);
        tree[p].add += z;
        return;
    }
    spread(p);
    int mid = tree[p].l + tree[p].r >> 1;
    if (x <= mid)
        add(p * 2, x, y, z);
    if (y > mid)
        add(p * 2 + 1, x, y, z);
    tree[p].pre = tree[p * 2].pre + tree[p * 2 + 1].pre;
}
long long sum(int p, int x, int y)
{
    if (x <= tree[p].l && y >= tree[p].r)
        return tree[p].pre;
    spread(p);
    int mid = tree[p].l + tree[p].r >> 1;
    long long ans = 0;
    if (x <= mid)
        ans += sum(p * 2, x, y);
    if (y > mid)
        ans += sum(p * 2 + 1, x, y);
    return ans;
}
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1;i<=n;i++)
    {
        cin >> a[i];
    }
    build(1, 1, n);
    for (int i = 1;i<=m;i++)
    {
        int q, x, y, z;
        cin >> q;
        if(q==1)
        {
            cin >> x >> y >> z;
            add(1, x, y, z);
        }
        else
        {
            cin >> x >> y;
            cout << sum(1, x, y) << endl;
        }
    }
    return 0;
}

 四十一·矩阵快速幂

#include <iostream>
#include <cstring>
#define mod 1000000007
#define ll long long
using namespace std;
struct Mat
{
    ll m[101][101];
};        
Mat a, e; 
ll n, p;
Mat Mul(Mat x, Mat y) 
{
    Mat c;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
             c.m[i][j] = 0;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
             for (int k = 1; k <= n; k++)
             {
                 c.m[i][j] = c.m[i][j] % mod + x.m[i][k] * y.m[k][j] % mod;
             }
        }
    }
    return c;
}
Mat pow(Mat x, ll y) 
{
    Mat ans = e;
    while (y)
    {
        if (y & 1)
            ans = Mul(ans, x);
        x = Mul(x, x);
        y >>= 1;
    }
    return ans;
}

int main()
{
    cin >> n >> p;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cin >> a.m[i][j];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        e.m[i][i] = 1;
    }
    Mat ans = pow(a, p);
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cout << ans.m[i][j] % mod << " ";
        }
        cout << endl;
    }
    return 0;
}

 

 四十二·退役前最后的一次更新  进制转换，10 转其他

#include<iostream>
#include<cstdio>
using namespace std;
int n,m;
char f[20] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
void  zhuan(int n,int m)
{
    if(n==0)
    {
        return;
    }
    if(n>0||n%m==0)
    {
        zhuan(n / m, m);
        cout << f[n % m];
    }
    else
    {
        zhuan(n / m + 1, m);
        cout << f[-m+n % m];
    }
    
}
int main()
{
    cin >> n;
    cin >> m;
    cout << n << "=";
    zhuan(n, m);
    cout << "(base" << m << ")" << endl;
    return 0;
}