I love reading autographies, especially these with life-time stories. it’s a window to explore kinds of life possibilites. and recently I readed << the only girl >>, Robbin at Rolling Stone magazines in 1970s.

I remember some toughts about life meanings. there are three kinds: 1) to crazy satisfy yourself, or pursue a free life, live the way you really want. e.g the freelancer; 2) ladder up to the higher social class, which is happening a lot in developing countries, and to be rich and success is the guarantee; 3) enjoy the beauty of nature and civilazation in this short period of life time.

the last two meanings can not be done immediately, to crazily or desperately satisfy self, is then the easiest way to fight against the fucking environment. like when getting tired of this busy world, I behave more like a hippie, no big deal to anything, and kill time on drama, books, or drugs or sex.

the hippie lifestyle is momental, it creats a space to seperate from daily troubles; after a few days or nights, I am back to real life, continuing on career stuff.

so take it, the reality for me, as born in Asian developing country, with traditional family responsibility, is pursuing career, and of course it helps to take a break, and enjoying hippies, but don’t take it as the life-time way.

mostly of my inner voices are: either busy to live or busy to die; problem-solving skills, leadership; to figure out how the economy machine functions in small and big roles; and be the smart guy in market and at office.

and no need with another degree or matured platform to be problem-solvingable or leadershipable. these skills are in everywhere.

在美国开长途，沿途总是遇见wendy’s, McDonald’s， auto zone 等等连锁店。也不论在toledo等中部小城市，还是芝加哥、纽约等国际大城市，这些店也到处都有。甚至costco商店在底特律，布法罗，哥伦布，三番等城市的商品布局摆放都是一摸一样的。

中国很少有这种在从三四线城市到一线城市都连锁的服务品牌，除了重资产的，比如商业地产（万达广场）， 酒店，大型购物超市，阿里仓库，烟草局等。而餐饮、汽修、家装等等基本都是地方特色。

美国各州相对很独立。比如，buffalo wings 从布法罗开到了全美国， kfc 从肯塔基开到了全美国。把产品、模式从一个地方复制到另一个地方很容易实现。而且不仅产品本身，其背后的供应链也同样反映了平坦。所以是整个体系很成熟，容易实现规模效益，从而正向强化成功。

中国地方性壁垒比较高，一个成功的产品、模式难轻松复制。好处是发展了很多地方性的特色服务。当然对资本而言是不经济的。好奇麦当劳进入中国，是怎么做供应链的，如何在不规范、体系不成熟的环境下复制美国模式的。

一个顶级成功的商业，应该是建立系统。然后，利润就在系统运营和管理中流淌出来。就像顶级的造车公司，是能够把研发、生产、销售等subsystem打通，建立一个造车system的公司。这也是matured market 的特征，系统成熟运作，利润稳定地流淌。emerging market 就处于探索建立系统的过程。一般是从新科技、产品subsystem出发，因为商业模式、市场等subsystem比较好从已经有的成熟体系里借鉴，然后融合、打通。

中国出现了两种特有的经济行为：外卖和淘宝。他们的价值就是打通原本因为地域壁垒很难复制的产品。互联网不存在地域壁垒，所以有效最优化资源，并实现规模效益。相比，美国不存在大范围的外卖、淘宝，因为产品复制在地域上很容易。

商业的本质，就是建立一套稳定运转的系统，不论中美。因为美国的资本、商业环境、企业规范、地方行政等方面的成熟，即游戏规则已经稳固且清晰，成功是更容易的。相比，在中国，就需要官商结合重资本打开局面。因此在中国，赚大钱更容易。

很多汽车公司（供应商，oem）都有大量职位招：CAN, control, EE 背景的同学。相反，cae产品却很少出现在供应商的招聘中。先给个预判：汽车电子处于草莽时代。

汽车电子

首先，汽车电子，不论硬件、软件，都很面向产品。出来的直接可以拿到市场去卖。另一方面，这类产品又很成熟，不论是电子元器件，汽车网络，摄像头等传感器，控制算法都不是新技术，而更像是一次“组合创新”。基于已有部件，在新的应用场景，重新组合，研发需求本身很低。

即使前沿应用场景，比如自动驾驶，其实是需要重新定义很多基础部件，包括通信协议、ai算法、传感器的融合、路面设备等，必然有很多研发需求，但目前的自动驾驶大多在现有adas基础上的迭代，还没有真正的超越。

另外，因为各个终端产品的差异性，市面上会出现各种解决方案。这是一个行业的草莽时代，各家都自立山头。还没有出现几家鼎力。

由于应用层的需求，而不是研发需求，汽车电子需要熟练的软件/硬件工程师去拼装产品。这也是ME, EE偏控制方向的同学，在汽车行业就业的窗口期。

汽车CAE

CAE行业的黄金期是80年代到2000年，当时也是各个解决方案在市场上乱飞，甚至应用商（汽车厂等)内部都有独立的CAE开发团队，而且做了很牛逼的产品。那个年代，CAE算是emerging tech，很吸引投资和就业。到现在，这样的窗口期已经结束，北美几大CAE厂商三足鼎立： 加州msc, 密西根altair, 匹兹堡ansys，还有一些小众厂商。还有就是更大只的PLM厂商： 西门子， 达索等。

整个行业处于成熟期。产品的研发、市场、客户都已经形成了模式。应用行业也基本稳定，民用品：汽车、电子消费品、医疗等，军用：航空航天、核物理等。当然，未来会拓展新的应用领域，以及需求新产品研发。

虽然整个行业处于成熟期，进入门槛很高了。实际上，如果不在大厂里，CAE还是辅助的。有接触到设计制造供应商，都会使用CAE分析，但经常是Design engineer 顺带跑一下cae分析。也可以看到供应商更需要直接面向产品的设计工程师，而不是CAE应用工程师。

大厂里面有CAE研究部门，尝试新的分析场景；CAE支持部门，包括部署、debug、用户支持；以及CAE工程师。

两种思维

不同的思维反映了不同的背景。面对一个商业想法，一个对细节严肃的工程师，首先会估量自己对讨论的领域是否足够熟悉，然后会考虑技术上是否可行。马云说他是阿里巴巴最不懂技术的人，却能够把握大方向；相反往往问题没解决，责怪技术不够的，会陷入用一个技术解决另一个技术的游戏中，而远离了大方向。

张首晟教授有分享在知识信息爆炸的时代该怎么学习。因为最优秀的书籍也已经多到一个人一辈子都读不完了，所以重要的是抓住道(principle)。举个极端的例子，如果地球毁灭，最后一个人只能带1kb 的信息离开地球，这个信息该是什么，能够保证人类文明不断流。

道与术的例子， 日本远海70公里发生了地震，多久巨浪会到达海岸线？一个细节严苛的学流体力学仿真的研究生，要跑一套cfd程序，考虑近似若干边界初始条件，然后花一两天调试，运行得到结果。而一个有物理常识的人，大概能估计几个跟巨浪速度有关的变量，就可以得到一个近似结果。

我的经验就是太容易过分依赖技术（本质是一种惰性，想回避该用人脑的分析），而忘了新技术的初衷，单纯为了迭代技术本身而发展新技术。世界正在把太多新技术太快速地塞进普通人的视野，不要说思考这些新技术到底意味什么，甚至这些新技术到底将如何产业化，进入普通人的生活都没有清晰。

很长时间，我对工程仿真技术有这样的误区。我已经忽略了cae本身要解决的问题，而只是沉迷在cae技术本身。或者说是，从研究（学生）到商业（职场）的角色没有转变过来。而商业需要的是一个能够打穿新技术与产品落地。他／她可以不懂技术的深度，但一定有广度和连结，能觉察到新技术可以在哪里发挥价值。

越来越感受到，思维会决定行为，而具有倾向性的行为会强化思维。一个没有商业经验的且受过高等技能教育的年轻人，会倾向强调技术，放大其重要性，而看不到其在企业经济大方向上的不合理性。比如，工程师倾向使用最新的技术在产品开发中，但企业定位可能是一款廉价快速打入市场的产品。这时候，在工程师看来完美的合理方案，于企业战略就是不合理的。

emerging market

由新知识引导的商业创新，比如，生物科技，基因技术，新材料，量子计算，人工智能，核物理等，首先很容易给人带来极大的快感，特别让年轻人欲罢不能， 更吸引投资、社会关注。但是，emerging tech存在周期性：从新技术到产品的会有很长的空窗期。历史上电气时代（1830 - 1860年），在爱迪生开发电灯泡之后，数百家电气公司迅速出现，但20年内大部分被淘汰掉；铁路公司，PC电脑, 汽车制造，消费电子，包括最近的AI、自驾车行业，都体现着emerging market的规律：早期快速极度膨胀，然后几年内极度跌落，再慢慢恢复理性。

经济学上还有一个概念，就是新技术带来的就业远不能弥补旧行业消失造成的失业。时间久了，emerging market也会成为matured market。

团队选择

emerging tech非常强调先发优势。很多新知识引导的商业创新，源自学校研究第一梯队，他们本身就是某项技术的原创团队，具有极强的先发优势，而且因为新知识门槛，被市场快速复制的可能性极低。比如，机器人、柔性可穿戴电子器件、基因检测、ai等等。

普通人的第一次团队选择，大多是在高校完成的。聪明人跟对了团队，在博士期间就可以引领emerging market。《新资本论》中提到，21世纪，劳动力与资本收益分配是1:7。 稍微感受下，知识经济将明显比资本有更高收益。

如果错过了第一次团队选择，普通人很难有后发优势，没钱没技术。所以，除非对该领域具有极强的认同感，执着的信仰，否则想在创业团队谋一份职业，可能是误判。

现实与认知之间的矛盾，往往反映一个人还没成熟。我的假象包括：创业团队更锻炼人，更吸引眼球，站在风头浪尖上，然而没有一个因素是因为我对该领域的认同感，不过是渴望它附加的虚荣。另外，个人成长动力不该仅源自环境，而必须是内心。环境在满足基本需求后，只叫人不讨厌它了；但爱上它，必须是从心发出的。

普通人的第二次团队选择，大多是在职场完成的。明确自己该要什么，不该要什么，也许对普通人选择matured market更友好。一方面是老生常谈的大企业病：成熟平庸。但是，创新成功并不都是声名噪动，也有闷声发大财。 成熟行业或成熟企业的创新，也许不是产品／技术本身，而在体系和管理。

而在一个成熟行业待不少于5年，才有可能了解系统，接触到管理。写到这里，不由又盘算要不要读MBA了，正好遇到明年经济糟糕。

– 感谢Selena

leetCode 147, this is another example when solving problem, either find a good data structure, which looks like stand in a higher dimensions with additional DOF, or define the routines on the given data structure.

additional set

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

struct classcomp {
  bool operator() (const ListNode* lhs, const ListNode* rhs) const
  {return lhs->val < rhs->val;}
};  
class Solution {
public:
    set<ListNode*, classcomp>  labels ; 
    ListNode* insertionSortList(ListNode* head) {
            while(head){
                labels.insert(head); 
                head = head->next ;
            }
     
            head = labels[0]; 
            ListNode* node = labels[0]; 
            for(int i=1; i<labels.size(); i++){
                node->next =  labels[i]; 
                node = node->next ; 
            }
            
            return head; 
    }
};
``` 
basically `unordered_set` has ordering by default, so how about first inserting each element from the list to set, then set the next pointer for each element, which take additional space, but did the job straight forward 
## single linked list
since single linked list can't access the previous node, so define prev pointer and current pointer, and every insertaion needs do the compare from frist element to the previous element. 
```c 
public class Solution {
  public  ListNode *insertionoSortList(ListNode *head){
    ListNode *result = nullptr ;
    if(head == nullprt || head.next = null){
      result = head ;
      return result ;
    }
    ListNode *dummy = new ListNode(0); 
    ListNode *cur = head ; 
    ListNode *next, *pre;
    while(cur != nullptr){
        next = cur->next ;
        pre = dummy ; 
        while(pre.next != nullptr && pre.next->val <  cur->val){
          pre = pre.next ; 
        }  //return the position where cur node should insert 
        cur->next = pre->next ; 
        pre->next = cur ; 
        cur = next ; 
      }       
    }

leetCode 146, for non-CS background, this kind of problem is out of mind, what is talking about, but I know at all it is about design a data structure to meet some requirements:

first a hash map data structure for key, value operations, e.g. get(), put(); but normal hash map can’t track the most recent used element, so either find a data structure, which can track the recently used element in the hash map; or define some routines to do it.

a data structure to catch recently used

each get(), put() will operate on one special element, and that element should be marked as recently used, and the next element is the least recently used element, which can be overlapped in next operation.

stack and queue have some property to track the most recent element, but they are one-way, not straight forward to manage two neighbor elements.

double linked list is a good choice to track both the most recent element and the least most recent element.

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

struct node{
	int val ;
	int key ;
	Node *pre ;
	Node *next ;
	public Node(int value_, int key_)
	{
		val = value_;
		key = key_ ; 
		pre = NULL ;
		next = NULL;
	}
}
class LRUCache {
	public: 
		list<node*> recent ;
		unorder_map<int, node*>  hash ;
		int capacity ;
		
		LRUCache(int cap): capacity(cap) {}
		
		node* get(int key){
			if(hash.find(key) != hash.end()){
				recent.remove(hash[key])
				recent.push_front(hash[key]); 
				return hash[key] ;
			}
			return -1 ;
		}
		
		void put(int key, int value){
			if(hash.find(key) != hash.end()){
				recent.remove(hash[key]);
				hash[key] =  value; 
				recent.push_front(hash[key]);
			}
			
			node* tmp = new node(value, key); 
			hash[key] = tmp ; 
			recent.remove(tmp); 
			recent.push_front(tmp);
	
			if(hash.size() >= capacity){
				node *tmp2 = recent.back(); 
				hash.erase(tmp2->key); 
			}
		}
	}

routines to track recently used

in this way, the hash is still needed, but define routine to set the latest updated node always at front.

void setHead(Node* n){
    n.next = head ; 
    n.pre = null ;
    if(head != null) head.pre = n ;
    head = n ; 
    if(end == null) end = head;  //only 1 element 
}

when solving real problems, either has a good understand about special data structure, which can solve this problem, or the raw way is to implement routines based on the exisiting input

in the nude

“only after the tide has faded, know who is in the nude”, the wise said.

distributable resources(social relationship, capital, core tech, market vision) define the success of a man in the world.

in normal days, people feel good about themselves, like they can take things in control and looks well, these factors are ignored, and crisis is under the hood; when situation changes, the crisis appears, then people feel unexpected surprise.

how crisis is so close along with us for a long time, and get igored for a long time ? another word, “standing in the wind, elephant can fly to the sky”, when market is good, normal people make money from stock.

it is not him become smart, worse he is not prepared for the coming bad times.

with no money, no social relations, and no core tech standing in the world, I should be humble to dirt, rather talking like everything is in control. for many young immigrants, the breakthrough is through education and learn core skill, and earn money and gradually being successful.

this evening, watched Jack Ma speech, some ideas: in age 20 - 30, the best thing is to find a good boss and learn from him or the team; from age 30 - 40, try something for yourself, either to start a business or go for a art design degree; from 40 - 50, make sure to do things yourself most good at.

life is previous and short, no waste. find out my contribute to the world, and do it.

the right thing

I shared my thoughts with a friend, that I thought AV was the future in vehicle industry, so even though I had no experience in control algorithms, computer vision, sensor hardware, I will find a way in; on the other side, I am pretty familiar with CAE software products development and applications, how I choose ?

my friend said, neither. job is to make money.

Have to say, I am still focusing too much on the strong or the weak, the right or wrong. spent too much energy to find the line to divide future into simple right choic and wrong choice.

I remembered another good friend, said I am used to pre-define or label people, but forget every similar story could have many different reasons and results.

if there is a unique right thing in the world, then everyone must follow it, but since the right thing/decision for each person is different, even though the world drive people to be similar, I should realize in every situation, every step, it is ok to have a different right thing, rather than holding on the unique rightness

leetcode 139

dfs

traversing string ,and split it one char by next, if find the splited left word in dict, recursiving the remaining right substring. in this way, it will make sure find a solution, but also traversing all unnecessary possibilites. and need design a class variable to stop the dfs()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

bool found = false;
bool dfs(string s, unordered_set<string>& dict){
  string left, right ;
  if(s.size() == 0 || s.empty())
  {
    found = true;
    return found;
  }
  for(int i=0; i<=s.size(); i++)
  {
    left = s.substr(0, i);
    right = s.substr(i, s.size()-i);
    if(dict.find(left) !=  dict.end())
    {
      dfs(right, dict);
    }
  }
  return found;
};

bfs

as mentioned above, dfs goes to all possibile branches, which is not required. bfs is like a greedy way, to find out one working solution and done.

also need keep track of searched left sub-strings, since the remaining right sub-strings may can not find a matched from dict, then the left sub-string is not acceptable, so the left sub-string need move one char further.

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

  bool bfs(string s, unordered_set<string>& dict)
{
    int len = s.size();
    string s1, q, left, right;
    queue<string> sq;
    sq.push(s);
    string tmp ;
    while(!sq.empty()){
    tmp = sq.front(); sq.pop();
    int i=0;
    s1 = s ;
    while(!s1.empty() && i <= s1.size())
    {
      if(tmp == s){
        left = s1.substr(0, i);
        right = s1.substr(i, s1.size()-i);
      }else
      {
        left = s1.substr(0, i+tmp.size()); ///will dead-cycle 
        right = s1.substr(i+tmp.size(), s1.size()-i-tmp.size());
      }
      i++;
      if(dict.find(left) !=  dict.end())
      {
        q += left ;
        sq.push(left);
        s1 = right;
        i = 0;
      }
    }
  }

this bfs is not good design.
a pretty simple sample code

at the end of 2018, I was lay off from GM after only a couple months. in the middle of 2018, I was planning to jump out from the traditional CAE group, to try the new autonomous vehicle. but a few things I missed when made that decision:

the big environment

how long will the traditional automotive industry stay in a sort of good shape? the answer now is not long. from Oct 2018, both Ford and GM publicly lay off over 15%, the vehicle market at both China and NA were significantly down from Q3; even earlier the manufactoring robotic supplieres mentioned their 2019 order were almost zero. so layoff employees is almost destined.

in economics, consumer index is the reason, employment/unemployment rate is the result, not the reverse. and there is a delay from consumer index to unemployment, about 3 ~ 6 month. so when the market is done, a few month later, the unempolyment rate will show up.

an even biggger environment, the trade war among China and USA raise the cost, fear both the consumers and the investors. not only vehicle market, consumer electronics (e.g. apple), internet(e.g. Google), retail industry(e.g. Alibaba) and as closely related to lologistics, chips, energy, housing, finance all go down.

the winter is coming. Sooo scary, hate Trump !

new techs in vehicle

for a new stuff in market, the trend is starting extremely high, then low to bottom, then go to rationality. it happens to AI, autonomous vehicle(AV) market. starting from 2016, billions invest in, every step looks promising, revolution. but 2 years now, even Waymo said it can’t make AV in bussiness.

on one way, OEMs can’t be lay behind, so buy startups, on the other way, they can’t all invest in AV, which has no mature market strategy. the more invest, the higher risk.

for people who want to eat this AV cake, cold cold.

how to face the changing world

have to say, there is no well-prepared in this quick-changing world, plan is always out of date.

at the middle of year, I thought I made the right decision to leave Ford CAE group, join GM autonmous group, now put myself in a poor situation.

I usually have a mind, that this thing has to, must to be done in this and only this way; this situation is and has to be dealed in this and only this way; this person is and has to be treated in this and only this way. I know this is the poor mindset.

they say “poor people make poor decisions”, thanks to warn me up. e.g.

* so high risk to depend on one single incoming resource 

* no stable business, keep humble and keep foolish

* be positive, be felxible. 

leetcode 133, the solution is traversing the graph, so either bfs or dfs should work.

dfs works like a stack, take an example when processA is running, inside processB is invoked, then processA hang, and go into processB; as processB is running, inside processC is invoked, then processB hanged, and go into processC. e.t.c. so the finished order is from innerest to outest. dfs will always traverse all possibilities, then return to the outest layer.

in clone graph, e.g.

#0, 1,  2
#1, 2
#2, 2 

dfs process as:

first deal with first line, element 0, which trick element 1, so process goes to second line, and trick element 2, so go to third line(done), then return to second line(done), then return to first line, trick second neighbor 2 go on…

bfs works different, during processA running, processB is invoked, will still run processA to done, but also push processB to job queue, which will run next time. so using bfs, usually has a queue variable to mark unfinished jobs.

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

 
 struct UndirectedGraphNode {
  int label ;
  vector<UndirectedGraphNode *> neighbors ;
  UndirectedGraphNode(int x) : label(x) {};
};
//graph traversing by bfs
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node){
      if(!node) return nullptr ;
      UndirectedGraphNode *c_node = new UndirectedGraphNode(node->label);
      queue<UndirectionGraphNode*> qlist ;
      unorder_map<int, UndirectionGraphNode*> map;
      map[c_node->label] = c_node ;
      qlist.push(c_node);
      UndirectedGraphNode cur, neighbor = nullptr;
      
      while(!qlist.empty()){
        cur = qlist.front(); qlist.pop();
        for(int i=0; i<cur->neighbors.size(); i++){
         neighbor =  cur->neighbors[i];
         if(map.find(neighbor->label))
         {
           c_node->neighbors.push_back(neighbor);
         }else{
           UndirectedGraphNode *tmp = new UndirectedGraphNode(neighbor->label);
           c_node->neighbors.push_back(tmp); 
           map[tmp->label] = tmp ;
           qlist.push(tmp);  //bfs idea: find new node, push it to queue and deal
           // with it in next while loop
         }
      }
    }
      return map[c_node->label];
  }
 //dfs
 void dfs(UndirectedGraphNode\* node, unorder_map<int, UndirectionGraphNode*>& map)
 {
    UndirectedGraphNode * c_node = nullptr;
    if(!map.find(node->label)){
      c_node = new UndirectedGraphNode(node->label);
      map[c_node->label] = c_node;
    }else{
      c_node = map.find(node->label);
    }
    UndirectedGraphNode* nei;
    for(int i=0; i<node->neighbors.size(); i++){
        nei = node->neighbors[i];
        if(map.find(nei->label)){
          c_node->neighbors.push_back(nei);
        }else{
          dfs(nei, map);
        }
      }
  }
 UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node){
   unorder_map<int, UndirectionGraphNode*> map;
   dfs(node, map);
   return map[node->label]; 
 }