一、
P为给定的二维平面整数点集。定义 P 中某点x，如果x满足 P 中任意点都不在 x 的右上方区域内（横纵坐标都大于x），则称其为“最大的”。求出所有“最大的”点的集合。（所有点的横坐标和纵坐标都不重复, 坐标轴范围在[0, 1e9) 内）
如下图：实心点为满足条件的点的集合。请实现代码找到集合 P 中的所有 ”最大“ 点的集合并输出。
本质：找边界点。
1、sort()排序
#include<iostream>
#include<algorithm> //载入库
using namespace std;
int main()
{
int a[10]={9,6,3,8,5,2,7,4,1,0};
cout<<"排序前：";
for(int i=0;i<10;i++)
cout<<a[i]<<' ';
cout<<endl;
sort(a,a+10); //调用函数
cout<<"排序后：";
for(int i=0;i<10;i++)
cout<<a[i]<<' ';
return 0;
}
这是默认的从小到大的排序规则，如果特殊的情况需要自己定义函数来定义比较规则。
2、定义比较函数
比较函数是一个自己定义的函数，返回值是bool型，它规定了什么样的关系才是“小于”。
#include<iostream>
#include<algorithm> //载入库
using namespace std;
bool cmp(int a,int b)
{
return a>b;
}
int main()
{
int a[10]={9,6,3,8,5,2,7,4,1,0};
cout<<"排序前：";
for(int i=0;i<10;i++)
cout<<a[i]<<' ';
cout<<endl;
sort(a,a+10,cmp); //调用函数
cout<<"排序后：";
for(int i=0;i<10;i++)
cout<<a[i]<<' ';
return 0;
}
从大到小排序。
3、对于点来说的排序
#include<iostream>
#include<algorithm> //载入库
#include<vector>
using namespace std;
struct point{ //定义结构体
int x,y;
};
bool cmp(point a,point b) //排序规则
{
if(a.y<b.y) //y小的排在前面，（y从小到大）
{
return 1;
}
else
{
if(a.y==b.y){ //y相等时，
if(a.x>b.x){ //x大的排在前面，（x从大到小）
return 1;
}
}
else{
return 0;
}
}
}
int main()
{
vector<point>vec;
point p[4];
p[0].x=1,p[0].y=6;
p[1].x=5,p[1].y=3;
p[2].x=4,p[2].y=2;
p[3].x=7,p[3].y=6;
cout<<"排序前："<<endl;
for(int i=0;i<4;i++){
cout<<p[i].x<<" "<<p[i].y<<endl;
vec.push_back(p[i]);
}
sort(vec.begin(),vec.end(),cmp); // 注意调用方式
cout<<"排序后："<<endl;
for(int i=0;i<4;i++){
cout<<vec[i].x<<" "<<vec[i].y<<endl;
}
return 0;
} //5 1 2 5 3 4 6 7 5 9 0
先按y从小到大排序，然后y相等时，x从大到小排。
4、排序规则代码优化
#include<iostream>
#include<algorithm> //载入库
#include<vector>
using namespace std;
struct point{ //定义结构体
int x,y;
};
bool cmp(point a,point b) //排序规则
{
return a.y==b.y?a.x>b.x:a.y<b.y; //a.y等于b.y的话，取冒号前面的内容，x大的排在前面；如果a.y不等于b.y的话，取冒号后边的内容，y小的排在前面。
}
int main()
{
vector<point>vec;
point p[4];
p[0].x=1,p[0].y=6;
p[1].x=5,p[1].y=3;
p[2].x=4,p[2].y=2;
p[3].x=7,p[3].y=6;
cout<<"排序前："<<endl;
for(int i=0;i<4;i++){
cout<<p[i].x<<" "<<p[i].y<<endl;
vec.push_back(p[i]);
}
sort(vec.begin(),vec.end(),cmp); // 注意调用方式
cout<<"排序后："<<endl;
for(int i=0;i<4;i++){
cout<<vec[i].x<<" "<<vec[i].y<<endl;
}
return 0;
} //5 1 2 5 3 4 6 7 5 9 0
5、该题方法
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct point{ //定义结构体
int x,y;
};
bool cmp(point a,point b){ //自定义排序方法
return a.y==b.y?a.x>b.x:a.y<b.y; //y升序，x降序
}
int main(){
int count; //计数
cout<<"输入点的个数和点：" ;
cin>>count;
vector<point>p; //容器用来装 平面上的 点
for(int i=0;i<count;i++){
point temp;
cin>>temp.x>>temp.y;
p.push_back(temp); //插入容器中，点
}
vector<point>res; //定义新的容器
sort(p.begin(),p.end(),cmp); //排序；排序的意义在于减少比较时的次数
res.push_back(p[count-1]); //左上角的那个点，一定符合条件
int maxx=p[count-1].x;
for(int i=count-2;i>=0;i--){ //逆序往回排，y始终在减小，符合条件的是，x变大的那个点。
if(p[i].x>maxx){
res.push_back(p[i]);
maxx=p[i].x;
}
}
cout<<"符合条件的点："<<endl;
for(int i=0;i<res.size();i++){
printf("%d %d
", res[i].x, res[i].y);
}
return 0;
} // 5 1 2 5 3 4 6 7 5 9 0
解析：如下图。排序后，点按从1到5排好了序，逆向取点时，y始终在减小，只需下一个点比上一个点的x坐标大即可。这样就只需比较相邻的点即可，而不用整个范围内的比较点。
5、Python画图
import matplotlib.pyplot as plt plt.xlim(xmax=10,xmin=-1) plt.ylim(ymax=10,ymin=-1) plt.plot([1,5,4,7,9],[2,3,6,5,0],'ro') plt.show()
二、
给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个：
区间中的最小数 * 区间所有数的和最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列 [6 2 1]则根据上述公式, 可得到所有可以选定各个区间的计算值:
[6] = 6 * 6 = 36;
[2] = 2 * 2 = 4;
[1] = 1 * 1 = 1;
[6,2] = 2 * 8 = 16;
[2,1] = 1 * 3 = 3;
[6, 2, 1] = 1 * 9 = 9;
从上述计算可见选定区间 [6] ，计算值为 36， 则程序输出为 36。
区间内的所有数字都在[0, 100]的范围内;
1、
#include <iostream>
#include<time.h>
using namespace std;
int main()
{
int n;
while(cin>>n)
{
int x[n];
for (int i=0; i<n; i++)
cin>>x[i]; //输入序列
int max=0;
for (int i=0; i<n; i++)
{
int j=i;
int k=i-1; //？？
int sum1=0;
while(x[i]<=x[j] && j<n) //向右找比自己大的数
{
sum1+=x[j]; //求和
j++;
}
while(x[i]<=x[k] && k>=0) //向左找比自己大的数
{
sum1+=x[k]; //累计求和
k--;
}
int temp=sum1;
if (x[i]*temp>max) //存储最大值
max=x[i]*temp;
}
cout << max << endl;
}
return 0;
}
注意理解题意：不会隔数取序列的。如上面不会出现[6,1]这种情况。
先假设第i个值是最小的，然后向左向右找比它大的数，求和，找出最大值。
三、
1、java
import java.util.*;
public class Main{
private static Scanner sc = new Scanner(System.in);
static class IdeaTask {
int pmSeq;
int raiseTime;
int prio;
int timeCost;
int endTime;
public IdeaTask(int pmSeq, int raiseTime, int prio, int timeCost) {
this.pmSeq = pmSeq;
this.raiseTime = raiseTime;
this.prio = prio;
this.timeCost = timeCost;
}
}
static class PM {
PriorityQueue<IdeaTask> pq = new PriorityQueue<>(Comparator.comparingInt(x -> x.raiseTime));
//给定程序员开始工作的时间，找到这个PM最想完成的任务
IdeaTask mostDesiredTask(int startTime) {
PriorityQueue<IdeaTask> pq2 = new PriorityQueue<>((x, y) -> {
if (x.prio != y.prio) return y.prio - x.prio;
else {
if (x.timeCost != y.timeCost) return x.timeCost - y.timeCost;
else return x.raiseTime - y.raiseTime;
}
});
while (pq.peek() != null && pq.peek().raiseTime <= startTime) {
pq2.offer(pq.poll());
}
IdeaTask mostDesiredTask = (pq2.isEmpty()) ? pq.poll() : pq2.poll();
while (!pq2.isEmpty()) {
pq.offer(pq2.poll());
}
return mostDesiredTask;
}
}
static class Programmer {
int nextWorkTime;//下次可以工作的时间
public Programmer(int nextWorkTime) {
this.nextWorkTime = nextWorkTime;
}
}
//从多个PM 最想要完成的Idea中，选其中的一个PM想要完成的idea
private static IdeaTask selectTask(PM[] pms, int workTime) {
PriorityQueue<IdeaTask> pq = new PriorityQueue<>((x, y) -> {
if (x.raiseTime == y.raiseTime || (x.raiseTime <= workTime && y.raiseTime <= workTime)) {
if (x.timeCost != y.timeCost) return x.timeCost - y.timeCost;
else return x.pmSeq - y.pmSeq;
}
if (x.raiseTime > workTime && y.raiseTime > workTime) return x.raiseTime - y.raiseTime;
if (x.raiseTime > workTime) return 1;
if (y.raiseTime > workTime) return -1;
return 0;
});
for (int i = 1; i < pms.length; i++) {
PM pm = pms[i];
IdeaTask desiredTask = pm.mostDesiredTask(workTime);
if (desiredTask != null)
pq.offer(desiredTask);
}
IdeaTask task = pq.poll();
while (!pq.isEmpty()) {
IdeaTask tmp = pq.poll();
pms[tmp.pmSeq].pq.offer(tmp);
}
return task;
}
private static List<IdeaTask> getTasks(int taskNum) {
List<IdeaTask> tasks = new LinkedList<>();
while (taskNum-- > 0) {
tasks.add(new IdeaTask(sc.nextInt(), sc.nextInt(), sc.nextInt(), sc.nextInt()));
}
return tasks;
}
private static PM[] initPM(int n, List<IdeaTask> tasks) {
PM[] pms = new PM[n + 1];
for (int i = 1; i <= n; i++) pms[i] = new PM();
for (IdeaTask task : tasks) {
pms[task.pmSeq].pq.offer(task);
}
return pms;
}
public static void main(String[] args) {
int n = sc.nextInt(), m = sc.nextInt(), p = sc.nextInt();
List<IdeaTask> tasks = getTasks(p);
PM[] pms = initPM(n, tasks);
PriorityQueue<Programmer> losersPq = new PriorityQueue<>(Comparator.comparingInt(x -> x.nextWorkTime));
for (int i = 0; i < m; i++) losersPq.offer(new Programmer(0));
while (true) {
Programmer loser = losersPq.poll();
IdeaTask task = selectTask(pms, loser.nextWorkTime);
if (task == null) break;
task.endTime = Integer.max(task.raiseTime, loser.nextWorkTime) + task.timeCost;
loser.nextWorkTime = task.endTime;
losersPq.offer(loser);
}
for (IdeaTask task : tasks) {
System.out.println(task.endTime);
}
}
}
2、C++
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id;
int pm;
int time;
int pri;
int dur;
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //?? 非重复？
int proid = 1;
struct Programer
{
Programer()
{
t = 0;
this->id = proid++;
}
int t;//当前的时间
int id;
int doTask()
{
vector<Task>::iterator findT;
int index = -1;
for (size_t i = 0; i < pmtasks.size(); i++)
{
auto& tasks = pmtasks.at(i);
if (tasks.size() == 0) continue;
auto it = tasks.begin();
while (it!= tasks.end() && it->time > t)
it++;
if (it == tasks.end()) continue;
if (index == -1)
{
findT = it;
index = i;
}
else
{
if (it->dur < findT->dur)
{
findT = it;
index = i;
}
}
}
if (index != -1)
{
t += findT->dur;
result[findT->id] = t;
pmtasks.at(index).erase(findT);
return 1;
}
else
t++;
return 0;
}
};
int main()
{
int n, m, p;
cin >> n >> m >> p;
pmtasks.resize(n);
for (size_t i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur;
task.id = i;
pmtasks.at(task.pm - 1).push_back(task);
}
for (size_t i = 0; i < pmtasks.size(); i++)
{
auto& tasks = pmtasks.at(i);
if (tasks.size() == 0) continue;
sort(tasks.begin(), tasks.end(), [](Task & t1, Task & t2)
{
if (t1.pri == t2.pri)
{
if (t1.dur == t2.dur)
{
return t1.time < t2.time;
}
else return t1.dur < t2.dur;
}
else return t1.pri > t2.pri;
});
}
vector<Programer> pros(m);
while (p > 0)
{
sort(pros.begin(), pros.end(), [&](Programer & t1, Programer & t2)
{
return t1.t < t2.t;
});
p -= pros.begin()->doTask();
}
for (auto &it : result)
cout << it.second << endl;
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
3、at
粗略理解at 和[ ] 等价
// vector::at
#include <iostream>
#include <vector>
int main ()
{
std::vector<int> myvector (10); // 10 zero-initialized ints
// assign some values:
for (unsigned i=0; i<myvector.size(); i++)
myvector.at(i)=i;
std::cout << "myvector contains:";
for (unsigned i=0; i<myvector.size(); i++)
std::cout << ' ' << myvector.at(i);
std::cout << '
';
return 0;
}
4、resize()
重新给空间的函数，多的话就补。少的话就删。
// resizing vector
#include <iostream>
#include <vector>
int main ()
{
std::vector<int> myvector;
// set some initial content:
for (int i=1;i<10;i++)
myvector.push_back(i);
for (int i=0;i<myvector.size();i++)
std::cout << ' ' << myvector[i];
std::cout << '
';
myvector.resize(5);
for (int i=0;i<myvector.size();i++)
std::cout << ' ' << myvector[i];
std::cout << '
';
myvector.resize(8,100);
for (int i=0;i<myvector.size();i++)
std::cout << ' ' << myvector[i];
std::cout << '
';
myvector.resize(12);
for (int i=0;i<myvector.size();i++)
std::cout << ' ' << myvector[i];
std::cout << '
';
return 0;
}
5、-> 理解为指向
->是指针的指向运算符，通常与结构体一起使用。
5.1
下标法
#include<iostream>
using namespace std;
struct book {
char name[30];
char author[20];
}a[2] = { {"Nature","Lina" },{ "Animals","Nick" } };
int main() {
int i;
for (i = 0; i < 2; i++) {
printf("book name: %s author: %s
", a[i].name, a[i].author);
};
return 0;
}
5.2
数组指针的移动
#include<iostream>
using namespace std;
struct book {
char name[30];
char author[20];
}a[2] = { {"Nature","Lina" },{ "Animals","Nick" } };
int main() {
struct book *p;
for (p = a; p < a+2; p++) {
printf("book name: %s author: %s
", p->name, p->author);
};
return 0;
}
数组指针的使用。
5.3
数组名和指针名两个都要有。
#include<iostream>
using namespace std;
struct book {
char name[30];
char author[20];
};
int main() {
struct book*p;
struct book a[2] = { { "Nature","Lina" },{ "Animals","Nick" } };
p = &a[0];
printf("book name: %s author: %s
", p->name, p->author);
p++;
printf("book name: %s author: %s
", p->name, p->author);
return 0;
}
6、
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Idea{
public:
Idea(int PM, int start, int pri, int cost)
: mPm(PM-1), mStart(start), mPriority(pri), mCost(cost), mAchieve(0){};
//true 优先级高
bool operator< (const Idea &idea)
{
// 比较优先级
if (mPriority > idea.mPriority)
return true;
else if (mPriority < idea.mPriority)
return false;
if (mCost < idea.mCost)
return true;
else if (mCost > idea.mCost)
return false;
if (mStart < idea.mStart)
return true;
else if (mStart > idea.mStart)
return false;
if (mPm < idea.mPm)
return true;
else
return false;
};
public:
int mPm;
int mStart;
int mPriority;
int mCost;
int mAchieve;
};
bool sortPIdea(Idea* a, Idea* b){
if (*a < *b)
return true;
else
return false;
}
void printTime(vector<Idea> &vec){
for (int i = 0; i < vec.size(); i++){
cout << vec[i].mAchieve << endl;
}
}
int main()
{
int nums_PM, nums_programmer, nums_idea;
cin >> nums_PM >> nums_programmer >> nums_idea;
vector<Idea> vec_idea;
vector<vector<Idea*> > pm_idea;
vector<int> pro_state;
pm_idea.resize(nums_PM);
pro_state.assign(nums_programmer, 0);
for (int i = 0; i < nums_idea; i++){
int pm, start, pri, cost;
cin >> pm >> start >> pri >> cost;
vec_idea.push_back(Idea(pm, start, pri, cost));
}
for (int i = 0; i < nums_idea; i++){
pm_idea[vec_idea[i].mPm].push_back(&vec_idea[i]);
}
int time = 0;
int sum_idea = nums_idea;
while (1){
time++;
//更新程序员状态
for (int i = 0; i < pro_state.size(); i++){
if (pro_state[i] != 0)
pro_state[i]--;
}
//PM任务排序，[0]是PM最想实现的
for (int i = 0; i < pm_idea.size(); i++){
int j = 0;
for (j = 0; j < pm_idea[i].size(); j++){
if (pm_idea[i][j]->mStart > time){
break;
}
}
std::sort(pm_idea[i].begin(), pm_idea[i].begin() + j, sortPIdea);
}
//程序源接idea
for (int i = 0; i < pro_state.size(); i++){
if (sum_idea == 0)
{
printTime(vec_idea);
return 0 ;
}
if (pro_state[i] == 0){
Idea* p = NULL;
int index = 0;
for (int j = 0; j < pm_idea.size(); j++){
if (pm_idea[j].size() > 0 && pm_idea[j][0]->mStart <= time){
if (p == NULL){
p = pm_idea[j][0];
index = j;
}
else{
if (pm_idea[j][0]->mCost < p->mCost){
p = pm_idea[j][0];
index = j;
}
}
}
}
//暂时没有idea
if (p == NULL){
continue;
}
//接idea
sum_idea--;
pro_state[i] = p->mCost;
p->mAchieve = time + p->mCost;
pm_idea[index].erase(pm_idea[index].begin());
}
}
}
return 0;
}
7、
A是类的名字，类似于int、string等。类型A下叫aa的名字，期中a是公开的，所以aa.a可以访问，而b是不公开的，所以aa.b不可以访问。
#include<iostream>
using namespace std;
class A
{
public:
int a;
private:
int b;
};
int main()
{
A aa;
aa.a=1;
aa.b=2; //会出错，说无法访问私有成员
}
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
struct Programer
{
Programer()
{
t = 0;
this->id = proid++;
}
int t;//当前的时间
int id;
int doTask()
{
vector<Task>::iterator findT;
int index = -1;
for (size_t i = 0; i < pmtasks.size(); i++)
{
auto& tasks = pmtasks.at(i);
if (tasks.size() == 0) continue;
auto it = tasks.begin();
while (it!= tasks.end() && it->time > t)
it++;
if (it == tasks.end()) continue;
if (index == -1)
{
findT = it;
index = i;
}
else
{
if (it->dur < findT->dur)
{
findT = it;
index = i;
}
}
}
if (index != -1)
{
t += findT->dur;
result[findT->id] = t;
pmtasks.at(index).erase(findT);
return 1;
}
else
t++;
return 0;
}
};
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
auto tasks = pmtasks[i]; //自动判断类型，包含多个任务
if (tasks.size() == 0)
continue;
sort(tasks.begin(), tasks.end(), [](Task & t1, Task & t2) //排序
{
if (t1.pri == t2.pri)
{
if (t1.dur == t2.dur)
{
return t1.time < t2.time;
}
else return t1.dur < t2.dur;
}
else return t1.pri > t2.pri;
});
}
vector<Programer> pros(m);
while (p > 0)
{
sort(pros.begin(), pros.end(), [&](Programer & t1, Programer & t2)
{
return t1.t < t2.t;
});
p -= pros.begin()->doTask();
}
for (auto &it : result)
cout << it.second << endl;
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
8、 sort()
8.1
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理的所有任务"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
auto tasks = pmtasks[i]; //自动判断类型，包含多个任务
if (tasks.size() == 0)
continue;
sort(tasks.begin(), tasks.end(), [](Task t1, Task t2) //排序
{
if (t1.pri == t2.pri) //优先级相等时
{
if (t1.dur == t2.dur) //花费时间相等
{
return t1.time < t2.time; //提出时间早的在前
}
else return t1.dur < t2.dur; //花费时间短的在前
}
else return t1.pri > t2.pri; //优先级不相等时，优先级高的在前
});
cout<<"第"<<i+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<tasks.size();j++)
{
cout<<tasks[j].id<<" "<<tasks[j].pm<<" "<<tasks[j].time<<" "<<tasks[j].pri<<" "<<tasks[j].dur<<endl;
}
}
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
以上排序，没有将排序逻辑单独列成函数，还可以将上述程序改为如下形式。
8.2
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
bool myfunction (Task t1, Task t2) //排序逻辑函数
{
if (t1.pri == t2.pri) //优先级相等时
{
if (t1.dur == t2.dur) //花费时间相等
{
return t1.time < t2.time; //提出时间早的在前
}
else return t1.dur < t2.dur; //花费时间短的在前
}
else return t1.pri > t2.pri; //优先级不相等时，优先级高的在前
}
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理的所有任务"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
auto tasks = pmtasks[i]; //自动判断类型，包含多个任务
if (tasks.size() == 0)
continue;
sort(tasks.begin(), tasks.end(), myfunction); //排序
cout<<"第"<<i+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<tasks.size();j++)
{
cout<<tasks[j].id<<" "<<tasks[j].pm<<" "<<tasks[j].time<<" "<<tasks[j].pri<<" "<<tasks[j].dur<<endl;
}
}
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
8.3
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
bool myfunction (Task t1, Task t2) //排序逻辑函数
{
if (t1.pri == t2.pri) //优先级相等时
{
if (t1.dur == t2.dur) //花费时间相等
{
return t1.time < t2.time; //提出时间早的在前
}
else return t1.dur < t2.dur; //花费时间短的在前
}
else return t1.pri > t2.pri; //优先级不相等时，优先级高的在前
}
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理的所有任务"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
auto& tasks = pmtasks[i]; //自动判断类型，包含多个任务
if (tasks.size() == 0)
continue;
sort(tasks.begin(), tasks.end(), myfunction); //排序
/*for(int j=0;j<tasks.size();j++)
{
cout<<tasks[j].id<<" "<<tasks[j].pm<<" "<<tasks[j].time<<" "<<tasks[j].pri<<" "<<tasks[j].dur<<endl;
}*/
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
auto & 的意思是引用，旨在对pmtasks内部按照一定逻辑排序。
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
bool myfunction (Task t1, Task t2) //排序逻辑函数
{
if (t1.pri == t2.pri) //优先级相等时
{
if (t1.dur == t2.dur) //花费时间相等
{
return t1.time < t2.time; //提出时间早的在前
}
else return t1.dur < t2.dur; //花费时间短的在前
}
else return t1.pri > t2.pri; //优先级不相等时，优先级高的在前
}
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理的所有任务"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
auto tasks = pmtasks[i]; //自动判断类型，包含多个任务
if (tasks.size() == 0)
continue;
sort(tasks.begin(), tasks.end(), myfunction); //排序
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
去掉引用后，如下
pmtasks内部值的顺序是不变的。
8.4
可以不用中间变量 tasks,直接在pmtasks上进行修改
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
bool myfunction (Task t1, Task t2) //排序逻辑函数
{
if (t1.pri == t2.pri) //优先级相等时
{
if (t1.dur == t2.dur) //花费时间相等
{
return t1.time < t2.time; //提出时间早的在前
}
else return t1.dur < t2.dur; //花费时间短的在前
}
else return t1.pri > t2.pri; //优先级不相等时，优先级高的在前
}
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理的所有任务"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
if (pmtasks[i].size() == 0)
continue;
sort(pmtasks[i].begin(), pmtasks[i].end(), myfunction); //排序
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
9.map()
#include<bits/stdc++.h>
using namespace std;
int main()
{
map<int,string> A;
A[3]="c";
A[1]="a";
A[4]="d";
A[2]="b";
for(int i=0;i<A.size();i++)
{
cout<<A[i]<<" "; // 注意这里的i是键，而非下标
}
for(map<int,string>::iterator it=A.begin();it!=A.end();it++) //利用迭代器往外输出
{
cout<<it->first<<" "<<it->second<<endl;
}
}
注意map键和下标的区分，所以最好利用迭代器输出。
再有，map 会自动去重，排序。
10、
#include<bits/stdc++.h>
using namespace std;
struct Task //任务
{
int id; //编号
int pm; // pm
int time; //任务提出时间
int pri; //优先级
int dur; //完成花费时间
};
vector< vector<Task> > pmtasks; //任务装进容器
map<int, int> result; //存放结果，任务对应的结束时间
int proid = 1;
struct Programer
{
Programer() //函数重载，给程序员赋初始值
{
t = 0;
this->id = proid++; //程序员id
}
int t;//当前的时间
int id; //程序员id
int doTask() //程序员具体操作
{
vector<Task>::iterator findT;
int index = -1;
for (size_t i = 0; i < pmtasks.size(); i++) //i是产品经理人数，
{
auto& tasks = pmtasks.at(i);
if (tasks.size() == 0)
continue;
auto it = tasks.begin();
while (it!= tasks.end() && it->time > t) //循环查找问题提出时间小于等于 当前程序员时间的任务
it++;
if (it == tasks.end())
continue;
if (index == -1)
{
findT = it; //找到任务的位置
index = i; //找到要做那个 产品经理的任务
}
else
{
if (it->dur < findT->dur) //比较两个产品经理任务耗时，选择小的那个耗时来做
{
findT = it;
index = i;
}
}
}
if (index != -1)
{
t += findT->dur;
result[findT->id] = t; //每个任务完成时间
pmtasks.at(index).erase(findT); //将index产品经理的任务删除
for(int k=0;k<pmtasks.size();k++)
{
cout<<"第"<<k+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<pmtasks[k].size();j++)
cout<<pmtasks[k][j].id<<" "<<pmtasks[k][j].pm<<" "<<pmtasks[k][j].time<<" "<<pmtasks[k][j].pri<<" "<<pmtasks[k][j].dur<<endl; //任务输出
}
return 1; //任务数减1
}
else
t++; //说明该时间没有任务可做，让其自由流逝
return 0; //任务数不变
}
};
int main()
{
int n, m, p;
cin >> n >> m >> p; //pm人数，coder人数，任务数
pmtasks.resize(n); //预留空间
for (int i = 0; i < p; i++)
{
Task task;
cin >> task.pm >> task.time >> task.pri >> task.dur; //输入
task.id = i;
pmtasks[task.pm - 1].push_back(task); //分 pm 插入数值
}
for (int i = 0; i < pmtasks.size(); i++) //pmtasks.size() 是pm的个数，
{
auto &tasks = pmtasks[i]; //自动判断类型，包含多个任务
if (tasks.size() == 0)
continue;
sort(tasks.begin(), tasks.end(), [](Task t1, Task t2) //排序
{
if (t1.pri == t2.pri) //优先级高的在前
{
if (t1.dur == t2.dur) //花费时间短的在前
{
return t1.time < t2.time; //提出时间早的在前
}
else return t1.dur < t2.dur;
}
else return t1.pri > t2.pri;
});
}
for(int i=0;i<pmtasks.size();i++)
{
cout<<"第"<<i+1<<"个产品经理所有任务按优先级排序后的情况"<<endl;
for(int j=0;j<pmtasks[i].size();j++)
cout<<pmtasks[i][j].id<<" "<<pmtasks[i][j].pm<<" "<<pmtasks[i][j].time<<" "<<pmtasks[i][j].pri<<" "<<pmtasks[i][j].dur<<endl; //任务输出
}
vector<Programer> pros(m); //调用程序员函数 ,m为程序员人数，默认为初始值为0。
cout<<"初始程序员列表："<<endl;
for(int i=0;i<pros.size();i++)
{
cout<<pros[i].t<<" "<<pros[i].id<<endl;
}
while (p > 0)
{
sort(pros.begin(), pros.end(), [](Programer t1, Programer t2) //排序当前时间早的在前 ，完成任务时间早的在前
{
return t1.t < t2.t;
});
cout<<"第"<<5-p<<"个任务程序员列表："<<endl;
for(int i=0;i<pros.size();i++)
{
cout<<pros[i].t<<" "<<pros[i].id<<endl;
}
p -= pros.begin()->doTask(); // 排在最前的程序员开始做任务
}
for (auto &it : result) //输出结果
cout << it.second << endl;
return 0;
}
//2 2 5 1 1 1 2 1 2 1 1 1 3 2 2 2 1 1 2 2 3 5 5
展示了每个程序员的完成情况 和 产品经理的任务剩余情况。