cf706C(dp)

题目链接：http://codeforces.com/problemset/problem/706/C

题意：给出n个字符串，反转第 i 个字符串需要花费 ai，问通过反转操作将n个字符串变成升序排列，最小花费是多少，不能使其升序排列的话输出-1;

思路：dp

不难想到只有当前字符串的前一个字符串会对当前字符串产生直接影响，而每个字符串都只有反转和不反转两种状态；

我们可以用dp[i][0]表示第i个字符串不反转的情况从第0到第i个字符变成升序的需要的最小花费，dp[i][1]表示第i个字符串反转的情况从第0到第i个字符变成升序的需要的最小花费；

对于第 i 个字符串我们可以选择反转或者不反转，对于每种选择又会产生三中可能, 我们用str1, str2存储当前字符串和其反转字符串，s, rs存储前一个字符串和对应反转字符串，

那么有：

当前字符串不反转:

　　str1>=s&&str1>=rs

　　str1>=s&&str1<rs

　　str1>=rs&&str1<s

当前字符串反转:

　　str2>=s&&str2>=rs

　　str2>=s&&str2<rs

　　 str2>=rs&&str2<s

想清楚了这些状态也就不难写出状态转移方程式了：

 　　　　　　　if(str1>=s&&str1>=rs){
                 dp[i][]=min(dp[i-][], dp[i-][]);
             }else if(str1>=s){
                 dp[i][]=dp[i-][];
             }else if(str1>=rs){
                 dp[i][]=dp[i-][];
             }else{
                 ok1=false; //不反转比s, rs都要小
             }
             //若当前字符串反转
             if(str2>=s&&str2>=rs){
                 dp[i][]=min(dp[i-][], dp[i-][])+a[i];
             }else if(str2>=s){
                 dp[i][]=dp[i-][]+a[i];
             }else if(str2>=rs){
                 dp[i][]=dp[i-][]+a[i];
             }else{
                 ok2=false;//反转比s, rs都要小
             }

代码：

 #include <bits/stdc++.h>
 #define ll long long
 using namespace std;

 const int MAXN=1e5+;
 const ll inf=0x3f3f3f3f3f3f3f3f;
 ll dp[MAXN][], a[MAXN];//a数组存储花费
 //dp[i][0]表示第i个字符串不反转的情况从第0到第i个字符变成升序的需要的最小花费,dp[i][1]表示第i个字符串反转的情况从第0到第i个字符变成升序的需要的最小花费

 int main(void){
     ios::sync_with_stdio(false), cin.tie(), cout.tie();
     int n;
     cin >> n;
     for(int i=; i<n; i++){
         cin >> a[i];
     }
     bool flag=true;
     string s, rs, str1, str2;
     cin >> s;
     rs=s;
     reverse(rs.begin(), rs.end());
     dp[][]+=a[];
     for(int i=; i<n; i++){
         cin >> str1;
         str2=str1;
         reverse(str2.begin(), str2.end());
         if(flag){
             bool ok1=true, ok2=true;
             //**若当前字符串不反转
             if(str1>=s&&str1>=rs){
                 dp[i][]=min(dp[i-][], dp[i-][]);
             }else if(str1>=s){
                 dp[i][]=dp[i-][];
             }else if(str1>=rs){
                 dp[i][]=dp[i-][];
             }else{
                 ok1=false; //不反转比s, rs都要小
             }
             //若当前字符串反转
             if(str2>=s&&str2>=rs){
                 dp[i][]=min(dp[i-][], dp[i-][])+a[i];
             }else if(str2>=s){
                 dp[i][]=dp[i-][]+a[i];
             }else if(str2>=rs){
                 dp[i][]=dp[i-][]+a[i];
             }else{
                 ok2=false;//反转比s, rs都要小
             }
             if(!ok1&&!ok2){
                 flag=false;
             }else if(!ok1&&ok2){
                 dp[i][]=inf;
             }else if(ok1&&!ok2){
                 dp[i][]=inf;
             }
         }
         s=str1;
         rs=str2;
     }
     ll ans=min(dp[n-][], dp[n-][]);
     if(!flag||ans>=inf){
         cout << - << endl;
     }else{
         cout << ans << endl;
     }
     return ;
 }