数据结构与算法之递归: LeetCode 37. 解数独 (Ts版)

macOS 12.7.6部署Ollama+Dify避坑指南 本文介绍了在macOS 12.7.6系统下部署Ollama和Dify的详细步骤及避坑指南。主要内容包括:1)关闭系统完整性保护(SIP)以允许修改系统目录;2)安装特定版本的Docker(2.1.0.5)和docker-compose(v2.38.2)以避免兼容性问题;3)配置Ollama服务并下载nomic-embed-text和deepseek-r1:7b模型;4)针对macOS调整Dify的docker配置文件,包括延长超时时间、修改存储路径、增加资源限制等关键设置。文中提供了完整的命令操作步骤和配置 阅读详情

解数独

描述

  • 编写一个程序,通过填充空格来解决数独问题
  • 数独的解法需 遵循如下规则:
    • 数字 1-9 在每一行只能出现一次
    • 数字 1-9 在每一列只能出现一次
    • 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。(请参考示例图)
  • 数独部分空格内已填入了数字,空白格用 ‘.’ 表示

示例 1

输入: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"]]
输出:[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]

解释:输入的数独如上图所示,唯一有效的解决方案如下所示:

提示

  • board.length == 9
  • board[i].length == 9
  • board[i][j] 是一位数字或者 ‘.’
  • 题目数据 保证 输入数独仅有一个解

Typescript 版算法实现


1 ) 方案1: 回溯

/**
 Do not return anything, modify board in-place instead.
 */
function solveSudoku(board: string[][]): void {
    const line: boolean[][] = Array.from({ length: 9 }, () => Array(9).fill(false));
    const column: boolean[][] = Array.from({ length: 9 }, () => Array(9).fill(false));
    const block: boolean[][][] = Array.from({ length: 3 }, () => 
        Array.from({ length: 3 }, () => Array(9).fill(false))
    );
    const spaces: number[][] = [];

    // 初始化状态
    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            if (board[i][j] === '.') {
                spaces.push([i, j]);
            } else {
                const digit = parseInt(board[i][j]) - 1;
                line[i][digit] = true;
                column[j][digit] = true;
                block[Math.floor(i / 3)][Math.floor(j / 3)][digit] = true;
            }
        }
    }

    // 深度优先搜索函数
    function dfs(pos: number): boolean {
        if (pos === spaces.length) {
            return true;
        }
        const [i, j] = spaces[pos];
        for (let digit = 0; digit < 9; digit++) {
            if (!line[i][digit] && !column[j][digit] && !block[Math.floor(i / 3)][Math.floor(j / 3)][digit]) {
                line[i][digit] = true;
                column[j][digit] = true;
                block[Math.floor(i / 3)][Math.floor(j / 3)][digit] = true;
                board[i][j] = (digit + 1).toString();

                if (dfs(pos + 1)) {
                    return true;
                }

                // 回溯
                line[i][digit] = false;
                column[j][digit] = false;
                block[Math.floor(i / 3)][Math.floor(j / 3)][digit] = false;
                board[i][j] = '.';
            }
        }
        return false;
    }

    dfs(0);
}

2 ) 方案2: 位运算优化

/**
 Do not return anything, modify board in-place instead.
 */
function solveSudoku(board: string[][]): void {
    const line: number[] = Array(9).fill(0);
    const column: number[] = Array(9).fill(0);
    const block: number[][] = Array.from({ length: 3 }, () => Array(3).fill(0));
    const spaces: number[][] = [];

    // 翻转函数,用于设置或清除位
    function flip(i: number, j: number, digit: number) {
        const mask = 1 << digit;
        line[i] ^= mask;
        column[j] ^= mask;
        block[Math.floor(i / 3)][Math.floor(j / 3)] ^= mask;
    }

    // 初始化状态
    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            if (board[i][j] === '.') {
                spaces.push([i, j]);
            } else {
                const digit = parseInt(board[i][j]) - 1;
                flip(i, j, digit);
            }
        }
    }

    // 深度优先搜索函数
    function dfs(pos: number): boolean {
        if (pos === spaces.length) {
            return true;
        }
        const [i, j] = spaces[pos];
        let mask = 0x1ff & ~(line[i] | column[j] | block[Math.floor(i / 3)][Math.floor(j / 3)]);

        while (mask > 0) {
            const digit = Math.log2(mask & -mask); // 找到最右侧的 1 的位置
            flip(i, j, digit);
            board[i][j] = (digit + 1).toString();
            if (dfs(pos + 1)) {
                return true;
            }
            flip(i, j, digit);
            mask &= mask - 1; // 将最右侧的 1 置为 0
        }
        return false;
    }

    dfs(0);
}

3 ) 方案3: 枚举优化

/**
 Do not return anything, modify board in-place instead.
 */
function solveSudoku(board: string[][]): void {
    const line: number[] = Array(9).fill(0);
    const column: number[] = Array(9).fill(0);
    const block: number[][] = Array.from({ length: 3 }, () => Array(3).fill(0));
    const spaces: number[][] = [];

    // 翻转函数,用于设置或清除位
    function flip(i: number, j: number, digit: number) {
        const mask = 1 << digit;
        line[i] ^= mask;
        column[j] ^= mask;
        block[Math.floor(i / 3)][Math.floor(j / 3)] ^= mask;
    }

    // 初始化已知数字的状态
    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            if (board[i][j] !== '.') {
                const digit = parseInt(board[i][j]) - 1;
                flip(i, j, digit);
            }
        }
    }

    // 尝试通过唯一解填充空格
    let modified: boolean;
    do {
        modified = false;
        for (let i = 0; i < 9; i++) {
            for (let j = 0; j < 9; j++) {
                if (board[i][j] !== '.') {
                    continue;
                }
                let mask = 0x1ff & ~(line[i] | column[j] | block[Math.floor(i / 3)][Math.floor(j / 3)]);
                if ((mask & (mask - 1)) === 0 && mask !== 0) { // mask 的二进制表示仅有一个 1
                    const digit = Math.log2(mask); // 找到最右侧的 1 的位置
                    flip(i, j, digit);
                    board[i][j] = (digit + 1).toString();
                    modified = true;
                }
            }
        }
    } while (modified);

    // 记录剩余未填充的空格
    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            if (board[i][j] === '.') {
                spaces.push([i, j]);
            }
        }
    }

    // 深度优先搜索函数
    function dfs(pos: number): boolean {
        if (pos === spaces.length) {
            return true;
        }
        const [i, j] = spaces[pos];
        let mask = 0x1ff & ~(line[i] | column[j] | block[Math.floor(i / 3)][Math.floor(j / 3)]);

        while (mask > 0) {
            const digit = Math.log2(mask & -mask); // 找到最右侧的 1 的位置
            flip(i, j, digit);
            board[i][j] = (digit + 1).toString();
            if (dfs(pos + 1)) {
                return true;
            }
            flip(i, j, digit);
            mask &= mask - 1; // 将最右侧的 1 置为 0
        }
        return false;
    }

    dfs(0);
}
Cisco Packet Tracert 无线路由器配置 阅读详情

相关推荐

arcgis select by attributes一次选多个_视频:如何基于ArcGIS与GeoDa求莫兰指数和绘制莫兰散点图?...

莫兰指数是全域莫兰指数(Global Moran's I)的简称,是澳大利亚统计学家帕特里克·阿尔弗雷德·皮尔斯·莫兰(Patrick Alfred Pierce Moran),在1950年提出的。详细介绍,如下:莫兰指数取值范围在-1.0至1.0之间。当Moran's I >0时,表示空间正相关性,其值越大,空间相关性越明显;当Moran's I <0时,表示空间负相关性...

weixin_39948247的博客 1760

TypeScript 解数独

TS 解数独几个关键函数和变量解释一下 几个关键函数和变量解释一下 board :棋盘 , 1 - 9 表示填入的数字 ,0 表示没有填数字 index : 传入 x 和 y , 返回 board 中对应的位置 dump : 打印当前棋盘 getValid : 传入 x 和 y,返回对应位置可填入的合法的数字. 1 - 9 排除同行同列的数字 ,再排除所在3*3区域的数字 resu : ...

mrleipc的博客 361

世界模型和大语言模型结合开发自动驾驶算法

摘要:自动驾驶系统开发中,融合世界模型和大语言模型可显著提升效率和安全性。世界模型负责环境感知与预测(如目标检测、轨迹预测),而大语言模型优化代码生成、决策解释等环节。实施路径包括需求分析(1-2周)、模型开发(2-4个月)、模拟测试(1-2个月)、实车测试(2-3个月)和合规优化(1-2个月),总周期6-12个月。关键技术工具包括PyTorch/TensorFlow、CARLA模拟器和ROS系统,核心设计理念强调模块化、安全优先和敏捷迭代。示例代码展示了YOLO目标检测与大语言模型决策建议的集成方案。该方

ponygame的博客 827

LeetCode题解回溯篇(TS版)

这是因为:即使把 5 选上,后面的数只有 6 和 7,一共就 3 个候选数,凑不出 4 个数的组合。数组中可能含有重复元素,如出现两个整数相等,也可以视作递增序列的一种特殊情况。按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。如果存在多种有效的行程,请你按字典排序返回最小的行程组合。,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。如果至少一个数字的被选数量不同,则两种组合是不同的。的字符串,返回所有它能表示的字母组合。,用以表示一个 IP 地址,返回所有可能的。

Leon_Chenl的博客 569

海康威视SADP SDK实战:5分钟搞定局域网设备搜索(附C++代码示例)

本文详细解析了海康威视SADP SDK在局域网设备搜索中的高效应用,通过C++代码示例展示如何快速实现设备发现与信息获取。SADP协议支持全面设备信息采集和实时状态更新,适用于智能安防和物联网管理场景,帮助开发者5分钟内完成设备搜索功能集成。

rum55的博客 882

python爬取巨潮资讯网所有股票年报数据

爬虫获取巨潮资讯网数据

qq_42752524的博客 6130

数据结构与算法笔记:字典序最大问题分析

字典序最大问题 问题描述 给定一个1到n的排列(无序状态的),依次插入到栈中,在每时每刻都可以多次从栈中弹出栈顶 问:应如何使得弹出栈顶的序列的字典序最大,并输出这个序列 问题分析 什么是字典序 比如两个序列:5,4,3,2,1和1,2,3,4,5 这两个中第一个的字典序最大 每个位置上的数字比其他序列上同一位置的数字要大 比如:第一位置中5比1大,第二位置中4比2大这样 即:字典序最大 = 从左向右看这个序列,每个数字都尽量大 题目给定一个1到n的排列,每个数字只出现一次 要使出栈的字典序最大

Wang的专栏 4396

UCOS-III 系统移植

UCOSIII系统移植到GD32F303详细过程 工程代码:https://github.com/jslaobing/techIot_ucosiii_porting

TechIoT - 探索物联网与嵌入式系统 2088

数据结构与算法笔记:农夫过河问题python3实现

问题描述 农夫(Human)过河。一个农夫带着一只狼(Wolf),一只羊(Sheep)和一些菜(Vegetable)过河。河边只有一条船,由于船太小,只能装下农夫和他的一样东西。在无人看管的情况下,狼要吃羊,羊要吃菜,请问农夫如何才能使三样东西平安过河? 要求: 输出一行,为最终的过河方式,方案格式为 过河人员、回来人员、过河人员、回来人员、…、过河人员。 过去和回来的人员之间,用空格隔开。 以四...

Wang的专栏 3374

从 VS Code 创建 ABAP Development Objects,包、命名、传输请求和 Clean Core 的一条线打通

文章摘要: SAP ABAP开发工具正从传统SAP GUI/Eclipse向VS Code迁移,通过ABAP Development Tools扩展实现代码编辑、调试和传输管理。文章重点分析了创建ABAP对象背后的治理逻辑:1)对象创建涉及包结构、命名规范、传输层等关键设计决策;2)VS Code通过命令面板(Ctrl+Shift+P)提供统一创建入口;3)对象类型选择反映架构意图,应从业务模型角度规划;4)Package是重要的治理边界,需按业务能力分区;5)命名和描述需体现业务语义;6)传输请求标记对象

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 178

BevFusion (1): 传感器介绍

激光雷达,也称光学雷达(LIght Detection And Ranging)是激光探测与测距系统的简称,它通过测定传感器发射器与目标物体之间的传播距离,分析目标物体表面的反射能量大小、反射波谱的幅度、频率和相位等信息,从而呈现出目标物精确的三维结构信息。激光雷达是自动驾驶车辆的关键传感器,如下图所示,车辆上方旋转的圆柱体对应就是激光雷达传感器。

@bangbang的博客 1475

数据结构与算法笔记:计算思维之经典农夫过河问题C++实现

农夫、羊、狼、菜的过河问题 问题描述 角色:农夫,羊,狼,菜 条件1:船很小,只能装下农夫和其他一个角色 条件2:无人看管,羊吃菜,狼吃羊 问:如何让其他三种角色被农夫平安带着过河? 相关分析 我们可以先用人脑尝试一下相关渡河策略 1 ) 先渡狼,人回来再渡菜,人回来再渡羊 2 ) 先渡菜,人回来再渡狼,人回来再渡羊 以上两种很好想到,而且我们可以知道羊这种角色是不能先渡河过去的,羊需要最后再渡 如果先渡了羊了,之后再渡任何其他角色,都要将羊带回来 可以参考小游戏:http://gameschool

Wang的专栏 3314

GJB 5000B二级-II实施基础

本文主要描述GJB 5000B二级II实施基础与GJB 5000A的变化情况,以及过程域各条款的实施要点

Abel的博客 2590

数据结构与算法笔记:图搜索之DFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的,比BSF要简单的多 同样,我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主,她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽,但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象

Wang的专栏 3119

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

数据结构与算法笔记:计算思维之人鬼渡河问题

人鬼渡河问题 1 ) 问题描述 目标:将东岸的3人3鬼通过一只小船安全转移到西岸,希望摆渡次数尽可能少 条件 船的容量有限,一次最多只能坐2人(或2鬼或1人1鬼) 无论是在河的东岸还是在河的西岸,一旦鬼数多于人数,则人将被鬼吃掉 怎样渡河的大权掌握在人的手中 说明:划船的时间忽略不计。船一靠岸即将船与岸视为一体,人和鬼即使还没有下 船也视为已上岸 任务:编写程序,求出一种渡河方案 备注:图片托管于github,请确保网络的可访问性 2 ) 分析 目标是找

Wang的专栏 2447

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

数据结构与算法之二叉树: LeetCode 701. 二叉搜索树中的插入操作 (Ts版)

1 ) 方案1:模拟。2 ) 方案2:递归。

Wang的专栏 2270

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

数据结构与算法笔记:计算思维之下楼梯台阶和象棋跳马问题

下台阶问题 1 ) 问题描述 从楼上走到楼下共有 h 个台阶,每一步有三种走法 走一个台阶; 走二个台阶; 走三个台阶。 问:一共可以走出多少种方案? 即共要多少步? 每一步走几级台阶? 2 ) 分析 初始思路 我们根据题目给定的场景,先简单模拟一下,设定 h=4h=4h=4 备注:图片托管于github,请确保网络的可访问性 如上图所示, 这里有4阶楼梯, 红色数字代表每一步走几级台阶 这里枚举了4层台阶的所有可能情况, 但是不管具体有几级台阶,下

Wang的专栏 2114

Python笔记:滑动验证码的识别算法

概述 用程序识别极验滑动验证码的验证,包括分析识别思路、识别缺口位置、生成滑块拖动路径、模拟实现滑块拼合通过验证等步骤。 准备工作 使用Python库是Selenium,浏览器为Chrome。请确保已安装Selenium库和ChromeDriver浏览器驱动。 关于极验滑动验证码: 极验滑动验证码官网为:http://www.geetest.com/ 验证方式为拖动滑块拼合图像,若图像完全拼合...

Wang的专栏 2105

数据结构与算法之堆: LeetCode 295. 数据流的中位数 (Ts版)

/ 返回 1.5 ((1 + 2) / 2)中位数是有序整数列表中的中间值。如果列表的大小是偶数,则没有中间值,中位数是两个中间值的平均值。3 ) 方案3:有序集合 + 双指针。2 ) 方案2:优先队列-优化版。1 ) 方案1:优先队列。

Wang的专栏 1907

数据结构与算法笔记:计算思维之谁做的好事与刑侦作案问题

谁做的好事 清华附中有四位同学中的一位做了好事,不留名,表扬信来了之后,校长问这四位是谁做的好事。 A说:不是我。 B说:是C。 C说:是D。 D说:他胡说。 已知:三个人说的是真话,一个人说的是假话。 现在请你根据这些信息,编写程序找出做了好事的人。 分析 将四个人说的四句话(自然语言)转换成计算机可以计算的式子, 可使用循环枚举的方式来判断 (1) 思路一:通过字符表示人 先定义一个字符变量 thisman 表示要寻找的做了好事的人的“名字(代号)”(A、B、C、D),即 char this

Wang的专栏 1835

数据结构与算法笔记:图搜索之BFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) 广度优先搜索BFS 我们可以用比喻来说明广度优先搜索算法 在一片草木枯黄的深秋草原上,在草原的某一处出现了一处野火 一开始的时候野火集中于一点之上,在这点野火耗尽当前植被变成灰烬之前点燃了周围的植被 比如节点s是初始火种,假设我们手中有一个秒表,每过1秒,我们的大火会向外迈进一步 这个过程只能向外,不能向内,因为只能点燃植被,不能把灰烬点燃 蓝色的点是即将变为灰烬的点,红色的点是刚被点燃的点,灰色的圆形或

Wang的专栏 1795

数据结构与算法之动态规划: LeetCode 1494. 并行课程 II (Ts版)

给你一个整数 n 表示某所大学里课程的数目,编号为 1 到 n ,数组 relations 中, relations[i] = [xi, yi] 表示一个先修课的关系,也就是课程 xi 必须在课程 yi 之前上。解释:上图展示了题目输入的图。一个最优方案是:第一学期上课程 2 和 3,第二学期上课程 4 ,第三学期上课程 1 ,第四学期上课程 5。然后第二个学期上课程 1 ,第三个学期上课程 4。在一个学期中,你 最多 可以同时上 k 门课,前提是这些课的先修课在之前的学期里已经上过了。

Wang的专栏 1749

数据结构与算法笔记:求直方图最大面积算法分析

直方图最大面积 问题描述 有n列的直方图,第j列高度为hjh_jhj​, 求一个面积最大的子矩阵 备注:图片托管于github,请确保网络的可访问性 格式要求 输入第一行正整数n,第二行n个空格隔开的非负整数 数据范围: 所有直方图的列不会超过30000 关键算法实现 1 ) 算法1:时间复杂度为: O(n3)O(n^3)O(n3)的实现 分析 矩形面积为底和高的乘积 底部从a到b,那么底边长为: b-a+1 高为:min{hi∣a≤i≤b}min \{h

Wang的专栏 1664

数据结构与算法之LRU: 实现 LRU 缓存算法功能 (Ts, Py, Go版)

LRU - Lease Recently Used 最近使用如果内存优先,只缓存最近使用的,删除 ‘沉睡’ 数据核心 api: get set分析。

Wang的专栏 1601

数据结构与算法之贪心: LeetCode 455. 分饼干 (Ts, Py, Go版)

对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j]。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。2 )排序 + 双指针 + 贪心。1 )排序 + 遍历。

Wang的专栏 1569

动态规划(Dynamic Programming)详解:从入门到 LeetCode Hot 100

将一个复杂问题拆分成多个规模更小的子问题,通过保存子问题的计算结果,避免重复计算,最终得到原问题的答案。先看一个经典问题。dp[i] = 以第 i 个元素结尾的最优结果例如最长递增子序列。最长递增子序列不一定以最后一个元素结尾,因此必须遍历整个数组取最大值。dp[i] = 前 i 个元素的最优结果这种情况下,最终答案通常就是dp[n]。关键在于理解 dp 数组的定义。动态规划的核心并不是背诵某个固定模板,而是建立正确的状态定义,并通过状态转移方程解决问题。dp[i] 或 dp[i][j] 表示什么?

zengjiajun2006的博客 910
上一篇: 数据结构与算法之递归: LeetCode 47. 全排列 II (Ts版)
下一篇: 数据结构与算法之递归: LeetCode 39. 组合总和 (Ts版)
Wang's Blog
博客等级 码龄12年 7440粉丝 2427原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wang's Blog

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

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

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

打赏作者

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

抵扣说明:

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

余额充值