力扣每日一题2021 5月

(5.1)690. 员工的重要性

/*
// Definition for Employee.
class Employee {
public:
    int id;
    int importance;
    vector<int> subordinates;
};
*/

class Solution {
    int res=0;
    void dfs(Employee a,vector<Employee*> employees)
    {
        res+=a.importance;
        for(int i=0;i<a.subordinates.size();i++)
        {
           for(int j=0;j<employees.size();j++)
           {
               if(employees[j]->id==a.subordinates[i]) dfs(*employees[j],employees);
           }
        }
    }
public:
    int getImportance(vector<Employee*> employees, int id) {
          for(int j=0;j<employees.size();j++)
           {
               if(employees[j]->id==id) 
               {dfs(*employees[j],employees);
               break;}
           }
           return res;
    }
};

(5.3)7. 整数反转

class Solution {
public:
    int reverse(int x) {
        long n=0;
            while(x!=0){
               n=n*10+x%10;
              x=x/10;
            }
            return (n>INT_MAX||n<INT_MIN) ? 0:int(n);
    }
};

(5.5)740. 删除并获得点数

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) {
   int n=nums.size();
   sort(nums.begin(),nums.end());
   int max_v=nums[n-1];
   vector<int>target(max_v+1,0);
   for(int i=0;i<nums.size();i++)
   {
       target[nums[i]]=target[nums[i]]+nums[i];
   }
   vector<int>dp(max_v+1,0);
   dp[1]=target[1];
   for(int i=2;i<=max_v;i++)
   {
    dp[i]=max(dp[i-2]+target[i],dp[i-1]);
   }
   return dp[max_v];
    }
};

(5.6)1720. 解码异或后的数组

class Solution {
public:
    vector<int> decode(vector<int>& encoded, int first) {
     vector<int>res;
     int f=first;
     res.push_back(first);
     for(int i=0;i<encoded.size();i++)
     {
         res.push_back(f^encoded[i]);
         f=res.back();
     }
     return res;
    }
};

(5.7)1486. 数组异或操作

class Solution {
public:
    int xorOperation(int n, int start) {
    int res=start;
    for(int i=1;i<n;i++)
    {
      int f=start+2;
      res=res^f;
      start=f;
    }
    return res;
    }
};

(5.8)1723. 完成所有工作的最短时间

//二分查找
class Solution {

   bool dfs(vector<int>& jobs,vector<int>& work,int mid,int i)
   {
       if(i>=jobs.size()) return true;
       for(auto& w:work)
       {
           if(w+jobs[i]<=mid)
           {
               w+=jobs[i];//第j个工人选择该工作
               if(dfs(jobs,work,mid,i+1)) return true;
               w-=jobs[i];//第j个工人不选择该工作
           }
           if(w==0||w+jobs[i]==mid) break;
       }
       return false;
   }

    bool check(vector<int>& jobs,int mid,int k)
    {
        vector<int>work(k,0);
        return dfs(jobs,work,mid,0);
    }
public:
    int minimumTimeRequired(vector<int>& jobs, int k) {
    sort(jobs.begin(),jobs.end(),greater<int>());
    int l=jobs[0];
    int r=accumulate(jobs.begin(),jobs.end(),0);
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(check(jobs,mid,k))
         r=mid;
        else
         l=mid+1;
    }
    return l;
    }
};

(5.9)1482. 制作 m 束花所需的最少天数

class Solution {
    bool check(int mid, vector<int>bloomDay, int m, int k)
    {
        int curflower = 0;
       
        for (int i =0; i < bloomDay.size(); i++)
        {
            bloomDay[i] = bloomDay[i] - mid < 0 ? 0 : bloomDay[i] - mid;
            if (bloomDay[i] == 0)
            {
                if (i > 0 && bloomDay[i] == bloomDay[i - 1])curflower++;
                else curflower = 1;
            }
            if (curflower == k) { m--; curflower = 0; }
            if (m == 0) return true;
        }
        return false;
    }
public:
    int minDays(vector<int>& bloomDay, int m, int k) {
        if (bloomDay.size() < m * k) return -1;
        int l = *min_element(bloomDay.begin(), bloomDay.end());
        int r = *max_element(bloomDay.begin(), bloomDay.end());
        while (l < r)
        {
            int mid = (l + r) >> 1;
            if (check(mid, bloomDay, m, k))
                r = mid;
            else
                l = mid + 1;
        }
        return l;
    }
};

(5.10)872. 叶子相似的树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
        vector<int>a;
        vector<int>b;
    void dfs(TreeNode* t,vector<int>&a)
    {
        if(t==nullptr) return;
        if(!t->left&&!t->right)
         {a.push_back(t->val);return;}
        dfs(t->left,a);
        dfs(t->right,a);
    }
public:
    bool leafSimilar(TreeNode* root1, TreeNode* root2){
        dfs(root1,a);
        dfs(root2,b);
        if(a.size()!=b.size()) return false;
        for(int i=0;i<a.size();i++)
        {
            if(a[i]!=b[i]) return false;
        }
        return true;
    }
};

(5.11)1734. 解码异或后的排列

class Solution {
public:
    vector<int> decode(vector<int>& encoded) {
        int a=0;int n=encoded.size();
        for(int i=0;i<n;i+=2)
        {
          a^=encoded[i];
        }
        int b=0;
        for(int i=1;i<=n+1;i++)
        {
            b^=i;
        }
        vector<int>res(n+1,0);
        res[n]=a^b;
        for(int i=n-1;i>=0;i--)
        {
            res[i]=res[i+1]^encoded[i];
        }
     return res;
    }
};

(5.12)1310. 子数组异或查询

class Solution {
public:
    vector<int> xorQueries(vector<int>& arr, vector<vector<int>>& queries) {
        vector<int>dp;
        int n=arr.size();
        dp.resize(n,0);
        dp[0]=arr[0];
        for(int i=1;i<n;i++)
        dp[i]=arr[i]^dp[i-1];
        vector<int>res;
        for(int i=0;i<queries.size();i++)
        {
         res.push_back(dp[queries[i][0]]^dp[queries[i][1]]^arr[queries[i][0]]);
        }
        return res;
    }
};

(5.13)

(5.14)12. 整数转罗马数字（今天开始用GO打卡）

var val = [...]int{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}
var s = [...]string{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}

func intToRoman(num int) string {
    var res string = ""
	for i := 0; i < len(val); i++ {

		for {
			if val[i] > num {
				break
			}
			num -= val[i]
			res += s[i]
		}

	}
	return res
}

(5.15)13. 罗马数字转整数

var (
	ss  = [...]string{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}
	val = [...]int{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}
)

func romanToInt(s string) int {
	res := 0
		for i := 0; i < len(ss); i++ {
			for{ 
                if !strings.HasPrefix(s, ss[i]) {
                    break} //判断是否有前缀SS[i]
				s = strings.TrimPrefix(s, ss[i]) //返回去除前缀为SS[i]的子串
				res += val[i]
            
            }
        }
	return res
}

(5.16)421. 数组中两个数的最大异或值

type TrimTree struct {
	left, right *TrimTree //l:1 r:0

}

func (root *TrimTree) addTrimTree(num int) {
	cur := root
	for i := 31; i >= 0; i-- {
		j := (num >> i) & 1
		if j == 1 {
			if cur.left == nil {

				cur.left = new(TrimTree)
			}
			cur = cur.left
		} else {
			if cur.right == nil {
				cur.right = new(TrimTree)
			}
			cur = cur.right
		}
	}
}
func (root *TrimTree) check(num int) int {
	res := 0
	cur := root
	for i := 31; i >= 0; i-- {
		j := (num >> i) & 1
		if j == 1 {
			if cur.right != nil {
				res = res*2 + 1
				cur = cur.right
			} else {
				res = res * 2
				cur = cur.left
			}
		} else {
			if cur.left != nil {
				res = res*2 + 1
				cur = cur.left
			} else {
				res = res * 2
				cur = cur.right
			}
		}
	}
	return res
}
func maxint(a int, b int) int {
	if a >= b {
		return a
	} else {
		return b
	}
}
func findMaximumXOR(nums []int) int {
	max_v := 0
	root := &TrimTree{}
	for i := 1; i < len(nums); i++ {
		root.addTrimTree(nums[i-1])
		max_v = maxint(max_v, root.check(nums[i]))
	}
	return max_v
}

(5.17)993. 二叉树的堂兄弟节点

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
 func maxint(a int,b int)int{
   if a>b {
       return a
   }else{
       return b
   }
 }
func dfs(root *TreeNode,x int,y int,sum int)int {
      if root==nil {
          return 0}
      if root.Val==x{
         return sum}
    if root.Right!=nil&&root.Left!=nil{
      if (root.Right.Val==x&& root.Left.Val==y){
          return 0}
     }
      return maxint(dfs(root.Left,x,y,sum+1),dfs(root.Right,x,y,sum+1))
}
func isCousins(root *TreeNode, x int, y int) bool {
     if dfs(root,x,y,0)==dfs(root,y,x,0) && dfs(root,x,y,0)!=0{
         return true
     }else{
         return false
     }
  }
  

(5.18)1442. 形成两个异或相等数组的三元组数目

func countTriplets(arr []int) int {
    dp:=make([]int,len(arr)+1)
    dp[0]=0
    dp[1]=arr[0]
    for i:=2;i<=len(arr);i++{
        dp[i]=dp[i-1]^arr[i-1]
    }
    res:=0
    for i:=0;i<=len(arr);i++{
        for j:=i+1;j<=len(arr);j++{
                if dp[i]==dp[j]{
                    res++
                }
            }
        }
    }
    return res 
}

(5.19)1738. 找出第 K 大的异或坐标值

func kthLargestValue(matrix [][]int, k int) int {
	dp := make([][]int, len(matrix))
	for i := range dp {
		dp[i] = make([]int, len(matrix[0]))
		dp[i][0] = matrix[i][0]
	}
	for i := 0; i < len(dp); i++ {
		for j := 1; j < len(dp[0]); j++ {
			dp[i][j] = dp[i][j-1] ^ matrix[i][j]
		}
	}
	for i := 1; i < len(dp); i++ {
		for j := 0; j < len(dp[0]); j++ {
			dp[i][j] = dp[i-1][j] ^ dp[i][j]
		}
	}
	res:=make([]int,len(matrix)*len(matrix[0]))
    for i := 0; i < len(dp); i++ {
		for j := 0; j < len(dp[0]); j++ {
            res[j+i*len(dp[0])]=dp[i][j]
        }   
    }
     sort.Sort(sort.Reverse(sort.IntSlice(res)))
    return res[k-1]
}

(5.20)692. 前K个高频单词

func topKFrequent(words []string, k int) []string {
	mp := make(map[string]int)
	for _, v := range words {
		mp[v]++
	}
    type wd struct{
        s string
        n int
    }
	var wds []wd
	for k, v := range mp {
		wds = append(wds, wd{k, v})
	}
	sort.Slice(wds, func(i,j int)bool{
        if wds[i].n > wds[j].n {
		return true
	} else if wds[i].n < wds[j].n {
		return false
	} else {
		if wds[i].s < wds[j].s{
			return true
		} else {
			return false
		}
	}
    })
	res := make([]string, 0)
	for i := 0; i < k; i++ {
		res = append(res, wds[i].s)
	}
	return res
}

(5.21)1035. 不相交的线

func maxInt(a int,b int)int{
    if a>b {
        return a
    }else{
        return b
    }
}
func maxUncrossedLines(nums1 []int, nums2 []int) int {
  dp:=make([][]int,len(nums1)+1)
  for i:=0;i<len(nums1)+1;i++{
      dp[i]=make([]int,len(nums2)+1)
  }
  for i:=1;i<len(nums1)+1;i++{
      for j:=1;j<len(nums2)+1;j++{
            if nums1[i-1]==nums2[j-1]{
                dp[i][j]=dp[i-1][j-1]+1
            }else{
                dp[i][j]=maxInt(dp[i-1][j],dp[i][j-1])
            }
      }
  }
  return dp[len(nums1)][len(nums2)]
}

(5.22)1035. 不相交的线

func xorGame(nums []int) bool {
sum:=0
for i:=0;i<len(nums);i++{
    sum^=nums[i]
}
return sum==0||len(nums)%2==0
}

(5.23)1707. 与数组中元素的最大异或值

type TrimTree struct {
	c [2]*TrimTree //l:1 r:0
}

func (root *TrimTree) addTrimTree(num int) {
	cur := root
	for i := 29; i >= 0; i-- {
		bit := num >> i & 1
		if cur.c[bit] == nil {
			cur.c[bit] = &TrimTree{}
		}
		cur = cur.c[bit]
	}

}
func (root *TrimTree) check(num int) int {
	cur := root
	res := 0
	for i := 29; i >= 0; i-- {
		bit := (num >> i) & 1
		if cur.c[bit^1] != nil {
			res |= 1 << i
			bit ^= 1
		}
		cur = cur.c[bit]
	}
	return res
}
func maximizeXor(nums []int, queries [][]int) []int {
	res := make([]int, len(queries))
	sort.Ints(nums)
	//矩阵扩维存其索引值
	for i := range queries {
		queries[i] = append(queries[i], i)
	}
	//queries排序
	sort.Slice(queries, func(i, j int) bool {
		return queries[i][1] < queries[j][1]
	})
	j, root := 0, &TrimTree{}
	for _, q := range queries {
		x, limit, index := q[0], q[1], q[2]
		for j < len(nums) && nums[j] <= limit {
			root.addTrimTree(nums[j])
			j++
		}
		if j == 0 {
			res[index] = -1
		} else {
			res[index] = root.check(x)
		}
	}
	return res
}

(5.24)664. 奇怪的打印机

func intmin(a,b int)int{
    if a<b{
        return a
    }else{
        return b
    }
}
func strangePrinter(s string) int {
	n:=len(s)
    dp := make([][]int, n)
    for i:=0;i<len(dp);i++{
       dp[i]=make([]int,n)
       dp[i][i]=1
    }
    for i:=n-1;i>=0;i--{
        for j:=i+1;j<n;j++{
            if s[i]==s[j]{
                dp[i][j]=dp[i][j-1]
            }else{
                minn:= int(^uint(0) >> 1)
                for k:=i;k<j;k++{
                    minn=intmin(minn,dp[i][k]+dp[k+1][j])
                }
                dp[i][j]=minn
            }
        }
    }
	
	return dp[0][n-1]
}

(5.25)1787. 使所有区间的异或结果为零

const inf=math.MaxInt32
const max=1<<10
func minint(a,b int)int{
    if a<b {
        return a
    }else{
        return b
    }
}
func minChanges(nums []int, k int) int {
n:=len(nums)
dp:=make([][]int,k)
for i:=range dp{
    dp[i]=make([]int,max)
}
g:=make([]int,k)
for i:=0;i<len(dp);i++{
    for j:=0;j<len(dp[0]);j++{
        dp[i][j]=inf
    }
    g[i]=inf
}
for i:=0;i<k;i++{
    cnt:=0
    mp:=make(map[int]int)
    for j:=i;j<n;j+=k{
        mp[nums[j]]++
        cnt++
    }
    if i==0{
        for xor:=0;xor<max;xor++{
            v,ok:=mp[xor]
            if ok==true{
                dp[0][xor]=minint(dp[0][xor],cnt-v)
            }else{
                 dp[0][xor]=minint(dp[0][xor],cnt)
            }
           g[0]=minint(g[0],dp[0][xor])
        }
    }else{
        for xor:=0;xor<max;xor++{
            dp[i][xor]=g[i-1]+cnt//整列替换
            for k1,v1:=range mp{
                dp[i][xor]=minint(dp[i][xor],dp[i-1][xor^k1]+cnt-v1)
            }
             g[i]=minint(g[i],dp[i][xor])
        }
    }
}
return dp[k-1][0]
}

(5.26)1190. 反转每对括号间的子串

func swap(s []byte,i int,j int){
    for ;i<j;i++{
        s[i],s[j]=s[j],s[i]
        j--
    }
}
func reverseParentheses(s string) string {
s1:=[]byte(s)
stack:=[]int{}
for i:=0;i<len(s);i++{
    if s1[i]=='('{
        stack=append(stack,i)
    }
    if s1[i]==')'{
        swap(s1,stack[len(stack)-1],i)
        stack=stack[:len(stack)-1]
    }
}
s=string(s1)
s=strings.Replace(s, "(", "", -1)
s=strings.Replace(s, ")", "", -1)
return s
}

(5.27)461. 汉明距离

func hammingDistance(x int, y int) int {
res:=0
x=x^y
for ;x!=0;x=x>>1{
    if x&1==1{
        res++
    }  
}
return res
}

(5.28)477. 汉明距离总和

func totalHammingDistance(nums []int) int {
   res:=0
   a1:=make([]int,32)
   n:=len(nums)
   for i:=0;i<n;i++{
       j:=0
      for ;nums[i]>0;nums[i]=nums[i]>>1{
          if nums[i]&1==1{
              a1[j]++
          }
          j++
      }
   }
   for i:=0;i<len(a1);i++{
       res+=a1[i]*(n-a1[i])
   }
   return res 
}

(5.29)1074. 元素和为目标值的子矩阵数量

func numSubmatrixSumTarget(matrix [][]int, target int) int {
	var m, n int = len(matrix), len(matrix[0])
	dp := make([][]int, m+1)
	for i := range dp {
		dp[i] = make([]int, n+1)
	}
	for i := 1; i < m+1; i++ {
		for j := 1; j < n+1; j++ {
			dp[i][j] = dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + matrix[i-1][j-1]
		}
	}
	res := 0
	for top := 1; top < m+1; top++ {
		for bot := top; bot < m+1; bot++ {
			cur := 0
			mp := make(map[int]int)
			for r := 1; r < n+1; r++ {
				cur = dp[bot][r] - dp[top-1][r]
				if cur == target {
					res++
				}
				_, ok := mp[cur-target]
				if ok {
					res += mp[cur-target]
				}
				mp[cur]++
			}
		}
	}
	return res
}

(5.30)231. 2 的幂

func isPowerOfTwo(n int) bool {
res:=0
for;n>0;n=n>>1{
    if res>1{
        break
    }
    if n&1==1{
        res++
    }
}
if res==1 {
    return true
}else{
    return false
}
}


//
func isPowerOfTwo(n int) bool {
if n<=0{
return false
}
return n&(n-1)==0
}

(5.31)342. 4的幂

func isPowerOfFour(n int) bool {
	if n <= 0 {
		return false
	}
	var n1 int
	n1 = int(math.Sqrt(float64(n)))
	return n1*n1 == n && n&(n-1) == 0
}