Codeforces Round #596 Div1 A~E题解

Posted 2020-12-01 gmh77

我好菜啊

A

题意：
定义p-二进制数为2^k-p，给出n和p，求用最小个数的p-二进制数来表示n
1<=n<=10^9,-1000<=p<=1000

题解：
猜结论，答案不会很大
n可以表示成kp+s的形式，枚举k，判断(n-kp)是否能用k个2的幂构成
画一下图可以发现，如果可以构成，那么满足(n-kp)的位数<=k<=n-kp
（相当于把一颗二叉树上一个点变成两个）
证明答案不会很大：
首先(n-kp)的位数最多为30
①p>=0
显然当k超过30后，如果不满足则之后也不满足
②p<0
那么n-kp显然大于等于k

code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

long long n,s;
int p,i,j,k,l;

bool pd(long long t)
{
    long long T=t;
    int sum=0;
    
    while (T)
    {
        sum+=T&1;
        T>>=1;
    }
    
    if (s>=sum && s<=t)
    return 1;
    else
    return 0;
}

int main()
{
//  freopen("a.in","r",stdin);
    
    scanf("%I64d%d",&n,&p);
    
    while (!pd(n))
    {
        n-=p;
        ++s;
        
        if (n<0 ||s>100)
        break;
    }
    
    if (n>=0 && pd(n))
    printf("%I64d
",s);
    else
    printf("-1
");
}

B

题意：
给出n个数和k，求(i,j)的个数（i<j），使得ai*aj=x^k
n<=10^5,2<=k<=100

题解：
能表示成x的k次方，意味着乘积质因数分解后每一位的指数%k=0
也就是(ai中p的指数+aj中p的指数)%k=0，把i或j的指数取负，变成求ai和aj质因数指数相等的(i,j)个数
可以排序搞，根据k讨论一下大质数

code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define min(a,b) (a<b?a:b)
using namespace std;

int a[200001];
int p[200001][66];
int P[317];
int c[200001];
int N,n,K,i,j,k,l,s,len,ls,s1,s2;
long long ans;
bool bz;

bool cmp(int a,int b)
{
    int i;
    
    fo(i,1,65)
    if (p[a][i]<p[b][i])
    return 1;
    else
    if (p[a][i]>p[b][i])
    return 0;
    
    return 0;
}

bool pd(int t)
{
    int i;
    
    fo(i,1,65)
    if (p[a[t]][i]!=p[a[t+1]][i])
    return 0;
    return 1;
}

bool Cmp(int x,int y)
{
    return p[x][0]<p[y][0];
}

int main()
{
//  freopen("b.in","r",stdin);
    
    fo(i,2,316)
    {
        k=1;
        
        fo(j,2,floor(sqrt(i)))
        if (!(i%j))
        {
            k=0;
            break;
        }
        
        if (k)
        P[++len]=i;
    }
    
    scanf("%d%d",&n,&K);
    fo(i,1,n)
    {
        scanf("%d",&l);
        fo(j,1,len)
        if (!(l%P[j]))
        {
            while (!(l%P[j]))
            {
                l/=P[j];
                ++p[i][j];
            }
            p[i][j]%=K;
            p[i+n][j]=(K-p[i][j])%K;
        }
        
        if (l>1)
        {
            p[i][0]=l;
            p[i+n][0]=l;
        }
    }
    
    N=n+n;
    fo(i,1,N)
    a[i]=i;
    
//  fo(i,1,N)
//  {
//      fo(j,0,5)
//      cout<<p[i][j]<<" ";
//      cout<<endl;
//  }
    
    sort(a+1,a+N+1,cmp);
    
//  fo(i,1,N)
//  cout<<a[i]<<endl;
//  fo(i,1,N)
//  {
//      fo(j,0,5)
//      cout<<p[a[i]][j]<<" ";
//      cout<<endl;
//  }
    
    ls=1;
    fo(i,1,N)
    if (i==N || !pd(i))
    {
        l=0;
        fo(j,ls,i)
        c[++l]=a[j];
        
        sort(c+1,c+l+1,Cmp);
        
        if (K>=3)
        {
            s1=0;s2=0;
            
            fo(j,1,l)
            if (!p[c[j]][0])
            {
                if (c[j]<=n)
                ++s1; else ++s2;
            }
            
//          fo(j,1,l)
//          if (c[j]<=n)
//          cout<<c[j]<<" ";
//          else
//          cout<<-(c[j]-n)<<" ";
//          cout<<endl;
//          cout<<" "<<s1*s2<<" "<<s1<<" "<<s2<<endl;
            
            ans+=(long long)s1*s2;
        }
        else
        {
            s1=0;s2=0;
            fo(j,1,l)
            {
                if (j==1 || p[c[j]][0]==p[c[j-1]][0])
                {
                    if (c[j]<=n)
                    ++s1; else ++s2;
                }
                else
                {
                    ans+=(long long)s1*s2;
                    
                    s1=0;s2=0;
                    if (c[j]<=n)
                    ++s1; else ++s2;
                }
            }
            ans+=(long long)s1*s2;
        }
        
        ls=i+1;
    }
    
    if (K==2)
    {
        fo(i,1,n)
        {
            fo(j,1,65)
            if ((p[i][j]*2%K))
            break;
            
            if (j>65)
            --ans;
        }
    }
    else
    {
        fo(i,1,n)
        if (!p[i][0])
        {
            fo(j,1,65)
            if ((p[i][j]*2%K))
            break;
            
            if (j>65)
            --ans;
        }
    }
    
    printf("%I64d
",ans/2);
}

C

题意：
给出n*m的方格图，每个格子上有514石头或者为空
从(1,1)开始向(n,m)移动（只能向右/下），每次移动会把一行/一列的石头向右/下推一格，不能把石头推出方格图外
求方案数

题解：
差点就切了的sb题
一个合法的路径有若干次转折，可以发现每次转折时所转到的方向上的石头都没被推过
所以只需要考虑当前方向往后的石头个数即可转移，用前缀和优化

code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define mod 1000000007
using namespace std;

bool a[2002][2002];
int s1[2002][2002];
int s2[2002][2002];
int f[2002][2002][2];
int g[2002][2002][2];
int n,m,i,j,k,l;
char ch;

int main()
{
//  freopen("c.in","r",stdin);
    
    scanf("%d%d",&n,&m);
    fo(i,1,n)
    {
        fo(j,1,m)
        {
            ch=getchar();
            while (ch!='.' && ch!='R')
            ch=getchar();
            
            a[i][j]=ch=='R';
        }
    }
    
    if (a[n][m])
    {
        printf("0
");
        return 0;
    }
    if (n==1 && m==1)
    {
        printf("1
");
        return 0;
    }
    
    fd(i,n,1)
    {
        fd(j,m,1)
        {
            s1[i][j]=s1[i][j+1]+a[i][j];
            s2[i][j]=s2[i+1][j]+a[i][j];
        }
    }
    
    f[1][1][0]=1;
    f[1][1][1]=1;
    fo(i,1,n)
    {
        fo(j,1,m)
        {
            if (i>1 || j>1)
            {
                f[i][j][0]=g[i][j][0];
                f[i][j][1]=g[i][j][1];
            }
            
            fo(k,0,1)
            if (f[i][j][k])
            {
                if (!k)
                {
                    g[i][j][k^1]=(g[i][j][k^1]+f[i][j][k])%mod;
                    g[i][m-s1[i][j+1]+1][k^1]=(g[i][m-s1[i][j+1]+1][k^1]-f[i][j][k])%mod;
                }
                else
                {
                    g[i][j][k^1]=(g[i][j][k^1]+f[i][j][k])%mod;
                    g[n-s2[i+1][j]+1][j][k^1]=(g[n-s2[i+1][j]+1][j][k^1]-f[i][j][k])%mod;
                }
            }
            
            g[i][j+1][1]=(g[i][j+1][1]+g[i][j][1])%mod;
            g[i+1][j][0]=(g[i+1][j][0]+g[i][j][0])%mod;
        }
    }
    
    printf("%d
",((f[n][m][0]+f[n][m][1])%mod+mod)%mod);
}

D

题意：
把一条链进行若干次操作，每次操作选择一个点，把这个点的父亲设为其父亲的父亲
求最小的操作使得能把链变成给出的一棵树，并给出链的初始编号和每次操作的点编号

题解：
很妙的构造题
一开始想把每个点接到兄弟节点中深度最小的点，但是挂了
考虑把树变成链，一次操作实质是把一个点的父亲设为其的一个兄弟节点
由于每次操作树的深度最多+1，所以操作次数的下限为(n-深度)
先找出树上最长链，每次把最长链上的一个点v下移到兄弟u，下移后最长链多了u
每次深度+1，所以这样的操作次数刚好是(n-深度)，即为最优

code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define min(a,b) (a<b?a:b)
#define max(a,b) (a>b?a:b)
using namespace std;

int a[100001][2];
int ls[100001];
int fa[100001];
int nx[100001];
int Ans[100001];
bool bz[100001];
int d[100001];
int n,i,j,k,l,len,ans,tot,tot2,mx,mx2,h,t;

void New(int x,int y)
{
    ++len;
    a[len][0]=y;
    a[len][1]=ls[x];
    ls[x]=len;
}

void dfs(int t,int d)
{
    int i;
    
    if (d>mx)
    mx=d,mx2=t;
    
    for (i=ls[t]; i; i=a[i][1])
    fa[a[i][0]]=t,dfs(a[i][0],d+1);
}

int main()
{
//  freopen("d.in","r",stdin);
    
    scanf("%d",&n);
    fo(i,2,n)
    {
        scanf("%d",&fa[i]);++fa[i];
        New(fa[i],i);
    }
    
    dfs(1,1);
    
    while (mx2)
    {
        bz[mx2]=1;
        
        nx[fa[mx2]]=mx2;
        mx2=fa[mx2];
    }
    fo(j,1,n)
    if (bz[j])
    {
        for (i=ls[j]; i; i=a[i][1])
        if (!bz[a[i][0]])
        d[++t]=a[i][0];
    }
    
    while (h<t)
    {
        ++h;
        j=nx[fa[d[h]]];
        
        for (i=ls[d[h]]; i; i=a[i][1])
        d[++t]=a[i][0];
        
        fa[j]=d[h];
        nx[fa[d[h]]]=d[h];
        nx[d[h]]=j;
        
        Ans[++tot]=j;
    }
    
    for (i=1; i; i=nx[i])
    printf("%d ",i-1);
    printf("
");
    printf("%d
",tot);
    fd(i,tot,1)
    printf("%d ",Ans[i]-1);
}

E

题意：
给出一个数k和n个数（都不能整除k），每次可以把两个数合并，合并后的值除k直到不整除为止
求一种把n个数合并成1的方案
n<=16,k<=2000,∑ai<=2000

题解：
O(3^n*2000)的做法显然过不了
可以发现，每种合并的方案最终都可以表示为∑ai*k^bi，其中bi<0
证明每种∑ai*k^bi=1的情况都能对应一种合法方案：
①n=1
那么只有a1=1时才成立
（不存在a1>1的情况）
②n>1
设序列中最小的bi为B，那么必定存在至少两个bi=B
证明：
若只有一个，那么
∑ai*k^bi=1
∑ai*k^(bi-B)=k^(-B)
当bi>B时，乘积必为k的倍数，而右侧也为k的倍数
如果只有一个bi=B，且ai%k≠0，左右在模k意义下不等，实际也必然不等

那么每次把bi=bj=B的ij合并，把新的数的b变为(b+合并后的数除k的次数)，合并的数变为f(i+j)即可
可以发现这样仍满足∑ai*k^bi=1，而n-1的所有情况都已经归纳证明了
③n=2
由于n=1比较特殊，所以n=2也要特殊考虑
从n>1的结论得知，b1=b2=B
因为a1*k^B+a2*k^B=1
a1+a2=k^(-B)
所以f(a1+a2)=1，可以变为n=1的情况，即上文所说不存在a1>1

---

那么dp就很显然了，考虑每次操作加一个a，或者对于所有的a除以k
把一种合法的序列还原时，可以发现其中不存在小数
所以dp时的ai和也必为整数
用bitset优化，反着还原dp，然后正着求出每次操作
还原dp时不需要记录上个状态（因为有bitset），每次枚举一种操作判断原状态是否存在即可

code

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <bitset>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

struct type{
    int a,b;
} b[17];
int p[17];
int a[17];
int ans[101];
bitset<2001> f[65536];
int n,K,L,i,j,k,l,sum,len,s,tot;

bool cmp(type a,type b)
{
    return a.b>b.b;
}

int main()
{
//  freopen("e.in","r",stdin);
    
    p[1]=1;
    fo(i,2,16)
    p[i]=p[i-1]<<1;
    
    scanf("%d%d",&n,&K);L=(p[n]<<1)-1;
    fo(i,1,n)
    scanf("%d",&a[i]),sum+=a[i];
    sum/=K;
    
    f[0][0]=1;
    fo(i,1,L)
    {
        fo(j,1,n)
        if (i&p[j])
        f[i]|=f[i^p[j]]<<a[j];
        
        fd(j,sum,1)
        if (f[i][j*K])
        f[i][j]=1;
    }
    
    if (!f[L][1])
    printf("NO
");
    else
    {
        printf("YES
");
        
        s=L;j=1;
        while (j)
        {
            if (j<=sum && f[s][j*K])
            {
                j*=K;
                ans[++len]=-1;
                continue;
            }
            
            fo(i,1,n)
            if (s&p[i] && j>=a[i] && f[s-p[i]][j-a[i]])
            {
                s-=p[i];
                j-=a[i];
                ans[++len]=i;
                
                break;
            }
        }
        
        j=0;
        fo(i,1,len)
        if (ans[i]==-1)
        ++j;
        else
        b[++tot]={a[ans[i]],-j};
        
        while (tot>1)
        {
            sort(b+1,b+tot+1,cmp);
            
            printf("%d %d
",b[tot-1].a,b[tot].a);
            b[tot-1].a+=b[tot].a;
            
            --tot;
            while (!(b[tot].a%K))
            b[tot].a/=K,++b[tot].b;
        }
    }
}