LeetCode 2016 391,297,87,93

最新推荐文章于 2017-02-10 17:10:29 发布

原创最新推荐文章于 2017-02-10 17:10:29 发布 · 418 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

63 篇文章

订阅专栏

391 Perfect Rectangle

// -------------------Seeing Discuss & Searching the Solutions
// Analysis:
/* 	任意一个矩形均有4个顶点，当出现Perfect Rectangle时，在最大覆盖矩形内部，
	所有其它矩形的任意一个顶点均会出现偶数次（因为一个矩形旁边应当有一个或三个矩形
	和它紧密相连，那么这个相接的顶点就出现了偶数次）。所以，可以构建一个HashSet set,
	以一个矩形的四个顶点的(x,y)坐标构造字符串 (x+","+y),以该字符串做键值，当set中
	不存在该键值时，则存入该键值；当set中存在该键值时，则删除该键值；最终set中应该
	只剩下四个键，这四个键即是最大覆盖矩形的四个顶点。*/
// 总的来说就是：
// 		1. 如果是正方形的话，所有出现的点应该都是偶数个。
//		2. 面积的总和应该跟最下角，右上角的面积匹配。
//		3. 用一个set来记录，出现过就删除，没出现就添加，最后剩下的应该是最大矩形的四个点。
// url:
// https://discuss.leetcode.com/topic/56052/really-easy-understanding-solution-o-n-java/22
// Code:
class Solution {
public:
    bool isRectangleCover(vector<vector<int> >& rectangles)
    {
        int n = rectangles.size();
        if (n==0) return false;
        int m = rectangles[0].size();
        if (m==0) return false;
        int x1 = INT_MAX, y1 = INT_MAX;
        int x2 = INT_MIN, y2 = INT_MIN;
        int area = 0;
        set<pair<int,int> > points;
        points.clear();
        set<pair<int,int> >::iterator it1,it2,it3,it4;
        for(auto rec:rectangles)
        {
            if (rec[0]<x1) x1=rec[0];
            if (rec[1]<y1) y1=rec[1];
            if (rec[2]>x2) x2=rec[2];
            if (rec[3]>y2) y2=rec[3];
            area += (rec[2]-rec[0])*(rec[3]-rec[1]);
            pair<int,int> p1 = pair<int,int>(rec[0],rec[1]);
            pair<int,int> p2 = pair<int,int>(rec[2],rec[3]);
            pair<int,int> p3 = pair<int,int>(rec[2],rec[1]);
            pair<int,int> p4 = pair<int,int>(rec[0],rec[3]);
            it1= points.find(p1);
            it2= points.find(p2);
            it3= points.find(p3);
            it4= points.find(p4);
            if (it1==points.end())
                points.insert(p1);
            else points.erase(it1);// can use points.erase(p1);
            if (it2==points.end())
                points.insert(p2);
            else points.erase(it2);
            if (it3==points.end())
                points.insert(p3);
            else points.erase(it3);
            if (it4==points.end())
                points.insert(p4);
            else points.erase(it4);
        }
        int finalArea = (x2-x1) * (y2-y1);
        if (finalArea!=area || points.size()!=4) return false;
        if (points.find(pair<int,int>(x1,y1))==points.end()) return false;
        if (points.find(pair<int,int>(x2,y2))==points.end()) return false;
        if (points.find(pair<int,int>(x1,y2))==points.end()) return false;
        if (points.find(pair<int,int>(x2,y1))==points.end()) return false;
        return true;
    }
};

297 Serialize and Deserialize Binary Tree

// -----------------------
// 用题中提到的编码方式，不过把null换成了#
// Code
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root)
    {
        // *,*,*,*,#,#,*
        if(root==NULL) return "";
        queue<TreeNode*> q;
        while(!q.empty())q.pop();
        string res="";
        q.push(root);
        stringstream ss;string tmpstr;
        while(!q.empty())
        {
            TreeNode* node = q.front();q.pop();
            if (node==NULL)
            {
                res += "#,";
            }
            else
            {
                ss.clear();
                ss<<(node->val);
                ss>>tmpstr;
                res += tmpstr+",";
                q.push(node->left);
                q.push(node->right);
            }
        }
        return res;
    }
    // Decodes your encoded data to tree.
    string deData;
    string getNextVal()
    {
        int pos = deData.find(",");
        string tmpdata = deData.substr(0,pos);
        deData=deData.substr(pos+1);
        return tmpdata;
    }
    TreeNode* deserialize(string data)
    {
        if (data=="") return NULL;
        deData = data;
        queue<TreeNode*> q;
        while(!q.empty()) q.pop();
        TreeNode* root = new TreeNode(atoi(getNextVal().c_str()));
        q.push(root);
        while(!q.empty())
        {
            TreeNode* node = q.front();q.pop();
            string lchstr = getNextVal();
            string rchstr = getNextVal();
            if (lchstr=="#")
            {
                node->left=NULL;
            }
            else
            {
                TreeNode* lchild = new TreeNode(atoi(lchstr.c_str()));
                node->left = lchild;
                q.push(lchild);
            }
            if(rchstr=="#")
            {
                node->right=NULL;
            }
            else
            {
                TreeNode* rchild = new TreeNode(atoi(rchstr.c_str()));
                node->right = rchild;
                q.push(rchild);
            }
        }
        return root;
    }
};

// -------------------RE, 以及空间超出范围-----------
// 本来打算中序+后序生成树，可是各种超出范围
// Code:
/*
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root)
    {
        vector<int> inorder = inorderTraversal(root);
        vector<int> postorder = postorderTraversal(root);
        string strInorder = "", strPostorder = "";

        // *,*,*,+*,*,*,
        // inorder + postorder
        stringstream ss;string tmpstr;
        for(int i=0;i<inorder.size();i++)
        {
            ss.clear();
            ss<<inorder[i];
            ss>>tmpstr;
            strInorder += tmpstr+",";
        }
        for(int i=0;i<postorder.size();i++)
        {
            ss.clear();
            ss<<postorder[i];
            ss>>tmpstr;
            strPostorder += tmpstr+",";
        }
        return strInorder+"+"+strPostorder;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data)
    {
        //int b=atoi(str.c_str());
        int posPlus = data.find("+");
        string strInorder = data.substr(0,posPlus);
        string strPostorder = data.substr(posPlus+1);
        vector<int> inorder,postorder;
        inorder.clear();postorder.clear();
        while(strInorder.size()!=0)
        {
            int pos = strInorder.find(",");
            inorder.push_back(atoi(strInorder.substr(0,pos).c_str()));
            strInorder=strInorder.substr(pos+1);
        }
        while(strPostorder.size()!=0)
        {
            int pos = strPostorder.find(",");
            postorder.push_back(atoi(strPostorder.substr(0,pos).c_str()));
            strPostorder=strPostorder.substr(pos+1);
        }
        return buildTree(inorder,postorder);
    }
private:
    vector<int> ansPost;
    vector<int> post;
    map<int,int> inmap;
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
    {
        if (postorder.size()==0 || inorder.size()==0) return NULL;
        inmap.clear();
        for(int i=0;i<inorder.size();i++)
            inmap[inorder[i]]=i;
        post=postorder;
        return constructTree(0,inorder.size()-1,0,post.size()-1);
    }

    TreeNode* constructTree(int inStart,int inEnd,
                            int postStart,int postEnd)
    {
        if (inEnd<inStart || postEnd<postStart) return NULL;
        TreeNode* root = new TreeNode(post[postEnd]);
        int inIndex = inmap[post[postEnd]];
        root->left=constructTree(inStart,inIndex-1,
                                 postStart,postStart+inIndex-inStart-1);
        root->right=constructTree(inIndex+1,inEnd,
                                  postStart+inIndex-inStart,postEnd-1);
        return root;
    }
    vector<int> postorderTraversal(TreeNode* root)
    {
        ansPost.clear();
        if (root==NULL) return ansPost;
        depthPost(root);
        return ansPost;
    }
    void depthPost(TreeNode* root)
    {
        if (root->left!=NULL) depthPost(root->left);
        if (root->right!=NULL) depthPost(root->right);
        ansPost.push_back(root->val);
    }
    vector<int> inorderTraversal(TreeNode* root)
    {
        vector<int> ans;
        if (root == NULL) return ans;
        stack<TreeNode*> s;
        TreeNode* T = root;
        while (T || !s.empty())
        {
            while (T)
            {
                s.push(T);
                T=T->left;
            }
            T = s.top();
            s.pop();
            ans.push_back(T->val);
            T=T->right;
        }
        return ans;
    }
};
*/

87 Scramble String

// 基本思路
// 在WA的基础上，分割点用循环变量mid来代替。
// 然后递归去处理
// 分两种：
// 			一种左边少，右边多；
//			一种左边多，右边少。
// Code:
class Solution {
public:
    bool isScramble(string s1, string s2)
    {
        int len1 = s1.size(),len2 = s2.size();
        if(len1!=len2) return false;
        if (len1==1) return s1==s2;
        bool flag1,flag2;
        for(int mid =1;mid<len1;mid++)
        {
            string left1,right1,left2,right2;
            flag1=false;flag2=false;
            left1 = s1.substr(0,mid);
            left2 = s2.substr(0,mid);
            right1 = s1.substr(mid);
            right2 = s2.substr(mid);
            if (sameLetters(left1,left2)&&sameLetters(right1,right2))
            {
                flag1=isScramble(left1,left2)&&isScramble(right1,right2);
                flag2=true;
                if(!flag1) continue;
            }
            else
            {
                left2 = s2.substr(0,len1-mid);
                right2 = s2.substr(len1-mid);
                if (sameLetters(left1,right2)&&(sameLetters(right1,left2)))
                {
                    flag2= isScramble(left1,right2)&&isScramble(right1,left2);
                    flag1=true;
                    if(!flag2) continue;
                }
            }
            if(flag1&&flag2) return true;
        }
        return false;
    }
    bool sameLetters(string s1,string s2)
    {
        vector<int>letters(26,0);
        int len = s1.size();
        if(len==1) return s1==s2;
        for(int i=0;i<len;i++)
        {
            letters[s1[i]-'a']++;
        }
        for(int i=0;i<len;i++)
        {
            letters[s2[i]-'a']--;
            if (letters[s2[i]-'a']<0) return false;
        }
        return true;
    }
};
// ------------WA 1ST----------
// 不是等分partition，不是必须一半一半，以及奇数左边比右边少一个。

93 Restore IP Addresses

class Solution {
public:
    vector<string> ans;
    vector<string> restoreIpAddresses(string s)
    {
        ans.clear();
        depthSearch(1,s,"");
        return ans;
    }
    void depthSearch(int k,string left,string res)
    {
        if(k==5 && left=="")
        {
            res=res.substr(0,res.size()-1);
            ans.push_back(res);
            return ;
        }
        if(k==5) return ;
        for(int i=1;i<=3;i++)
        {
            if(i>left.size()) break;
            string sNums = left.substr(0,i);
            if(sNums.size()!=1 && sNums[0]=='0') return ;
            int nums = atoi(sNums.c_str());
            if (nums>255 || nums<0) continue;
            depthSearch(k+1,left.substr(i),res+sNums+".");
        }
        return ;
    }
};