minhas informações de contato
Correspondência[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
🍭 大家好这里是Kiyotaka-senpai , um programador que adora algoritmos
💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导
✨ Esta série planeja continuar sendo atualizada Perguntas do teste escrito Qiuzhao
👏 感谢大家的订阅➕ 和 喜欢💗
📧 清隆这边最近正在收集近一年半互联网笔试题汇总，有需要的小伙伴可以关注 Fim do artigo Pegue o cruzeiro da princesa ~
O Sr. A possui um canteiro circular, que é dividido em nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão área de bloco. Inicialmente, o Sr. A selecionou três áreas do canteiro para plantar rosas.
Agora, o Sr. A quer usar operações móveis para fazer o jardim de flores chegarEstado equilibrado。
Estado de equilíbrio: A distância entre quaisquer duas áreas plantadas com rosas não é inferior a kko(A distância entre áreas adjacentes é 1 1 1）。
Operação de movimentação: troca o status das áreas adjacentes (a área rosa torna-se área vazia, a área vazia torna-se área rosa).
Ao mesmo tempo, o Sr. A é uma pessoa que dá muita atenção à eficiência, por isso espera que você consiga usar o número mínimo de movimentos para fazer o canteiro de flores atingir um estado de equilíbrio.
Insira um número inteiro positivo na primeira linha ttpara, indicando o número de consultas.
Próximo ttpara linhas, cada linha contém cinco inteiros positivos nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão、 kko、 um 1 a_1a1、 um 2 a_2a2、 um 3 a_3a3, representando respectivamente o número de áreas de canteiros, a distância mínima exigida e a posição inicial das três áreas de rosas.
saída ttpara linhas, cada uma gerando um número inteiro representando o número mínimo de trocas necessárias para equilibrar o canteiro de flores.Se o equilíbrio não puder ser alcançado, o produto − 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≤para≤104
1 ≤ n ≤ 1 0 9 1 leq n leq 10^91≤nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão≤109
1 ≤ k, a 1, a 2, a 3 ≤ n 1 leq k, a_1, a_2, a_3 leq n1≤o,a1,a2,a3≤nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão
Este problema pode ser resolvido analisando as condições de equilíbrio.
Primeiro, se a distância mínima exigida kko Excedeu o número de áreas ajardinadas nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão um terço de , então a condição não pode ser satisfeita, não importa o que aconteça, e neste momento a saída − 1 -1 −1。
Caso contrário, podemos primeiro classificar as posições das três áreas de rosas e depois calcular a distância entre as áreas de rosas adjacentes.A seguir, para cada distância, se for menor que kko, então uma operação de movimento é necessária e o número de movimentos é kko A diferença desta distância.
Finalmente, quando todas as distâncias atendem aos requisitos, o canteiro de flores atinge um estado equilibrado e o número total de movimentos pode ser produzido.
A complexidade do tempo é O ( t log t ) O(t log t)O(paraeisgpara), a complexidade do espaço é O ( 1 ) O(1)O(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;
}
Lu recentemente se viciou em um jogo musical focado em sons de piano.No jogo, cada peça de piano tem um número, sendo o número mínimo 1 1 1 . Se você acertar cinco peças de piano com números crescentes consecutivos, receberá uma moeda de ouro.
Por exemplo, se a senhorita Lu acertar o número 1, 2, 3, 4, 5, 6 de peças para piano, então para1, 2, 3, 4, 5 Por esses cinco blocos com números crescentes consecutivos, ela receberá uma moeda de ouro.
Quando um nível tiver progredido por um longo período, o número será redefinido. O número de redefinição mudará de. 1 1 1 começar. Portanto, para um nível, é possível acertar vários blocos de piano com o mesmo número, mas com números diferentes.
Observe que apenas cinco peças de piano com números continuamente crescentes no mesmo nível são necessárias para obter moedas de ouro.
Devido à força superior da senhorita Lu, ela passou de quatro níveis.Miss Lu agora recebe quatro níveis de dificuldade AAA、 BBB、 CCC e DDE Número da peça do piano atingida Quantas moedas de ouro a Sra. Lu consegue no total nesses quatro níveis?
A primeira linha contém um número inteiro positivo nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão（ 1 ≤ n ≤ 1 0 5 1 leq n leq 10^51≤nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão≤105), representando o número total de peças de piano atingidas pela Srta. Lu nos quatro níveis.
Próximo nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão linhas, insira três parâmetros em cada linha: ai a_iaeu、 bi b_ibeu（ 1 ≤ ai , bi ≤ 1 0 9 1 leq a_i, b_i leq 10^91≤aeu,beu≤109)e ci c_iceu（ ci ∈ { ′ A ′ , ′ B ′ , ′ C ′ , ′ D ′ } c_i em {'A', 'B', 'C', 'D'}ceu∈{′A′,′B′,′C′,′E′}), representando respectivamente o número, a quantidade e o nível de cada peça do piano.
Produza um número inteiro representando o número total de moedas de ouro que a Srta. Lu pode obter.
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
Para níveis AAA,primeiro 1, 2, 3, 4, 5 Você pode conseguir uma moeda de ouro e então2, 3, 4, 5, 6 Você pode obter outra moeda de ouro.
Para níveis BBB，7, 8, 9, 10, 11 Você pode obter uma moeda de ouro.
Portanto, um total de 3 3 3 moedas de ouro.
5
1 1 C
2 2 C
3 2 C
4 2 C
6 1 C
0
No nível CCC Em, cinco números crescentes consecutivos não podem ser obtidos, então o número de moedas de ouro é 0 0 0。
Este problema pode ser resolvido usando tabelas hash e classificação. As ideias específicas são as seguintes:
Usar tabela hash cnt Registre o número de vezes que cada número aparece em cada nível. A chave é a combinação do caractere do nível e do número, e o valor é o número de vezes que o número aparece no nível.
Classifique os dados de entrada de acordo com os caracteres e números do nível para garantir que os números do mesmo nível sejam consecutivos.
Percorra os dados classificados e, para cada número, determine se todos os seus cinco números consecutivos existem no nível atual. Se existir, pegue o valor mínimo do número de ocorrências entre esses cinco números, conte-o na resposta e subtraia o valor mínimo do número de ocorrências desses cinco números.
A resposta final é a soma de todas as moedas de ouro que atendem às condições.
A complexidade do tempo é O ( n log n ) O(n log n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoeisgnãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão), a complexidade do espaço é O ( n ) O(n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão)。
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;
}
Senhorita Lu tem um comprimento de nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão em um jardim plantado com nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão Plante flores diferentes.Cada flor tem um valor de beleza ai a_iaeu。
Dona Lu acha que um lindo jardim deve ser único, ou seja, tem n − 1 n-1nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão−1 O valor da beleza das flores plantadas é o mesmo, apenas 1 1 1 O valor da beleza das flores plantadas é diferente de outras flores.
Para cada operação, a senhorita Lu pode escolher uma flor e aumentar seu valor de beleza. 1 1 1 ou menos 1 1 1。
Agora, dona Lu quer saber quantas operações são necessárias para tornar o jardim único.
A primeira linha contém um número inteiro positivo nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão, indicando o comprimento do jardim.
A segunda linha contém nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão número inteiro positivo um 1, um 2, …, um a_1, a_2, ldots, um_na1,a2,…,anãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão, indicando o valor da beleza de cada flor.
Produz um número inteiro que representa o número mínimo de operações necessárias para tornar o jardim único.
4
1 2 3 4
2
A solução ideal é tornar-se a mediana e enumerar todos os custos de se tornar a mediana.
A complexidade do tempo é O ( n log n ) O(n log n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoeisgnãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão), a complexidade do espaço é O ( n ) O(n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão)。
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 ficou obcecada pela pintura de personagens. Ela acredita que a beleza de uma pintura de personagens é igual ao número de símbolos idênticos consecutivos na pintura de personagens.Por exemplo, a estética da pintura do personagem "aabbccddef" é 6 6 6。
A amiga de LYA deu a ela um 0 0 0 e 1 1 1 LYA, que ficou obcecada pelo desenho de personagens, quer conhecer todos os fios que compõem esse barbante.substringQual é a soma da estética?
Nota: existem C n + 1 2 C^{2}_{n+1}Cnãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão+12 substring.
Insira um número inteiro positivo na primeira linha nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão, indicando o comprimento da string.
O comprimento da segunda linha é nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão de 01 01 01 Corda.
Produza um número inteiro representando a soma da estética de todas as substrings.
4
0011
14
1 ≤ n ≤ 2 × 1 0 5 1 leq n leq 2 vezes 10^51≤nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão≤2×105
Este problema pode ser resolvido através da ideia de soma de prefixo.
Primeiro, podemos calcular o número total de substrings da string, ou seja n ( n + 1 ) 2 fração {n(n+1)}{2}2nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão+1)。
Então, iteramos sobre a string e usamos as variáveis eueu Registre a posição inicial dos símbolos idênticos consecutivos atuais, variável rrr Grave a localização atual.quando s [ r ] ≠ s [ r − 1 ] s[r] neq s[r-1]e[r]=e[r−1] Quando , significa que um novo símbolo aparece e podemos calcular [ eu , r ) [ eu, r)[eu,r) O número de substrings no intervalo, ou seja ( r − eu ) ( r − eu + 1 ) 2 frac{(rl)(r-l+1)}{2}2(r−eu)(r−eu+1), subtraia-o do número total de substrings.
Finalmente, o que resta é o número de todas as belas substrings que podem ser geradas.
complexidade de tempo O ( n ) O(n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão), complexidade do espaço O ( 1 ) O(1)O(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;
}
A senhorita Lu tem um plano muito grandioso, ela quer deletar todos os arrays do mundo! Mas sua capacidade é limitada. Ela só pode selecionar dois elementos idênticos na matriz de cada vez e excluir todos os elementos entre eles (incluindo os próprios dois elementos).
Agora, na frente da senhorita Lu, há um comprimento de nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão matriz de aaa, ela quer saber quantos elementos desse array ela pode excluir no máximo.
A primeira linha contém um número inteiro positivo nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão, representa uma matriz aaa comprimento.
A segunda linha contém nãonãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão inteiros positivos separados por espaço um 1, um 2, …, um a_1, a_2, ldots, um_na1,a2,…,anãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão, representa uma matriz aaa Elementos.
Produza um número inteiro, indicando o número máximo de elementos que Miss Lu pode excluir.
4
1 2 1 2
1
Este problema pode ser resolvido usando as ideias de classificação e ponteiros duplos.
Primeiro, podemos converter o array aaa Os elementos são classificados por valor e a posição original de cada elemento na matriz é registrada. O objetivo disso é facilitar-nos encontrar o intervalo de posições do mesmo elemento.
A seguir, podemos iterar pelo array classificado e, para cada elemento, encontrar o intervalo de posições de todos os elementos que possuem o mesmo valor que ele. [ E , D ] [ E , D][eu,R] . Os elementos neste intervalo podem ser excluídos porque estão localizados entre dois elementos idênticos na matriz original.Podemos calcular o intervalo [ E , D ] [ E , D][eu,R] O número de elementos em R − E − 1 R - E - 1R−eu−1, compare-o com o número máximo atual de elementos excluídos e atualize o valor máximo.
Finalmente, produza o número máximo de elementos excluídos.
A complexidade do tempo é O ( n log n ) O(n log n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoeisgnãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão) , principalmente a complexidade do tempo de classificação.A complexidade do espaço é O ( n ) O(n)O(nãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoãoão), usado para armazenar a posição original do 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;
}
Aqui, gostaria de recomendar a você a cabine de check-in do acompanhante de recrutamento de outono. Ela o guiará passo a passo para resolver questões comuns de testes escritos na Internet em 31 dias.
[Check-in de recrutamento de outono] Dia 01 - Classificação personalizada - Blog CSDN
Fornecemos análises on-line de perguntas reais de grandes fabricantes anteriores. Amigos interessados podem enviar uma mensagem privada para Qinglong para saber mais.
E mais! E mais! além do mais!
Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.
Correspondência[email protected]