小菜鸟

增重

如果体重不达标（低于标准体重范围），可以从以下几个方面来改善：

增加热量摄入

• 合理安排饮食结构
  • 增加主食量：选择高能量、易消化的主食，如大米、小麦、燕麦等。可以适当增加每餐的主食分量，例如，原本每餐吃 100 克米饭，可逐渐增加到 120 - 150 克。同时，也可以将部分精细米面换成粗粮，如红薯、玉米等，它们富含碳水化合物，还能提供丰富的膳食纤维。
  • 摄入优质蛋白质：蛋白质是身体细胞的重要组成部分，对于增肌增重至关重要。像瘦肉（鸡肉、牛肉、猪肉）、鱼类（三文鱼、鳕鱼等）、蛋类、豆类（黄豆、黑豆）及奶制品（牛奶、酸奶）都是优质蛋白质的良好来源。可以每天保证摄入足够的蛋白质食物，如每天吃 1 - 2 个鸡蛋、100 - 150 克肉类等。
  • 适当增加健康脂肪摄入：选择不饱和脂肪，如橄榄油、鱼油、坚果（杏仁、核桃）中的油脂等。这些脂肪有助于身体吸收脂溶性维生素，并且能提供较高的热量。每天可以吃一小把坚果或者在烹饪中使用适量的健康油。
• 少食多餐
  • 在正常三餐之外，增加 2 - 3 次小餐，如上午和下午的加餐可以选择牛奶、酸奶、水果、全麦面包等。这样既能保证热量的持续供给，又不会给肠胃造成太大负担。例如，上午加餐可以是一杯牛奶（200 - 250 毫升）和一片全麦面包，下午加餐可以是一个苹果和一小份坚果。

进行力量训练

• 制定训练计划
  • 全身性力量训练：包括深蹲、卧推、硬拉等复合动作，这些动作可以同时锻炼多个肌群，刺激肌肉生长。刚开始训练时，可以每周进行 2 - 3 次，每次选择 2 - 3 个动作，每个动作进行 2 - 3 组，每组 8 - 12 次。例如，深蹲可以锻炼腿部、臀部肌肉，每次做 3 组，每组 10 次左右。
  • 针对薄弱部位训练：如果发现自己身体某个部位比较瘦弱，如手臂或肩膀，可以增加针对性的训练动作。比如针对手臂，可以进行哑铃弯举、杠铃弯举等动作；针对肩膀，可以进行哑铃推举、侧平举等动作。同样，每周进行 2 - 3 次训练，每次 2 - 3 组，每组 8 - 12 次。
• 逐渐增加负荷
  • 随着训练的进行，身体适应了当前的训练强度后，需要逐渐增加负荷，如增加重量、次数或者组数。但要注意避免过度训练，防止受伤。例如，在进行哑铃卧推时，最初可以使用 10 - 15 公斤的哑铃，当能够轻松完成规定组数和次数后，可以增加到 15 - 20 公斤。

保持良好的生活习惯

• 保证充足睡眠
  • 睡眠过程中身体会进行自我修复和激素调节，尤其是生长激素的分泌，对于肌肉生长和体重增加非常重要。每天应保证 7 - 9 小时的高质量睡眠。建立规律的睡眠时间，例如每天晚上 10 点半左右上床睡觉，早上 7 点左右起床，创造一个有利于睡眠的环境，保持卧室安静、黑暗和凉爽。
• 减少压力
  • 长期的高压力状态会影响食欲和身体的代谢功能。可以通过各种方式来缓解压力，如冥想、瑜伽、深呼吸等。每天花 10 - 15 分钟进行简单的冥想练习，找一个安静舒适的地方坐下或躺下，闭上眼睛，专注于自己的呼吸，排除杂念，这有助于放松身心，改善身体的整体状态。

RTB实时竞价

在RTB场景下，最优出价算法会受到计费方式的影响。

常见的计费方式有两种：

• 二价计费拍卖（SPA）

  二价计费拍卖下，流量方会根据出价对所有参竞广告排序，出价最高的广告获得曝光机会，按第二高的出价计费。

• 一价计费拍卖（FPA）

  而在一价计费拍卖下，按照最高出价来计费。

理想二价环境下，由于实际支付的价格和出价无关，DSP的最佳策略是直接使用真实出价。但一价拍卖下，真实出价并不是DSP的最佳选择。假设DSP的真实出价是X，而外部最高出价是Y，其最优策略是将出价略高于Y，这样既能确保赢得竞标，又不会支付过高的费用。

哈夫曼树

霍夫曼树也叫哈夫曼树，也称为最优二叉树，是一种带权路径最短的二叉树。在信息检索时很常用。

概念

• 节点之间的路径长度：从一个节点到另一个节点之间的分支数量称为两个节点之间的路径长度
• 树的路径长度：从根节点到树中每一个节点的路径长度之和
• 节点的带权路径长度：从该节点到根节点之间的路径长度与节点上权的乘积
• 树的带权路径：树中所有叶子节点的带权路径长度之和

对于n个叶子节点哈夫曼树来说，一共需要2*n-1个节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

public class HuffmanTree<E> {

    static class Node<E> {
        E data;
        double weight;
        Node<E> left;
        Node<E> right;

        public Node(E data, double weight) {
            this.data = data;
            this.weight = weight;
        }

        @Override
        public String toString() {
            return new StringJoiner(", ", Node.class.getSimpleName() + "[", "]")
                    .add("data=" + data)
                    .add("weight=" + weight)
//                    .add("left=" + left)
//                    .add("right=" + right)
                    .toString();
        }
    }

    public static void main(String[] args) {
        List<Node<String>> nodes = new ArrayList<>();
        nodes.add(new Node<>("A", 40));
        nodes.add(new Node<>("B", 8));
        nodes.add(new Node<>("C", 10));
        nodes.add(new Node<>("D", 30));
        nodes.add(new Node<>("E", 10));
        nodes.add(new Node<>("F", 2));

        Node<String> root = createTree(nodes);

        System.out.println(breadthFirst(root));

    }

    private static <E> List<Node<E>> breadthFirst(Node root) {
        Queue<Node<E>> queue = new ArrayDeque<>();

        List<Node<E>> result = new ArrayList<>();

        if (root != null) {
            queue.add(root);

            while (!queue.isEmpty()) {
                Node<E> node = queue.poll();
                result.add(node);

                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }

        return result;
    }

    private static <E> Node<E> createTree(List<Node<E>> nodes) {
        while (nodes.size() > 1) {
            nodes.sort(Comparator.comparingDouble(o -> -o.weight));

            Node<E> left = nodes.get(nodes.size() - 1);
            Node<E> right = nodes.get(nodes.size() - 2);
            Node<E> parent = new Node<E>(null, left.weight + right.weight);
            parent.left = left;
            parent.right = right;
            nodes.remove(nodes.size() - 1);
            nodes.remove(nodes.size() - 1);
            nodes.add(parent);
        }
        return nodes.get(0);
    }
}

结果为

1

[Node[data=null, weight=100.0], Node[data=A, weight=40.0], Node[data=null, weight=60.0], Node[data=null, weight=30.0], Node[data=D, weight=30.0], Node[data=C, weight=10.0], Node[data=null, weight=20.0], Node[data=null, weight=10.0], Node[data=E, weight=10.0], Node[data=F, weight=2.0], Node[data=B, weight=8.0]]

哈夫曼编码

使用哈夫曼树可以解决报文编码问题，相当于进行了压缩。如对字符串”abcdabcaba”进行编码，使用频率作为权值，a、b、c、d的权值分别为4、3、2、1。从哈夫曼树根节点开始，对左子树分配代码0，对右子树分配代码1，得到的哈夫曼树为

然后将字符串”abcdabcaba”按照该二进制码生成为0101101110101100100，仅为19个字符

循环队列

用数组实现队列时，如果不移动，随着数组的不断读写，会出现假满队列的情况。即尾数组已满，但头数组还是空的。循环队列解决了这个问题，在逻辑上把数组的头尾相连，形成循环队列，当数组尾满的时候，要判断数组头是否为空，不为空继续存放数据。

判断循环队列中的存储情况

• front == tail时队列为空

• (tail + 1) % capacity == front表示队列已满

  浪费了一个空间，tail没有放数据

优点

• 可以有效的利用资源

缺点

• 由于入队时尾指针向前追赶头指针，出队时头指针向前追赶尾指针，造成队空或队满时头尾指针均相等。无法通过front==rear来判断队列是空还是满

广播域和冲突域

路由器是用于连接多个逻辑上分开的网络，路由器的每个端口所连接的网络都独自构成一个广播域。

集线器内部，各接口都是通过背板总线连接在一起的，在逻辑上构成一个共享的总线，集线器和所有接口的主机共同构成了一个冲突域。

交换机上每个接口都是自己的一个冲突域。