Problem:
Score : 400 points

Problem Statement

Takahashi will play a game using a piece on an array of squares numbered 1, 2, \cdots, N. Square i has an integer C_i written on it. Also, he is given a permutation of 1, 2, \cdots, N: P_1, P_2, \cdots, P_N.

Now, he will choose one square and place the piece on that square. Then, he will make the following move some number of times between 1 and K (inclusive):

In one move, if the piece is now on Square i (1 \leq i \leq N), move it to Square P_i. Here, his score increases by C_{P_i}.

Help him by finding the maximum possible score at the end of the game. (The score is 0 at the beginning of the game.)

Constraints

2 \leq N \leq 5000

1 \leq K \leq 10^9

1 \leq P_i \leq N

P_i \neq i

P_1, P_2, \cdots, P_N are all different.

-10^9 \leq C_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
P_1 P_2 \cdots P_N
C_1 C_2 \cdots C_N

Output

Print the maximum possible score at the end of the game.

Sample Input 1

5 2
2 4 5 1 3
3 4 -10 -8 8

Sample Output 1

8

When we start at some square of our choice and make at most two moves, we have the following options:

If we start at Square 1, making one move sends the piece to Square 2, after which the score is 4. Making another move sends the piece to Square 4, after which the score is 4 + (-8) = -4.

If we start at Square 2, making one move sends the piece to Square 4, after which the score is -8. Making another move sends the piece to Square 1, after which the score is -8 + 3 = -5.

If we start at Square 3, making one move sends the piece to Square 5, after which the score is 8. Making another move sends the piece to Square 3, after which the score is 8 + (-10) = -2.

If we start at Square 4, making one move sends the piece to Square 1, after which the score is 3. Making another move sends the piece to Square 2, after which the score is 3 + 4 = 7.

If we start at Square 5, making one move sends the piece to Square 3, after which the score is -10. Making another move sends the piece to Square 5, after which the score is -10 + 8 = -2.

The maximum score achieved is 8.

Sample Input 2

2 3
2 1
10 -7

Sample Output 2

13

Sample Input 3

3 3
3 1 2
-1000 -2000 -3000

Sample Output 3

-1000

We have to make at least one move.

Sample Input 4

10 58
9 1 6 7 8 4 3 2 10 5
695279662 988782657 -119067776 382975538 -151885171 -177220596 -169777795 37619092 389386780 980092719

Sample Output 4

29507023469

The absolute value of the answer may be enormous.

Solution in Ruby (2.7.1) (judge verdict: Runtime Error)

def g
  gets.chomp.split(' ').map(&:to_i)
end

def build_loops(n, ps)
  cnt = 0
  ret = []
  while cnt != n
    arr = []
    idx = 0
    idx += 1 while ps[idx] == -1

    while idx < n && ps[idx] != -1
      nex = ps[idx] - 1
      arr << nex
      ps[idx] = -1
      idx = nex
      cnt += 1
    end

    ret << arr
  end

  ret
end

def cross_range(arr, l, r, m)
  ls_max = nil
  l_max = m
  sum = 0
  m.downto(l) do |i|
    sum += arr[i]
    if ls_max.nil? || sum > ls_max
      ls_max = sum
      l_max = i
    end
  end

  rs_max = nil
  r_max = m + 1
  sum = 0
  (m+1).upto(r) do |i|
    sum += arr[i]
    if rs_max.nil? || sum > rs_max
      rs_max = sum
      r_max = i
    end
  end

  [l_max, r_max, ls_max + rs_max]
end

def max_range(arr, l = 0, r = arr.size - 1)
  return [l, r, arr[l]] if l == r
  mid = (l+r)/2
  l_l, l_r, l_sum = max_range(arr, l, mid)
  r_l, r_r, r_sum = max_range(arr, mid + 1, r)
  c_l, c_r, c_sum = cross_range(arr, l, r, mid)

  ma = [l_sum, r_sum, c_sum].max
  case ma
  when l_sum then [l_l, l_r, l_sum]
  when r_sum then [r_l, r_r, r_sum]
  when c_sum then [c_l, c_r, c_sum]
  end
end

def best_point(k, l, cs)
  sum = 0
  lsize = l.size
  arr = l.map { |e| n = cs[e]; sum += n; n }
  point = 0
  if sum >= 0
    point += sum * (k / lsize)
    k = k % lsize
  else
    if k >= lsize
      k = lsize
    end
  end

  # require 'pry'; binding.pry
  # loop
  arr += arr
  left = 0
  max = nil
  while left < lsize
    right = left + k - 1
    _ , _, s = max_range(arr, left, right)
    if max.nil? || s > max
      max = s
    end
    left += 1
  end

  point + max
end

# puts best_point(3, [1, 0], [10, -7])
# puts best_point(58, [8, 9, 4, 7, 1, 0], %w[695279662 988782657 -119067776 382975538 -151885171 -177220596 -169777795 37619092 389386780 980092719].map(&:to_i))
# exit 0

n, k = g
ps = g
cs = g

max = nil
loops = build_loops(n, ps)
loops.each do |loo|
  pt = best_point(k, loo, cs)
  if max.nil? || pt > max
    max = pt
  end
end

puts max