编写程序实现： 1、<验证> 输入背包容量，物品数量、价值及重量，利用动态规划法解决0-1背包问题，要求输出装入物品的对应指示向量，并分析该算法性能。 2、<探索> 当背包允许物品部分装入时，重新设计动态规划策略，满足背包承载最大时价值最高，输出指示向量，并与问题1结果相比较，同时分析算法性能差异。

好的，我可以帮您回答这个问题。

问题1：

以下是实现0-1背包问题的动态规划算法程序，以Python为例：

def knapsack_01(capacity, weights, values, n):
    K = [[0 for x in range(capacity + 1)] for x in range(n + 1)]
    for i in range(n + 1):
        for w in range(capacity + 1):
            if i == 0 or w == 0:
                K[i][w] = 0
            elif weights[i-1] <= w:
                K[i][w] = max(values[i-1] + K[i-1][w-weights[i-1]], K[i-1][w])
            else:
                K[i][w] = K[i-1][w]
 
    res = K[n][capacity]
    print("最大价值为：", res)
     
    w = capacity
    for i in range(n, 0, -1):
        if res <= 0:
            break
        if res == K[i - 1][w]:
            continue
        else:
            print("选择物品", i)
            res -= values[i - 1]
            w -= weights[i - 1]

函数`knapsack_01`的输入参数为背包容量`capacity`、物品重量列表`weights`、物品价值列表`values`、物品数量`n`。程序输出最大价值和装入物品的对应指示向量。

算法分析：

该算法的时间复杂度为$O(nC)$，其中$n$为物品数量，$C$为背包容量。空间复杂度为$O(nC)$。因为需要构造一个二维数组来保存子问题的最优解。

问题2：

以下是实现部分装入背包问题的动态规划算法程序，以Python为例：

def fractional_knapsack(capacity, weights, values, n):
    items = []
    for i in range(n):
        items.append([weights[i], values[i], values[i]/weights[i]])
    items = sorted(items, key=lambda x:x[2], reverse=True)
    
    current_weight = 0
    current_value = 0
    for i in range(n):
        if current_weight + items[i][0] <= capacity:
            current_weight += items[i][0]
            current_value += items[i][1]
            print("选择物品", i+1, "全部装入")
        else:
            remaining_capacity = capacity - current_weight
            value_per_weight = items[i][1] / items[i][0]
            fraction = remaining_capacity / items[i][0]
            current_weight += remaining_capacity
            current_value += fraction * items[i][1]
            print("选择物品", i+1, "装入部分，装入比例为", fraction)
    print("总价值为：", current_value)

函数`fractional_knapsack`的输入参数与问题1相同。程序输出总价值和装入物品的对应指示向量。

算法分析：

该算法的时间复杂度为$O(n \log n)$，主要是由于需要对物品进行排序。空间复杂度为$O(n)$。因为只需要保存物品的重量、价值和单位价值。与问题1相比，该算法的性能较好，但它是一个贪心算法，不一定能得到最优解。