宝石手串

#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")

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))
#运行超时暂时懒得改了

n=int(input())
for i in range(n):
    num=input()
    s=input()*2
    if len(s)==4:
        print(-1)
    else:
        list1=[]
        for j in range(len(s)//2):
            for k in range(j+1,j+len(s)//2):
                if s[j]==s[k]:
                    list1.append(k-j)
                    break
        if len(list1)==0:
            print(-1)
        else:
            print(min(list1)-1)

#include <climits>
#include <iostream>
#include <vector>
using namespace std;
 
int main() {
    int n;
    cin >> n;
    vector<pair<int, string>> vec(n);//store input data
    int num;
    string str;
    for (int i = 0; i < n; ++i) { //赋值给vec
        cin >> num;
        cin >> str;
        vec[i].first = num;
        vec[i].second = str;
    }
 
    for (int i = 0; i < n; ++i) {
        int min_gap = INT_MAX;
        for (char c = 'a'; c <= 'z'; ++c) { //本来想暴力破解，奈何运行时间超出要求，那就遍历26个字母了
            char loc = c;
            vector<int> subscript; //用于存放字母的下标
            for (int j = 0; j < vec[i].first; ++j) {
                if ( loc == vec[i].second[j])
                    subscript.push_back(j); //存入字母下标
            }
            if (subscript.size() == 0 || subscript.size() == 1 )
                continue; //无该字母或只有一个该字母，无须执行之后操作
            for (int k = 0; k < subscript.size() - 1; ++k) {
                int a = subscript[k + 1] - subscript[k] - 1;
                min_gap = min(min_gap, a );
            }
            int b = subscript[0] + vec[i].first - subscript[subscript.size() - 1] - 1;//环形字母间隔
            if (b < min_gap)
                min_gap = b;
            if (min_gap == 0) //如果存在两相同字母紧挨，则排斥，无须之后继续遍历当下字符串
                break;
        }
        if (min_gap == INT_MAX)
            cout << -1 << endl;
        else
            cout << min_gap << endl;
    }
    return 0;
}

T=int(input())
for i in range(T):
    n=int(input())
    s=input()
    s_dict={}
    count=len(s)
    if len(s)==len(set(s)):
        print('-1')
    else:
        for idx,char in enumerate(s):
            if char in s_dict:
                s_dict[char].append(idx)
            else:
                s_dict[char]=[idx]
        for item,value in s_dict.items():
            if len(value)>=2:
                count=min(count,min(value[i]-value[i-1] for i in range(1,len(value)))-1,len(s)-value[-1]+value[0]-1)
        print(count)

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