Codeforces Round #570 (Div. 3) (F.暴力+剪枝/(思维+特判)+H.子序列dp)

心得

莫名感觉F题比别的题难好多好多……

H题当时写出来了，别人的代码看不懂，

自己是根据写过的一个FZU的子序列的题魔改的

F.Topforces Strikes Back

q(q<=2e5)个询问，每次询问给你n(1<=n<=2e5)个数

第i个数ai(2<=ai<=1e5)，让你从中挑出一个集合，集合内包括最多三个数，

挑出的数彼此直接不能整除，即没有任意一个是任意另一个的倍数

求集合内的数的最大和

参考代码(维护答案集set<int>x)

#include <bits/stdc++.h>
using namespace std;
#define re return
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define make_unique(x) sort(all(x)),x.resize(unique(all(x))-x.begin())
#define fi first
#define se second
#define ss second.second
#define sf second.first
#define ff first.first
#define fs first.second
#define sqrt(x) sqrt(abs(x))
#define mp make_pair
#define PI 3.14159265358979323846
#define E 2.71828182845904523536
#define er erase
#define in insert
#define fo(i,n) for((i)=0;(i)<(n);(i)++)
#define ro(i,n) for((i)=n-1;(i)>=0;(i)--)
#define fr(i,j,n) for((i)=(j);(i)<(n);(i)++)
#define rf(i,j,n) for((i)=((n)-1);(i)>=(j);(i)--)
//template <class T> using _tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> ii;
typedef vector<ii> vii;
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
    const int N=(int)1e6+100;
#define filename ""
int main()
{
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    srand(time(0));
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t,n,i,a;
    cin>>t;
    while(t--)
    {
        cin>>n;
        set<int> m;
        fo(i,n)
        {
            cin>>a;
            m.in(a);
        }
        int ans=0;
        set<int> x;
        for(set<int>::reverse_iterator j=m.rbegin();j!=m.rend();j++)
        {
            bool d=1;
            for(auto q:x)
            {
                if ((*j)%q==0||q%(*j)==0)
                {
                    d=0;
                    break;
                }
            }
            if (!d) continue;
            x.in(*j);
            ans+=*j;
            if (x.size()==3) break;
        }
        for(auto c:m)
        {
            if (c%2==0&&c%3==0&&c%5==0&&m.count(c/2)&&m.count(c/3)&&m.count(c/5))
            {
                ans=max(ans,c/2+c/3+c/5);
            }
        }
        cout<<ans<<'\n';
    }
}

题解

排序，去重，倒序处理

注意找到第一个最大的数ai之后，如果能找到不能被其整除的最大的数aj，同理aj的条件下找到ak

那么(ai,aj,ak)在绝大多数情况下是最大的，

①考虑只取一个数，那么ai是最大；

②如果取两个数，ai和aj，那么如果存在al和am都在ai后面且和比ai+aj大的话

前提是al和am都能被ai整除，那么al<=ai/2，am<al<=ai/3，矛盾

③如果取三个数，那么如果存在an,ap,aq比ai+aj+ak大的话

由于an<=ai/2，ap<=ai/3，aq<=ai/5(aq也不能被an整除 所以不能是ai/4)

故最大情况an=ai/2,ap=ai/3,aq=ai/5，其三者之和大于ai，所以是有可能的

考虑样例3000 1500 1000 600 11 7的情形，就不是(3000,11,7)最大，而是(1500,1000,600)

这种情况留到最后特判即可，先把最大三元组的ans更新，再更新这种情况

由于对于ai来讲去重后最多有logai个数能被其整除，所以复杂度应该是O(logai*logaj+nlogn)的

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
int n,q,a[maxn];
map<int,int>cnt; 
int ans;
bool ok;
int main()
{
	scanf("%d",&q);
	while(q--)
	{
		cnt.clear();
		ans=0;
		ok=0;
		scanf("%d",&n);
		for(int i=1;i<=n;++i)
		{
			scanf("%d",&a[i]);
			cnt[a[i]]++;
		}
		sort(a+1,a+n+1,greater<int>());
		n=unique(a+1,a+n+1)-(a+1);
		for(int i=1;i<=n&&!ok;++i)
		{
			ans=max(ans,a[i]);
			for(int j=i+1;j<=n&&!ok;++j)
			{
				if(a[i]%a[j]==0)continue;
				ans=max(ans,a[i]+a[j]);
				for(int k=j+1;k<=n&&!ok;++k)
				{
					if(a[i]%a[k]==0)continue;
					if(a[j]%a[k]==0)continue;
					ans=max(ans,a[i]+a[j]+a[k]);
					ok=1;
				}
			}
		}
		for(auto p:cnt)
		{
			int v=p.first;
			if(v%2==0&&v%3==0&&v%5==0&&cnt.count(v/2)&&cnt.count(v/3)&&cnt.count(v/5))
			ans=max(ans,v/2+v/3+v/5); 
		}
		printf("%d\n",ans);
	}
	return 0;
} 

另有，三层for循环+当前答案小于ans就break的剪枝作法，复杂度很难说

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+10;
int n,q,a[maxn];
int ans;
bool ok;
int main()
{
	scanf("%d",&q);
	while(q--)
	{
		ans=0;
		ok=0;
		scanf("%d",&n);
		for(int i=1;i<=n;++i)
		scanf("%d",&a[i]);
		sort(a+1,a+n+1,greater<int>());
		n=unique(a+1,a+n+1)-(a+1);
		for(int i=1;i<=n;++i)
		{
			ans=max(ans,a[i]);
			for(int j=i+1;j<=n;++j)
			{
				if(a[i]%a[j]==0)continue;
				ans=max(ans,a[i]+a[j]);
				if(j+1<=n&&a[i]+a[j]+a[j+1]<ans)break;
				for(int k=j+1;k<=n;++k)
				{
					if(a[i]%a[k]==0)continue;
					if(a[j]%a[k]==0)continue;
					if(a[i]+a[j]+a[k]<ans)break;
					ans=max(ans,a[i]+a[j]+a[k]);
				}
			}
		}
		printf("%d\n",ans);
	}
	return 0;
} 

H - Subsequences (hard version)

一个长度为n(n<=100)的字符串，要求你取出k(1<=k<=1e12)个不同的子序列

取出一个长度为len的子序列的代价为n-len，要求最小化代价，输出代价

如果子序列总个数不足k，输出-1

题解

瞎搞搞过去了，总结一下

dp[i][j]表示前i个字母长度为j的子序列总个数，last[a]表示a所代表字母上一次出现的位置

①如果a这个字母新出现的，那么dp[i][j]=dp[i-1][j]+dp[i-1][j-1]，

继承上一个字母的dp[i-1][j]，从j-1后补一个得j，

还多了一个单个字母的子序列，dp[i][1]++;

②如果a这个字母上次在last[a]出现过，那么dp[i][j]=dp[i-1][j]+dp[i-1][j-1]-dp[last[s[i]]-1][j-1]

减去重复的，因为在last[s[i]]处补a这个字母产生的dp[last[s[i]]-1][j-1]种方案，在dp[last[s[i]][j]那里已经计算过，减去

dp[i][1]不加，之前有过

由于允许串长为空，所以dp[len][1]=1；

统计时，挑cost小的先统计

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[105][105],n,k;
char s[105];
int last[26],len,v;
ll cost;
int main()
{ 
	scanf("%I64d%I64d",&n,&k);
	scanf("%s",s+1);
	len=strlen(s+1);
	for(int i=1;i<=len;++i)
	{
		v=s[i]-'a';
		if(!last[v])
		{
			for(int j=1;j<=i;++j)
			{
				dp[i][j]=dp[i-1][j];
				dp[i][j]+=dp[i-1][j-1];
			}
			dp[i][1]++;
		}
		else
		{
			for(int j=1;j<=i;++j)
			{
				dp[i][j]=dp[i-1][j];
				dp[i][j]+=dp[i-1][j-1];
				dp[i][j]-=dp[last[v]-1][j-1];
			}
		}
		last[v]=i;
	}
	dp[len][0]=1;//空串 
	for(int i=len;i>=0;--i)
	{
		if(!dp[len][i])continue;
		if(k>=dp[len][i])
		{
			cost+=dp[len][i]*(len-i);
			k-=dp[len][i];
			
		}
		else
		{
			cost+=k*(len-i);
			k=0;
			break;
		}
	}
	if(!k)printf("%I64d\n",cost);
	else puts("-1");
	return 0;
}