当前位置：首页 > news >正文

【2025蓝桥杯省赛填空压轴题-pythonA组和研究生组】Ipv6 解析（四维dp）

news 来源：原创 2025/4/25 19:09:22

这是一个很有意思的题目，思路和方法可以非常多，做为一个5分的填空题实在可惜，目前看了一圈网上的解答，很少有完整解答的，这里给一条思路和代码，仅供参考。

文章目录

A.题目
B.思路
- 1.压缩
- 2.可能长度
- 3.四维dp
- 4.结果统计
C.代码
D.答案

A.题目

【问题描述】
小蓝最近在学习网络工程相关的知识。他最近学习到，IPv6 地址本质上是
一个 128 位的二进制数，而字符串形式的 IPv6 地址是由被冒号分开的八段 16
进制数组成的, 例如，下面每行是一个字符串形式的 IPv6 地址:
0000:0000:0000:0000:0000:0000:0000:0000
0000:0001:0000:0000:0000:0001:0000:0000
0000:0001:00ab:0000:0023:0000:0a00:0e00
0000:0000:00ab:0000:000a:0001:0a00:0e00
0000:0000:00ab:0000:0000:0001:0a00:0e00
其中，每一段最长 4 位，且每一段的前导零都可以去掉（如果 4 位都为 0
需要写成 0）。
另外，IPv6 地址还可以将其中相邻的值为 0 的段合并压缩起来，用两个冒
号来表示，不过只能压缩一段。
例如上述地址最短的压缩后的形式分别为
::
0:1::1:0:0
0:1🆎:23:0:a00:e00
:🆎0🅰️1:a00:e00
0:0🆎:1:a00:e00
小蓝想知道, 所有 IPv6 地址的最短压缩形式的长度的和为多少？由于答案
很大（甚至超过了 128 位二进制整数的范围），请填写答案时填写这个总和除以
109 + 7 的余数。

【答案提交】
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数（在 0 到 109 + 6 的范围内），在提交答案时只填写这个整数，填写多余的
内容将无法得分。

B.思路

1.压缩

第一个关键点在于理解Ipv6压缩的思想：【可以将最长的一段“连续的全 0 分组”用 :: 压缩一次】
例如把 0000:0000:00ab:0000:000a:0001:0a00:0e00 压成 :🆎0🅰️1:a00:e00 等。
注意：

如果没有长度 ≥2 的连续全零分组，则不值得使用 ::（对单个 0 分组用 :: 反而会变长）。
若存在多段长度相同的连续零分组，都能达到相同的压缩长度，随便选哪一段做压缩都不会影响最终的最短表示长度。

不压缩时的长度 = 所有分组去掉前导零后的长度之和 + 7( 7 个冒号)
如果有一段最大长度为 $r(\ge2)$ 的“连续零分组”，那么使用 $::$ 可以把那 $r$ 个零分组从 $r * ‘‘0" + (r - 1) * ‘‘ : "$ 替换成 $‘‘ : "$ 。

替换前此部分占 $r + (r - 1) = 2 r - 1$ 个字符，替换后只剩下 $::$ 两个字符，故可少占 $(2 r - 1) - 2 = 2 r - 3$ 个字符
若最大连续零分组长度 $< 2$ ，则不压缩。

2.可能长度

第二个关键点在于，可以把每个 16 位分组(0–65535)在去除前导零后，可能的“表示长度”及其出现次数统计出来：
分组值为 0：只会表示成 “0”，长度 =1。这种情况共有 1 种取值。
分组值非零时，根据最高有效的十六进制位在哪儿，可分为：

长度 1 (十六进制 1 位)：有 15 种取值 (0x1 ~ 0xf)
长度 2：有 240 种取值 (0x10 ~ 0xff)
长度 3：有 3840 种取值 (0x100 ~ 0xfff)
长度 4：有 61440 种取值 (0x1000 ~ 0xffff)

3.四维dp

一条 IPv6 地址只有 8 段，我们可以在“分组层面”做一个多维 DP。
核心思想是：逐段扫描 8 个分组，用 DP 记录“目前已经处理到第几段、当前连续零分组长度、已出现的最大连续零分组长度、当前总的字符和”下，有多少种地址取值组合”。

我们令 $\text{dp}[pos][curRun][maxRun][sumLen]$ ,表示：当已经处理到第 $p os$ 段(取值范围 0~8)，当前连续零分组长度是 $c u r R u n$ ，历史上最大的连续零分组长度是 $ma x R u n$ ，并且已经累加的“去前导零后字符总和”为 $s u m L e n$ 时，有多少种具体的分组取值序列能到达这里。

四个维度的取值范围：

$p os$ 范围是 0~8(共 9 个状态，用于表示“还没开始到处理完第 8 段”)
$c u r R u n$ 范围是 0~8（因为一口气最多可能 8 个分组都为 0）
$ma x R u n$ 范围也是 0~8
$s u m L e n$ 最大不会超过 $\times 4 = 32$ （如果全部分组都是 4 位表示），最小是 $8$ （如果全部分组都是 0，表示长度都为 1），所以可以开到 0~32 即可

状态转移：

在处理下一段 $\rightarrow pos+1$ 时，需要考虑这段可能是：

0，表示长度 =1，有 1 种取值
- 则新状态里 $n e x tC u r R u n = c u r R u n + 1$
- $n e x tM a x R u n = ma x (ma x R u n, n e x tC u r R u n)$
- $n e x tS u m L e n = s u m L e n + 1$
非零分组，表示长度可能是 1、2、3、4；相应取值种数分别是 15、240、3840、61440
- 则新状态里 $n e x tC u r R u n = 0$ (因为连续零被断开了)
  • $n e x tM a x R u n = ma x R u n$ (不变)
  • $n e x tS u m L e n = s u m L e n + L$ (L 为该分组的表示长度 1/2/3/4)
  • 每种转移要把路径数 $\text{dp}[pos][curRun][maxRun][sumLen]$ 乘以“这一段对应的取值种数”再累加到下一状态去。

4.结果统计

当 $p os = 8$ 时，说明 8 段都处理完了， $s u m L e n$ 就是这 8 段去掉前导零后的总长度， $ma x R u n$ 是全局最长连续零分组长度。

对每个末状态 $\text{dp}[8][curRun][maxRun][sumLen]$ ，其最短表示长度就是
$\text{(sumLen)} + 7 \;-\; \max\bigl(0,\;2\times(\text{maxRun}) - 3\bigr)$
若 $ma x R u n < 2$ ，则减数为 0 (不使用 $::$ )
若 $\ge 2$ ，则减数为 $(2\,\times\,\text{maxRun} - 3)$
把这一“最短表示长度”乘上末状态对应的路径数量（也就是有多少具体 IPv6 地址对应到这个状态），然后再对所有末状态求和，即可得到所有 IPv6 地址的最短表示长度之和。最后取模 ( $10^9+7$ ) 输出。

C.代码

import java.util.Arrays;

public class Main {

    static final int MOD = (int)1e9 + 7;

    public static void main(String[] args) {
        // 按照表示长度 1/2/3/4 分别是多少种取值
        int[] nonZeroLen = {1, 2, 3, 4};
        // 长度=1(非零): 15 种; 长度=2: 240; 长度=3: 3840; 长度=4: 61440
        int[] nonZeroWays = {15, 240, 3840, 61440};
        
        /**
         * dp[pos][curRun][maxRun][sumLen]：表示前 pos 段处理完后，连续零分组数=curRun，
         * 历史最大连续零分组数=maxRun，已累计分组字符和=sumLen 的情况下，共有多少种 IPv6 地址
         * 把第4维sumLen合并到三维数组里，减少一维
         */
        long[][][] dpCur = new long[9][9][33];
        long[][][] dpNxt = new long[9][9][33];
        
        dpCur[0][0][0] = 1;

        // 逐段处理
        for (int pos = 0; pos < 8; pos++) {
            // 清空下一层
            for (int curRun = 0; curRun <= 8; curRun++) {
                for(int k = 0; k <= 8; k++) {
                    Arrays.fill(dpNxt[curRun][k], 0);
                }
            }

            // 枚举状态
            for (int curRun = 0; curRun <= 8; curRun++) {
                for (int maxRun = 0; maxRun <= 8; maxRun++) {
                    for (int sumLen = 0; sumLen <= 32; sumLen++) {
                        long count = dpCur[curRun][maxRun][sumLen];
                        if (count == 0) {
                            continue;
                        }

                        // 1) 零分组 => 表示长度=1
                        int nextCurRun0 = curRun + 1; // 连续零分组 + 1
                        int nextMaxRun0 = Math.max(maxRun, nextCurRun0);
                        int nextSumLen0 = sumLen + 1;
                        if (nextSumLen0 <= 32) {
                            dpNxt[nextCurRun0][nextMaxRun0][nextSumLen0] =
                                    (dpNxt[nextCurRun0][nextMaxRun0][nextSumLen0] + count) % MOD;
                        }

                        // 2) 非零分组 => 可能长度=1/2/3/4
                        for (int i = 0; i < nonZeroLen.length; i++) {
                            int L = nonZeroLen[i];
                            int waysThis = nonZeroWays[i];
                            int nextCurRun = 0;         // 连续零断掉
                            int nextSumLen = sumLen + L;
                            if (nextSumLen <= 32) {
                                long ways = (count * waysThis) % MOD;
                                dpNxt[nextCurRun][maxRun][nextSumLen] =
                                        (dpNxt[nextCurRun][maxRun][nextSumLen] + ways) % MOD;
                            }
                        }
                    }
                }
            }
            // dpNxt -> dpCur
            long[][][] tmp = dpCur;
            dpCur = dpNxt;
            dpNxt = tmp;
        }

        // 处理完 8 段后，dpCur[curRun][maxRun][sumLen] 就是所有地址在“分组层面”统计的结果
        // 最后把最短表示长度 累加到答案
        long answer = 0;
        for (int curRun = 0; curRun <= 8; curRun++) {
            for (int maxRun = 0; maxRun <= 8; maxRun++) {
                for (int sumLen = 0; sumLen <= 32; sumLen++) {
                    long count = dpCur[curRun][maxRun][sumLen];
                    if (count == 0) {
                        continue;
                    }
                    // 不压缩长度 = sumLen + 7
                    // 压缩贡献 = 如果 maxRun >= 2，则可减 (2*maxRun - 3)
                    int reduce = 0;
                    if (maxRun >= 2) {
                        reduce = 2 * maxRun - 3;
                    }
                    int minLen = (sumLen + 7) - reduce;

                    // 贡献 = minLen * count
                    long contrib = (long)minLen * count;
                    answer = (answer + (contrib % MOD)) % MOD;
                }
            }
        }
        // 983499503
        System.out.println(answer);
    }
}