Submission #132287

#	Time	Username	Problem	Language	Result	Execution time	Memory
132287		hugo_pm	Shortcut (IOI16_shortcut)	C++17	38 / 100	2052 ms	71376 KiB

shortcut

#include "shortcut.h"
#include <cassert>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
using llg = long long;
using pii = pair<llg, llg>;
 
const llg BIG = (llg)(1e9) * (llg)(1e7);
 
llg nbSta;
llg lenShortcut;
llg lenMap;
 
pii finAutor(llg tempsVise, llg debutShort, vector<llg> &pos, vector<llg> &poids, vector<vector<llg>> &table, llg &maxAvant)
{
	pii finPos {0, BIG};
 
	for (llg sta = max(0LL, debutShort-1); sta < debutShort; ++sta) {
		maxAvant = max(maxAvant, poids[sta] - pos[sta]);
		int dm = poids[sta] + pos[sta] + maxAvant;
		if (dm > tempsVise) return {-1, -1};
	}
 
	llg posDebut = pos[debutShort];
 
	for (llg sta = debutShort; sta < nbSta; ++sta) {
		llg risqueApres = table[sta][debutShort] - posDebut;
 
		bool canAvant = (poids[sta] + pos[sta] + maxAvant <= tempsVise);
		llg risqueAvant = posDebut + maxAvant;
		if (canAvant) risqueAvant = -BIG;
 
		if (canAvant && risqueApres < 0) continue;
 
		llg tempsPlus = tempsVise - max(risqueApres, risqueAvant) - lenShortcut - poids[sta];
		if (tempsPlus < 0) return {-1, -1};
		finPos.first = max(finPos.first, pos[sta] - tempsPlus);
		finPos.second = min(finPos.second, pos[sta] + tempsPlus);
	}
 
	return finPos;
}
 
vector<vector<llg>> genTable(llg tempsVise, vector<llg> &pos, vector<llg> &poids)
{
	vector<vector<llg>> table(nbSta);
 
	for (llg sta = 0; sta < nbSta; ++sta) {
		table[sta].resize(sta+1);
		table[sta][sta] = -BIG;
		llg maxAutor = tempsVise - poids[sta] - pos[sta];
		llg curMax = -BIG;
		for (llg prev = sta-1; prev >= 0; --prev) {
			llg valPrev = poids[prev] - pos[prev];
			if (valPrev > maxAutor) { // Ne peut pas etre attellg direct
				curMax = max(curMax, poids[prev] + pos[prev]);
			}
			table[sta][prev] = curMax;
		}
	}
 
	return table;
}
 
bool estPossibleGlob(llg tempsVise, vector<llg> &pos, vector<llg> &revPos, vector<llg> &poids, vector<llg> &revPoids)
{
	vector<pii> finToDebut(nbSta);
	auto tabNor = genTable(tempsVise, pos, poids);
	auto tabRev = genTable(tempsVise, revPos, revPoids);
 
	llg maxAvant = -BIG;
	for (llg sta = 0; sta < nbSta; ++sta) {
		pii x = finAutor(tempsVise, sta, revPos, revPoids, tabRev, maxAvant);
		finToDebut[nbSta-1-sta] = {lenMap - x.second, lenMap - x.first};
	}
 
	maxAvant = -BIG;
	for (llg deb = 0; deb < nbSta; ++deb) {
		pii posFinOk = finAutor(tempsVise, deb, pos, poids, tabNor, maxAvant);
		for (llg fin = deb; fin < nbSta; ++fin) {
			if (posFinOk.first <= pos[fin] && pos[fin] <= posFinOk.second) {
				auto corDebOk = finToDebut[fin];
				if (corDebOk.first <= pos[deb] && pos[deb] <= corDebOk.second) {
					return true;
				}
			}
		}
	}
 
	return false;
}
 
long long find_shortcut(int _n, std::vector<int> _l, std::vector<int> _d, int _c)
{
	nbSta = _n;
	lenShortcut = _c;
	vector<llg> pos, revPos;
	vector<llg> poids, revPoids;
	pos.resize(nbSta);
	revPos.resize(nbSta);
	poids.resize(nbSta);
	revPoids.resize(nbSta);
	llg curPos = 0;
 
	for (llg iSta = 0; iSta < nbSta; ++iSta) {
		pos[iSta] = curPos;
		if (iSta < nbSta-1) curPos += _l[iSta];
 
		poids[iSta] = _d[iSta];
		revPoids[iSta] = _d[nbSta-1-iSta];
	}
 
	lenMap = pos.back();
 
	curPos = 0;
	for (llg iSta = nbSta-1; iSta >= 0; --iSta) {
		revPos[iSta] = curPos;
		if (iSta > 0) curPos += _l[iSta-1];
	}
 
	reverse(revPos.begin(), revPos.end());
	//reverse(revPoids.begin(), revPoids.end());
 
 
	llg lo = 0, ri = 0;

	pii toPr = {-1, -1};

	for (int a = 0; a < nbSta; ++a) {
		for (int b = a+1; b < nbSta; ++b) {
			lo = max(lo, poids[a] + poids[b] + min(lenShortcut, pos[b] - pos[a]));
			llg newRi = max(ri, poids[a] + poids[b] + (pos[b] - pos[a]));
			if (newRi > ri) {
				newRi = ri;
				toPr = {a, b};
			}
		}
	}
 
	auto gd = [&] (int a, int b) {
		llg r1 = abs(pos[a] - pos[b]);
		llg r2 = abs(pos[a] - pos[toPr.first]) + lenShortcut + abs(pos[b] - pos[toPr.second]);
		llg r3 = abs(pos[a] - pos[toPr.second]) + lenShortcut + abs(pos[b] - pos[toPr.first]);
		return min(r1, min(r2, r3));
	};

	ri = 0;

	for (int a = 0; a < nbSta; ++a) {
		for (int b = a+1; b < nbSta; ++b) {
			ri = max(ri, poids[a] + poids[b] + gd(a, b));
		}
	}

	while (lo < ri) {
		llg mid = (lo + ri) / 2;
		if (estPossibleGlob(mid, pos, revPos, poids, revPoids)) {
			ri = mid;
		} else {
			lo = mid+1;
		}
	}
 
	return lo;
}

• Subtask 1: 9 / 9
• Subtask 2: 14 / 14
• Subtask 3: 8 / 8
• Subtask 4: 7 / 7
• Subtask 5: 0 / 33
• Subtask 6: 0 / 22
• Subtask 7: 0 / 4
• Subtask 8: 0 / 3