贪心算法
1. 最大连续子序列
int maxSubArray(vector<int> &nums) {
int s = 0, ans = -1000000;
for(int i = 0; i < nums.size(); i ++) {
if(s > 0) s += nums[i];
else s = nums[i];
ans = max(s, ans);
}
return ans;
}
2. 删除数字
string removeKdigits(string &num, int k) {
int i;
while(k --) {
for(i = 0; i < num.size() - 1 && num[i] <= num[i+1]; i ++);
num.erase(num.begin() + i);
}
// remove 0
auto it = num.begin();
while(it != num.end() && *it == '0') {
num.erase(it);
it = num.begin();
}
if(num.size() == 0) num = "0";
return num;
}
3. 无重叠区间
classs Interval {
int start, end;
Interval(int start, int end) {
this->start = start;
this->end = end;
}
}
bool cmp(Interval a, Interval b) {
if(a.end < b.end) return 1;
else return 0;
}
int eraseOverlapIntervals(vector<Interval> &intervals) {
sort(intervals.begin(), intervals.end(), cmp);
int cnt = 0;
Interval tmp = intervals[0];
for(int i = 1; i < intervals.size(); i ++) {
if(tmp.end <= intervals[i].start) tmp = intervals[i];
else {
cnt ++;
}
}
return cnt;
}
4. 合并数字
int mergeNumber(vector<int> &numbers) {
priority_queue<int, vector<int>, greater<int>> pq;
for(int i = 0; i < numbers.size(); i ++) {
pq.push(numbers[i]);
}
int cost = 0;
while(pq.size() > 1) {
int a = pq.top();
pq.pop();
int b = pq.top();
pq.pop();
cost += (a + b);
pq.push(a + b);
}
return cost;
}
5. 最小支撑树
struct Edge {
int src, dest, weight;
};
struct Graph {
int V, E;
struct Edge* edge;
};
struct Graph* createGraph(int V, int E) {
struct Graph* graph = new Graph;
graph->V = V;
graph->E = E;
graph->edge = new Edge[E];
return graph;
}
struct subset {
int parent;
int rank;
};
int find(struct subset subsets[], int i) {
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
void Union(struct subset subsets[], int x, int y) {
int xroot = find(subsets, x);
int yroot = find(subsets, y);
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
else {
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
int myComp(const void* a, const void* b) {
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}
void KruskalMST(struct Graph* graph) {
int V = graph->V;
struct Edge result[V];
int e = 0;
int i = 0;
qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);
struct subset *subsets =
(struct subset*) malloc( V * sizeof(struct subset) );
for (int v = 0; v < V; ++v) {
subsets[v].parent = v;
subsets[v].rank = 0;
}
while (e < V - 1) {
struct Edge next_edge = graph->edge[i++];
int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);
if (x != y) {
result[e++] = next_edge;
Union(subsets, x, y);
}
}
return;
}
6. 补齐数组
int minPatches(vector<int> &nums, int n) {
sort(nums.begin(), nums.end());
long long r = 1;
int i = 0;
int cnt = 0;
while(r <= n) {
if(i < nums.size() && nums[i] <= r) r += nums[i++];
else {
cnt ++;
r *= 2;
}
}
return cnt;
}
7. 买卖股票的最佳时机
int maxProfit(vector<int> &prices) {
int minp = prices[0];
int ans = 0;
for(int i = 1; i < prices.size(); i ++) {
ans = max(ans, prices[i] - minp);
minp = min(minp, prices[i]);
}
return ans;
}
8. 买卖股票的最佳时机II
int maxProfit(vector<int> &prices) {
int sum = 0;
for(int i=1;i<prices.size();i++){
if(prices[i] > prices[i-1]){
sum += prices[i] - prices[i-1];
}
}
return sum;
}
9. 买卖股票的最佳时机含手续费
int maxProfit(vector<int> &prices, int fee) {
int sell = 0, buy = -prices[0];
for (int price : prices) {
int sellOld = sell;
sell = max(sell, buy + price - fee);
buy = max(buy, sellOld - price);
}
return sell;
}
10. 最后的猫
int gcd(int a, int b) {
if(a == 0) return b;
return gcd(b % a, a);
}
int solve(vector<int> &h) {
if(h.size() == 1) return h[0];
int ans = gcd(h[0], h[1]);
for(int i = 2; i < h.size(); i ++) {
ans = gcd(ans, h[i]);
}
return ans;
}