HDU 4433 locker（DP）（2012 Asia Tianjin Regional Contest）

Problem Description

A password locker with N digits, each digit can be rotated to 0-9 circularly.
You can rotate 1-3 consecutive digits up or down in one step.
For examples:
567890 -> 567901 (by rotating the last 3 digits up)
000000 -> 000900 (by rotating the 4th digit down)
Given the current state and the secret password, what is the minimum amount of steps you have to rotate the locker in order to get from current state to the secret password?

 

Input

Multiple (less than 50) cases, process to EOF.
For each case, two strings with equal length (≤ 1000) consists of only digits are given, representing the current state and the secret password, respectively.

 

Output

For each case, output one integer, the minimum amount of steps from the current state to the secret password.

题目大意：从一串数字转成另一串数字，每次操作可以把连续的1~3个数字都+1或者-1（9+1=0，0-1=9），问最少须要多少次操作。

思路：DP。dp[i][x][y]表示，把第一个字符串变为第 i 位是 x，第 i-1 位是 y， i-1前面的全部都与第二个字符串相同，最少须要多少步。

假设第一串数字是a[]，第二串数字是b[]

那么状态转移就是，对于每一个dp[i][x][y]，判断从a[i]须要转多少步操作才能到x（两种操作都要枚举），设为k，然后枚举 i-1 跟着转多少步才能到达 y，设为p（p≤k），再枚举 i-2 须要跟着转多少步才能到达b[i]，设为q（q≤p）。详见代码。

最终答案为dp[n][b[n]][b[n-1]]

代码（203MS）：

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <cstring>
 using namespace std;
 typedef long long LL;

 const int MAXN = ;

 int a[MAXN], b[MAXN], n;
 int dp[MAXN][][];
 char s[MAXN];

 inline int make(int x) {
     if(x < ) x += ;
     if(x > ) x -= ;
     return x;
 }

 inline void update_min(int &a, const int &b) {
     if(a > b) a = b;
 }

 inline int calc(int x, int y) {
     if(x > y) y += ;
     return y - x;
 }

 int solve() {
     memset(dp, 0x3f, sizeof(dp));
     dp[][a[]][] = ;
     for(int i = ; i <= ; ++i) {
         update_min(dp[][make(a[] + i)][], i);
         update_min(dp[][make(a[] - i)][], i);
     }
     for(int i = ; i <= n; ++i) {
         for(int x = ; x <= ; ++x) {
             for(int y = ; y <= ; ++y) {
                 int k = calc(a[i], x);
                 for(int p = ; p <= k; ++p) {
                     for(int q = ; q <= p; ++q)
                         update_min(dp[i][x][y], dp[i - ][make(y - p)][make(b[i - ] - q)] + k);
                 }

                 k =  - k;
                 for(int p = ; p <= k; ++p) {
                     for(int q = ; q <= p; ++q)
                         update_min(dp[i][x][y], dp[i - ][make(y + p)][make(b[i - ] + q)] + k);
                 }
             }
         }
     }
     return dp[n][b[n]][b[n - ]];
 }

 int main() {
     while(scanf("%s", s) != EOF) {
         n = strlen(s);
         for(int i = ; i < n; ++i) a[i + ] = s[i] - '';
         scanf("%s", s);
         for(int i = ; i < n; ++i) b[i + ] = s[i] - '';
         printf("%d\n", solve());
     }
 }