Example 1:

Input: mat = [[0,1],[1,0]], target = [[1,0],[0,1]]
Output: true
Explanation: We can rotate mat 90 degrees clockwise to make mat equal target.

Example 2:

Input: mat = [[0,1],[1,1]], target = [[1,0],[0,1]]
Output: false
Explanation: It is impossible to make mat equal to target by rotating mat.

Example 3:

Input: mat = [[0,0,0],[0,1,0],[1,1,1]], target = [[1,1,1],[0,1,0],[0,0,0]]
Output: true
Explanation: We can rotate mat 90 degrees clockwise two times to make mat equal target.

Constraints:

• n == mat.length == target.length
• n == mat[i].length == target[i].length
• 1 <= n <= 10
• mat[i][j] and target[i][j] are either 0 or 1.

Solution: Simulation

Time complexity: O(n²)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool findRotation(vector<vector<int>>& mat, vector<vector<int>>& target) {    
    const int n = mat.size();
    auto rot = [n](vector<vector<int>>& mat) {      
      for (int i = 0; i < n; ++i)
        for (int j = i; j < n; ++j)
          swap(mat[i][j], mat[j][i]);
      for (int j = 0; j < n; j++)
        for (int i = 0; i < n / 2; ++i)
          swap(mat[i][j], mat[n - i - 1][j]);
      return mat;
    };
    for (int i = 0; i < 4; ++i)
      if (rot(mat) == target) return true;    
    return false;
  }
};

The post 花花酱 LeetCode 1886. Determine Whether Matrix Can Be Obtained By Rotation appeared first on Huahua's Tech Road.

There may be duplicates in the original array.

Note: An array A rotated by x positions results in an array B of the same length such that A[i] == B[(i+x) % A.length], where % is the modulo operation.

Example 1:

Input: nums = [3,4,5,1,2]
Output: true
Explanation: [1,2,3,4,5] is the original sorted array.
You can rotate the array by x = 3 positions to begin on the the element of value 3: [3,4,5,1,2].

Example 2:

Input: nums = [2,1,3,4]
Output: false
Explanation: There is no sorted array once rotated that can make nums.

Example 3:

Input: nums = [1,2,3]
Output: true
Explanation: [1,2,3] is the original sorted array.
You can rotate the array by x = 0 positions (i.e. no rotation) to make nums.

Example 4:

Input: nums = [1,1,1]
Output: true
Explanation: [1,1,1] is the original sorted array.
You can rotate any number of positions to make nums.

Example 5:

Input: nums = [2,1]
Output: true
Explanation: [1,2] is the original sorted array.
You can rotate the array by x = 5 positions to begin on the element of value 2: [2,1].

Constraints:

• 1 <= nums.length <= 100
• 1 <= nums[i] <= 100

Solution: Counting and checking

Count how many turning points (nums[i] < nums[i – 1]) in the array. Return false if there are more than 1.
For the turning point r, (nums[r] < nums[r – 1), return true if both of the following conditions are satisfied:
1. nums[r – 1] is the largest number, e.g. nums[r – 1] >= nums[n – 1]
2. nums[r] is the smallest number, e.g. nums[r] <= nums[0]

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  bool check(vector<int>& nums) {
    int count = 0;
    int r = -1;
    for (size_t i = 1; i < nums.size(); ++i)
      if (nums[i] < nums[i - 1]) {
        ++count;
        r = i;
      }
    if (count == 0) return true;
    if (count > 1) return false;     
    return nums[r] <= nums[0] && nums[r - 1] >= nums.back();
  }
};

The post 花花酱 LeetCode 1752. Check if Array Is Sorted and Rotated appeared first on Huahua's Tech Road.

• p[0] = start
• p[i] and p[i+1] differ by only one bit in their binary representation.
• p[0] and p[2^n -1] must also differ by only one bit in their binary representation.

Example 1:

Input: n = 2, start = 3
Output: [3,2,0,1]
Explanation: The binary representation of the permutation is (11,10,00,01). 
All the adjacent element differ by one bit. Another valid permutation is [3,1,0,2]

Example 2:

Input: n = 3, start = 2
Output: [2,6,7,5,4,0,1,3]
Explanation: The binary representation of the permutation is (010,110,111,101,100,000,001,011).

Constraints:

• 1 <= n <= 16
• 0 <= start < 2 ^ n

Solution 1: Gray Code (DP) + Rotation

Gray code starts with 0, need to rotate after generating the list.

Time complexity: O(2^n)
Space complexity: O(2^n)

// Author: Huahua
class Solution {
public:
  vector<int> circularPermutation(int n, int start) {
    vector<vector<int>> dp(n + 1);
    dp[0] = {0};    
    for (int i = 1; i <= n; ++i) {
      dp[i] = dp[i - 1];
      for (int j = dp[i - 1].size() - 1; j >= 0; --j)
        dp[i].push_back(dp[i - 1][j] | (1 << (i - 1)));
    }
    for (auto it = begin(dp[n]); it != end(dp[n]); ++it)
      if (*it == start) {
        rotate(begin(dp[n]), it, end(dp[n]));
        break;
      }
    return dp[n];
  }
};

Solution 2: Gray code with a start

Time complexity: O(2^n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> circularPermutation(int n, int start) {
    vector<int> ans(1 << n);
    for (int i = 0; i < 1 << n; ++i)
      ans[i] = start ^ i ^ i >> 1;
    return ans;
  }
};

The post 花花酱 LeetCode 1238. Circular Permutation in Binary Representation appeared first on Huahua's Tech Road.

Problem

A string S of lowercase letters is given.  Then, we may make any number of moves.

In each move, we choose one of the first K letters (starting from the left), remove it, and place it at the end of the string.

Return the lexicographically smallest string we could have after any number of moves.

Input: S = "cba", K = 1
Output: "acb"
Explanation: 
In the first move, we move the 1st character ("c") to the end, obtaining the string "bac".
In the second move, we move the 1st character ("b") to the end, obtaining the final result "acb".

Input: S = "baaca", K = 3
Output: "aaabc"
Explanation: 
In the first move, we move the 1st character ("b") to the end, obtaining the string "aacab".
In the second move, we move the 3rd character ("c") to the end, obtaining the final result "aaabc".

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  string orderlyQueue(string S, int K) {
    if (K > 1) {
      sort(begin(S), end(S));
      return S;
    }
    
    string ans = S;
    for (int i = 1; i < S.size(); ++i)
      ans = min(ans, S.substr(i) +  S.substr(0, i));
    return ans;
  }
};

// Author: Huahua
class Solution {
  public String orderlyQueue(String S, int K) {
    if (K > 1) {
      char[] chars = S.toCharArray();
      Arrays.sort(chars);
      return new String(chars);
    }
    
    String ans = S;
    for (int i = 1; i < S.length(); ++i) {
      String tmp = S.substring(i) + S.substring(0, i);
      if (tmp.compareTo(ans) < 0) ans = tmp;        
    }
    return ans;
  }
}

# Author: Huahua 48 ms
class Solution:
  def orderlyQueue(self, S, K):
    if K > 1: return ''.join(sorted(S))
    return min([S[i:] + S[0:i] for i in range(0, len(S))])

# Author: Huahua 36 ms
class Solution:
  def orderlyQueue(self, S, K):
    if K > 1: return ''.join(sorted(S))
    ans = S
    for i in range(0, len(S)):
      ans = min(ans, S[i:] + S[0:i])
    return ans

The post 花花酱 LeetCode 899. Orderly Queue appeared first on Huahua's Tech Road.

Given an array, rotate the array to the right by k steps, where k is non-negative.

Example 1:

Input: [1,2,3,4,5,6,7] and k = 3 
Output: [5,6,7,1,2,3,4]
Explanation: rotate 1 steps to the right: [7,1,2,3,4,5,6] rotate 2 steps to the right: [6,7,1,2,3,4,5] 
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2:

Input:[-1,-100,3,99] and k = 2 
Output: [3,99,-1,-100] 
Explanation: rotate 1 steps to the right: [99,-1,-100,3] rotate 2 steps to the right: [3,99,-1,-100]

Note:

• Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
• Could you do it in-place with O(1) extra space?

Solution 1: Simulate rotation with three reverses.

If k >= n, rotating k times has the same effect as rotating k % n times.

[1,2,3,4,5,6,7], K = 3

[5,6,7,1,2,3,4]

We can simulate the rotation with three reverses.

1. reverse the whole array O(n) [7,6,5,4,3,2,1]
2. reverse the left part 0 ~ k – 1 O(k) [5,6,7,4,3,2,1]
3. reverse the right part k ~ n – 1 O(n-k) [5,6,7,1,2,3,4]

Time complexity: O(n)

Space complexity: O(1) in-place

C++

class Solution {
public:
  void rotate(vector<int>& nums, int k) {
    if (nums.empty()) return;
    k %= nums.size();
    if (k == 0) return;
    reverse(begin(nums), end(nums));
    reverse(begin(nums), begin(nums) + k);
    reverse(begin(nums) + k, end(nums));
  }
};

The post 花花酱 LeetCode 189. Rotate Array appeared first on Huahua's Tech Road.