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

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 +
4000
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;
}