LeetCode Weekly Contest 32

581. Shortest Unsorted Continuous Subarray

Given an integer array, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order, too.

You need to find the shortest such subarray and output its length.

Input: [2, 6, 4, 8, 10, 9, 15]
Output: 5
Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.

排好序，然后对比一下就行了

 class Solution {
 public:
     int findUnsortedSubarray(vector<int>& nums) {
         int n=nums.size();
         vector<int> nums2;
         nums2.insert(nums2.end(),nums.begin(),nums.end());
         sort(nums2.begin(),nums2.end());
         int st=,ed=n-;
         while(st!=n&&nums2[st]==nums[st])  st++;
         while(ed!=-&&nums2[ed]==nums[ed])  ed--;
         if(st==n)   return ;
         return ed-st+;
     }

 };

582. Kill Process

删除一个树上的节点，求出所有子节点编号

真的很生疏了，树都不知道怎么遍历了

由于可能编号开的很大，因此用map作下映射，不说数据范围真坑，一直TLE（leetcode有TLE？），最后改了下数组大小AC了

Input:
pid =  [1, 3, 10, 5]
ppid = [3, 0, 5, 3]
kill = 5
Output: [5,10]
Explanation:
           3
         /   \
        1     5
             /
            10
Kill 5 will also kill 10.

 class Solution {
 public:
 vector<int> ans;
         map<int,int> mp;
         map<int,int> fmp;
         int tot;
 vector<int> g[];
     void dfs(int i){
         ans.push_back(fmp[i]);
         for(int j=;j<g[i].size();j++){
             dfs(g[i][j]);
         }
     }
     vector<int> killProcess(vector<int>& pid, vector<int>& ppid, int kill) {
         int n=pid.size();
         int i,st;
         tot=;
         for(i=;i<n;i++){
             if(!mp[ppid[i]]){
                 mp[ppid[i]]=tot;
                 fmp[tot]=ppid[i];
                 tot++;
             }
             if(!mp[pid[i]]){
                 mp[pid[i]]=tot;
                 fmp[tot]=pid[i];
                 tot++;
             }
             int u=mp[ppid[i]],v=mp[pid[i]];
             g[u].push_back(v);
         }
         dfs(mp[kill]);
         return ans;

     }
 };

583. Delete Operation for Two Strings

Given two words word1 and word2, find the minimum number of steps required to make word1 and word2 the same, where in each step you can delete one character in either string.

Input: "sea", "eat"
Output: 2
Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".

求下最长公共序列，注意是序列不是子串，因为对于abcab,abab这样的情况，公共子串就无法解决，求完之后减一下就可以了

 class Solution {
 public:
 int Max(int a,int b)
 {
     return (a>b)?a:b;
 }
 int creatDp(string s1,string s2,int *dp)
 {
     int len1 = s1.length();
     int len2 = s2.length();
     //int *dp = new int[len1*len2];
     //先求出第一行
     for(int j = ;j<len2;j++)
     {
         if(s1[] == s2[j]){
             *(dp+*len2+j) = ;
             for(;j<len2;j++)
                 *(dp+*len2+j) = ;
             break;
         }
         else
                 *(dp+*len2+j) = ;
     }
     //然后求第一列
     for(int i = ;i<len1;i++)
     {
         if(s1[i] == s2[]){
             *(dp+i*len2+) = ;
             for(;i<len1;i++)
                 *(dp+i*len2+) = ;
             break;
         }
         else
             *(dp+i*len2+) = ;
     }
     //求其他的数据
     for(int i =;i<len1;i++)
     {
         for(int j =;j<len2;j++)
         {
             if(s1[i] == s2[j])
                 *(dp+i*len2+j) = *(dp+(i-)*len2+(j-))+;
             else
                 *(dp+i*len2+j) = Max(*(dp+(i-)*len2+j),*(dp+i*len2+j-));
         }
     }
    return dp[len1*len2-];
 }
     int minDistance(string word1, string word2) {
         int len1 = word1.length();
         int len2 = word2.length();
         int *dp = new int[len1*len2];
         int w=creatDp(word1, word2,dp);
         return len1-w+len2-w;
     }
 };

587. Erect the Fence

裸凸包问题，找了几个模板都没套进去，重载操作符没法用，23333，leetcode真坑