oj.uz

Submission #550377

# Submission time Handle Problem Language Result Execution time Memory
550377 2022-04-18T01:43:46 Z LucaDantas Long Distance Coach (JOI17_coach) C++17
0 / 100
 1 ms 340 KB 
#include <bits/stdc++.h>
using namespace std;

/* struct Line {
	long long a, b;
	Line(long long _a, long long _b) : a(_a), b(_b) {}
	bool operator <(const Line& o) const { return a > o.a; }
	long long eval(long long x) const { return a*x + b; }
};

// queries are decreasing so we can always query the last value
struct CHT : multiset<Line> {
	bool hasNext(multiset<Line>::iterator it) { return next(it) != this->end(); }
	bool hasPrev(multiset<Line>::iterator it) { return it != this->begin(); }
	long double intersect(Line x, Line y) { return ((long double)(x.a-y.a)) / (y.b-x.b); }
	bool bad(Line a, Line b, Line c) { return intersect(a, c) <= intersect(a, b); }
	
	void add(Line l) {
		auto it = this->lower_bound(l);
		if(it != this->end() && it->a == l.a) {
			if(it->b < l.b) return;
			this->erase(it);
		}

		it = this->insert(l);
		
		if(hasNext(it) && hasPrev(it) && bad(*prev(it), *it, *next(it)))
			return (void)(this->erase(it));
		
		while(hasNext(it) && hasNext(next(it)) && bad(*it, *next(it), *next(next(it))))
			this->erase(next(it));

		while(hasPrev(it) && hasPrev(prev(it)) && bad(*prev(prev(it)), *prev(it), *it))
			this->erase(prev(it));
	}

	long long query(long long x) {
		// long long ans = 0x3f3f3f3f3f3f3f3f;
		// for(Line l : *this)
			// ans = min(ans, l.eval(x));
		// return ans;

		if((this->size()) == 0) return 0x3f3f3f3f3f3f3f3f;

		while(this->size() >= 2 && prev(this->end())->eval(x) >= prev( prev(this->end()) )->eval(x))
			this->erase(prev(this->end()));
		return prev(this->end())->eval(x);
	}
} cht; */

constexpr long long inf = 0x3f3f3f3f3f3f3f3f;

struct Line
{
	long long a, b, x; // vou codar com inteiros msm
	Line(long long _a = 0, long long _b = 0, long long _x = inf) : a(_a), b(_b), x(_x) {}
	bool operator<(const Line& o) const { return a > o. a; } // change < for >, for min queries
	bool operator<(const long long& o) const { return x < o; }
};

struct LineContainer : multiset<Line, less<>>
{
	bool hasNext(iterator it) { return next(it) != end(); }
	bool hasPrev(iterator it) { return it != begin(); }
	long double intersect(Line l1, Line l2) { return ((long double)(l1.b-l2.b)) / (l2.a-l1.a); }
	bool bad(Line l1, Line l2, Line l3) { return intersect(l1, l3) <= intersect(l1, l2); }
	iterator get_x(iterator it) {
		if(!hasNext(it)) return it;
		Line l = *it;
		l.x = intersect(l, *next(it));
		erase(it);
		return insert(l);
	}
	void add(Line l) {
		auto it = lower_bound(l);
		long long a = l.a, b = l.b;
		if(it != end() && it->a == a) {
			if(it->b >= b) return;
			erase(it);
		}
		it = insert(l);
		if(hasPrev(it) && hasNext(it) && bad(*prev(it), *it, *next(it)))
			return (void)(erase(it));
		while(hasPrev(it) && hasPrev(prev(it)) && bad(*prev(prev(it)), *prev(it), *it))
			erase(prev(it));
		while(hasNext(it) && hasNext(next(it)) && bad(*it, *next(it), *next(next(it))))
			erase(next(it));
		it = get_x(it);
		if(hasPrev(it)) get_x(prev(it));
	}
	long long query(long long x) {
		// assert(!empty());
		if(empty()) return 0x3f3f3f3f3f3f3f3f;
		auto it = lower_bound(x);
		return it->a*x + it->b;
	}
} cht;

constexpr int maxn = 2e5+10;

int nxt[maxn]; // next living guy after a water refill

long long X, N, M, W, T;

long long refill[maxn], time_person[maxn], kill_person[maxn], dp[maxn];

int main() {
	scanf("%lld %lld %lld %lld %lld", &X, &N, &M, &W, &T);
	for(int i = 1; i <= N; i++)
		scanf("%lld", &refill[i]);
	refill[++N] = X;

	sort(refill+1, refill+1+N, [&](long long x1, long long x2) { return x1%T > x2%T; });

	for(int i = 1; i <= M; i++)
		scanf("%lld %lld", &time_person[i], &kill_person[i]);

	vector<pair<long long, long long>> tempos; // o tempo T é o fim
	for(int i = 1; i <= M; i++)
		tempos.push_back({time_person[i], kill_person[i]});
	sort(tempos.begin(), tempos.end());

	for(int i = 0; i < M; i++)
		time_person[i+1] = tempos[i].first, kill_person[i+1] = tempos[i].second;
	time_person[M+1] = T; // setto o valor do piloto

	for(int i = 1; i <= N; i++)
		nxt[i] = lower_bound(time_person+1, time_person+1+M, refill[i] % T) - time_person; // ID do proximo cara vivo dps de mim

	for(int i = 2; i <= M; i++)
		kill_person[i] += kill_person[i-1];

	auto qtd = [&](long long tempo) { return X / T + (tempo < X%T); };

	dp[M+1] = W * (X/T + 1);
	for(int i = M, j = 1; i >= 1; i--) {
		// cht
		// val[j] + pref[i-1] = {dp[nxt[j]] + pref[nxt[j]-1] + (refill[j]/T) * W * (r+1)} + l * {- (refill[j] / T) * W}

		for(; j <= N && refill[j] % T >= time_person[i]; j++)
			cht.add(Line(-1 * (refill[j] / T) * W, dp[nxt[j]] + kill_person[nxt[j]-1] + (refill[j]/T)*W*((nxt[j]-1)+1) ));

		// opção 1: fico vivo até o final
		// opção 2: uso alguem pra me matar
		dp[i] = min(dp[i+1] + W * qtd(time_person[i]), cht.query(i) - kill_person[i-1]);
	}

	printf("%lld\n", dp[1]);
}

Compilation message

coach.cpp: In function 'int main()':
coach.cpp:108:7: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  108 |  scanf("%lld %lld %lld %lld %lld", &X, &N, &M, &W, &T);
      |  ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
coach.cpp:110:8: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  110 |   scanf("%lld", &refill[i]);
      |   ~~~~~^~~~~~~~~~~~~~~~~~~~
coach.cpp:116:8: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  116 |   scanf("%lld %lld", &time_person[i], &kill_person[i]);
      |   ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 340 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 0 ms 340 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Incorrect 0 ms 212 KB Output isn't correct
13 Halted 0 ms 0 KB -

Subtask #2
0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 340 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 0 ms 340 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Incorrect 0 ms 212 KB Output isn't correct
13 Halted 0 ms 0 KB -

Subtask #3
0 / 25.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 340 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 0 ms 340 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Incorrect 0 ms 212 KB Output isn't correct
13 Halted 0 ms 0 KB -

Subtask #4
0 / 29.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 340 KB Output is correct
2 Correct 0 ms 212 KB Output is correct
3 Correct 1 ms 212 KB Output is correct
4 Correct 0 ms 212 KB Output is correct
5 Correct 1 ms 340 KB Output is correct
6 Correct 0 ms 212 KB Output is correct
7 Correct 1 ms 212 KB Output is correct
8 Correct 0 ms 212 KB Output is correct
9 Correct 0 ms 340 KB Output is correct
10 Correct 1 ms 212 KB Output is correct
11 Correct 1 ms 212 KB Output is correct
12 Incorrect 0 ms 212 KB Output isn't correct
13 Halted 0 ms 0 KB -