201903-5 317号子任务（100分优化过程）

最新推荐文章于 2023-02-08 16:34:57 发布
最新推荐文章于 2023-02-08 16:34:57 发布
阅读量495 收藏 3
点赞数 1
分类专栏： # csp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JUandjuddd/article/details/109298781
版权

csp 201903-5 317号子任务

这个只是用来记录含辛茹苦的优化过程，具体讲解在这里：
201903-5 317号子任务（100分）

测试用例：
7 6 2
1 0 1 0 1 1 0
1 4 1
1 2 3
2 4 4
2 3 5
2 5 7
6 7 5

30分 弗洛伊德：

#include <iostream>
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

#define INF 0x7fffffff

using namespace std;


int main()
{

    int n,m,k;

    while(cin>>n>>m>>k){
        vector<bool> important;

        for(int i = 0; i < n; i++){
            int temp;
            cin>> temp;
            if(temp == 1){
                important.push_back(true);
            }else{
                important.push_back(false);
            }
        }

        int* eage = new int[n*n];
        //init
         for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(i == j){
                    eage[i*n+j] = 0;
                }else{
                    eage[i*n+j] = INF;
                }
            }
        }
        for(int j = 0; j < m; j++){
            int left;
            int right;
            int weight;
            cin>>left>>right>>weight;

            if(weight< eage[(left-1)*n+right-1]){
                eage[(left-1)*n+right-1] = weight;
                eage[(right-1)*n+left-1] = weight;
            }
        }


        //int* dp = new int[n*n];
        //cal
        for(int p = 0; p < n;p++){
            for(int i = 0; i < n; i++){
                for(int j = 0; j < i; j++){
                    if(eage[i*n+p] != INF && eage[p*n+j] != INF){
                        eage[i*n+j] = min(eage[i*n+p]+eage[p*n+j],eage[i*n+j]);
                        eage[j*n+i] = eage[i*n+j];
                    }
                }
            }
        }
		


        for(int i = 0; i < n;i++){

            int count = 0;
            priority_queue<int,vector<int>,less<int> > myqueue;
            for(int j = 0; j < n;j++){
                if(important[j]){
                    int weight = eage[i*n+j];
                    if(count >= k){
                        if(weight < myqueue.top()){
                            myqueue.pop();
                            myqueue.push(weight);
                        }
                    }else{
                        if(weight != INF){
                            myqueue.push(weight);
                            count++;
                        }
                    }
                }
            }
            int size  = myqueue.size();
            int sum = 0;
            for(int p = 0; p <size && p < k; p++){
                sum += myqueue.top();
                myqueue.pop();
            }
            cout << sum<<endl;
        }
        delete [] eage;
    }


    return 0;
}

30分 迪杰斯特拉：

#include <iostream>
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

#define INF 0x7fffffff

using namespace std;


int main()
{

    int n,m,k;

    while(cin>>n>>m>>k){
        vector<bool> important;

        for(int i = 0; i < n; i++){
            int temp;
            cin>> temp;
            if(temp == 1){
                important.push_back(true);
            }else{
                important.push_back(false);
            }
        }

        int* eage = new int[n*n];
        //init
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(i == j){
                    eage[i*n+j] = 0;
                }else{
                    eage[i*n+j] = INF;
                }
            }
        }
        for(int j = 0; j < m; j++){
            int left;
            int right;
            int weight;
            cin>>left>>right>>weight;

            if(weight< eage[(left-1)*n+right-1]){
                eage[(left-1)*n+right-1] = weight;
                eage[(right-1)*n+left-1] = weight;
            }
        }


        int* mindis = new int[n*n];
        //cal
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                mindis[i*n+j] = eage[i*n+j];
            }
        }
        for(int i = 0; i< n; i++){
        	//int* currdis = new int[n];
        	vector<int> currdis;
        	vector<bool> visit;
        	for(int j = 0; j < n; j++){
        		//currdis[j] = dis[i*n+j];
        		currdis.push_back(eage[i*n+j]);
        		visit.push_back(false);
			}
			
			int min = INF;
			int postion = -1;
			while(true){
				//min one
				for(int j = 0; j < n; j++){
	        		if(!visit[j] && currdis[j] < min){
	        			min = currdis[j];
	        			postion = j;
					}
				}
				
				if(min == INF){
					break;
				}
				
				//visit
				visit[postion] = true;
				mindis[i*n+postion] = min;
				mindis[postion*n+i] =  mindis[i*n+postion];
				
				//update
				for(int j = 0; j < n; j++){
	        		if(!visit[j]){
	        			if(eage[postion*n+j] != INF && min+eage[postion*n+j] < currdis[j]){
	        				currdis[j] = min+eage[postion*n+j];
						}
					}
				}
				
				min = INF;	
			}
		}


        for(int i = 0; i < n;i++){

            int count = 0;
            priority_queue<int,vector<int>,less<int> > myqueue;
            for(int j = 0; j < n;j++){
                if(important[j]){
                    int weight = mindis[i*n+j];
                    if(count >= k){
                        if(weight < myqueue.top()){
                            myqueue.pop();
                            myqueue.push(weight);
                        }
                    }else{
                        if(weight != INF){
                            myqueue.push(weight);
                            count++;
                        }
                    }
                }
            }
            int size  = myqueue.size();
            int sum = 0;
            for(int p = 0; p <size && p < k; p++){
                sum += myqueue.top();
                myqueue.pop();
            }
            cout << sum<<endl;
        }

		delete [] mindis;
        delete [] eage;
    }


    return 0;
}

只用了行星发动点，依旧是30分呜呜呜

#include <iostream>
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

#define INF 0x7fffffff

using namespace std;


int main()
{

    int n,m,k;

    while(cin>>n>>m>>k){
        vector<bool> important;

        for(int i = 0; i < n; i++){
            int temp;
            cin>> temp;
            if(temp == 1){
                important.push_back(true);
            }else{
                important.push_back(false);
            }
        }

        int* eage = new int[n*n];
        //init
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(i == j){
                    eage[i*n+j] = 0;
                }else{
                    eage[i*n+j] = INF;
                }
            }
        }
        for(int j = 0; j < m; j++){
            int left;
            int right;
            int weight;
            cin>>left>>right>>weight;

            if(weight< eage[(left-1)*n+right-1]){
                eage[(left-1)*n+right-1] = weight;
                eage[(right-1)*n+left-1] = weight;
            }
        }


        int* mindis = new int[n*n];
        //cal
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                mindis[i*n+j] = eage[i*n+j];
            }
        }
        for(int i = 0; i< n; i++){

            if(!important[i]){
                continue;
            }

        	vector<int> currdis;
        	vector<bool> visit;

        	for(int j = 0; j < n; j++){
        		currdis.push_back(eage[i*n+j]);
        		visit.push_back(false);
			}

			int min = INF;
			int postion = -1;
			while(true){
				//min one
				for(int j = 0; j < n; j++){
	        		if(!visit[j] && currdis[j] < min){
	        			min = currdis[j];
	        			postion = j;
					}
				}

				if(min == INF){
					break;
				}

				//visit
				visit[postion] = true;
				mindis[i*n+postion] = min;
				mindis[postion*n+i] =  mindis[i*n+postion];


				//update
				for(int j = 0; j < n; j++){
	        		if(!visit[j]){
	        			if(eage[postion*n+j] != INF && min+eage[postion*n+j] < currdis[j]){
	        				currdis[j] = min+eage[postion*n+j];
						}
					}
				}

				min = INF;
			}


		}

        for(int i = 0; i < n;i++){

                int count = 0;
                priority_queue<int,vector<int>,less<int> > myqueue;
                for(int j = 0; j < n;j++){
                    if(important[j]){
                        int weight = mindis[i*n+j];
                        if(count >= k){
                            if(weight < myqueue.top()){
                                myqueue.pop();
                                myqueue.push(weight);
                            }
                        }else{
                            if(weight != INF){
                                myqueue.push(weight);
                                count++;
                            }
                        }
                    }
                }
                int size  = myqueue.size();
                int sum = 0;
                for(int p = 0; p <size && p < k; p++){
                    sum += myqueue.top();
                    myqueue.pop();
                }
                cout << sum<<endl;
        }

		delete [] mindis;
        delete [] eage;
    }


    return 0;
}

我继续改，用了heap的迪杰斯特拉，30分

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

#define INF 0x7fffffff

using namespace std;

struct node{
    int id;
    int dis;
};


struct cmp{
    bool operator()(const node& a,const node& b){
        return a.dis > b.dis;
    }
};

int main()
{

    int n,m,k;

    while(cin>>n>>m>>k){
        vector<int> important;

        for(int i = 0; i < n; i++){
            int temp;
            cin>> temp;
            if(temp == 1){
                important.push_back(i);
            }
        }

        int* eage = new int[n*n];
        //init
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(i == j){
                    eage[i*n+j] = 0;
                }else{
                    eage[i*n+j] = INF;
                }
            }
        }
        for(int j = 0; j < m; j++){
            int left;
            int right;
            int weight;
            cin>>left>>right>>weight;

            if(weight< eage[(left-1)*n+right-1]){
                eage[(left-1)*n+right-1] = weight;
                eage[(right-1)*n+left-1] = weight;
            }
        }


        int* mindis = new int[n*n];
        //cal
        for(int w = 0; w< important.size(); w++){

            int i = important[w];


        	//vector<int> currdis;
        	priority_queue<node,vector<node>,cmp> heap;
        	vector<bool> visit;

        	for(int j = 0; j < n; j++){
        		//currdis.push_back(eage[i*n+j]);
        		node tempnode;
                tempnode.id = j;
                tempnode.dis = eage[i*n+j];
                heap.push(tempnode);
        		visit.push_back(false);
			}



			while(!heap.empty()){
				//min one
                node minnode = heap.top();
                heap.pop();

                int postion = minnode.id;
                int min = minnode.dis;

                if(visit[postion]){
                    continue;
                }


				//visit
				visit[postion] = true;
				mindis[i*n+postion] = min;
				mindis[postion*n+i] =  mindis[i*n+postion];


				if(min == INF){
					continue;
				}


				//update
				for(int j = 0; j < n; j++){
	        		if(!visit[j] && eage[postion*n+j] != INF){
	        			node tempnode;
	        			tempnode.id = j;
	        			tempnode.dis = min+eage[postion*n+j];
	        			heap.push(tempnode);
					}
				}

			}


		}

        for(int i = 0; i < n;i++){

                int count = 0;
                priority_queue<int,vector<int>,less<int> > myqueue;

                for(int w = 0; w < important.size();w++){
                    int j = important[w];
                    int weight = mindis[i*n+j];
                    if(count >= k){
                        if(weight < myqueue.top()){
                            myqueue.pop();
                            myqueue.push(weight);
                        }
                    }else{
                        if(weight != INF){
                            myqueue.push(weight);
                            count++;
                        }
                    }
                }
                int size  = myqueue.size();
                int sum = 0;
                for(int p = 0; p <size && p < k; p++){
                    sum += myqueue.top();
                    myqueue.pop();
                }
                cout << sum<<endl;
        }

		delete [] mindis;
        delete [] eage;
    }


    return 0;
}

啊啊啊啊100分！！！！！

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

#define INF 0x7fffffff

using namespace std;

struct node{
    int id;
    int dis;
};


struct cmp{
    bool operator()(const node& a,const node& b){
        return a.dis > b.dis;
    }
};

int main()
{

    int n,m,k;

    while(scanf("%d %d %d",&n,&m,&k)!= EOF){
        vector<int> important;

        for(int i = 0; i < n; i++){
            int temp;
            //cin>> temp;
            scanf("%d",&temp);
            if(temp == 1){
                important.push_back(i);
            }
        }

        //int* eage = new int[n*n];
        vector<vector<node> > eage(n);

        //init
        for(int i = 0; i < n; i++){

            node temp;
            temp.id = i;
            temp.dis = 0;
            eage[i].push_back(temp);
        }
        for(int j = 0; j < m; j++){
            int left;
            int right;
            int weight;
            //cin>>left>>right>>weight;
            scanf("%d %d %d",&left,&right,&weight);
//            if(weight< eage[(left-1)*n+right-1]){
//                eage[(left-1)*n+right-1] = weight;
//                eage[(right-1)*n+left-1] = weight;
//            }
            node temp;
            temp.id = right-1;
            temp.dis = weight;
            eage[left-1].push_back(temp);

            temp.id = left-1;
            eage[right-1].push_back(temp);
        }


        int* mindis = new int[n*n];
        //cal
        for(int w = 0; w< important.size(); w++){

            int i = important[w];



        	//vector<int> currdis;
        	priority_queue<node,vector<node>,cmp> heap;
        	vector<bool> visit;

        	for(int j = 0; j < n; j++){
        		visit.push_back(false);
			}

            for(int j = 0; j < eage[i].size(); j++){
                heap.push(eage[i][j]);
			}




			while(!heap.empty()){
				//min one
                node minnode = heap.top();
                heap.pop();

                int postion = minnode.id;
                int min = minnode.dis;


                if(visit[postion]){
                    continue;
                }

                //printf("from: %d;min: %d;position: %d\n",i,min,postion);

				//visit
				visit[postion] = true;
				mindis[i*n+postion] = min;
				mindis[postion*n+i] =  mindis[i*n+postion];


				//update
				for(int j = 0; j < eage[postion].size(); j++){
	        		if(!visit[eage[postion][j].id]){
	        			node tempnode;
	        			tempnode.id = eage[postion][j].id;
	        			tempnode.dis = min+eage[postion][j].dis;
	        			heap.push(tempnode);
					}
				}

			}

            for(int j = 0; j < n; j++){
                if(!visit[j]){
                    mindis[i*n+j] = INF;
                    mindis[j*n+i] =  mindis[i*n+j];
                }
			}


		}

        for(int i = 0; i < n;i++){

                int count = 0;
                priority_queue<int,vector<int>,less<int> > myqueue;

                for(int w = 0; w < important.size();w++){
                    int j = important[w];
                    int weight = mindis[i*n+j];
                    if(count >= k){
                        if(weight < myqueue.top()){
                            myqueue.pop();
                            myqueue.push(weight);
                        }
                    }else{
                        if(weight != INF){
                            myqueue.push(weight);
                            count++;
                        }
                    }
                }
                int size  = myqueue.size();
                int sum = 0;
                for(int p = 0; p <size && p < k; p++){
                    sum += myqueue.top();
                    myqueue.pop();
                }
                //cout << sum<<endl;
                printf("%d\n",sum);
        }

		delete [] mindis;
    }


    return 0;
}
有人找你
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Delphi5开发人员指南
07-18
4.5.4 子窗体TChildForm 94 4.5.5 数据库基础模式窗体TDBMode- Form 96 4.5.6 数据库导航/状态窗体TDBNavstat- Form 97 4.5.7 使用框架进行应用程序结构 设计 102 4.6 一些项目管理的功能 103 4.6.1 在项目中添加...
Oracle SQL高级编程(资深Oracle专家力作，OakTable团队推荐)--随书源代码
02-04
11.7 反联结执行计划 317 11.8 控制反联结执行计划 326 11.8.1 使用提示控制反联结执行计划 326 11.8.2 在实例级控制反联结执行计划 327 11.9 反联结限制条件 330 11.10 反联结必要条件 333 11.11 小结 333 ...
317号子任务 CCF 201903-5 Apare_xzc Dijkstra 60分(据说没有AC的)
Apare_xzc的博客
11-19 529
317号子任务 题面： Sample input 7 6 2 1 0 1 0 1 1 0 1 4 1 1 2 3 2 4 4 2 3 5 2 5 7 6 7 5 Sample output 8 8 10 10 0 5 据说这题没人100分，最高60… 思路： 存图，我用链式前向星 去重边和自环, 用map<<int,int>int> 因为60%的数据行星发动...
317号子任务 题解
最新发布
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
02-08 123
csp-317号子任务 题解
CSP 201903-5 317号子任务 暴力30分+优化100分
想买很多漂亮衣服但是买不起的博客
03-12 376
原题链接CSP 201903-5 317号子任务 #include <bits/stdc++.h> using namespace std; #define ll long long const int MAX=10010; const int INF=1e8; int n,m,k; int f[MAX]; struct node { int v,w; node(int _v,int _w) { v=_v; w=_w; } };
CCF-CSP 201903-5 317号子任务【Floyd】（30分）
inv0ker的博客
08-16 1280
试题编号： 201903-5 试题名称： 317号子任务 时间限制： 1.0s 内存限制： 512.0MB 题目描述： 只会Floyd拿前30分，能拿60分的算法不会写，能拿100分的算法至今还没听说 代码如下（30分）： #include <iostream> #include <cstring> #include <algorithm> using n...
CCF 201903-5 317号子任务(60分)
qq_36472818的博客
08-22 282
目录前言题目思路SPFA实现代码总结 前言 本文为CCF201903-5的思考 题目 思路 思路对于学算法的来说应该很清晰，难点是怎么写出不超时的程序得满分，如果你对思路不清晰，还请继续学习下算法。 说来，本题就是求出每个顶点到行星基地的最短路径，然后在这些最短路径里选择最短的k个累加起来输出，完成的重点在于怎么找到这些最短路径，本文最后实现的代码只拿到了30分，还是超时了，有需要的可以参考...
CSP 201903-5(317号子任务 100分) 优先队列+dijkstra
all23333333的博客
03-30 278
题面 题目传送门 优化过程 思路 最短路径问题，可用Floyd，dijkstra，SPFA等解决，主要是后续优化。n值比较大且题目中明确说了有重边或自环，故不用邻接矩阵存图。用邻接表可以满足空间开销且避免了重边或自环带来的麻烦。Dijkstra通过优先队列优化后总复杂度为O(mlog2n)，是最高效的最短路径算法。此题一个很关键的地方是计算距离时只计算发动机据点到各点的距离并保存下来，求其他点的最短路径时直接使用即可。求每个据点结果时，先排除不可达点，把其到剩下重要据点的距离放进数组，用sort按从小到
CSP2019-03-5 317号子任务
Q_000的博客
08-21 438
代码是30分 采用的方法是邻接矩阵和Floyd算法，第一次写的比较复杂，超了内存限制，修改后超时只能得30分，简单搜了一下没找到满分代码，或许用邻接表能过？不过不打算改了， #include<iostream> #include <cstring> #include <algorithm> using namespace std; #define INF...
CCF201903-5 317号子任务（100分题解链接）
海岛Blog
08-22 541
试题编号： 201903-5 试题名称： 317号子任务 时间限制： 1.0s 内存限制： 512.0MB 问题链接：CCF201903-5 317号子任务 问题简述：（略） 问题分析：参考链接都是100分。 程序说明：（略） 参考链接： 201903-5 317号子任务（100分优化过程） 201903-5 317号子任务（100分） CCF-CSP 20190305 317号子任务(满分) 题记：（略） 100分的C++语言程序如下： ...
CCF 201903-5 317号子任务 30分
江河湖海
12-03 219
#include<bits/stdc++.h> using namespace std; const int maxn = 10010; const int INF = 0x3f3f3f3f; bool Is_im[maxn]; int Map[maxn][maxn]; int main() { int n, m, K; scanf("%d %d %d", &amp...
python实现 CCF2019-3-5 317子任务
MK422的博客
05-02 735
1.思路分析 使用warshell算法就算最短路径，然后将据点的距离提出来进行排序，但是运行超时，不知道有没有大神指导一下？ 2.零分代码（运行超时） ''' 7 6 2 1 0 1 0 1 1 0 1 4 1 1 2 3 2 4 4 2 3 5 2 5 7 6 7 5 ''' import math def shortDistance(dis): node_num = le...
（课设第一套）1-5 317号子任务 (100 分)（Dijkstra:重边自环）
Abider2的博客
02-28 601
题目 1-5 317号子任务 (100 分) 背景： “你在平原上走着走着，突然迎面遇到一堵墙，这墙向上无限高，向下无限深，向左无限远，向右无限远，这墙是什么？”——《流浪地球》原著 我们带着地球去流浪了，为了处理流浪过程中可能会发生的危机，联合政府找到你，希望你能协助完成 317 号子任务：制定应急预案。 题目： 地球的表面有 n 个据点，这些据点之间存在 m 条双向道路。 这些据点中，有的是建立在行星发动机之下，受到行星发动机的保护（行星发动机据点），而其他据点则没有行星发动机的保护（普通据点，比如燃料
ccf csp 201903-5 317号任务
qq_39366020的博客
08-14 435
这道题数据规模太大，总是超时。求大佬给100分代码，实在不知道怎么改进。 我的解题思路是对每个点进行一次Dijkstra算法，找出符合要求的最近的点。 #include<iostream> #include<cstring> #include<vector> #include<queue> const int INF = 1005;//最大弧长，相...
317号子任务 CSP
匿名用户
03-15 176
#include <iostream> #include <cstring> #include <queue> #include <algorithm> using namespace std; const int N = 10010,M = 20010,INF = 0x3f3f3f3f; // 无向边，边要取双倍 int n,m,k; int dist[N]; // 排序后取前k个。 // 存储每个点到x号点的最短距离 int h[N], w[M].
CP-317控制包与FDS系列控制器用户手册概览
CP-317用户手册是针对FDS系列控制器的专业文档，它提供了对安川公司生产的控制包CP-317的详细规格和系统设计指导。该手册强调了安全使用的重要性，要求用户在安装、操作、维护和检测之前全面阅读《使用说明和维护...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值