给定一个由N个小写字母组成的字符数组str[]和一个由[0, N – 1]范围内的数字组成的整数数组arr[ ] 。以下是将在问题中执行的操作：
- 从左到右遍历字符数组str[] 。
- 对于每个第i个索引，存储最小的奇数长度（ >1 ）间隔（如果存在），比如[L, R]使得str[L] = str[R] 。
任务是从str[]中找到符合下列条件之一的字典序最小的字符：
- 其中str[L] == str[R]的字符不存在奇数长度间隔。
- 字符的所有区间必须包含不同的索引数组元素。
例子：
Input: str[] = { ‘a’, ‘b’, ‘c’, ‘a’, ‘e’, ‘a’, ‘a’ }, arr[] = { 4, 6 }
Output: a
Explanation:
Possible smallest odd-length interval of the character ‘a’ in str are { [0, 6], [3, 5] }
Since the interval [0, 6] contains arr[1] and the interval [3, 5] contains arr[0]. Therefore, the required output is ‘a’.
Input: str[] = { ‘a’, ‘b’, ‘c’, ‘d’ }, arr[] = { 3, 4 }
Output: a
Explanation:
Since no interval exist for any element of the character array. Therefore, the lexicographically smallest character of str[] is ‘a’.
Input: str[] = { ‘z’, ‘z’, ‘z’, ‘z’ }, arr[] = { 2 }
Output: -1
Explanation:
Possible smallest odd-length intervals of the character ‘z’ are { [0, 2], [1, 3] }
Since the interval [0, 2] contain arr[0] and the interval [1, 3] also contain arr[0] which is not distinct indexed array element. Therefore, the required output is -1.
方法：这个想法是为str[] 的每个可能的索引找到最小的奇数长度间隔。遍历 str[] 的每个不同字符并检查该字符满足上述条件。如果有多个字符满足上述条件，则从它们中打印字典序最小的字符。请按照以下步骤解决问题：
- 初始化一个数组，说散列[]，以检查是否存在字符阵列中的字符，STR []或没有。
- 初始化一个 ArrayList，比如间隔 [] ，形式为{ X, Y }以存储最小奇数长度间隔的起点和终点。
- 遍历数组hash[]并存储str[]的每个不同字符的所有最小奇数长度间隔。
- 按 X 的递增顺序对 interval[] 进行排序。
- 按升序对数组 arr[] 进行排序。
- 通过执行以下操作，检查一个字符的所有区间是否满足上述条件：
- 初始化一个 PriorityQueue 说， PQ来存储间隔Y的递增顺序的间隔。
- 使用变量i从左到右遍历arr[]数组。对于arr[] 的每个第i个索引，使用变量j遍历区间 []并检查区间 [j] 的起点是否小于arr[i] 。如果发现为真，则将间隔插入PQ 。
- 如果arr[i]存在于区间范围内，则移除PQ的顶部元素以确保不同的索引数组元素被分配到不同的区间。
- 如果在任何时间点arr[i]小于interval[i]的终点或PQ顶部元素的终点小于arr[i]则打印-1 。
- 否则，从满足条件的数组arr[]中打印字典序最小的字符。
下面是上述方法的实现：
Java
// Java Program to implement
// the above approach
import java.io.*;
import java.util.*;
class GFG {
// Structure of an interval
static class SpecialInterval {
// Stores start point of
// an interval
int low = 0;
// Stores end point of
// an interval
int high = 0;
// Initialize a interval
SpecialInterval(int low, int high)
{
this.low = low;
this.high = high;
}
}
// Function to check if a character
// present in arr[] or not
static boolean[] checkChar(char[] str)
{
// hash[i]: Check if character i
// is present in arr[] or not
boolean[] hash = new boolean[26];
// Traverse the character array
for (int i = 0; i < str.length; i++) {
// Mark arr[i] as true
hash[str[i] - 'a'] = true;
}
return hash;
}
// Function to check if all the intervals of a
// character satisfies the condition or not
private static boolean
checkIfValid(List intervals,
int[] arr)
{
// If no intervals found for
// the current character
if (intervals.size() == 0) {
return true;
}
// Sort intervals on increasing
// order of start point
Collections.sort(intervals,
(interval1, interval2)
-> interval1.low - interval2.low);
// Store the intervals on increasing
// order of end point of interval
PriorityQueue pq
= new PriorityQueue(
intervals.size(),
(interval1, interval2)
-> interval1.high - interval2.high);
// Stores count of array elements that
// is present in different intervals
int count = 0;
// Stores index of an interval
int j = 0;
// Traverse the character array
for (int i = 0; i < arr.length
&& count < intervals.size();
i++) {
// Traverse intervals[] array
while (j < intervals.size()) {
// Stores interval
// at j-th index
SpecialInterval interval
= intervals.get(j);
// If start point of interval
// greater than arr[i]
if (interval.low > arr[i])
break;
// Update j
j++;
// Insert interval into pq
pq.offer(interval);
}
// If count of intervals
// in pq greater than 0
if (pq.size() > 0) {
// Stores top element of pq
SpecialInterval interval
= pq.poll();
// arr[i] does not lie in
// the range of the interval
if (arr[i] > interval.high) {
break;
}
// Update count
count++;
}
}
return count == intervals.size();
}
// Function to find the intervals
// for each distinct character of str[]
private static List
findSpecialIntevals(char[] str, char ch)
{
// Stores the odd index
// of the character array
int oddPrev = -1;
// Stores even index of
// the character array
int evenPrev = -1;
// Stores all intervals for each
// distinct character of str
List intervals
= new ArrayList();
// Traverse the character array
for (int i = 0; i < str.length;
i++) {
if (str[i] == ch) {
// If i is even
if (i % 2 == 0) {
// If evenPrev not
// equal to -1
if (evenPrev == -1) {
// Update evenPrev
evenPrev = i;
}
else {
// Initialize an interval
SpecialInterval interval
= new SpecialInterval(
evenPrev, i);
// Insert current interval
// into intervals
intervals.add(interval);
// Update evenPrev
evenPrev = -1;
}
}
else {
// If oddPrev not
// equal to -1
if (oddPrev == -1) {
// Update oddPrev
oddPrev = i;
}
else {
// Initialize an interval
SpecialInterval interval
= new SpecialInterval(
oddPrev, i);
// Insert current interval
// into intervals
intervals.add(interval);
// Update oddPrev
oddPrev = -1;
}
}
}
}
return intervals;
}
// Function to print lexicographically smallest
// character that satisfies the condition
static void printAnswer(char[] str, int arr[])
{
// Sort the array
Arrays.sort(arr);
// Check if a character is present in
// str that satisfies the condition
boolean possible = false;
// hash[i]: Check if character i
// is present in arr[] or not
boolean[] hash = checkChar(str);
// Traverse all possible distinct
// character of str
for (int ch = 0; ch < 26; ch++) {
// If ch present in str
if (!hash[ch])
continue;
// Find all the intervals for
// current character
List intervals
= findSpecialIntevals(str,
(char)(ch + 'a'));
// Update possible
possible
= checkIfValid(intervals, arr);
// If a character found in str that
// satisfies the condition
if (possible) {
System.out.println(
(char)(ch + 'a'));
break;
}
}
// If no character found that
// satisfies the condition
if (!possible)
System.out.println(-1);
}
// Driver Code
public static void main(String[] args)
{
char[] str = { 'a', 'b', 'c', 'a',
'e', 'a', 'a' };
int arr[] = { 4, 6 };
printAnswer(str, arr);
}
} 输出：
a时间复杂度： O(N * log(N))
辅助空间： O(N)
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。