CF1485X Codeforces Round #701

D Multiples and Power Differences （构造）

题目大意：给一个n*m的矩阵a，a[i][j]在1到16之间。现在要构造矩阵b，需要满足如下条件：

1.b[i][j]在1到1e6之间

2.b[i][j]是a[i][j]的倍数

3.对于矩阵中任意相邻的两个数，要求存在正整数k，他们的差值绝对值等于k的四次方，不要求所有对的k都相同

构造神仙题，乍一看不可做。。

考虑第二个条件，由于a最多到16，发现1到16所有数的最小公倍数是$720720$！小于1e6。

在考虑第三个条件，可以对b矩阵黑白染色，黑点构造成$720720+a[i][j]^{4}$，白点是$720720$

矩阵问题不仅可以建边跑图论，还可以染色处理

const int N1=505; const int maxn=720720;

int n,m;
int a[N1][N1],b[N1][N1];

int main()
{
    freopen("a.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",&a[i][j]);
    for(int i=1;i<=n;i++,puts("")) for(int j=1;j<=m;j++) 
    {
        if((i+j)%2==0){
            b[i][j]=maxn;
        }else{
            b[i][j]=maxn+a[i][j]*a[i][j]*a[i][j]*a[i][j];
        }
        printf("%d ",b[i][j]);
    }
    return 0;
}

E Move and Swap （树形DP）

题目大意：给你一棵有根树，开始时有红蓝两个棋子放在根上，一次移动需要进行如下操作：

设红蓝棋子当前未知分别为r，b

1.把红棋子移动到r的某个子节点上

2.把蓝棋子移动到深度=dep[b]+1的某个点上

3.可选择是否交换红蓝棋子的位置

每次移动产生$|a[r]-a[b]|$点代价，现在求代价之和的最大值

对点按深度从大到小依次处理

令$f[i]$表示$i$节点放红色棋子时的最大贡献，$g[j]$表示$j$子节点中$f$的最大值

可得转移方程$f[i]=maxleft { max(g[i],g[j])+|a[i]-a[j]| ight } $  

将相同深度的点按a排序，正反各计算一次，即可消掉绝对值，再用前缀/后缀最大值优化转移即可

const int N1=200005; const ll inf=0x3f3f3f3f3f3f3f3fll;

int n,T;
struct EDGE{
int to[N1],nxt[N1],head[N1],cte;
void ae(int u,int v)
{ cte++; to[cte]=v; nxt[cte]=head[u]; head[u]=cte; } 
}e;

ll f[N1],g[N1];
int fa[N1],a[N1],dep[N1],madep;
vector<int>id[N1];
int cmp1(int x,int y){ return a[x]<a[y]; }
void clr()
{
    for(int i=1;i<=n;i++) e.head[i]=0, id[i].clear(), f[i]=g[i]=dep[i]=0;
    while(e.cte) e.to[e.cte]=e.nxt[e.cte]=0, e.cte--; 
}

void dfs(int u)
{
    for(int j=e.head[u];j;j=e.nxt[j])
    {
        int v=e.to[j]; dep[v]=dep[u]+1; madep=max(madep,dep[v]);
        id[dep[v]].push_back(v);
        dfs(v);
    }
}

int main()
{
    freopen("a.in","r",stdin);
    scanf("%d",&T);
    while(T--){

    scanf("%d",&n);
    for(int i=2;i<=n;i++) scanf("%d",&fa[i]), e.ae(fa[i],i);
    for(int i=2;i<=n;i++) scanf("%d",&a[i]);
    madep=0; dfs(1);
    ll tma,ma;
    for(int k=madep,i;k>=1;k--)
    {
        sort(id[k].begin(),id[k].end(),cmp1);
        tma=-inf; ma=-inf;
        for(int j=0;j<id[k].size();j++)
        {
            i=id[k][j]; tma=max(tma,g[i]-a[i]); ma=max(ma,-1ll*a[i]);
            f[i]=max(tma+a[i],g[i]+a[i]+ma);
        }
        tma=-inf; ma=-inf;
        for(int j=(int)id[k].size()-1;j>=0;j--)
        {
            i=id[k][j]; tma=max(tma,g[i]+a[i]); ma=max(ma,1ll*a[i]);
            f[i]=max(f[i],max(tma-a[i],g[i]+ma-a[i]));
        }
        for(int j=0;j<id[k].size();j++)
        {
            i=id[k][j]; g[fa[i]]=max(g[fa[i]],f[i]);
        }
    }
    printf("%lld
",g[1]);
    clr();

    }
    return 0;
}

F Copy or Prefix Sum （线段树优化DP）

题目大意：给定数组b，现在求有多少满足如下条件的a数组：

$b[i]=a[i]$或$b[i]=sum_{j=1}^{i}a[j]$

考场上最后一分钟调出来了，结果我非得给数组多按个0然后CE（MLE）了。。不然就不会掉分了

发现第二个条件是前缀和比较特殊，并且第一个条件不影响答案

考虑DP选择第二个条件的位置

定义f[i]表示i位置满足第二个条件且不满足第一个条件时的方案数

不满足第一个条件时$b[i] e a[i]$，计算可得$sum[i-1]-sum[j-1] e 0$

$f[i]=sum_{j=1}^{i-1}f[j](sum[i-1] e sum[j-1])$

线段树优化DP就好了！又由于sum值域较大且可能为负，动态开点+整体往右挪

const int N1=200005; const int inf=0x3f3f3f3f;
const ll maxn=1e15;
const int p=1000000007;

int T,n;
int a[N1],b[N1];
ll f[N1];
struct SEG{
ll sum[N1*65]; int ls[N1*65],rs[N1*65],tot;
void pushup(int rt){ sum[rt]=(sum[ls[rt]]+sum[rs[rt]])%p; }
void upd(ll x,ll l,ll r,int &rt,ll w)
{
    if(!rt) rt=++tot;
    if(l==r){ (sum[rt]+=w)%=p; return; }
    ll mid=(l+r)>>1;
    if(x<=mid) upd(x,l,mid,ls[rt],w);
    else upd(x,mid+1,r,rs[rt],w);
    pushup(rt);
}
ll query(ll L,ll R,ll l,ll r,int rt)
{
    if(!rt) return 0;
    if(L<=l&&r<=R) return sum[rt];
    ll mid=(l+r)>>1; ll ans=0;
    if(L<=mid) ans+=query(L,R,l,mid,ls[rt]);
    if(R>mid) ans+=query(L,R,mid+1,r,rs[rt]);
    ans%=p;
    return ans;
}
void clr()
{
    while(tot) sum[tot]=0, ls[tot]=rs[tot]=0, tot--;    
}
}s;
ll sum[N1];

int main()
{
    scanf("%d",&T);
    ll ans=0,mi=maxn,ma=-maxn;
    while(T--)
    {
        scanf("%d",&n); 
        for(int i=1;i<=n;i++) scanf("%d",&b[i]), sum[i]=sum[i-1]+b[i], mi=min(mi,sum[i]), ma=max(ma,sum[i]);
        ll ans=1; f[1]=0; int root=0;
        for(int i=2;i<=n;i++)
        {
            // f[i]=1;
            if(sum[i-1]!=0) f[i]=1; else f[i]=0;
            // for(int j=1;j<i;j++) if(sum[i-1]!=sum[j-1])
            //     (f[i]+=f[j])%=p;
            if(mi<sum[i-1]) (f[i]+=s.query(mi+maxn,sum[i-1]+maxn-1,mi+maxn,ma+maxn,root));
            if(sum[i-1]<ma) (f[i]+=s.query(sum[i-1]+maxn+1,ma+maxn,mi+maxn,ma+maxn,root));
            f[i]%=p;
            s.upd(sum[i-1]+maxn,mi+maxn,ma+maxn,root,1ll*f[i]);
            (ans+=f[i])%=p;
        }
        printf("%lld
",ans);
        s.clr();
    }
    return 0;
}