Teknologian jakaminen

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

🍭 大家好这里是Kiyotaka-senpai , ohjelmoija, joka rakastaa algoritmeja

💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导

✨ Tämä sarja aikoo päivittää edelleen Qiuzhao kirjalliset testikysymykset
👏 感谢大家的订阅➕ 和 喜欢💗

---

📧 清隆这边最近正在收集近一年半互联网笔试题汇总，有需要的小伙伴可以关注 Artikkelin loppu Hanki prinsessaristeily~

🎀 01.A先生的环形花圃

Kysymyksen kuvaus

Mr. A:lla on pyöreä kukkapenkki, joka on jaettu $n$ lohkoalue. Aluksi herra A valitsi kukkapenkistä kolme aluetta ruusujen istuttamiseksi.

Nyt herra A haluaa käyttää mobiilitoimintoja kukkapuutarhan tavoittamiseenTasapainoinen tila。

Tasapainoinen tila: Kahden ruusuilla istutetun alueen välinen etäisyys on vähintään $k$(Virekkäisten alueiden välinen etäisyys on $1$）。

Siirtotoiminto: vaihda viereisten alueiden tilaa (ruusualueesta tulee tyhjä alue, tyhjästä ruusualueesta).

Samalla herra A on henkilö, joka kiinnittää suurta huomiota tehokkuuteen, joten hän toivoo, että voit käyttää mahdollisimman vähän liikkeitä saadaksesi kukkapenkin tasapainoisen tilan.

Syöttömuoto

Syötä ensimmäiselle riville positiivinen kokonaisluku $t$, joka osoittaa tiedustelujen määrän.

Seuraava $t$ riviä, jokainen rivi sisältää viisi positiivista kokonaislukua$n$、$k$、$a_1$、$a_2$、$a_3$, jotka edustavat kukkapenkkialueiden lukumäärää, vaadittua vähimmäisetäisyyttä ja kolmen ruusualueen alkusijaintia.

Tulostusmuoto

ulostulo $t$ rivit, joista kukin tulostaa kokonaisluvun, joka edustaa vaihtojen vähimmäismäärää, joka tarvitaan kukkapenkin saattamiseen tasapainoon.Jos tasapainoa ei saavuteta, tulosta$-1$。

Näytesyöttö

3
5 1 1 2 3
5 2 1 2 3
6 2 2 3 6
1
2
3
4

Näytetulostus

0
-1
1
1
2
3

dataväli

$1\le t\le 10^4$
$1\le n\le 10^9$
$1\le k,a_1,a_2,a_3\le n$

vastaus

Tämä ongelma voidaan ratkaista analysoimalla tasapainoolosuhteet.

Ensinnäkin, jos vaadittu vähimmäisetäisyys $k$ Puutarha-alueiden määrä ylitetty$n$ yksi kolmasosa , niin ehtoa ei voida täyttää riippumatta siitä, mitä, ja tällä hetkellä tulos$-1$。

Muussa tapauksessa voimme ensin lajitella kolmen ruusualueen sijainnit ja sitten laskea vierekkäisten ruusualueiden välisen etäisyyden.Seuraavaksi kullekin etäisyydelle, jos se on pienempi kuin$k$, silloin tarvitaan liiketoiminto, ja liikkeiden määrä on $k$ Ero tästä etäisyydestä.

Lopuksi, kun kaikki etäisyydet täyttävät vaatimukset, kukkapenkki saavuttaa tasapainoisen tilan ja liikkeiden kokonaismäärä voidaan tulostaa.

Aika monimutkaisuus on $O(t\log t)$, tilan monimutkaisuus on $O(1)$。

Viitekoodi

• Python

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• Java

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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

• Cpp

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

🪐 02.卢小姐的音游金币

Ongelman kuvaus

Rouva Lu on äskettäin koukussa musiikkipeliin, joka keskittyy pianon ääniin.Pelissä jokaisella pianolaatalla on numero, jonka vähimmäismäärä on$1$ . Jos osut viiteen pianolaattaan kasvavalla numerolla peräkkäin, saat kultakolikon.

Esimerkiksi jos neiti Lu osuu numeroon 1, 2, 3, 4, 5, 6 pianokappaleista, sitten1, 2, 3, 4, 5 Näistä viidestä lohkosta, joiden luvut kasvavat peräkkäin, hän saa kultakolikon.

Kun tasoa on edetty pitkään, numero nollataan. Nollausnumero vaihtuu $1$ alkaa. Joten tasolle on mahdollista lyödä useita pianolaattoja samalla numerolla, mutta erilaisilla.

Huomaa, että kultakolikoiden saamiseksi tarvitaan vain viisi pianolaattaa, joiden lukumäärä jatkuvasti kasvaa samalla tasolla.

Neiti Lu:n ylivoimaisen vahvuuden ansiosta hän on läpäissyt neljä tasoa.Neiti Lu on nyt saanut neljä vaikeustasoa$A$、$B$、$C$ ja$D$ Pianolaatan osuman lukumäärä Kuinka monta kultakolikkoa rouva Lu voi saada yhteensä näillä neljällä tasolla?

Syöttömuoto

Ensimmäinen rivi sisältää positiivisen kokonaisluvun $n$（$1\le n\le 10^5$), joka edustaa Miss Lu:n osumien pianolaattojen kokonaismäärää neljällä tasolla.

Seuraava $n$ rivit, kirjoita kolme parametria kullekin riville:$a_i$、$b_i$（$1\le a_i,b_i\le 10^9$)ja $c_i$（ ci ∈ { 'A ', 'B', 'C', 'D'} c_i kirjaimissa {'A', 'B', 'C', 'D'}ci​∈{′A′,′B′,′C′,′D′}), joka edustaa kunkin pianolaatan määrää, määrää ja tasoa.

Tulostusmuoto

Tulosta kokonaisluku, joka edustaa kultakolikoiden kokonaismäärää, jonka neiti Lu voi saada.

Näytesyöttö

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
1
2
3
4
5
6
7
8
9
10
11
12

Näytetulostus

3
1

Esimerkkikuvaus

Tasoja varten $A$,ensimmäinen 1, 2, 3, 4, 5 Voit saada kultakolikon, ja sitten2, 3, 4, 5, 6 Voit saada toisen kultakolikon.

Tasoja varten $B$，7, 8, 9, 10, 11 Voit saada kultakolikon.

Siksi yhteensä $3$ Kultakolikot.

Esimerkkisyöttö 2

5
1 1 C
2 2 C
3 2 C 
4 2 C
6 1 C
1
2
3
4
5
6

Näytelähtö 2

0
1

Esimerkkikuvaus 2

tasolla $C$ Vuonna viittä peräkkäistä kasvavaa numeroa ei voida saada, joten kultakolikoiden määrä on$0$。

dataväli

• $1\le n\le 10^5$
• $1\le a_i,b_i\le 10^9$
• ci ∈ { 'A ', 'B', 'C', 'D'} c_i kirjaimissa {'A', 'B', 'C', 'D'}ci​∈{′A′,′B′,′C′,′D′}

vastaus

Tämä ongelma voidaan ratkaista käyttämällä hash-taulukoita ja lajittelua. Tarkat ideat ovat seuraavat:

1. Käytä hash-taulukkoa cnt Kirjaa ylös, kuinka monta kertaa kukin numero näkyy kullakin tasolla. Avain on tasomerkin ja numeron yhdistelmä, ja arvo on kuinka monta kertaa numero esiintyy tasolla.

2. Lajittele syötetiedot tason merkkien ja numeroiden mukaan varmistaaksesi, että saman tason numerot ovat peräkkäisiä.

3. Selaa lajitellut tiedot ja määritä jokaiselle numerolle, ovatko sen viisi peräkkäistä numeroa kaikki nykyisellä tasolla. Jos se on olemassa, ota näiden viiden luvun esiintymisten lukumäärän minimiarvo, laske se vastauksessa ja vähennä minimiarvo näiden viiden luvun esiintymisten määrästä.

4. Lopullinen vastaus on kaikkien ehdot täyttävien kultakolikoiden summa.

Aika monimutkaisuus on $O(n\log n)$, tilan monimutkaisuus on $O(n)$。

Viitekoodi

• Python

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• Java

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

• Cpp

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

✨ 03. Neiti Lu:n ainutlaatuinen puutarha

Ongelman kuvaus

Neiti Lu on pitkä $n$ puutarhassa, johon on istutettu$n$ Istuta erilaisia ​​kukkia.Jokaisella kukalla on kauneusarvo$a_i$。

Rouva Lu katsoo, että kauniin puutarhan tulee olla ainutlaatuinen, eli niin on $n-1$ Istutettujen kukkien kauneusarvo on sama, vain$1$ Istutettujen kukkien kauneusarvo on erilainen kuin muiden kukkien.

Neiti Lu voi valita jokaiselle leikkaukselle kukkan ja lisätä sen kauneusarvoa. $1$ tai miinus$1$。

Nyt neiti Lu haluaa tietää, kuinka monta toimenpidettä tarvitaan, jotta puutarhasta tulee ainutlaatuinen.

Syöttömuoto

Ensimmäinen rivi sisältää positiivisen kokonaisluvun $n$, joka osoittaa puutarhan pituuden.

Toinen rivi sisältää $n$ positiivinen kokonaisluku$a_1,a_2,\dots ,a_n$, joka osoittaa kunkin kukan kauneusarvon.

Tulostusmuoto

Tulostaa kokonaisluvun, joka edustaa toimintojen vähimmäismäärää, joka tarvitaan puutarhan tekemiseen ainutlaatuiseksi.

Näytesyöttö

4
1 2 3 4
1
2

Näytetulostus

2
1

dataväli

• $1\le n\le 10^5$
• $1\le a_i\le 10^9$

vastaus

Optimaalinen ratkaisu on tulla mediaaniksi ja laskea kaikki mediaaniksi tulemisen kustannukset.

Aika monimutkaisuus on $O(n\log n)$, tilan monimutkaisuus on $O(n)$。

Viitekoodi

• Python

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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• Java

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));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• Cpp

#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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

🥝 04.LYA的字符画

Kysymyksen kuvaus

LYA on viime aikoina ollut pakkomielle hahmomaalauksesta. Hän uskoo, että hahmomaalauksen kauneus vastaa peräkkäisten identtisten symbolien määrää hahmomaalauksessa.Esimerkiksi hahmomaalauksen "aabbccddef" estetiikka on$6$。

LYAn ystävä antoi hänelle a $0$ ja$1$ LYA, josta on tullut pakkomielle hahmojen piirtämiseen, haluaa tietää kaikki tämän merkkijonon kielet.alamerkkijonoMikä on estetiikan summa?

Huomautus: Niitä on $C_{n+1}^2$ alamerkkijono.

Syöttömuoto

Syötä ensimmäiselle riville positiivinen kokonaisluku $n$, joka osoittaa merkkijonon pituuden.

Toisen rivin pituus on $n$ /$01$ merkkijono.

Tulostusmuoto

Tulosta kokonaisluku, joka edustaa kaikkien osamerkkijonojen esteettisyyden summaa.

Näytesyöttö

4
0011
1
2

Näytetulostus

14
1

dataväli

$1\le n\le 2\times 10^5$

vastaus

Tämä ongelma voidaan ratkaista etuliitesumman idealla.

Ensin voimme laskea merkkijonon osamerkkijonojen kokonaismäärän, eli $\frac{n(n+1)}{2}$。

Sitten iteroimme merkkijonon yli ja käytämme muuttujia $l$ Kirjaa muistiin nykyisten peräkkäisten identtisten symbolien lähtöpaikka, muuttuja$r$ Tallenna nykyinen sijainti.kun$s[r]\ne s[r-1]$ Kun , se tarkoittaa, että uusi symboli ilmestyy, ja voimme laskea$[l,r)$ Välissä olevien osamerkkijonojen lukumäärä, eli$\frac{(r-l)(r-l+1)}{2}$, vähennä se osamerkkijonojen kokonaismäärästä.

Lopuksi jäljellä on kaikkien kauniiden alijonojen lukumäärä, jotka voidaan tulostaa.

aika monimutkaisuus $O(n)$, tilan monimutkaisuus $O(1)$。

Viitekoodi

• Python

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• Java

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• Cpp

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

🌸 05.卢小姐的数组删除计划

Kysymyksen nimi

Ongelman kuvaus

Neiti Lulla on erittäin suuri suunnitelma, hän haluaa poistaa kaikki taulukot maailmassa! Mutta hänen kykynsä on rajoitettu, hän voi valita vain kaksi identtistä elementtiä taulukosta joka kerta ja poistaa kaikki elementit niiden välillä (mukaan lukien itse kaksi elementtiä).

Nyt neiti Lu:n edessä on pituus $n$ joukko$a$, hän haluaa tietää, kuinka monta elementtiä tästä taulukosta hän voi enintään poistaa.

Syöttömuoto

Ensimmäinen rivi sisältää positiivisen kokonaisluvun $n$, edustaa taulukkoa $a$ pituus.

Toinen rivi sisältää $n$ välilyönnillä erotetut positiiviset kokonaisluvut$a_1,a_2,\dots ,a_n$, edustaa taulukkoa $a$ Elementit.

Tulostusmuoto

Tulosta kokonaisluku, joka osoittaa, kuinka monta elementtiä neiti Lu voi poistaa.

Näytesyöttö

4
1 2 1 2
1
2

Näytetulostus

1
1

dataväli

• $1\le n\le 2\times 10^5$
• $1\le a_i\le 10^9$

vastaus

Tämä ongelma voidaan ratkaista käyttämällä lajitteluideoita ja kaksoisosoittimia.

Ensin voimme muuntaa taulukon $a$ Kohteen elementit lajitellaan arvon mukaan, ja jokaisen elementin alkuperäinen sijainti taulukossa tallennetaan. Tämän tarkoituksena on auttaa meitä löytämään saman elementin sijaintialue.

Seuraavaksi voimme iteroida lajiteltua taulukkoa ja löytää jokaisesta elementistä kaikkien niiden elementtien sijaintialueen, joilla on sama arvo. $[L,R]$ . Tämän alueen elementit voidaan poistaa, koska ne sijaitsevat kahden identtisen elementin välissä alkuperäisessä taulukossa.Voimme laskea alueen$[L,R]$ Elementtien määrä$R-L-1$, vertaa sitä nykyiseen poistettujen elementtien enimmäismäärään ja päivitä enimmäisarvo.

Tulosta lopuksi poistettujen elementtien enimmäismäärä.

Aika monimutkaisuus on $O(n\log n)$ , lähinnä lajittelun aika monimutkaisuus.Tilan monimutkaisuus on$O(n)$, jota käytetään elementin alkuperäisen sijainnin tallentamiseen.

Viitekoodi

• Python

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• Java

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• Cpp

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

kirjoittaa loppuun

Tässä haluan suositella seniorin rekrytointikumppanin lähtöselvityshyttiä. Se vie sinut askel askeleelta ratkaisemaan yleisiä kirjallisia Internet-koekysymyksiä. Jokainen päivä on täynnä hyödyllistä tietoa.

🎧 秋招陪伴刷题打卡

• Kokeilua:

[Syksyn rekrytointiin kirjautuminen] Päivä01 - Mukautettu lajittelu -CSDN-blogi

[Syksyn rekrytointiin kirjautuminen] Päivä 02 - Vahvin kaksiosainen sarja - Binaarihaku - CSDN-blogi

[Syksyn rekrytointiin kirjautuminen] Päivä 03 - Vahvin kahden pisteen sarja - Kahden pisteen vastaus - CSDN-blogi

Tarjoamme online-arvosteluja todellisista kysymyksistä aiemmilta suurilta valmistajilta. Kiinnostuneet ystävät voivat lähettää yksityisviestin Qinglongille saadaksesi lisätietoja.

Ja lisää! sitä paitsi!

✈️ Kattava tiivistelmä kirjallisista koekysymyksistä