1. Enlace de título:
CodeForces-1076F
2. La idea principal del tema:
Hay n páginas de papel, solo se puede escribir una línea horizontalmente
Cada página debe estar escrita con a [i] 0 yb [i] 1
Después de eso, las n páginas de papel se empalman en secuencia y no se permiten más de k 0 o 1 consecutivos. Pregunte si es factible.
3. Análisis:
DP obviamente lineal.
Pero mi estado dijo: dp [a] [b] [c] [d] [e]
El estado del jefe: dp [i] [0/1]
Sí, mi DP es violencia ...
De hecho, siempre que piense en la representación del estado, el cálculo del estado seguirá (devolverá) mano (sí) y (no) (voluntad).
Estado significa dp [i] [0] significa el número mínimo de ceros que terminan en 0 en la i-ésima página después de escribir la i-ésima página.
dp [i] [1] representa el número mínimo de unos que terminan en 1 en la página i después de escribir la página i.
4. Implementación del código:
#include <bits/stdc++.h>
using namespace std;
const int M = (int)3e5;
const int inf = 0x3f3f3f3f;
int n, k;
int a[M + 5], b[M + 5];
int dp[M + 5][2];
int cal(int pa, int pb, int a, int b)
{
int ans = inf;
if(pa <= k)
{
int cnt = (pa + a + k - 1) / k - 1;
if(b == cnt)
ans = min(ans, pa + a - cnt * k);
else if(b > cnt && b <= 1ll * a * k)
ans = min(ans, 1);
}
if(pb <= k)
{
int cnt = (a + k - 1) / k - 1;
if(b == cnt)
ans = min(ans, a - cnt * k);
else if(b > cnt && b <= 1ll * (a - 1) * k + k - pb)
ans = min(ans, 1);
}
return ans;
}
int main()
{
scanf("%d %d", &n, &k);
for(int i = 1; i <= n; ++i) scanf("%d", &a[i]), dp[i][0] = inf;
for(int i = 1; i <= n; ++i) scanf("%d", &b[i]), dp[i][1] = inf;
dp[0][0] = dp[0][1] = 0;
for(int i = 1; i <= n; ++i)
{
dp[i][0] = cal(dp[i - 1][0], dp[i - 1][1], a[i], b[i]);
dp[i][1] = cal(dp[i - 1][1], dp[i - 1][0], b[i], a[i]);
}
puts(dp[n][0] == inf && dp[n][1] == inf ? "NO" : "YES");
return 0;
}