ABC391F题解

不加火车头（不吸氧）不开快读全部 long long 提交记录。

使用了我所知的三种优化后的提交记录（最慢点还是没有在一秒内跑过啊）。

做法非常的妙，我们先将 \(A,B,C\) 这三个数组降序排序，我们设 \(f(i,j,k) = A_iB_j+B_jC_k+C_kA_i\)，由于 \(f(i,j,k) \ge f(i+1,j,k),f(i,j,k) \ge f(i,j+1,k),f(i,j,k) \ge f(i,j,k+1)\)，我们想到了一种类似 bfs 的做法，因为 bfs 的正确性就在于每次取出的点一定是在某种意义上最小或最大的（根据题目决定大还是小），而我们这道题无法保证这一点，但是可以使用优先队列 priority_queue 来解决，同时它也满足 bfs 的一个性质：每次取出一个点，放入的点一定在某种意义上比它小或大（根据题目决定大还是小），所以我们可以使用 bfs 的做法，只需要把队列 queue 换成优先队列 priority_queue 即可。

时间复杂度：\(O(N \log N+K \log K)\)。\(O(N \log N)\) 是排序部分，\(O(K \log K)\) 指的是优先队列 priority_queue 中最多会出现 \(O(K)\) 个元素，然后优先队列 priority_queue 中插入删除复杂度为 \(O(\log K)\)。当然，此题还有不可忽视的 STL 常数，导致实际跑出来的结果时间方面没有那么理想，不过也因为我没有开火车头（不吸氧），粗暴地全开 long long，这样会导致程序常数增加，所以没法在一秒内跑过。

代码一号（优化前）：

#include<bits/stdc++.h>
using namespace std;
#define int long long 
const int N = 2e5+5;
struct node
{
	int v;
	int x;
	int y;
	int z;
	int operator<(const node&a)const
	{
		return v<a.v;
	}
};
priority_queue<node>q;
int a[N];
int b[N];
int c[N];
map<pair<pair<int,int>,int>,int>mp;
signed main()
{
	int n,k;
	scanf("%lld %lld",&n,&k);
	for(int i = 1;i<=n;i++)
	{
		scanf("%lld",&a[i]);
	}
	for(int i = 1;i<=n;i++)
	{
		scanf("%lld",&b[i]);
	}
	for(int i = 1;i<=n;i++)
	{
		scanf("%lld",&c[i]);
	}
	sort(a+1,a+n+1,greater<int>());
	sort(b+1,b+n+1,greater<int>());
	sort(c+1,c+n+1,greater<int>());
	q.push({a[1]*b[1]+a[1]*c[1]+b[1]*c[1],1,1,1});
	mp[{{1,1},1}] = 1;
	for(int i = 1;i<=k;i++)
	{
		int x = q.top().x,y = q.top().y,z = q.top().z,v = q.top().v;
		q.pop();
		if(i == k)
		{
			printf("%lld",v);
			return 0;
		}
		int ax = x+1,ay = y,az = z;
		int bx = x,by = y+1,bz = z;
		int cx = x,cy = y,cz = z+1; 
		if(ax<=n&&mp.find({{ax,ay},az}) == mp.end())
		{
			mp[{{ax,ay},az}] = 1;
			q.push({a[ax]*b[ay]+a[ax]*c[az]+b[ay]*c[az],ax,ay,az});
		}
		if(by<=n&&mp.find({{bx,by},bz}) == mp.end())
		{
			mp[{{bx,by},bz}] = 1;
			q.push({a[bx]*b[by]+a[bx]*c[bz]+b[by]*c[bz],bx,by,bz});
		}
		if(cz<=n&&mp.find({{cx,cy},cz}) == mp.end())
		{
			mp[{{cx,cy},cz}] = 1;
			q.push({a[cx]*b[cy]+a[cx]*c[cz]+b[cy]*c[cz],cx,cy,cz});
		}
	}
    return 0;
}

代码二号（优化后）：

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include<bits/stdc++.h>
using namespace std;
namespace fast_IO {
#define FASTIO
#define IOSIZE 100000
	char ibuf[IOSIZE], obuf[IOSIZE];
	char *p1 = ibuf, *p2 = ibuf, *p3 = obuf;
#ifdef ONLINE_JUDGE
#define getchar() ((p1==p2)and(p2=(p1=ibuf)+fread(ibuf,1,IOSIZE,stdin),p1==p2)?(EOF):(*p1++))
#define putchar(x) ((p3==obuf+IOSIZE)&&(fwrite(obuf,p3-obuf,1,stdout),p3=obuf),*p3++=x)
#endif//fread in OJ, stdio in local
	
#define isdigit(ch) (ch>47&&ch<58)
#define isspace(ch) (ch<33)
	template<typename T> inline T read() {
		T s = 0;
		int w = 1;
		char ch;
		while (ch = getchar(), !isdigit(ch) and (ch != EOF)) if (ch == '-') w = -1;
		if (ch == EOF) return false;
		while (isdigit(ch)) s = s * 10 + ch - 48, ch = getchar();
		return s * w;
	}
	template<typename T> inline bool read(T &s) {
		s = 0;
		int w = 1;
		char ch;
		while (ch = getchar(), !isdigit(ch) and (ch != EOF)) if (ch == '-') w = -1;
		if (ch == EOF) return false;
		while (isdigit(ch)) s = s * 10 + ch - 48, ch = getchar();
		return s *= w, true;
	}
	inline bool read(char &s) {
		while (s = getchar(), isspace(s));
		return true;
	}
	inline bool read(char *s) {
		char ch;
		while (ch = getchar(), isspace(ch));
		if (ch == EOF) return false;
		while (!isspace(ch)) *s++ = ch, ch = getchar();
		*s = '\000';
		return true;
	}
	template<typename T> inline void print(T x) {
		if (x < 0) putchar('-'), x = -x;
		if (x > 9) print(x / 10);
		putchar(x % 10 + 48);
	}
	inline void print(char x) {
		putchar(x);
	}
	inline void print(char *x) {
		while (*x) putchar(*x++);
	}
	inline void print(const char *x) {
		for (int i = 0; x[i]; ++i) putchar(x[i]);
	}
#ifdef _GLIBCXX_STRING
	inline bool read(std::string& s) {
		s = "";
		char ch;
		while (ch = getchar(), isspace(ch));
		if (ch == EOF) return false;
		while (!isspace(ch)) s += ch, ch = getchar();
		return true;
	}
	inline void print(std::string x) {
		for (int i = 0, n = x.size(); i < n; ++i)
			putchar(x[i]);
	}
#endif//string
	template<typename T, typename... T1> inline int read(T& a, T1&... other) {
		return read(a) + read(other...);
	}
	template<typename T, typename... T1> inline void print(T a, T1... other) {
		print(a);
		print(other...);
	}
	
	struct Fast_IO {
		~Fast_IO() {
			fwrite(obuf, p3 - obuf, 1, stdout);
		}
	} io;
	template<typename T> Fast_IO& operator >> (Fast_IO &io, T &b) {
		return read(b), io;
	}
	template<typename T> Fast_IO& operator << (Fast_IO &io, T b) {
		return print(b), io;
	}
#define cout io
#define cin io
#define endl '\n'
}
using namespace fast_IO;
const int N = 2e5+5;
struct node
{
	long long v;
	int x;
	int y;
	int z;
	int operator<(const node&a)const
	{
		return v<a.v;
	}
};
priority_queue<node>q;
long long a[N];
long long b[N];
long long c[N];
map<pair<pair<int,int>,int>,int>mp;
signed main()
{
	int n,k;
	cin >> n >> k;
	for(int i = 1;i<=n;i++)
	{
		cin >> a[i];
	}
	for(int i = 1;i<=n;i++)
	{
		cin >> b[i];
	}
	for(int i = 1;i<=n;i++)
	{
		cin >> c[i];
	}
	sort(a+1,a+n+1,greater<int>());
	sort(b+1,b+n+1,greater<int>());
	sort(c+1,c+n+1,greater<int>());
	q.push({a[1]*b[1]+a[1]*c[1]+b[1]*c[1],1,1,1});
	mp[{{1,1},1}] = 1;
	for(int i = 1;i<=k;i++)
	{
		int x = q.top().x,y = q.top().y,z = q.top().z;
		long long v = q.top().v;
		q.pop();
		if(i == k)
		{
			cout << v;
			return 0;
		}
		int ax = x+1,ay = y,az = z;
		int bx = x,by = y+1,bz = z;
		int cx = x,cy = y,cz = z+1; 
		if(ax<=n&&mp.find({{ax,ay},az}) == mp.end())
		{
			mp[{{ax,ay},az}] = 1;
			q.push({a[ax]*b[ay]+a[ax]*c[az]+b[ay]*c[az],ax,ay,az});
		}
		if(by<=n&&mp.find({{bx,by},bz}) == mp.end())
		{
			mp[{{bx,by},bz}] = 1;
			q.push({a[bx]*b[by]+a[bx]*c[bz]+b[by]*c[bz],bx,by,bz});
		}
		if(cz<=n&&mp.find({{cx,cy},cz}) == mp.end())
		{
			mp[{{cx,cy},cz}] = 1;
			q.push({a[cx]*b[cy]+a[cx]*c[cz]+b[cy]*c[cz],cx,cy,cz});
		}
	}
    return 0;
}

当然我相信再加上一些毒瘤优化后应该是能在一秒内跑过的。

代码看不懂或思路看不懂欢迎私信！

哦，忘了说了，我的洛谷号是 linjinkun。