```go
package main

import (
	"bufio"
	"io"
	"math/bits"
	"os"
	"strconv"
)

func mwis(weights []int64, adj []uint64) int64 {
	k := len(weights)
	if k == 0 {
		return 0
	}

	k1 := k / 2
	k2 := k - k1

	var leftLimit uint64
	if k1 > 0 {
		leftLimit = (uint64(1) << uint(k1)) - 1
	}
	var rightLimit uint64
	if k2 > 0 {
		rightLimit = (uint64(1) << uint(k2)) - 1
	}

	adjLL := make([]int, k1)
	adjLR := make([]uint32, k1)
	for i := 0; i < k1; i++ {
		adjLL[i] = int(adj[i] & leftLimit)
		if k2 > 0 {
			adjLR[i] = uint32((adj[i] >> uint(k1)) & rightLimit)
		}
	}

	adjRR := make([]int, k2)
	for j := 0; j < k2; j++ {
		idx := k1 + j
		if k2 > 0 {
			adjRR[j] = int((adj[idx] >> uint(k1)) & rightLimit)
		}
	}

	rightSize := 1 << uint(k2)
	dp := make([]int64, rightSize)
	for i := 1; i < rightSize; i++ {
		dp[i] = -1
	}
	for mask := 1; mask < rightSize; mask++ {
		lb := mask & -mask
		v := bits.TrailingZeros(uint(lb))
		pm := mask ^ lb
		if dp[pm] >= 0 && (adjRR[v]&pm) == 0 {
			dp[mask] = dp[pm] + weights[k1+v]
		} else {
			dp[mask] = -1
		}
	}

	for i := 0; i < k2; i++ {
		bit := 1 << uint(i)
		for mask := 0; mask < rightSize; mask++ {
			if mask&bit != 0 && dp[mask^bit] > dp[mask] {
				dp[mask] = dp[mask^bit]
			}
		}
	}

	ans := dp[rightSize-1]

	leftSize := 1 << uint(k1)
	leftW := make([]int64, leftSize)
	leftAllow := make([]uint32, leftSize)
	for i := 1; i < leftSize; i++ {
		leftW[i] = -1
	}
	var allR uint32
	if k2 > 0 {
		allR = uint32(rightSize - 1)
	}
	leftAllow[0] = allR

	for mask := 1; mask < leftSize; mask++ {
		lb := mask & -mask
		v := bits.TrailingZeros(uint(lb))
		pm := mask ^ lb
		if leftW[pm] >= 0 && (adjLL[v]&pm) == 0 {
			leftW[mask] = leftW[pm] + weights[v]
			leftAllow[mask] = leftAllow[pm] &^ adjLR[v]
			cand := leftW[mask] + dp[int(leftAllow[mask])]
			if cand > ans {
				ans = cand
			}
		} else {
			leftW[mask] = -1
		}
	}

	return ans
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') {
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return val
	}

	n := nextInt()
	m := nextInt()

	forced := make([]bool, m)
	adjOrig := make([]uint64, m)

	first := nextInt() - 1
	prev := first
	for i := 1; i < n; i++ {
		cur := nextInt() - 1
		if prev == cur {
			forced[prev] = true
		} else {
			adjOrig[prev] |= uint64(1) << uint(cur)
			adjOrig[cur] |= uint64(1) << uint(prev)
		}
		prev = cur
	}
	last := prev

	forced[first] = true
	forced[last] = true

	cost := make([]int64, m)
	for i := 0; i < m; i++ {
		cost[i] = int64(nextInt())
	}

	mapNew := make([]int, m)
	for i := 0; i < m; i++ {
		mapNew[i] = -1
	}

	var forcedCost int64
	var totalRem int64
	weights := make([]int64, 0, m)
	for i := 0; i < m; i++ {
		if forced[i] {
			forcedCost += cost[i]
		} else {
			mapNew[i] = len(weights)
			weights = append(weights, cost[i])
			totalRem += cost[i]
		}
	}

	adjNew := make([]uint64, len(weights))
	for i := 0; i < m; i++ {
		ni := mapNew[i]
		if ni == -1 {
			continue
		}
		var mask uint64
		for j := 0; j < m; j++ {
			if adjOrig[i]&(uint64(1)<<uint(j)) != 0 {
				nj := mapNew[j]
				if nj != -1 {
					mask |= uint64(1) << uint(nj)
				}
			}
		}
		adjNew[ni] = mask
	}

	maxIS := mwis(weights, adjNew)
	ans := forcedCost + totalRem - maxIS

	out := bufio.NewWriter(os.Stdout)
	out.WriteString(strconv.FormatInt(ans, 10))
	out.WriteByte('\n')
	out.Flush()
}
```