1.题目描述
一群孩子站成一排，每一个孩子有自己的评分。现在需要给这些孩子发糖果，规则是如果一个孩子的评分比自己身旁的一个孩子要高，那么这个孩子就必须得到比身旁孩子更多的糖果；所有孩子至少要有一个糖果。求解最少需要多少个糖果。
输入输出样例
输入是一个数组，表示孩子的评分。输出是最少糖果的数量。
Input: [1,0,2]
Output: 5
在这个样例中，最少的糖果分法是 [2,1,2]。
思路：
贪心算法只考虑最近邻，因此需要从左往右遍历，大的+1，再从右往左遍历，大的+1
#include <stdio.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
int Candy(std::vector<int>& ratings)
{
int size = ratings.size();
if(ratings.size()<2) return ratings.size();
vector<int> num(size,1);
for(int i=1;i<size;++i)
{
if(ratings[i-1]<ratings[i]) num[i]=num[i-1]+1;
}
for(int i=size-1;i>0;--i)
{
if(ratings[i]<ratings[i-1]) num[i-1]=max(num[i-1],num[i]+1);
}
return accumulate(num.begin(),num.end(),0);
}
int main(void) {
int a[]={1,0,2};
vector<int> ratings(a,a+3);
int outt=0;
outt = Candy(ratings);
std::cout << outt << std::endl;;
return 0;
}
2.题目描述
给定多个区间，计算让这些区间互不重叠所需要移除区间的最少个数。起止相连不算重叠。
输入输出样例
输入是一个数组，数组由多个长度固定为 2 的数组组成，表示区间的开始和结尾。输出一个
整数，表示需要移除的区间数量。
Input: [[1,2], [2,4], [1,3]]
Output: 1
在这个样例中，我们可以移除区间 [1,3]，使得剩余的区间 [[1,2], [2,4]] 互不重叠。
思路：
贪心策略，关注区间的结尾，结尾越小，代表所占空间较小，留给其余的区间空间较大，保留的越多，因此对区间结尾进行排序，优先保留结尾小、无重叠的区间，本题中排序后： [[1,2], [1,3], [2,4]]，[1,2], [1,3]重叠，跳过，[1,2], [2,4]无重叠，保留。
#include <stdio.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
int eraseoverlapIntervals(vector<vector<int>>& intervalss)
{
int prev = intervalss[0][1];
if (intervalss.empty()) return 0;
sort(intervalss.begin(),intervalss.end(),[](vector<int>&a,vector<int>& b)
{
return a[1]<b[1];
});
int total=0;
int size = intervalss.size();
for(int i=1;i<size;++i)
{
if(intervalss[i][0]<prev) ++total;
else prev = intervalss[i][1];
}
return total;
}
int main(void) {
int a[3][2] = {{1,2},{1,3},{2,4}};
vector<vector<int>> interval(3,vector<int >(2));
for(int i=0;i<3;i++)
{
for(int j=0;j<2;j++)
{
interval[i][j]=a[i][j];
// cout<<interval[i][j]<<endl;
}
}
int outt=0;
outt = eraseoverlapIntervals(interval);
std::cout << outt << std::endl;
return 0;
}
3.题目描述：
flowered数组中1表示已经种下了花朵。花朵之间至少需要一个单位的间隔，求解能否种下n多花。
Input: flowerbed = [1,0,0,0,1], n = 1
Output: True
思路：
一个坑两边都没花，就能种
#include <stdio.h>
#include <vector>
using namespace std;
bool Flower(std::vector<int>& flowerbed,int n)
{
int size=flowerbed.size();
int total=0;
for(int i=1;i<size-1;i++)
{
// flowerbed = [0]+flowerbed+[0];
if(flowerbed[i]==0)
{
if(flowerbed[i-1]==0 & flowerbed[i+1]==0) ++total;
}
}
if(total>=n) return 1;
return 0;
}
int main(void) {
int a[] = {1,0,0,0,0,1};
int n=3;
vector<int> flowerbed(a,a+6);
int out;
out = Flower(flowerbed,n);
if(out==1)
printf("yes");
else printf("no");
return 0;
}
4.问题描述
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。
一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。
给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。
示例 1：
输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球
示例 2：
输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
示例 3：
输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2
示例 4：
输入：points = [[1,2]]
输出：1
示例 5：
输入：points = [[2,3],[2,3]]
输出：1
思路：
区间问题，按照区间尾部大小进行排序，两个区间无交集就+1
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<stdlib.h>
using namespace std;
int Arrow(vector<vector<int>>& balloon)
{
int n = balloon.size();
int total = 1;
sort(balloon.begin(), balloon.end(), [](vector<int>& a, vector<int>& b)
{
return a[0] < b[0];
});
//printf(balloon);
int first_end = balloon[0][1];
for (int i = 1; i < n; i++)
{
if (balloon[i][0] > first_end)
{
total += 1;
first_end = balloon[i][1];
}
}
return total;
}
int main()
{
system("pause");
int a[4][2] = {{1,2},{2,3},{3,4},{4,5}};
vector<vector<int>> balloon(4, vector<int >(2));
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 2; j++)
{
balloon[i][j] = a[i][j];
}
}
int outt = 0;
outt = Arrow(balloon);
printf("out:%d",outt);
return 0;
}
5.问题描述
给定一个字符串，拆分这个字符串，使得任何子串的任意一个字符不得在除了在自己这个子串的其他子串中出现。
思路：
遍历一遍字符串，记录每个元素最后一次出现的位置，第一个元素最后出现位置tag假设是n。0-n的元素最后出现位置若大于n，则此元素最后出现位置为tag；若都在0-n之间，则拆分，此时tag为第n+1个字符的最后位置。
python：利用字典记录元素的最后位置
def chaifenString(S):
# 建立一个字典存放元素最后位置
index = {}
for i in range(len(S)):
s = S[i]
index[s] = i
result = []
length=-1
tag = index[S[0]]
for i in range(len(S)):
if index[S[i]]>tag:
tag = index[S[i]]
elif i==tag:
result.append(i-length)
length = i
if i != len(S)-1:
tag = index[S[i+1]]
print(index)
return result
s = 'ababcbacadefegdehijhklij'
out = chaifenString(s)
print(out)
C++ 利用字母的ASCII记录最后位置
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<stdlib.h>
using namespace std;
vector<int> partition(string s)
{
//使用ASCII码作为数组下标记录字母最后位置
int array[26] = { 0 };
int n = s.size();
int length = -1;
vector<int> result;
for (int i = 0; i < n; i++)
{
array[s[i] - 'a'] = i;
}
/*for (int i = 0; i < 26; i++)
{
printf("%d\n", array[i]);
}*/
int tag = array[s[0]-'a'];
for (int i = 1; i < n; i++)
{
if (array[s[i] - 'a'] > tag)
{
tag = array[s[i] - 'a'];
}
if (i == tag)
{
result.push_back(i - length);
length = i;
if (i != n-1)
{
tag = array[s[i + 1]-'a'];
}
}
//printf("%d\n", tag);
}
int h = result.size();
//for (int i = 0; i < h; i++)
//{
// //printf("%d\n", result[i]);
//
//}
return result;
}
int main()
{
string s = "ababcbacadefegdehijhklij";
vector<int> outt = partition(s);
int length = outt.size();
for (int i = 0; i < length; i++)
{
printf("%d", outt[i],"\n");
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
