le mie informazioni di contatto
Posta[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
🍭 大家好这里是Kiyotaka-senpai , un programmatore che ama gli algoritmi
💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导
✨ Questa serie prevede di continuare ad aggiornarsi Qiuzhao domande della prova scritta
👏 感谢大家的订阅➕ 和 喜欢💗
📧 清隆这边最近正在收集近一年半互联网笔试题汇总，有需要的小伙伴可以关注 Fine dell'articolo Prendi la crociera della principessa~
Il signor A ha un'aiuola circolare, divisa in non-negligenzaN zona di blocco. Inizialmente, il signor A ha selezionato tre aree dell'aiuola per piantare le rose.
Ora, il signor A vuole utilizzare le operazioni mobili per raggiungere il giardino fioritoStato equilibrato。
Stato equilibrato: la distanza tra due aree coltivate a rose non è inferiore a ciaoK(La distanza tra aree adiacenti è 1 1 1）。
Operazione di spostamento: scambia lo stato delle aree adiacenti (l'area rosa diventa area vuota, l'area vuota diventa area rosa).
Allo stesso tempo, il signor A è una persona che presta grande attenzione all'efficienza, quindi spera che tu possa utilizzare il numero minimo di mosse per far sì che l'aiuola raggiunga uno stato equilibrato.
Immettere un numero intero positivo nella prima riga ioT, indicando il numero di richieste.
Prossimo ioT righe, ciascuna riga contiene cinque numeri interi positivi non-negligenzaN、 ciaoK、 un 1 un_1UN1、 un 2 un_2UN2、 un 3 un_3UN3, che rappresentano rispettivamente il numero di aree di aiuola, la distanza minima richiesta e la posizione iniziale delle tre aree di rose.
produzione ioT linee, ciascuna delle quali restituisce un numero intero che rappresenta il numero minimo di scambi richiesti per portare l'aiuola in equilibrio.Se l’equilibrio non può essere raggiunto, produzione − 1 -1 −1。
3
5 1 1 2 3
5 2 1 2 3
6 2 2 3 6
0
-1
1
1 ≤ t ≤ 1 0 4 1 leq t leq 10^41≤T≤104
1 ≤ n ≤ 1 0 9 1 leq n leq 10^91≤N≤109
1 ≤ k , a 1 , a 2 , a 3 ≤ n 1 quanto k, a_1, a_2, a_3 quanto n1≤K,UN1,UN2,UN3≤N
Questo problema può essere risolto analizzando le condizioni di equilibrio.
Innanzitutto, se la distanza minima richiesta ciaoK Superato il numero di aree giardino non-negligenzaN un terzo di , allora la condizione non può essere soddisfatta, qualunque cosa accada, e in questo momento l'output − 1 -1 −1。
Altrimenti possiamo prima ordinare le posizioni delle tre aree di rose e poi calcolare la distanza tra le aree di rose adiacenti.Successivamente, per ogni distanza, se è inferiore a ciaoK, allora è richiesta un'operazione di movimento e il numero di movimenti è ciaoK La differenza da questa distanza.
Alla fine, quando tutte le distanze soddisfano i requisiti, l'aiuola raggiunge uno stato equilibrato ed è possibile eseguire il numero totale di movimenti.
La complessità temporale è O(t log t) O(t log t)Lo(TIoGT), la complessità dello spazio è L'(1) L'(1)Lo(1)。
t = int(input())
for _ in range(t):
n, k, *a = map(int, input().split())
a.sort()
if k * 3 > n:
print(-1)
continue
b = [a[1] - a[0], a[2] - a[1], n - a[2] + a[0]]
ans = sum(max(0, k - d) for d in b)
print(ans)
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
int k = sc.nextInt();
int[] a = new int[3];
for (int i = 0; i < 3; i++) {
a[i] = sc.nextInt();
}
Arrays.sort(a);
if (k * 3 > n) {
System.out.println(-1);
continue;
}
int[] b = {a[1] - a[0], a[2] - a[1], n - a[2] + a[0]};
int ans = 0;
for (int d : b) {
ans += Math.max(0, k - d);
}
System.out.println(ans);
}
}
}
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k, a[3];
cin >> n >> k >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
if (k * 3 > n) {
cout << -1 << endl;
continue;
}
int b[] = {a[1] - a[0], a[2] - a[1], n - a[2] + a[0]};
int ans = 0;
for (int d : b) {
ans += max(0, k - d);
}
cout << ans << endl;
}
return 0;
}
La signora Lu è recentemente diventata dipendente da un gioco musicale incentrato sui suoni del pianoforte.Nel gioco, ogni tessera pianoforte ha un numero, dove il numero minimo è 1 1 1 . Se colpisci cinque tessere pianoforte con numeri crescenti in fila, otterrai una moneta d'oro.
Ad esempio, se la signorina Lu colpisce il numero 1, 2, 3, 4, 5, 6 di pezzi per pianoforte, poi per1, 2, 3, 4, 5 Per questi cinque blocchi con numeri crescenti consecutivi, riceverà una moneta d'oro.
Quando si avanza in un livello per un lungo periodo, il numero verrà ripristinato. Il numero di ripristino cambierà da 1 1 1 inizio. Quindi, per un livello, è possibile colpire più tessere di pianoforte con lo stesso numero ma diverse.
Tieni presente che per ottenere monete d'oro sono necessarie solo cinque tessere pianoforte con numeri in continuo aumento nello stesso livello.
Grazie alla forza superiore della signorina Lu, ha superato quattro livelli.Alla signorina Lu ora vengono assegnati quattro livelli di difficoltà aaUN、 BBB、 CCC E GGD Numero della tessera pianoforte colpita Quante monete d'oro può ottenere in totale la signora Lu in questi quattro livelli?
La prima riga contiene un numero intero positivo non-negligenzaN（ 1 ≤ n ≤ 1 0 5 1 leq n leq 10^51≤N≤105), che rappresenta il numero totale di tessere pianoforte colpite da Miss Lu nei quattro livelli.
Prossimo non-negligenzaN righe, immettere tre parametri in ciascuna riga: io ioUNioooooooooooo、 bi biBioooooooooooo（ 1 ≤ ai , bi ≤ 1 0 9 1 leq a_i, b_i leq 10^91≤UNioooooooooooo,Bioooooooooooo≤109)E ci c_iCioooooooooooo（ ci ∈ { ′ A ′ , ′ B ′ , ′ C ′ , ′ D ′ } c_i in {'A', 'B', 'C', 'D'}Cioooooooooooo∈{′UN′,′B′,′C′,′D′}), che rappresentano rispettivamente il numero, la quantità e il livello di ciascuna tessera pianoforte.
Emetti un numero intero che rappresenta il numero totale di monete d'oro che Miss Lu può ottenere.
11
1 1 A
2 2 A
3 2 A
4 2 A
5 2 A
6 1 A
7 1 B
8 2 B
9 2 B
10 2 B
11 1 B
3
Per i livelli aaUN,Primo 1, 2, 3, 4, 5 Puoi ottenere una moneta d'oro, e poi2, 3, 4, 5, 6 Puoi ottenere un'altra moneta d'oro.
Per i livelli BBB，7, 8, 9, 10, 11 Puoi ottenere una moneta d'oro.
Pertanto, un totale di 3 3 3 monete d'oro.
5
1 1 C
2 2 C
3 2 C
4 2 C
6 1 C
0
a livello CCC In , non è possibile ottenere cinque numeri crescenti consecutivi, quindi il numero di monete d'oro lo è 0 0 0。
Questo problema può essere risolto utilizzando tabelle hash e ordinamento. Le idee specifiche sono le seguenti:
Utilizza la tabella hash cnt Registra il numero di volte in cui ciascun numero appare in ciascun livello. La chiave è la combinazione del carattere del livello e del numero, mentre il valore è il numero di volte in cui il numero appare nel livello.
Ordinare i dati di input in base ai caratteri e ai numeri del livello per garantire che i numeri dello stesso livello siano consecutivi.
Attraversa i dati ordinati e, per ciascun numero, determina se i suoi cinque numeri consecutivi esistono tutti nel livello corrente. Se esiste, prendi il valore minimo del numero di occorrenze tra questi cinque numeri, contalo nella risposta e sottrai il valore minimo dal numero di occorrenze di questi cinque numeri.
La risposta finale è la somma di tutte le monete d'oro che soddisfano le condizioni.
La complessità temporale è O ( n log n ) O(n log n)Lo(NIoGN), la complessità dello spazio è O (n) O (n)Lo(N)。
from collections import defaultdict
import sys
def solve():
n = int(input())
cnt = defaultdict(int)
vec = []
for _ in range(n):
a, b, c = input().split()
a, b = int(a), int(b)
cnt[c + str(a)] += b
vec.append((c, a))
vec.sort()
ans = 0
for v in vec:
arr = [v[0] + str(v[1] + i) for i in range(5)]
t = min(cnt[a] for a in arr)
ans += t
for a in arr:
cnt[a] -= t
print(ans)
if __name__ == '__main__':
solve()
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
Map<String, Integer> cnt = new HashMap<>();
List<int[]> vec = new ArrayList<>();
for (int i = 0; i < n; i++) {
String[] input = br.readLine().split(" ");
int a = Integer.parseInt(input[0]);
int b = Integer.parseInt(input[1]);
String c = input[2];
String key = c + a;
cnt.put(key, cnt.getOrDefault(key, 0) + b);
vec.add(new int[]{c.charAt(0), a});
}
vec.sort((x, y) -> {
if (x[0] != y[0]) {
return x[0] - y[0];
}
return x[1] - y[1];
});
long ans = 0;
for (int[] v : vec) {
String[] arr = new String[5];
for (int i = 0; i < 5; i++) {
arr[i] = (char) v[0] + String.valueOf(v[1] + i);
}
int t = Integer.MAX_VALUE;
for (String a : arr) {
t = Math.min(t, cnt.getOrDefault(a, 0));
}
ans += t;
for (String a : arr) {
cnt.put(a, cnt.get(a) - t);
}
}
System.out.println(ans);
}
}
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <climits>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
map<string, ll> cnt;
vector<pair<string, int>> vec;
for (int i = 1; i <= n; i++) {
int a, b;
string c;
cin >> a >> b >> c;
cnt[c + to_string(a)] += b;
vec.push_back({c, a});
}
sort(vec.begin(), vec.end());
ll ans = 0;
for (auto& v : vec) {
vector<string> arr;
for (int i = 0; i < 5; i++) {
arr.push_back(v.first + to_string(v.second + i));
}
ll t = LLONG_MAX;
for (auto& a : arr) {
t = min(t, cnt[a]);
}
ans += t;
for (auto& a : arr) {
cnt[a] -= t;
}
}
cout << ans << endl;
return 0;
}
La signorina Lu ha una lunghezza di non-negligenzaN in un giardino piantumato con non-negligenzaN Pianta fiori diversi.Ogni fiore ha un valore di bellezza io ioUNioooooooooooo。
La signora Lu ritiene che un bel giardino dovrebbe essere unico, cioè lo è n − 1 n-1N−1 Il valore di bellezza dei fiori piantati è lo stesso, solo 1 1 1 Il valore di bellezza dei fiori piantati è diverso da quello degli altri fiori.
Per ogni operazione, Miss Lu può scegliere un fiore e aumentarne il valore di bellezza. 1 1 1 o meno 1 1 1。
Ora la signora Lu vuole sapere quante operazioni sono necessarie per rendere unico il giardino.
La prima riga contiene un numero intero positivo non-negligenzaN, indicante la lunghezza del giardino.
La seconda riga contiene non-negligenzaN intero positivo un 1 , un 2 , … , un a_1, a_2, ldots, unUN1,UN2,…,UNN, indicando il valore di bellezza di ciascun fiore.
Restituisce un numero intero che rappresenta il numero minimo di operazioni richieste per rendere unico il giardino.
4
1 2 3 4
2
La soluzione ottimale è diventare la mediana ed enumerare tutti i costi necessari per diventare tale.
La complessità temporale è O ( n log n ) O(n log n)Lo(NIoGN), la complessità dello spazio è O (n) O (n)Lo(N)。
def main():
n = int(input())
w = list(map(int, input().split()))
w.sort()
if w[0] == w[n - 1]:
print("1")
return
s1, s2 = 0, 0
m1, m2 = w[(n - 1) // 2], w[(n + 1) // 2]
for i in range(n - 1):
s1 += abs(m1 - w[i])
for i in range(1, n):
s2 += abs(m2 - w[i])
print(min(s1, s2))
if __name__ == "__main__":
main()
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] w = new int[n];
for (int i = 0; i < n; i++)
w[i] = scanner.nextInt();
Arrays.sort(w);
if (w[0] == w[n - 1]) {
System.out.println("1");
return;
}
long s1 = 0, s2 = 0;
int m1 = w[(n - 1) / 2], m2 = w[(n + 1) / 2];
for (int i = 0; i < n - 1; i++)
s1 += Math.abs(m1 - w[i]);
for (int i = 1; i < n; i++)
s2 += Math.abs(m2 - w[i]);
System.out.println(Math.min(s1, s2));
}
}
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 100010;
int main() {
int n, w[N];
cin >> n;
for (int i = 0; i < n; i++)
cin >> w[i];
sort(w, w + n);
if (w[0] == w[n - 1]) {
cout << "1" << endl;
return 0;
}
ll s1 = 0, s2 = 0;
int m1 = w[(n - 1) / 2], m2 = w[(n + 1) / 2];
for (int i = 0; i < n - 1; i++)
s1 += abs(m1 - w[i]);
for (int i = 1; i < n; i++)
s2 += abs(m2 - w[i]);
cout << min(s1, s2) << endl;
return 0;
}
LYA è recentemente diventata ossessionata dalla pittura dei personaggi. Crede che la bellezza di un dipinto dei personaggi sia uguale al numero di simboli identici consecutivi nel dipinto dei personaggi.Ad esempio, l'estetica del dipinto del personaggio "aabbccddef" lo è 6 6 6。
L'amica di LYA le ha dato un 0 0 0 E 1 1 1 LYA, che è diventata ossessionata dal disegno dei personaggi, vuole conoscere tutte le stringhe composte da questa stringa.sottostringaQual è la somma dell'estetica?
Nota: ci sono C n + 1 2 C^{2}_{n+1}CN+12 sottostringa.
Immettere un numero intero positivo nella prima riga non-negligenzaN, che indica la lunghezza della corda.
La lunghezza della seconda riga è non-negligenzaN Di 01 01 01 Corda.
Restituisce un numero intero che rappresenta la somma dell'estetica di tutte le sottostringhe.
4
0011
14
1 ≤ n ≤ 2 × 1 0 5 1 leq n leq 2 volte 10^51≤N≤2×105
Questo problema può essere risolto attraverso l'idea della somma del prefisso.
Per prima cosa possiamo calcolare il numero totale di sottostringhe della stringa n ( n + 1 ) 2 frazione {n(n+1)}{2}2N(N+1)。
Quindi, iteriamo sulla stringa e utilizziamo le variabili LLl Registra la posizione iniziale degli attuali simboli identici consecutivi, variabile rrR Registra la posizione corrente.Quando s [ r ] ≠ s [ r − 1 ] s[r] neq s[r-1]S[R]=S[R−1] Quando , significa che appare un nuovo simbolo e possiamo calcolare [ l , r ) [ l , r )[l,R) Cioè il numero di sottostringhe nell'intervallo ( r − l ) ( r − l + 1 ) 2 frazioni {(rl)(r-l+1)}{2}2(R−l)(R−l+1), sottrailo dal numero totale di sottostringhe.
Infine, ciò che rimane è il numero di tutte le sottostringhe belle che possono essere emesse.
complessità temporale O (n) O (n)Lo(N), complessità spaziale L'(1) L'(1)Lo(1)。
def cal(length):
return length * (length + 1) // 2
n = int(input())
s = input() + '#'
ans = 0
total = cal(n)
l = 0
for r in range(1, n + 1):
if s[r] != s[r - 1]:
ans += total - cal(l) - cal(n - r)
l = r
print(ans)
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String s = sc.next() + "#";
long ans = 0;
long total = cal(n);
int l = 0;
for (int r = 1; r <= n; r++) {
if (s.charAt(r) != s.charAt(r - 1)) {
ans += total - cal(l) - cal(n - r);
l = r;
}
}
System.out.println(ans);
}
private static long cal(int len) {
return (long) len * (len + 1) / 2;
}
}
#include <iostream>
#include <string>
using namespace std;
using ll = long long;
ll cal(int len) {
return (ll) len * (len + 1) / 2;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
s += "#";
ll ans = 0;
ll total = cal(n);
int l = 0;
for (int r = 1; r <= n; r++) {
if (s[r] != s[r - 1]) {
ans += total - cal(l) - cal(n - r);
l = r;
}
}
cout << ans << endl;
return 0;
}
La signorina Lu ha un piano davvero grandioso: vuole eliminare tutti gli array del mondo! Ma la sua capacità è limitata. Può selezionare ogni volta solo due elementi identici nell'array ed eliminare tutti gli elementi tra di loro (compresi i due elementi stessi).
Ora, di fronte alla signorina Lu, c'è una lunghezza di non-negligenzaN serie di aaUN, vuole sapere quanti elementi in questo array può eliminare al massimo.
La prima riga contiene un numero intero positivo non-negligenzaN, rappresenta una matrice aaUN lunghezza.
La seconda riga contiene non-negligenzaN interi positivi separati da spazi un 1 , un 2 , … , un a_1, a_2, ldots, unUN1,UN2,…,UNN, rappresenta una matrice aaUN Elementi.
Emette un numero intero, che indica il numero massimo di elementi che Miss Lu può eliminare.
4
1 2 1 2
1
Questo problema può essere risolto utilizzando le idee dell'ordinamento e dei doppi puntatori.
Per prima cosa possiamo convertire l'array aaUN Gli elementi sono ordinati per valore e viene registrata la posizione originale di ciascun elemento nell'array. Lo scopo di questo è facilitarci nel trovare l'intervallo di posizione dello stesso elemento.
Successivamente, possiamo scorrere l'array ordinato e, per ciascun elemento, trovare l'intervallo di posizione di tutti gli elementi che hanno il suo stesso valore [ S , D ] [ S , D ][L,R] . Gli elementi in questo intervallo possono essere eliminati perché si trovano tra due elementi identici nell'array originale.Possiamo calcolare l'intervallo [ S , D ] [ S , D ][L,R] Il numero di elementi in R − L − 1 R - L - 1R−L−1, confrontalo con il numero massimo corrente di elementi eliminati e aggiorna il valore massimo.
Infine, genera il numero massimo di elementi eliminati.
La complessità temporale è O ( n log n ) O(n log n)Lo(NIoGN) , principalmente la complessità temporale dell'ordinamento.La complessità dello spazio è O (n) O (n)Lo(N), utilizzato per memorizzare la posizione originale dell'elemento.
n = int(input())
a = list(map(int, input().split()))
idx = sorted(range(n), key=lambda x: a[x])
ans = 0
i = 0
while i < n:
j = i
L, R = n, -1
while j < n and a[idx[j]] == a[idx[i]]:
L = min(L, idx[j])
R = max(R, idx[j])
j += 1
ans = max(ans, R - L - 1)
i = j
print(ans)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
Integer[] idx = new Integer[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
idx[i] = i;
}
Arrays.sort(idx, Comparator.comparingInt(i -> a[i]));
int ans = 0;
for (int i = 0; i < n;) {
int j = i;
int L = n, R = -1;
while (j < n && a[idx[j]] == a[idx[i]]) {
L = Math.min(L, idx[j]);
R = Math.max(R, idx[j]);
j++;
}
ans = Math.max(ans, R - L - 1);
i = j;
}
System.out.println(ans);
}
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> idx(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
idx[i] = i;
}
sort(idx.begin(), idx.end(), [&](int i, int j) {
return a[i] < a[j];
});
int ans = 0;
for (int i = 0; i < n;) {
int j = i;
int L = n, R = -1;
while (j < n && a[idx[j]] == a[idx[i]]) {
L = min(L, idx[j]);
R = max(R, idx[j]);
j++;
}
ans = max(ans, R - L - 1);
i = j;
}
cout << ans << endl;
return 0;
}
Qui vorrei consigliarti la cabina check-in per il reclutamento autunnale degli anziani. Ti aiuterà passo dopo passo a risolvere le domande più comuni delle prove scritte su Internet in 31 giorni. Ogni giorno è pieno di informazioni utili.
[Check-in del reclutamento autunnale] Day01-Ordinamento personalizzato-CSDN Blog
Forniamo recensioni online di domande reali dei principali produttori precedenti. Gli amici interessati possono inviare un messaggio privato a Qinglong per saperne di più.
E altro ancora! Oltretutto!
Si dedica alla ricerca tecnologica da più di 30 anni ed è esperto in vari linguaggi come Java, Linux, Javascript, php, css, ecc. Ha dato numerosi contributi nel campo dell'open source stazione di documentazione per gli sviluppatori per condividere alcuni problemi nello sviluppo della tecnologia per riferimento futuro
Posta[email protected]