DP&图论 DAY 2 下午 考试

Problem A
Problem Description
有一天 Tarzan 写了一篇文章，我们发现这文章当中一共出现了 n 个汉字，其中第 i 个汉
字出现了 ai 次，因为 Tarzan 不希望文章被别人偷看，他要给这 n 个字分别用一个特殊的字
符串表示，其中每一个字符串由两类字符组构成，一类是 a，另一类是 ha，例如 ahaha 就是
由 a、 ha 和 ha 构成的，我们希望帮助 Tarzan 给每个汉字一个独一无二的字符串，其中不能
存在两个字符串一个是另一个的前缀。我们同时希望文章尽量短，太长会把女神惹烦，文章
长度就是每一个汉字出现次数乘以对应字符串的长度之和，请输出最短的文章长度。
Input format
第一行一个整数 n 表示汉字数量。
第二行 n 个整数，分别表示每个汉字的出现次数。
Output format
一行一个整数表示最短的文章长度。

Examples

Constrains and Notes
对于 15% 的数据满足： n ≤ 15
对于 40% 的数据满足： n ≤ 100
对于 70% 的数据满足： n ≤ 400
对于 100% 的数据满足： 3 ≤ n ≤ 750; 1 ≤ ai ≤ 100000，数据保证存在一定的阶梯性

Solution

每个分配一个叶子（大雾）

最深的分配给出现次数最少的

一定是二叉树，否则不优

题目就是在这样一颗二叉树上选择n个没有祖先后代关系的结点（叶子结点），所需的最少层数，（ha是2层，a是1层），然后一个数组记录在最少层数的情况下文章的最小长度

为了最优，最浅的叶子要分配给出现次数最多的，最深的叶子分配给出现次数最多的

从根开始找：

dp[i][x][y][k]  当前到了第 i 层 ， i 层还有x个芽，i+1层有y个芽， 已经有k个填好了汉字，此时文章的最短长度

枚举 i 层有多少个叶子 ( 没有梦想，不想变成芽）p个

转移就是dp[i][x][y][k] = min( dp[i+1][x+y-p][x-p][k+p] + sum[n] - sum[k+p]）,

解释一下：

到了下一层i+1

i+1层的芽是x+y-p

i+1+1层的芽是x-p，因为此处我们就假设y不长了啊，然后可以变成芽的就只有x-p个

已经选好了k+p个汉字（叶子）

然后不断枚举叶子p是几个就好啦

其中sum[i]表示前 i 种汉字一共出现的次数

产生的贡献就是 k+p+1~n 这些后来的汉字提供的，因为一共n个点，选了k+p个点，已经完结了，还剩下k+p+1~n个点待处理，每个点都会经过这一层的边，所以会产生贡献

考虑优化一维度，计算每一层对答案的贡献

dp[x][y][k]  到了i层 , x本层的芽，y是下一层的芽，k是已经设置了k个叶子

dp[x][y][k] = min { dp[x+y-p][x-p][k+p] + sum[n] - sum[k+p] }

降维之后，考虑搞一搞p

我们可以一个叶子一个叶子的长，所以一次就只用考虑长一个叶子和不想长叶子两种情况

dp[x][y][k] 转移：

1.再长一个叶子  dp[x-1][y][k+1]

这里只是让x长了一个叶子，不考虑往下长芽，所以不计算代价

2.往下长芽  dp[x+y][x][k]+sum[n]-sum[k]

转移 O（1），一共有三维，所以复杂度O(n^3)

看一下zhhx的Solution：
? 首先我们设 dp[i][x][y][k] 表示当前到了第 i 层，这一层 x 个，
上一层 y 个，已经有 k 个结束了
? 转移的话就直接枚举一下， y 这一层有 p 个结束了即可，然
后算上结束的代价
? Time complexity O(N5) 到 O(N4 ∗ log(N))
? 我们考虑把第一维优化掉，我们设 dp[x][y][k] 表示最下方一
层 x 个，倒数第二层 y 个，结束了 k 个。
? 转移的时候就直接，枚举 y 这一层结束了 p 个，注意这里代
价不是每一个元素结束的时候记上了，我们在没往下一层
时，我们算一下这一层会产生的贡献。
? Time complexity O(N4)
? 我们再把转移优化掉。
? 我们就考虑每一次是把 y 减 1 表示，把倒数第二层一个元
素封上，还是把 y 个全部分叉转移到 dp[y][x+y][k]，加上这
一层的贡献即可。
? Time complexity O(N3) 滚动数组优化后 Space complexity
O(N2)

代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<map>
#include<cassert>
using namespace std;
const int N=755;
typedef unsigned int uint;
const uint inf=(1u<<31)-1;

uint n,a[N],sum[N];

bool cmp(uint x,uint y) {return x>y;}

uint dp[2][N][N];int r;

int main()
{

    freopen("A.in","r",stdin);
    freopen("A.out","w",stdout);

    scanf("%u",&n);
    //assert(3<=n && n<=750);

    for (int i=1;i<=n;i++) scanf("%u",&a[i]),assert(1<=a[i] && a[i]<=100000);

    sort(a+1,a+n+1,cmp);
    for (int i=1;i<=n;i++) sum[i]=sum[i-1]+a[i];

    for (int x=0;x<N;x++)
        for (int y=0;y<N;y++) dp[0][x][y]=dp[1][x][y]=inf;

    dp[r=0][0][0]=0;
    for (int k=n-1;k>=0;k--)
    {
        for (int y=n-k;y>=0;y--)
            for (int x=n-k-y;x>=0;x--)
            dp[r^1][x][y]=
            min(inf,x==0&&y==0?inf:
                min(
                y==0?inf:dp[r][x][y-1],
                x+y+y+k>n?inf:sum[n]-sum[k] + dp[r^1][y][x+y]
                )
            );

    /*    for (int x=0;x<=n-(k+1);x++)
            for (int y=0;y<=n-(k+1)-x;y++) dp[r][x][y]=inf;*/
        r^=1;
    }

    printf("%u\n",sum[n]+dp[r][1][1]);
    return 0;
}

Solution

首先这道题是数位 dp 的一般的形式：求区间 [n,m] 满足某些限
制的数字的数量是多少。条件一般与数的大小无关，而与数的组
成有关。
讲什么考什么！
而同时这是一个 C 进制的数位 dp。
对于% 30 的数据直接枚举每个数判断即可。

对于 10 进制，和二进制，是 C 进制的一种特殊情况。我们可以
来考虑 C 进制怎么做。
首先限制条件和数字和是有关系的，同时还可以注意到一个数的
数字和是很小的，那么就启发我们可以枚举这个数字和 sum 是
多少，然后考虑有多少数，它的数位和是 sum，且这个数对 sum
取模为 0，也就是这个数的 sum 的倍数。

按照数位 dp 的一般套路，我们就设 f[i][sum][rest] 表示到了第 i
位，之前的数位和是 sum，数字对枚举的和取模是 rest，考虑枚
举这位是多少假设为 x，最终的和为 S：
f[i][sum][rest]+ = f[i - 1][sum + x][(rest ∗ C + x)%S]

代码：

#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;

ll A,B;
int C;
int a[70],na,b[70],nb,p[70];

int mod;
ll f[70][400][400];

ll query(int *a,int i,int sum,int rest,bool o)
{
    if (sum<0) return 0;
    if (i==0) return sum==0&&rest==0 ? 1:0;

    if (!o&&f[i][sum][rest]!=-1) return f[i][sum][rest];
    ll ans=0;
    int up=o ? a[i] : C-1;

    for (int j=0;j<=up;j++)
    ans+=query(a,i-1,sum-j,(rest+mod-j*p[i]%mod)%mod,o&&j==up);
    if (!o) f[i][sum][rest]=ans;
    return ans;
}

int main()
{
    freopen("B.in","r",stdin);
    freopen("B.out","w",stdout);
    scanf("%lld%lld%lld",&B,&A,&C);

    B--;

    while (A) a[++na]=A%C,A/=C;
    while (B) b[++nb]=B%C,B/=C;

     //printf("na=%d\n",na);
    memset(f,-1,sizeof(f));

    ll ans=0;
    for (int i=1;i<=na*C;i++)
    {
        mod=i;
        p[1]=1;
        for (int j=2;j<=na;j++) p[j]=p[j-1]*C%mod;

        ans+=query(a,na,mod,0,true)-(nb==0 ? 0:query(b,nb,mod,0,true));

        for (int x=0;x<=na;x++)
            for (int y=0;y<=i;y++)
                for (int z=0;z<=mod;z++) f[x][y][z]=-1;
    }
    printf("%lld",ans);
    return 0;
}

Solution

% 20 和% 40 的数据
? 对于% 20 的数据，直接枚举每一个线段在哪一个包里面即
可。 Time complexity O(kn)
? 对于% 40 的数据， dfs 搜索每个线段在哪个包里面，根据写
法的优劣，可以得到最高 40 分的部分分，复杂度是和第二
类斯特林数相关。仅作了解能过即可。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
#include<cstdlib>
#include<queue>

using namespace std;

inline int read()
{
    int ans=0;
    char last=‘ ‘,ch=getchar();
    while(ch<‘0‘||ch>‘9‘) last=ch,ch=getchar();
    while(ch>=‘0‘&&ch<=‘9‘) ans=ans*10+ch-‘0‘,ch=getchar();
    if(last==‘-‘) ans=-ans;
    return ans;
}

int n,k,ans=0;
struct node
{
    int l,r,len;
}line[6005];

bool cmp(node x,node y) {return x.len >y.len ;}

int main()
{
    freopen("C.in","r",stdin);
    freopen("C.out","w",stdout);
    n=read();k=read();
    for(int i=1;i<=n;i++)
    {
        line[i].l=read();
        line[i].r =read();
        line[i].len =line[i].r-line[i].l ;
    }
    sort(line+1,line+n+1,cmp);
    for(int i=1;i<k;i++)
      ans+=line[i].len ;
    int l1 ,r1 ;
    for(int i=k;i<=n;i++)
    {
        if(i==k) l1=line[k].l ,r1=line[k].r ;
        else l1=max(l1,line[i].l),r1=min(r1,line[i].r);
    }
    if(r1-l1>0) ans+=(r1-l1);
    printf("%d\n",ans);

    return 0;
}

20 ’ Code

solution: % 70 的数据

观察性质！
? 首先最多只会有一组是空集。我们假设存在空集的话，就是
找前 K-1 长的算答案即可。再求剩余的 maxL 和 minR，即
可算出交集的大小。
? 假设没有空集的话。我们再观察一个性质，对于一个完全可
以包含另一个线段 B 的线段 A， A 肯定是要和 B 在一个组
的。放别的组，肯定不优。

不可能存在两个集合交集为空

如果存在一个集合交集为空，那么我们就单列出一些线段，直接取前 k-1长的线段就好

如果线段A包含B，那么A和B在一个集合结果一定不会差，因为A放到别的集合里会限制别的交集有一定限制，一定不会使得答案更优，

所以就只考虑不包含任何线段的线段，那么包含它的线段就和他放一起，答案不会更差

不包含任何线段的线段，按照左端点排个序，那么右端点也是递增的

（否则不就是包含了么）

solution: % 100 的数据

dp[i][j] = max(dp[x][j - 1] + R[x + 1]jR[x + 1] > L[i]) - L[i]
这就又来到了我们的可以单调队列优化的形式了，决策点在一个
区间之内，求最小值。
求出来这个之后，我们考虑我们选了多少集合，设为 p，则这种
情况的答案为： dp[n][p]+ 其他那些不在这 m 个线段集合的线段
的前 k-p 长的线段长度之和，然后枚举 p 取最优值即可。
总复杂度 O(n ∗ k)。

代码：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
using namespace std;
const int N=6006;
typedef long long ll;
const ll inf=5e13;

int n,m,k,len_n,r;

ll len[N],ans,dp[2][N];
struct aa
{
    int L,R;
}t1[N],t2[N];
bool cmp(aa a,aa b)
{
    if (a.R==b.R) return a.L>b.L;
    return a.R<b.R;
}

int q[N],H,T;

int main()
{

    freopen("C.in","r",stdin);
    freopen("C.out","w",stdout);
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++) scanf("%d%d",&t1[i].L,&t1[i].R),len[i]=t1[i].R-t1[i].L;

    sort(len+1,len+n+1);
    for (int i=0;i<k-1;i++) ans+=len[n-i];

    sort(t1+1,t1+n+1,cmp);

//    printf("ans=%lld\n",ans);

    memset(len,0,sizeof(len));
    int mx=0;
    for (int i=1;i<=n;i++)
    if (t1[i].L>mx)
    {
        t2[++m]=t1[i];
        mx=t1[i].L;
    }else len[++len_n]=t1[i].R-t1[i].L;

    sort(len+1,len+len_n+1,greater<ll>());
    for (int i=2;i<=n;i++) len[i]+=len[i-1];

    sort(t2+1,t2+m+1,cmp);

    r=1;

    for (int i=1;i<=m;i++)
    if (t2[1].R<=t2[i].L) dp[0][i]=-inf;else dp[0][i]=t2[1].R-t2[i].L;

    ans=max(ans,dp[0][m]+len[k-1]);

    for (int j=2;j<=min(k,m);j++,r^=1)
    {
        q[H=T=1]=1;dp[r][1]=-inf;
        for (int i=2;i<=m;i++)
        {
            while (H<=T&&t2[q[H]+1].R<=t2[i].L) H++;
            if (H<=T) dp[r][i]=dp[r^1][q[H]]+t2[q[H]+1].R-t2[i].L;else dp[r][i]=-inf;
            while (H<=T&&dp[r^1][i]+t2[i+1].R>=dp[r^1][q[T]]+t2[q[T]+1].R)  T--;
            q[++T]=i;
        }
        ans=max(ans,dp[r][m]+len[k-j]);
    }

    printf("%lld\n",ans);
    return 0;
}

原文地址：https://www.cnblogs.com/xiaoyezi-wink/p/11323447.html