让建站和SEO变得简单
让不懂建站的用户快速建站，让会建站的提高建站效率！
让不懂建站的用户快速建站，让会建站的提高建站效率！
和单双
2026-05-07：给定规模内均衡整数的数量。用go讲话，给定两个整数 low 和 high，统计在闭区间 [low， high] 内得志“均衡”要求的整数个数。
对某个整数，先要求它至少是两位数。接着把它的每一位数字按位置从左到右编号，最左边是第 1 位。将通盘在奇数位上的数字相加，得到奇数位数字和；再把通盘在偶数位上的数字相加，得到偶数位数字和。淌若这两个和特殊，则该整数被称为“均衡整数”。
最终，你需要复返区间 [low， high] 中通盘均衡整数的数量。
1
输入： low = 1， high = 100。
输出： 9。
阐明：
1 到 100 之间共有 9 个均衡数，折柳是 11、22、33、44、55、66、77、88 和 99。
题目来独力扣3791。
均衡整数计数代码试验过程分步详解
一、代码举座试验手脚（分阶段）
阶段1：基础领域过滤
1. 函数给与low和high两个超大整数（int64类型）；
2. 领先判断：淌若high
3. 把low修正为max(low， 11)，排斥1-10这些无效数字，减轻盘算规模。
阶段2：数字相貌化与预处理
1. 将修正后的low和high诊疗成字符串：
• 方向：简短逐位处理每一位数字（数位DP的中枢操作）；
2. 盘算high的字符串长度n（最大数字的位数）：
• 示例中high=100，字符串是"100"，长度n=3；
3. 盘算diffLH：high的位数 - low的位数，用于后续终局低位数字的胪列规模；
4. 启动化顾忌化数组（memo）：
• 二维数组：第一维是现时处理到第几位（0~n-1），第二维是奇偶位差值的存储位；
• 作用：缓存一经盘算过的景色，幸免重迭递归，大幅提高成果。
阶段3：中枢逻辑 —— 数位DFS递归（深度优先搜索）
界说递归函数dfs，这是数位DP的中枢，参数含义：
• i：现时正在处理第i位数字（从0出手，对应数字的最高位）；
• diff：奇数位和 - 偶数位和的差值（最终diff=0即是均衡数）；
• limitLow：布尔值，现时位是否受low的下限拘谨；
• limitHigh：布尔值，现时位是否受high的上限拘谨。
递归试验历程：
子手脚1：递归辩认要求
当i == n（通盘位数处理完毕）：
• 判断diff是否等于0：
等于0 → 是均衡数，复返1（计数+1）；
不等于0 → 不是均衡数，复返0。
子手脚2：顾忌化缓存读取
淌若现时不受low和high的数字终局（不错解放胪列0-9）：
1. 盘算顾忌数组的下标（将差值偏移为非负数，着重数组越界）；
2. 淌若该景色一经盘算过 → 班师复返缓存的完毕，不重迭盘算；
3. 淌若没盘算过 → defer延伸存储完毕，盘算完成后写入缓存。
子手脚3：详情现时位的胪列规模
把柄limitLow和limitHigh，终局现时位能选的数字：
• 下限lo：受拘谨时=low对应位的数字，不受拘谨时=0；
• 上限hi：受拘谨时=high对应位的数字，不受拘谨时=9；
• 示例：处理100的百位时，快乐彩app官方下载hi只关联词1，不成朝上high的数字。
子手脚4：胪列现时位的通盘正当数字
轮回遍历从lo到hi的每一个数字d：
1. 更新差值diff：
• 第i位是奇数位（i%2=0）：diff = diff + d；
• 第i位是偶数位（i%2=1）：diff = diff - d；
2. 更新拘谨要求：
• 下一位的limitLow = 现时拘谨 且 现时选的数字=下限；
• 下一位的limitHigh = 现时拘谨 且 现时选的数字=上限；
3. 递归调用下一位，累加通盘正当完毕。
子手脚5：复返累计完毕
将现时位通盘胪列情况的完毕乞降，复返给上一层递归。
阶段4：复返最终谜底
启动递归dfs(0， 0， true， true)（从第0位出手，启动差值为0，同期受low和high拘谨），函数复返的即是[low， high]内均衡整数的总额量。
二、针对示例输入的试验考证
输入：low=1，high=100
1. 过滤：high=100≥11，low修正为11；
2. 相貌化：low="11"（2位），high="100"（3位），n=3；
3. 递归胪列通盘11~100的两位数、三位数：
• 两位数（11~99）：奇数位=十位，偶数位=个位，十位=个位 → 11、22…99，共9个；
• 三位数（100）：奇数位（百位+个位）=1+0=1，偶数位（十位）=0，1≠0 → 分歧法；
4. 最终完毕=9，与题目输出一致。
三、时代复杂度 & 异常空间复杂度
1. 时代复杂度
O(位数 × 最大差值 × 10)
• 中枢变量：
1. 数字最大位数n：10¹⁵对应15位；
2. 奇偶位最大差值：每位最大9，总差值≤15×9=135；
3. 每位胪列数字：0~9共10种遴荐；
• 算盘算量：15 × 135 × 10 = 20250（常数级极小盘算量）；
• 骨子：O(1) 常数时代复杂度（因为位数固定最大15，无变量级增长）。
2. 异常空间复杂度
O(位数 × 最大差值)
• 中枢占用：顾忌化数组memo；
• 大小：15（位数） × 135（最大差值）= 2025 个int64元素；
• 递归栈空间：最大深度=数字位数=15，可忽略；
• 骨子：O(1) 常数空间复杂度。
追念
1. 代码中枢是数位DP+顾忌化递归，特意贬责超大规模数字的数位统计问题；
2. 试验历程：领域过滤→数字相貌化→顾忌化DFS逐位胪列→统计正当均衡数；
3. 时代复杂度：O(1)（常数级）；
4. 异常空间复杂度：O(1)（常数级）。
Go完满代码如下：
package main
import (
"fmt"
"strconv"
)
func countBalanced(low， high int64)int64 {
// 最小的得志要求的数是 11
if high
return0
}
low = max(low， 11)
lowS := strconv.FormatInt(low， 10)
highS := strconv.FormatInt(high， 10)
n := len(highS)
diffLH := n - len(lowS)
memo := make([][]int64， n)
for i := range memo {
// diff 至少 floor(n/2) * 9，至多 ceil(n/2) * 9，值域大小 n * 9
memo[i] = make([]int64， n*9+1)
}
var dfs func(int， int， bool， bool)int64
dfs = func(i， diff int， limitLow， limitHigh bool) (res int64) {
if i == n {
if diff != 0 { // 分歧法
return0
}
return1
}
if !limitLow && !limitHigh {
p := &memo[i][diff+n/2*9] // 保证下标非负
if *p > 0 {
return *p - 1
}
deferfunc { *p = res + 1 } // 顾忌化的时候加一，这么 memo 不错启动化成 0
}
lo := 0
if limitLow && i >= diffLH {
lo = int(lowS[i-diffLH] - '0')
}
hi := 9
if limitHigh {
hi = int(highS[i] - '0')
}
for d := lo; d
// 下一个位置奇偶性翻转
res += dfs(i+1， diff+(1-i%2*2)*d，
limitLow && d == lo， limitHigh && d == hi)
}
return
}
return dfs(0， 0， true， true)
}
func main {
low := int64(1)
high := int64(100)
result := countBalanced(low， high)
fmt.Println(result)
}
Python完满代码如下：
# -*-coding:utf-8-*-
def count_balanced(low: int， high: int) -> int:
if high
return0
low = max(low， 11)
low_str = str(low)
high_str = str(high)
n = len(high_str)
diff_lh = n - len(low_str)
# 顾忌化数组：memo[i][diff_offset]
# diff 的取值规模：[-max_diff， max_diff]，max_diff = (n // 2 + (n % 2)) * 9
max_possible_diff = ((n + 1) // 2) * 9
memo = [[-1] * (2 * max_possible_diff + 1) for _ in range(n)]
def dfs(i: int， diff: int， limit_low: bool， limit_high: bool) -> int:
if i == n:
return1if diff == 0else0
# 顾忌化：惟一当不受 low 和 high 终局时才能复用
if not limit_low and not limit_high:
idx = diff + max_possible_diff
if memo[i][idx] != -1:
return memo[i][idx]
lo = 0
if limit_low and i >= diff_lh:
lo = int(low_str[i - diff_lh])
hi = 9
if limit_high:
hi = int(high_str[i])
total = 0
for d in range(lo， hi + 1):
# 把柄位置 i 的奇偶性决定 diff 的增减
# i=0 是最高位（视为偶数位，与 Go 版块一致）
sign = 1if i % 2 == 0else-1
total += dfs(i + 1， diff + sign * d，
limit_low and d == lo，
limit_high and d == hi)
if not limit_low and not limit_high:
memo[i][diff + max_possible_diff] = total
return total
return dfs(0， 0， True， True)
if __name__ == "__main__":
low_val = 1
high_val = 100
result = count_balanced(low_val， high_val)
print(result)
C++完满代码如下：
#include
#include
#include
#include
#include
#include
using namespace std;
long long countBalanced(long long low， long long high) {
// 最小的得志要求的数是 11
if (high
return0;
}
low = max(low， 11LL);
string lowS = to_string(low);
string highS = to_string(high);
int n = highS.length;
int diffLH = n - lowS.length;
// 启动化顾忌化数组，使用 -1 默示未盘算
vector> memo(n， vector(n * 9 + 1， -1));
// 使用函数对象好意思满递归
function dfs = [&](int i， int diff， bool limitLow， bool limitHigh) -> long long {
if (i == n) {
return diff == 0 ? 1 : 0;
}
if (!limitLow && !limitHigh) {
int idx = diff + n / 2 * 9;
if (idx >= 0 && idx
return memo[i][idx];
}
}
int lo = 0;
if (limitLow && i >= diffLH) {
lo = lowS[i - diffLH] - '0';
}
int hi = 9;
if (limitHigh) {
hi = highS[i] - '0';
}
long long res = 0;
for (int d = lo; d
// 下一个位置奇偶性翻转
res += dfs(i + 1， diff + (1 - i % 2 * 2) * d，
limitLow && d == lo， limitHigh && d == hi);
}
if (!limitLow && !limitHigh) {
int idx = diff + n / 2 * 9;
if (idx >= 0 && idx
memo[i][idx] = res;
}
}
return res;
};
return dfs(0， 0， true， true);
}
int main {
long long low = 1;
long long high = 100;
long long result = countBalanced(low， high);
cout
return0;
}
咱们服气东谈主工智能为庸碌东谈主提供了一种“增强用具”，并神敢于共享全场地的AI常识。在这里，您不错找到最新的AI科普著述、用具评测、提高成果的隐秘以及行业知悉。
迎接关切“福大大架构师逐日一题”快乐彩，发音信可取得口试贵寓，让AI助力您的翌日发展。
博亚体育app官方网站上一篇：快乐彩app官方最新版下载 泡泡玛特王宁：在LABUBU最火的时刻，暂停了线下营销以及对外互助
下一篇：没有了
备案号: