Codeforces Round #629 (Div. 3) DEF

最新推荐文章于 2024-09-27 11:17:47 发布
最新推荐文章于 2024-09-27 11:17:47 发布
阅读量102 收藏
点赞数
分类专栏： Codeforces Round 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43298454/article/details/105170001
版权

D. Carousel

题意：
给n个数染色，这n个数组成一个环，相邻不同数的颜色必须不同，问最少需要的颜色种类数和具体的染色方案。

题解：

·如果n个数都是相同的，那么只要选择一种颜色即可。
·如果n是偶数且n个数不全相同，那么只要按照121212…染色即可，因为相同的数可以不同颜色。
·如果n是奇数且n个数不全相同，那么只要寻找有没有a[k]=a[k+1]即可，如果有，那么，从1到k,k+1到n的染色顺序为1,2,1,2,…,1(k),1(k+1)，（或者2(k),2(k+1)，根据k奇偶判断),…1,2；如果没有，那么就需要三种元素，前n-1个元素是1,2,1,2…,1,2，最后一个元素为3，因为n为奇数，那么第1个元素和第n个元素按照之前的染色方法会染上相同颜色，不符合题意。

AC_CODE（和题解思路有点出入==因为过完才发现更简单的做法）：

/*
 * Author: lwktxdy
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define UFOR(I, A, B) for (int I = (A); I >= (B); --I)
#define UREPP(I, A, B) for (int I = (A); I > (B); --I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
string to_string(vector<bool> v) { bool first = true;string res = "{";for (int i = 0; i < static_cast<int>(v.size()); i++) {if (!first) {res += ", ";}first = false;res += to_string(v[i]);}res += "}";return res;}
template <size_t N> string to_string(bitset<N> v) {string res = "";for (size_t i = 0; i < N; i++) {res += static_cast<char>('0' + v[i]);}return res;}
template <typename A> string to_string(A v) {bool first = true;string res = "{";for (const auto &x : v) {if (!first) {res += ", ";}first = false;res += to_string(x);}res += "}";return res;}
template <typename A, typename B> string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";}
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 in freopen("in.txt","r",stdin);
#define out freopen("out.txt","w",stdout);
const ll mod = 998244353;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
LL C(LL n,LL m){if(m > n) return 0;LL ans = 1;FOR(i,1,m){LL a = (n + i - m) % mod;LL b = i % mod;ans = ans * (a * powmod(b, mod-2) % mod) % mod;}return ans;}
const int maxn = 4e6+5;

/*
struct node{
	
}k[maxn];
*/

void solve(){
	int n;
	R(n);
	VI v(n);
	set<int>s;
	REPP(i,0,n) R(v[i]), s.insert(v[i]);
	VI ans(n);
	ans[0] = 1;
	bool flag = 0;
	if(SZ(s) ==1) flag = 1;
	int a = 1;
	REPP(i,0,n-1){
		if(v[i] == v[i-1]) {
			ans[i] = a;
		} else {
			if(a == 1) a = 2;
			else a = 1;
			ans[i] = a;
		}
	}
	if(v[n-2] == v[0] && v[n-1] == v[0]) ans[n-1] = a;
	else if(v[n-2] != v[n-1] && v[n-1] != v[0] && v[n-2] != v[0]) {
		if(ans[n-2] == ans[0]) ans[n-1] = (a == 1 ? 2 : 1);
		else {
			bool pp = 0;
			for(int i=n-2; i>0; --i) {
				if(v[i] == v[i-1]) {
					ans[i] = (ans[i] == 1 ? 2 : 1);
					pp = 1;
					break;
				} else {
					ans[i] = (ans[i] == 1 ? 2 : 1);
				}
			}
			if(!pp) {
				ans[0] = (ans[0] == 1 ? 2 : 1);
				ans[n-1] = 3;
			} else {
				ans[n-1] = (ans[n-2] == 1 ? 2 : 1);
			}
		}
	}
	else if(v[n-2] != v[n-1] && v[n-2] == v[0]) {
		if(ans[0] == ans[n-2]) ans[n-1] = (a == 1 ? 2 : 1);
		else {
			bool ok = 0;
			for(int i=n-2; i>0; --i) {
				if(v[i] != v[i-1]) {
					if(ans[i] == 1) ans[i] = 2;
					else if(ans[i] == 2) ans[i] = 1;
				} else {
					if(ans[i] == 1) ans[i] = 2;
					else if(ans[i] == 2) ans[i] = 1;
					ok = 1;
					break;
				}
			}
			if(ok) ans[n-1] = (ans[n-2] == 1 ? 2 : 1);
			else ans[n-1] = 3, ans[0] = (ans[0] == 1 ? 2 : 1);
		}
	}
	else if(v[n-2] != v[n-1] && v[n-1] == v[0]) ans[n-1] = (a == 1 ? 2 : 1);
	else if(v[n-2] == v[n-1] && v[n-1] != v[0]) ans[n-1] = (ans[0] == 1 ? 2 : 1);
	if(flag) {
		W(1);
		W(VI(n,1));
		return;
	}
	else if(ans[n-1] == 3) W(3);
	else W(2);
	W(ans);
}

int main(){
	CASET{solve();}
	//solve();
}

E. Tree Queries

题意：
给定一颗顶点为1的树，有q组询问，每次询问给出k个顶点，询问在顶点出发的某一条链上，是否可以让这k个顶点到链的距离d<=1（即点可以在链上）。

题解：
要使这k个顶点到链的距离d<=1，那么这k个点（除了根节点）的父节点必定在同一条链上，dfs记录每个点的父节点，以及每个节点的入栈和出栈顺序，然后有两种判断方法：第一种是将这k个节点的父节点按照深度排序，那么在同一条链上的点，深度小的节点的入栈顺序一定小于深度大的入栈顺序，并且深度小的节点的出栈顺序一定大于深度大的节点。第二种是维护k个节点的父节点的入栈顺序最大值maxx以及出栈顺序最小值minn，当且仅当maxx <= minn才可保证所有节点处于同一链上。

AC_CODE:
1.

/*
 * Author: lwktxdy
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define UFOR(I, A, B) for (int I = (A); I >= (B); --I)
#define UREPP(I, A, B) for (int I = (A); I > (B); --I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
string to_string(vector<bool> v) { bool first = true;string res = "{";for (int i = 0; i < static_cast<int>(v.size()); i++) {if (!first) {res += ", ";}first = false;res += to_string(v[i]);}res += "}";return res;}
template <size_t N> string to_string(bitset<N> v) {string res = "";for (size_t i = 0; i < N; i++) {res += static_cast<char>('0' + v[i]);}return res;}
template <typename A> string to_string(A v) {bool first = true;string res = "{";for (const auto &x : v) {if (!first) {res += ", ";}first = false;res += to_string(x);}res += "}";return res;}
template <typename A, typename B> string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";}
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 in freopen("in.txt","r",stdin);
#define out freopen("out.txt","w",stdout);
const ll mod = 998244353;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
LL C(LL n,LL m){if(m > n) return 0;LL ans = 1;FOR(i,1,m){LL a = (n + i - m) % mod;LL b = i % mod;ans = ans * (a * powmod(b, mod-2) % mod) % mod;}return ans;}
const int maxn = 4e6+5;
char s[maxn];
int n,m,cnt;
VI v[maxn];
int pre[maxn], dep[maxn], ldf[maxn], rdf[maxn], q[maxn];
 
/*
struct node{
	
}k[maxn];
*/
 
void dfs(int u, int fa){
	dep[u] = dep[pre[u] = fa] + 1;
	ldf[u] = ++cnt;
	for(auto x: v[u]) {
		if(x != fa) dfs(x, u);
	}
	rdf[u] = cnt;
}
 
void solve(){
	R(n,m);
	FOR(i,1,n-1){
		int a,b;
		R(a,b);
		v[a].PB(b);
		v[b].PB(a);
	}
	dfs(1,0);
	while(m--){
		int k;
		R(k);
		FOR(i,1,k){
			int a;
			R(a);
			q[i] = (a == 1 ? 1 : pre[a]);
		}
		sort(q+1,q+1+k,[](int i, int j){return dep[i] < dep[j];});
		bool ok = 1;
		FOR(i,2,k){
			if(ldf[q[i]] < ldf[q[i-1]] || rdf[q[i]] > rdf[q[i-1]]) ok = 0;
		}
		if(ok) W("YES");
		else W("NO");
	}
}
 
int main(){
	//CASET{solve();}
	solve();
}

/*
 * Author: lwktxdy
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define UFOR(I, A, B) for (int I = (A); I >= (B); --I)
#define UREPP(I, A, B) for (int I = (A); I > (B); --I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
string to_string(vector<bool> v) { bool first = true;string res = "{";for (int i = 0; i < static_cast<int>(v.size()); i++) {if (!first) {res += ", ";}first = false;res += to_string(v[i]);}res += "}";return res;}
template <size_t N> string to_string(bitset<N> v) {string res = "";for (size_t i = 0; i < N; i++) {res += static_cast<char>('0' + v[i]);}return res;}
template <typename A> string to_string(A v) {bool first = true;string res = "{";for (const auto &x : v) {if (!first) {res += ", ";}first = false;res += to_string(x);}res += "}";return res;}
template <typename A, typename B> string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";}
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 in freopen("in.txt","r",stdin);
#define out freopen("out.txt","w",stdout);
const ll mod = 998244353;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
LL C(LL n,LL m){if(m > n) return 0;LL ans = 1;FOR(i,1,m){LL a = (n + i - m) % mod;LL b = i % mod;ans = ans * (a * powmod(b, mod-2) % mod) % mod;}return ans;}
const int maxn = 4e6+5;
char s[maxn];
int n,m,cnt;
VI v[maxn];
int pre[maxn], dep[maxn], ldf[maxn], rdf[maxn], q[maxn];
 
/*
struct node{
	
}k[maxn];
*/
 
void dfs(int u, int fa){
	dep[u] = dep[pre[u] = fa] + 1;
	ldf[u] = ++cnt;
	for(auto x: v[u]) {
		if(x != fa) dfs(x, u);
	}
	rdf[u] = cnt;
}
 
void solve(){
	R(n,m);
	FOR(i,1,n-1){
		int a,b;
		R(a,b);
		v[a].PB(b);
		v[b].PB(a);
	}
	dfs(1,0);
	while(m--){
		int k;
		R(k);
		int nx=1,mx=n;
		FOR(i,1,k){
			int a;
			R(a);
			q[i] = (a == 1 ? 1 : pre[a]);
			nx=max(nx,ldf[q[i]]);
			mx=min(mx,rdf[q[i]]);
		}
		if(nx<=mx) W("YES");
		else W("NO");
	}
}
 
int main(){
	//CASET{solve();}
	solve();
}

F. Make k Equal

题意：
给定一个数组，每次可以将数组最小的数+1或者最大的数-1，问最少需要多少次操作使得数组有k个数相等。

题解：
如果原数组已有k个或以上的数相等，直接输出0。否则，
设经过x次操作后数组有k个数相同，值为y，那么y一定是原数组中的某个数，（这个动手画一画就好了），将原数组排序，然后有三种情况：
·1到i-1个数全部转换成a[i]，再从中挑选(i-k)个数变成a[i]-1。
·i+1到n个数全部转换成a[i]，再从中挑选(n-k+1-i)个数变成a[i]+1。
·将1到i-1个数全部转换成a[i]，i+1到n个数全部转换成a[i]，然后去除(n-k)个数即可。

用前缀和记录前i个数转换成ai需要的步数，后缀和记录后i个数转换成ai需要的步数，然后按照上面步骤维护最小值即可。

AC_CODE：

/*
 * Author: lwktxdy
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define UFOR(I, A, B) for (int I = (A); I >= (B); --I)
#define UREPP(I, A, B) for (int I = (A); I > (B); --I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long ll,LL;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
string to_string(vector<bool> v) { bool first = true;string res = "{";for (int i = 0; i < static_cast<int>(v.size()); i++) {if (!first) {res += ", ";}first = false;res += to_string(v[i]);}res += "}";return res;}
template <size_t N> string to_string(bitset<N> v) {string res = "";for (size_t i = 0; i < N; i++) {res += static_cast<char>('0' + v[i]);}return res;}
template <typename A> string to_string(A v) {bool first = true;string res = "{";for (const auto &x : v) {if (!first) {res += ", ";}first = false;res += to_string(x);}res += "}";return res;}
template <typename A, typename B> string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";}
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 in freopen("in.txt","r",stdin);
#define out freopen("out.txt","w",stdout);
const ll mod = 998244353;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
LL C(LL n,LL m){if(m > n) return 0;LL ans = 1;FOR(i,1,m){LL a = (n + i - m) % mod;LL b = i % mod;ans = ans * (a * powmod(b, mod-2) % mod) % mod;}return ans;}
const int maxn = 4e6+5;
char s[maxn];
ll a[maxn];
ll f[maxn], g[maxn];
 
/*
struct node{
	
}k[maxn];
*/
 
void solve(){
	int n,k;
	R(n,k);
	FOR(i,1,n) R(a[i]);
	sort(a+1,a+1+n);
	{
		int num = 1;
		int maxx = 1;
		FOR(i,2,n){
			if(a[i] == a[i-1]) num += 1;
			else maxx = max(maxx, num), num = 1;
		}
		maxx = max(maxx, num);
		if(maxx >= k){
			W(0);
			return;
		}
	}
	FOR(i,1,n){
		f[i] = (i-1) * (a[i]-a[i-1]) + f[i-1];
	}
	for(int i=n; i>=1; --i){
		g[i] = (n-i) * (a[i+1]-a[i]) + g[i+1];
	}
	ll minn = 1LL<<60;
	FOR(i,k,n) minn = min(minn, f[i]-(i-k));
	for(int i=n-k+1; i>0; --i) minn = min(minn, g[i]-(n-k+1-i));
	FOR(i,1,n){
		minn = min(minn, f[i]+g[i]-(n-k));
	}
	W(minn);
}
 
int main(){
	//CASET{solve();}
	solve();
}
代不在‘
关注
专栏目录
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #693 (Div. 3)
qq_43461168的博客
01-14 241
A. Cards for Friends 题意：有一张 w*h 的卡片，现在要把这张卡片剪成不少于n片，如果w为偶数那么可以沿着w一分为二，如果h为偶数同理。 思路：只有偶数可以剪。对w和h单独考虑可以剪几次。剪一次，个数就乘以2。所以对w和h一直除2，答案一直乘2就行了。 AC代码： #include <iostream> #include <cstdio> #include <cstdlib> #include <iomanip> #include &lt
Codeforces Round #744 (Div. 3)
NEFU AB-IN's Blog
09-29 281
a,b,c,d,e1,e2(树状数组求逆序对)
Codeforces Round 874 (Div. 3)
qq_61657632的博客
05-20 313
因为左边全部数最后都要放在后面，所以如果继续往左边扩展，那么新扩展的数最后就会成为后面第一个数，如果不扩展最后面的第一个数就是最左边的第一个数a[1]所以我直接拿了set判定点左右邻居是否重复且是否存在两个确定的邻居，只要环里面的邻居有一个点没确定就直接把他给合并。我直接维护了每个点直接的个数，直接找i到i-m+1的区间是否合法，贡献就是这个区间的人数相乘。首先贪心的想，字典序最大，因为是排列，所以最大数只有一个，所以贪心先让最大的数排在前面。B 直接排序 小的对小的，大的对大的数。
Codeforces Round 940 (Div. 2) and CodeCraft-23补题题解(A-D)
ChuanhuaYu的博客
04-23 894
Codeforces Round 940 (Div. 2) and CodeCraft-23 （A~D题解-python）
Codeforces Round 968 (Div. 2) ABC题详细题解(C++,Python)
2401_83669813的博客
08-27 878
本文为Codeforces Round 968 (Div. 2)的ABC详细题解，包含C++,Python语言描述，觉得有帮助或者写的不错可以点个赞
Codeforces Round #585 (Div. 2)
31415926535x的博客
09-19 155
https://www.cnblogs.com/31415926535x/p/11553164.html 感觉很硬核啊这场，，越往后越做不动，，，emmmm，，，（这场是奔着最后一题 2sat 来的，，，上次学这玩意是在今年的3、4月份把，，，早忘得差不多了，，， A. Yellow Cards A题较简单，，贪心就行了，， #include <bits/stdc++.h> #def...
Codeforces Round 955 (Div. 2) (A~D) python
wyzkeyy的博客
06-26 520
用双端队列维护当前的牌，记录总点数，按顺序拿牌，每次能获胜则直接结束，否则若息小于l则继续拿，大于r则将，最前面的牌移出，直到空或者不再大于r，模拟该牌在之前被放弃的情况。每次可以使k*k的子矩阵同时加减任意数，只需计算每个子矩阵0，1的数量差，每次操作可使山的差距变化差值的整数倍。每次加到能整除k，然后除到不能整除为止，剩下不够加到能整除，x直接加上剩余k，打印答案。当存在一些差值的gcd是山总差值的因子时，则可经过多次固定的操作将山的总差值消除。要使两种山的高度和相同，只需要消除其总差值，
Codeforces Round #617 (Div. 3)
qq_15557181的专栏
02-08 146
前言 宅在家还是比较无聊的，所以想学着用用python，然后一搜适合python的online judge，发现codeforces居然正好支持，因为python复杂的功能数据结构还不会，所以先试试div3的题 A http://codeforces.com/contest/1296/problem/A 题目大意： 给你N个数字，并且允许你用其中出现的数字任意覆盖别的数字，问你能否使得所有数字的和...
Codeforces Round #655 (Div. 2) DEF
qq_26518655的博客
07-23 274
Codeforces Round #654 (Div. 2) DEF 文章目录Codeforces Round #654 (Div. 2) DEFD题目思路代码E题目思路代码F题目思路代码 D 题目 思路 只需要选择不选择相邻的就行了，最后可以形成(n+1)/2个数相加 延长两倍之后选择即可 代码 #include <iostream> #include <cstdio> #include <set> #include <list> #include &lt
Codeforces Round #673 (Div. 2) C. k-Amazing Numbers
ACkingdom的博客
09-28 570
题目链接 题意： 给你两个数n，k，求从1~n之间的每一个i在长度为n的数组中的，所有连续的长度为i的数组的公共最小值，如果没有重复值则输出-1. 思路： 遍历求每个相同的数之间的距离，即求出i到达几时这些数成为公共值，然后遍历所有求得的公共值，输出最小值即可。 代码： #include<bits/stdc++.h> #define int long long #define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); #def
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
Codeforces Round #629 (Div. 3) E.Tree Queries (DFS)
01-03
Codeforces Round #629 (Div. 3) E.Tree Queries (DFS) 思路：若ai 在路径上 ，则ai的父结点一定在路径上，若ai是路径上某个结点的子结点，则ai的父结点一定在路径上，综上只需考虑ai的父节点就行了。对每个ai判断...
Codeforces Round #629 (Div. 3) E – Tree Queries dfs序判祖先关系
01-20
标题中的"Codeforces Round #629 (Div. 3) E – Tree Queries dfs序判祖先关系"指的是一场编程竞赛中的问题，涉及到树结构的查询和深度优先搜索（DFS）来判断节点间的祖先关系。这个问题的目标是设计算法来确定在...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 394
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
最新发布
qq_42568323的博客
09-27 862
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 520
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
python 实现harmonic series调和级数算法
luthane的博客
09-24 912
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
codeforces round #828 (div. 3)
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值