【剪枝】个人练习-Leetcode-2468. Split Message Based on Limit_splitmessage

题目链接：https://leetcode.cn/problems/split-message-based-on-limit/

题目大意：给出一个字符串message和一个整数limit，要求将message分割成part个子串，并且每个子串最后要加上表示当前是第几个子串的标签"<num/part>"，要求【加上标签后的每个子串】长度都等于limit（只有最后一个子串可以小于等于limit）。要求part数最小，求分割后的子串的列表。如果无法分割，返回空的vector<string>

思路：message本身的内容无所谓，最关键的点是要找到part是多少。

实际上一旦part和limit都知道了，那么就确定了【一种分割】，这种分割能容纳的最长长度是可以计算的。代码如下，其中digit是part的位数。因为标签"<num/part>"的长度是根据当前的位数变化的，根据最大位数来计算容纳的长度，1位的话只用计算个位，2位的话就计算个位+十位，以此类推。因为字符串最大长度为10000，因此做到5位就够了。

    int calLen(int part, int digit, int limit) {
        switch (digit) {
            case 1: return part * (limit - 5);
            case 2: return 9 * (limit - 6) + (part - 9) * (limit - 7);
            case 3: return 9 * (limit - 7) + 90 * (limit - 8) + (part - 99) * (limit - 9);
            case 4: return 9 * (limit - 8) + 90 * (limit - 9) + 900 * (limit - 10) + (part - 999) * (limit - 11);
            default: return 9 * (limit - 9) + 90 * (limit - 10) + 900 * (limit - 11) + 9000 * (limit - 12) + (part - 9999) * (limit - 13);
        }   
    }
1
2
3
4
5
6
7
8
9

首先先搞定一些edge cases。注意到标签"<num/part>"的长度大于等于5，因此如果limit <= 5那么实际上每个子串连标签都容纳不下或仅能容纳标签，那么无法分割，返回空。

        vector<string> ept;
        if (limit < 6)
            return ept;
1
2
3

随后，因为希望part尽可能小，那么我们从下界N/(limit-5)开始遍历，这是假设了标签长度为5时候的情况。遍历计算这种分割【part和limit确定一种分割】能容纳的最长长度，如果大于等于message.length()了，说明这个就是合法的一种分割。又因为我们是从下界开始遍历的，只要找到了合法的，那就是最小的合法分割。

        int N = message.length();
        int part = N/(limit-5);
        int min_part = N+1;
        while (min_part == N+1 && part <= N) {
            int digit = calD(part);
            if (limit <= 3 + digit*2) 
                return ept;

            int len = calLen(part, digit, limit);
            if (len >= N) {
                min_part = min(min_part, part);
                break;
            }
            else
                part++;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

【注意！】：然而，part虽然是我们自己给出的，但limit是题目给定的。由于一种分割能容纳的最长长度是由part和limit一起决定的，因此【最长长度】【并不是】【根据part递增的】。换句话说，并不是part数越多，能容纳的最长长度就越长，它还与limit有关！注意到在上面写的函数calLen()里，有着limit - x的因数，也就是说，如果limit很小，但我们选择的part却很大的话，可能会出现limit - x < 0的情况，这样的分割是不合法的。然而由于我们是从下界开始遍历的，并且part再变大也无法使得分割合法，此时就不存在合法的分割了，返回空。

如果遍历结束也没有合法的分割，也返回空

        if (min_part == N+1)
            return ept;
1
2

如果存在最小的合法分割，那么根据这个分割计算message的分割结果即可。注意每一次加入的长度，一般是limit减去标签的长度，但如果是最后一个子串，它的长度可能小于【limit减去标签的长度】，因此要与N-ptr做对比，取小的那个。

    vector<string> calAns(int min_part, int digit, int limit, string message) {
        vector<string> ans;
        int ptr = 0;
        int N = message.length();
        string ps = to_string(min_part);
        for (int i = 1; i <= min_part; i++) {
            if (i < 10) {
                int pace = min(limit-digit-4, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else if (i < 100) {
                int pace = min(limit-digit-5, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else if (i < 1000) {
                int pace = min(limit-digit-6, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else if (i < 10000) {
                int pace = min(limit-digit-7, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else {
                int pace = min(limit-digit-8, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
        }
        return ans;
    }    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

完整代码

class Solution {
public:
    int calD(int mid) {
        int ret = 0;
        while (mid) {
            mid /= 10;
            ret++;
        }
        if (ret == 0)
            return 1;
        return ret;
    }

    int calLen(int part, int digit, int limit) {
        switch (digit) {
            case 1: return part * (limit - 5);
            case 2: return 9 * (limit - 6) + (part - 9) * (limit - 7);
            case 3: return 9 * (limit - 7) + 90 * (limit - 8) + (part - 99) * (limit - 9);
            case 4: return 9 * (limit - 8) + 90 * (limit - 9) + 900 * (limit - 10) + (part - 999) * (limit - 11);
            default: return 9 * (limit - 9) + 90 * (limit - 10) + 900 * (limit - 11) + 9000 * (limit - 12) + (part - 9999) * (limit - 13);
        }   
    }

    vector<string> calAns(int min_part, int digit, int limit, string message) {
        vector<string> ans;
        int ptr = 0;
        int N = message.length();
        string ps = to_string(min_part);
        for (int i = 1; i <= min_part; i++) {
            if (i < 10) {
                int pace = min(limit-digit-4, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else if (i < 100) {
                int pace = min(limit-digit-5, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else if (i < 1000) {
                int pace = min(limit-digit-6, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else if (i < 10000) {
                int pace = min(limit-digit-7, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
            else {
                int pace = min(limit-digit-8, N-ptr);
                ans.emplace_back(message.substr(ptr, pace) + "<" + to_string(i) + "/" + ps + ">");
                ptr += pace;
            }
        }
        return ans;
    }    


    vector<string> splitMessage(string message, int limit) {
        vector<string> ept;
        if (limit < 6)
            return ept;
        int N = message.length();
        int part = N/(limit-5);
        int min_part = N+1;
        while (min_part == N+1 && part <= N) {
            int digit = calD(part);
            if (limit <= 3 + digit*2) 
                return ept;

            int len = calLen(part, digit, limit);
            if (len >= N) {
                min_part = min(min_part, part);
                break;
            }
            else
                part++;
        }

        if (min_part == N+1)
            return ept;
        
        int digit = calD(min_part);
        return calAns(min_part, digit, limit, message);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87