2022华为软件挑战赛流量管理

已于 2022-08-04 23:14:23 修改
阅读量336 收藏
点赞数
于 2022-07-11 18:53:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leangx86/article/details/125727524
版权

java 算法 华为云

1.题目描述

  1. 共有 M 个客户节点和 N 个边缘节点。
  2. 在每个时刻，要决策如何把每个客户节点的带宽需求分配到边缘节点。
  3. 为了确保调度质量，每个客户节点的需求只能分配到满足 QoS 约束的边缘节点
    上。即：当客户节点和边缘节点之间的 QoS 小于“QoS 上限”时，才会进行流量
    分配。
  4. 在每个时刻，每个边缘节点接收的带宽需求总和不能超过其带宽上限。
  5. 合理分配所有时刻的客户节点带宽需求，使得最终的带宽总成本尽量小。
  6. 成本为某个边缘节点，统计它在每个时刻分配的带宽之和，这些值
    在整个时间线上形成一个带宽序列，对其进行升序排序，以其 95%位置（向上
    取整）的带宽值作为该节点的 95 百分位带宽。
    7.总成本为求和所有边缘节点成本得到带宽总成本。
    在这里插入图片描述
    在这里插入图片描述

2.思路

将网络节点根据连接用户数量和带宽大小进行降序排序，让一部分节点每个时刻都尽量占用带宽，一部分节点只部署5%个时刻的带宽，这些节点的成本即为0。
在这里插入图片描述
如图，竖条为所有网络节点在所有时刻的带宽部署情况，横条为95%时刻位置，前一部分的网络节点带宽最大，连接用户数量最多，在每个时刻都尽量占用，而后面的节点只占用前5%。作为前一部分节点的数量称为阈值。
最终成绩为武长赛区43名，无缘复赛，只能拿到三等奖。
在这里插入图片描述

3.代码（Java）

注释还是比较清楚的，一些细节问题可以直接看。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Properties;

public class Main {//文件名+路径+print
	
	static int T,M,N,qos_constraint;
	static String[][] demand,qos,site_bandwidth;
	static ArrayList rear=new ArrayList();
	
	public static void main(String[] args) {
		output("");
		
        demand=new String[8929][35];//T M  [T-1][M-1]  T<=8928,N<=135,M<=35  width=430080
        site_bandwidth=new String[136][2];//N 2  [N-1][1]
        qos=new String[136][35];//N M   [N-1][M-1]   
		input();//T M N 101 11 101
		
		int gate=T-(int) Math.ceil((T-1)*0.95)-1;      //95位
		Netnode[] netnodes=new Netnode[N];//1--N-1 
		for(int i=1;i<M;i++) {
			for(int j=1;j<M;j++) {
				if(demand[0][j].equals(qos[0][i])) {
					for(int k=0;k<T;k++) {
						String t=demand[k][i];
						demand[k][i]=demand[k][j];
						demand[k][j]=t;
					}
					break;
				}
			}
		}
		for(int i=1;i<N;i++) {
			for(int j=1;j<N;j++) {
				if(site_bandwidth[j][0].equals(qos[i][0])) {
					netnodes[i]=new Netnode(Integer.parseInt(site_bandwidth[j][1]), T, M, qos[i], qos_constraint);//导入网络节点
					break;
				}
			}
			for(int j=1;j<i;j++) {
				if(netnodes[j].t<netnodes[i].t) {//根据网络节点的连接用户数排序；'<'或'>'需要根据数据集实际情况进行调整
					Netnode netnode=netnodes[i];
					netnodes[i]=netnodes[j];
					netnodes[j]=netnode;
				}
			}
		}
		for(int i=1;i<N;i++) {
			for(int j=i+1;j<N;j++) {
				if(netnodes[i].t==netnodes[j].t) {
					if(netnodes[i].width<netnodes[j].width) {//连接用户数相同在根据总带宽排序；'<'或'>'需要根据数据集实际情况进行调整
						Netnode netnode=netnodes[i];
						netnodes[i]=netnodes[j];
						netnodes[j]=netnode;
					}
				}else {
					break;
				}
			}
		}
		int threshold=getthreshold(netnodes);  //阈值，阈值前面的网络节点尽量塞满，后面的只塞5%
		for(int i=threshold;i<N;i++) {
			for(int j=i+1;j<N;j++) {
				if(netnodes[i].t>netnodes[j].t) {//对阈值后面的节点根据网络节点的连接用户数排序；'<'或'>'需要根据数据集实际情况进行调整，记得和函数getthreshold里这部分同号
					Netnode netnode=netnodes[i];
					netnodes[i]=netnodes[j];
					netnodes[j]=netnode;
				}
			}
		}
		for(int i=threshold;i<N;i++) {
			for(int j=i+1;j<N;j++) {
				if(netnodes[i].t==netnodes[j].t) {
					if(netnodes[i].width>netnodes[j].width) {//连接用户数相同在根据总带宽排序；'<'或'>'需要根据数据集实际情况进行调整，记得和函数getthreshold里这部分同号
						Netnode netnode=netnodes[i];
						netnodes[i]=netnodes[j];
						netnodes[j]=netnode;
					}
				}else {
					break;
				}
			}
		}
		for(int i=1;i<T;i++) {
			for(int j=1;j<M;j++) {
				output(distribute(i, j, threshold, netnodes)+"\n");//进行模拟
			}
			for(int j=1;j<N;j++) {
				netnodes[j].twidth=netnodes[j].width;//更新本轮带宽
			}
			for(int j=0;j<rear.size();j++) {
				netnodes[(int) rear.get(j)].gate--;
			}
			rear.clear();
		}
		print(netnodes);//remove
	}
	public static int getthreshold(Netnode[] tnetnodes) {//测试最佳阈值
		int threshold=0,cost=500000000;
		Netnode[] netnodes=new Netnode[N];
		for(int m=1;m<N;m++) {            //测试最佳阈值
			for(int i=1;i<N;i++) {
				netnodes[i]=tnetnodes[i];
			}
			for(int i=m;i<N;i++) {
				for(int j=i+1;j<N;j++) {
					if(netnodes[i].t>netnodes[j].t) {//根据网络节点的连接用户数排序；'<'或'>'需要根据数据集实际情况进行调整
						Netnode netnode=netnodes[i];
						netnodes[i]=netnodes[j];
						netnodes[j]=netnode;
					}
				}
			}
			for(int i=m;i<N;i++) {
				for(int j=i+1;j<N;j++) {
					if(netnodes[i].t==netnodes[j].t) {
						if(netnodes[i].width>netnodes[j].width) {//对阈值后面的节点排序；'<'或'>'需要根据数据集实际情况进行调整
							Netnode netnode=netnodes[i];
							netnodes[i]=netnodes[j];
							netnodes[j]=netnode;
						}
					}else {
						break;
					}
				}
			}
			for(int i=1;i<T;i++) {
				for(int j=1;j<M;j++) {
					distribute(i, j, m, netnodes);
				}
				for(int j=1;j<N;j++) {
					netnodes[j].twidth=netnodes[j].width;
				}
				for(int j=0;j<rear.size();j++) {
					netnodes[(int) rear.get(j)].gate--;
				}
				rear.clear();
			}
			int sum=0;
			for(int i=1;i<N;i++) {
				Arrays.sort(netnodes[i].widtharray);
				sum+=netnodes[i].widtharray[(int)Math.ceil((T-1)*0.95-1)];
			}
			if(cost>sum) {
				cost=sum;
				threshold=m;
			}
			for(int j=1;j<N;j++) {
				for(int k=1;k<T;k++) {
					netnodes[j].widtharray[k-1]=0;
					netnodes[j].gate=T-(int) Math.ceil((T-1)*0.95)-1;
				}
			}
		}
		return threshold;
	}
	public static String distribute(int i,int j,int threshold,Netnode[] netnodes) {//分配算法
		int need=Integer.parseInt(demand[i][j]);
		String ts=demand[0][j]+":";
		if(need==0) {
			return ts;
		}
		for(int k=1;k<N;k++) {
			if(netnodes[k].qos[j]<qos_constraint&&netnodes[k].twidth>0) {//判断用户能否接上该节点
				if(k<threshold) {//N/4-(15-20)   //判断该用户节点进去阈值前段还是阈值后段
					if(need>netnodes[k].twidth) {
						need-=netnodes[k].twidth;
						netnodes[k].widtharray[i-1]=netnodes[k].width;
						ts+="<"+netnodes[k].id+","+netnodes[k].twidth+">,";
						netnodes[k].twidth=0;
					}else if(need<=netnodes[k].twidth){
						netnodes[k].twidth-=need;
						netnodes[k].widtharray[i-1]+=need;
						ts+="<"+netnodes[k].id+","+need+">";
						need=0;
						break;
					}
				}else {
					if(netnodes[k].gate>0) {         //判断阈值后端的节点是否还有位置（5%）
						if(need>netnodes[k].twidth) {
							need-=netnodes[k].twidth;
							netnodes[k].widtharray[i-1]=netnodes[k].width;
							ts+="<"+netnodes[k].id+","+netnodes[k].twidth+">,";
							netnodes[k].twidth=0;
							netnodes[k].gate--;
							if(rear.contains(k)) {
								rear.remove(rear.indexOf(k));
							}
						}else if(need<=netnodes[k].twidth){
							netnodes[k].twidth-=need;
							netnodes[k].widtharray[i-1]+=need;
							ts+="<"+netnodes[k].id+","+need+">";
							need=0;
							if(!rear.contains(k)) {
								rear.add(k);
							}
							//netnodes[k].gate--;
							break;
						}
					}
				}
			}
		}
		if(need!=0) {      //判断该用户节点的需求是否已经分配完
			for(int k=threshold;k<N;k++) {
				if(netnodes[k].qos[j]<qos_constraint&&netnodes[k].twidth>0) {
					if(need>netnodes[k].twidth) {
						need-=netnodes[k].twidth;
						netnodes[k].widtharray[i-1]=netnodes[k].width;
						ts+="<"+netnodes[k].id+","+netnodes[k].twidth+">,";
						netnodes[k].twidth=0;
					}else if(need<=netnodes[k].twidth){
						netnodes[k].twidth-=need;
						netnodes[k].widtharray[i-1]+=need;
						ts+="<"+netnodes[k].id+","+need+">";
						need=0;
						break;
					}
				}
			}
		}
		return ts;
	}
	public static void print(Netnode[] netnodes) {//打印结果
		int sum1=0;
		for(int i=1;i<N;i++) {
			Arrays.sort(netnodes[i].widtharray);
			//System.out.println(i+":"+Arrays.toString(netnodes[i].widtharray));
			output(i+":"+Arrays.toString(netnodes[i].widtharray)+"\n\n");
			sum1+=netnodes[i].widtharray[(int)Math.ceil((T-1)*0.95-1)];
		}
		System.out.println(sum1);
	}
	public static void input(){//输入
		String line = "";
        String tarray[];
        int i=0,j=0;
        try (BufferedReader br = new BufferedReader(new FileReader("D:\\华为软件挑战赛\\线下调试数据\\data1\\demand.csv"))) {//"/data/demand.csv"
        	while ((line = br.readLine()) != null) {
                tarray = line.split(",");
                for(j=0;j<tarray.length;j++) {
                	demand[i][j]=tarray[j];
                }
                i++;
            }
    		T=i--;
    		M=j--;
        } catch (IOException e) {
            e.printStackTrace();
        }
        i=0;
        try (BufferedReader br = new BufferedReader(new FileReader("D:\\华为软件挑战赛\\线下调试数据\\data1\\site_bandwidth.csv"))) {//"/data/site_bandwidth.csv"
        	while ((line = br.readLine()) != null) {
                tarray = line.split(",");
                for(j=0;j<tarray.length;j++) {
                	site_bandwidth[i][j]=tarray[j];
                }
                i++;
            }
    		N=i--;
        } catch (IOException e) {
            e.printStackTrace();
        }
        i=0;
        try (BufferedReader br = new BufferedReader(new FileReader("D:\\华为软件挑战赛\\线下调试数据\\data1\\qos.csv"))) {//"/data/qos.csv"
        	while ((line = br.readLine()) != null) {
                tarray = line.split(",");
                for(j=0;j<tarray.length;j++) {
                	qos[i][j]=tarray[j];
                }
                i++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        
		try {
			FileInputStream fin;
			fin = new FileInputStream("D:\\华为软件挑战赛\\线下调试数据\\data1\\config.ini");//"/data/config.ini"
			Properties props=new Properties();
			props.load(fin);
			qos_constraint=Integer.parseInt(props.getProperty("qos_constraint"));
			fin.close(); 
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static void output(String result) {//输出
		String path="D:\\华为软件挑战赛\\线下调试数据\\data1\\output\\solution.txt";//"/output/solution.txt"
		FileWriter fwriter = null;
        try {
        	if(!result.equals("")) {
        		fwriter = new FileWriter(path, true);
                fwriter.write(result);
        	}else {
        		fwriter = new FileWriter(path);
                fwriter.write(result);
        	}
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                fwriter.flush();
                fwriter.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
	}
}
class Netnode{                    //网络节点类
	public int width,twidth,t,gate;
	public int[] qos,widtharray;//qos:1--m-1
	String id;
	public Netnode(int width,int T,int M,String[] d,int qc){
		this.width=width;
		twidth=width;
		widtharray=new int[T-1];
		gate=T-(int) Math.ceil((T-1)*0.95)-1;
		qos=new int[M];
		id=d[0];
		for(int i=1;i<M;i++) {
			qos[i]=Integer.parseInt(d[i]);
			if(qos[i]<qc) {
				t++;
			}
		}
	}
}
leangx86
关注
2022华为软件精英挑战赛比赛经历
Wuerlix
07-08 3053
2022华为软件精英挑战赛比赛经历
2020中国高校计算机大赛·华为云大数据挑战赛热身赛——交通流量预测赛题分析（Rank7 完结撒花）
热门推荐
weixin_43945120的博客
04-16 1万+
2020中国高校计算机大赛·华为云大数据挑战赛热身赛题_交通流量预测赛题分析(持续更新！！！） 写在前面：大家好！我是在读本科生数据新手JerryX，各位数据挖掘大佬有什么问题和建议多多指教！！也欢迎大家多多点赞，多多评论，多多批评指正！！ 0. 赛题介绍 赛题背景 随着电子信息和移动通信技术高速发展和不断融合，人工智能在各个领域都相继取得了巨大的突破，城市智能体也应运而生，而城市交通又是城市智能...
2022华为软件精英挑战赛
qq_38422570的博客
03-28 3381
3.14-3.27，历经两个周，终于是落下帷幕了。最后成绩虽然还没出，但是最多也就是个谢谢参与奖了。整理一下比赛以来学到的新东西吧。 3.14之前 先把C++ STL库的东西大概了解了一下，但是不深，也不怎么会应用。 ​​​​​​概述 - C++ STL Tutorial (gitbook.io) 还根据目前的赛题简介稍微猜一猜是流量控制，还去看了相关的视频 陌陌直播智能CDN调度系统实践之路 3.14初赛赛题公布 根据赛题整理了一下数据结构，分别是客户节点、边缘节点、服务质量。然
2022华为软件精英挑战赛-总结
b_rillian_t的博客
07-15 8493
2022华为软挑，粤港澳赛区第四，全球总决赛27名
2022年华为软件精英挑战赛区域初赛解读（基于数学规划模型附代码）
专注运筹学，数据科学领域，只发原创文章
04-23 2850
0 写在前面的 本文是对2022年华为软件精英挑战赛（普朗克计划）区域初赛的一个解读。首先说明的是本文的算法无法直接拿来参赛的，因为区域初赛的要求是不能调用其它的算法包，python的话只能用numpy，其它的第三方包一概不能使用。而本文的方法是基于数学规划模型，需要调用求解器来求解（例如：Gurobi, Cplex等）。因此本文是作为一个运筹优化爱好者的角度来看看如何解决一个实际的优化问题，如果能给对比赛感兴趣的同学一点启发的话那就更好了。关于区域初赛的说明文档，测试数据和本文算法的代码，我已经全部上传在
2022华为软挑赛题讲解(CodeCraft-2022)
不负AC不负卿的博客
07-05 3423
2022华为软挑赛题简单讲解，涉及初赛、复赛、决赛
2019华为网络精英挑战赛初赛资料
04-28
在2019年的华为网络精英挑战赛初赛中，涉及了多个5G的关键知识点。 1. **SRAN与Cloud RAN的区别**：题目指出SRAN和Cloud RAN并非功能相同，这表明SRAN可能指的是传统的集中式或分布式无线接入网络，而Cloud RAN则...
华为挑战赛复赛1800点案例
04-22
【华为挑战赛复赛1800点案例】是一场以技术实力和创新思维为主题的竞赛，其中涉及到的主要知识点是测试案例的设计与应用。在这样的竞赛中，参赛者通常需要利用编程技能、算法理解和数据分析能力来解决复杂的问题。在...
华为软件精英挑战赛：自动驾驶路线规划解决城市拥堵
2019华为软件精英挑战赛的复赛任务书版本V2.01聚焦于智能交通管理的实践应用。在这个虚拟的城市环境中，参赛者需要扮演“首席城市交通规划官”的角色，设计出高效的车辆路线规划策略，以应对日益严重的城市交通拥堵...
2022年华为软件精英挑战赛（杭厦赛区冠军，全球第五）
威廉姆斯的博客
06-14 2161
时光匆匆流逝。转眼一年稍纵即逝。去年软调历历在目。 去年参加比赛体验极佳，虽然没有打入决赛，但是和各个大佬互相竞争，斗智斗勇还是挺有意思的。 于是乎今年又参加了华为软调。 仰慕去年零零妖大哥冲榜时之手遮天的气魄，于是乎加了妖哥大佬的联系方式。 得益于紧抱妖哥大腿,今年打到总决赛季军，全球排名第五。我们队叫土豪法称霸杭厦。 鉴于妖哥已经总结了一遍我就不重复总结了。 直接放妖哥总结链接 https://zhuanlan.zhihu.com/p/523783019 练习赛一直霸占榜一。最后虽然被抄了一点，但是决赛
2017 华为软件精英挑战赛赛题
04-03
2017 华为软件精英挑战赛赛题：大视频时代•布局 在给定结构的G省电信网络中，为了视频内容快速低成本的传送到每个住户小区，需要在这个给定网络结构中选择一些网络节点附近放置视频内容存储服务器。需要解决的问题是：在满足所有的住户小区视频播放需求的基本前提下，如何选择视频内容存储服务器放置位置，使得成本最小。
2020华为软件精英挑战赛初复赛赛题包.zip
05-26
2020华为软件精英挑战赛初复赛赛题包，不包含民间数据集，民间数据集在博客中给出大佬github地址。
2019届华为软件精英挑战赛赛题为“智能世界•纵横”！思路
weixin_40657079的博客
03-09 3613
1. 背景信息 l 道路交通是城市的核心要素之一。 l 随着社会经济的发展，中国城市的车辆保有量已经越来越多，大都市慢慢变成了“堵”市。如何在出行时避免拥堵，是每一个人的目标。 l 日常生活中，很多拥堵是由于车辆行驶路线规划失误，大批车辆集中选择主干道行驶导致通行效率下降。 l 如果车辆都由调度中心统一规划调度路线，拥堵问题将得到大大缓解甚至彻底解决。 l 实际上这一技术已经在工业领域如...
【比赛总结】软件挑战赛
qq_36553828的博客
04-18 193
前言 这算是本人第一次参加正式参加华为的比赛，去年在外围观望各位大佬，参加了比华为难度低一些的中兴算法笔试，今年的题目相对于往年难度较低，对于数据结构有一定的高度，但最重要的还是多种多样的解题思路，可能同样的算法构建难度，较好的解题思路缺能起到很好的效果。本次的成绩是初赛：练习赛第10，正式赛第11；复赛：练习赛第13，正式赛第17。由此可以看出该赛区的竞争激烈，本队维护的代码基本框架是具有一定普适性，但要得到更高的分数需要在某些方面进行约束 后期更改的数据集的对于维护的代码不太优化，慢慢的变成了调参细
华为软件精英挑战赛2020题目
安辰的博客
04-10 7925
华为2020软件精英挑战赛赛题及答案
华为软件精英挑战赛
weixin_41563161的博客
03-07 2293
人生艰难，不仅仅在于我们要经历成长过程中的种种磨砺，而更要经受一些迫不得已的离别之苦。于家人，为了求学、工作，我们背井离乡，从此乡人再也没能喝上一口井水。于爱人，情侣间一个简单的拥抱，都因为异地而变得更加来之不易。 但是，这一切终会有一个简单的理由支撑着我们勇往直前：为了你生命中最在乎的人而努力变好。 如果可以，请放下手中无聊、无谓、无奈、无趣的事情，对他们说句：我爱你！ 而最让我眼中常含满泪水的，是我知道你们有一个算法不会。 今天小编想要给大家介绍一条脚踩技面、手撕HR、月入十万、迎娶白富美、登上人
华为2022年软挑赛初赛试题及初级代码（成渝赛区）
weixin_45564943的博客
03-31 1125
目录 1.赛题描述 2.全部代码 1.赛题描述 2.全部代码 # import psutil ##查看程序所占用的内存空间 # import os import numpy as np import configparser import time start =time.clock() config_path = 'F:\\桌面\\data\\config.ini' path1 = "F:\\桌面\\data\\demand.csv" path2 = "F..
2023华为软件精英挑战赛赛题解析及baseline（C++实现）
最新发布
qq_37795916的博客
03-16 1万+
我这只是实现了一个baseline，虽然分数比较低，但是我实现了机器人移动到目标工作台的功能，并且我只移动了一个机器人，使其在两个工作台之间移动一次就停止了，所以还有很大的提升空间。比如，你可以让机器人移动到某个工作台a购买产品1（假设花费100元），然后移动到另一个工作台b出售产品1（假设售价1000元），那么你可以赚取900元的差价。自己花了一两天写出了一个baseline，我的baseline实现的功能就是移动一个机器人到某一个工作台购买产品，然后移动到另一个工作台出售产品。
机器学习实战（一）：2018华为精英软件挑战赛（时间序列）
lygeneral的博客
04-07 590
概览一、前言二、时间序列基础1.AR2.MA3.ARMA4.ARIMA三、预测四、服务器部署 一、前言 2018年参加了华为的软件挑战赛，当初我所在的学院参加了这个比赛拿到名次的同学也基本都拿到了华为的offer，有的去了华为，有的因为各种原因去了其他的公司。最近在回顾时间序列算法模型，当时参加比赛使用了几种模型，于是在此进行回顾。 时间序列模型通常分为传统机器学习模型和神经网络模型，其中传统机器...
华为2021精英软件挑战赛代码解析及回顾
华为精英挑战赛是华为公司主办的一项针对软件开发者的竞赛活动。该赛事通常会聚焦在解决实际的技术难题、软件开发、算法设计以及系统架构设计等方面。通过比赛，华为旨在吸引和选拔具有创新精神和高水平技术能力的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值