CF1103D Professional layer dp

正解:dp

解题报告:

传送门!

首先不难想到求个gcd,然后把gcd质因数分解成p₁^w₁*p₂^w₂*p₃^w₃*...*p_m^w_m

显然只要满足对每个p有一个a_i%p_j!=0就好,也就是说对每个p_j找出一个a_i然后代价最小就好

然后这时候就考虑dp

先考虑最简单的,f[i][x][s]:dp到第i个了,改了x个,p的状态为s的最小花费

然后直接枚举删哪个质因子集,判是否合法(<=k)即可

这时候发现复杂度不太对,是O(nm3^m)不会分析复杂度不要问我为什么是这个式子,,,

但反正是跑不过去的这个是可以发现的

因为可以发现m<=11(2*3*5*7*11*13*17*19*23*29*31)嘛,这样显然是会T的

所以考虑怎么优化

考虑到我们最开始的那个dp能有一个小优化

那个dp的顺序显然是for(i)for(x)for(S)for(T),其中S指的是原来的状态,T指的是增加的状态嘛

这里可以考虑到,对质因数的倍数的集合,我们只要保留前m个就欧克了,后面显然都是浪费(这里关于集合这个词可能比较难get,,,指的是对每个数,有意义的地方只在那些单纯由gcd的质因数构成的数,所以把每个数的最大的这个有用数拿出来,把这个有用数相当的数就可以作为一个集合辣!(还是说得不太清楚的样子QAQ

继续优化,可以发现对于每个状态其实也只要保留前m个就欧克了

所以对每个状态也只要枚m次,超过了就不枚了

所以考虑改变枚举顺序,先枚T,然后枚T的补集的子集S

然后这里先港下枚举集合的正确姿势

如果现在是要枚举集合满足j是k的子集

显然首先肯定要已知一个集合,就分类讨论下,看是已知j还是已知k

如果是已知j了,就是说枚举包含某个集合的集合,就可以for(ri k=(j+1)|j;k<=S;k=(k+1)|j)

(因为,一般要枚举集合之类的都是在dp转移中,所以就不考虑k=j的情况了QAQ

然后如果是已知k了,就是说枚举某个集合的子集,就可以for(ri j=(k-1)&k;j;j=(j-1)&k)

原理还是挺显然的?实在无法理解手动模拟下就能get辣

然后好像就差不多了?

#include<bits/stdc++.h>
using namespace std;
#define fr first
#define sc second
#define il inline
#define ll long long
#define gc getchar()
#define rl register ll
#define rc register char
#define rb register bool
#define rp(i,x,y) for(rl i=x;i<=y;++i)
#define my(i,x,y) for(rl i=x;i>=y;--i)

const ll N=1e6+,M=;
ll n,K,gcdd,fac[M],fac_cnt,f[M][<<M],S,poww[M]={},as,inf;
bool vis[<<M];
struct node{ll a,e;}nod[N];
map< ll,vector<ll> >Mp;

il ll read()
{
    rc ch=gc;rl x=;rb y=;
    while(ch!='-' && (ch>'' || ch<''))ch=gc;
    if(ch=='-')ch=gc,y=;
    while(ch>='' && ch<='')x=(x<<)+(x<<)+(ch^''),ch=gc;
    return y?x:-x;
}
il ll gcd(rl gd,rl gs){return gs?gcd(gs,gd%gs):gd;}

int main()
{
//     freopen("ayg.in","r",stdin);freopen("ayg.out","w",stdout);
    n=read();K=read();rp(i,,n)nod[i].a=read();rp(i,,n)nod[i].e=read();gcdd=nod[].a;rp(i,,n)gcdd=gcd(gcdd,nod[i].a);
    if(!(gcdd^))return printf("0\n"),;
    for(rl i=;i*i<=gcdd;++i)if(!(gcdd%i)){fac[fac_cnt++]=i;while(!(gcdd%i))gcdd/=i;}
    if(gcdd^)fac[fac_cnt++]=gcdd;
    rp(i,,n){rl tmp=;rp(j,,fac_cnt-)while(!(nod[i].a%fac[j]))tmp*=fac[j],nod[i].a/=fac[j];Mp[tmp].push_back(nod[i].e);}
    memset(f,,sizeof(f));inf=as=f[][];f[][]=;
    S=(<<fac_cnt)-;rp(i,,fac_cnt)poww[i]=poww[i-]<<;
    for(auto i:Mp)
    {
        ll x=i.fr;sort(i.sc.begin(),i.sc.end());if(i.sc.size()>fac_cnt)i.sc.resize(fac_cnt);
        rp(j,,S){rl y=x,z=;rp(k,,fac_cnt-)if(j&poww[k])while(!(y%fac[k]))y/=fac[k],z*=fac[k];vis[j]=(z<=K);}
        for(auto j:i.sc)
        {
            bool flg=;
            my(k,fac_cnt-,)
                rp(p,,S)
                    if(f[k][p]<inf)
                        for(rl q=(p+)|p;q<=S;q=(q+)|p)if(vis[q^p])if(f[k+][q]>f[k][p]+j)flg=,f[k+][q]=f[k][p]+j;
            if(!flg)break;
        }
    }
    rp(i,,fac_cnt)if(f[i][S]<inf)as=min(as,f[i][S]*i);if(as^inf)printf("%lld\n",as);else printf("-1\n");
    return ;
}

这儿是代码QAQ