力扣每日一题2021 6月

(6.1)1744. 你能在你最喜欢的那天吃到你最喜欢的糖果吗？

func canEat(candiesCount []int, queries [][]int) []bool {
dp:=make([]int,len(candiesCount))
dp[0]=candiesCount[0]
    for i:=1;i<len(dp);i++{
        dp[i]=dp[i-1]+candiesCount[i]
    }
res:=make([]bool,len(queries))
for i:=0;i<len(queries);i++{
    fti:=queries[i][0]
    fdi:=queries[i][1]
    fci:=queries[i][2]
    x1:=fdi+1
    y1:=(fdi+1)*fci
    x2:=1
    if fti!=0{
        x2=dp[fti-1]+1
    }
    y2:=dp[fti]
    res[i]=(!(y1<x2||y2<x1))
}
return res
}

(6.2)523. 连续的子数组和

func checkSubarraySum(nums []int, k int) bool {
	dp := make([]int, len(nums)+1)
	for i := 1; i < len(dp); i++ {
		dp[i] = dp[i-1] + nums[i-1]
	}
    mp:=make(map[int]bool)
	for i := 2; i < len(dp); i++ {
	     mp[dp[i-2]%k]=true
         _,ok:=mp[dp[i]%k]
         if ok{
             return true 
         }
		}
	return false
}

(6.3)525. 连续数组

func max(i, j int) int {
	if i > j {
		return i
	} else {
		return j
	}
}
func findMaxLength(nums []int) int {
	dp := make([]int, len(nums)+1)
	dp[0] = -1
	for i := 1; i < len(dp); i++ {
		if nums[i-1] == 0 {
			dp[i] = dp[i-1] - 1
		} else {
			dp[i] = dp[i-1] + 1
		}
	}
	mp := make(map[int]int)
	res := 0
	for i := 2; i < len(dp); i++ {
		_, ok1 := mp[dp[i-2]]
		if !ok1 {
			mp[dp[i-2]] = i - 2
		}

		_, ok := mp[dp[i]]
		if ok {
			res = max(res, i-mp[dp[i]])
		}
	}
	return res
}

(6.4)160. 相交链表

func getIntersectionNode(headA, headB *ListNode) *ListNode {
flag:=0
cur1,cur2:=headA,headB
 for{
     if (flag>2) {
         return nil
     }
     if (cur1==cur2) {
         return cur1
     }
     if cur1.Next==nil{
         cur1=headB
          flag++
     }else{
         cur1=cur1.Next
        
     }
    if cur2.Next==nil{
         cur2=headA 
         flag++
     }else{
         cur2=cur2.Next
     }
 }
}

(6.4)160. 相交链表

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func getIntersectionNode(headA, headB *ListNode) *ListNode {
flag:=0
cur1,cur2:=headA,headB
 for{
     if (flag>2) {
         return nil
     }
     if (cur1==cur2) {
         return cur1
     }
     if cur1.Next==nil{
         cur1=headB
          flag++
     }else{
         cur1=cur1.Next
        
     }
    if cur2.Next==nil{
         cur2=headA 
         flag++
     }else{
         cur2=cur2.Next
     }
 }
}

(6.5)203. 移除链表元素

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeElements(head *ListNode, val int) *ListNode {
anchor:=&ListNode{}
anchor.Next=head
cur1,cur2:=anchor,head
for{
    for{
        if cur2==nil||cur2.Val!=val {
            break}
        cur2=cur2.Next
      }
      cur1.Next=cur2
      cur1=cur2
       if cur2==nil {
        break}
      cur2=cur2.Next
    }
    return anchor.Next
}

(6.6)474. 一和零

func max(i,j int)int{
    if i>j {
        return i
    }else{
        return j
    }
}
func findMaxForm(strs []string, m int, n int) int {
v0:=make([]int,len(strs))
v1:=make([]int,len(strs))
for i:=0;i<len(v0);i++{
    f1:=[]byte(strs[i])
    for j:=0;j<len(f1);j++{
        if f1[j]=='1'{
            v1[i]++
        }else{
            v0[i]++
        }
    }
}

dp:=make([][]int,m+1)
for i,_:=range dp{
    dp[i]=make([]int,n+1)
}


for i:=0;i<len(strs);i++{
    for j:=m;j>=0;j--{
          for k:=n;k>=0;k--{
            if j>=v0[i]&&k>=v1[i]{
                dp[j][k]=max(dp[j-v0[i]][k-v1[i]]+1,dp[j][k])
            }
          }
    }
}
return dp[m][n]



}

(6.8)494. 目标和

//dfs
func dfs(nums[]int,target int,i int,ans int)int{
 if i>=len(nums) {
       if ans !=target{
           return 0
       }else{
           return 1
       }
 }

return dfs(nums,target,i+1,ans-nums[i])+dfs(nums,target,i+1,ans+nums[i])

}

func findTargetSumWays(nums []int, target int) int {
return dfs(nums,target,0,0)
}
//dp
func abs(i int)int{
    if i<0{
        return -i
    }else{
        return i
    }
}


func findTargetSumWays(nums []int, target int) int {
sum:=0
for _,v:=range nums{
sum+=abs(v)
}
if (target>sum||(sum-target)%2!=0) {
    return 0}
m:=(sum-target)/2
dp:=make([][]int,len(nums)+1)
for i,_:=range dp{
    dp[i]=make([]int,m+1)
}
dp[0][0]=1

for i:=1;i<len(dp);i++{
    for j:=0;j<len(dp[0]);j++{ 
     dp[i][j]+=dp[i-1][j]
       if(j>=nums[i-1]){
       dp[i][j]+=dp[i-1][j-nums[i-1]]}
    }
}
return dp[len(nums)][m]
}

(6.8) 1049. 最后一块石头的重量 II

func max(i,j int)int{
    if i<j{
        return j
    }else{
        return i
    }
}
func abs(i int)int{
    if i<0{
        return -i
    }else{
        return i
    }
}
func lastStoneWeightII(stones []int) int {
sum:=0
for _,v:=range stones{
sum+=v
}
t:=sum/2
dp:=make([][]int,len(stones)+1)
for i,_:=range dp{
    dp[i]=make([]int,t+1)
}
for i:=1;i<len(dp);i++{
    for j:=0;j<=t;j++{
      dp[i][j]=dp[i-1][j]
     if j>=stones[i-1]{
     dp[i][j]=max(dp[i][j],dp[i-1][j-stones[i-1]]+stones[i-1])
     }
    }
}

return abs(sum-dp[len(stones)][t]-dp[len(stones)][t])

}