对于图像压缩问题，设输入P=<10，12，15，255，1，2>，编程求出最优分段方式及存储位数

对于图像压缩问题，可以使用分段压缩的方法来减少存储位数。最优的分段方式可以通过动态规划算法来求解。

假设将P分成k段，每一段的值域为[l, r]，则存储这k个区间的端点和每段的位数即可。其中，每段的位数可以通过计算每个像素值与区间左端点的差值所需的二进制位数之和来求解。

设dp[i][j]表示前i个像素分成j段的最小位数，则有状态转移方程：

dp[i][j] = min(dp[k][j-1] + cost[k+1][i])，其中 0 <= k < i

其中，cost[k+1][i]表示将第k+1到i个像素分成一段所需的位数之和，可以通过遍历k+1到i的像素值，计算每个像素值与区间左端点的差值所需的二进制位数之和来求解。

最终的最优解为dp[n][k]，即将n个像素分成k段的最小位数。可以通过记录每个状态的转移来源来还原出最优分段方式。

具体实现可以参考以下伪代码：

n = 6  # 像素个数
P = [10, 12, 15, 255, 1, 2]  # 像素值列表
k = 3  # 分成3段

cost = [[0] * n for _ in range(n)]
for i in range(n):
    for j in range(i, n):
        left = P[i]
        right = P[j]
        for x in range(i+1, j+1):
            left = min(left, P[x])
            right = max(right, P[x])
        cost[i][j] = (right - left).bit_length() * (j - i + 1)

dp = [[float('inf')] * (k+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(1, n+1):
    for j in range(1, k+1):
        for l in range(i):
            dp[i][j] = min(dp[i][j], dp[l][j-1] + cost[l+1][i-1])

# 输出最小位数
print(dp[n][k])

# 还原分段方案
seg = []
i, j = n, k
while j > 0:
    for l in range(i):
        if dp[i][j] == dp[l][j-1] + cost[l+1][i-1]:
            seg.append((l, i))
            i = l
            j -= 1
            break
seg.reverse()
print(seg)

对于输入P=<10，12，15，255，1，2>，分成3段的最优分段方式为[(0, 2), (3, 3), (4, 5)]，存储位数为22。