Minimum representation

Minimum representation

1. Principle of minimum representation

Problem: given a string, we can rotate the string arbitrarily to return the string representation with the smallest dictionary order.

  • Assuming that the given string is s, we first copy s to the tail of S. assuming that the string length is n, when we enumerate the starting point start and return 0~n-1, we can get the representation of all strings.

  • Initially let i=0, j=1, compare s[i+k] and s[j+k], and use K to represent the offset position relative to I and J. if it is equal, let K + + until the first unequal position is compared. Assuming s[i+k] > s[j+k], it indicates that the string starting from i~i+k is not the minimum representation of the original string, and I can be updated to i+k+1; Conversely, you can update J.

  • In the update process, if i==j, you need to stagger the two. You can let i + + and finally return min(i, j). This position is the starting point of the minimum representation corresponding to the string.

2. Minimum representation problem on acwing

AcWing 158. Necklace

Problem description

analysis

  • Find the minimum representation of two strings and compare whether they are equal.

code

  • C++
#include <iostream>
#include <cstring>

using namespace std;

const int N = 2000010;

int n;
char a[N], b[N];

int get_min(char s[]) {
    
    int i = 0, j = 1;
    while (i < n && j < n) {
        int k = 0;
        while (k < n && s[i + k] == s[j + k]) k++;
        if (s[i + k] > s[j + k]) i += k + 1;
        else j += k + 1;
        
        if (i == j) i++;
    }
    int k = min(i, j);
    s[k + n] = 0;
    return k;
}

int main() {
    
    scanf("%s%s", a, b);
    
    n = strlen(a);
    memcpy(a + n, a, n);
    memcpy(b + n, b, n);
    
    int x = get_min(a), y = get_min(b);
    if (strcmp(a + x, b + y)) puts("No");
    else {
        puts("Yes");
        puts(a + x);
    }
    
    return 0;
}

3. Minimum representation on force buckle

Leetcode 0796 rotate string

Title Description: Leetcode 0796 rotate string

analysis

  • The test point of this question: minimum representation.

  • Find the minimum representation of two strings and compare whether they are equal.

  • Assuming that the given string is s, we first copy s to the tail of S. assuming that the string length is n, when we enumerate the starting point start and return 0~n-1, we can get the representation of all strings.

  • Initially let i=0, j=1, compare s[i+k] and s[j+k], and use K to represent the offset position relative to I and J. if it is equal, let K + + until the first unequal position is compared. Assuming s[i+k] > s[j+k], it indicates that the string starting from i~i+k is not the minimum representation of the original string, and I can be updated to i+k+1; Conversely, you can update J.

  • In the update process, if i==j, you need to stagger the two. You can let i + + and finally return min(i, j). This position is the starting point of the minimum representation corresponding to the string.

code

  • C++
class Solution {
public:
    bool rotateString(string A, string B) {
        if (A.size() != B.size()) return false;
        return get_min(A) == get_min(B);
    }

    string get_min(string s) {
        int n = s.size();
        s = s + s;
        int i = 0, j = 1;
        while (i < n && j < n) {
            int k = 0;
            while (k < n && s[i + k] == s[j + k]) k++;
            if (s[i + k] > s[j + k]) i += k + 1;
            else j += k + 1;

            if (i == j) i++;
        }
        int k = min(i, j);
        return s.substr(k, n);
    }
};
  • Java
class Solution {
    public boolean rotateString(String A, String B) {
        if (A.length() != B.length()) return false;
        return get_min(A).equals(get_min(B));
    }

    private String get_min(String s) {
        int n = s.length();
        StringBuilder sb = new StringBuilder();
        sb.append(s).append(s);
        char[] cs = sb.toString().toCharArray();
        int i = 0, j = 1;
        while (i < n && j < n) {
            int k = 0;
            while (k < n && cs[i + k] == cs[j + k]) k++;
            if (cs[i + k] > cs[j + k]) i += k + 1;
            else j += k + 1;

            if (i == j) i++;
        }
        int k = Math.min(i, j);
        return sb.substring(k, k + n).toString();
    }
}

Spatiotemporal complexity analysis

  • Time complexity: O ( n ) O(n) O(n), n is the string length.

  • Space complexity: O ( n ) O(n) O(n).

Tags: Algorithm

Posted on Fri, 01 Oct 2021 22:54:10 -0400 by NZ_Kiwis