给定26个1-100表示的非归一化概率，和一个26个小写字母组成的序列，计算使用霍夫曼压缩后，这个序列占用的总比特数。输入为1行，前面26个数字为小写字母a-z的非归一化概率，然后是一个序列，数字和序列间均以空格隔开，输出为一个数字，表示这个序列占用的总比特数。

这是一个霍夫曼编码的问题，可以使用霍夫曼树来解决。首先根据给定的非归一化概率构建霍夫曼树，然后对于给定的序列，将每个字母的霍夫曼编码拼接在一起，最终计算出占用的总比特数。

以下是Python的实现代码：

import heapq

class Node:
    def __init__(self, char=None, freq=0, left=None, right=None):
        self.char = char
        self.freq = freq
        self.left = left
        self.right = right
    
    def __lt__(self, other):
        return self.freq < other.freq

def build_huffman_tree(freq_dict):
    heap = [Node(char=k, freq=v) for k, v in freq_dict.items()]
    heapq.heapify(heap)
    while len(heap) > 1:
        node1 = heapq.heappop(heap)
        node2 = heapq.heappop(heap)
        parent = Node(freq=node1.freq + node2.freq, left=node1, right=node2)
        heapq.heappush(heap, parent)
    return heap[0]

def get_huffman_codes(root):
    codes = {}
    def traverse(node, code):
        if node.char:
            codes[node.char] = code
        else:
            traverse(node.left, code + '0')
            traverse(node.right, code + '1')
    traverse(root, '')
    return codes

def huffman_compress(freq_list, seq):
    freq_dict = {chr(ord('a') + i): freq_list[i] for i in range(26)}
    root = build_huffman_tree(freq_dict)
    codes = get_huffman_codes(root)
    compressed = ''.join(codes[c] for c in seq)
    return (len(compressed) + 7) // 8

freq_list = list(map(int, input().split()))
seq = input().strip()
print(huffman_compress(freq_list, seq))

输入格式为：26个数字以空格分隔，然后是一个字符串，输出格式为一个整数。