1. Fusión de piedras
1. Solución de problemas:
Intervalo dp, usando el principio de optimización de paralelogramo
2.ac código:
Lo extraño es que cuando N es 2000, dev no produce datos. ¿Quizás es demasiado largo? Pero después de Niuke.com
, cuando N es igual a 20, dev está bien.
#include<stdio.h>
#include<bits/stdc++.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#define N 2000
#define INF 1<<30
using namespace std;
typedef long long ll;
int dp[N][N],sum[N];
int n;
int Minval(){
int i,j;
int s[N][N];
for(i=1;i<=n;i++){
dp[i][i]=0;
s[i][i]=i;
}
for(int len=1;len<n;len++){
for(i=1;i<=n-len;i++){
j=len+i;
dp[i][j]=INF;
for(int k=s[i][j-1];k<=s[i+1][j];k++){
if(dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]<dp[i][j]){
dp[i][j]=dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1];
s[i][j]=k;
}
}
}
}
return dp[1][n];
}
int main(){
int i,j,x;
while(cin>>n){
sum[0]=0;
for(i=1;i<=n;i++){
cin>>x;
sum[i]=sum[i-1]+x;
}
x=Minval();
cout<<x<<endl;
}
}
Palíndromo
1. Solución de problemas:
<< Competencia de algoritmos desde la entrada hasta la avanzada >> P138
w [] representa el costo de eliminar o insertar. Insertar en un lado de la matriz o eliminar en el otro es equivalente, así que tome el valor mínimo,
dp [i] [j] representa la cadena s [i] [j] El costo mínimo de convertirse en palíndromo
2.ac código:
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#define N 2010
#define INF 1<<30
using namespace std;
typedef long long ll;
int dp[N][N],sum[N];
int w[N];
int x,y;
char s[N];
int n,m;
int main(){
int i,j;
char c;
while(cin>>n>>m){
cin>>s;
for(i=0;i<n;i++){
cin>>c>>x>>y;
w[c-'a']=min(x,y);
}
memset(dp,0,sizeof(dp));
for(i=m-1;i>=0;i--){
//i从右向左
for(j=i+1;j<m;j++){
//j从i+1向右
if(s[i]==s[j])
dp[i][j]=dp[i+1][j-1];
else
dp[i][j]=min(dp[i+1][j]+w[s[i]-'a'],dp[i][j-1]+w[s[j]-'a']);
}
}
cout<<dp[0][m-1]<<endl;
}
}
Polígono
1. Significado de la pregunta:
ligeramente
2. Solución de problemas:
Clave 1: Eslabón roto es una cadena
Clave 2: Convertido en piedra dp
Clave 3: Máximo y mínimo relacionados Cuando
c (i) es X:
Máximo:
1. Máximo x máximo (todo positivo)
2. Mínimo x mínimo (todo negativo )
3 .Máximo x mínimo (un lado negativo, un lado positivo)
valor mínimo:
mínimo x mínimo (ambos positivos)
máximo x máximo (ambos negativos)
mínimo x máximo (un lado negativo, un lado positivo)
c (i) es + :Valor máximo:
1.Máximo + máximo
mínimo:
mínimo + mínimo
3.ac código:
#include<stdio.h>
#include<bits/stdc++.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#define N 150
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
int f[N][N],g[N][N];//f区间最大，g区间最小
int a[N];
char c[N];
int main(){
int n,i,j;
char s;
while(cin>>n){
for(i=1;i<=n;i++){
cin>>c[i]>>a[i];
c[i+n]=c[i];//断环为链
a[i+n]=a[i];
//printf("%c %d ",c[i],a[i]);
}
for(int i=1;i<=(n<<1);i++){
for(int j=1;j<=(n<<1);j++){
f[i][j]=-INF,g[i][j]=INF;
}
}
for(i=1;i<=(n<<1);i++){
f[i][i]=g[i][i]=a[i];
}
for(int len=1;len<n;len++){
for(i=1;i<=2*n-len;i++){
j=i+len;
for(int k=i;k<j;k++){
if(c[k+1]=='x'){
f[i][j]=max(f[i][j],max(f[i][k]*f[k+1][j],max(g[i][k]*g[k+1][j],max(f[i][k]*g[k+1][j],g[i][k]*f[k+1][j]))));
g[i][j]=min(g[i][j],min(f[i][k]*f[k+1][j],min(g[i][k]*g[k+1][j],min(f[i][k]*g[k+1][j],g[i][k]*f[k+1][j]))));
// printf("%d %d\n",f[i][j],g[i][j]);
}
else if(c[k+1]=='t'){
f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]);
g[i][j]=min(g[i][j],g[i][k]+g[k+1][j]);
// printf("%d %d\n",f[i][j],g[i][j]);
}
}
}
}
int ans=-INF;
for(i=1;i<=n;i++){
ans=max(ans,f[i][i+n-1]);
}
printf("%d\n",ans);
for(i=1;i<=n;i++){
if(f[i][i+n-1]==ans)
printf("%d ",i);
}
printf("\n");
}
}
//4
//t -7 t 4 x 2 x 5