Rapport de participation au concours AtCoder Débutant 160

Percer en une minute et demie. Il suffit d'écrire.

S = input()

if S[2] == S[3] and S[4] == S[5]:
    print('Yes')
else:
    print('No')

ABC160B - Golden Coins

Percer en deux minutes et demie.500 yens c'est mieux pour cospa, donc 500 yens c'est autant que possible, et le reste est de 5 yens.

X = int(input())

result = (X // 500) * 1000
X -= (X // 500) * 500
result += (X // 5) * 5
print(result)

ABC160C - Traveling Salesman around Lake

Percer en 7 minutes. Les juges sont bloqués et le test de code a été difficile à exécuter. Faire le tour de toutes les N maisons signifie que vous n'avez pas à marcher uniquement entre le point de départ et le point final du mouvement, c'est donc le maximum Cherchez juste l'endroit.

K, N = map(int, input().split())
A = list(map(int, input().split()))

result = A[0] - A[N - 1] + K
for i in range(N - 1):
    result = max(result, A[i + 1] - A[i])
print(K - result)

ABC160D - Line++

Je suis allé à E sans le résoudre, mais aurais-je dû le résoudre?

Addendum: Évidemment, j'aurais dû résoudre ce problème. C'était très facile. Je l'ai fait. Je dois faire quelque chose à propos de ma faiblesse dans le graphique. Le plus petit est la distance la plus courte en allant directement et en déformant de X à Y, donc j'ai agrégé Juste afficher.

N, X, Y = map(int, input().split())

t = [0] * (N - 1)
for i in range(1, N):
    for j in range(i + 1, N + 1):
        t[min(j - i, abs(X - i) + 1 + abs(Y - j)) - 1] += 1
print('\n'.join(map(str, t)))

ABC160E - Red and Green Apples

J'ai pensé que je devrais le trier, l'additionner et l'écraser, mais je n'ai pas pu effacer 5 WA.

Addendum: erreur Off-by-One. ʻOk: = max (0, Y- (C- (X-i))) - -1 sur 1` manquait orz.

Même si vous triez par ordre décroissant et additionnez la somme cumulée, TLE est inévitable car la quantité de calcul est de 10 ^{10 </ sup> si vous doublez les boucles X et Y. Par conséquent, le nombre de pommes rouges en train de manger des boucles. , Le nombre de pommes vertes consommées sera déterminé par une dichotomie. Si vous bouclez le nombre de pommes vertes consommées, le goût total devrait augmenter de façon monotone puis diminuer de façon monotone de quelque part. Recherche de points par dichotomie Dans ce cas, il n'y a pas de problème car la quantité de calcul est d'environ 1,7 * 10 ^{6 </ sup>.}}

Eh bien, comme vous pouvez le voir dans le PDF des commentaires, vous pouvez le résoudre sans faire des choses aussi ennuyeuses, mais comme un enregistrement que vous pourriez résoudre comme ça.

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

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

func main() {
	X := readInt()
	Y := readInt()
	A := readInt()
	B := readInt()
	C := readInt()

	p := make([]int, A+1)
	q := make([]int, B+1)
	r := make([]int, C+1)

	for i := 0; i < A; i++ {
		p[i+1] = readInt()
	}
	for i := 0; i < B; i++ {
		q[i+1] = readInt()
	}
	for i := 0; i < C; i++ {
		r[i+1] = readInt()
	}

	sort.Sort(sort.Reverse(sort.IntSlice(p[1:])))
	sort.Sort(sort.Reverse(sort.IntSlice(q[1:])))
	sort.Sort(sort.Reverse(sort.IntSlice(r[1:])))

	for i := 1; i < A; i++ {
		p[i+1] += p[i]
	}
	for i := 1; i < B; i++ {
		q[i+1] += q[i]
	}
	for i := 1; i < C; i++ {
		r[i+1] += r[i]
	}

	result := 0
	for i := max(0, X-C); i <= X; i++ {
		ok := max(0, Y-(C-(X-i))) - 1
		ng := Y
		for ng-ok != 1 {
			m := ok + (ng-ok)/2
			t0 := q[m] + r[(X-i)+(Y-m)]
			t1 := q[m+1] + r[(X-i)+(Y-(m+1))]
			if t0 < t1 {
				ok = m
			} else {
				ng = m
			}
		}
		j := ok + 1
		result = max(result, p[i]+q[j]+r[(X-i)+(Y-j)])
	}

	fmt.Println(result)
}

const (
	ioBufferSize = 1 * 1024 * 1024 // 1 MB
)

var stdinScanner = func() *bufio.Scanner {
	result := bufio.NewScanner(os.Stdin)
	result.Buffer(make([]byte, ioBufferSize), ioBufferSize)
	result.Split(bufio.ScanWords)
	return result
}()

func readString() string {
	stdinScanner.Scan()
	return stdinScanner.Text()
}

func readInt() int {
	result, err := strconv.Atoi(readString())
	if err != nil {
		panic(err)
	}
	return result
}