[ARC 066] Tutorial

Link:

ARC 066 传送门

C：

如果存在可行方案则答案为$2^{n/2}$

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=1e5+,MOD=1e9+;
int n,x,res[MAXN];

int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++)
    {
        scanf("%d",&x);
        int rk=(n-+x)/;
        if(!res[rk+]) res[rk+]=i;
        else if(!res[n-rk]) res[n-rk]=i;
        else return puts(""),;
    }
    int res=;
    for(int i=;i<=n/;i++) (res*=)%=MOD;
    printf("%d",res);
    return ;
}

Problem C

D：

挺不错的一道数位$dp$

由于无法直接计算$sum$和$xor$的对数，因此考虑枚举$a,b$，而将$sum,xor\le n$作为限制条件

又因为公式：$a+b=aXORb+2*(a\&b)$，所以$a+b\le aXORb$，只考虑$a+b$的限制即可

此时问题转化为对于每个$sum\le n$求$xor$的取值个数

这样就可以用$dp[i][s]$表示前$i$位确定，$a+b$的和为$s$的个数，每次分$a,b$在该位上总共有几个1转移

（按每位1的个数转移才不会考虑异或与和同时相同的情况！）

但这样复杂度是不对的，在枚举$s$上明显花费了不必要的时间

根据一般数位$dp$记录上限的思想，如果前$i$位的$n-s\ge 2$，这些数以后都保证合法，就能统一计算了

这样就从$dp[i][s]$变成了$dp[i][0/1/2]$

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int,int> P;
#define MAX_D 64
#define MOD ((ll)1e9 + 7)
ll N,dp[MAX_D][],res;int nxt;

int main()
{
    scanf("%lld",&N);
    dp[MAX_D-][]=;
    for(int i=MAX_D-;i>;i--)
        for(int j=; j <= ; j++)
            for(int k=;k<=;k++)
            {
                nxt=j*+((N>>(i-))&)-k;
                if (nxt<) continue;
                nxt=nxt>?:nxt;
                (dp[i-][nxt]+=dp[i][j])%=MOD;
            }
    res=;
    for (int i=;i<=;i++) (res+=dp[][i])%=MOD;
    printf("%lld\n", res);
    return ;
}

Solution A

从后往前用记忆化搜索的形式写起来更加方便

一开始将上限值就设为$n$，每次确定最后一位取几个以后去掉最后一位，不用考虑和的合法性了

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int,int> P;
const int MOD=1e9+;
map<ll,ll> dp;ll n;

ll dfs(ll x)
{
    if(dp.count(x)) return dp[x];
    return dp[x]=(dfs(x>>)+dfs((x-)>>)+dfs((x-)>>))%MOD;
}

int main()
{
    scanf("%lld",&n);
    dp[]=;dp[]=;
    printf("%lld",dfs(n));
    return ;
}

Solution B

E：

首先要观察出几点性质：

1、只有在减号后可能加括号

2、括号不可能嵌套超过两层，否则可以转化为只有两层的简化情况

这样就可以记录$dp[0/1/2]$分别表示当前还有几个左括号未匹配的最大值来$dp$了

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
int n,x;char op;ll dp[],nxt[];

int main()
{
    scanf("%d%d",&n,&dp[]);
    dp[]=dp[]=-1ll<<;
    for(int i=;i<n;i++)
    {
        scanf(" %c%d",&op,&x);
        if(op=='-') x=-x;
        nxt[]=dp[]+x,nxt[]=dp[]-x,nxt[]=dp[]+x;
        dp[]=max(nxt[],max(nxt[],nxt[]));
        if(op=='+') dp[]=max(nxt[],nxt[]),dp[]=nxt[];
        else dp[]=dp[],dp[]=max(nxt[],nxt[]);
    }
    printf("%lld",dp[]);
    return ;
}

Solution A

其实也可以不用$dp$，考虑如果在某个减号后加了第一个括号的最优解

发现此时能保证将下一个减号后的值都变为正贡献，但对当前位到下一个减号间的值是无能为力的

这样枚举第一个括号的位置对答案更新即可

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=1e5+;
char op[MAXN];
int n,dat[MAXN],nxt[MAXN],fst;
ll suf[MAXN],cur,res=-1ll<<;

int main()
{
    scanf("%d%d",&n,&fst);
    for(int i=;i<n;i++)
        scanf(" %c%d",&op[i],&dat[i]);
    cur=n;
    for(int i=n-;i;i--)
    {
        suf[i]=suf[i+]+dat[i];
        if(op[i]=='-') nxt[i]=cur,cur=i;
    }
    cur=;
    for(int i=;i<n;i++)
        if(op[i]=='-')
            res=max(res,cur-suf[i]+*suf[nxt[i]]),cur-=dat[i];
        else cur+=dat[i];
    res=max(res,cur);
    printf("%lld",res+fst);
    return ;
}

Solution B

F：