ABC227 二分贪心 dp状态设计 枚举

D

二分，贪心

给$n$种东西的个数，要求每组都包含$k$个种类的的元素，问最多能分多少组？

$k=1e12$，显然二分。但是$check$有点难想。首先假设当前二分的组数是$m$，那一个种类的东西，最多给$m$个，分别分布在$m$组，再多就要有两个该种类的东西分配到同一组了，不符合要求。如果一个种类的个数$x<m$，那这$x$个也可以全部拿来用，把他们放在$x$个不同组就可以了。所以每个种类的东西可以贡献$min(m,a_i)$，最后看总数是否达到$m\ast k$就行了

void solve(void){
	int n,k;
	cin>>n>>k;
	vi a(n+1);
	rep(i,1,n){
		cin>>a[i];
	}
	
	int l=0,r=1e18;
	auto check=[&](int x)->bool{
		int sum=0;
		rep(i,1,n){
			sum+=min(a[i],x);
		}	
		return sum/x>=k;
	};
	while(l<=r){
		int m=l+r>>1;
		if(check(m))l=m+1;
		else r=m-1;
	}
	cout<<r;
}

E

dp状态设计

给一个只含三种字符的字符串，每次操作可以交换两个相邻字符，问操作不超过$k$次可以得到的不同字符个数？

$n=30$，因此可以考虑大胆一点的状态设计。首先注意到操作次数超过$n^2/2$次就变成任意字符，所以操作次数肯定不会超过$O(n^2)$，那么对于操作次数不超过$k$的这个约束，我们可以把操作次数加入状态。

接下来的问题是怎么维护，操作一定次数得到的新串个数这个问题。首先从原串操作得到新串不好想，可以考虑等价问题：哪些串操作一定次数可以得到原串。

那我们可以把当前前缀分别已经选择了多少个$K,E,Y$记录在状态里，然后假设下一个选$K$，那么从当前最后一个$K$，到下一个$K$之间的$E,Y$都要交换，举例来说就是$KEYK->KKEY$，想把第二个$K$作为当前的新加入的字符，需要把它移动到末尾，那么路途上经过的$E,Y$都需要一次交换，类似于冒泡排序的过程。

因此状态转移就是
$$dp(i+1,j,k,d+cost)+=dp(i,j,k,d)$$
$i,j,k分别表示三种字符目前的个数，d表示目前的操作次数$
$cost就是到下一个K之间的EY个数$

如果新加入的是$EY$也同理。这里需要维护三种字符出现次数的前缀和，用于计算区间内字符个数，以及一个下标数组，用于查找下一个字符的下标

最后$k$可能很大，但根据前面的分析，实际上交换次数不会超过$O(n^2)$，因此只用累加操作次数不超过$n^2$的答案

int dp[N][N][N][N*N];
void solve(void){
	string s;
	cin>>s;
	int n=s.size();
	s=' '+s;
	
	int k;
	cin>>k;
	
	vvi sum(3,vi(n+1));
	vvi pos(3);
	
	rep(i,1,n){
		if(s[i]=='K')sum[0][i]++,pos[0].push_back(i);
		else if(s[i]=='E')sum[1][i]++,pos[1].push_back(i);
		else sum[2][i]++,pos[2].push_back(i);
		
		rep(j,0,2){
			sum[j][i]+=sum[j][i-1];
		}
	}
	
	dp[0][0][0][0]=1;
	rep(a,0,pos[0].size()){
		rep(b,0,pos[1].size()){
			rep(c,0,pos[2].size()){
				rep(d,0,900){
					if(a<pos[0].size()){
						int p=pos[0][a];
						int cnt=max(0ll,sum[1][p]-b)+max(0ll,sum[2][p]-c);
						
						dp[a+1][b][c][d+cnt]+=dp[a][b][c][d];
					}
					if(b<pos[1].size()){
						int p=pos[1][b];
						int cnt=max(0ll,sum[0][p]-a)+max(0ll,sum[2][p]-c);
						
						dp[a][b+1][c][d+cnt]+=dp[a][b][c][d];
					}
					if(c<pos[2].size()){
						int p=pos[2][c];
						int cnt=max(0ll,sum[0][p]-a)+max(0ll,sum[1][p]-b);
						
						dp[a][b][c+1][d+cnt]+=dp[a][b][c][d];
					}
				}
			}
		}
	}
	int ans=0;
	rep(i,0,min(k,900ll)){
		ans+=dp[pos[0].size()][pos[1].size()][pos[2].size()][i];
	}
	cout<<ans;
}

F

枚举，dp

网格图只能往下往右走，一条路径的价值是路径中前k大的权值和，问路径最小价值？

网格图dp很简单，但这个前k大不好处理，我们不可能在dp过程中，维护到达当前点的所有方案的前k大元素。

注意到$n=30$很小，那么既然这个前k大不好处理，我们可以枚举第k大的值，这样走网格图的时候大于这个值的就必须选中，小于的就不选中，等于的可选可不选。然后要求是前k大的权值和，那最多选k个，dp数组增加一个维度记录已经选了几个。

这类似一个背包。每个东西的代价是1，选k个，问最小价值和。不同点在于背包每个东西都可选，我们可以以任意顺序遍历所有东西进行转移。但在网格图上我们只能在一条连续路径里选一些东西。

枚举第k大的值时，显然第k大肯定是网格图里已有的某个权值，枚举网格图中的元素即可。最后复杂度$O(n^5)$，其实$n=30$也提示了这个复杂度和做法

void solve(void){
	int n,m,k;
	cin>>n>>m>>k;
	
	
	vvi a(n+1,vi(m+1));
	rep(i,1,n){
		rep(j,1,m){
			cin>>a[i][j];
		}
	}
	
	auto cal=[&](int x)->int{
		vector<vvi>dp(n+1,vvi(m+1,vi(k+1,1e18)));
		
		dp[0][0][0]=dp[1][0][0]=dp[0][1][0]=0;
		rep(i,1,n){
			rep(j,1,m){
				if(a[i][j]>=x){
					rep(l,1,k){
						dp[i][j][l]=min(dp[i-1][j][l-1],dp[i][j-1][l-1])+a[i][j];
					}
				}
				if(a[i][j]<=x){
					rep(l,0,k){
						dp[i][j][l]=min({dp[i][j][l],dp[i-1][j][l],dp[i][j-1][l]});
					}
				}
			}
		}
		return dp[n][m][k];
	};
	
	int ans=1e18;
	rep(i,1,n){
		rep(j,1,m){
			ans=min(ans,cal(a[i][j]));
		}
	}
	cout<<ans;
}