*188. Best Time to Buy and Sell Stock IV
class Solution {
public static int MIN_VALUE= (int) -1e6;
public int maxProfit(int k, int[] prices) {
int times=prices.length;
int [][][] dp=new int[times+1][k+2][2];
for (int i=0;i<times;i++){
for (int j=0;j<=k+1;j++){
Arrays.fill(dp[i][j],MIN_VALUE);
}
}
for (int j=1;j<=k+1;j++){
dp[0][j][0]=0;
}
for (int i=0;i<times;i++){
for (int j=1;j<=k+1;j++){
dp[i+1][j][0]=Math.max(dp[i][j][0],dp[i][j-1][1]+prices[i]);
dp[i+1][j][1]=Math.max(dp[i][j][1],dp[i][j][0]-prices[i]);
}
}
return dp[times][k+1][0];
}
}
190. Reverse Bits
public int reverseBits(int n) {
int[] res=new int[32];
for (int i=0;i<32;i++){
res[i]=n>>i&1;
}
int val=0;
for (int i=0;i<31;i++){
val+=res[i];
val = val<<1;
}
val+=res[31];
return val;
}
更好地解法
public int reverseBits(int n) {
int[] res=new int[32];
int val=0;
for (int i=0;i<32;i++){
res[i]=n>>i&1;
val = val |(res[i]<<(31-i));
}
return val;
}
202. Happy Number
public boolean isHappy(int n) {
HashSet<Integer> set=new HashSet<>();
while (true){
int sum=0;
while (n>0){
int curr=n%10;
n/=10;
sum+=curr*curr;
}
if (sum==1){
return true;
}
if (set.contains(sum)){
return false;
}
n=sum;
set.add(sum);
}
}
*201. Bitwise AND of Numbers Range
public int rangeBitwiseAnd(int left, int right) {
if (left==right){
return left;
}
int res=left^right;
int count=0;
for (int i=31;i>=0;i--){
if (res>>i!=0){
break;
}
count++;
}
count=32-count;
return (right>>count)<<count;
}
203. Remove Linked List Elements
public ListNode removeElements(ListNode head, int val) {
ListNode dummy=new ListNode(1);
dummy.next=head;
ListNode prev=dummy;
ListNode curr=head;
while (curr!=null){
if (curr.val==val){
prev.next=curr.next;
curr=curr.next;
}
else{
prev=curr;
curr=curr.next;
}
}
return dummy.next;
}
204. Count Primes
public int countPrimes(int n) {
boolean[] bits=new boolean[n+1];
for (int i=2;i<=n/2;i++){
if (!bits[i]){
int j=i*2;
while (j<n){
bits[j]=true;
j+=i;
}
}
}
int count=0;
for (int i=2;i<n;i++){
if (!bits[i]){
count++;
}
}
return count;
}
205. Isomorphic Strings
public boolean isIsomorphic(String s, String t) {
HashMap<Character,Character> map=new HashMap<>(26);
for (int i=0;i<t.length();i++){
if (map.containsKey(s.charAt(i))&&map.get(s.charAt(i))!=t.charAt(i)){
return false;
}
else if (!map.containsKey(s.charAt(i))&& map.containsValue(t.charAt(i))){
return false;
}
else if (!map.containsKey(s.charAt(i))){
map.put(s.charAt(i),t.charAt(i));
}
}
return true;
}
206. Reverse a Linked List
public ListNode reverseList(ListNode head) {
if(head==null){
return null;
}
ListNode prev=null;
ListNode curr=head;
ListNode next;
while(curr!=null){
next = curr.next;
curr.next=prev;
prev=curr;
curr=next;
}
return prev;
}
207. Course Schedule
class Solution {
public static HashSet<Integer> visited=new HashSet<>();
public static HashSet<Integer> overallVisited=new HashSet<>();
public boolean canFinish(int numCourses, int[][] prerequisites) {
visited.clear();
overallVisited.clear();
int[] courses=IntStream.range(0,numCourses).toArray();
HashMap<Integer,ArrayList<Integer>> prerequisitesMap=new HashMap<>();
for(var c:courses){
prerequisitesMap.put(c,new ArrayList<>());
}
for(var arr:prerequisites){
prerequisitesMap.get(arr[0]).add(arr[1]);
}
for(int course:courses){
if(overallVisited.contains(course)){
continue;
}
if(!dfs(course,prerequisitesMap)){
return false;
}
}
return true;
}
public boolean dfs(int course,HashMap<Integer,ArrayList<Integer>> prerequisitesMap){
overallVisited.add(course);
if(visited.contains(course)){
return false;
}
if(prerequisitesMap.get(course).isEmpty()){
return true;
}
visited.add(course);
var currPrerequisites=prerequisitesMap.get(course);
for(int c:currPrerequisites){
if(!dfs(c,prerequisitesMap)){
return false;
}
}
visited.remove(course);
prerequisitesMap.get(course).clear();
return true;
}
}
208. Implement Trie (Prefix Tree)
public static class TrieNode{
public HashMap<Character,TrieNode> children=new HashMap<>();
public boolean endOfWord=false;
}
public TrieNode root=new TrieNode();
public Trie() {
}
public void insert(String word) {
var curr=root;
for(int i=0;i<word.length();i++){
if (!curr.children.containsKey(word.charAt(i))){
curr.children.put(word.charAt(i),new TrieNode());
}
curr=curr.children.get(word.charAt(i));
}
curr.endOfWord=true;
}
public boolean search(String word) {
var curr=root;
for (int i=0;i<word.length();i++){
if (curr.children.containsKey(word.charAt(i))){
curr=curr.children.get(word.charAt(i));
}
else {
return false;
}
}
return curr.endOfWord;
}
public boolean startsWith(String prefix) {
var curr=root;
for (int i=0;i<prefix.length();i++){
if(!curr.children.containsKey(prefix.charAt(i))){
return false;
}
curr=curr.children.get(prefix.charAt(i));
}
return true;
}
*209. Minimum Size Subarray Sum
public int minSubArrayLen(int target, int[] nums) {
int minLength=111111;
int left=0;
int right=0;
int sum=0;
int currLength=0;
while (right<nums.length){
target-=nums[right];
if (target<=0){
currLength=right-left+1;
minLength=Math.min(currLength,minLength);
}
while (target<=0){
target+=nums[left];
left++;
minLength=Math.min(minLength,right-left+2);
}
right++;
}
if (minLength==111111){
return 0;
}
return minLength;
}