11.03T1 DP

#3874 naive 的瓶子

描述

众所周知，小 naive 有 n 个瓶子，它们在桌子上排成一排。第 i 个瓶子的颜色为 ci，每个瓶子都有灵性，每次操作可以选择两个相邻的瓶子，消耗他们颜色的数值乘积的代价将其中一个瓶子的颜色变成另一个瓶子的颜色。

现在 naive 要让所以瓶子的颜色都一样，操作次数不限，但要使得操作的总代价最小。

输入

输入文件为 colour.in。

一个测试点内多组数据。

第一行，一个正整数 T，表示数据组数。 每组数据内：

第一行一个整数 n，为瓶子的个数。

第二行共 n 个整数，第 i 个整数为第 i 个瓶子的颜色 ci。

输出

输入文件为 colour.out。

共一行，一个整数，为最小的总代价。

样例输入[复制]

1
4
7 4 6 10

样例输出[复制]

92

提示

样例解释

{7 4 6 10}− > {4 4 6 10}− > {4 4 4 10}− > {4 4 4 4}。

总代价为 7 × 4 + 4 × 6 + 4 × 10 = 92。

【数据范围】

1 ≤ T ≤ 10。

n<=300,ci<=10^5

标签

ZYH

 

 

 

方法

测试点 1-8

naive 的瓶子 (colour)

记忆化搜索，把当前的状态用 vector<int> 表示，用 map<vetor<int>, long long> 记录到达 vector<int> 的最小总代价，O(n) 枚举转移。设 m = min(n, max{a_i})，时间复杂度为O(mⁿ× n × m × log₂m)。

测试点 9-20

首先我们可以枚举最后的颜色 sc。

可以发现，一个瓶子要么直接被染成目标颜色，要么先被染成数值比较小的颜色，再被染成目标颜色。也就是说一个瓶子颜色的数值最多变小一次。这个结论十分显然。首先我们肯定是把一些颜色不为目标颜色的数值比较大的瓶子染成数值比较小颜色，但要确保还存在目标颜色，再最后把所有其他颜色染成目标颜色。在第一步中，一个瓶子颜色的数值肯定不会变大， 此外，也不会变小两次，假设他变小了两次，那么我们完全可以直接变小成第二次，这样肯定不会变劣。

所以我们就可以动态规划了，设 f_i为把前 i 个瓶子染成目标颜色的最小代价，每次转移选择接下来的一个区间，先把他们染成这个区间中数值最小的颜色，再染成目标颜色。

但需要注意的是，在第一步中不能把所有颜色都染成非目标颜色，那么我们可以类似 f_i的再做一遍 g_i，为把 [i, n] 染成目标颜色的最小代价。那么最后的答案为 min{f_i−1+g_i+1|c_i= sc}。

感觉这题的复杂度还可以优化，但是出题人太菜了。

code：

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 1000
using namespace std;
long long a[N],Min[N][N],dp[N][N],vis[N],f[N];
int main(){
    long long T;
    cin>>T;
    while(T--){
        long long n;
        cin>>n;
        memset(a,0,sizeof a);
        memset(Min,0,sizeof Min);
        for(long long i=1;i<=n;i++)cin>>a[i];
        memset(dp,0,sizeof dp);
        for(long long i=1;i<=n;i++){
            Min[i][i]=a[i];
            dp[i][i]=0;
            for(long long j=i+1;j<=n;j++){
                Min[i][j]=min(Min[i][j-1],a[j]);
                for(long long k=i;k<=j;k++){
                    if(a[k]==Min[i][j])continue;
                    dp[i][j]+=Min[i][j]*a[k];//calc val
                }
            }
        }
        memset(vis,0,sizeof(vis));
        long long min0=9999999999999;
        for(long long i=1;i<=n;i++){//枚举我要变成的值 
            if(vis[a[i]])continue;
            vis[a[i]]=1;
            long long now=a[i];
            memset(f,0x3f3f3f3f,sizeof f);
            f[0]=0;
            for(long long j=1;j<=n;j++){//枚举我当前计算的f[j] 
                for(long long k=0;k<j;k++){
                    f[j]=min(f[j],f[k]+dp[k+1][j]+(Min[k+1][j]!=now)*Min[k+1][j]*now*(j-k));
                } 
            }
            min0=min(min0,f[n]);
        }
        cout<<min0<<'
';
    }
    return 0;
}

over