算法题-golang实现第二章

最新推荐文章于 2024-01-11 17:39:51 发布
最新推荐文章于 2024-01-11 17:39:51 发布
阅读量287 收藏
点赞数
分类专栏： Go学习 文章标签： 算法 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ac123321123321/article/details/113292601
版权

算法题-golang实现


往期文章： 第一章

第二章

题目来源于Leetcode题库

1.三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

package main

import (
  "fmt"
  "sort"
)
func threeSum(nums []int) [][]int {
    res := make([][]int, 0)
    if len(nums) < 3 {
      return res
    }
    sort.Ints(nums)
    i := 0
    last := len(nums) - 1
    for i < last {
      if nums[i] > 0 {
        break
      }
      j := i + 1
      k := last
      a := nums[i]
      for j < k {
          b, c := nums[j], nums[k]
          sum := nums[j] + nums[k] + nums[i]
          if sum == 0 {
            res = append(res, []int {nums[i], nums[j], nums[k]})
          }
          if sum <= 0 {
            for  j < k && nums[j] == b {
              j++
            }
          }
          if sum >= 0 {
            for j < k && nums[k] == c {
              k--
            }
          }
      }
      for i < last && nums[i] == a {
        i++
      }
    }
    return res
}

func main()  {
  nums := []int {0,0,0}
  res := threeSum(nums)
  fmt.Println(res)
}

2.岛屿的最大面积

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。
找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)
示例 1:
[[0,0,1,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,1,1,0,1,0,0,0,0,0,0,0,0],
[0,1,0,0,1,1,0,0,1,0,1,0,0],
[0,1,0,0,1,1,0,0,1,1,1,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,0,1,1,0,0,0,0]]
对于上面这个给定矩阵应返回 6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的‘1’。
示例 2:
[[0,0,0,0,0,0,0,0]]
对于上面这个给定的矩阵, 返回 0。
注意: 给定的矩阵grid 的长度和宽度都不超过 50。

package main

import (
  "fmt"
)
func maxAreaOfIsland(grid [][]int) int {
	maxArea := 0
	temp := 0
	for i := 0; i < len(grid); i++ {
		for j := 0; j < len(grid[0]); j++ {
			temp = getArea(grid, i, j)
			if maxArea <= temp {
				maxArea = temp
			}
		}
	}
	return maxArea
}

func getArea(grid [][]int, x int, y int) int {
	if x >= len(grid) || x < 0{
		return 0
	}
	if y >= len(grid[0]) || y < 0{
		return 0
	}
	if grid[x][y] == 0 || grid[x][y] == -1 {
		return 0
	}
	//左右上下
	grid[x][y] = -1
	return 1 + getArea(grid, x, y+1) + getArea(grid, x, y-1) + getArea(grid, x-1, y) + getArea(grid, x+1, y)
}

func main() {
	arr := [][]int {{1}}
	fmt.Println(maxAreaOfIsland(arr))
}

3.搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

package main

import (
	"fmt"
)
func search(nums []int, target int) int {
		lt := 0;
        rt := len(nums) - 1;
        for lt <= rt {
            mid := (rt - lt) / 2 + lt;
            if nums[mid] == target {
				return mid;
			} else if nums[mid] < nums[rt] { // mid在右半部分，代表mid向右的部分有序
                if nums[mid] < target && nums[rt] >= target {
                    lt = mid + 1;
                } else {
                    rt = mid - 1;
                }
            } else {// mid在左半部分，代表mid向左的部分有序
                if nums[lt] <= target && nums[mid] > target {
                    rt = mid - 1;
                } else {
                    lt = mid + 1;
                }
            }
        }
        
        return -1;
}

func main()  {
	nums := []int {4,5,6,7,0,1,2}
	target := 0
	fmt.Println(search(nums, target))
}

4.最长连续递增序列

给定一个未经排序的整数数组，找到最长且连续的的递增序列。
示例 1:
输入: [1,3,5,4,7]
输出: 3
解释: 最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为5和7在原数组里被4隔开。
示例 2:
输入: [2,2,2,2,2]
输出: 1
解释: 最长连续递增序列是 [2], 长度为1。
注意：数组长度不会超过10000。

package main

import (
	"fmt"
)
func findLengthOfLCIS(nums []int) int {
	if len(nums) == 0 {
		return 0
	}
	count := 1
	max := 0
    for i := 0; i < len(nums) - 1; i++ {
		if nums[i] >= nums[i+1] {
			if max < count {
				max = count
			}
			count = 1
		} else {
			count++
		}
		// fmt.Println("count: i = ", i, count)
	}
	if max < count {
		max = count
	}
	return max
}

func main()  {
	nums := []int {1,3,5,7}
	fmt.Println(findLengthOfLCIS(nums))
}

5.数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:
你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

package main

import (
	"fmt"
)
func findKthLargest(nums []int, k int) int {
	max := 0
	index := 0
	length := len(nums)
    for i := 0; i < k; i++ {
		if len(nums) - 1 - i < 0 {
			break
		}
		max = nums[length - 1 - i]
		for j := 0; j < length - i; j++ {
			if max <= nums[j] {
				max = nums[j]
				index = j
			}
		}
		nums[length - 1 - i], nums[index] = max, nums[length - 1 - i]
		// fmt.Println("nums: ", nums)
	}
	return nums[length - k]
}

func find2(nums []int, k int) int {
	length := len(nums)
	for i := 0; i < length - 1; i++ {
		for j := 0; j < length - 1 - i; j++ {
			if nums[j] > nums[j+1] {
				nums[j], nums[j+1] = nums[j+1], nums[j]
			}
		}
	}
	fmt.Println(nums)
	return nums[length-k]
}

func main() {
	nums := []int {3,2,1,5,6,4}
	fmt.Println(findKthLargest(nums, 2))
	// fmt.Println(find2(nums, 3))
}

6.最长连续序列

给定一个未排序的整数数组，找出最长连续序列的长度。
要求算法的时间复杂度为 O(n)。
示例:
输入: [100, 4, 200, 1, 3, 2]
输出: 4
解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。

package main

import(
	"fmt"
)
func longestConsecutive(nums []int) int {
	max := 0
	left := 0
	right := 0
	mp := make(map[int]int)
	for _, v := range nums {
		if mp[v] == 0 {
			left = mp[v-1]
			right = mp[v+1]
			mp[v] = left + right + 1
			if left != 0 {
				mp[v-left] = left + right + 1
			}
			if right != 0 {
				mp[v+right] = left + right + 1
			}
			if max < left + right + 1 {
				max = left + right + 1
			}
		}
	}
	return max
}

7.第k个排列

给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。
按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
“123”
“132”
“213”
“231”
“312”
“321”
给定 n 和 k，返回第 k 个排列。
说明：
给定 n 的范围是 [1, 9]。
给定 k 的范围是[1, n!]。
示例 1:
输入: n = 3, k = 3
输出: “213”
示例 2:
输入: n = 4, k = 9
输出: “2314”
思路：1.求出k处于n的第几组数，从未选择的数中按顺序获取可用的数；2.重复1步骤

package main

import(
	"fmt"
	"strconv"
)
func getPermutation(n int, k int) string {
    mp := make(map[int]int, n) //保存选择状态的map,[1:0,2:0,...],key为数，val为0-未，1-已选择
	res := "" //结果
	group := 0 //商，也就是第几组
	offset := 0 //属于第几组，选择位移
	second := 0 //余数
	total := 1 //阶乘积
	times := n //次数
	for i := 1; i <= n; i++ {
		total *= i
	}
	for times > 0 {
		total = total/times
		group = k/total
		second = k%total
		if second > 0 {
			k = second
			offset = group + 1
		} else {
			offset = group
            k = k / group //余数为0，说明在当前组内，需要/group作为下一位的数的k，因为group=k/a(每组数的数量)
		}
		res += strconv.Itoa(getMinNum(mp, offset, n))
		fmt.Println(total, group, second, offset, res, mp)
		times--
	}
	return res
} 

func getMinNum(mp map[int]int, offset int, n int) int {
	for i := 1; i <= n; i++ {
		if mp[i] == 0 {
			offset--
		}
		if offset == 0 {
			mp[i] = 1
			return i
		}
	}
	return 0
}

func main()  {
	fmt.Println(getPermutation(4,9))
}

8.朋友圈

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。
给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。
示例 1:
输入:
[[1,1,0],
[1,1,0],
[0,0,1]]
输出: 2
说明：已知学生0和学生1互为朋友，他们在一个朋友圈。
第2个学生自己在一个朋友圈。所以返回2。
示例 2:
输入:
[[1,1,0],
[1,1,1],
[0,1,1]]
输出: 1
说明：已知学生0和学生1互为朋友，学生1和学生2互为朋友，所以学生0和学生2也是朋友，所以他们三个在一个朋友圈，返回1。
注意：
N 在[1,200]的范围内。
对于所有学生，有M[i][i] = 1。
如果有M[i][j] = 1，则有M[j][i] = 1。
思路：深度优先DFS，按升序找，找到连接点，再以连接点往下找，直至标记所有尽可能到达的点

package main

import(
	"fmt"
)
func findCircleNum(M [][]int) int {
	length := len(M)
	state := make([]int, length)
	i := 0
	count := 0
    for i < length {
		if state[i] ==0 {
			findByDfs(i, M, state)
			fmt.Println(state)
			count++
		}
		i++
	}
	return count
}

func findByDfs(index int, M [][]int, state []int) {
	if state[index] == 1 {
		return
	} else {
		state[index] = 1
	}
	for i := 0; i < len(M[index]); i++ {
		if i != index && M[index][i] == 1 {
			findByDfs(i, M, state)
		}
	}
}

func main()  {
	M := [][]int {{1,0,0,1},{0,1,1,0},{0,1,1,1},{1,0,1,1}}
	fmt.Println(findCircleNum(M))
}

9.合并区间

给出一个区间的集合，请合并所有重叠的区间。
示例 1:
输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:
输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
思路：先以每一组的第一位以小到大排序，以mergeState标记处理过的组，每读取一个元素，遍历并且合并后续的元素，合并的标记已处理

func merge(intervals [][]int) [][]int {
	res := make([][]int, 0)
	left := 0
	right := 0
	length := len(intervals)
	mergeState := make([]int, len(intervals))
	intervals = sortNums(intervals)
    for i := 0; i < length; i++ {
		if mergeState[i] != 0 {
			continue
		}
		mergeState[i] = 1
		left = intervals[i][0]
		right = intervals[i][1]
		left, right = checkMerge(intervals, mergeState, left, right)
		res = append(res, []int{left, right})
		fmt.Println("res is ", res)
	}
	return res
}

func sortNums(nums [][]int) [][]int {
	for i := 0; i < len(nums) - 1; i++ {
		for j := 0; j < len(nums) - 1 - i; j++ {
			if nums[j][0] > nums[j+1][0] {
				nums[j][0], nums[j+1][0] = nums[j+1][0], nums[j][0]
				nums[j][1], nums[j+1][1] = nums[j+1][1], nums[j][1]
			}
		}
	}
	return nums
}

func checkMerge(nums [][]int, mergeState []int, left int, right int) (int, int) {
	index := 0
	for index < len(nums) {
		if mergeState[index] != 0 {
			index++
			continue
		}
		if right >= nums[index][0] {
			mergeState[index] = 1
			if right <= nums[index][1] {
				right = nums[index][1]
			}
		}
		index++
	}
	return left, right
}


func main()  {
	intervals := [][]int {{2,3},{4,6},{5,7},{3,4}}
	fmt.Println(merge(intervals))
}

10.接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。
示例:
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

func trap(height []int) int {
	n := len(height);
	result := 0;
	if n == 0 || n == 1 {
		return result;
	}
	left := 0;
	right := n - 1;
	leftHeight := 0;
	rightHeight := 0;
	for left < right {
		if height[left] <= height[right] {
			//从左到右，只有呈现下降趋势，才是雨水的地方
			if leftHeight < height[left] {
				leftHeight = height[left]
			}
			result += leftHeight - height[left];
			left++;
		} else { 
			//从右到左，只有呈现下降趋势，才是雨水的地方
			if rightHeight < height[right] {
				rightHeight = height[right]
			}
			result += rightHeight - height[right];
			right--;
		}
	}
	return result;
}

func main() {
	// height := []int {2,0,2}
	height := []int {5,4,1,2}
	fmt.Println(trap(height)) 
}
OrangeTuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二章[变量与数据类型]:2.5:整数
刘老师的技术森林
11-30 470
什么是整数?认识整数,整数的进制,整数进制转换,其他数据类型转整数,整数转其他数据类型,数字分隔符
用于分布式速率限制的滑动窗口算法的Golang实现。-Golang开发
05-26
滑动窗口算法的分布式窗口限速的Golang实现。 安装$ go get -u github.com/RussellLuo/slidingwindow设计slidewindow是t slidewindowow的一种实现，Golang是滑动窗口算法的一种实现，用于分布式速率限制。 安装$ go get -u github.com/RussellLuo/slidingwindow设计slidewindow是Kong使用的可伸缩速率限制算法的实现。 假设我们有一个限制器，该限制器每分钟允许100个事件，现在时间到了“ 75s”点，则内部窗口将如下所示：在这种情况下，该限制器在当前窗口期间允许了12个事件，
Golang算法题目小计
gotaotao的博客
09-24 1270
1 请符合两数之和的索引 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。 你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 第一种实现：暴力破解法 func twoSum(nums []int, ta...
golang常见算法题
最新发布
weixin_38385580的博客
01-11 754
1、 翻转一个字符串 2、 字符串对位交换 3、 返回一个数组所有可能排列 4、 交替打印字母数字
golang实现算法题合集一
weixin_42278305的博客
12-08 559
1. 找到一个数组中第二大的数 思路： 定义一个最大值和第二大值变量，遍历一次数组。需要注意的是最大值可能有多个。 func getMax(arr []int) int { // 初始化 maxNum := arr[0] secondMaxNum := arr[1] if maxNum < secondMaxNum { maxNum, secondMaxNum = secondMaxNum, maxNum } for i := 0; i < len(arr); i++ { i
Leetcode面试算法题（Golang版）
07-10
用来记录我们刷LeetCode题目时候的心酸历史。我们保证，这些代码一定通过了当时LeetCode的测试，虽然后续可能因为LeetCode测试条件的改变导致某些解题无法通过，但我们会实时的跟进。 编程语言使用Golang，代码风格上面并没有强制的采用什么编码规范，毕竟是算法解题，只需要代码清晰易懂就可以了。 鉴于个人精力时间有限，可能并不会完全最优解，请多多见谅。
算法题-golang实现第一章
ac123321123321的博客
01-25 254
算法题-golang实现第一章1.无重复字符的最长子串2.最长公共前缀3.字符串的排列4.字符串相乘5.翻转字符串里的单词6.简化Linux路径7.复原IP地址 第一章 题目来源于Leetcode题库 1.无重复字符的最长子串 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。 示例 1: 输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。 示例 2: 输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以
word源码java-go-algorithm-demos:golang演示项目
06-05
word源码java go-algorithm-demos golang 实现的部分leetcode的算法demo 课程相关其他代码仓 , 代码仓: , 代码仓: , ...我的LeetCode题解代码仓： （注：以C++实现为主） ...第二章：面试中的复杂度分析 2-1 究竟什么
leetcode走迷宫-Algorithms-in-Go:我在Go中的数据结构和算法实现
07-06
leetcode 走迷宫 algorithms-in-go my implementations in go 学习资料 [剑指offer] 趣味应用类算法 迷宫生成 正则匹配 剑指offer 题目 leetcode 题目 其他题目 微软变形面试题1 bfs 走迷宫 ...第十二章
golang知识图谱
点滴生活
09-06 1652
其他 常用包 常用包 说明 fmt 实现格式化的输入输出操作，其中的fmt.Printf()和fmt.Println()是开发者使用最为频繁的函数。 io 实现了一系列非平台相关的IO相关接口和实现，比如提供了对os中系统相关的IO功能的封装。我们在进行流式读写（比如读写文件）时，通常会用到该包。 bufio 它在io的基础上提供了缓存功能。在具备了缓存功能后， bufio可以比较方便地提供ReadLine之类的操作。 strconv ...
leetcode题库-algorithm-for-go:算法学习笔记，包括leetcode算法题解及思路，详细的Golang版本
06-29
leetcode题库 algorithm-for-go golang版本的一些数据结构的实现及算法代码, 把自己练习算法题都总结到这个仓库里 目录结构 /base/structure # 这是基本数据结构的实现 /leetcode # 这是按照leetcodet题号的题目及解答, 会按照结构类型去分类 / linkedlist / stackandqueue / ... LeetCode
Golang精编100题
05-04
Golang精编面试题100题，级别 模型 初级 primary 熟悉基本语法，能够看懂代码的意图； 在他人指导下能够完成用户故事的开发，编写的代码符合CleanCode规范； 中级 intermediate 能够独立完成用户故事的开发和测试； 能够嗅出代码的坏味道，并知道如何重构达成目标； 高级 senior 能够开发出高质量高性能的代码； 能够熟练使用高级特性，开发编程框架或测试框架；
兄弟连golang神技（1）-关于 Go 语言的介绍
尹成的技术博客
07-03 1355
计算机一直在演化，但是编程语言并没有以同样的速度演化。现在的手机，内置的 CPU 核数可能都多于我们使用的第一台电脑。高性能服务器拥有 64 核、128 核，甚至更多核。但是我们依旧在使用为单核设计的技术在编程。编程的技术同样在演化。大部分程序不再由单个开发者来完成，而是由处于不同时区、不同时间段工作的一组人来完成。大项目被分解为小项目，指派给不同的程序员，程序员开发完成后，再以可以在各个应用程序...
通过golang实现一些经典算法问题
任性的白菜
03-01 538
1、sparsearray 稀疏数组 1.1、先看一个问题 1.2、基本介绍 1.3、举栗说明 1.4、应用实例 代码： package main import "fmt" /** * @Description：稀疏数组 * @Author: guai * @Date：2020/3/1 9:06 **/ type valNode struct { row int ...
leetcode：算法题golang
qq_33690342的博客
11-29 834
1、在一个字符串里面找出最长的不重复子串 2、数组中的重复数字 第一种解法：先排序再扫描。从排好序的数组进行遍历，记录当前位置与其之前位置的数进行比较，若相等则输出该数。 时间复杂度：O（nlogn）;空间复杂度O（1） 第二种解法：对数组进行遍历，每次判断哈希表中是否含有该元素，若有，输出此元素。若最后哈希表中的元素数量与数组中的相同，表面无重复数据。 时间复杂度：O（n）;空间复杂度O（n） 3、给定一个数组代表股票每天的价格，请问买卖多次的情况下，最大化利润是多少？（日期不重...
golang经典编程题30题（带答案）golang基础算法30题
热门推荐
疯狂的鸭血
10-18 1万+
1.打印出九九乘法表并统计耗时 package main import ( "fmt" "time" ) func main() { start := time.Now() var i, j int for i = 1; i <= 9; i++ { for j = 1; j <= i; j++ { fmt.Printf("%d*%d=%d\t", i, j, i...
golang实现算法题合集二
weixin_42278305的博客
12-09 307
1. 判断链表是否有环，如果有环找到环入口 思路：定义快、慢指针，从链表头开始，快指针每次走两步，慢指针每次走一步，如果相遇，说明有环。碰撞之后慢指针回到链表头部，快慢指针每次走一步，第一次相遇就是环入口。 func getLinkCircle(head *Node) *Node { fast := head last := head cur := head for cur != nil && cur.Next != nil { last = last.Next fast =
golang 算法题 : 两数相加
weixin_33910434的博客
05-11 188
package mainimport "fmt"type ListNode struct { Val int Next *ListNode}func main() { l1 := &ListNode{ Val: 1, Next: &ListNode{ Val: 2, Next: &ListNode{ Val: 3, ...
go算法题
zhaoliang831214的专栏
12-27 885
=================================================== //**冒泡排序 func BubbleSort(arr *[5]int){ n :=len(*arr) temp := 0 for i := 0; i < n-1; i++ { for j :=i+1; j < n; j++ { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值