Une personne qui veut résoudre le problème D avec ABC d'AtCoder a essayé de gratter

introduction

Objectif

à partir de maintenant

Lien vers le problème

Répondre

ABC 142 D

import math 

A, B = [int(item) for item in input().split()]

def gdc(A, B):
    if B == 0:
        return A
    else:
        return gdc(B, A % B)

def chk_pn(num):
    flag = True
    if num  <= 3:
        pass
    else:    
        for i in range(2, int(math.sqrt(num)) + 1):
            if num % i == 0:
                flag = False
                break
    return flag

def mk_factor(num):
    max_divisor = int(math.sqrt(num))+1
    divisor = 2
    factor_list = [1]

    while divisor <= max_divisor:
        if num % divisor == 0:
            factor_list.append(divisor)
            num /= divisor
        else:
            divisor += 1
    
    factor_list.append(num) #N'oubliez pas d'inclure le nombre restant dans la fraction
    return factor_list

GDC = gdc(A, B)
pn_factor = [i for i in mk_factor(GDC) if chk_pn(i) is True]
# print(pn_factor)
print(len(set(pn_factor)))

ABC 141 D


import heapq as hp
N, M = [int(item) for item in input().split()]
price_list = sorted([-1 * int(item) for item in input().split()])

total_m = 0

def discount(price_list, ticket_num):
    total_ticket =0
    hp.heapify(price_list)

    while total_ticket < ticket_num:
        temp = hp.heappop(price_list)
        hp.heappush(price_list, -1* (-1*temp//2))
        total_ticket += 1

    return price_list

res = discount(price_list, M)
print(res)
print(-1 * sum(res))

ABC 140 D

     def compress(arr):
    """La personne qui s'est comprimée et a disparu est heureuse"""
    cnt_h = 0
    new_arr = []
    comp_arr = ['L']

    #Dans un premier temps, définissez le début sur L. Cette rotation est interdite
    if arr[0] == 'R':
        for item in arr:
            if item == 'L':
                new_arr.append('R')
            else:
                new_arr.append('L')

            prev_item = item
    else:
        new_arr = arr
    #Compter les opérations de compression et les bribes compressées

    for i in range(1, N):
        if new_arr[i - 1] == new_arr[i]:
            cnt_h += 1
        else:
            comp_arr.append(new_arr[i])

    return [comp_arr, cnt_h] 


def execute(arr, cnt_h, K):
    #Nombre d'opérations nécessaires pour inverser toutes les limites
    max_rotation = len(arr)//2
    #Il se termine lorsque tout devient L ou que le nombre d'inversions atteint K
    if max_rotation <= K:
        cnt_h += len(arr) - 1
    else:
        cnt_h += 2*K

    return cnt_h

ABC 139 D

N = int(input())
print((N-1)*N //2 )

ABC 138 D

version de la liste python

N, Q = [int(item) for item in input().split()]

tree_list = [input().split() for j in range(1, N)]

query_list = [input().split() for k in range(Q)]
query_list_int = [[int(k) for k in i] for i in query_list]

val_list = [0 for _ in range(N)]

linked_node_list = [[] for _ in range(N)]

#Créer une relation de lien pour les graphiques non dirigés (y compris les connexions en amont)
for a, b in tree_list:
    a, b = int(a)-1, int(b) -1
    linked_node_list[a].append(b) #Ajouter un enfant
    linked_node_list[b].append(a) #Ajouter un parent


for index, val in query_list_int:
    val_list[index-1] += val

stack = [0] #Générer une pile contenant la valeur du nœud racine et stocker la cible à patrouiller
parent = [0] * (N+1) #Stocke une pile qui stocke les nœuds visités

#Si vous utilisez une fonction récursive, vous serez bloqué dans la limite de mémoire, alors exécutez-la séquentiellement avec while
#Utilisez LIFO dans la pile. Puisqu'il devient un LIFO, vous pouvez rechercher de la profondeur tout en regardant le plus jeune.
#Souvenez-vous du nœud parent et essayez de jouer
#Si vous le définissez avec un graphe orienté, vous n'avez pas besoin de jouer le parent

while True:
    #Patrouiller dans l'ordre depuis la route
    v=stack.pop()
    for child in linked_node_list[v]:
        if child != parent[v]:
            parent[child] = v #Stocker les nœuds visités
            stack.append(child) #Stocker le nœud de destination de connexion de ce nœud v dans la pile
            val_list[child] += val_list[v] #Somme cumulée
    if not stack:
        #La patrouille se termine lorsque la pile est épuisée
        break

print(*val_list)

version de l'objet nœud pypy3


from collections import deque
N, Q = [int(item) for item in input().split()]

tree_list = [input().split() for j in range(1, N)]
query_list = [input().split() for k in range(Q)]


class Node:
    def __init__(self, val):
        self.val = val
        self.child_list = []
        self.cnt = 0

class my_tree:
    def __init__(self, tree_list):
        self.node_list = []

        for i in range(N):
            self.node_list.append(Node(i+1))

        for a, b in tree_list:
            a, b = int(a), int(b)

            child_node = self.node_list[b-1]
            parent_node = self.node_list[a-1]
            self.node_list[a-1].child_list.append(child_node)
            self.node_list[b-1].child_list.append(parent_node)

    def adding(self, query_list):
        for a, data in query_list:
            a, data = int(a), int(data)
            self.node_list[a-1].cnt += data

        stack = deque([self.node_list[0]])
        parent_node_list = [self.node_list[0]]*(N + 1)

        while True:
            v = stack.pop()
            for child in v.child_list:
                if child != parent_node_list[v.val -1]:
                    child.cnt += v.cnt
                    parent_node_list[child.val -1] = v
                    stack.append(child)

            if not stack:
                break


ins = my_tree(tree_list)
ins.adding(query_list)
print(*[node.cnt for node in ins.node_list])

Problèmes pour pratiquer le problème D

Disco2020 B


N = int(input())
A_list = [int(item) for item in input().split()]

all_sum = sum(A_list)

F_sum_list = [A_list[0]]

for j in range(1,N):
    F_sum_list.append(F_sum_list[-1] + A_list[j])

delta_list = [abs(all_sum - 2* i) for i in F_sum_list]

print(min(delta_list))

ABC 146 C


A, B, X = [int(item) for item in input().split()]
res_list = []
left = 1 -1
right = 10 ** 9 + 1

is_search = True

while is_search:
    N = (left + right)//2
    res = A * N + B * len(str(N))

    if res > X:
        right = N
    elif res <= X:
        res_list.append(N)
        left = N

    if right - left <= 1:
        is_search = False

if res_list == []:
    print(0)
else:
    print(max(res_list))
import math
 
A, B, X = [int(item) for item in input().split()]
 
res = 0
res_list = []
delta = 10**9 // 4
N= 10**9 // 2
 
 
is_search = True
 
while is_search:
    res = A * N + B * len(str(N))
    if res > X:
        N = N -delta
    elif res <= X:
        res_list.append(N)
        N = N + delta
 
    if delta <= 0:
        break
 
    delta = delta // 2 
 
new_res_list = []
for i in range(N - 1000, N + 1000):
    res = A * i + B * len(str(i))
    if res <= X:
        new_res_list.append(i)
 
 
if new_res_list == [] or max(new_res_list) <1:
    print(0)
else:
    if 1<= max(new_res_list) < 10**9:
        print(max(new_res_list))
    else:
        print(10**9)

Recommended Posts

Une personne qui veut résoudre le problème D avec ABC d'AtCoder a essayé de gratter
Je voulais résoudre le problème ABC164 A ~ D avec Python
[AtCoder] Résoudre un problème de ABC101 ~ 169 avec Python
[Explication AtCoder] Contrôlez les problèmes A, B, (C), D de ABC165 avec Python!
[Explication AtCoder] Contrôlez les problèmes A, B, C, D d'ABC181 avec Python!
[AtCoder] Résoudre ABC1 ~ 100 Un problème avec Python
Résoudre AtCoder ABC168 avec python (A ~ D)
[Explication AtCoder] Contrôlez les problèmes A, B, C d'ABC182 avec Python!
[Explication AtCoder] Contrôle ABC184 Problèmes A, B, C avec Python!
Défiez AtCoder (ABC) 164 avec Python! Un problème ~ C
J'ai essayé de créer un modèle avec l'exemple d'Amazon SageMaker Autopilot
J'ai essayé de résoudre le problème avec Python Vol.1
J'ai essayé de visualiser les caractéristiques des nouvelles informations sur les personnes infectées par le virus corona avec wordcloud
Le 15e temps réel hors ligne, j'ai essayé de résoudre le problème de l'écriture avec python
J'ai essayé de trouver l'entropie de l'image avec python
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai essayé de résoudre le problème de F02 comment écrire en temps réel hors ligne avec Python
Trouver une solution au problème N-Queen avec un algorithme génétique (2)
J'ai essayé de résoudre le problème d'optimisation des combinaisons avec Qiskit
Une histoire sur la façon de traiter le problème CORS
AtCoder ABC 182 Python (A ~ D)
Créez un tableau à deux dimensions en ajoutant une ligne à la fin d'un tableau vide avec numpy
J'ai écrit un doctest dans "J'ai essayé de simuler la probabilité d'un jeu de bingo avec Python"
J'ai essayé d'utiliser PI Fu pour générer un modèle 3D d'une personne à partir d'une image
J'ai essayé de déverrouiller l'entrée 2 lock sésame d'une simple pression sur le bouton AWS IoT
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
[Commentaire d'AtCoder] Gagnez le problème ABC165 C "Many Requirements" avec Python!
[Introduction à StyleGAN] J'ai joué avec "The Life of a Man" ♬
Essayez de résoudre le problème N Queen avec SA de PyQUBO
J'ai essayé de créer une liste de nombres premiers avec python
J'ai essayé d'agrandir la taille du volume logique avec LVM
J'ai essayé d'améliorer l'efficacité du travail quotidien avec Python
PhytoMine-I a essayé d'obtenir les informations génétiques de la plante avec Python
J'ai essayé de créer un mécanisme de contrôle exclusif avec Go
Résoudre ABC166 A ~ D avec Python
Un débutant qui programme depuis 2 mois a tenté d'analyser le PIB réel du Japon en séries chronologiques avec le modèle SARIMA.
Je souhaite résoudre le problème de fuite de mémoire lors de la sortie d'un grand nombre d'images avec Matplotlib
J'ai essayé de visualiser la tranche d'âge et la distribution des taux d'Atcoder
J'ai essayé d'exprimer de la tristesse et de la joie face au problème du mariage stable.
[Introduction à Python] Comment trier efficacement le contenu d'une liste avec le tri par liste
Essayez de résoudre le problème du voyageur de commerce avec un algorithme génétique (théorie)
J'ai essayé d'obtenir le code d'authentification de l'API Qiita avec Python.
J'ai essayé d'analyser la négativité de Nono Morikubo. [Comparer avec Posipa]
J'ai essayé de visualiser le texte du roman "Weather Child" avec Word Cloud
J'ai essayé d'obtenir les informations sur le film de l'API TMDb avec Python
Essayez de résoudre un problème défini de mathématiques au lycée avec Python
J'ai essayé d'afficher la valeur d'altitude du DTM dans un graphique
J'ai essayé de vérifier le résultat du test A / B avec le test du chi carré
J'ai essayé de prédire le comportement du nouveau virus corona avec le modèle SEIR.
J'ai essayé de créer facilement une image 3D de haute précision avec une seule photo [-1]. (La zone cachée est-elle vraiment visible?)
AtCoder ABC155 Problème D Pairs Review Note 1
J'ai essayé de déplacer le modèle 3D en faisant quelque chose comme la capture de mouvement avec juste un ordinateur portable + une caméra Web
Je voulais connaître le nombre de lignes dans plusieurs fichiers et j'ai essayé de l'obtenir avec une commande
J'ai essayé la détection 3D d'une voiture