DSP系统mysql数据库搭建

发表于 2018-01-09

字数统计: 550 | 阅读时长 ≈ 3

MySQL操作执行sql脚本方法： cmd执行【Mysql的bin目录】\mysql –u用户名 –p密码 –D数据库<【sql脚本文件路径全名】，示例：mysql –uroot –p123456 -D database_name < d:\test\ss.sql 进入mysql的控制台后，使用source命令执行 Mysql>source 【sql脚本文件的路径全名】或 Mysql>\. 【sql脚本文件的路径全名】，示例：source d:\test\ss.sql 或者 \. d:\test\ss.sql 从文件导入数据表LOAD DATA LOCAL I ...

阅读全文 »

【九章算法基础班】数与数组

发表于 2017-12-24 | 分类于算法，九章算法

字数统计: 17,024 | 阅读时长 ≈ 88

outline Sorted Array merge two sorted array Intersection of Two Arrays Multiply Two Arrays median of two sorted array Subarray Best Time to Buy and Sekk Stoocks I,II,III Subarrat I,II,III,IV Two pointers Two Sum,3Sum,4Sum,kSum,3Sum Closest Partition Array 排序数组Sorted ArrayMerge Sorted Array ...

阅读全文 »

【九章算法基础班】课程笔记——链表

发表于 2017-12-11 | 分类于算法，九章算法

字数统计: 5,288 | 阅读时长 ≈ 26

考点重要程度：链表 -> DFS/BFS ->DP

基础

test:

//print() 打印完整链表
ListNode node1 = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);
ListNode head = node1;
node1.next = node2;
node2.next = node3;
print(head);
//1->2->3
node1 = node2;
print(head);
//1->2->3
ListNode包括一个值和一个指针，head占4Byte(32bit)空间，head实际上是一个指针，通过head所指向的地址去找对应节点存储的值和下一个指针。
链表结构：
    [1,] ->  [2,] -> [3,]  
      ↑        ↑       ↑
   head,n1     n2     n3
   4byte     4byte   4byte
   
node1和node2都是指向节点的指针，如果令node1 = node2,那么只是node1存储的地址和node2存储的地址一样了，但是链表的机构没有改变，所以输出依然是:
1->2->3 
  
如果要改变链表的结构，需要node.next = balabala

阅读全文 »

DeepFM论文笔记

发表于 2017-12-10 | 分类于 RTB

字数统计: 332 | 阅读时长 ≈ 1

线性模型不好捕捉交叉特征，FM由于模型复杂性，通常只能捕捉到两维特征交互，NN捕获低维特征能力弱。wide&deep模型能够同时获取低维特征，但是需要低纬、高维两部分特征分开输入模型，而且wide部分的特征也是需要专门的特征工程进行的。

阅读全文 »

【九章算法基础班】二分法

发表于 2017-12-07 | 分类于算法，九章算法

字数统计: 5,543 | 阅读时长 ≈ 28

二分查找

classical Binary Search

定义

给定一个排序数组和一个元素n，返回元素n的位置

index	0	1	2	3	4	5	6	7	8
num	2	3	5	8	13	21	34	55	89

查找元素5的位置

方法

初始化:

start = 0;end = 8;mid = 4

nums[mid] = 13;start = 0;end = 4,mid = 2
nums[mid] = 5;find it!

时间复杂度

数据规模为n:
T(n) = T(n/2)+O(1)
其中O(1)为比较的时间复杂度，T(n/2)为比较之后
时间复杂度是:O(logn)

实现方式

递归：
- 优点：代码简洁
- 缺点：递归利用栈空间，递归层数过多会导致栈溢出
while循环
- 优点：占用空间小
- 缺点：代码可读性稍差，不够简洁
面试的时候用什么？

如果用递归的方式写会好理解很多，就用递归写，不然就不用递归，在工程上，递归很容易导致栈溢出。

这道题用最好用非递归的方式写，因为是很简短的

通用模板

start + 1 < end
mid = start +(end - start)/2;如果用(start + end)/2，如果start和end都很大相加就有可能溢出
A[mid] = < > 三种情况讨论
A[start] A[end]?target

public int findPosition(int[] nums, int target) {
        if (nums.length <= 0){
            return -1;
        }
        // write your code here
        int start = 0;
        int end = nums.length - 1;
        while (start + 1 < end) {
            //中值
            int mid = start + (end - start) / 2;
            //三种情况讨论
            if (nums[mid] == target) {
                end = mid;
            }
            if (nums[mid] < target) {
                start = mid;
            }
            if (nums[mid] > target) {
                end = mid;
            }
        }
        //结果
        if (nums[start] == target) {
            return start;
        }
        if (nums[end] == target) {
            return end;
        } else {
            return -1;
        }
    }

阅读全文 »

WAND算法

发表于 2017-12-07

字数统计: 56 | 阅读时长 ≈ 1

阅读全文 »

【九章算法基础班】二叉树与分治法

发表于 2017-11-29 | 分类于算法，九章算法

字数统计: 11,065 | 阅读时长 ≈ 53

数组：内存空间连续，支持下标访问，访问时间复杂度 $O(1)$

链表：内存空间不联系，不支持下表访问，访问时间复杂度 $O(n)$

1. 树形分析法求解时间复杂度：

$T(n) = T(n/2)+O(1) -> O(logn)$ $T(n) = T(n/2)+O(n) -> O(n)$ $T(n) = 2T(n/2) + O(1) -> O(n)$

T(n) = 2T(n/2) + O(1) -> O(n)
O(1)：一次拆分所需时间
 --	 			        n
  |               ↙             ↘       ················O(1)拆分所需时间
  |            n/2                n/2
log(n)      ↙       ↘          ↙       ↘	················O(2)
  |       n/4       n/4       n/4       n/4
  |      ↙  ↘      ↙  ↘     ↙  ↘      ↙  ↘	················O(4)
  |    n/8  n/8  n/8  n/8  n/8  n/8   n/8  n/8   			
  |			················				················O(n)
  | n/n	n/n	n/n		·············	n/n	n/n	n/n
 --
 O(1+2+4+....+n) = O(2n-1) = O(n)
 由此如果T(n) = 2T(n/2) + O(1)，则时间复杂度为O(n)