Codeforces Round #433 (Div. 2, based on Olympiad of Metropolises)

于 2017-09-07 14:07:05 发布
阅读量175 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： codeforces、
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sasuke__/article/details/77880486

A

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 1e6 + 10;
const int INF = 1e9 + 10;
int Gcd(int a, int b) {
	return b == 0 ? a : Gcd(b, a % b);
}

int main(){
	int n;	scanf("%d", &n);
	bool f = false;
	int a, b;
	for(int i = 0; i <= n; ++i) {
		for(int j = i; j <= n; ++j) {
			if(Gcd(i, j) != 1)	continue;
			if(j == 0)	continue;
			if(i + j == n) {
				if(!f) {
					f = true;
					a = i, b = j;
				} else {
					if(a * j < b * i) {
						a = i, b = j;
					}
				}
			}
		}
	}
	if(a > b)	swap(a, b);
	printf("%d %d\n", a, b);
	return 0;
}


B

题意：n个房子，其中k间房已经住了人，good房间的定义两点，第一点这个房子是空房子，第二点相邻房间至少有一个住了人，k间已经可以住人房间可以任意，问最少和最多有多少间good房子

思路：最少答案要么0要么1， 最多的话可以知道 0 1 0 0 1 0，这样的是在k较少的情况下最多的，这个情况填完后每多一个已经住人的房子，相应的good房就会少一个

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 1e6 + 10;
const int INF = 1e9 + 10;
LL n, k;

int main(){
	scanf("%lld%lld", &n, &k);
	if(n == k || k == 0 || n == 1) {
		printf("0 0\n");
		return 0;
	}
	if(k <= n / 3) {
		printf("1 %lld\n", k * 2);
	} else {
		printf("1 %lld\n", n - k);
	}
	return 0;
}


C

题意：n个航班，原本n个飞机都是在1到n顺序时间点出发，但由于某些原因所有航班延误了k分钟，也就是说得在k + 1 到 k + n 起飞每架飞机，每架飞机有一个延误权值，每延误一分钟对应会增加相应权值，最后求所有飞机权值和最小，延误后的飞机起飞还有条件，就是起飞时间不能低于原本计划的起飞时间，比如原计划第5分钟飞的飞机在新计划中得5分钟以后起飞（包括第5分钟）

思路：用一个堆去维护前i分钟能起飞的飞机，每次取出权值最大的使他起飞即可

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 1e6 + 10;
const int INF = 1e9 + 10;
struct Node {
	LL t;
	int id;
	bool operator < (const Node &w) const {
		return t < w.t;
	}
}p[qq], tmp;
priority_queue<Node> Q;
LL n, k;
LL ans[qq];

int main(){
	scanf("%lld%lld", &n, &k);
	LL sum = 0;
	for(int i = 1; i <= n; ++i) {
		scanf("%lld", &p[i].t);
		sum += p[i].t;
		p[i].id = i;
	}
	for(int i = 1; i <= k; ++i) {
		Q.push(p[i]);
	}
	LL tot = 0;
	for(int i = k + 1; i <= n; ++i) {
		Q.push(p[i]);
		tmp = Q.top();
		Q.pop();
		ans[tmp.id] = i;
		tot += (LL)(i - tmp.id) * tmp.t;
	}
	for(int i = n + 1; i <= n + k; ++i) {
		tmp = Q.top();
		Q.pop();
		ans[tmp.id] = i;
		tot += (LL)(i - tmp.id) * tmp.t;
	}
	printf("%lld\n", tot);
	for(int i = 1; i <= n; ++i) {
		printf("%lld ", ans[i]);
	}
	puts("");
	return 0;
}


D

题意：这题意很长阿，大致就是这样 n个人去 0 点参加会议，这n个人分布在1 - n中的城市，且一个人仅在一个城市，现在有m个起飞航班和离开航班，所有航班要么从0起飞，要么到达0，现在要求把n个人聚在0点要停留k天，从人到齐的第二天开始算，要准确的停留k天之后才能走，现在问满足n个人能来 0 这个点停留k天并能回去的最小花费。

注意到达那天和离开那天都不能算是停留的天数

思路：用两个数组维护，dpcm[i]代表第i天人全部到齐的最小花费，dpbk[i]代表第i天开始陆续有人离开(并且最终能全部离开)的最小花费，那么很显然答案就是dpcm[i] + dp[i + k + 1]的最小值

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 1e6 + 10;
const LL INF = 1e18 + 10;
struct Node {
	int d, x, cost;
	Node(){}
	Node(int _d, int _x, int _cost) : d(_d), x(_x), cost(_cost){}
	bool operator < (const Node &w) const {
		if(d == w.d)	return cost > w.cost;
		return d > w.d;
	}
}come[qq], back[qq];
int n, m, k;
LL dpcm[qq], dpbk[qq];
int c[qq];
bool cmp1(const Node &a, const Node &b) {
	if(a.d == b.d)	return a.cost < b.cost;
	return a.d < b.d;
}
bool cmp2(const Node &a, const Node &b) {
	if(a.d == b.d)	return a.cost < b.cost;
	return a.d > b.d;
}
int main(){
	scanf("%d%d%d", &n, &m, &k);
	for(int i = 1; i < qq; ++i) {
		dpcm[i] = dpbk[i] = INF;
	}
	int t1, t2;
	t1 = t2 = 0;
	int di, fi, ti, ci;
	for(int i = 0; i < m; ++i) {
		scanf("%d%d%d%d", &di, &fi, &ti, &ci);
		if(fi == 0)	back[t2++] = Node(di, ti, ci);
		else	come[t1++] = Node(di, fi, ci);
	}
	int kind = 0;
	LL sum = 0;
	sort(come, come + t1, cmp1);
	mst(c, -1);
	for(int i = 0; i < t1; ++i) {
		if(c[come[i].x] == -1) {
			sum += come[i].cost;
			c[come[i].x] = come[i].cost;
			++kind;
		} else if(c[come[i].x] > come[i].cost){
				sum += (come[i].cost - c[come[i].x]);
				c[come[i].x] = come[i].cost;
		}
		if(kind == n)	dpcm[come[i].d] = min(dpcm[come[i].d], sum);
	}
	sort(back, back + t2, cmp2);
	sum = 0, kind = 0;
	mst(c, -1);
	for(int i = 0; i < t2; ++i) {
		if(c[back[i].x] == -1) {
			sum += back[i].cost;
			c[back[i].x] = back[i].cost;
			++kind;
		} else if(c[back[i].x] > back[i].cost) {
			sum += (back[i].cost - c[back[i].x]);
			c[back[i].x] = back[i].cost;
		}
		if(kind == n)	dpbk[back[i].d] = min(dpbk[back[i].d], sum);
	}
	for(int i = 2; i < qq - 1; ++i) {
		dpcm[i] = min(dpcm[i], dpcm[i - 1]);
	}
	for(int i = qq - 2; i >= 0; --i) {
		dpbk[i] = min(dpbk[i], dpbk[i + 1]);
	}
	LL ans = INF;
	for(int i = 1; i < qq - k - 1; ++i) {
		ans = min(ans, dpcm[i] + dpbk[i + k + 1]);
	}
	if(ans == INF)	ans = -1;
	printf("%lld\n", ans);
	return 0;
}


之前一直以为是求n个在0人只要待k天即可.....

代码是这样的

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 1e6 + 10;
const int INF = 1e9 + 10;
struct Node {
	LL x;
	LL cost;
	bool operator < (const Node &w) {
		return x < w.x;
	}
}p[qq], tmp;
vector<Node> come[qq], back[qq];
int n, m, k;
bool f;
LL sum;
void Judge(int u) {
	sort(come[u].begin(), come[u].end());
	sort(back[u].begin(), back[u].end());
	int i = come[u].size(), j = back[u].size();
	if(i == 0 || j == 0) {
		f = false;
		return;
	}
	LL minx = 1e18;
	i--, j--;
	set<LL> mp;
	LL l, r;
	while(i >= 0) {
		while(j >= 0 && come[u][i].x + k + 1 <= back[u][j].x) {
			mp.insert(back[u][j].cost);
			--j;
		}
		if(mp.size() > 0) {
			minx = min(minx, come[u][i].cost + *(mp.begin()));
		}
		--i;
	}
	mp.clear();
	if(minx == 1e18) {
		f = false;
		return;
	}
	printf("%lld\n", minx);
	sum += minx;
}

int main(){
	sum = 0;
	scanf("%d%d%d", &n, &m, &k);
	LL di, fi, ti, ci;
	for(int i = 1; i <= m; ++i) {
		scanf("%lld%lld%lld%lld", &di, &fi, &ti, &ci);
		tmp.x = di, tmp.cost = ci;
		if(fi == 0)	back[ti].pb(tmp);
		else if(ti == 0)	come[fi].pb(tmp);
	}
	f = true;
	for(int i = 1; i <= n; ++i) {
		Judge(i);
		if(!f)	break;
	}
	if(!f)	puts("-1");
	else	printf("%lld\n", sum);
	return 0;
}


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值