技术积累 U3D

UNITY_LEARN/2018-06-17

Today, I followed the tutorial online, and finished the rounded mesh.

Some lessons learnt.

  1. Setting vertices to the mesh means transfer from the RAM of CPU to the RAM of GPU. Though C# treat variables as reference, but it’s neccessary to assign the vertices to the mesh after every edit process.
法国生活

第一篇

终于开始学着写博客了

为了能将每天在异域的风情记录下来，逼着自己开了一个博客，学习了基于github创建博客、基于Hexo做框架、学习markdown的语法，然后为了上传图片又学习了怎么用七牛的云存储，现在万事俱备，就等我每天出去逛逛或者学习、工作并将这些记录下来吧。All free ^_^。

之后再有空时再看看怎么把ejs等等，看看怎么把这个模板完善一下。

第一天的琐事记录

说是第一天，其实是第二天了。13号下午到的Aix，中间飞机晚点改签到下午3点的航班。刚出飞机时感觉还行，阳光海滨，蓝天绿水。一张照片远不能表现出来这里的风景阿，终于出飞机了，得好好吸收一下这里的新鲜空气。
终于下飞机了

这里的第一天其实是14号了，也是法国巴士底日放假的第二天，满街的店都关了不少，即便如此，游客仍然熙熙攘攘好不热闹。
我现在住的地方在Aix的市政广场旁边，虽然有900欧，但是比酒店要便宜起码一半。略奢侈，但是比之前倪木一在马村也仅贵了200欧每月。
下图中右边的门就是我现在住处的大门了，据房东讲这建筑有一百年的历史了，里面的翻新就是刷刷墙，重新装修了厨房和浴室。这里墙有小半米厚，据说冬天时一点也不冷呢。现在夏天每天房子会被晒半天，但是屋内仍然是阴凉的，相比之下国内的商品房可能还达不到这样的质量和用料水准吧。

我的门

老旧的楼梯，森森的一下子就想到各种欧美电影里的场景。
楼梯

吃饭

早饭忘记拍了，第一天时差倒得很痛苦,由于是国庆日，晚上这里直到半夜2点才安静下去。早上4点多我就睡不着了，直接醒来去煮了方便面吃了起来。
吃完我得赶紧出门找吃的了，新鲜的蔬菜、水果、肉、米。但是转了半天，只买到了我熟悉的胡萝卜、西红柿、鸡蛋、樱桃。

面对不多的食材，我这食神附体也做不出山珍海味阿。
我先吃点樱桃平复一下心情。

樱桃

之后我拿出平生所学，精心烹饪一道美味：

烹饪

嗯，我的中饭就是这样了，挺好。

第一天的早饭

一点点探索

吃完饭后，之后我就开始小小探索了一下小城，目标还是希望能买到米和肉。路上已经遇到一家肉店了，但是米，riz，到底在哪呢。我就不停地走啊，看啊，小镇还是有不少有意思的地方的。
小镇
小镇

今天就到这里，明天见啦。

技术积累

身在法国凌晨起不来只能之后慢慢做题解馋的leetcode竞赛

leetcode上写代码最激动人心的一刻应该是提交后看到一个绿色的accept吧，啊哈哈。

这次的4题难度不小，以我的水平解出四题已经超过2小时了~~。

  1. 第一题是送分题，不说了, 虽然是用python写的，但完全是C++的样子，代码如下：
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
class Solution(object):
    def repeatedStringMatch(self, A, B):
        """
        :type A: str
        :type B: str
        :rtype: int
        """
        ret = 0
        #if B is substring of A
        if A.find(B) >=0:
            return 1
        #if a is substring of b
        elif B.find(A) >=0:
            tmpi = B.find(A)
            ret = 0
            if tmpi>0:
                ret += 1
                if B[:tmpi] != A[-tmpi:]:
                    return -1
            tr = (len(B)-tmpi)%len(A)
            tc = int((len(B)-tmpi)/len(A))
            #print("tr{} tc{}".format(tr,tc))
            ret += tc
            for i in range(tc):
                if B[tmpi+i*len(A):tmpi+i*len(A)+len(A)] != A:
                    return -1
            if tr > 0:
                ret += 1
                #print(B[-tr:])
                if A.find(B[-tr:]) != 0:
                    return -1
            return ret
        #if a is not substring of b
        elif len(B)<len(A)*2:
            #find the begin part
            start = max(1,len(B)-len(A)+1)
            #print(start)
            for i in range(start,len(B)):
                if A[-i:] == B[:i] and A[:len(B)-i] == B[i:]:
                    return 2
        return -1
  1. 第二题主要的思路是最长的长度就是一个节点左边最长的同值链长度加上右边最长的同值链长度，使用动态规划算法深度优先递归求得各节点向下最长的长度，然后供上层节点调用即可。
    这里，用了lendown map来缓存子节点的最长向下长度。
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
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
#include <map>
using namespace std;

class Solution {
public:
    map<TreeNode *,int> lendown;
    map<int, int> maxlen;
    
    int longestDown(TreeNode *node){
        if(lendown.find(node) != lendown.end())
            return lendown[node];
        int lenl = 0;
        int lenr = 0;
        if(node->right && node->right->val == node->val){
            lenr = 1 + longestDown(node->right);
        }
        if(node->left && node->left->val == node->val){
            lenl = 1+longestDown(node->left);
        }
        if(maxlen.find(node->val)==maxlen.end())
            maxlen[node->val]=0;
        maxlen[node->val]=max(maxlen[node->val],lenl+lenr);
        lendown[node] = max(lenl,lenr);
        return lendown[node];
    }
        
    int longestUnivaluePath(TreeNode* root) {
        vector<TreeNode *> q;
        if(root)
            q.push_back(root);
        int ret = 0;
        while(q.size()>0){
            TreeNode *node = q.back();
            q.pop_back();
            longestDown(node);
            ret = max(maxlen[node->val],ret);
            if(node->right)
                q.push_back(node->right);
            if(node->left)
                q.push_back(node->left);
        }
        return ret;
    }
};
  1. 第三题一开始看到概率，小数点我就头疼了。但是其实这题还是动态规划的题。设f(i,j,k)为棋盘上第（i,j）格子k步内留在棋盘上的概率。则设k步后的概率为8个方向各走一步后，再走k-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
class Solution {
public:
    double *dp;
    int myN;
    int myK;
    int mydpWidth;
    
    double OutP(int i,int j, int k){
        if(dp[i*mydpWidth+j*(myK+1)+k]>=0.0)
            return dp[i*mydpWidth+j*(myK+1)+k];
        int ni,nj;
        double oc = 0.0;
        static int step[8][2] = {{-2,-1},{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2}};
        for(int idx=0;idx<8;++idx)
        {
            ni=i+step[idx][0];
            nj=j+step[idx][1];
            if(ni>=myN || nj >=myN || ni<0 || nj<0){
                oc += 1.0;
            }
            else 
                oc += OutP(ni,nj, k-1);
        }

        dp[i*mydpWidth+j*(myK+1)+k] = oc/8.0;
        return dp[i*mydpWidth+j*(myK+1)+k];
    }
    
    double knightProbability(int N, int K, int r, int c) {
        dp = new double[N*N*(K+1)];  //possibility of i,j th cell go out by k steps  
        for(int i=0;i<N*N*(K+1);++i)
            dp[i] = -1.0;
        for(int i=0;i<N*N;++i)
            dp[i*(K+1)] = 0.0;
        myN = N;
        myK = K;
        mydpWidth = N*(K+1);
        return 1-OutP(r,c,K);
    }
};
  1. 第4题咋一看头疼啊，其实头疼就是因为人脑算不过来啊，但是电脑可以让他记啊，分而治之，动态规划。又是动态规划。
    可恨啊，写代码手生了，写写改改就过去一小时了。
    要点有2个：1. 当前位置向后k个值相加的结果存到一个单独的数组中。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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class Solution {
public:
	vector<int> sumk;
	vector<int> dp2;
	vector<int> dp1;
	int k;

	int maxSum(int start) {
		if (dp1[start] >= 0) {
			return dp1[start];
		}
		int tmp = sumk[start];
		int maxnow = sumk[maxSum(start + 1)];
		if (maxnow > tmp)
			dp1[start] = dp1[start + 1];
		else
			dp1[start] = start;
		return dp1[start];
	}

	int maxSum2(int start) {
		if (dp2[start] >= 0)
			return dp2[start];
		int maxpost = sumk[maxSum2(start + 1)] + sumk[maxSum(dp2[start+1]+k)];
		int maxnow = sumk[start] + sumk[maxSum(start + k)];
		if(maxnow >= maxpost)
			dp2[start] = start;
		else
			dp2[start] = dp2[start + 1];
		return dp2[start];
	}

	vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
		sumk.resize(nums.size() - k + 1);
		sumk[0] = 0;
		this->k = k;
		for (int i = 0; i<k; ++i) {
			sumk[0] += nums[i];
		}
		for (int i = 1; i<nums.size() - k + 1; ++i) {
			sumk[i] = sumk[i - 1] - nums[i - 1] + nums[i + k - 1];
			//cout<<i<<" "<<sumk[i]<<endl;
		}
		dp2.resize(sumk.size());
		dp1.resize(sumk.size());
		for (int i = 0; i<sumk.size(); ++i) {
			dp1[i] = -1;
			dp2[i] = -1;
		}
		dp1[sumk.size() - 1] = sumk.size() - 1;
		dp2[sumk.size() - 1 - k] = sumk.size() - 1 - k;
		//iteratively check
		vector<int> ret;
		ret.resize(3);
		int maxsum = 0;
		for (int i = nums.size() - k * 3; i >= 0; --i) {
			int tmp = sumk[i] + sumk[maxSum2(i + k)] + sumk[maxSum(maxSum2(i + k) + k)];
			if (tmp>=maxsum)
			{
				ret[0] = i;
				ret[1] = maxSum2(i + k);
				ret[2] = maxSum(maxSum2(i + k) + k);
				maxsum = tmp;
			}
		}
		return ret;
	}
};
法国生活

2017-10-01

斯洛文尼亚感觉是一个很难再去的地方了。
这里是布莱德，从斯洛文尼亚唯一的国际机场来需要坐一个小时的出租车。



这里的湖真清啊，再湖边可以很清楚地看到湖底的水草。





最后一天，会议方组织了高山速降的项目，我们都试了一下哦。

法国生活

suits观后感

看了快四季的suits，除了领略一下纽约西装革履的讼棍们的日常外，还是深有所感的。

首先，看美剧学英语，每一集的shit语简直之极灵魂深处：

1
2
3
4
5
6
7
8
9
10
11
12
I'm gonna beat the shit out of you.
You piece of shit.
I'm gonna fire the shit out of you.
Who you are in bed with.
He did some bad shit.
You and I don't mess shit up.
He sang like a canary. (告密的小婊砸)
I am god dammn do it.
You and Mike are gonna to work your shit out.
All he want to do is shake us down. (敲诈，就是把你拎起来然后把钱摇出来。)
He's the guy you shit bed with.
You evidence-manufacturing piece of shit.
1
2
Junior ==> Senior ==> Name partner.
We both know laywers are nothing but power-hungry bottom-feeders.

律所里有这么一位律师路易，心地纯良，但总是被他人利用其性格搞砸很多事，但每每让人感动的也是他啊。

1
There comes a time when a man must look at himself in the mirror, to judge himself instead of waiting to be judged by others.
学术积累

学生t检验，Student's T Test

今天和临时Boss，Michael讨论了一下怎么进行程序的正确性校验，被上了一课。
程序的校验一般是通过对比实验的测量结果和程序的计算结果进行的，判断程序计算可靠性其实就是对比实验测量结果和计算结果是同一个事件的置信度。这个置信度的计算可借助统计学中的学生t检验进行。

相似得置信度估计方法包括：Z-test，ANOVA（变异数分析），Student’s T test。
Student’s T test 是英国人威廉·戈塞针对小样本数量的 Z test的改进。
当带比较得数据有3组以上时，因误差无法压低，可以使用ANOVA。

从维基百科开始，我对Student’s T test做了一个详细的调研和理解，如下是学习笔记。

学生t-分布, Student’s t-distribution

回到正态分布的概念，正态分布的意义是：在已知样本总体方差的前提下（比如采样数量足够大时），根据采样结果得到的总体的均值的分布函数。比如已知采样结果[a1, a2, …, an],假设n非常大，那么目标的

但是，对于数量较小的采样样本，正态分布的假设（已知样本总体方差）不成立，为此引入了学生t分布。

结论

对于我们的已经收敛的蒙卡粒子输运程序而言，Z-test可能是更好的置信度分析方法。