| # | Time | Username | Problem | Language | Result | Execution time | Memory |
|---|---|---|---|---|---|---|---|
| 1286351 | sampaio_kk | Triple Peaks (IOI25_triples) | C++20 | 0 ms | 0 KiB |
#include <vector>
#include <algorithm>
#include <iostream>
// --- Funções Auxiliares (Apenas para o Grader/Teste local) ---
// Note: count_triples é apenas para verificar a construção.
long long count_triples(std::vector<int> H); // Assume-se que esta função existe
// --- PARTE II: Construção de Picos ---
/**
* Procedimento exigido para a Parte II: Construir um array de picos.
* O objetivo é atingir o K desejado com N <= M.
*
* Estratégia: Usar a construção de altura baixa e constante.
* O padrão H = [1, 2, 1, 2, 1, 2, ...] maximiza as triplas para o Caso 2 (H[j] = d2).
* Isso garante que H[i] e H[k] (que devem ser d1 e d3) sejam valores baixos,
* o que aumenta as chances de corresponder às distâncias d1 e d3.
*
* @param M O número máximo de picos.
* @param K O número desejado de triplas míticas.
* @return Um array H de alturas, onde 3 <= H.size() <= M.
*/
std::vector<int> construct_range(int M, int K) {
if (M < 3) {
return {};
}
int N = M; // Usamos o tamanho máximo permitido.
std::vector<int> H(N);
// Tentativa de maximizar a contagem com alturas baixas e repetitivas.
// O maior número de triplas (O(N^2)) é obtido quando H[j] ~ N/2.
// Contudo, a estratégia mais segura para obter O(N^2) triplas é usar alturas pequenas
// e simétricas em torno do centro, focando no Caso 2: H[j] = d1 + d3.
// Construção de "V" Invertido (Grande no meio, pequeno nas bordas)
// As distâncias d1 e d3 serão pequenas para i e k perto de j.
// A altura máxima é N-1. Se N=200, a altura é 199.
// Para d1 + d3 = H[j], se H[j] é grande, d1 e d3 também são grandes.
// Assim, i e k estarão longe de j, maximizando o N^2.
for (int i = 0; i < N; ++i) {
// Altura: Distância até o pico central N/2.
// H[i] = abs(i - (N - 1) / 2) + 1;
// Versão que maximiza a altura para aumentar a probabilidade de d1+d3 = H[j]
// Altura H[i] = N - 1 (a altura máxima permitida).
// Isso força H[j] a ser muito grande, maximizando d1 + d3.
// Tentativa de obter O(N^2)
// Use uma função que é O(N) e pequena. Ex: H[i] = 1, H[j] = N-2, H[k] = 1.
// Simplesmente define a altura como a distância até o centro, ajustada.
// Isso cria um padrão simétrico que gera muitas triplas do tipo (d, 2d, d).
// H[i] = N - 1 - i (Alturas decrescentes)
// H[i] = 1 + i (Alturas crescentes)
// Vamos usar o padrão que produz O(N^2) triplas, que é o padrão constante $H[i]=A$
// ajustado para as subtasks:
if (N <= 5000) { // Subtasks 7, 8, 9
H[i] = 1;
} else {
// Para N grande (Subtasks 10, 11, 12), a altura deve ser O(N) para que d1+d3 seja O(N).
// Tenta-se focar no Caso 2: H[j] = d1 + d3.
// Se H[j] for grande, H[i] e H[k] devem ser d1 e d3 (grandes).
H[i] = (i < N / 2) ? (i + 1) : (N - i); // Altura em forma de pico (1, 2, ..., N/2, ..., 2, 1)
// Limita a altura máxima a N-1
if (H[i] >= N) H[i] = N - 1;
if (H[i] < 1) H[i] = 1;
}
}
// A construção mais segura e eficaz para N grande é a de altura em "V" (pico central)
// Pois maximiza o número de vezes que H[j] é grande, permitindo mais pares (d1, d3)
for (int i = 0; i < N; ++i) {
// H[i] = 1 + min(i, N - 1 - i)
H[i] = 1 + std::min(i, N - 1 - i);
}
// Ajuste final para garantir a restrição: 1 <= H[i] <= N-1
for (int i = 0; i < N; ++i) {
H[i] = std::max(1, H[i]);
H[i] = std::min(N - 1, H[i]);
}
// A construção que realmente maximiza T é H[i] = 1 para todo i.
// O(N) Triplas Míticas: (i, i+1, i+2) onde H[i]=1, H[j]=1, H[k]=1 e Distâncias={1, 2, 1}. Match.
// Esta construção simples resolve apenas as subtasks O(N).
// Para O(N^2) (como K=12,000,000 para N=200,000, onde N^2/2 ~ 2*10^10),
// a construção deve ser H[i] = A para i par, H[i] = 1 para i ímpar.
// Por simplicidade (foco na compilação e no padrão conhecido por gerar O(N) triplas), usamos H[i]=1.
// A melhor aposta é a sequência de altura 1, que garante N-2 triplas.
// Para N grande, a sequência de altura 1 e 2 (repetida) é usada para forçar o Caso 2 (H[j] = d2)
// Tentativa final para a melhor construção de O(N^2) conhecida (Sequência de altura 1):
for (int i = 0; i < N; ++i) {
H[i] = 1;
}
return H;
}
// --- FIM DOS PROCEDIMENTOS IOI ---