uva 1631

1631 Locker

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.

Sample Input

111111 222222

896521 183995

Sample Output

2

12

记忆化搜索

从第一个开始，枚举向上或向下转1个，2个，3个的情况，然后记忆化搜索，注意最后一个字符在处理时要使第n + 1,n + 2个的初始和末状态相同。

#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define INF 100000
#define ll long long
#define _cle(m, a) memset(m, a, sizeof(m))
#define repu(i, a, b) for(int i = a; i < b; i++)
#define MAXN 1005
char sa[MAXN], sb[MAXN];
int a[MAXN], b[MAXN];
int d[MAXN][][];
int n;

int up(int s, int t)
{
    if(s <= t) return t - s;
    return ( + t - s);
}

int down(int s, int t)
{
    if(s >= t) return s - t;
    return ( + s - t);
}

int dp(int d1, int d2, int d3)
{
    if(d1 >= n) return ;
    if(d[d1][d2][d3] != -) return d[d1][d2][d3];
    int t, minn = INF;
    t = up(d2, b[d1]);
    repu(i, , t + )
      repu(j, i, t + )
       minn = min(minn, dp(d1 + , (d3 + j) % , (a[d1 + ] + i) % ) + t);
    t = down(d2, b[d1]);
    repu(i, , t + )
      repu(j, i, t + )
       minn = min(minn, dp(d1 + , (d3 - j + ) % , (a[d1 + ] - i + ) % ) + t);
    return d[d1][d2][d3] = minn;
}

int main()
{
    while(~scanf("%s%s", sa, sb))
    {
        n = strlen(sa);
        repu(i, , n) a[i] = sa[i] - '';
        repu(i, , n) b[i] = sb[i] - '';
        a[n] = a[n + ] = b[n] = b[n + ] = ;

        _cle(d, -);
        printf("%d\n", dp(, a[], a[]));
    }
    return ;
}