【codeforces】gym 101137 E - Economy Printing【dp】

题目链接：【codeforces】gym 101137 E - Economy Printing

对值排序，会发现只有最后两个元素有用，枚举他们是被压缩在哪种类型，接在哪个数后面，dp即可。

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

typedef pair < int , int > pii ;

#define clr( a , x ) memset ( a , x, sizeof a )

const int MAXN = 200005 ;
const int INF = 0x3f3f3f3f ;
int n ;

int len[MAXN] ;
int a[MAXN] ;
int dp[MAXN][4][4] ;
int f[MAXN] ;
pii p[MAXN][4][4] ;
int vis[MAXN] ;

int calc ( int x ) {
    int t = 0 ;
    while ( x ) {
        t ++ ;
        x /= 10 ;
    }
    return t ;
}

void dfs ( int n , int x , int y ) {
    if ( n == 1 ) return ;
    int nx = p[n][x][y].first ;
    int ny = x ;
    f[n] = p[n][x][y].second ;
    dfs ( n - 1 , nx , ny ) ;
}

int dfs2 ( int x ) {
    vis[x] = 1 ;
    if ( f[x] == 0 ) return x ;
    return dfs2 ( f[x] ) ;
}   

void solve () {
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%d" , &a[i] ) ;
    }
    sort ( a + 1 , a + n + 1 ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        len[i] = calc ( a[i] ) ;
    }
    clr ( f , 0 ) ;
    clr ( p , 0 ) ;
    clr ( dp , INF ) ;
    dp[0][0][0] = 0 ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        for ( int j = 0 ; j < 4 ; ++ j ) {
            for ( int k = 0 ; k < 4 ; ++ k ) if ( dp[i - 1][j][k] != INF ) {
                for ( int l = 0 ; l < 4 ; ++ l ) {
                    int tmp = dp[i - 1][j][k] + 1 + len[i] ;
                    if ( l ) tmp = tmp + 1 + len[i] ;
                    if ( l == 1 && a[i] % 2 == 0 ) continue ;
                    if ( l == 2 && a[i] % 2 == 1 ) continue ;
                    if ( dp[i][k][l] > tmp ) {
                        dp[i][k][l] = tmp ;
                        p[i][k][l] = pii ( j , 0 ) ;
                    }
                }
                if ( j == 1 || j == 2 ) {
                    if ( i > 2 && a[i] - a[i - 2] == 2 ) {
                        int tmp = dp[i - 1][j][k] + len[i] - len[i - 2] ;
                        if ( dp[i][k][j] > tmp ) {
                            dp[i][k][j] = tmp ;
                            p[i][k][j] = pii ( j , i - 2 ) ;
                        }
                    }
                }
                if ( k == 1 || k == 2 ) {
                    if ( i > 1 && a[i] - a[i - 1] == 2 ) {
                        int tmp = dp[i - 1][j][k] + len[i] - len[i - 1] ;
                        if ( dp[i][k][k] > tmp ) {
                            dp[i][k][k] = tmp ;
                            p[i][k][k] = pii ( j , i - 1 ) ;
                        }
                    }
                }
                if ( k == 3 ) {
                    if ( i > 1 && a[i] - a[i - 1] == 1 ) {
                        int tmp = dp[i - 1][j][k] + len[i] - len[i - 1] ;
                        if ( dp[i][k][k] > tmp ) {
                            dp[i][k][k] = tmp ;
                            p[i][k][k] = pii ( j , i - 1 ) ;
                        }
                    }
                }
            }
        }
    }
    int ans = INF , x = -1 , y = -1 ;
    for ( int i = 0 ; i < 4 ; ++ i ) {
        for ( int j = 0 ; j < 4 ; ++ j ) {
            if ( dp[n][i][j] < ans ) {
                ans = dp[n][i][j] ;
                x = i ;
                y = j ;
            }
        }
    }
    dfs ( n , x , y ) ;
    //printf ( "%d\n" , ans - 1 ) ;
    clr ( vis , 0 ) ;
    int flag = 0 ;
    for ( int i = n ; i >= 1 ; -- i ) if ( !vis[i] ) {
        int L = dfs2 ( i ) ;
        if ( flag ) putchar ( ',' ) ;
        flag = 1 ;
        if ( L == i ) printf ( "%d" , a[i] ) ;
        else {
            printf ( "%d" , a[L] ) ;
            if ( a[i] - a[f[i]] == 2 ) {
                if ( a[i] % 2 == 0 ) putchar ( '%' ) ;
                else putchar ( '#' ) ;
            } else putchar ( '-' ) ;
            printf ( "%d" , a[i] ) ;
        }
    }
    puts ( "" ) ;
}

int main () {
    while ( ~scanf ( "%d" , &n ) ) solve () ;
    return 0 ;
}