LeetCode 2015.7.16 165,235,36,237,101,110,102,107,2

LeetCode 2015.7.16 165,235,36,237,101,110,102,107,2

165 Compare Version Numbers
class Solution {
public:
    int compareVersion(string version1, string version2) {
        vector<int> p[2];
        vector<int> num[2];
        vector<string> version;
        num[0].clear();num[1].clear();
        p[0].clear();p[1].clear();
        version.push_back("");
        version.push_back("");
        p[0].push_back(-1);
        p[1].push_back(-1);
        version[0]=version1+".";
        version[1]=version2+".";
        for(int k=0;k<=1;k++)
        {
            for(int i=0;i<version[k].size();i++)
                if (version[k][i]=='.') p[k].push_back(i);
        }
        for(int k=0;k<=1;k++)
        {
            for(int i=1;i<p[k].size();i++)
            {
                string tmp="";
                for(int j=p[k][i-1]+1;j<p[k][i];j++)
                    tmp=tmp + version[k][j];
                num[k].push_back(atoi(tmp.c_str()));
            }
        }
        for(int k=0;k<=1;k++)
        {
            while (num[k].size()<num[1-k].size())
            {
                num[k].push_back(0);
            }
        }
        for(int i=0;i<num[0].size();i++)
        {
            if (num[0][i]==num[1][i]) continue;
            if (num[0][i]<num[1][i]) return -1; else return 1;
        }
        return 0;
    }
};

235 Lowest Common Ancestor of a Binary Search Tree
class Solution {
struct Node
{
    int dep;
    int cnt;
};

public:
    map<TreeNode*,Node> ans;
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        findNode(root,p->val,1);
        findNode(root,q->val,1);
        map<TreeNode*,Node>::iterator i;
        int tmpdep=-1;
        TreeNode* result;
        for(i=ans.begin();i!=ans.end();i++)
        {
            if (((i->second).cnt>1)&&((i->second).dep>tmpdep))
            {
                tmpdep=(i->second).dep;
                result = i->first;
            }
        }
        return result;
    }

    void insertAns(TreeNode* root,int dep)
    {
        map<TreeNode*,Node>::iterator i;
        i = ans.find(root);
        int tmp=1;
        if (i!=ans.end())
        {
            tmp=(i->second).cnt + 1;
            ans.erase(i);
        }
        Node node;
        node.cnt=tmp;
        node.dep=dep;
        ans.insert(pair<TreeNode*,Node>(root,node));
    }

    void findNode(TreeNode* root,int value,int dep)
    {
        insertAns(root,dep);
        if (value > root->val) findNode(root->right,value,dep+1);
        if (value < root->val) findNode(root->left,value,dep+1);
    }
    Solution(){
        ans.clear();
    }
};

36 Valid Sudoku
class Solution {
public:
    bool isValidSudoku(vector< vector<char> >& board) {
        int flagrow[10]={0};
        int flagcol[10]={0};
        int flagre[10]={0};
        int grid[15][15]={0};
        int x[10]={0,1,1,1,4,4,4,7,7,7};
        int y[10]={0,1,4,7,1,4,7,1,4,7};
        for(int i=0;i<9;i++)
        {
            for(int j=0;j<9;j++)
            {
                if (board[i][j]=='.') grid[i+1][j+1]=0;
                else grid[i+1][j+1]=board[i][j]-'0';
            }
        }

        // row & col
        for(int i=1;i<=9;i++)
        {
            for(int p=0;p<=9;p++)
            {
                flagrow[p]=0;
                flagcol[p]=0;
            }
            for(int j=1;j<=9;j++)
            {
                flagrow[grid[i][j]]++;
                flagcol[grid[j][i]]++;
            }
            for(int k=1;k<=9;k++)
            {
                if (flagrow[k]>1) return false;
                if (flagcol[k]>1) return false;
            }
        }

        // sub grid
        for(int i=1;i<=9;i++)
        {
            for(int p=0;p<=9;p++)
                flagre[p]=0;
            for(int xi=x[i];xi<=x[i]+2;xi++)
            {
                for(int yi=y[i];yi<=y[i]+2;yi++)
                    flagre[grid[xi][yi]]++;
            }
            for(int k=1;k<=9;k++)
                if (flagre[k]>1) return false;
        }
        return true;
    }
};

237 Delete Node in a Linked List
class Solution {
public:
    void deleteNode(ListNode* node) {
        while (node->next!=NULL)
        {
            node->val=node->next->val;
            if (node->next->next==NULL)
                node->next=NULL;
            else
                node=node->next;
        }
    }
};

101 Symmetric Tree
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root==NULL) return true;
        TreeNode* rootnew;
        rootnew=copyTree(root);
        invert(rootnew);
        return isSameTree(root,rootnew);
    }
    TreeNode* copyTree(TreeNode* root)
    {
        if(root==NULL) return NULL;
        TreeNode* tmp=new TreeNode(root->val);
        tmp->left=copyTree(root->left);
        tmp->right=copyTree(root->right);
        return tmp;
    }
    void invert(TreeNode* root) {
        TreeNode* tmp;
        if (!(root->left==NULL && root->right==NULL))
        {
            tmp = root->left;
            root->left = root->right;
            root->right = tmp;
            if (root->left!=NULL)invert(root->left);
            if (root->right!=NULL)invert(root->right);
        }
        else return ;
    }

    bool isSameTree(TreeNode* p, TreeNode* q) {
        bool flag1,flag2;
        if ((p==NULL)&&(q==NULL)) return true;
        if ((p==NULL)+(q==NULL) ==1) flag1=false; else flag1=true;
        if (flag1)
        {
            if (p->val==q->val) flag2=true; else flag2=false;
        }
        return (flag1 && flag2 && isSameTree(p->left,q->left) && isSameTree(q->right,p->right));
    }
};

110 Balanced Binary Tree
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if (root == NULL) return true;
        bool flag = abs(maxDepth(root->left)-maxDepth(root->right))<=1;
        return (flag && isBalanced(root->left) && isBalanced(root->right));
    }
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

102 Binary Tree Level Order Traversal
class Solution {
struct node
{
    int val;
    int dep;
    node(int x,int y) :val(x),dep(y){}
};
public:
    vector<node> v;
    int maxdep;

    vector< vector<int> > levelOrder(TreeNode* root) {
        vector< vector<int> > ans;
        ans.clear();
        if (root==NULL) return ans;
        broad(root,0);
        ans.resize(maxdep+1);
        for(int k=0;k<=maxdep;k++)
        {
            for(int i=0;i<v.size();i++)
            {
              if (v[i].dep==k)
                    ans[k].push_back(v[i].val);
            }
        }
        return ans;
    }
    void broad(TreeNode* root,int depth)
    {
        if (root==NULL) return ;
        if (depth>maxdep) maxdep=depth;
        node tmp(root->val,depth);
        v.push_back(tmp);
        broad(root->left,depth+1);
        broad(root->right,depth+1);
    }
    Solution()
    {
        v.clear();
        maxdep=-INT_MAX;
    }
};

107 Binary Tree Level Order Traversal II
class Solution {
struct node
{
    int val;
    int dep;
    node(int x,int y) :val(x),dep(y){}
};
public:
    vector<node> v;
    int maxdep;

    vector< vector<int> > levelOrderBottom(TreeNode* root) {
        vector< vector<int> > ans;
        ans.clear();
        if (root==NULL) return ans;
        broad(root,0);
        ans.resize(maxdep+1);
        for(int k=maxdep;k>=0;k--)
        {
            for(int i=0;i<v.size();i++)
            {
              if (v[i].dep==k)
                    ans[maxdep-k].push_back(v[i].val);
            }
        }
        return ans;
    }
    void broad(TreeNode* root,int depth)
    {
        if (root==NULL) return ;
        if (depth>maxdep) maxdep=depth;
        node tmp(root->val,depth);
        v.push_back(tmp);
        broad(root->left,depth+1);
        broad(root->right,depth+1);
    }
    Solution()
    {
        v.clear();
        maxdep=-INT_MAX;
    }
};

2 Add Two Numbers
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if (l1==NULL && l2==NULL) return NULL;
        ListNode* head=new ListNode(0);
        ListNode* tmphead=head;
        int flag=0;
        while (l1!=NULL && l2!=NULL)
        {
            int sum = l1->val+l2->val + flag;
            ListNode* tmp=new ListNode(sum%10);
            flag=sum/10;
            sum%=10;
            tmphead->next=tmp;
            tmphead=tmp;
            l1=l1->next;
            l2=l2->next;
        }
        if (l1!=NULL) tmphead->next=l1;
        if (l2!=NULL) tmphead->next=l2;
        while (flag>0)
        {
            if (tmphead->next==NULL)
            {
                ListNode* node = new ListNode(flag);
                tmphead->next=node;
                flag=0;
            }
            else
            {
                tmphead=tmphead->next;
                int sum = tmphead->val+flag;
                tmphead->val=sum%10;
                flag=sum/10;
            }
        }
        return head->next;
    }
};