#include <bits/stdc++.h>
inline __attribute__((always_inline)) void init_io() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.tie(nullptr);
  std::fixed(std::cout).precision(10);
}
template <typename... Args>
inline __attribute__((always_inline)) bool read(Args&... args) {
  return (bool)(std::cin >> ... >> args);
}
template <typename... Args>
inline __attribute__((always_inline)) void write(Args&&... args) {
  (std::cout << ... << std::forward<Args>(args));
}
template <class... Args>
inline __attribute__((always_inline)) void writeln(Args&&... args) {
  write(std::forward<Args>(args)..., '\n');
}
inline __attribute__((always_inline)) void flush() { std::flush(std::cout); }
constexpr int8_t operator""_i8(unsigned long long val) { return val; }
constexpr uint8_t operator""_u8(unsigned long long val) { return val; }
constexpr int16_t operator""_i16(unsigned long long val) { return val; }
constexpr uint16_t operator""_u16(unsigned long long val) { return val; }
constexpr int32_t operator""_i32(unsigned long long val) { return val; }
constexpr uint32_t operator""_u32(unsigned long long val) { return val; }
constexpr int64_t operator""_i64(unsigned long long val) { return val; }
constexpr uint64_t operator""_u64(unsigned long long val) { return val; }
using graph_t = std::vector<std::vector<int>>;
void get_depth_size_impl(const graph_t& g, std::vector<int>& depth,
                         std::vector<int>& size, int v, int p, int d) {
  depth[v] = d;
  int sz = 1;
  for (int u : g[v]) {
    if (u == p) continue;
    get_depth_size_impl(g, depth, size, u, v, d + 1);
    sz += size[u];
  }
  size[v] = sz;
}
std::pair<std::vector<int>, std::vector<int>> get_depth_size(const graph_t& g,
                                                             int root) {
  std::vector<int> depth(g.size());
  std::vector<int> size(g.size());
  get_depth_size_impl(g, depth, size, root, -1, 0);
  return {depth, size};
}
int main() {
  init_io();
  int n, k;
  read(n, k);
  graph_t g(n);
  for (int i = 1; i < n; ++i) {
    int a, b;
    read(a, b);
    --a, --b;
    g[a].push_back(b);
    g[b].push_back(a);
  }
  auto [depth, size] = get_depth_size(g, 0);
  struct score_t {
    int score;
    int v;
  };
  std::vector<int> scores(n);
  for (int i = 0; i < n; ++i) scores[i] = depth[i] - (size[i] - 1);
  std::nth_element(scores.begin(), scores.begin() + k, scores.end(),
                   std::greater<int>());
  int64_t total = 0;
  for (int i = 0; i < k; ++i) total += scores[i];
  writeln(total);
  return 0;
}
