2017-3-9 leetcode 283 287 289

今天操作系统课，没能安心睡懒觉23333，妹抖龙更新，可惜感觉水分不少。。。。怀念追RE0的感觉

===================================================================

leetcode283 Move Zeroes

leetcode287 Find the Duplicate Number

leetcode289 Game of Life

==================================================================

283讲的是
给你一个数组，其中有一些0，把0移到数组的最后，其他非零数字的相对位置（前后关系）不变。
要求 1，不能使用额外的空间（不能拷贝整个数组）。2，进行的操作尽可能少。

我的思路
两个指针，一个指向当前位置，一个指向最前的可以放非零数字的位置。。。说不清，水题，看代码吧

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n=nums.size(),ptr=0;
        for(int i=0;i<n;i++){
            if(nums[i]){
                if(ptr-i){
                    nums[ptr]=nums[i];
                }
                ptr++;
            }
        }
        for(int i=ptr;i<n;i++)nums[i]=0;
    }
};

看了看别人的，都这么写的。。。。

===================================================================

287讲的是
给你n+1个数字，每个数字的值属于[1,n]，现在保证有且仅有一个数字出现了多次（可能大于两次），在最多O(1)空间，O(n^2)的时间找出这个数字。

我的思路
一开始我看到这题，特别激动，总算看到学长天天嚷嚷的异或找数字的题目了，后来发现神TM可能出现不确定的多次。。。。好吧，不是那道题。
老规矩，一下就会想到hash，可惜对空间有要求。
那就sort然后扫一遍好了，O(nlogn) 突然发现有要求不能修改原始数组。。。。。。
我去，好吧，那我们最暴力双重循环来搞吧，好久没有这么暴力过了（手动扶额
我怎么感觉会有O(n)的算法等我膜拜呢。。。。。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        for(int i=0;i<nums.size();i++){
            for(int j=i+1;j<nums.size();j++){
                if(nums[i]==nums[j])return nums[i];
            }
        }
    }
};

被%99的用户击败了hhhhh，膜拜一波

这道题目可以这么思考，把数组的每个元素当作一个点，里面的值是出去的单向边到达的点的标号，每个点出度都为1，意味着这张图有且只有一个环，而且只有进环的路径，没有出环的路径。
抛开这道题目，我们在一个长度单圈长度为n的单向环路上任取一点作为起点，两个指针一快一慢移动，（假设每条路的长度为1）快的每次移动2，慢的每次移动1，那么很容易发现，他们下一次重逢就在起点，且快的走了两圈，慢的是一圈。

如果两个指针同时从圈外的一个长度为m的“毛刺”开始移动（所有的“毛刺”指向“圈”）直到他们再次重合，那么，慢的那个还是会移动n，也就是说在圈上移动n-m，快的那个和他的位置相同。

这个时候，如果指针的再移动m，就可以定位到圈上有“毛刺”的地方。

有了这个思路，我们再来看看这道题，是不是豁然开朗！

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        if(nums.size()<2)return -1;
        int f_ptr=nums[nums[0]],s_ptr=nums[0];
        while(f_ptr!=s_ptr){
            f_ptr=nums[nums[f_ptr]];
            s_ptr=nums[s_ptr];
        }
        f_ptr=0;
        while(f_ptr!=s_ptr){
            f_ptr=nums[f_ptr];
            s_ptr=nums[s_ptr];
        }
        return s_ptr;
    }
};

这个算法可以看到慢的那个绕环最多一周，所以是O(n)的算法

=================================================================

 289讲的是
讲的是让你手动实现一个元胞自动机，给你一个状态，问你下一个状态是怎么样的
（元胞自动机是这样变化的
1，如果3×3的范围内有少于2个活着的邻居，且中心格子是活的，则中心格子因为孤独死亡
2，如果3×3的范围内有多余3个活着的邻居，且中心格子是活的，则中心格子因为拥挤死亡，
3，如果3×3的范围内有2--3个活着的邻居，且中心格子是活的，则中心格子继续活
4，如果3×3的范围内有3个活着的邻居，且中心格子是死的，则中心格子因为乘重生而活）

如果仅仅如此，还是比较简单，但是。。。。第一，要求在原图上修改！！！！，第二，问你元胞如果跑到了数组边界，我们怎么办？
QAQ。。。。。我能怎么办，我也很绝望啊

 我的思路
我没什么特别优的思路，因为更新某一个点的时候需要用到上一行上一个元素过去的值，我花了O(n)的空间把他们存了起来，不知道犯规不。。

class Solution {
public:
    void gameOfLife(vector<vector<int>>& board) {
        int n=board.size();
        if(!n)return ;
        int m=board[0].size();
        if(!m)return ;
        vector<int> old(m,0);
        int fro=0;
        for(int i=0;i<n;i++){
            vector<int> bak(board[i]);
            for(int j=0;j<m;j++){
                int cnt=0;
                for(int k=-1;k<2;k++){
                    int ptr=j+k;
                    if(ptr>=0&&ptr<m){
                        cnt+=old[ptr];
                    }
                }
                cnt+=fro;
                fro=board[i][j];
                if(j+1<m)cnt+=board[i][j+1];
                if(i+1<n){
                    for(int k=-1;k<2;k++){
                        int ptr=j+k;
                        if(ptr>=0&&ptr<m){
                            cnt+=board[i+1][ptr];
                        }
                    }
                }
                if(fro){
                    if(cnt==2||cnt==3)board[i][j]=1;
                    else board[i][j]=0;
                }else{
                    if(cnt==3)board[i][j]=1;
                }
            }
            old=bak;
            fro=0;
        }
    }
};

啊。。。。。又蠢了，因为这里面的值只有01，我们可以直接把新状态乘二，二进制的十位是新状态，个位是原始状态。。。。呵呵QAQ，不过我感觉还是不怎么优雅，毕竟只存01我直接用bool，多个O(n)的bool也比现在省无数的空间。

好吧，不得不说，确实是自己蠢了没注意到这点。。。

void gameOfLife(vector<vector<int>>& board) {
    int m = board.size(), n = m ? board[0].size() : 0;
    for (int i=0; i<m; ++i) {
        for (int j=0; j<n; ++j) {
            int count = 0;
            for (int I=max(i-1, 0); I<min(i+2, m); ++I)
                for (int J=max(j-1, 0); J<min(j+2, n); ++J)
                    count += board[I][J] & 1;
            if (count == 3 || count - board[i][j] == 3)
                board[i][j] |= 2;
        }
    }
    for (int i=0; i<m; ++i)
        for (int j=0; j<n; ++j)
            board[i][j] >>= 1;
}

他的这个边界判断写的也很销魂，学习一个