LeetCode Weekly Contest 118

要死要死，第一题竟然错误8次，心态崩了呀，自己没有考虑清楚，STL用的也不是很熟，一直犯错。

第二题也是在室友的帮助下完成的，心态崩了。

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

题目意思很清楚就不解释了。说下两个很坑的数据吧，输出结果可以任意顺序， 第一个：输入  1 1 1     输出 [1]  第二个  1 2 100  输出 [2,3,5,9,17,33,65]

class Solution {
public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
        vector<int> ans;
        if( x < y ) swap(x, y);
        int px = 1, py = 1;
        while( px <= bound ) {
            py = 1;
            while( px + py <= bound ) {
                ans.push_back(px+py);
                py = py*y;
                if( y == 1 ) break;
            }
            px = px * x;
            if( x == 1 ) break;
        }
        sort(ans.begin(), ans.end());
        ans.erase(unique(ans.begin(), ans.end()), ans.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]

题意：规定了翻转规则是：选择一个数k将数组前面的k个数字移到数组后面。现在问你给你一个打乱顺序的数组A，你要尽量多少次这样的翻转才能将其变成一个有序的数组（1-n排列）。

思路：无论怎么翻转，最后的结果肯定是A[i]=i+1，所以直接去数组中找对应的数字然后直接按照规则翻转就好。

class Solution {
public:
    vector<int> pancakeSort(vector<int>& A) {
        vector<int> ans;
        int n = A.size();

        for (int i = n; i > 0; i--) {
            int index = find(A.begin(), A.end(), i) - A.begin();
            ans.push_back(index + 1);
            reverse(A.begin(), A.begin() + index + 1);
            ans.push_back(i);
            reverse(A.begin(), A.begin() + i);
        }

        return ans;
    }
};

原文地址：https://www.cnblogs.com/Asimple/p/10228326.html