相似推荐、最短路劲、最少基站、简单加密解密、des加密-算法

已于 2023-03-06 14:34:12 修改
阅读量271 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 算法 java 数据结构
于 2020-08-31 10:27:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/teachy/article/details/108316520
版权

1:相似推荐

public class UserCF {

public static void init(String userName) {

	Set<String> items = new HashSet();
	items.add("A");
	items.add("B");
	items.add("C");
	items.add("D");
	items.add("E");
	items.add("F");
	items.add("G");
	items.add("H");
	items.add("I");
	Map<String, Set<String>> allSet = new HashMap();
	Set<String> set1 = new HashSet();
	set1.add("p01");
	set1.add("p02");
	allSet.put("A", set1);
	Set<String> set2 = new HashSet();
	set2.add("p01");
	set2.add("p02");
	set2.add("p04");
	allSet.put("B", set2);
	Set<String> set3 = new HashSet();
	set3.add("p01");
	set3.add("p02");
	set3.add("p03");
	allSet.put("C", set3);
	Set<String> set4 = new HashSet();
	set4.add("p01");
	set4.add("p02");
	set4.add("p03");
	set4.add("p04");
	allSet.put("D", set4);
	Set<String> set5 = new HashSet();
	set5.add("p02");
	set5.add("p03");
	set5.add("p04");
	set5.add("p05");
	allSet.put("E", set5);
	Set<String> set6 = new HashSet();
	set6.add("p03");
	set6.add("p04");
	set6.add("p05");
	allSet.put("F", set6);
	Set<String> set7 = new HashSet();
	set7.add("p02");
	set7.add("p04");
	set7.add("p05");
	allSet.put("G", set7);
	Set<String> set8 = new HashSet();
	set8.add("p01");
	set8.add("p05");
	set8.add("p06");
	allSet.put("H", set8);
	Set<String> set9 = new HashSet();
	set9.add("p01");
	set9.add("p02");
	set9.add("p03");
	set9.add("p04");
	set9.add("p05");
	set9.add("p06");
	allSet.put("I", set9);

	Map<String, Set<String>> allUserSet = new HashMap();
	Set<String> set01 = new HashSet();
	set01.add("A");
	set01.add("B");
	set01.add("C");
	set01.add("D");
	set01.add("H");
	set01.add("I");
	allUserSet.put("p01", set01);

	Set<String> set02 = new HashSet();
	set02.add("B");
	set02.add("C");
	set02.add("D");
	set02.add("E");
	set02.add("G");
	set02.add("I");
	allUserSet.put("p02", set02);

	Set<String> set03 = new HashSet();
	set03.add("C");
	set03.add("D");
	set03.add("E");
	set03.add("F");
	set03.add("I");
	allUserSet.put("p03", set03);

	Set<String> set04 = new HashSet();
	set04.add("B");
	set04.add("D");
	set04.add("E");
	set04.add("F");
	set04.add("G");
	set04.add("I");
	allUserSet.put("p04", set04);

	Set<String> set05 = new HashSet();
	set05.add("A");
	set05.add("E");
	set05.add("F");
	set05.add("G");
	set05.add("H");
	set05.add("I");
	allUserSet.put("p05", set05);

	Set<String> set06 = new HashSet();
	set05.add("H");
	set05.add("I");
	allUserSet.put("p06", set06);
	Set<String> s1 = new HashSet();
	Set<String> result = new HashSet();
	for (String item : items) {// 遍历每一件物品
		Set<String> users = allSet.get(item);
		if (!users.contains(userName) && !result.contains(item)) {
			for (String user : users) {
				s1.clear();
				s1.addAll(allUserSet.get(userName));
				Set<String> s2 = allUserSet.get(user);
				s1.retainAll(s2);
				if (s1.size() >= 3) {
					result.addAll(allUserSet.get(userName));
					result.addAll(s2);
				} else {
					continue;
				}
			}
		}
		if (result.size() == items.size()) {
			break;
		}
	}
	result.removeAll(allUserSet.get(userName));
	for (String item : result) {
		System.out.print(item + ",");
	}
	System.out.println();
}

public static void main(String[] args) {
	init("p03");
	init("p04");
	init("p06");
}

}
2：最短路劲

/**

  • 用户推送
  • @author teach

*/
public class ZDJU {

private static int max = 0;
private static int max1 = Integer.MAX_VALUE;

public static void main(String[] args) {
	int[][] all = new int[][] { { 0, 4, 6, max, max, max, 8, max, max, max },
			{ 4, 0, max, 3, 3, max, max, max, max, max }, { 6, max, 0, 2, max, max, max, max, max, max },
			{ max, 3, 2, 0, max, 1, max, max, max, 5 }, { max, 3, max, max, 0, 2, 2, max, 3, max },
			{ max, max, max, 1, 2, 0, max, max, max, 3 }, { 8, max, max, max, 2, max, 0, 3, max, max },
			{ max, max, max, max, max, max, 3, 0, 1, max }, { max, max, max, max, 3, max, max, 1, 0, 4 },
			{ max, max, max, 5, max, 3, max, max, 4, 0 } };

	List<Node> allNode = new ArrayList();
	allNode.add(new Node(0, "p01", max1, 0));
	allNode.add(new Node(1, "p02", max1, 0));
	allNode.add(new Node(2, "p03", max1, 0));
	allNode.add(new Node(3, "p04", max1, 0));
	allNode.add(new Node(4, "p05", max1, 0));
	allNode.add(new Node(5, "p06", max1, 0));
	allNode.add(new Node(6, "p07", max1, 0));
	allNode.add(new Node(7, "p08", max1, 0));
	allNode.add(new Node(8, "p09", max1, 0));
	allNode.add(new Node(9, "p10", max1, 0));
	int d = 0;
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			// 找到了相连节点
			if (all[i][j] != 0) {
				// 上一个节点的最短路径的值+与下一个节点相连路径上的值
				d = allNode.get(i).value + all[i][j];
				// 判断是否比原先的值要小，如果小就将0-j节点的长度替换
				if (d < allNode.get(j).value) {
					allNode.get(j).value = d;
					// 记录前一个节点的序号
					allNode.get(j).parent = i;
				}
			}
		}
	}
	List<Integer> list = new ArrayList();
	List<String> list1 = new ArrayList();
	Node node = allNode.get(9);
	while (node.parent != 0) {
		list.add(node.number);
		list1.add(node.name);
		node = allNode.get(node.parent);
	}
	list.add(node.number);
	list1.add(node.name);
	list.add(0);2
	list1.add("p01");
	Collections.sort(list);
	Collections.sort(list1);
	System.out.println("路劲为：");
	for (String str : list1) {
		System.out.print("-->" + str);
	}
	System.out.println("总距离：");
	int sum = 0;
	for (int i = 0; i < list.size() - 1; i++) {
		sum = sum + all[list.get(i)][list.get(i + 1)];
	}
	System.out.println(sum);
}

static class Node {

	public String name;
	public int number;
	public int value;
	public int parent;

	public Node(int number, String n, int v, int p) {
		this.name = n;
		this.number = number;
		this.value = v;
		this.parent = p;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}

	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}

	public int getParent() {
		return parent;
	}

	public void setParent(int parent) {
		this.parent = parent;
	}

}

}
3：最少基站

public class For4 {

public static void main(String[] args) {
	String[] S01 = { "成都", "德阳", "绵阳", "广元" };
	String[] S02 = { "雅安", "眉山", "乐山" };
	String[] S03 = { "成都", "资阳", "内江", "泸州" };
	String[] S04 = { "宜宾", "泸州" };
	String[] S05 = { "重庆", "泸州", "内江" };
	String[] S06 = { "遂宁", "南充", "广安", "重庆" };
	String[] S07 = { "资阳", "遂宁", "内江" };
	String[] S08 = { "绵阳", "德阳", "遂宁", "南充" };
	String[] baseStationNOArray = { "S01", "S02", "S03", "S04", "S05", "S06", "S07", "S08" };
	Set<String> allArea = new HashSet();
	List<String> a1 = Arrays.asList(S01);
	List<String> a2 = Arrays.asList(S02);
	List<String> a3 = Arrays.asList(S03);
	List<String> a4 = Arrays.asList(S04);
	List<String> a5 = Arrays.asList(S05);
	List<String> a6 = Arrays.asList(S06);
	List<String> a7 = Arrays.asList(S07);
	List<String> a8 = Arrays.asList(S08);
	Map<String, List<String>> allsetMap = new HashMap<String, List<String>>();
	allsetMap.put("S01", a1);
	allsetMap.put("S02", a2);
	allsetMap.put("S03", a3);
	allsetMap.put("S04", a4);
	allsetMap.put("S05", a5);
	allsetMap.put("S06", a6);
	allsetMap.put("S07", a7);
	allsetMap.put("S08", a8);

	allArea.addAll(a1);
	allArea.addAll(a2);
	allArea.addAll(a3);
	allArea.addAll(a4);
	allArea.addAll(a5);
	allArea.addAll(a6);
	allArea.addAll(a7);
	allArea.addAll(a8);

	List<String> all = new ArrayList<String>();

	List<String> reStrings = new ArrayList<String>();
	for (String s : baseStationNOArray) {
		List<String> temp = new ArrayList<String>();
		all.clear();
		all.addAll(allArea);
		List<String> aList = allsetMap.get(s);
		all.removeAll(aList);
		temp.add(s);
		while (!all.isEmpty()) {
			String tempString="ddd";
			int tempInt=0;;
			for (String s1 : baseStationNOArray) {
				if (!temp.contains(s1)) {
					aList = allsetMap.get(s1);
					if(aList.size()>tempInt) {
						tempInt=aList.size();
						tempString = s1;
					}
				}
			}
			if (all.isEmpty()) {
				break;
			}
			temp.add(tempString);
			all.removeAll(allsetMap.get(tempString));

		}
		if (all.isEmpty() && (reStrings.isEmpty() || reStrings.size() > temp.size())) {
			reStrings.clear();
			reStrings.addAll(temp);
		}
	}
	System.out.println(reStrings);
}

}

4：简单加密解密

public class For5 {
public static String sgin=“###”;
public static void main(String[] args) {
jiami(“d://test.txt”,“d://test1.txt”);
jiemi(“d://test1.txt”,“d://test2.txt”);
}

public static void jiemi(String path1,String path2) {
	BufferedReader bufferedReader = null;
	BufferedWriter bufferedWriter = null;
	try {
		bufferedReader = new BufferedReader(new FileReader(path1));
		bufferedWriter = new BufferedWriter(new FileWriter(path2));
		String lineString = "";
		while ((lineString = bufferedReader.readLine()) != null) {
			if(lineString.endsWith(sgin)) {
				lineString = lineString.substring(0,lineString.length()-sgin.length());
			}
			int begin = 0;
			int end = 2;
			while (begin <= lineString.length()) {
				if (begin + end > lineString.length()) {
					end = lineString.length() - begin;
				}
				bufferedWriter.write(lineString, begin, end);
				begin=begin+2+sgin.length();
				bufferedWriter.flush();
			}
			bufferedWriter.newLine();

		}

	} catch (Exception e) {
		try {
			bufferedReader.close();
			bufferedWriter.close();
		} catch (IOException e1) {				
			e1.printStackTrace();
		}			
		e.printStackTrace();
	}
}


public static void jiami(String path1,String path2) {
	BufferedReader bufferedReader = null;
	BufferedWriter bufferedWriter = null;
	try {
		bufferedReader = new BufferedReader(new FileReader(path1));
		bufferedWriter = new BufferedWriter(new FileWriter(path2));
		String lineString = "";
		while ((lineString = bufferedReader.readLine()) != null) {
			int begin = 0;
			int end = 2;
			while (begin <= lineString.length()) {
				if (begin + end > lineString.length()) {
					end = lineString.length() - begin;
				}
				bufferedWriter.write(lineString, begin, end);
				bufferedWriter.write(sgin);
				begin=begin+2;
				bufferedWriter.flush();
			}
			bufferedWriter.newLine();

		}

	} catch (Exception e) {
		try {
			bufferedReader.close();
			bufferedWriter.close();
		} catch (IOException e1) {				
			e1.printStackTrace();
		}			
		e.printStackTrace();
	}
}

}

5 des加密

public class For7 {
public static String sgin=“###”;
public static void main(String[] args) {
jiami(“d://test.txt”,“d://test1.txt”);
jiemi(“d://test1.txt”,“d://test2.txt”);
}

public static void jiemi(String path1,String path2) {

}

static String string = "这是一段需要加密的数据";
public static void jiami(String path1,String path2) {
	try {		
		DESKeySpec desKeySpec = new DESKeySpec("cdszgh2020".getBytes("UTF-8"));
		SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
		Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec); 
        // 加密
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
        byte[] result = cipher.doFinal(string.getBytes());
        System.out.println("jdk des encrypt:" + new String(result));
        
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
        result = cipher.doFinal(result);
        System.out.println("jdk des decrypt:" + new String(result));
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
}

}

涂99
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分支限界求最短路劲
05-26
在计算机科学领域，寻找最短路径问题是一种常见的优化问题，特别是在网络分析、图论和算法设计中占有重要地位。本文将深入探讨如何利用分支限界法（Branch and Bound）来解决这一问题，以及如何用纯C语言实现这一...
AstarPath寻找两点之间的最短路劲
12-06
A*（A-star）算法是一种在图形搜索中用于寻找从起点到终点最短路径的启发式搜索算法。它结合了Dijkstra算法的全局最优性和BFS（广度优先搜索）的效率，通过引入一个评估函数来估计从起点到目标的代价，从而更快地...
最短路径分析+路书（详细导航信息）
DuoWei1993的博客
04-22 2074
最短路径+路书
分层图解决的一些最短路问题
qq_63047764的博客
07-25 172
农产主可以指定一条从11号基站到NN号基站的路径，并指定路径上不超过KK条电缆，由电话公司免费提供升级服务。第2..P+12..P+1行第i+1i+1行包含三个整数Ai,Bi,LiAi,Bi,Li。现在，农场主希望对通信线路进行升级，其中升级第ii条电缆需要花费LiLi。特别地，11号基站是通信公司的总站，NN号基站位于一座农场中。若11号基站与NN号基站之间不存在路径，则输出−1−1。第11行三个整数N，P，KN，P，K。求至少用多少钱可以完成升级。.........
340 通信线路（单源最短路径 + 二分）
二哈
10-16 303
1. 问题描述： 在郊区有 N 座通信基站，P 条双向电缆，第 i 条电缆连接基站 Ai 和 Bi。特别地，1 号基站是通信公司的总站，N 号基站位于一座农场中。现在，农场主希望对通信线路进行升级，其中升级第 i 条电缆需要花费 Li。电话公司正在举行优惠活动。农产主可以指定一条从 1 号基站到 N 号基站的路径，并指定路径上不超过 K 条电缆，由电话公司免费提供升级服务。农场主只需要支付在该路径上剩余的电缆中，升级价格最贵的那条电缆的花费即可。求至少用多少钱可以完成升级。 输入格式 第 1 行：三个
百万年薪的算法题解决方法
yzd
05-28 76
这个问题的地址是：http://mitibar.com/superdrink.php 我只是解决了这个问题，并无入职那个公司的打算。 第一种是：遗传算法 这个问题可以抽象成数学模型是这样的： 我有一个有向图G，他有n个节点，其中任意一个节点a都有到另外n-1个节点的路径！ 例如3个节点的图可以这样解释：（图差不进去） 箭头我没画，太难了，呵呵！每个路径上有一定的费用...
数据结构 笔记：最短路劲
Qiuery的博客
12-03 232
最短路劲的概念 如果从有向图中某一顶点（起始顶点）到达另一顶点（终止顶点）的路劲不止一条，那么如何找到一条路径不止一条，那么如何找到一条路径使得此路径各边上的权值总和达到最小？ 问题的提法： -给定一个带权有向图G与起始顶点v，求从v到G中其他顶点的最短路径（每条边上都存在有意义的权值） 解决思路 -Dijkstra提出按路径长度的递增次序，逐步产生最短路径 ·首先求出长度最短的一...
图算法——求最短路径（Dijkstra算法）
热门推荐
在夜里行走的博客
11-22 8万+
图解Dijkstra算法，让你了解Dijkstra算法的每一步是怎么进行的
数据结构与算法—单源最短路径dijkstra算法
bigsai
09-15 8254
介绍 对于dijkstra算法，很多人可能感觉熟悉而又陌生，可能大部分人比较了解bfs和dfs，而对dijkstra和floyd算法可能知道大概是图论中的某个算法，但是可能不清楚其中的作用和原理，又或许，你曾经感觉它很难，那么，这个时候正适合你重新认识它。 Dijkstra能是干啥的？ Dijkstra是用来求单源最短路径的 单源什么意思？ 从一个顶点出发，Dijkstra算法只能求一个顶点...
最短路径: Dijkstra算法、Bellman-Ford算法、Floyd算法
AN_ERA的博客
09-07 1740
目录 最短路径（Shortest Path） 最短路径 – 无权图 最短路径 – 负权边 最短路径 – 负权环 最短路径算法 Dijkstra (迪杰斯特拉算法) Dijkstra –思路 Dijkstra – 执行过程 Dijkstra –代码实现 Bellman-Ford (贝尔曼-福特算法) Bellman-Ford–思路 Bellman-Ford–思考 Bellman-Ford –执行过程 Bellman-Ford –代码实现 Floyd (弗洛伊德算法...
最短路径（Dijkstra算法和Floyd算法）
weixin_44267007的博客
08-18 5万+
最短路径 ​ 在图中，不可避免要解决的一个问题就是计算两点之间的最短路径，对于图结构来说，两个点之间不一定只有一条路径，那么如何才能找出最短的那一条就是图中最短路径问题。最短路径问题在实际生活中应用十分广泛。接下来主要介绍两种较为常用的最短路径算法—DijkstraDijkstraDijkstra算法和FloydFloydFloyd算法。 文章目录最短路径迪杰斯特拉DijkstraDijkstraDijkstra算法FloydFloydFloyd算法最小生成树与最短路径的区别 ​ 首先需要对最短路径问题进行
使用3DES加密与解密实习Android端和后台的数据加密传输
林老师带你学编程
09-11 2877
这篇主要讲怎么进行加密的安全传输。通过双发所持有的秘钥进行解密，具有很高的安全性。 下面就不多说啦直接看代码。 Android端： ThreeDesUtil加密解密类： package com.ge.tool; import java.security.Key; import javax.crypto.Cipher; import javax.crypto.SecretKeyFactory
最短路径.zip_Z最短路径 迪杰特斯拉_最短路_最短路劲_最短路径
07-14
自己写的一个关于最短路劲的小程序，有图像，很直观
GA_PSO-master.zip_PSO解决_ga_pso_hybrid pso_路劲规划_路劲规划 算法
07-15
pso和ga混合算法用来解决路劲规划问题
算法：外卖调度
m0_73915763的博客
08-13 1102
有N个餐厅和M个外卖员，每个餐厅在某个时间点会产生一个外卖订单，这些订单都有产生时间、所需送达时间和优先级。外卖员在空闲时会选择最优先的订单来配送，直到所有订单都被送达。具体规则如下: 对于每个餐厅的订单，优先级高的订单优先，其次是所需送达时间最短的订单，再次是产生时间最早的订单。外卖员在空闲时会从所有餐厅的最高优先级订单中挑选一个所需送达时间最短的订单进行配送，若所需送达时间相同则选择餐厅编号最小的订单。
【LeetCode】字母异位词分组
LittleFishC的博客
08-14 84
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
看demo学算法之 循环神经网络（RNN）
最新发布
wx740851326的博客
08-15 212
今天我们来聊聊神经网络中的“记忆大师”——循环神经网络（RNN）。想象一下，你正在看电影，每一帧都连贯着前一帧的故事情节。RNN就像是这样一位观众，它能记住之前看到的内容，帮助理解当前的画面。是不是很酷？🎬。
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 502
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
最短路劲Floyd算法
08-24
Floyd算法是一种多源最短路径算法，用于计算图中任意两个顶点之间的最短路径。它通过动态规划的思想逐步更新路径的长度来计算最短路径。 Floyd算法的基本思想是通过一个中间顶点集合，逐个考察这个集合中的顶点，看...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值