package main
import (
"bufio"
"container/heap"
"fmt"
"os"
"sort"
)
type FastScanner struct {
r *bufio.Reader
}
func NewFastScanner() *FastScanner {
return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}
func (fs *FastScanner) NextInt() int64 {
sign := int64(1)
val := int64(0)
c, _ := fs.r.ReadByte()
for (c < '0' || c > '9') && c != '-' {
c, _ = fs.r.ReadByte()
}
if c == '-' {
sign = -1
c, _ = fs.r.ReadByte()
}
for c >= '0' && c <= '9' {
val = val*10 + int64(c-'0')
c, _ = fs.r.ReadByte()
}
return val * sign
}
type Item struct {
key float64
idx int
a int64
b int64
}
type MinHeap []Item
func (h MinHeap) Len() int { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i].key < h[j].key }
func (h MinHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *MinHeap) Push(x interface{}) { *h = append(*h, x.(Item)) }
func (h *MinHeap) Pop() interface{} {
old := *h
n := len(old)
it := old[n-1]
*h = old[:n-1]
return it
}
func buildTopRIndices(a, b []int64, r int, alpha float64) ([]int, int64, int64) {
n := len(a)
tiny := 1e-9
h := &MinHeap{}
heap.Init(h)
var sumA, sumB int64
for i := 0; i < n; i++ {
key := alpha*float64(a[i]) + (1.0-alpha)*float64(b[i]) + float64(i)*tiny
if h.Len() < r {
heap.Push(h, Item{key: key, idx: i, a: a[i], b: b[i]})
sumA += a[i]
sumB += b[i]
} else {
if key > (*h)[0].key {
top := heap.Pop(h).(Item)
sumA -= top.a
sumB -= top.b
heap.Push(h, Item{key: key, idx: i, a: a[i], b: b[i]})
sumA += a[i]
sumB += b[i]
}
}
}
indices := make([]int, h.Len())
for i := 0; i < len(indices); i++ {
it := heap.Pop(h).(Item)
indices[i] = it.idx
}
return indices, sumA, sumB
}
func slopeSumTopR(a, b []int64, r int, alpha float64) int64 {
n := len(a)
tiny := 1e-9
h := &MinHeap{}
heap.Init(h)
var slopeSum int64
for i := 0; i < n; i++ {
key := alpha*float64(a[i]) + (1.0-alpha)*float64(b[i]) + float64(i)*tiny
if h.Len() < r {
heap.Push(h, Item{key: key, idx: i, a: a[i], b: b[i]})
slopeSum += (a[i] - b[i])
} else {
if key > (*h)[0].key {
top := heap.Pop(h).(Item)
slopeSum -= (top.a - top.b)
heap.Push(h, Item{key: key, idx: i, a: a[i], b: b[i]})
slopeSum += (a[i] - b[i])
}
}
}
return slopeSum
}
func checkAndPrint(S []int, a, b []int64, sumAAll, sumBAll int64, r int) bool {
if len(S) > r {
S = S[:r]
}
used := make([]bool, len(a))
var sa, sb int64
for _, idx := range S {
if !used[idx] {
used[idx] = true
sa += a[idx]
sb += b[idx]
}
}
if 2*sa > sumAAll && 2*sb > sumBAll {
fmt.Println(len(S))
for i := 0; i < len(S); i++ {
if i > 0 {
fmt.Print(" ")
}
fmt.Print(S[i] + 1)
}
fmt.Println()
return true
}
return false
}
func padToR(base []int, order []int, r int) []int {
if len(base) >= r {
return base[:r]
}
used := make(map[int]bool, len(base))
for _, x := range base {
used[x] = true
}
out := make([]int, 0, r)
out = append(out, base...)
for _, idx := range order {
if !used[idx] {
out = append(out, idx)
used[idx] = true
if len(out) == r {
break
}
}
}
return out
}
func main() {
in := NewFastScanner()
n := int(in.NextInt())
a := make([]int64, n)
b := make([]int64, n)
var sumAAll, sumBAll int64
for i := 0; i < n; i++ {
a[i] = in.NextInt()
sumAAll += a[i]
}
for i := 0; i < n; i++ {
b[i] = in.NextInt()
sumBAll += b[i]
}
r := n/2 + 1
// Precompute orders
idxAll := make([]int, n)
for i := 0; i < n; i++ {
idxAll[i] = i
}
// by d = a-b ascending
byD := make([]int, n)
copy(byD, idxAll)
sort.Slice(byD, func(i, j int) bool {
di := a[byD[i]] - b[byD[i]]
dj := a[byD[j]] - b[byD[j]]
if di == dj {
return byD[i] < byD[j]
}
return di < dj
})
// by a+b descending for padding
byApBDesc := make([]int, n)
copy(byApBDesc, idxAll)
sort.Slice(byApBDesc, func(i, j int) bool {
si := a[byApBDesc[i]] + b[byApBDesc[i]]
sj := a[byApBDesc[j]] + b[byApBDesc[j]]
if si == sj {
return byApBDesc[i] < byApBDesc[j]
}
return si > sj
})
// Alpha-based search
low, high := 0.0, 1.0
for it := 0; it < 28; it++ {
mid := (low + high) / 2.0
ss := slopeSumTopR(a, b, r, mid)
G := 2*ss - (sumAAll - sumBAll)
if G < 0 {
low = mid
} else {
high = mid
}
}
var alphaCandidates []float64
addAlpha := func(x float64) {
if x < 0 {
x = 0
}
if x > 1 {
x = 1
}
alphaCandidates = append(alphaCandidates, x)
}
addAlpha(0.0)
addAlpha(1.0)
addAlpha(low)
addAlpha(high)
addAlpha((low + high) / 2.0)
addAlpha(low - 1e-6)
addAlpha(high + 1e-6)
addAlpha(0.25)
addAlpha(0.5)
addAlpha(0.75)
seenAlpha := make(map[int64]bool)
for _, alpha := range alphaCandidates {
key := int64(alpha * 1e12)
if seenAlpha[key] {
continue
}
seenAlpha[key] = true
S, sa, sb := buildTopRIndices(a, b, r, alpha)
if 2*sa > sumAAll && 2*sb > sumBAll {
fmt.Println(len(S))
for i := 0; i < len(S); i++ {
if i > 0 {
fmt.Print(" ")
}
fmt.Print(S[i] + 1)
}
fmt.Println()
return
}
}
// Structured candidates based on byD
m := n / 2
// L and R halves
L := make([]int, 0, m)
R := make([]int, 0, m)
for i := 0; i < m; i++ {
L = append(L, byD[i])
}
for i := n - 1; i >= n-m; i-- {
if i >= 0 {
R = append(R, byD[i])
}
}
// L plus best A from R
if len(L) < r {
best := -1
var bestA int64 = -1
for _, idx := range R {
if a[idx] > bestA {
bestA = a[idx]
best = idx
}
}
cand := append([]int{}, L...)
if best != -1 {
cand = append(cand, best)
}
cand = padToR(cand, byApBDesc, r)
if checkAndPrint(cand, a, b, sumAAll, sumBAll, r) {
return
}
}
// R plus best B from L
if len(R) < r {
best := -1
var bestB int64 = -1
for _, idx := range L {
if b[idx] > bestB {
bestB = b[idx]
best = idx
}
}
cand := append([]int{}, R...)
if best != -1 {
cand = append(cand, best)
}
cand = padToR(cand, byApBDesc, r)
if checkAndPrint(cand, a, b, sumAAll, sumBAll, r) {
return
}
}
// Odds in byD
odds := []int{}
for i := 0; i < n; i += 2 {
odds = append(odds, byD[i])
}
if len(odds) < r {
odds = append(odds, byD[n-1])
}
odds = padToR(odds, byApBDesc, r)
if checkAndPrint(odds, a, b, sumAAll, sumBAll, r) {
return
}
// Evens in byD
evens := []int{}
for i := 1; i < n; i += 2 {
evens = append(evens, byD[i])
}
if len(evens) < r {
evens = append(evens, byD[0])
}
evens = padToR(evens, byApBDesc, r)
if checkAndPrint(evens, a, b, sumAAll, sumBAll, r) {
return
}
// Pick per pair by larger a
candA := []int{}
for i := 0; i < m; i++ {
l := byD[i]
rg := byD[n-1-i]
if a[l] >= a[rg] {
candA = append(candA, l)
} else {
candA = append(candA, rg)
}
}
if n%2 == 1 {
candA = append(candA, byD[m])
}
candA = padToR(candA, byApBDesc, r)
if checkAndPrint(candA, a, b, sumAAll, sumBAll, r) {
return
}
// Pick per pair by larger b
candB := []int{}
for i := 0; i < m; i++ {
l := byD[i]
rg := byD[n-1-i]
if b[l] >= b[rg] {
candB = append(candB, l)
} else {
candB = append(candB, rg)
}
}
if n%2 == 1 {
candB = append(candB, byD[m])
}
candB = padToR(candB, byApBDesc, r)
if checkAndPrint(candB, a, b, sumAAll, sumBAll, r) {
return
}
// Fallback: top r by a+b
cand := make([]int, 0, r)
for i := 0; i < r && i < n; i++ {
cand = append(cand, byApBDesc[i])
}
if checkAndPrint(cand, a, b, sumAAll, sumBAll, r) {
return
}
// As ultimate fallback (shouldn't happen), output first r indices
cand = make([]int, 0, r)
for i := 0; i < r && i < n; i++ {
cand = append(cand, i)
}
fmt.Println(len(cand))
for i := 0; i < len(cand); i++ {
if i > 0 {
fmt.Print(" ")
}
fmt.Print(cand[i] + 1)
}
fmt.Println()
}