2017多校第9场

1002
离线询问，把每个询问变成 q[b]-q[a-1] ,抄一个树链剖分的模板

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include <algorithm>
#include<iostream>
#define inf 0x7fffffff
#define N 400005
#define M 400005
#define ll long long
using namespace std;
int n,cnt,sz,m;
int v[N],dep[N],size[N],head[N],fa[N];
int pos[N],bl[N];
struct Q
{
    int id,s,t,fg,num;
} q[N];
struct W
{
    int w,id;
} w[N];
struct data
{
    int to,next;
} e[M];
struct seg
{
    int l,r,mx;
    ll sum;
} t[400005*4];
void insert(int u,int v)
{
    e[++cnt].to=v;
    e[cnt].next=head[u];
    head[u]=cnt;
    e[++cnt].to=u;
    e[cnt].next=head[v];
    head[v]=cnt;
}
void dfs1(int x)
{
    size[x]=1;
    for(int i=head[x]; i; i=e[i].next)
    {
        if(e[i].to==fa[x])continue;
        dep[e[i].to]=dep[x]+1;
        fa[e[i].to]=x;
        dfs1(e[i].to);
        size[x]+=size[e[i].to];
    }
}
void dfs2(int x,int chain)
{
    int k=0;
    sz++;
    pos[x]=sz;//分配x结点在线段树中的编号
    bl[x]=chain;
    for(int i=head[x]; i; i=e[i].next)
        if(dep[e[i].to]>dep[x]&&size[e[i].to]>size[k])
            k=e[i].to;//选择子树最大的儿子继承重链
    if(k==0)return;
    dfs2(k,chain);
    for(int i=head[x]; i; i=e[i].next)
        if(dep[e[i].to]>dep[x]&&k!=e[i].to)
            dfs2(e[i].to,e[i].to);//其余儿子新开重链
}
void build(int k,int l,int r)//建线段树
{
    t[k].l=l;
    t[k].r=r;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
}
void change(int k,int x,int y)//线段树单点修改
{
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==r)
    {
        t[k].sum=t[k].mx=y;
        return;
    }
    if(x<=mid)change(k<<1,x,y);
    else change(k<<1|1,x,y);
    t[k].sum=t[k<<1].sum+t[k<<1|1].sum;
    t[k].mx=max(t[k<<1].mx,t[k<<1|1].mx);
}
ll querysum(int k,int x,int y)//线段树区间求和
{
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==x&&y==r)return t[k].sum;
    if(y<=mid)return querysum(k<<1,x,y);
    else if(x>mid)return querysum(k<<1|1,x,y);
    else
    {
        return querysum(k<<1,x,mid)+querysum(k<<1|1,mid+1,y);
    }
}

ll ask(int x,int y)
{
    ll sum=0;
    while(bl[x]!=bl[y])
    {
        if(dep[bl[x]]<dep[bl[y]])swap(x,y);
        sum+=querysum(1,pos[bl[x]],pos[x]);
        x=fa[bl[x]];
    }
    if(pos[x]>pos[y])swap(x,y);
    sum+=querysum(1,pos[x],pos[y]);
    return sum;
}
bool cmp(Q a,Q b)
{
    return a.num<b.num;
}

bool cmpw(W a,W b)
{
    return a.w<b.w;
}
ll res[N];
int s,tt,a,b;
void solve()
{
    build(1,1,n);
    int tot=0;
    memset(res,0,sizeof res);
    for(int i=1; i<=n; i++)
        change(1,pos[i],0);
    for (int i=1; i<=m; i++)
    {
        scanf("%d%d%d%d",&s,&tt,&a,&b);
        q[++tot].s=s;
        q[tot].t=tt;
        q[tot].num=a-1;
        q[tot].fg=-1;
        q[tot].id=i;
        q[++tot].s=s;
        q[tot].t=tt;
        q[tot].num=b;
        q[tot].fg=1;
        q[tot].id=i;
    }
    sort(q+1,q+tot+1,cmp);
    sort(w+1,w+1+n,cmpw);

    int now=1;
    for (int i=1; i<=tot; i++)
    {
        while(w[now].w <= q[i].num && now<=n)
        {
            change(1,pos[w[now].id],w[now].w);
            now++;
        }
        res[q[i].id] += q[i].fg * ask(q[i].s,q[i].t);
    }
    for (int i=1; i<=m; i++)
        printf("%lld%c",res[i],i==m?'\n':' ');
}
int main()
{
    while (scanf("%d%d",&n,&m)!=EOF)
    {
    memset(head,0,sizeof head);
    memset(size,0,sizeof size);
    memset(dep,0,sizeof dep);
    memset(fa,0,sizeof fa);
    memset(pos,0,sizeof pos);
    memset(bl,0,sizeof bl);
    sz=0;
    cnt=0;
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&v[i]);
        w[i].w=v[i];
        w[i].id=i;
    }

    for(int i=1; i<n; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        insert(x,y);
    }
    dfs1(1);
    dfs2(1,1);
    solve();
    }
    return 0;
}

1008
每得到一个新的答案，暴力删除所有之前的答案和这个的答案的和，类似筛法，辣鸡方法用lower_bound写的

#include <bits/stdc++.h>
using namespace std;

int mark[130000],res[1010],a[130000];
int main()
{
    int n;
    //freopen("tst.in","r",stdin);
    while (scanf("%d",&n)!=EOF)
    {
        memset(mark,0,sizeof mark);
        for (int i=1;i<=n;i++)
          scanf("%d",&a[i]);
        sort(a+1,a+1+n);
        res[1] = a[1];
        int cnt=1;
        int now=2;
        int pret;
        while ( cnt*(cnt+1)/2 < n )
        {
            res[++cnt] = a[now++];
            pret=now;
            for (int j=1;j<cnt;j++)
            {
                int tar=res[cnt] + res[j];
                int t=lower_bound(a+pret,a+1+n,tar)-a;
                while (mark[t]==1 && a[t+1]==tar) t++;
                mark[t] = 1;
                pret=t;
                while (mark[now]==1) now++;
            }
        }

        printf("%d\n",cnt);
        for (int i=1;i<=cnt;i++)
            printf("%d%c",res[i],i==cnt?'\n':' ');
    }
    return 0;
}

1010
把每个*和前面的字母合并，则这个字母就是一个闭包，可以取0到无穷个
对闭包和非闭包的字母分开匹配，类似做一个FA

#include <bits/stdc++.h>
#define ll long long
#define clr(x,y) memset(x,y,sizeof x)
using namespace std;

int dp[2650][2600],hull[2555] ;
char s1[2510],s2[2555],str[2555];
int n,m,len;
void nxt(int i,int j)
{
    int tmp=i+1;
    while (s1[tmp] == s1[tmp-1] && tmp<=n)
    {
        dp[tmp][j] = 1;
        tmp++;
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T --)
    {
        scanf("%s%s",s1+1,str+1);
        memset(hull,0,sizeof hull);
        n=strlen(s1+1);len=strlen(str+1);m=0;
        for (int i=1; i<=len; i++)
            if (str[i]=='*') hull[m]=1; else s2[++m]=str[i];
        clr(dp,0) ;
        int tmp=1;
        while (hull[tmp]) dp[0][tmp++]=1;
        dp[0][0] = 1;
        for(int i=1; i<= n; i++)
            for(int j=1; j<=m; j++)
                if (dp[i][j]==0)
                {
                    if (hull[j]==0)
                    {
                        if(s2[j]== '.')
                            dp[i][j] |= dp[i-1][j-1]|dp[i][j-1] ;
                        else
                            if(s1[i] == s2[j]) dp[i][j] |= dp[i-1][j-1] ;
                            else dp[i][j] = 0;

                    }
                    else
                    {
                        if (s2[j]=='.')
                        {
                            dp[i][j] |= dp[i-1][j-1];
                            if (dp[i][j]) nxt(i,j);
                        }
                        else
                        {
                            if(s1[i] == s2[j]) dp[i][j] |= dp[i-1][j-1] ;
                            else dp[i][j] = 0;
                            if (dp[i][j]) nxt(i,j);
                        }
                        dp[i][j]|=dp[i][j-1];
                    }
                }
        if(dp[n][m])  puts("yes");
        else puts("no");
    }
    return 0;
}