牛客练习赛94D题解

相当于是一张n * inf的矩阵，第i行第j列值为ai * j，定义排列p1,p2,p3,...,pn的权值为各行上对应位置求和，问第k小排列的值。

场上暴力写了个二分答案+dfs判可行性，结果交上去t了。思考了一下加了一个剪枝，就过了。

场后发现自己的二分+dfs和标算的O(nk)跑的时间几乎一致，仔细分析了一下感觉自己的复杂度好像也是正确的。

二分+dfs+剪枝做法：

首先二分答案，然后dfs出有小于等于这个答案的方案数是否大于等于k。

显然暴力dfs，一种可行情况可能要dfs到第n + 1个位置（dfs完所有n个位置）才会统计，导致此时复杂度为(log(ans) * n * k)，会tle。

剪枝：将各行按照权值从小到大排序，则如果dfs到当前第x行，取一个第x行的元素就会超出二分的答案，则在此时就可并统计返回。考虑一下，这时我们往下dfs一个位置，能够保证一定产生额外的1个贡献，因此复杂度为(log(ans) * k), 可以ac

代码：

#include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define sc second
#define pb push_back
#define ll long long
#define trav(v,x) for(auto v:x)
#define all(x) (x).begin(), (x).end()
#define VI vector<int>
#define VLL vector<ll>
#define pll pair<ll, ll>
#define double long double
//#define int long long
using namespace std;
const int N = 1e6 + 100;
const int inf = 1e9;
//const ll inf = 1e18
const ll mod = 998244353;//1e9 + 7

#ifdef LOCAL
void debug_out(){cerr << endl;}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T)
{
	cerr << " " << to_string(H);
	debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif


int n, m;
int a[N];

int las;
ll lim;

void dfs(int x)
{
	if(las <= 0)
		return;
	if(x == n + 1 || lim < a[x])
	{
		--las;
		return;
	}
	for(ll val = 0; val <= lim; val += a[x])
	{
		lim -= val;
		dfs(x + 1);
		lim += val;
		if(las <= 0)
			return;
	}
}

bool chk(ll x)
{
	las = m;
	lim = x;
	dfs(1);
	if(las <= 0)
		return 1;
	return 0; 
}

void sol()
{
	cin >> n >> m;
//	n = 80, m = 1e6;
	for(int i = 1; i <= n; i++)
	{
	//	a[i] = rand() % (int)(1e6) + 1;
		cin >> a[i];
	}
	sort(a + 1, a + n + 1);
	ll l = 0, r = 1e12, mid, res = 1e12;
	while(l <= r)
	{
		mid = (l + r) / 2;
		if(chk(mid))
			res = mid, r = mid - 1;
		else l = mid + 1;
	}
	cout << res << '\n';
}

signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
//	int tt;
//	cin >> tt;
//	while(tt--)
		sol();
}

正解做法，维护n个单调队列，

每次找到n个队列队首最小元素（元素定义为一个排列），然后把这个元素第i行当前向右移动1的方案加入第i个单调队列的队尾，重复上述操作k次即可得到答案

复杂度为O（nk）