#include <iostream>
#include <cstddef>
#include <string>
#include <vector>
#include <algorithm>

template<size_t P>
struct static_factorial{
  static const size_t value = static_factorial<P-1>::value * P;
};
template<>
struct static_factorial<0>{
  static const size_t value = 1;
};

template<char C, char... Cs>
struct debug_output{

  template<typename T, typename ... Ts>
  inline void operator() (T param, Ts ... params) {
    std::cout << C << '=' << param << "::" << typeid(T).name() << ", ";
    debug_output<Cs ...>()(params ...);
  }
};

template<char D>
struct debug_output<D>{

  template<typename T>
  inline void operator() (T param) {
    std::cout << D << '=' << param << "::" << typeid(T).name() << std::endl;
  }
};

size_t dist(const std::string &a, const std::string &b){
    size_t size_a = a.size();
    size_t size_b = b.size();
    std::vector<std::vector<size_t>> mtx;
    mtx.resize(size_a + 1);
    for(auto &r: mtx){
        r.resize(size_b + 1);
    }

    for(size_t i = 0; i <= size_a; ++i){
      mtx[i][0] = i;
    }
    for(size_t i = 0; i <= size_b; ++i){
      mtx[0][i] = i;
    }
    for(size_t i = 0; i < size_a; i++)
      for(size_t j = 0; j < size_b; j++){
        int subcost;
        if(a[i] == b[j]) subcost = 0;
        else subcost = 1;

        mtx[i+1][j+1] = std::min({mtx[i][j+1] + 1, mtx[i+1][j]+1, mtx[i][j] + subcost});
      }
      return mtx[size_a][size_b];
}

int main() {
  
#define TEST3

#ifdef TEST1
  std::cout << static_factorial<10>::value << std::endl;
#endif

#ifdef TEST2
  int a=5;
  int b=3;
  std::string test="asdasd";

  debug_output<'x'>()("asdasdad"); //vypise: x=543543::i
  debug_output<'a', 't'>()(a, test); //vypise: a=5, t=asdasd::string
  debug_output<'a', 't', 'x'>()(a, test, 666);
#endif

#ifdef TEST3
  std::string a,b;
  std::getline(std::cin, a);
  std::getline(std::cin, b);
  std::cout << dist(a,b) <<std::endl;
#endif

  return 0;

}