“人造太阳”计划

// 有关学生信息的头文件student.h代码如下 #include #include using namespace std; struct Student // 表示学生信息的结构体 { string id; // 学号 string name; // 姓名 int grade; // 年级 int cls; // 班级 Student(){} Student( string id, string n, int g, int c ) // 构造函数 : id( id ), name( n ), grade( g ), cls( c ) { } friend istream & operator >> ( istream &, Student & ); // 友元输入函数 friend ostream & operator << ( ostream &, const Student &);// 友元输出函数 }; istream & operator >> ( istream &is, Student &stu ) // 输入函数 { is >> stu.id; if( stu.id == "-1" ) // 如果输入学号为-1，则表示结束输入 { is.setstate( ios_base::failbit ); // 设置输入流状态 return is; // 返回 }

最近班里开始玩24点了。起因是一个在计算器上两人比赛24点的程序，但计算器判断一组数据是否有解需要15秒，于是这个程序就没有判定有解这一功能。 这么慢的速度我当然看不下去，但去优化那个BASIC程序是不可能的，我就开始写自己的24点程序。正好之前的算法课中递归一章提到过24点，我就理所当然地用开始写递归求解算法。 第一个版本是一个运行在PC上的非常复杂的C++程序，用上了十多个头文件。由于它太烂了，我把它注释掉以后又删掉了。这个程序最后算出1820组数据中有1362组有解数据，与网上查到的数字是一致的，不过算得很慢，要二十几秒。 这个时候我的想法还是单片机上的程序通过标准库随机数函数产生数据然后跑一遍求解算法。于是我就把这个程序修改了一下，标准库容器换成数组替换掉了，排序就随便写了个冒泡。PC上所有数据遍历一遍需要十几秒。 1 #include <iostream> 2 #include <cstdint> 3 4 using Integer = std::uint16_t; 5 6 template <typename T> 7 inline void swap(T& lhs, T& rhs) 8 { 9 auto temp = lhs; 10 lhs = rhs; 11 rhs = temp; 12 } 13 14 template <typename I> 15 inline

选择排序 （Selection sort）是一种简单直观的 排序算法 。它首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 也就是：n个数从左至右，索引从0开始到n-1，两两依次比较，记录大值索引，此轮所有数比较完毕，将大数和索引0数交换，如果大数就是索引1，不交换。第二轮，从1开始比较，找到最大值，将它和索引1位置交换，如果它就在索引1位置则不交换。依次类推，每次左边都会固定下一个大数。 以列表 [8, 5, 2, 6, 9, 3, 1, 4, 0, 7] 为例。 第一次从列表 [8, 5, 2, 6, 9, 3, 1, 4, 0, 7] 中找到最小的数 0，放到数组的最前面（与第一个元素进行交换）： 交换后： 然后 在剩余的序列中 [5, 2, 6, 9, 3, 1, 4, 8, 7] 中找到最小的数 1，与该序列的第一个个元素进行位置交换： 交换后： 再 在剩余的序列中 [2, 6, 9, 3, 5, 4, 8, 7] 中找到最小的数 2，与该序列的第一个个元素进行位置交换（实际上不需要交换）： 重 复上述过程，直到最后一个元素就完成了排序。 示例动图如下： 代码实现如下： lst = [17, 23, 20, 14, 12, 25, 1, 20,

#int#str#tuple#list#dict#bool#set# print(dir(int))#告诉我所拥有的方法# print([1].__add__([2]))# print(dir(""))# print(dir(()))# print(dir([]))# print(dir(bool))# print(dir(range(10)))#只要可以for循环就可以迭代# print(dir([].__iter__()))#一个列表执行了__iter__返回值就是一个迭代器# print(set(dir([].__iter__()))-set(dir([])))# # print([1,2,3].__iter__().__length_hint__())#元素个数# list=[1,2,3]# Iter=list.__iter__()# print(Iter.__iter__().__next__())#迭代器--》通过__next__在迭代器中一个一个取值# print(Iter.__iter__().__next__())#只要是含有—__iter__方法的都是可迭代的# #只要含有__iter__就是可迭代的-------可迭代协议# #可迭代协议：只要含有__next__和_iter__方法的就是迭代器# print("__iter__"in dir([])._

redis源码分析3---结构体---字典 字典，简单来说就是一种用于保存键值对的抽象数据结构； 注意，字典中每个键都是独一无二的；在redis中，内部的redis的数据库就是使用字典作为底层实现的； 1 字典的实现 在redis中，字典是使用哈希表作为底层实现的，一个hash表里面可以有多个hash表节点，而每个hash表节点就保存了字典中的一个键值对； hash表定义 table属性是一个数组，数组中的每个元素都是一个指向dictEntry结构的指针，每个dictEntry结构保存着一个键值对； 一个空的hash表： hash表节点 key保存键值对中的键，v为值，union表示三个钟选择一个，next是指向另一个hash表节点的指针，这个指针可以将多个hash值相同的键值对连接在一起，以此来解决冲突的问题； 比如 字典结构 总的来说，没有rehash的字节结构图如下 2 hash算法 当要将一个新的键值对添加到字典里面时，程序需要先根据键值对的键计算出hash值和索引值，然后再根据索引值，将包含新建支队的hash表节点放到哈市表数组的制定索引上面。 3 解决冲突 在hash表中不可避免的会出现冲突，当有两个或者两个以上的键被分配到了hash表数组的同一个索引上面时，就说发生了冲突； 在redis中使用链地址法来解决键冲突；就是我们在前面的结构中定义的next指针实现的； 4

redis源码分析2---结构体---链表 因为redis包含大量的键值对，redis中列表键的底层实现之一就是链表；当一个链表键包含了数量比较多的 元素，又或者列表中包含的元素都是比较长的字符串时，redis就会使用链表作为底层实现； 另外链表做外数据结构中最常使用的结构，如何高效的实现和值得我们学习；我之前在项目中大量使用了链表 但是感觉总是写的不大好；redis都是大神们写出来的，值得好好学学！ redis源码分析1中讲的SDS部分结构：先总说SDS的实现，再分析源代码，这种结构将贯穿整个redis源码分析过程； 希望这样能方便大家理解。 1 为什么使用链表和链表定义。 链表提供了高效的节点重排能力，以及顺序性的节点访问方式，并且可以通过增删节点来灵活的调整链表的长度。底层列表键的实现方式之一就是链表。 节点定义如下 是一个双端链表 链表的结构定义如下 dup函数用于复制链表节点所保存的值 free函数用于释放链表节点所保存的值 match函数则用于对比链表节点所保存的值和另一个输入值是否相等； 综合看起来，redis中的链表结构如下：我们以一个list结构和三个listnode结构组成的链表为例。 2 链表的API 3 源代码分析 3.1 迭代器 为了便于访问，在adlist.h中定义了双端链表迭代器，方便访问整个链表； 3.2 直接通过属性获得的函数具体实现办法 3.3

可以被for循环的：列表，元组，字符串，range()，enumerate()。 print(dir([])&dir('')) # iterable __iter__（） 用迭代器方便，节省空间（不会把一个程序全部读出，而是一句一句随着循环生成） __next__() l = [1,2] iterator = l.__iter__() while 1: print(iterator.__next__()) 来源： https://www.cnblogs.com/shuoran/p/11649075.html

传送门 介是你没有体验过的 \(chuan\) 新做法。 暴力点分治算出每个点作为中心时的答案。 对于路径 \(c\rightarrow u\rightarrow c\rightarrow v\rightarrow c\) 的长度除以 \(2\) ，我们可以看做 \(dis(u,v)+c\) 到路径 \((u,v)\) 的距离乘 \(2\) 。 把路径分成两类： 经过分治中心的： 对于这种路径， \(dfs\) 一遍树，当脱离了某条路径时，比如走边 \((2,4)\) 或 \((2,5)\) ，开始计算该路径的贡献。假设走边 \((x,y)\) 脱离了该路径，则 \(y\) 子树内每个点 \(i\) 都会有 \(dis(i,x)\times 2+dis(u,v)\) 的贡献。 具体实现：给每条边维护一个权值 \(V\) ，对每条路径上的边的 \(V\) 对 \(dis(u,v)\) 取 \(\max\) 。算出每个点每条出边 \(V\) 的最大值和次大值。 \(dfs\) 时维护当前最大贡献 \(now\) ，对每个点，等于该点最大值的边选次小值更新 \(now\) ，否则选最大值，累加边权乘 \(2\) 即可。 这样会发现从根节点开始 \(dfs\) 时会出现这种情况： 此时，红色路径和绿色路径为最大和次大。 由于一条路径可能会占据根节点的两条出边，维护最大值和次大值就出 \

import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data #载入数据集 mnist = input_data.read_data_sets("MNIST_data",one_hot=True) #每个批次的大小 batch_size = 64 #计算一共有多少个批次 n_batch = mnist.train.num_examples // batch_size #定义两个placeholder x = tf.placeholder(tf.float32,[None,784]) y = tf.placeholder(tf.float32,[None,10]) #创建一个简单的神经网络 W = tf.Variable(tf.zeros([784,10])) b = tf.Variable(tf.zeros([10])) prediction = tf.nn.softmax(tf.matmul(x,W)+b) #交叉熵代价函数 # loss = tf.losses.softmax_cross_entropy(y,prediction) loss = tf.losses.mean_squared_error(y,prediction) #使用梯度下降法 # train_step =

import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data #载入数据集 mnist = input_data.read_data_sets("MNIST_data",one_hot=True) #每个批次的大小 batch_size = 64 #计算一共有多少个批次 n_batch = mnist.train.num_examples // batch_size #定义两个placeholder x = tf.placeholder(tf.float32,[None,784]) y = tf.placeholder(tf.float32,[None,10]) keep_prob=tf.placeholder(tf.float32) # 784-1000-500-10 #创建一个简单的神经网络 W1 = tf.Variable(tf.truncated_normal([784,1000],stddev=0.1)) b1 = tf.Variable(tf.zeros([1000])+0.1) L1 = tf.nn.tanh(tf.matmul(x,W1)+b1) L1_drop = tf.nn.dropout(L1,keep_prob) W2 = tf.Variable(tf