Weekly Contest 118

970. Powerful Integers

Given two non-negative integers x and y, an integer is powerful if it is equal to x^i + y^j for some integers i >= 0 and j >= 0.

Return a list of all powerful integers that have value less than or equal to bound.

You may return the answer in any order.  In your answer, each value should occur at most once.

Example 1:

Input: x = 2, y = 3, bound = 10
Output: [2,3,4,5,7,9,10]
Explanation:
2 = 2^0 + 3^0
3 = 2^1 + 3^0
4 = 2^0 + 3^1
5 = 2^1 + 3^1
7 = 2^2 + 3^1
9 = 2^3 + 3^0
10 = 2^0 + 3^2

Example 2:

Input: x = 3, y = 5, bound = 15
Output: [2,4,6,8,10,14]

Note:

• 1 <= x <= 100
• 1 <= y <= 100
• 0 <= bound <= 10^6

Approach #1: C++.

class Solution {
public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
       vector<int> arr_x, arr_y;
        int num_x = 1, num_y = 1;

        if (x == 1) arr_x.push_back(1);
        else for (int i = num_x; i < bound; i *= x) arr_x.push_back(i);

        if (y == 1) arr_y.push_back(1);
        else for (int j = num_y; j < bound; j *= y) arr_y.push_back(j);

        set<int> temp;

        for (int i = 0; i < arr_x.size(); ++i) {
            for (int j = 0; j < arr_y.size(); ++j) {
                if (arr_x[i] + arr_y[j] <= bound) {
                    temp.insert(arr_x[i] + arr_y[j]);
                } else {
                    break;
                }
            }
        }

        vector<int> ans(temp.begin(), temp.end());

        return ans;
    }
};

　　

969. Pancake Sorting

Given an array A, we can perform a pancake flip: We choose some positive integer k <= A.length, then reverse the order of the first kelements of A.  We want to perform zero or more pancake flips (doing them one after another in succession) to sort the array A.

Return the k-values corresponding to a sequence of pancake flips that sort A.  Any valid answer that sorts the array within 10 * A.lengthflips will be judged as correct.

Example 1:

Input: [3,2,4,1]
Output: [4,2,4,3]
Explanation:
We perform 4 pancake flips, with k values 4, 2, 4, and 3.
Starting state: A = [3, 2, 4, 1]
After 1st flip (k=4): A = [1, 4, 2, 3]
After 2nd flip (k=2): A = [4, 1, 2, 3]
After 3rd flip (k=4): A = [3, 2, 1, 4]
After 4th flip (k=3): A = [1, 2, 3, 4], which is sorted.

Example 2:

Input: [1,2,3]
Output: []
Explanation: The input is already sorted, so there is no need to flip anything.
Note that other answers, such as [3, 3], would also be accepted.

Note:

1. 1 <= A.length <= 100
2. A[i] is a permutation of [1, 2, ..., A.length]

Approach #2: C++.

class Solution {
public:
    vector<int> pancakeSort(vector<int>& A) {
        vector<int> ans;
        vector<int> temp(A.begin(), A.end());
        while (!is_sorted(A.begin(), A.end())) {
            int size = temp.size();
            int pos = max_element(temp.begin(), temp.end()) - temp.begin();
            if (pos != size-1) {
                if (pos != 0) {
                    ans.push_back(pos+1);
                    reverse(temp.begin(), temp.begin()+pos+1);
                }
                ans.push_back(size);
                reverse(temp.begin(), temp.begin()+size);
            }
            A = temp;
            temp.resize(size-1);
        }

        return ans;
    }
};

　　

971. Flip Binary Tree To Match Preorder Traversal

Given a binary tree with N nodes, each node has a different value from {1, ..., N}.

A node in this binary tree can be flipped by swapping the left child and the right child of that node.

Consider the sequence of N values reported by a preorder traversal starting from the root.  Call such a sequence of N values the voyage of the tree.

(Recall that a preorder traversal of a node means we report the current node's value, then preorder-traverse the left child, then preorder-traverse the right child.)

Our goal is to flip the least number of nodes in the tree so that the voyage of the tree matches the voyage we are given.

If we can do so, then return a list of the values of all nodes flipped.  You may return the answer in any order.

If we cannot do so, then return the list [-1].

Example 1:

Input: root = [1,2], voyage = [2,1]
Output: [-1]

Example 2:

Input: root = [1,2,3], voyage = [1,3,2]
Output: [1]

Example 3:

Input: root = [1,2,3], voyage = [1,2,3]
Output: []

Note:

1. 1 <= N <= 100

Approach #1: C++.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> ans;
    int i = 0;

    vector<int> flipMatchVoyage(TreeNode* root, vector<int>& voyage) {
        if (dfs(root, voyage)) return ans;
        ans.clear();
        ans.push_back(-1);
        return ans;
    }

    bool dfs(TreeNode* node, vector<int>& voyage) {
        if (node == NULL) return true;
        if (node->val != voyage[i++]) return false;
        if (node->left && node->left->val == voyage[i]) {
            return dfs(node->left, voyage) && dfs(node->right, voyage);
        } else if (node->right && node->right->val == voyage[i]) {
            if (node->left)
                ans.push_back(node->val);
            return dfs(node->right, voyage) && dfs(node->left, voyage);
        }
        return !node->left && !node->right;
    }
};

　　

972. Equal Rational Numbers

Given two strings S and T, each of which represents a non-negative rational number, return True if and only if they represent the same number. The strings may use parentheses to denote the repeating part of the rational number.

In general a rational number can be represented using up to three parts: an integer part, a non-repeating part, and a repeating part. The number will be represented in one of the following three ways:

• <IntegerPart> (e.g. 0, 12, 123)
• <IntegerPart><.><NonRepeatingPart>  (e.g. 0.5, 1., 2.12, 2.0001)
• <IntegerPart><.><NonRepeatingPart><(><RepeatingPart><)> (e.g. 0.1(6), 0.9(9), 0.00(1212))

The repeating portion of a decimal expansion is conventionally denoted within a pair of round brackets.  For example:

1 / 6 = 0.16666666... = 0.1(6) = 0.1666(6) = 0.166(66)

Both 0.1(6) or 0.1666(6) or 0.166(66) are correct representations of 1 / 6.

Example 1:

Input: S = "0.(52)", T = "0.5(25)"
Output: true
Explanation:
Because "0.(52)" represents 0.52525252..., and "0.5(25)" represents 0.52525252525..... , the strings represent the same number.

Example 2:

Input: S = "0.1666(6)", T = "0.166(66)"
Output: true

Example 3:

Input: S = "0.9(9)", T = "1."
Output: true
Explanation:
"0.9(9)" represents 0.999999999... repeated forever, which equals 1.  [See this link for an explanation.]
"1." represents the number 1, which is formed correctly: (IntegerPart) = "1" and (NonRepeatingPart) = "".

Note:

1. Each part consists only of digits.
2. The <IntegerPart> will not begin with 2 or more zeros.  (There is no other restriction on the digits of each part.)
3. 1 <= <IntegerPart>.length <= 4
4. 0 <= <NonRepeatingPart>.length <= 4
5. 1 <= <RepeatingPart>.length <= 4

Approach #1: C++.

class Solution {
public:
    bool isRationalEqual(string S, string T) {
        return f(S) == f(T);
    }

    double f(string S) {
        auto i = S.find('(');
        if (i == string::npos) return stod(S);
        string base = S.substr(0, i);
        string rep = S.substr(i+1, S.length()-i-1-1);
        for (int i = 0; i < 20; ++i) {
            base += rep;
        }
        return stod(base.substr(0, 4+1+4+12));
    }
};

　　

Analysis:

https://leetcode.com/problems/equal-rational-numbers/discuss/214203/C%2B%2BPython-Easy-Cheat