topcoder srm 684 div1 -3

最新推荐文章于 2019-01-08 08:40:16 发布

转载最新推荐文章于 2019-01-08 08:40:16 发布 · 78 阅读

本文探讨了两个复杂的算法问题：一是从给定整数集合中找出最大的good子集，通过动态规划解决；二是构造满足特定条件的数列，采用容斥原理与动态规划结合的方法。文章提供了详细的思路解析与代码实现。

1、一个整数集合$S$满足如下条件时称为good：（1）首先由$S$中任意两个元素的差的绝对值得到新的集合$D$；（2）$D$中的任意两个元素$x,y$满足$x\leq k*y$。现在给定$k$以及整数集合$P$，选出一个$P$的子集$S$，使得$S$是good且$S$中的元素尽量多。

思路：首先由$P$中任意两元素的绝对值得到集合$Q$。然后枚举$Q$中的每个元素作为集合$D$中的最大值$Max$，这样就能确定最后集合$D$中的最小值要大于等于$Min=\frac{Max+k-1}{k}$。然后再枚举$S$中元素的最小值即可依次从小到大确定$S$中的所有值。因为假设$S$中最小的元素是$x$，且当前最大元素是$y$，那么对于一个元素$z，z>y$,要么不选它；如果要选进来就要满足$z-x\leq Max$且$z-y\geq Min$。这样可以用一个简单的dp来解决。

#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <stack>
using namespace std;

int a[55];
int K;
int n;

int f[55][55];

int cal(const int Max)
{
    const int Min=(Max+K-1)/K;

    int ans=0;
    for(int k=1;k<=n;++k)
    {
        memset(f,-1,sizeof(f));
        f[k][k]=1;
        for(int i=k+1;i<=n;++i)
        {
            for(int j=k;j<=i-1;++j)
            {
                f[i][j]=f[i-1][j];
                if(f[i-1][j]!=-1&&a[i]-a[j]>=Min&&a[i]-a[k]<=Max)
                {
                    f[i][i]=max(f[i][i],f[i-1][j]+1);
                }
            }
        }
        for(int i=k;i<=n;++i) ans=max(ans,f[n][i]);
    }
    return ans;
}

class CliqueParty
{
public:
	int maxsize(vector<int> A,int k)
	{
	    K=k;
	    n=(int)A.size();
	    for(int i=1;i<=n;++i) a[i]=A[i-1];

        sort(a+1,a+n+1);

        A.clear();
        for(int i=1;i<=n;++i) for(int j=i+1;j<=n;++j) A.push_back(a[j]-a[i]);
        sort(A.begin(),A.end());
        int ans=0;
        for(int i=0;i<(int)A.size();++i)
        {
            if(i==0||A[i]!=A[i-1]) ans=max(ans,cal(A[i]));
        }
        return ans;
	}
};

2、构造一个长度为$n$的数列$A$，满足：（1）$1\leq A_{i} \leq k$ （2）任意两个相邻元素满足$A_{i}\leq A_{i+1} $或者$A_{i}$%$A_{i+1} \neq 0$.给定$n,k$，问这样的数列有多少？$1 \leq n,k \leq 50000$

思路：设$s_{i}$表示连续$i$个元素任意两个相邻元素$x,y$满足$x>y$且$x$%$y$=0的方案数。$s$数组可以通过简单的dp来计算得到。

$f_{x}$表示长度为$x$的数组$A$的方案数。答案为$f_{n}$。$f_{0}=1$,$f_{t}=\sum_{r=1}^{t}f_{t-r}s_{r}(-1)^{r+1}=f_{t-1}s_{1}-f_{t-2}s_{2}+f_{t-3}s_{3}...$.其中$s_{1}=k$。

这个容斥可以这样理解：首先不理会$A_{n-1}$和$A_{n}$的关系，那么$A_{n}$有$s_{1}=k$种选择，所以$f_{n}=f_{n-1}s_{1}$。这样会导致$f_{n-1},f_{n}$不满足第二个条件，那么$f_{n-2}s_{2}$包含了所有的这种情况，同时$f_{n-2}s_{2}$还包含了$f_{n-2}$和$f_{n-1}$不满足第二个条件的情况，所以减去$f_{n-2}s_{2}$然后继续向后计算。

由于$k$最多只有$50000$，那么最多只会出现连续 16个数字是倍数关系，也就是说当$r>16$时$s_{r}=0$。所以$f_{t}=\sum_{r=1}^{min(t,16)}f_{t-r}s_{r}(-1)^{r+1}$

#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <stack>
using namespace std;

const int N=50005;
const int mod=1000000007;


void add(int &x,int y)
{
    x+=y;
    if(x>=mod) x-=mod;
}

int f[17][N],s[N];
int dp[N];

class DivFree
{
public:
	int dfcount(int n,int k)
	{
	    for(int i=1;i<=k;++i) f[1][i]=1;
	    s[1]=k;
	    for(int i=2;i<=16;++i)
        {
            for(int j=1;j<=k;++j) for(int t=j+j;t<=k;t+=j)
            {
                add(f[i][t],f[i-1][j]);
            }
            for(int j=1;j<=k;++j) add(s[i],f[i][j]);
        }
        dp[0]=1;
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=16&&j<=i;++j)
            {
                if(j&1) add(dp[i],(long long)dp[i-j]*s[j]%mod);
                else add(dp[i],mod-(long long)dp[i-j]*s[j]%mod);
            }
        }
        return dp[n];
	}
};