LeetCode 2015.10.6 287,41,154,117,128,33,81,72,138,133,164

LeetCode 2015.10.6 287,41,154,117,128,33,81,72,138,133,164

287 Find the Duplicate Number
法一：

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

法二：
class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int len=nums.size();
        int left=0,right=len-1,mid=0;
        while (left<right)
        {
            mid=(right-left)/2+left;
            int cnt=countLess(mid,len,nums);
            if (cnt<=mid) left=mid+1;
            else right=mid;
        }
        return left;
    }

    int countLess(int mid,int len,vector<int> nums)
    {
        int cnt=0;
        for(int i=0;i<len;i++)
            if (nums[i]<=mid)
            cnt++;
        return cnt;
    }
};


41 First Missing Positive
class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        int len=nums.size();
        if (len==0) return 1;
        for(int i=0;i<len;i++)
        {
            if (nums[i]>=len) continue;
            if (nums[i]>0 && nums[i]!=i+1)
            {
                int index=i;
                while ((nums[index]>0) && (nums[nums[index]-1]!=nums[index]))
                {
                    int index2=nums[index]-1;
                    int tmp=nums[index];
                    nums[index]=nums[index2];
                    nums[index2]=tmp;
                }
            }
        }
        for(int i=0;i<len;i++)
            if (nums[i]!=i+1) return i+1;
        return nums[len-1]+1;
    }
};

154 Find Minimum in Roated Sorted Array II
class Solution {
public:
    int findMin(vector<int>& nums) {
        int len=nums.size();
        int index=0;
        for(int i=1;i<len;i++)
        {
            if(nums[i]!=nums[i-1])
            {
                index++;
                nums[index]=nums[i];
            }
        }
        int left=0,right=index;
        while (left<=right)
        {
            if (left==right) return nums[left];
            if (left+1==right) return min(nums[left],nums[right]);
            int mid=(left+right)/2;
            if (nums[mid]<nums[left] && nums[mid]<nums[right])
                right=mid;
            else
            {
                if (nums[left]<nums[right])
                    right=mid-1;
                else
                    left=mid+1;
            }
        }
        return 0;
    }
};

117 Poplulating Next Right Pointers in Each Node II
class Solution {
public:
    void connect(TreeLinkNode *root) {
        if (root==NULL) return ;
        queue<TreeLinkNode*> q[2];
        queue<int>qindex;
        int now=0;
        q[now].push(root);
        TreeLinkNode* tmpnode(0);
        while (!q[now].empty())
        {
            while (!q[now].empty())
            {
                tmpnode=q[now].front();
                q[now].pop();
                if (tmpnode->left!=NULL) q[1-now].push(tmpnode->left);
                if (tmpnode->right!=NULL) q[1-now].push(tmpnode->right);
                if (!q[now].empty())
                    tmpnode->next=q[now].front();
            }
            now=1-now;
        }
    }
};

128 Longest Consecutive Sequence
class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        map<int,bool> flag;
        int len=nums.size();
        if (len==0) return 0;
        map<int,bool>::iterator it;
        int ans=-INT_MAX;
        int segLen=0;
        for(int i=0;i<len;i++)
        {
            it=flag.find(nums[i]);
            if (it==flag.end())
                flag[nums[i]]=true;
        }
        int last=flag.begin()->first - 1;
        for(it=flag.begin();it!=flag.end();it++)
        {
            if (segLen>ans) ans=segLen;
            int now=it->first;
            if (now==last+1) segLen++;
            else segLen=1;
            last=now;
        }
        if (segLen>ans) ans=segLen;
        return ans;
    }
};

33 Search in Rotated Sorted Array
class Solution {
public:
    int search(vector<int>& nums, int target) {
        map<int,int> flag;
        int len=nums.size();
        for(int i=0;i<len;i++)
            flag[nums[i]]=i;
        map<int,int>::iterator it;
        it=flag.find(target);
        if (it!=flag.end()) return it->second;
        else return -1;
    }
};

81 Search in Rotated Sorted Array II
class Solution {
public:
    bool search(vector<int>& nums, int target) {
        map<int,int> flag;
        map<int,int>::iterator it;
        int len=nums.size();
        for(int i=0;i<len;i++)
        {
            it=flag.find(nums[i]);
            if (it==flag.end())
                flag[nums[i]]=i;
        }
        it=flag.find(target);
        if (it!=flag.end()) return true;
        else return false;
    }
};

72 Edit Distance
class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1=word1.size(),len2=word2.size();
        int f[len1+5][len2+5];
        for(int j=0;j<=len2;j++) f[0][j]=j;
        for(int i=0;i<=len1;i++) f[i][0]=i;
        f[0][0]=0;
        for(int ix=0;ix<len1;ix++)
            for(int jx=0;jx<len2;jx++)
            {
                int i=ix+1,j=jx+1;
                f[i][j]=min(f[i-1][j],f[i][j-1])+1;
                if (word1[ix]==word2[jx])
                    f[i][j]=min(f[i][j],f[i-1][j-1]);
                    else f[i][j]=min(f[i][j],f[i-1][j-1]+1);
            }
        return f[len1][len2];
    }
};

138 Copy List with Random Pointer
class Solution {
    map<RandomListNode*,RandomListNode*> flag;
    map<RandomListNode*,RandomListNode*>::iterator it;
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if (head==NULL) return NULL;
        it=flag.find(head);
        if (it==flag.end())
        {
            RandomListNode* newNode = new RandomListNode(0);
            flag[head]=newNode;
            newNode->label=head->label;
            if (head->next!=NULL)
                newNode->next=copyRandomList(head->next);
            if (head->random!=NULL)
                newNode->random=copyRandomList(head->random);
            return newNode;
        }
        else return flag[head];
    }
};

133 Clone Graph
class Solution {
    map<UndirectedGraphNode*,UndirectedGraphNode*> flag;
    map<UndirectedGraphNode*,UndirectedGraphNode*>::iterator it;
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        if (node==NULL) return NULL;
        it=flag.find(node);
        if (it!=flag.end()) return flag[node];
        UndirectedGraphNode* newNode= new UndirectedGraphNode(node->label);
        flag[node]=newNode;
        int nlen=node->neighbors.size();
        if (nlen!=0)
        {
            for(int i=0;i<nlen;i++)
            {
                newNode->neighbors.push_back(cloneGraph(node->neighbors[i]));
            }
        }
        return newNode;
    }
};

164 Maximum Gap
class Solution {
    map<int,bool> flag;
    map<int,bool>::iterator it;
public:
    int maximumGap(vector<int>& nums) {
        int len=nums.size();
        if (len<2) return 0;
        int ans=-INT_MAX;
        for(int i=0;i<len;i++)
        {
            it=flag.find(nums[i]);
            if (it==flag.end())
                flag[nums[i]]=true;
        }
        map<int,bool>::iterator last=flag.begin();
        it=flag.begin();it++;
        for(;it!=flag.end();it++)
        {
            int tmp =(it->first)-(last->first);
            if (tmp>ans) ans=tmp;
            last=it;
        }
        if (flag.size()==1) return 0;
        return ans;
    }
};