灯的个人博客

forever young,forever weeping.

0%

发表于 更新于 分类于

一个情绪崩溃的晚上

茫然

有些彷徨

不知道该怎么办

忍不住哭啊。

哭啊

嗯，又没忍住。。

出去走走吧

所以生命啊，它苦涩如歌

发表于 更新于 分类于

感觉有些烦躁，知道原因是什么

但是想不明白，我应该怎么做。

过去的经历，不能够给我带来抉择的办法

没办法静下心来思考

这对我很重要吗？ 没有

那我为什么还在纠结这件事？ 不甘心吗？不是，会失去一些然我觉得快乐的事情。

是或者不是带来的后果是什么？ 做或者不做，没太多区别。

那就不做

这就是别人觉着我无趣的原因？

患得患失，思绪太重。

本是一件小事

不应该费心思

否掉

干

发表于 更新于

生日快乐！

真快呀，转眼三十了。依稀记得18岁生日的场景，好像也没啥感觉，不，还是有点emo，期待总是不可靠的，虽然期望已经很低了。

不要抱怨，没有意义。

努力、奋斗，做最好的自己。

永远年轻，永远热泪盈眶。

Best wish for me.

发表于 更新于

emmm，这次尝试用不那么杂乱的方式去记录。

遇到一个小姑娘，人挺好，脾气也挺大，不太清楚什么原因，我挺喜欢跟她混在一起。

她是一个什么样子的人？

  • 第一反应是奇怪，很多想法跟我差距蛮大的，有些东西我甚至难以理解，是不是年龄差距大，有代沟了。
  • 脾气，不太好，应该生过好多次气，大部分都是打哈哈就过去了。不过有一次，我也很生气，一个月互相都没联系。
  • 怕冷场，努力的说话，就是为了场面不那么尴尬。可能这对她来说，是一个不太想回忆的场景？
  • 可能是一个内向的人吧，我们俩人格测试的结果差不多，她比我严重点。纠结、内耗、讨好型、I还是E型来着，记不清楚了。。
  • 喜欢唱歌，唱的也好听，上次晚上吃完饭，一起散步，路灯下，桂花旁，两个人，她唱着歌，我在她身边晃悠的走着。我很喜欢这种感觉，内心有一丝悸动。
  • emmm，不知道算不算，跟她在一起会感到快乐。

有想过追她吗

  • 想过，但是每次都放弃了，很多原因
  • 我现在还没有结束，哪怕已经是这样子了，依然会有负罪感
  • 另外一个是自卑吧，年龄差距大，她也很受人喜欢，感觉我不太配
  • 另外的一些性格、尿性。感觉也不太适合。
  • 嗯，把上面这些写下来，感觉确实不应该追。
  • 总体来说，喜欢跟她在一起，但是种种原因又导致，不适合在一起。

她跟你的关系

  • 她对我应该有些好感，类似大哥哥那种？或者大叔？我也是第一次遇到，很新奇的感觉
  • 不知道是不是喜欢，感觉像，又感觉不像。。。有人说过，当你有这种感觉的时候，那就不是。

你的打算

维持现状吧，没有太多的想法，不要越界，享受现在拥有的，这对我来说已经够了。

随便写写

感觉我自己是有点问题，太少与异性打交道了，导致稍微有一些好感，就会胡思乱想。

需要调整一下这种心态，嗨，屌丝的命。。。

挺羡慕朋友的风格，不管行不行，先去试试，万一成了呢

考虑的太多，导致我不太愿意去改变，不想接受失败的后果，好吧，好像也没那么难以接受。。。性格使然吧

就这。

发表于 更新于 分类于

给一个单向关系图，实现广度优先算法

题解

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
use std::collections::HashMap;
use std::collections::HashSet;

fn search_m<'a>(hashmap: HashMap<&str, Vec<&'a str>>) -> Option<&'a str> {
    let mut queue: Vec<&str> = Vec::new();
    let mut check_list = HashSet::new();
    if let Some(first) = hashmap.get("you") {
        for ele in first {
            queue.push(ele);
        }
    }
    while queue.len() > 0 {
        let c = queue.remove(0);
        if check_list.contains(c) {
            continue;
        }
        check_list.insert(c);
        if c.ends_with("m") {
            return Some(c);
        }
        if let Some(eles) = hashmap.get(c) {
            for ele in eles {
                queue.push(ele)
            }
        }
    }
    None
}

fn main() {
    let mut hashmap = HashMap::new();
    hashmap.insert("you", vec!["alice", "bob", "claire"]);
    hashmap.insert("bob", vec!["anuj", "peggy"]);
    hashmap.insert("alice", vec!["peggy"]);
    hashmap.insert("claire", vec!["you", "thom", "jonny"]);
    hashmap.insert("anuj", vec![]);
    hashmap.insert("peggy", vec![]);
    hashmap.insert("thom", vec![]);
    hashmap.insert("jonny", vec![]);

    let v = search_m(hashmap);
    match v {
        Some(i) => {
            println!("find mongoose! name {:?}", i);
        }
        None => {
            println!("not find mongoose");
        }
    }
}

思路

创建一个队列，把离自己最近的一层放在队列内
队列出队，检查当前元素是否符合要求，符合终止查找
不符合，把该元素的子集放入队列
这样子，只要队列不为空，就能把所有的内容检查一遍，且依照离原点最近的距离检查。

发表于 更新于 分类于

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn q_srot(arr: &Vec<i32>) -> Vec<i32> {
    if arr.len() < 2 {
        return arr.clone();
    }
    let base = arr[0];
    let small: Vec<i32> = arr.into_iter().filter(|x| *x < &base).map(|x| *x).collect();
    let bigger: Vec<i32> = arr.iter().filter(|x| *x > &base).map(|x| *x).collect();
    let result: Vec<i32> = q_srot(&small)
        .into_iter()
        .chain(vec![base])
        .chain(q_srot(&bigger))
        .collect();
    return result;
}

理解思路

分治，就是把问题不断的分解，这个问题的最小解就是问题的答案。不是所有的问题都可以使用分治

递归是实现分治的方案

递归实现的两个重要条件

  • 基准条件，满足此条件相当于找到最小解，可以结束递归
  • 递归条件，如何递归能得到结果

草，写这个东西是真的很困难。

还是需要在理解一下分治

发表于 更新于 分类于

重要的两点

  • 如何找出基线条件
  • 如何缩小计算规模

示例

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
/**
 * 计算元素的和
 */
function sum(arr: number[]) {
  if (arr.length === 0) {
    return 0;
  }
  if (arr.length === 1) {
    return arr[0];
  }
  let [c, ...rest] = arr;
  return c + sum(rest);
}

let a =  sum([2, 4, 6]);
console.log(a);

/**
 * 计算元素的长度
 */
function ArrayLength(arr: number[]) {
  if (arr.length === 0) {
    return 0;
  }
  let [i, ...rest] = arr;
  return 1 + ArrayLength(rest);
}

let a = ArrayLength([2, 4, 6]);
console.log(a);

/**
 * 找出元素中的最大值
 */
function maxNumber(arr: number[]) {
  if (arr.length === 0) {
    return -Infinity;
  }
  let [i, ...rest] = arr;
  let max = maxNumber(rest);
  return i > max ? i : max;
}

let a = maxNumber([-1]);
console.log(a);


/**
 * 二分查找，分治方法
 */
function midSearch(arr: number[], search: number) {
  if (arr.length === 0) {
    return -1;
  }
  if (arr[0] === search) {
    return arr[0];
  }
  let mid = (arr.length - 1) / 2;
  if (arr[mid] > search) {
    return midSearch(arr.slice(0, mid), search);
  } else {
    return midSearch(arr.slice(mid, arr.length), search);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 分治，二分查找，Rust版本
fn mid_search(arr: Vec<i32>, search: i32) -> i32 {
    if arr.len() == 0 {
        return -1;
    }
    if arr[0] == search {
        return arr[0];
    }
    let mid = (arr.len() - 1) / 2;
    if arr[mid] > search {
        return mid_search(arr[0..mid].to_vec(), search);
    } else {
        return mid_search(arr[mid..arr.len()].to_vec(), search);
    }
}

发表于 更新于 分类于

题目

写一个选择排序

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
fn selection_sort(arr: Vec<i32>) -> Vec<i32> {
    let mut min = std::i32::MIN;
    let mut result = vec![];
    for _i in &arr {
        let c_min = find_small(&arr, min);
        min = c_min;
        result.push(c_min);
    }
    result
}
fn find_small(arr: &Vec<i32>, min: i32) -> i32 {
    let mut c_min = std::i32::MAX;
    for i in arr {
        if *i <= min {
            continue;
        }
        if *i < c_min {
            c_min = *i;
        }
    }
    c_min
}

发表于 更新于 分类于

题目

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); –> 返回 -3.
minStack.pop();
minStack.top(); –> 返回 0.
minStack.min(); –> 返回 -2.

题解

个人

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
use std::{f32::MIN, vec};

struct MinStack {
    stack_a: Vec<i32>,
    stack_b: Vec<i32>,
}

/**
 * `&self` means the method takes an immutable reference.
 * If you need a mutable reference, change it to `&mut self` instead.
 */
impl MinStack {
    /** initialize your data structure here. */
    fn new() -> Self {
        return MinStack {
            stack_a: vec![],
            stack_b: vec![],
        };
    }

    fn push(&mut self, x: i32) {
        self.stack_a.push(x);
        if self.stack_b.len() == 0 {
            self.stack_b.push(x);
        } else if self.min() >= x {
            self.stack_b.push(x);
        } else {
            self.stack_b.push(self.min());
        }
    }

    fn pop(&mut self) {
        self.stack_a.pop();
        self.stack_b.pop();
    }

    fn top(&self) -> i32 {
        let top: i32 = self.stack_a.last().unwrap().clone();
        top
    }

    fn min(&self) -> i32 {
        let min: i32 = self.stack_b.last().unwrap().clone();
        min
    }
}

思路

  • emmm，没思路，对栈不熟悉，看了代码才知道应该用两个栈来存储数据。
  • 第一个栈正常存数据，第二个栈存数据的最小值，一一对应的

来源