LeetCode Weekly Contest 32 解题报告

第一次参加leetcode的比赛，刚开始全得用class写十分不适应，这场表现的不是很好，以后继续努力吧……

A.Shortest Unsorted Continuous Subarray

class Solution {
public:
    int findUnsortedSubarray(vector<int>& nums) {
        priority_queue<int>que;
        que.push(nums[0]);
        int lo=-1,an=0;
        for(int i=1;i<nums.size();++i)
        {
            if(nums[i]<que.top())
            {
                    for(int j=0;j<i;++j)
                    {
                        if(nums[j]>nums[i])
                        {
                            if(lo==-1)
                            lo=j;
                            else
                                lo=min(lo,j);
                            an=i-lo+1;
                            break;
                        }
                    }
            }
            que.push(nums[i]);
        }
        return an;
    }

};

最开始想法有点问题，一直在想着用单调栈写，卡了很久……改成直接暴力居然就直接过了，用时也很短，失误。

B.Kill Process

class Solution {
public:
    vector<int> killProcess(vector<int>& pid, vector<int>& ppid, int kill) {
        const int MAX=1e5+5;
        vector <int> an,son[MAX];
        for(int i=0;i<pid.size();++i)
        {
            son[ppid[i]].push_back(pid[i]);
        }
        queue<int> que;
        que.push(kill);
        while(!que.empty())
        {
            int tem=que.front();que.pop();
            an.push_back(tem);
            for(int i=0;i<son[tem].size();++i)
            {
                que.push(son[tem][i]);
            }
        }
        return an;
    }
};

非常非常水的题，按要求搜索即可。

C.Delete Operation for Two Strings

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1=word1.length(),len2=word2.length();
        int a[len1+5][len2+5];
        memset(a,0,sizeof(a));
        for(int i=0;i<=len1;i++)
            a[i][0]=0;
        for(int j=0;j<=len2;j++)
            a[0][j]=0;
        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;j++)
            {
                if(word1[i-1]==word2[j-1])
                    a[i][j]=a[i-1][j-1]+1;
                else
                    a[i][j]=max(a[i][j-1],a[i-1][j]);
            }
        }
        return len1+len2-2*a[len1][len2];
    }
};

LCS问题，数组下标从1开始比较好，刚开始从0开始一直wa一些数据……

D.Erect the Fence

class Solution {
public:
    /*计算两点之间距离*/
    static int dis(Point p1,Point p2)
    {
        return (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y);
    }
    /*利用×乘 计算三点之间关系 0：共线 1：依次成顺时针 2：依次成逆时针*/
    static int orientation(Point p1,Point p2,Point p3)
    {
        int val=(p3.y-p1.y)*(p2.x-p1.x)-(p3.x-p1.x)*(p2.y-p1.y);
        if(val==0)
            return 0;
        else
            return val>0?2:1;
    }
    /*将点排序 采用结构体进行排序 第一次见*/
    struct pointsComparator
    {
        Point p0;/*基准点*/
        bool operator() (const Point& p1,const Point&  p2)
        {
            int val=orientation(p0,p1,p2);
            if(val==0)
                return dis(p0,p1)<=dis(p0,p2);
            else
                return val==2;
        }
        pointsComparator(Point p): p0(p){}
    };
    vector<Point> outerTrees(vector<Point>& points) {
        int n=points.size();
        if(n<=3)
            return points;
        int ymin=points[0].y,minlo=0;/*找y坐标最小的点，记录其下标*/
        for(int i=1;i<n;++i)
        {
            if(points[i].y<ymin||(points[i].y==ymin&&points[i].x<points[minlo].x))
                ymin=points[i].y,minlo=i;
        }
        Point tem=points[0];
        points[0]=points[minlo];
        points[minlo]=tem;
        Point p0=points[0];
        sort(points.begin(),points.end(),pointsComparator(p0));
        
        
        Point pn = points.back();
        if (orientation(p0, points[1], pn) != 0) {//非所有点都共线
            int idx = n-1;
            while (orientation(p0, points[idx], pn) == 0) {//找到
                idx--;
            }
            reverse(points.begin() + idx + 1, points.end());//调序？？为啥
        }
        
        
        vector<Point> vertices;
        vertices.push_back(points[0]);
        vertices.push_back(points[1]);
        vertices.push_back(points[2]);
        for(int i=3;i<n;++i)
        {
            while(orientation(vertices[vertices.size()-2],vertices.back(),points[i])==1)
                vertices.pop_back();
            vertices.push_back(points[i]);
        }
        return vertices;
    }
};

学到很多的题目，利用了一些几何性质。