剑指Offer——当当+搜狐+好未来笔试题+知识点总结_好未来校招笔试题(1)

于 2024-05-02 15:32:31 发布
阅读量155 收藏
点赞数 3
分类专栏： 程序员 文章标签： 代理模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84419493/article/details/138393116
版权

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

/**
* 动态规划求解TSP问题
* @author SHQ
*
*/
public class TSP {

private double[][] dArray; 	// 距离矩阵
private int length; 		// 距离矩阵的长度
private int lengthOfLength; // 距离矩阵长度字符串的长度
private String allzero = "";// 0组成的字符串最大值是length个(length - 1)连接起来的字符串，同样最小值是length个0连接起来
private String biggest = "";
private List<String> list = new ArrayList<String>(); // 城市流列表
private Map<String, Double> store;		// 存储中间数据
private String notExist = "不存在";
private String firnalRoad = notExist; 	// 最终的路径，即距离矩阵的列号取值
private String firnalCityFlow = ""; 	// 最终形成的城市流
private String min = notExist; 			// 最终求得的最小值
private String allFlowTime = notExist; 	// 求解所有城市流的时间
private String guihuaTime = notExist; 	// 动态规划的时间

/\*\* Creates a new instance of TwentyTwo \*/
public TSP(double[][] dArray) {
	if (this.check(dArray)) {
		this.dArray = dArray;
		this.length = dArray.length;
		this.lengthOfLength = (length - 1 + "").length();
		for (int zeroLength = 0; zeroLength < (length \* lengthOfLength);) {
			allzero += 0;
			zeroLength = allzero.length();
		}
		for (int i = this.length; i > 0; i--) {
			this.biggest += this.toLengthOfLength(i - 1);
		}
		long start = System.currentTimeMillis();
		this.allFlow();
		long end = System.currentTimeMillis();
		this.allFlowTime = end - start + "毫秒";
		start = System.currentTimeMillis();
		this.initstoreMap();
		this.guihua(this.length - 2);
		end = System.currentTimeMillis();
		this.guihuaTime = end - start + "毫秒";
	}
}

public String getFirnalRoad() {
	return this.firnalRoad;
}

public String getFirnalCityFlow() {
	if ("".equals(this.firnalCityFlow)) {
		return this.notExist;
	}
	return this.firnalCityFlow;
}

public String getMin() {
	return this.min;
}

public String getAllFlowTime() {
	return this.allFlowTime;
}

public String getGuihuaTime() {
	return this.guihuaTime;
}

// 输入距离矩阵的有效性判读
private boolean check(double[][] dArray) {
	if (dArray.length < 3) {
		System.out.println("错误信息：距离矩阵长度过小");
		return false;
	}
	for (int i = 0; i < dArray.length; i++) { // 每个double[]的长度都进行判断
		if (dArray.length != dArray[i].length) {
			// 非方阵
			System.out.println("错误信息：距离数组长度不合法");
			return false;
		}
	}
	for (int i = 0; i < dArray.length; i++) {
		if (!oneZero(dArray[i], i)) {
			System.out.println("错误信息：距离数组顺序或元素值设置不合法");
			return false;
		}
	}
	return true;
}

// 对于一个doulbe类型的数组，只有第i个元素为0的判断

private boolean oneZero(double[] dArray, int i) {
	int numOfZero = 0;
	for (double d : dArray) {
		if (d == 0.0) {
			numOfZero++;
		}
	}
	if (numOfZero == 1 && (dArray[i] == 0)) {
		return true;
	} else {
		return false;
	}
}

// 判断一个城市流是否合法

private boolean oneFlow(String str) {
	// 将一个字符串更改为一个字符链表
	List<String> listString = new ArrayList<String>();
	for (int i = 0; i < (this.length \* this.lengthOfLength);) {
		listString.add(str.substring(i, i + this.lengthOfLength));
		i += this.lengthOfLength;
	}
	// 如果有相同的元素，则false
	for (int i = 0; i < (this.length - 1); i++) {
		for (int j = i + 1; j < this.length; j++) {
			if (listString.get(i \* this.lengthOfLength).equals(
					listString.get(j \* this.lengthOfLength))) {
				return false;
			}
		}
	}
	// 如果有距离矩阵全0对角线上的元素，则false
	for (int i = 0; i < listString.size(); i++) {
		if (Integer.parseInt(listString.get(i)) == i) {
			return false;
		}
	}
	// 排除没有遍历所有城市的情况（从0点出发到达0点）
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	for (int i = 0; i < this.length;) {
		map.put(i,
				Integer.parseInt(str.substring(i, i + this.lengthOfLength)));
		i += this.lengthOfLength;
	}
	int allcity = 0;
	for (int i = 0;;) {
		i = map.get(i);
		allcity++;
		if (i == 0) {
			break;
		}
	}
	if (allcity < this.length) {
		return false;
	}
	return true;
}

// 初始化存储map

private void initstoreMap() {
	this.store = new HashMap<String, Double>();
	// 存距离矩阵最后一行可能的列号
	for (int i = 0; i < this.length - 1; i++) {
		this.store.put(this.toLengthOfLength(i),
				this.dArray[this.length - 1][i]);
	}
	// 存距离矩阵倒数两行可能的列号
	for (int i = 0; i < this.length; i++) {
		if (i == this.length - 2)
			continue;
		for (int j = 0; j < this.length - 1; j++) {
			if (i == j) {
				continue;
			}
			store.put(
					this.toLengthOfLength(i) + this.toLengthOfLength(j),
					this.dArray[this.length - 2][i]
							+ store.get(this.toLengthOfLength(j)));
		}
	}
}

// 两个相近的城市流，前length - 2 - temp个数相同，后面不同，用动态规划实现
private void guihua(int temp) {
	if (list.size() == 1) {
		this.firnalRoad = list.get(0);
		this.thePrint(list.get(0));
		this.min = this.store.get(list.get(0)) + "";
		return;
	}
	for (int i = 0; i < (list.size() - 1); i++) {
		int next = (i + 1);
		if (list.get(i)
				.substring(0, temp \* this.lengthOfLength)
				.equals(list.get(next).substring(0,
						temp \* this.lengthOfLength))) {
			double iValue = 0;
			double nextValue = 0;

			iValue = this.dArray[temp][Integer.parseInt(list.get(i)
					.substring(temp, temp + this.lengthOfLength))]
					+ store.get(list.get(i).substring(
							(temp + 1) \* this.lengthOfLength));
			nextValue = this.dArray[temp][Integer.parseInt(list.get(next)
					.substring(temp, temp + this.lengthOfLength))]
					+ store.get(list.get(next).substring(
							(temp + 1) \* this.lengthOfLength));

			this.store.put(list.get(i)
					.substring(temp \* this.lengthOfLength), iValue);
			this.store.put(
					list.get(next).substring(temp \* this.lengthOfLength),
					nextValue);

			if (iValue >= nextValue) {
				list.remove(i);
			} else {
				list.remove(next);
			}
			i--;
		}
	}
	this.guihua(temp - 1);
}

// 组成所有的城市流
private void allFlow() {
	while (!this.biggest.equals(this.allzero)) {
		this.allzero = this.addone(this.allzero);
		if (this.oneFlow(this.allzero)) {
			this.list.add(this.allzero);
		}
	}
}

// 将length进制的字符串加1操作

private String addone(String str) {
	List<String> listString = new ArrayList<String>();
	for (int i = 0; i < (this.length \* this.lengthOfLength);) {
		listString.add(str.substring(i, i + this.lengthOfLength));
		i += this.lengthOfLength;
	}
	for (int i = (length - 1); i > -1; i--) {
		int last = Integer.parseInt(listString.get(i));
		if (last == (length - 1)) {
			last = 0;
			String strLast = this.toLengthOfLength(last);
			listString.set(i, strLast);
		} else {
			last++;
			String strLast = this.toLengthOfLength(last);
			listString.set(i, strLast);
			break;
		}
	}
	String ret = "";
	for (String s : listString) {
		ret += s;
	}
	return ret;
}

// 如果一个int字符串长度不够lengthOfLength 则补足

private String toLengthOfLength(Object i) {
	String returnString = i.toString();
	while (returnString.length() < this.lengthOfLength) {
		returnString = (0 + returnString);
	}
	return returnString;
}

// 将一个字符串键值映射，并标准输出

private void thePrint(String str) {
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	for (int i = 0; i < this.length;) {
		map.put(i, Integer.parseInt(str.substring(i, i + this.lengthOfLength)));
		i += this.lengthOfLength;
	}
	String cityFlow = this.toLengthOfLength(0);
	for (int i = 0;;) {
		i = map.get(i);
		cityFlow += this.toLengthOfLength(i);
		if (i == 0) {
			break;
		}
	}
	for (int i = 0; i < this.length + 1;) {
		if (i < (this.length)) {
			this.firnalCityFlow += Integer.parseInt(cityFlow.substring(i, i	+ this.lengthOfLength)) + "->";
		} else {
			this.firnalCityFlow += Integer.parseInt(cityFlow.substring(i, i	+ this.lengthOfLength));
		}
		i += this.lengthOfLength;
	}
}

public static void main(String[] args) {
	double[][] first = {		 // 各个节点之间路径长度的二维数组
	{ 0, 2, 1, 3, 4, 5, 5, 6 },
	{ 1, 0, 4, 4, 2, 5, 5, 6 },
	{ 5, 4, 0, 2, 2, 6, 5, 6 },
	{ 5, 2, 2, 0, 3, 2, 5, 6 },
	{ 4, 2, 4, 2, 0, 3, 5, 6 },
	{ 4, 2, 4, 2, 3, 0, 5, 6 },
	{ 4, 2, 4, 2, 4, 3, 0, 6 },
	{ 4, 2, 4, 2, 8, 3, 5, 0 } };
	long start = System.currentTimeMillis();
	TSP ff = new TSP(first);
	System.out.println("路径是：" + ff.getFirnalRoad());
	System.out.println("城市顺序：" + ff.getFirnalCityFlow());
	System.out.println("最小值：" + ff.getMin());
	System.out.println("生成所有合法城市流用时：" + ff.getAllFlowTime());
	System.out.println("动态规划求解过程用时：" + ff.getGuihuaTime());
	long end = System.currentTimeMillis();
	System.out.println("总用时：" + (end - start));
}

}


![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/ba38f85d0d27c9e4e2443151eaa8155a.png)


### 三、当当编程题


![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/d71217d7be542419997715e95be9532b.png)  
 ![这里写图片描述](https://img-blog.csdnimg.cn/img_convert/def060e5cf730ea5ca7b8bf76024046b.png)


### 四、搜狐编程题


#### 4.1 袋鼠过河


#### 4.2 保留最大的数


#### 4.3 彩色宝石项链


时间限制：C/C++语言 1000MS；其他语言 3000MS  
 内存限制：C/C++语言 65536KB；其他语言 589824KB  
 题目描述：



> 
> 有一条彩色宝石项链，是由很多种不同的宝石组成的，包括红宝石，蓝宝石，钻石，翡翠，珍珠等。有一天国王把项链赏赐给了一个学者，并跟他说，你可以带走这条项链，但是王后很喜欢红宝石，蓝宝石，紫水晶，翡翠和钻石这五种，我要你从项链中截取连续的一小段还给我，这一段中必须包含所有的这五种宝石，剩下的部分你可以带走。如果无法找到则一个也无法带走。请帮助学者找出如何切分项链才能够拿到最多的宝石。
> 
> 
> 


输入



### 基础学习：

前端最基础的就是 HTML , CSS 和 JavaScript 。

##### 网页设计：HTML和CSS基础知识的学习

HTML是网页内容的载体。内容就是网页制作者放在页面上想要让用户浏览的信息，可以包含文字、图片、视频等。

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/topics/618166371)**

![](https://img-blog.csdnimg.cn/img_convert/e8ea7ea559d885d04bd318b465ea3b91.webp?x-oss-process=image/format,png)


CSS样式是表现。就像网页的外衣。比如，标题字体、颜色变化，或为标题加入背景图片、边框等。所有这些用来改变内容外观的东西称之为表现。

![](https://img-blog.csdnimg.cn/img_convert/d723e41135e5143e0718a491e4451eb9.webp?x-oss-process=image/format,png)


##### 动态交互：JavaScript基础的学习

JavaScript是用来实现网页上的特效效果。如：鼠标滑过弹出下拉菜单。或鼠标滑过表格的背景颜色改变。还有焦点新闻（新闻图片）的轮换。可以这么理解，有动画的，有交互的一般都是用JavaScript来实现的。

[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/topics/618166371)**

[外链图片转存中...(img-A1VgWUOW-1714635132994)]


CSS样式是表现。就像网页的外衣。比如，标题字体、颜色变化，或为标题加入背景图片、边框等。所有这些用来改变内容外观的东西称之为表现。

[外链图片转存中...(img-eguUz1KO-1714635132995)]


##### 动态交互：JavaScript基础的学习

JavaScript是用来实现网页上的特效效果。如：鼠标滑过弹出下拉菜单。或鼠标滑过表格的背景颜色改变。还有焦点新闻（新闻图片）的轮换。可以这么理解，有动画的，有交互的一般都是用JavaScript来实现的。

![](https://img-blog.csdnimg.cn/img_convert/bc5d189a993d334930318cdfcd5578a1.webp?x-oss-process=image/format,png)
2401_84419493
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
好未来2024Java春招笔试第二批
Give_me_a_future的博客
03-16 696
常见的 HTTP 状态码：(我就只写了这几个)状态码分类：（转自菜鸟教程）
好未来笔试题目- 输出字符串str中的连续最长的数字串
fei
03-10 226
好未来笔试题目- 输出字符串str中的连续最长的数字串 题目描述： 读入一个字符串str，输出字符串str中的连续最长的数字串 思路: 贪心思想加双指针；每次左指针left找到第一个数字字符之后，令右指针right指向下一个字符，直到right指向下一个非数字字符停止，记录此时的长度，并和上一次匹配的长度比较，如果长度大于上一次匹配的数字串，则跟新开始本次局部最长数字串的开始位置（即left的下标）和长度，令左指针的位置等于右指针，最后开始下一次匹配。 input ： abcd12345ed125
小九九学前端随记01
大空翼的博客
07-10 134
HTML、CSS、JavaScript
剑指Offer——当当+搜狐+好未来笔试题+知识点总结
热门推荐
IT全栈 华强工作室
12-05 4万+
剑指Offer——当当+搜狐+好未来笔试题+知识点总结情景回顾 时间:2016.9.21 15：00-21：00 地点:山东省网络环境智能计算技术重点实验室 事件:当当笔试、搜狐笔试、好未来笔试3场笔试中好未来相对简单点。 好未来编程题马踏棋盘(贪心算法)  马踏棋盘是经典的程序设计问题之一，主要的解决方案有两种：一种是基于深度优先搜索的方法，另一种是基于贪婪算法的方法。第一种基于深度优先搜索(DF
面试官：说说微信小程序的支付流程？
weixin_44475093的博客
10-26 3031
一、前言微信小程序为电商类小程序，提供了非常完善、优秀、安全的支付功能在小程序内可调用微信的API完成支付功能，方便、快捷场景如下图所示：用户通过分享或扫描二维码进入商户小程序，用户选择购...
微信小程序支付流程（前端）
weixin_62918410的博客
03-25 2144
微信小程序的支付只要用到官方的支付API ： wx.requestPayment(Object object)
微信小程序支付完整流程（前端）
m0_74429971的博客
10-23 4万+
微信小程序支付完整流程
leetcode答案-TargetOffer:剑指offer编程题系列+校招真题解法
06-30
牛客网剑指offer编程题系列解法 每一道题都尽可能的多写几种解法，没加注释的应该是最好解法。 除了java之外，也有其他语言的解法，为了效率，并没有把所有的解法都转换为java解法。合格的程序员应该是什么语言都能...
剑指Offer——名企面试官精讲典型编程题 C++ 面试 笔试 编程
03-12
《剑指Offer——名企面试官精讲典型编程题 C++ 面试 笔试 编程》这本书是为那些准备进入IT行业的求职者，尤其是对C++编程语言有深厚兴趣的人士量身定制的。它涵盖了大量数据结构与算法的实践题目，旨在帮助读者提升...
《剑指Offer》刷题笔记——面试题59. 滑动窗口的最大值
12-22
1、剑指解析 2、代码实现 class Solution: def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]: deque = [];result = [] # deque也可以用collection里的双端队列实现 for i in range(0, len...
offer_牛客_剑指offer_剑指Offer算法题编程代码解析汇总_
10-02
《剑指Offer：牛客网算法题编程代码解析汇总》 在编程领域，尤其是在面试准备过程中，"剑指Offer"是一本备受推崇的书籍，它集合了大量的算法题目，旨在提升程序员在解决实际问题中的能力。牛客网作为国内知名的在线...
《剑指Offer》刷题笔记——面试题06. 从尾到头打印链表
01-21
1、剑指解析： 2、代码实现： I、辅助栈 from typing import List ###### 代码主体 ###### class Solution: def reversePrint(self, head: ListNode) -> List[int]: stack = [] if head is None: return [] ...
面试之订单微信支付业务流程
丢币的小孩的博客
08-17 709
订单，微信支付
前端实现微信支付（H5，微信小程序）
Ak47a7的博客
04-17 9517
前端实现微信支付（H5，微信小程序）
24届好未来数开笔试
qq_51047851的博客
10-18 330
tmp 表统计每个部门的用户访问量。求每个部门的用户访问量Top3。2. Hive 的数据结构。tmp2 表添加伪列排序。
靠这份面试攻略，腾讯微信支付 安卓开发岗 四面上岸啦
m0_56146626的博客
06-07 220
再分享一份腾讯的内部面试题资料，需要的朋友可以扫描免费领取！！！由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要《Android面试大厂必考174题》完整文档的可以加微信即可免费领取!Android面试大厂必考174题纲要。
vuex项目中的微信支付、支付宝支付
最新发布
2401_84438160的博客
04-27 574
);});// console.log(“微信外支付”)let data={window.location.replace(url) //这里是后端返回的URL直接进行跳转即可完成微信外支付}else{Toast({});});},4.在调起支付的页面监听从其他页面返回的事件，进行一些刷新业务逻辑的实现即可，至此微信外支付已经完成。//需要的操作});
好未来笔试题-第二大的数
专心扫地
04-22 277
#include<iostream> #include<vector> #include<queue> using namespace std; int main() { int n; vector<int>tmp; //建立一个最大堆 priority_queue<int>q; ci...
《剑指Offer》精华思路总结：42道经典算法题
"《剑指offer》思路汇总---简化版的原书思路共42页，涵盖了数组、字符串、链表、树与二叉树、栈和队列、递归与循环六大主题的算法题目及解题思路，旨在帮助求职者准备面试和提升编程能力。" 这篇文档是《剑指Offer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值