场景中有4张加密卡，当队列任务较少，不需要排队时，4张加密卡依序执行任务且不能空闲；当队列任务较多，需要排队时，动态调整各队列任务权重，根据权重分配队列任务；对于某一张加密卡，只有一个队列任务执行完了才处理下一个任务。利用独立任务最优调度问题 动态规划算法 C语言实现

这个问题可以看做是一个带有约束条件的独立任务调度问题。在任务较少的情况下，可以直接采用独立任务最优调度算法。而在任务较多的情况下，需要根据任务的权重来分配任务，同时需要考虑每个任务在哪张加密卡上执行。

以下是一种可能的解决方案：

1. 定义状态：设f(i, j, k)表示前i个任务放在j张加密卡上，第k张加密卡最后执行的任务编号。

2. 状态转移方程：与独立任务最优调度问题类似，考虑第i个任务，它可以独立放在一张加密卡上，也可以与前面的任务一起放在一张加密卡上。但是，需要额外考虑当前任务在哪张加密卡上执行。因此，有以下两种情况：

1) 第i个任务独立放在一张加密卡上，那么前i-1个任务就需要放在j-1张加密卡上，此时状态转移方程为：

f(i, j, k) = min(f(i-1, j, k), f(i-1, j-1, k-1)) + cost(i)

2) 第i个任务与前面的任务一起放在一张加密卡上，那么前i-1个任务就需要放在j张加密卡上，此时状态转移方程为：

f(i, j, k) = f(i-1, j, k) + cost(i)

其中，cost(i)表示第i个任务的花费，k表示当前任务在哪张加密卡上执行。

3. 边界条件：当i=1时，只需要考虑前1个任务放在1张加密卡上的情况，即f(1,1,1)=cost(1)。当j=1时，只能将前i个任务都放在1张加密卡上，即f(i,1,k)=f(i-1,1,k)+cost(i)。

4. 最终答案：最小花费为min(f(n,1,1), f(n,2,1), f(n,3,1), f(n,4,1))，其中n为总任务数。

下面是C语言代码实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_TASKS 100
#define MAX_CARDS 4

int min(int a, int b) {
    return a < b ? a : b;
}

int main() {
    int n, i, j, k, cost[MAX_TASKS + 1], f[MAX_TASKS + 1][MAX_CARDS + 1][MAX_TASKS + 1];

    // 读入任务数和每个任务的花费
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        scanf("%d", &cost[i]);
    }

    // 初始化边界条件
    for (i = 1; i <= n; i++) {
        f[i][1][i] = f[i-1][1][i-1] + cost[i];
    }
    for (j = 1; j <= MAX_CARDS; j++) {
        for (k = 1; k <= n; k++) {
            f[1][j][k] = cost[1];
        }
    }

    // 动态规划求解
    for (i = 2; i <= n; i++) {
        for (j = 2; j <= MAX_CARDS; j++) {
            for (k = i; k >= j; k--) {
                f[i][j][k] = f[i-1][j][k] + cost[i];
                if (k > j) {
                    f[i][j][k] = min(f[i][j][k], f[i-1][j-1][k-1] + cost[i]);
                }
            }
        }
    }

    // 输出最小花费
    int ans = f[n][1][1];
    for (j = 2; j <= MAX_CARDS; j++) {
        for (k = j; k <= n; k++) {
            ans = min(ans, f[n][j][k]);
        }
    }
    printf("%d\n", ans);

    return 0;
}

在任务较少的情况下，直接调用上面的独立任务最优调度算法即可。在任务较多的情况下，需要根据加密卡的使用情况来动态分配权重，可以采用贪心算法或者其他算法来实现。