big之DP

最新推荐文章于 2025-01-09 14:07:35 发布

chm517

最新推荐文章于 2025-01-09 14:07:35 发布

阅读量575

点赞数

CC 4.0 BY-SA版权

分类专栏：【DP】_有点难

本文链接：https://blog.youkuaiyun.com/chm517/article/details/21808343

【DP】_有点难专栏收录该内容

5 篇文章

订阅专栏

1799：数位。要用滚动数组把20(10^18的位数)那一维优化到2，此时2*163^3还是略超64M。关键是构造一个元素个数尽可能少的集合，使得对于任意i属于[1,163]集合里至少有一个i的倍数。不清楚最优解是如何，唯一想到的一个办法大概降为原来的一半左右。

//BIG 1799
#include <cstdio> 
#include <cstring> 
#include <algorithm> 
#include <iostream> 
#include <cstdlib> 
#include <cmath> 
#include <queue> 
#include <vector> 
#include <map> 
#define pb push_back 
#define mp make_pair 
#define eps 1e-9 
#define zero(x) (fabs(x)<eps) 
#define pi acos(-1.0) 
#define f1 first 
#define f2 second 
const int inf=0x3f3f3f3f; 
const long long INF=1LL<<50; 
using namespace std; 
typedef long long LL; 
typedef pair <int,double> PII; 
#define N 163 
#define B 20 
LL dp[2][N][81][N]; 
int bit[B],len,o; 
int nc[N]; 
int s[81]; 
LL AA,BB; 
int vis[N],id[N]; 
  
LL calc(LL x) 
{   LL ans=0; 
  
    if (x==-1) return -1; 
    if (x==0) return 0; 
    len=0; 
    while (x) 
        {   bit[len++]=x%10; 
            x/=10; 
        } 
    int na=0; 
    memset(nc,0,sizeof(nc)); 
    memset(dp,0,sizeof(dp)); 
    for (int i=len-1;i>=0;i--) 
        { 
            int now=i&1,last=1-now; 
            memset(dp[now],0,sizeof(dp[now])); 
            for (int a=0;a<N;a++) 
            for (int b=0;b<o;b++) 
            for (int c=0;c<s[b];c++) 
            if (dp[last][a][b][c]) 
            for (int r=0;r<=9;r++) 
                dp[now][a+r][b][(c*10+r)%s[b]]+=dp[last][a][b][c]; 
  
  
            for (int r=0;r<bit[i];r++) 
            for (int b=0;b<o;b++) 
                dp[now][na+r][b][(nc[b]*10+r)%s[b]]++; 
            na+=bit[i]; 
            for (int b=0;b<o;b++) 
            nc[b]=(nc[b]*10+bit[i])%s[b]; 
  
        } 
    for (int b=0;b<o;b++) 
        dp[0][na][b][nc[b]]++; 
  
    for (int i=1;i<N;i++) 
    for (int j=0;j<N;j++) 
        if (j%i==0) 
        ans+=dp[0][i][id[vis[i]]][j]; 
  
    return ans; 
} 
  
void pre() 
{ 
    for (int i=N-1;i>=1;i--) 
    {   vis[i]=i; 
        for (int j=i+1;j<N;j++) 
            if (j%i==0) {vis[i]=vis[j]; break;} 
    } 
    o=0; 
    for (int i=1;i<N;i++) 
        if (vis[i]==i) {s[o]=i; id[i]=o++;} 
} 
int main() 
{   pre(); 
    while (scanf("%lld%lld",&AA,&BB)!=EOF) 
             printf("%lld\n",calc(BB)-calc(AA-1)); 
    return 0; 
}

3124:树形DP,直径问题延伸。若砍掉一条边后，剩下的两棵子树的直径的最大值比原来小，则该边必定在所有直径中。

//big 3124
//ans[i]:从i出发到叶子的最长、次大、此次大（可能会从父亲方向更新）
//ff[i]: 以i为根的子树但不含i点的直径的最大、次大(不会从父亲方向更新)
//f[i]:  以i为根的子树的直径最大值
//h[i]:  挖掉以i为根的子树后剩下的树的直径最大值
#include<algorithm>
#include<cstdio>
#include<cstring>
#define N 200005
typedef long long LL;
using namespace std;
struct edge{
    int  to,next;
    LL w;
}e[N<<1];
struct{
     LL a[3];
     int from[3];
}ans[N],ff[N];

int n,o;
int fa[N],head[N];
LL f[N],h[N];
void add(int x,int y,int w)
{
    e[o].to=y;
    e[o].w=w;
    e[o].next=head[x];
    head[x]=o++;
}

void update_ans(int u,int v,LL w)
{
    if (w>ans[u].a[0])
        {    ans[u].a[2]=ans[u].a[1]; ans[u].from[2]=ans[u].from[1];
             ans[u].a[1]=ans[u].a[0]; ans[u].from[1]=ans[u].from[0];
             ans[u].a[0]=w;           ans[u].from[0]=v;
        }
    else if (w>ans[u].a[1])
        {    ans[u].a[2]=ans[u].a[1]; ans[u].from[2]=ans[u].from[1];
             ans[u].a[1]=w;           ans[u].from[1]=v;
        }
    else if (w>ans[u].a[2])
        {   ans[u].a[2]=w;         ans[u].from[2]=v;
        }
}

void update_ff(int u,int v,LL w)
{     if (w>ff[u].a[0])
        {    ff[u].a[1]=ff[u].a[0];  ff[u].from[1]=ff[u].from[0];
             ff[u].a[0]=w;           ff[u].from[0]=v;
        }
    else if (w>ff[u].a[1])
        {    ff[u].a[1]=w;           ff[u].from[1]=v;
        }


}
void DFS0(int now,int fa)
{    for (int k=head[now];k!=-1;k=e[k].next)
      {  int j=e[k].to;
         if (j==fa) continue;
         DFS0(j,now);
         update_ans(now,j,ans[j].a[0]+e[k].w);
         update_ff(now,j,f[j]);
         f[now]=max(f[now],f[j]);
      }
     f[now]=max(f[now],ans[now].a[0]+ans[now].a[1]);
}



void DFS1(int now,int fa)
{
    for (int k=head[now];k!=-1;k=e[k].next)
      {int j=e[k].to;
       if (j==fa) continue;
       h[j]=max(h[j],h[now]);
       if (j==ff[now].from[0]) h[j]=max(h[j],ff[now].a[1]);else h[j]=max(h[j],ff[now].a[0]);
       update_ans(j,now,(ans[now].from[0]!=j)?ans[now].a[0]+e[k].w:ans[now].a[1]+e[k].w);
            if (j==ans[now].from[0]) h[j]=max(h[j],ans[now].a[1]+ans[now].a[2]);
       else if (j==ans[now].from[1]) h[j]=max(h[j],ans[now].a[0]+ans[now].a[2]);
       else h[j]=max(h[j],ans[now].a[0]+ans[now].a[1]);
       DFS1(j,now);
      }

}

void doit()
{   int x,y,w;

    memset(head,255,sizeof(head)); o=0;
    memset(ans,0,sizeof(ans));
    memset(ff,0,sizeof(ff));
    for (int i=1;i<=n-1;i++)
         {scanf("%d%d%d",&x,&y,&w);
          add(x,y,w);add(y,x,w);
         }

    memset(f,0,sizeof(f));
    memset(h,0,sizeof(h));
    DFS0(1,-1);
    h[1]=0;
    DFS1(1,-1);
    LL anss=f[1];
    int an=0;
    for (int i=2;i<=n;i++)
        if (max(f[i],h[i])!=anss) an++;
    printf("%lld\n%d\n",anss,an);
}

int main()
{   while (scanf("%d",&n)!=EOF) doit();
}

1017：题意有一点未清楚：所有装备恰构成一颗树。

//big 1017
//代码一
//F[i][j][k]表示i物品贡献给父亲j个花了k的最大力量
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define zero(x) (fabs(x)<eps)
#define pi acos(-1.0)
#define f1 first
#define f2 second
const int inf=0x3f3f3f3f;
const long long INF=1LL<<50;
using namespace std;
typedef long long LL;
typedef pair <int,double> PII;
#define MAXN 53
#define MAXP 110
#define MAXM 2010
using namespace std;
int F[MAXN][MAXP][MAXM],G[MAXM],ans;
int n,m,power[MAXN],cost[MAXN],can[MAXN],father[MAXN];
int o,head[MAXN];
struct edge{
     int to,next,w;
}e[MAXN];
void add(int x,int y,int w)
{   e[o].to=y;
    e[o].w=w;
    e[o].next=head[x];
    head[x]=o++;
}


void dfs(int p)
{
    if(head[p]==-1)
    {
        can[p]=min(can[p],m/cost[p]);
        for(int i=0;i<=can[p];i++)
            for(int j=i;j<=can[p];j++)
                F[p][i][j*cost[p]]=(j-i)*power[p];
        return ;
    }
    can[p]=1<<30;
    for(int i=head[p];~i;i=e[i].next)
        dfs(e[i].to),can[p]=min(can[p],can[e[i].to]/e[i].w);
    for(int i=0;i<=can[p];i++)
        F[p][i][0]=0;
    for(int i=head[p],v=e[i].to;~i;i=e[i].next,v=e[i].to)
        for(int j=0;j<=can[p];j++)
        {
            memcpy(G,F[p][j],sizeof(F[p][j]));
            memset(F[p][j],-1,sizeof(F[p][j]));
            for(int k=m;k>=0;k--)
            for(int r=k;r>=0;r--)
                    if(G[k-r]!=-1&&F[v][j*e[i].w][r]!=-1)
                        F[p][j][k]=max(F[p][j][k],G[k-r]+F[v][j*e[i].w][r]);


        }
    for(int i=0;i<=can[p];i++)
        for(int j=i;j<=can[p];j++)
            for(int k=0;k<=m;k++)
                if(F[p][j][k]!=-1)
                    F[p][i][k]=max(F[p][i][k],F[p][j][k]+(j-i)*power[p]);
}
void doit()
{   char type;
    memset(head,255,sizeof(head)); o=0;
    memset(father,0,sizeof(father));
    for(int i=1,p,a,b;i<=n;i++)
    {
        scanf("%d %c",&power[i],&type);
        if(type=='B')  scanf("%d %d",&cost[i],&can[i]);
        else
            for(scanf("%d",&p);p>=1;p--)
            {
                scanf("%d %d",&a,&b);
                add(i,a,b),father[a]=i;
            }
    }
    memset(F,-1,sizeof(F));
    int root;
    for(int i=1;i<=n;i++)
        if(father[i]==0)
            {dfs(i);root=i;}
    int ans=0;
    for (int k=0;k<=m;k++)
        ans=max(ans,F[root][0][k]);
    printf("%d\n",ans);
}
int main()
{   while (scanf("%d%d",&n,&m)!=EOF) doit();
}

//big 1017
//代码二
//http://vfleaking.blog.163.com/blog/static/17480763420130242646240/
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <vector>
#include <map>
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define zero(x) (fabs(x)<eps)
#define pi acos(-1.0)
#define f1 first
#define f2 second
const int inf=0x3f3f3f3f;
const long long INF=1LL<<50;
using namespace std;
typedef long long LL;
typedef pair <int,double> PII;
#define MAXN 53
#define MAXM 2010
using namespace std;
int f[MAXN][MAXM],g[MAXN][MAXM],tmp[MAXM];
int n,m,power[MAXN],cost[MAXN],can[MAXN],father[MAXN];
int o,head[MAXN];
struct edge{
     int to,next,w;
}e[MAXN];
void add(int x,int y,int w)
{   e[o].to=y;
    e[o].w=w;
    e[o].next=head[x];
    head[x]=o++;
}
bool relax(int &a,int b)
{
    if (b<=a) return 0;
    a=b;
    return 1;
}
bool relaxdp(int *a,int *b)
{
    bool re=0;
    for (int i=m-1;i>=0;i--)
        if (a[i]>0||i==0)
    for (int j=1;i+j<=m;j++)
        if (b[j]>0&&relax(a[i+j],a[i]+b[j]))
        re=1;
    int v=0;
    for (int i=0;i<=m;i++)
        {
            if (a[i]<=v) a[i]=0;
            else v=a[i];
        }
    return re;
}
void getinfo(int now)
{
    if (head[now]!=-1) {cost[now]=0;can[now]=MAXM;}
    for (int i=head[now];~i;i=e[i].next)
        {
            getinfo(e[i].to);
            can[now]=min(can[now],can[e[i].to]/e[i].w);
            cost[now]+=cost[e[i].to]*e[i].w;
        }
    can[now]=min(can[now],m/cost[now]);

}

void dfs(int now,int sum)
{   //printf("~%d\n",now);
    for (int i=head[now];~i;i=e[i].next)
        dfs(e[i].to,can[now]*e[i].w);
    int *cf=f[now],*cg=g[now];
    memset(tmp,0,sizeof(tmp));
    for (int i=head[now];~i;i=e[i].next)
    {   int v=e[i].to;
        relaxdp(tmp,f[v]);
        for (int j=0;j<e[i].w;j++)
            if (!relaxdp(cg,g[v])) break;
    }
    bool re=1;
    for (int i=can[now]-sum;i>=0;i--)
        {   int newcost=i*cost[now],newpower=i*power[now];
            //printf("%d %d\n",newcost,newpower);
            for (int j=newcost;j<=m;j++)
                 relax(cf[j],tmp[j-newcost]+newpower);
            if (re)
                re=relaxdp(tmp,cg);

        }
    if (cost[now]<=m)
        relax(cg[cost[now]],power[now]);
}
void doit()
{   char type;
    memset(head,255,sizeof(head)); o=0;
    memset(father,0,sizeof(father));
    for(int i=1,p,a,b;i<=n;i++)
    {
        scanf("%d %c",&power[i],&type);
        if(type=='B')  scanf("%d %d",&cost[i],&can[i]);
        else
            for(scanf("%d",&p);p>=1;p--)
            {
                scanf("%d %d",&a,&b);
                add(i,a,b),father[a]=i;
            }
    }
    memset(f,0,sizeof(f));
    memset(g,0,sizeof(g));
    int root;
    for(int i=1;i<=n;i++)
        if(father[i]==0)
            {root=i; break;}

    getinfo(root);
    dfs(root,0);
    int ans=0;

    for (int i=0;i<=m;i++)
        ans=max(ans,f[root][i]);
    printf("%d\n",ans);
}
int main()
{   while (scanf("%d%d",&n,&m)!=EOF) doit();
}

3522：该OJ将MLE判成TLE。开两个N2的int数组就200MB了。。所以要用set

//big 3522
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <vector>
#include <set>
#include <map>
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define zero(x) (fabs(x)<eps)
#define pi acos(-1.0)
#define f1 first
#define f2 second
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define initial 1,n,1
const int inf=0x3f3f3f3f;
const long long INF=1LL<<50;
using namespace std;
typedef long long LL;
typedef pair <int, int> PII;
template<typename X> inline bool minimize(X&p,X q){if(p<=q)return 0;p=q;return 1;}
template<typename X> inline bool maximize(X&p,X q){if(p>=q)return 0;p=q;return 1;}
#define N 5005
struct node{
    int id,c;
    node(){}
    node(int nid,int nc):id(nid),c(nc){}
    bool operator<(const node &oth)const{
        return id<oth.id;
    }
};
typedef int I[N];
typedef set<node> D;
typedef set<node>::iterator Di;
typedef set<node>::reverse_iterator Dj;
D son[N],son1[N],temp;
I Get_re;


int head[N],o,n,root;
LL ans;
struct edge{
    int to,next;
}e[N<<1];
void add(int x,int y)
{
    e[o].to=y;
    e[o].next=head[x];
    head[x]=o++;
}

//id always in[min_id,max_id]
//op==0+,op==1-
void SUM(D &a,D& b,int *V,int add_id,int min_id,int max_id,bool op)
{   node re;
    Di r;
    for (Di p=b.begin();p!=b.end();++p)
        {     re=*p;
              re.id+=add_id;
              if (re.id<min_id||re.id>max_id) continue;
              V[re.id]+=re.c*(op?-1:1);
              r=a.lower_bound(re);
              if (r==a.end())
                   {if (!op)if (re.c!=0) a.insert(node(re.id,+re.c));
                    if (op) if (-re.c!=0)a.insert(node(re.id,-re.c));
                   }
              else {
                    if ((*r).id==re.id)
                         {int yy=(*r).c;a.erase(r);
                          if (!op)if (yy+re.c!=0)a.insert(node(re.id,yy+re.c));
                          if (op) if (yy-re.c!=0)a.insert(node(re.id,yy-re.c));
                         }
                    else a.insert(re);
                   }
        }

}
void dfs1(int now,int fa)
{   for (int k=head[now];~k;k=e[k].next)
         {
             int v=e[k].to;
             if (v==fa) continue;
             dfs1(v,now);
             SUM(son[now],son[v],Get_re,1,0,n,0);
         }
    son[now].insert(node(0,1));
}
void dfs3(int now,int fa)
{   for (int k=head[now];~k;k=e[k].next)
         {
             int v=e[k].to;
             if (v==fa) continue;
             dfs3(v,now);
             memset(Get_re,0,sizeof(Get_re));
             SUM(son1[now],son1[v],Get_re,1,0,n,0);
             for (int i=0;i<N;i++)
                {if (Get_re[i]==0) continue;
                 node re=node(i,Get_re[i]);
                 Di r=son[now].lower_bound(re);
                 int tmp=Get_re[i],tmp2=(*r).c;
                 if (tmp>=2) ans-=LL(tmp)*(tmp-1)*(tmp2-tmp)/2;
                 if (tmp>=3) ans-=LL(tmp)*(tmp-1)*(tmp-2)/6;
                }
         }
    son1[now].insert(node(0,1));
}

void dfs2(int now,int fa)
{   for (int k=head[now];~k;k=e[k].next)
         {
             int v=e[k].to;
             if (v==fa) continue;
             temp=son[v];
             SUM(temp,son[v],Get_re,2,0,n,1);
             son[v]=temp;
             SUM(son[v],son[now],Get_re,1,0,n,0);
             dfs2(v,now);
         }
}
void dfs4(int now,int fa)
{   for (int k=head[now];~k;k=e[k].next)
         {
             int v=e[k].to;
             if (v==fa) continue;
             memset(Get_re,0,sizeof(Get_re));
             temp=son1[v];
             SUM(temp,son1[v],Get_re,2,0,n,1);
             son1[v]=temp;
             SUM(son1[v],son1[now],Get_re,1,0,n,0);
             for (int i=0;i<N;i++)
                {if (Get_re[i]==0) continue;
                 node re=node(i,Get_re[i]);
                 Di r=son[v].lower_bound(re);
                 int tmp=Get_re[i],tmp2=(*r).c;
                 if (tmp>=2) ans-=LL(tmp)*(tmp-1)*(tmp2-tmp)/2;
                 if (tmp>=3) ans-=LL(tmp)*(tmp-1)*(tmp-2)/6;
                }
             dfs4(v,now);
         }
}
void doit()
{   ans=0;
    memset(head,255,sizeof(head));o=0;
    for (int i=1;i<=n;i++)
         {
             son[i].clear();
             son1[i].clear();
         }
    for (int i=1,x,y;i<n;i++)
        {
            scanf("%d%d",&x,&y);
            add(x,y); add(y,x);
        }
    root=1;
    dfs1(root,-1);
    dfs2(root,-1);

    node re;
    for (int i=1;i<=n;i++){ //printf("i=%d\t\t",i);
    for (Di p=son[i].begin();p!=son[i].end();++p)
         {
             re=*p;
             LL x=LL(re.c);
             ans+=x*(x-1)*(x-2)/6;
             //printf("[%d %d]\n",re.id,re.c);
         }
         //printf("\n");
    }
    dfs3(root,-1);
    dfs4(root,-1);

    printf("%lld\n",ans);
}
int main()
{
    while (scanf("%d",&n)!=EOF) doit();
}
/*
7
1 2
5 7
2 5
2 3
5 6
4 5
*/