- 区域和检索-数组可修改
很简单的一道题
class NumArray {
vector<int> m_sum;
vector<int> m_nums;
public:
NumArray(vector<int>& nums) {
m_nums = nums;
m_sum = nums;
if (nums.size() == 0)
return;
for (int i = 1; i < nums.size(); i++)
{
m_sum[i] += m_sum[i - 1];
}
}
void update(int i, int val) {
int dif = val - m_nums[i];
m_nums[i] = val;
for (int j = i; j < m_sum.size(); j++)
{
m_sum[j] += dif;
}
}
int sumRange(int i, int j) {
if (i == 0)
return m_sum[j];
else
return m_sum[j] - m_sum[i - 1];
}
};
/**
* Your NumArray object will be instantiated and called as such:
* NumArray* obj = new NumArray(nums);
* obj->update(i,val);
* int param_2 = obj->sumRange(i,j);
*/
- 最佳买卖股票时机含冷冻期
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)
经典动态规划运用。首先写出第I天的状态和i-1天的关系，然后再进行降维优化即可
class Solution {
public:
int maxProfit(vector<int>& prices) {
if (prices.empty()) {
return 0;
}
int n = prices.size();
int f0 = -prices[0];
int f1 = 0;
int f2 = 0;
for (int i = 1; i < n; ++i) {
int newf0 = max(f0, f2 - prices[i]);
int newf1 = f0 + prices[i];
int newf2 = max(f1, f2);
f0 = newf0;
f1 = newf1;
f2 = newf2;
}
return max(f1, f2);
}
};
- 最小高度树
对于一个具有树特征的无向图，我们可选择任何一个节点作为根。图因此可以成为树，在所有可能的树中，具有最小高度的树被称为最小高度树。给出这样的一个图，写出一个函数找到所有的最小高度树并返回他们的根节点。
本题主要考察点为，最小高度树如果用图的叶子为根则其他点到该叶子至少是1 + 叶子父亲节点。由此可知叶子节点不是我们的选项。从所有的叶子节点向中间靠拢，逐层递归剥离直至相遇，则为距离最短的交点。根据深度的奇偶数可能是1个结果或者2个结果
class Solution {
public:
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
if (n == 1)
return {
0 };
else if (n == 2)
return{
0,1 };
vector<int> indegree(n,0);//入度数组，并初始化
vector<int> v;
vector<vector<int>> graph(n,v);//图形表示，并初始化
for (int i = 0; i < edges.size(); i++)//构造图与入度数组：无向图，两个点都要处理
{
graph[edges[i][0]].push_back(edges[i][1]);
graph[edges[i][1]].push_back(edges[i][0]);
indegree[edges[i][0]]++;
indegree[edges[i][1]]++;
}
queue<int> myqueue;//装载入度为1的queue
for (int i = 0; i < n; i++)
{
if (indegree[i] == 1)
myqueue.push(i);
}
int cnt = myqueue.size();//！！令cnt等于myqueue.size()，一次性将入度为1的点全部删去。
while (n>2)
{
n -= cnt;//一次性将入度为一的点全部删去！！不能一个一个删！
while (cnt--)
{
int temp = myqueue.front();
myqueue.pop();
indegree[temp] = 0;
//更新temp的邻接点：若temp临接点的入度为1，则将其放入queue中。
for (int i = 0; i < graph[temp].size(); i++)
{
if (indegree[graph[temp][i]] != 0)
{
indegree[graph[temp][i]]--;
if (indegree[graph[temp][i]] == 1)//放在这里做！只判断邻接点。
myqueue.push(graph[temp][i]);
}
}
}
cnt = myqueue.size();
}
vector<int> result;
while (!myqueue.empty())
{
result.push_back(myqueue.front());
myqueue.pop();
}
return result;
}
};
- 戳气球
有 n 个气球，编号为0 到 n-1，每个气球上都标有一个数字，这些数字存在数组 nums 中。
现在要求你戳破所有的气球。如果你戳破气球 i ，就可以获得 nums[left] * nums[i] * nums[right] 个硬币。 这里的 left 和 right 代表和 i 相邻的两个气球的序号。注意当你戳破了气球 i 后，气球 left 和气球 right 就变成了相邻的气球。
求所能获得硬币的最大数量。
经典动态规划题，可以采用自顶向下或者自底向上的思想解。核心思想：如果是戳气球那就先戳每次内部最小气球，最后戳边缘。如果是加气球就从大的开始加
class Solution {
public:
int maxCoins(vector<int>& nums) {
int n = nums.size();
vector<vector<int>> rec(n + 2, vector<int>(n + 2));
vector<int> val(n + 2);
val[0] = val[n + 1] = 1;
for (int i = 1; i <= n; i++) {
val[i] = nums[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
for (int j = i + 2; j <= n + 1; j++) {
for (int k = i + 1; k < j; k++) {
int sum = val[i] * val[k] * val[j];
sum += rec[i][k] + rec[k][j];
rec[i][j] = max(rec[i][j], sum);
}
}
}
return rec[0][n + 1];
}
};
- 超级丑数
编写一段程序来查找第 n 个超级丑数。
超级丑数是指其所有质因数都是长度为 k 的质数列表 primes 中的正整数。
1）队列的元素来源：堆顶元素*质数列表，将新生成的元素放入队列，弹出的第n个元素就是我们求的超级丑数。但是，弹出的元素不一定是第n个最小的质数，因此我们弹出前需要排序。
2）第n个质数，则要求队列是有序的，且是从小到大排列的，因此我们取小顶堆
class Solution {
public:
int nthSuperUglyNumber(int n, vector<int> &primes)
{
priority_queue<long long, vector<long long>, greater<long long>> buff;
unordered_set<long long> primeset;
buff.push(1);
primeset.insert(1);
long long i = 1;
int count = 0;
while (count < n) {
count++;
i = buff.top();
buff.pop();
for (long long prime : primes) {
long long next = i * prime;
if (next<=INT32_MAX && !primeset.count(next)) {
buff.push(next);
primeset.insert(next);
}
}
}
return i;
}
};
- 计算右侧小于当前元素的个数
给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。
本题采用树状数组求解，是一道经典题。可以理解为每个桶存储一个数值的个数，然后累加即可
class Solution {
private:
int lowbit(int x){
return x & (-x);
}
void update(int i, vector<int>&C){
while (i < C.size()) {
C[i]++;
i += lowbit(i);
}
}
void query(int i, int j, vector<int>&C, vector<int>&counts){
while (i >= 1) {
counts[j] += C[i];
i -= lowbit(i);
}
}
public:
vector<int> countSmaller(vector<int>& nums) {
vector<int>counts(nums.size(), 0);
if (nums.size() < 1) {
return counts;
}
vector<int>N(nums);
// Sort and unique
sort(N.begin(), N.end());
int slow = 1;
int fast = 1;
while(fast< N.size()) {
if (N[fast] != N[slow - 1]) {
N[slow] = N[fast];
slow++;
fast++;
}else{
fast++;
}
}
N.resize(slow);
// key: number, value: i
map<int, int>m;
for (int j = 1; j < 1 + N.size(); ++j) {
m[N[j - 1]] = j;
}
// traverse
vector<int>C(N.size() + 1, 0); // C[i] is necessary, but A[i] not
int i;
for (int j = nums.size() - 1; j >= 0; --j) {
i = m[nums[j]];
update(i, C);
if (i != 1) {
query(i - 1, j, C, counts);
}else{
counts[j] = 0;
}
}
return counts;
}
};
- 去除重复字母
给你一个仅包含小写字母的字符串，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。
要想使结果的字典序最小，就应该尽可能地将小的元素留在前面。如果stk栈顶的元素大于当前遍历到的元素，根据上述原则，则应该在条件允许的情况下回避这一情况，根据题目要求（去重）,只有在后续还有这个栈顶元素的情况下才能将这个栈顶元素去掉（减少一个逆序）。如果后续没有这个栈顶元素，则只能将它保留在这儿，即使它大于它的下一个元素。
class Solution {
public:
string removeDuplicateLetters(string s) {
string stk;
size_t i = 0;
for(size_t i = 0;i < s.size(); ++i)
{
if(stk.find(s[i]) != string::npos) continue;
while(!stk.empty()&& stk.back() > s[i]&&
s.find(stk.back(), i) != string::npos)
stk.pop_back();
stk.push_back(s[i]);
}
return stk;
}
};