宝石手串

def baoshi(s):
    c = 1
    for char in s:
        if s.count(char) >= 2:
            c = 0
    if c:
        return -1
    huan_s = s + s
    break_c = []
    for i in range(len(huan_s)):
        for j in range(i+1,len(huan_s)):
            if huan_s[i] == huan_s[j]:
                c = j - i - 1
                break_c.append(c)
    return min(break_c)

n = int(input())
for i in range(n):
    k = int(input())
    shoucuan = str(input())
    print(baoshi(shoucuan))
#运行超时暂时懒得改了

#include <iostream>
using namespace std;

int calcu(){
    string s;
    int n;
    cin >> n;
    cin >> s;
    if(n == 2) return -1;
    int mini = 1e5 + 5;
    s = "*" + s + s + "*";
    int len = s.size() / 2;
    for(int i = 1; i < len; i++){
        char c = s[i];
        if(s.find(c, i + 1) != -1){
            int l = s.find(c, i + 1) - i - 1;
            if(l == n - 1) continue;
            mini = min(mini, l);
        }
    }
    if(mini != 1e5 + 5) return mini;
    return -1;
}
int main() {
    int T;
    cin >> T;
    while(T--){
        cout << calcu() << endl;
    }
}
// 64 位输出请用 printf("%lld")

N = int(input())
while 1:
    try:
        n = int(input())
        ls = list(input())
        count = n
        code = {}
        for i in range(n):
            if ls[i] in code:
                code[ls[i]].append(i)
            else:
                code[ls[i]] = []
                code[ls[i]].append(i)
        psbls = []
        for x in code.items():
            if len(x[1])>1:
                psbls.append(x[0])
        if len(psbls) == 0:
            print(-1)
        else:
            for x in psbls:
                for i in range(len(code[x])-1):
                    if (code[x][i+1] - code[x][i]-1)<count:
                        count = code[x][i+1] - code[x][i]-1
                if (n - code[x][-1] + code[x][0] - 1)<count:
                    count = n - code[x][-1] + code[x][0] - 1
            print(count)

    except:
        break

#include <climits>
#include <iostream>
#include <vector>
using namespace std;

int main() {

    int num;
    cin >> num;
    while (num--) {
        int stonenum;
        cin >> stonenum;
        string str;
        cin >> str;
        vector<vector<int>> store(26);
        for (int i = 0; i < str.size(); i++) {
            store[str[i] - 'a'].push_back(i);
        }

        // 不能破坏的情况
        int breakflag = 0;
        for (int i = 0; i < 26; i++) {
            if (store[i].size() <= 1) continue;
            else {
                breakflag = 1;
            }
        }
        if (breakflag == 0) {
            cout << -1 << endl;
            continue;
        }

        //  能破坏的情况
        int mindis = INT_MAX;
        for (int i = 0; i < 26; i++) {
            if (store[i].size() <= 1) continue;

            // 比较前后大小
            for (int j = 1; j < store[i].size(); j++) {
                int prediff = store[i][j] - store[i][j - 1] - 1;
                int backdiff = stonenum - store[i][j] + store[i][0] - 1;

                mindis = min(mindis, min(prediff, backdiff));
            }
        }

        cout << mindis << endl;
    }
}

m=int(input())
for _ in range(m):
    n=int(input())
    m=input()
    if n==2 and m[0]!=m[1]:
        print(-1)
    else:
        last={}
        for j,k in enumerate(m):#abcdajlc
            if k not in last:
                last[k]=j
            else:
                print(j-last[k]-1)

            
            

把原字符串再复制一份，模拟收尾相连的字符串，比如原字符串为ac，我们把它变为acac，
从头开始遍历字符串，用HashMap时刻记录各个元素最近出现的位置，求出距离最小值。
注意，如果遍历结束，距离最小值为字符串的长度 - 1，说明原字符串没有相同元素，返回-1。
否则返回距离的最小值。
import java.util.Scanner;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int T = in.nextInt();
        for (int i = 0; i < T; i++) {
            int n = in.nextInt();
            in.nextLine();
            String s = in.nextLine();
            String str = s + s;
            Map<Character, Integer> map = new HashMap<>();
            char[] chars = str.toCharArray();
            int min = Integer.MAX_VALUE;
            for (int j = 0; j < chars.length; j++) {
                if (map.containsKey(chars[j])) {
                    min = Math.min(min, j - map.get(chars[j]) - 1);
                }
                map.put(chars[j], j);
            }
            if (min == s.length() - 1) {
                System.out.println(-1);
            } else {
                System.out.println(min);
            }
        }
    }
}

def compute(n,s):
    my_dict = {}
    # value是三元组 首位置 上一个位置 最小距离
    for i in range(n):
        a = s[i]
        if a in my_dict:        
            my_dict[a][2] = min(my_dict[a][2],min(i-my_dict[a][1]-1,my_dict[a][0]+n-1-i))
            my_dict[a][1] = i
        else:
            my_dict[a] = [i,i,n+1]

    ans = min([value[-1] for value in my_dict.values()])
    return ans if ans<n else -1


T = int(input())
for i in range(T):
    n = int(input())
    s = str(input())
    print(compute(n,s))

#include <algorithm>
#include <climits>
#include <cstdint>
#include <iostream>
#include <set>
#include <vector>
using namespace std;

int main() {

    int n;
    cin >> n;

    while (n--) {
        int cnt;
        string str;
        cin >> cnt;
        cin >> str;

        bool hasConnect = false;
        for ( int i = 0; i < cnt; i++ ) {
            if ( str[i] == str[ (i + 1) % cnt ] ) {
                hasConnect = true;
                break;
            }
        }

        if ( hasConnect ) {
            cout << 0 << endl;
            continue;
        }

        if ( cnt == 2 ) {
            cout << -1 << endl;
            continue;
        }

        int min_gap = INT_MAX;
        for ( char c = 'a'; c <= 'z'; c++ ) {
            vector<int> vec;
            for ( int i = 0; i < cnt; i++ ) {
                if ( str[i] == c ) {
                    vec.push_back(i);
                }
            }
            if ( vec.size() < 2 ) {
                continue;;
            }
            for ( int i = 0; i < vec.size() - 1; i++ ) {
                if ( vec[i + 1] - vec[i] - 1 < min_gap ) {
                    min_gap = vec[i + 1] - vec[i] - 1;
                }
            }
            //环形处理
            int nu = ( cnt - vec.back() ) + vec.front() - 1;
            min_gap = min( nu, min_gap );

        }
        if ( min_gap == INT_MAX ) {
            cout << -1 << endl;
        } else {
            cout << min_gap << endl;
        }

    }
}
// 64 位输出请用 printf("%lld")