• codeforces 706C


    C题,读懂题后一眼秒

    题意 n个字符串,你可以翻转任意一个字符串,有c[i]的代价。求最小代价,使得n个字符串按非严格字典序排列(可相同)。不可能则输出-1。

    一开始先把总长度小于10万看成了每个串小于10万,想不到该怎么做。

    读懂题后秒懂dp

    然后。。。

    本来不想写的,感觉就乱搞一下就行,然后还是写了。

    char comp,reverse,然后讨论16种情况。。。不想写copy了,就用了内置函数。

    写了3K

      1 #include<cstdio>
      2 #include<iostream>
      3 #include<cstring>
      4 #define maxn 100005
      5 #define inf 10000000000000005
      6 using namespace std;
      7 long long n,dp[maxn][2],x[maxn];
      8 char now[maxn],next[maxn],revnow[maxn],revnext[maxn];
      9 void rev(){
     10     int len=strlen(next);revnext[len]=0;
     11     for(int i=0;i<len;i++)
     12     revnext[len-1-i]=next[i];
     13 }
     14 bool strcomp(char* a,char* b){
     15     int lena=strlen(a),lenb=strlen(b),len=min(lena,lenb);
     16     for(int i=0;i<len;i++){
     17         if(a[i]<b[i])return 1;
     18         if(a[i]>b[i]) return 0;
     19     }
     20     if(lena>lenb) return 0;
     21     else return 1;
     22 }
     23 int main(){
     24     scanf("%I64d",&n);
     25     for(int i=1;i<=n;i++){
     26         scanf("%I64d",&x[i]);
     27     }
     28     scanf("%s",now);strcpy(next,now);rev();strcpy(revnow,revnext);
     29     dp[1][0]=0;dp[1][1]=x[1];int comp1,comp2,comp3,comp4;
     30     for(int i=2;i<=n;i++)
     31     {    
     32         scanf("%s",next);rev();
     33         comp1=strcomp(now,next);
     34         comp2=strcomp(revnow,next);
     35         comp3=strcomp(now,revnext);
     36         comp4=strcomp(revnow,revnext);
     37         if(dp[i-1][0]==inf) comp1=0,comp3=0;
     38         if(dp[i-1][1]==inf) comp2=0,comp4=0;
     39         if(comp1){
     40             if(comp2){
     41                 if(comp3){
     42                     if(comp4){
     43                         dp[i][0]=min(dp[i-1][0],dp[i-1][1]);
     44                         dp[i][1]=min(dp[i-1][0],dp[i-1][1])+x[i];
     45                     }
     46                     else{
     47                         dp[i][0]=min(dp[i-1][0],dp[i-1][1]);
     48                         dp[i][1]=dp[i-1][0]+x[i];
     49                     }
     50                 }
     51                 else{
     52                     if(comp4){
     53                         dp[i][0]=min(dp[i-1][0],dp[i-1][1]);
     54                         dp[i][1]=dp[i-1][1]+x[i];
     55                     }
     56                     else{
     57                         dp[i][0]=min(dp[i-1][0],dp[i-1][1]);
     58                         dp[i][1]=inf;
     59                     }
     60                 }
     61             }
     62             else{
     63                 if(comp3){
     64                     if(comp4){
     65                         dp[i][0]=dp[i-1][0];
     66                         dp[i][1]=min(dp[i-1][0],dp[i-1][1])+x[i];
     67                     }
     68                     else{
     69                         dp[i][0]=dp[i-1][0];
     70                         dp[i][1]=dp[i-1][0]+x[i];
     71                     }
     72                 }
     73                 else{
     74                     if(comp4){
     75                         dp[i][0]=dp[i-1][0];
     76                         dp[i][1]=dp[i-1][1]+x[i];
     77                     }
     78                     else{
     79                         dp[i][0]=dp[i-1][0];
     80                         dp[i][1]=inf;
     81                     }
     82                 }
     83             }
     84         }
     85         else{
     86             if(comp2){
     87                 if(comp3){
     88                     if(comp4){
     89                         dp[i][0]=dp[i-1][1];
     90                         dp[i][1]=min(dp[i-1][0],dp[i-1][1])+x[i];
     91                     }
     92                     else{
     93                         dp[i][0]=dp[i-1][1];
     94                         dp[i][1]=dp[i-1][0]+x[i];
     95                     }
     96                 }
     97                 else{
     98                     if(comp4){
     99                         dp[i][0]=dp[i-1][1];
    100                         dp[i][1]=dp[i-1][1]+x[i];
    101                     }
    102                     else{
    103                         dp[i][0]=dp[i-1][1];
    104                         dp[i][1]=inf;
    105                     }
    106                 }
    107             }
    108             else{
    109                 if(comp3){
    110                     if(comp4){
    111                         dp[i][0]=inf;
    112                         dp[i][1]=min(dp[i-1][0],dp[i-1][1])+x[i];
    113                     }
    114                     else{
    115                         dp[i][0]=inf;
    116                         dp[i][1]=dp[i-1][0]+x[i];
    117                     }
    118                 }
    119                 else{
    120                     if(comp4){
    121                         dp[i][0]=inf;
    122                         dp[i][1]=dp[i-1][1]+x[i];
    123                     }
    124                     else{
    125                         dp[i][0]=inf;
    126                         dp[i][1]=inf;
    127                     }
    128                 }
    129             }
    130         }
    131         strcpy(now,next);strcpy(revnow,revnext);
    132     }
    133     dp[n][0]=min(dp[n][0],dp[n][1]);
    134     if(dp[n][0]==inf) printf("-1
    ");
    135     else printf("%I64d
    ",dp[n][0]);
    136     return 0;
    137 }
    View Code

    A了以后去翻了翻cf上大神的代码

     1 #define N (1<<17)
     2 #define LL long long
     3 #define INFP (1LL<<60)
     4 #include <bits/stdc++.h>
     5 using namespace std;
     6 LL dp[N][2];
     7 int n,c[N][2];
     8 string s[N][2];
     9 int main()
    10 {
    11     cin>>n;
    12     for(int i=1;i<=n;i++)
    13         scanf("%d",&c[i][1]);
    14     for(int i=1;i<=n;i++)
    15         cin>>s[i][0],s[i][1]=s[i][0],reverse(s[i][1].begin(),s[i][1].end());
    16     for(int i=1;i<=n;i++)
    17         for(int j=0;j<2;j++)
    18         {
    19             dp[i][j]=INFP;
    20             for(int k=0;k<2;k++)
    21                 if(s[i][j]>=s[i-1][k]) dp[i][j]=min(dp[i][j],dp[i-1][k]+c[i][j]);
    22         }
    23     LL res=min(dp[n][0],dp[n][1]);
    24     cout<<(res>=INFP?-1:res)<<endl;
    25 }
    IcyGirl's Code

    。。。我傻逼

  • 相关阅读:
    POJ 1436 Horizontally Visible Segments (线段树+区间覆盖)
    HDU 4671 Backup Plan (构造)
    POJ 3325 Help with Intervals (线段树(难))
    HDU 4649 Professor Tian (位运算 + 按位DP)
    HDU 4662 MU Puzzle (YY+枚举)
    HDU 4638 Group (线段树 + 离线)
    深入浅出Node.js (附录A)
    JS的变量声明和函数声明提升
    JS基础:翻转数组
    JS基础:求一组数中的最大最小值,以及所在位置
  • 原文地址:https://www.cnblogs.com/awipppp/p/5985026.html
Copyright © 2020-2023  润新知