leetcode 234 questions / 264 questions / 338 one bit Python 3 questions

Method 1: speed pointer + reverse linked list

This O1 is so hard. Set the function to reverse the linked list, and then set the fast and slow pointer to find half of the nodes in the linked list (the fast pointer is always one step faster than the slow pointer, so when the fast pointer comes to the end, the slow pointer is just at half of the linked list). Reverse the latter half of the list to check the first half of the list = = the second half of the list.

```class Solution:
def isPalindrome(self, head: ListNode) -> bool:
second_half_start = self.reverseList(first_half_end.next)

second_position = second_half_start
while second_position:
if first_position.val != second_position.val:
return False
first_position = first_position.next
second_position = second_position.next
return True

def reverseList(self, head: ListNode) -> ListNode:
return cur

while fast.next and fast.next.next:
fast = fast.next.next
slow = slow.next
return slow```

Method 2: traverse the linked list

```class Solution:
def isPalindrome(self, head: ListNode) -> bool:
while node:
vals.append(node.val)
node = node.next
return vals == vals[::-1]
```

264 ugly numbers

#For example, 1, 2 and 3 now have three ugly numbers, and the next ugly number 4 uses the product of 2, so the subscript + 1,
#For factor 2: 2 is no longer used as the basic multiplier.
#1,2,3,4 now there are 4 ugly numbers, and the next ugly number 5 uses the 5 product subscript + 1,
#For factor 5, 1 is no longer used as the basic multiplier.
#That is, start to consider the multiplier after 1 as the basic multiplier. This is the meaning of subscript + 1. After using this factor, throw away the previous multiplier for this factor

The idea of dynamic programming is very good..

```class Solution:
def nthUglyNumber(self, n: int) -> int:
dp = [1] * n
index5 = index2 = index3 = 0
for i in range(1, n):
dp[i] = min(dp[index2]*2, dp[index3]*3, dp[index5]*5)
if dp[i] == 2 * dp[index2]: index2 += 1
if dp[i] == 3 * dp[index3]: index3 += 1
if dp[i] == 5 * dp[index5]: index5 += 1
return dp[n-1]
```

338 question bit count

We can only think of the conventional solution of O(nlogn) time complexity, traverse each i and count 1 bits for each i. The official answered three DPS to me.. We should study it carefully. In addition, in the conventional solution, if the ans array is set to traverse, the time will be one bit longer than that of writing the function call function

DP 1: most significant bit

For 0 < = J < I, there is always bits{i} = bits{j} + 1. Find the conditions and laws to do dp

For the power y of 2, only the highest bit of Y is 1, that is, one bit of Y is 1

For 0 < = y < x, X is z larger than y, then one bit of X is obviously 1 more than one bit of z, that is, bits{x} = bits{z} + 1

Explanation: because the 1 of Y is in the highest bit, and the value z of x is larger than y, the binary expression singled out is exactly the same as the last few bits of x, so one bit of x is only the 1 with the highest bit more than one bit of z

When the next power of 2 is encountered, the most significant digit is updated.

```class Solution:
def countBits(self, n: int) -> List[int]:
ans = [0] * (n+1)
for i in range(1, n+1):
if (i & i-1) == 0:
highbits = i
ans[i] = ans[i-highbits] + 1
return ans```

DP 2: least significant bit

I don't think it's easy to understand that it's called the least significant bit. Its idea is actually simple. It's better to use the method of naming and descending times

For any number x, shift it to the right by one bit, that is, discard the lowest bit, then bits{x} = bits{x/2} + a

When the lowest bit discarded is 1, then a=1, otherwise 0

The operation of x/2 is to reduce the original power, because one bit less binary is to reduce the power of 1.

```class Solution:
def countBits(self, n: int) -> List[int]:
ans = [0] * (n+1)
for i in range(n+1):
ans[i] = ans[i>>1] + (i&1) #Here, I > > 1 has the same effect as i//2, which is slightly slower
return ans
#Using append without declaring array space in advance is also slightly slower```

DP 3: lowest setting bit

I & I-1 is still used as Kung Fu. This operation will delete the last 1

That is, for y, x = y & Y-1, bits {y} = bits {x}+   one

```class Solution:
def countBits(self, n: int) -> List[int]:
ans = [0] * (n+1)
for i in range(1, n+1):
ans[i] = ans[i&i-1] + 1
return ans```

Bit operation is really broad and profound!!!! Sure enough, it is the most basic of computer

Posted on Thu, 30 Sep 2021 22:27:10 -0400 by MentalMonkey