Submission #525517

#	Time	Username	Problem	Language	Result	Execution time	Memory
525517		LucaDantas	Dungeons Game (IOI21_dungeons)	C++17	89 / 100	7118 ms	1216140 KiB

dungeons

#define _FORTIFY_SOURCE 0 
#pragma GCC optimize("Ofast") 
#pragma GCC optimize("no-stack-protector") 
#pragma GCC optimize("unroll-loops") 
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma") 
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx") 
#pragma GCC optimize("inline") 
#pragma GCC optimize("-fgcse") 
#pragma GCC optimize("-fgcse-lm") 
#pragma GCC optimize("-fipa-sra") 
#pragma GCC optimize("-ftree-pre") 
#pragma GCC optimize("-ftree-vrp") 
#pragma GCC optimize("-fpeephole2") 
#pragma GCC optimize("-ffast-math") 
#pragma GCC optimize("-fsched-spec") 
#pragma GCC optimize("unroll-loops") 
#pragma GCC optimize("-falign-jumps") 
#pragma GCC optimize("-falign-loops") 
#pragma GCC optimize("-falign-labels") 
#pragma GCC optimize("-fdevirtualize") 
#pragma GCC optimize("-fcaller-saves") 
#pragma GCC optimize("-fcrossjumping") 
#pragma GCC optimize("-fthread-jumps") 
#pragma GCC optimize("-funroll-loops") 
#pragma GCC optimize("-fwhole-program") 
#pragma GCC optimize("-freorder-blocks") 
#pragma GCC optimize("-fschedule-insns") 
#pragma GCC optimize("inline-functions") 
#pragma GCC optimize("-ftree-tail-merge") 
#pragma GCC optimize("-fschedule-insns2") 
#pragma GCC optimize("-fstrict-aliasing") 
#pragma GCC optimize("-fstrict-overflow") 
#pragma GCC optimize("-falign-functions") 
#pragma GCC optimize("-fcse-skip-blocks") 
#pragma GCC optimize("-fcse-follow-jumps") 
#pragma GCC optimize("-fsched-interblock") 
#pragma GCC optimize("-fpartial-inlining") 
#pragma GCC optimize("no-stack-protector") 
#pragma GCC optimize("-freorder-functions") 
#pragma GCC optimize("-findirect-inlining") 
#pragma GCC optimize("-fhoist-adjacent-loads") 
#pragma GCC optimize("-frerun-cse-after-loop") 
#pragma GCC optimize("inline-small-functions") 
#pragma GCC optimize("-finline-small-functions") 
#pragma GCC optimize("-ftree-switch-conversion") 
#pragma GCC optimize("-foptimize-sibling-calls") 
#pragma GCC optimize("-fexpensive-optimizations") 
#pragma GCC optimize("-funsafe-loop-optimizations") 
#pragma GCC optimize("inline-functions-called-once") 
#pragma GCC optimize("-fdelete-null-pointer-checks")


#include "dungeons.h"
#include <vector>

constexpr int maxn = 4e5+10, logn = 24, log_lift = 8, base_lift = 8;
constexpr int inf = 0x3f3f3f3f;

	int f[logn][log_lift][maxn];
	int tab[logn][log_lift][maxn];
	long long cost[logn][log_lift][maxn];

	void add_i(const int& i, const int& x, const int& v, const int& st, const int& lg) { f[lg][0][i] = x, cost[lg][0][i] = v, tab[lg][0][i] = st; }

	void build(int n, int lg) {
		f[lg][0][n] = n;

		for(int l = 1; l < log_lift; l++) {
			for(int i = 0; i <= n; i++) {
				f[lg][l][i] = i;
				tab[lg][l][i] = tab[lg][l-1][i];

				for(int k = 0; k < base_lift; k++) {
					if(tab[lg][l-1][f[lg][l][i]] < inf)
						tab[lg][l][i] = std::max(0ll, std::min((long long)tab[lg][l][i], tab[lg][l-1][f[lg][l][i]] - cost[lg][l][i]));
					cost[lg][l][i] += cost[lg][l-1][f[lg][l][i]];
					f[lg][l][i] = f[lg][l-1][f[lg][l][i]];
				}
			}
		}
	}

	void go(int& x, long long& val, const int& lg) {
		for(int l = log_lift-1; l >= 0; l--)
			for(int k = 0; k < base_lift-1; k++)
				if(tab[lg][l][x] >  val || tab[lg][l][x] == inf) val += cost[lg][l][x], x = f[lg][l][x];
	}

int N;

void init(int n, std::vector<int> s, std::vector<int> p, std::vector<int> w, std::vector<int> l) {
	N = n;
	for(int lg = 0; lg < logn; lg++) {
		for(int i = 0; i < n; i++) {
			if(s[i] < (2<<lg)) add_i(i, w[i], s[i], inf, lg);
			else add_i(i, l[i], p[i], s[i], lg);
		}
		build(n, lg);
	}

	return;
}

long long simulate(int x, int z) {
	long long val = z;
	for(int lg = 0; lg < logn; lg++)
		if(x != N) go(x, val, lg);
	return val;
}

Compilation message (stderr)

dungeons.cpp:1: warning: "_FORTIFY_SOURCE" redefined
    1 | #define _FORTIFY_SOURCE 0
      | 
<built-in>: note: this is the location of the previous definition
dungeons.cpp:25:39: warning: bad option '-fwhole-program' to pragma 'optimize' [-Wpragmas]
   25 | #pragma GCC optimize("-fwhole-program")
      |                                       ^
dungeons.cpp:32:41: warning: bad option '-fstrict-overflow' to pragma 'optimize' [-Wpragmas]
   32 | #pragma GCC optimize("-fstrict-overflow")
      |                                         ^
dungeons.cpp:34:41: warning: bad option '-fcse-skip-blocks' to pragma 'optimize' [-Wpragmas]
   34 | #pragma GCC optimize("-fcse-skip-blocks")
      |                                         ^
dungeons.cpp:48:51: warning: bad option '-funsafe-loop-optimizations' to pragma 'optimize' [-Wpragmas]
   48 | #pragma GCC optimize("-funsafe-loop-optimizations")
      |                                                   ^
In file included from dungeons.cpp:53:
dungeons.h:3:96: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
    3 | void init(int n, std::vector<int> s, std::vector<int> p, std::vector<int> w, std::vector<int> l);
      |                                                                                                ^
dungeons.h:3:96: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.h:3:96: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.h:3:96: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.h:3:96: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
dungeons.h:3:96: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.h:3:96: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.h:3:96: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
    4 | long long simulate(int x, int z);
      |                                ^
dungeons.h:4:32: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.h:4:32: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.cpp:63:83: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
   63 |  void add_i(const int& i, const int& x, const int& v, const int& st, const int& lg) { f[lg][0][i] = x, cost[lg][0][i] = v, tab[lg][0][i] = st; }
      |                                                                                   ^
dungeons.cpp:63:83: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.cpp:63:83: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.cpp:63:83: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.cpp:65:26: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
   65 |  void build(int n, int lg) {
      |                          ^
dungeons.cpp:65:26: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.cpp:65:26: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.cpp:65:26: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.cpp:83:47: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
   83 |  void go(int& x, long long& val, const int& lg) {
      |                                               ^
dungeons.cpp:83:47: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.cpp:83:47: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.cpp:83:47: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.cpp:91:96: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
   91 | void init(int n, std::vector<int> s, std::vector<int> p, std::vector<int> w, std::vector<int> l) {
      |                                                                                                ^
dungeons.cpp:91:96: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.cpp:91:96: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.cpp:91:96: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
dungeons.cpp:104:32: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
  104 | long long simulate(int x, int z) {
      |                                ^
dungeons.cpp:104:32: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
dungeons.cpp:104:32: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
dungeons.cpp:104:32: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]

• Subtask 1: 11 / 11
• Subtask 2: 26 / 26
• Subtask 3: 13 / 13
• Subtask 4: 12 / 12
• Subtask 5: 27 / 27
• Subtask 6: 0 / 11