De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot din cazanul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
Voi exemplifica explicaţia cu cod în **limbajul C++**
==code(cpp) |
dp[1][0]=1;
for(j=1; j<=k; j++)
dp[1][j]=(1LL*j*hazard[1])%MOD;
for(i=2; i<=n; i++)
{
dp[i][0]=1;
for(j=1; j<=k; j++)
{
for(x=0; x<=j-1; x++)
dp[i][j]=(dp[i][j]+1LL*dp[i-1][x]*(j-x)*hazard[i])%MOD;
dp[i][j]=(dp[i][j]+dp[i-1][j])%MOD;
}
}
==
h2. $Solutie N*K, memorie N*K - 80 puncte$
Trecerea de la $O(N*K^2^)$ la $O(N*K)$ se face cu ajutorul sumelor partiale.
OBS:
CAZAN69 h1. 'Soluţia':warm-up-2019/solutii/shoturi problemei 'Shoturi':problema/shoturi
h2. $Soluţie backtracking - 10 puncte$
Generăm toate variantele posibile ale vectorului <tex>x</tex> pentru care <tex>x[1] + x[2] + ... + x[N] = K</tex>. Această soluţie obţine 0 sau 10 puncte în funcţie de implementarea backtrackingului, care ar avea complexitatea <tex> O(K^N) </tex> amortizat.
h2. $Soluţie N*K^2^ - 50 puncte$
Această soluţie presupune tehnica programării dinamice. Vom folosi matricea $dp[n][k]$, pentru care:
* $dp[i][j]$ = suma potenţelor tuturor amestecurilor posibile ingerând j -shoturi- păhărele din primele i -substanţe interzise- sucuri.
De aici deducem recurenţa: <tex>\displaystyle \ dp[i][j]=\sum_{x=0}^{j-1} dp[i-1][x]*(j-x)*hazard[i] + dp[i-1][j]</tex>
De ce? Pentru că, din cum am definit dinamica, $dp[i-1][x]$ = suma potenţelor tuturor amestecurilor posibile ingerând x păhărele din primele i-1 sucuri. Cum $dp[i][j]$ presupune ingerarea a j pahare $=>$ se vor ingera j-x pahare de tipul i, care vor inmulţi fiecare potenţă cu <tex>(j-x)*hazard[i]</tex>. Adunăm $dp[i-1][j]$ la dp[i][j] deoarece tinerii pot alege sa nu bea niciun shot de tipul i.
Observatie: <tex>$dp[i][0]=1$</tex>, <tex>1<=i<=n</tex>, ca să ne iasă calculele :)
