从给定的字符串数组中按字典顺序最小的第 K 个不同字符串

给定一个具有N个字符串和一个整数K的数组arr ，任务是找到字典上最小的第 K个不同字符串。如果不存在这样的字符串，则打印一个空字符串。

例子：

Input: arr[]={“aa”, “aa”, “bb”, “cc”, “dd”, “cc”}, K = 2
Output: dd
Explanation: Distinct strings are: “bb”, “dd”. 2nd smallest string among these is “dd”

Input: arr[]={“aa”, “aa”, “bb”, “cc”, “dd”, “cc”}, K = 1
Output: bb

方法：给定的问题可以通过首先对给定的字符串数组进行排序，然后以频率1打印第K个字符串来解决。按照以下步骤解决这个问题：

1. 对给定的字符串数组进行排序
2. 创建一个映射来存储每个字符串的频率。
3. 现在，遍历映射并在每次找到频率为 1 的字符串时减小 K 的值。
4. 当K变为零时，打印频率为 1 的下一个字符串。

下面是上述方法的实现：

C++

// C++ code for the above approach
 
#include 
using namespace std;
 
// Function to print lexicographically
// smallest Kth string
string KthDistinctString(vector& arr, int K)
{
 
    // Sorting the array of strings
    sort(arr.begin(), arr.end());
 
    // Map to store the strings
    map mp;
    for (auto x : arr) {
        mp[x]++;
    }
 
    for (auto x : mp) {
 
        // Reducing K
        if (x.second == 1) {
            K--;
        }
 
        if (K == 0 and x.second == 1) {
            return x.first;
        }
    }
 
    return "";
}
 
// Driver Code
int main()
{
    vector a
        = { "aa", "aa", "bb", "cc", "dd", "cc" };
    int K = 2;
    cout << KthDistinctString(a, K);
}

Java

// Java code for the above approach
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
 
class GFG {
 
    // Function to print lexicographically
    // smallest Kth string
    static String KthDistinctString(ArrayList arr, int K) {
 
        // Sorting the array of strings
        Collections.sort(arr);
 
        // Map to store the strings
        HashMap mp = new HashMap();
 
        for (String x : arr) {
            int count = 0;
 
            if (mp.containsKey(x)) {
                count = mp.get(x);
            }
            mp.put(x, count + 1);
        }
 
        for (String x : mp.keySet()) {
            // Reducing K
            if (mp.get(x) == 1) {
                K--;
            }
 
            if (K == 0 && mp.get(x) == 1) {
                return x;
            }
        }
 
        return "";
    }
 
    // Driver Code
    public static void main(String args[]) {
        ArrayList a = new ArrayList();
 
        a.add("aa");
        a.add("aa");
        a.add("bb");
        a.add("cc");
        a.add("dd");
        a.add("cc");
 
        int K = 2;
        System.out.println(KthDistinctString(a, K));
    }
}
 
// This code is contributed by gfgking

Python3

# Python3 code for the above approach
 
# Function to print lexicographically
# smallest Kth string
def KthDistinctString(arr, K):
     
    # Sorting the array of strings
    arr.sort()
 
    # Map to store the strings
    mp = {}
    for x in arr:
        if x in mp:
            mp[x] += 1
        else:
            mp[x] = 1
 
    for x in mp:
 
        # Reducing K
        if (mp[x] == 1):
            K -= 1
 
        if (K == 0 and mp[x] == 1):
            return x
 
    return ""
 
# Driver Code
if __name__ == "__main__":
 
    a = [ "aa", "aa", "bb", "cc", "dd", "cc" ]
    K = 2
     
    print(KthDistinctString(a, K))
 
# This code is contributed by rakeshsahni

C#

// C# code for the above approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG
{
   
// Function to print lexicographically
// smallest Kth string
static string KthDistinctString(ArrayList arr, int K)
{
 
    // Sorting the array of strings
    arr.Sort();
 
    // Map to store the strings
    Dictionary mp =
          new Dictionary();
           
    foreach (string x in arr) {
        int count = 0;
         
        if (mp.ContainsKey(x)) {
                count = mp[x];
        }
        mp[x] = count + 1;
    }
 
    foreach (KeyValuePair x in mp) {
        // Reducing K
        if (x.Value == 1) {
            K--;
        }
 
        if (K == 0 && x.Value == 1) {
            return x.Key;
        }
    }
 
    return "";
}
 
// Driver Code
public static void Main()
{
    ArrayList a = new ArrayList();
     
    a.Add("aa");
    a.Add("aa");
    a.Add("bb");
    a.Add("cc");
    a.Add("dd");
    a.Add("cc");
     
    int K = 2;
    Console.Write(KthDistinctString(a, K));
}
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

 
       // JavaScript Program to implement
       // the above approach
 
       // Function to print lexicographically
       // smallest Kth string
       function KthDistinctString(arr, K) {
 
           // Sorting the array of strings
           arr.sort();
 
           // Map to store the strings
           let mp = new Map();
           for (let x of arr) {
               if (mp.has(x))
                   mp.set(x, mp.get(x) + 1);
               else
                   mp.set(x, 1);
 
           }
 
           for (let [key, value] of mp)
           {
 
               // Reducing K
               if (value == 1) {
                   K--;
               }
 
               if (K == 0 && value == 1) {
                   return key;
               }
           }
 
           return "";
       }
 
       // Driver Code
       let a
           = ["aa", "aa", "bb", "cc", "dd", "cc"];
       let K = 2;
       document.write(KthDistinctString(a, K));
 
   // This code is contributed by Potta Lokesh
   

输出

dd

时间复杂度： O(NlogN)
辅助空间： O(N)