1、买卖股票的最佳时机
这里最容易想到的就是暴力枚举，两层for循环，i = 0， j = i + 1开始，但是这样是O(n ^ 2)的时间复杂度，即使倒过来，选定一个值，找到这个值前面的一堆数字中的最小值，一减就能找到最大利润，但是没解决本质。不妨想一下，从第二个数开始往后走。每一次都找前面一堆数字的最小值，但后面要找的其实已经包含前面要找的了，也就是找第7个数字之前的最小值，一大部分已经在找第6个数字之前的最小值时找过了，只要把这个最小值和第6个数字一比较，谁小，谁就是找第7个数字之前的最小值，这样，算法就是O(N)了。
int maxProfit(vector<int>& prices) {
int res = 0;
for(int i = 0, prev = INT_MAX; i < prices.size(); ++i)
{
res = max(res, prices[i] - prev);//先更新结果是因为如果先更新最小值，那么结果就没法计算了
prev = min(prev, prices[i]);
}
return res;
}
2、买卖股票的最佳时机Ⅱ
根据这个图，可以画一个折线图，每天的价格就是一个点，连接起来所有点。思路就是每次选一个点，都找到从这个点开始持续递增后的点，如果价格出现减少或不变，那就停止，这样每个增长趋势内可得到的最大利润都被算进来了，就能得到最大利润。
为了找到严格递增过程中最大的点，可以用双指针来控制。另一个方法是把每段交易变成一天一天，这个思路是只要第二天的数字比第一天大，那就加上第二天的数字。
//双指针
int ret = 0, n = prices.size();
for(int i = 0; i < n; ++i)
{
int j = i;
while(j + 1 < n && prices[j + 1] > prices[j]) ++j;
ret += prices[j] - prices[i];
i = j;
}
return ret;
//拆分
int ret = 0;
for(int i = 1; i < prices.size(); ++i)
{
if(prices[i] > prices[i - 1])
ret += prices[i] - prices[i - 1];
}
return ret;
3、K次取反后最大化的数组和
理解这道题后会发现，应当先对最小的负数取反，才能得到最大和。从负数开始，从小到大，一个个取反。假设m是负数个数，m > k，那就把前k小的负数转化成正数；m == k，把所有负数全部转化为正数；m < k，先把所有负数都取反，剩余的次数k - m，如果它是偶数，那么就无影响，可以只对一个数字取反偶次数，那么这个数不变，如果是k - m是奇数，那就得把现有正数（因为已经取反了所有负数）中最小的那个数取反奇次数，就可以拿到最大数组和了。
int largestSumAfterKNegations(vector<int>& nums, int k) {
int m = 0, minElem = INT_MAX, n = nums.size();
for(auto x : nums)
{
if(x < 0) m++;
minElem = min(minElem, abs(x));
}
int ret = 0;
if(m > k)
{
sort(nums.begin(), nums.end());
for(int i = 0; i < k; ++i)
{
ret += -nums[i];
}
for(int i = k; i < n; ++i)
{
ret += nums[i];
}
}
else
{
for(auto x: nums) ret += abs(x);
if((k - m) % 2)
{
ret -= minElem * 2;
}
}
return ret;
}
4、按身高排序
我们可以创建一个新数组pair<int, string>这样名字和数字都在一起，对这个数组排序就行。
解法二是利用哈希表存映射关系。对身高数组排序，根据结果在哈希表里找名字即可。
以上两种思路类似，这里走一个不同的思路，虽然要排序，但不是真正的排序，对其中的元素不做手脚，但要能按照给出最终的顺序对应的元素。这里创建一个下标数组，只对下标数组排序，根据下标数组排序后的结果，找到原数组的信息。
vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
int n = names.size();
vector<int> index(n);
for(int i = 0; i < n; ++i)
{
index[i] = i;
}
sort(index.begin(), index.end(), [&](int i, int j)
{
return heights[i] > heights[j];
});
vector<string> ret;
for(auto i : index)
{
ret.push_back(names[i]);
}
return ret;
}
5、优势洗牌
这道题的意思是给了两个数组，返回一个最终的数组，比如例1，
2 7 11 15
1 10 4 11
第一个位置可以放2，比1，第二个位置可以放11，比10大，第三个可以放15，比4大，但这样第四个位置就放不了，所以这样优势不是最大化，第三个位置放7，第四个位置可以放15，这样优势就最大化了。
这道题可以用田忌赛马的思路，即，如果比不过，就放到另一个数组最大的那个对应的位置，如果能比过，那就直接比。在这之前，先排序一遍。
按照这个思路，看例2，我们会得到[12, 24, 32, 8]这个答案，和示例不一样，这是因为，我们是按照排序后的数组去做的结果，这个结果还需要对应上原先数组，所以还得改一下顺序，才是最终结果。
为此，要和上一个题一样，用下标数组来做。
vector<int> advantageCount(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size();
//排序
sort(nums1.begin(), nums1.end());
vector<int> index2(n);
for(int i = 0; i < n; ++i) index2[i] = i;
sort(index2.begin(), index2.end(), [&](int i, int j)
{
return nums2[i] < nums2[j];
});
//田忌赛马
vector<int> ret(n);
int left = 0, right = n - 1;
for(auto x : nums1)
{
if(x > nums2[index2[left]]) ret[index2[left++]] = x;
else ret[index2[right--]] = x;
}
return ret;
}
6、最长回文串
按照题目，回文串的长度是偶数或者奇数，从中间切一刀，两边都一样，中间切开的那个位置没有元素或者只有一个元素。所以我们可以这样想，一个字符串中可能出现的所有字符，记录下每个字符出现的次数，如果次数为偶数，就可以两边都放，那就是直接加上这个数字；如果是奇数，就-1，然后两边都放。所有次数可能不止有一个奇数，但奇数的个数不用担心，按照上面的做法，偶数就直接加，奇数就-1加上，算出来的长度如果等于原字符串长度，说明都是偶数，那就不用继续处理，直接返回；如果小于原字符串，说明出现了奇数，那么就+1，再返回。
int longestPalindrome(string s) {
int hash[127] = {0};
for(char ch : s) hash[ch]++;
int ret = 0;
for(int x : hash)
{
ret += x / 2 * 2;//这样奇数偶数都能计算
}
return ret < s.size() ? ret + 1 : ret;
}
7、增减字符串匹配
题目的意思就是给定一个字符串，比如IDI，那就增减增，从0123四个数字中选择来组成数组。
这道题体现的贪心是，为了符合字符串展现的规则，遇到I时，应当选择当前最小的那个数，遇到D时，选择当前最大的那个数。
vector<int> diStringMatch(string s) {
int left = 0, right = s.size();
vector<int> res;
for(auto ch : s)
{
if(ch == 'I') res.push_back(left++);
else res.push_back(right--);
}
res.push_back(left);
return res;
}
结束。
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
