从去年9月奥地利开会回来后，十一期间我将简历整理了一番，从国庆节之后开始正式进入找工作的洪流之中。最终也收获了几个offer，我从一开始，对自己的期望工作和工作性质就有明确要求：1.不做纯技术，coding少。2. 互联网相关。3.工程+研究最好。这一点在我找寻过程中基本满足，也有所微调整。

比如之前签的Amazon，在经过重重面试后最终斩获，它是我在互联网领域屡投不中后给我机会的第一个公司。之前我也说过，读过phd找工作时不一定比硕士时更好，其实面更窄，公司要求更专，数据挖掘方向是敲开这类公司大门的不二法门。虽然Amazon这个职位没有太多研究成分，而是更注重技术开发，但我看重的是它在互联网电子商务中的强势力量，也青睐于它的三驾马车之一的云计算基础平台EC2，因此我也就从了，年前把三方给交了。后来发现自己的长处和优势在这个地方无法施展。在我读书的这几年手头渐生，写代码这活感觉上干不赢硕士，遂后来放弃。

互联网类企业

（1）baidu。当我想找同学内推时，发现已经错过内推时间了，而且我直接网上投递了简历，也无法再走内推的流程。百度校园第一次笔试时，我刚刚投完简历，第二次笔试时恰逢我的马拉松比赛，我主动将其推迟了近一个月，直到11月4日的第三次网上笔试才顺利参加。不过面到2面时挂了。回想硕士阶段我还在baidu的商务搜索部实习过呢，投的也是这个部门的研究类职位，应该有不少优势。加上面试时自我感觉聊得挺欢快的，近1个半小时的面试感觉时间很快就过去了。不过baidu最后迟迟没给我消息，当我主动打电话过去时得知“很遗憾”，没缘分。

（2）tencent是我第一场笔试，tencent也成为我第一个正儿八经的面试，很仓促的打车去银科大厦，等待了近3个小时候由一个内部员工面我。当时准备不足，经验亦不足，在自我介绍部分连姓名都忘记介绍了，在那呱唧半天面试官似乎心不在焉。无果。

(3) 搜狗的研究类职位均专注于搜索，笔试时我再度fail，但题目做出了不少，毕竟已经经历过几场笔试了。但我不甘心，自己毛遂自荐，给HR写了封不长不短的邮件。动之以情晓之以理，告之他我对互联网的热爱和为何没通过笔试的原因，让其转发给manager看看，过了两天果然通知我面试。不过manager详细了解过我的研究经历后，说还是不match，可以推荐到另外一个流媒体部门，最后也不了了之了。

(4) 网易有道。没啥好说的，面试上来直接写程序，崇尚技术、实实在在。有道和google的经历在我另一篇blog中有详细叙述。(4) google，找师兄帮忙内推，投的是互联网产品经理。经过一轮英语面试后，首轮技术面同样也是写程序，很和谐的败下阵来，不过对google的印象真是很好。

(5) 亚马逊。一轮笔试三轮面试，表现的中规中矩，技术面试时为一些细节抓耳挠腮，实在是太久没碰某些技术了，不过分析得还基本靠谱，也证明了基础还在，这也是我通过技术面的原因吧。然后群面，manager面，顺利获得一个迟来的互联网offer。最终虽然没有选择这里，但我认为亚马逊的环境和团队氛围相当好，有师弟在那实习为证，若我是个硕士我会毫不犹豫去亚马逊的。

(6) 互动百科，也是我投的第二个产品类职位(第一个是google的)。这是一家创业型web公司，也有近4年多的运营经验，据他们的计划，想在最近2年内上市。其CEO还是我科大的校友，更生一份好感。自己平时写的互联网、电信观察的独立blog在面试这类产品类职位时帮了大忙，给对方留下不错印象。期间还布置了一个产品经理的必备作业，5天内完成。我饶有兴致的又是制作问卷调查，又是写些小程序，查资料，写文档，很好的完成了这个作业，不亦乐乎。最后也有各种原因放弃了这个offer，但我对其心存好感，依然感激。有感兴趣的朋友可以去看看（目前被baidu百科恶意竞争，他们的所有词条都直接被baidu搜索屏蔽，只有google才能搜索得到，这其实也侧面说明中国互联网还不成熟和规范）

其它

本来应该还有子标题的，不过其它的一些地方不想花太多笔墨介绍了，归为其它。聊聊数笔结束本文吧。

1. 在奥地利开会时碰到华为的技术专家(他们小组也发表了文章)，他是很谦逊，很有能力和人格魅力的一个人（似乎华为都这种风格，深藏不露，低调严谨）。聊得甚为投机。我对他们今年新成立的研究院和P2P分布式相关研究的职位很感兴趣，他们那个分布式小组可以提供与世界级一流大事交流和直接在美国工作的机会，很吸引人。最终我也拿到了其offer，不过各种原因，最后我放弃了这边，我的同学进去后待遇很不错。如果想做研究而非纯开发，如果想做一些电信领域前瞻、引领潮流的工作，华为研究类职位很不错。
2. 在此期间，有位互联网上认识的朋友(我们完全通过blog对P2P技术的一些交流认识的)，还帮助我内推他们公司的P2P职位，将我的简历转发给了部门领导，在此非常感谢他。不过因为他们公司在上海，因而我没有进一步的面试。我帮助他们的HR在北邮bbs发帖招人，据HR说还有8，9份简历投递过去的，很开心。

我感觉目前找工作有如下几个特点：

1. 更看重表达能力。很多地方都要求15分钟的ppt汇报，包括dx研究院，yd研究院，Motorola,HSTC等等。

2. 技术、背景、经验都是硬件条件，其实我感觉软实力，比如是否让人觉得舒服、合群、易相处更为重要。

3. 战线长，让人很累。公司一般没个3-4面的，都不好意思招人。MIIT dx研究院1笔4面，累死了。这也没啥好说的，企业想要自己最需要的人，毕业生想要得到最满意的机会。注定了找工作这档子事不是一个轻松的活。谁都会经历这个过程，度过了这个阶段，人的心智也会更成熟一些。

为了一个面试准备的ppt材料，不过发现还是不太理解其中的一些细节，尤其是电信网络中传输层的Qos控制机制，包括扩很多参数设定、含义等。一般的资料上也没有查到。

理解的几个传输层IP层的关键概念：

• 承载级QoS参数包括QCI(Qos分类ID)、分配与保持优先级(ARP)、GBR(Guaranteed Bit Rate)、最大比特速率(MBR)和聚合最大比特速率(AMBR)。
• （IP-CAN）IP连接访问网络。规范中频繁出现，之前在IMS概念中有了解，不深入。
  　　IP-CAN是通过IP实现UE与IMS实体之间的连通的网络实体和接口的集合， 典型的例子就是GPRS，在WLAN中时PDP。该术语通常使用于峰窝背景中表示3GPP接入网络如GPRS或EDGE，但也可以用于描述WLAN或DSL网络。它在3GPP IMS（IP媒体子系统）中作为通用术语引入，表示任何基于IP的访问网络如IMS，并注重接入与服务网络的分离。
• IP-CAN承载(bearer) ： 定义了速度，延迟，误码率(BER)等属性的IP传输通道。
• IP-CAN会话(session)：用户终端与IP网络之间的关联。该关联通过终端的IP的地址及可用的终端ID信息来标识。一个IP-CAN会话包含一个或多个IP-CAN承载。对多个IP-CAN承载的支持取决于IP-CAN的类型。只要终端IP地址与IP网络维持连接，IP-CAN会话就会一直存在
• Service Data Flow的概念。他属于AF的session，来自应用层面的会话数据流，一般翻译为业务流，比如， IMS核心网中session的概念。(个人理解)

策略控制包含4大类功能：
1. 准入控制。Gating Control.
2. 事件上报，Reporting. 在网关层面以及用户平面都会触发的事件
3. Qos控制.   Qos Control (这一部分不够理解)
4. 建立bearer。

/**
*
*/

/**找钱币游戏。有面额为1，2，5，10，20各五种钱币，给定数额，
* 1. 输出最优解决方案
* 2. 输出所有解决方案
* @author caicono
* S= {1，2，5，10，20）比如 4元有以下组合。
* {1,1,1,1} {1,1,2,} {2,2}
*/
public class MoneyProblem {
    final int OUTBOUND = 999;
    void getOptimalSolution(int S[],int amount)
    {
        //首先将S[]排序 由大到小。插入排序
        int NS[] = S;
        int kinds = NS.length;
        int sum = 0;
        List solution = new ArrayList();
        for(int i = 0;i<kinds; i++)
        {
            while(sum + NS[i] < amount)
            {
                sum += NS[i];
                System.out.println(“add “+NS[i]+” “);
                solution.add(new Integer(NS[i]));
            }
            if(sum + NS[i] > amount)
            {
                System.out.println(“discard “+NS[i]+” “);
                continue;
            }
            else
            {
                System.out.println(“sum :”+sum+“,NS[i]“+NS[i]+“,ready to add it”);
                sum += NS[i];
                solution.add(new Integer(NS[i]));
               
                System.out.println(“Solution is :”);
                for(int j =0; j<solution.size(); j++)
                {
                    if(j!=solution.size() -1)
                        System.out.print(“”+solution.get(j)+“,”);
                    else
                        System.out.println(“”+solution.get(j));
                }
                break;
            }
        }
       
    }
   
    void getAllSolutions(int S[],int amount)
    {
        //首先将S[]排序 由大到小。简单的插入或者快速排序
        //int NS[] = quickSort(S);
        int NS[] = S;
   
        int kinds = NS.length;
        int sum = 0;
        ArrayList solution = new ArrayList();
        int snum =0;
        for(int i = 0;i<kinds; i++)
        {
            while(sum + NS[i] < amount)
            {
                sum += NS[i];
                System.out.println(“add “+NS[i]+” “);
                solution.add(new Integer(NS[i]));
            }
            if(sum + NS[i] > amount)
            {
                continue;
            }
            else  //得到一个解。
            {
                sum += NS[i];
                solution.add(new Integer(NS[i]));
               
                System.out.println(“&&&&&Solution["+(++snum)+"] is :”);
                for(int j =0; j<solution.size(); j++)
                {
                    if(j!=solution.size() -1)
                        System.out.print(“”+solution.get(j)+“,”);
                    else
                        System.out.println(“”+solution.get(j));
                }
                //得到解之后，回溯解空间，求解其它可能解。
   
                Integer topElem ; //解向量的最后一个元素，也可以看做栈顶元素。
               
                while(solution.size()!=0)
                {
                    topElem = ((Integer)solution.get(solution.size()-1));
                    sum -= topElem.intValue();
                    //删除栈顶元素
                    int k = solution.lastIndexOf(topElem);                   
                    Integer removedElem =(Integer)solution.remove(k);
                    //如果栈顶元素是S中最小元素(本题中S中最小元素为1)，则直接继续弹出栈顶元素。
                    if(removedElem == 1)
                    {
                        continue;
                    }
                    //否则，得到该元素在S集合中比他小的元素index，从这个位置开始，重新开始新一轮的累加遍历
                    else
                    {
                        i = getIndex(S,removedElem);
                        break;
                    }
                   
                }
                System.out.println(“next iterator i=”+i+“,tem Sum:”+sum);
            }
        }
       
    }
   
    /**自己实现的递归快速排序法
     * 就地排序
     * @param s
     * @return
     */
    private int[] quickSort(int l, int h, int[] s) {
        // TODO Auto-generated method stub
       
        if(l >= h)
            return s;
        else
        {
            int low = l+1; int high = h;
            int pivot = l;
            while(true)
            {
                //找到比pivot bigger的元素，位置low
                while(s[pivot]>s[low] && low < high)
                    low++;
                while(s[pivot]<s[high] && low < high)
                    high–;
                if(low < high)
                {
                    int temp = s[low];
                    s[low] = s[high];
                    s[high] =temp;
                }
                else //如果low 和high有交叠(low >= high)，则分区结束
                {
                    break;
               
                }
               
            }
            int temp = s[pivot];
            s[pivot] = s[high];
            s[high] = temp;
           
            quickSort(l,high-1,s);
            quickSort(high+1,h,s);
           
        }
        return s;
    }

    private int getIndex(int[] s, Integer i) {
        int k = i.intValue();
        int l=0,h=s.length-1, m;
        while(l<=h)
        {
            m = (l+h )/ 2;
            if(s[m]>k)
            {
                l = m +1;
            }
            else if(s[m]<k)
            {
                h = m-1;       
            }
               
            else
            {
                return m;
            }
               
        }
       
       
        // TODO Auto-generated method stub
        System.out.println(“No such element:”+k+” in Array:”);
        return OUTBOUND;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MoneyProblem MP = new MoneyProblem();
        int S[] = {20,10,5,2,1};
        int amount = 7;
        //MP.getOptimalSolution(S, amount);
        //MP.getNext(S, new Integer(13));
        /*MP.getNext(S, new Integer(1));
        MP.getNext(S, new Integer(2));
        */
    }

}

* @author caicono
*
*/
public class TestQ {

   
    void m_print(int [][]data,int N)
    {
        N = 3;
       
//        di :表示对角线diagonal，对于N的矩阵，有2N-1条对角线
        for(int di =0; di< 2*N-1; di++)
        {
            if(di%2 ==0) //
            {
                int sum = 0;               
                for(int j=0;j<N;j++)
                      for(int i=0;i<N;i++)
                  {
                   
                    if(i+j == di)
                    {
                        System.out.println(data[i][j]);
                        sum++;
                        if(sum == di+1) //已经将所有符合条件的i，j找到，第di条对角线有di+1个元素符合条件。
                            break;
                    }
                    else
                       ;
                  }
            }
            else //将ij的位置对调，即可实现反向输出
            {
               int sum = 0;
               for(int i=0;i<N;i++)
                   for(int j=0;j<N;j++)
              
                {
                    if(i+j == di)
                    {
                        System.out.println(data[i][j]);
                        sum++;
                        if(sum == di+1) //已经将所有符合条件的i，j找到，第di条对角线有di+1个元素符合条件。
                            break;
                    }

                }
            }
           
        }
    }
   
    public static void  main(String args[])
    {
        TestQ t = new TestQ();
        int a[][] = {{0,1,2},{3,4,5},{6,7,8}};
        int N = 3;
        t.m_print(a, N);
    }
}

public class RegExp {
   
   
    /**给定两个字符串，后者带有*号正则表达，表示1个或者多个字符。
     * 判别前后两个字符串是否相等。比如：
     * 1.cabbca/*ab*
     * 2.accbca/a**b*a
     * 3.abca/a*ca
     *
     * @param src
     * @param des
     * @return
     */
    boolean isSame(char src[], char des[])
    {
        int dIndex = 0, sIndex = 0;
        int dPre = -1; //前向指针
        int count = 0; //src串遍历时增加的距离
        boolean goonFlag = false;
        while (dIndex < des.length)
        {
            while(des[dIndex] == ‘*’)
            {
                System.out.println(“discard * at des["+dIndex+"]“);
                dIndex++;
                dPre++;
                if(dIndex == des.length) //到头了
                {
                    return true;
                }
            }

            count = 0;
            //找源串中的字符位置
            for( ; sIndex < src.length; sIndex++)
            {           
                System.out.println(“find in src string:src["+sIndex+"]“+src[sIndex]+“,des["+dIndex+"]“+des[dIndex]);
                if(src[sIndex] == des[dIndex])
                {
                    if(count > 0)
                    {
                        //还有一种情况，就是des的首字母与src偏移后某个字母相等。此时匹配也是失败
                        if(dPre == -1)
                            return false;
                        else if(des[dPre]==‘*’) //只要des之前的元素为*，则这一次判别就成功,继续des串的判别
                        {
                            goonFlag = true;
                        }
                        else
                            return false;
                    }
                    else //既然找到了src位置，而且正常偏移，则跳出循环，继续des串下一位的判别
                    {
                        goonFlag = true;
                    }   
                }
                else //如果src目前的字符元素不等于des的元素，则src指针自加
                {
                    count++;
                    System.out.println(“not equalls, goon. sIndex inc:”+(sIndex+1));
                }
            }
           
            if(goonFlag)
            {
                sIndex++; //src串前进到下一次比较的位置
                break;
            }
           
            dIndex++;
            dPre++;
        }
       
        if(sIndex < src.length)    return false; //des已经遍历完，而src尚未完成，则显然不匹配
       
        return true;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        RegExp re = new RegExp();
//        char src[] = {‘a’,'c’,'c’,'b’,'c’,'a’};
//        char des[] = {‘a’,'*’,'*’,'b’,'*’,'a’};
       
        char src[] = {‘a’,‘c’,‘c’,‘b’,‘c’,‘a’};
        char des[] = {‘c’,‘*’,‘*’,‘*’};        
        boolean b = re.isSame(src, des);
        System.out.println(“Result is :” + b);
    }

}