关闭

[置顶] NOIP之前在做什么?有没有空呢?可以来打板子吗?

221人阅读 评论(2) 收藏 举报
分类:

N logN求最大上升子序列(LIS)

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;
int rise[999999];
int a[1100],cnt=1;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
     scanf("%d",&a[i]);
    rise[1]=a[1];
    for(int i=2;i<=n;i++)
     if(a[i]>rise[cnt])
      rise[++cnt]=a[i];
     else
     {
        int pos=lower_bound(rise+1,rise+cnt+1,a[i])-rise;
        rise[pos]=a[i];
     }
     printf("%d",cnt);
} 

质数线性筛

用于各种需要素数的题中,很重要的工具

#include <cstdio>
#include <iostream>
#include <algorithm>
#define N 1e6+1
using namespace std;
bool vis[11000000];
int prime[1100000],cnt;
int main()
{
    vis[1]=1;

    for(int i=2;i<=N;i++)
    {
        if(!vis[i])
        {
            prime[++cnt]=i;
        }

        for(int j=1;j<=cnt&&i*prime[j]<=N;j++)
        {
            vis[i*prime[j]]=1;
            if(i%prime[j]==0)
             break;
        }
    }
}

快速幂

更基本的工具之一

#include <cstdio>
#include <iostream>
using namespace std;
int f_pow(int x,int y)
{
    int ans=1;
    while(y)
    {
        if(y&1) ans*=x;
        x*=x;
        y/=2;
    }
    return ans;
}
int main()
{
    int x,y;
    scanf("%d%d",&x,&y);
    printf("%d",f_pow(x,y));
}

归并排序

可以N log N排好序,主要是可以求出逆序对的个数。
相较于树状数组的优势在于,可以把数字的问题转化成字典序排序的字符串问题,在比较的时候加上二分和哈希
而树状数组无法解决这类问题(可能行,但是我不会)

#include <cstdio>
#include <iostream>
using namespace std;
int a[999999];
int tmp[999999];
int ans=0;//逆序对个数
void sort(int l,int r)
{
    if(l>=r) return;
    int mid=(l+r)/2;
    sort(l,mid);
    sort(mid+1,r);
    int i=l,j=mid+1;
    int now=l;
    while(i<=mid||j<=r)
    {
        bool flag;
        if(i>mid) flag=0;
        if(j>r) flag=1;
        if(i<=mid&&j<=r)
         if(a[i]<=a[j]) flag=1;//千万要注意,一定加上=号
         else flag=0;
        if(flag)
         tmp[now++]=a[i++];
        else
        {
            ans+=(mid-i+1);
            tmp[now++]=a[j++];
        }
    }
    for(int i=l;i<=r;i++)
     a[i]=tmp[i];
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
     scanf("%d",&a[i]);
    sort(1,n);
    for(int i=1;i<=n;i++)
     printf("%d ",a[i]);
    printf("\n%d",ans); 
    return 0;
}

树状数组

树状数组是一种简单版的线段树,核心思想的一个lowbit的函数,不再概述。
作用主要是求逆序对的个数问题
也是 N logN
相较于归并排序 的优势在于,好打不易错
但是劣势也很明显,需要进行离散化,无法处理字典序问题

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
const int maxm=500000;
int sum[510000];//极限数据
int a[510000],w[510000];
int lowbit(int x)
{
    return x&-x;
} 
void ins(int x)
{
    for(int i=x;i<=maxm;i+=lowbit(i))
     sum[i]++; 
}
int ask(int x)
{
    int ans=0;
    for(int i=x;i>=1;i-=lowbit(i))
     ans+=sum[i];
    return ans;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
     scanf("%d",&a[i]),w[i]=a[i];
    sort(w+1,w+n+1);
    int t=unique(w+1,w+n+1)-w-1;//去重函数,为了搞离散化 
    for(int i=1;i<=n;i++)
     a[i]=lower_bound(w+1,w+t+1,a[i])-w;
    int ans=0;
    for(int i=n;i>=1;i--)
    {
        ans+=ask(a[i]);
        ins(a[i]+1);
    } 
    printf("%d",ans);
    return 0;
}

离散化

一些题目中的数据会有大量间隙,导致内存爆炸。
离散化用于的是对于数据的大小关系决定答案的一类问题。
比如逆序对,以及一些纸牌的问题。
具体离散化方法如下
先把所有的元素扔进一个数组中
排序,去重。
然后对于原数组,用二分找排序数组中这个数值的位置,用这个位置来做具体值。
复杂度为N log N

Tarjan

关于Tarjan的用途有很多,比如求强连通分量,求割点或者割边,以及树上最近公共祖先
对于强连通分量,我们可以有很多的用途,比方说缩点。
这里给出求强连通分量的代码

#include <cstdio>
#include <iostream>
using namespace std;
const int maxm=1e6+1;
int dfn[maxm],low[maxm],c[maxm],stk[maxm];
bool vis[maxm];
int col,num,top;
int head[maxm],net[maxm],to[maxm];
int cnt,maxi,maxc;
void add(int x,int y)
{
    cnt++;
    to[cnt]=y;
    net[cnt]=head[x];
    head[x]=cnt;
}
void tarjan(int x)
{
    dfn[x]=low[x]=++num;
    stk[++top]=x;
    vis[x]=1;
    for(int i=head[x];i;i=net[i])
    {
        int p=to[i];
        if(!dfn[p])
        {
            tarjan(p);
            low[x]=min(low[x],low[p]);
        }
        else
        if(vis[p])
         low[x]=min(low[x],dfn[p]);
    }
    if(low[x]==dfn[x])
    {
        col++;
        //int tot=1;
        while(stk[top]!=x)
        {
            c[stk[top]]=col;
            vis[stk[top--]]=0;
        }
        //if(tot>maxi) maxi=tot,maxc=col;
        top--;
        c[x]=col;
        vis[x]=0;
    }
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int u,v,t;
        scanf("%d%d",&u,&v);
        add(u,v);
        //if(t==2) add(v,u);
    }
    for(int i=1;i<=n;i++)
     if(!dfn[i]) tarjan(i);
    //printf("%d\n",maxi);
    for(int i=1;i<=n;i++)
     //if(c[i]==maxc)
      printf("%d ",c[i]);

     return 0;
}

Tarjan缩点

在很多题中,可以把强连通里的点当一个点处理。
这时就需要用到Tarjan的缩点法则
首先记录下原图的信息,求出原图的强连通分量,然后用原图信息重新构图即可
一道练手题

#include <cstdio>
#include <iostream>
#include <cstring> 
using namespace std;
const int maxm=2*1e6+1;
int head[maxm],net[maxm],to[maxm];
int val[maxm],cval[maxm];
int dfn[maxm],low[maxm],c[maxm],stk[maxm];
int col,num,cnt,top;
int dp[maxm];
bool vis[maxm];
struct node{
    int x,y;
}a[maxm];
void add(int x,int y)
{
    cnt++;
    to[cnt]=y;
    net[cnt]=head[x];
    head[x]=cnt;
}
void tarjan(int x)
{
    vis[x]=1;
    dfn[x]=low[x]=++num;
    stk[++top]=x;
    for(int i=head[x];i;i=net[i])
    {
        int p=to[i];
        if(!dfn[p])
        {
            tarjan(p);
            low[x]=min(low[x],low[p]);
        }
        else
         if(vis[p])
          low[x]=min(low[x],dfn[p]);
    }
    if(low[x]==dfn[x])
    {
        c[x]=++col;
        vis[x]=0;
        cval[col]+=val[x];
        while(stk[top]!=x)
        {
            vis[stk[top]]=0;
            c[stk[top]]=col;
            cval[col]+=val[stk[top]];
            vis[stk[top--]]=0;
        }
        top--;
    }
}
void dfs(int x)
{
    //if(dp[x]) return dp[x];
    dp[x]=cval[x];
    //printf("%d ",x);
    int maxi=0;
    for(int i=head[x];i;i=net[i])
    {
        int p=to[i];
        //if(!p) continue;
        if(!dp[p]) dfs(p);
        maxi=max(maxi,dp[p]);
    }
    dp[x]+=maxi;
    //return dp[x]=cval[x]+maxi;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
     scanf("%d",val+i);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&a[i].x,&a[i].y);
        add(a[i].x,a[i].y);
    }
    for(int i=1;i<=n;i++)
     if(!dfn[i]) tarjan(i);

    memset(head,0,sizeof(head));
    memset(net,0,sizeof(net));
    memset(to,0,sizeof(to));
    cnt=0;

    for(int i=1;i<=m;i++)
    if(c[a[i].x]!=c[a[i].y])
     add(c[a[i].x],c[a[i].y]);
    //else printf("--%d %d--\n",a[i].x,a[i].y);
    //printf("---%d---\n",col);
    /*for(int i=1;i<=n;i++)
     printf("%d\n",c[i]);*/
    int ans=0;

    for(int i=1;i<=col;i++)
    {
        if(!dp[i]) dfs(i);
        ans=max(ans,dp[i]);
    }

    printf("%d",ans);

    return 0; 
}

LCA

LCA有非常多的用途,比方说求树上两点的最短路径长度
这条路径一定是 u->lca(u,v)->v
那么最短路径即为 dis[u]+dis[v]-2*dis[lca(u,v)]
dis为距离根节点的距离
对于LCA的求法也有很多
1:Tarjan求
2:倍增求
两种方法都很快,但是第二种方法易被卡,但对于求具体的路径却没有第二种来的方便
这里给出两种方法的代码
Tarjan求法

#include <cstdio>
#include <iostream>
using namespace std;
const int maxm=1010000;
int head[2][maxm],net[2][maxm],to[2][maxm],lca[2][maxm];
int cnt[2],fat[maxm];
bool vis[maxm];
int find(int x)
{
    if(fat[x]==x) return x;
    return fat[x]=find(fat[x]);
}
void add(int id,int x,int y)
{
    cnt[id]++;
    to[id][cnt[id]]=y;
    net[id][cnt[id]]=head[id][x];
    head[id][x]=cnt[id];
}
void tarjan(int x)
{
    fat[x]=x;
    vis[x]=1;
    for(int i=head[0][x];i;i=net[0][i])
    {
        int p=to[0][i];
        if(vis[p]) continue;
        tarjan(p);
        fat[p]=x;
    }
    for(int i=head[1][x];i;i=net[1][i])
    {
        int p=to[1][i];
        if(!vis[p]) continue;
        int fa=find(p);
        lca[1][i]=fa;
        if(i%2) lca[1][i+1]=fa;
        else lca[1][i-1]=fa;
    }
}
int main()
{
    int n,q,root;
    scanf("%d%d%d",&n,&q,&root);
    for(int i=1;i<n;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        add(0,u,v);
        add(0,v,u);
    }
    for(int i=1;i<=q;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        add(1,u,v);
        add(1,v,u);
    }
    /*for(int i=1;i<=n;i++)
     if(!vis[i]) tarjan(i); */
    tarjan(root);
    for(int i=1;i<=q;i++)
     printf("%d\n",lca[1][i*2]); 
}

倍增法

#include <cstdio>
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
const int max1=1000001;
int p[max1][23],deep[max1];
int head[max1],net[2*max1],to[2*max1];
bool vis[max1];
int cnt;    
int n,q,root;
void add(int x,int y)
{
    cnt++;
    to[cnt]=y;
    net[cnt]=head[x];
    head[x]=cnt;
}
void get_deep(int x)
{
    vis[x]=1;
    for(int i=head[x];i;i=net[i])
    {
        int tmp=to[i];
        if(vis[tmp]) continue;  
        p[tmp][0]=x;
        deep[tmp]=deep[x]+1;
        get_deep(tmp); 
    }
} 
void get_fat()
{
    for(int j=1;(1<<j)<=n;j++)
     for(int i=1;i<=n;i++)
      if(p[i][j-1]!=-1)
      {
         //printf("--%d %d--\n",i,j);
         p[i][j]=p[p[i][j-1]][j-1];
         //if(i==5&&j==1) printf("--%d %d--\n",p[i][j-1],p[p[i][j-1]][j-1]);
      }

}
int lca(int u,int v)
{
    if(deep[u]<deep[v]) swap(u,v);

    int i;
    for(i=0;(1<<i)<=deep[u];i++);
    i--;
    for(int j=i;j>=0;j--)
    if(deep[u]-(1<<j)>=deep[v])
      u=p[u][j];

    if(u==v) return u;

    for(int j=i;j>=0;j--)
     if(p[u][j]!=-1&&p[u][j]!=p[v][j])
      u=p[u][j],v=p[v][j];
  return p[u][0];
}
int main()
{
    scanf("%d%d%d",&n,&q,&root);
    for(int i=1;i<n;i++)
     {
        int u,v;
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
     }
    p[root][0]=-1;
    get_deep(root);
    get_fat();
    //p[5][1]=p[p[5][0]][0];
    for(int i=1;i<=q;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        printf("%d\n",lca(u,v));
    }
    //p[5][1]=p[p[5][0]][0];
    //printf("%d %d",p[4][0],p[5][1]);
}

最小(最大)生成树算法

最小生成树一般有两种方法
1:Prim算法
2:Kruskal算法
第一种不加堆优化可以到N^2的复杂度
加了以后为NlogN
遗憾的是,我不会。
于是使用第二种算法
复杂度为 M logN

一般不会卡的。

最小生成树一般用于最短连接问题,即用最小的花费把所有的点搞成联通图。
最大生成树用于限重性问题,如NOIP2013 货车运输。
这里给出最小生成树算法,最大的反过来排序就行了

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
struct node{
    int x,y;
    int cost;
};
node a[210000];
int fat[5001];
int find(int x)
{
    if(fat[x]==x) return x;
    return fat[x]=find(fat[x]);
}
bool comp(node xx,node yy)
{
    return xx.cost<yy.cost;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
     scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].cost);
    for(int i=1;i<=n;i++) fat[i]=i;
    sort(a+1,a+m+1,comp); 
    int tot=0,ans=0;
    for(int i=1;i<=m;i++)
     if(find(a[i].x)!=find(a[i].y))
     {
        fat[find(a[i].x)]=find(a[i].y);
        tot++;
        ans+=a[i].cost;
        if(tot==n-1)
        {
            printf("%d\n",ans);
            return 0;
        }
     }
     printf("orz\n");
     return 0;
}

最短路径算法

我知道的有Floyd算法,Dijkstra算法,Bellman-Ford算法,以及SPFA
其中 SPFA是Bellman-Ford的优化。
Floyd能够求任意两点之间的最短距离,而其他三种只能够求单源最短路
Floyd非常好写,复杂度N^3,如果不是太小的数据范围,基本不予考虑
Dijkstra算法无堆优化N^2,有了 N log (可是我TM不会堆优化)
SPFA是Bellman-Ford的优化,所以我这里只给出了SPFA的模板

#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
const int max1=600001;
int head[max1],net[2*max1],to[2*max1],cost[2*max1];
bool vis[max1];
int cnt,dis[max1];
queue <int> dl;
void add(int x,int y,int z)
{
    cnt++;
    cost[cnt]=z;
    to[cnt]=y;
    net[cnt]=head[x];
    head[x]=cnt;
}
int main()
{
    int n,m,s;
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=m;i++)
     {
        int u,v,c;
        scanf("%d%d%d",&u,&v,&c);
        add(u,v,c);
     }
    memset(dis,127/3,sizeof(dis));
    dis[s]=0;
    dl.push(s);
    vis[s]=1;
    while(!dl.empty())
    {
        int d=dl.front();
        dl.pop();
        vis[d]=0;
        for(int i=head[d];i;i=net[i])
        {
            int p=to[i];
            if(dis[p]>dis[d]+cost[i])
            {
                dis[p]=dis[d]+cost[i];
                if(vis[p]) continue;
                dl.push(p),vis[p]=1;
            }
        }
    }
    for(int i=1;i<=n;i++)
     if(dis[i]!=dis[0]) printf("%d ",dis[i]);
     else printf("2147483647 ");
    return 0;
}

并查集

普通的并查集,带反集的并查集,带权并查集,按秩合并并查集,单向并查集
前四种会,先给出第一种的基本板子,先打完最简单的板子再来填坑

#include <cstdio>
#include <iostream>
using namespace std;
const int maxm=11000;
int fat[maxm];
int find(int x)
{
    if(fat[x]==x) return x;
    return fat[x]=find(fat[x]);
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
     fat[i]=i;
    for(int i=1;i<=m;i++)
    {
        int opt,x,y;
        scanf("%d%d%d",&opt,&x,&y);
        if(opt==1) fat[find(x)]=find(y);
        else 
         if(find(x)==find(y)) printf("Y\n");
         else printf("N\n");
    }
    return 0;
} 

ST表

ST表其实就是倍增的思想 可以维护最大值,最小值,以及位运算的和
查询做到了O(1)

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
int st[110000][19]; 
int ask(int l,int r)
{
    int len=(r-l+1);
    int t=log2(len);
    return max(st[l][t],st[r-(1<<t)+1][t]);
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1,x;i<=n;i++)
     scanf("%d",&x),st[i][0]=x;
    for(int j=1;(1<<j)<=n;j++)
     for(int i=1;i<=n;i++)
      if(i+(1<<j-1)<=n)
       st[i][j]=max(st[i][j-1],st[i+(1<<j-1)][j-1]);
    for(int i=1;i<=m;i++)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        printf("%d\n",ask(l,r));
    }
    return 0;
}

线段树

我会写的只是最基本的线段树,只会维护最大值,最小值,和,单点修改,区间加与区间乘.
妈的线段树真好吃
区间 +

#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
struct node{
    ll adi,sum;
    ll len;
};
node st[4*110000];
ll a[110000];
void build(int o,int l,int r)
{
    if(l==r)
    {
        st[o].sum=a[l];
        st[o].len=1;
        return;
    }
    int mid=(l+r)/2;
    build((o<<1),l,mid);
    build((o<<1)|1,mid+1,r);
    st[o].sum=st[(o<<1)].sum+st[(o<<1)|1].sum;
    st[o].len=r-l+1;
}
void push_down(int o)
{
    if(st[o].adi)
    {
        st[(o<<1)].adi+=st[o].adi;
        st[(o<<1)|1].adi+=st[o].adi;
        st[(o<<1)].sum+=st[o].adi*st[(o<<1)].len;
        st[(o<<1)|1].sum+=st[o].adi*st[(o<<1)|1].len;
        st[o].adi=0;
    }
}
void updata(int o,int l,int r,int ql,int qr,ll add)
{
    if(l>qr||r<ql) return;
    if(ql<=l&&r<=qr)
    {
        st[o].adi+=add;
        st[o].sum+=st[o].len*add;
        return;
    }
    push_down(o);
    int mid=(l+r)/2;

    updata((o<<1),l,mid,ql,qr,add);
    updata((o<<1)|1,mid+1,r,ql,qr,add);

    st[o].sum=st[(o<<1)].sum+st[(o<<1)|1].sum;
}
ll ask(int o,int l,int r,int ql,int qr)
{
    if(l>qr||r<ql) return 0;
    if(ql<=l&&r<=qr) return st[o].sum;
    push_down(o);
    int mid=(l+r)/2;
    return ask((o<<1),l,mid,ql,qr)+ask((o<<1)|1,mid+1,r,ql,qr);
}
int main()
{
    int n,q;
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)
     scanf("%lld",&a[i]);
    build(1,1,n);
    for(int i=1;i<=q;i++)
    {
        int opt;
        scanf("%d",&opt);
        if(opt==2)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            printf("%lld\n",ask(1,1,n,l,r));
        }
        else
        {
            int l,r,k;
            scanf("%d%d%d",&l,&r,&k);
            updata(1,1,n,l,r,k);
        }
    }

    return 0;
}

区间 X

#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
struct node{
    ll adi,sum,adx;
    ll len;
};
node st[4*110000];
ll a[110000];
int mod;
void build(int o,int l,int r)
{
    st[o].adx=1;
    if(l==r)
    {
        st[o].sum=a[l];
        st[o].len=1;
        return;
    }
    int mid=(l+r)/2;
    build((o<<1),l,mid);
    build((o<<1)|1,mid+1,r);
    st[o].sum=(st[(o<<1)].sum+st[(o<<1)|1].sum)%mod;
    st[o].len=r-l+1;
}
inline void push_down(ll o)
{
    if(st[o].adi==0&&st[o].adx==1) return;
    st[(o<<1)].adi=(st[(o<<1)].adi*st[o].adx+st[o].adi)%mod;
    st[(o<<1)|1].adi=(st[(o<<1)|1].adi*st[o].adx+st[o].adi)%mod;
    st[(o<<1)].adx=(st[(o<<1)].adx*st[o].adx)%mod;
    st[(o<<1)|1].adx=(st[(o<<1)|1].adx*st[o].adx)%mod;
    st[(o<<1)].sum=((st[o].adi*(st[(o<<1)].len)%mod)%mod+(st[(o<<1)].sum*st[o].adx)%mod)%mod;
    st[(o<<1)|1].sum=((st[o].adi*(st[(o<<1)|1].len)%mod)%mod+(st[(o<<1)|1].sum*st[o].adx)%mod)%mod;
    st[o].adi=0;st[o].adx=1;
}
void updata_j(int o,int l,int r,int ql,int qr,ll add)
{
    if(l>qr||r<ql) return;
    if(ql<=l&&r<=qr)
    {
        st[o].adi=(st[o].adi+add)%mod;
        st[o].sum=(st[o].sum+(st[o].len*add)%mod);
        return;
    }
    push_down(o);
    int mid=(l+r)/2;

    updata_j((o<<1),l,mid,ql,qr,add);
    updata_j((o<<1)|1,mid+1,r,ql,qr,add);

    st[o].sum=(st[(o<<1)].sum+st[(o<<1)|1].sum)%mod;
}
void updata_x(int o,int l,int r,int ql,int qr,ll add)
{
    if(l>qr||r<ql) return;
    if(ql<=l&&r<=qr)
    {
        st[o].adi=(st[o].adi*add)%mod;
        st[o].sum=(st[o].sum*add)%mod;
        st[o].adx=(st[o].adx*add)%mod;
        return;
    }
    push_down(o);
    int mid=(l+r)/2;

    updata_x((o<<1),l,mid,ql,qr,add);
    updata_x((o<<1)|1,mid+1,r,ql,qr,add);

    st[o].sum=(st[(o<<1)].sum+st[(o<<1)|1].sum)%mod;
}
ll ask(int o,int l,int r,int ql,int qr)
{
    if(l>qr||r<ql) return 0;
    if(ql<=l&&r<=qr) return st[o].sum%mod;
    push_down(o);
    int mid=(l+r)/2;
    return (ask((o<<1),l,mid,ql,qr)+ask((o<<1)|1,mid+1,r,ql,qr))%mod;
}
int main()
{
    int n,q;
    scanf("%d%d%d",&n,&q,&mod);
    for(int i=1;i<=n;i++)
     scanf("%lld",&a[i]);
    build(1,1,n);
    for(int i=1;i<=q;i++)
    {
        int opt;
        scanf("%d",&opt);
        if(opt==1)
        {
            int l,r,k;
            scanf("%d%d%d",&l,&r,&k);
            updata_x(1,1,n,l,r,k);
        }
        if(opt==2)
        {
            int l,r,k;
            scanf("%d%d%d",&l,&r,&k);
            updata_j(1,1,n,l,r,k);
        }
        if(opt==3)
        {
            int l,r,k;
            scanf("%d%d",&l,&r);
            printf("%lld\n",ask(1,1,n,l,r)%mod);
        }
    }

    return 0;
}

读入优化

C++中有一个函数:getchar() ,用于读入字符,那么这跟读入整数有什么关系呢?
其实,经过类似高精度的处理,就可以实现类型转换啦!
读字符肯定要比您直接读数快!

long long read()
{
    long long x=0,w=1;
    char ch=0;
    while(ch<'0'||ch>'9') 
     {
        if(ch=='-') w=-1;
        ch=getchar();
     }
    while(ch>='0'&&ch<='9')
     x=(x<<3)+(x<<1)+ch-'0',ch=getchar();//x*8+x*2,用位运算还要快!
    return x*w;
}

乘法逆元

(a+b)%p=a%p+b%p
(a*b)%p=a%p * b%p
但是
(a/b)%p !=a%p/b%p
但是若有
b*x ≡ 1 (mod p)
那么(a/b)%p=a % p * x%p
方法有三
1:费马小定理
若p为质数
那么a关于p的逆元即为 ap2
2 : 拓展欧几里得定理
p不用为质数

#include <cstdio>
using namespace std;
void e_gcd(int a,int b,int &x,int &y)
{
    if(!b)
    {
        x=1;
        y=0;
        return;
    }
    e_gcd(b,a%b,x,y);
    int tmp=x;
    x=y;
    y=tmp-(a/b)*y;

}
int main()
{
    int a,b,x,y;
    scanf("%d%d",&a,&b);
    e_gcd(a,b,x,y);
    printf("%d",(x+b)%b);
}

3 : 线性逆元筛法

#include <iostream>
#include <cstdio>
#include <algorithm>
#define ll long long
using namespace std;
const int maxm=1e6+1;
int inv[3*maxm];
int main()
{
    int n,p;
    scanf("%d%d",&n,&p);

    inv[1]=1;
    for(int i=2;i<=n;i++)
    {
        inv[i]=(p-p/i)*inv[p%i];
        while(inv[i]<0) inv[i]+=p;
        printf("%d\n",inv[i-1]%p);
    }

    printf("%d\n",inv[n]%p);

    return 0;
}

差分

差分有3种 (我所知道的)
一维差分 二维差分 树上差分
1 一维差分:
我用的是用两个数组维护的差分
令 f 数组为差分数组
给 l-r区间上加数 k
只需在 f[l]+=k f[r+1]-=k
i1f[i] 即为 i 位置上操作加上的数字
2: 二维差分
令s[i][j]=a[i][j]-a[i-1][j]-a[i][j-1]+a[i-1][j-1]。
则a[i][j]=s[1][1]…+s[1][j]+s[2][1]+…+s[2][j]+…+s[i][1]+…+s[i][j]。
对于每次以(x,y)为左上角,(x2,y2)为右下角的矩阵操作,相当于是令s[x][y]+=k,s[x][y2+1]-=k,s[x2+1][y]-=k,s[x2+1][y2+1]+=k。

s[x][y]+=k; s[x][y2+1]-=k; 
s[x2+1][y]-=k; s[x2+1][y2+1]+=k;

for (i=1; i<=n; i++)
  for (j=1; j<=n; j++)
    a[i][j]=a[i-1][j]+a[i][j-1]-a[i-1][j-1]+s[i][j];

3:树上差分
对于 ui>lca(ui,vi)>vi若干路径
我们想求出每条边被经过了几次
我们只需对s[ui]++,s[vi]++,s[lca(ui,vi)]=2
然后DFS遍历 S[i]+=S[]
这样s[i]即为边 i->fat[i]的边被经过的次数
这玩意啥用?
详见 NOIP原题运输计划

二分图匹配

匈牙利算法,可以找出最优匹配
若只判断这张图是不是二分图,可以使用黑白染色法

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
bool f[999999]; 
int match[999999];
int n,m,e;
int head[999999],to[999999],net[999999],cnt;
void add(int x,int y)
{
    cnt++;
    to[cnt]=y;
    net[cnt]=head[x];
    head[x]=cnt;
}
int dfs(int u)
{
    for(int i=head[u];i;i=net[i])
    {
      int tmp=to[i];
      if(f[tmp]) continue;
      f[tmp]=1;
      if(!match[tmp]||dfs(match[tmp]))
        {
            match[u]=tmp;
            match[tmp]=u;
            return 1;
        }

    }
    return 0;
}
int main()
{
    freopen("c.in","r",stdin);
    scanf("%d%d%d",&n,&m,&e);

    for(int i=1;i<=e;i++)
     {
        int x,y;

        scanf("%d%d",&x,&y);
        if(y>m) continue;
        add(x,y+n);
        add(y+n,x);
     }

    int sum=0; 

    for(int i=1;i<=n;i++)
     {
      for(int j=1;j<=n+m;j++)
       f[j]=0;
      sum+=dfs(i);
     }

     printf("%d",sum);

     return 0;
} 

Hash

哈希可以暴力求出两段字符串是否相同
如何得到一段区间的hash值?
hash[l->r]=hash[r]-hash[l-1]*base^len
单模容易被卡,双模大法好

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;
struct node{
    ll hash1,hash2;
}a[99999];
const int mod1=1e9+7;
const int mod2=1e9+9;
const int base1=31;
const int base2=31;
char s[9999999];
ll make_hash1()
{
    ll hash=0;
    int len=strlen(s+1);
    for(int i=1;i<=len;i++)
     hash=(hash*base1+(ll)s[i])%mod1;
    return hash;
}
ll make_hash2()
{
    ll hash=0;
    int len=strlen(s+1);
    for(int i=1;i<=len;i++)
     hash=(hash*base2+(ll)s[i])%mod2;
    return hash;
}
bool comp(node x,node y)
{
    return x.hash1<y.hash1;
}
int main()
{
    int n;
    scanf("%d\n",&n);
    for(int i=1;i<=n;i++)
     scanf("%s",(s+1)),a[i].hash1=make_hash1(),a[i].hash2=make_hash2();
    sort(a+1,a+n+1,comp);
    int ans=1;

    for(int i=2;i<=n;i++)
     if(a[i].hash1!=a[i-1].hash1||a[i].hash2!=a[i-1].hash2) ans++;

    return printf("%d",ans)*0;
}

状态压缩

状态压缩好像只与DP联系在一起
但其实并不是的,它同样运用于BFS或者是DFS中(逃)
状压的题非常好看出来
很明显的特征就是数据范围贼小。
八成就是状压或者是爆搜了
状压的基本思路就是枚举基础状态,然后转移。
这里给出一道练手题
标签是记忆化搜索,我居然用状压水过去了 (雾)
基本的状压思路是差不多的,就看你怎么操作了233

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;
bool dp[1<<17][17];
char w[101],t[101],len[101];
char s[200];
int main()
{
    int n;
    scanf("%d\n",&n);
    for(int i=1;i<=n;i++)
     scanf("%s",(s+1)),w[i]=s[1],t[i]=s[strlen(s+1)],len[i]=strlen(s+1);
    for(int i=1;i<=n;i++)
     dp[1<<i-1][i]=1;
    dp[0][0]=1;
    for(int i=0;i<1<<n;i++)
     for(int j=1;j<=n;j++)
      if(dp[i][j])
      {
        for(int k=1;k<=n;k++)
         if(((1<<k-1)&i)==0&&j!=k)
          if(t[j]==w[k]) dp[i|(1<<k-1)][k]=1;
      }
    int ans=0;
    for(int i=0;i<1<<n;i++)
     for(int j=1;j<=n;j++)
     if(dp[i][j])
     {
        int num=0;
        for(int k=1;k<=n;k++)
         if(i&(1<<k-1)) num+=len[k];
        //puts("");
        ans=max(ans,num); 
     }
    printf("%d",ans);
}

高精度

压位比较快233
高精加和高精除(其他两个改就行)

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int a[99999];
int b[99999];
int c[99999];
char s[99999];
int main()
{
    scanf("%s",(s+1));
    int len=strlen(s+1);
    int lena=1,k=1;
    for(int i=len;i>=1;i--)
    {
        if(k==1000) k=1,lena++;
        a[lena]+=k*(s[i]-'0');
        k*=10;
    }
    scanf("%s",(s+1));
    k=1;
    len=strlen(s+1);
    int lenb=1;
    for(int i=len;i>=1;i--)
    {
        if(k==1000) k=1,lenb++;
        b[lenb]+=k*(s[i]-'0');
        k*=10;
    }

    len=max(lena,lenb);
    for(int i=1;i<=len;i++)
    {
        c[i]+=a[i]+b[i];
        if(c[i]>=1000) c[i+1]+=c[i]/1000,c[i]%=1000;
    }
    while(c[len+1]) len++;

    printf("%d",c[len]);
    for(int i=len-1;i>=1;i--)
     printf("%03d",c[i]);
}  

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define ll long long
using namespace std;
const ll K=1e9;
char s[1000000];
ll a[100000],b;
int main()
{
    scanf("%s",(s+1));
    int len=strlen(s+1);
    ll k=1;
    int lena=1;

    for(int i=len;i>=1;i--)
    {
        a[lena]+=(s[i]-'0')*k;
        k*=10;
        if(k==K) k=1,lena++;
    }
    ll x;
    scanf("%lld",&x);
    for(int i=lena;i>=1;i--)
    {
        a[i-1]+=a[i]%x*K;
        a[i]/=x;
    }
    while(lena>=1&&!a[lena]) lena--;

    printf("%lld",a[lena--]);
    for(int i=lena;i>=1;i--)
     printf("%09d",a[i]);
    return 0;
} 

矩阵快速幂

用于递推问题,先推出矩阵,然后模拟即可

模板题

#include <cstdio>
#include <iostream>
#include <cstring>
#define ll long long
using namespace std;
const int mod=1e9+7;
ll ans[4][4],x[4][4],c[4][4];
void ans_x()
{
    for(int i=1;i<=3;i++)
     c[1][i]=ans[1][i],ans[1][i]=0;
    for(int i=1;i<=1;i++)
     for(int j=1;j<=3;j++)
      for(int k=1;k<=3;k++)
       ans[i][j]=(ans[i][j]+(c[i][k]*x[k][j])%mod)%mod;
}
void x_x()
{
    for(int i=1;i<=3;i++)
     for(int j=1;j<=3;j++)
      c[i][j]=x[i][j],x[i][j]=0;
    for(int i=1;i<=3;i++)
     for(int j=1;j<=3;j++)
      for(int k=1;k<=3;k++)
       x[i][j]=(x[i][j]+(c[i][k]*c[k][j])%mod)%mod;
}
void init()
{
    memset(ans,0,sizeof(ans));
    memset(x,0,sizeof(x));
    ans[1][1]=1,ans[1][2]=1,ans[1][3]=1;
    x[1][1]=1,x[1][3]=1,x[2][1]=1,x[3][2]=1;
}
ll fast_pow(ll k)
{
    if(k<=3) return 1;
    init();
    k-=3;
    while(k)
    {
        if(k%2) ans_x();
        k/=2;
        x_x();
    }
    /*for(int i=1;i<=3;i++)
     for(int j=1;j<=3;j++)
      printf("-%d ",x[i][j]);*/
    return ans[1][1]%mod;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        ll x;
        scanf("%lld",&x);
        printf("%lld\n",fast_pow(x));
    }

    return 0;
} 

单调队列

一个队列递增或者递减成为单调队列
单调队列对于动态求最小最大值有奇效。
详见 NOIP2016 蚯蚓
险恶的出题人,卡double ,但是没卡住Float
注意啦,维护三队列时绝对不能开FIFO队列,会RE,别问我咋知道的
蚯蚓的链接,可以当做练手题

#include <cstdio>
#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
ll dl1[7*1000000+100000+100];
ll dl2[7*1000000+100000+100];
ll dl3[7*1000000+100000+100]; 
ll a[999999];
int main()
{
    memset(dl1,128,sizeof(dl1));
    memset(dl2,128,sizeof(dl2));
    memset(dl3,128,sizeof(dl3));
    int n,m,q,u,v,t;
    scanf("%d%d%d%d%d%d",&n,&m,&q,&u,&v,&t);
    float p=(float)u/(float)v;
    //printf("%lf",p);
    for(int i=1;i<=n;i++)
     scanf("%d",a+i);
    sort(a+1,a+n+1);
    for(int i=n;i>=1;i--)
     dl1[n-i+1]=a[i];
    int l1=1,l2=1,l3=1;
    for(int i=1;i<=m;i++)
    {
        ll x1=-1e7,x2=-1e7,x3=-1e7;
        x1=dl1[l1];
        x2=dl2[l2];
        x3=dl3[l3];
        ll x=max(x1,max(x2,x3));
        if(x==x1) l1++;
        else 
        {
            if(x==x2) l2++;
             else l3++;
        }
        ll p1=(x+=(i-1)*q)*u/v;
        if(i%t==0) 
        printf("%lld ",x);
        //ll p1=x*p;
        ll p2=x-p1;
        p1-=(i*q);
        p2-=(i*q);
        dl2[i]=p1,dl3[i]=p2;
    }
    puts("");
    for(int i=1;i<=(n+m);i++)
    {
        ll x1=-1e7,x2=-1e7,x3=-1e7;
        x1=dl1[l1];
        x2=dl2[l2];
        x3=dl3[l3];
        ll x=max(x1,max(x2,x3));
        if(x==x1) l1++;
        else 
        {
            if(x==x2) l2++;
             else l3++;
        }
        x+=m*q;
        if(i%t==0)
        printf("%lld ",x);
    }

    return 0;
} 
2
0
查看评论

bzoj5144 [Ynoi2018]末日时在做什么?有没有空?可以来拯救吗?

这个死宅题面就不吐槽了。。。 2018目标:一定要让nzhtl1477" role="presentation" style="position: relative;">nzhtl1477nzhtl1477nzhtl1477把罚抄打通! 这...
  • yfzcsc
  • yfzcsc
  • 2018-01-23 21:17
  • 289

【BZOJ5136】【LOJ6256】【CodePlus 2017 12 月赛】可做题1 & LibreOJ6256

Description click me Solution 可以证明每个矩阵是巧妙的当且仅当其每个2阶子矩阵均是巧妙的: 若该矩阵有一个不巧妙的2阶子矩阵,则其他部分任意选择,这两行选择不同,则和不同,所以该矩阵不是巧妙的。 用goodi,j" role="pres...
  • hhaannyyii
  • hhaannyyii
  • 2017-12-24 15:44
  • 129

【loj6257】「CodePlus 2017 12 月赛」可做题2

题目描述 “codeplus比赛的时候在做什么?有没有空?能来解决丢番图方程问题吗?”sublinekelzrip这样问qmqmqm。当然,qmqmqm并不会丢番图方程问题,所以sublinekelzrip改为提出了另一个题目,现在请你帮助qmqmqm解决这个题目。这个问题是这样的:若一个数列aa...
  • w_yqts
  • w_yqts
  • 2017-12-24 18:33
  • 156

可做题1(Code+第二次网络赛)

题目背景“codeplus比赛的时候在做什么?有没有空?能来解决停机问题吗?”qmqmqm这样问sublinekelzrip。当然,sublinekelzrip并不会停机问题,所以qmqmqm改为提出了另一个题目,现在请你帮助sublinekelzrip解决这个题目。题目描述这个问题是这样的:对于任...
  • wu_tongtong
  • wu_tongtong
  • 2017-12-25 20:14
  • 113

当 CPU 空闲时它都在做什么? | Linux 中国

大量的睡眠进程,它们都在等待某种情况下被唤醒,差不多在 100% 的 CPU 时间中,都处于虚构的“空闲任务”中。-- Gustavo Duarte编译自 | https://manybutfinite.com/post/what-does-an-idle-cpu-do/  作者 | Gu...
  • F8qG7f9YD02Pe
  • F8qG7f9YD02Pe
  • 2018-02-02 00:00
  • 26

javascript可以做图形界面吗?

爱尔兰的天空(ai & love),wordpress,情侣主题,情侣博客,wordpress主题,wordpress博客 http://yangxiaozhao.sinaapp.com/ POPMusic 最好听的流行音乐在线收听,2013最新最全的中国华语流行音乐排行榜,推荐最红网络红...
  • u012532350
  • u012532350
  • 2013-11-22 10:58
  • 593

C#可空类型

可空类型是 System.Nullable 结构的实例。可空类型可以表示其基础值类型正常范围内的值,再加上一个 null 值。例如,Nullable,读作“可空的 Int32”,可以被赋值为 -2147483648 到 2147483647 之间的任意值,也可以被赋值为 null 值。Nullabl...
  • xyq1986
  • xyq1986
  • 2006-11-24 18:13
  • 7142

oracle数据库表的外键可以为空

http://blog.sina.com.cn/s/blog_7d45df5b0101bm26.html
  • xingkongdeasi
  • xingkongdeasi
  • 2014-04-02 09:43
  • 1234

最近文化课和训练的总结 && NOIP2017赛前检查

今天是11.9日,其实还是我的生日,当然,这并不是很重要。昨天考完了期中考,对了下答案,感觉又要退步了。 总体来说不该丢的分上了20分,所以这次考试没有个前50很正常吧。后天不是联赛了吗?什么辣鸡文化课给我滚开。从高中停课开始算,总共有19场比赛。 然而我是一个初中生,只做了3场,虽然这3场的成...
  • Cold_Chair
  • Cold_Chair
  • 2017-11-09 21:06
  • 131

数据库出现主键为空时的处理方法

CREATE VIEW [Enterprise].[SelfSafeRankView] AS SELECT ROW_NUMBER() OVER (PARTITION BY ssr.Id ORDER BY ssr.Id) AS Id, ssr.Id AS SelfSafeRankId,sr.Id A...
  • qiqingxueye
  • qiqingxueye
  • 2015-05-27 09:14
  • 295
    个人资料
    • 访问:49764次
    • 积分:4751
    • 等级:
    • 排名:第7207名
    • 原创:407篇
    • 转载:2篇
    • 译文:0篇
    • 评论:12条
    最新评论