术式终端的并行调度

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	var n, c, m int
	fmt.Fscan(reader, &n, &c, &m)
	type task struct {
		cpu int
		mem int
		val int
	}
	full := 1 << n
	validval := make([]int, full)
	tasks := make([]task, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &tasks[i].cpu, &tasks[i].mem, &tasks[i].val)
	}
	for mask := 0; mask < full; mask++ {
		csum, msum, vsum, temp := 0, 0, 0, mask
		len := bits.Len(uint(mask))
		for i := 0; i < len; i++ {
			if temp&1 == 1 {
				csum += tasks[i].cpu
				msum += tasks[i].mem
				vsum += tasks[i].val
			}
			temp = temp >> 1
		}
		if csum <= c && msum <= m {
			validval[mask] = vsum
		}
	}
	dp := make([][]int, n+1)
	for i := 0; i <= n; i++ {
		dp[i] = make([]int, full)
		for j := 0; j < full; j++ {
			dp[i][j] = -1
		}
	}
	dp[0][0] = 0
	for k := 1; k <= n; k++ {
		for mask := 1; mask < full; mask++ {
			sub := mask
			for sub > 0 {
				if validval[sub] != 0 {
					pre := mask ^ sub
					if dp[k-1][pre] != -1 {
						dp[k][mask] = fmax(dp[k][mask], dp[k-1][pre]+validval[sub])
					}
				}
				sub = (sub - 1) & mask
			}
		}
	}

	exact := make([]int, n+1)
	for k := 1; k <= n; k++ {
		best := 0
		for mask := 0; mask < full; mask++ {
			if dp[k][mask] > best {
				best = dp[k][mask]
			}
		}
		exact[k] = best
	}

	ans := make([]int, n+1)
	for k := 1; k <= n; k++ {
		if exact[k] > ans[k-1] {
			ans[k] = exact[k]
		} else {
			ans[k] = ans[k-1]
		}
		fmt.Fprintln(writer, ans[k])
	}

}
func fmax(a, b int) int {
	if a > b {
		return a
	}
	return b
}