LeetCode 2015.7.27 64,62,59,466,48,53,113,16

LeetCode 2015.7.27 64,62,59,466,48,53,113,16

64 Minimum Path Sum
class Solution {
public:
    int minPathSum(vector< vector<int> >& grid) {
        int row = grid.size(), col = grid[0].size();
        vector< vector<int> > f;
        f.resize(row);
        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++)
            {
                int up=INT_MAX,left=INT_MAX,tmp;
                if (i-1>=0) up = f[i-1][j];
                if (j-1>=0) left = f[i][j-1];
                if (i==0 && j==0) tmp=0;
                else tmp =min(up,left);
                f[i].push_back(tmp+grid[i][j]);
            }
        }
        return f[row-1][col-1];
    }
};

62 Unique Paths
1.
class Solution {
public:
    int uniquePaths(int m, int n) {
        int f[m+5][n+5];
        for(int i=0;i<=m;i++)
            f[i][0] = 0;
        for(int i=0;i<=n;i++)
            f[0][i] = 0;
        f[0][1] = 1;
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++)
                f[i][j] = f[i-1][j] + f[i][j-1];
        return f[m][n];
    }
};

2. 
初始化二维vector
vector<vector<int> > v(m + 1, vector<int>(n + 1, 0));

初始化一维vector
vector<int> x(m+1,0);

59 Spiral Matrix II
class Solution {
public:
    vector< vector<int> > generateMatrix(int n) {
        vector< vector<int> > f(n+2, vector<int>(n+2,0));
        for(int i=0;i<=n+1;i++)
        {
            f[0][i] = -1;
            f[n+1][i] = -1;
            f[i][0] = -1;
            f[i][n+1] = -1;
        }
        int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
        int dir = 0, cnt = 0, total = n*n, x=1, y=0;
        while (cnt != total)
        {
            while (f[x + dx[dir % 4]][y + dy[dir % 4]]==0)
            {
                x += dx[dir % 4];
                y += dy[dir % 4];
                cnt++;
                f[x][y]=cnt;
            }
            dir++;
        }
        vector< vector<int> > ans(n, vector<int> (n));
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                ans[i][j]=f[i+1][j+1];
            }
        }
        return ans;
    }
};

46 Permutations
1.
class Solution {
public:
    vector<bool> flag;
    vector< vector<int> > ans;
    vector<int> per;
    vector< vector<int> > permute(vector<int>& nums) {
        flag.resize(nums.size());
        per.resize(nums.size());
        ans.clear();
        for(int i=0;i<flag.size();i++)
        {
            flag[i]=true;
            per[i]=0;
        }
        depthSearch(0,nums.size(),nums);
        return ans;
    }
    void depthSearch(int k,int n,vector<int> nums) {
        if (k==n)
        {
            ans.push_back(per);
            return;
        }
        for(int i=0;i<n;i++)
            if (flag[i])
            {
                flag[i]=false;
                per[k]=nums[i];
                depthSearch(k+1,n,nums);
                flag[i]=true;
            }
        return;
    }
};

2. 
next_permutation
class Solution {
public:
    vector< vector<int> > permute(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector< vector<int> > ans;
        ans.push_back(nums);
        while (next_permutation(nums.begin(),nums.end()))
            ans.push_back(nums);
        return ans;
    }
};

48 Rotate Image
1.
class Solution {
public:
    void rotate(vector< vector<int> >& matrix) {
        int n = matrix.size();
        int f[n][n];
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                f[j][n-i-1]=matrix[i][j];
            }
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                matrix[i][j]=f[i][j];
        }
    }
};

2.搜的思路
class Solution {
public:
    void rotate(vector< vector<int> >& matrix) {
        int n=matrix.size()-1;
        int m=n/2;
        for(int i=0;i<=n;i++)
            for(int j=0;j<=i;j++)
            {
                int tmp = matrix[i][j];
                matrix[i][j]=matrix[j][i];
                matrix[j][i]=tmp;
            }
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
            {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[i][n-j];
                matrix[i][n-j]=tmp;
            }
    }
};

53 Maximum Subarray
1.
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int ans,n=nums.size();
        int f[n];
        if (nums.size()==0) return 0;
        f[0]=nums[0];
        ans=nums[0];
        for(int i=1;i<n;i++)
        {
            f[i]=max(nums[i],f[i-1]+nums[i]);
            if (f[i]>ans) ans =f[i];
        }
        return ans;
    }
};

113 Path Sum II
class Solution {
public:
    vector< vector<int> > ans;
    vector<int> route;
    vector< vector<int> > pathSum(TreeNode* root, int sum) {
        route.clear();
        if (root==NULL) return ans;
        depthSearch(root,0,sum);
        return ans;
    }

    void depthSearch(TreeNode* root, int tmp, int sum)
    {
        route.push_back(root->val);
        tmp +=root->val;
        if (root->left!=NULL) depthSearch(root->left,tmp,sum);
        if (root->right!=NULL) depthSearch(root->right,tmp,sum);
        if (root->left==NULL && root->right==NULL & tmp==sum)
            ans.push_back(route);
        route.pop_back();
        tmp -=root->val;
        return ;
    }
};

16 3Sum Closest
class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int closest = nums[0] + nums[1] + nums[2];
        for(int i=0;i<nums.size()-2;i++)
        {
            if (i>0 & nums[i]==nums[i-1])
                continue;
            int l = i+1,r=nums.size()-1;
            while (l<r)
            {
                int tmp = nums[i]+nums[l]+nums[r];
                if (abs(tmp-target)<abs(closest-target))
                    closest = tmp;
                if (tmp==target)
                    return target;
                else
                    if (tmp>target)
                        r--;
                    else
                        l++;
            }
        }
        return closest;
    }
};