【NOIP模拟题】[状压dp][线段树]

最新推荐文章于 2024-11-01 07:53:22 发布

原创最新推荐文章于 2024-11-01 07:53:22 发布 · 627 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#状压dp #dfs序列 #线段树

dp 同时被 3 个专栏收录

7 篇文章

订阅专栏

考试考试

4 篇文章

订阅专栏

线段树

3 篇文章

订阅专栏

给出一个长度不超过100只包含’B’和’R’的字符串，将其无限重复下去。
比如，BBRB则会形成BBRBBBRBBBRB。现在给出一个区间[l,r]询问该区间内有多少个字符’B’(区间下标从1开始)

思路：
写起走就行了…考试的时候脑抽写了高精度…结果wa完了TAT
主要就是把left、right扩展开到端点，处理小小注意一下就行qwq

#include<iostream>
#include<cstdio>
#include<cstring>
#define LL long long
using namespace std;
int n,tot;
LL le,ri,ans;
char mo[105],c;
void worrk()
{
    cin>>le>>ri;
    int y1=le%n,y2=ri%n,gg=0;
    if(!y1)y1=n;
    if(!y2)y2=n;
    le-=y1;
    ri+=n-y2;
    for(int i=1;i<=n;i++)
    if(mo[i]=='B')tot++;
    for(int i=1;i<y1;i++)
    if(mo[i]=='B')gg++;
    for(int i=n;i>y2;i--)
    if(mo[i]=='B')gg++;
    ans=(ri-le)/(LL)n*(LL)tot;
    ans-=(LL)gg;
    cout<<ans;
}
int main()
{
    freopen("a.in","r",stdin);
    freopen("a.out","w",stdout);
    scanf("%s",mo+1);n=strlen(mo+1);
    worrk();
}

我们要从n种食物选m个出来，安排一个顺序吃掉它（们），每种食物有个美味值ai，然后我们有k个规则，每个规则有 xi, yi 和 ci三个数，如果吃完第xi种食物接下来马上吃第yi种食物，第j种食物的美味值会增加ci。每种食物至多吃一个，求美味值最大的和是多少？
【数据范围】
30% m<=n<=5 ,0<=ci,ai<=1e5
100% m<=n<=18，0<=ci,ai<=1e9

思路：
事实证明这道题貌似以前见到过…
看数据范围就可以看出来…咦，n只有18所以毫无疑问考虑状态压缩….嗯压缩的时候没有用for而是用了队列，结果…后头全T了qwq

#include<iostream>
#include<cstdio>
#include<queue>
#include<map>
#define LL long long
using namespace std;
const int N=20;
int n,m,k,x,y,z;
LL c[N],ans,f[N][N],s[19][(1<<18)+1];
struct node{
    LL zt,ta;
    int las,ch;
};
queue<node>q;
LL max(LL a,LL b)
{
    if(a>b)return a;
    else return b;
}
void worrk()
{
    /*for(int i=1;i<=n;i++)
    {
        node a;
        a.zt=0|1<<(i-1);a.ta=c[i];
        a.las=i;a.ch=1;
        q.push(a);
    }
    while(!q.empty())
    {
        node w=q.front();q.pop();
        if(w.ch==m){
            ans=max(ans,w.ta);
            continue;
        }
        int u=w.las;LL r=w.zt;
        if(s[u][r]<w.ta)s[u][r]=w.ta;
        else continue;
        for(int i=1;i<=n;i++)
        if(i!=u&&!(r&1<<(i-1)))
        {
            node k;
            k.zt=r|1<<(i-1);
            k.ta=f[u][i]+w.ta+c[i];
            k.las=i;k.ch=w.ch+1;
            q.push(k);
        }
    }*/
    for(int i=1;i<(1<<n);i++)
    {
        int tot=0;
        for(int j=0;j<n;j++)
            if(i&1<<j)tot++;
        if(tot>m)continue;
        for(int j=1;j<=n;j++) //this
        {
            if((i&1<<(j-1))==0)continue;
            if(tot==1){
                s[0][i]=s[j][i]=c[j];
                break;
            }
            LL ma=0;
            for(int k=1;k<=n;k++) //last
            {
                if((1<<(k-1)&i)==0||j==k)continue;
                ma=max(ma,s[k][i&(~(1<<(j-1)))]+f[k][j]+c[j]);
            }
            s[j][i]=ma;
            if(tot==m)ans=max(s[j][i],ans);
        }
    }
    cout<<ans<<endl;
}
int main()
{
    freopen("b.in","r",stdin);
    freopen("b.out","w",stdout);
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    scanf("%d",&c[i]);
    for(int i=1;i<=k;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        f[x][y]=max(f[x][y],z);
    }
    worrk();
}

ps：注释的部分是之前用map写的队列（以为1<<18开不下，脑抽orz）

给定一棵树，1,为根节点，有m个操作或询问，操作(x,k)为将x节点权值加k，它儿子加k+1,孙子加k+2,以此类推，查询为求x及它形成子树权值总和。
n<=5e4,m<=1e5

思路：
这道题…拿到后看数据范围，可以判断每次询问或修改要控制在logn左右才行，再加上昨天看了树链剖分，就比较容易会想到是将树铺成一条链，再用线段树维护。由于把公式写复杂了所以考虑复杂了于是乎考试时没写完qwq交了个暴力结果wa了TAT
单点公式：dp[v]-dp[root]+k; dp指深度，root是操作时的根。
知道单点修改之后，注意每次修改的 k-dp[root]是一样的，所以将它延迟在线段树上处理，只需*区间的size即可，而dp[v]在建树时可以区段求和，于是便很好处理了。
代码代码qwq：

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#define R(x) (x<<1|1)
#define L(x) (x<<1)
#define LL long long
using namespace std;
const int N=50005;
int n,q,x,y,head[N],next[N],tov[N],tot,fa[N];
int w[N],id,tail[N];
LL ans;
char c;
struct node{
    int siz,dp,add;
    LL cl;
}tr[N];
struct node2{
    int le,ri,ci;
    LL qq,sum,dps;
}cc[N*4];
void build(int a,int b)
{tot++;next[tot]=head[a];tov[tot]=b;head[a]=tot;}
void dfs(int k)
{
    int u=head[k],v=tov[u];
    tr[k].siz=1;
    while(u)
    {
        tr[v].dp=tr[k].dp+1;
        dfs(v);
        tr[k].siz+=tr[v].siz;
        u=next[u];v=tov[u];
    }
}
void dfs2(int k,int t)
{
    w[k]=++id;fa[id]=k;
    int u=head[k],v=tov[u];
    while(u)
    {
        dfs2(v,v);
        u=next[u];v=tov[u];
    }
    tail[k]=id;
}
void pushup(int u)
{
    cc[u].dps=cc[R(u)].dps+cc[L(u)].dps;
}
void pushdown(int u)
{
    cc[u].sum+=cc[u].dps*(LL)cc[u].ci+cc[u].qq*(LL)(cc[u].ri-cc[u].le+1);
    cc[R(u)].ci+=cc[u].ci;cc[R(u)].qq+=cc[u].qq;
    cc[L(u)].ci+=cc[u].ci;cc[L(u)].qq+=cc[u].qq;
    cc[u].ci=0;cc[u].qq=0;
}
void update(int u)
{
    pushdown(R(u));pushdown(L(u));  //!!!!!!
    cc[u].sum=cc[R(u)].sum+cc[L(u)].sum;
}
void buildtr(int u,int l,int r)
{
    cc[u].le=l;cc[u].ri=r;
    if(l==r)
    {
        cc[u].dps=tr[fa[r]].dp;
        return;
    }
    int mid=(l+r)>>1;
    buildtr(R(u),mid+1,r);
    buildtr(L(u),l,mid);
    pushup(u);
}
void add(int u,int l,int r,int k,int gen)
{
    if(cc[u].le==l&&cc[u].ri==r)
    {
        cc[u].qq+=(k-tr[gen].dp);
        cc[u].ci++;
        pushdown(u);
        return ;
    }
    int mid=(cc[u].le+cc[u].ri)>>1;
    if(mid>=r)add(L(u),l,r,k,gen);
    else if(mid<l)add(R(u),l,r,k,gen);
    else{
        add(L(u),l,mid,k,gen);
        add(R(u),mid+1,r,k,gen);
    }
    update(u);
}
void sear(int u,int l,int r)  //单点dp[v]-dp[gen]+k;->区段处理后延迟更新 
{
    if(cc[u].le==l&&cc[u].ri==r)
    {
        pushdown(u);
        ans+=cc[u].sum;
        return;
    }
    if(cc[u].ci)pushdown(u);
    int mid=(cc[u].le+cc[u].ri)>>1;
    if(mid>=r)sear(L(u),l,r);
    else if(mid<l)sear(R(u),l,r);
    else{
        sear(L(u),l,mid);
        sear(R(u),mid+1,r);
    }
    update(u);
}
void pre()
{
    for(int i=2;i<=n;i++)
    {
        scanf("%d",&x);
        build(x,i);
    }
    tr[1].dp=1;dfs(1);
    dfs2(1,1);
    buildtr(1,1,n);
}
void worrk()
{
    for(int i=1;i<=q;i++)
    {
        c=getchar();while(c!='A'&&c!='Q')c=getchar();
        if(c=='A')
        {
            scanf("%d%d",&x,&y);
            add(1,w[x],tail[x],y,x);
        }
        else{
            scanf("%d",&x);
            ans=0;sear(1,w[x],tail[x]);
            printf("%I64d\n",ans);
        }
    }
}
int main()
{
    freopen("c.in","r",stdin);
    freopen("c.out","w",stdout);
    scanf("%d%d",&n,&q);
    pre();
    worrk();
}