zoukankan      html  css  js  c++  java
  • 头条机试(一)

    一、

    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
    

    展示了每个程序员的完成情况 和 产品经理的任务剩余情况。

  • 相关阅读:
    python使用数据库的一些操作
    正则表达式整理
    tomcat启动成功但是访问不到官网
    控制反转 依赖注入 AOP 和 IOC
    abstract 和 interface区别
    input文本框 鼠标点击默认消失,不输入离开鼠标恢复默认值
    声明式管理事务:基于AspectJ的xml方式
    使用注解配置声明式事务
    spring事物 (mu课)
    oracle表之数据类型
  • 原文地址:https://www.cnblogs.com/ruo-li-suo-yi/p/9445789.html
Copyright © 2011-2022 走看看