![在这里插入图片描述](/static/img/images/01126.png)






```python
from typing import List
class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if not digits:
            return list()
        phoneMap = {
            "2": "abc",
            "3": "def",
            "4": "ghi",
            "5": "jkl",
            "6": "mno",
            "7": "pqrs",
            "8": "tuv",
            "9": "wxyz",
        }
        def backtrack(index: int):
            if index == len(digits):
                combinations.append("".join(combination))
                return
            digit = digits[index]
            for letter in phoneMap[digit]:
                combination.append(letter)
                backtrack(index + 1)
                combination.pop()
        combination = list()
        combinations = list()
        backtrack(0)
        return combinations
print(Solution().letterCombinations("234"))
```

17. 电话号码的字母组合（递归+回溯 ）

![在这里插入图片描述](/static/img/images/01127.png)





```python
from typing import List
class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        ans = []
        def backtrack(S, left, right):
            if len(S) == 2 * n:
                ans.append(''.join(S))
                return
            if left < n:
                S.append('(')
                backtrack(S, left+1, right)
                S.pop()
            if right < left:
                S.append(')')
                backtrack(S, left, right+1)
                S.pop()
        backtrack([], 0, 0)
        return ans
print(Solution().generateParenthesis(3))
```

22. 括号生成（递归+回溯 ）

[https://leetcode-cn.com/problems/permutations/solution/quan-pai-lie-by-leetcode-solution-2/](https://leetcode-cn.com/problems/permutations/solution/quan-pai-lie-by-leetcode-solution-2/)





![在这里插入图片描述](/static/img/images/01128.png)

```python
from typing import List
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def dfs(start):
            if start == n:
                sol.append(nums[:])
            for i in range(start, n):
                nums[start], nums[i] =  nums[i], nums[start]
                dfs( start+1 )
                nums[start], nums[i] =  nums[i], nums[start]
        sol = []
        n = len(nums)
        dfs(0)
        return sol
a = Solution()
print(a.permute([1, 2, 3]))
```

或者写成：
```
from typing import List
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def dfs(sol):
            if len(sol) == n:
                res.append(nums[:])
            for i in range(0, n):
                if used[i]: continue
                sol.append(nums[i])
                used[i] = 1
                dfs(sol)
                sol.pop()
                used[i] = 0
        res = []
        n = len(nums)
        used = [0 for _ in range(n)]
        dfs([])
        return res
print(Solution().permute([1, 2, 3]))
```



[https://leetcode-cn.com/problems/permutations-ii/solution/](https://leetcode-cn.com/problems/permutations-ii/solution/)

![在这里插入图片描述](/static/img/images/01129.png)

```python
from typing import List
class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        def dfs(sol):
            if len(sol) == n:
                res.append(sol[:])
                return
            for i in range(0, n):  # nums 不改变
                # print(i, used)
                if used[i]: continue  # 当前位置的元素被使用过
                if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]: continue  # 剪枝：新位置元素和上一个相同，并且上一个元素是没用过
                sol.append(nums[i])
                used[i] = 1
                dfs(sol)
                sol.pop()
                used[i] = 0
        res = []
        n = len(nums)
        nums.sort()
        used = [0 for i in range(n)]  # 全局，看看是第几层递归
        dfs([])
        # res=[tuple(i) for i in res]
        # return list(set(res))
        return res
print(Solution().permuteUnique([1, 1, 1]))
```

【算法题目】【DFS】全排列1,2

[https://leetcode-cn.com/problems/n-queens/solution/liang-chong-shi-xian-xiang-xi-tu-jie-51-n-huang-ho/](https://leetcode-cn.com/problems/n-queens/solution/liang-chong-shi-xian-xiang-xi-tu-jie-51-n-huang-ho/)






伪代码

```python
dfs函数(x) { 
    if x==n { //如果x等于n了，说明每行的皇后都放置完毕
        //将棋盘内容的快照保存下来
        return
    }
    for(y=0;i<n;++y) {
        if [x,y]这个位置是有效的，即横、竖、两个斜线都有没有被攻击 {
            将棋盘[x,y]位置设置为 Q
            dfs(x+1) 继续尝试下一行
            将棋盘[x,y]位置还原
        }
    }
}
```

python3
```python
class Solution(object):
    def solveNQueens(self, n):
        # 生成N*N的棋盘，填充棋盘，每个格子默认是''.''表示没有放置皇后
        arr = [["." for _ in range(n)] for _ in range(n)]  # 生成列表最好方式是采用列表推导式
        res = []  # 存放最终结果
        # 检查当前的行和列是否可以放置皇后
        def check(x: int, y: int):
            # 检查竖着的一列是否有皇后
            for i in range(x):
                if arr[i][y] == "Q":
                    return False
            # 检查左上的斜边是否有皇后
            i, j = x - 1, y - 1
            while i >= 0 and j >= 0:
                if arr[i][j] == "Q":
                    return False
                i, j = i - 1, j - 1
            # 检查左下的斜边是否有皇后
            i, j = x - 1, y + 1
            while i >= 0 and j < n:
                if arr[i][j] == "Q":
                    return False
                i, j = i - 1, j + 1
            # 检查右上的斜边是否有皇后
            i, j = x + 1, y - 1
            while i < n and j >= 0:
                if arr[i][j] == "Q":
                    return False
                i, j = i + 1, j - 1
            # 检查右下的斜边是否有皇后
            i, j = x + 1, y + 1
            while i < n and j < n:
                if arr[i][j] == "Q":
                    return False
                i, j = i + 1, j + 1
            return True
        def dfs(x):
            # x是从0开始计算的
            # 当x==n时所有行的皇后都放置完毕，此时记录结果
            if x == n:
                res.append(["".join(arr[i]) for i in range(n)])
                return
            # 遍历每一列
            for y in range(n):
                # 检查[x,y]这一坐标是否可以放置皇后
                # 如果满足条件，就放置皇后，并继续检查下一行
                if check(x, y):
                    arr[x][y] = "Q"  # 放上皇后
                    dfs(x + 1)  # 搜索下一行策略
                    arr[x][y] = "."  # 撤销皇后，y进入下一列搜索
        dfs(0)
        return res
print(len(Solution().solveNQueens(8)))
```

利用一个规律改进算法。之前check()是循环，效率不高。

python3
```python
class Solution(object):
    def solveNQueens(self, n):
        # 生成N*N的棋盘，填充棋盘，每个格子默认是''.''表示没有放置皇后
        arr = [["." for _ in range(n)] for _ in range(n)]  # 生成列表最好方式是采用列表推导式
        res = []  # 存放最终结果
        columns = set()
        hypotenuse1 = set()
        hypotenuse2 = set()
        # 检查当前的行和列是否可以放置皇后
        def check(x: int, y: int):
            if y in columns:
                return False
            if x - y in hypotenuse1:
                return False
            if x + y in hypotenuse2:
                return False
            return True
        def dfs(x):
            # x是从0开始计算的
            # 当x==n时所有行的皇后都放置完毕，此时记录结果
            if x == n:
                res.append(["".join(arr[i]) for i in range(n)])
                return
            # 遍历每一列
            for y in range(n):
                # 检查[x,y]这一坐标是否可以放置皇后
                # 如果满足条件，就放置皇后，并继续检查下一行
                if check(x, y):
                    columns.add(y)
                    hypotenuse1.add(x - y)
                    hypotenuse2.add(x + y)
                    arr[x][y] = "Q"  # 放上皇后
                    dfs(x + 1)  # 搜索下一行策略
                    arr[x][y] = "."  # 撤销皇后，y进入下一列搜索
                    columns.remove(y)
                    hypotenuse1.remove(x - y)
                    hypotenuse2.remove(x + y)
        dfs(0)
        return res
print(Solution().solveNQueens(8))
```

![在这里插入图片描述](/static/img/images/01130.png)

![在这里插入图片描述](/static/img/images/01131.png)

N皇后（递归+回溯）

# 36. 有效的数独 





![在这里插入图片描述](/static/img/images/01132.png)

python
```python
from typing import List
class Solution:
    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """
        # init data
        rows = [{} for i in range(9)] # 字典 哈希表 列表第一个字典：rows[0]这个字典是第一行的键值信息
        columns = [{} for i in range(9)] # 字典 哈希表
        boxes = [{} for i in range(9)] # 字典 哈希表
        # validate a board
        for i in range(9):
            for j in range(9):
                num = board[i][j]  # 第i行  第j列  的元素
                if num != '.':
                    num = int(num)
                    box_index = (i // 3) * 3 + j // 3    # 在一个3*3方格里的index
                    # keep the current cell value
                    rows[i][num] = rows[i].get(num, 0) + 1  # 第i行的rows字典里找这个元素，找不到就是0，加1后变成1. 找得到加上1后就会大于1
                    columns[j][num] = columns[j].get(num, 0) + 1
                    boxes[box_index][num] = boxes[box_index].get(num, 0) + 1
                    # check if this value has been already seen before
                    if rows[i][num] > 1 or columns[j][num] > 1 or boxes[box_index][num] > 1:
                        return False
        return True
print(Solution().isValidSudoku([
  ["5","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]  ]))
```

运行完毕后：

![在这里插入图片描述](/static/img/images/01133.png)

![在这里插入图片描述](/static/img/images/01134.png)

![在这里插入图片描述](/static/img/images/01135.png)

按健寻值的字典：

```python
rows = [{} for i in range(9)]
print(rows)
rows[0][1]=1
rows[0][3]=1
rows[1][1]=1
print(rows)
```

结果
```python
C:\Users\xd_du\Anaconda3\envs\py37\python.exe C:/Users/xd_du/PycharmProjects/wave/gendata.py
[{}, {}, {}, {}, {}, {}, {}, {}, {}]
[{1: 1, 3: 1}, {1: 1}, {}, {}, {}, {}, {}, {}, {}]
Process finished with exit code 0
```

# 37. 解数独

https://leetcode-cn.com/problems/sudoku-solver/solution/jie-shu-du-by-leetcode-solution/

![在这里插入图片描述](/static/img/images/01136.png)

```python
from typing import List
class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        def dfs(pos: int):
            nonlocal valid
            if pos == len(spaces):
                valid = True
                return
            i, j = spaces[pos]
            for digit in range(9):
                if line[i][digit] == column[j][digit] == block[i // 3][j // 3][digit] == False:
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = True
                    board[i][j] = str(digit + 1)
                    dfs(pos + 1)   #递归
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = False
                if valid:
                    return
        line = [[False] * 9 for _ in range(9)]
        column = [[False] * 9 for _ in range(9)]
        block = [[[False] * 9 for _a in range(3)] for _b in range(3)]
        valid = False
        spaces = list()
        for i in range(9):
            for j in range(9):
                if board[i][j] == ".":
                    spaces.append((i, j))
                else:
                    digit = int(board[i][j]) - 1
                    line[i][digit] = column[j][digit] = block[i // 3][j // 3][digit] = True
        dfs(0)
board = [
    ["5", "3", ".", ".", "7", ".", ".", ".", "."],
    ["6", ".", ".", "1", "9", "5", ".", ".", "."],
    [".", "9", "8", ".", ".", ".", ".", "6", "."],
    ["8", ".", ".", ".", "6", ".", ".", ".", "3"],
    ["4", ".", ".", "8", ".", "3", ".", ".", "1"],
    ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
    [".", "6", ".", ".", ".", ".", "2", "8", "."],
    [".", ".", ".", "4", "1", "9", ".", ".", "5"],
    [".", ".", ".", ".", "8", ".", ".", "7", "9"]]
Solution().solveSudoku(board)
for i in range(9):
    print(board[i])
```

```python
def check(matrix, row, col, value):
    """
    检测在(row,col)放value是否合适
    1.每行含1-9,不含重复值value
    2.每列含1-9,不含重复值value
    3.3*3区块含1-9,不含重复值value
    """
    # 检测每行
    for j in range(9):
        if matrix[row][j] == value:
            return False
    # 检测每列
    for i in range(9):
        if matrix[i][col] == value:
            return False
    # 检测元素所在3*3区域
    area_row = (row // 3) * 3
    area_col = (col // 3) * 3
    for i in range(area_row, area_row + 3):
        for j in range(area_col, area_col + 3):
            if matrix[i][j] == value:
                return False
    return True
def solveSudoku(matrix, count=0):
    """
    遍历每一个未填元素，遍历1-9替换为合适的数字
    """
    if (count == 81):  # 递归出口
        return True
    #行优先遍历
    row = count // 9  # 行标
    col = count % 9  # 列标
    if matrix[row][col] != 0:  # 已填充
        return solveSudoku(matrix, count=count + 1)
    else:  # 未填充
        for i in range(1, 10):
            if check(matrix, row, col, i):  # 找到可能的填充数
                matrix[row][col] = i
                if solveSudoku(matrix, count=count + 1):  # 是否可完成
                    return True  # 可完成
                # 不可完成
                matrix[row][col] = 0  # 回溯
        return False  # 不可完成
while True:
    try:
        matrix = []
        for i in range(9):
            matrix.append([int(i) for i in  input().split(' ')])#多维列表输入
        solveSudoku(matrix)
        for i in range(9):
            print( ' '.join(map(str, matrix[i])))
    except:
        break
```



# 生成一张标准数独地图

标准数独地图有17个数字提示，且是有唯一解的。

36. 有效的数独（遍历一次 9+9+9个字典 哈希） 37. 解数独

# 1. 两数之和





https://leetcode-cn.com/problems/two-sum/

给定一个整数数组 nums 和一个整数目标值 target，需要在数组中找到两个数，使得它们的和等于 target，并返回这两个数的数组下标。可以假设每种输入只会对应一个答案，并且不能重复使用同一个元素。可以按任意顺序返回答案。

```python
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashdict=dict()
        for k,item in enumerate(nums):
            if target-item not in hashdict:
                hashdict[item]=k
            else:
                return [hashdict[target-item],k]
        
        return []
```


## 2. Two Sum II - Input Array Is Sorted​​ (两数之和 II - 输入有序数组)

链接：https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/

特点：输入数组是​​已排序的​​，且需要返回所有可能的组合（但通常题目要求返回​​一个​​组合，但可以扩展为返回所有组合）。

点评：和一般的两数之和解法一模一样，只不过这个要借助enumerate去从下标1开始，而且有空间要求。


空间复杂度 O(n) 的解法：

```python
class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        hashdict={}
        for k,item in enumerate(numbers,1):
            if target-item not in hashdict:
                hashdict[item]=k
            else:
                return [hashdict[target-item],k]
        return []
```
常量级的额外空间 ， 也就是 O(1) 的解法，使用双指针：


```python
class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left, right = 0, len(numbers) - 1
        while left < right:
            current_sum = numbers[left] + numbers[right]
            if current_sum == target:
                return [left + 1, right + 1]
            elif current_sum < target:
                left += 1
            else:
                right -= 1
        return [-1, -1]  # As per problem statement, this line is not needed
```

## 3. Two Sum Less Than K

给定一个整数数组 nums 和一个整数 k，返回数组中两个数的和的最大值，该和小于 k。如果没有满足条件的两个数，则返回 -1。

示例：​​

示例 1：
输入：nums = [34,23,1,24,75,33,54,8], k = 60
输出：58
解释：34 和 24 的和是 58，且 58 小于 60，且没有其他组合的和更大。
示例 2：
输入：nums = [10,20,30], k = 15
输出：-1
解释：没有两个数的和小于 15。




# 2 三数之和

![在这里插入图片描述](/static/img/images/01139.png)

python
```python
from typing import List
class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        n = len(nums)
        nums.sort()
        ans = list()
        # 枚举 a
        for first in range(n):  # 遍历所有元素
            # 需要和上一次枚举的数不相同
            if first > 0 and nums[first] == nums[first - 1]:
                continue
            # c 对应的指针初始指向数组的最右端
            third = n - 1
            target = -nums[first]
            # 枚举 b
            for second in range(first + 1, n):
                # 需要和上一次枚举的数不相同
                if second > first + 1 and nums[second] == nums[second - 1]:
                    continue
                # 需要保证 b 的指针在 c 的指针的左侧
                while second < third and nums[second] + nums[third] > target:
                    third -= 1
                # 如果指针重合，随着 b 后续的增加
                # 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if second == third:
                    break
                if nums[second] + nums[third] == target:
                    ans.append([nums[first], nums[second], nums[third]])
        return ans
print(Solution().threeSum([3, 5, 4, 4, -2, -2, -1, -3, -3]))
```

# 3 四数之和

https://leetcode-cn.com/problems/4sum/solution/si-shu-zhi-he-by-leetcode-solution/

![在这里插入图片描述](/static/img/images/01140.png)

1. 两数之和（哈希表） 15. 三数之和（双指针） 18. 四数之和

https://leetcode-cn.com/problems/container-with-most-water/





![在这里插入图片描述](/static/img/images/01141.png)

python

```python
class Solution:
    def maxArea(self, height) -> int:
        l, r = 0, len(height) - 1  # 左右指针
        ans = 0
        while l < r:  # 左右指针指向同一个元素的时候退出循环
            area = min(height[l], height[r]) * (r - l)  # 面积　＝　最短挡板　×　间距
            ans = max(ans, area)  # 答案只想要最大的面积
            if height[l] <= height[r]:  # 左挡板 小于 右挡板
                l += 1  # 左指针移动
            else:
                r -= 1  # 右指针移动
        return ans
print(Solution().maxArea([3, 5, 4]))
```

左右指针正确性：

（1）假设左指针指着height[0]不动；

（2）移动可行性：右指针指着height[-1]，此时面积假设为area1。如果右指针移动，指着height[-2]，此时面积假设为area2。间距的缩小，使得只有当height[-2]挡板大于之前的，才有可能找到更大的值。

（3）该移动哪一个指针？：左挡板 小于等于 右挡板，那么就移动左指针。

11. 盛最多水的容器 双指针

# 水壶问题：数学解法与DFS双视角剖析

## 题目

[https://leetcode-cn.com/problems/water-and-jug-problem/](https://leetcode-cn.com/problems/water-and-jug-problem/)

有两个容量分别为 x 升 和 y 升 的水壶以及无限多的水。请判断能否通过使用这两个水壶，从而可以得到恰好 z 升 的水？

如果可以，最后请用以上水壶中的一或两个来盛放取得的 z 升 水。

你允许：

- 装满任意一个水壶
- 清空任意一个水壶
- 从一个水壶向另外一个水壶倒水，直到装满或者倒空



---

## 1. 题目深度解析

### 问题本质

题目等价于存在无限水源，通过两个容器（x升和y升）的操作，能否组合出z升水。关键操作包括：装满、倒空、相互倒水。最终z升水可以存在于任一或两个容器中。

### 易错点澄清

- 题目没有明确说明是否允许容器部分装满，但实际操作允许任意水量状态
- 原题描述存在歧义，正确理解应为：**最终总水量（两个容器水量之和）等于z即可**

---

## 2. 数学解法精讲

### 贝祖定理应用

若存在整数 a, b 使得 `ax + by = z`，则 z 是 x 和 y 最大公约数（GCD）的倍数。具体判断条件如下：

1. **容量总和限制**：`z ≤ x + y`
2. **特殊情况处理**：
   - 任一容器为0时，只能得到0或另一容器容量的水
   - z=0 时总是成立
3. **最大公约数判断**：`z % gcd(x, y) == 0`

### 示例分析

```python
x=3, y=5 → gcd(3,5)=1
z=4 → 4%1=0 → 可行

x=2, y=6 → gcd(2,6)=2
z=5 → 5%2=1 → 不可行
```

### 数学解法代码

```python
import math

def can_measure_water(x: int, y: int, z: int) -> bool:
    if z == 0:
        return True
    if x + y < z:
        return False
    if x == 0 or y == 0:
        return z == max(x, y)
    return z % math.gcd(x, y) == 0
```

---

## 3. DFS解法全面解析

### 算法思路

通过状态空间搜索，枚举所有可能的水量组合：

1. **状态表示**：`(remain_x, remain_y)` 表示当前两容器中的水量
2. **状态转移**：定义6种基本操作：
   - 装满X/Y
   - 倒空X/Y
   - X→Y倒水（至Y满或X空）
   - Y→X倒水（至X满或Y空）
3. **终止条件**：任一容器或总水量等于z
4. **剪枝优化**：使用集合记录已访问状态，避免重复计算

### 时间复杂度分析

- 最坏情况：O(x*y)（状态总数为x*y种）
- 实际效率：适合x,y较小时使用，大数值时效率急剧下降

### DFS代码详解

```python
class Solution:
    def canMeasureWater(self, x: int, y: int, z: int) -> bool:
        stack = [(0, 0)]  # 初始状态：两容器皆空
        visited = set()    # 记录已探索状态
        
        while stack:
            rx, ry = stack.pop()
            
            # 终止条件检测
            if rx == z or ry == z or rx + ry == z:
                return True
            
            # 状态剪枝
            if (rx, ry) in visited:
                continue
            visited.add((rx, ry))
            
            # 生成所有可能状态
            # 操作1：装满X
            stack.append((x, ry))
            # 操作2：装满Y
            stack.append((rx, y))
            # 操作3：倒空X
            stack.append((0, ry))
            # 操作4：倒空Y
            stack.append((rx, 0))
            # 操作5：X→Y倒水
            transfer = min(rx, y - ry)
            stack.append((rx - transfer, ry + transfer))
            # 操作6：Y→X倒水
            transfer = min(ry, x - rx)
            stack.append((rx + transfer, ry - transfer))
        
        return False
```

### 操作过程示例（x=3, y=5, z=4）

1. 初始状态：(0,0)
2. 倒满Y → (0,5)
3. Y→X倒3升 → (3,2)
4. 倒空X → (0,2)
5. Y→X倒2升 → (2,0)
6. 倒满Y → (2,5)
7. Y→X倒1升 → (3,4) → 总水量7，超过z值
8. 倒空X → (0,4) → ry=4符合条件

---

## 4. 方法对比与选择建议

| 方法        | 时间复杂度        | 空间复杂度 | 适用场景               |
|-----------|---------------|-------|--------------------|
| 数学解法      | O(log(min(x,y))) | O(1)  | 任意规模，最优选择         |
| DFS/BFS   | O(xy)         | O(xy) | 小规模数据，需要具体操作路径时 |

### 推荐策略

- **面试首选数学解法**，体现数学思维
- **需要展示具体操作步骤时使用BFS**（可记录路径）
- **竞赛场景优先考虑数学解法的高效性**

---

## 5. 进阶思考

1. **如何记录具体操作路径？**
   - 使用字典保存状态转移路径
   - BFS更适合路径记录，可保证最短操作序列

2. **三容器问题扩展？**
   - 数学解法不再适用
   - 需使用图搜索算法
   - 状态复杂度升至 O(xyz)

3. **存在测量误差时的容错处理？**
   - 引入模糊判断机制
   - 设定允许误差范围（如±0.5升）

水壶问题

要在Android中实现震动50ms，并将震动等级设置为低，你可以使用`Vibrator`类。下面是一个简单的代码示例，展示如何实现这个功能：





```java
import android.content.Context;
import android.os.VibrationEffect;
import android.os.Vibrator;
public void vibratePhone(Context context) {
    Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
    if (vibrator != null && vibrator.hasVibrator()) {
        // 设置震动等级低一点，使用VibrationEffect.DEFAULT_AMPLITUDE的一半
        int vibrationAmplitude = VibrationEffect.DEFAULT_AMPLITUDE / 2;
        VibrationEffect vibrationEffect = VibrationEffect.createOneShot(50, vibrationAmplitude);
        vibrator.vibrate(vibrationEffect);
    }
}
```

### 代码说明：

- `Vibrator`：获取系统的震动服务。

- `VibrationEffect.createOneShot(50, vibrationAmplitude)`：创建一个持续50ms的震动效果，并将震动等级设置为默认等级的一半。

- `vibrator.vibrate(vibrationEffect)`：让设备执行震动。

这个代码可以放在你的活动或服务中，只要传入`Context`即可。这样可以实现设备震动50ms，并且震动等级相对较低。


要调用上面提供的震动功能代码，你需要在合适的地方使用 `vibratePhone` 方法。以下是如何在一个 Android 活动（Activity）中调用这个方法的示例。

### 示例代码：

```java
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 调用震动方法
        vibratePhone(this);
    }
    // 震动方法的定义
    private void vibratePhone(Context context) {
        Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
        if (vibrator != null && vibrator.hasVibrator()) {
            // 设置震动等级低一点，使用VibrationEffect.DEFAULT_AMPLITUDE的一半
            int vibrationAmplitude = VibrationEffect.DEFAULT_AMPLITUDE / 2;
            VibrationEffect vibrationEffect = VibrationEffect.createOneShot(50, vibrationAmplitude);
            vibrator.vibrate(vibrationEffect);
        }
    }
}
```

### 调用说明：

- 在 `MainActivity` 的 `onCreate` 方法中，调用了 `vibratePhone(this)`，并将当前活动的 `Context` 传递给方法。

- `vibratePhone` 方法会在活动创建时执行设备震动50ms。

你可以在任何需要的地方调用这个方法，例如按钮点击事件、某个特定条件触发时等。

### 示例：在按钮点击时触发震动
```java
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.appcompat.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 查找按钮
        Button vibrateButton = findViewById(R.id.vibrateButton);
        // 设置按钮点击监听器
        vibrateButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 按钮点击时调用震动方法
                vibratePhone(MainActivity.this);
            }
        });
    }
    // 震动方法的定义
    private void vibratePhone(Context context) {
        Vibrator vibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
        if (vibrator != null && vibrator.hasVibrator()) {
            int vibrationAmplitude = VibrationEffect.DEFAULT_AMPLITUDE / 2;
            VibrationEffect vibrationEffect = VibrationEffect.createOneShot(50, vibrationAmplitude);
            vibrator.vibrate(vibrationEffect);
        }
    }
}
```

在这个示例中，`vibrateButton` 是一个按钮的ID，当用户点击按钮时，会触发震动。

【Android】android，震动一下，50ms，震动等级设置低一点

在Android中，你可以自定义Toast以实现放中间、加粗字体和红色文本的效果。以下是一个示例代码：





```java
// 创建一个新的Toast对象
Toast toast = Toast.makeText(getApplicationContext(), "这是一个自定义Toast", Toast.LENGTH_SHORT);
// 设置Toast的位置为屏幕中央
toast.setGravity(Gravity.CENTER, 0, 0);
// 获取Toast的View
View toastView = toast.getView();
// 获取Toast的TextView并自定义样式
TextView textView = toastView.findViewById(android.R.id.message);
if (textView != null) {
    textView.setTextColor(Color.RED); // 设置字体颜色为红色
    textView.setTypeface(textView.getTypeface(), Typeface.BOLD); // 设置字体加粗
    textView.setTextSize(18); // 设置字体大小（可选）
}
// 显示Toast
toast.show();
```

这段代码将显示一个Toast消息，该消息将居中显示，文本为红色并加粗。你可以根据需要调整字体大小等其他样式。

## 自定义Toast在Android中的使用

在Android开发中，Toast是一种常用的轻量级消息提示方式。它可以在不打断用户操作的情况下显示一段信息，并且自动消失。默认情况下，Toast的样式和位置是固定的，但有时候我们可能需要更灵活地自定义Toast，例如将Toast显示在屏幕中央、设置特定的文本颜色、字体样式等。本文将介绍如何实现这些自定义需求。

### 一、基本Toast的使用

在介绍自定义Toast之前，我们先简单回顾一下基本的Toast用法。以下是一个创建并显示简单Toast的示例：

```java
Toast.makeText(getApplicationContext(), "这是一个简单的Toast", Toast.LENGTH_SHORT).show();
```

这段代码会在屏幕底部显示一条短暂的消息“这是一个简单的Toast”。

### 二、在屏幕中间显示Toast

默认情况下，Toast会显示在屏幕的底部。然而，我们可以通过设置Toast的位置，将其显示在屏幕的中央。可以使用`setGravity`方法来调整Toast的位置。

```java
Toast toast = Toast.makeText(getApplicationContext(), "这是一个居中的Toast", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();
```

### 三、自定义Toast的文本样式

在某些情况下，我们可能希望自定义Toast的文本样式，例如改变文本的颜色、字体大小、或者将文本加粗。以下是一个实现这些效果的示例：

```java
Toast toast = Toast.makeText(getApplicationContext(), "这是一个自定义样式的Toast", Toast.LENGTH_SHORT);
// 设置Toast的位置为屏幕中央
toast.setGravity(Gravity.CENTER, 0, 0);
// 获取Toast的View
View toastView = toast.getView();
// 获取Toast的TextView并自定义样式
TextView textView = toastView.findViewById(android.R.id.message);
if (textView != null) {
    textView.setTextColor(Color.RED); // 设置字体颜色为红色
    textView.setTypeface(textView.getTypeface(), Typeface.BOLD); // 设置字体加粗
    textView.setTextSize(18); // 设置字体大小（可选）
}
// 显示Toast
toast.show();
```

### 四、进一步的自定义

除了上述基本样式的自定义外，我们还可以通过加载自定义的布局文件来进一步定制Toast的外观。例如，我们可以设计一个XML布局文件来完全控制Toast的外观。

```xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/custom_background"
    android:orientation="horizontal"
    android:padding="10dp">
    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/ic_toast_icon" />
    <TextView
        android:id="@+id/custom_toast_message"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="这是自定义布局的Toast"
        android:textColor="@android:color/white"
        android:textSize="16sp" />
</LinearLayout>
```

然后，在代码中加载并显示这个自定义布局的Toast：

```java
LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.custom_toast, (ViewGroup) findViewById(R.id.custom_toast_container));
TextView text = layout.findViewById(R.id.custom_toast_message);
text.setText("这是一个自定义布局的Toast");
Toast toast = new Toast(getApplicationContext());
toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.setDuration(Toast.LENGTH_SHORT);
toast.setView(layout);
toast.show();
```

### 五、总结

通过本文的介绍，你已经了解了如何在Android中自定义Toast，包括设置Toast的位置、修改文本的样式、以及使用自定义布局文件来实现更复杂的UI效果。Toast的自定义功能虽然简单，但在很多场景下可以有效提升用户体验，让应用更加美观和易用。希望这篇文章对你在Android开发中的实践有所帮助。

如果你对更多Android开发相关的内容感兴趣，欢迎关注我的博客。