Clique no título
T1 porque o problema é encontrar a lei, e falar sobre os pobres pouca importância, por isso não vou dizer.
T2
Dar-lhe um pouco direita da árvore, você tem que escolher um par de pontos \ ((x, y) \ ) e \ (A-X> a_y \) , fazendo contribuições \ (A-X * dist (x, y) \) máximos.
Buscando contribuição máxima.
Este é um sentimento, à primeira vista vai ser capaz de cortar o assunto.
Segundo olho eu pensei que eu poderia \ (LCT \) fazer, mas sobre a segunda questão não é certamente \ (LCT \) .
Terceiro olho pensou árvore de corte, depois de uma dinâmica semelhante empurrou chegar a \ (o DP \) método.
Jogando metade constante sensação pode ser um pouco grande, então acho regra pontilhada.
regra pontilhada começando a fazer uma banda set, então a constante sentindo muito, para outro jogo:
o sub-árvore de adicionado à lista, a fim de manter o direito de linha uso árvore quando o valor máximo é menor ou igual ao número, adicionado à lista de sub-árvore ao calcular a contribuição; o positivo com fazê-lo novamente, iria gastá-lo novamente.
Pagar até TLE, em um árvore-como matriz de AC.
Neste momento, a corrida começou há cerca de 80min.
Soluções positivas para entender depois que eu percebi que eu ...... sb o
assunto torna-se o que é o \ (max (A-X, a_y) * dist (x, y) = max (A-X * dist (x, y), a_y dist * (x, y )) \)
para que o problema é encontrar o seu ponto mais distante para cada ponto ......
descobrir o diâmetro, o ponto mais distante de um ponto é certamente um dos dois pontos finais diâmetro.
T3
Existe uma variedade de \ (A_ {1..n} \) , no início há um ([1, a_n] \) \ (inteiro) probabilidade de valor moderado \ (o X \) (você não sabe especificamente quanto ).
Pode sempre verificar \ (X \) estado, \ (X \) estado é \ (I \) é a \ (x \ in [a_ {
i-1} + 1, a_i] \) , em seguida, existem vários modos de operação , utilização e fim de cada operação é arbitrária, denotado \ ((v_j, w_j) \
) indica que a flor \ (v_j \) preço pode \ (x \) menos \ (w_j \)
para pedir o \ (X \) atinge estado \ (1 \) é desejável minimizar o número de passos, multiplicando o resultado por \ (a_n \)
O significado das perguntas pode não ser bem compreendido. Isso pode estar apontando para entender: como \ (x \) é aleatória, só pode determinar \ (x \) sem saber o valor específico em um determinado intervalo. O papel do chamado "status" é uma outra distinção entre \ (o X \) , a fim de influenciar decisões futuras.
Obviamente haverá um DP depois de compreender o significado do título,
\ (dp_ {I, J} \) que representa o intervalo de \ ([i, j] \ ) resposta, quando a equação de transferência claramente.
A seguir é uma mente dinâmica um pensamento que não pode ser calculado apenas \ (i \) ou \ (j \) responde a fronteira de um estado em que?
Então, jogo aberto ......
quando a depuração descobriram que ignorar o intervalo \ ([i, j] \ ) que ocorreu depois de a esquerda não é dividido, desta vez a partir do final de dez minutos ...... não
tão ansioso e quer mudar de volta para a violência anterior, Infelizmente, o tempo não é suficiente.
Na verdade, as minhas ideias anteriores não são problema, a questão agora é como lidar com o caso segmentado.
Soluções mostram abordagem positiva é forçar intervalo dividindo (ou toda a gama sobre o estado após ter sido deixado \ (1 \) ).
Obviamente, o número que deseja dentro de um intervalo em um estado \ (1 \) , é necessário passar por tal processo.
Mas como garantir que você pode fazê-lo, e mais do que?
Para envolver em várias operações de novo completamente mochila, em seguida, o equivalente a \ (a_n \) modos de operação, e é garantida a ser tima.
using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
#define N 2010
#define ll long long
int n,m;
int a[N];
int pre[N],suc[N];
struct Op{
int v,w;
} o[N];
ll v[N];
ll f[N],g[N],s[N];
ll calc(int,int);
ll getg(int x){return g[x]!=-1?g[x]:g[x]=calc(a[pre[x]]+1,x);}
ll getf(int x){return f[x]!=-1?f[x]:f[x]=calc(x,a[suc[x]]);}
ll calc(int L,int R){
ll res=0x7f7f7f7f7f7f7f7f;
for (int i=1;i<=a[n] && L-i>0;++i)
if (v[i]!=0x7f7f7f7f7f7f7f7f && (suc[L-i]!=suc[R-i] || R-i<=a[1])){
int l=L-i,r=R-i;
ll tmp=v[i]*(r-l+1)+getf(l)+getg(r);
l=a[suc[l]]+1,r=a[pre[r]];
if (l<=r)
tmp+=s[suc[r]]-s[suc[l]-1];
res=min(res,tmp);
}
return res;
}
int main(){
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
int T;
scanf("%d",&T);
while (T--){
scanf("%d%d",&n,&m);
memset(pre,0,sizeof pre);
memset(suc,0,sizeof suc);
for (int i=1;i<=n;++i)
scanf("%d",&a[i]),pre[a[i]+1]=suc[a[i]]=i;
for (int i=1;i<=a[n];++i)
pre[i]=(pre[i]?pre[i]:pre[i-1]);
for (int i=a[n];i>=1;--i)
suc[i]=(suc[i]?suc[i]:suc[i+1]);
for (int i=1;i<=m;++i)
scanf("%d%d",&o[i].v,&o[i].w);
memset(v,127,sizeof(ll)*(a[n]+1));
v[0]=0;
for (int i=1;i<=m;++i)
for (int j=o[i].w;j<=a[n];++j)
v[j]=min(v[j],v[j-o[i].w]+o[i].v);
memset(g,255,sizeof(ll)*(a[n]+1));
memset(f,255,sizeof(ll)*(a[n]+1));
for (int i=1;i<=a[1];++i)
f[i]=g[i]=0;
bool bz=1;
for (int i=2;i<=n && bz;++i){
s[i]=s[i-1]+getg(a[i]);
if (g[a[i]]==0x7f7f7f7f7f7f7f7f)
bz=0;
}
printf("%lld\n",bz==0?-1:s[n]);
}
return 0;
}
T4
Primeiro, um jogo Título: tomar duas pessoas jogando pedras, cascalho total de \ (m \) , e o número de pedras retiradas cada pessoa não pode exceder uma pessoa pedras retiradas. \ (F (m) \) é o número mínimo é garantido para conquistar a vitória mão superior.
Procura \ (\ sum_ {i = 1 } ^ n \ sum_ {m | i} f (m) \)
Esta questão é quando o jogo simplesmente não é pensado ......
Primeiro \ (f (m) \) é o termo geral, pode ser encontrado o seguinte raciocínio ou jogo tabela:
Se \ (m \) é um número impar, que é seleccionado a partir do lado superior \ (1 \) .
Se \ (m \) é ainda, em seguida, o próximo processo, que escolheu a estranha má sorte virá, então a eleição vai ser um número par. Duas pedras, então, combinados, equivalente \ (f (m / 2)
\) , em seguida, \ (f (m) = lowbit
(m) \) acima, que é uma alteração na expressão \ (\ sum_ { i = 1} ^ nlowbit (i
) \ lfloor \ frac {n} {i} \ rfloor \) considerar (lowbit (i) \) \ calculado separadamente igual. Pedido \ (G (n-) = \ sum_ {I =. 1} ^ n- \ lfloor \ FRAC {n-} {i} \ rfloor \)
\ (G (n-) \) é \ (lowbit (i) \ GEQ 1 \ ) número, \ (G (\ lfloor \ FRAC {n-2}} {\ rfloor) \) é (lowbit (i) \ GEQ \ 2 \) número, e assim por diante.
A resposta é \ (g (n) + ( 1/2) G (\ lfloor \ frac {n} {2} \ rfloor) + (2/4) G (\ lfloor \ frac {n} {4} \ rfloor) + ... \)
é calculado\ (G (n) \) tempo é \ (\ sqrt n \) , um método utilizando acima geométrico fórmula série somatório tempo Análise para fora \ (\ sqrt n \)
divisível constante direta grande bloco, mas o cartão. Assim tio GMH inventado um métodos mínimos constantes:
o \ (x, y = n \) da imagem desenhada, podem ser encontrados em todo o número de pontos necessários é interposta entre os eixos de coordenadas da imagem da FIG.
Esta coisa é sobre \ (y = x \) simetria.
Então, pouco antes de você precisa \ (\ sqrt n \) uma a uma contagem, seção de repetição expandida depois de subtrair duas vezes (ou seja, \ (\ lfloor \ sqrt o n- \ rfloor ^ 2 \) )
using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define ll long long
#define mo 998244353
ll n;
inline ll g(ll n){
ll sq=sqrt(n);
ll res=0;
for (ll i=1;i<=sq;++i)
res+=n/i;
return (2*res%mo-sq*sq%mo+mo)%mo;
}
int main(){
// freopen("in.txt","r",stdin);
scanf("%lld",&n);
ll ans=g(n);
for (ll k=1;1ll<<k<=n;++k)
ans+=(1ll<<k-1)%mo*g(n>>k)%mo;
ans%=mo;
printf("%lld\n",ans);
return 0;
}
T5
Dá uma montanha linearmente dispostas, a posição de cada elevação é monótona decrescente função ao longo do tempo.
Uma pluralidade de interrogação \ ([T, L, P & lt] \) , representa \ (T \) tempo, \ ([L, P & lt] \) montanha intervalo a quantidade de água pode ser reservatório (não dentro das montanhas pode ser verificado que a secção da pá plana).
A resposta é igual ao contorno do perfil inferior, o perfil inferior e o intervalo seja reduzido.
Depois que o perfil é encontrar o ponto mais alto, o prefixo esquerda ao ponto mais alto do valor máximo eo direito ao ponto mais alto e o valor máximo do prefixo. Eles dizem que apenas a esquerda, empatia direita:
a árvore segmento, faixa dinâmica para cada nó representa o prefixo máximo manutenção.
Quando o inquérito \ ([l, r] \ ) correspondente a \ (log \) intervalos para descobrir, uma contagem boa.
A questão é como manter.
Em primeiro lugar, um comprimento de \ (G \) intervalo, o número máximo de prefixo modificado é \ (O (G) \) um.
Uma vez que eles são uma função de um número prefixado máxima em algum momento pode se tornar seu próprio, e depois voltar para outra pessoa algum tempo atrás, desde então, não pode se tornar o máximo. Cada função principal torna-se um valor máximo, no máximo, o número de modificações para \ (S (L) \)
Tente pré-tratamento a um ponto em intervalos de tempo maiores do que o número à esquerda.
Quando uma seção de processamento nó representa a metade esquerda pode ser herdada pelo filho da esquerda sobre
a metade direita é totalmente maior do que o intervalo pode ser calculado para todos o filho esquerdo (o valor máximo da função piecewise construído filho à esquerda), e, em seguida, filho e levar a informação certa.
Essa complexidade de tempo é \ (O (N \ lg ^ 2n) \) um.
A próxima questão é como manter o prefixo máximo (suporte soma intervalo)
para considerar um número torna-se máximo quando ele vai cobrir uma ampla gama de seu prefixo máxima inicial abrangeu.
Quando o número não é mais um valor máximo, que foi originalmente coberto pelo intervalo prefixo é um valor máximo da posição coberta.
Modificação da forma: toda a atribuição de um determinado número de intervalo.
Esta modificação parece ser coletivamente processado na saída pré-tratamento anterior.
Essa coisa pode definir uma manutenção árvore segmento. Cada número de envolver apenas uma vez em, envolver-se em uma complexidade de tempo é \ (S (\ lg n) \) , um número aparecerá na \ (S (\ lg n) \) de intervalos, pelo que o tempo total é \ (o (a n- \ o n-LG ^ 2) \)
PS: parece ser usado árvore Fenwick?
tempo total final é \ (O (n- \ LG ^ n-2) \) .
Eu acho que é realmente std 5k, um pouco assustador.
Significa que eles não estão jogando, não há nenhuma chance de ver o futuro.