【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 字符串化繁为简

最新推荐文章于 2024-06-15 19:00:00 发布
最新推荐文章于 2024-06-15 19:00:00 发布
阅读量120 收藏
点赞数
文章标签： 华为od eclipse 算法 数据结构 ci/cd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73659489/article/details/131749092
版权

为了更好的阅读体检，可以查看我的算法学习网
本题在线评测链接:P1360

题目描述

给定一个输入字符串，字符串只可能由英文字母 (‘ a a a’ ~‘ z z z’、‘ A A A’ ~ ‘ Z Z Z’ )和左右小括号 (‘(’、‘)’)组成。

当字符里存在小括号时，小括号是成对的，可以有一个或多个小括号对，小括号对不会嵌套，小括号对内可以包含 1 1 1个或多个英文字母，也可以不包含英文字母。

当小括号对内包含多个英文字母时，这些字母之间是相互等效的关系，而且等效关系可以在不同的小括号对之间传递，即当存在“ a a a"和’ b b b’等效和存在’ b b b’和’ c c c’ 等效时，‘ a a a’ 和 ' c c c’也等效，另外，同一个英文字母的大写字母和小写字母也相互等效 (即使它们分布在不同的括号对里)

需要对这个输入字符串做简化，输出一个新的字符串，输出字符串里只需保留输入字符串里的没有被小括号对包含的字符(按照输入字符串里的字符顺序) ，并将每个字符替换为在小括号对里包含且字典序最小的等效字符。

如果简化后的字符串为空，请输出为" 0 0 0”。

示例:

输入字符串为" n e v e r ( d o n t ) g i v e ( r u n ) u p ( f ) ( ) never(dont)give(run)up(f)() never(dont)give(run)up(f)()"，初始等效字符集合为(‘ d d d’,‘ o o o’,‘ n n n’,‘ t t t’)、(‘ r r r’,‘ u u u’,‘ n n n’)，由于等效关系可以传递，因此最终等效字符集合为(‘ d d d’,‘ o o o’,‘ n n n’,‘ t t t’,‘ r r r’,‘ u u u’)，将输入字符串里的剩余部分按字典序最小的等效字符替换后得到" d e v e d g i v e d p devedgivedp devedgivedp’

输入描述

i n p u t input input_ s t r i n g string string

输入为 1 1 1行，代表输入字符串。

输出描述

o u t p u t output output_ s t r i n g string string

输出为 1 1 1行，代表输出字符串。

备注

输入字符串的长度在 1 1 1~ 100000 100000 100000之间。

样例

输入

()abd

输出

abd

说明

输入字符串里没有被小括号包含的子字符串为" a b d abd abd"，其中每个字符没有等效字符，输出为" a b d abd abd"

输入

(abd)demand(fb)for

输出

aemanaaor

说明

等效字符集为(‘ a a a’，‘ b b b’，‘ d d d’,‘ f f f’)，输入字符串里没有被小括号包含的子字符串集合为’ d e m a n d f o r demandfor demandfor”，将其中字符替换为字典序最小的等效字符后输出为:“ a e m a n a a o r aemanaaor aemanaaor”

输入

()happy(xyz)new(wxy)year(t)

输出

happwnewwear

说明

等效字符集为(‘ x x x’，‘ y y y’,‘ z z z’,‘ w w w’)，输入字符串里没有被小括号包含的子字符串集合为" h a p p y n e w y e a r happynewyear happynewyear”，将其中字符替换为字典序最小的等效字符后输出为:" h a p p w n e w w e a r happwnewwear happwnewwear”

输入

()abcdefgaAC(a)(Ab)(C)

输出

AAcdefgAC

说明

等效字符集为(‘ a a a’，‘ A A A’，‘ b b b’)，输入字符里没有被小括号包含的子字符串集合为" a b c d e f g A C abcdefgAC abcdefgAC"，将其中字符替换为字典序最小的等效字符后输出为:“ A A c d e f g A C AAcdefgAC AAcdefgAC”

思路

该题是一道模拟题。解决这题，我们发现难点在于如何对于处理各个字符的等价关系。假如我们知道了所有字母的等价关系，那么我们直接遍历一遍去除括号内元素的字符串，将每一个元素按照等价关系进行转换即可。

因此，题目关键就是等价关系。

首先，我们发现等价关系都是出现在括号内部，因此我们可以按照直觉将每一个括号内部的元素组成一个等价关系。而所用的数据结构，可以是 l i s t list list也可以是 s e t set set。这里我们选择 s e t set set。我们将每一组括号内部元素组合成一个 s e t set set之后，第二个问题就是如何合并。

这个问题的暴力解法很容易想到，那就是对每一个 s e t set set找所有其他 s e t set set是否和这个 s e t set set存在相同元素，如果存在，就合并并删除其中一个 s e t set set，不存在，就继续查找。

因此。问题的解决就出来了，我们首先需要将原字符串进行分离，将每一个括号内部的元素组合成一个 s e t set set，将括号外的元素作为待转换串。之后，我们通过暴力解法将所有 s e t set set合并。合并之后，我们对于待转换串进行转换，每次转化就去找目标字符所在的 s e t set set，并替换为字典序最小的那一个。

类似题目推荐

代码

C++

#include <iostream>
#include <vector>
#include <queue>
#include <sstream>

using namespace std;

int getResult(vector<vector<string>>& matrix) {
    int row = matrix.size();
    int col = matrix[0].size();

    // 记录宜居取坐标位置
    queue<pair<int, int>> que;
    // 记录可改造区数量
    int need = 0;

    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if (matrix[i][j] == "YES") {
                que.push({i, j});
            } else if (matrix[i][j] == "NO") {
                need += 1;
            }
        }
    }

    // 如果没有宜居区，则无法改造，直接返回-1
    if (que.empty()) {
        return -1;
    }
    // 如果全是宜居区，则无需改造，直接返回0
    else if (que.size() == row * col) {
        return 0;
    }

    // 记录花费的天数
    int day = 0;
    // 上，下，左，右四个方向的偏移量
    vector<pair<int, int>> offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    // 图的多源BFS模板
    while (!que.empty() && need > 0) {
        queue<pair<int, int>> newQueue;

        while (!que.empty()) {
            pair<int, int> coordinates = que.front();
            que.pop();

            int x = coordinates.first;
            int y = coordinates.second;

            for (auto& offset : offsets) {
                // 上，下，左，右四个方向扩散
                int newX = x + offset.first;
                int newY = y + offset.second;

                // 如果新位置没有越界，且为NO，则可以被改造
                if (newX >= 0 && newX < row && newY >= 0 && newY < col && matrix[newX][newY] == "NO") {
                    matrix[newX][newY] = "YES";
                    newQueue.push({newX, newY});
                    need -= 1;
                }
            }
        }

        day += 1;
        que = newQueue;
    }

    if (need == 0) {
        return day;
    } else {
        return -1;
    }
}

int main() {
    vector<vector<string>> matrix;

    string line;
    while (getline(cin, line)) {
        istringstream iss(line);
        vector<string> row;
        string value;
        while (iss >> value) {
            row.push_back(value);
        }
        matrix.push_back(row);
    }

    cout << getResult(matrix) << endl;

    return 0;
}

python

def getResult(str):
    # 主体字符容器
    sb = []
    # 等效字符容器的集合
    eqs = []

    # isOpen标志，表示有没有遇到 '(' 字符
    isOpen = False
    s = list(str.strip())
    # 下面逻辑用于从输入字符串中解析处主体字符，和等效字符
    for c in s:
        if c == '(':
            isOpen = True
            eqs.append(set())
        elif c == ')':
            isOpen = False
            if len(eqs[-1]) == 0:
                eqs.pop()  # 如果等效字符容器为空，则删除
        else:
            if not isOpen:
                sb.append(c)
            else:
                eqs[-1].add(c)
#     return len(sb)
    # 暴力的对等效字符容器进行合并
    while True:
        for i in range(len(eqs)):
            for j in range(i + 1, len(eqs)):
                if canCombine(eqs[i], eqs[j]):
                    eqs[i].update(eqs[j])
                    eqs.pop(j)
                    break
            else:
                continue
            break
        else:
            break

    cArr = list(sb)
    
    # 替换主体字符容器中的字符
    for eq in eqs:
        ls = list(eq)
        ls.sort()
        t = ls[0]
        for i in range(len(cArr)):
            if cArr[i] in eq:
                cArr[i] = t
    
    ans = "".join(cArr)
    
    # 如果简化后的字符串为空，请输出为"0"。
    return "0" if len(ans) == 0 or ans == '' else ans


def canCombine(set1, set2):
    # c 是小写字符
    for c in range(ord('a'), ord('z') + 1):
        uc = chr(c - 32)  # uc是大写字符
        if (chr(c) in set1 or uc in set1) and (chr(c) in set2 or uc in set2):
            return True
    return False


s = input()
print(getResult(s))

Java

import java.util.LinkedList;
import java.util.Scanner;
import java.util.TreeSet;
 
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String s = sc.nextLine();
    System.out.println(getResult(s));
  }
 
  public static String getResult(String s) {
    // 主体字符容器
    StringBuilder sb = new StringBuilder();
    // 等效字符容器的集合
    LinkedList<TreeSet<Character>> eqs = new LinkedList<>();
 
    //  isOpen标志，表示有没有遇到 '(' 字符
    boolean isOpen = false;
 
    // 下面逻辑用于从输入字符串中解析处主体字符，和等效字符
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
 
      if (c == '(') {
        isOpen = true;
        eqs.add(new TreeSet<>());
      } else if (c == ')') {
        isOpen = false;
        if (eqs.getLast().size() == 0) eqs.removeLast(); // 如果等效字符容器为空，则删除
      } else {
        if (!isOpen) sb.append(c);
        else eqs.getLast().add(c);
      }
    }
 
    // 暴力的对等效字符容器进行合并
    outer:
    while (true) {
      for (int i = 0; i < eqs.size(); i++) {
        for (int j = i + 1; j < eqs.size(); j++) {
          if (canCombine(eqs.get(i), eqs.get(j))) {
            eqs.get(i).addAll(eqs.get(j));
            eqs.remove(j);
            continue outer;
          }
        }
      }
      break;
    }
 
    char[] cArr = sb.toString().toCharArray();
 
    // 替换主体字符容器中的字符
    for (TreeSet<Character> eq : eqs) {
      Character t = eq.first();
      for (int i = 0; i < cArr.length; i++) {
        if (eq.contains(cArr[i])) cArr[i] = t;
      }
    }
 
    String ans = new String(cArr);
 
    // 如果简化后的字符串为空，请输出为"0"。
    return ans.length() == 0 ? "0" : ans;
  }
 
  public static boolean canCombine(TreeSet<Character> set1, TreeSet<Character> set2) {
    // c 是小写字符
    for (char c = 'a'; c <= 'z'; c++) {
      char uc = (char) (c - 32); // uc是大写字符
      if ((set1.contains(c) || set1.contains(uc)) && (set2.contains(c) || set2.contains(uc))) {
        return true;
      }
    }
    return false;
  }
}

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strings"
)

func getResult(str string) string {
	var ans string
	var sb []byte
	var eqs []map[byte]bool
	isOpen := false
	s := strings.TrimSpace(str)

	for i := 0; i < len(s); i++ {
		c := s[i]
		if c == '(' {
			isOpen = true
			eqs = append(eqs, make(map[byte]bool))
		} else if c == ')' {
			isOpen = false
			if len(eqs[len(eqs)-1]) == 0 {
				eqs = eqs[:len(eqs)-1]
			}
		} else {
			if !isOpen {
				sb = append(sb, c)
			} else {
				eqs[len(eqs)-1][c] = true
			}
		}
	}

	for {
		merged := false
		for i := 0; i < len(eqs); i++ {
			for j := i + 1; j < len(eqs); j++ {
				if canCombine(eqs[i], eqs[j]) {
					for k := range eqs[j] {
						eqs[i][k] = true
					}
					eqs = append(eqs[:j], eqs[j+1:]...)
					merged = true
					break
				}
			}
			if merged {
				break
			}
		}
		if !merged {
			break
		}
	}

	cArr := []byte(sb)

	for _, eq := range eqs {
		ls := make([]byte, 0, len(eq))
		for k := range eq {
			ls = append(ls, k)
		}
		sort.Slice(ls, func(i, j int) bool {
			return ls[i] < ls[j]
		})
		t := ls[0]
		for i := 0; i < len(cArr); i++ {
			if _, ok := eq[cArr[i]]; ok {
				cArr[i] = t
			}
		}
	}

	ans = string(cArr)

	if ans == "" {
		return "0"
	}
	return ans
}

func canCombine(set1, set2 map[byte]bool) bool {
	for c := byte('a'); c <= 'z'; c++ {
		uc := c - 32
		if (set1[c] || set1[uc]) && (set2[c] || set2[uc]) {
			return true
		}
	}
	return false
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	str, _ := reader.ReadString('\n')
	fmt.Println(getResult(str))
}

Js

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
 
rl.on("line", (line) => {
  console.log(getResult(line));
});
 
function getResult(s) {
  // 主体字符容器
  const cArr = [];
  // 等效字符容器的集合
  const eqs = [];
 
  //  isOpen标志，表示有没有遇到 '(' 字符
  let isOpen = false;
 
  // 下面逻辑用于从输入字符串中解析处主体字符，和等效字符
  for (let i = 0; i < s.length; i++) {
    const c = s[i];
 
    if (c == "(") {
      isOpen = true;
      eqs.push(new Set());
    } else if (c == ")") {
      isOpen = false;
      if (eqs.at(-1).size == 0) eqs.pop(); // 如果等效字符容器为空，则删除
    } else {
      if (!isOpen) cArr.push(c);
      else eqs.at(-1).add(c);
    }
  }
 
  // 暴力的对等效字符容器进行合并
  outer: while (true) {
    for (let i = 0; i < eqs.length; i++) {
      for (let j = i + 1; j < eqs.length; j++) {
        if (canCombine(eqs[i], eqs[j])) {
          eqs[i] = new Set([...eqs[i], ...eqs[j]]);
          eqs.splice(j, 1);
          continue outer;
        }
      }
    }
    break;
  }
 
  // 替换主体字符容器中的字符
  for (let eq of eqs) {
    const t = [...eq].sort()[0];
    for (let i = 0; i < cArr.length; i++) {
      if (eq.has(cArr[i])) cArr[i] = t;
    }
  }
 
  const ans = cArr.join("");
 
  // 如果简化后的字符串为空，请输出为"0"。
  return ans.length == 0 ? "0" : ans;
}
 
function canCombine(set1, set2) {
  for (let c = 97; c <= 122; c++) {
    const lower = String.fromCharCode(c); // 小写字符
    const upper = String.fromCharCode(c - 32); // 大写字符
    if (
      (set1.has(lower) || set1.has(upper)) &&
      (set2.has(lower) || set2.has(upper))
    ) {
      return true;
    }
  }
 
  return false;
}
塔子哥学算法
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
华为OD机试 - 字符串化繁为简（Java & JS & Python）
u012657708的博客
06-10 357
给定一个输入字符串，字符串只可能由英文字母（ 'a' ~ 'z'、'A' ~ 'Z' ）和左右小括号（ '('、')' ）组成。当字符里存在小括号时，小括号是成对的，可以有一个或多个小括号对，小括号对不会嵌套，小括号对内可以包含1个或多个英文字母，也可以不包含英文字母。
华为OD机试 - 字符串化繁为简（Python）
m0_46181452的博客
07-04 221
输入字符串为"never(dont)give(run)up(f)()"，初始等效字符集合为('d', 'o', 'n', 't')、('r', 'u', 'n')，由于等效关系可以传递，因此最终等效字符集合为('d', 'o', 'n', 't', 'r', 'u')，将输入字符串里的剩余部分按字典序最小的等效字符替换后得到"devedgivedp'给定一个输入字符串，字符串只可能由英文字母（ 'a' ~ 'z'、'A' ~ 'Z' ）和左右小括号（ '('、')' ）组成。输入为1行，代表输入字符串。
华为OD机考算法题：字符串化繁为简
星光灿烂
09-07 2371
华为OD机试题目《字符串化繁为简》的题目解读、最优解的思路分析和代码实现（包括Java和JavaScript）。 时间复杂度为 O(n)，空间复杂度为 O(1)。
【华为OD机试】字符串化繁为简【2023 B卷|200分】
goldarmour的博客
07-13 672
给定一个输入字符串，字符串只可能由英文字母 (a ~z、A~ Z ) 和左右小括号 (、) 组成当字符里存在小括号时，小括号是成对的，可以有一个或多个小括号对，小括号对不会嵌套，小括号对内可以包含1个或多个英文字母也可以不包含英文字母。
华为OD机试 - 字符串化繁为简 (c++并查集)
qq_43184135的博客
08-03 171
UnionFindSet(int n) : count(n) { // 构造函数，初始化父节点为自身。= y_fa) { // 如果两个节点不在同一个连通块中，则合并。void unionSet(int x, int y) { // 合并两个节点所在的连通块。int find(int x,int mnum) { // 查找节点的根节点。// 存储每个节点的父节点。
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 字符串摘要
m0_73659489的博客
07-17 231
为了更好的阅读体检，可以查看我的算法。
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 恢复数字序列
2301_78482949的博客
06-19 620
为了更好的阅读体检，可以查看我的算法学习博客。
电子测量中的东方集成测试仪器携手华为备战W-CDMA
11-22
一个可以作为佐证的事实是，华为公司日前储备了近400台的手机生产测试仪器，备战W-CDMA项目。据华为在测试仪器领域的合作伙伴东方集成透露，华为为新的手机项目准备600台到800台手机综测仪，其中一半将由中国测试...
2010-2013华为历年笔试题大汇总-31.pdf
06-08
"华为历年笔试题大汇总-31" 本资源汇总了华为历年来的笔试题目，涵盖了多种类型的岗位和...该资源汇总了华为历年来的笔试题，涵盖了多种类型的岗位和领域，能够帮助考生更好地备战华为笔试，提高自己的知识和技能。
H12-111-ENU HCIA-IoT考题.docx
10-22
HCIA-IoT是由华为公司提供的一种认证考试，旨在评估考生的ICT技术知识和技能，特别是在物联网领域。该考试涵盖了物联网技术的各个方面，包括5G、NB-IoT、物联网架构、数据处理和分析等。 二、HCIA-IoT考试大纲 ...
竞赛资料源码-备战2021“华为杯”研究生数学建模竞赛.zip
01-25
教育部认可的大学生竞赛备赛资料代码，源码，竞赛总结，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通 数学建模、全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯...
竞赛资料源码-备战2020第十一届蓝桥杯大赛.zip
01-25
教育部认可的大学生竞赛备赛资料代码，源码，竞赛总结，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通 全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯、集成电路...
华为OD机考题HJ1 字符串最后一个单词的长度
磐门的博客
06-13 418
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
最新发布
清隆学长的博客
06-15 107
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 目录管理器(200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 92
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 生成哈夫曼树(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 221
LYA 是一名计算机专业的学生,最近她学习了哈夫曼编码。为了巩固知识,她决定写一个程序来生成哈夫曼树。 给定一个长度为 $n$ 的正整数数组,每个数字代表二叉树叶子节点的权值。请你帮助 LYA 生成一棵哈夫曼树,并将其按中序遍历的顺序输出。 为了保证输出的哈夫曼树唯一,需要满足以下条件: 1. 树中每个非叶子节点的权值等于其左右子节点权值之和。 2. 对于权值相同的两个节点,左子树的高度应小于等于右子树的高度。 3. 在满足上述条件的前提下,左子节点的权值应小于等于右子节点的权值。 ### 输
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 启动多任务排序(200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 174
卢小姐在开发一个应用程序，启动时需要执行多个初始化任务。这些任务之间可能存在依赖关系，例如任务 𝐴 A 依赖任务 𝐵 B，那么必须在任务 𝐵 B 执行完成之后，才能开始执行任务 𝐴 A。现在给出多条任务依赖关系的规则，请输出任务的执行顺序。规则采用贪心策略，即如果一个任务没有依赖的任务，则立即开始执行；如果同时有多个任务可以执行，则按照任务名称的字母顺序排序。 例如，如果任务 𝐵 B 依赖任务 𝐴 A，任务 𝐶 C 依赖任务 𝐴 A，任务 𝐷 D 依赖任务 𝐵 B
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 特惠寿司(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 285
LYA 去一家寿司店吃饭，店里正在举办优惠活动。转盘上有 $n$ 盘寿司，第 $i$ 盘寿司的价格为 $prices[i]$。如果 LYA 选择第 $i$ 盘寿司，店家会免费赠送距离第 $i$ 盘寿司最近的下一盘价格更低的寿司 $j$（即 $prices[j] < prices[i]$）。如果不存在这样的寿司 $j$，则不赠送。每种价格的寿司数量无限。请问 LYA 选择每盘寿司，最终实际得到的寿司总价格分别是多少？ ### 输入格式 输入一行，包含 $n$ 个空格分隔的正整数，表示 $n$ 盘寿司的价格
华为od机试 数大雁
08-01
华为OD机试题目通常由一系列算法编程题组成，其中涵盖了数据结构和算法、字符串操作、动态规划、图论、递归、搜索等各个方面的知识点。考生需要根据题目要求，自行设计算法并编写相应的代码，来解决问题。 这一环节...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

塔子哥学算法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值