Reorganice los caracteres en una string de modo que no haya dos adyacentes iguales usando hash

Dada una string str con caracteres repetidos, la tarea es reorganizar los caracteres en una string de modo que no haya dos caracteres adyacentes iguales. Si es posible, imprima Sí , de lo contrario, imprima No.
Ejemplos: 

Entrada: str = “geeksforgeeks” 
Salida: Sí 
, “egeksforegeks” es uno de esos arreglos.

Entrada: str = “bbbbb” 
Salida: No 

Enfoque: la idea es almacenar la frecuencia de cada carácter en un mapa_desordenado y comparar la frecuencia máxima del carácter con la diferencia de la longitud de la string y el número de frecuencia máxima. Si la frecuencia máxima es menor que la diferencia, entonces no se puede arreglar de otra manera.

1. Comencemos poniendo todos los caracteres que tienen la frecuencia máxima alternativamente. Luego, como mínimo, necesitamos (max_freq-1) espacios entre ellos para resolver la pregunta de modo que no estén adyacentes entre sí.
2. Pero nos quedan (longitud de la string – max_freq) espacios. Por lo tanto, (longitud de la string – max_freq) debe ser al menos (max_freq-1) para organizar de tal manera que no haya dos caracteres iguales.
3. Entonces, funciona de esta manera: (max_freq-1) <= (longitud de la string – max_freq) 
    

A continuación se muestra la implementación del enfoque anterior:

// C++ implementation of the approach
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
 
// Function that returns true if it is possible
// to rearrange the characters of the string
// such that no two consecutive characters are same
int isPossible(string str)
{
 
    // To store the frequency of
    // each of the character
    unordered_map<char, int> freq;
 
    // To store the maximum frequency so far
    int max_freq = 0;
    for (int j = 0; j < (str.length()); j++) {
        freq[str[j]]++;
        if (freq[str[j]] > max_freq)
            max_freq = freq[str[j]];
    }
 
    // If possible
    if (max_freq <= (str.length() - max_freq + 1))
        return true;
    return false;
}
 
// Driver code
int main()
{
    string str = "geeksforgeeks";
 
    if (isPossible(str))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}

// Java implementation of the approach
import java.util.*;
 
class GFG {
 
    // Function that returns true if it is possible
    // to rearrange the characters of the string
    // such that no two consecutive characters are same
    static boolean isPossible(char[] str)
    {
 
        // To store the frequency of
        // each of the character
        Map<Character, Integer> freq = new HashMap<>();
 
        // To store the maximum frequency so far
        int max_freq = 0;
        for (int j = 0; j < (str.length); j++) {
            if (freq.containsKey(str[j])) {
                freq.put(str[j], freq.get(str[j]) + 1);
                if (freq.get(str[j]) > max_freq)
                    max_freq = freq.get(str[j]);
            }
            else {
                freq.put(str[j], 1);
                if (freq.get(str[j]) > max_freq)
                    max_freq = freq.get(str[j]);
            }
        }
 
        // If possible
        if (max_freq <= (str.length - max_freq + 1))
            return true;
        return false;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str = "geeksforgeeks";
 
        if (isPossible(str.toCharArray()))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// This code is contributed by Rajput-Ji

# Python3 implementation of the approach
 
# Function that returns true if it is possible
# to rearrange the characters of the String
# such that no two consecutive characters are same
def isPossible(Str):
 
    # To store the frequency of
    # each of the character
    freq = dict()
 
    # To store the maximum frequency so far
    max_freq = 0
    for j in range(len(Str)):
        freq[Str[j]] = freq.get(Str[j], 0) + 1
        if (freq[Str[j]] > max_freq):
            max_freq = freq[Str[j]]
 
    # If possible
    if (max_freq <= (len(Str) - max_freq + 1)):
        return True
    return False
 
# Driver code
Str = "geeksforgeeks"
 
if (isPossible(Str)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by Mohit Kumar

// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function that returns true if it is possible
    // to rearrange the characters of the string
    // such that no two consecutive characters are same
    static Boolean isPossible(char[] str)
    {
 
        // To store the frequency of
        // each of the character
        Dictionary<char, int> freq = new Dictionary<char, int>();
 
        // To store the maximum frequency so far
        int max_freq = 0;
        for (int j = 0; j < (str.Length); j++) {
            if (freq.ContainsKey(str[j])) {
                var v = freq[str[j]] + 1;
                freq.Remove(str[j]);
                freq.Add(str[j], v);
                if (freq[str[j]] > max_freq)
                    max_freq = freq[str[j]];
            }
            else {
                freq.Add(str[j], 1);
                if (freq[str[j]] > max_freq)
                    max_freq = freq[str[j]];
            }
        }
 
        // If possible
        if (max_freq <= (str.Length - max_freq + 1))
            return true;
        return false;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        String str = "geeksforgeeks";
 
        if (isPossible(str.ToCharArray()))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code is contributed by Princi Singh

<script>
 
    // Javascript implementation of the approach
 
    // Function that returns true if it is possible
    // to rearrange the characters of the string
    // such that no two consecutive characters are same
    function isPossible(str)
    {
  
        // To store the frequency of
        // each of the character
        let freq = new Map();
  
        // To store the maximum frequency so far
        let max_freq = 0;
        for (let j = 0; j < (str.length); j++) {
            if (freq.has(str[j])) {
                freq.set(str[j], freq.get(str[j]) + 1);
                if (freq.get(str[j]) > max_freq)
                    max_freq = freq.get(str[j]);
            }
            else {
                freq.set(str[j], 1);
                if (freq.get(str[j]) > max_freq)
                    max_freq = freq.get(str[j]);
            }
        }
  
        // If possible
        if (max_freq <= (str.length - max_freq + 1))
            return true;
        return false;
    }
     
    // Driver code
     
     let str = "geeksforgeeks";
  
        if (isPossible(str.split('')))
            document.write("Yes");
        else
           document.write("No");
 
// This code is contributed by rrrtnx.
</script>

Yes

Complejidad de tiempo: O (N), ya que estamos usando un bucle para atravesar N veces.
Espacio auxiliar: O(26), ya que estamos usando el mapa de frecuencias.